Subversion Repositories Scribus

Rev

Rev 6402 | Rev 6414 | 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"
16
#include "scribusXml.moc"
17
#include <qfile.h>
18
#include <qtextstream.h>
19
#include <qapplication.h>
20
#include <qtl.h>
21
#include <qcursor.h>
22
#include <qregexp.h>
23
#include <qdir.h>
24
#include <qtextcodec.h>
25
#include <cstdlib>
26
#include <cmath>
27
#include "missing.h"
3670 cbradney 28
#include "page.h"
456 fschmid 29
#include "pageitem.h"
1525 cbradney 30
#include "units.h"
2834 cbradney 31
#include "prefsmanager.h"
3252 craig 32
#include "scribusview.h"
4546 subik 33
#include "commonstrings.h"
5184 avox 34
#include "text/nlsconfig.h"
128 Franz 35
 
3646 craig 36
// We use some common routines defined in fileloader.h
37
#include "fileloader.h"
38
 
1542 cbradney 39
#include <iostream>
40
 
2688 craig 41
#include "scconfig.h"
128 Franz 42
 
3 paul 43
#ifdef HAVE_LIBZ
44
#include <zlib.h>
45
#endif
2531 craig 46
#include "util.h"
6125 cbradney 47
#include "colorutil.h"
6402 fschmid 48
#include "scpattern.h"
325 Franz 49
 
504 cbradney 50
using namespace std;
51
 
2834 cbradney 52
ScriXmlDoc::ScriXmlDoc()
53
{
54
        prefsManager=PrefsManager::instance();
55
}
56
 
5642 cbradney 57
// bool ScriXmlDoc::IsScribus(QString fileName)
58
// {
59
//      QString fText(FileLoader::readSLA(fileName));
60
//      if ((fText.isEmpty()) || (!fText.startsWith("<SCRIBUS")) || (fText.contains("<PAGE ", true) == 0))
61
//              return false;
62
//      return true;
63
// }
383 Franz 64
 
3197 fschmid 65
void ScriXmlDoc::GetItemText(QDomElement *it, ScribusDoc *doc, bool VorLFound, bool impo, PageItem* obj)
332 Franz 66
{
3197 fschmid 67
        QString tmp2, tmf, tmpf, tmp3;
517 fschmid 68
        tmp2 = it->attribute("CH");
69
        tmp2.replace(QRegExp("\r"), QChar(5));
70
        tmp2.replace(QRegExp("\n"), QChar(5));
71
        tmp2.replace(QRegExp("\t"), QChar(4));
1194 fschmid 72
        tmpf = it->attribute("CFONT", doc->toolSettings.defFont);
3197 fschmid 73
        bool unknown = false;
5980 avox 74
        ScFace dummy = ScFace::none();
75
        if ((!prefsManager->appPrefs.AvailFonts.contains(tmpf)) || (!prefsManager->appPrefs.AvailFonts[tmpf].usable()))
1428 fschmid 76
        {
3197 fschmid 77
                bool isThere = false;
5980 avox 78
                for (uint dl = 0; dl < dummyScFaces.count(); ++dl)
1428 fschmid 79
                {
5980 avox 80
                        if ((*dummyScFaces.at(dl)).scName() == tmpf)
1789 fschmid 81
                        {
3197 fschmid 82
                                isThere = true;
5980 avox 83
                                dummy = *dummyScFaces.at(dl);
3197 fschmid 84
                                break;
1789 fschmid 85
                        }
1428 fschmid 86
                }
3197 fschmid 87
                if (!isThere)
1428 fschmid 88
                {
5980 avox 89
//FIXME                 dummy = new ScFace(tmpf, "", tmpf, "", "", 1, false);
90
                        dummyScFaces.append(dummy);
1428 fschmid 91
                }
3197 fschmid 92
                unknown = true;
5980 avox 93
                if ((!prefsManager->appPrefs.GFontSub.contains(tmpf)) || (!prefsManager->appPrefs.AvailFonts[prefsManager->appPrefs.GFontSub[tmpf]].usable()))
1789 fschmid 94
                {
3197 fschmid 95
                        newReplacement = true;
96
                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.toolSettings.defFont);
1789 fschmid 97
                }
3197 fschmid 98
                else
99
                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.GFontSub[tmpf]);
1428 fschmid 100
        }
332 Franz 101
        else
1428 fschmid 102
        {
3197 fschmid 103
                if (!doc->UsedFonts.contains(tmpf))
104
                {
3544 avox 105
//                      QFont fo = prefsManager->appPrefs.AvailFonts[tmpf]->Font;
106
//                      fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
107
                        doc->AddFont(tmpf);
3197 fschmid 108
                }
1428 fschmid 109
        }
4026 craig 110
        int size = qRound(it->attribute("CSIZE").toDouble() * 10);
3197 fschmid 111
        QString fcolor = it->attribute("CCOLOR");
2382 fschmid 112
        int extra;
113
        if (it->hasAttribute("CEXTRA"))
4026 craig 114
                extra = qRound(it->attribute("CEXTRA").toDouble() / it->attribute("CSIZE").toDouble() * 1000.0);
2382 fschmid 115
        else
4026 craig 116
                extra = it->attribute("CKERN").toInt();
117
        int shade = it->attribute("CSHADE").toInt();
5184 avox 118
        int cstyle = it->attribute("CSTYLE").toInt() & 255;
4026 craig 119
        int ab = it->attribute("CAB", "0").toInt();
4546 subik 120
        QString stroke = it->attribute("CSTROKE",CommonStrings::None);
4026 craig 121
        int shade2 = it->attribute("CSHADE2", "100").toInt();
122
        int scale = qRound(it->attribute("CSCALE", "100").toDouble() * 10);
123
        int scalev = qRound(it->attribute("CSCALEV", "100").toDouble() * 10);
124
        int base = qRound(it->attribute("CBASE", "0").toDouble() * 10);
125
        int shX = qRound(it->attribute("CSHX", "5").toDouble() * 10);
126
        int shY = qRound(it->attribute("CSHY", "-5").toDouble() * 10);
127
        int outL = qRound(it->attribute("COUT", "1").toDouble() * 10);
128
        int ulp = qRound(it->attribute("CULP", "-0.1").toDouble() * 10);
129
        int ulw = qRound(it->attribute("CULW", "-0.1").toDouble() * 10);
130
        int stp = qRound(it->attribute("CSTP", "-0.1").toDouble() * 10);
131
        int stw = qRound(it->attribute("CSTW", "-0.1").toDouble() * 10);
5721 avox 132
#if 0
517 fschmid 133
        for (uint cxx=0; cxx<tmp2.length(); ++cxx)
3197 fschmid 134
        {
135
                hg = new ScText;
136
                hg->ch = tmp2.at(cxx);
137
                if (hg->ch == QChar(5))
138
                        hg->ch = QChar(13);
139
                if (hg->ch == QChar(4))
140
                        hg->ch = QChar(9);
141
                if (unknown)
5691 avox 142
                        hg->setFont(dummy);
3197 fschmid 143
                else
5691 avox 144
                        hg->setFont((*doc->AllFonts)[tmpf]);
145
                hg->setFontSize(size);
146
                hg->setFillColor(fcolor);
147
                hg->setTracking(extra);
148
                hg->setFillShade(shade);
149
                hg->setEffects(static_cast<StyleFlag>(cstyle));
3197 fschmid 150
                if (impo)
151
                {
152
                        if (VorLFound)
153
                                hg->cab = DoVorl[ab].toUInt();
154
                        else
155
                        {
156
                                if (ab < 5)
157
                                        hg->cab = ab;
158
                                else
159
                                        hg->cab = 0;
160
                        }
161
                }
162
                else
163
                        hg->cab = ab;
5691 avox 164
                hg->setStrokeColor(stroke);
165
                hg->setStrokeShade(shade2);
166
                hg->setScaleH(QMIN(QMAX(scale, 100), 4000));
167
                hg->setScaleV(QMIN(QMAX(scalev, 100), 4000));
168
                hg->setBaselineOffset(base);
169
                hg->setShadowXOffset(shX);
170
                hg->setShadowYOffset(shY);
171
                hg->setOutlineWidth(outL);
172
                hg->setUnderlineOffset(ulp);
173
                hg->setUnderlineWidth(ulw);
174
                hg->setStrikethruOffset(stp);
175
                hg->setStrikethruWidth(stw);
3197 fschmid 176
                obj->itemText.append(hg);
177
        }
5184 avox 178
#else
179
        for (uint cxx=0; cxx<tmp2.length(); ++cxx)
180
        {
181
                CharStyle style;
182
                QChar ch = tmp2.at(cxx);
183
                if (ch == QChar(5))
5721 avox 184
                        ch = SpecialChars::PARSEP;
5184 avox 185
                if (ch == QChar(4))
5721 avox 186
                        ch = SpecialChars::TAB;
5184 avox 187
                if (unknown)
5721 avox 188
                        style.setFont(dummy);
5184 avox 189
                else
5721 avox 190
                        style.setFont((*doc->AllFonts)[tmpf]);
191
                style.setFontSize(size);
192
                style.setFillColor(fcolor);
193
                style.setTracking(extra);
194
                style.setFillShade(shade);
195
                style.setEffects(static_cast<StyleFlag>(cstyle));
196
                int pstyleNr;
197
                if (impo)
5184 avox 198
                {
199
                                if (VorLFound)
5721 avox 200
                                        pstyleNr = DoVorl[ab].toUInt();
5184 avox 201
                                else
202
                                {
203
                                        if (ab < 5)
5721 avox 204
                                                pstyleNr = ab;
5184 avox 205
                                        else
5721 avox 206
                                                pstyleNr = 0;
5184 avox 207
                                }
208
                }
209
                else
5721 avox 210
                        pstyleNr = ab;
211
 
212
                style.setStrokeColor(stroke);
213
                style.setStrokeShade(shade2);
214
                style.setScaleH(QMIN(QMAX(scale, 100), 4000));
215
                style.setScaleV(QMIN(QMAX(scalev, 100), 4000));
216
                style.setBaselineOffset(base);
217
                style.setShadowXOffset(shX);
218
                style.setShadowYOffset(shY);
219
                style.setOutlineWidth(outL);
220
                style.setUnderlineOffset(ulp);
221
                style.setUnderlineWidth(ulw);
222
                style.setStrikethruOffset(stp);
223
                style.setStrikethruWidth(stw);
5184 avox 224
                int pos = obj->itemText.length();
225
                obj->itemText.insertChars(pos, QString(ch));
5721 avox 226
                if (ch == SpecialChars::PARSEP)                
227
                        obj->itemText.applyStyle(pos, doc->docParagraphStyles[pstyleNr]);
228
                else
229
                        obj->itemText.applyCharStyle(pos, 1, style);
5184 avox 230
        }
231
#endif  
3197 fschmid 232
        return;
517 fschmid 233
}
234
 
2834 cbradney 235
QString ScriXmlDoc::AskForFont(SCFonts &avail, QString fStr, ScribusDoc *doc)
517 fschmid 236
{
5642 cbradney 237
        PrefsManager *prefsManager=PrefsManager::instance();
3544 avox 238
//      QFont fo;
517 fschmid 239
        QString tmpf = fStr;
5980 avox 240
        if ((!avail.contains(tmpf)) || (!avail[tmpf].usable()))
340 Franz 241
        {
5980 avox 242
                if ((!prefsManager->appPrefs.GFontSub.contains(tmpf)) || (!avail[prefsManager->appPrefs.GFontSub[tmpf]].usable()))
340 Franz 243
                {
517 fschmid 244
                        qApp->setOverrideCursor(QCursor(arrowCursor), true);
2834 cbradney 245
                        MissingFont *dia = new MissingFont(0, tmpf, doc);
517 fschmid 246
                        dia->exec();
713 cbradney 247
                        tmpf = dia->getReplacementFont();
517 fschmid 248
                        delete dia;
249
                        qApp->setOverrideCursor(QCursor(waitCursor), true);
2834 cbradney 250
                        prefsManager->appPrefs.GFontSub[fStr] = tmpf;
340 Franz 251
                }
517 fschmid 252
                else
2834 cbradney 253
                        tmpf = prefsManager->appPrefs.GFontSub[tmpf];
1166 fschmid 254
                ReplacedFonts[fStr] = tmpf;
340 Franz 255
        }
1786 fschmid 256
        if (!doc->UsedFonts.contains(tmpf))
257
        {
3544 avox 258
//              fo = avail[tmpf]->Font;
259
//              fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
260
                doc->AddFont(tmpf);
1786 fschmid 261
        }
517 fschmid 262
        DoFonts[fStr] = tmpf;
263
        return tmpf;
332 Franz 264
}
265
 
517 fschmid 266
void ScriXmlDoc::SetItemProps(QDomElement *ob, PageItem* item, bool newFormat)
332 Franz 267
{
2881 fschmid 268
        double xf, yf;
332 Franz 269
        QString tmp, tmpy;
522 fschmid 270
        if (newFormat)
271
                ob->setAttribute("OwnPage", item->OwnPage);
1460 cbradney 272
        ob->setAttribute("PTYPE",item->itemType());
3903 cbradney 273
        ob->setAttribute("XPOS",item->xPos());
274
        ob->setAttribute("YPOS",item->yPos());
3934 cbradney 275
        ob->setAttribute("WIDTH",item->width());
276
        ob->setAttribute("HEIGHT",item->height());
3989 cbradney 277
        ob->setAttribute("RADRECT",item->cornerRadius());
332 Franz 278
        ob->setAttribute("FRTYPE", item->FrameType);
279
        ob->setAttribute("CLIPEDIT", item->ClipEdited ? 1 : 0);
4580 cbradney 280
        ob->setAttribute("PWIDTH",item->lineWidth());
1394 cbradney 281
        ob->setAttribute("PCOLOR",item->fillColor());
282
        ob->setAttribute("PCOLOR2",item->lineColor());
5559 avox 283
        ob->setAttribute("TXTFILL",item->itemText.defaultStyle().charStyle().fillColor());
284
        ob->setAttribute("TXTSTROKE",item->itemText.defaultStyle().charStyle().strokeColor());
285
        ob->setAttribute("TXTSTRSH",item->itemText.defaultStyle().charStyle().strokeShade());
286
        ob->setAttribute("TXTFILLSH",item->itemText.defaultStyle().charStyle().fillShade());
287
        ob->setAttribute("TXTSCALE",item->itemText.defaultStyle().charStyle().scaleH() / 10.0);
288
        ob->setAttribute("TXTSCALEV",item->itemText.defaultStyle().charStyle().scaleV() / 10.0);
289
        ob->setAttribute("TXTBASE",item->itemText.defaultStyle().charStyle().baselineOffset() / 10.0);
290
        ob->setAttribute("TXTSHX",item->itemText.defaultStyle().charStyle().shadowXOffset() / 10.0);
291
        ob->setAttribute("TXTSHY",item->itemText.defaultStyle().charStyle().shadowYOffset() / 10.0);
292
        ob->setAttribute("TXTOUT",item->itemText.defaultStyle().charStyle().outlineWidth() / 10.0);
293
        ob->setAttribute("TXTULP",item->itemText.defaultStyle().charStyle().underlineOffset() / 10.0);
294
        ob->setAttribute("TXTULW",item->itemText.defaultStyle().charStyle().underlineWidth() / 10.0);
295
        ob->setAttribute("TXTSTP",item->itemText.defaultStyle().charStyle().strikethruOffset() / 10.0);
296
        ob->setAttribute("TXTSTW",item->itemText.defaultStyle().charStyle().strikethruWidth() / 10.0);
297
        ob->setAttribute("TXTSTYLE",item->itemText.defaultStyle().charStyle().effects());
298
        ob->setAttribute("COLUMNS", item->columns());
299
        ob->setAttribute("COLGAP", item->columnGap());
332 Franz 300
        ob->setAttribute("NAMEDLST",item->NamedLStyle);
1394 cbradney 301
        ob->setAttribute("SHADE",item->fillShade());
302
        ob->setAttribute("SHADE2",item->lineShade());
332 Franz 303
        ob->setAttribute("GRTYP",item->GrType);
3934 cbradney 304
        ob->setAttribute("ROT",item->rotation());
332 Franz 305
        ob->setAttribute("PLINEART",item->PLineArt);
306
        ob->setAttribute("PLINEEND", item->PLineEnd);
307
        ob->setAttribute("PLINEJOIN", item->PLineJoin);
5559 avox 308
        ob->setAttribute("LINESP",item->itemText.defaultStyle().lineSpacing());
309
        ob->setAttribute("LINESPMode", item->itemText.defaultStyle().lineSpacingMode());
310
        ob->setAttribute("TXTKERN",item->itemText.defaultStyle().charStyle().tracking());
3985 cbradney 311
        ob->setAttribute("LOCALSCX",item->imageXScale());
312
        ob->setAttribute("LOCALSCY",item->imageYScale());
313
        ob->setAttribute("LOCALX",item->imageXOffset());
314
        ob->setAttribute("LOCALY",item->imageYOffset());
4492 cbradney 315
        ob->setAttribute("PICART", item->imageShown() ? 1 : 0);
332 Franz 316
        ob->setAttribute("PLTSHOW", item->PoShow ? 1 : 0);
317
        ob->setAttribute("BASEOF", item->BaseOffs);
1392 cbradney 318
        ob->setAttribute("FLIPPEDH", item->imageFlippedH());
319
        ob->setAttribute("FLIPPEDV", item->imageFlippedV());
4335 fschmid 320
/*      ob->setAttribute("BBOXX",item->BBoxX);
321
        ob->setAttribute("BBOXH",item->BBoxH); */
5980 avox 322
        ob->setAttribute("IFONT",item->itemText.defaultStyle().charStyle().font().scName());
5559 avox 323
        ob->setAttribute("ISIZE",item->itemText.defaultStyle().charStyle().fontSize() / 10.0 );
332 Franz 324
        ob->setAttribute("SCALETYPE", item->ScaleType ? 1 : 0);
325
        ob->setAttribute("RATIO", item->AspectRatio ? 1 : 0);
4698 cbradney 326
        ob->setAttribute("PRINTABLE", item->printEnabled() ? 1 : 0);
4084 cbradney 327
        if(item->isAnnotation())
332 Franz 328
        {
329
                ob->setAttribute("ANNOTATION",1);
4084 cbradney 330
                ob->setAttribute("ANTYPE", item->annotation().Type());
331
                ob->setAttribute("ANACTION", item->annotation().Action());
332
                ob->setAttribute("ANEACT", item->annotation().E_act());
333
                ob->setAttribute("ANXACT", item->annotation().X_act());
334
                ob->setAttribute("ANDACT", item->annotation().D_act());
335
                ob->setAttribute("ANFOACT", item->annotation().Fo_act());
336
                ob->setAttribute("ANBLACT", item->annotation().Bl_act());
337
                ob->setAttribute("ANKACT", item->annotation().K_act());
338
                ob->setAttribute("ANFACT", item->annotation().F_act());
339
                ob->setAttribute("ANVACT", item->annotation().V_act());
340
                ob->setAttribute("ANCACT", item->annotation().C_act());
341
                if (item->annotation().ActionType() == 8)
342
                        ob->setAttribute("ANEXTERN", item->annotation().Extern());
332 Franz 343
                else
4084 cbradney 344
                        ob->setAttribute("ANEXTERN", Path2Relative(item->annotation().Extern()));
345
                ob->setAttribute("ANZIEL", item->annotation().Ziel());
346
                ob->setAttribute("ANACTYP", item->annotation().ActionType());
347
                ob->setAttribute("ANTOOLTIP", item->annotation().ToolTip());
348
                ob->setAttribute("ANBWID", item->annotation().Bwid());
349
                ob->setAttribute("ANBSTY", item->annotation().Bsty());
350
                ob->setAttribute("ANFEED", item->annotation().Feed());
351
                ob->setAttribute("ANFLAG", item->annotation().Flag());
352
                ob->setAttribute("ANFONT", item->annotation().Font());
353
                ob->setAttribute("ANFORMAT", item->annotation().Format());
354
                ob->setAttribute("ANROLL", item->annotation().RollOver());
355
                ob->setAttribute("ANDOWN", item->annotation().Down());
356
                ob->setAttribute("ANVIS", item->annotation().Vis());
357
                ob->setAttribute("ANMC", item->annotation().MaxChar());
358
                ob->setAttribute("ANCHK", item->annotation().IsChk());
359
                ob->setAttribute("ANAA", item->annotation().AAact());
360
                ob->setAttribute("ANCHKS", item->annotation().ChkStil());
361
                ob->setAttribute("ANBCOL", item->annotation().borderColor());
362
                ob->setAttribute("ANHTML", item->annotation().HTML());
363
                ob->setAttribute("ANICON", item->annotation().UseIcons());
364
                ob->setAttribute("ANPLACE", item->annotation().IPlace());
365
                ob->setAttribute("ANSCALE", item->annotation().ScaleW());
332 Franz 366
        }
367
        else
368
                ob->setAttribute("ANNOTATION",0);
1361 tsoots 369
        ob->setAttribute("ANNAME", !item->AutoName ? item->itemName() : QString(""));
5620 jghali 370
        // "TEXTFLOWMODE" succeed to "TEXTFLOW" "TEXTFLOW2" and "TEXTFLOW3" attributes
371
        ob->setAttribute("TEXTFLOWMODE", (int) item->textFlowMode() );
372
        // Set "TEXTFLOW" "TEXTFLOW2" and "TEXTFLOW3" attributes for compatibility
373
        // with versions prior to 1.3.4
374
        ob->setAttribute("TEXTFLOW" , item->textFlowAroundObject() ? 1 : 0);
1653 craig 375
        ob->setAttribute("TEXTFLOW2", item->textFlowUsesBoundingBox() ? 1 : 0);
1656 craig 376
        ob->setAttribute("TEXTFLOW3", item->textFlowUsesContourLine() ? 1 : 0);
332 Franz 377
        ob->setAttribute("AUTOTEXT", item->isAutoText ? 1 : 0);
3988 cbradney 378
        ob->setAttribute("EXTRA",item->textToFrameDistLeft());
379
        ob->setAttribute("TEXTRA",item->textToFrameDistTop());
380
        ob->setAttribute("BEXTRA",item->textToFrameDistBottom());
381
        ob->setAttribute("REXTRA",item->textToFrameDistRight());
3625 avox 382
        if (((item->asImageFrame()) || (item->asTextFrame())) && (!item->Pfile.isEmpty()))
332 Franz 383
                ob->setAttribute("PFILE",Path2Relative(item->Pfile));
384
        else
385
                ob->setAttribute("PFILE","");
2877 cbradney 386
        if (!item->Pfile2.isEmpty())
332 Franz 387
                ob->setAttribute("PFILE2",Path2Relative(item->Pfile2));
388
        else
389
                ob->setAttribute("PFILE2","");
2877 cbradney 390
        if (!item->Pfile3.isEmpty())
332 Franz 391
                ob->setAttribute("PFILE3",Path2Relative(item->Pfile3));
392
        else
393
                ob->setAttribute("PFILE3","");
394
        ob->setAttribute("PRFILE",item->IProfile);
395
        ob->setAttribute("EPROF", item->EmProfile);
396
        ob->setAttribute("IRENDER",item->IRender);
397
        ob->setAttribute("EMBEDDED", item->UseEmbedded ? 1 : 0);
1392 cbradney 398
        ob->setAttribute("LOCK", item->locked() ? 1 : 0);
399
        ob->setAttribute("LOCKR", item->sizeLocked() ? 1 : 0);
3988 cbradney 400
        ob->setAttribute("REVERS", item->reversed() ? 1 : 0);
1394 cbradney 401
        ob->setAttribute("TransValue", item->fillTransparency());
402
        ob->setAttribute("TransValueS", item->lineTransparency());
5746 fschmid 403
        ob->setAttribute("TransBlend", item->fillBlendmode());
404
        ob->setAttribute("TransBlendS", item->lineBlendmode());
332 Franz 405
        ob->setAttribute("isTableItem", static_cast<int>(item->isTableItem));
406
        ob->setAttribute("TopLine", static_cast<int>(item->TopLine));
407
        ob->setAttribute("LeftLine", static_cast<int>(item->LeftLine));
408
        ob->setAttribute("RightLine", static_cast<int>(item->RightLine));
409
        ob->setAttribute("BottomLine", static_cast<int>(item->BottomLine));
410
        if (item->isTableItem)
411
        {
412
                if (item->TopLink != 0)
413
                        ob->setAttribute("TopLINK", item->TopLink->ItemNr);
414
                else
415
                        ob->setAttribute("TopLINK", -1);
416
                if (item->LeftLink != 0)
417
                        ob->setAttribute("LeftLINK", item->LeftLink->ItemNr);
418
                else
419
                        ob->setAttribute("LeftLINK", -1);
420
                if (item->RightLink != 0)
421
                        ob->setAttribute("RightLINK", item->RightLink->ItemNr);
422
                else
423
                        ob->setAttribute("RightLINK", -1);
424
                if (item->BottomLink != 0)
425
                        ob->setAttribute("BottomLINK", item->BottomLink->ItemNr);
426
                else
427
                        ob->setAttribute("BottomLINK", -1);
428
                ob->setAttribute("OwnLINK", item->ItemNr);
429
        }
430
        ob->setAttribute("NUMDASH", static_cast<int>(item->DashValues.count()));
431
        QString dlp = "";
432
        QValueList<double>::Iterator dax;
433
        for (dax = item->DashValues.begin(); dax != item->DashValues.end(); ++dax)
434
                dlp += tmp.setNum((*dax)) + " ";
435
        ob->setAttribute("DASHS", dlp);
436
        ob->setAttribute("DASHOFF", item->DashOffset);
437
        ob->setAttribute("NUMPO",item->PoLine.size());
438
        QString polp = "";
439
        for (uint nxx=0; nxx<item->PoLine.size(); ++nxx)
440
        {
441
                item->PoLine.point(nxx, &xf, &yf);
442
                polp += tmp.setNum(xf) + " " + tmpy.setNum(yf) + " ";
443
        }
444
        ob->setAttribute("POCOOR", polp);
340 Franz 445
        ob->setAttribute("NUMCO",item->ContourLine.size());
446
        QString colp = "";
447
        for (uint nxx=0; nxx<item->ContourLine.size(); ++nxx)
448
        {
449
                item->ContourLine.point(nxx, &xf, &yf);
450
                colp += tmp.setNum(xf) + " " + tmpy.setNum(yf) + " ";
451
        }
452
        ob->setAttribute("COCOOR", colp);
332 Franz 453
        ob->setAttribute("NUMGROUP", static_cast<int>(item->Groups.count()));
454
        QString glp = "";
455
        QValueStack<int>::Iterator nx;
456
        for (nx = item->Groups.begin(); nx != item->Groups.end(); ++nx)
457
                glp += tmp.setNum((*nx)) + " ";
458
        ob->setAttribute("GROUPS", glp);
5559 avox 459
        ob->setAttribute("LANGUAGE", item->itemText.defaultStyle().charStyle().language());
4061 craig 460
        ob->setAttribute("startArrowIndex", item->startArrowIndex());
461
        ob->setAttribute("endArrowIndex", item->endArrowIndex());
332 Franz 462
}
463
 
5643 cbradney 464
//CB: Private only now
5980 avox 465
void ScriXmlDoc::GetStyle(QDomElement *pg, ParagraphStyle *vg, StyleSet<ParagraphStyle> &docParagraphStyles, ScribusDoc* doc, bool fl)
332 Franz 466
{
467
        bool fou;
468
        QString tmpf, tmf, tmV;
2282 fschmid 469
        double xf, xf2;
332 Franz 470
        fou = false;
5184 avox 471
        vg->setName(pg->attribute("NAME"));
472
        vg->setLineSpacingMode(static_cast<ParagraphStyle::LineSpacingMode>(pg->attribute("LINESPMode", "0").toInt()));
473
        vg->setLineSpacing(pg->attribute("LINESP").toDouble());
474
        vg->setLeftMargin(pg->attribute("INDENT", "0").toDouble());
475
        vg->setFirstIndent(pg->attribute("FIRST", "0").toDouble());
476
        vg->setAlignment(pg->attribute("ALIGN").toInt());
477
        vg->setGapBefore(pg->attribute("VOR", "0").toDouble());
478
        vg->setGapAfter(pg->attribute("NACH", "0").toDouble());
1194 fschmid 479
        tmpf = pg->attribute("FONT", doc->toolSettings.defFont);
2877 cbradney 480
        if (tmpf.isEmpty())
1194 fschmid 481
                tmpf = doc->toolSettings.defFont;
332 Franz 482
        tmf = tmpf;
483
        if (!DoFonts.contains(tmpf))
2834 cbradney 484
                tmpf = AskForFont(prefsManager->appPrefs.AvailFonts, tmpf, doc);
332 Franz 485
        else
486
                tmpf = DoFonts[tmf];
5691 avox 487
        vg->charStyle().setFont(prefsManager->appPrefs.AvailFonts[tmpf]);
488
        vg->charStyle().setFontSize(qRound(pg->attribute("FONTSIZE", "12").toDouble() * 10.0));
5184 avox 489
        vg->setHasDropCap(static_cast<bool>(pg->attribute("DROP", "0").toInt()));
490
        vg->setDropCapLines(pg->attribute("DROPLIN", "2").toInt());
491
        vg->setDropCapOffset(pg->attribute("DROPDIST", "0").toDouble());
5691 avox 492
        vg->charStyle().setEffects(static_cast<StyleFlag>(pg->attribute("EFFECT", "0").toInt()));
493
        vg->charStyle().setFillColor(pg->attribute("FCOLOR", doc->toolSettings.dBrush));
494
        vg->charStyle().setFillShade(pg->attribute("FSHADE", "100").toInt());
495
        vg->charStyle().setStrokeColor(pg->attribute("SCOLOR", doc->toolSettings.dPen));
496
        vg->charStyle().setStrokeShade(pg->attribute("SSHADE", "100").toInt());
5184 avox 497
        vg->setUseBaselineGrid(static_cast<bool>(pg->attribute("BASE", "0").toInt()));
5691 avox 498
        vg->charStyle().setShadowXOffset(qRound(pg->attribute("TXTSHX", "5").toDouble() * 10));
499
        vg->charStyle().setShadowYOffset(qRound(pg->attribute("TXTSHY", "-5").toDouble() * 10));
500
        vg->charStyle().setOutlineWidth(qRound(pg->attribute("TXTOUT", "1").toDouble() * 10));
501
        vg->charStyle().setUnderlineOffset(qRound(pg->attribute("TXTULP", "-0.1").toDouble() * 10));
502
        vg->charStyle().setUnderlineWidth(qRound(pg->attribute("TXTULW", "-0.1").toDouble() * 10));
503
        vg->charStyle().setStrikethruOffset(qRound(pg->attribute("TXTSTP", "-0.1").toDouble() * 10));
504
        vg->charStyle().setStrikethruWidth(qRound(pg->attribute("TXTSTW", "-0.1").toDouble() * 10));
505
        vg->charStyle().setScaleH(qRound(pg->attribute("SCALEH", "100").toDouble() * 10));
506
        vg->charStyle().setScaleV(qRound(pg->attribute("SCALEV", "100").toDouble() * 10));
507
        vg->charStyle().setBaselineOffset(qRound(pg->attribute("BASEO", "0").toDouble() * 10));
508
        vg->charStyle().setTracking(qRound(pg->attribute("KERN", "0").toDouble() * 10));
5184 avox 509
        vg->tabValues().clear();
4026 craig 510
        if ((pg->hasAttribute("NUMTAB")) && (pg->attribute("NUMTAB", "0").toInt() != 0))
332 Franz 511
        {
5184 avox 512
                ParagraphStyle::TabRecord tb;
332 Franz 513
                QString tmp = pg->attribute("TABS");
514
                QTextStream tgv(&tmp, IO_ReadOnly);
5184 avox 515
                vg->tabValues().clear();
4026 craig 516
                for (int cxv = 0; cxv < pg->attribute("NUMTAB", "0").toInt(); cxv += 2)
332 Franz 517
                {
518
                        tgv >> xf;
2282 fschmid 519
                        tgv >> xf2;
520
                        tb.tabPosition = xf2;
521
                        tb.tabType = static_cast<int>(xf);
522
                        tb.tabFillChar = QChar();
5184 avox 523
                        vg->tabValues().append(tb);
332 Franz 524
                }
525
                tmp = "";
526
        }
527
        else
2282 fschmid 528
        {
529
                QDomNode IT = pg->firstChild();
530
                while(!IT.isNull())
531
                {
532
                        QDomElement it = IT.toElement();
533
                        if (it.tagName()=="Tabs")
534
                        {
5184 avox 535
                                ParagraphStyle::TabRecord tb;
4026 craig 536
                                tb.tabPosition = it.attribute("Pos").toDouble();
537
                                tb.tabType = it.attribute("Type").toInt();
2282 fschmid 538
                                QString tbCh = "";
539
                                tbCh = it.attribute("Fill","");
2877 cbradney 540
                                if (tbCh.isEmpty())
2282 fschmid 541
                                        tb.tabFillChar = QChar();
542
                                else
543
                                        tb.tabFillChar = tbCh[0];
5184 avox 544
                                vg->tabValues().append(tb);
2282 fschmid 545
                        }
546
                        IT=IT.nextSibling();
547
                }
548
        }
1065 cbradney 549
        for (uint xx=0; xx<docParagraphStyles.count(); ++xx)
332 Franz 550
        {
5184 avox 551
                if (vg->name() == docParagraphStyles[xx].name())
332 Franz 552
                {
4097 cbradney 553
                        //Compare the attributes of the pasted styles vs existing ones
5184 avox 554
                        if (vg->equiv(docParagraphStyles[xx]))
335 Franz 555
                        {
556
                                if (fl)
557
                                {
558
                                        DoVorl[VorlC] = tmV.setNum(xx);
559
                                        VorlC++;
560
                                }
332 Franz 561
                                fou = true;
335 Franz 562
                        }
332 Franz 563
                        else
564
                        {
5184 avox 565
                                vg->setName("Copy of "+docParagraphStyles[xx].name());
332 Franz 566
                                fou = false;
567
                        }
568
                        break;
569
                }
570
        }
571
        if (!fou)
572
        {
1065 cbradney 573
                for (uint xx=0; xx< docParagraphStyles.count(); ++xx)
332 Franz 574
                {
5184 avox 575
                        if (vg->equiv(docParagraphStyles[xx]))
2282 fschmid 576
                        {
5184 avox 577
                                vg->setName(docParagraphStyles[xx].name());
332 Franz 578
                                fou = true;
579
                                if (fl)
580
                                {
581
                                        DoVorl[VorlC] = tmV.setNum(xx);
582
                                        VorlC++;
583
                                }
584
                                break;
585
                        }
586
                }
587
        }
588
        if (!fou)
589
        {
5980 avox 590
                docParagraphStyles.append(vg);
332 Franz 591
                if (fl)
592
                {
1065 cbradney 593
                        DoVorl[VorlC] = tmV.setNum(docParagraphStyles.count()-1);
332 Franz 594
                        VorlC++;
595
                }
596
        }
597
}
598
 
80 Franz 599
bool ScriXmlDoc::ReadElemHeader(QString file, bool isFile, double *x, double *y, double *w, double *h)
3 paul 600
{
6028 jghali 601
        QString ff = "";
3 paul 602
        QDomDocument docu("scridoc");
603
        if (isFile)
167 Franz 604
        {
6013 jghali 605
                QCString f;
606
                if (!loadRawText(file, f))
3 paul 607
                        return false;
6062 jghali 608
                if (f.left(16) == "<SCRIBUSELEMUTF8")
6013 jghali 609
                        ff = QString::fromUtf8(f.data());
3 paul 610
                else
611
                        ff = f;
167 Franz 612
        }
3 paul 613
        else
167 Franz 614
        {
6028 jghali 615
                // JG Ugly and wrong conversion from an utf8 encoded array
616
                // to a QString using local enconding
617
                /*if (file.startsWith("<SCRIBUSELEMUTF8"))
3 paul 618
                        ff = QString::fromUtf8(file);
619
                else
6028 jghali 620
                        ff = file;*/
621
                ff  = file;
167 Franz 622
        }
6028 jghali 623
        if(!docu.setContent(ff))
624
                return false;
3 paul 625
        QDomElement elem=docu.documentElement();
626
        if ((elem.tagName() != "SCRIBUSELEM") && (elem.tagName() != "SCRIBUSELEMUTF8"))
627
                return false;
4026 craig 628
        *x = elem.attribute("XP").toDouble();
629
        *y = elem.attribute("YP").toDouble();
630
        *w = elem.attribute("W", "0").toDouble();
631
        *h = elem.attribute("H", "0").toDouble();
3 paul 632
        return true;
633
}
634
 
3743 fschmid 635
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 636
{
6062 jghali 637
        QString ff = "";
1065 cbradney 638
        struct CopyPasteBuffer OB;
5184 avox 639
        ParagraphStyle vg;
6013 jghali 640
        QString tmp, tmpf, tmp2, tmp3, tmp4, tmV, tmf;
28 Franz 641
        QMap<QString,QString> DoMul;
234 Franz 642
        QMap<int,int> TableID;
741 fschmid 643
        QMap<int,int> arrowID;
234 Franz 644
        QPtrList<PageItem> TableItems;
3 paul 645
        bool VorLFound = false;
68 Franz 646
        bool newVersion = false;
332 Franz 647
        int x;
648
        double GrX, GrY;
3 paul 649
        int GrMax = doc->GroupCounter;
2886 fschmid 650
        ScColor lf = ScColor();
3 paul 651
        QDomDocument docu("scridoc");
652
        if (Fi)
167 Franz 653
        {
6013 jghali 654
                QCString f;
655
                if (!loadRawText(fileName, f))
3 paul 656
                        return false;
6062 jghali 657
                if (f.left(16) == "<SCRIBUSELEMUTF8")
6013 jghali 658
                        ff = QString::fromUtf8(f.data());
3 paul 659
                else
660
                        ff = f;
167 Franz 661
        }
3 paul 662
        else
167 Franz 663
        {
6062 jghali 664
                ff = fileName;
167 Franz 665
        }
6062 jghali 666
        if(!docu.setContent(ff))
667
                return false;
3 paul 668
        QDomElement elem=docu.documentElement();
669
        if ((elem.tagName() != "SCRIBUSELEM") && (elem.tagName() != "SCRIBUSELEMUTF8"))
670
                return false;
671
        if (loc)
167 Franz 672
        {
3743 fschmid 673
                GrX = 0.0;
674
                GrY = 0.0;
167 Franz 675
        }
3 paul 676
        else
167 Franz 677
        {
4026 craig 678
                GrX = elem.attribute("XP").toDouble();
679
                GrY = elem.attribute("YP").toDouble();
167 Franz 680
        }
68 Franz 681
        if (elem.hasAttribute("Version"))
682
                newVersion = true;
3 paul 683
        QDomNode DOC=elem.firstChild();
684
        DoFonts.clear();
1194 fschmid 685
        DoFonts[doc->toolSettings.defFont] = doc->toolSettings.defFont;
3 paul 686
        DoVorl.clear();
113 Franz 687
        DoVorl[0] = "0";
688
        DoVorl[1] = "1";
689
        DoVorl[2] = "2";
690
        DoVorl[3] = "3";
691
        DoVorl[4] = "4";
3 paul 692
        VorlC = 5;
234 Franz 693
        TableItems.clear();
694
        TableID.clear();
741 fschmid 695
        arrowID.clear();
63 Franz 696
        QString CurDirP = QDir::currentDirPath();
282 Franz 697
        QDir::setCurrent(QDir::homeDirPath());
741 fschmid 698
        int startNumArrows = doc->arrowStyles.count();
3 paul 699
        while(!DOC.isNull())
167 Franz 700
        {
3 paul 701
                QDomElement pg=DOC.toElement();
741 fschmid 702
                if(pg.tagName()=="Arrows")
703
                {
4026 craig 704
                        if (pg.attribute("Index").toInt() > startNumArrows)
741 fschmid 705
                        {
1065 cbradney 706
                                struct ArrowDesc arrow;
741 fschmid 707
                                double xa, ya;
760 fschmid 708
                                arrow.name = pg.attribute("Name");
776 fschmid 709
                                arrow.userArrow = true;
741 fschmid 710
                                QString tmp = pg.attribute("Points");
711
                                QTextStream fp(&tmp, IO_ReadOnly);
712
                                for (uint cx = 0; cx < pg.attribute("NumPoints").toUInt(); ++cx)
713
                                {
714
                                        fp >> xa;
715
                                        fp >> ya;
760 fschmid 716
                                        arrow.points.addPoint(xa, ya);
741 fschmid 717
                                }
718
                                doc->arrowStyles.append(arrow);
4026 craig 719
                                arrowID.insert(pg.attribute("Index").toInt(), doc->arrowStyles.count());
741 fschmid 720
                        }
721
                        else
4026 craig 722
                                arrowID.insert(pg.attribute("Index").toInt(), pg.attribute("Index").toInt());
741 fschmid 723
                }
3 paul 724
                if(pg.tagName()=="FONT")
167 Franz 725
                {
3 paul 726
                        tmpf = pg.attribute("NAME");
5980 avox 727
                        if ((!avail.contains(tmpf)) || (!avail[tmpf].usable()))
167 Franz 728
                        {
5980 avox 729
                                if (!FontSub.contains(tmpf) || (!avail[FontSub[tmpf]].usable()))
3 paul 730
                                {
2834 cbradney 731
                                        MissingFont *dia = new MissingFont(0, tmpf, doc);
3 paul 732
                                        dia->exec();
713 cbradney 733
                                        tmpf = dia->getReplacementFont();
3 paul 734
                                        FontSub[pg.attribute("NAME")] = tmpf;
735
                                        delete dia;
167 Franz 736
                                }
3 paul 737
                                else
738
                                        tmpf = FontSub[tmpf];
167 Franz 739
                        }
3544 avox 740
//                      fo = avail[tmpf]->Font;
741
//                      fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
3 paul 742
                        if(!doc->UsedFonts.contains(tmpf))
3544 avox 743
                                doc->AddFont(tmpf);
3 paul 744
                        DoFonts[pg.attribute("NAME")] = tmpf;
167 Franz 745
                }
516 fschmid 746
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
4546 subik 747
                if(pg.tagName()=="COLOR" && pg.attribute("Name")!=CommonStrings::None)
167 Franz 748
                {
5880 jghali 749
                        lf.setDocument(doc);
28 Franz 750
                        if (pg.hasAttribute("CMYK"))
751
                                lf.setNamedColor(pg.attribute("CMYK"));
752
                        else
753
                                lf.fromQColor(QColor(pg.attribute("RGB")));
3051 fschmid 754
                        if (pg.hasAttribute("Spot"))
4618 fschmid 755
                                lf.setSpotColor(static_cast<bool>(pg.attribute("Spot").toInt()));
3051 fschmid 756
                        else
757
                                lf.setSpotColor(false);
4618 fschmid 758
                        if (pg.hasAttribute("Register"))
759
                                lf.setRegistrationColor(static_cast<bool>(pg.attribute("Register").toInt()));
760
                        else
761
                                lf.setRegistrationColor(false);
3 paul 762
                        if (!doc->PageColors.contains(pg.attribute("NAME")))
167 Franz 763
                                doc->PageColors[pg.attribute("NAME")] = lf;
764
                }
28 Franz 765
                if(pg.tagName()=="MultiLine")
167 Franz 766
                {
28 Franz 767
                        multiLine ml;
768
                        QDomNode MuLn = DOC.firstChild();
769
                        while(!MuLn.isNull())
167 Franz 770
                        {
28 Franz 771
                                QDomElement MuL = MuLn.toElement();
1065 cbradney 772
                                struct SingleLine sl;
28 Franz 773
                                sl.Color = MuL.attribute("Color");
4026 craig 774
                                sl.Dash = MuL.attribute("Dash").toInt();
775
                                sl.LineEnd = MuL.attribute("LineEnd").toInt();
776
                                sl.LineJoin = MuL.attribute("LineJoin").toInt();
777
                                sl.Shade = MuL.attribute("Shade").toInt();
778
                                sl.Width = MuL.attribute("Width").toDouble();
33 Franz 779
                                ml.push_back(sl);
28 Franz 780
                                MuLn = MuLn.nextSibling();
167 Franz 781
                        }
28 Franz 782
                        if (!doc->MLineStyles.contains(pg.attribute("Name")))
783
                                doc->MLineStyles.insert(pg.attribute("Name"), ml);
167 Franz 784
                }
3 paul 785
                if(pg.tagName()=="STYLE")
167 Franz 786
                {
2834 cbradney 787
                        GetStyle(&pg, &vg, doc->docParagraphStyles, doc, true);
3 paul 788
                        VorLFound = true;
167 Franz 789
                }
6402 fschmid 790
                if(pg.tagName()=="Pattern")
791
                {
792
                        ScPattern pat;
793
                        QDomNode pa = DOC.firstChild();
794
                        uint ac = doc->Items->count();
795
                        bool savedAlignGrid = doc->useRaster;
796
                        bool savedAlignGuides = doc->SnapGuides;
797
                        doc->useRaster = false;
798
                        doc->SnapGuides = false;
799
                        while(!pa.isNull())
800
                        {
801
                                QDomElement pite = pa.toElement();
802
                                GetItemProps(newVersion, &pite, &OB);
803
                                OB.Xpos = pite.attribute("XPOS").toDouble() + doc->currentPage()->xOffset();
804
                                OB.Ypos = pite.attribute("YPOS").toDouble() + doc->currentPage()->yOffset();
805
                                OB.startArrowIndex =  arrowID[pite.attribute("startArrowIndex", "0").toInt()];
806
                                OB.endArrowIndex =  arrowID[pite.attribute("endArrowIndex", "0").toInt()];
807
                                OB.isBookmark=pite.attribute("BOOKMARK").toInt();
808
                                OB.NamedLStyle = pite.attribute("NAMEDLST", "");
809
                                if (!doc->MLineStyles.contains(OB.NamedLStyle))
810
                                        OB.NamedLStyle = "";
811
                                OB.textAlignment = DoVorl[pite.attribute("ALIGN", "0").toInt()].toUInt();
812
                                tmf = pite.attribute("IFONT", doc->toolSettings.defFont);
813
                                if (tmf.isEmpty())
814
                                        tmf = doc->toolSettings.defFont;
815
                                if (DoFonts[tmf].isEmpty())
816
                                        OB.IFont = doc->toolSettings.defFont;
817
                                else
818
                                        OB.IFont = DoFonts[tmf];
819
                                OB.LayerNr = 0;
820
                                OB.Language = pite.attribute("LANGUAGE", doc->Language);
821
                                tmp = "";
822
                                if ((pite.hasAttribute("GROUPS")) && (pite.attribute("NUMGROUP", "0").toInt() != 0))
823
                                {
824
                                        tmp = pite.attribute("GROUPS");
825
                                        QTextStream fg(&tmp, IO_ReadOnly);
826
                                        OB.Groups.clear();
827
                                        for (int cx = 0; cx < pite.attribute("NUMGROUP", "0").toInt(); ++cx)
828
                                        {
829
                                                fg >> x;
830
                                                OB.Groups.push(x+doc->GroupCounter);
831
                                                GrMax = QMAX(GrMax, x+doc->GroupCounter);
832
                                        }
833
                                        tmp = "";
834
                                }
835
                                else
836
                                        OB.Groups.clear();
837
                                tmp = "";
838
                                QDomNode IT=pite.firstChild();
839
                                while(!IT.isNull())
840
                                {
841
                                        QDomElement it=IT.toElement();
842
                                        if (it.tagName()=="CSTOP")
843
                                        {
844
                                                QString name = it.attribute("NAME");
845
                                                double ramp = it.attribute("RAMP", "0.0").toDouble();
846
                                                int shade = it.attribute("SHADE", "100").toInt();
847
                                                double opa = it.attribute("TRANS", "1").toDouble();
848
                                                OB.fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
849
                                                OB.GrColor = "";
850
                                                OB.GrColor2 = "";
851
                                        }
852
                                        if (it.tagName()=="Tabs")
853
                                        {
854
                                                ParagraphStyle::TabRecord tb;
855
                                                tb.tabPosition = it.attribute("Pos").toDouble();
856
                                                tb.tabType = it.attribute("Type").toInt();
857
                                                QString tbCh = "";
858
                                                tbCh = it.attribute("Fill","");
859
                                                if (tbCh.isEmpty())
860
                                                        tb.tabFillChar = QChar();
861
                                                else
862
                                                        tb.tabFillChar = tbCh[0];
863
                                                OB.TabValues.append(tb);
864
                                        }
865
                                        IT=IT.nextSibling();
866
                                }
867
                                OB.itemText = "";
868
                                OB.LayerNr = -1;
869
                                view->PasteItem(&OB, true, true);
870
                                PageItem* Neu = doc->Items->at(doc->Items->count()-1);
871
                                Neu->setXYPos(Neu->xPos() - doc->currentPage()->xOffset(), Neu->yPos() - doc->currentPage()->yOffset(), true);
872
                                IT=pite.firstChild();
873
                                while(!IT.isNull())
874
                                {
875
                                        QDomElement it=IT.toElement();
876
                                        if (it.tagName()=="ITEXT")
877
                                                GetItemText(&it, doc, VorLFound, true, Neu);
878
                                        if (it.tagName()=="ImageEffect")
879
                                        {
880
                                                struct ScImage::imageEffect ef;
881
                                                ef.effectParameters = it.attribute("Param");
882
                                                ef.effectCode = it.attribute("Code").toInt();
883
                                                Neu->effectsInUse.append(ef);
884
                                        }
885
                                        if (it.tagName() == "PSDLayer")
886
                                        {
887
                                                struct ImageLoadRequest loadingInfo;
888
                                                loadingInfo.blend = it.attribute("Blend");
889
                                                loadingInfo.opacity = it.attribute("Opacity").toInt();
890
                                                loadingInfo.visible = static_cast<bool>(it.attribute("Visible").toInt());
891
                                                loadingInfo.useMask = static_cast<bool>(it.attribute("useMask", "1").toInt());
892
                                                Neu->pixm.imgInfo.RequestProps.insert(it.attribute("Layer").toInt(), loadingInfo);
893
                                                Neu->pixm.imgInfo.isRequest = true;
894
                                        }
895
                                        IT=IT.nextSibling();
896
                                }
897
                                if ((Neu->effectsInUse.count() != 0) || (Neu->pixm.imgInfo.RequestProps.count() != 0))
898
                                        doc->LoadPict(Neu->Pfile, Neu->ItemNr, true);
899
                                if (Neu->isTableItem)
900
                                {
901
                                        TableItems.append(Neu);
902
                                        TableID.insert(pite.attribute("OwnLINK", "0").toInt(), Neu->ItemNr);
903
                                }
904
                                if (Neu->asPathText())
905
                                        Neu->updatePolyClip();
906
                                pa = pa.nextSibling();
907
                        }
908
                        doc->useRaster = savedAlignGrid;
909
                        doc->SnapGuides = savedAlignGuides;
910
                        uint ae = doc->Items->count();
911
                        pat.setDoc(doc);
912
                        PageItem* currItem = doc->Items->at(ac);
913
                        pat.pattern = currItem->DrawObj_toImage();
914
                        for (uint as = ac; as < ae; ++as)
915
                        {
916
                                PageItem* Neu = doc->Items->take(ac);
917
                                Neu->ItemNr = pat.items.count();
918
                                pat.items.append(Neu);
919
                        }
920
                        pat.offsetX = pg.attribute("offsetX", "0").toDouble();
921
                        pat.offsetY = pg.attribute("offsetY", "0").toDouble();
922
                        pat.scaleX = pg.attribute("scaleX", "0").toDouble();
923
                        pat.scaleY = pg.attribute("scaleY", "0").toDouble();
924
                        pat.rotation = pg.attribute("rotation", "0").toDouble();
925
                        pat.width = pg.attribute("width", "0").toDouble();
926
                        pat.height = pg.attribute("height", "0").toDouble();
927
                        doc->docPatterns.insert(pg.attribute("Name"), pat);
928
                }
3 paul 929
                DOC=DOC.nextSibling();
167 Franz 930
        }
3 paul 931
        DOC=elem.firstChild();
932
        while(!DOC.isNull())
167 Franz 933
        {
3 paul 934
                QDomElement pg=DOC.toElement();
935
                if(pg.tagName()=="ITEM")
167 Franz 936
                {
332 Franz 937
                        GetItemProps(newVersion, &pg, &OB);
4026 craig 938
                        OB.Xpos = Xp + pg.attribute("XPOS").toDouble() - GrX;
939
                        OB.Ypos = Yp + pg.attribute("YPOS").toDouble() - GrY;
940
                        OB.startArrowIndex =  arrowID[pg.attribute("startArrowIndex", "0").toInt()];
941
                        OB.endArrowIndex =  arrowID[pg.attribute("endArrowIndex", "0").toInt()];
942
                        OB.isBookmark=pg.attribute("BOOKMARK").toInt();
27 Franz 943
                        OB.NamedLStyle = pg.attribute("NAMEDLST", "");
944
                        if (!doc->MLineStyles.contains(OB.NamedLStyle))
945
                                OB.NamedLStyle = "";
4026 craig 946
                        OB.textAlignment = DoVorl[pg.attribute("ALIGN", "0").toInt()].toUInt();
1194 fschmid 947
                        tmf = pg.attribute("IFONT", doc->toolSettings.defFont);
2877 cbradney 948
                        if (tmf.isEmpty())
1194 fschmid 949
                                tmf = doc->toolSettings.defFont;
2877 cbradney 950
                        if (DoFonts[tmf].isEmpty())
1194 fschmid 951
                                OB.IFont = doc->toolSettings.defFont;
323 Franz 952
                        else
953
                                OB.IFont = DoFonts[tmf];
332 Franz 954
                        OB.LayerNr = 0;
75 Franz 955
                        OB.Language = pg.attribute("LANGUAGE", doc->Language);
3 paul 956
                        tmp = "";
4026 craig 957
                        if ((pg.hasAttribute("GROUPS")) && (pg.attribute("NUMGROUP", "0").toInt() != 0))
167 Franz 958
                        {
3 paul 959
                                tmp = pg.attribute("GROUPS");
960
                                QTextStream fg(&tmp, IO_ReadOnly);
961
                                OB.Groups.clear();
4026 craig 962
                                for (int cx = 0; cx < pg.attribute("NUMGROUP", "0").toInt(); ++cx)
167 Franz 963
                                {
3 paul 964
                                        fg >> x;
965
                                        OB.Groups.push(x+doc->GroupCounter);
966
                                        GrMax = QMAX(GrMax, x+doc->GroupCounter);
167 Franz 967
                                }
3 paul 968
                                tmp = "";
167 Franz 969
                        }
3 paul 970
                        else
971
                                OB.Groups.clear();
972
                        tmp = "";
973
                        QDomNode IT=DOC.firstChild();
974
                        while(!IT.isNull())
167 Franz 975
                        {
3 paul 976
                                QDomElement it=IT.toElement();
295 Franz 977
                                if (it.tagName()=="CSTOP")
978
                                {
979
                                        QString name = it.attribute("NAME");
4026 craig 980
                                        double ramp = it.attribute("RAMP", "0.0").toDouble();
981
                                        int shade = it.attribute("SHADE", "100").toInt();
982
                                        double opa = it.attribute("TRANS", "1").toDouble();
690 cbradney 983
                                        OB.fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
2180 fschmid 984
                                        OB.GrColor = "";
985
                                        OB.GrColor2 = "";
295 Franz 986
                                }
2282 fschmid 987
                                if (it.tagName()=="Tabs")
988
                                {
5184 avox 989
                                        ParagraphStyle::TabRecord tb;
4026 craig 990
                                        tb.tabPosition = it.attribute("Pos").toDouble();
991
                                        tb.tabType = it.attribute("Type").toInt();
2282 fschmid 992
                                        QString tbCh = "";
993
                                        tbCh = it.attribute("Fill","");
2877 cbradney 994
                                        if (tbCh.isEmpty())
2282 fschmid 995
                                                tb.tabFillChar = QChar();
996
                                        else
997
                                                tb.tabFillChar = tbCh[0];
998
                                        OB.TabValues.append(tb);
999
                                }
167 Franz 1000
                                IT=IT.nextSibling();
1001
                        }
2858 fschmid 1002
                        OB.itemText = "";
3 paul 1003
                        OB.LayerNr = -1;
456 fschmid 1004
                        view->PasteItem(&OB, true, true);
3727 cbradney 1005
                        PageItem* Neu = doc->Items->at(doc->Items->count()-1);
2858 fschmid 1006
                        IT=DOC.firstChild();
1007
                        while(!IT.isNull())
1008
                        {
1009
                                QDomElement it=IT.toElement();
1010
                                if (it.tagName()=="ITEXT")
3197 fschmid 1011
                                        GetItemText(&it, doc, VorLFound, true, Neu);
4055 fschmid 1012
                                if (it.tagName()=="ImageEffect")
1013
                                {
1014
                                        struct ScImage::imageEffect ef;
1015
                                        ef.effectParameters = it.attribute("Param");
1016
                                        ef.effectCode = it.attribute("Code").toInt();
1017
                                        Neu->effectsInUse.append(ef);
1018
                                }
4326 fschmid 1019
                                if (it.tagName() == "PSDLayer")
1020
                                {
5937 jghali 1021
                                        struct ImageLoadRequest loadingInfo;
4326 fschmid 1022
                                        loadingInfo.blend = it.attribute("Blend");
1023
                                        loadingInfo.opacity = it.attribute("Opacity").toInt();
1024
                                        loadingInfo.visible = static_cast<bool>(it.attribute("Visible").toInt());
6138 fschmid 1025
                                        loadingInfo.useMask = static_cast<bool>(it.attribute("useMask", "1").toInt());
4326 fschmid 1026
                                        Neu->pixm.imgInfo.RequestProps.insert(it.attribute("Layer").toInt(), loadingInfo);
1027
                                        Neu->pixm.imgInfo.isRequest = true;
1028
                                }
2858 fschmid 1029
                                IT=IT.nextSibling();
1030
                        }
4326 fschmid 1031
                        if ((Neu->effectsInUse.count() != 0) || (Neu->pixm.imgInfo.RequestProps.count() != 0))
4055 fschmid 1032
                                doc->LoadPict(Neu->Pfile, Neu->ItemNr, true);
234 Franz 1033
                        if (Neu->isTableItem)
1034
                        {
1035
                                TableItems.append(Neu);
4026 craig 1036
                                TableID.insert(pg.attribute("OwnLINK", "0").toInt(), Neu->ItemNr);
234 Franz 1037
                        }
4536 fschmid 1038
                        if (Neu->asPathText())
4688 cbradney 1039
                                Neu->updatePolyClip();
167 Franz 1040
                }
3 paul 1041
                DOC=DOC.nextSibling();
167 Franz 1042
        }
234 Franz 1043
        if (TableItems.count() != 0)
1044
        {
1045
                for (uint ttc = 0; ttc < TableItems.count(); ++ttc)
1046
                {
1047
                        PageItem* ta = TableItems.at(ttc);
1048
                        if (ta->TopLinkID != -1)
3727 cbradney 1049
                                ta->TopLink = doc->Items->at(TableID[ta->TopLinkID]);
234 Franz 1050
                        else
1051
                                ta->TopLink = 0;
1052
                        if (ta->LeftLinkID != -1)
3727 cbradney 1053
                                ta->LeftLink = doc->Items->at(TableID[ta->LeftLinkID]);
234 Franz 1054
                        else
1055
                                ta->LeftLink = 0;
1056
                        if (ta->RightLinkID != -1)
3727 cbradney 1057
                                ta->RightLink = doc->Items->at(TableID[ta->RightLinkID]);
234 Franz 1058
                        else
1059
                                ta->RightLink = 0;
1060
                        if (ta->BottomLinkID != -1)
3727 cbradney 1061
                                ta->BottomLink = doc->Items->at(TableID[ta->BottomLinkID]);
234 Franz 1062
                        else
1063
                                ta->BottomLink = 0;
1064
                }
1065
        }
3 paul 1066
        doc->GroupCounter = GrMax + 1;
63 Franz 1067
        QDir::setCurrent(CurDirP);
3 paul 1068
        return true;
1069
}
1070
 
4130 cbradney 1071
QString ScriXmlDoc::WriteElem(ScribusDoc *doc, ScribusView *view, Selection* selection)
3 paul 1072
{
6402 fschmid 1073
        double xp, yp;
1074
        QString tmp, tmpy;
3 paul 1075
        PageItem *item;
1076
        QDomDocument docu("scribus");
1077
        QString st="<SCRIBUSELEMUTF8></SCRIBUSELEMUTF8>";
1078
        docu.setContent(st);
1079
        QDomElement elem=docu.documentElement();
4130 cbradney 1080
        item = selection->itemAt(0);
3 paul 1081
        QValueList<uint> ELL;
4130 cbradney 1082
        for (uint cor=0; cor<selection->count(); ++cor)
1083
                ELL.append(selection->itemAt(cor)->ItemNr);
3 paul 1084
        qHeapSort(ELL);
4130 cbradney 1085
        if (selection->isMultipleSelection())
167 Franz 1086
        {
5087 subik 1087
                xp = view->GroupX - doc->currentPage()->xOffset();
1088
                yp = view->GroupY - doc->currentPage()->yOffset();
456 fschmid 1089
                elem.setAttribute("W", view->GroupW);
1090
                elem.setAttribute("H", view->GroupH);
167 Franz 1091
        }
3 paul 1092
        else
167 Franz 1093
        {
6402 fschmid 1094
                if (item->rotation() != 0)
1095
                {
6407 fschmid 1096
                        double minx = 99999.9;
1097
                        double miny = 99999.9;
1098
                        double maxx = -99999.9;
1099
                        double maxy = -99999.9;
1100
                        double xpo = item->xPos() - doc->currentPage()->xOffset();
1101
                        double ypo = item->yPos() - doc->currentPage()->yOffset();
6402 fschmid 1102
                        FPointArray pb(4);
1103
                        pb.setPoint(0, FPoint(xpo, ypo));
1104
                        pb.setPoint(1, FPoint(item->width(), 0.0, xpo, ypo, item->rotation(), 1.0, 1.0));
1105
                        pb.setPoint(2, FPoint(item->width(), item->height(), xpo, ypo, item->rotation(), 1.0, 1.0));
1106
                        pb.setPoint(3, FPoint(0.0, item->height(), xpo, ypo, item->rotation(), 1.0, 1.0));
1107
                        for (uint pc = 0; pc < 4; ++pc)
1108
                        {
1109
                                minx = QMIN(minx, pb.point(pc).x());
1110
                                miny = QMIN(miny, pb.point(pc).y());
1111
                                maxx = QMAX(maxx, pb.point(pc).x());
1112
                                maxy = QMAX(maxy, pb.point(pc).y());
1113
                        }
6407 fschmid 1114
                        elem.setAttribute("W", maxx - minx);
1115
                        elem.setAttribute("H", maxy - miny);
6402 fschmid 1116
                }
1117
                else
1118
                {
6407 fschmid 1119
                        elem.setAttribute("W", item->width());
1120
                        elem.setAttribute("H", item->height());
6402 fschmid 1121
                }
6407 fschmid 1122
                xp = item->xPos() - doc->currentPage()->xOffset();
1123
                yp = item->yPos() - doc->currentPage()->yOffset();
167 Franz 1124
        }
3735 fschmid 1125
        elem.setAttribute("XP", xp);
1126
        elem.setAttribute("YP", yp);
4130 cbradney 1127
        elem.setAttribute("COUNT", selection->count());
2800 fschmid 1128
        elem.setAttribute("Version", QString(VERSION));
3544 avox 1129
        QMap<QString,int>::Iterator itf;
322 Franz 1130
        for (itf = doc->UsedFonts.begin(); itf != doc->UsedFonts.end(); ++itf)
1131
        {
1132
                QDomElement fn=docu.createElement("FONT");
1133
                fn.setAttribute("NAME",itf.key());
1134
                elem.appendChild(fn);
1135
        }
1065 cbradney 1136
        ColorList::Iterator itc;
322 Franz 1137
        for (itc = doc->PageColors.begin(); itc != doc->PageColors.end(); ++itc)
1138
        {
1139
                QDomElement co=docu.createElement("COLOR");
1140
                co.setAttribute("NAME",itc.key());
4535 fschmid 1141
                if (doc->PageColors[itc.key()].getColorModel() == colorModelRGB)
1142
                        co.setAttribute("RGB",doc->PageColors[itc.key()].nameRGB());
1143
                else
1144
                        co.setAttribute("CMYK",doc->PageColors[itc.key()].nameCMYK());
3051 fschmid 1145
                co.setAttribute("Spot",static_cast<int>(doc->PageColors[itc.key()].isSpotColor()));
3060 fschmid 1146
                co.setAttribute("Register",static_cast<int>(doc->PageColors[itc.key()].isRegistrationColor()));
322 Franz 1147
                elem.appendChild(co);
1148
        }
1065 cbradney 1149
        QMap<int, ParagraphStyle> UsedStyles;
322 Franz 1150
        QMap<int, int> UsedMapped2Saved;
1151
        int NewStylesNum = 5;
1152
        UsedStyles.clear();
1153
        UsedMapped2Saved.clear();
5184 avox 1154
        ParagraphStyle vg;
1065 cbradney 1155
        if (doc->docParagraphStyles.count() > 5)
322 Franz 1156
        {
3934 cbradney 1157
                //for (uint co=0; co<Selitems->count(); ++co)
4130 cbradney 1158
                for (uint co=0; co<selection->count(); ++co)
322 Franz 1159
                {
3727 cbradney 1160
                        item = doc->Items->at(ELL[co]);
5569 avox 1161
                        int parstyle = findParagraphStyle(doc, item->itemText.defaultStyle());
1162
                        if (parstyle > 4)
322 Franz 1163
                        {
5569 avox 1164
                                vg = item->itemText.defaultStyle();
1165
                                UsedStyles[parstyle] = vg;
322 Franz 1166
                        }
5184 avox 1167
                        if (((item->asTextFrame()) || (item->asPathText())) && (item->itemText.length() != 0))
322 Franz 1168
                        {
5184 avox 1169
#ifndef NLS_PROTO
5753 jghali 1170
                                for (int tx = 0; tx < item->itemText.length(); ++tx)
322 Franz 1171
                                {
5721 avox 1172
                                        if (item->itemText.text(tx) == SpecialChars::PARSEP)
322 Franz 1173
                                        {
5721 avox 1174
                                                vg = item->itemText.paragraphStyle(tx);
1175
                                                UsedStyles[findParagraphStyle(doc, vg)] = vg;
322 Franz 1176
                                        }
1177
                                }
5184 avox 1178
#endif
322 Franz 1179
                        }
1180
                }
1181
                QValueList<int> StyleNumb = UsedStyles.keys();
1182
                qHeapSort(StyleNumb);
1183
                for (uint ff = 0; ff < StyleNumb.count(); ++ff)
1184
                {
1185
                        int actSt = (*StyleNumb.at(ff));
1186
                        UsedMapped2Saved.insert(actSt, NewStylesNum);
1187
                        NewStylesNum++;
1188
                        QDomElement fo=docu.createElement("STYLE");
5184 avox 1189
                        fo.setAttribute("NAME",UsedStyles[actSt].name());
1190
                        fo.setAttribute("ALIGN",UsedStyles[actSt].alignment());
1191
                        fo.setAttribute("LINESPMode",UsedStyles[actSt].lineSpacingMode());
4546 subik 1192
                        //CB #2738:
4097 cbradney 1193
                        //UsedStyles[actSt].LineSpa is something like this is using automatic from the font:
1194
                        //10.34912109375000000000. Default attribute value is then 10.3491 which then becomes //10.34909999999999996589 and then does not compare. This fixes, should we change our
1195
                        //default precision?
5184 avox 1196
                        fo.setAttribute("LINESP",QString::number(UsedStyles[actSt].lineSpacing(),'f',13));
1197
                        fo.setAttribute("INDENT",UsedStyles[actSt].leftMargin());
1198
                        fo.setAttribute("FIRST",UsedStyles[actSt].firstIndent());
1199
                        fo.setAttribute("VOR",UsedStyles[actSt].gapBefore());
1200
                        fo.setAttribute("NACH",UsedStyles[actSt].gapAfter());
5980 avox 1201
                        fo.setAttribute("FONT",UsedStyles[actSt].charStyle().font().scName());
5184 avox 1202
                        fo.setAttribute("FONTSIZE",UsedStyles[actSt].charStyle().fontSize() / 10.0);
1203
                        fo.setAttribute("DROP", static_cast<int>(UsedStyles[actSt].hasDropCap()));
1204
                        fo.setAttribute("DROPLIN", UsedStyles[actSt].dropCapLines());
1205
                        fo.setAttribute("DROPDIST", UsedStyles[actSt].dropCapOffset());
1206
                        fo.setAttribute("EFFECT", UsedStyles[actSt].charStyle().effects());
1207
                        if (UsedStyles[actSt].tabValues().count() != 0)
2282 fschmid 1208
                        {
5184 avox 1209
                                for (uint a = 0; a < UsedStyles[actSt].tabValues().count(); ++a)
2282 fschmid 1210
                                {
1211
                                        QDomElement tabs = docu.createElement("Tabs");
5184 avox 1212
                                        tabs.setAttribute("Type", (*UsedStyles[actSt].tabValues().at(a)).tabType);
1213
                                        tabs.setAttribute("Pos", (*UsedStyles[actSt].tabValues().at(a)).tabPosition);
2282 fschmid 1214
                                        QString tabCh = "";
5184 avox 1215
                                        if (!(*UsedStyles[actSt].tabValues().at(a)).tabFillChar.isNull())
1216
                                                tabCh = QString((*UsedStyles[actSt].tabValues().at(a)).tabFillChar);
2282 fschmid 1217
                                        tabs.setAttribute("Fill", tabCh);
1218
                                        fo.appendChild(tabs);
1219
                                }
1220
                        }
5691 avox 1221
                        fo.setAttribute("FCOLOR",UsedStyles[actSt].charStyle().fillColor());
1222
                        fo.setAttribute("FSHADE",UsedStyles[actSt].charStyle().fillShade());
1223
                        fo.setAttribute("SCOLOR",UsedStyles[actSt].charStyle().strokeColor());
1224
                        fo.setAttribute("SSHADE",UsedStyles[actSt].charStyle().strokeShade());
5184 avox 1225
                        fo.setAttribute("BASE", static_cast<int>(UsedStyles[actSt].useBaselineGrid()));
5691 avox 1226
                        fo.setAttribute("TXTSHX",UsedStyles[actSt].charStyle().shadowXOffset() / 10.0);
1227
                        fo.setAttribute("TXTSHY",UsedStyles[actSt].charStyle().shadowYOffset() / 10.0);
1228
                        fo.setAttribute("TXTOUT",UsedStyles[actSt].charStyle().outlineWidth() / 10.0);
1229
                        fo.setAttribute("TXTULP",UsedStyles[actSt].charStyle().underlineOffset() / 10.0);
1230
                        fo.setAttribute("TXTULW",UsedStyles[actSt].charStyle().underlineWidth() / 10.0);
1231
                        fo.setAttribute("TXTSTP",UsedStyles[actSt].charStyle().strikethruOffset() / 10.0);
1232
                        fo.setAttribute("TXTSTW",UsedStyles[actSt].charStyle().strikethruWidth() / 10.0);
1233
                        fo.setAttribute("SCALEH",UsedStyles[actSt].charStyle().scaleH() / 10.0);
1234
                        fo.setAttribute("SCALEV",UsedStyles[actSt].charStyle().scaleV() / 10.0);
1235
                        fo.setAttribute("BASEO",UsedStyles[actSt].charStyle().baselineOffset() / 10.0);
1236
                        fo.setAttribute("KERN",UsedStyles[actSt].charStyle().tracking() / 10.0);
322 Franz 1237
                        elem.appendChild(fo);
1238
                }
1239
        }
1240
        QMap<QString,multiLine>::Iterator itMU;
1241
        for (itMU = doc->MLineStyles.begin(); itMU != doc->MLineStyles.end(); ++itMU)
1242
        {
1243
                QDomElement MuL=docu.createElement("MultiLine");
1244
                MuL.setAttribute("Name",itMU.key());
1245
                multiLine ml = itMU.data();
1246
                multiLine::iterator itMU2;
1247
                for (itMU2 = ml.begin(); itMU2 != ml.end(); ++itMU2)
1248
                {
1249
                        QDomElement SuL=docu.createElement("SubLine");
1250
                        SuL.setAttribute("Color", (*itMU2).Color);
1251
                        SuL.setAttribute("Shade", (*itMU2).Shade);
1252
                        SuL.setAttribute("Dash", (*itMU2).Dash);
1253
                        SuL.setAttribute("LineEnd", (*itMU2).LineEnd);
1254
                        SuL.setAttribute("LineJoin", (*itMU2).LineJoin);
1255
                        SuL.setAttribute("Width", (*itMU2).Width);
1256
                        MuL.appendChild(SuL);
1257
                }
1258
                elem.appendChild(MuL);
1259
        }
1065 cbradney 1260
        QMap<int, ArrowDesc> usedArrows;
1261
        QMap<int, ArrowDesc>::Iterator itar;
1262
        struct ArrowDesc arrow;
3934 cbradney 1263
        //for (uint co=0; co<Selitems->count(); ++co)
4130 cbradney 1264
        for (uint co=0; co<selection->count(); ++co)
167 Franz 1265
        {
3727 cbradney 1266
                item = doc->Items->at(ELL[co]);
4061 craig 1267
                int startIndex = item->startArrowIndex();
1268
                int endIndex = item->endArrowIndex();
1269
                if (startIndex != 0)
741 fschmid 1270
                {
4061 craig 1271
                        arrow.points = (*doc->arrowStyles.at(startIndex-1)).points.copy();
1272
                        arrow.name = (*doc->arrowStyles.at(startIndex-1)).name;
1273
                        usedArrows.insert(startIndex, arrow);
741 fschmid 1274
                }
4061 craig 1275
                if (endIndex != 0)
741 fschmid 1276
                {
4061 craig 1277
                        arrow.points = (*doc->arrowStyles.at(endIndex-1)).points.copy();
1278
                        arrow.name = (*doc->arrowStyles.at(endIndex-1)).name;
1279
                        usedArrows.insert(endIndex, arrow);
741 fschmid 1280
                }
1281
        }
1282
        if (usedArrows.count() != 0)
1283
        {
1284
                for (itar = usedArrows.begin(); itar != usedArrows.end(); ++itar)
1285
                {
776 fschmid 1286
                        if (itar.data().userArrow)
741 fschmid 1287
                        {
776 fschmid 1288
                                QDomElement ar=docu.createElement("Arrows");
1289
                                ar.setAttribute("NumPoints", itar.data().points.size());
1290
                                QString arp = "";
1291
                                double xa, ya;
1292
                                for (uint nxx = 0; nxx < itar.data().points.size(); ++nxx)
1293
                                {
1294
                                        itar.data().points.point(nxx, &xa, &ya);
1295
                                        arp += tmp.setNum(xa) + " " + tmpy.setNum(ya) + " ";
1296
                                }
1297
                                ar.setAttribute("Points", arp);
1298
                                ar.setAttribute("Name", itar.data().name);
1299
                                ar.setAttribute("Index", itar.key());
1300
                                elem.appendChild(ar);
741 fschmid 1301
                        }
1302
                }
1303
        }
6402 fschmid 1304
        QStringList patterns = doc->getUsedPatternsSelection();
1305
        for (uint c = 0; c < patterns.count(); ++c)
1306
        {
1307
                ScPattern pa = doc->docPatterns[patterns[c]];
1308
                QDomElement pat = docu.createElement("Pattern");
1309
                pat.setAttribute("Name", patterns[c]);
1310
                pat.setAttribute("offsetX", pa.offsetX);
1311
                pat.setAttribute("offsetY", pa.offsetY);
1312
                pat.setAttribute("scaleX", pa.scaleX);
1313
                pat.setAttribute("scaleY", pa.scaleY);
1314
                pat.setAttribute("rotation", pa.rotation);
1315
                pat.setAttribute("width", pa.width);
1316
                pat.setAttribute("height", pa.height);
1317
                for (uint o = 0; o < pa.items.count(); o++)
1318
                {
1319
                        item = pa.items.at(o);
1320
                        QDomElement ob = docu.createElement("PatternItem");
1321
                        WriteObject(doc, docu, ob, UsedMapped2Saved, item);
1322
                        pat.appendChild(ob);
1323
                }
1324
                elem.appendChild(pat);
1325
        }
4130 cbradney 1326
        for (uint co=0; co<selection->count(); ++co)
741 fschmid 1327
        {
282 Franz 1328
                QDir::setCurrent(QDir::homeDirPath());
3727 cbradney 1329
                item = doc->Items->at(ELL[co]);
6402 fschmid 1330
                QDomElement ob = docu.createElement("ITEM");
1331
                WriteObject(doc, docu, ob, UsedMapped2Saved, item);
1332
                elem.appendChild(ob);
1333
        }
1334
        return docu.toString();
1335
}
1336
 
1337
void ScriXmlDoc::WriteObject(ScribusDoc *doc, QDomDocument &docu, QDomElement &ob, QMap<int, int> &UsedMapped2Saved, PageItem *item)
1338
{
1339
        int te, te2, tsh, tsh2, tst, tst2, tsb, tsb2, tshs, tshs2;
1340
        QString text, tf, tf2, tc, tc2, tcs, tcs2, tmp, tmpy;
1341
        double ts, ts2, tsc, tsc2, tscv, tscv2, tb, tb2, tsx, tsx2, tsy, tsy2, tout, tout2, tulp, tulp2, tulw, tulw2, tstp, tstp2, tstw, tstw2;
1342
        QString CurDirP = QDir::currentDirPath();
1343
        int textAlignment = findParagraphStyle(doc, item->itemText.defaultStyle());
1344
        if (textAlignment > 4)
1345
                ob.setAttribute("ALIGN",UsedMapped2Saved[textAlignment]);
1346
        else
1347
                ob.setAttribute("ALIGN",textAlignment);
1348
        SetItemProps(&ob, item, false);
1349
        ob.setAttribute("LOCK", 0);
1350
        ob.setAttribute("XPOS",item->xPos() - doc->currentPage()->xOffset());
1351
        ob.setAttribute("YPOS",item->yPos() - doc->currentPage()->yOffset());
1352
        ob.setAttribute("BOOKMARK", item->isBookmark ? 1 : 0);
1353
        ob.setAttribute("fillRule", static_cast<int>(item->fillRule));
1354
        ob.setAttribute("doOverprint", static_cast<int>(item->doOverprint));
1355
        if (item->effectsInUse.count() != 0)
1356
        {
1357
                for (uint a = 0; a < item->effectsInUse.count(); ++a)
2056 fschmid 1358
                {
6402 fschmid 1359
                        QDomElement imeff = docu.createElement("ImageEffect");
1360
                        imeff.setAttribute("Code", (*item->effectsInUse.at(a)).effectCode);
1361
                        imeff.setAttribute("Param", (*item->effectsInUse.at(a)).effectParameters);
1362
                        ob.appendChild(imeff);
2056 fschmid 1363
                }
6402 fschmid 1364
        }
1365
        if (item->TabValues.count() != 0)
1366
        {
1367
                for (uint a = 0; a < item->TabValues.count(); ++a)
2282 fschmid 1368
                {
6402 fschmid 1369
                        QDomElement tabs = docu.createElement("Tabs");
1370
                        tabs.setAttribute("Type", (*item->TabValues.at(a)).tabType);
1371
                        tabs.setAttribute("Pos", (*item->TabValues.at(a)).tabPosition);
1372
                        QString tabCh = "";
1373
                        if (!(*item->TabValues.at(a)).tabFillChar.isNull())
1374
                                tabCh = QString((*item->TabValues.at(a)).tabFillChar);
1375
                        tabs.setAttribute("Fill", tabCh);
1376
                        ob.appendChild(tabs);
2282 fschmid 1377
                }
6402 fschmid 1378
        }
1379
        if (((item->asImageFrame()) || (item->asTextFrame())) && (!item->Pfile.isEmpty()) && (item->pixm.imgInfo.layerInfo.count() != 0) && (item->pixm.imgInfo.isRequest))
1380
        {
1381
                QMap<int, ImageLoadRequest>::iterator it2;
1382
                for (it2 = item->pixm.imgInfo.RequestProps.begin(); it2 != item->pixm.imgInfo.RequestProps.end(); ++it2)
4326 fschmid 1383
                {
6402 fschmid 1384
                        QDomElement psd = docu.createElement("PSDLayer");
1385
                        psd.setAttribute("Layer",it2.key());
1386
                        psd.setAttribute("Visible", static_cast<int>(it2.data().visible));
1387
                        psd.setAttribute("useMask", static_cast<int>(it2.data().useMask));
1388
                        psd.setAttribute("Opacity", it2.data().opacity);
1389
                        psd.setAttribute("Blend", it2.data().blend);
1390
                        ob.appendChild(psd);
4326 fschmid 1391
                }
6402 fschmid 1392
        }
1393
        if (item->GrType != 0)
1394
        {
1395
                if (item->GrType == 8)
1396
                        ob.setAttribute("pattern", item->pattern());
1397
                else
295 Franz 1398
                {
6402 fschmid 1399
                        QPtrVector<VColorStop> cstops = item->fill_gradient.colorStops();
1400
                        for (uint cst = 0; cst < item->fill_gradient.Stops(); ++cst)
295 Franz 1401
                        {
6402 fschmid 1402
                                QDomElement itcl = docu.createElement("CSTOP");
1403
                                itcl.setAttribute("RAMP", cstops.at(cst)->rampPoint);
1404
                                itcl.setAttribute("NAME", cstops.at(cst)->name);
1405
                                itcl.setAttribute("SHADE", cstops.at(cst)->shade);
1406
                                itcl.setAttribute("TRANS", cstops.at(cst)->opacity);
1407
                                ob.appendChild(itcl);
295 Franz 1408
                        }
6402 fschmid 1409
                        ob.setAttribute("GRSTARTX", item->GrStartX);
1410
                        ob.setAttribute("GRSTARTY", item->GrStartY);
1411
                        ob.setAttribute("GRENDX", item->GrEndX);
1412
                        ob.setAttribute("GRENDY", item->GrEndY);
295 Franz 1413
                }
6402 fschmid 1414
        }
1415
        QDir::setCurrent(CurDirP);
1416
        for(int k=0;k<item->itemText.length();++k)
1417
        {
1418
                const CharStyle& style4(item->itemText.charStyle(k));
1419
                QChar ch = item->itemText.text(k);
1420
                QDomElement it=docu.createElement("ITEXT");
1421
                ts = style4.fontSize() / 10.0;
1422
                tf = style4.font().scName();
1423
                tc = style4.fillColor();
1424
                te = style4.tracking();
1425
                tsh = style4.fillShade();
1426
                tst = style4.effects() & 2047;
5721 avox 1427
#if 0 // FIXME NLS ndef NLS_PROTO
1428
                        if (item->itemText.item(k)->cab > 4)
1429
                                tsb = UsedMapped2Saved[item->itemText.item(k)->cab];
322 Franz 1430
                        else
5721 avox 1431
                                tsb = item->itemText.item(k)->cab;
5184 avox 1432
#else
6402 fschmid 1433
                tsb = 0;
5184 avox 1434
#endif
6402 fschmid 1435
                tcs = style4.strokeColor();
1436
                tshs = style4.strokeShade();
1437
                tsc = style4.scaleH() / 10.0;
1438
                tscv = style4.scaleV() / 10.0;
1439
                tb = style4.baselineOffset() / 10.0;
1440
                tsx = style4.shadowXOffset() / 10.0;
1441
                tsy = style4.shadowYOffset() / 10.0;
1442
                tout = style4.outlineWidth() / 10.0;
1443
                tulp = style4.underlineOffset() / 10.0;
1444
                tulw = style4.underlineWidth() / 10.0;
1445
                tstp = style4.strikethruOffset()/ 10.0;
1446
                tstw = style4.strikethruWidth() / 10.0;
1447
                if (ch == SpecialChars::PARSEP)
1448
                        text = QChar(5);
1449
                else if (ch == SpecialChars::TAB)
1450
                        text = QChar(4);
1451
                else
1452
                        text = ch;
1453
                ++k;
1454
                if (k == item->itemText.length())
1455
                {
3 paul 1456
                        it.setAttribute("CH",text);
1457
                        it.setAttribute("CSIZE",ts);
1458
                        it.setAttribute("CFONT",tf);
1459
                        it.setAttribute("CCOLOR",tc);
2382 fschmid 1460
                        it.setAttribute("CKERN",te);
3 paul 1461
                        it.setAttribute("CSHADE",tsh);
1462
                        it.setAttribute("CSTYLE",tst);
1463
                        it.setAttribute("CAB",tsb);
68 Franz 1464
                        it.setAttribute("CSTROKE",tcs);
1465
                        it.setAttribute("CSHADE2",tshs);
1466
                        it.setAttribute("CSCALE",tsc);
2230 fschmid 1467
                        it.setAttribute("CSCALEV",tscv);
2234 fschmid 1468
                        it.setAttribute("CBASE",tb);
2247 fschmid 1469
                        it.setAttribute("CSHX",tsx);
1470
                        it.setAttribute("CSHY",tsy);
2257 fschmid 1471
                        it.setAttribute("COUT",tout);
2262 fschmid 1472
                        it.setAttribute("CULP",tulp);
1473
                        it.setAttribute("CULW",tulw);
2272 fschmid 1474
                        it.setAttribute("CSTP",tstp);
1475
                        it.setAttribute("CSTW",tstw);
3 paul 1476
                        ob.appendChild(it);
6402 fschmid 1477
                        break;
167 Franz 1478
                }
6402 fschmid 1479
                const CharStyle& style5(item->itemText.charStyle(k));
1480
                ch = item->itemText.text(k);
1481
                ts2 = style5.fontSize() / 10.0;
1482
                tf2 = style5.font().scName();
1483
                tc2 = style5.fillColor();
1484
                te2 = style5.tracking();
1485
                tsh2 = style5.fillShade();
1486
                tst2 = style5.effects() & 2047;
1487
#if 0 //FIXME NLS ndef NLS_PROTO
1488
                        if (item->itemText.item(k)->cab > 4)
1489
                                tsb2 = UsedMapped2Saved[item->itemText.item(k)->cab];
1490
                        else
1491
                                tsb2 = item->itemText.item(k)->cab;
1492
#else
1493
                tsb2 = 0;
1494
#endif
1495
                tcs2 = style5.strokeColor();
1496
                tshs2 = style5.strokeShade();
1497
                tsc2 = style5.scaleH() / 10.0;
1498
                tscv2 = style5.scaleV() / 10.0;
1499
                tb2 = style5.baselineOffset() / 10.0;
1500
                tsx2 = style5.shadowXOffset() / 10.0;
1501
                tsy2 = style5.shadowYOffset() / 10.0;
1502
                tout2 = style5.outlineWidth() / 10.0;
1503
                tulp2 = style5.underlineOffset() / 10.0;
1504
                tulw2 = style5.underlineWidth() / 10.0;
1505
                tstp2 = style5.strikethruOffset() / 10.0;
1506
                tstw2 = style5.strikethruWidth() / 10.0;
1507
                while ((ts2 == ts)
1508
                                                && (tsb2 == tsb)
1509
                                                && (tf2 == tf)
1510
                                                && (tc2 == tc)
1511
                                                && (te2 == te)
1512
                                                && (tsh2 == tsh)
1513
                                                && (tshs2 == tshs)
1514
                                                && (tsc2 == tsc)
1515
                                                && (tscv2 == tscv)
1516
                                                && (tcs2 == tcs)
1517
                                                && (tb2 == tb)
1518
                                                && (tsx2 == tsx)
1519
                                                && (tsy2 == tsy)
1520
                                                && (tout2 == tout)
1521
                                                && (tulp2 == tulp)
1522
                                                && (tulw2 == tulw)
1523
                                                && (tstp2 == tstp)
1524
                                                && (tstw2 == tstw)
1525
                                                && (tst2 == tst))
1526
                {
1527
                        if (ch == QChar(13))
1528
                                text += QChar(5);
1529
                        else if (ch == QChar(9))
1530
                                text += QChar(4);
1531
                        else
1532
                                text += ch;
1533
                        ++k;
1534
                        if (k == item->itemText.length())
1535
                                break;
1536
                        const CharStyle& style6(item->itemText.charStyle(k));
1537
                        ch = item->itemText.text(k);
1538
                        ts2 = style6.fontSize() / 10.0;
1539
                        tf2 = style6.font().scName();
1540
                        tc2 = style6.fillColor();
1541
                        te2 = style6.tracking();
1542
                        tsh2 = style6.fillShade();
1543
                        tst2 = style6.effects() & 2047;
1544
#if 0 //FIXME NLS ndef NLS_PROTO
1545
                                if (item->itemText.item(k)->cab > 4)
1546
                                        tsb2 = UsedMapped2Saved[item->itemText.item(k)->cab];
1547
                                else
1548
                                        tsb2 = item->itemText.item(k)->cab;
1549
#else
1550
                        tsb2 = 0;
1551
#endif
1552
                        tcs2 = style6.strokeColor();
1553
                        tshs2 = style6.strokeShade();
1554
                        tsc2 = style6.scaleH() / 10.0;
1555
                        tscv2 = style6.scaleV() / 10.0;
1556
                        tb2 = style6.baselineOffset() / 10.0;
1557
                        tsx2 = style6.shadowXOffset() / 10.0;
1558
                        tsy2 = style6.shadowYOffset() / 10.0;
1559
                        tout2 = style6.outlineWidth() / 10.0;
1560
                        tulp2 = style6.underlineOffset() / 10.0;
1561
                        tulw2 = style6.underlineWidth() / 10.0;
1562
                        tstp2 = style6.strikethruOffset() / 10.0;
1563
                        tstw2 = style6.strikethruWidth() / 10.0;
1564
                }
1565
                it.setAttribute("CH",text);
1566
                it.setAttribute("CSIZE",ts);
1567
                it.setAttribute("CFONT",tf);
1568
                it.setAttribute("CCOLOR",tc);
1569
                it.setAttribute("CKERN",te);
1570
                it.setAttribute("CSHADE",tsh);
1571
                it.setAttribute("CSTYLE",tst);
1572
                it.setAttribute("CAB",tsb);
1573
                it.setAttribute("CSTROKE",tcs);
1574
                it.setAttribute("CSHADE2",tshs);
1575
                it.setAttribute("CSCALE",tsc);
1576
                it.setAttribute("CSCALEV",tscv);
1577
                it.setAttribute("CBASE",tb);
1578
                it.setAttribute("CSHX",tsx);
1579
                it.setAttribute("CSHY",tsy);
1580
                it.setAttribute("COUT",tout);
1581
                it.setAttribute("CULP",tulp);
1582
                it.setAttribute("CULW",tulw);
1583
                it.setAttribute("CSTP",tstp);
1584
                it.setAttribute("CSTW",tstw);
1585
                k--;
1586
                ob.appendChild(it);
1587
        }
1588
        ob.setAttribute("NUMTEXT",item->itemText.length());
1589
        QString txnu = "";
1590
        for(int kt = 0; kt < item->itemText.length(); ++kt)
5184 avox 1591
#ifndef NLS_PROTO
6402 fschmid 1592
                txnu += tmp.setNum(item->itemText.item(kt)->glyph.xoffset) + " " + tmpy.setNum(item->itemText.item(kt)->glyph.yoffset) + " ";
5184 avox 1593
#else
6402 fschmid 1594
                txnu += "0 0 ";
5184 avox 1595
#endif
6402 fschmid 1596
        ob.setAttribute("TEXTCOOR", txnu);
1597
        ob.setAttribute("BACKITEM", -1);
1598
        ob.setAttribute("BACKPAGE", -1);
1599
        ob.setAttribute("NEXTITEM", -1);
1600
        ob.setAttribute("NEXTPAGE", -1);
3 paul 1601
}