Subversion Repositories Scribus

Rev

Rev 14150 | Rev 14168 | 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
                        scribusXml.cpp the document xml library for scribus
9
                             -------------------
10
    begin                : Sam Jul 14 10:00:00 CEST 2001
167 Franz 11
    copyright            : (C) 2001 by Christian T�p
3 paul 12
    email                : christian.toepp@mr-ct@gmx.de
13
 ***************************************************************************/
75 Franz 14
 
3 paul 15
#include "scribusXml.h"
10334 jghali 16
 
17
#include <QtAlgorithms>
18
#include <QApplication>
19
#include <QByteArray>
12795 fschmid 20
#include <QBuffer>
10334 jghali 21
#include <QCursor>
22
#include <QDir>
10223 cbradney 23
#include <QFile>
24
#include <QRegExp>
25
#include <QTextCodec>
10002 fschmid 26
#include <QTextStream>
10009 jghali 27
#include <QXmlSimpleReader>
10334 jghali 28
#include <QXmlStreamReader>
10407 jghali 29
#include <QXmlStreamWriter>
11713 fschmid 30
#include <QDebug>
10334 jghali 31
 
3 paul 32
#include <cstdlib>
33
#include <cmath>
13650 cbradney 34
#include "ui/missing.h"
3670 cbradney 35
#include "page.h"
456 fschmid 36
#include "pageitem.h"
10660 cbradney 37
#include "pageitem_latexframe.h"
13839 fschmid 38
#ifdef HAVE_OSG
39
        #include "pageitem_osgframe.h"
40
#endif
13805 jghali 41
#include "selection.h"
1525 cbradney 42
#include "units.h"
2834 cbradney 43
#include "prefsmanager.h"
3252 craig 44
#include "scribusview.h"
13805 jghali 45
#include "scribusdoc.h"
13457 cbradney 46
#include "scclocale.h"
4546 subik 47
#include "commonstrings.h"
5184 avox 48
#include "text/nlsconfig.h"
128 Franz 49
 
1542 cbradney 50
#include <iostream>
51
 
2688 craig 52
#include "scconfig.h"
128 Franz 53
 
3 paul 54
#include <zlib.h>
2531 craig 55
#include "util.h"
12277 cbradney 56
#include "util_text.h"
10203 cbradney 57
#include "util_math.h"
58
#include "util_color.h"
6402 fschmid 59
#include "scpattern.h"
13839 fschmid 60
#include "sctextstream.h"
12039 jghali 61
#include "scxmlstreamwriter.h"
12795 fschmid 62
#include "scpainter.h"
325 Franz 63
 
504 cbradney 64
using namespace std;
65
 
10334 jghali 66
ScriXmlDoc::ScriXmlDoc()
10009 jghali 67
{
10334 jghali 68
        prefsManager=PrefsManager::instance();
69
}
70
 
12039 jghali 71
bool ScriXmlDoc::attrHasValue(const QXmlStreamAttributes& attrs, const char* attName)
72
{
73
        QLatin1String attString(attName);
74
        bool hasValue = false;
75
        QXmlStreamAttributes::ConstIterator pIter, pEnd  = attrs.constEnd();
76
        for (pIter = attrs.constBegin(); pIter != pEnd; ++pIter)
77
        {
78
                if (pIter->name() == attString)
79
                {
80
                        hasValue = true;
81
                        break;
82
                }
83
        }
84
        return hasValue;
85
}
86
 
10870 jghali 87
bool ScriXmlDoc::attrAsBool(const QXmlStreamAttributes& attrs, const char* attName, bool defVal)
10334 jghali 88
{
10870 jghali 89
        QLatin1String attString(attName);
10334 jghali 90
        bool value = defVal;
10870 jghali 91
        QStringRef att = attrs.value(attString);
10334 jghali 92
        if (!att.isEmpty())
11722 jghali 93
                value = static_cast<bool>(QString::fromRawData(att.constData(), att.length()).toInt());
10334 jghali 94
        return value;
95
}
96
 
10870 jghali 97
int ScriXmlDoc::attrAsInt(const QXmlStreamAttributes& attrs, const char* attName, int defVal)
10334 jghali 98
{
10870 jghali 99
        QLatin1String attString(attName);
10334 jghali 100
        int value = defVal;
10870 jghali 101
        QStringRef att = attrs.value(attString);
10334 jghali 102
        if (!att.isEmpty())
11722 jghali 103
                value = QString::fromRawData(att.constData(), att.length()).toInt();
10334 jghali 104
        return value;
105
}
106
 
10870 jghali 107
double ScriXmlDoc::attrAsDbl(const QXmlStreamAttributes& attrs, const char* attName, double defVal)
10334 jghali 108
{
10870 jghali 109
        QLatin1String attString(attName);
10334 jghali 110
        double value = defVal;
10870 jghali 111
        QStringRef att = attrs.value(attString);
10334 jghali 112
        if (!att.isEmpty())
13457 cbradney 113
                value = ScCLocale::toDoubleC(QString::fromRawData(att.constData(), att.length()));
10334 jghali 114
        return value;
115
}
116
 
10870 jghali 117
QString ScriXmlDoc::attrAsString (const QXmlStreamAttributes& attrs, const char* attName, const QString& defVal)
10334 jghali 118
{
10870 jghali 119
        QLatin1String attString(attName);
120
        QStringRef att = attrs.value(attString);
10334 jghali 121
        if (!att.isNull())
122
                return att.toString();
123
        return defVal;
124
}
125
 
126
void ScriXmlDoc::GetItemProps(const QXmlStreamAttributes& attrs, struct CopyPasteBuffer *OB, const QString& baseDir, bool newVersion)
127
{
128
        QString tmp;
129
        int x, y;
130
        double xf, yf, xf2;
131
        OB->PType   = static_cast<PageItem::ItemType>(attrAsInt(attrs, "PTYPE"));
132
        OB->Width   = attrAsDbl(attrs, "WIDTH", 0.0);
133
        OB->Height  = attrAsDbl(attrs, "HEIGHT", 0.);
134
        OB->RadRect = attrAsDbl(attrs, "RADRECT", 0.0);
135
        OB->ClipEdited = attrAsInt(attrs, "CLIPEDIT", 0);
136
        OB->FrameType  = attrAsInt(attrs, "FRTYPE", 0);
137
        OB->Pwidth     = attrAsDbl(attrs, "PWIDTH");
138
        OB->Pcolor     = attrAsString(attrs, "PCOLOR", CommonStrings::None);
139
        if ((!newVersion) && (OB->PType == 4))
10009 jghali 140
        {
10334 jghali 141
                OB->TxtFill = attrAsString(attrs, "PCOLOR2", CommonStrings::None);
142
                OB->Pcolor2 = CommonStrings::None;
10009 jghali 143
        }
10334 jghali 144
        else
10009 jghali 145
        {
10334 jghali 146
                OB->Pcolor2 = attrAsString(attrs, "PCOLOR2", CommonStrings::None);
147
                OB->TxtFill = attrAsString(attrs, "TXTFILL", "Black");
148
        }
149
        OB->Shade      = attrAsInt(attrs, "SHADE");
150
        OB->Shade2     = attrAsInt(attrs, "SHADE2");
151
        OB->FillRule   = attrAsInt(attrs, "fillRule", 1);
152
        OB->TxtStroke  = attrAsString(attrs, "TXTSTROKE", CommonStrings::None);
153
        OB->ShTxtFill  = attrAsInt(attrs, "TXTFILLSH", 100);
154
        OB->ShTxtStroke= attrAsInt(attrs, "TXTSTRSH", 100);
155
        OB->TxtScale   = qRound(attrAsDbl(attrs, "TXTSCALE", 100.0) * 10);
156
        OB->TxtScaleV  = qRound(attrAsDbl(attrs, "TXTSCALEV", 100.0) * 10);
157
        OB->TxTBase    = qRound(attrAsDbl(attrs, "TXTBASE", 0) * 10);
158
        OB->TxTStyle   = attrAsInt(attrs, "TXTSTYLE", 0);
159
        OB->TxtShadowX = qRound(attrAsDbl(attrs, "TXTSHX", 5.0) * 10);
160
        OB->TxtShadowY = qRound(attrAsDbl(attrs, "TXTSHY", -5.0)* 10);
161
        OB->TxtOutline = qRound(attrAsDbl(attrs, "TXTOUT", 1.0) * 10);
162
        OB->TxtUnderPos   = qRound(attrAsDbl(attrs, "TXTULP", -0.1) * 10);
163
        OB->TxtUnderWidth = qRound(attrAsDbl(attrs, "TXTULW", -0.1) * 10);
164
        OB->TxtStrikePos  = qRound(attrAsDbl(attrs, "TXTSTP", -0.1) * 10);
165
        OB->TxtStrikeWidth= qRound(attrAsDbl(attrs, "TXTSTW", -0.1) * 10);
166
        OB->Cols   = attrAsInt(attrs, "COLUMNS", 1);
167
        OB->ColGap = attrAsDbl(attrs, "COLGAP" , 0.0);
168
        OB->GrType = attrAsInt(attrs, "GRTYP"  , 0);
169
        OB->fill_gradient.clearStops();
170
        if (OB->GrType != 0)
171
        {
172
                if (OB->GrType == 8)
10009 jghali 173
                {
10334 jghali 174
                        OB->pattern = attrAsString(attrs, "pattern", "");
175
                        OB->patternScaleX   = attrAsDbl(attrs, "pScaleX", 100.0);
176
                        OB->patternScaleY   = attrAsDbl(attrs, "pScaleY", 100.0);
177
                        OB->patternOffsetX  = attrAsDbl(attrs, "pOffsetX", 0.0);
178
                        OB->patternOffsetY  = attrAsDbl(attrs, "pOffsetY", 0.0);
179
                        OB->patternRotation = attrAsDbl(attrs, "pRotation", 0.0);
10009 jghali 180
                }
10334 jghali 181
                else
182
                {
183
                        OB->GrStartX = attrAsDbl(attrs, "GRSTARTX", 0.0);
184
                        OB->GrStartY = attrAsDbl(attrs, "GRSTARTY", 0.0);
185
                        OB->GrEndX   = attrAsDbl(attrs, "GRENDX", 0.0);
186
                        OB->GrEndY   = attrAsDbl(attrs, "GRENDY", 0.0);
187
                        OB->GrColor  = attrAsString(attrs, "GRCOLOR", "Black");
188
                        if (OB->GrColor.isEmpty())
189
                                OB->GrColor = "Black";
190
                        OB->GrColor2 = attrAsString(attrs, "GRCOLOR2","Black");
191
                        if (OB->GrColor2.isEmpty())
192
                                OB->GrColor2 = "Black";
193
                        OB->GrShade  = attrAsInt(attrs, "GRSHADE", 100);
194
                        OB->GrShade2 = attrAsInt(attrs, "GRSHADE2", 100);
195
                }
10009 jghali 196
        }
10334 jghali 197
        OB->Rot        = attrAsDbl(attrs, "ROT", 0.0);
198
        OB->PLineArt   = Qt::PenStyle    ( attrAsInt(attrs, "PLINEART", 0) );
199
        OB->PLineEnd   = Qt::PenCapStyle ( attrAsInt(attrs, "PLINEEND", 0) );
200
        OB->PLineJoin  = Qt::PenJoinStyle( attrAsInt(attrs, "PLINEJOIN", 0));
201
        OB->LineSp     = attrAsDbl(attrs, "LINESP");
202
        OB->LineSpMode = attrAsInt(attrs, "LINESPMode", 0);
203
        OB->LocalScX   = attrAsDbl(attrs, "LOCALSCX");
204
        OB->LocalScY   = attrAsDbl(attrs, "LOCALSCY");
205
        OB->LocalX     = attrAsDbl(attrs, "LOCALX");
206
        OB->LocalY     = attrAsDbl(attrs, "LOCALY");
207
        OB->PicArt     = attrAsInt(attrs, "PICART");
208
        OB->flippedH   = attrAsInt(attrs, "FLIPPEDH") % 2;
209
        OB->flippedV   = attrAsInt(attrs, "FLIPPEDV") % 2;
210
/*      OB->BBoxX=obj->attribute("BBOXX").toDouble();
211
        OB->BBoxH=obj->attribute("BBOXH").toDouble(); */
212
        OB->ScaleType  = attrAsInt(attrs, "SCALETYPE", 1);
213
        OB->AspectRatio= attrAsInt(attrs, "RATIO", 0);
214
        OB->isPrintable= attrAsInt(attrs, "PRINTABLE");
215
        OB->m_isAnnotation = attrAsInt(attrs, "ANNOTATION", 0);
216
        OB->m_annotation.setType  (attrAsInt(attrs, "ANTYPE", 0));
217
        OB->m_annotation.setAction(attrAsString(attrs, "ANACTION",""));
218
        OB->m_annotation.setE_act (attrAsString(attrs, "ANEACT",""));
219
        OB->m_annotation.setX_act (attrAsString(attrs, "ANXACT",""));
220
        OB->m_annotation.setD_act (attrAsString(attrs, "ANDACT",""));
221
        OB->m_annotation.setFo_act(attrAsString(attrs, "ANFOACT",""));
222
        OB->m_annotation.setBl_act(attrAsString(attrs, "ANBLACT",""));
223
        OB->m_annotation.setK_act (attrAsString(attrs, "ANKACT",""));
224
        OB->m_annotation.setF_act (attrAsString(attrs, "ANFACT",""));
225
        OB->m_annotation.setV_act (attrAsString(attrs, "ANVACT",""));
226
        OB->m_annotation.setC_act (attrAsString(attrs, "ANCACT",""));
227
        OB->m_annotation.setActionType(attrAsInt(attrs, "ANACTYP", 0));
228
        OB->m_annotation.setExtern    (attrAsString(attrs, "ANEXTERN",""));
229
        if ((!OB->m_annotation.Extern().isEmpty()) && (OB->m_annotation.ActionType() != 8))
230
        {
231
                QFileInfo efp(OB->m_annotation.Extern());
10508 cbradney 232
                OB->m_annotation.setExtern(efp.absoluteFilePath());
10334 jghali 233
        }
234
        OB->m_annotation.setZiel (attrAsInt(attrs, "ANZIEL", 0));
235
        OB->AnName = attrAsString(attrs, "ANNAME","");
236
        OB->m_annotation.setToolTip (attrAsString(attrs, "ANTOOLTIP",""));
237
        OB->m_annotation.setRollOver(attrAsString(attrs, "ANROLL",""));
238
        OB->m_annotation.setDown  (attrAsString(attrs, "ANDOWN",""));
239
        OB->m_annotation.setBwid  (attrAsInt(attrs, "ANBWID", 1));
240
        OB->m_annotation.setBsty  (attrAsInt(attrs, "ANBSTY", 0));
241
        OB->m_annotation.setFeed  (attrAsInt(attrs, "ANFEED", 1));
242
        OB->m_annotation.setFlag  (attrAsInt(attrs, "ANFLAG", 0));
243
        OB->m_annotation.setFont  (attrAsInt(attrs, "ANFONT", 4));
244
        OB->m_annotation.setFormat(attrAsInt(attrs, "ANFORMAT", 0));
245
        OB->m_annotation.setVis   (attrAsInt(attrs, "ANVIS", 0));
246
        OB->m_annotation.setIsChk (attrAsBool(attrs, "ANCHK", false));
247
        OB->m_annotation.setAAact (attrAsBool(attrs, "ANAA", false));
13145 fschmid 248
        OB->m_annotation.setHTML  (attrAsInt(attrs, "ANHTML", 0));
10334 jghali 249
        OB->m_annotation.setUseIcons(attrAsBool(attrs, "ANICON", false));
250
        OB->m_annotation.setChkStil (attrAsInt(attrs, "ANCHKS", 0));
251
        OB->m_annotation.setMaxChar (attrAsInt(attrs, "ANMC", -1));
252
        OB->m_annotation.setBorderColor(attrAsString(attrs, "ANBCOL",CommonStrings::None));
253
        OB->m_annotation.setIPlace  (attrAsInt(attrs, "ANPLACE", 1));
254
        OB->m_annotation.setScaleW  (attrAsInt(attrs, "ANSCALE", 0));
255
        if (attrAsInt(attrs, "TRANSPARENT", 0) == 1)
256
                OB->Pcolor = CommonStrings::None;
257
        OB->textAlignment = attrAsInt(attrs, "ALIGN", 0);
258
        if (!attrs.value("TEXTFLOWMODE").isEmpty() )
259
                OB->TextflowMode = (PageItem::TextFlowMode) attrAsInt(attrs, "TEXTFLOWMODE", 0);
260
        else if (attrAsInt(attrs, "TEXTFLOW", 0))
261
        {
262
                if (attrAsInt(attrs, "TEXTFLOW2", 0))
263
                        OB->TextflowMode = PageItem::TextFlowUsesBoundingBox;
264
                else if (attrAsInt(attrs, "TEXTFLOW3", 0))
265
                        OB->TextflowMode = PageItem::TextFlowUsesContourLine;
266
                else
267
                        OB->TextflowMode = PageItem::TextFlowUsesFrameShape;   
268
        }
269
        else
270
                OB->TextflowMode = PageItem::TextFlowDisabled;
271
        OB->Extra    = attrAsDbl(attrs, "EXTRA", 0.0);
272
        OB->TExtra   = attrAsDbl(attrs, "TEXTRA", 1.0);
273
        OB->BExtra   = attrAsDbl(attrs, "BEXTRA", 1.0);
274
        OB->RExtra   = attrAsDbl(attrs, "REXTRA", 1.0);
12269 cbradney 275
        OB->firstLineOffsetP = static_cast<FirstLineOffsetPolicy>(attrAsInt(attrs, "FLOP", 0));
10334 jghali 276
        OB->PoShow   = attrAsInt(attrs, "PLTSHOW", 0);
277
        OB->BaseOffs = attrAsDbl(attrs, "BASEOF", 0.0);
278
        OB->textPathType    = attrAsInt (attrs, "textPathType", 0);
279
        OB->textPathFlipped = attrAsBool(attrs, "textPathFlipped", false);
280
        OB->ISize      = qRound(attrAsDbl(attrs, "ISIZE", 12.0) * 10);
281
        if (!attrs.value("EXTRAV").isEmpty())
282
                OB->ExtraV = qRound( attrAsDbl(attrs, "EXTRAV", 0.0) / attrAsDbl(attrs, "ISIZE", 12.0) * 1000.0);
283
        else
284
                OB->ExtraV = attrAsInt(attrs, "TXTKERN");
11239 fschmid 285
/*      OB->Pfile      = Relative2Path( attrAsString(attrs, "PFILE" ,""), baseDir);
10334 jghali 286
        OB->Pfile2     = Relative2Path( attrAsString(attrs, "PFILE2",""), baseDir);
11239 fschmid 287
        OB->Pfile3     = Relative2Path( attrAsString(attrs, "PFILE3",""), baseDir); */
288
        OB->Pfile      = attrAsString(attrs, "PFILE" ,"");
289
        OB->Pfile2     = attrAsString(attrs, "PFILE2","");
290
        OB->Pfile3     = attrAsString(attrs, "PFILE3","");
10334 jghali 291
        OB->IProfile   = attrAsString(attrs, "PRFILE","");
292
        OB->EmProfile  = attrAsString(attrs, "EPROF","");
293
        OB->IRender    = attrAsInt (attrs, "IRENDER", 1);
294
        OB->UseEmbedded= attrAsInt (attrs, "EMBEDDED", 1);
295
        OB->Locked       = attrAsBool(attrs, "LOCK", false);
296
        OB->LockRes      = attrAsBool(attrs, "LOCKR", false);
297
        OB->Reverse      = attrAsBool(attrs, "REVERS", false);
298
        OB->isTableItem  = attrAsBool(attrs, "isTableItem", false);
299
        OB->TopLine      = attrAsBool(attrs, "TopLine", false);
300
        OB->LeftLine     = attrAsBool(attrs, "LeftLine", false);
301
        OB->RightLine    = attrAsBool(attrs, "RightLine", false);
302
        OB->BottomLine   = attrAsBool(attrs, "BottomLine", false);
303
        OB->TopLinkID    = attrAsInt(attrs, "TopLINK", -1);
304
        OB->LeftLinkID   = attrAsInt(attrs, "LeftLINK", -1);
305
        OB->RightLinkID  = attrAsInt(attrs, "RightLINK", -1);
306
        OB->BottomLinkID = attrAsInt(attrs, "BottomLINK", -1);
307
        OB->Transparency = attrAsDbl(attrs, "TransValue", 0.0);
308
        if (!attrs.value("TransValueS").isEmpty())
309
                OB->TranspStroke = attrAsDbl(attrs, "TransValueS", 0.0);
310
        else
311
                OB->TranspStroke = OB->Transparency;
312
        OB->TransBlend  = attrAsInt(attrs, "TransBlend", 0);
313
        OB->TransBlendS = attrAsInt(attrs, "TransBlendS", 0);
314
        tmp = "";
315
        int numClip = attrAsInt(attrs, "NUMCLIP", 0);
316
        if (numClip > 0)
317
        {
318
                OB->Clip.resize(numClip);
319
                tmp = attrAsString(attrs, "CLIPCOOR", "");
320
                QTextStream fc(&tmp, QIODevice::ReadOnly);
321
                for (int c=0; c < numClip; ++c)
322
                {
323
                        fc >> x;
324
                        fc >> y;
325
                        OB->Clip.setPoint(c, x, y);
326
                }
327
        }
328
        else
329
                OB->Clip.resize(0);
330
        tmp = "";
331
        int numPo = attrAsInt(attrs, "NUMPO", 0);
332
        if (numPo > 0 )
333
        {
334
                OB->PoLine.resize(numPo);
335
                tmp = attrAsString(attrs, "POCOOR", "");
336
                QTextStream fp(&tmp, QIODevice::ReadOnly);
337
                for (int cx=0; cx < numPo; ++cx)
338
                {
13471 cbradney 339
                        QString s;
340
                        fp >> s;
341
                        xf = ScCLocale::toDoubleC(s);
342
                        fp >> s;
343
                        yf = ScCLocale::toDoubleC(s);
10334 jghali 344
                        OB->PoLine.setPoint(cx, xf, yf);
345
                }
346
        }
347
        else
348
                OB->PoLine.resize(0);
349
        tmp = "";
350
        int numCo = attrAsInt(attrs, "NUMCO", 0);
351
        if (numCo > 0)
352
        {
353
                OB->ContourLine.resize(numCo);
354
                tmp = attrAsString(attrs, "COCOOR", "");
355
                QTextStream fp(&tmp, QIODevice::ReadOnly);
356
                for (int cx=0; cx < numCo; ++cx)
357
                {
13471 cbradney 358
                        QString s;
359
                        fp >> s;
360
                        xf = ScCLocale::toDoubleC(s);
361
                        fp >> s;
362
                        yf = ScCLocale::toDoubleC(s);
10334 jghali 363
                        OB->ContourLine.setPoint(cx, xf, yf);
364
                }
365
        }
366
        else
367
                OB->ContourLine.resize(0);
368
        tmp = "";
369
        int numTab = attrAsInt(attrs, "NUMTAB", 0);
370
        if (numTab > 0)
371
        {
372
                ParagraphStyle::TabRecord tb;
373
                tmp = attrAsString(attrs, "TABS", "");
374
                QTextStream tgv(&tmp, QIODevice::ReadOnly);
375
                OB->TabValues.clear();
376
                for (int cxv = 0; cxv < numTab; cxv += 2)
377
                {
13471 cbradney 378
                        QString s;
379
                        tgv >> s;
380
                        xf = ScCLocale::toDoubleC(s);
381
                        tgv >> s;
382
                        xf2 = ScCLocale::toDoubleC(s);
10334 jghali 383
                        tb.tabPosition = xf2;
384
                        tb.tabType = static_cast<int>(xf);
385
                        tb.tabFillChar = QChar();
386
                        OB->TabValues.append(tb);
387
                }
388
                tmp = "";
389
        }
390
        else
391
                OB->TabValues.clear();
392
        int numDash = attrAsInt(attrs, "NUMDASH", 0);
393
        if (numDash > 0)
394
        {
395
                tmp = attrAsString(attrs, "DASHS", "");
396
                QTextStream dgv(&tmp, QIODevice::ReadOnly);
397
                OB->DashValues.clear();
398
                for (int cxv = 0; cxv < numDash; ++cxv)
399
                {
13471 cbradney 400
                        QString s;
401
                        dgv >> s;
402
                        xf = ScCLocale::toDoubleC(s);
10334 jghali 403
                        OB->DashValues.append(xf);
404
                }
405
                tmp = "";
406
        }
407
        else
408
                OB->DashValues.clear();
409
        OB->DashOffset = attrAsDbl(attrs, "DASHOFF", 0.0);
2834 cbradney 410
}
411
 
12039 jghali 412
void ScriXmlDoc::GetItemText(const QXmlStreamAttributes& attrs, StoryText& story, ScribusDoc *doc, LastStyles* last, bool VorLFound, bool impo)
332 Franz 413
{
12039 jghali 414
        CharStyle newStyle;
415
        QString pstylename;
3197 fschmid 416
        QString tmp2, tmf, tmpf, tmp3;
10334 jghali 417
        tmp2 = attrAsString(attrs, "CH", "");
517 fschmid 418
        tmp2.replace(QRegExp("\r"), QChar(5));
419
        tmp2.replace(QRegExp("\n"), QChar(5));
420
        tmp2.replace(QRegExp("\t"), QChar(4));
12039 jghali 421
 
12983 jghali 422
        ReadLegacyCStyle(attrs, newStyle, doc);
12039 jghali 423
 
10334 jghali 424
        QString pstyleName = attrAsString(attrs, "PSTYLE", "");
12039 jghali 425
        int calign = attrAsInt(attrs, "CALIGN", -1);   
426
        int cab    = attrAsInt(attrs, "CAB", -1);
427
        if (cab >= 5) {
428
                pstylename = DoVorl[cab];
429
                calign = -1;
430
        }
431
        else if (cab >= 0) {
432
                pstylename = "";
433
                calign = cab;
434
        }
435
 
8588 jghali 436
        for (int cxx=0; cxx<tmp2.length(); ++cxx)
3197 fschmid 437
        {
5184 avox 438
                CharStyle style;
439
                QChar ch = tmp2.at(cxx);
440
                if (ch == QChar(5))
5721 avox 441
                        ch = SpecialChars::PARSEP;
5184 avox 442
                if (ch == QChar(4))
5721 avox 443
                        ch = SpecialChars::TAB;
12039 jghali 444
 
445
                if (impo && cab >= 0 && VorLFound)
446
                        last->ParaStyle = DoVorl[cab];
5184 avox 447
                else
12039 jghali 448
                        last->ParaStyle = pstylename;
449
 
450
                int pos = story.length();
451
                story.insertChars(pos, QString(ch));
452
 
453
                if (newStyle != last->Style) {
454
                        story.applyCharStyle(last->StyleStart, pos-last->StyleStart, last->Style);
455
                        last->Style = newStyle;
456
                        last->StyleStart = pos;
5184 avox 457
                }
7442 avox 458
                if (ch == SpecialChars::PARSEP)
459
                {
460
                        ParagraphStyle pstyle;
12039 jghali 461
                        if (!pstyleName.isEmpty())
462
                                pstyle.setParent(pstyleName);
463
                        if (calign >= 0)
464
                                pstyle.setAlignment(static_cast<ParagraphStyle::AlignmentType>(calign));
465
                        story.applyStyle(pos, pstyle);
7442 avox 466
                }
5721 avox 467
                else
12039 jghali 468
                        story.applyCharStyle(pos, 1, style);
5184 avox 469
        }
12039 jghali 470
        story.applyCharStyle(last->StyleStart, story.length()-last->StyleStart, last->Style);
471
        ParagraphStyle pstyle;
12857 jghali 472
        pstyle.setParent( last->ParaStyle );
12039 jghali 473
        if (calign >= 0)
474
                pstyle.setAlignment(static_cast<ParagraphStyle::AlignmentType>(calign));
12857 jghali 475
        story.applyStyle(story.length()-1, pstyle);
12039 jghali 476
        last->StyleStart = story.length();
517 fschmid 477
}
478
 
2834 cbradney 479
QString ScriXmlDoc::AskForFont(SCFonts &avail, QString fStr, ScribusDoc *doc)
517 fschmid 480
{
5642 cbradney 481
        PrefsManager *prefsManager=PrefsManager::instance();
3544 avox 482
//      QFont fo;
517 fschmid 483
        QString tmpf = fStr;
5980 avox 484
        if ((!avail.contains(tmpf)) || (!avail[tmpf].usable()))
340 Franz 485
        {
13967 cbradney 486
                if ((!prefsManager->appPrefs.fontPrefs.GFontSub.contains(tmpf)) || (!avail[prefsManager->appPrefs.fontPrefs.GFontSub[tmpf]].usable()))
340 Franz 487
                {
9380 fschmid 488
                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
2834 cbradney 489
                        MissingFont *dia = new MissingFont(0, tmpf, doc);
517 fschmid 490
                        dia->exec();
713 cbradney 491
                        tmpf = dia->getReplacementFont();
517 fschmid 492
                        delete dia;
9380 fschmid 493
                        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
13967 cbradney 494
                        prefsManager->appPrefs.fontPrefs.GFontSub[fStr] = tmpf;
340 Franz 495
                }
517 fschmid 496
                else
13967 cbradney 497
                        tmpf = prefsManager->appPrefs.fontPrefs.GFontSub[tmpf];
1166 fschmid 498
                ReplacedFonts[fStr] = tmpf;
340 Franz 499
        }
1786 fschmid 500
        if (!doc->UsedFonts.contains(tmpf))
501
        {
3544 avox 502
//              fo = avail[tmpf]->Font;
503
//              fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
504
                doc->AddFont(tmpf);
1786 fschmid 505
        }
517 fschmid 506
        DoFonts[fStr] = tmpf;
507
        return tmpf;
332 Franz 508
}
509
 
12039 jghali 510
void ScriXmlDoc::SetItemProps(ScXmlStreamWriter& writer, ScribusDoc *doc, PageItem* item, const QString& baseDir, bool newFormat)
332 Franz 511
{
2881 fschmid 512
        double xf, yf;
332 Franz 513
        QString tmp, tmpy;
522 fschmid 514
        if (newFormat)
12039 jghali 515
                writer.writeAttribute("OwnPage", item->OwnPage);
10407 jghali 516
        const ParagraphStyle& defaultStyle = item->itemText.defaultStyle();
517
        const CharStyle&      charStyle    = item->itemText.defaultStyle().charStyle();
12039 jghali 518
        writer.writeAttribute("PTYPE"    ,item->realItemType());
519
        writer.writeAttribute("XPOS"     ,item->xPos() - doc->currentPage()->xOffset());
520
        writer.writeAttribute("YPOS"     ,item->yPos() - doc->currentPage()->yOffset());
521
        writer.writeAttribute("WIDTH"    ,item->width());
522
        writer.writeAttribute("HEIGHT"   ,item->height());
523
        writer.writeAttribute("RADRECT"  ,item->cornerRadius());
524
        writer.writeAttribute("FRTYPE"   ,item->FrameType);
10407 jghali 525
        writer.writeAttribute("CLIPEDIT" ,item->ClipEdited ? "1" : "0");
12039 jghali 526
        writer.writeAttribute("PWIDTH"   ,item->lineWidth());
10407 jghali 527
        writer.writeAttribute("PCOLOR"   ,item->fillColor());
528
        writer.writeAttribute("PCOLOR2"  ,item->lineColor());
12039 jghali 529
        writer.writeAttribute("IFONT"    ,charStyle.font().scName());
530
        writer.writeAttribute("ISIZE"    ,charStyle.fontSize() / 10.0);
10407 jghali 531
        writer.writeAttribute("TXTFILL"  ,charStyle.fillColor());
532
        writer.writeAttribute("TXTSTROKE",charStyle.strokeColor());
12039 jghali 533
        writer.writeAttribute("TXTSTRSH" ,charStyle.strokeShade());
534
        writer.writeAttribute("TXTFILLSH",charStyle.fillShade());
535
        writer.writeAttribute("TXTSCALE" ,charStyle.scaleH() / 10.0);
536
        writer.writeAttribute("TXTSCALEV",charStyle.scaleV() / 10.0);
537
        writer.writeAttribute("TXTBASE"  ,charStyle.baselineOffset() / 10.0);
538
        writer.writeAttribute("TXTSHX"   ,charStyle.shadowXOffset() / 10.0);
539
        writer.writeAttribute("TXTSHY"   ,charStyle.shadowYOffset() / 10.0);
540
        writer.writeAttribute("TXTOUT"   ,charStyle.outlineWidth() / 10.0);
541
        writer.writeAttribute("TXTULP"   ,charStyle.underlineOffset() / 10.0);
542
        writer.writeAttribute("TXTULW"   ,charStyle.underlineWidth() / 10.0);
543
        writer.writeAttribute("TXTSTP"   ,charStyle.strikethruOffset() / 10.0);
544
        writer.writeAttribute("TXTSTW"   ,charStyle.strikethruWidth() / 10.0);
545
        writer.writeAttribute("TXTKERN"  ,charStyle.tracking());
546
        writer.writeAttribute("TXTSTYLE" ,charStyle.effects());
547
        writer.writeAttribute("COLUMNS"  ,item->columns());
548
        writer.writeAttribute("COLGAP"   ,item->columnGap());
10407 jghali 549
        writer.writeAttribute("NAMEDLST" ,item->NamedLStyle);
12039 jghali 550
        writer.writeAttribute("SHADE"    ,item->fillShade());
551
        writer.writeAttribute("SHADE2"   ,item->lineShade());
552
        writer.writeAttribute("GRTYP"    ,item->GrType);
553
        writer.writeAttribute("ROT"      ,item->rotation());
554
        writer.writeAttribute("PLINEART" ,item->PLineArt);
555
        writer.writeAttribute("PLINEEND" ,item->PLineEnd);
556
        writer.writeAttribute("PLINEJOIN",item->PLineJoin);
557
        writer.writeAttribute("LINESP"   ,defaultStyle.lineSpacing());
558
        writer.writeAttribute("LINESPMode",defaultStyle.lineSpacingMode());
559
        writer.writeAttribute("LOCALSCX" ,item->imageXScale());
560
        writer.writeAttribute("LOCALSCY" ,item->imageYScale());
561
        writer.writeAttribute("LOCALX"   ,item->imageXOffset());
562
        writer.writeAttribute("LOCALY"   ,item->imageYOffset());
10407 jghali 563
        writer.writeAttribute("PICART"   ,item->imageShown() ? "1" : "0");
564
        writer.writeAttribute("PLTSHOW"  ,item->PoShow ? "1" : "0");
12039 jghali 565
        writer.writeAttribute("BASEOF"   ,item->BaseOffs);
566
        writer.writeAttribute("textPathType",item->textPathType);
10407 jghali 567
        writer.writeAttribute("textPathFlipped",item->textPathFlipped ? "1" : "0");
568
        writer.writeAttribute("FLIPPEDH" , item->imageFlippedH() ? "1" : "0");
569
        writer.writeAttribute("FLIPPEDV" , item->imageFlippedV() ? "1" : "0");
570
/*      writer.writeAttribute("BBOXX",item->BBoxX);
571
        writer.writeAttribute("BBOXH",item->BBoxH); */
572
        writer.writeAttribute("SCALETYPE",item->ScaleType ? "1" : "0");
573
        writer.writeAttribute("RATIO"    ,item->AspectRatio ? "1" : "0");
574
        writer.writeAttribute("PRINTABLE",item->printEnabled() ? "1" : "0");
4084 cbradney 575
        if(item->isAnnotation())
332 Franz 576
        {
10407 jghali 577
                writer.writeAttribute("ANNOTATION","1");
12039 jghali 578
                writer.writeAttribute("ANTYPE"  , item->annotation().Type());
10407 jghali 579
                writer.writeAttribute("ANACTION", item->annotation().Action());
580
                writer.writeAttribute("ANEACT"  , item->annotation().E_act());
581
                writer.writeAttribute("ANXACT"  , item->annotation().X_act());
582
                writer.writeAttribute("ANDACT"  , item->annotation().D_act());
583
                writer.writeAttribute("ANFOACT" , item->annotation().Fo_act());
584
                writer.writeAttribute("ANBLACT" , item->annotation().Bl_act());
585
                writer.writeAttribute("ANKACT"  , item->annotation().K_act());
586
                writer.writeAttribute("ANFACT"  , item->annotation().F_act());
587
                writer.writeAttribute("ANVACT"  , item->annotation().V_act());
588
                writer.writeAttribute("ANCACT"  , item->annotation().C_act());
4084 cbradney 589
                if (item->annotation().ActionType() == 8)
10407 jghali 590
                        writer.writeAttribute("ANEXTERN", item->annotation().Extern());
332 Franz 591
                else
10407 jghali 592
                        writer.writeAttribute("ANEXTERN", Path2Relative(item->annotation().Extern(), baseDir));
12039 jghali 593
                writer.writeAttribute("ANZIEL"  , item->annotation().Ziel());
594
                writer.writeAttribute("ANACTYP" , item->annotation().ActionType());
10407 jghali 595
                writer.writeAttribute("ANTOOLTIP", item->annotation().ToolTip());
12039 jghali 596
                writer.writeAttribute("ANBWID"  , item->annotation().Bwid());
597
                writer.writeAttribute("ANBSTY"  , item->annotation().Bsty());
598
                writer.writeAttribute("ANFEED"  , item->annotation().Feed());
599
                writer.writeAttribute("ANFLAG"  , item->annotation().Flag());
600
                writer.writeAttribute("ANFONT"  , item->annotation().Font());
601
                writer.writeAttribute("ANFORMAT", item->annotation().Format());
10407 jghali 602
                writer.writeAttribute("ANROLL"  , item->annotation().RollOver());
603
                writer.writeAttribute("ANDOWN"  , item->annotation().Down());
12039 jghali 604
                writer.writeAttribute("ANVIS"   , item->annotation().Vis());
605
                writer.writeAttribute("ANMC"    , item->annotation().MaxChar());
10407 jghali 606
                writer.writeAttribute("ANCHK"   , item->annotation().IsChk() ? "1" : "0");
607
                writer.writeAttribute("ANAA"    , item->annotation().AAact() ? "1" : "0");
12039 jghali 608
                writer.writeAttribute("ANCHKS"  , item->annotation().ChkStil());
10407 jghali 609
                writer.writeAttribute("ANBCOL"  , item->annotation().borderColor());
610
                writer.writeAttribute("ANHTML"  , item->annotation().HTML() ? "1" : "0");
611
                writer.writeAttribute("ANICON"  , item->annotation().UseIcons() ? "1" : "0");
612
                writer.writeAttribute("ANPLACE" , item->annotation().IPlace() ? "1" : "0");
613
                writer.writeAttribute("ANSCALE" , item->annotation().ScaleW() ? "1" : "0");
332 Franz 614
        }
615
        else
10407 jghali 616
                writer.writeAttribute("ANNOTATION","0");
617
        writer.writeAttribute("ANNAME", !item->AutoName ? item->itemName() : QString(""));
5620 jghali 618
        // "TEXTFLOWMODE" succeed to "TEXTFLOW" "TEXTFLOW2" and "TEXTFLOW3" attributes
12039 jghali 619
        writer.writeAttribute("TEXTFLOWMODE", (int) item->textFlowMode() );
5620 jghali 620
        // Set "TEXTFLOW" "TEXTFLOW2" and "TEXTFLOW3" attributes for compatibility
621
        // with versions prior to 1.3.4
10407 jghali 622
        writer.writeAttribute("TEXTFLOW" , item->textFlowAroundObject()    ? "1" : "0");
623
        writer.writeAttribute("TEXTFLOW2", item->textFlowUsesBoundingBox() ? "1" : "0");
624
        writer.writeAttribute("TEXTFLOW3", item->textFlowUsesContourLine() ? "1" : "0");
625
        writer.writeAttribute("AUTOTEXT" , item->isAutoText ? "1" : "0");
12039 jghali 626
        writer.writeAttribute("EXTRA"    , item->textToFrameDistLeft());
627
        writer.writeAttribute("TEXTRA"   , item->textToFrameDistTop());
628
        writer.writeAttribute("BEXTRA"   , item->textToFrameDistBottom());
629
        writer.writeAttribute("REXTRA"   , item->textToFrameDistRight());
12269 cbradney 630
        writer.writeAttribute("FLOP"    ,item->firstLineOffset());
13839 fschmid 631
#ifdef HAVE_OSG
632
        if (((item->asImageFrame() && !(item->asLatexFrame() || item->asOSGFrame())) || (item->asTextFrame())) && (!item->Pfile.isEmpty()))
633
#else
634
        if (((item->asImageFrame() && !(item->asLatexFrame())) || (item->asTextFrame())) && (!item->Pfile.isEmpty()))
635
#endif
12795 fschmid 636
        {
13090 fschmid 637
                writer.writeAttribute("ImageRes", item->pixm.imgInfo.lowResType);
638
                writer.writeAttribute("Pagenumber", item->pixm.imgInfo.actualPageNumber);
12795 fschmid 639
                if (item->isInlineImage)
640
                {
641
                        writer.writeAttribute("PFILE", "");
642
                        writer.writeAttribute("isInlineImage", static_cast<int>(item->isInlineImage));
643
                        QFileInfo inlFi(item->Pfile);
644
                        writer.writeAttribute("inlineImageExt", inlFi.suffix());
645
                        QFile inFil(item->Pfile);
646
                        if (inFil.open(QIODevice::ReadOnly))
647
                        {
648
                                QByteArray ba = qCompress(inFil.readAll()).toBase64();
649
                                writer.writeAttribute("ImageData", QString(ba));
650
                                inFil.close();
651
                        }
652
                }
653
                else
654
                        writer.writeAttribute("PFILE",Path2Relative(item->Pfile, baseDir));
655
        }
13839 fschmid 656
#ifdef HAVE_OSG
657
        else if (item->asOSGFrame())
658
        {
659
                if (!item->Pfile.isEmpty())
660
                {
661
                        writer.writeAttribute("PFILE", "");
662
                        writer.writeAttribute("isInlineImage", static_cast<int>(item->isInlineImage));
663
                        QFileInfo inlFi(item->Pfile);
664
                        writer.writeAttribute("inlineImageExt", inlFi.suffix());
665
                        QFile inFil(item->Pfile);
666
                        if (inFil.open(QIODevice::ReadOnly))
667
                        {
668
                                QByteArray ba = qCompress(inFil.readAll()).toBase64();
669
                                writer.writeAttribute("ImageData", QString(ba));
670
                                inFil.close();
671
                        }
672
                        PageItem_OSGFrame *osgframe = item->asOSGFrame();
673
                        writer.writeAttribute("modelFile", Path2Relative(osgframe->modelFile, baseDir));
674
                        writer.writeAttribute("currentViewName", osgframe->currentView);
675
                }
676
        }
677
#endif
2877 cbradney 678
        if (!item->Pfile2.isEmpty())
10407 jghali 679
                writer.writeAttribute("PFILE2",Path2Relative(item->Pfile2, baseDir));
332 Franz 680
        else
10407 jghali 681
                writer.writeAttribute("PFILE2","");
2877 cbradney 682
        if (!item->Pfile3.isEmpty())
10407 jghali 683
                writer.writeAttribute("PFILE3",Path2Relative(item->Pfile3, baseDir));
332 Franz 684
        else
10407 jghali 685
                writer.writeAttribute("PFILE3","");
686
        writer.writeAttribute("PRFILE"     , item->IProfile);
687
        writer.writeAttribute("EPROF"      , item->EmProfile);
12039 jghali 688
        writer.writeAttribute("IRENDER"    , item->IRender);
10407 jghali 689
        writer.writeAttribute("EMBEDDED"   , item->UseEmbedded ? "1" : "0");
690
        writer.writeAttribute("LOCK"       , item->locked() ? "1" : "0");
691
        writer.writeAttribute("LOCKR"      , item->sizeLocked() ? "1" : "0");
692
        writer.writeAttribute("REVERS"     , item->reversed() ? "1" : "0");
12039 jghali 693
        writer.writeAttribute("TransValue" , item->fillTransparency());
694
        writer.writeAttribute("TransValueS", item->lineTransparency());
695
        writer.writeAttribute("TransBlend" , item->fillBlendmode());
696
        writer.writeAttribute("TransBlendS", item->lineBlendmode());
697
        writer.writeAttribute("isTableItem", static_cast<int>(item->isTableItem));
698
        writer.writeAttribute("TopLine"    , static_cast<int>(item->TopLine));
699
        writer.writeAttribute("LeftLine"   , static_cast<int>(item->LeftLine));
700
        writer.writeAttribute("RightLine"  , static_cast<int>(item->RightLine));
701
        writer.writeAttribute("BottomLine" , static_cast<int>(item->BottomLine));
332 Franz 702
        if (item->isTableItem)
703
        {
704
                if (item->TopLink != 0)
12039 jghali 705
                        writer.writeAttribute("TopLINK", item->TopLink->ItemNr);
332 Franz 706
                else
10407 jghali 707
                        writer.writeAttribute("TopLINK", "-1");
332 Franz 708
                if (item->LeftLink != 0)
12039 jghali 709
                        writer.writeAttribute("LeftLINK", item->LeftLink->ItemNr);
332 Franz 710
                else
10407 jghali 711
                        writer.writeAttribute("LeftLINK", "-1");
332 Franz 712
                if (item->RightLink != 0)
12039 jghali 713
                        writer.writeAttribute("RightLINK", item->RightLink->ItemNr);
332 Franz 714
                else
10407 jghali 715
                        writer.writeAttribute("RightLINK", "-1");
332 Franz 716
                if (item->BottomLink != 0)
12039 jghali 717
                        writer.writeAttribute("BottomLINK", item->BottomLink->ItemNr);
332 Franz 718
                else
10407 jghali 719
                        writer.writeAttribute("BottomLINK", "-1");
12039 jghali 720
                writer.writeAttribute("OwnLINK", item->ItemNr);
332 Franz 721
        }
10407 jghali 722
        writer.writeAttribute("isGroupControl", item->isGroupControl ? "1" : "0");
6451 fschmid 723
        if (item->isGroupControl)
724
        {
725
                if (item->groupsLastItem != 0)
12039 jghali 726
                        writer.writeAttribute("groupsLastItem", item->groupsLastItem->ItemNr - item->ItemNr);
6451 fschmid 727
        }
12039 jghali 728
        writer.writeAttribute("NUMDASH", item->DashValues.count());
332 Franz 729
        QString dlp = "";
12055 jghali 730
        QVector<double>::Iterator dax;
332 Franz 731
        for (dax = item->DashValues.begin(); dax != item->DashValues.end(); ++dax)
732
                dlp += tmp.setNum((*dax)) + " ";
10407 jghali 733
        writer.writeAttribute("DASHS"  , dlp);
12039 jghali 734
        writer.writeAttribute("DASHOFF", item->DashOffset);
735
        writer.writeAttribute("NUMPO"  , item->PoLine.size());
332 Franz 736
        QString polp = "";
737
        for (uint nxx=0; nxx<item->PoLine.size(); ++nxx)
738
        {
739
                item->PoLine.point(nxx, &xf, &yf);
740
                polp += tmp.setNum(xf) + " " + tmpy.setNum(yf) + " ";
741
        }
10407 jghali 742
        writer.writeAttribute("POCOOR", polp);
12039 jghali 743
        writer.writeAttribute("NUMCO" , item->ContourLine.size());
340 Franz 744
        QString colp = "";
745
        for (uint nxx=0; nxx<item->ContourLine.size(); ++nxx)
746
        {
747
                item->ContourLine.point(nxx, &xf, &yf);
748
                colp += tmp.setNum(xf) + " " + tmpy.setNum(yf) + " ";
749
        }
10407 jghali 750
        writer.writeAttribute("COCOOR"  , colp);
12039 jghali 751
        writer.writeAttribute("NUMGROUP", item->Groups.count());
332 Franz 752
        QString glp = "";
9921 fschmid 753
        QStack<int>::Iterator nx;
332 Franz 754
        for (nx = item->Groups.begin(); nx != item->Groups.end(); ++nx)
755
                glp += tmp.setNum((*nx)) + " ";
10407 jghali 756
        writer.writeAttribute("GROUPS"  , glp);
757
        writer.writeAttribute("LANGUAGE", charStyle.language());
12039 jghali 758
        writer.writeAttribute("startArrowIndex", item->startArrowIndex());
759
        writer.writeAttribute("endArrowIndex"  , item->endArrowIndex());
332 Franz 760
}
761
 
5643 cbradney 762
//CB: Private only now
12039 jghali 763
void ScriXmlDoc::GetStyle(QXmlStreamReader &reader, ParagraphStyle &vg, StyleSet<ParagraphStyle>* tempStyles, ScribusDoc* doc, bool fl)
332 Franz 764
{
12039 jghali 765
        bool fou = false;
332 Franz 766
        QString tmpf, tmf, tmV;
2282 fschmid 767
        double xf, xf2;
12039 jghali 768
        const StyleSet<ParagraphStyle>& docParagraphStyles = tempStyles ? *tempStyles : doc->paragraphStyles();
769
        QString tagName = reader.name().toString();
770
        if (tagName != "STYLE" || !reader.isStartElement())
771
                return;
772
        QXmlStreamAttributes attrs = reader.attributes();
773
        vg.setName( attrAsString(attrs, "NAME", "") );
774
        vg.setLineSpacingMode(static_cast<ParagraphStyle::LineSpacingMode>(attrAsInt(attrs, "LINESPMode", 0)));
775
        if (static_cast<bool>(attrAsInt(attrs, "BASE", 0)))
776
                vg.setLineSpacingMode(ParagraphStyle::BaselineGridLineSpacing);
777
        vg.setLineSpacing( attrAsDbl(attrs, "LINESP") );
778
        vg.setLeftMargin( attrAsDbl(attrs, "INDENT", 0.0) );
779
        vg.setFirstIndent( attrAsDbl(attrs, "FIRST", 0.0) );
780
        vg.setAlignment(static_cast<ParagraphStyle::AlignmentType>(attrAsInt(attrs, "ALIGN", 0)));
781
        vg.setGapBefore( attrAsDbl(attrs, "VOR", 0.0) );
782
        vg.setGapAfter( attrAsDbl(attrs, "NACH", 0.0) );
783
        vg.setHasDropCap   (static_cast<bool>(attrAsInt(attrs, "DROP", 0)));
784
        vg.setDropCapLines ( attrAsInt(attrs, "DROPLIN", 2) );
785
        vg.setDropCapOffset( attrAsDbl(attrs, "DROPDIST", 0.0) );
786
 
13996 cbradney 787
        tmpf = attrAsString(attrs, "FONT", doc->itemToolPrefs.textFont);
2877 cbradney 788
        if (tmpf.isEmpty())
13996 cbradney 789
                tmpf = doc->itemToolPrefs.textFont;
332 Franz 790
        tmf = tmpf;
791
        if (!DoFonts.contains(tmpf))
13955 cbradney 792
                tmpf = AskForFont(prefsManager->appPrefs.fontPrefs.AvailFonts, tmpf, doc);
332 Franz 793
        else
794
                tmpf = DoFonts[tmf];
12039 jghali 795
 
13955 cbradney 796
        vg.charStyle().setFont(prefsManager->appPrefs.fontPrefs.AvailFonts[tmpf]);
12039 jghali 797
        vg.charStyle().setFontSize(qRound(attrAsDbl(attrs, "FONTSIZE", 12.0) * 10.0));
798
        vg.charStyle().setFeatures(static_cast<StyleFlag>(attrAsInt(attrs, "EFFECT", 0)).featureList());
14014 cbradney 799
        vg.charStyle().setFillColor(attrAsString(attrs, "FCOLOR", doc->itemToolPrefs.shapeFillColor));
12039 jghali 800
        vg.charStyle().setFillShade(attrAsInt(attrs, "FSHADE", 100));
14014 cbradney 801
        vg.charStyle().setStrokeColor(attrAsString(attrs, "SCOLOR", doc->itemToolPrefs.shapeLineColor));
12039 jghali 802
        vg.charStyle().setStrokeShade(attrAsInt(attrs, "SSHADE", 100));
803
        vg.charStyle().setShadowXOffset(qRound(attrAsDbl(attrs, "TXTSHX", 5.0) * 10));
804
        vg.charStyle().setShadowYOffset(qRound(attrAsDbl(attrs, "TXTSHY", -5.0) * 10));
805
        vg.charStyle().setOutlineWidth(qRound(attrAsDbl(attrs, "TXTOUT", 1.0) * 10));
806
        vg.charStyle().setUnderlineOffset(qRound(attrAsDbl(attrs, "TXTULP", -0.1) * 10));
807
        vg.charStyle().setUnderlineWidth(qRound(attrAsDbl(attrs, "TXTULW", -0.1) * 10));
808
        vg.charStyle().setStrikethruOffset(qRound(attrAsDbl(attrs, "TXTSTP", -0.1) * 10));
809
        vg.charStyle().setStrikethruWidth(qRound(attrAsDbl(attrs, "TXTSTW", -0.1) * 10));
810
        vg.charStyle().setScaleH(qRound(attrAsDbl(attrs, "SCALEH", 100.0) * 10));
811
        vg.charStyle().setScaleV(qRound(attrAsDbl(attrs, "SCALEV", 100.0) * 10));
812
        vg.charStyle().setBaselineOffset(attrAsDbl(attrs, "BASEO", 0.0) * 10);
813
        vg.charStyle().setTracking(qRound(attrAsDbl(attrs, "KERN", 0.0) * 10));
814
//      vg.tabValues().clear();
8871 cbradney 815
 
12039 jghali 816
        int numTab = attrAsInt(attrs, "NUMTAB", 0);
817
        if (numTab != 0)
332 Franz 818
        {
9797 avox 819
                QList<ParagraphStyle::TabRecord> tbs;
5184 avox 820
                ParagraphStyle::TabRecord tb;
12039 jghali 821
                QString tmp = attrAsString(attrs, "TABS", "");
10002 fschmid 822
                QTextStream tgv(&tmp, QIODevice::ReadOnly);
6733 avox 823
                tbs.clear();
12039 jghali 824
                for (int cxv = 0; cxv < numTab; cxv += 2)
332 Franz 825
                {
13471 cbradney 826
                        QString s;
827
                        tgv >> s;
828
                        xf = ScCLocale::toDoubleC(s);
829
                        tgv >> s;
830
                        xf2 = ScCLocale::toDoubleC(s);
2282 fschmid 831
                        tb.tabPosition = xf2;
832
                        tb.tabType = static_cast<int>(xf);
833
                        tb.tabFillChar = QChar();
6733 avox 834
                        tbs.append(tb);
332 Franz 835
                }
7191 jghali 836
                vg.setTabValues(tbs);
332 Franz 837
                tmp = "";
838
        }
839
        else
2282 fschmid 840
        {
9797 avox 841
                QList<ParagraphStyle::TabRecord> tbs;
12039 jghali 842
                while (!reader.atEnd() && !reader.hasError())
2282 fschmid 843
                {
12755 fschmid 844
//                      QXmlStreamReader::TokenType tType = reader.readNext();
845
                        reader.readNext();
12039 jghali 846
                        QString tagName = reader.name().toString();
847
                        if (tagName == "STYLE" && reader.isEndElement())
848
                                break;
849
                        if (tagName == "Tabs" && reader.isStartElement())
2282 fschmid 850
                        {
5184 avox 851
                                ParagraphStyle::TabRecord tb;
12039 jghali 852
                                QXmlStreamAttributes tabAttrs = reader.attributes();
853
                                tb.tabPosition = attrAsDbl(tabAttrs, "Pos");
854
                                tb.tabType     = attrAsInt(tabAttrs, "Type");
855
                                QString tbCh   = attrAsString(tabAttrs, "Fill","");
856
                                tb.tabFillChar = tbCh.isEmpty() ? QChar() : tbCh.at(0);
6733 avox 857
                                tbs.append(tb);
2282 fschmid 858
                        }
859
                }
7191 jghali 860
                vg.setTabValues(tbs);
2282 fschmid 861
        }
10400 subik 862
        for (int xx=0; xx<docParagraphStyles.count(); ++xx)
332 Franz 863
        {
7191 jghali 864
                if (vg.name() == docParagraphStyles[xx].name())
332 Franz 865
                {
4097 cbradney 866
                        //Compare the attributes of the pasted styles vs existing ones
7191 jghali 867
                        if (vg.equiv(docParagraphStyles[xx]))
335 Franz 868
                        {
869
                                if (fl)
870
                                {
871
                                        DoVorl[VorlC] = tmV.setNum(xx);
872
                                        VorlC++;
873
                                }
332 Franz 874
                                fou = true;
335 Franz 875
                        }
332 Franz 876
                        else
877
                        {
7191 jghali 878
                                vg.setName("Copy of "+docParagraphStyles[xx].name());
332 Franz 879
                                fou = false;
880
                        }
881
                        break;
882
                }
883
        }
884
        if (!fou)
885
        {
10400 subik 886
                for (int xx=0; xx< docParagraphStyles.count(); ++xx)
332 Franz 887
                {
7191 jghali 888
                        if (vg.equiv(docParagraphStyles[xx]))
2282 fschmid 889
                        {
7191 jghali 890
                                vg.setName(docParagraphStyles[xx].name());
332 Franz 891
                                fou = true;
892
                                if (fl)
893
                                {
894
                                        DoVorl[VorlC] = tmV.setNum(xx);
895
                                        VorlC++;
896
                                }
897
                                break;
898
                        }
899
                }
900
        }
901
        if (!fou)
902
        {
12039 jghali 903
                if (tempStyles)
904
                        tempStyles->create(vg);
905
                else
906
                {
907
                        StyleSet<ParagraphStyle> tmp;
908
                        tmp.create(vg);
909
                        doc->redefineStyles(tmp, false);
910
                }
332 Franz 911
                if (fl)
912
                {
1065 cbradney 913
                        DoVorl[VorlC] = tmV.setNum(docParagraphStyles.count()-1);
332 Franz 914
                        VorlC++;
915
                }
916
        }
917
}
918
 
80 Franz 919
bool ScriXmlDoc::ReadElemHeader(QString file, bool isFile, double *x, double *y, double *w, double *h)
3 paul 920
{
6028 jghali 921
        QString ff = "";
3 paul 922
        if (isFile)
167 Franz 923
        {
9535 fschmid 924
                QByteArray f;
6013 jghali 925
                if (!loadRawText(file, f))
3 paul 926
                        return false;
6062 jghali 927
                if (f.left(16) == "<SCRIBUSELEMUTF8")
6013 jghali 928
                        ff = QString::fromUtf8(f.data());
3 paul 929
                else
930
                        ff = f;
167 Franz 931
        }
3 paul 932
        else
10334 jghali 933
                ff  = file;
934
 
935
        bool succeed = false;
936
        QStringRef tName;
937
        QXmlStreamReader sReader(ff);
938
        QXmlStreamReader::TokenType tType;
939
        while (!sReader.atEnd() && !sReader.hasError())
167 Franz 940
        {
10334 jghali 941
                tType = sReader.readNext();
942
                if (tType == QXmlStreamReader::StartElement)
943
                {
944
                        tName = sReader.name();
945
                        if ((tName == "SCRIBUSELEM") || (tName == "SCRIBUSELEMUTF8"))
946
                        {
947
                                QXmlStreamAttributes attrs;
948
                                QString attx = attrs.value("XP").toString();
949
                                QString atty = attrs.value("YP").toString();
950
                                QString attw = attrs.value("W").toString();
951
                                QString atth = attrs.value("H").toString();
13457 cbradney 952
                                *x = (attx.isEmpty()) ? 0.0 : ScCLocale::toDoubleC(attx);
953
                                *y = (atty.isEmpty()) ? 0.0 : ScCLocale::toDoubleC(atty);
954
                                *w = (attw.isEmpty()) ? 0.0 : ScCLocale::toDoubleC(attw);
955
                                *h = (atth.isEmpty()) ? 0.0 : ScCLocale::toDoubleC(atth);
10334 jghali 956
                                succeed = true;
957
                        }
958
                }
167 Franz 959
        }
10334 jghali 960
        return (succeed && !sReader.hasError());
3 paul 961
}
962
 
3743 fschmid 963
bool ScriXmlDoc::ReadElem(QString fileName, SCFonts &avail, ScribusDoc *doc, double Xp, double Yp, bool Fi, bool loc, QMap<QString,QString> &FontSub, ScribusView *view)
3 paul 964
{
12907 fschmid 965
        return ReadElemToLayer(fileName,avail,doc,Xp,Yp,Fi,loc,FontSub,view,0);
966
}
967
 
968
bool ScriXmlDoc::ReadElemToLayer(QString fileName, SCFonts &avail, ScribusDoc *doc, double Xp, double Yp, bool Fi, bool loc, QMap<QString,QString> &FontSub, ScribusView *view, int toLayer)
969
{
10334 jghali 970
        QString ff;
1065 cbradney 971
        struct CopyPasteBuffer OB;
5184 avox 972
        ParagraphStyle vg;
10334 jghali 973
        QString tmp, tmpf, tmf;
234 Franz 974
        QMap<int,int> TableID;
741 fschmid 975
        QMap<int,int> arrowID;
13635 jghali 976
        QMap<int,int> groupMap;
6451 fschmid 977
        QMap<PageItem*, int> groupID;
10334 jghali 978
        QMap<int, ImageLoadRequest> loadRequests;
13839 fschmid 979
#ifdef HAVE_OSG
980
        QHash<QString, PageItem_OSGFrame::viewDefinition> viewMap;
981
#endif
10334 jghali 982
        QList<PageItem*>  TableItems;
983
        ScImageEffectList imageEffects;
3 paul 984
        bool VorLFound = false;
68 Franz 985
        bool newVersion = false;
10334 jghali 986
        double GrX = 0.0, GrY = 0.0;
13471 cbradney 987
        int x;
988
        int GrMax = doc->GroupCounter;
2886 fschmid 989
        ScColor lf = ScColor();
10334 jghali 990
 
10398 cbradney 991
        QString fileDir = QDir::homePath();
3 paul 992
        if (Fi)
167 Franz 993
        {
9535 fschmid 994
                QByteArray f;
6013 jghali 995
                if (!loadRawText(fileName, f))
3 paul 996
                        return false;
6062 jghali 997
                if (f.left(16) == "<SCRIBUSELEMUTF8")
6013 jghali 998
                        ff = QString::fromUtf8(f.data());
3 paul 999
                else
1000
                        ff = f;
10508 cbradney 1001
                fileDir = QFileInfo(fileName).absolutePath();
167 Franz 1002
        }
3 paul 1003
        else
167 Franz 1004
        {
6062 jghali 1005
                ff = fileName;
167 Franz 1006
        }
10334 jghali 1007
 
10870 jghali 1008
        // In case ff contains some old broken scribus xml
1009
        ff.replace(QChar(5), SpecialChars::PARSEP);
1010
        ff.replace(QChar(4), SpecialChars::TAB);
12185 fschmid 1011
        ff.replace(QChar(0), QChar(32));
1012
        ff.replace("&#x5;", SpecialChars::PARSEP);
1013
        ff.replace("&#x4;", SpecialChars::TAB);
10870 jghali 1014
 
10334 jghali 1015
        bool isScribusElem = false;
1016
        QXmlStreamReader     sReader(ff);
1017
        QXmlStreamAttributes attrs;
1018
        while (!sReader.atEnd() && !sReader.hasError())
167 Franz 1019
        {
10334 jghali 1020
                if (sReader.readNext() == QXmlStreamReader::StartElement)
1021
                {
1022
                        QStringRef tName = sReader.name();
1023
                        if (tName == "SCRIBUSELEM" || tName == "SCRIBUSELEMUTF8")
1024
                        {
1025
                                QXmlStreamAttributes attrs = sReader.attributes();
1026
                                if (!loc)
1027
                                {
13457 cbradney 1028
                                        GrX = ScCLocale::toDoubleC(attrs.value("XP").toString());
1029
                                        GrY = ScCLocale::toDoubleC(attrs.value("YP").toString());
10334 jghali 1030
                                }
1031
                                if (!attrs.value("Version").isEmpty())
1032
                                        newVersion = true;
1033
                                isScribusElem = true;
1034
                                break;
1035
                        }
1036
                }
167 Franz 1037
        }
10334 jghali 1038
        if (!isScribusElem || sReader.hasError())
1039
                return false;
1040
 
3 paul 1041
        DoFonts.clear();
13996 cbradney 1042
        DoFonts[doc->itemToolPrefs.textFont] = doc->itemToolPrefs.textFont;
3 paul 1043
        DoVorl.clear();
113 Franz 1044
        DoVorl[0] = "0";
1045
        DoVorl[1] = "1";
1046
        DoVorl[2] = "2";
1047
        DoVorl[3] = "3";
1048
        DoVorl[4] = "4";
3 paul 1049
        VorlC = 5;
234 Franz 1050
        TableItems.clear();
1051
        TableID.clear();
741 fschmid 1052
        arrowID.clear();
10398 cbradney 1053
        QString CurDirP = QDir::currentPath();
1054
        QDir::setCurrent(QDir::homePath());
741 fschmid 1055
        int startNumArrows = doc->arrowStyles.count();
10334 jghali 1056
        while (!sReader.atEnd() && !sReader.hasError())
167 Franz 1057
        {
10334 jghali 1058
                if (sReader.readNext() != QXmlStreamReader::StartElement)
1059
                        continue;
1060
                QString tagName = sReader.name().toString();
1061
                attrs           = sReader.attributes();
1062
                if( tagName == "Arrows")
741 fschmid 1063
                {
10334 jghali 1064
                        QString attIndex = attrs.value("Index").toString();
1065
                        if (attIndex.toInt() > startNumArrows)
741 fschmid 1066
                        {
1065 cbradney 1067
                                struct ArrowDesc arrow;
741 fschmid 1068
                                double xa, ya;
10334 jghali 1069
                                arrow.name  = attrs.value("Name").toString();
776 fschmid 1070
                                arrow.userArrow = true;
10334 jghali 1071
                                QString tmp = attrs.value("Points").toString();
10002 fschmid 1072
                                QTextStream fp(&tmp, QIODevice::ReadOnly);
10334 jghali 1073
                                uint numPoints = attrs.value("NumPoints").toString().toUInt();
1074
                                for (uint cx = 0; cx < numPoints; ++cx)
741 fschmid 1075
                                {
13471 cbradney 1076
                                        QString xs;
1077
                                        fp >> xs;
1078
                                        xa = ScCLocale::toDoubleC(xs);
1079
                                        fp >> xs;
1080
                                        ya = ScCLocale::toDoubleC(xs);
760 fschmid 1081
                                        arrow.points.addPoint(xa, ya);
741 fschmid 1082
                                }
1083
                                doc->arrowStyles.append(arrow);
10334 jghali 1084
                                arrowID.insert(attIndex.toInt(), doc->arrowStyles.count());
741 fschmid 1085
                        }
1086
                        else
10334 jghali 1087
                                arrowID.insert(attIndex.toInt(), attIndex.toInt());
741 fschmid 1088
                }
10334 jghali 1089
                if ( tagName == "FONT" )
167 Franz 1090
                {
10334 jghali 1091
                        QString attName = attrs.value("NAME").toString();
1092
                        tmpf = attName;
5980 avox 1093
                        if ((!avail.contains(tmpf)) || (!avail[tmpf].usable()))
167 Franz 1094
                        {
5980 avox 1095
                                if (!FontSub.contains(tmpf) || (!avail[FontSub[tmpf]].usable()))
3 paul 1096
                                {
2834 cbradney 1097
                                        MissingFont *dia = new MissingFont(0, tmpf, doc);
3 paul 1098
                                        dia->exec();
713 cbradney 1099
                                        tmpf = dia->getReplacementFont();
10334 jghali 1100
                                        FontSub[attName] = tmpf;
3 paul 1101
                                        delete dia;
167 Franz 1102
                                }
3 paul 1103
                                else
1104
                                        tmpf = FontSub[tmpf];
167 Franz 1105
                        }
3544 avox 1106
//                      fo = avail[tmpf]->Font;
1107
//                      fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
3 paul 1108
                        if(!doc->UsedFonts.contains(tmpf))
3544 avox 1109
                                doc->AddFont(tmpf);
10334 jghali 1110
                        DoFonts[attName] = tmpf;
167 Franz 1111
                }
516 fschmid 1112
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
10334 jghali 1113
                if ( tagName=="COLOR" && attrs.value("NAME")!=CommonStrings::None )
167 Franz 1114
                {
10334 jghali 1115
                        QString colName = attrs.value("NAME").toString();
1116
                        if (!attrs.value("CMYK").isEmpty())
1117
                                lf.setNamedColor(attrs.value("CMYK").toString());
28 Franz 1118
                        else
10334 jghali 1119
                                lf.fromQColor(QColor(attrs.value("RGB").toString()));
1120
                        lf.setSpotColor( attrAsBool(attrs, "Spot", false) );
1121
                        lf.setRegistrationColor( attrAsBool(attrs, "Register", false) );
1122
                        if (!doc->PageColors.contains(colName))
1123
                                doc->PageColors[colName] = lf;
167 Franz 1124
                }
10334 jghali 1125
                if (tagName=="MultiLine")
167 Franz 1126
                {
28 Franz 1127
                        multiLine ml;
10334 jghali 1128
                        SingleLine sl;
1129
                        QString  mlName = attrs.value("Name").toString();
1130
                        while(!(sReader.isEndElement() && sReader.name() == tagName))
167 Franz 1131
                        {
10334 jghali 1132
                                if (sReader.readNext() != QXmlStreamReader::StartElement)
1133
                                        continue;
1134
                                QString tagName1 = sReader.name().toString();
1135
                                QXmlStreamAttributes attrs1 = sReader.attributes();
1136
                                if (tagName1 == "SubLine")
1137
                                {
1138
                                        sl.Color    = attrs1.value("Color").toString();
1139
                                        sl.Dash     = attrAsInt(attrs1, "Dash");
1140
                                        sl.LineEnd  = attrAsInt(attrs1, "LineEnd");
1141
                                        sl.LineJoin = attrAsInt(attrs1, "LineJoin");
1142
                                        sl.Shade    = attrAsInt(attrs1, "Shade");
1143
                                        sl.Width    = attrAsDbl(attrs1, "Width");
1144
                                        ml.push_back(sl);
1145
                                }
167 Franz 1146
                        }
10334 jghali 1147
                        if (!doc->MLineStyles.contains(mlName))
1148
                                doc->MLineStyles.insert(mlName, ml);
167 Franz 1149
                }
14150 fschmid 1150
                if (tagName == "Gradient")
1151
                {
1152
                        VGradient gra;
1153
                        QString grName = attrs.value("Name").toString();gra = VGradient(VGradient::linear);
1154
                        gra.clearStops();
1155
                        while(!(sReader.isEndElement() && sReader.name() == tagName))
1156
                        {
1157
                                if (sReader.readNext() != QXmlStreamReader::StartElement)
1158
                                        continue;
1159
                                QString tagName1 = sReader.name().toString();
1160
                                QXmlStreamAttributes attrs1 = sReader.attributes();
1161
                                if (tagName1 == "CSTOP")
1162
                                {
1163
                                        QString name = attrs1.value("NAME").toString();
1164
                                        double ramp  = ScCLocale::toDoubleC(attrs1.value("RAMP").toString());
1165
                                        double opa   = ScCLocale::toDoubleC(attrs1.value("TRANS").toString());
1166
                                        int shade    = attrAsInt(attrs1, "SHADE");
1167
                                        gra.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
1168
                                }
1169
                        }
1170
                        if (!doc->docGradients.contains(grName))
1171
                                doc->docGradients.insert(grName, gra);
1172
                }
12039 jghali 1173
                if (tagName=="STYLE")
167 Franz 1174
                {
12039 jghali 1175
                        GetStyle(sReader, vg, NULL, doc, true);
3 paul 1176
                        VorLFound = true;
12039 jghali 1177
                }
10334 jghali 1178
                if (tagName=="Pattern")
6402 fschmid 1179
                {
1180
                        ScPattern pat;
12185 fschmid 1181
//                      uint ac = doc->Items->count();
12039 jghali 1182
                        QString patFile = Fi ? fileName : QString();
1183
                        ReadPattern(sReader, doc, view, patFile, GrMax, VorLFound, newVersion);
1184
 
6402 fschmid 1185
                }
167 Franz 1186
        }
10334 jghali 1187
 
1188
        sReader.clear();
1189
        sReader.addData(ff);
1190
 
1191
        bool inItem = false;
1192
        bool isGroupControl = false;
14164 fschmid 1193
        bool doOverprint = false;
10334 jghali 1194
        int  groupsLastItem = 0;
1195
        int  itemOwnLink    = 0;
1196
        QString itemClip;
12039 jghali 1197
        StoryText  storyText;
1198
        LastStyles lastStyles;
12980 herm 1199
        int LatexDPI = 0;
1200
        bool LatexPream = true;
12685 fschmid 1201
        QString LatexConfig;
12980 herm 1202
        bool inlineF = false;
12795 fschmid 1203
        QByteArray inlineImageData;
1204
        QString inlineImageExt;
13090 fschmid 1205
        int lowResType = 1;
1206
        int actualPageNumber = 0;
13839 fschmid 1207
        QString modelFile;
1208
        QString currentView;
14150 fschmid 1209
        QString gradName;
10334 jghali 1210
        while(!sReader.atEnd() && !sReader.hasError())
167 Franz 1211
        {
10407 jghali 1212
                sReader.readNext();
10334 jghali 1213
                QString tagName = sReader.name().toString();
1214
                QXmlStreamAttributes attrs = sReader.attributes();
1215
                if (sReader.isStartElement() && tagName == "ITEM")
167 Franz 1216
                {
10334 jghali 1217
                        inItem = true;
1218
                        imageEffects.clear();
1219
                        loadRequests.clear();
12857 jghali 1220
                        storyText = StoryText(doc);
12039 jghali 1221
                        lastStyles = LastStyles();
10334 jghali 1222
                        GetItemProps(attrs, &OB, fileDir, newVersion);
1223
                        OB.Xpos = Xp + attrAsDbl(attrs, "XPOS", 0.0) - GrX;
1224
                        OB.Ypos = Yp + attrAsDbl(attrs, "YPOS", 0.0) - GrY;
1225
                        OB.startArrowIndex = arrowID[ attrAsInt(attrs, "startArrowIndex", 0) ];
1226
                        OB.endArrowIndex   = arrowID[ attrAsInt(attrs, "endArrowIndex", 0)];
1227
                        OB.isBookmark      = attrAsInt(attrs, "BOOKMARK");
1228
                        OB.NamedLStyle     = attrAsString(attrs, "NAMEDLST", "");
14150 fschmid 1229
                        gradName           = attrAsString(attrs, "GRNAME", "");
10334 jghali 1230
                        isGroupControl     = attrAsBool(attrs, "isGroupControl", false);
14164 fschmid 1231
                        doOverprint        = attrAsBool(attrs, "doOverprint", false);
10334 jghali 1232
                        groupsLastItem     = attrAsInt (attrs, "groupsLastItem", 0);
1233
                        itemOwnLink        = attrAsInt (attrs, "OwnLINK", 0);
1234
                        itemClip           = attrAsString(attrs, "ImageClip", "");
13090 fschmid 1235
                        lowResType         = attrAsInt (attrs, "ImageRes", 1);
1236
                        actualPageNumber   = attrAsInt (attrs, "Pagenumber", 0);
12795 fschmid 1237
                        inlineF = attrAsBool(attrs, "isInlineImage", false);
1238
                        inlineImageData.resize(0);
1239
                        QString dat = attrAsString(attrs, "ImageData", "");
1240
                        inlineImageData.append(dat);
1241
                        inlineImageExt = attrAsString(attrs, "inlineImageExt", "");
27 Franz 1242
                        if (!doc->MLineStyles.contains(OB.NamedLStyle))
1243
                                OB.NamedLStyle = "";
10334 jghali 1244
                        OB.itemText        = "";
1245
                        OB.textAlignment   = attrAsInt(attrs, "ALIGN", 0);
13996 cbradney 1246
                        tmf = attrAsString(attrs, "IFONT", doc->itemToolPrefs.textFont);
2877 cbradney 1247
                        if (tmf.isEmpty())
13996 cbradney 1248
                                tmf = doc->itemToolPrefs.textFont;
2877 cbradney 1249
                        if (DoFonts[tmf].isEmpty())
13996 cbradney 1250
                                OB.IFont = doc->itemToolPrefs.textFont;
323 Franz 1251
                        else
1252
                                OB.IFont = DoFonts[tmf];
13041 pierre 1253
                        // #7725
13875 jghali 1254
                        OB.LayerID   = toLayer;
10334 jghali 1255
                        OB.Language  = attrAsString(attrs, "LANGUAGE", doc->Language);
3 paul 1256
                        tmp = "";
10334 jghali 1257
                        int numGroup = attrAsInt(attrs, "NUMGROUP", 0);
1258
                        if ((!attrs.value("GROUPS").isEmpty()) && (numGroup > 0))
167 Franz 1259
                        {
13635 jghali 1260
                                QMap<int, int>::ConstIterator gIt;
10334 jghali 1261
                                tmp = attrAsString(attrs, "GROUPS", "");
10002 fschmid 1262
                                QTextStream fg(&tmp, QIODevice::ReadOnly);
3 paul 1263
                                OB.Groups.clear();
10334 jghali 1264
                                for (int cx = 0; cx < numGroup; ++cx)
167 Franz 1265
                                {
3 paul 1266
                                        fg >> x;
13635 jghali 1267
                                        gIt = groupMap.find(x);
1268
                                        if (gIt != groupMap.end())
1269
                                                OB.Groups.push(gIt.value());
1270
                                        else
1271
                                        {
1272
                                                OB.Groups.push(GrMax + 1);
1273
                                                groupMap.insert(x, GrMax + 1);
1274
                                                GrMax = qMax(GrMax + 1, doc->GroupCounter + 1);
1275
                                        }
167 Franz 1276
                                }
3 paul 1277
                                tmp = "";
167 Franz 1278
                        }
3 paul 1279
                        else
1280
                                OB.Groups.clear();
1281
                        tmp = "";
12685 fschmid 1282
                        LatexDPI = attrAsInt (attrs, "LatexDpi", 0);
1283
                        LatexPream = attrAsBool(attrs, "LatexUsePreamble", true);
1284
                        LatexConfig = attrAsString(attrs, "LatexConfig", "");
13839 fschmid 1285
                        modelFile = attrAsString(attrs, "modelFile", "");
1286
                        currentView = attrAsString(attrs, "currentViewName", "");
10334 jghali 1287
                }
1288
                if (inItem && sReader.isStartElement() && tagName == "ITEXT")
1289
                {
12039 jghali 1290
                        GetItemText(sReader.attributes(), storyText, doc, &lastStyles, VorLFound, true);
11713 fschmid 1291
//                      continue;
10334 jghali 1292
                }
12982 jghali 1293
                if (inItem && sReader.isStartElement() && tagName == "var")
1294
                {
1295
                        QString varName=attrAsString(attrs, "name", "");
1296
                        if (varName == "pgno")
1297
                                storyText.insertChars(storyText.length(), SpecialChars::PAGENUMBER);
1298
                        else
1299
                                storyText.insertChars(storyText.length(), SpecialChars::PAGECOUNT);
1300
                        CharStyle newStyle;
12983 jghali 1301
                        ReadLegacyCStyle(attrs, newStyle, doc);
12982 jghali 1302
                        storyText.setCharStyle(storyText.length()-1, 1, newStyle);
1303
                        lastStyles.StyleStart = storyText.length()-1;
1304
                        lastStyles.Style = newStyle;
1305
                }
12039 jghali 1306
                if (inItem && sReader.isStartElement() && tagName == "PARA")
1307
                {
1308
                        storyText.insertChars(storyText.length(), SpecialChars::PARSEP);
1309
                        ParagraphStyle newStyle;
12185 fschmid 1310
//                      PrefsManager* prefsManager=PrefsManager::instance();
12039 jghali 1311
                        ReadPStyle(sReader, newStyle, doc);
1312
                        storyText.setStyle(storyText.length()-1, newStyle);
1313
                        storyText.setCharStyle(storyText.length()-1, 1, lastStyles.Style);
1314
                }
10660 cbradney 1315
                if (inItem && sReader.isStartElement() && tagName == "LATEX-SOURCE")
1316
                {
1317
                        OB.itemText = sReader.readElementText();
1318
                }
10334 jghali 1319
                if (inItem && sReader.isStartElement() && tagName == "ImageEffect")
1320
                {
10954 jghali 1321
                        struct ImageEffect ef;
10334 jghali 1322
                        ef.effectParameters = attrAsString(attrs, "Param", "");
1323
                        ef.effectCode       = attrAsInt(attrs, "Code");
1324
                        imageEffects.append(ef);
1325
                }
1326
                if (inItem && sReader.isStartElement() && tagName == "PSDLayer")
1327
                {
1328
                        struct ImageLoadRequest loadingInfo;
1329
                        loadingInfo.blend   = attrAsString(attrs, "Blend", "");
1330
                        loadingInfo.opacity = attrAsInt(attrs, "Opacity", 1);
1331
                        loadingInfo.visible = attrAsBool(attrs, "Visible", true);
1332
                        loadingInfo.useMask = attrAsBool(attrs, "useMask", true);
1333
                        loadRequests.insert( attrAsInt(attrs, "Layer"), loadingInfo);
1334
                }
13839 fschmid 1335
#ifdef HAVE_OSG
1336
                if (inItem && sReader.isStartElement() && tagName == "OSGViews")
1337
                {
1338
                        struct PageItem_OSGFrame::viewDefinition currentView;
1339
                        currentView.angleFOV = attrAsDbl(attrs, "angleFOV", 0.0);
1340
                        QString tmp = "";
1341
                        tmp = attrAsString(attrs, "trackM", "");
1342
                        ScTextStream fp(&tmp, QIODevice::ReadOnly);
1343
                        double m1, m2, m3, m4;
1344
                        double m5, m6, m7, m8;
1345
                        double m9, m10, m11, m12;
1346
                        double m13, m14, m15, m16;
1347
                        fp >> m1 >> m2 >> m3 >> m4;
1348
                        fp >> m5 >> m6 >> m7 >> m8;
1349
                        fp >> m9 >> m10 >> m11 >> m12;
1350
                        fp >> m13 >> m14 >> m15 >> m16;
1351
                        currentView.trackerMatrix.set(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16);
1352
                        tmp = "";
1353
                        tmp = attrAsString(attrs, "trackC", "");
1354
                        ScTextStream fp2(&tmp, QIODevice::ReadOnly);
1355
                        double v1, v2, v3;
1356
                        fp2 >> v1 >> v2 >> v3;
1357
                        currentView.trackerCenter.set(v1, v2, v3);
1358
                        tmp = "";
1359
                        tmp = attrAsString(attrs, "cameraP", "");
1360
                        ScTextStream fp3(&tmp, QIODevice::ReadOnly);
1361
                        fp3 >> v1 >> v2 >> v3;
1362
                        currentView.cameraPosition.set(v1, v2, v3);
1363
                        tmp = "";
1364
                        tmp = attrAsString(attrs, "cameraU", "");
1365
                        ScTextStream fp4(&tmp, QIODevice::ReadOnly);
1366
                        fp4 >> v1 >> v2 >> v3;
1367
                        currentView.cameraUp.set(v1, v2, v3);
1368
                        currentView.trackerDist = attrAsDbl(attrs, "trackerDist", 0.0);
1369
                        currentView.trackerSize = attrAsDbl(attrs, "trackerSize", 0.0);
1370
                        currentView.illumination = static_cast<PageItem_OSGFrame::LightType>(attrAsInt(attrs, "illumination", 1));
1371
                        currentView.rendermode = static_cast<PageItem_OSGFrame::RenderType>(attrAsInt(attrs, "rendermode", 0));
13874 fschmid 1372
                        currentView.addedTransparency = attrAsDbl(attrs, "trans", 0.5);
1373
                        currentView.colorAC = QColor(attrAsString(attrs, "colorAC", ""));
1374
                        currentView.colorFC = QColor(attrAsString(attrs, "colorFC", ""));
13839 fschmid 1375
                        viewMap.insert(attrAsString(attrs, "viewName", ""), currentView);
1376
                }
1377
#endif
10334 jghali 1378
                if (inItem && sReader.isStartElement() && tagName == "CSTOP")
1379
                {
1380
                        QString name = attrAsString(attrs, "NAME", "");
1381
                        double ramp  = attrAsDbl(attrs, "RAMP", 0.0);
1382
                        int shade    = attrAsInt(attrs, "SHADE", 100);
1383
                        double opa   = attrAsDbl(attrs, "TRANS", 1.0);
1384
                        OB.fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
1385
                        OB.GrColor   = "";
1386
                        OB.GrColor2  = "";
1387
                }
1388
                if (inItem && sReader.isStartElement() && tagName == "Tabs")
1389
                {
1390
                        ParagraphStyle::TabRecord tb;
1391
                        tb.tabPosition  = attrAsDbl(attrs, "Pos", 0.0);
1392
                        tb.tabType      = attrAsInt(attrs,"Type");
1393
                        QStringRef tbCh = attrs.value("Fill");
1394
                        if (tbCh.isEmpty())
1395
                                tb.tabFillChar = QChar();
1396
                        else
1397
                                tb.tabFillChar = tbCh.at(0);
1398
                        OB.TabValues.append(tb);
1399
                }
1400
                if (inItem && Fi && attrAsBool(attrs, "relativePaths", false))
1401
                {
1402
                        if (!OB.Pfile.isEmpty())
167 Franz 1403
                        {
10334 jghali 1404
                                QFileInfo pfi(fileName);
10508 cbradney 1405
                                QString test = QDir::cleanPath(QDir::convertSeparators(pfi.absolutePath()+"/"+OB.Pfile));
10334 jghali 1406
                                QFileInfo pfi2(test);
10508 cbradney 1407
                                OB.Pfile = pfi2.absoluteFilePath();
167 Franz 1408
                        }
10334 jghali 1409
                        if (!OB.Pfile2.isEmpty())
8288 fschmid 1410
                        {
10334 jghali 1411
                                QFileInfo pfi(fileName);
10508 cbradney 1412
                                QString test = QDir::cleanPath(QDir::convertSeparators(pfi.absolutePath()+"/"+OB.Pfile2));
10334 jghali 1413
                                QFileInfo pfi2(test);
10508 cbradney 1414
                                OB.Pfile2 = pfi2.absoluteFilePath();
8288 fschmid 1415
                        }
10334 jghali 1416
                        if (!OB.Pfile3.isEmpty())
1417
                        {
1418
                                QFileInfo pfi(fileName);
10508 cbradney 1419
                                QString test = QDir::cleanPath(QDir::convertSeparators(pfi.absolutePath()+"/"+OB.Pfile3));
10334 jghali 1420
                                QFileInfo pfi2(test);
10508 cbradney 1421
                                OB.Pfile3 = pfi2.absoluteFilePath();
10334 jghali 1422
                        }
13839 fschmid 1423
                        if (!modelFile.isEmpty())
1424
                        {
1425
                                QFileInfo pfi(fileName);
1426
                                QString test = QDir::cleanPath(QDir::convertSeparators(pfi.absolutePath()+"/"+modelFile));
1427
                                QFileInfo pfi2(test);
1428
                                modelFile = pfi2.absoluteFilePath();
1429
                        }
10334 jghali 1430
                }
1431
                if (sReader.isEndElement() && (tagName == "ITEM"))
1432
                {
12039 jghali 1433
                        LastStyles lastStyle;
6431 fschmid 1434
                        view->PasteItem(&OB, true, true, false);
3727 cbradney 1435
                        PageItem* Neu = doc->Items->at(doc->Items->count()-1);
14150 fschmid 1436
                        Neu->setGradient(gradName);
14164 fschmid 1437
                        Neu->doOverprint = doOverprint;
12039 jghali 1438
                        storyText.setDefaultStyle(Neu->itemText.defaultStyle());
12685 fschmid 1439
                        if (Neu->asLatexFrame())
1440
                        {
1441
                                PageItem_LatexFrame *latexitem = Neu->asLatexFrame();
1442
                                latexitem->setConfigFile(LatexConfig);
1443
                                latexitem->setDpi(LatexDPI);
1444
                                latexitem->setUsePreamble(LatexPream);
1445
                        }
12795 fschmid 1446
                        if (Neu->asImageFrame() && inlineF)
1447
                        {
1448
                                if (inlineImageData.size() > 0)
1449
                                {
1450
                                        Neu->tempImageFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_XXXXXX." + inlineImageExt);
1451
                                        Neu->tempImageFile->open();
1452
                                        QString fileName = getLongPathName(Neu->tempImageFile->fileName());
1453
                                        Neu->tempImageFile->close();
1454
                                        Neu->isInlineImage = true;
1455
                                        Neu->Pfile = fileName;
1456
                                        inlineImageData = qUncompress(QByteArray::fromBase64(inlineImageData));
1457
                                        QFile outFil(fileName);
1458
                                        if (outFil.open(QIODevice::WriteOnly))
1459
                                        {
1460
                                                outFil.write(inlineImageData);
1461
                                                outFil.close();
1462
                                                Neu->setImageXYScale(OB.LocalScX, OB.LocalScY);
1463
                                                Neu->setImageXYOffset(OB.LocalX, OB.LocalY);
1464
                                                Neu->IProfile = OB.IProfile;
1465
                                                Neu->EmProfile = OB.EmProfile;
1466
                                                Neu->IRender = OB.IRender;
1467
                                                Neu->UseEmbedded = OB.UseEmbedded;
1468
                                                if (!Neu->Pfile.isEmpty())
1469
                                                        doc->LoadPict(Neu->Pfile, doc->Items->count()-1);
1470
                                                Neu->setImageXYScale(OB.LocalScX, OB.LocalScY);
1471
                                                Neu->setImageShown(OB.PicArt);
1472
                                                Neu->ScaleType = OB.ScaleType;
1473
                                                Neu->AspectRatio = OB.AspectRatio;
1474
                                        }
1475
                                }
1476
                        }
13839 fschmid 1477
#ifdef HAVE_OSG
1478
                        if (Neu->asOSGFrame())
1479
                        {
1480
                                PageItem_OSGFrame *osgframe = Neu->asOSGFrame();
1481
                                osgframe->modelFile = modelFile;
1482
                                osgframe->currentView = currentView;
1483
                                osgframe->viewMap = viewMap;
1484
                                osgframe->loadModel();
1485
                        }
1486
#endif
12039 jghali 1487
                        Neu->itemText = storyText;
10334 jghali 1488
                        Neu->effectsInUse = imageEffects;
1489
                        Neu->pixm.imgInfo.RequestProps = loadRequests;
1490
                        Neu->pixm.imgInfo.isRequest    = (loadRequests.count() > 0);
13090 fschmid 1491
                        Neu->pixm.imgInfo.lowResType = lowResType;
1492
                        Neu->pixm.imgInfo.actualPageNumber = actualPageNumber;
13996 cbradney 1493
                        if ((Neu->effectsInUse.count() != 0) || (Neu->pixm.imgInfo.RequestProps.count() != 0) || (doc->itemToolPrefs.imageLowResType != lowResType))
4055 fschmid 1494
                                doc->LoadPict(Neu->Pfile, Neu->ItemNr, true);
10334 jghali 1495
                        if (Neu->pixm.imgInfo.PDSpathData.contains(itemClip))
8757 fschmid 1496
                        {
10334 jghali 1497
                                Neu->imageClip = Neu->pixm.imgInfo.PDSpathData[itemClip].copy();
1498
                                Neu->pixm.imgInfo.usedPath = itemClip;
13951 fschmid 1499
                                QTransform cl;
8757 fschmid 1500
                                cl.translate(Neu->imageXOffset()*Neu->imageXScale(), Neu->imageYOffset()*Neu->imageYScale());
1501
                                cl.scale(Neu->imageXScale(), Neu->imageYScale());
1502
                                Neu->imageClip.map(cl);
1503
                        }
234 Franz 1504
                        if (Neu->isTableItem)
1505
                        {
1506
                                TableItems.append(Neu);
10334 jghali 1507
                                TableID.insert(itemOwnLink, Neu->ItemNr);
234 Franz 1508
                        }
10334 jghali 1509
                        Neu->isGroupControl = isGroupControl;
6451 fschmid 1510
                        if (Neu->isGroupControl)
11644 fschmid 1511
                                groupID.insert(Neu, groupsLastItem + Neu->ItemNr );
4536 fschmid 1512
                        if (Neu->asPathText())
4688 cbradney 1513
                                Neu->updatePolyClip();
10334 jghali 1514
                        imageEffects.clear();
1515
                        loadRequests.clear();
13839 fschmid 1516
#ifdef HAVE_OSG
1517
                        viewMap.clear();
1518
#endif
10334 jghali 1519
                        inItem = false;
167 Franz 1520
                }
1521
        }
234 Franz 1522
        if (TableItems.count() != 0)
1523
        {
9856 fschmid 1524
                for (int ttc = 0; ttc < TableItems.count(); ++ttc)
234 Franz 1525
                {
1526
                        PageItem* ta = TableItems.at(ttc);
1527
                        if (ta->TopLinkID != -1)
3727 cbradney 1528
                                ta->TopLink = doc->Items->at(TableID[ta->TopLinkID]);
234 Franz 1529
                        else
1530
                                ta->TopLink = 0;
1531
                        if (ta->LeftLinkID != -1)
3727 cbradney 1532
                                ta->LeftLink = doc->Items->at(TableID[ta->LeftLinkID]);
234 Franz 1533
                        else
1534
                                ta->LeftLink = 0;
1535
                        if (ta->RightLinkID != -1)
3727 cbradney 1536
                                ta->RightLink = doc->Items->at(TableID[ta->RightLinkID]);
234 Franz 1537
                        else
1538
                                ta->RightLink = 0;
1539
                        if (ta->BottomLinkID != -1)
3727 cbradney 1540
                                ta->BottomLink = doc->Items->at(TableID[ta->BottomLinkID]);
234 Franz 1541
                        else
1542
                                ta->BottomLink = 0;
1543
                }
1544
        }
6451 fschmid 1545
        if (groupID.count() != 0)
1546
        {
1547
                QMap<PageItem*, int>::Iterator it;
1548
                for (it = groupID.begin(); it != groupID.end(); ++it)
1549
                {
11644 fschmid 1550
                        if (it.value() >= doc->Items->count())
1551
                        {
1552
                                it.key()->isGroupControl = false;
1553
                                continue;
1554
                        }
10508 cbradney 1555
                        it.key()->groupsLastItem = doc->Items->at(it.value());
6451 fschmid 1556
                }
1557
        }
3 paul 1558
        doc->GroupCounter = GrMax + 1;
63 Franz 1559
        QDir::setCurrent(CurDirP);
10334 jghali 1560
        return (!sReader.hasError());
3 paul 1561
}
1562
 
12039 jghali 1563
void ScriXmlDoc::ReadPattern(QXmlStreamReader &reader, ScribusDoc *doc, ScribusView *view, const QString& fileName,
1564
                                                         int& GrMax, bool styleFound, bool newVersion)
1565
{
1566
        QString tmp, tmpf, tmf;
1567
        QList<PageItem*>  TableItems;
1568
        QMap<int, ImageLoadRequest> loadRequests;
1569
        QMap<int,int> TableID;
1570
        QMap<int,int> arrowID;
13635 jghali 1571
        QMap<int, int> groupMap;
12039 jghali 1572
        QMap<PageItem*, int> groupID;
1573
        ScImageEffectList imageEffects;
1574
        ScPattern pat;
1575
        struct CopyPasteBuffer OB;
1576
        bool savedAlignGrid   = doc->useRaster;
1577
        bool savedAlignGuides = doc->SnapGuides;
1578
        bool isGroupControl   = false;
14164 fschmid 1579
        bool doOverprint      = false;
12039 jghali 1580
        bool isFile = !fileName.isEmpty();
1581
        doc->useRaster  = false;
1582
        doc->SnapGuides = false;
1583
        QXmlStreamAttributes attrs = reader.attributes();
1584
        QString patClipPath;
1585
        QString patName   = attrs.value("Name").toString();
1586
        double  patScaleX = attrAsDbl(attrs, "scaleX", 0.0);
1587
        double  patScaleY = attrAsDbl(attrs, "scaleY", 0.0);
1588
        double  patWidth  = attrAsDbl(attrs, "width", 0.0);
1589
        double  patHeight = attrAsDbl(attrs, "height", 0.0);
12744 fschmid 1590
        double  patxoffset  = attrAsDbl(attrs, "xoffset", 0.0);
1591
        double  patyoffset = attrAsDbl(attrs, "yoffset", 0.0);
12039 jghali 1592
        int     patOwnLink = 0;
12744 fschmid 1593
        int     groupsLastItem = 0;
1594
        int x = doc->GroupCounter;
12039 jghali 1595
        uint    ac = doc->Items->count();
1596
        QString fileDir    = QDir::homePath();
1597
        StoryText  storyText;
1598
        LastStyles lastStyles;
12980 herm 1599
        int LatexDPI = 0;
1600
        bool LatexPream = true;
12744 fschmid 1601
        QString LatexConfig;
12980 herm 1602
        bool inlineF = false;
12795 fschmid 1603
        QByteArray inlineImageData;
1604
        QString inlineImageExt;
14164 fschmid 1605
        QString gradName;
13090 fschmid 1606
        int lowResType = 1;
1607
        int actualPageNumber = 0;
12744 fschmid 1608
        while(!reader.atEnd() && !reader.hasError())
12039 jghali 1609
        {
12744 fschmid 1610
                reader.readNext();
1611
                if (reader.hasError())
12039 jghali 1612
                        break;
12744 fschmid 1613
                QString tagName1 = reader.name().toString();
1614
                QXmlStreamAttributes attrs1 = reader.attributes();
12039 jghali 1615
 
12744 fschmid 1616
                if (tagName1 == "PatternItem" && reader.isStartElement())
12039 jghali 1617
                {
1618
                        loadRequests.clear();
1619
                        imageEffects.clear();
12857 jghali 1620
                        storyText  = StoryText(doc);
12039 jghali 1621
                        lastStyles = LastStyles();
1622
                        GetItemProps(attrs1, &OB, fileDir, newVersion);
1623
                        patClipPath    = attrs1.value("ImageClip").toString();
14164 fschmid 1624
                        lowResType         = attrAsInt (attrs1, "ImageRes", 1);
1625
                        actualPageNumber   = attrAsInt (attrs1, "Pagenumber", 0);
1626
                        gradName           = attrAsString(attrs1, "GRNAME", "");
1627
                        inlineF = attrAsBool(attrs1, "isInlineImage", false);
12795 fschmid 1628
                        inlineImageData.resize(0);
14164 fschmid 1629
                        QString dat = attrAsString(attrs1, "ImageData", "");
12795 fschmid 1630
                        inlineImageData.append(dat);
14164 fschmid 1631
                        inlineImageExt = attrAsString(attrs1, "inlineImageExt", "");
12039 jghali 1632
                        patOwnLink     = attrAsInt(attrs1, "OwnLINK", 0);
1633
                        isGroupControl = attrAsBool(attrs1, "isGroupControl", false);
14164 fschmid 1634
                        doOverprint    = attrAsBool(attrs, "doOverprint", false);
12039 jghali 1635
                        groupsLastItem = attrAsInt(attrs1, "groupsLastItem", 0);
1636
                        OB.Xpos = attrAsDbl(attrs1, "XPOS") + doc->currentPage()->xOffset();
1637
                        OB.Ypos = attrAsDbl(attrs1, "YPOS") + doc->currentPage()->yOffset();
1638
                        OB.startArrowIndex = arrowID[ attrAsInt(attrs1, "startArrowIndex", 0) ];
1639
                        OB.endArrowIndex   = arrowID[ attrAsInt(attrs1, "endArrowIndex", 0)];
1640
                        OB.isBookmark      = attrAsInt(attrs1, "BOOKMARK");
1641
                        OB.NamedLStyle     = attrs1.value("NAMEDLST").toString();
1642
                        if (!doc->MLineStyles.contains(OB.NamedLStyle))
1643
                                OB.NamedLStyle = "";
1644
                        OB.itemText        = "";
1645
                        OB.textAlignment   = attrAsInt(attrs1, "ALIGN");
13996 cbradney 1646
                        tmf = attrAsString(attrs1, "IFONT", doc->itemToolPrefs.textFont);
12039 jghali 1647
                        if (tmf.isEmpty())
13996 cbradney 1648
                                tmf = doc->itemToolPrefs.textFont;
12039 jghali 1649
                        if (DoFonts[tmf].isEmpty())
13996 cbradney 1650
                                OB.IFont = doc->itemToolPrefs.textFont;
12039 jghali 1651
                        else
1652
                                OB.IFont = DoFonts[tmf];
13875 jghali 1653
                        OB.LayerID  = attrAsInt(attrs1, "LAYER");
12039 jghali 1654
                        OB.Language = attrAsString(attrs1, "LANGUAGE", doc->Language);
1655
                        tmp = "";
12744 fschmid 1656
                        int numGroup = attrAsInt(attrs1, "NUMGROUP", 0);
1657
                        if ((!attrs1.value("GROUPS").isEmpty()) && (numGroup > 0))
12039 jghali 1658
                        {
13635 jghali 1659
                                QMap<int, int>::ConstIterator gIt;
12039 jghali 1660
                                tmp = attrAsString(attrs1, "GROUPS", "");
1661
                                QTextStream fg(&tmp, QIODevice::ReadOnly);
1662
                                OB.Groups.clear();
12744 fschmid 1663
                                for (int cx = 0; cx < numGroup; ++cx)
12039 jghali 1664
                                {
1665
                                        fg >> x;
13635 jghali 1666
                                        gIt = groupMap.find(x);
1667
                                        if (gIt != groupMap.end())
1668
                                                OB.Groups.push(gIt.value());
1669
                                        else
1670
                                        {
1671
                                                OB.Groups.push(GrMax + 1);
1672
                                                groupMap.insert(x, GrMax + 1);
1673
                                                GrMax = qMax(GrMax + 1, doc->GroupCounter + 1);
1674
                                        }
12039 jghali 1675
                                }
12744 fschmid 1676
                                tmp = "";
12039 jghali 1677
                        }
1678
                        else
1679
                                OB.Groups.clear();
1680
                        tmp.clear();
12744 fschmid 1681
                        LatexDPI = attrAsInt (attrs1, "LatexDpi", 0);
1682
                        LatexPream = attrAsBool(attrs1, "LatexUsePreamble", true);
1683
                        LatexConfig = attrAsString(attrs1, "LatexConfig", "");
12039 jghali 1684
                }
12744 fschmid 1685
                if (tagName1 == "ITEXT" && reader.isStartElement())
12039 jghali 1686
                {
12744 fschmid 1687
                        GetItemText(reader.attributes(), storyText, doc, &lastStyles, styleFound, true);
12039 jghali 1688
                }
12744 fschmid 1689
                if (tagName1 == "ImageEffect" && reader.isStartElement())
12039 jghali 1690
                {
1691
                        struct ImageEffect ef;
1692
                        ef.effectParameters = attrAsString(attrs1, "Param", "");
1693
                        ef.effectCode       = attrAsInt(attrs1, "Code");
1694
                        imageEffects.append(ef);
1695
                }
12744 fschmid 1696
                if (tagName1 == "PSDLayer" && reader.isStartElement())
12039 jghali 1697
                {
1698
                        struct ImageLoadRequest loadingInfo;
1699
                        loadingInfo.blend   = attrAsString(attrs1, "Blend", "");
1700
                        loadingInfo.opacity = attrAsInt(attrs1, "Opacity", 1);
1701
                        loadingInfo.visible = attrAsBool(attrs, "Visible", false);
1702
                        loadingInfo.useMask = attrAsBool(attrs, "useMask", true);
1703
                        loadRequests.insert( attrAsInt(attrs1, "Layer"), loadingInfo);
1704
                }
12744 fschmid 1705
                if (tagName1 == "CSTOP" && reader.isStartElement())
12039 jghali 1706
                {
1707
                        QString name = attrs1.value("NAME").toString();
1708
                        double ramp  = attrAsDbl(attrs1, "RAMP", 0.0);
1709
                        int shade    = attrAsInt(attrs1, "SHADE", 100);
1710
                        double opa   = attrAsDbl(attrs1, "TRANS", 1.0);
1711
                        OB.fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
1712
                        OB.GrColor   = "";
1713
                        OB.GrColor2  = "";
1714
                }
12744 fschmid 1715
                if (tagName1=="Tabs" && reader.isStartElement())
12039 jghali 1716
                {
1717
                        ParagraphStyle::TabRecord tb;
1718
                        tb.tabPosition  = attrAsDbl(attrs1, "Pos");
1719
                        tb.tabType      = attrAsInt(attrs1, "Type");
1720
                        QStringRef tbCh = attrs1.value("Fill");
1721
                        if (tbCh.isEmpty())
1722
                                tb.tabFillChar = QChar();
1723
                        else
1724
                                tb.tabFillChar = tbCh.at(0);
1725
                        OB.TabValues.append(tb);
1726
                }
1727
                if (isFile && attrAsBool(attrs1, "relativePaths", false))
1728
                {
1729
                        if (!OB.Pfile.isEmpty())
1730
                        {
1731
                                QFileInfo pfi(fileName);
1732
                                QString test = QDir::cleanPath(QDir::convertSeparators(pfi.absolutePath()+"/"+OB.Pfile));
1733
                                QFileInfo pfi2(test);
1734
                                OB.Pfile = pfi2.absoluteFilePath();
1735
                        }
1736
                        if (!OB.Pfile2.isEmpty())
1737
                        {
1738
                                QFileInfo pfi(fileName);
1739
                                QString test = QDir::cleanPath(QDir::convertSeparators(pfi.absolutePath()+"/"+OB.Pfile2));
1740
                                QFileInfo pfi2(test);
1741
                                OB.Pfile2 = pfi2.absoluteFilePath();
1742
                        }
1743
                        if (!OB.Pfile3.isEmpty())
1744
                        {
1745
                                QFileInfo pfi(fileName);
1746
                                QString test = QDir::cleanPath(QDir::convertSeparators(pfi.absolutePath()+"/"+OB.Pfile3));
1747
                                QFileInfo pfi2(test);
1748
                                OB.Pfile3 = pfi2.absoluteFilePath();
1749
                        }
1750
                }
12744 fschmid 1751
                if (tagName1 == "PatternItem" && reader.isEndElement())
12039 jghali 1752
                {
1753
                        LastStyles lastStyle;
1754
                        view->PasteItem(&OB, true, true, false);
1755
                        PageItem* Neu = doc->Items->at(doc->Items->count()-1);
14164 fschmid 1756
                        Neu->doOverprint = doOverprint;
1757
                        Neu->setGradient(gradName);
12039 jghali 1758
                        Neu->setXYPos(Neu->xPos() - doc->currentPage()->xOffset(), Neu->yPos() - doc->currentPage()->yOffset(), true);
1759
                        storyText.setDefaultStyle(Neu->itemText.defaultStyle());
1760
                        Neu->itemText = storyText;
12795 fschmid 1761
                        if (Neu->asImageFrame() && inlineF)
1762
                        {
1763
                                if (inlineImageData.size() > 0)
1764
                                {
1765
                                        Neu->tempImageFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_XXXXXX." + inlineImageExt);
1766
                                        Neu->tempImageFile->open();
1767
                                        QString fileName = getLongPathName(Neu->tempImageFile->fileName());
1768
                                        Neu->tempImageFile->close();
1769
                                        inlineImageData = qUncompress(QByteArray::fromBase64(inlineImageData));
1770
                                        QFile outFil(fileName);
1771
                                        if (outFil.open(QIODevice::WriteOnly))
1772
                                        {
1773
                                                outFil.write(inlineImageData);
1774
                                                outFil.close();
1775
                                                Neu->isInlineImage = true;
1776
                                                Neu->Pfile = fileName;
1777
                                                Neu->setImageXYScale(OB.LocalScX, OB.LocalScY);
1778
                                                Neu->setImageXYOffset(OB.LocalX, OB.LocalY);
1779
                                                Neu->IProfile = OB.IProfile;
1780
                                                Neu->EmProfile = OB.EmProfile;
1781
                                                Neu->IRender = OB.IRender;
1782
                                                Neu->UseEmbedded = OB.UseEmbedded;
1783
                                                if (!Neu->Pfile.isEmpty())
1784
                                                        doc->LoadPict(Neu->Pfile, doc->Items->count()-1);
1785
                                                Neu->setImageXYScale(OB.LocalScX, OB.LocalScY);
1786
                                                Neu->setImageShown(OB.PicArt);
1787
                                                Neu->ScaleType = OB.ScaleType;
1788
                                                Neu->AspectRatio = OB.AspectRatio;
1789
                                        }
1790
                                }
1791
                        }
12039 jghali 1792
                        Neu->effectsInUse = imageEffects;
1793
                        Neu->pixm.imgInfo.RequestProps = loadRequests;
1794
                        Neu->pixm.imgInfo.isRequest    = (loadRequests.count() > 0);
13090 fschmid 1795
                        Neu->pixm.imgInfo.lowResType = lowResType;
1796
                        Neu->pixm.imgInfo.actualPageNumber = actualPageNumber;
13996 cbradney 1797
                        if ((Neu->effectsInUse.count() != 0) || (Neu->pixm.imgInfo.RequestProps.count() != 0) || (doc->itemToolPrefs.imageLowResType != lowResType))
12039 jghali 1798
                                doc->LoadPict(Neu->Pfile, Neu->ItemNr, true);
1799
                        if (Neu->pixm.imgInfo.PDSpathData.contains(patClipPath))
1800
                        {
1801
                                Neu->imageClip = Neu->pixm.imgInfo.PDSpathData[patClipPath].copy();
1802
                                Neu->pixm.imgInfo.usedPath = patClipPath;
13951 fschmid 1803
                                QTransform cl;
12039 jghali 1804
                                cl.translate(Neu->imageXOffset()*Neu->imageXScale(), Neu->imageYOffset()*Neu->imageYScale());
1805
                                cl.scale(Neu->imageXScale(), Neu->imageYScale());
1806
                                Neu->imageClip.map(cl);
1807
                        }
12744 fschmid 1808
                        if (Neu->asLatexFrame())
1809
                        {
1810
                                PageItem_LatexFrame *latexitem = Neu->asLatexFrame();
1811
                                latexitem->setConfigFile(LatexConfig);
1812
                                latexitem->setDpi(LatexDPI);
1813
                                latexitem->setUsePreamble(LatexPream);
1814
                        }
12039 jghali 1815
                        if (Neu->isTableItem)
1816
                        {
1817
                                TableItems.append(Neu);
1818
                                TableID.insert(patOwnLink, Neu->ItemNr);
1819
                        }
1820
                        Neu->isGroupControl = isGroupControl;
1821
                        if (Neu->isGroupControl)
1822
                                groupID.insert(Neu, groupsLastItem + Neu->ItemNr);
1823
                        if (Neu->asPathText())
1824
                                Neu->updatePolyClip();
1825
                        imageEffects.clear();
1826
                        loadRequests.clear();
1827
                }
12744 fschmid 1828
                if (tagName1 == "Pattern" && reader.isEndElement())
1829
                        break;
12039 jghali 1830
        }
12744 fschmid 1831
        if (groupID.count() != 0)
1832
        {
1833
                QMap<PageItem*, int>::Iterator it;
1834
                for (it = groupID.begin(); it != groupID.end(); ++it)
1835
                {
1836
                        if (it.value() >= doc->Items->count())
1837
                        {
1838
                                it.key()->isGroupControl = false;
1839
                                continue;
1840
                        }
1841
                        it.key()->groupsLastItem = doc->Items->at(it.value());
1842
                }
1843
        }
12039 jghali 1844
        doc->useRaster = savedAlignGrid;
1845
        doc->SnapGuides = savedAlignGuides;
1846
        uint ae = doc->Items->count();
1847
        if (ae > ac)
1848
        {
1849
                pat.setDoc(doc);
1850
                PageItem* currItem = doc->Items->at(ac);
1851
                pat.pattern = currItem->DrawObj_toImage();
12744 fschmid 1852
                pat.scaleX = patScaleX;
1853
                pat.scaleY = patScaleY;
1854
                pat.width  = patWidth;
1855
                pat.height = patHeight;
1856
                pat.xoffset = patxoffset;
1857
                pat.yoffset = patyoffset;
1858
                pat.pattern = pat.pattern.copy(-patxoffset, -patyoffset, pat.width, pat.height);
12039 jghali 1859
                for (uint as = ac; as < ae; ++as)
1860
                {
1861
                        PageItem* Neu = doc->Items->takeAt(ac);
12744 fschmid 1862
                        Neu->moveBy(pat.xoffset, pat.yoffset, true);
1863
                        Neu->gXpos += pat.xoffset;
1864
                        Neu->gYpos += pat.yoffset;
12039 jghali 1865
                        Neu->ItemNr = pat.items.count();
1866
                        pat.items.append(Neu);
1867
                }
1868
                if (