Subversion Repositories Scribus

Rev

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