Subversion Repositories Scribus

Rev

Rev 25113 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
25113 jghali 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
/***************************************************************************
8
                          symbolpalette.cpp  -  description
9
                             -------------------
10
    begin                : Sat May 8 2010
11
    copyright            : (C) 2010 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
24381 jghali 14
 
25113 jghali 15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
#include "symbolpalette.h"
24
#include <QPainter>
25
#include <QByteArray>
26
#include <QDrag>
27
#include <QMimeData>
28
#include "scpattern.h"
29
#include "scribusdoc.h"
30
#include "scribus.h"
31
 
32
SymbolView::SymbolView(QWidget* parent) : QListWidget(parent)
33
{
34
        setDragEnabled(true);
35
        setViewMode(QListView::IconMode);
36
        setFlow(QListView::LeftToRight);
37
        setSortingEnabled(true);
38
        setWrapping(true);
39
        setAcceptDrops(true);
40
        setDropIndicatorShown(true);
41
        setDragDropMode(QAbstractItemView::DragDrop);
42
        setResizeMode(QListView::Adjust);
43
        setSelectionMode(QAbstractItemView::SingleSelection);
44
        setContextMenuPolicy(Qt::CustomContextMenu);
25115 jghali 45
        m_delegate = new ScListWidgetDelegate(this, this);
46
        setItemDelegate(m_delegate);
25113 jghali 47
        setIconSize(QSize(48, 48));
48
        connect(this, SIGNAL(customContextMenuRequested (const QPoint&)), this, SLOT(handleContextMenu(QPoint)));
49
}
50
 
51
void SymbolView::handleContextMenu(QPoint p)
52
{
53
        QListWidgetItem *item = itemAt(p);
54
        if (item)
55
                return;
56
 
57
        QMenu *pmenu = new QMenu();
58
        QAction* viewAct;
59
        viewAct = pmenu->addAction( tr("Display Icons only"));
60
        viewAct->setCheckable(true);
25115 jghali 61
        viewAct->setChecked(m_delegate->iconOnly());
25113 jghali 62
        connect(viewAct, SIGNAL(triggered()), this, SLOT(changeDisplay()));
63
        pmenu->exec(QCursor::pos());
25115 jghali 64
        pmenu->deleteLater();
25113 jghali 65
}
66
 
67
void SymbolView::changeDisplay()
68
{
69
        reset();
25115 jghali 70
        m_delegate->setIconOnly(!m_delegate->iconOnly());
25113 jghali 71
        repaint();
72
}
73
 
74
void SymbolView::dragEnterEvent(QDragEnterEvent *e)
75
{
76
        if (e->source() == this)
77
                e->ignore();
78
        else
79
                e->acceptProposedAction();
80
}
81
 
82
void SymbolView::dragMoveEvent(QDragMoveEvent *e)
83
{
84
        if (e->source() == this)
85
                e->ignore();
86
        else
87
                e->acceptProposedAction();
88
}
89
 
90
void SymbolView::dropEvent(QDropEvent *e)
91
{
92
        if (e->mimeData()->hasText())
93
        {
94
                e->acceptProposedAction();
95
                if (e->source() == this)
96
                        return;
97
                QString text = e->mimeData()->text();
98
                if ((text.startsWith("<SCRIBUSELEM")) || (text.startsWith("SCRIBUSELEMUTF8")))
99
                        emit objectDropped();
100
        }
101
        else
102
                e->ignore();
103
}
104
 
105
 
106
bool SymbolView::viewportEvent(QEvent *event)
107
{
108
        if (event != nullptr)
109
        {
110
                if (event->type() == QEvent::ToolTip)
111
                {
112
                        QHelpEvent *helpEvent = static_cast<QHelpEvent *>(event);
113
                        QListWidgetItem* it = itemAt(helpEvent->pos());
114
                        if (it != nullptr)
115
                        {
116
                                event->accept();
117
                                QString tipText = it->text();
118
                                QToolTip::showText(helpEvent->globalPos(), tipText, this);
119
                                return true;
120
                        }
121
                }
122
                else if (event->type() == QEvent::MouseButtonPress)
123
                {
124
                        QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
125
                        if (mouseEvent->button() == Qt::RightButton)
126
                                return true;
127
                }
128
                else if (event->type() == QEvent::MouseButtonRelease)
129
                {
130
                        QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
131
                        if (mouseEvent->button() == Qt::RightButton)
132
                        {
133
                                emit customContextMenuRequested(mouseEvent->pos());
134
                                return true;
135
                        }
136
                }
137
        }
138
        return QListWidget::viewportEvent(event);
139
}
140
 
141
 void SymbolView::startDrag(Qt::DropActions supportedActions)
142
 {
143
        QMimeData *mimeData = new QMimeData;
144
        QByteArray data = currentItem()->text().toLocal8Bit();
145
        mimeData->setData("text/symbol", data);
146
        QDrag *drag = new QDrag(this);
147
        drag->setMimeData(mimeData);
148
        drag->setPixmap(currentItem()->icon().pixmap(48, 48));
149
        drag->exec(Qt::CopyAction);
150
        clearSelection();
151
}
152
 
24381 jghali 153
SymbolPalette::SymbolPalette( QWidget* parent) : ScDockPalette(parent, "Symb", Qt::WindowFlags())
154
{
155
        setContentsMargins(3, 3, 3, 3);
156
        setMinimumSize( QSize( 220, 240 ) );
157
        setObjectName(QString::fromLocal8Bit("Symb"));
158
        setSizePolicy( QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum));
25113 jghali 159
        SymbolViewWidget = new SymbolView(this);
160
        SymbolViewWidget->clear();
161
        setWidget( SymbolViewWidget );
162
 
163
        unsetDoc();
164
        m_scMW  = nullptr;
165
        editItemNames.clear();
166
        languageChange();
167
        m_item = nullptr;
168
        connect(SymbolViewWidget, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(handleDoubleClick(QListWidgetItem*)));
169
        connect(SymbolViewWidget, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(handleContextMenu(QPoint)));
170
        connect(SymbolViewWidget, SIGNAL(objectDropped()), this, SIGNAL(objectDropped()));
171
}
172
 
173
void SymbolPalette::handleContextMenu(QPoint p)
174
{
175
        if (!m_doc)
176
                return;
177
 
178
        QListWidgetItem *item = SymbolViewWidget->itemAt(p);
179
        if (!item)
180
                return;
181
        m_item = item;
182
 
183
        QMenu *pmenu = new QMenu();
184
        QAction* editAct = pmenu->addAction( tr("Edit Item"));
185
        editAct->setEnabled(item->flags() & Qt::ItemIsEnabled);
186
        connect(editAct, SIGNAL(triggered()), this, SLOT(handleEditItem()));
187
 
188
        QAction* delAct = pmenu->addAction( tr("Remove Item"));
189
        delAct->setEnabled(item->flags() & Qt::ItemIsEnabled);
190
        connect(delAct, SIGNAL(triggered()), this, SLOT(handleDeleteItem()));
191
 
192
        pmenu->exec(QCursor::pos());
25115 jghali 193
        pmenu->deleteLater();
25113 jghali 194
}
195
 
196
void SymbolPalette::handleDoubleClick(QListWidgetItem *item)
197
{
198
        if (item)
199
                emit startEdit(item->text());
200
}
201
 
202
void SymbolPalette::handleEditItem()
203
{
204
        if (m_item != nullptr)
205
        {
206
                emit startEdit(m_item->text());
207
                m_item = nullptr;
208
        }
209
}
210
 
211
void SymbolPalette::handleDeleteItem()
212
{
213
        if (m_item == nullptr)
214
                return;
215
 
216
        if (m_doc->docPatterns.contains(m_item->text()))
217
        {
218
                m_doc->removePattern(m_item->text());
219
                updateSymbolList();
220
                m_doc->regionsChanged()->update(QRect());
221
        }
222
        m_item = nullptr;
223
}
224
 
225
void SymbolPalette::editingStart(QStringList names)
226
{
227
        editItemNames = names;
228
        for (int a = 0; a < editItemNames.count(); a++)
229
        {
230
                QList<QListWidgetItem*> items = SymbolViewWidget->findItems(names[a], Qt::MatchExactly);
231
                if (items.count() > 0)
232
                        items[0]->setFlags(Qt::NoItemFlags);
233
        }
234
}
235
 
236
void SymbolPalette::editingFinished()
237
{
238
        editItemNames.clear();
239
        updateSymbolList();
240
}
241
 
242
void SymbolPalette::setMainWindow(ScribusMainWindow *mw)
243
{
244
        m_scMW = mw;
245
        if (m_scMW == nullptr)
246
        {
247
                SymbolViewWidget->clear();
248
                disconnect(m_scMW, SIGNAL(UpdateRequest(int)), this, SLOT(handleUpdateRequest(int)));
249
                return;
250
        }
251
        connect(m_scMW, SIGNAL(UpdateRequest(int)), this, SLOT(handleUpdateRequest(int)), Qt::UniqueConnection);
252
}
253
 
254
void SymbolPalette::setDoc(ScribusDoc *newDoc)
255
{
256
        if (m_scMW == nullptr)
257
                m_doc = nullptr;
258
        else
259
                m_doc = newDoc;
260
        if (m_doc == nullptr)
261
        {
262
                SymbolViewWidget->clear();
263
                setEnabled(true);
264
        }
265
        else
266
        {
267
                setEnabled(!m_doc->drawAsPreview);
268
                updateSymbolList();
269
        }
270
}
271
 
272
void SymbolPalette::unsetDoc()
273
{
274
        m_doc = nullptr;
275
        SymbolViewWidget->clear();
276
        setEnabled(true);
277
}
278
 
279
void SymbolPalette::handleUpdateRequest(int updateFlags)
280
{
281
        if (updateFlags & reqSymbolsUpdate)
282
                updateSymbolList();
283
}
284
 
285
void SymbolPalette::updateSymbolList()
286
{
287
        SymbolViewWidget->clear();
288
        SymbolViewWidget->setWordWrap(true);
289
        if (!m_doc)
290
                return;
291
 
292
        QStringList patK = m_doc->docPatterns.keys();
293
        patK.sort();
25115 jghali 294
        for (int i = 0; i < patK.count(); ++i)
25113 jghali 295
        {
25115 jghali 296
                const QString& patternName = patK.at(i);
297
                ScPattern sp = m_doc->docPatterns.value(patternName);
25113 jghali 298
                QPixmap pm;
299
                if (sp.getPattern()->width() >= sp.getPattern()->height())
300
                        pm = QPixmap::fromImage(sp.getPattern()->scaledToWidth(48, Qt::SmoothTransformation));
301
                else
302
                        pm = QPixmap::fromImage(sp.getPattern()->scaledToHeight(48, Qt::SmoothTransformation));
303
                QPixmap pm2(48, 48);
304
                pm2.fill(palette().color(QPalette::Base));
305
                QPainter p;
306
                p.begin(&pm2);
307
                p.drawPixmap(24 - pm.width() / 2, 24 - pm.height() / 2, pm);
308
                p.end();
25115 jghali 309
                QListWidgetItem *item = new QListWidgetItem(pm2, patternName, SymbolViewWidget);
310
                if (editItemNames.contains(patternName))
25113 jghali 311
                        item->setFlags(Qt::NoItemFlags);
312
                else
313
                        item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
314
        }
315
}
316
 
317
void SymbolPalette::changeEvent(QEvent *e)
318
{
319
        if (e->type() == QEvent::LanguageChange)
320
        {
321
                languageChange();
322
        }
323
        else
324
                ScDockPalette::changeEvent(e);
325
}
326
 
327
void SymbolPalette::languageChange()
328
{
329
        setWindowTitle( tr( "Symbols" ) );
330
}
331
 
332
void SymbolPalette::keyPressEvent(QKeyEvent* e)
333
{
334
        if (!m_doc)
335
                return;
336
        switch (e->key())
337
        {
338
                case Qt::Key_Backspace:
339
                case Qt::Key_Delete:
340
                        {
341
                                QListWidgetItem* it = SymbolViewWidget->currentItem();
342
                                if (it != nullptr)
343
                                {
344
                                        if (m_doc->docPatterns.contains(it->text()))
345
                                        {
346
                                                m_doc->removePattern(it->text());
347
                                                updateSymbolList();
348
                                                m_doc->regionsChanged()->update(QRect());
349
                                                e->accept();
350
                                        }
351
                                }
352
                        }
353
                        break;
354
                default:
355
                        break;
356
        }
357
}