Subversion Repositories Scribus

Rev

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