Subversion Repositories Scribus

Rev

Rev 15720 | Rev 16159 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4430 cbradney 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
*/
3 paul 7
/***************************************************************************
8
                          serializer.cpp  -  description
9
                             -------------------
10
    begin                : Sat May 5 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
 
24
#include "serializer.h"
217 Franz 25
#include "scribusdoc.h"
10028 cbradney 26
#include "scribusstructs.h"
456 fschmid 27
#include "pageitem.h"
8398 avox 28
#include "sccolor.h"
10601 mrdocs 29
#include "scpattern.h"
5064 cbradney 30
#include "util.h"
10203 cbradney 31
#include "util_math.h"
32
#include "util_color.h"
8455 avox 33
#include "resourcecollection.h"
34
 
8266 avox 35
#include "desaxe/simple_actions.h"
36
#include "desaxe/saxXML.h"
8382 avox 37
#include "desaxe/uniqueid.h"
2534 craig 38
 
10660 cbradney 39
#include <QTextCodec>
40
#include <QList>
41
#include <QDebug>
8382 avox 42
 
8266 avox 43
using namespace desaxe;
44
 
45
 
8412 avox 46
struct Collection
47
{
9856 fschmid 48
        QList<PageItem*> items;
8412 avox 49
        ColorList colors;
50
        StyleSet<ParagraphStyle> pstyles;
51
        StyleSet<CharStyle> cstyles;
9403 jghali 52
        QMap<QString,multiLine> lstyles;
9803 fschmid 53
        QList<QString> fonts;
54
        QList<QString> patterns;
8412 avox 55
 
56
        void collectItem(PageItem* p)              { items.append(p); }
57
        void collectColor(QString name, ScColor c) { colors[name] = c; }
8464 avox 58
        void collectStyle(ParagraphStyle* style)   { if (style && !style->name().isEmpty()) pstyles.append(style); }
59
        void collectCharStyle(CharStyle* style)    { if (style && !style->name().isEmpty()) cstyles.append(style); }
9403 jghali 60
        void collectLineStyle(QString name, multiLine& m) { lstyles[name] = m; }
8412 avox 61
        void collectFont(QString name)             { fonts.append(name); }
62
        void collectPattern(QString name)          { patterns.append(name); }
63
};
64
 
65
 
66
class CollectColor_body : public Action_body
67
{
9403 jghali 68
        void begin (const Xml_string& tagname, Xml_attr attr)
8412 avox 69
        {
70
                m_name = attr["name"];
71
        }
72
 
9403 jghali 73
        void end (const Xml_string& tagname)
8412 avox 74
        {
13085 jghali 75
//              qDebug() << QString("collect %1").arg(tagname);
8834 cbradney 76
                Collection* coll = this->dig->lookup<Collection>("<collection>");
8412 avox 77
                ScColor* color = this->dig->top<ScColor>();
78
                coll->collectColor(m_name, *color);
79
        }
80
private:
81
        QString m_name;
82
};
83
 
84
class CollectColor : public MakeAction<CollectColor_body>
85
{};
86
 
9403 jghali 87
class CollectMultiLine_body : public Action_body
88
{
89
        void begin (const Xml_string& tagname, Xml_attr attr)
90
        {
91
                m_name = attr["Name"];
92
        }
93
 
94
        void end (const Xml_string& tagname)
95
        {
13085 jghali 96
//              qDebug() << QString("collect %1").arg(tagname);
9403 jghali 97
                Collection* coll  = this->dig->lookup<Collection>("<collection>");
98
                multiLine*  mline = this->dig->top<multiLine>();
99
                coll->collectLineStyle(m_name, *mline);
100
        }
101
private:
102
        QString m_name;
103
};
8412 avox 104
 
9403 jghali 105
class CollectMultiLine : public MakeAction<CollectMultiLine_body>
106
{};
107
 
108
class CollectSingleLine_body : public Action_body
109
{
110
        void begin (const Xml_string& tagname, Xml_attr attr)
111
        {
112
        }
113
 
114
        void end (const Xml_string& tagname)
115
        {
13085 jghali 116
//              qDebug() << QString("collect %1").arg(tagname);
10585 fschmid 117
//              Collection* coll  = this->dig->lookup<Collection>("<collection>");
9403 jghali 118
                multiLine*  mline = this->dig->lookup<multiLine>("<multiline>");
119
                SingleLine* sline = this->dig->top<SingleLine>();
120
                mline->append(*sline);
121
        }
122
};
123
 
124
class CollectSingleLine : public MakeAction<CollectSingleLine_body>
125
{};
126
 
15361 jghali 127
class MergeColors_body : public Action_body
128
{
129
        void end (const Xml_string& tagname)
130
        {
131
//              qDebug() << QString("collect %1").arg(tagname);
132
                Collection* coll = this->dig->lookup<Collection>("<collection>");
133
                ScribusDoc* doc  = this->dig->lookup<ScribusDoc>("<scribusdoc>");
134
                doc->PageColors.addColors(coll->colors, false);
135
        }
136
};
137
 
138
class MergeColors : public MakeAction<MergeColors_body>
139
{};
140
 
8193 avox 141
Serializer::Serializer(ScribusDoc& doc) : Digester(), m_Doc(doc)
3 paul 142
{
8193 avox 143
        // register desaxe rules for styles, colors and elems
8412 avox 144
        addRule("/SCRIBUSFRAGMENT", Factory<Collection>());
145
        addRule("/SCRIBUSFRAGMENT", Store<Collection>("<collection>"));
15361 jghali 146
 
15720 fschmid 147
        addRule("/SCRIBUSFRAGMENT/color", Factory<ScColor>());
148
        addRule("/SCRIBUSFRAGMENT/color", SetAttribute<ScColor, QString>( &ScColor::setNamedColor, "RGB" ));
149
        addRule("/SCRIBUSFRAGMENT/color", SetAttribute<ScColor, QString>( &ScColor::setNamedColor, "CMYK" ));
150
        addRule("/SCRIBUSFRAGMENT/color", SetAttributeWithConversion<ScColor, bool>( &ScColor::setSpotColor, "Spot", &parseBool ));
151
        addRule("/SCRIBUSFRAGMENT/color", SetAttributeWithConversion<ScColor, bool>( &ScColor::setRegistrationColor, "Register", &parseBool ));
152
        addRule("/SCRIBUSFRAGMENT/color", CollectColor());
8398 avox 153
 
8412 avox 154
        CharStyle::desaxeRules("/SCRIBUSFRAGMENT/", *this);
155
        addRule("/SCRIBUSFRAGMENT/charstyle", SetterP<Collection, CharStyle>( & Collection::collectCharStyle ));
156
 
157
        ParagraphStyle::desaxeRules("/SCRIBUSFRAGMENT/", *this);
158
        addRule("/SCRIBUSFRAGMENT/style", SetterP<Collection, ParagraphStyle>( & Collection::collectStyle ));
159
 
9403 jghali 160
        addRule("/SCRIBUSFRAGMENT/MultiLine", Factory<multiLine>());
161
        addRule("/SCRIBUSFRAGMENT/MultiLine", Store<multiLine>("<multiline>"));
162
        addRule("/SCRIBUSFRAGMENT/MultiLine", CollectMultiLine());
163
 
164
        addRule("/SCRIBUSFRAGMENT/MultiLine/SubLine", Factory<SingleLine>());
165
        addRule("/SCRIBUSFRAGMENT/MultiLine/SubLine", SetAttributeWithConversion<SingleLine, const QString&> ( &SingleLine::setColor, "Color", &parse<const Xml_string&>, "Black"));
166
        addRule("/SCRIBUSFRAGMENT/MultiLine/SubLine", SetAttributeWithConversion<SingleLine, int>( &SingleLine::setShade, "Shade", &parseInt ));
167
        addRule("/SCRIBUSFRAGMENT/MultiLine/SubLine", SetAttributeWithConversion<SingleLine, int>( &SingleLine::setDash , "Dash", &parseInt ));
168
        addRule("/SCRIBUSFRAGMENT/MultiLine/SubLine", SetAttributeWithConversion<SingleLine, int>( &SingleLine::setLineEnd , "LineEnd", &parseInt ));
169
        addRule("/SCRIBUSFRAGMENT/MultiLine/SubLine", SetAttributeWithConversion<SingleLine, int>( &SingleLine::setLineJoin, "LineJoin", &parseInt ));
170
        addRule("/SCRIBUSFRAGMENT/MultiLine/SubLine", SetAttributeWithConversion<SingleLine, double>( &SingleLine::setLineWidth, "Width", &parseDouble ));
171
        addRule("/SCRIBUSFRAGMENT/MultiLine/SubLine", CollectSingleLine());
172
 
8412 avox 173
        addRule("/SCRIBUSFRAGMENT/font", SetAttribute<Collection, QString>( & Collection::collectFont, "name"));
174
 
8289 avox 175
        PageItem::desaxeRules("", *this, "item");
8412 avox 176
        addRule("/SCRIBUSFRAGMENT/item", SetterP<Collection,PageItem>( & Collection::collectItem ));
3 paul 177
}
178
 
179
 
8382 avox 180
void Serializer::serializeObjects(const Selection& selection, SaxHandler& outputhandler)
8266 avox 181
{
8289 avox 182
        Xml_attr attr;
8382 avox 183
        UniqueID handler( & outputhandler );
8289 avox 184
        handler.beginDoc();
185
        handler.begin("SCRIBUSFRAGMENT", attr);
16084 jghali 186
 
187
        if (selection.count() == 0)
188
        {
189
                handler.end("SCRIBUSFRAGMENT");
190
                handler.endDoc();
191
                return;
192
        }
8328 avox 193
        ScribusDoc* doc = selection.itemAt(0)->doc();
8398 avox 194
 
195
        QMap<QString,int>::Iterator itf;
196
        for (itf = doc->UsedFonts.begin(); itf != doc->UsedFonts.end(); ++itf)
197
        {
198
                attr["name"] = itf.key();
199
                handler.beginEnd("font", attr);
200
        }
201
 
202
        ColorList usedColors;
203
        doc->getUsedColors(usedColors, false);
204
        ColorList::Iterator itc;
205
        for (itc = usedColors.begin(); itc != usedColors.end(); ++itc)
206
        {
207
                Xml_attr cattr;
208
                cattr["name"] = itc.key();
209
                if (doc->PageColors[itc.key()].getColorModel() == colorModelRGB)
210
                        cattr["RGB"] = doc->PageColors[itc.key()].nameRGB();
211
                else
212
                        cattr["CMYK"] = doc->PageColors[itc.key()].nameCMYK();
213
                cattr["Spot"] = toXMLString(doc->PageColors[itc.key()].isSpotColor());
214
                cattr["Register"] = toXMLString(doc->PageColors[itc.key()].isRegistrationColor());
215
                handler.beginEnd("color", cattr);
216
        }
217
 
8455 avox 218
        ResourceCollection lists;
9903 fschmid 219
        for (int i=0; i < doc->Items->count(); ++i)
8455 avox 220
                doc->Items->at(i)->getNamedResources(lists);
221
 
9803 fschmid 222
        QList<QString>::Iterator it;
223
        QList<QString> names = lists.styleNames();
8455 avox 224
        for (it = names.begin(); it != names.end(); ++it)
8643 cbradney 225
                doc->paragraphStyles().get(*it).saxx(handler);
8455 avox 226
 
227
        names = lists.charStyleNames();
228
        for (it = names.begin(); it != names.end(); ++it)
8643 cbradney 229
                doc->charStyles().get(*it).saxx(handler);
8455 avox 230
 
231
        names = lists.lineStyleNames();
232
        for (it = names.begin(); it != names.end(); ++it)
8328 avox 233
        {
8455 avox 234
                Xml_attr multiattr;
235
                multiattr["Name"] = *it;
236
                handler.begin("MultiLine", multiattr);         
237
                multiLine ml = doc->MLineStyles[*it];
238
 
10028 cbradney 239
                multiLine::Iterator itMU2;
8455 avox 240
                for (itMU2 = ml.begin(); itMU2 != ml.end(); ++itMU2)
241
                {
242
                        Xml_attr lineattr;
243
                        lineattr["Color"] = (*itMU2).Color;
8835 avox 244
                        lineattr["Shade"] = toXMLString((*itMU2).Shade);
245
                        lineattr["Dash"] = toXMLString((*itMU2).Dash);
246
                        lineattr["LineEnd"] = toXMLString((*itMU2).LineEnd);
247
                        lineattr["LineJoin"] = toXMLString((*itMU2).LineJoin);
248
                        lineattr["Width"] = toXMLString((*itMU2).Width);
8455 avox 249
                        handler.beginEnd("SubLine", lineattr);
250
                }
251
                handler.end("MultiLine");
252
        }
253
 
254
        /*      names = lists.patterns();
255
        for (it = names.begin(); it != names.end(); ++it)
256
                doc->patterns[*it].saxx(handler);
257
*/
12795 fschmid 258
/*
259
        QStringList patterns = doc->getUsedPatternsSelection((Selection*)&selection);
260
        for (int c = 0; c < patterns.count(); ++c)
261
        {
262
                ScPattern& pa = doc->docPatterns[patterns[c]];
263
                Xml_attr cattr;
264
                cattr["Name"] = patterns[c];
265
                cattr["scaleX"] = toXMLString(pa.scaleX);
266
                cattr["scaleY"] = toXMLString(pa.scaleY);
267
                cattr["width"] = toXMLString(pa.width);
268
                cattr["height"] = toXMLString(pa.height);
269
                cattr["xoffset"] = toXMLString(pa.xoffset);
270
                cattr["yoffset"] = toXMLString(pa.yoffset);
271
                handler.begin("Pattern", cattr);
272
                for (int o = 0; o < pa.items.count(); o++)
273
                {
274
                        pa.items.at(o)->saxx(handler);
275
                }
276
                handler.end("Pattern");
277
        }
278
*/
9903 fschmid 279
        for (int i=0; i < doc->Items->count(); ++i)
8455 avox 280
        {
8328 avox 281
                int k = selection.findItem(doc->Items->at(i));
282
                if (k >=0)
283
                        doc->Items->at(i)->saxx(handler);
284
        }
8398 avox 285
 
8289 avox 286
        handler.end("SCRIBUSFRAGMENT");
287
        handler.endDoc();
288
}
3 paul 289
 
290
 
12406 avox 291
Selection Serializer::cloneObjects(const Selection& objects)
292
{
293
        backUpColors = m_Doc.PageColors;
294
        store<ScribusDoc>("<scribusdoc>", &m_Doc);
295
 
296
        serializeObjects(objects, *this);
297
 
298
        return importCollection();
299
}
300
 
301
 
9535 fschmid 302
Selection Serializer::deserializeObjects(const QByteArray & xml)
8289 avox 303
{
13659 cbradney 304
        reset();
11303 fschmid 305
        backUpColors = m_Doc.PageColors;
8289 avox 306
        store<ScribusDoc>("<scribusdoc>", &m_Doc);
8412 avox 307
 
8289 avox 308
        parseMemory(xml, xml.length());
8266 avox 309
 
8412 avox 310
        return importCollection();
8266 avox 311
}
312
 
8328 avox 313
Selection Serializer::deserializeObjects(const QFile & file)
8266 avox 314
{
13659 cbradney 315
        reset();
11303 fschmid 316
        backUpColors = m_Doc.PageColors;
8289 avox 317
        store<ScribusDoc>("<scribusdoc>", &m_Doc);
8412 avox 318
 
8328 avox 319
        QFileInfo fi(file);
8289 avox 320
        parseFile(fi.filePath());
8412 avox 321
 
322
        return importCollection();
323
}
324
 
325
 
326
Selection Serializer::importCollection()
11303 fschmid 327
{
8412 avox 328
        Collection* coll = lookup<Collection>("<collection>");
8289 avox 329
        Selection result( &m_Doc, false);
13085 jghali 330
//      qDebug() << QString("deserialize: collection %1 doc %2").arg((ulong)coll).arg((ulong)&m_Doc);
8455 avox 331
        if (coll == NULL)
13085 jghali 332
                qDebug() << "deserialize: no objects collected";
8455 avox 333
        else
8289 avox 334
        {
8455 avox 335
                QMap<QString,QString> newNames;
8881 cbradney 336
 
337
                //TODO: fonts
338
 
339
                do {
340
                        newNames.clear();
10400 subik 341
                        for (int i = 0; i < coll->cstyles.count(); ++i)
8881 cbradney 342
                        {
343
                                QString oldName = coll->cstyles[i].name();
344
                                int oldIndex = m_Doc.charStyles().find(oldName);
345
                                if (oldIndex >= 0 && m_Doc.charStyle(oldName) == coll->cstyles[i])
346
                                        continue;
347
                                QString newName = oldName;
348
                                if (oldIndex >= 0 && !newNames.contains(oldName))
349
                                {
350
                                        int counter = 0;
351
                                        while (m_Doc.charStyles().find(newName) >= 0)
352
                                                newName = (QObject::tr("Copy of %1 (%2)")).arg(oldName).arg(++counter);
353
                                        newNames[oldName] = newName;
354
                                }
355
                        }
356
 
357
                        coll->cstyles.rename(newNames);
8455 avox 358
                }
8881 cbradney 359
                while (newNames.count() > 0);
360
                m_Doc.redefineCharStyles(coll->cstyles, false);        
361
 
362
                do {
363
                        newNames.clear();
10400 subik 364
                        for (int i = 0; i < coll->pstyles.count(); ++i)  // FIXME:  QValueList<QString> StyleSet::names()
8881 cbradney 365
                        {
366
                                QString oldName = coll->pstyles[i].name();
367
                                int oldIndex = m_Doc.paragraphStyles().find(oldName);
13085 jghali 368
//                              qDebug() << QString("comparing %1 (old %2 new %3): parent '%4'='%5' cstyle %6 equiv %7").arg(oldName).arg(oldIndex).arg(i)
8881 cbradney 369
//                                         .arg(oldIndex>=0? m_Doc.paragraphStyle(oldName).parent() : "?").arg(coll->pstyles[i].parent())
370
//                                         .arg(oldIndex>=0? m_Doc.paragraphStyle(oldName).charStyle() == coll->pstyles[i].charStyle() : false)
13085 jghali 371
//                                         .arg(oldIndex>=0? m_Doc.paragraphStyle(oldName).equiv(coll->pstyles[i]) : false);
8881 cbradney 372
 
373
                                if (oldIndex >= 0 && coll->pstyles[i] == m_Doc.paragraphStyle(oldName) )
374
                                        continue;
375
                                QString newName = oldName;
376
                                if (oldIndex >= 0 && !newNames.contains(oldName))
377
                                {
378
                                        int counter = 0;
379
                                        while (m_Doc.paragraphStyles().find(newName) >= 0)
380
                                                newName = (QObject::tr("Copy of %1 (%2)")).arg(oldName).arg(++counter);
381
                                        newNames[oldName] = newName;
382
                                }
383
                        }
384
                        coll->pstyles.rename(newNames);
8455 avox 385
                }
8881 cbradney 386
                while(newNames.count() > 0);
8455 avox 387
 
8881 cbradney 388
                m_Doc.redefineStyles(coll->pstyles, false);            
389
 
9403 jghali 390
                //TODO: linestyles : this is temporary code until MultiLine is replaced by LineStyle
391
                QMap<QString,multiLine>::Iterator mlit;
392
                for (mlit = coll->lstyles.begin(); mlit != coll->lstyles.end(); ++mlit)
393
                {
10455 cbradney 394
                        multiLine& ml = mlit.value();
9403 jghali 395
                        QString    oldName = mlit.key();
396
                        QString    newName = mlit.key();
397
                        QMap<QString,multiLine>::ConstIterator mlitd = m_Doc.MLineStyles.find(oldName);
10455 cbradney 398
                        if (mlitd != m_Doc.MLineStyles.end() && ml != mlitd.value())
9403 jghali 399
                        {
400
                                int counter = 0;
401
                                while (m_Doc.MLineStyles.contains(newName))
402
                                        newName = (QObject::tr("Copy of %1 (%2)")).arg(oldName).arg(++counter);
403
                        }
404
                        m_Doc.MLineStyles.insert(newName, ml);
405
                }
8881 cbradney 406
 
8455 avox 407
                //TODO: patterns
408
 
9856 fschmid 409
                QList<PageItem*>* objects = &(coll->items);
11303 fschmid 410
                m_Doc.PageColors = backUpColors;
411
                m_Doc.PageColors.addColors(coll->colors, false);
12388 fschmid 412
                int maxG = m_Doc.GroupCounter;
9903 fschmid 413
                for (int i=0; i < objects->count(); ++i)
8455 avox 414
                {
415
                        PageItem* currItem = objects->at(i);
416
                        currItem->Clip = FlattenPath(currItem->PoLine, currItem->Segments);
11303 fschmid 417
                        currItem->setFillQColor();
418
                        currItem->setLineQColor();
14952 fschmid 419
                        currItem->set4ColorColors(currItem->GrColorP1, currItem->GrColorP2, currItem->GrColorP3, currItem->GrColorP4);
15024 fschmid 420
                        for (int grow = 0; grow < currItem->meshGradientArray.count(); grow++)
421
                        {
422
                                for (int gcol = 0; gcol < currItem->meshGradientArray[grow].count(); gcol++)
423
                                {
424
                                        meshPoint mp = currItem->meshGradientArray[grow][gcol];
425
                                        currItem->setMeshPointColor(grow, gcol, mp.colorName, mp.shade, mp.transparency);
426
                                }
427
                        }
8455 avox 428
                        result.addItem(currItem);
12388 fschmid 429
                        if (currItem->Groups.count() != 0)
430
                        {
431
                                QStack<int> groups;
432
                                for (int i=0; i < currItem->groups().count(); ++i)
433
                                {
434
                                        int newGroup = m_Doc.GroupCounter + currItem->groups()[i] - 1;
435
                                        groups.append(newGroup);
436
                                }
437
                                currItem->setGroups(groups);
438
                                maxG = qMax(maxG, currItem->Groups.top()+1);
439
                        }
8455 avox 440
                }
12388 fschmid 441
                m_Doc.GroupCounter = maxG;
9554 jghali 442
                updateGradientColors(coll->colors);
8455 avox 443
                delete coll;
8289 avox 444
        }
445
        return result;
8266 avox 446
}
447
 
448
 
8045 avox 449
bool Serializer::writeWithEncoding(const QString& filename, const QString& encoding,
450
                                                                   const QString& txt)
451
{
19 Franz 452
        QTextCodec *codec;
8045 avox 453
        if (encoding.isEmpty())
19 Franz 454
                codec = QTextCodec::codecForLocale();
455
        else
10585 fschmid 456
                codec = QTextCodec::codecForName(encoding.toLocal8Bit());
9535 fschmid 457
        QByteArray dec = codec->fromUnicode( txt );
8045 avox 458
        QFile f(filename);
8501 cbradney 459
        if (f.open(QIODevice::WriteOnly))
167 Franz 460
        {
10585 fschmid 461
                f.write(dec, dec.length());
3 paul 462
                f.close();
8045 avox 463
                return true;
167 Franz 464
        }
8045 avox 465
        return false;
3 paul 466
}
467
 
8045 avox 468
 
469
bool Serializer::readWithEncoding(const QString& filename, const QString& encoding,
470
                                                                  QString &txt)
471
{
9535 fschmid 472
        QByteArray file;
15 Franz 473
        QTextCodec *codec;
8045 avox 474
        if (encoding.isEmpty())
15 Franz 475
                codec = QTextCodec::codecForLocale();
476
        else
10585 fschmid 477
                codec = QTextCodec::codecForName(encoding.toLocal8Bit());
8045 avox 478
        if (loadRawText(filename, file))
479
        {
480
                txt = codec->toUnicode( file.data() );
481
                return true;
482
        }
483
        return false;
3 paul 484
}
9554 jghali 485
 
486
void Serializer::updateGradientColors(const ColorList& colors)
487
{
488
        VColorStop* grStop;
489
        uint itemsCount = m_Doc.Items->count();
490
        for (uint c=0; c < itemsCount; ++c)
491
        {
492
                PageItem *ite = m_Doc.Items->at(c);
10009 jghali 493
                QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
9554 jghali 494
                for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
495
                {
496
                        grStop = cstops.at(cst);
497
                        if (colors.contains(grStop->name))
498
                                grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
499
                }
14277 fschmid 500
                cstops = ite->stroke_gradient.colorStops();
501
                for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
502
                {
503
                        grStop = cstops.at(cst);
504
                        if (colors.contains(grStop->name))
505
                                grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
506
                }
14297 fschmid 507
                cstops = ite->mask_gradient.colorStops();
508
                for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
509
                {
510
                        grStop = cstops.at(cst);
511
                        if (colors.contains(grStop->name))
512
                                grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
513
                }
9554 jghali 514
        }
515
        uint masterItemsCount =  m_Doc.MasterItems.count();
516
        for (uint c=0; c < masterItemsCount; ++c)
517
        {
518
                PageItem *ite = m_Doc.MasterItems.at(c);
10009 jghali 519
                QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
9554 jghali 520
                for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
521
                {
522
                        grStop = cstops.at(cst);
523
                        if (colors.contains(grStop->name))
524
                                grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
525
                }
14277 fschmid 526
                cstops = ite->stroke_gradient.colorStops();
527
                for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
528
                {
529
                        grStop = cstops.at(cst);
530
                        if (colors.contains(grStop->name))
531
                                grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
532
                }
14297 fschmid 533
                cstops = ite->mask_gradient.colorStops();
534
                for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
535
                {
536
                        grStop = cstops.at(cst);
537
                        if (colors.contains(grStop->name))
538
                                grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
539
                }
9554 jghali 540
        }
541
        uint frameItemsCount = m_Doc.FrameItems.count();
542
        for (uint c=0; c < frameItemsCount; ++c)
543
        {
544
                PageItem *ite = m_Doc.FrameItems.at(c);
10009 jghali 545
                QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
9554 jghali 546
                for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
547
                {
548
                        grStop = cstops.at(cst);
549
                        if (colors.contains(grStop->name))
550
                                grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
551
                }
14277 fschmid 552
                cstops = ite->stroke_gradient.colorStops();
553
                for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
554
                {
555
                        grStop = cstops.at(cst);
556
                        if (colors.contains(grStop->name))
557
                                grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
558
                }
14297 fschmid 559
                cstops = ite->mask_gradient.colorStops();
560
                for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
561
                {
562
                        grStop = cstops.at(cst);
563
                        if (colors.contains(grStop->name))
564
                                grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
565
                }
9554 jghali 566
        }
567
        QStringList patterns =m_Doc.docPatterns.keys();
568
        for (int c = 0; c < patterns.count(); ++c)
569
        {
570
                ScPattern& pa = m_Doc.docPatterns[patterns[c]];
9903 fschmid 571
                for (int o = 0; o < pa.items.count(); o++)
9554 jghali 572
                {
573
                        PageItem *ite = pa.items.at(o);
10009 jghali 574
                        QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
9554 jghali 575
                        for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
576
                        {
577
                                grStop = cstops.at(cst);
578
                                if (colors.contains(grStop->name))
579
                                        grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
580
                        }
14277 fschmid 581
                        cstops = ite->stroke_gradient.colorStops();
582
                        for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
583
                        {
584
                                grStop = cstops.at(cst);
585
                                if (colors.contains(grStop->name))
586
                                        grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
587
                        }
14297 fschmid 588
                        cstops = ite->mask_gradient.colorStops();
589
                        for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
590
                        {
591
                                grStop = cstops.at(cst);
592
                                if (colors.contains(grStop->name))
593
                                        grStop->color = SetColor(&m_Doc, grStop->name, grStop->shade);
594
                        }
9554 jghali 595
                }
596
        }
597
}