Subversion Repositories Scribus

Rev

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