Subversion Repositories Scribus

Rev

Rev 18480 | Rev 18754 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
16856 craig 1
/*
2
Copyright (C) 2011 Elvis Stansvik <elvstone@gmail.com>
3
 
4
For general Scribus (>=1.3.2) copyright and licensing information please refer
5
to the COPYING file provided with the program. Following this notice may exist
6
a copyright and/or license notice that predates the release of Scribus 1.3.2
7
for which a new license (GPL+exception) is in place.
8
*/
9
#include <QColor>
10
#include <QListWidget>
11
#include <QListWidgetItem>
12
#include <QWidget>
13
 
14
#include "colorcombo.h"
15
#include "commonstrings.h"
16
#include "pageitem_table.h"
17
#include "sccolorengine.h"
18
#include "scribus.h"
19
#include "selection.h"
20
#include "tableborder.h"
21
#include "tablesideselector.h"
22
#include "util.h"
23
#include "util_color.h"
24
#include "util_icon.h"
25
 
26
#include "propertiespalette_table.h"
27
 
28
PropertiesPalette_Table::PropertiesPalette_Table(QWidget* parent) : QWidget(parent),
29
        m_mainWindow(0), m_doc(0), m_item(0), m_previousItem(0)
30
{
31
        setupUi(this);
17383 fschmid 32
        setSizePolicy( QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum));
16856 craig 33
 
34
        addBorderLineButton->setIcon(QIcon(loadIcon("penciladd.png")));
35
        removeBorderLineButton->setIcon(QIcon(loadIcon("pencilsub.png")));
17333 fschmid 36
        labelTable->setBuddy(tableStyleCombo);
37
        buttonClearTableStyle->setIcon(loadIcon("16/edit-clear.png"));
38
        labelCells->setBuddy(cellStyleCombo);
39
        buttonClearCellStyle->setIcon(loadIcon("16/edit-clear.png"));
40
        connect(tableStyleCombo, SIGNAL(newStyle(const QString&)), this, SLOT(setTableStyle(const QString&)));
41
        connect(cellStyleCombo, SIGNAL(newStyle(const QString&)), this, SLOT(setCellStyle(const QString&)));
16856 craig 42
}
43
 
44
void PropertiesPalette_Table::handleUpdateRequest(int updateFlags)
45
{
46
        if (updateFlags & reqColorsUpdate)
47
                updateColorList();
17333 fschmid 48
        tableStyleCombo->updateFormatList();
49
        cellStyleCombo->updateFormatList();
16856 craig 50
}
51
 
52
void PropertiesPalette_Table::updateColorList()
53
{
54
        if (!m_doc)
55
                return;
56
 
57
        borderLineColor->updateBox(m_doc->PageColors, ColorCombo::smallPixmaps);
58
        fillColor->updateBox(m_doc->PageColors, ColorCombo::smallPixmaps);
59
}
60
 
61
void PropertiesPalette_Table::setMainWindow(ScribusMainWindow* mainWindow)
62
{
63
        m_mainWindow = mainWindow;
64
 
65
        connect(m_mainWindow, SIGNAL(UpdateRequest(int)), SLOT(handleUpdateRequest(int)));
17327 fschmid 66
        connect(m_mainWindow, SIGNAL(AppModeChanged(int,int)), this, SLOT(updateFillControls()));
17333 fschmid 67
        connect(m_mainWindow, SIGNAL(AppModeChanged(int,int)), this, SLOT(updateStyleControls()));
16856 craig 68
}
69
 
70
void PropertiesPalette_Table::setDocument(ScribusDoc *doc)
71
{
72
        m_doc = doc;
17333 fschmid 73
        tableStyleCombo->setDoc(m_doc);
74
        cellStyleCombo->setDoc(m_doc);
16856 craig 75
}
76
 
77
void PropertiesPalette_Table::unsetDocument()
78
{
79
        m_doc = 0;
17333 fschmid 80
        tableStyleCombo->setDoc(m_doc);
81
        cellStyleCombo->setDoc(m_doc);
16856 craig 82
}
83
 
84
void PropertiesPalette_Table::setItem(PageItem* item)
85
{
86
        m_item = item;
17332 fschmid 87
        if (item->isTable())
88
                connect(m_item->asTable(), SIGNAL(selectionChanged()), this, SLOT(handleCellSelectionChanged()));
16856 craig 89
}
90
 
91
void PropertiesPalette_Table::unsetItem()
92
{
18753 fschmid 93
        disconnect(this, SLOT(handleCellSelectionChanged()));
94
 
95
//      if ((m_item) && (m_item->isTable()))
96
//              disconnect(m_item->asTable(), SIGNAL(selectionChanged()), this, SLOT(handleCellSelectionChanged()));
16856 craig 97
        m_item = 0;
98
}
99
 
100
void PropertiesPalette_Table::handleSelectionChanged()
101
{
102
        if (!m_doc)
103
                return;
104
 
105
        // We only handle a single item for now.
106
        if (m_doc->m_Selection->count() >= 1 && m_doc->m_Selection->itemAt(0)->isTable())
107
                m_item = m_doc->m_Selection->itemAt(0);
108
        else
109
                m_item = 0;
110
 
111
        // HACK: Guard against "false" re-selections resulting from m_item->update().
112
        if (m_item == m_previousItem)
113
                return;
114
        m_previousItem = m_item;
115
 
116
        sideSelector->setSelection(TableSideSelector::All);
117
 
118
        updateFillControls();
17333 fschmid 119
        updateStyleControls();
16856 craig 120
}
121
 
17327 fschmid 122
void PropertiesPalette_Table::handleCellSelectionChanged()
123
{
124
        if (!m_doc)
125
                return;
126
        if (!m_item)
127
                return;
128
        updateFillControls();
17333 fschmid 129
        updateStyleControls();
17327 fschmid 130
}
131
 
17333 fschmid 132
void PropertiesPalette_Table::displayTableStyle(const QString& name)
133
{
134
        bool blocked = tableStyleCombo->blockSignals(true);
135
        tableStyleCombo->setFormat(name);
136
        tableStyleCombo->blockSignals(blocked);
137
}
138
 
139
void PropertiesPalette_Table::displayCellStyle(const QString& name)
140
{
141
        bool blocked = cellStyleCombo->blockSignals(true);
142
        cellStyleCombo->setFormat(name);
143
        cellStyleCombo->blockSignals(blocked);
144
}
145
 
146
void PropertiesPalette_Table::updateStyleControls()
147
{
148
        if (m_item && m_item->isTable())
149
        {
150
                PageItem_Table* table = m_item->asTable();
151
                tableStyleCombo->setEnabled(true);
152
                cellStyleCombo->setEnabled(true);
153
                buttonClearTableStyle->setEnabled(true);
154
                buttonClearCellStyle->setEnabled(true);
155
                // Fill in values.
156
                if (m_doc->appMode != modeEditTable)
157
                {
158
                        displayTableStyle(table->style());
159
                        cellStyleCombo->setEnabled(false);
160
                        buttonClearCellStyle->setEnabled(false);
161
                }
162
                else
163
                {
17336 fschmid 164
//                      displayTableStyle(table->style());
17333 fschmid 165
                        displayCellStyle(table->activeCell().style());
166
                }
167
        }
168
        else
169
        {
170
                tableStyleCombo->setEnabled(false);
171
                cellStyleCombo->setEnabled(false);
172
                buttonClearTableStyle->setEnabled(false);
173
                buttonClearCellStyle->setEnabled(false);
174
        }
175
}
176
 
177
void PropertiesPalette_Table::setTableStyle(const QString &name)
178
{
179
        if (!m_item || !m_item->isTable())
180
                return;
181
        m_item->asTable()->setStyle(name);
182
        m_item->asTable()->update();
183
        displayTableStyle(name);
184
}
185
 
186
void PropertiesPalette_Table::setCellStyle(const QString &name)
187
{
188
        if (!m_item || !m_item->isTable())
189
                return;
190
        m_doc->dontResize = true;
191
        m_item->asTable()->activeCell().setStyle(name);
192
        m_doc->dontResize = true;
193
        m_item->asTable()->update();
194
        displayCellStyle(name);
195
}
196
 
16856 craig 197
void PropertiesPalette_Table::on_sideSelector_selectionChanged()
198
{
199
        if (!m_item || !m_item->isTable())
200
                return;
201
 
202
        /*
203
         * Figure out the selection state. Either
204
         *
205
         * 1) Some sides are selected and they all have the same border, or
206
         * 2) Some sides are selected but they have different borders, or
207
         * 3) No sides are selected.
208
         */
209
        State borderState = Unset;
210
        m_currentBorder = TableBorder();
211
        TableSideSelector::Sides selectedSides = sideSelector->selection();
212
        PageItem_Table* table = m_item->asTable();
213
 
214
        if (selectedSides & TableSideSelector::Left)
215
        {
216
                if (borderState == Unset && !table->leftBorder().isNull())
217
                {
218
                        m_currentBorder = table->leftBorder();
219
                        borderState = Set;
220
                }
221
                else if (m_currentBorder != table->leftBorder())
222
                        borderState = TriState;
223
        }
224
 
225
        if (selectedSides & TableSideSelector::Right)
226
        {
227
                if (borderState == Unset && !table->rightBorder().isNull())
228
                {
229
                        m_currentBorder = table->rightBorder();
230
                        borderState = Set;
231
                }
232
                else if (m_currentBorder != table->rightBorder())
233
                        borderState = TriState;
234
        }
235
 
236
        if (selectedSides & TableSideSelector::Top)
237
        {
238
                if (borderState == Unset && !table->topBorder().isNull())
239
                {
240
                        m_currentBorder = table->topBorder();
241
                        borderState = Set;
242
                }
243
                else if (m_currentBorder != table->topBorder())
244
                        borderState = TriState;
245
        }
246
 
247
        if (selectedSides & TableSideSelector::Bottom)
248
        {
249
                if (borderState == Unset && !table->bottomBorder().isNull())
250
                {
251
                        m_currentBorder = table->bottomBorder();
252
                        borderState = Set;
253
                }
254
                else if (m_currentBorder != table->bottomBorder())
255
                        borderState = TriState;
256
        }
257
 
258
        if (borderState == Set)
259
        {
260
                /// Some sides selected and they have same border.
261
                addBorderLineButton->setEnabled(true);
262
                removeBorderLineButton->setEnabled(true);
263
                borderLineList->setEnabled(true);
264
        }
265
        else if (borderState == TriState)
266
        {
267
                /// Some sides selected but they have different border.
268
                m_currentBorder = TableBorder();
269
                addBorderLineButton->setEnabled(true);
270
                removeBorderLineButton->setEnabled(true);
271
                borderLineList->setEnabled(true);
272
        }
273
        else
274
        {
275
                /// No sides selected.
276
                m_currentBorder = TableBorder();
277
                addBorderLineButton->setEnabled(false);
278
                removeBorderLineButton->setEnabled(false);
279
                borderLineList->setEnabled(false);
280
        }
281
 
282
        updateBorderLineList();
283
}
284
 
285
void PropertiesPalette_Table::updateBorderLineList()
286
{
287
        borderLineList->clear();
288
        foreach (const TableBorderLine& borderLine, m_currentBorder.borderLines())
289
        {
17417 fschmid 290
                QString text = QString(" %1%2 %3").arg(borderLine.width()).arg(borderLineWidth->suffix()).arg(CommonStrings::translatePenStyleName(borderLine.style()));
291
                if (borderLine.color() != CommonStrings::None)
292
                {
293
                        QPixmap *icon = getWidePixmap(getColor(borderLine.color(), borderLine.shade()));
294
                        borderLineList->addItem(new QListWidgetItem(*icon, text, borderLineList));
295
                }
296
                else
297
                        borderLineList->addItem(new QListWidgetItem(text, borderLineList));
16856 craig 298
        }
17336 fschmid 299
        removeBorderLineButton->setEnabled(borderLineList->count() > 1);
16856 craig 300
}
301
 
302
void PropertiesPalette_Table::updateBorderLineListItem()
303
{
304
        QListWidgetItem* item = borderLineList->currentItem();
17417 fschmid 305
        QString text = QString(" %1%2 %3").arg(borderLineWidth->getValue()).arg(borderLineWidth->suffix()).arg(CommonStrings::translatePenStyleName(static_cast<Qt::PenStyle>(borderLineStyle->currentIndex() + 1)));
306
        if (borderLineColor->currentColor() != CommonStrings::None)
307
        {
308
                QPixmap *icon = getWidePixmap(getColor(borderLineColor->currentColor(), borderLineShade->value()));
309
                item->setIcon(*icon);
310
        }
16856 craig 311
        item->setText(text);
312
}
313
 
314
void PropertiesPalette_Table::updateFillControls()
315
{
316
        if (m_item && m_item->isTable())
317
        {
318
                PageItem_Table* table = m_item->asTable();
319
                // Enable fill editing controls.
320
                fillColor->setEnabled(true);
321
                fillColorLabel->setEnabled(true);
322
                fillShade->setEnabled(true);
323
                fillShadeLabel->setEnabled(true);
324
                // Fill in values.
17327 fschmid 325
                if (m_doc->appMode != modeEditTable)
17318 fschmid 326
                {
17327 fschmid 327
                        QString color = table->fillColor();
328
                        if (color == CommonStrings::None)
329
                                color = CommonStrings::tr_NoneColor;
330
                        setCurrentComboItem(fillColor, color);
18480 jghali 331
                        bool sigBlocked = fillShade->blockSignals(true);
17318 fschmid 332
                        fillShade->setValue(table->fillShade());
18480 jghali 333
                        fillShade->blockSignals(sigBlocked);
17318 fschmid 334
                }
17327 fschmid 335
                else
17318 fschmid 336
                {
17327 fschmid 337
                        TableCell cell = table->activeCell();
338
                        QString color = cell.fillColor();
339
                        if (color == CommonStrings::None)
340
                                color = CommonStrings::tr_NoneColor;
341
                        setCurrentComboItem(fillColor, color);
18480 jghali 342
                        bool sigBlocked = fillShade->blockSignals(true);
17318 fschmid 343
                        fillShade->setValue(cell.fillShade());
18480 jghali 344
                        fillShade->blockSignals(sigBlocked);
17318 fschmid 345
                }
16856 craig 346
        }
347
        else
348
        {
349
                // Disable fill editing controls.
350
                fillColor->setEnabled(false);
351
                fillColorLabel->setEnabled(false);
352
                fillShade->setEnabled(false);
353
                fillShadeLabel->setEnabled(false);
354
        }
355
}
356
 
357
QColor PropertiesPalette_Table::getColor(const QString& colorName, int shade) const
358
{
359
        if (!m_doc)
360
                return QColor();
361
 
362
        return ScColorEngine::getDisplayColor(m_doc->PageColors[colorName], m_doc, shade);
363
}
364
 
365
void PropertiesPalette_Table::on_borderLineList_currentRowChanged(int row)
366
{
367
        if (row == -1)
368
        {
369
                // No list item selected, so disable editing widgets.
370
                borderLineWidth->setEnabled(false);
371
                borderLineWidthLabel->setEnabled(false);
372
                borderLineColor->setEnabled(false);
373
                borderLineColorLabel->setEnabled(false);
374
                borderLineStyle->setEnabled(false);
375
                borderLineStyleLabel->setEnabled(false);
376
                borderLineShade->setEnabled(false);
377
                borderLineShadeLabel->setEnabled(false);
378
        }
379
        else
380
        {
381
                QList<TableBorderLine> borderLines = m_currentBorder.borderLines();
382
                Q_ASSERT(borderLineList->count() == borderLines.size());
383
                TableBorderLine line = borderLines.at(row);
384
 
385
                // Enable editing widgets.
386
                borderLineWidth->setEnabled(true);
387
                borderLineWidthLabel->setEnabled(true);
388
                borderLineColor->setEnabled(true);
389
                borderLineColorLabel->setEnabled(true);
390
                borderLineStyle->setEnabled(true);
391
                borderLineStyleLabel->setEnabled(true);
392
                borderLineShade->setEnabled(true);
393
                borderLineShadeLabel->setEnabled(true);
394
 
395
                // Fill in values.
396
                borderLineWidth->showValue(line.width());
397
                setCurrentComboItem(borderLineColor, line.color());
398
                borderLineStyle->setCurrentIndex(static_cast<int>(line.style()) - 1);
17311 fschmid 399
                borderLineShade->setValue(line.shade());
16856 craig 400
        }
401
}
402
 
403
/// Handles adding of a new border line.
404
void PropertiesPalette_Table::on_addBorderLineButton_clicked()
405
{
406
        if (!m_item || !m_item->isTable())
407
                return;
408
 
409
        m_currentBorder.addBorderLine(TableBorderLine());
410
        updateBorderLineList();
411
}
412
 
413
/// Handles removing of a border line.
414
void PropertiesPalette_Table::on_removeBorderLineButton_clicked()
415
{
416
        int index = borderLineList->currentRow();
417
        borderLineList->removeItemWidget(borderLineList->currentItem());
418
        m_currentBorder.removeBorderLine(index);
419
        updateBorderLineList();
420
}
421
 
422
void PropertiesPalette_Table::on_borderLineWidth_valueChanged(double width)
423
{
424
        int index = borderLineList->currentRow();
425
        TableBorderLine borderLine = m_currentBorder.borderLines().at(index);
426
        borderLine.setWidth(width);
427
        m_currentBorder.replaceBorderLine(index, borderLine);
428
 
429
        updateBorders();
430
        updateBorderLineListItem();
431
}
432
 
17311 fschmid 433
void PropertiesPalette_Table::on_borderLineShade_valueChanged(int shade)
434
{
435
        int index = borderLineList->currentRow();
436
        TableBorderLine borderLine = m_currentBorder.borderLines().at(index);
437
        borderLine.setShade(shade);
438
        m_currentBorder.replaceBorderLine(index, borderLine);
439
 
440
        updateBorders();
441
        updateBorderLineListItem();
442
}
443
 
16856 craig 444
void PropertiesPalette_Table::on_borderLineColor_activated(const QString& colorName)
445
{
446
        int index = borderLineList->currentRow();
447
        TableBorderLine borderLine = m_currentBorder.borderLines().at(index);
448
        borderLine.setColor(colorName);
449
        m_currentBorder.replaceBorderLine(index, borderLine);
450
 
451
        updateBorders();
452
        updateBorderLineListItem();
453
}
454
 
455
void PropertiesPalette_Table::on_borderLineStyle_activated(int style)
456
{
457
        int index = borderLineList->currentRow();
458
        TableBorderLine borderLine = m_currentBorder.borderLines().at(index);
459
        borderLine.setStyle(static_cast<Qt::PenStyle>(style + 1));
460
        m_currentBorder.replaceBorderLine(index, borderLine);
461
 
462
        updateBorders();
463
        updateBorderLineListItem();
464
}
465
 
466
void PropertiesPalette_Table::on_fillColor_activated(const QString& colorName)
467
{
468
        if (!m_item || !m_item->isTable())
469
                return;
17327 fschmid 470
        QString color = colorName;
471
        if (colorName == CommonStrings::tr_NoneColor)
472
                color = CommonStrings::None;
16856 craig 473
        PageItem_Table* table = m_item->asTable();
17327 fschmid 474
        if (m_doc->appMode != modeEditTable)
17318 fschmid 475
        {
17327 fschmid 476
                table->setFillColor(color);
17318 fschmid 477
                table->setFillShade(fillShade->value());
478
        }
17327 fschmid 479
        else
17318 fschmid 480
        {
17327 fschmid 481
                TableCell cell = table->activeCell();
482
                cell.setFillColor(color);
17318 fschmid 483
                cell.setFillShade(fillShade->value());
484
        }
485
 
17311 fschmid 486
        table->update();
487
}
16856 craig 488
 
17311 fschmid 489
void PropertiesPalette_Table::on_fillShade_valueChanged(int shade)
490
{
491
        if (!m_item || !m_item->isTable())
492
                return;
493
 
17327 fschmid 494
        QString color = fillColor->currentColor();
495
        if (color == CommonStrings::tr_NoneColor)
496
                color = CommonStrings::None;
17311 fschmid 497
        PageItem_Table* table = m_item->asTable();
17327 fschmid 498
        if (m_doc->appMode != modeEditTable)
17318 fschmid 499
        {
17327 fschmid 500
                table->setFillColor(color);
17318 fschmid 501
                table->setFillShade(shade);
502
        }
17327 fschmid 503
        else
17318 fschmid 504
        {
17327 fschmid 505
                TableCell cell = table->activeCell();
506
                cell.setFillColor(color);
17318 fschmid 507
                cell.setFillShade(shade);
508
        }
16856 craig 509
        table->update();
510
}
511
 
17336 fschmid 512
void PropertiesPalette_Table::on_buttonClearTableStyle_clicked()
513
{
514
        if (!m_item || !m_item->isTable())
515
                return;
516
        PageItem_Table* table = m_item->asTable();
517
        table->unsetDirectFormatting();
518
        table->update();
519
}
520
 
521
void PropertiesPalette_Table::on_buttonClearCellStyle_clicked()
522
{
523
        if (!m_item || !m_item->isTable())
524
                return;
525
        m_doc->dontResize = true;
526
        PageItem_Table* table = m_item->asTable();
527
        table->activeCell().unsetDirectFormatting();
528
        table->adjustTable();
529
        table->update();
530
}
531
 
16856 craig 532
void PropertiesPalette_Table::updateBorders()
533
{
534
        if (!m_doc || !m_item || !m_item->isTable())
535
                return;
536
 
537
        PageItem_Table* table = m_item->asTable();
538
        TableSideSelector::Sides selectedSides = sideSelector->selection();
539
 
17327 fschmid 540
        m_doc->dontResize = true;
17336 fschmid 541
        if (m_doc->appMode != modeEditTable)
542
        {
543
                if (selectedSides & TableSideSelector::Left)
544
                        table->setLeftBorder(m_currentBorder);
545
                if (selectedSides & TableSideSelector::Right)
546
                        table->setRightBorder(m_currentBorder);
547
                if (selectedSides & TableSideSelector::Top)
548
                        table->setTopBorder(m_currentBorder);
549
                if (selectedSides & TableSideSelector::Bottom)
550
                        table->setBottomBorder(m_currentBorder);
551
        }
552
        else
553
        {
554
                TableCell cell = table->activeCell();
555
                if (selectedSides & TableSideSelector::Left)
556
                        cell.setLeftBorder(m_currentBorder);
557
                if (selectedSides & TableSideSelector::Right)
558
                        cell.setRightBorder(m_currentBorder);
559
                if (selectedSides & TableSideSelector::Top)
560
                        cell.setTopBorder(m_currentBorder);
561
                if (selectedSides & TableSideSelector::Bottom)
562
                        cell.setBottomBorder(m_currentBorder);
563
        }
17327 fschmid 564
        table->adjustTable();
16856 craig 565
        table->update();
566
}
567
 
568
void PropertiesPalette_Table::languageChange()
569
{
17333 fschmid 570
        cellStyleCombo->setToolTip( tr("Cell style of currently selected cell"));
571
        tableStyleCombo->setToolTip( tr("Table style of currently selected table"));
17336 fschmid 572
        buttonClearCellStyle->setToolTip( tr("Remove Direct Cell Formatting"));
573
        buttonClearTableStyle->setToolTip( tr("Remove Direct Table Formatting"));
16856 craig 574
}
575
 
576
void PropertiesPalette_Table::unitChange()
577
{
578
        // Not implemented.
579
}