Subversion Repositories Scribus

Rev

Rev 17311 | Go to most recent revision | Details | 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());
233
        }
234
        else
235
        {
236
                // Disable fill editing controls.
237
                fillColor->setEnabled(false);
238
                fillColorLabel->setEnabled(false);
239
                fillShade->setEnabled(false);
240
                fillShadeLabel->setEnabled(false);
241
        }
242
}
243
 
244
QColor PropertiesPalette_Table::getColor(const QString& colorName, int shade) const
245
{
246
        if (!m_doc)
247
                return QColor();
248
 
249
        return ScColorEngine::getDisplayColor(m_doc->PageColors[colorName], m_doc, shade);
250
}
251
 
252
void PropertiesPalette_Table::on_borderLineList_currentRowChanged(int row)
253
{
254
        if (row == -1)
255
        {
256
                // No list item selected, so disable editing widgets.
257
                borderLineWidth->setEnabled(false);
258
                borderLineWidthLabel->setEnabled(false);
259
                borderLineColor->setEnabled(false);
260
                borderLineColorLabel->setEnabled(false);
261
                borderLineStyle->setEnabled(false);
262
                borderLineStyleLabel->setEnabled(false);
263
                borderLineShade->setEnabled(false);
264
                borderLineShadeLabel->setEnabled(false);
265
        }
266
        else
267
        {
268
                QList<TableBorderLine> borderLines = m_currentBorder.borderLines();
269
                Q_ASSERT(borderLineList->count() == borderLines.size());
270
                TableBorderLine line = borderLines.at(row);
271
 
272
                // Enable editing widgets.
273
                borderLineWidth->setEnabled(true);
274
                borderLineWidthLabel->setEnabled(true);
275
                borderLineColor->setEnabled(true);
276
                borderLineColorLabel->setEnabled(true);
277
                borderLineStyle->setEnabled(true);
278
                borderLineStyleLabel->setEnabled(true);
279
                borderLineShade->setEnabled(true);
280
                borderLineShadeLabel->setEnabled(true);
281
 
282
                // Fill in values.
283
                borderLineWidth->showValue(line.width());
284
                setCurrentComboItem(borderLineColor, line.color());
285
                borderLineStyle->setCurrentIndex(static_cast<int>(line.style()) - 1);
286
        }
287
}
288
 
289
/// Handles adding of a new border line.
290
void PropertiesPalette_Table::on_addBorderLineButton_clicked()
291
{
292
        if (!m_item || !m_item->isTable())
293
                return;
294
 
295
        m_currentBorder.addBorderLine(TableBorderLine());
296
        updateBorderLineList();
297
}
298
 
299
/// Handles removing of a border line.
300
void PropertiesPalette_Table::on_removeBorderLineButton_clicked()
301
{
302
        int index = borderLineList->currentRow();
303
 
304
        borderLineList->removeItemWidget(borderLineList->currentItem());
305
        m_currentBorder.removeBorderLine(index);
306
 
307
        updateBorderLineList();
308
}
309
 
310
void PropertiesPalette_Table::on_borderLineWidth_valueChanged(double width)
311
{
312
        int index = borderLineList->currentRow();
313
        TableBorderLine borderLine = m_currentBorder.borderLines().at(index);
314
        borderLine.setWidth(width);
315
        m_currentBorder.replaceBorderLine(index, borderLine);
316
 
317
        updateBorders();
318
        updateBorderLineListItem();
319
}
320
 
321
void PropertiesPalette_Table::on_borderLineColor_activated(const QString& colorName)
322
{
323
        int index = borderLineList->currentRow();
324
        TableBorderLine borderLine = m_currentBorder.borderLines().at(index);
325
        borderLine.setColor(colorName);
326
        m_currentBorder.replaceBorderLine(index, borderLine);
327
 
328
        updateBorders();
329
        updateBorderLineListItem();
330
}
331
 
332
void PropertiesPalette_Table::on_borderLineStyle_activated(int style)
333
{
334
        int index = borderLineList->currentRow();
335
        TableBorderLine borderLine = m_currentBorder.borderLines().at(index);
336
        borderLine.setStyle(static_cast<Qt::PenStyle>(style + 1));
337
        m_currentBorder.replaceBorderLine(index, borderLine);
338
 
339
        updateBorders();
340
        updateBorderLineListItem();
341
}
342
 
343
void PropertiesPalette_Table::on_fillColor_activated(const QString& colorName)
344
{
345
        if (!m_item || !m_item->isTable())
346
                return;
347
 
348
        PageItem_Table* table = m_item->asTable();
349
        table->setFillColor(colorName);
350
 
351
        table->update();
352
}
353
 
354
void PropertiesPalette_Table::updateBorders()
355
{
356
        if (!m_doc || !m_item || !m_item->isTable())
357
                return;
358
 
359
        PageItem_Table* table = m_item->asTable();
360
        TableSideSelector::Sides selectedSides = sideSelector->selection();
361
 
362
        if (selectedSides & TableSideSelector::Left)
363
                table->setLeftBorder(m_currentBorder);
364
        if (selectedSides & TableSideSelector::Right)
365
                table->setRightBorder(m_currentBorder);
366
        if (selectedSides & TableSideSelector::Top)
367
                table->setTopBorder(m_currentBorder);
368
        if (selectedSides & TableSideSelector::Bottom)
369
                table->setBottomBorder(m_currentBorder);
370
 
371
        table->update();
372
}
373
 
374
void PropertiesPalette_Table::languageChange()
375
{
376
        // Not implemented.
377
}
378
 
379
void PropertiesPalette_Table::unitChange()
380
{
381
        // Not implemented.
382
}