Subversion Repositories Scribus

Rev

Rev 14170 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
10220 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
*/
8193 avox 7
 
8
 
10203 cbradney 9
#include "desaxe/saxiohelper.h"
10
#include "desaxe/simple_actions.h"
8193 avox 11
#include "pageitem.h"
8229 avox 12
#include "pageitem_imageframe.h"
10203 cbradney 13
#include "pageitem_line.h"
8229 avox 14
#include "pageitem_pathtext.h"
10203 cbradney 15
#include "pageitem_polygon.h"
8229 avox 16
#include "pageitem_polyline.h"
10203 cbradney 17
#include "pageitem_textframe.h"
10660 cbradney 18
#include "pageitem_latexframe.h"
13839 fschmid 19
#ifdef HAVE_OSG
20
        #include "pageitem_osgframe.h"
21
#endif
8229 avox 22
#include "scribusdoc.h"
13839 fschmid 23
#include "sctextstream.h"
10203 cbradney 24
#include "util_color.h"
25
#include "util_math.h"
10204 jghali 26
#include "util.h"
8193 avox 27
 
11012 mrdocs 28
#include <QDebug>
29
 
8193 avox 30
using namespace desaxe;
31
 
14170 jghali 32
eRenderIntent parseIntent(const Xml_string& str)
33
{
34
        return (eRenderIntent) str.toInt();
35
}
8193 avox 36
 
8800 jghali 37
FPointArray parseSVG(const Xml_string& str)
8229 avox 38
{
39
        FPointArray result;
40
        result.parseSVG(str);
41
        return result;
42
}
43
 
44
 
8289 avox 45
static Xml_attr PageItemXMLAttributes(const PageItem* item)
8193 avox 46
{
47
        Xml_attr result;
48
 
8333 avox 49
        result.insert("id", "obj" + toXMLString(const_cast<PageItem*>(item)->getUId()));
8399 fschmid 50
        if (!item->AutoName)
51
                result.insert("name", item->itemName());
8193 avox 52
        const PageItem* nxt = item->nextInChain();
53
        if (nxt)
8394 avox 54
                result.insert("nextframe", "obj" + toXMLString(nxt->getUId()));
13875 jghali 55
        result.insert("layer", toXMLString(item->LayerID));
8229 avox 56
        result.insert("level", toXMLString(item->ItemNr));
10660 cbradney 57
        result.insert("itemtype", toXMLString(item->realItemType()));
8193 avox 58
 
8412 avox 59
        result.insert("is-annotation", toXMLString(item->isAnnotation()));
8229 avox 60
        result.insert("is-bookmark", toXMLString(item->isPDFBookmark()));
61
        result.insert("printable", toXMLString(item->printEnabled()));
62
        result.insert("locked", toXMLString(item->locked()));
63
        result.insert("size-locked", toXMLString(item->sizeLocked()));
8193 avox 64
 
8229 avox 65
        result.insert("width", toXMLString(item->width()));
66
        result.insert("height", toXMLString(item->height()));
8326 avox 67
        result.insert("ownpage", toXMLString(item->OwnPage));
11826 jghali 68
        //Page* page = (item->OwnPage >= 0) ? item->doc()->Pages->at(item->OwnPage) : NULL;
69
        Page* page = item->doc()->currentPage(); //#6175
8326 avox 70
        if (page)
71
        {
72
                result.insert("xorigin", toXMLString(item->xPos() - page->xOffset()));
73
                result.insert("yorigin", toXMLString(item->yPos() - page->yOffset()));
74
        }
75
        else
76
        {
77
                result.insert("xorigin", toXMLString(item->xPos()));
78
                result.insert("yorigin", toXMLString(item->yPos()));
79
        }
8229 avox 80
        result.insert("rotation", toXMLString(item->rotation()));
8193 avox 81
        result.insert("fill-color", item->fillColor());
8229 avox 82
        result.insert("fill-shade", toXMLString(item->fillShade()));
83
        result.insert("fill-transparency", toXMLString(item->fillTransparency()));
84
        result.insert("fill-blendmode", toXMLString(item->fillBlendmode()));
85
        result.insert("fill-gradient-type", toXMLString(item->gradientType()));
86
        result.insert("fill-evenodd", toXMLString(item->fillEvenOdd()));
87
        result.insert("do-overprint", toXMLString(item->overprint()));
8193 avox 88
 
89
        result.insert("line-color", item->lineColor());
8229 avox 90
        result.insert("line-shade", toXMLString(item->lineShade()));
91
        result.insert("line-transparency", toXMLString(item->lineTransparency()));
92
        result.insert("line-blendmode", toXMLString(item->lineBlendmode()));
93
        result.insert("line-width", toXMLString(item->lineWidth()));
94
        result.insert("line-style", toXMLString(item->PLineArt));
95
        result.insert("line-cap", toXMLString(item->PLineEnd));
96
        result.insert("line-join", toXMLString(item->PLineJoin));
97
        result.insert("line-customstyle", item->customLineStyle());
98
        result.insert("line-start-arrow", toXMLString(item->startArrowIndex()));
99
        result.insert("line-end-arrow", toXMLString(item->endArrowIndex()));
8193 avox 100
 
8229 avox 101
        result.insert("frame-type", toXMLString(item->frameType()));
102
        result.insert("frame-shape", toXMLString(item->shape()));
103
        result.insert("frame-has-default-shape", toXMLString(item->hasDefaultShape()));
104
        result.insert("corner-radius", toXMLString(item->cornerRadius()));     
105
        result.insert("frame-contour", toXMLString(item->contour()));
106
        result.insert("text-flow-mode", toXMLString((int) item->textFlowMode() ));
8193 avox 107
 
8229 avox 108
        result.insert("left-distance", toXMLString(item->textToFrameDistLeft()));
109
        result.insert("top-distance", toXMLString(item->textToFrameDistTop()));
110
        result.insert("bottom-distance", toXMLString(item->textToFrameDistBottom()));
111
        result.insert("right-distance", toXMLString(item->textToFrameDistRight()));
12269 cbradney 112
        result.insert("first-line-offset", toXMLString(item->firstLineOffset()));
8193 avox 113
 
8229 avox 114
        result.insert("text-autoframes", toXMLString(item->isAutoFrame()));
115
        result.insert("text-columns", toXMLString(item->columns()));
116
        result.insert("text-columngap", toXMLString(item->columnGap()));
117
        result.insert("text-reversed", toXMLString(item->reversed()));
118
        result.insert("pathtext-type", toXMLString(item->pathTextType()));
119
        result.insert("pathtext-flipped", toXMLString(item->flipPathText()));
120
        result.insert("pathtext-baseoffset", toXMLString(item->pathTextBaseOffset()));
121
        result.insert("pathtext-showpath", toXMLString(item->pathTextShowFrame()));
8193 avox 122
 
8229 avox 123
        result.insert("image-scale-framesize", toXMLString(item->fitImageToFrame()));
124
        result.insert("image-scale-proportional", toXMLString(item->keepAspectRatio()));
125
        result.insert("image-x-scale", toXMLString(item->imageXScale()));
126
        result.insert("image-y-scale", toXMLString(item->imageYScale()));
127
        result.insert("image-x-position", toXMLString(item->imageXOffset()));
128
        result.insert("image-y-position", toXMLString(item->imageYOffset()));
129
        //      result.insert("image-x-dpi", toXMLString(item->imageXDpi()));
130
        //      result.insert("image-y-dpi", toXMLString(item->imageYDpi()));
131
        result.insert("image-shown", toXMLString(item->imageShown()));
132
        result.insert("image-use-embedded", toXMLString(item->useEmbeddedImageProfile()));
133
        result.insert("image-embedded-profile", item->embeddedImageProfile());
134
        result.insert("image-flipped-hor", toXMLString(item->imageFlippedH()));
135
        result.insert("image-flipped-vert", toXMLString(item->imageFlippedV()));
13949 fschmid 136
        result.insert("pagenumber", toXMLString(item->pixm.imgInfo.actualPageNumber));
8229 avox 137
        result.insert("cms-profile", item->cmsProfile());
138
        result.insert("cms-intent", toXMLString(item->cmsRenderingIntent()));
8193 avox 139
 
8326 avox 140
        if (item->groups().count() > 0)
8193 avox 141
        {
8326 avox 142
                QString grouplist = "";
9919 jghali 143
                QStack<int>::const_iterator it;
8326 avox 144
                for (it = item->groups().begin(); it != item->groups().end(); ++it)
145
                        grouplist += toXMLString( *it ) + " "; 
146
                result.insert("groups", toXMLString(grouplist));
147
                result.insert("isGroupControl", toXMLString(item->controlsGroup()));
148
                if (item->isGroupControl)
149
                {
150
                        if (item->groupsLastItem != 0)
8394 avox 151
                                result.insert("groupsLastItem", "obj" + toXMLString(item->groupsLastItem->getUId()));
8326 avox 152
                }
8193 avox 153
        }
154
 
8229 avox 155
        result.insert("isTableItem", toXMLString(item->isTableItem));
8193 avox 156
        if (item->isTableItem)
157
        {
8326 avox 158
                result.insert("TopLine", toXMLString(item->TopLine));
159
                result.insert("LeftLine", toXMLString(item->LeftLine));
160
                result.insert("RightLine", toXMLString(item->RightLine));
161
                result.insert("BottomLine", toXMLString(item->BottomLine));
8193 avox 162
                if (item->TopLink != 0)
8394 avox 163
                        result.insert("TopLINK", "obj" + toXMLString(item->TopLink->getUId()));
8193 avox 164
                if (item->LeftLink != 0)
8394 avox 165
                        result.insert("LeftLINK", "obj" + toXMLString(item->LeftLink->getUId()));
8193 avox 166
                if (item->RightLink != 0)
8394 avox 167
                        result.insert("RightLINK", "obj" + toXMLString(item->RightLink->getUId()));
8193 avox 168
                if (item->BottomLink != 0)
8394 avox 169
                        result.insert("BottomLINK", "obj" + toXMLString(item->BottomLink->getUId()));
8193 avox 170
        }
171
 
8229 avox 172
//      result.insert("ANNAME", !item->AutoName ? item->itemName() : QString(""));  // not used
10730 fschmid 173
        const PageItem_LatexFrame *latexframe = NULL;
11012 mrdocs 174
        if (item->realItemType() == PageItem::LatexFrame)
10730 fschmid 175
                latexframe = dynamic_cast<const PageItem_LatexFrame*>(item);
8229 avox 176
 
10660 cbradney 177
        if ((item->itemType()==PageItem::ImageFrame || item->itemType()==PageItem::TextFrame) && (!item->externalFile().isEmpty()) && !latexframe)
12795 fschmid 178
        {
179
                if (item->isInlineImage)
180
                {
181
                        result.insert("image-file", "");
182
                        result.insert("isInlineImage", toXMLString(item->isInlineImage));
183
                        QFileInfo inlFi(item->Pfile);
184
                        result.insert("inlineImageExt", inlFi.suffix());
185
                        QFile inFil(item->Pfile);
186
                        if (inFil.open(QIODevice::ReadOnly))
187
                        {
188
                                QByteArray ba = qCompress(inFil.readAll()).toBase64();
189
                                result.insert("ImageData", QString(ba));
190
                                inFil.close();
191
                        }
192
                }
193
                else
194
                        result.insert("image-file", Path2Relative(item->externalFile(), QDir::homePath()));
195
        }
13839 fschmid 196
#ifdef HAVE_OSG
197
        if (item->realItemType() == PageItem::OSGFrame)
198
        {
199
                if (!item->Pfile.isEmpty())
200
                {
201
                        const PageItem_OSGFrame *osgframe = dynamic_cast<const PageItem_OSGFrame*>(item);
202
                        result.insert("modelFile", Path2Relative(osgframe->modelFile, QDir::homePath()));
203
                        result.insert("currentViewName", osgframe->currentView);
204
                }
205
        }
206
#endif
8229 avox 207
        if (!item->fileIconPressed().isEmpty())
12309 fschmid 208
                result.insert("icon-pressed-file", Path2Relative(item->fileIconPressed(), QDir::homePath()));
8229 avox 209
        if (!item->fileIconRollover().isEmpty())
12309 fschmid 210
                result.insert("icon-rollover-file", Path2Relative(item->fileIconRollover(), QDir::homePath()));
10660 cbradney 211
        if (latexframe) {
11505 mrdocs 212
                result.insert("latex-dpi", toXMLString(latexframe->dpi()));
213
                result.insert("latex-configfile", latexframe->configFile());
214
                result.insert("latex-use-preamble", toXMLString(latexframe->usePreamble()));
10660 cbradney 215
        }
8229 avox 216
 
217
        if (item->dashes().count() > 0)
218
                result.insert("line-dashes", toXMLString(item->dashes()));
219
        if (item->dashOffset() != 0.0)
220
                result.insert("line-dash-offset", toXMLString(item->dashOffset()));
8193 avox 221
        return result;
222
}      
223
 
8412 avox 224
 
8800 jghali 225
void PageItem::saxx(SaxHandler& handler, const Xml_string& elemtag) const
8193 avox 226
{
8289 avox 227
        Xml_attr att(PageItemXMLAttributes(this));
10660 cbradney 228
        Xml_attr empty;
13085 jghali 229
//      qDebug() << QString("PageItem::saxx %1 %2").arg((ulong) &handler);
8266 avox 230
        handler.begin(elemtag, att);
8193 avox 231
 
232
        if (effectsInUse.count() != 0)
233
        {
8800 jghali 234
                for (int a = 0; a < effectsInUse.count(); ++a)
8193 avox 235
                {
236
                        Xml_attr imeff;
9803 fschmid 237
                        imeff.insert("Code", toXMLString(effectsInUse.at(a).effectCode));
238
                        imeff.insert("Param", effectsInUse.at(a).effectParameters);
8193 avox 239
                        handler.begin("ImageEffect", imeff);
240
                        handler.end("ImageEffect");
241
                }
242
        }
243
 
244
        if ((itemType()==ImageFrame || itemType()==TextFrame) && !Pfile.isEmpty()
245
                && pixm.imgInfo.layerInfo.count() != 0 && pixm.imgInfo.isRequest)
246
        {
247
                QMap<int, ImageLoadRequest>::const_iterator it2;
248
                for (it2 = pixm.imgInfo.RequestProps.begin(); it2 != pixm.imgInfo.RequestProps.end(); ++it2)
249
                {
250
                        Xml_attr psd;
8229 avox 251
                        psd.insert("Layer", toXMLString(it2.key()));
10427 cbradney 252
                        psd.insert("Visible", toXMLString(it2.value().visible));
253
                        psd.insert("useMask", toXMLString(it2.value().useMask));
254
                        psd.insert("Opacity", toXMLString(it2.value().opacity));
255
                        psd.insert("Blend", it2.value().blend);
8193 avox 256
                        handler.begin("PSDLayer", psd);
257
                        handler.end("PSDLayer");
258
                }
259
        }
14168 fschmid 260
        if (!strokePattern().isEmpty())
261
        {
262
                Xml_attr patt;
263
                patt.insert("patternS", strokePattern());
264
                double patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation;
265
                strokePatternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
266
                patt.insert("pScaleXS", toXMLString(patternScaleX));
267
                patt.insert("pScaleYS", toXMLString(patternScaleY));
268
                patt.insert("pOffsetXS", toXMLString(patternOffsetX));
269
                patt.insert("pOffsetYS", toXMLString(patternOffsetY));
270
                patt.insert("pRotationS", toXMLString(patternRotation));
271
                handler.begin("PatternStroke", patt);
272
                handler.end("PatternStroke");
273
        }
8229 avox 274
        if (gradientType() != 0)
8193 avox 275
        {
8229 avox 276
                if (gradientType() == 8)
8193 avox 277
                {
278
                        Xml_attr patt;
279
                        patt.insert("pattern", pattern());
280
                        double patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation;
8289 avox 281
                        patternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
8229 avox 282
                        patt.insert("pScaleX", toXMLString(patternScaleX));
283
                        patt.insert("pScaleY", toXMLString(patternScaleY));
284
                        patt.insert("pOffsetX", toXMLString(patternOffsetX));
285
                        patt.insert("pOffsetY", toXMLString(patternOffsetY));
286
                        patt.insert("pRotation", toXMLString(patternRotation));
8193 avox 287
                        handler.begin("Pattern", patt);
288
                        handler.end("Pattern");
289
                }
290
                else
291
                {
14150 fschmid 292
                        Xml_attr gradientV;
293
                        gradientV.insert("GRTYPE", toXMLString(GrType));
294
                        gradientV.insert("GRSTARTX", toXMLString(GrStartX));
295
                        gradientV.insert("GRSTARTY", toXMLString(GrStartY));
296
                        gradientV.insert("GRENDX", toXMLString(GrEndX));
297
                        gradientV.insert("GRENDY", toXMLString(GrEndY));
298
                        gradientV.insert("GRNAME", toXMLString(gradient()));
299
                        handler.begin("Gradient", gradientV);
10009 jghali 300
                        QList<VColorStop*> cstops = fill_gradient.colorStops();
8193 avox 301
                        for (uint cst = 0; cst < const_cast<VGradient&>(fill_gradient).Stops(); ++cst) //FIXME make const
302
                        {
303
                                Xml_attr itcl;
8229 avox 304
                                itcl.insert("RAMP", toXMLString(cstops.at(cst)->rampPoint));
8193 avox 305
                                itcl.insert("NAME", cstops.at(cst)->name);
8229 avox 306
                                itcl.insert("SHADE", toXMLString(cstops.at(cst)->shade));
307
                                itcl.insert("TRANS", toXMLString(cstops.at(cst)->opacity));
8193 avox 308
                                handler.begin("CStop",itcl);
309
                                handler.end("CStop");
310
                        }
311
                        handler.end("Gradient");
312
                }
14231 fschmid 313
                if (GrTypeStroke > 0)
314
                {
315
                        Xml_attr gradientV;
316
                        gradientV.insert("GRTYPES", toXMLString(GrTypeStroke));
317
                        gradientV.insert("GRSTARTXS", toXMLString(GrStrokeStartX));
318
                        gradientV.insert("GRSTARTYS", toXMLString(GrStrokeStartY));
319
                        gradientV.insert("GRENDXS", toXMLString(GrStrokeEndX));
320
                        gradientV.insert("GRENDYS", toXMLString(GrStrokeEndY));
321
                        gradientV.insert("GRNAMES", toXMLString(strokeGradient()));
322
                        handler.begin("GradientS", gradientV);
323
                        QList<VColorStop*> cstops = fill_gradient.colorStops();
324
                        for (uint cst = 0; cst < const_cast<VGradient&>(fill_gradient).Stops(); ++cst) //FIXME make const
325
                        {
326
                                Xml_attr itcl;
327
                                itcl.insert("RAMP", toXMLString(cstops.at(cst)->rampPoint));
328
                                itcl.insert("NAME", cstops.at(cst)->name);
329
                                itcl.insert("SHADE", toXMLString(cstops.at(cst)->shade));
330
                                itcl.insert("TRANS", toXMLString(cstops.at(cst)->opacity));
331
                                handler.begin("S_CStop",itcl);
332
                                handler.end("S_CStop");
333
                        }
334
                        handler.end("GradientS");
335
                }
8193 avox 336
        }
8229 avox 337
 
338
        // TODO: PI attributes...
339
 
8193 avox 340
        if (isAnnotation())
341
        {
342
                annotation().saxx(handler);
343
        }
8289 avox 344
        if (prevInChain() == NULL && itemText.length() > 0)
8193 avox 345
        {
8266 avox 346
                itemText.saxx(handler, "text-content");
8193 avox 347
        }
11012 mrdocs 348
 
10730 fschmid 349
        const PageItem_LatexFrame *latexframe = NULL;
11012 mrdocs 350
        if (this->realItemType() == PageItem::LatexFrame)
10730 fschmid 351
                latexframe = dynamic_cast<const PageItem_LatexFrame*>(this);
13839 fschmid 352
        if (latexframe)
353
        {
10660 cbradney 354
                handler.begin("latex-source", empty);
11012 mrdocs 355
                QMapIterator<QString, QString> i(latexframe->editorProperties);
13839 fschmid 356
                while (i.hasNext())
357
                {
11012 mrdocs 358
                        Xml_attr property;
359
                        i.next();
360
                        property.insert("name", i.key());
361
                        property.insert("value", i.value());
362
                        handler.begin("property", property);
11505 mrdocs 363
                        handler.end("property");
11012 mrdocs 364
                }
11505 mrdocs 365
                handler.chars(latexframe->formula());
10660 cbradney 366
                handler.end("latex-source");
367
        }
13839 fschmid 368
#ifdef HAVE_OSG
369
        if (this->realItemType() == PageItem::OSGFrame)
370
        {
371
                const PageItem_OSGFrame *osgitem = dynamic_cast<const PageItem_OSGFrame*>(this);
372
                if (!osgitem->Pfile.isEmpty())
373
                {
374
                        QHashIterator<QString, PageItem_OSGFrame::viewDefinition> itv(osgitem->viewMap);
375
                        while (itv.hasNext())
376
                        {
377
                                Xml_attr osg;
378
                                itv.next();
379
                                osg.insert("viewName", toXMLString(itv.key()));
380
                                osg.insert("angleFOV", toXMLString(itv.value().angleFOV));
381
                                QString tmp;
382
                                QString trackM = "";
383
                                for (uint matx = 0; matx < 4; ++matx)
384
                                {
385
                                        for (uint maty = 0; maty < 4; ++maty)
386
                                        {
387
                                                trackM += tmp.setNum(itv.value().trackerMatrix(matx, maty))+" ";
388
                                        }
389
                                }
390
                                osg.insert("trackM", trackM);
391
                                QString trackC = "";
392
                                trackC += tmp.setNum(itv.value().trackerCenter[0])+" ";
393
                                trackC += tmp.setNum(itv.value().trackerCenter[1])+" ";
394
                                trackC += tmp.setNum(itv.value().trackerCenter[2]);
395
                                osg.insert("trackC", trackC);
396
                                QString cameraP = "";
397
                                cameraP += tmp.setNum(itv.value().cameraPosition[0])+" ";
398
                                cameraP += tmp.setNum(itv.value().cameraPosition[1])+" ";
399
                                cameraP += tmp.setNum(itv.value().cameraPosition[2]);
400
                                osg.insert("cameraP", cameraP);
401
                                QString cameraU = "";
402
                                cameraU += tmp.setNum(itv.value().cameraUp[0])+" ";
403
                                cameraU += tmp.setNum(itv.value().cameraUp[1])+" ";
404
                                cameraU += tmp.setNum(itv.value().cameraUp[2]);
405
                                osg.insert("cameraU", cameraU);
406
                                osg.insert("trackerDist", toXMLString(itv.value().trackerDist));
407
                                osg.insert("trackerSize", toXMLString(itv.value().trackerSize));
408
                                osg.insert("illumination", toXMLString(itv.value().illumination));
409
                                osg.insert("rendermode", toXMLString(itv.value().rendermode));
13874 fschmid 410
                                osg.insert("trans", toXMLString(itv.value().addedTransparency));
411
                                osg.insert("colorAC", toXMLString(itv.value().colorAC.name()));
412
                                osg.insert("colorFC", toXMLString(itv.value().colorFC.name()));
13839 fschmid 413
                                handler.begin("OSGViews", osg);
414
                                handler.end("OSGViews");
415
                        }
416
                }
417
        }
418
#endif
8266 avox 419
        handler.end(elemtag);
8193 avox 420
}
8229 avox 421
 
13839 fschmid 422
#ifdef HAVE_OSG
423
class OSGViews_body : public Action_body
424
{
425
        void begin (const Xml_string& tagName, Xml_attr attr)
426
        {
427
                if (tagName=="OSGViews")
428
                {
429
                        PageItem_OSGFrame* osgframe = dynamic_cast<PageItem_OSGFrame *> (this->dig->top<PageItem>());
430
                        struct PageItem_OSGFrame::viewDefinition defaultView;
431
                        defaultView.angleFOV = parseDouble(attr["angleFOV"]);
432
                        QString tmp = "";
433
                        tmp = attr["trackM"];
434
                        ScTextStream fp(&tmp, QIODevice::ReadOnly);
435
                        double m1, m2, m3, m4;
436
                        double m5, m6, m7, m8;
437
                        double m9, m10, m11, m12;
438
                        double m13, m14, m15, m16;
439
                        fp >> m1 >> m2 >> m3 >> m4;
440
                        fp >> m5 >> m6 >> m7 >> m8;
441
                        fp >> m9 >> m10 >> m11 >> m12;
442
                        fp >> m13 >> m14 >> m15 >> m16;
443
                        defaultView.trackerMatrix.set(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16);
444
                        tmp = "";
445
                        tmp = attr["trackC"];
446
                        ScTextStream fp2(&tmp, QIODevice::ReadOnly);
447
                        double v1, v2, v3;
448
                        fp2 >> v1 >> v2 >> v3;
449
                        defaultView.trackerCenter.set(v1, v2, v3);
450
                        tmp = "";
451
                        tmp = attr["cameraP"];
452
                        ScTextStream fp3(&tmp, QIODevice::ReadOnly);
453
                        fp3 >> v1 >> v2 >> v3;
454
                        defaultView.cameraPosition.set(v1, v2, v3);
455
                        tmp = "";
456
                        tmp = attr["cameraU"];
457
                        ScTextStream fp4(&tmp, QIODevice::ReadOnly);
458
                        fp4 >> v1 >> v2 >> v3;
459
                        defaultView.cameraUp.set(v1, v2, v3);
460
                        defaultView.trackerDist = parseDouble(attr["trackerDist"]);
461
                        defaultView.trackerSize = parseDouble(attr["trackerSize"]);
462
                        defaultView.illumination = static_cast<PageItem_OSGFrame::LightType>(parseInt(attr["illumination"]));
463
                        defaultView.rendermode = static_cast<PageItem_OSGFrame::RenderType>(parseInt(attr["rendermode"]));
13874 fschmid 464
                        defaultView.addedTransparency = parseDouble(attr["trans"]);
465
                        defaultView.colorAC = QColor(attr["colorAC"]);
466
                        defaultView.colorFC = QColor(attr["colorFC"]);
13839 fschmid 467
                        QString name = attr["viewName"];
468
                        osgframe->viewMap.insert(name, defaultView);
469
                }
470
        }
471
};
8229 avox 472
 
13839 fschmid 473
class OSGViews : public MakeAction<OSGViews_body>
474
{};
475
#endif
8412 avox 476
 
8229 avox 477
class CreatePageItem_body : public Generator_body<PageItem>
478
{
8800 jghali 479
        void begin (const Xml_string& /*tagname*/, Xml_attr attr)
8229 avox 480
        {
481
                PageItem* result;
8289 avox 482
                ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
8229 avox 483
 
8289 avox 484
                PageItem::ItemType type = parseEnum<PageItem::ItemType>(attr["itemtype"]);
8326 avox 485
                PageItem::ItemFrameType frametype = PageItem::Unspecified; // parseEnum<PageItem::ItemFrameType>(attr["frame-type"]);
486
                // int ownpage = parseInt(attr["ownpage"]);
487
                // doc->setCurrentPage(doc->Pages->at(ownpage));
488
                double xpos = parseDouble(attr["xorigin"]) + doc->currentPage()->xOffset();
489
                double ypos = parseDouble(attr["yorigin"]) + doc->currentPage()->yOffset();
8229 avox 490
                double width = parseDouble(attr["width"]);
491
                double height = parseDouble(attr["height"]);
492
                double linewidth = parseDouble(attr["line-width"]);
493
                QString fillC = attr["fill-color"];
494
                QString lineC = attr["line-color"];
11582 jghali 495
                int nr = doc->itemAdd(type, frametype, xpos, ypos, width, height, linewidth, fillC, lineC, true);
8289 avox 496
                result = doc->Items->at(nr);
8229 avox 497
                this->dig->push(result);
13085 jghali 498
//              qDebug() << QString("pushed item: %1,%2 params %3,%4").arg(result->xPos()).arg(result->yPos()).arg(xpos).arg(ypos);
8229 avox 499
        }
500
};
501
 
502
class CreatePageItem : public MakeGenerator<CreatePageItem_body, PageItem>
503
{};
504
 
505
 
8266 avox 506
 
507
///   PageItem StoryText -> PageItem StoryText
508
class SetItemText_body : public Action_body
8229 avox 509
{
8800 jghali 510
        void end (const Xml_string& /*tagname*/)
8266 avox 511
        {
512
                PageItem* item = this->dig->top<PageItem>(1);
513
                StoryText* story = this->dig->top<StoryText>(0);
514
                item->itemText.clear();
515
                item->itemText.setDefaultStyle(story->defaultStyle());
516
                item->itemText.append(*story);  // story has no document attached, so we dont want to assign here
517
        }
518
};
519
 
520
class SetItemText : public MakeAction<SetItemText_body>
521
{};
522
 
8289 avox 523
 
8412 avox 524
 
525
class Gradient_body : public Action_body
526
{
8800 jghali 527
        void begin (const Xml_string& tagName, Xml_attr attr)
8412 avox 528
        {
13085 jghali 529
//              qDebug() << QString("pageitem_desaxe: gradient %1").arg(tagName);
8412 avox 530
                if (tagName=="CStop")
531
                {
9797 avox 532
//                      ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
8412 avox 533
                        PageItem* item = this->dig->top<PageItem>();
534
                        QString name = attr["NAME"];
535
                        double ramp = parseDouble(attr["RAMP"]);
536
                        int shade = parseInt(attr["SHADE"]);
537
                        double opa = parseDouble(attr["TRANS"]);
9554 jghali 538
                        // Hack : at this stage, colors may still not exists in document and SetColor would create it, 
539
                        // so use the dummy brown and update manually gradient colors in Serializer
540
                        // item->fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
541
                        item->fill_gradient.addStop( QColor(150, 100, 50) , ramp, 0.5, opa, name, shade);
8412 avox 542
                }
14231 fschmid 543
                if (tagName=="S_CStop")
8412 avox 544
                {
14231 fschmid 545
//                      ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
8412 avox 546
                        PageItem* item = this->dig->top<PageItem>();
14231 fschmid 547
                        QString name = attr["NAME"];
548
                        double ramp = parseDouble(attr["RAMP"]);
549
                        int shade = parseInt(attr["SHADE"]);
550
                        double opa = parseDouble(attr["TRANS"]);
551
                        // Hack : at this stage, colors may still not exists in document and SetColor would create it, 
552
                        // so use the dummy brown and update manually gradient colors in Serializer
553
                        // item->fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
554
                        item->stroke_gradient.addStop( QColor(150, 100, 50) , ramp, 0.5, opa, name, shade);
8412 avox 555
                }
14231 fschmid 556
                if (tagName=="GradientS")
557
                {
558
                        PageItem* item = this->dig->top<PageItem>();
559
                        item->GrTypeStroke = parseInt(attr["GRTYPES"]);
560
                        item->GrStrokeStartX = parseDouble(attr["GRSTARTXS"]);
561
                        item->GrStrokeStartY = parseDouble(attr["GRSTARTYS"]);
562
                        item->GrStrokeEndX = parseDouble(attr["GRENDXS"]);
563
                        item->GrStrokeEndY = parseDouble(attr["GRENDYS"]);
564
                        item->setStrokeGradient(attr["GRNAMES"]);
565
                        item->stroke_gradient.clearStops();
566
                }
8412 avox 567
        }
568
};
569
 
570
class Gradient : public MakeAction<Gradient_body>
571
{};
572
 
573
 
574
 
9454 avox 575
class Pattern_body : public Action_body
576
{
577
        void begin (const Xml_string& tagName, Xml_attr attr)
578
        {
579
                PageItem* item = this->dig->top<PageItem>();
580
 
581
                double patternScaleX = parseDouble(attr["pScaleX"]);
582
                double patternScaleY = parseDouble(attr["pScaleY"]);
583
                double patternOffsetX = parseDouble(attr["pOffsetX"]);
584
                double patternOffsetY = parseDouble(attr["pOffsetY"]);
585
                double patternRotation = parseDouble(attr["pRotation"]);
586
                item->setPattern(attr["pattern"]);
587
                item->setPatternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
588
        }
589
};
590
 
591
class Pattern : public MakeAction<Pattern_body>
592
{};
593
 
14168 fschmid 594
class PatternStroke_body : public Action_body
595
{
596
        void begin (const Xml_string& tagName, Xml_attr attr)
597
        {
598
                PageItem* item = this->dig->top<PageItem>();
599
 
600
                double patternScaleX = parseDouble(attr["pScaleXS"]);
601
                double patternScaleY = parseDouble(attr["pScaleYS"]);
602
                double patternOffsetX = parseDouble(attr["pOffsetXS"]);
603
                double patternOffsetY = parseDouble(attr["pOffsetYS"]);
604
                double patternRotation = parseDouble(attr["pRotationS"]);
605
                item->setStrokePattern(attr["patternS"]);
606
                item->setStrokePatternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
607
        }
608
};
9454 avox 609
 
14168 fschmid 610
class PatternStroke : public MakeAction<PatternStroke_body>
611
{};
9454 avox 612
 
14168 fschmid 613
 
614
 
8412 avox 615
class ImageEffectsAndLayers_body : public Action_body
616
{
8800 jghali 617
        void begin (const Xml_string& tagName, Xml_attr attr)
8412 avox 618
        {
13085 jghali 619
//              qDebug() << QString("pageitem_desaxe: effects/layers %1").arg(tagName);
8412 avox 620
                if (tagName=="ImageEffect")
621
                {
622
                        PageItem* obj = this->dig->top<PageItem>();
10954 jghali 623
                        struct ImageEffect ef;
8412 avox 624
                        ef.effectParameters = attr["Param"];
625
                        ef.effectCode = parseInt(attr["Code"]);
626
                        obj->effectsInUse.append(ef);
627
                }
628
                if (tagName == "PSDLayer")
629
                {
630
                        PageItem* obj = this->dig->top<PageItem>();
631
                        struct ImageLoadRequest loadingInfo;
632
                        loadingInfo.blend = attr["Blend"];
633
                        loadingInfo.opacity = parseInt(attr["Opacity"]);
634
                        loadingInfo.visible = parseBool(attr["Visible"]);
635
                        loadingInfo.useMask = parseBool(attr["useMask"]);
636
                        obj->pixm.imgInfo.RequestProps.insert(parseInt(attr["Layer"]), loadingInfo);
637
                        obj->pixm.imgInfo.isRequest = true;
638
                }
639
        }
640
};
641
 
642
class ImageEffectsAndLayers : public MakeAction<ImageEffectsAndLayers_body>
643
{};
644
 
645
 
646
 
8304 jghali 647
class LoadPicture_body : public Action_body
8289 avox 648
{
8800 jghali 649
        void end (const Xml_string& /*tagname*/)
8289 avox 650
        {
651
                PageItem* item = this->dig->top<PageItem>();
652
                if (item->itemType() == PageItem::ImageFrame)
653
                        item->loadImage(item->externalFile(), true);
654
        }
655
};
656
 
8304 jghali 657
class LoadPicture : public MakeAction<LoadPicture_body>
8289 avox 658
{};
659
 
660
 
8412 avox 661
 
8298 avox 662
class AdjustGroupIds_body : public Action_body
663
{
8800 jghali 664
        void begin (const Xml_string& tagname, Xml_attr attr)
8298 avox 665
        {
666
                if (tagname != PageItem::saxxDefaultElem)
667
                {
668
                        ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
669
                        minGroup = doc->GroupCounter;
670
                        maxGroup = minGroup - 1;
671
                }
672
        }
8289 avox 673
 
8800 jghali 674
        void end (const Xml_string& tagname)
8298 avox 675
        {
676
                if (tagname != PageItem::saxxDefaultElem)
677
                {
678
                        ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
679
                        doc->GroupCounter = maxGroup + 1;
680
                }
12388 fschmid 681
                else
682
                {
8298 avox 683
                        PageItem* item = this->dig->top<PageItem>();
9919 jghali 684
                        QStack<int> groups;
8800 jghali 685
                        for (int i=0; i < item->groups().count(); ++i)
8298 avox 686
                        {
687
                                int newGroup = minGroup + item->groups()[i];
688
                                if (newGroup > maxGroup)
689
                                        maxGroup = newGroup;
13085 jghali 690
//                              qDebug() << QString("group id %1 -> %2").arg(item->groups()[i]).arg(newGroup);
8298 avox 691
                                groups.append(newGroup);
692
                        }
693
                        item->setGroups(groups);
694
                }
695
        }
696
 
697
private:
698
        int minGroup;
699
        int maxGroup;
700
};
8289 avox 701
 
8298 avox 702
class AdjustGroupIds : public MakeAction<AdjustGroupIds_body>
703
{};
704
 
705
 
10660 cbradney 706
class LatexSource_body : public Action_body
707
{
708
        public:
709
                void chars(const Xml_string& txt)
710
                {
11012 mrdocs 711
                        if (this->dig->top<PageItem>()->realItemType() == PageItem::LatexFrame)
10730 fschmid 712
                        {
713
                                PageItem_LatexFrame* obj = dynamic_cast<PageItem_LatexFrame *> (this->dig->top<PageItem>());
714
                                obj->setFormula(txt);
715
                        }
10660 cbradney 716
                }
717
};
8298 avox 718
 
10660 cbradney 719
struct  LatexSource : public MakeAction<LatexSource_body>
720
{};
8298 avox 721
 
10660 cbradney 722
 
723
class LatexParams_body : public Action_body
724
{
725
        public:
726
                void begin(const Xml_string& tag, Xml_attr attr)
727
                {
11012 mrdocs 728
                        if (this->dig->top<PageItem>()->realItemType() == PageItem::LatexFrame)
10730 fschmid 729
                        {
730
                                PageItem_LatexFrame* obj = dynamic_cast<PageItem_LatexFrame *> (this->dig->top<PageItem>());
11505 mrdocs 731
                                obj->setConfigFile(attr["latex-configfile"]);
10730 fschmid 732
                                obj->setDpi(parseInt(attr["latex-dpi"]));
733
                                obj->setUsePreamble(parseBool(attr["latex-use-preamble"]));
734
                        }
10660 cbradney 735
                }
736
};
737
 
738
struct  LatexParams : public MakeAction<LatexParams_body>
739
{};
740
 
741
 
13839 fschmid 742
#ifdef HAVE_OSG
743
class OSGParams_body : public Action_body
744
{
745
        public:
746
                void begin(const Xml_string& tag, Xml_attr attr)
747
                {
748
                        if (this->dig->top<PageItem>()->realItemType() == PageItem::OSGFrame)
749
                        {
750
                                PageItem_OSGFrame* osgframe = dynamic_cast<PageItem_OSGFrame *> (this->dig->top<PageItem>());
751
                                osgframe->setExternalModelFile(attr["modelFile"]);
752
                                osgframe->currentView = attr["currentViewName"];
753
                                osgframe->loadModel();
754
                        }
755
                }
756
};
10660 cbradney 757
 
13839 fschmid 758
struct  OSGParams : public MakeAction<OSGParams_body>
759
{};
760
#endif
761
 
8266 avox 762
const Xml_string PageItem::saxxDefaultElem("item");
763
 
8412 avox 764
 
765
 
8834 cbradney 766
void PageItem::desaxeRules(const Xml_string& prefixPattern, Digester& ruleset, Xml_string elemtag)
8266 avox 767
{
768
        Xml_string itemPrefix(Digester::concat(prefixPattern, elemtag));
8229 avox 769
 
8289 avox 770
        // the generator CreatePageItem *requires* the Scribusdoc stored as "<scribusdoc>"
8229 avox 771
        ruleset.addRule(itemPrefix, CreatePageItem() );
772
 
8289 avox 773
        ruleset.addRule(itemPrefix, IdRef<PageItem>() );
774
//      ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>("id", toXMLString(const_cast<PageItem*>(item)->getUId())); // set automatically
8229 avox 775
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setLayer, "layer", &parseInt )); // set to activelayer in constructor
776
        static const QString dummy(""); // otherwise the next line gives a warning: default-initialization of 'const QString& desaxe::SetAttributeWithConversion_body<PageItem, const QString&>::default_', which has reference type ...
777
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setItemName, "name", dummy ));    // ... which could be ignored, but without is nicer
8289 avox 778
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::link, "nextframe" ));
8229 avox 779
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & ?PageItem::setLevel, "level", &parseInt ));  // set automatically
8289 avox 780
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::??, "itemtype", &parseInt ));  // automatically in createPageItem()
8229 avox 781
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>(?, "ownpage", &parseInt);  // set to current page in constructor
782
 
8412 avox 783
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsAnnotation,  "is-annotation", &parseBool ));
8229 avox 784
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsPDFBookmark,  "is-bookmark", &parseBool ));
785
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setPrintEnabled, "printable", &parseBool ));
786
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setLocked, "locked", &parseBool ));
787
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setSizeLocked, "size-locked", &parseBool ));
788
 
8289 avox 789
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setWidth, "width", &parseDouble ));  // also in createPageItem()
790
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setHeight, "height", &parseDouble ));  // also in createPageItem()
791
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setXPos, "xorigin", &parseDouble ));  // also in createPageItem()
792
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setYPos, "yorigin", &parseDouble ));  // also in createPageItem()
8229 avox 793
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setRotation, "rotation", &parseDouble ));
8289 avox 794
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setFillColor, "fill-color", dummy ));  // also in createPageItem()
9920 fschmid 795
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setFillShade, "fill-shade", &parseDouble ));
8229 avox 796
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setFillTransparency, "fill-transparency", &parseDouble ));
797
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setFillBlendmode, "fill-blendmode", &parseInt ));
9454 avox 798
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setGradientType, "fill-gradient-type", &parseInt ));
8229 avox 799
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,PageItem::TextFlowMode>( & PageItem::setTextFlowMode, "text-flow-mode", &parseEnum<PageItem::TextFlowMode> ));
800
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setFillEvenOdd, "frame-fill-evenodd", &parseBool ));
801
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setOverprint, "do-overprint", &parseBool ));
802
 
8289 avox 803
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setLineColor, "line-color", dummy ));  // also in createPageItem()
9920 fschmid 804
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setLineShade, "line-shade", &parseDouble ));
8229 avox 805
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setLineTransparency, "line-transparency", &parseDouble ));
806
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setLineBlendmode, "line-blendmode", &parseInt ));
8289 avox 807
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setLineWidth, "line-width", &parseDouble ));  // also in createPageItem()
8501 cbradney 808
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,Qt::PenStyle>( & PageItem::setLineStyle, "line-style", &parseEnum<Qt::PenStyle> ));
809
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,Qt::PenCapStyle>( & PageItem::setLineEnd, "line-cap", &parseEnum<Qt::PenCapStyle> ));
810
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,Qt::PenJoinStyle>( & PageItem::setLineJoin, "line-join", &parseEnum<Qt::PenJoinStyle> ));
8229 avox 811
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setCustomLineStyle, "line-customstyle", dummy )); // see comment above for setItemName
812
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setStartArrowIndex, "line-start-arrow", &parseInt ));
813
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setEndArrowIndex, "line-end-arrow", &parseInt ));
814
 
815
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setFrameType, "frame-type", &parseInt ));
8800 jghali 816
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem, FPointArray>( & PageItem::setShape, "frame-shape", &parseSVG ));
8229 avox 817
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasDefaultShape, "frame-has-default-shape", &parseBool ));       
818
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setCornerRadius, "corner-radius", &parseDouble ));
819
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,FPointArray>( & PageItem::setContour, "frame-contour", &parseSVG ));
820
 
821
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistLeft, "left-distance", &parseDouble ));
822
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistTop, "top-distance", &parseDouble ));
823
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistBottom, "bottom-distance", &parseDouble ));
824
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistRight, "right-distance", &parseDouble ));
12269 cbradney 825
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,FirstLineOffsetPolicy>( & PageItem::setFirstLineOffset, "first-line-offset", &parseEnum ));
826
 
8229 avox 827
 
828
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsAutoFrame, "text-autoframe", &parseBool ));
829
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setColumns, "text-columns", &parseInt ));
830
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setColumnGap, "text-columngap", &parseDouble ));
831
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setReversed, "text-reversed", &parseBool ));
832
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setPathTextType, "pathtext-type", &parseInt ));
833
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setFlipPathText, "pathtext-flipped", &parseBool ));
834
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setPathTextBaseOffset, "pathtext-baseoffset", &parseDouble));
835
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setPathTextShowFrame, "pathtext-showpath", &parseBool ));
836
 
837
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setFitImageToFrame, "image-scale-framesize", &parseBool ));
838
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setKeepAspectRatio, "image-scale-proportional", &parseBool ));
839
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageXScale, "image-x-scale", &parseDouble ));
840
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageYScale, "image-y-scale", &parseDouble ));
841
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageXOffset, "image-x-position", &parseDouble ));
842
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageYOffset, "image-y-position", &parseDouble ));
13949 fschmid 843
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setImagePagenumber, "pagenumber", &parseInt ));
8229 avox 844
        //      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>("image-x-dpi", &parseDouble ));  //NYI
845
        //      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>("image-y-dpi", &parseDouble ));  //NYI
846
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageShown, "image-shown", &parseBool ));
847
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setUseEmbeddedImageProfile, "image-use-embedded", &parseBool ));
848
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setEmbeddedImageProfile, "image-embedded-profile" ));
849
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageFlippedH, "image-flipped-hor", &parseBool ));
850
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageFlippedV, "image-flipped-vert", &parseBool ));
851
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setCmsProfile, "cms-profile" ));
14170 jghali 852
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem, eRenderIntent>( & PageItem::setCmsRenderingIntent, "cms-intent", &parseIntent ));
8229 avox 853
 
854
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setControlsGroup, "isGroupControl", &parseBool ));
8289 avox 855
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setGroupsLastItem, "groupsLastItem" ));
9919 jghali 856
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,QStack<int> >( & PageItem::setGroups, "groups", &parseIntStack ));
8229 avox 857
 
8289 avox 858
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsTableItem, "isTableItem", &parseBool ));
859
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setTopLink, "TopLink" ));
860
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setLeftLink, "LeftLink" ));
861
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setRightLink, "RightLink" ));
862
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setBottomLink, "BottomLink" ));
863
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasTopLine, "TopLine", &parseBool ));
864
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasLeftLine, "LeftLine", &parseBool ));
865
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasRightLine, "RightLine", &parseBool ));
866
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasBottomLine, "BottomLine", &parseBool ));
8229 avox 867
 
9454 avox 868
        ruleset.addRule(Digester::concat(itemPrefix, "Pattern"), Pattern());
14168 fschmid 869
        ruleset.addRule(Digester::concat(itemPrefix, "PatternStroke"), PatternStroke());
8412 avox 870
 
871
        Gradient gradient;
872
        Xml_string gradientPrefix(Digester::concat(itemPrefix, "Gradient"));
873
        ruleset.addRule(gradientPrefix, gradient);
874
        ruleset.addRule(Digester::concat(gradientPrefix, "CStop"), gradient);
14231 fschmid 875
        Gradient gradientS;
876
        Xml_string gradientPrefixS(Digester::concat(itemPrefix, "GradientS"));
877
        ruleset.addRule(gradientPrefixS, gradientS);
878
        ruleset.addRule(Digester::concat(gradientPrefixS, "S_CStop"), gradientS);
8412 avox 879
 
880
        ImageEffectsAndLayers effectsAndLayers;
881
        ruleset.addRule(Digester::concat(itemPrefix, "ImageEffect"), effectsAndLayers);
882
        ruleset.addRule(Digester::concat(itemPrefix, "PSDLayer"), effectsAndLayers);
883
 
884
        Annotation::desaxeRules(itemPrefix, ruleset);
885
        ruleset.addRule(Digester::concat(itemPrefix, Annotation::saxxDefaultElem),
886
                                        SetterWithConversion<PageItem,const Annotation&,Annotation>( & PageItem::setAnnotation ));
887
 
8289 avox 888
        // TODO: obj attributes
889
 
8229 avox 890
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setExternalFile, "image-file" ));
13839 fschmid 891
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageInline, "isInlineImage", &parseBool ));
892
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setInlineExt, "inlineImageExt" ));
893
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setInlineData, "ImageData" ));
8229 avox 894
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setFileIconPressed, "icon-pressed-file" ));
895
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setFileIconRollover, "icon-rollover-file" ));
10660 cbradney 896
        ruleset.addRule("latex-source", LatexSource());
897
        ruleset.addRule(itemPrefix, LatexParams());
13839 fschmid 898
#ifdef HAVE_OSG
899
        ruleset.addRule(itemPrefix, OSGParams());
900
        OSGViews osgViewset;
901
        ruleset.addRule(Digester::concat(itemPrefix, "OSGViews"), osgViewset);
902
#endif
8229 avox 903
 
12055 jghali 904
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,QVector<double> >( & PageItem::setDashes, "line-dashes", &parseDoubleVector ));
8229 avox 905
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setDashOffset, "line-dash-offset", &parseDouble ));
8266 avox 906
 
907
        StoryText::desaxeRules(itemPrefix, ruleset, "text-content");
908
        Xml_string storyPrefix = Digester::concat(itemPrefix, "text-content");
909
        ruleset.addRule(storyPrefix, SetItemText());
8289 avox 910
 
8304 jghali 911
        ruleset.addRule(itemPrefix, LoadPicture());
8298 avox 912
 
12388 fschmid 913
//      AdjustGroupIds adjustGroupIds;
914
//      ruleset.addRule("/", adjustGroupIds);
915
//      ruleset.addRule(PageItem::saxxDefaultElem, adjustGroupIds);
8298 avox 916
 
8266 avox 917
}