Subversion Repositories Scribus

Rev

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