Subversion Repositories Scribus

Rev

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

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