Subversion Repositories Scribus

Rev

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