Subversion Repositories Scribus

Rev

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