Scribus Developer Documentation - API
logo-pen

Scribus Developer Documentation - API

pageitem_desaxe.cpp

Go to the documentation of this file.
00001 /*
00002 For general Scribus (>=1.3.2) copyright and licensing information please refer
00003 to the COPYING file provided with the program. Following this notice may exist
00004 a copyright and/or license notice that predates the release of Scribus 1.3.2
00005 for which a new license (GPL+exception) is in place.
00006 */
00007 
00008 
00009 #include "desaxe/saxiohelper.h"
00010 #include "desaxe/simple_actions.h"
00011 #include "pageitem.h"
00012 #include "pageitem_imageframe.h"
00013 #include "pageitem_line.h"
00014 #include "pageitem_pathtext.h"
00015 #include "pageitem_polygon.h"
00016 #include "pageitem_polyline.h"
00017 #include "pageitem_textframe.h"
00018 #include "pageitem_latexframe.h"
00019 #include "scribusdoc.h"
00020 #include "util_color.h"
00021 #include "util_math.h"
00022 #include "util.h"
00023 
00024 #include <QDebug>
00025 
00026 using namespace desaxe;
00027 
00028 
00029 
00030 FPointArray parseSVG(const Xml_string& str)
00031 {
00032     FPointArray result;
00033     result.parseSVG(str);
00034     return result;
00035 }
00036 
00037 
00038 static Xml_attr PageItemXMLAttributes(const PageItem* item)
00039 {
00040     Xml_attr result;
00041     
00042     result.insert("id", "obj" + toXMLString(const_cast<PageItem*>(item)->getUId()));
00043     if (!item->AutoName)
00044         result.insert("name", item->itemName());
00045     const PageItem* nxt = item->nextInChain(); 
00046     if (nxt)
00047         result.insert("nextframe", "obj" + toXMLString(nxt->getUId())); 
00048     result.insert("layer", toXMLString(item->LayerNr));
00049     result.insert("level", toXMLString(item->ItemNr));
00050     result.insert("itemtype", toXMLString(item->realItemType()));
00051     
00052     result.insert("is-annotation", toXMLString(item->isAnnotation()));
00053     result.insert("is-bookmark", toXMLString(item->isPDFBookmark()));
00054     result.insert("printable", toXMLString(item->printEnabled()));
00055     result.insert("locked", toXMLString(item->locked()));
00056     result.insert("size-locked", toXMLString(item->sizeLocked()));
00057     
00058     result.insert("width", toXMLString(item->width()));
00059     result.insert("height", toXMLString(item->height()));
00060     result.insert("ownpage", toXMLString(item->OwnPage));
00061     Page* page = item->doc()->Pages->at(item->OwnPage);
00062     if (page)
00063     {
00064         result.insert("xorigin", toXMLString(item->xPos() - page->xOffset()));
00065         result.insert("yorigin", toXMLString(item->yPos() - page->yOffset()));
00066     }
00067     else
00068     {
00069         result.insert("xorigin", toXMLString(item->xPos()));
00070         result.insert("yorigin", toXMLString(item->yPos()));
00071     }
00072     result.insert("rotation", toXMLString(item->rotation()));
00073     result.insert("fill-color", item->fillColor());
00074     result.insert("fill-shade", toXMLString(item->fillShade()));
00075     result.insert("fill-transparency", toXMLString(item->fillTransparency()));
00076     result.insert("fill-blendmode", toXMLString(item->fillBlendmode()));
00077     result.insert("fill-gradient-type", toXMLString(item->gradientType()));
00078     result.insert("fill-evenodd", toXMLString(item->fillEvenOdd()));
00079     result.insert("do-overprint", toXMLString(item->overprint()));
00080     
00081     result.insert("line-color", item->lineColor());
00082     result.insert("line-shade", toXMLString(item->lineShade()));
00083     result.insert("line-transparency", toXMLString(item->lineTransparency()));
00084     result.insert("line-blendmode", toXMLString(item->lineBlendmode()));
00085     result.insert("line-width", toXMLString(item->lineWidth()));
00086     result.insert("line-style", toXMLString(item->PLineArt));
00087     result.insert("line-cap", toXMLString(item->PLineEnd));
00088     result.insert("line-join", toXMLString(item->PLineJoin));
00089     result.insert("line-customstyle", item->customLineStyle());
00090     result.insert("line-start-arrow", toXMLString(item->startArrowIndex()));
00091     result.insert("line-end-arrow", toXMLString(item->endArrowIndex()));
00092 
00093     result.insert("frame-type", toXMLString(item->frameType()));
00094     result.insert("frame-shape", toXMLString(item->shape()));
00095     result.insert("frame-has-default-shape", toXMLString(item->hasDefaultShape())); 
00096     result.insert("corner-radius", toXMLString(item->cornerRadius()));  
00097     result.insert("frame-contour", toXMLString(item->contour()));
00098     result.insert("text-flow-mode", toXMLString((int) item->textFlowMode() ));
00099     
00100     result.insert("left-distance", toXMLString(item->textToFrameDistLeft()));
00101     result.insert("top-distance", toXMLString(item->textToFrameDistTop()));
00102     result.insert("bottom-distance", toXMLString(item->textToFrameDistBottom()));
00103     result.insert("right-distance", toXMLString(item->textToFrameDistRight()));
00104 
00105     result.insert("text-autoframes", toXMLString(item->isAutoFrame()));
00106     result.insert("text-columns", toXMLString(item->columns()));
00107     result.insert("text-columngap", toXMLString(item->columnGap()));
00108     result.insert("text-reversed", toXMLString(item->reversed()));
00109     result.insert("pathtext-type", toXMLString(item->pathTextType()));
00110     result.insert("pathtext-flipped", toXMLString(item->flipPathText()));
00111     result.insert("pathtext-baseoffset", toXMLString(item->pathTextBaseOffset()));
00112     result.insert("pathtext-showpath", toXMLString(item->pathTextShowFrame()));
00113 
00114     result.insert("image-scale-framesize", toXMLString(item->fitImageToFrame()));
00115     result.insert("image-scale-proportional", toXMLString(item->keepAspectRatio()));
00116     result.insert("image-x-scale", toXMLString(item->imageXScale()));
00117     result.insert("image-y-scale", toXMLString(item->imageYScale()));
00118     result.insert("image-x-position", toXMLString(item->imageXOffset()));
00119     result.insert("image-y-position", toXMLString(item->imageYOffset()));
00120     //  result.insert("image-x-dpi", toXMLString(item->imageXDpi()));
00121     //  result.insert("image-y-dpi", toXMLString(item->imageYDpi()));
00122     result.insert("image-shown", toXMLString(item->imageShown()));
00123     result.insert("image-use-embedded", toXMLString(item->useEmbeddedImageProfile()));
00124     result.insert("image-embedded-profile", item->embeddedImageProfile());
00125     result.insert("image-flipped-hor", toXMLString(item->imageFlippedH()));
00126     result.insert("image-flipped-vert", toXMLString(item->imageFlippedV()));
00127     result.insert("cms-profile", item->cmsProfile());
00128     result.insert("cms-intent", toXMLString(item->cmsRenderingIntent()));
00129     
00130     if (item->groups().count() > 0)
00131     {
00132         QString grouplist = "";
00133         QStack<int>::const_iterator it;
00134         for (it = item->groups().begin(); it != item->groups().end(); ++it)
00135             grouplist += toXMLString( *it ) + " ";  
00136         result.insert("groups", toXMLString(grouplist));
00137         result.insert("isGroupControl", toXMLString(item->controlsGroup()));
00138         if (item->isGroupControl)
00139         {
00140             if (item->groupsLastItem != 0)
00141                 result.insert("groupsLastItem", "obj" + toXMLString(item->groupsLastItem->getUId()));
00142         }
00143     }
00144     
00145     result.insert("isTableItem", toXMLString(item->isTableItem));
00146     if (item->isTableItem)
00147     {
00148         result.insert("TopLine", toXMLString(item->TopLine));
00149         result.insert("LeftLine", toXMLString(item->LeftLine));
00150         result.insert("RightLine", toXMLString(item->RightLine));
00151         result.insert("BottomLine", toXMLString(item->BottomLine));
00152         if (item->TopLink != 0)
00153             result.insert("TopLINK", "obj" + toXMLString(item->TopLink->getUId()));
00154         if (item->LeftLink != 0)
00155             result.insert("LeftLINK", "obj" + toXMLString(item->LeftLink->getUId()));
00156         if (item->RightLink != 0)
00157             result.insert("RightLINK", "obj" + toXMLString(item->RightLink->getUId()));
00158         if (item->BottomLink != 0)
00159             result.insert("BottomLINK", "obj" + toXMLString(item->BottomLink->getUId()));
00160     }
00161     
00162 //  result.insert("ANNAME", !item->AutoName ? item->itemName() : QString(""));  // not used
00163     const PageItem_LatexFrame *latexframe = NULL;
00164     if (item->realItemType() == PageItem::LatexFrame)
00165         latexframe = dynamic_cast<const PageItem_LatexFrame*>(item);
00166     
00167     if ((item->itemType()==PageItem::ImageFrame || item->itemType()==PageItem::TextFrame) && (!item->externalFile().isEmpty()) && !latexframe)
00168         result.insert("image-file", Path2Relative(item->externalFile()));
00169     if (!item->fileIconPressed().isEmpty())
00170         result.insert("icon-pressed-file", Path2Relative(item->fileIconPressed()));
00171     if (!item->fileIconRollover().isEmpty())
00172         result.insert("icon-rollover-file", Path2Relative(item->fileIconRollover()));   
00173     if (latexframe) {
00174         result.insert("latex-dpi", toXMLString(latexframe->dpi()));
00175         result.insert("latex-configfile", latexframe->configFile());
00176         result.insert("latex-use-preamble", toXMLString(latexframe->usePreamble()));
00177     }
00178     
00179     if (item->dashes().count() > 0)
00180         result.insert("line-dashes", toXMLString(item->dashes()));
00181     if (item->dashOffset() != 0.0)
00182         result.insert("line-dash-offset", toXMLString(item->dashOffset()));
00183     return result;
00184 }   
00185 
00186 
00187 void PageItem::saxx(SaxHandler& handler, const Xml_string& elemtag) const
00188 {
00189     Xml_attr att(PageItemXMLAttributes(this));
00190     Xml_attr empty;
00191 //  qDebug(QString("PageItem::saxx %1 %2").arg((ulong) &handler));
00192     handler.begin(elemtag, att);
00193 
00194     if (effectsInUse.count() != 0)
00195     {
00196         for (int a = 0; a < effectsInUse.count(); ++a)
00197         {
00198             Xml_attr imeff;
00199             imeff.insert("Code", toXMLString(effectsInUse.at(a).effectCode));
00200             imeff.insert("Param", effectsInUse.at(a).effectParameters);
00201             handler.begin("ImageEffect", imeff);
00202             handler.end("ImageEffect");
00203         }
00204     }
00205     
00206     if ((itemType()==ImageFrame || itemType()==TextFrame) && !Pfile.isEmpty() 
00207         && pixm.imgInfo.layerInfo.count() != 0 && pixm.imgInfo.isRequest)
00208     {
00209         QMap<int, ImageLoadRequest>::const_iterator it2;
00210         for (it2 = pixm.imgInfo.RequestProps.begin(); it2 != pixm.imgInfo.RequestProps.end(); ++it2)
00211         {
00212             Xml_attr psd;
00213             psd.insert("Layer", toXMLString(it2.key()));
00214             psd.insert("Visible", toXMLString(it2.value().visible));
00215             psd.insert("useMask", toXMLString(it2.value().useMask));
00216             psd.insert("Opacity", toXMLString(it2.value().opacity));
00217             psd.insert("Blend", it2.value().blend);
00218             handler.begin("PSDLayer", psd);
00219             handler.end("PSDLayer");
00220         }
00221     }
00222     if (gradientType() != 0)
00223     {
00224         if (gradientType() == 8)
00225         {
00226             Xml_attr patt;
00227             patt.insert("pattern", pattern());
00228             double patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation;
00229             patternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
00230             patt.insert("pScaleX", toXMLString(patternScaleX));
00231             patt.insert("pScaleY", toXMLString(patternScaleY));
00232             patt.insert("pOffsetX", toXMLString(patternOffsetX));
00233             patt.insert("pOffsetY", toXMLString(patternOffsetY));
00234             patt.insert("pRotation", toXMLString(patternRotation));
00235             handler.begin("Pattern", patt);
00236             handler.end("Pattern");
00237         }
00238         else
00239         {
00240             Xml_attr gradient;
00241             gradient.insert("GRTYPE", toXMLString(GrType));
00242             gradient.insert("GRSTARTX", toXMLString(GrStartX));
00243             gradient.insert("GRSTARTY", toXMLString(GrStartY));
00244             gradient.insert("GRENDX", toXMLString(GrEndX));
00245             gradient.insert("GRENDY", toXMLString(GrEndY));
00246             handler.begin("Gradient", gradient);
00247             QList<VColorStop*> cstops = fill_gradient.colorStops();
00248             for (uint cst = 0; cst < const_cast<VGradient&>(fill_gradient).Stops(); ++cst) //FIXME make const
00249             {
00250                 Xml_attr itcl;
00251                 itcl.insert("RAMP", toXMLString(cstops.at(cst)->rampPoint));
00252                 itcl.insert("NAME", cstops.at(cst)->name);
00253                 itcl.insert("SHADE", toXMLString(cstops.at(cst)->shade));
00254                 itcl.insert("TRANS", toXMLString(cstops.at(cst)->opacity));
00255                 handler.begin("CStop",itcl);
00256                 handler.end("CStop");
00257             }
00258             handler.end("Gradient");
00259         }
00260     }
00261     
00262     // TODO: PI attributes...
00263     
00264     if (isAnnotation())
00265     {
00266         annotation().saxx(handler);
00267     }
00268     if (prevInChain() == NULL && itemText.length() > 0)
00269     {
00270         itemText.saxx(handler, "text-content");
00271     }
00272 
00273     const PageItem_LatexFrame *latexframe = NULL;
00274     if (this->realItemType() == PageItem::LatexFrame)
00275         latexframe = dynamic_cast<const PageItem_LatexFrame*>(this);
00276     if (latexframe) {
00277         handler.begin("latex-source", empty);
00278         QMapIterator<QString, QString> i(latexframe->editorProperties);
00279         while (i.hasNext()) {
00280             Xml_attr property;
00281             i.next();
00282             property.insert("name", i.key());
00283             property.insert("value", i.value());
00284             handler.begin("property", property);
00285             handler.end("property");
00286         }
00287         handler.chars(latexframe->formula());
00288         handler.end("latex-source");
00289     }
00290     handler.end(elemtag);
00291 }
00292 
00293 
00294 
00295 class CreatePageItem_body : public Generator_body<PageItem>
00296 {
00297     void begin (const Xml_string& /*tagname*/, Xml_attr attr)
00298     {
00299         PageItem* result;
00300         ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
00301         
00302         PageItem::ItemType type = parseEnum<PageItem::ItemType>(attr["itemtype"]);
00303         PageItem::ItemFrameType frametype = PageItem::Unspecified; // parseEnum<PageItem::ItemFrameType>(attr["frame-type"]);
00304         // int ownpage = parseInt(attr["ownpage"]);
00305         // doc->setCurrentPage(doc->Pages->at(ownpage));
00306         double xpos = parseDouble(attr["xorigin"]) + doc->currentPage()->xOffset();
00307         double ypos = parseDouble(attr["yorigin"]) + doc->currentPage()->yOffset();
00308         double width = parseDouble(attr["width"]);
00309         double height = parseDouble(attr["height"]);
00310         double linewidth = parseDouble(attr["line-width"]);
00311         QString fillC = attr["fill-color"];
00312         QString lineC = attr["line-color"];
00313         int nr = doc->itemAdd(type, frametype, xpos, ypos, width, height, linewidth, fillC, lineC, true);
00314         result = doc->Items->at(nr);
00315         this->dig->push(result);
00316 //      qDebug(QString("pushed item: %1,%2 params %3,%4").arg(result->xPos()).arg(result->yPos()).arg(xpos).arg(ypos));
00317     }
00318 };
00319 
00320 class CreatePageItem : public MakeGenerator<CreatePageItem_body, PageItem>
00321 {};
00322 
00323 
00324 
00326 class SetItemText_body : public Action_body
00327 {
00328     void end (const Xml_string& /*tagname*/)
00329     {
00330         PageItem* item = this->dig->top<PageItem>(1);
00331         StoryText* story = this->dig->top<StoryText>(0);
00332         item->itemText.clear();
00333         item->itemText.setDefaultStyle(story->defaultStyle());
00334         item->itemText.append(*story);  // story has no document attached, so we dont want to assign here
00335     }
00336 };
00337 
00338 class SetItemText : public MakeAction<SetItemText_body>
00339 {};
00340 
00341 
00342 
00343 class Gradient_body : public Action_body
00344 {
00345     void begin (const Xml_string& tagName, Xml_attr attr)
00346     {
00347 //      qDebug(QString("pageitem_desaxe: gradient %1").arg(tagName));
00348         if (tagName=="CStop")
00349         {
00350 //          ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
00351             PageItem* item = this->dig->top<PageItem>();
00352             QString name = attr["NAME"];
00353             double ramp = parseDouble(attr["RAMP"]);
00354             int shade = parseInt(attr["SHADE"]);
00355             double opa = parseDouble(attr["TRANS"]);
00356             // Hack : at this stage, colors may still not exists in document and SetColor would create it, 
00357             // so use the dummy brown and update manually gradient colors in Serializer
00358             // item->fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
00359             item->fill_gradient.addStop( QColor(150, 100, 50) , ramp, 0.5, opa, name, shade);
00360         }
00361         if (tagName=="Gradient")
00362         {
00363             PageItem* item = this->dig->top<PageItem>();
00364             item->GrType = parseInt(attr["GRTYPE"]);
00365             item->GrStartX = parseDouble(attr["GRSTARTX"]);
00366             item->GrStartY = parseDouble(attr["GRSTARTY"]);
00367             item->GrEndX = parseDouble(attr["GRENDX"]);
00368             item->GrEndY = parseDouble(attr["GRENDY"]);
00369             item->fill_gradient.clearStops();
00370         }
00371     }
00372 };
00373 
00374 class Gradient : public MakeAction<Gradient_body>
00375 {};
00376 
00377 
00378 
00379 class Pattern_body : public Action_body
00380 {
00381     void begin (const Xml_string& tagName, Xml_attr attr)
00382     {
00383         PageItem* item = this->dig->top<PageItem>();
00384         
00385         double patternScaleX = parseDouble(attr["pScaleX"]);
00386         double patternScaleY = parseDouble(attr["pScaleY"]);
00387         double patternOffsetX = parseDouble(attr["pOffsetX"]);
00388         double patternOffsetY = parseDouble(attr["pOffsetY"]);
00389         double patternRotation = parseDouble(attr["pRotation"]);
00390 //      qDebug(QString("pageitem_desaxe: pattern %6: *(%1,%2) +(%3,%4) °%5").arg(patternScaleX).arg(patternScaleY).arg(patternOffsetX).arg(patternOffsetY).arg(patternRotation).arg(attr["pattern"]));
00391 
00392         item->setPattern(attr["pattern"]);
00393         item->setPatternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
00394     }
00395 };
00396 
00397 class Pattern : public MakeAction<Pattern_body>
00398 {};
00399 
00400 
00401 
00402 class ImageEffectsAndLayers_body : public Action_body
00403 {
00404     void begin (const Xml_string& tagName, Xml_attr attr)
00405     {
00406 //      qDebug(QString("pageitem_desaxe: effects/layers %1").arg(tagName));
00407         if (tagName=="ImageEffect")
00408         {
00409             PageItem* obj = this->dig->top<PageItem>();
00410             struct ImageEffect ef;
00411             ef.effectParameters = attr["Param"];
00412             ef.effectCode = parseInt(attr["Code"]);
00413             obj->effectsInUse.append(ef);
00414         }
00415         if (tagName == "PSDLayer")
00416         {
00417             PageItem* obj = this->dig->top<PageItem>();
00418             struct ImageLoadRequest loadingInfo;
00419             loadingInfo.blend = attr["Blend"];
00420             loadingInfo.opacity = parseInt(attr["Opacity"]);
00421             loadingInfo.visible = parseBool(attr["Visible"]);
00422             loadingInfo.useMask = parseBool(attr["useMask"]);
00423             obj->pixm.imgInfo.RequestProps.insert(parseInt(attr["Layer"]), loadingInfo);
00424             obj->pixm.imgInfo.isRequest = true;
00425         }
00426     }
00427 };
00428 
00429 class ImageEffectsAndLayers : public MakeAction<ImageEffectsAndLayers_body>
00430 {};
00431 
00432 
00433 
00434 class LoadPicture_body : public Action_body
00435 {
00436     void end (const Xml_string& /*tagname*/)
00437     {
00438         PageItem* item = this->dig->top<PageItem>();
00439         if (item->itemType() == PageItem::ImageFrame)
00440             item->loadImage(item->externalFile(), true);
00441     }
00442 };
00443 
00444 class LoadPicture : public MakeAction<LoadPicture_body>
00445 {};
00446 
00447 
00448 
00449 class AdjustGroupIds_body : public Action_body
00450 {
00451     void begin (const Xml_string& tagname, Xml_attr attr)
00452     {
00453         if (tagname != PageItem::saxxDefaultElem)
00454         {
00455             ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
00456             minGroup = doc->GroupCounter;
00457             maxGroup = minGroup - 1;
00458         }
00459     }
00460 
00461     void end (const Xml_string& tagname)
00462     {
00463         if (tagname != PageItem::saxxDefaultElem)
00464         {
00465             ScribusDoc* doc = this->dig->lookup<ScribusDoc>("<scribusdoc>");
00466             doc->GroupCounter = maxGroup + 1;
00467         }
00468         else {
00469             PageItem* item = this->dig->top<PageItem>();
00470             QStack<int> groups;
00471             for (int i=0; i < item->groups().count(); ++i)
00472             {
00473                 int newGroup = minGroup + item->groups()[i];
00474                 if (newGroup > maxGroup)
00475                     maxGroup = newGroup;
00476 //              qDebug(QString("group id %1 -> %2").arg(item->groups()[i]).arg(newGroup));
00477                 groups.append(newGroup);
00478             }
00479             item->setGroups(groups);
00480         }
00481     }
00482     
00483 private:
00484     int minGroup;
00485     int maxGroup;
00486 };
00487 
00488 class AdjustGroupIds : public MakeAction<AdjustGroupIds_body>
00489 {};
00490 
00491 
00492 class LatexSource_body : public Action_body
00493 {
00494     public: 
00495         void chars(const Xml_string& txt)
00496         {
00497             if (this->dig->top<PageItem>()->realItemType() == PageItem::LatexFrame)
00498             {
00499                 PageItem_LatexFrame* obj = dynamic_cast<PageItem_LatexFrame *> (this->dig->top<PageItem>());
00500                 obj->setFormula(txt);
00501             }
00502         }
00503 };
00504 
00505 struct  LatexSource : public MakeAction<LatexSource_body> 
00506 {};
00507 
00508 
00509 class LatexParams_body : public Action_body
00510 {
00511     public: 
00512         void begin(const Xml_string& tag, Xml_attr attr) 
00513         {
00514             if (this->dig->top<PageItem>()->realItemType() == PageItem::LatexFrame)
00515             {
00516                 PageItem_LatexFrame* obj = dynamic_cast<PageItem_LatexFrame *> (this->dig->top<PageItem>());
00517                 obj->setConfigFile(attr["latex-configfile"]);
00518                 obj->setDpi(parseInt(attr["latex-dpi"]));
00519                 obj->setUsePreamble(parseBool(attr["latex-use-preamble"]));
00520             }
00521         }
00522 };
00523 
00524 struct  LatexParams : public MakeAction<LatexParams_body> 
00525 {};
00526 
00527 
00528 
00529 const Xml_string PageItem::saxxDefaultElem("item");
00530 
00531 
00532 
00533 void PageItem::desaxeRules(const Xml_string& prefixPattern, Digester& ruleset, Xml_string elemtag)
00534 {
00535     Xml_string itemPrefix(Digester::concat(prefixPattern, elemtag));
00536     
00537     // the generator CreatePageItem *requires* the Scribusdoc stored as "<scribusdoc>"
00538     ruleset.addRule(itemPrefix, CreatePageItem() );
00539 
00540     ruleset.addRule(itemPrefix, IdRef<PageItem>() );
00541 //  ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>("id", toXMLString(const_cast<PageItem*>(item)->getUId())); // set automatically
00542     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setLayer, "layer", &parseInt )); // set to activelayer in constructor
00543     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 ...
00544     ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setItemName, "name", dummy ));    // ... which could be ignored, but without is nicer
00545     ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::link, "nextframe" ));
00546 //  ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & ?PageItem::setLevel, "level", &parseInt ));  // set automatically
00547 //  ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::??, "itemtype", &parseInt ));  // automatically in createPageItem()
00548 //  ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>(?, "ownpage", &parseInt);  // set to current page in constructor
00549     
00550     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsAnnotation,  "is-annotation", &parseBool ));
00551     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsPDFBookmark,  "is-bookmark", &parseBool ));
00552     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setPrintEnabled, "printable", &parseBool ));
00553     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setLocked, "locked", &parseBool ));
00554     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setSizeLocked, "size-locked", &parseBool ));
00555     
00556     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setWidth, "width", &parseDouble ));  // also in createPageItem()
00557     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setHeight, "height", &parseDouble ));  // also in createPageItem()
00558 //  ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setXPos, "xorigin", &parseDouble ));  // also in createPageItem()
00559 //  ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setYPos, "yorigin", &parseDouble ));  // also in createPageItem()
00560     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setRotation, "rotation", &parseDouble ));
00561     ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setFillColor, "fill-color", dummy ));  // also in createPageItem()
00562     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setFillShade, "fill-shade", &parseDouble ));
00563     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setFillTransparency, "fill-transparency", &parseDouble ));
00564     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setFillBlendmode, "fill-blendmode", &parseInt ));
00565     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setGradientType, "fill-gradient-type", &parseInt ));
00566     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,PageItem::TextFlowMode>( & PageItem::setTextFlowMode, "text-flow-mode", &parseEnum<PageItem::TextFlowMode> ));
00567     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setFillEvenOdd, "frame-fill-evenodd", &parseBool ));
00568     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setOverprint, "do-overprint", &parseBool ));
00569     
00570     ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setLineColor, "line-color", dummy ));  // also in createPageItem()
00571     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setLineShade, "line-shade", &parseDouble ));
00572     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setLineTransparency, "line-transparency", &parseDouble ));
00573     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setLineBlendmode, "line-blendmode", &parseInt ));
00574     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setLineWidth, "line-width", &parseDouble ));  // also in createPageItem()
00575     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,Qt::PenStyle>( & PageItem::setLineStyle, "line-style", &parseEnum<Qt::PenStyle> ));
00576     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,Qt::PenCapStyle>( & PageItem::setLineEnd, "line-cap", &parseEnum<Qt::PenCapStyle> ));
00577     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,Qt::PenJoinStyle>( & PageItem::setLineJoin, "line-join", &parseEnum<Qt::PenJoinStyle> ));
00578     ruleset.addRule(itemPrefix, SetAttribute<PageItem,const QString&>( & PageItem::setCustomLineStyle, "line-customstyle", dummy )); // see comment above for setItemName
00579     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setStartArrowIndex, "line-start-arrow", &parseInt ));
00580     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setEndArrowIndex, "line-end-arrow", &parseInt ));
00581     
00582     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setFrameType, "frame-type", &parseInt ));
00583     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem, FPointArray>( & PageItem::setShape, "frame-shape", &parseSVG ));
00584     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setHasDefaultShape, "frame-has-default-shape", &parseBool ));    
00585     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setCornerRadius, "corner-radius", &parseDouble )); 
00586     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,FPointArray>( & PageItem::setContour, "frame-contour", &parseSVG ));
00587     
00588     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistLeft, "left-distance", &parseDouble ));
00589     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistTop, "top-distance", &parseDouble ));
00590     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistBottom, "bottom-distance", &parseDouble ));
00591     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setTextToFrameDistRight, "right-distance", &parseDouble ));
00592     
00593     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setIsAutoFrame, "text-autoframe", &parseBool ));
00594     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setColumns, "text-columns", &parseInt ));
00595     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setColumnGap, "text-columngap", &parseDouble ));
00596     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setReversed, "text-reversed", &parseBool ));
00597     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setPathTextType, "pathtext-type", &parseInt ));
00598     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setFlipPathText, "pathtext-flipped", &parseBool ));
00599     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setPathTextBaseOffset, "pathtext-baseoffset", &parseDouble));
00600     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setPathTextShowFrame, "pathtext-showpath", &parseBool ));
00601     
00602     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setFitImageToFrame, "image-scale-framesize", &parseBool ));
00603     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setKeepAspectRatio, "image-scale-proportional", &parseBool ));
00604     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageXScale, "image-x-scale", &parseDouble ));
00605     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageYScale, "image-y-scale", &parseDouble ));
00606     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageXOffset, "image-x-position", &parseDouble ));
00607     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>( & PageItem::setImageYOffset, "image-y-position", &parseDouble ));
00608     //  ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>("image-x-dpi", &parseDouble ));  //NYI
00609     //  ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,double>("image-y-dpi", &parseDouble ));  //NYI
00610     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageShown, "image-shown", &parseBool ));
00611     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setUseEmbeddedImageProfile, "image-use-embedded", &parseBool ));
00612     ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setEmbeddedImageProfile, "image-embedded-profile" ));
00613     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageFlippedH, "image-flipped-hor", &parseBool ));
00614     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setImageFlippedV, "image-flipped-vert", &parseBool ));
00615     ruleset.addRule(itemPrefix, SetAttribute<PageItem,QString>( & PageItem::setCmsProfile, "cms-profile" ));
00616     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,int>( & PageItem::setCmsRenderingIntent, "cms-intent", &parseInt ));
00617 
00618     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,bool>( & PageItem::setControlsGroup, "isGroupControl", &parseBool ));
00619     ruleset.addRule(itemPrefix, PatchIdRefAttribute<PageItem, PageItem>( & PageItem::setGroupsLastItem, "groupsLastItem" ));
00620     ruleset.addRule(itemPrefix, SetAttributeWithConversion<PageItem,QStack<int> >( & PageItem::setGroups, "groups", &parseIntStack ));
00621 
00622     ruleset.addRule(itemPrefix,