Subversion Repositories Scribus

Rev

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