Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
15599 fschmid 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
*   Copyright (C) 2010 by Franz Schmid                                    *
9
*   franz.schmid@altmuehlnet.de                                           *
10
*                                                                         *
11
*   This program is free software; you can redistribute it and/or modify  *
12
*   it under the terms of the GNU General Public License as published by  *
13
*   the Free Software Foundation; either version 2 of the License, or     *
14
*   (at your option) any later version.                                   *
15
*                                                                         *
16
*   This program is distributed in the hope that it will be useful,       *
17
*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
18
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
19
*   GNU General Public License for more details.                          *
20
*                                                                         *
21
*   You should have received a copy of the GNU General Public License     *
22
*   along with this program; if not, write to the                         *
23
*   Free Software Foundation, Inc.,                                       *
18122 mrdocs 24
*   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
15599 fschmid 25
***************************************************************************/
26
#include "paintmanager.h"
27
 
28
#include <QCheckBox>
29
#include <QMessageBox>
30
#include <QDomDocument>
15662 fschmid 31
#include <QMenu>
32
#include <QCursor>
16016 fschmid 33
#include <QEventLoop>
34
#include <QImageReader>
35
#include <QDir>
36
#include <QFileDialog>
15599 fschmid 37
#include "cmykfw.h"
38
#include "colorlistbox.h"
39
#include "commonstrings.h"
40
#include "ui/customfdialog.h"
41
#include "dcolor.h"
42
#include "fileloader.h"
43
#include "gradientaddedit.h"
15622 fschmid 44
#include "loadsaveplugin.h"
16016 fschmid 45
#include "plugins/formatidlist.h"
15599 fschmid 46
#include "prefsfile.h"
47
#include "prefsmanager.h"
48
#include "query.h"
49
#include "sccolor.h"
50
#include "sccolorengine.h"
51
#include "scconfig.h"
16504 fschmid 52
#include "sclimits.h"
15599 fschmid 53
#include "sclistboxpixmap.h"
54
#include "scclocale.h"
55
#include "scpainter.h"
56
#include "scpaths.h"
57
#include "sctextstream.h"
16016 fschmid 58
#include "scribusXml.h"
59
#include "undomanager.h"
15599 fschmid 60
#include "util.h"
61
#include "util_color.h"
62
#include "util_formats.h"
63
#include "util_icon.h"
64
 
17400 fschmid 65
PaintManagerDialog::PaintManagerDialog(QWidget* parent, QHash<QString, VGradient> *docGradients, ColorList doco, QString docColSet, QHash<QString, ScPattern> *docPatterns, ScribusDoc *doc, ScribusMainWindow *scMW) : QDialog(parent)
15599 fschmid 66
{
67
        setupUi(this);
68
        setModal(true);
69
        paletteLocked = false;
15674 fschmid 70
        modified = false;
15662 fschmid 71
        sortRule = 0;
15599 fschmid 72
        m_doc = doc;
73
        m_colorList = doco;
74
        mainWin = scMW;
75
        setWindowIcon(QIcon(loadIcon ( "AppIcon.png" )));
15662 fschmid 76
        dataTree->setContextMenuPolicy(Qt::CustomContextMenu);
16016 fschmid 77
        dataTree->setIconSize(QSize(60, 48));
15599 fschmid 78
        colorItems = new QTreeWidgetItem(dataTree);
79
        colorItems->setText(0, tr("Solid Colors"));
80
        gradientItems = new QTreeWidgetItem(dataTree);
81
        gradientItems->setText(0, tr("Gradients"));
17400 fschmid 82
        for (QHash<QString, VGradient>::Iterator it = docGradients->begin(); it != docGradients->end(); ++it)
15599 fschmid 83
        {
84
                dialogGradients.insert(it.key(), it.value());
85
                origNames.insert(it.key(), it.key());
86
        }
87
        origGradients = docGradients->keys();
15635 fschmid 88
 
16016 fschmid 89
        patternItems = new QTreeWidgetItem(dataTree);
90
        patternItems->setText(0, tr("Patterns"));
17400 fschmid 91
        for (QHash<QString, ScPattern>::Iterator it = docPatterns->begin(); it != docPatterns->end(); ++it)
16016 fschmid 92
        {
93
                dialogPatterns.insert(it.key(), it.value());
94
                origNamesPatterns.insert(it.key(), it.key());
95
        }
96
        origPatterns = docPatterns->keys();
97
 
15599 fschmid 98
        csm.findPaletteLocations();
15635 fschmid 99
        systemSwatches = LoadColSet->addTopLevelItem( tr("Scribus Swatches"));
100
        csm.findPalettes(systemSwatches);
101
        LoadColSet->addSubItem("Scribus Small", systemSwatches);
102
        systemSwatches->setExpanded(true);
103
        userSwatches = LoadColSet->addTopLevelItem( tr("User Swatches"));
15681 fschmid 104
        csm.findUserPalettes(userSwatches);
15684 fschmid 105
        customColSet = csm.userPaletteNames();
15635 fschmid 106
        userSwatches->setExpanded(true);
15764 fschmid 107
//      QFileInfo fi(docColSet);
108
        LoadColSet->setCurrentComboItem(docColSet);
16016 fschmid 109
        if (mainWin->HaveDoc)
15663 fschmid 110
        {
111
                label->setText( tr("Merge Color Set"));
15647 fschmid 112
                m_doc->getUsedColors(inDocUsedColors);
15676 fschmid 113
                paletteLocked = false;
15663 fschmid 114
        }
15676 fschmid 115
        else
116
        {
15681 fschmid 117
                if (docColSet != "Scribus Small")
15676 fschmid 118
                {
15681 fschmid 119
                        QString pfad = "";
15684 fschmid 120
                        if (customColSet.contains(docColSet))
15681 fschmid 121
                                pfad = csm.userPaletteFileFromName(docColSet);
122
                        else
123
                                pfad = csm.paletteFileFromName(docColSet);
124
                        QFileInfo fi(pfad);
125
                        if (fi.absolutePath().contains(ScPaths::getApplicationDataDir()+"swatches/locked"))
126
                                paletteLocked = true;
127
                        else
128
                                paletteLocked = !fi.isWritable();
15676 fschmid 129
                }
130
        }
15599 fschmid 131
        importButton->setEnabled(false);
132
        newButton->setEnabled(false);
133
        editButton->setEnabled(false);
134
        duplicateButton->setEnabled(false);
135
        deleteButton->setEnabled(false);
136
        deleteUnusedButton->setEnabled(false);
16016 fschmid 137
        updateColorList();
15599 fschmid 138
        updateGradientList();
16016 fschmid 139
        updatePatternList();
15622 fschmid 140
        dataTree->expandItem(colorItems);
141
        dataTree->expandItem(gradientItems);
16016 fschmid 142
        dataTree->expandItem(patternItems);
15647 fschmid 143
        dataTree->setSelectionMode(QAbstractItemView::ExtendedSelection);
15599 fschmid 144
        connect(dataTree, SIGNAL(itemClicked(QTreeWidgetItem*, int)), this, SLOT(itemSelected(QTreeWidgetItem*)));
15622 fschmid 145
        connect(dataTree, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), this, SLOT(selEditColor(QTreeWidgetItem*)));
15647 fschmid 146
        connect(dataTree, SIGNAL(itemSelectionChanged()), this, SLOT(itemSelectionChanged()));
15662 fschmid 147
        connect(dataTree, SIGNAL(customContextMenuRequested (const QPoint &)), this, SLOT(slotRightClick(QPoint)));
15599 fschmid 148
        connect(newButton, SIGNAL(clicked()), this, SLOT(createNew()));
149
        connect(editButton, SIGNAL(clicked()), this, SLOT(editColorItem()));
150
        connect(duplicateButton, SIGNAL(clicked()), this, SLOT(duplicateColorItem()));
151
        connect(deleteButton, SIGNAL(clicked()), this, SLOT(removeColorItem()));
152
        connect(deleteUnusedButton, SIGNAL(clicked()), this, SLOT(removeUnusedColorItem()));
153
        connect(importButton, SIGNAL(clicked()), this, SLOT(importColorItems()));
15674 fschmid 154
        connect(okButton, SIGNAL(clicked()), this, SLOT(leaveDialog()));
15599 fschmid 155
        connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
156
        connect(SaveColSet, SIGNAL(clicked()), this, SLOT(saveDefaults()));
15696 fschmid 157
        connect(LoadColSet, SIGNAL(activated(QTreeWidgetItem*)), this, SLOT(loadDefaults(QTreeWidgetItem*)));
15599 fschmid 158
}
159
 
15674 fschmid 160
void PaintManagerDialog::leaveDialog()
161
{
16016 fschmid 162
/*      if (!mainWin->HaveDoc)
15674 fschmid 163
        {
164
                if (modified)
165
                {
166
                        if (paletteLocked)
167
                                saveDefaults();
168
                        else
169
                                doSaveDefaults(LoadColSet->text(), true);
170
                }
16016 fschmid 171
        } */
15674 fschmid 172
        accept();
173
}
174
 
16016 fschmid 175
QTreeWidgetItem* PaintManagerDialog::updatePatternList(QString addedName)
176
{
177
        QList<QTreeWidgetItem*> lg = patternItems->takeChildren();
178
        for (int a = 0; a < lg.count(); a++)
179
        {
180
                delete lg[a];
181
        }
182
        QTreeWidgetItem* ret = 0;
17400 fschmid 183
        QStringList patK = dialogPatterns.keys();
184
        qSort(patK);
185
        for (int a = 0; a < patK.count(); a++)
16016 fschmid 186
        {
17400 fschmid 187
                ScPattern sp = dialogPatterns.value(patK[a]);
16016 fschmid 188
                QPixmap pm;
17400 fschmid 189
                if (sp.getPattern()->width() >= sp.getPattern()->height())
190
                        pm = QPixmap::fromImage(sp.getPattern()->scaledToWidth(48, Qt::SmoothTransformation));
16016 fschmid 191
                else
17400 fschmid 192
                        pm = QPixmap::fromImage(sp.getPattern()->scaledToHeight(48, Qt::SmoothTransformation));
16016 fschmid 193
                QPixmap pm2(48, 48);
194
                pm2.fill(palette().color(QPalette::Base));
195
                QPainter p;
196
                p.begin(&pm2);
197
                p.drawPixmap(24 - pm.width() / 2, 24 - pm.height() / 2, pm);
198
                p.end();
199
                QTreeWidgetItem *item = new QTreeWidgetItem(patternItems);
17400 fschmid 200
                item->setText(0, patK[a]);
201
                if (patK[a] == addedName)
16016 fschmid 202
                        ret = item;
203
                item->setIcon(0, pm2);
204
                item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
205
        }
206
        return ret;
207
}
208
 
15623 craig 209
QTreeWidgetItem* PaintManagerDialog::updateGradientList(QString addedName)
15599 fschmid 210
{
211
        QList<QTreeWidgetItem*> lg = gradientItems->takeChildren();
212
        for (int a = 0; a < lg.count(); a++)
213
        {
214
                delete lg[a];
215
        }
216
        QTreeWidgetItem* ret = 0;
17400 fschmid 217
        QStringList patK = dialogGradients.keys();
218
        qSort(patK);
219
        for (int a = 0; a < patK.count(); a++)
15599 fschmid 220
        {
17400 fschmid 221
                VGradient gr = dialogGradients.value(patK[a]);
15599 fschmid 222
                QImage pixm(48, 12, QImage::Format_ARGB32);
223
                QPainter pb;
224
                QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
225
                pb.begin(&pixm);
226
                pb.fillRect(0, 0, 48, 12, b);
227
                pb.end();
228
                ScPainter *p = new ScPainter(&pixm, 48, 12);
17794 fschmid 229
                p->setPen(Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
15599 fschmid 230
                p->setFillMode(2);
17400 fschmid 231
                p->fill_gradient = gr;
15599 fschmid 232
                p->setGradient(VGradient::linear, FPoint(0,6), FPoint(48, 6), FPoint(0, 0), 1.0, 0.0);
233
                p->drawRect(0, 0, 48, 12);
234
                p->end();
235
                delete p;
236
                QPixmap pm;
237
                pm = QPixmap::fromImage(pixm);
238
                QTreeWidgetItem *item = new QTreeWidgetItem(gradientItems);
17400 fschmid 239
                item->setText(0, patK[a]);
240
                if (patK[a] == addedName)
15599 fschmid 241
                        ret = item;
242
                item->setIcon(0, pm);
243
                item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
244
        }
245
        return ret;
246
}
247
 
15623 craig 248
QTreeWidgetItem* PaintManagerDialog::updateColorList(QString addedName)
15599 fschmid 249
{
250
        QList<QTreeWidgetItem*> lg = colorItems->takeChildren();
251
        for (int a = 0; a < lg.count(); a++)
252
        {
253
                delete lg[a];
254
        }
255
        QTreeWidgetItem* ret = 0;
15662 fschmid 256
        if (sortRule > 0)
15599 fschmid 257
        {
15662 fschmid 258
                QMap<QString, QString> sortMap;
259
                ColorList::Iterator it;
260
                for (it = m_colorList.begin(); it != m_colorList.end(); ++it)
261
                {
262
                        if (sortRule == 1)
263
                        {
264
                                QColor c = it.value().getRawRGBColor();
265
                                QString sortString = QString("%1-%2-%3-%4").arg(c.hue(), 3, 10, QChar('0')).arg(c.saturation(), 3, 10, QChar('0')).arg(c.value(), 3, 10, QChar('0')).arg(it.key());
266
                                sortMap.insert(sortString, it.key());
267
                        }
268
                        else if (sortRule == 2)
269
                        {
270
                                QString sortString = QString("%1-%2");
271
                                if (it.value().isRegistrationColor())
272
                                        sortMap.insert(sortString.arg("A").arg(it.key()), it.key());
273
                                else if (it.value().isSpotColor())
274
                                        sortMap.insert(sortString.arg("B").arg(it.key()), it.key());
275
                                else if (it.value().getColorModel() == colorModelCMYK)
276
                                        sortMap.insert(sortString.arg("C").arg(it.key()), it.key());
277
                                else
278
                                        sortMap.insert(sortString.arg("D").arg(it.key()), it.key());
279
                        }
280
                }
281
                QMap<QString, QString>::Iterator itc;
282
                for (itc = sortMap.begin(); itc != sortMap.end(); ++itc)
283
                {
284
                        QTreeWidgetItem *item = new QTreeWidgetItem(colorItems);
285
                        item->setText(0, itc.value());
286
                        if (itc.value() == addedName)
287
                                ret = item;
288
                        QPixmap* pPixmap = getFancyPixmap(m_colorList[itc.value()], m_doc);
289
                        item->setIcon(0, *pPixmap);
290
                        item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
291
                }
15599 fschmid 292
        }
15662 fschmid 293
        else
294
        {
295
                ColorList::Iterator it;
296
                for (it = m_colorList.begin(); it != m_colorList.end(); ++it)
297
                {
298
                        QTreeWidgetItem *item = new QTreeWidgetItem(colorItems);
299
                        item->setText(0, it.key());
300
                        if (it.key() == addedName)
301
                                ret = item;
302
                        QPixmap* pPixmap = getFancyPixmap(it.value(), m_doc);
303
                        item->setIcon(0, *pPixmap);
304
                        item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
305
                }
306
        }
15599 fschmid 307
        return ret;
308
}
309
 
15662 fschmid 310
void PaintManagerDialog::slotRightClick(QPoint p)
311
{
312
        QTreeWidgetItem* it = dataTree->itemAt(p);
313
        if (it)
314
        {
315
                if ((it->parent() == colorItems) || (it == colorItems))
316
                {
317
                        QMenu *pmen = new QMenu();
318
                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
319
                        pmen->addAction( tr("Sort by Name"));
320
                        pmen->addAction( tr("Sort by Color"));
321
                        pmen->addAction( tr("Sort by Type"));
322
                        sortRule = pmen->actions().indexOf(pmen->exec(QCursor::pos()));
323
                        delete pmen;
324
                        updateColorList();
325
                }
326
        }
327
}
328
 
15623 craig 329
void PaintManagerDialog::selEditColor(QTreeWidgetItem *it)
15622 fschmid 330
{
331
        if ((it) && (!paletteLocked))
332
        {
333
                if ((it->parent() == colorItems) || (it->parent() == gradientItems))
334
                {
335
                        QString curCol = it->text(0);
336
                        ScColor tmpColor = m_colorList[curCol];
337
                        bool enableDel  = (curCol != "Black" && curCol != "White" && !tmpColor.isRegistrationColor()) && (m_colorList.count() > 1);
338
                        bool enableEdit = (curCol != "Black" && curCol != "White" && !tmpColor.isRegistrationColor());
339
                        duplicateButton->setEnabled(curCol != "Registration");
340
                        deleteButton->setEnabled(enableDel);
341
                        editButton->setEnabled(enableEdit);
342
                        if(enableEdit)
343
                                editColorItem();
344
                }
345
        }
346
}
347
 
15647 fschmid 348
void PaintManagerDialog::itemSelectionChanged()
349
{
350
        QList<QTreeWidgetItem *> selItems = dataTree->selectedItems();
351
        if (selItems.count() > 1)
352
                deleteButton->setEnabled(true);
353
}
354
 
15623 craig 355
void PaintManagerDialog::itemSelected(QTreeWidgetItem* it)
15599 fschmid 356
{
15647 fschmid 357
        QList<QTreeWidgetItem *> selItems = dataTree->selectedItems();
16016 fschmid 358
        importButton->setText( tr("&Import"));
359
        newButton->setText( tr("Add"));
360
        editButton->setText( tr("&Edit"));
15599 fschmid 361
        if ((it) && (!paletteLocked))
362
        {
363
                if ((it->parent() == colorItems) || (it->parent() == gradientItems))
364
                {
365
                        importButton->setEnabled(false);
366
                        newButton->setEnabled(true);
367
                        deleteUnusedButton->setEnabled(it->parent() == colorItems);
15622 fschmid 368
                        if (it->parent() == colorItems)
369
                        {
370
                                QString curCol = it->text(0);
371
                                ScColor tmpColor = m_colorList[curCol];
372
                                bool enableDel  = (curCol != "Black" && curCol != "White" && !tmpColor.isRegistrationColor()) && (m_colorList.count() > 1);
373
                                bool enableEdit = (curCol != "Black" && curCol != "White" && !tmpColor.isRegistrationColor());
374
                                duplicateButton->setEnabled(curCol != "Registration");
375
                                deleteButton->setEnabled(enableDel);
376
                                editButton->setEnabled(enableEdit);
377
                        }
378
                        else
379
                        {
380
                                editButton->setEnabled(true);
381
                                duplicateButton->setEnabled(true);
382
                                deleteButton->setEnabled(true);
383
                        }
15599 fschmid 384
                }
16016 fschmid 385
                else if (it->parent() == patternItems)
386
                {
387
                        importButton->setText( tr("Load File"));
388
                        newButton->setText( tr("Load Set"));
389
                        editButton->setText( tr("Rename"));
390
                        importButton->setEnabled(true);
391
                        newButton->setEnabled(true);
392
                        editButton->setEnabled(true);
393
                        duplicateButton->setEnabled(false);
394
                        deleteButton->setEnabled(true);
395
                }
396
                else if (it == patternItems)
397
                {
398
                        importButton->setText( tr("Load File"));
399
                        newButton->setText( tr("Load Set"));
400
                        importButton->setEnabled(true);
401
                        newButton->setEnabled(true);
402
                        editButton->setEnabled(false);
403
                        duplicateButton->setEnabled(false);
404
                        if (selItems.count() < 2)
405
                                deleteButton->setEnabled(it->childCount() > 0);
406
                        else
407
                                deleteButton->setEnabled(true);
408
                }
15599 fschmid 409
                else
410
                {
411
                        importButton->setEnabled(true);
412
                        newButton->setEnabled(true);
413
                        editButton->setEnabled(false);
414
                        duplicateButton->setEnabled(false);
15647 fschmid 415
                        if (selItems.count() < 2)
416
                                deleteButton->setEnabled(it->childCount() > 0);
417
                        else
418
                                deleteButton->setEnabled(true);
15599 fschmid 419
                        deleteUnusedButton->setEnabled((it == colorItems) && (it->childCount() > 0));
420
                }
421
        }
422
        else
423
        {
424
                importButton->setEnabled(false);
425
                newButton->setEnabled(false);
426
                editButton->setEnabled(false);
427
                duplicateButton->setEnabled(false);
428
                deleteButton->setEnabled(false);
429
                deleteUnusedButton->setEnabled(false);
430
                dataTree->clearSelection();
431
        }
432
}
433
 
15623 craig 434
void PaintManagerDialog::createNew()
15599 fschmid 435
{
436
        if (paletteLocked)
437
                return;
438
        QTreeWidgetItem* it = dataTree->currentItem();
439
        if (it)
440
        {
441
                if ((it->parent() == gradientItems) || (it == gradientItems))
442
                {
443
                        VGradient fill_gradient = VGradient(VGradient::linear);
444
                        fill_gradient.clearStops();
445
                        fill_gradient.addStop(QColor(Qt::black), 0.0, 0.5, 1.0, "Black", 100);
446
                        fill_gradient.addStop(QColor(Qt::white), 1.0, 0.5, 1.0, "White", 100);
447
                        gradientEditDialog *dia = new gradientEditDialog(this, tr("New Gradient"), fill_gradient, m_colorList, m_doc, &dialogGradients, true);
448
                        if (dia->exec())
449
                        {
450
                                dialogGradients.insert(dia->name(), dia->gradient());
451
                                QTreeWidgetItem *lg = updateGradientList(dia->name());
452
                                if (lg != 0)
453
                                {
454
                                        dataTree->expandItem(lg->parent());
455
                                        dataTree->setCurrentItem(lg, 0, QItemSelectionModel::ClearAndSelect);
456
                                }
457
                                itemSelected(dataTree->currentItem());
15674 fschmid 458
                                modified = true;
15599 fschmid 459
                        }
460
                        delete dia;
461
                }
462
                else if ((it->parent() == colorItems) || (it == colorItems))
463
                {
464
                        ScColor tmpColor = ScColor(0, 0, 0, 0);
15696 fschmid 465
                        CMYKChoose* dia = new CMYKChoose(this, m_doc, tmpColor, tr("New Color"), &m_colorList, true);
15599 fschmid 466
                        if (dia->exec())
467
                        {
468
                                dia->Farbe.setSpotColor(dia->Separations->isChecked());
469
                                m_colorList.insert(dia->Farbname->text(), dia->Farbe);
470
                                QTreeWidgetItem *lg = updateColorList(dia->Farbname->text());
471
                                if (lg != 0)
472
                                {
473
                                        dataTree->expandItem(lg->parent());
474
                                        dataTree->setCurrentItem(lg, 0, QItemSelectionModel::ClearAndSelect);
475
                                }
476
                                itemSelected(dataTree->currentItem());
15674 fschmid 477
                                modified = true;
15599 fschmid 478
                        }
479
                        delete dia;
480
                }
16016 fschmid 481
                else if ((it->parent() == patternItems) || (it == patternItems))
482
                {
483
                        loadPatternDir();
484
                        updateColorList();
485
                        updateGradientList();
486
                        updatePatternList();
487
                        itemSelected(0);
488
                }
15599 fschmid 489
        }
490
}
491
 
15623 craig 492
void PaintManagerDialog::editColorItem()
15599 fschmid 493
{
494
        if (paletteLocked)
495
                return;
496
        QTreeWidgetItem* it = dataTree->currentItem();
497
        if (it)
498
        {
16016 fschmid 499
                if (it->parent() == gradientItems)
15599 fschmid 500
                {
501
                        QString gradN = it->text(0);
502
                        QString patternName = origNames[it->text(0)];
503
                        QString newName = "";
504
                        gradientEditDialog *dia = new gradientEditDialog(this, gradN, dialogGradients[gradN], m_colorList, m_doc, &dialogGradients, false);
505
                        if (dia->exec())
506
                        {
507
                                newName = dia->name();
508
                                if (newName != gradN)
509
                                {
510
                                        origNames.remove(patternName);
511
                                        origNames.insert(newName, patternName);
512
                                        replaceMap.insert(patternName, newName);
513
                                        dialogGradients.remove(gradN);
514
                                        dialogGradients.insert(newName, dia->gradient());
515
                                }
516
                                else
517
                                        dialogGradients[gradN] = dia->gradient();
16016 fschmid 518
                                QStringList patterns = dialogPatterns.keys();
519
                                for (int c = 0; c < dialogPatterns.count(); ++c)
520
                                {
521
                                        ScPattern pa = dialogPatterns[patterns[c]];
522
                                        for (int o = 0; o < pa.items.count(); o++)
523
                                        {
524
                                                PageItem *ite = pa.items.at(o);
525
                                                if (ite->gradient() == gradN)
526
                                                        ite->setGradient(newName);
527
                                                if (ite->strokeGradient() == gradN)
528
                                                        ite->setStrokeGradient(newName);
529
                                                if (ite->gradientMask() == gradN)
530
                                                        ite->setGradientMask(newName);
531
                                        }
532
                                        PageItem *ite = pa.items.at(0);
16504 fschmid 533
                                        dialogPatterns[patterns[c]].pattern = ite->DrawObj_toImage(pa.items, 1.0);
16016 fschmid 534
                                }
15599 fschmid 535
                                QTreeWidgetItem *lg = updateGradientList(dia->name());
536
                                if (lg != 0)
537
                                {
538
                                        dataTree->expandItem(lg->parent());
539
                                        dataTree->setCurrentItem(lg, 0, QItemSelectionModel::ClearAndSelect);
540
                                }
541
                                itemSelected(dataTree->currentItem());
15674 fschmid 542
                                modified = true;
15599 fschmid 543
                        }
544
                        delete dia;
545
                }
16016 fschmid 546
                else if (it->parent() == colorItems)
15599 fschmid 547
                {
548
                        ScColor tmpColor = m_colorList[it->text(0)];
15696 fschmid 549
                        CMYKChoose* dia = new CMYKChoose(this, m_doc, tmpColor, it->text(0), &m_colorList, false);
15599 fschmid 550
                        if (dia->exec())
551
                        {
552
                                dia->Farbe.setSpotColor(dia->Separations->isChecked());
553
                                dia->Farbe.setRegistrationColor(tmpColor.isRegistrationColor());
554
                                m_colorList[dia->Farbname->text()] = dia->Farbe;
555
                                if (it->text(0) != dia->Farbname->text())
556
                                {
557
                                        replaceColorMap.insert(it->text(0), dia->Farbname->text());
558
                                        m_colorList.remove(it->text(0));
559
                                }
560
                                updateGradientColors(dia->Farbname->text(), it->text(0));
561
                                updateGradientList();
16016 fschmid 562
                                updatePatternList();
15599 fschmid 563
                                QTreeWidgetItem *lg = updateColorList(dia->Farbname->text());
564
                                if (lg != 0)
565
                                {
566
                                        dataTree->expandItem(lg->parent());
567
                                        dataTree->setCurrentItem(lg, 0, QItemSelectionModel::ClearAndSelect);
568
                                }
569
                                itemSelected(dataTree->currentItem());
15674 fschmid 570
                                modified = true;
15599 fschmid 571
                        }
572
                        delete dia;
573
                }
16016 fschmid 574
                else if (it->parent() == patternItems)
575
                {
576
                        QString patternName = origNames[it->text(0)];
577
                        QString newName = "";
578
                        Query dia(this, "tt", 1, 0, tr("&Name:"), tr("Rename Entry"));
579
                        dia.setEditText(it->text(0), true);
580
                        dia.setTestList(dialogPatterns.keys());
581
                        if (dia.exec())
582
                        {
583
                                newName = dia.getEditText();
584
                                ScPattern pat = dialogPatterns.take(it->text(0));
585
                                dialogPatterns.insert(newName, pat);
586
                                replaceMapPatterns.insert(patternName, newName);
587
                                origNamesPatterns.remove(it->text(0));
588
                                origNamesPatterns.insert(newName, patternName);
589
                                QStringList patterns = dialogPatterns.keys();
590
                                for (int c = 0; c < dialogPatterns.count(); ++c)
591
                                {
592
                                        ScPattern pa = dialogPatterns[patterns[c]];
593
                                        for (int o = 0; o < pa.items.count(); o++)
594
                                        {
595
                                                PageItem *ite = pa.items.at(o);
596
                                                if ((ite->pattern() == patternName) && ((ite->GrType == 8) || (ite->itemType() == PageItem::Symbol)))
597
                                                        ite->setPattern(newName);
598
                                                if (!ite->strokePattern().isEmpty())
599
                                                {
600
                                                        if (ite->strokePattern() == patternName)
601
                                                                ite->setStrokePattern(newName);
602
                                                }
603
                                                if (!ite->patternMask().isEmpty())
604
                                                {
605
                                                        if (ite->patternMask() == patternName)
606
                                                                ite->setPatternMask(newName);
607
                                                }
608
                                        }
609
                                }
610
                                QTreeWidgetItem *lg = updatePatternList(newName);
611
                                if (lg != 0)
612
                                {
613
                                        dataTree->expandItem(lg->parent());
614
                                        dataTree->setCurrentItem(lg, 0, QItemSelectionModel::ClearAndSelect);
615
                                }
616
                                itemSelected(dataTree->currentItem());
617
                        }
618
                        else
619
                                return;
620
                }
15599 fschmid 621
        }
622
}
623
 
15623 craig 624
void PaintManagerDialog::duplicateColorItem()
15599 fschmid 625
{
626
        if (paletteLocked)
627
                return;
628
        QTreeWidgetItem* it = dataTree->currentItem();
629
        if (it)
630
        {
16016 fschmid 631
                if (it->parent() == gradientItems)
15599 fschmid 632
                {
633
                        QString gradN = tr("Copy of %1").arg(it->text(0));
634
                        dialogGradients.insert(gradN, dialogGradients[it->text(0)]);
635
                        origNames.insert(gradN, gradN);
636
                        QString patternName = origNames[gradN];
637
                        QString newName = "";
638
                        gradientEditDialog *dia = new gradientEditDialog(this, gradN, dialogGradients[gradN], m_colorList, m_doc, &dialogGradients, false);
639
                        if (dia->exec())
640
                        {
641
                                newName = dia->name();
642
                                if (newName != gradN)
643
                                {
644
                                        origNames.remove(patternName);
645
                                        origNames.insert(newName, patternName);
646
                                        replaceMap.insert(patternName, newName);
647
                                        dialogGradients.remove(gradN);
648
                                        dialogGradients.insert(newName, dia->gradient());
649
                                }
650
                                else
651
                                        dialogGradients[gradN] = dia->gradient();
16016 fschmid 652
                                updatePatternList();
15599 fschmid 653
                                QTreeWidgetItem *lg = updateGradientList(dia->name());
654
                                if (lg != 0)
655
                                {
656
                                        dataTree->expandItem(lg->parent());
657
                                        dataTree->setCurrentItem(lg, 0, QItemSelectionModel::ClearAndSelect);
658
                                }
659
                                itemSelected(dataTree->currentItem());
15674 fschmid 660
                                modified = true;
15599 fschmid 661
                        }
662
                        delete dia;
663
                }
16016 fschmid 664
                else if (it->parent() == colorItems)
15599 fschmid 665
                {
666
                        QString nam = tr("Copy of %1").arg(it->text(0));
667
                        m_colorList.insert(nam, m_colorList[it->text(0)]);
668
                        ScColor tmpColor = m_colorList[nam];
15696 fschmid 669
                        CMYKChoose* dia = new CMYKChoose(this, m_doc, tmpColor, nam, &m_colorList, false);
15599 fschmid 670
                        if (dia->exec())
671
                        {
672
                                dia->Farbe.setSpotColor(dia->Separations->isChecked());
673
                                dia->Farbe.setRegistrationColor(tmpColor.isRegistrationColor());
674
                                m_colorList[dia->Farbname->text()] = dia->Farbe;
675
                                if (nam != dia->Farbname->text())
676
                                {
677
                                        replaceColorMap.insert(nam, dia->Farbname->text());
678
                                        m_colorList.remove(nam);
679
                                }
680
                                updateGradientColors(dia->Farbname->text(), nam);
681
                                updateGradientList();
16016 fschmid 682
                                updatePatternList();
15599 fschmid 683
                                QTreeWidgetItem *lg = updateColorList(dia->Farbname->text());
684
                                if (lg != 0)
685
                                {
686
                                        dataTree->expandItem(lg->parent());
687
                                        dataTree->setCurrentItem(lg, 0, QItemSelectionModel::ClearAndSelect);
688
                                }
689
                                itemSelected(dataTree->currentItem());
15674 fschmid 690
                                modified = true;
15599 fschmid 691
                        }
692
                        delete dia;
693
                }
694
        }
695
}
696
 
15623 craig 697
void PaintManagerDialog::removeColorItem()
15599 fschmid 698
{
699
        if (paletteLocked)
700
                return;
15647 fschmid 701
        QList<QTreeWidgetItem *> selItems = dataTree->selectedItems();
702
        if (selItems.count() > 1)
15599 fschmid 703
        {
15647 fschmid 704
                QStringList usedColors;
705
                QStringList colors;
706
                QStringList gradients;
16016 fschmid 707
                QStringList patterns;
15647 fschmid 708
                for (int a = 0; a < selItems.count(); a++)
15599 fschmid 709
                {
15647 fschmid 710
                        QTreeWidgetItem* it = selItems[a];
15622 fschmid 711
                        if (it == gradientItems)
15647 fschmid 712
                                continue;
713
                        if (it == colorItems)
714
                                continue;
715
                        if (it->text(0) == "Black")
716
                                continue;
717
                        if (it->text(0) == "White")
718
                                continue;
719
                        if (m_colorList[it->text(0)].isRegistrationColor())
720
                                continue;
721
                        if (it->parent() == gradientItems)
722
                                gradients.append(it->text(0));
723
                        if (it->parent() == colorItems)
724
                                colors.append(it->text(0));
16016 fschmid 725
                        if (it->parent() == patternItems)
726
                                patterns.append(it->text(0));
15647 fschmid 727
                }
728
                for (int a = 0; a < gradients.count(); a++)
729
                {
730
                        dialogGradients.remove(gradients[a]);
731
                        replaceMap.insert(gradients[a], "");
732
                }
733
                bool hasUsed = false;
734
                ColorList UsedCG = getGradientColors();
735
                for (int a = 0; a < colors.count(); a++)
736
                {
737
                        if (UsedCG.contains(colors[a]) || inDocUsedColors.contains(colors[a]))
15622 fschmid 738
                        {
15647 fschmid 739
                                hasUsed = true;
740
                                usedColors.append(colors[a]);
15622 fschmid 741
                        }
15599 fschmid 742
                }
15647 fschmid 743
                if (hasUsed)
15599 fschmid 744
                {
15647 fschmid 745
                        ColorList dCols = m_colorList;
746
                        QString dColor = tr("Selected Colors");
747
                        for (int a = 0; a < usedColors.count(); a++)
15599 fschmid 748
                        {
15647 fschmid 749
                                dCols.remove(usedColors[a]);
15622 fschmid 750
                        }
15647 fschmid 751
                        dCols.insert(dColor , ScColor());
16016 fschmid 752
                        DelColor *dia = new DelColor(this, dCols, dColor, true);
15647 fschmid 753
                        if (dia->exec())
15622 fschmid 754
                        {
15647 fschmid 755
                                QString replacementColor(dia->getReplacementColor());
756
                                for (int a = 0; a < colors.count(); a++)
15622 fschmid 757
                                {
15647 fschmid 758
                                        dColor = colors[a];
15622 fschmid 759
                                        if (replacementColor == CommonStrings::tr_NoneColor)
760
                                                replacementColor = CommonStrings::None;
761
                                        if (replaceColorMap.values().contains(dColor))
15599 fschmid 762
                                        {
15622 fschmid 763
                                                QMap<QString,QString>::Iterator itt;
764
                                                for (itt = replaceColorMap.begin(); itt != replaceColorMap.end(); ++itt)
765
                                                {
766
                                                        if (itt.value() == dColor)
767
                                                                itt.value() = replacementColor;
768
                                                }
15599 fschmid 769
                                        }
15622 fschmid 770
                                        replaceColorMap.insert(dColor, replacementColor);
771
                                        m_colorList.remove(dColor);
772
                                        updateGradientColors(replacementColor, dColor);
15599 fschmid 773
                                }
15674 fschmid 774
                                modified = true;
15599 fschmid 775
                        }
15647 fschmid 776
                        delete dia;
15599 fschmid 777
                }
15647 fschmid 778
                else
779
                {
780
                        for (int a = 0; a < colors.count(); a++)
781
                        {
782
                                replaceColorMap.insert(colors[a], "Black");
783
                                m_colorList.remove(colors[a]);
784
                        }
15674 fschmid 785
                        modified = true;
15647 fschmid 786
                }
16016 fschmid 787
                updatePatternList();
15647 fschmid 788
                updateGradientList();
789
                updateColorList();
790
                itemSelected(0);
15599 fschmid 791
        }
15647 fschmid 792
        else
793
        {
794
                QTreeWidgetItem* it = dataTree->currentItem();
795
                if (it)
796
                {
797
                        if ((it->parent() == gradientItems) || (it == gradientItems))
798
                        {
799
                                if (it == gradientItems)
800
                                {
801
                                        int t = QMessageBox::warning(this, CommonStrings::trWarning, tr("Do you really want to clear all your gradients?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
802
                                        if (t == QMessageBox::No)
803
                                                return;
804
                                        replaceMap.clear();
17400 fschmid 805
                                        for (QHash<QString, VGradient>::Iterator it = dialogGradients.begin(); it != dialogGradients.end(); ++it)
15647 fschmid 806
                                        {
807
                                                replaceMap.insert(it.key(), "");
808
                                        }
809
                                        dialogGradients.clear();
810
                                }
811
                                else
812
                                {
813
                                        dialogGradients.remove(it->text(0));
814
                                        replaceMap.insert(it->text(0), "");
815
                                }
816
                        }
817
                        else if ((it->parent() == colorItems) || (it == colorItems))
818
                        {
819
                                if (it == colorItems)
820
                                {
821
                                        int t = QMessageBox::warning(this, CommonStrings::trWarning, tr("Do you really want to clear all your colors and gradients?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
822
                                        if (t == QMessageBox::No)
823
                                                return;
824
                                        replaceMap.clear();
17400 fschmid 825
                                        for (QHash<QString, VGradient>::Iterator it = dialogGradients.begin(); it != dialogGradients.end(); ++it)
15647 fschmid 826
                                        {
827
                                                replaceMap.insert(it.key(), "");
828
                                        }
829
                                        replaceColorMap.clear();
830
                                        for (ColorList::Iterator it = m_colorList.begin(); it != m_colorList.end(); ++it)
831
                                        {
832
                                                replaceColorMap.insert(it.key(), "Black");
833
                                        }
16016 fschmid 834
                                        dialogPatterns.clear();
15647 fschmid 835
                                        dialogGradients.clear();
836
                                        m_colorList.clear();
15912 jghali 837
                                        m_colorList.ensureDefaultColors();
15647 fschmid 838
                                }
839
                                else
840
                                {
841
                                        QString dColor = it->text(0);
842
                                        ColorList UsedCG = getGradientColors();
843
                                        if (inDocUsedColors.contains(dColor) || UsedCG.contains(dColor))
844
                                        {
16016 fschmid 845
                                                DelColor *dia = new DelColor(this, m_colorList, dColor, true);
15647 fschmid 846
                                                if (dia->exec())
847
                                                {
848
                                                        QString replacementColor(dia->getReplacementColor());
849
                                                        if (replacementColor == CommonStrings::tr_NoneColor)
850
                                                                replacementColor = CommonStrings::None;
851
                                                        if (replaceColorMap.values().contains(dColor))
852
                                                        {
853
                                                                QMap<QString,QString>::Iterator itt;
854
                                                                for (itt = replaceColorMap.begin(); itt != replaceColorMap.end(); ++itt)
855
                                                                {
856
                                                                        if (itt.value() == dColor)
857
                                                                                itt.value() = replacementColor;
858
                                                                }
859
                                                        }
860
                                                        replaceColorMap.insert(dColor, replacementColor);
861
                                                        m_colorList.remove(dColor);
862
                                                        updateGradientColors(replacementColor, dColor);
863
                                                }
864
                                                delete dia;
865
                                        }
866
                                        else
867
                                        {
868
                                                replaceColorMap.insert(dColor, "Black");
16016 fschmid 869
                                                updateGradientColors("Black", dColor);
15647 fschmid 870
                                                m_colorList.remove(dColor);
871
                                        }
872
                                }
873
                        }
16016 fschmid 874
                        else if ((it->parent() == patternItems) || (it == patternItems))
875
                        {
876
                                if (it == patternItems)
877
                                {
878
                                        int t = QMessageBox::warning(this, CommonStrings::trWarning, tr("Do you really want to clear all your patterns?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
879
                                        if (t == QMessageBox::No)
880
                                                return;
881
                                        replaceMapPatterns.clear();
17400 fschmid 882
                                        for (QHash<QString, ScPattern>::Iterator it = dialogPatterns.begin(); it != dialogPatterns.end(); ++it)
16016 fschmid 883
                                        {
884
                                                replaceMapPatterns.insert(it.key(), "");
885
                                        }
886
                                        dialogPatterns.clear();
887
                                }
888
                                else if (it->parent() == patternItems)
889
                                {
890
                                        QStringList patterns2Del;
891
                                        QStringList mainPatterns = dialogPatterns.keys();
892
                                        for (int a = 0; a < mainPatterns.count(); a++)
893
                                        {
894
                                                if (mainPatterns[a] != it->text(0))
895
                                                {
896
                                                        QStringList subPatterns;
897
                                                        subPatterns = getUsedPatternsHelper(mainPatterns[a], subPatterns);
898
                                                        if (subPatterns.contains(it->text(0)))
899
                                                                patterns2Del.append(mainPatterns[a]);
900
                                                }
901
                                        }
902
                                        patterns2Del.append(it->text(0));
903
                                        for (int a = 0; a < patterns2Del.count(); a++)
904
                                        {
905
                                                dialogPatterns.remove(patterns2Del[a]);
906
                                        }
907
                                }
908
                        }
909
                        updatePatternList();
910
                        updateGradientList();
911
                        updateColorList();
912
                        itemSelected(0);
913
                        modified = true;
15647 fschmid 914
                }
915
        }
15599 fschmid 916
}
917
 
16016 fschmid 918
QStringList PaintManagerDialog::getUsedPatternsHelper(QString pattern, QStringList &results)
919
{
920
        ScPattern *pat = &dialogPatterns[pattern];
921
        QStringList pats;
922
        pats.clear();
923
        for (int c = 0; c < pat->items.count(); ++c)
924
        {
16034 fschmid 925
                if ((pat->items.at(c)->GrType == 8) || (pat->items.at(c)->itemType() == PageItem::Symbol))
926
                {
927
                        const QString& patName = pat->items.at(c)->pattern();
928
                        if (!patName.isEmpty() && !results.contains(patName))
929
                                pats.append(patName);
930
                }
931
                const QString& pat2 = pat->items.at(c)->strokePattern();
932
                if (!pat2.isEmpty() && !results.contains(pat2))
933
                        pats.append(pat->items.at(c)->strokePattern());
934
                const QString& pat3 = pat->items.at(c)->patternMask();
935
                if (!pat3.isEmpty() && !results.contains(pat3))
936
                        pats.append(pat->items.at(c)->patternMask());
937
        }
938
        if (!pats.isEmpty())
939
        {
940
                results = pats;
941
                for (int c = 0; c < pats.count(); ++c)
942
                {
943
                        getUsedPatternsHelper(pats[c], results);
944
                }
945
        }
946
/*      QStringList pats;
947
        pats.clear();
948
        for (int c = 0; c < pat->items.count(); ++c)
949
        {
16016 fschmid 950
                if ((!results.contains(pat->items.at(c)->pattern())) && ((pat->items.at(c)->GrType == 8) || (pat->items.at(c)->itemType() == PageItem::Symbol)))
951
                        pats.append(pat->items.at(c)->pattern());
952
        }
953
        if (!pats.isEmpty())
954
        {
16034 fschmid 955
                results = pats;
16016 fschmid 956
                for (int c = 0; c < pats.count(); ++c)
957
                {
958
                        getUsedPatternsHelper(pats[c], results);
959
                }
16034 fschmid 960
        } */
961
        return results;
16016 fschmid 962
}
963
 
15623 craig 964
void PaintManagerDialog::removeUnusedColorItem()
15599 fschmid 965
{
966
        if (paletteLocked)
967
                return;
968
        QTreeWidgetItem* it = dataTree->currentItem();
969
        if (it)
970
        {
971
                if ((it->parent() == colorItems) || (it == colorItems))
972
                {
973
                        ColorList UsedC;
974
                        ColorList::Iterator it;
975
                        ColorList UsedCG = getGradientColors();
16016 fschmid 976
                        if (mainWin->HaveDoc)
15599 fschmid 977
                        {
15647 fschmid 978
                                m_colorList = inDocUsedColors;
15599 fschmid 979
                                for (it = UsedCG.begin(); it != UsedCG.end(); ++it)
980
                                {
981
                                        if (!m_colorList.contains(it.key()))
982
                                                m_colorList.insert(it.key(), it.value());
983
                                }
984
                        }
985
                        else
986
                                m_colorList = UsedCG;
15912 jghali 987
                        m_colorList.ensureDefaultColors();
16016 fschmid 988
                        updatePatternList();
15599 fschmid 989
                        updateGradientList();
990
                        updateColorList();
991
                        itemSelected(0);
15674 fschmid 992
                        modified = true;
15599 fschmid 993
                }
994
        }
995
}
996
 
15623 craig 997
void PaintManagerDialog::importColorItems()
15599 fschmid 998
{
999
        QTreeWidgetItem* it = dataTree->currentItem();
1000
        if (it)
1001
        {
1002
                if ((it->parent() == gradientItems) || (it == gradientItems))
1003
                {
1004
                        QString fileName;
1005
                        QString allFormats = tr("All Supported Formats")+" (";
1006
                        allFormats += "*.sgr *.SGR";
1007
                        allFormats += " *.ggr *.GGR";
1008
                        allFormats += ");;";
1009
                        QString formats = tr("Scribus Gradient Files \"*.sgr\" (*.sgr *.SGR);;");
1010
                        formats += tr("Gimp Gradient Files \"*.ggr\" (*.ggr *.GGR);;");
1011
                        formats += tr("All Files (*)");
1012
                        allFormats += formats;
1013
                        PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
1014
                        QString wdir = dirs->get("gradients", ".");
1015
                        CustomFDialog dia(this, wdir, tr("Open"), allFormats, fdHidePreviewCheckBox | fdExistingFiles);
1016
                        if (dia.exec() == QDialog::Accepted)
1017
                                fileName = dia.selectedFile();
1018
                        else
1019
                                return;
1020
                        if (!fileName.isEmpty())
1021
                        {
1022
                                PrefsManager::instance()->prefsFile->getContext("dirs")->set("gradients", fileName.left(fileName.lastIndexOf("/")));
1023
                                QFileInfo fi(fileName);
1024
                                QString ext = fi.suffix().toLower();
1025
                                if (ext == "sgr")
1026
                                        loadScribusFormat(fileName);
1027
                                else if (ext == "ggr")
1028
                                        loadGimpFormat(fileName);
1029
                                updateGradientList();
1030
                                updateColorList();
1031
                                itemSelected(0);
15674 fschmid 1032
                                modified = true;
15599 fschmid 1033
                        }
1034
                }
1035
                else if ((it->parent() == colorItems) || (it == colorItems))
1036
                {
17217 fschmid 1037
                        QStringList allFormatsV = LoadSavePlugin::getExtensionsForColors();
1038
                        allFormatsV.removeAll("sla");
1039
                        allFormatsV.removeAll("scd");
1040
                        allFormatsV.removeAll("sla.gz");
1041
                        allFormatsV.removeAll("scd.gz");
1042
                        allFormatsV.removeAll("ai");
1043
                        QString extra = allFormatsV.join(" *.");
1044
                        extra.prepend(" *.");
15599 fschmid 1045
                        QString fileName;
1046
                        PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
1047
                        QString wdir = dirs->get("colors", ".");
1048
                        QString docexts("*.sla *.sla.gz *.scd *.scd.gz");
1049
                        QString aiepsext(FormatsManager::instance()->extensionListForFormat(FormatsManager::EPS|FormatsManager::PS|FormatsManager::AI, 0));
17217 fschmid 1050
                        QString ooexts(" *.acb *.aco *.skp *.soc *.gpl *.xml");
1051
                        ooexts += extra;
15599 fschmid 1052
                        QString filter = tr("All Supported Formats (%1);;Documents (%2);;Other Files (%3);;All Files (*)").arg(docexts+" "+aiepsext+ooexts).arg(docexts).arg(aiepsext+ooexts);
1053
                        CustomFDialog dia(this, wdir, tr("Import Colors"), filter, fdHidePreviewCheckBox);
1054
                        if (dia.exec() == QDialog::Accepted)
1055
                                fileName = dia.selectedFile();
1056
                        else
1057
                                return;
1058
                        if (!fileName.isEmpty())
1059
                                dirs->set("colors", fileName.left(fileName.lastIndexOf("/")));
1060
                        if (!importColorsFromFile(fileName, m_colorList))
1061
                                QMessageBox::information(this, tr("Information"), "<qt>" + tr("The file %1 does not contain colors which can be imported.\nIf the file was a PostScript-based, try to import it with File -&gt; Import. \nNot all files have DSC conformant comments where the color descriptions are located.\n This prevents importing colors from some files.\nSee the Edit Colors section of the documentation for more details.").arg(fileName) + "</qt>", 1, 0, 0);
1062
                        else
1063
                        {
1064
                                updateGradientList();
1065
                                updateColorList();
15674 fschmid 1066
                                modified = true;
15599 fschmid 1067
                        }
1068
                        itemSelected(0);
1069
                }
16016 fschmid 1070
                else if ((it->parent() == patternItems) || (it == patternItems))
1071
                {
1072
                        QString fileName;
16169 fschmid 1073
                        QStringList formats;
16016 fschmid 1074
                        QString allFormats = tr("All Supported Formats")+" (";
1075
                        int fmtCode = FORMATID_ODGIMPORT;
1076
                        const FileFormat *fmt = LoadSavePlugin::getFormatById(fmtCode);
1077
                        while (fmt != 0)
1078
                        {
1079
                                if (fmt->load)
1080
                                {
16169 fschmid 1081
                                        formats.append(fmt->filter);
16016 fschmid 1082
                                        int an = fmt->filter.indexOf("(");
1083
                                        int en = fmt->filter.indexOf(")");
1084
                                        while (an != -1)
1085
                                        {
1086
                                                allFormats += fmt->filter.mid(an+1, en-an-1)+" ";
1087
                                                an = fmt->filter.indexOf("(", en);
1088
                                                en = fmt->filter.indexOf(")", an);
1089
                                        }
1090
                                }
1091
                                fmtCode++;
1092
                                fmt = LoadSavePlugin::getFormatById(fmtCode);
1093
                        }
1094
                        allFormats += "*.sce *.SCE ";
16169 fschmid 1095
                        formats.append("Scribus Objects (*.sce *.SCE)");
16016 fschmid 1096
                        QString form1 = "";
1097
                        QString form2 = "";
1098
                        QStringList imgFormats;
1099
                        bool jpgFound = false;
1100
                        bool tiffFound = false;
1101
                        for (int i = 0; i < QImageReader::supportedImageFormats().count(); ++i )
1102
                        {
1103
                                form1 = QString(QImageReader::supportedImageFormats().at(i)).toLower();
1104
                                form2 = QString(QImageReader::supportedImageFormats().at(i)).toUpper();
1105
                                if ((form1 == "png") || (form1 == "xpm") || (form1 == "gif"))
1106
                                {
16169 fschmid 1107
                                        formats.append(form2 + " (*."+form1+" *."+form2+")");
16016 fschmid 1108
                                        allFormats += "*."+form1+" *."+form2+" ";
1109
                                        imgFormats.append(form1);
1110
                                }
1111
                                else if ((form1 == "jpg") || (form1 == "jpeg"))
1112
                                {
1113
                                        // JPEG is a special case because both .jpg and .jpeg
1114
                                        // are acceptable extensions.
1115
                                        if (!jpgFound)
1116
                                        {
16169 fschmid 1117
                                                formats.append("JPEG (*.jpg *.jpeg *.JPG *.JPEG)");
16016 fschmid 1118
                                                allFormats += "*.jpg *.jpeg *.JPG *.JPEG ";
1119
                                                imgFormats.append("jpeg");
1120
                                                imgFormats.append("jpg");
1121
                                                jpgFound = true;
1122
                                        }
1123
                                }
1124
                                else if ((form1 == "tif") || (form1 == "tiff"))
1125
                                {
1126
                                        if (!tiffFound)
1127
                                        {
16169 fschmid 1128
                                                formats.append("TIFF (*.tif *.tiff *.TIF *.TIFF)");
16016 fschmid 1129
                                                allFormats += "*.tif *.tiff *.TIF *.TIFF ";
1130
                                                imgFormats.append("tif");
1131
                                                imgFormats.append("tiff");
1132
                                                tiffFound = true;
1133
                                        }
1134
                                }
1135
                                else if (form1 != "svg")
1136
                                {
1137
                                        imgFormats.append(form1);
1138
                                        allFormats += "*."+form1+" *."+form2+" ";
1139
                                }
1140
                        }
1141
                        if (!tiffFound)
1142
                        {
16169 fschmid 1143
                                formats.append("TIFF (*.tif *.tiff *.TIF *.TIFF)");
16016 fschmid 1144
                                allFormats += "*.tif *.tiff *.TIF *.TIFF ";
1145
                        }
1146
                        if (!jpgFound)
1147
                        {
16169 fschmid 1148
                                formats.append("JPEG (*.jpg *.jpeg *.JPG *.JPEG)");
16016 fschmid 1149
                                allFormats += "*.jpg *.jpeg *.JPG *.JPEG ";
1150
                        }
16169 fschmid 1151
                        formats.append("PSD (*.psd *.PSD)");
1152
                        formats.append("Gimp Patterns (*.pat *.PAT)");
16016 fschmid 1153
                        allFormats += "*.psd *.PSD ";
1154
                        allFormats += "*.pat *.PAT);;";
1155
                        imgFormats.append("tif");
1156
                        imgFormats.append("tiff");
1157
                        imgFormats.append("pat");
1158
                        imgFormats.append("psd");
17890 fschmid 1159
                //      imgFormats.append("pdf");
16016 fschmid 1160
                        imgFormats.append("eps");
1161
                        imgFormats.append("epsi");
1162
                        imgFormats.append("ps");
16169 fschmid 1163
                        qSort(formats);
1164
                        allFormats += formats.join(";;");
16016 fschmid 1165
                        PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
1166
                        QString wdir = dirs->get("patterns", ".");
1167
                        CustomFDialog dia(this, wdir, tr("Open"), allFormats, fdHidePreviewCheckBox | fdExistingFiles);
1168
                        if (dia.exec() == QDialog::Accepted)
1169
                                fileName = dia.selectedFile();
1170
                        else
1171
                                return;
1172
                        if (!fileName.isEmpty())
1173
                        {
16029 fschmid 1174
                                qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
16016 fschmid 1175
                                PrefsManager::instance()->prefsFile->getContext("dirs")->set("patterns", fileName.left(fileName.lastIndexOf("/")));
1176
                                QFileInfo fi(fileName);
16171 fschmid 1177
                                if ((fi.suffix().toLower() == "sce") || (!imgFormats.contains(fi.suffix().toLower())))
16016 fschmid 1178
                                {
1179
                                        loadVectors(fileName);
1180
                                }
1181
                                else
1182
                                {
1183
                                        QString patNam = fi.baseName().trimmed().simplified().replace(" ", "_");
1184
                                        ScPattern pat = ScPattern();
1185
                                        pat.setDoc(m_doc);
1186
                                        pat.setPattern(fileName);
1187
                                        if (!dialogPatterns.contains(patNam))
1188
                                        {
1189
                                                dialogPatterns.insert(patNam, pat);
1190
                                                origNamesPatterns.insert(patNam, patNam);
1191
                                        }
1192
                                }
1193
                                updateColorList();
1194
                                updateGradientList();
1195
                                updatePatternList();
1196
                                itemSelected(0);
16029 fschmid 1197
                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
16016 fschmid 1198
                        }
1199
                }
15599 fschmid 1200
        }
1201
}
1202
 
16016 fschmid 1203
void PaintManagerDialog::loadPatternDir()
1204
{
1205
        PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
1206
        QString wdir = dirs->get("patterndir", ".");
1207
        QString fileName = QFileDialog::getExistingDirectory(this, tr("Choose a Directory"), wdir);
1208
        if (!fileName.isEmpty())
1209
        {
1210
                QStringList formats;
1211
                formats += "eps";
1212
                formats += "epsi";
1213
                formats += "pdf";
1214
                QString form1 = "";
1215
                for ( int i = 0; i < QImageReader::supportedImageFormats().count(); ++i )
1216
                {
1217
                        form1 = QString(QImageReader::supportedImageFormats().at(i)).toLower();
1218
                        if (form1 == "jpeg")
1219
                                form1 = "jpg";
1220
                        if ((form1 == "png") || (form1 == "xpm") || (form1 == "gif"))
1221
                        formats += form1;
1222
                        else if (form1 == "jpg")
1223
                        {
1224
                                formats += "jpg";
1225
                                formats += "jpeg";
1226
                        }
1227
                }
1228
                formats += "tif";
1229
                formats += "tiff";
1230
                formats += "psd";
1231
                formats += "pat";
1232
                QDir d(fileName, "*", QDir::Name, QDir::Files | QDir::Readable | QDir::NoSymLinks);
1233
                if ((d.exists()) && (d.count() != 0))
1234
                {
1235
                        mainWin->setStatusBarInfoText( tr("Loading Patterns"));
1236
                        mainWin->mainWindowProgressBar->reset();
1237
                        mainWin->mainWindowProgressBar->setMaximum(d.count() * 2);
1238
                        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
1239
                        qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
1240
                        for (uint dc = 0; dc < d.count(); ++dc)
1241
                        {
1242
                                mainWin->mainWindowProgressBar->setValue(dc);
1243
                                qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
16577 craig 1244
                                QFileInfo fi(QDir::cleanPath(QDir::toNativeSeparators(fileName + "/" + d[dc])));
16016 fschmid 1245
                                QString ext = fi.suffix().toLower();
16171 fschmid 1246
                                if ((ext == "sce") || (!formats.contains(ext)))
16577 craig 1247
                                        loadVectors(QDir::cleanPath(QDir::toNativeSeparators(fileName + "/" + d[dc])));
16016 fschmid 1248
                        }
1249
                        for (uint dc = 0; dc < d.count(); ++dc)
1250
                        {
1251
                                mainWin->mainWindowProgressBar->setValue(d.count() + dc);
1252
                                qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
16577 craig 1253
                                QFileInfo fi(QDir::cleanPath(QDir::toNativeSeparators(fileName + "/" + d[dc])));
16016 fschmid 1254
                                QString ext = fi.suffix().toLower();
16171 fschmid 1255
                                if ((ext == "sce") || (!formats.contains(ext)))
16016 fschmid 1256
                                        continue;
1257
                                else if (formats.contains(ext))
1258
                                {
1259
                                        QString patNam = fi.baseName().trimmed().simplified().replace(" ", "_");
1260
                                        if (!dialogPatterns.contains(patNam))
1261
                                        {
1262
                                                ScPattern pat = ScPattern();
1263
                                                pat.setDoc(m_doc);
16577 craig 1264
                                                pat.setPattern(QDir::cleanPath(QDir::toNativeSeparators(fileName + "/" + d[dc])));
16016 fschmid 1265
                                                dialogPatterns.insert(patNam, pat);
1266
                                                origNamesPatterns.insert(patNam, patNam);
1267
                                        }
1268
                                }
1269
                                else
1270
                                        continue;
1271
                        }
1272
                        d.cdUp();
1273
                        dirs->set("patterndir", d.absolutePath());
1274
                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1275
                        mainWin->setStatusBarInfoText("");
1276
                        mainWin->mainWindowProgressBar->reset();
1277
                }
1278
        }
1279
}
1280
 
1281
void PaintManagerDialog::loadVectors(QString data)
1282
{
1283
        m_doc->PageColors = m_colorList;
1284
        m_doc->docGradients = dialogGradients;
1285
        UndoManager::instance()->setUndoEnabled(false);
1286
        m_doc->setLoading(true);
1287
        QFileInfo fi(data);
1288
        QString patNam = fi.baseName().trimmed().simplified().replace(" ", "_");
1289
        uint ac = m_doc->Items->count();
1290
        uint ap = m_doc->docPatterns.count();
18027 jghali 1291
        bool savedAlignGrid = m_doc->SnapGrid;
16016 fschmid 1292
        bool savedAlignGuides = m_doc->SnapGuides;
17744 craig 1293
        bool savedAlignElement = m_doc->SnapElement;
18027 jghali 1294
        m_doc->SnapGrid = false;
16016 fschmid 1295
        m_doc->SnapGuides = false;
17744 craig 1296
        m_doc->SnapElement = false;
16016 fschmid 1297
        if (fi.suffix().toLower() == "sce")
1298
        {
1299
                ScriXmlDoc ss;
1300
                ss.ReadElem(data, PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts, m_doc, m_doc->currentPage()->xOffset(), m_doc->currentPage()->yOffset(), true, true, PrefsManager::instance()->appPrefs.fontPrefs.GFontSub);
1301
        }
1302
        else
1303
        {
1304
                FileLoader *fileLoader = new FileLoader(data);
17326 jghali 1305
                int testResult = fileLoader->testFile();
16016 fschmid 1306
                delete fileLoader;
1307
                if ((testResult != -1) && (testResult >= FORMATID_ODGIMPORT))
1308
                {
1309
                        const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
1310
                        if( fmt )
16105 fschmid 1311
                        {
1312
                                fmt->setupTargets(m_doc, 0, mainWin, 0, &(PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts));
16016 fschmid 1313
                                fmt->loadFile(data, LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive|LoadSavePlugin::lfScripted|LoadSavePlugin::lfKeepPatterns|LoadSavePlugin::lfLoadAsPattern);
16105 fschmid 1314
                        }
16016 fschmid 1315
                }
1316
        }
18027 jghali 1317
        m_doc->SnapGrid = savedAlignGrid;
16016 fschmid 1318
        m_doc->SnapGuides = savedAlignGuides;
17744 craig 1319
        m_doc->SnapElement = savedAlignElement;
16016 fschmid 1320
        uint ae = m_doc->Items->count();
1321
        if (ac != ae)
1322
        {
1323
                for (uint as = ac; as < ae; ++as)
1324
                {
1325
                        PageItem* ite = m_doc->Items->at(ac);
1326
                        if (ite->itemType() == PageItem::PathText)
1327
                                ite->updatePolyClip();
1328
                        else
1329
                                ite->layout();
1330
                }
1331
                ScPattern pat = ScPattern();
1332
                pat.setDoc(m_doc);
1333
                PageItem* currItem = m_doc->Items->at(ac);
16504 fschmid 1334
                double minx =  std::numeric_limits<double>::max();
1335
                double miny =  std::numeric_limits<double>::max();
1336
                double maxx = -std::numeric_limits<double>::max();
1337
                double maxy = -std::numeric_limits<double>::max();
1338
                double x1, x2, y1, y2;
1339
                currItem->getVisualBoundingRect(&x1, &y1, &x2, &y2);
1340
                minx = qMin(minx, x1);
1341
                miny = qMin(miny, y1);
1342
                maxx = qMax(maxx, x2);
1343
                maxy = qMax(maxy, y2);
1344
                pat.pattern = currItem->DrawObj_toImage(qMax(maxx - minx, maxy - miny));
16972 fschmid 1345
                pat.width = maxx - minx;
1346
                pat.height = maxy - miny;
17890 fschmid 1347
                currItem->setXYPos(0, 0, true);
1348
                currItem->setWidthHeight(maxx - minx, maxy - miny, true);
1349
                currItem->groupWidth = maxx - minx;
1350
                currItem->groupHeight = maxy - miny;
1351
                currItem->gWidth = maxx - minx;
1352
                currItem->gHeight = maxy - miny;
16016 fschmid 1353
                for (uint as = ac; as < ae; ++as)
1354
                {
1355
                        pat.items.append(m_doc->Items->takeAt(ac));
1356
                }
1357
                if (!dialogPatterns.contains(patNam))
1358
                {
1359
                        dialogPatterns.insert(patNam, pat);
1360
                        origNamesPatterns.insert(patNam, patNam);
1361
                }
17400 fschmid 1362
                for (QHash<QString, ScPattern>::Iterator it = m_doc->docPatterns.begin(); it != m_doc->docPatterns.end(); ++it)
16016 fschmid 1363
                {
1364
                        if (!origPatterns.contains(it.key()))
1365
                        {
1366
                                dialogPatterns.insert(it.key(), it.value());
1367
                                origNamesPatterns.insert(it.key(), it.key());
1368
                        }
1369
                }
1370
        }
1371
        else
1372
        {
1373
                uint ape = m_doc->docPatterns.count();
1374
                if (ap != ape)
1375
                {
17400 fschmid 1376
                        for (QHash<QString, ScPattern>::Iterator it = m_doc->docPatterns.begin(); it != m_doc->docPatterns.end(); ++it)
16016 fschmid 1377
                        {
1378
                                if (!origPatterns.contains(it.key()))
1379
                                {
1380
                                        dialogPatterns.insert(it.key(), it.value());
1381
                                        origNamesPatterns.insert(it.key(), it.key());
1382
                                }
1383
                        }
1384
                }
1385
        }
1386
        m_doc->setLoading(false);
1387
        m_colorList = m_doc->PageColors;
1388
        dialogGradients = m_doc->docGradients;
17747 craig 1389
        UndoManager::instance()->setUndoEnabled(true);
16016 fschmid 1390
}
1391
 
15623 craig 1392
ColorList PaintManagerDialog::getGradientColors()
15599 fschmid 1393
{
1394
        ColorList colorList;
17400 fschmid 1395
        QHash<QString,VGradient>::Iterator itg;
15599 fschmid 1396
        for (itg = dialogGradients.begin(); itg != dialogGradients.end(); ++itg)
1397
        {
1398
                QList<VColorStop*> cstops = itg.value().colorStops();
1399
                for (uint cst = 0; cst < itg.value().Stops(); ++cst)
1400
                {
16016 fschmid 1401
                        if ((!colorList.contains(cstops.at(cst)->name)) && (cstops.at(cst)->name != CommonStrings::None))
15599 fschmid 1402
                                colorList.insert(cstops.at(cst)->name, m_colorList[cstops.at(cst)->name]);
1403
                }
1404
        }
16016 fschmid 1405
        QStringList patterns = dialogPatterns.keys();
1406
        for (int c = 0; c < dialogPatterns.count(); ++c)
1407
        {
1408
                ScPattern pa = dialogPatterns[patterns[c]];
1409
                for (int o = 0; o < pa.items.count(); o++)
1410
                {
1411
                        PageItem *ite = pa.items.at(o);
1412
                        if ((!colorList.contains(ite->lineColor())) && (ite->lineColor() != CommonStrings::None))
1413
                                colorList.insert(ite->lineColor(), m_colorList[ite->lineColor()]);
1414
                        if ((!colorList.contains(ite->fillColor())) && (ite->fillColor() != CommonStrings::None))
1415
                                colorList.insert(ite->fillColor(), m_colorList[ite->fillColor()]);
1416
                        QString gCol1, gCol2, gCol3, gCol4;
1417
                        ite->get4ColorColors(gCol1, gCol2, gCol3, gCol4);
1418
                        if ((!colorList.contains(gCol1)) && (gCol1 != CommonStrings::None))
1419
                                colorList.insert(gCol1, m_colorList[gCol1]);
1420
                        if ((!colorList.contains(gCol2)) && (gCol2 != CommonStrings::None))
1421
                                colorList.insert(gCol2, m_colorList[gCol2]);
1422
                        if ((!colorList.contains(gCol3)) && (gCol3 != CommonStrings::None))
1423
                                colorList.insert(gCol3, m_colorList[gCol3]);
1424
                        if ((!colorList.contains(gCol4)) && (gCol4 != CommonStrings::None))
1425
                                colorList.insert(gCol4, m_colorList[gCol4]);
1426
                        for (int grow = 0; grow < ite->meshGradientArray.count(); grow++)
1427
                        {
1428
                                for (int gcol = 0; gcol < ite->meshGradientArray[grow].count(); gcol++)
1429
                                {
1430
                                        meshPoint mp = ite->meshGradientArray[grow][gcol];
1431
                                        if ((!colorList.contains(mp.colorName)) && (mp.colorName != CommonStrings::None))
1432
                                                colorList.insert(mp.colorName, m_colorList[mp.colorName]);
1433
                                }
1434
                        }
1435
                        QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
1436
                        for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
1437
                        {
1438
                                if ((!colorList.contains(cstops.at(cst)->name)) && (cstops.at(cst)->name != CommonStrings::None))
1439
                                        colorList.insert(cstops.at(cst)->name, m_colorList[cstops.at(cst)->name]);
1440
                        }
1441
                        cstops = ite->stroke_gradient.colorStops();
1442
                        for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
1443
                        {
1444
                                if ((!colorList.contains(cstops.at(cst)->name)) && (cstops.at(cst)->name != CommonStrings::None))
1445
                                        colorList.insert(cstops.at(cst)->name, m_colorList[cstops.at(cst)->name]);
1446
                        }
1447
                        cstops = ite->mask_gradient.colorStops();
1448
                        for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
1449
                        {
1450
                                if ((!colorList.contains(cstops.at(cst)->name)) && (cstops.at(cst)->name != CommonStrings::None))
1451
                                        colorList.insert(cstops.at(cst)->name, m_colorList[cstops.at(cst)->name]);
1452
                        }
1453
                }
1454
        }
1455
        colorList.remove(CommonStrings::None);
15599 fschmid 1456
        return colorList;
1457
}
1458
 
15623 craig 1459
void PaintManagerDialog::updateGradientColors(QString newName, QString oldName)
15599 fschmid 1460
{
17400 fschmid 1461
        QHash<QString,VGradient>::Iterator itg;
15599 fschmid 1462
        for (itg = dialogGradients.begin(); itg != dialogGradients.end(); ++itg)
1463
        {
1464
                QList<VColorStop*> cstops = itg.value().colorStops();
1465
                for (uint cst = 0; cst < itg.value().Stops(); ++cst)
1466
                {
1467
                        if (oldName == cstops.at(cst)->name)
1468
                        {
1469
                                cstops.at(cst)->name = newName;
1470
                                const ScColor& col = m_colorList[cstops.at(cst)->name];
1471
                                cstops.at(cst)->color = ScColorEngine::getShadeColorProof(col, m_doc, cstops.at(cst)->shade);
1472
                        }
1473
                }
1474
        }
16016 fschmid 1475
        ColorList colorListBack = m_doc->PageColors;
1476
        m_doc->PageColors = m_colorList;
1477
        QStringList patterns = dialogPatterns.keys();
1478
        for (int c = 0; c < dialogPatterns.count(); ++c)
1479
        {
1480
                ScPattern pa = dialogPatterns[patterns[c]];
1481
                for (int o = 0; o < pa.items.count(); o++)
1482
                {
1483
                        PageItem *ite = pa.items.at(o);
1484
                        if (oldName == ite->lineColor())
1485
                                ite->setLineColor(newName);
1486
                        if (oldName == ite->fillColor())
1487
                                ite->setFillColor(newName);
1488
                        QString gCol1, gCol2, gCol3, gCol4;
1489
                        ite->get4ColorColors(gCol1, gCol2, gCol3, gCol4);
1490
                        if (oldName == gCol1)
1491
                                gCol1 = newName;
1492
                        if (oldName == gCol2)
1493
                                gCol2 = newName;
1494
                        if (oldName == gCol3)
1495
                                gCol3 = newName;
1496
                        if (oldName == gCol4)
1497
                                gCol4 = newName;
1498
                        ite->set4ColorColors(gCol1, gCol2, gCol3, gCol4);
1499
                        for (int grow = 0; grow < ite->meshGradientArray.count(); grow++)
1500
                        {
1501
                                for (int gcol = 0; gcol < ite->meshGradientArray[grow].count(); gcol++)
1502
                                {
1503
                                        meshPoint mp = ite->meshGradientArray[grow][gcol];
1504
                                        if (mp.colorName == oldName)
1505
                                        {
1506
                                                mp.colorName = newName;
1507
                                                ite->setMeshPointColor(grow, gcol, mp.colorName, mp.shade, mp.transparency);
1508
                                        }
1509
                                }
1510
                        }
1511
                        QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
1512
                        for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
1513
                        {
1514
                                if (oldName == cstops.at(cst)->name)
1515
                                {
1516
                                        cstops.at(cst)->name = newName;
1517
                                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
1518
                                }
1519
                        }
1520
                        cstops = ite->stroke_gradient.colorStops();
1521
                        for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
1522
                        {
1523
                                if (oldName == cstops.at(cst)->name)
1524
                                {
1525
                                        cstops.at(cst)->name = newName;
1526
                                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
1527
                                }
1528
                        }
1529
                        cstops = ite->mask_gradient.colorStops();
1530
                        for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
1531
                        {
1532
                                if (oldName == cstops.at(cst)->name)
1533
                                {
1534
                                        cstops.at(cst)->name = newName;
1535
                                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
1536
                                }
1537
                        }
1538
                }
1539
                PageItem *ite = pa.items.at(0);
16504 fschmid 1540
                dialogPatterns[patterns[c]].pattern = ite->DrawObj_toImage(pa.items, 1.0);
16016 fschmid 1541
        }
1542
        m_doc->PageColors = colorListBack;
15599 fschmid 1543
}
1544
 
15623 craig 1545
void PaintManagerDialog::loadGimpFormat(QString fileName)
15599 fschmid 1546
{
1547
        QFile f(fileName);
1548
        if (f.open(QIODevice::ReadOnly))
1549
        {
1550
                ScTextStream ts(&f);
1551
                QString tmp, dummy;
1552
                QString gradientName = "";
1553
                int numEntrys = 0;
1554
                int entryCount = 0;
1555
                int stopCount = 0;
1556
                double left, middle, right, r0, g0, b0, a0, r1, g1, b1, a1;
1557
                double oldr1 = 0.0;
1558
                double oldg1 = 0.0;
1559
                double oldb1 = 0.0;
1560
                double olda1 = 0.0;
1561
                tmp = ts.readLine();
1562
                if (tmp.startsWith("GIMP Gradient"))
1563
                {
1564
                        tmp = ts.readLine();
1565
                        ScTextStream CoE(&tmp, QIODevice::ReadOnly);
1566
                        CoE >> dummy;
1567
                        gradientName = CoE.readAll().trimmed();
1568
                }
1569
                if (!gradientName.isEmpty())
1570
                {
1571
                        QString stopName = gradientName+QString("_Stop%1");
1572
                        QString stopNameInUse;
1573
                        VGradient gra = VGradient(VGradient::linear);
1574
                        gra.clearStops();
1575
                        QColor color;
1576
                        tmp = ts.readLine();
1577
                        ScTextStream CoE(&tmp, QIODevice::ReadOnly);
1578
                        CoE >> numEntrys;
1579
                        while (!ts.atEnd())
1580
                        {
1581
                                entryCount++;
1582
                                tmp = ts.readLine();
1583
                                ScTextStream Cval(&tmp, QIODevice::ReadOnly);
1584
                                Cval >> left >> middle >> right >> r0 >> g0 >> b0 >> a0 >> r1 >> g1 >> b1 >> a1;
1585
                                if ((entryCount == 1) && (entryCount < numEntrys))
1586
                                {
1587
                                        stopNameInUse = stopName.arg(stopCount);
1588
                                        addGimpColor(stopNameInUse, r0, g0, b0);
1589
                                        color = QColor(qRound(r0 * 255), qRound(g0 * 255), qRound(b0 * 255));
1590
                                        gra.addStop(color, left, 0.5, a0, stopNameInUse, 100);
1591
                                        stopCount++;
1592
                                }
1593
                                else if (entryCount == numEntrys)
1594
                                {
1595
                                        if ((entryCount != 1) && ((r0 != oldr1) || (g0 != oldg1) || (b0 != oldb1) || (a0 != olda1)))
1596
                                        {
1597
                                                stopNameInUse = stopName.arg(stopCount);
1598
                                                addGimpColor(stopNameInUse, oldr1, oldg1, oldb1);
1599
                                                color = QColor(qRound(oldr1 * 255), qRound(oldg1 * 255), qRound(oldb1 * 255));
1600
                                                gra.addStop(color, left, 0.5, olda1, stopNameInUse, 100);
1601
                                                stopCount++;
1602
                                        }
1603
                                        stopNameInUse = stopName.arg(stopCount);
1604
                                        addGimpColor(stopNameInUse, r0, g0, b0);
1605
                                        color = QColor(qRound(r0 * 255), qRound(g0 * 255), qRound(b0 * 255));
1606
                                        gra.addStop(color, left, 0.5, a0, stopNameInUse, 100);
1607
                                        stopCount++;
1608
                                        stopNameInUse = stopName.arg(stopCount);
1609
                                        addGimpColor(stopNameInUse, r1, g1, b1);
1610
                                        color = QColor(qRound(r1 * 255), qRound(g1 * 255), qRound(b1 * 255));
1611
                                        gra.addStop(color, right, 0.5, a1, stopNameInUse, 100);
1612
                                        stopCount++;
1613
                                }
1614
                                else
1615
                                {
1616
                                        if ((r0 == oldr1) && (g0 == oldg1) && (b0 == oldb1) && (a0 == olda1))
1617
                                        {
1618
                                                stopNameInUse = stopName.arg(stopCount);
1619
                                                addGimpColor(stopNameInUse, r0, g0, b0);
1620
                                                color = QColor(qRound(r0 * 255), qRound(g0 * 255), qRound(b0 * 255));
1621
                                                gra.addStop(color, left, 0.5, a0, stopNameInUse, 100);
1622
                                                stopCount++;
1623
                                        }
1624
                                        else
1625
                                        {
1626
                                                stopNameInUse = stopName.arg(stopCount);
1627
                                                addGimpColor(stopNameInUse, oldr1, oldg1, oldb1);
1628
                                                color = QColor(qRound(oldr1 * 255), qRound(oldg1 * 255), qRound(oldb1 * 255));
1629
                                                gra.addStop(color, left, 0.5, olda1, stopNameInUse, 100);
1630
                                                stopCount++;
1631
                                                stopNameInUse = stopName.arg(stopCount);
1632
                                                addGimpColor(stopNameInUse, r0, g0, b0);
1633
                                                color = QColor(qRound(r0 * 255), qRound(g0 * 255), qRound(b0 * 255));
1634
                                                gra.addStop(color, left, 0.5, a0, stopNameInUse, 100);
1635
                                                stopCount++;
1636
                                        }
1637
                                }
1638
                                oldr1 = r1;
1639
                                oldg1 = g1;
1640
                                oldb1 = b1;
1641
                                olda1 = a1;
1642
                        }
1643
                        if (!dialogGradients.contains(gradientName))
1644
                                dialogGradients.insert(gradientName, gra);
1645
                        else
1646
                        {
1647
                                QString tmp;
1648
                                gradientName += "("+tmp.setNum(dialogGradients.count())+")";
1649
                                dialogGradients.insert(gradientName, gra);
1650
                        }
1651
                }
1652
                f.close();
1653
        }
1654
        /* File format is:
1655
   *
1656
   *   GIMP Gradient
1657
   *   Name: name
1658
   *   number_of_segments
1659
   *   left middle right r0 g0 b0 a0 r1 g1 b1 a1 type coloring left_color_type
1660
   *   left middle right r0 g0 b0 a0 r1 g1 b1 a1 type coloring right_color_type
1661
   *   ...
1662
   */
1663
}
1664
 
15623 craig 1665
void PaintManagerDialog::addGimpColor(QString &colorName, double r, double g, double b)
15599 fschmid 1666
{
1667
        ScColor lf = ScColor();
1668
        bool found = false;
1669
        int Rc, Gc, Bc, hR, hG, hB;
1670
        Rc = qRound(r * 255);
1671
        Gc = qRound(g * 255);
1672
        Bc = qRound(b * 255);
1673
        lf.setColorRGB(Rc, Gc, Bc);
1674
        for (ColorList::Iterator it = m_colorList.begin(); it != m_colorList.end(); ++it)
1675
        {
1676
                if (it.value().getColorModel() == colorModelRGB)
1677
                {
1678
                        it.value().getRGB(&hR, &hG, &hB);
1679
                        if ((Rc == hR) && (Gc == hG) && (Bc == hB))
1680
                        {
1681
                                colorName = it.key();
1682
                                found = true;
1683
                                return;
1684
                        }
1685
                }
1686
        }
1687
        if (!found)
1688
        {
1689
                m_colorList.insert(colorName, lf);
1690
                hasImportedColors = true;
1691
        }
1692
}
1693
 
15623 craig 1694
void PaintManagerDialog::loadScribusFormat(QString fileName)
15599 fschmid 1695
{
1696
        QFile f(fileName);
1697
        if(!f.open(QIODevice::ReadOnly))
1698
                return;
1699
        QDomDocument docu("scridoc");
1700
        QTextStream ts(&f);
1701
        ts.setCodec("UTF-8");
1702
        QString errorMsg;
1703
        int errorLine = 0, errorColumn = 0;
1704
        if( !docu.setContent(ts.readAll(), &errorMsg, &errorLine, &errorColumn) )
1705
        {
1706
                f.close();
1707
                return;
1708
        }
1709
        f.close();
1710
        QDomElement elem = docu.documentElement();
1711
        if (elem.tagName() != "SCRIBUSGRADIENT")
1712
                return;
1713
        QDomNode DOC = elem.firstChild();
1714
        while(!DOC.isNull())
1715
        {
1716
                QDomElement dc = DOC.toElement();
1717
                if (dc.tagName()=="COLOR")
1718
                {
1719
                        ScColor lf = ScColor();
1720
                        if (dc.hasAttribute("CMYK"))
1721
                                lf.setNamedColor(dc.attribute("CMYK"));
1722
                        else
1723
                                lf.fromQColor(QColor(dc.attribute("RGB")));
1724
                        if (dc.hasAttribute("Spot"))
1725
                                lf.setSpotColor(static_cast<bool>(dc.attribute("Spot").toInt()));
1726
                        else
1727
                                lf.setSpotColor(false);
1728
                        if (dc.hasAttribute("Register"))
1729
                                lf.setRegistrationColor(static_cast<bool>(dc.attribute("Register").toInt()));
1730
                        else
1731
                                lf.setRegistrationColor(false);
1732
                        if (!m_colorList.contains(dc.attribute("NAME")))
1733
                        {
1734
                                m_colorList.insert(dc.attribute("NAME"), lf);
1735
                                hasImportedColors = true;
1736
                        }
1737
                }
1738
                if (dc.tagName() == "Gradient")
1739
                {
1740
                        VGradient gra = VGradient(VGradient::linear);
1741
                        gra.clearStops();
1742
                        QDomNode grad = dc.firstChild();
1743
                        while(!grad.isNull())
1744
                        {
1745
                                QDomElement stop = grad.toElement();
1746
                                QString name = stop.attribute("NAME");
1747
                                double ramp  = ScCLocale::toDoubleC(stop.attribute("RAMP"), 0.0);
1748
                                int shade    = stop.attribute("SHADE", "100").toInt();
1749
                                double opa   = ScCLocale::toDoubleC(stop.attribute("TRANS"), 1.0);
1750
                                QColor color;
1751
                                if (name == CommonStrings::None)
1752
                                        color = QColor(255, 255, 255, 0);
1753
                                else
1754
                                {
1755
                                        const ScColor& col = m_colorList[name];
1756
                                        color = ScColorEngine::getShadeColorProof(col, NULL, shade);
1757
                                }
1758
                                gra.addStop(color, ramp, 0.5, opa, name, shade);
1759
                                grad = grad.nextSibling();
1760
                        }
1761
                        if (!dialogGradients.contains(dc.attribute("Name")))
1762
                                dialogGradients.insert(dc.attribute("Name"), gra);
1763
                        else
1764
                        {
1765
                                QString tmp;
1766
                                QString name = dc.attribute("Name");
1767
                                name += "("+tmp.setNum(dialogGradients.count())+")";
1768
                                dialogGradients.insert(name, gra);
1769
                        }
1770
                }
1771
                DOC=DOC.nextSibling();
1772
        }
1773
}
1774
 
15696 fschmid 1775
void PaintManagerDialog::loadDefaults(QTreeWidgetItem* item)
15599 fschmid 1776
{
15696 fschmid 1777
        QString txt = item->data(0, Qt::UserRole).toString() + "/" + item->text(0);
16016 fschmid 1778
        if (!mainWin->HaveDoc)
15611 fschmid 1779
        {
1780
                m_colorList.clear();
1781
                dialogGradients.clear();
16016 fschmid 1782
                dialogPatterns.clear();
15611 fschmid 1783
        }
15599 fschmid 1784
        QString pfadC2 = "";
15696 fschmid 1785
        if (item->text(0) == "Scribus Small")
15599 fschmid 1786
        {
1787
                m_colorList.insert("White", ScColor(0, 0, 0, 0));
1788
                m_colorList.insert("Black", ScColor(0, 0, 0, 255));
1789
                ScColor cc = ScColor(255, 255, 255, 255);
1790
                cc.setRegistrationColor(true);
1791
                m_colorList.insert("Registration", cc);
1792
                m_colorList.insert("Blue", ScColor(255, 255, 0, 0));
1793
                m_colorList.insert("Cyan", ScColor(255, 0, 0, 0));
1794
                m_colorList.insert("Green", ScColor(255, 0, 255, 0));
1795
                m_colorList.insert("Red", ScColor(0, 255, 255, 0));
1796
                m_colorList.insert("Yellow", ScColor(0, 0, 255, 0));
1797
                m_colorList.insert("Magenta", ScColor(0, 255, 0, 0));
1798
                paletteLocked = false;
1799
        }
1800
        else
1801
        {
15681 fschmid 1802
                if (!customColSet.contains(txt))
15599 fschmid 1803
                        pfadC2 = csm.paletteFileFromName(txt);
1804
                else
15681 fschmid 1805
                        pfadC2 = csm.userPaletteFileFromName(txt);
16016 fschmid 1806
                if (!mainWin->HaveDoc)
15676 fschmid 1807
                {
1808
                        QFileInfo fi(pfadC2);
15681 fschmid 1809
                        if (fi.absolutePath().contains(ScPaths::getApplicationDataDir()+"swatches/locked"))
1810
                                paletteLocked = true;
1811
                        else
1812
                                paletteLocked = !fi.isWritable();
15676 fschmid 1813
                }
1814
                else
1815
                        paletteLocked = false;
16016 fschmid 1816
                if (!csm.loadPalette(pfadC2, m_doc, m_colorList, dialogGradients, dialogPatterns, mainWin->HaveDoc))
15599 fschmid 1817
                {
1818
                        m_colorList.insert("White", ScColor(0, 0, 0, 0));
1819
                        m_colorList.insert("Black", ScColor(0, 0, 0, 255));
1820
                        ScColor cc = ScColor(255, 255, 255, 255);
1821
                        cc.setRegistrationColor(true);
1822
                        m_colorList.insert("Registration", cc);
1823
                        m_colorList.insert("Blue", ScColor(255, 255, 0, 0));
1824
                        m_colorList.insert("Cyan", ScColor(255, 0, 0, 0));
1825
                        m_colorList.insert("Green", ScColor(255, 0, 255, 0));
1826
                        m_colorList.insert("Red", ScColor(0, 255, 255, 0));
1827
                        m_colorList.insert("Yellow", ScColor(0, 0, 255, 0));
1828
                        m_colorList.insert("Magenta", ScColor(0, 255, 0, 0));
1829
                }
1830
        }
16016 fschmid 1831
        updateColorList();
15599 fschmid 1832
        updateGradientList();
16016 fschmid 1833
        updatePatternList();
15599 fschmid 1834
        itemSelected(0);
1835
}
1836
 
15623 craig 1837
void PaintManagerDialog::saveDefaults()
15599 fschmid 1838
{
15696 fschmid 1839
        QTreeWidgetItem* item = LoadColSet->currentItem();
1840
        QString NameK = item->data(0, Qt::UserRole).toString() + "/" + item->text(0);
15635 fschmid 1841
        QString Name = LoadColSet->text();
15599 fschmid 1842
        Query* dia = new Query(this, "Name", 1, 0, tr("&Name:"), tr("Choose a Name"));
15696 fschmid 1843
        if ((customColSet.contains(NameK)) && (!paletteLocked))
15681 fschmid 1844
                dia->setEditText(Name, false);
1845
        else
15599 fschmid 1846
                dia->setEditText("", false);
1847
        if (dia->exec())
15674 fschmid 1848
                doSaveDefaults(dia->getEditText(), (dia->getEditText() != Name));
1849
        delete dia;
1850
}
1851
 
1852
void PaintManagerDialog::doSaveDefaults(QString name, bool changed)
1853
{
16577 craig 1854
        QString Cpfad = QDir::toNativeSeparators(ScPaths::getApplicationDataDir());
15674 fschmid 1855
        QString Fname = name;
1856
        Fname.replace(" ", "_");
15681 fschmid 1857
        Fname  = Cpfad + "swatches/"+ Fname;
16016 fschmid 1858
        Fname += ".xml";       
1859
        const FileFormat *fmt = LoadSavePlugin::getFormatById(FORMATID_SLA150EXPORT);
1860
        if (fmt)
15599 fschmid 1861
        {
16016 fschmid 1862
                ScribusDoc *s_doc = new ScribusDoc();
1863
                s_doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
1864
                s_doc->setPage(100, 100, 0, 0, 0, 0, 0, 0, false, false);
1865
                s_doc->addPage(0);
1866
                s_doc->setGUI(false, mainWin, 0);
1867
                s_doc->PageColors = m_colorList;
1868
                s_doc->setGradients(dialogGradients);
1869
                s_doc->setPatterns(dialogPatterns);
1870
                fmt->setupTargets(s_doc, 0, mainWin, 0, &(PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts));
1871
                fmt->savePalette(Fname);
1872
                delete s_doc;
15599 fschmid 1873
        }
16016 fschmid 1874
        if (changed)
1875
        {
1876
                QString nameC = name;
1877
                nameC.replace(" ", "_");
1878
                nameC += ".xml";
1879
                QFileInfo fi(Fname);
1880
                customColSet.append(fi.absolutePath() + "/" + nameC);
1881
                QTreeWidgetItem *item = LoadColSet->addSubItem(name, userSwatches);
1882
                item->setData(0, Qt::UserRole, fi.absolutePath());
1883
                disconnect(LoadColSet, SIGNAL(activated(QTreeWidgetItem*)), this, SLOT(loadDefaults(QTreeWidgetItem*)));
1884
                LoadColSet->setCurrentComboItem(fi.absolutePath() + "/" + name);
1885
                connect(LoadColSet, SIGNAL(activated(QTreeWidgetItem*)), this, SLOT(loadDefaults(QTreeWidgetItem*)));
1886
        }
15599 fschmid 1887
}
1888
 
15623 craig 1889
QString PaintManagerDialog::getColorSetName()
15599 fschmid 1890
{
15764 fschmid 1891
        QString NameK;
15696 fschmid 1892
        QTreeWidgetItem* item = LoadColSet->currentItem();
15764 fschmid 1893
        if (item->text(0) == "Scribus Small")
1894
                NameK = "Scribus Small";
1895
        else
1896
                NameK = item->data(0, Qt::UserRole).toString() + "/" + item->text(0);
15696 fschmid 1897
        return NameK;
15599 fschmid 1898
}
15611 fschmid 1899
 
15623 craig 1900
ScColor PaintManagerDialog::selectedColor()
15611 fschmid 1901
{
1902
        QTreeWidgetItem* it = dataTree->currentItem();
1903
        if (it)
1904
        {
1905
                if (it->parent() == colorItems)
1906
                        return m_colorList[it->text(0)];
1907
        }
1908
        return ScColor();
1909
}
1910
 
15623 craig 1911
QString PaintManagerDialog::selectedColorName()
15611 fschmid 1912
{
1913
        QTreeWidgetItem* it = dataTree->currentItem();
1914
        if (it)
1915
        {
1916
                if (it->parent() == colorItems)
1917
                        return it->text(0);
1918
        }
1919
        return CommonStrings::None;
1920
}