Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
8193 avox 1
 
2
 
3
 
4
#include "pageitem.h"
5
#include "util.h"
8229 avox 6
#include "desaxe/simple_actions.h"
8193 avox 7
#include "desaxe/saxiohelper.h"
8229 avox 8
#include "pageitem_imageframe.h"
9
#include "pageitem_textframe.h"
10
#include "pageitem_pathtext.h"
11
#include "pageitem_polyline.h"
12
#include "pageitem_polygon.h"
13
#include "pageitem_line.h"
14
#include "scribusdoc.h"
8412 avox 15
#include "colorutil.h"
8193 avox 16
 
8229 avox 17
 
8193 avox 18
using namespace desaxe;
19
 
20
 
21
 
8807 jghali 22
FPointArray parseSVG(const Xml_string& str)
8229 avox 23
{
24
        FPointArray result;
25
        result.parseSVG(str);
26
        return result;
27
}
28
 
29
 
8289 avox 30
static Xml_attr PageItemXMLAttributes(const PageItem* item)
8193 avox 31
{
32
        Xml_attr result;
33
 
8333 avox 34
        result.insert("id", "obj" + toXMLString(const_cast<PageItem*>(item)->getUId()));
8399 fschmid 35
        if (!item->AutoName)
36
                result.insert("name", item->itemName());
8193 avox 37
        const PageItem* nxt = item->nextInChain();
38
        if (nxt)
8394 avox 39
                result.insert("nextframe", "obj" + toXMLString(nxt->getUId()));
8229 avox 40
        result.insert("layer", toXMLString(item->LayerNr));
41
        result.insert("level", toXMLString(item->ItemNr));
42
        result.insert("itemtype", toXMLString(item->itemType()));
8193 avox 43
 
8412 avox 44
        result.insert("is-annotation", toXMLString(item->isAnnotation()));
8229 avox 45
        result.insert("is-bookmark", toXMLString(item->isPDFBookmark()));
46
        result.insert("printable", toXMLString(item->printEnabled()));
47
        result.insert("locked", toXMLString(item->locked()));
48
        result.insert("size-locked", toXMLString(item->sizeLocked()));
8193 avox 49
 
8229 avox 50
        result.insert("width", toXMLString(item->width()));
51
        result.insert("height", toXMLString(item->height()));
8326 avox 52
        result.insert("ownpage", toXMLString(item->OwnPage));
53
        Page* page = item->doc()->Pages->at(item->OwnPage);
54
        if (page)
55
        {
56
                result.insert("xorigin", toXMLString(item->xPos() - page->xOffset()));
57
                result.insert("yorigin", toXMLString(item->yPos() - page->yOffset()));
58
        }
59
        else
60
        {
61
                result.insert("xorigin", toXMLString(item->xPos()));
62
                result.insert("yorigin", toXMLString(item->yPos()));
63
        }
8229 avox 64
        result.insert("rotation", toXMLString(item->rotation()));
8193 avox 65
        result.insert("fill-color", item->fillColor());
8229 avox 66
        result.insert("fill-shade", toXMLString(item->fillShade()));
67
        result.insert("fill-transparency", toXMLString(item->fillTransparency()));
68
        result.insert("fill-blendmode", toXMLString(item->fillBlendmode()));
69
        result.insert("fill-gradient-type", toXMLString(item->gradientType()));
70
        result.insert("fill-evenodd", toXMLString(item->fillEvenOdd()));
71
        result.insert("do-overprint", toXMLString(item->overprint()));
8193 avox 72
 
73
        result.insert("line-color", item->lineColor());
8229 avox 74
        result.insert("line-shade", toXMLString(item->lineShade()));
75
        result.insert("line-transparency", toXMLString(item->lineTransparency()));
76
        result.insert("line-blendmode", toXMLString(item->lineBlendmode()));
77
        result.insert("line-width", toXMLString(item->lineWidth()));
78
        result.insert("line-style", toXMLString(item->PLineArt));
79
        result.insert("line-cap", toXMLString(item->PLineEnd));
80
        result.insert("line-join", toXMLString(item->PLineJoin));
81
        result.insert("line-customstyle", item->customLineStyle());
82
        result.insert("line-start-arrow", toXMLString(item->startArrowIndex()));
83
        result.insert("line-end-arrow", toXMLString(item->endArrowIndex()));
8193 avox 84
 
8229 avox 85
        result.insert("frame-type", toXMLString(item->frameType()));
86
        result.insert("frame-shape", toXMLString(item->shape()));
87
        result.insert("frame-has-default-shape", toXMLString(item->hasDefaultShape()));
88
        result.insert("corner-radius", toXMLString(item->cornerRadius()));     
89
        result.insert("frame-contour", toXMLString(item->contour()));
90
        result.insert("text-flow-mode", toXMLString((int) item->textFlowMode() ));
8193 avox 91
 
8229 avox 92
        result.insert("left-distance", toXMLString(item->textToFrameDistLeft()));
93
        result.insert("top-distance", toXMLString(item->textToFrameDistTop()));
94
        result.insert("bottom-distance", toXMLString(item->textToFrameDistBottom()));
95
        result.insert("right-distance", toXMLString(item->textToFrameDistRight()));
8193 avox 96
 
8229 avox 97
        result.insert("text-autoframes", toXMLString(item->isAutoFrame()));
98
        result.insert("text-columns", toXMLString(item->columns()));
99
        result.insert("text-columngap", toXMLString(item->columnGap()));
100
        result.insert("text-reversed", toXMLString(item->reversed()));
101
        result.insert("pathtext-type", toXMLString(item->pathTextType()));
102
        result.insert("pathtext-flipped", toXMLString(item->flipPathText()));
103
        result.insert("pathtext-baseoffset", toXMLString(item->pathTextBaseOffset()));
104
        result.insert("pathtext-showpath", toXMLString(item->pathTextShowFrame()));
8193 avox 105
 
8229 avox 106
        result.insert("image-scale-framesize", toXMLString(item->fitImageToFrame()));
107
        result.insert("image-scale-proportional", toXMLString(item->keepAspectRatio()));
108
        result.insert("image-x-scale", toXMLString(item->imageXScale()));
109
        result.insert("image-y-scale", toXMLString(item->imageYScale()));
110
        result.insert("image-x-position", toXMLString(item->imageXOffset()));
111
        result.insert("image-y-position", toXMLString(item->imageYOffset()));
112
        //      result.insert("image-x-dpi", toXMLString(item->imageXDpi()));
113
        //      result.insert("image-y-dpi", toXMLString(item->imageYDpi()));
114
        result.insert("image-shown", toXMLString(item->imageShown()));
115
        result.insert("image-use-embedded", toXMLString(item->useEmbeddedImageProfile()));
116
        result.insert("image-embedded-profile", item->embeddedImageProfile());
117
        result.insert("image-flipped-hor", toXMLString(item->imageFlippedH()));
118
        result.insert("image-flipped-vert", toXMLString(item->imageFlippedV()));
119
        result.insert("cms-profile", item->cmsProfile());
120
        result.insert("cms-intent", toXMLString(item->cmsRenderingIntent()));
8193 avox 121
 
8326 avox 122
        if (item->groups().count() > 0)
8193 avox 123
        {
8326 avox 124
                QString grouplist = "";
125
                QValueStack<int>::const_iterator it;
126
                for (it = item->groups().begin(); it != item->groups().end(); ++it)
127
                        grouplist += toXMLString( *it ) + " "; 
128
                result.insert("groups", toXMLString(grouplist));
129
                result.insert("isGroupControl", toXMLString(item->controlsGroup()));
130
                if (item->isGroupControl)
131
                {
132
                        if (item->groupsLastItem != 0)
8394 avox 133
                                result.insert("groupsLastItem", "obj" + toXMLString(item->groupsLastItem->getUId()));
8326 avox 134
                }
8193 avox 135
        }
136
 
8229 avox 137
        result.insert("isTableItem", toXMLString(item->isTableItem));
8193 avox 138
        if (item->isTableItem)
139
        {
8326 avox 140
                result.insert("TopLine", toXMLString(item->TopLine));
141
                result.insert("LeftLine", toXMLString(item->LeftLine));
142
                result.insert("RightLine", toXMLString(item->RightLine));
143
                result.insert("BottomLine", toXMLString(item->BottomLine));
8193 avox 144
                if (item->TopLink != 0)
8394 avox 145
                        result.insert("TopLINK", "obj" + toXMLString(item->TopLink->getUId()));
8193 avox 146
                if (item->LeftLink != 0)
8394 avox 147
                        result.insert("LeftLINK", "obj" + toXMLString(item->LeftLink->getUId()));
8193 avox 148
                if (item->RightLink != 0)
8394 avox 149
                        result.insert("RightLINK", "obj" + toXMLString(item->RightLink->getUId()));
8193 avox 150
                if (item->BottomLink != 0)
8394 avox 151
                        result.insert("BottomLINK", "obj" + toXMLString(item->BottomLink->getUId()));
8193 avox 152
        }
153
 
8229 avox 154
//      result.insert("ANNAME", !item->AutoName ? item->itemName() : QString(""));  // not used
155
 
156
        if ((item->itemType()==PageItem::ImageFrame || item->itemType()==PageItem::TextFrame) && (!item->externalFile().isEmpty()))
157
                result.insert("image-file", Path2Relative(item->externalFile()));
158
        if (!item->fileIconPressed().isEmpty())
159
                result.insert("icon-pressed-file", Path2Relative(item->fileIconPressed()));
160
        if (!item->fileIconRollover().isEmpty())
161
                result.insert("icon-rollover-file", Path2Relative(item->fileIconRollover()));  
162
 
163
        if (item->dashes().count() > 0)
164
                result.insert("line-dashes", toXMLString(item->dashes()));
165
        if (item->dashOffset() != 0.0)
166
                result.insert("line-dash-offset", toXMLString(item->dashOffset()));
8193 avox 167
        return result;
168
}      
169
 
8412 avox 170
 
8807 jghali 171
void PageItem::saxx(SaxHandler& handler, const Xml_string& elemtag) const
8193 avox 172
{
8289 avox 173
        Xml_attr att(PageItemXMLAttributes(this));
8266 avox 174
        Xml_attr dumm;
175
//      qDebug(QString("PageItem::saxx %1 %2").arg((ulong) &handler));
176
        handler.begin(elemtag, att);
8193 avox 177
 
178
        if (effectsInUse.count() != 0)
179
        {
180
                for (uint a = 0; a < effectsInUse.count(); ++a)
181
                {
182
                        Xml_attr imeff;
8229 avox 183
                        imeff.insert("Code", toXMLString((*effectsInUse.at(a)).effectCode));
8193 avox 184
                        imeff.insert("Param", (*effectsInUse.at(a)).effectParameters);
185
                        handler.begin("ImageEffect", imeff);
186
                        handler.end("ImageEffect");
187
                }
188
        }
189
 
190
        if ((itemType()==ImageFrame || itemType()==TextFrame) && !Pfile.isEmpty()
191
                && pixm.imgInfo.layerInfo.count() != 0 && pixm.imgInfo.isRequest)
192
        {
193
                QMap<int, ImageLoadRequest>::const_iterator it2;
194
                for (it2 = pixm.imgInfo.RequestProps.begin(); it2 != pixm.imgInfo.RequestProps.end(); ++it2)
195
                {
196
                        Xml_attr psd;
8229 avox 197
                        psd.insert("Layer", toXMLString(it2.key()));
198
                        psd.insert("Visible", toXMLString(it2.data().visible));
199
                        psd.insert("useMask", toXMLString(it2.data().useMask));
200
                        psd.insert("Opacity", toXMLString(it2.data().opacity));
8193 avox 201
                        psd.insert("Blend", it2.data().blend);
202
                        handler.begin("PSDLayer", psd);
203
                        handler.end("PSDLayer");
204
                }
205
        }
8229 avox 206
        if (gradientType() != 0)
8193 avox 207
        {
8229 avox 208
                if (gradientType() == 8)
8193 avox 209
                {
210
                        Xml_attr patt;
211
                        patt.insert("pattern", pattern());
212
                        double patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation;
8289 avox 213
                        patternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
8229 avox 214
                        patt.insert("pScaleX", toXMLString(patternScaleX));
215
                        patt.insert("pScaleY", toXMLString(patternScaleY));
216
                        patt.insert("pOffsetX", toXMLString(patternOffsetX));
217
                        patt.insert("pOffsetY", toXMLString(patternOffsetY));
218
                        patt.insert("pRotation", toXMLString(patternRotation));
8193 avox 219
                        handler.begin("Pattern", patt);
220
                        handler.end("Pattern");
221
                }
222
                else
223
                {
224
                        Xml_attr gradient;
8412 avox 225
                        gradient.insert("GRTYPE", toXMLString(GrType));
8229 avox 226
                        gradient.insert("GRSTARTX", toXMLString(GrStartX));
227
                        gradient.insert("GRSTARTY", toXMLString(GrStartY));
228
                        gradient.insert("GRENDX", toXMLString(GrEndX));
229
                        gradient.insert("GRENDY", toXMLString(GrEndY));
8193 avox 230
                        handler.begin("Gradient", gradient);
231
                        QPtrVector<VColorStop> cstops = fill_gradient.colorStops();
232
                        for (uint cst = 0; cst < const_cast<VGradient&>(fill_gradient).Stops(); ++cst) //FIXME make const
233
                        {
234
                                Xml_attr itcl;
8229 avox 235
                                itcl.insert("RAMP", toXMLString(cstops.at(cst)->rampPoint));
8193 avox 236
                                itcl.insert("NAME", cstops.at(cst)->name);
8229 avox 237
                                itcl.insert("SHADE", toXMLString(cstops.at(cst)->shade));
238
                                itcl.insert("TRANS", toXMLString(cstops.at(cst)->opacity));
8193 avox 239
                                handler.begin("CStop",itcl);
240
                                handler.end("CStop");
241
                        }
242
                        handler.end("Gradient");
243
                }
244
        }
8229 avox 245
 
246
        // TODO: PI attributes...
247
 
8193 avox 248
        if (isAnnotation())
249
        {
250
                annotation().saxx(handler);
251
        }
8289 avox 252
        if (prevInChain() == NULL && itemText.length() > 0)
8193 avox 253
        {
8266 avox 254
                itemText.saxx(handler, "text-content");
8193 avox 255
        }
8266 avox 256
        handler.end(elemtag);
8193 avox 257
}
8229 avox 258
 
259
 
8412 avox 260
 
8229 avox 261
class CreatePageItem_body : public Generator_body<PageItem>
262
{
8832 avox 263
        void begin (const Xml_string& /*tagname*/, Xml_attr attr)
8229 avox 264
        {
265
                PageItem* result;
8289 avox 266
                ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
8229 avox 267
 
8289 avox 268
                PageItem::ItemType type = parseEnum<PageItem::ItemType>(attr["itemtype"]);
8326 avox 269
                PageItem::ItemFrameType frametype = PageItem::Unspecified; // parseEnum<PageItem::ItemFrameType>(attr["frame-type"]);
270
                // int ownpage = parseInt(attr["ownpage"]);
271
                // doc->setCurrentPage(doc->Pages->at(ownpage));
272
                double xpos = parseDouble(attr["xorigin"]) + doc->currentPage()->xOffset();
273
                double ypos = parseDouble(attr["yorigin"]) + doc->currentPage()->yOffset();
8229 avox 274
                double width = parseDouble(attr["width"]);
275
                double height = parseDouble(attr["height"]);
276
                double linewidth = parseDouble(attr["line-width"]);
277
                QString fillC = attr["fill-color"];
278
                QString lineC = attr["line-color"];
8289 avox 279
                int nr = doc->itemAdd(type, frametype, xpos, ypos, width, height, linewidth, fillC, lineC, false);
280
                result = doc->Items->at(nr);
8229 avox 281
                this->dig->push(result);
9452 avox 282
//              qDebug(QString("pushed item: %1,%2 params %3,%4").arg(result->xPos()).arg(result->yPos()).arg(xpos).arg(ypos));
8229 avox 283
        }
284
};
285
 
286
class CreatePageItem : public MakeGenerator<CreatePageItem_body, PageItem>
287
{};
288
 
289
 
8266 avox 290
 
291
///   PageItem StoryText -> PageItem StoryText
292
class SetItemText_body : public Action_body
8229 avox 293
{
8832 avox 294
        void end (const Xml_string& /*tagname*/)
8266 avox 295
        {
296
                PageItem* item = this->dig->top<PageItem>(1);
297
                StoryText* story = this->dig->top<StoryText>(0);
298
                item->itemText.clear();
299
                item->itemText.setDefaultStyle(story->defaultStyle());
300
                item->itemText.append(*story);  // story has no document attached, so we dont want to assign here
301
        }
302
};
303
 
304
class SetItemText : public MakeAction<SetItemText_body>
305
{};
306
 
8289 avox 307
 
8412 avox 308
 
309
class Gradient_body : public Action_body
310
{
8832 avox 311
        void begin (const Xml_string& tagName, Xml_attr attr)
8412 avox 312
        {
9452 avox 313
//              qDebug(QString("pageitem_desaxe: gradient %1").arg(tagName));
8412 avox 314
                if (tagName=="CStop")
315
                {
316
                        PageItem* item = this->dig->top<PageItem>();
317
                        QString name = attr["NAME"];
318
                        double ramp = parseDouble(attr["RAMP"]);
319
                        int shade = parseInt(attr["SHADE"]);
320
                        double opa = parseDouble(attr["TRANS"]);
9553 jghali 321
                        // Hack : at this stage, colors may still not exists in document and SetColor would create it, 
322
                        // so use the dummy brown and update manually gradient colors in Serializer
323
                        // item->fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
324
                        item->fill_gradient.addStop( QColor(150, 100, 50) , ramp, 0.5, opa, name, shade);
8412 avox 325
                }
326
                if (tagName=="Gradient")
327
                {
328
                        PageItem* item = this->dig->top<PageItem>();
329
                        item->GrType = parseInt(attr["GRTYPE"]);
330
                        item->GrStartX = parseDouble(attr["GRSTARTX"]);
331
                        item->GrStartY = parseDouble(attr["GRSTARTY"]);
332
                        item->GrEndX = parseDouble(attr["GRENDX"]);
333
                        item->GrEndY = parseDouble(attr["GRENDY"]);
8421 avox 334
                        item->fill_gradient.clearStops();
8412 avox 335
                }
336
        }
337
};
338
 
339
class Gradient : public MakeAction<Gradient_body>
340
{};
341
 
342
 
9450 avox 343
 
9449 avox 344
class Pattern_body : public Action_body
345
{
346
        void begin (const Xml_string& tagName, Xml_attr attr)
347
        {
348
                PageItem* item = this->dig->top<PageItem>();
349
 
350
                double patternScaleX = parseDouble(attr["pScaleX"]);
351
                double patternScaleY = parseDouble(attr["pScaleY"]);
352
                double patternOffsetX = parseDouble(attr["pOffsetX"]);
353
                double patternOffsetY = parseDouble(attr["pOffsetY"]);
354
                double patternRotation = parseDouble(attr["pRotation"]);
9452 avox 355
//              qDebug(QString("pageitem_desaxe: pattern %6: *(%1,%2) +(%3,%4) °%5").arg(patternScaleX).arg(patternScaleY).arg(patternOffsetX).arg(patternOffsetY).arg(patternRotation).arg(attr["pattern"]));
8412 avox 356
 
9449 avox 357
                item->setPattern(attr["pattern"]);
358
                item->setPatternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
359
        }
360
};
361
 
362
class Pattern : public MakeAction<Pattern_body>
363
{};
364
 
365
 
366
 
8412 avox 367
class ImageEffectsAndLayers_body : public Action_body
368
{
8832 avox 369
        void begin (const Xml_string& tagName, Xml_attr attr)
8412 avox 370
        {
9452 avox 371
//              qDebug(QString("pageitem_desaxe: effects/layers %1").arg(tagName));
8412 avox 372
                if (tagName=="ImageEffect")
373
                {
374
                        PageItem* obj = this->dig->top<PageItem>();
375
                        struct ScImage::imageEffect ef;
376
                        ef.effectParameters = attr["Param"];
377
                        ef.effectCode = parseInt(attr["Code"]);
378
                        obj->effectsInUse.append(ef);
379
                }
380
                if (tagName == "PSDLayer")
381
                {
382
                        PageItem* obj = this->dig->top<PageItem>();
383
                        struct ImageLoadRequest loadingInfo;
384
                        loadingInfo.blend = attr["Blend"];
385
                        loadingInfo.opacity = parseInt(attr["Opacity"]);
386
                        loadingInfo.visible = parseBool(attr["Visible"]);
387
                        loadingInfo.useMask = parseBool(attr["useMask"]);
388
                        obj->pixm.imgInfo.RequestProps.insert(parseInt(attr["Layer"]), loadingInfo);
389
                        obj->pixm.imgInfo.isRequest = true;
390
                }
391
        }
392
};
393
 
394
class ImageEffectsAndLayers : public MakeAction<ImageEffectsAndLayers_body>
395
{};
396
 
397
 
398
 
8304 jghali 399
class LoadPicture_body : public Action_body
8289 avox 400
{
8832 avox 401
        void end (const Xml_string& /*tagname*/)
8289 avox 402
        {
403
                PageItem* item = this->dig->top<PageItem>();
404
                if (item->itemType() == PageItem::ImageFrame)
405
                        item->loadImage(item->externalFile(), true);
406
        }
407
};
408
 
8304 jghali 409
class LoadPicture : public MakeAction<LoadPicture_body>
8289 avox 410
{};
411
 
412
 
8412 avox 413
 
8298 avox 414
class AdjustGroupIds_body : public Action_body
415
{
8832 avox 416
        void begin (const Xml_string& tagname, Xml_attr attr)
8298 avox 417
        {
418
                if (tagname != PageItem::saxxDefaultElem)
419
                {
420
                        ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
421
                        minGroup = doc->GroupCounter;
422
                        maxGroup = minGroup - 1;
423
                }
424
        }
8289 avox 425
 
8832 avox 426
        void end (const Xml_string& tagname)
8298 avox 427
        {
428
                if (tagname != PageItem::saxxDefaultElem)
429
                {
430
                        ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
431
                        doc->GroupCounter = maxGroup + 1;
432
                }
433
                else {
434
                        PageItem* item = this->dig->top<PageItem>();
435
                        QValueStack<int> groups;
436
                        for (uint i=0; i < item->groups().count(); ++i)
437
                        {
438
                                int newGroup = minGroup + item->groups()[i];
439
                                if (newGroup > maxGroup)
440
                                        maxGroup = newGroup;
9452 avox 441
//                              qDebug(QString("group id %1 -> %2").arg(item->groups()[i]).arg(newGroup));
8298 avox 442
                                groups.append(newGroup);
443
                        }
444
                        item->setGroups(groups);
445
                }
446
        }
447
 
448
private:
449
        int minGroup;
450
        int maxGroup;
451
};
8289 avox 452
 
8298 avox 453
class AdjustGroupIds : public MakeAction<AdjustGroupIds_body>
454
{};
455
 
456
 
457
 
458
 
8266 avox 459
const Xml_string PageItem::saxxDefaultElem("item");
460
 
8412 avox 461
 
462
 
8832 avox 463
void PageItem::desaxeRules(const Xml_string& prefixPattern, Digester& ruleset, Xml_string elemtag)
8266 avox 464
{
465
        Xml_string itemPrefix(Digester::concat(prefixPattern, elemtag));
8229 avox 466
 
8289 avox 467
        // the generator CreatePageItem *requires* the Scribusdoc stored as "<scribusdoc>"
8229 avox 468
        ruleset.addRule(itemPrefix, CreatePageItem() );
469
 
8289 avox 470
        ruleset.addRule(itemPrefix, IdRef<PageItem>() );
471
//      ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>("id", toXMLString(const_cast<PageItem*>(item)->getUId())); // set automatically
8229 avox 472
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setLayer, "layer", &parseInt )); // set to activelayer in constructor
473
        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 ...
474
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setItemName, "name", dummy ));    // ... which could be ignored, but without is nicer
8289 avox 475
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::link, "nextframe" ));
8229 avox 476
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & ?PageItem::setLevel, "level", &parseInt ));  // set automatically
8289 avox 477
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::??, "itemtype", &parseInt ));  // automatically in createPageItem()
8229 avox 478
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>(?, "ownpage", &parseInt);  // set to current page in constructor
479
 
8412 avox 480
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsAnnotation,  "is-annotation", &parseBool ));
8229 avox 481
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsPDFBookmark,  "is-bookmark", &parseBool ));
482
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setPrintEnabled, "printable", &parseBool ));
483
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setLocked, "locked", &parseBool ));
484
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setSizeLocked, "size-locked", &parseBool ));
485
 
8289 avox 486
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setWidth, "width", &parseDouble ));  // also in createPageItem()
487
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setHeight, "height", &parseDouble ));  // also in createPageItem()
488
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setXPos, "xorigin", &parseDouble ));  // also in createPageItem()
489
//      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setYPos, "yorigin", &parseDouble ));  // also in createPageItem()
8229 avox 490
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setRotation, "rotation", &parseDouble ));
8289 avox 491
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setFillColor, "fill-color", dummy ));  // also in createPageItem()
8229 avox 492
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setFillShade, "fill-shade", &parseInt ));
493
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setFillTransparency, "fill-transparency", &parseDouble ));
494
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setFillBlendmode, "fill-blendmode", &parseInt ));
9449 avox 495
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setGradientType, "fill-gradient-type", &parseInt ));
8229 avox 496
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,PageItem::TextFlowMode>( & PageItem::setTextFlowMode, "text-flow-mode", &parseEnum<PageItem::TextFlowMode> ));
497
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setFillEvenOdd, "frame-fill-evenodd", &parseBool ));
498
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setOverprint, "do-overprint", &parseBool ));
499
 
8289 avox 500
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setLineColor, "line-color", dummy ));  // also in createPageItem()
8229 avox 501
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setLineShade, "line-shade", &parseInt ));
502
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setLineTransparency, "line-transparency", &parseDouble ));
503
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setLineBlendmode, "line-blendmode", &parseInt ));
8289 avox 504
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setLineWidth, "line-width", &parseDouble ));  // also in createPageItem()
8229 avox 505
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,PenStyle>( & PageItem::setLineStyle, "line-style", &parseEnum<PenStyle> ));
506
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,PenCapStyle>( & PageItem::setLineEnd, "line-cap", &parseEnum<PenCapStyle> ));
507
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,PenJoinStyle>( & PageItem::setLineJoin, "line-join", &parseEnum<PenJoinStyle> ));
508
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setCustomLineStyle, "line-customstyle", dummy )); // see comment above for setItemName
509
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setStartArrowIndex, "line-start-arrow", &parseInt ));
510
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setEndArrowIndex, "line-end-arrow", &parseInt ));
511
 
512
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setFrameType, "frame-type", &parseInt ));
513
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,FPointArray>( & PageItem::setShape, "frame-shape", &parseSVG ));
514
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasDefaultShape, "frame-has-default-shape", &parseBool ));       
515
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setCornerRadius, "corner-radius", &parseDouble ));
516
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,FPointArray>( & PageItem::setContour, "frame-contour", &parseSVG ));
517
 
518
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistLeft, "left-distance", &parseDouble ));
519
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistTop, "top-distance", &parseDouble ));
520
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistBottom, "bottom-distance", &parseDouble ));
521
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistRight, "right-distance", &parseDouble ));
522
 
523
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsAutoFrame, "text-autoframe", &parseBool ));
524
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setColumns, "text-columns", &parseInt ));
525
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setColumnGap, "text-columngap", &parseDouble ));
526
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setReversed, "text-reversed", &parseBool ));
527
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setPathTextType, "pathtext-type", &parseInt ));
528
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setFlipPathText, "pathtext-flipped", &parseBool ));
529
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setPathTextBaseOffset, "pathtext-baseoffset", &parseDouble));
530
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setPathTextShowFrame, "pathtext-showpath", &parseBool ));
531
 
532
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setFitImageToFrame, "image-scale-framesize", &parseBool ));
533
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setKeepAspectRatio, "image-scale-proportional", &parseBool ));
534
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageXScale, "image-x-scale", &parseDouble ));
535
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageYScale, "image-y-scale", &parseDouble ));
536
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageXOffset, "image-x-position", &parseDouble ));
537
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageYOffset, "image-y-position", &parseDouble ));
538
        //      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>("image-x-dpi", &parseDouble ));  //NYI
539
        //      ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>("image-y-dpi", &parseDouble ));  //NYI
540
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageShown, "image-shown", &parseBool ));
541
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setUseEmbeddedImageProfile, "image-use-embedded", &parseBool ));
542
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setEmbeddedImageProfile, "image-embedded-profile" ));
543
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageFlippedH, "image-flipped-hor", &parseBool ));
544
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageFlippedV, "image-flipped-vert", &parseBool ));
545
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setCmsProfile, "cms-profile" ));
546
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setCmsRenderingIntent, "cms-intent", &parseInt ));
547
 
548
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setControlsGroup, "isGroupControl", &parseBool ));
8289 avox 549
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setGroupsLastItem, "groupsLastItem" ));
8229 avox 550
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,QValueStack<int> >( & PageItem::setGroups, "groups", &parseIntStack ));
551
 
8289 avox 552
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsTableItem, "isTableItem", &parseBool ));
553
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setTopLink, "TopLink" ));
554
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setLeftLink, "LeftLink" ));
555
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setRightLink, "RightLink" ));
556
        ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setBottomLink, "BottomLink" ));
557
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasTopLine, "TopLine", &parseBool ));
558
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasLeftLine, "LeftLine", &parseBool ));
559
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasRightLine, "RightLine", &parseBool ));
560
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasBottomLine, "BottomLine", &parseBool ));
8229 avox 561
 
9449 avox 562
        ruleset.addRule(Digester::concat(itemPrefix, "Pattern"), Pattern());
8412 avox 563
 
564
        Gradient gradient;
565
        Xml_string gradientPrefix(Digester::concat(itemPrefix, "Gradient"));
566
        ruleset.addRule(gradientPrefix, gradient);
567
        ruleset.addRule(Digester::concat(gradientPrefix, "CStop"), gradient);
568
 
569
        ImageEffectsAndLayers effectsAndLayers;
570
        ruleset.addRule(Digester::concat(itemPrefix, "ImageEffect"), effectsAndLayers);
571
        ruleset.addRule(Digester::concat(itemPrefix, "PSDLayer"), effectsAndLayers);
572
 
573
        Annotation::desaxeRules(itemPrefix, ruleset);
574
        ruleset.addRule(Digester::concat(itemPrefix, Annotation::saxxDefaultElem),
575
                                        SetterWithConversion<PageItem,const Annotation&,Annotation>( & PageItem::setAnnotation ));
576
 
8289 avox 577
        // TODO: obj attributes
578
 
8229 avox 579
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setExternalFile, "image-file" ));
580
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setFileIconPressed, "icon-pressed-file" ));
581
        ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setFileIconRollover, "icon-rollover-file" ));
582
 
583
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,QValueList<double> >( & PageItem::setDashes, "line-dashes", &parseDoubleList ));
584
        ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setDashOffset, "line-dash-offset", &parseDouble ));
8266 avox 585
 
586
        StoryText::desaxeRules(itemPrefix, ruleset, "text-content");
587
        Xml_string storyPrefix = Digester::concat(itemPrefix, "text-content");
588
        ruleset.addRule(storyPrefix, SetItemText());
8289 avox 589
 
8304 jghali 590
        ruleset.addRule(itemPrefix, LoadPicture());
8298 avox 591
 
592
        AdjustGroupIds adjustGroupIds;
593
        ruleset.addRule("/", adjustGroupIds);
8395 avox 594
        ruleset.addRule(PageItem::saxxDefaultElem, adjustGroupIds);
8298 avox 595
 
8266 avox 596
}