Subversion Repositories Scribus

Rev

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