dox/scribus/pageitem_8h_source.html

 /*

 For general Scribus (>=1.3.2) copyright and licensing information please refer

 to the COPYING file provided with the program. Following this notice may exist

 a copyright and/or license notice that predates the release of Scribus 1.3.2

 for which a new license (GPL+exception) is in place.

 */

 /***************************************************************************

                           pageitem.h  -  description

                              -------------------

     begin                : Sat Apr 7 2001

     copyright            : (C) 2001 by Franz Schmid

     email                : Franz.Schmid@altmuehlnet.de

  ***************************************************************************/


 /***************************************************************************

  *                                                                         *

  *   This program is free software; you can redistribute it and/or modify  *

  *   it under the terms of the GNU General Public License as published by  *

  *   the Free Software Foundation; either version 2 of the License, or     *

  *   (at your option) any later version.                                   *

  *                                                                         *

  ***************************************************************************/


 #ifndef PAGEITEM_H

 #define PAGEITEM_H


 #include <QObject>

 #include <QWidget>

 #include <QPolygon>

 #include <QStack>

 #include <QList>

 #include <QKeyEvent>

 #include <QMenu>

 #include <QRect>

 #include <QRectF>

 #include <QVector>

 #include <QTemporaryFile>


 #include "scribusapi.h"

 #include "annotation.h"

 #include "commonstrings.h"

 #include "colormgmt/sccolormgmtstructs.h"

 #include "desaxe/saxio.h"

 #include "observable.h"

 #include "pagestructs.h"

 #include "scimage.h"

 #include "margins.h"

 #include "sctextstruct.h"

 #include "text/storytext.h"

 #include "text/textlayout.h"

 #include "undoobject.h"

 #include "vgradient.h"

 #include "mesh.h"

 #ifdef HAVE_CONFIG_H

 #include "scconfig.h"

 #endif


 class QFrame;

 class QGridLayout;

 class ResourceCollection;

 class ScPainter;

 class ScribusDoc;

 class SimpleState;

 class UndoManager;

 class UndoState;


 class PageItem_Arc;

 class PageItem_Group;

 class PageItem_ImageFrame;

 class PageItem_LatexFrame;

 class PageItem_Line;

 class PageItem_NoteFrame;

 class PageItem_OSGFrame;

 class PageItem_PathText;

 class PageItem_PolyLine;

 class PageItem_Polygon;

 class PageItem_RegularPolygon;

 class PageItem_Spiral;

 class PageItem_Symbol;

 class PageItem_Table;

 class PageItem_TextFrame;


 #if defined(_MSC_VER)

 #define _unlink unlink

 #endif


 class SCRIBUS_API PageItem : public QObject, public UndoObject, public SaxIO, public SingleObservable<PageItem>

 {

     Q_OBJECT


     // Properties - see http://doc.trolltech.com/3.3/properties.html

     // See the accessors of these properties for details on their use.

     Q_PROPERTY(QString itemName READ itemName WRITE setItemName DESIGNABLE false)

     Q_PROPERTY(QString fillColor READ fillColor WRITE setFillColor DESIGNABLE false)

     Q_PROPERTY(QString lineColor READ lineColor WRITE setLineColor DESIGNABLE false)

     Q_PROPERTY(double fillShade READ fillShade WRITE setFillShade DESIGNABLE false)

     Q_PROPERTY(double lineShade READ lineShade WRITE setLineShade DESIGNABLE false)

     Q_PROPERTY(double fillTransparency READ fillTransparency WRITE setFillTransparency DESIGNABLE false)

     Q_PROPERTY(double lineTransparency READ lineTransparency WRITE setLineTransparency DESIGNABLE false)

     Q_PROPERTY(bool m_Locked READ locked WRITE setLocked DESIGNABLE false)

     Q_PROPERTY(bool m_SizeLocked READ sizeLocked WRITE setSizeLocked DESIGNABLE false)

     //used for notes frames

     Q_PROPERTY(bool m_SizeHLocked READ sizeHLocked WRITE setSizeHLocked DESIGNABLE false)

     Q_PROPERTY(bool m_SizeVLocked READ sizeVLocked WRITE setSizeVLocked DESIGNABLE false)

     Q_PROPERTY(bool m_ImageIsFlippedV READ imageFlippedV WRITE setImageFlippedV DESIGNABLE false)

     Q_PROPERTY(bool m_ImageIsFlippedH READ imageFlippedH WRITE setImageFlippedH DESIGNABLE false)

     Q_PROPERTY(double lineWidth READ lineWidth WRITE setLineWidth DESIGNABLE false)

     Q_PROPERTY(QString customLineStyle READ customLineStyle WRITE setCustomLineStyle DESIGNABLE false)

     Q_PROPERTY(int startArrowIndex READ startArrowIndex WRITE setStartArrowIndex DESIGNABLE false)

     Q_PROPERTY(int endArrowIndex READ endArrowIndex WRITE setEndArrowIndex DESIGNABLE false)


     Q_PROPERTY(bool m_PrintEnabled READ printEnabled WRITE setPrintEnabled DESIGNABLE false)

     Q_PROPERTY(double xPos READ xPos WRITE setXPos DESIGNABLE false)

     Q_PROPERTY(double yPos READ yPos WRITE setYPos DESIGNABLE false)

     Q_PROPERTY(double width READ width WRITE setWidth DESIGNABLE false)

     Q_PROPERTY(double height READ height WRITE setHeight DESIGNABLE false)

     Q_PROPERTY(double m_rotation READ rotation WRITE setRotation DESIGNABLE false)

     Q_PROPERTY(double m_imageXScale READ imageXScale WRITE setImageXScale DESIGNABLE false)

     Q_PROPERTY(double m_imageYScale READ imageYScale WRITE setImageYScale DESIGNABLE false)

     Q_PROPERTY(double imageXOffset READ imageXOffset WRITE setImageXOffset DESIGNABLE false)

     Q_PROPERTY(double imageYOffset READ imageYOffset WRITE setImageYOffset DESIGNABLE false)

     Q_PROPERTY(bool m_isReversed READ reversed WRITE setReversed DESIGNABLE false)

     Q_PROPERTY(double m_roundedCorderRadius READ cornerRadius WRITE setCornerRadius DESIGNABLE false)

     Q_PROPERTY(double textToFrameDistLeft READ textToFrameDistLeft WRITE setTextToFrameDistLeft DESIGNABLE false)

     Q_PROPERTY(double textToFrameDistRight READ textToFrameDistRight WRITE setTextToFrameDistRight DESIGNABLE false)

     Q_PROPERTY(double textToFrameDistTop READ textToFrameDistTop WRITE setTextToFrameDistTop DESIGNABLE false)

     Q_PROPERTY(double textToFrameDistBottom READ textToFrameDistBottom WRITE setTextToFrameDistBottom DESIGNABLE false)

     Q_PROPERTY(double ColGap READ columnGap WRITE setColumnGap DESIGNABLE false)

     Q_PROPERTY(int Cols READ columns WRITE setColumns DESIGNABLE false)

     Q_ENUMS(FirstLineOffsetPolicy)

     Q_PROPERTY(FirstLineOffsetPolicy firstLineOffset READ firstLineOffset WRITE setFirstLineOffset DESIGNABLE false)

     // FIXME: QMetaProperty can't translate these to/from enumerator names, probably because the

     // properties aren't moc'd in the Qt sources. They work fine in their

     // current state as plain integer properties.

 //      Q_ENUMS(PenStyle)

 //  Q_PROPERTY(PenStyle lineStyle READ lineStyle WRITE setLineStyle DESIGNABLE false)

 //  Q_ENUMS(PenCapStyle)

 //  Q_PROPERTY(PenCapStyle lineEnd READ lineEnd WRITE setLineEnd DESIGNABLE false)

 //  Q_ENUMS(PenJoinStyle)

 //  Q_PROPERTY(PenJoinStyle lineJoin READ lineJoin WRITE setLineJoin DESIGNABLE false)


     // This property may not hang around for too long, but should be useful

     // when testing out the pageitem refactoring work.  Setting it is unlikely

     // to currently have the desired effect.

     Q_ENUMS(ItemType)

     Q_PROPERTY(ItemType itemType READ itemType WRITE convertTo DESIGNABLE false)


 public: // Start enumerator definitions


     enum DrawOption {

         NoRotation = 1, // Draw as if item was not rotated

         NoSoftShadow = 2

     };


     enum ItemType {

         ItemType1       = 1,

         ImageFrame      = 2,

         ItemType3       = 3,

         TextFrame       = 4,

         Line            = 5,

         Polygon         = 6,

         PolyLine        = 7,

         PathText        = 8,

         LatexFrame      = 9,

         OSGFrame        = 10,

         Symbol          = 11,

         Group           = 12,

         RegularPolygon  = 13,

         Arc             = 14,

         Spiral          = 15,

         Table           = 16,

         Multiple        = 99

     };


     enum TextFlowMode {

         TextFlowDisabled            = 0,

         TextFlowUsesFrameShape      = 1,

         TextFlowUsesBoundingBox     = 2,

         TextFlowUsesContourLine     = 3,

         TextFlowUsesImageClipping   = 4

     };


     enum ItemFrameType {

         Unspecified =-1,

         Rectangle   = 0,

         Ellipse     = 1,

         Round       = 2,

         Other       = 3

     };

         //End enumerator definitions


 public: // Start public functions


     PageItem(ScribusDoc *pa, ItemType newType, double x, double y, double w, double h, double w2, QString fill, QString outline);

     virtual ~PageItem();


     /* these do essentially the same as a dynamic cast but might be more readable */

     virtual PageItem_Arc * asArc()                  { return NULL; }

     virtual PageItem_Group * asGroupFrame()         { return NULL; }

     virtual PageItem_ImageFrame * asImageFrame()    { return NULL; }

     virtual PageItem_LatexFrame * asLatexFrame()    { return NULL; }

     virtual PageItem_Line * asLine()                { return NULL; }

     virtual PageItem_NoteFrame * asNoteFrame()      { return NULL; }

     virtual PageItem_OSGFrame * asOSGFrame()        { return NULL; }

     virtual PageItem_PathText * asPathText()        { return NULL; }

     virtual PageItem_PolyLine * asPolyLine()        { return NULL; }

     virtual PageItem_Polygon * asPolygon()          { return NULL; }

     virtual PageItem_RegularPolygon * asRegularPolygon() { return NULL; }

     virtual PageItem_Spiral * asSpiral()            { return NULL; }

     virtual PageItem_Symbol * asSymbolFrame()       { return NULL; }

     virtual PageItem_Table * asTable()              { return NULL; }

     virtual PageItem_TextFrame * asTextFrame()      { return NULL; }


     virtual bool isArc()            const { return false; }

     virtual bool isAutoNoteFrame()  const { return false; }

     virtual bool isGroup()          const { return false; }

     virtual bool isImageFrame()     const { return false; }

     virtual bool isLatexFrame()     const { return false; }

     virtual bool isLine()           const { return false; }

     virtual bool isNoteFrame()      const { return false; }

     virtual bool isOSGFrame()       const { return false; }

     virtual bool isPathText()       const { return false; }

     virtual bool isPolyLine()       const { return false; }

     virtual bool isPolygon()        const { return false; }

     virtual bool isRegularPolygon() const { return false; }

     virtual bool isSpiral()         const { return false; }

     virtual bool isSymbol()         const { return false; }

     virtual bool isTable()          const { return false; }

     virtual bool isTextFrame()      const { return false; }


     virtual bool isGroupChild() const;

     virtual bool isTableCell() const;


     PageItem_Group* parentGroup() const { return (Parent ? Parent->asGroupFrame() : NULL); }

     PageItem_Table* parentTable() const { return (Parent ? Parent->asTable() : NULL); }


     virtual void applicableActions(QStringList& actionList) = 0;

     virtual QString infoDescription();

     virtual bool createInfoGroup(QFrame *, QGridLayout *) {return false;}


     //<< ********* Functions related to drawing the item *********


     void DrawObj(ScPainter *p, QRectF e);

     void DrawObj_Pre(ScPainter *p);

     virtual void DrawObj_Post(ScPainter *p);

     virtual void DrawObj_Decoration(ScPainter *p);

     virtual void DrawObj_Item(ScPainter *p, QRectF e) = 0;

     QImage DrawObj_toImage(double maxSize, int options = 0);

     QImage DrawObj_toImage(QList<PageItem*> &emG, double scaling);

     void DrawObj_Embedded(ScPainter *p, QRectF e, const CharStyle& style, PageItem* cembedded);

     void DrawStrokePattern(ScPainter *p, QPainterPath &path);

     void DrawSoftShadow(ScPainter *p);

     QRect getRedrawBounding(const double);

     void setRedrawBounding();

     void setPolyClip(int up, int down = 0);

     void updatePolyClip();

     //added switch for not updating welded items - used by notes frames with automatic size adjusted

     void updateClip(bool updateWelded = true);

     void convertClip();


     QRectF getBoundingRect() const;

     QRectF getCurrentBoundingRect(double moreSpace = 0.0) const;

     QRectF getVisualBoundingRect() const;


     virtual void getBoundingRect(double *x1, double *y1, double *x2, double *y2) const;

     virtual void getVisualBoundingRect(double *x1, double *y1, double *x2, double *y2) const;


     //>> ********* Functions related to drawing the item *********


     //<< ********* Functions to work on the contents of the items *********


     virtual void clearContents() {}

     virtual void truncateContents() {}


     //>> ********* Functions to work on the contents of the items *********


     //<< ********* Functions for user interaction with the item **********


     bool pointWithinItem(const int x, const int y) const;

     bool mouseWithinItem(const int x, const int y, double scale) const;


     virtual void handleModeEditKey(QKeyEvent *k, bool &keyRepeat);


     //>> ********* Functions for user interaction with the item **********


     int level() const;

     void saxx(SaxHandler& handler, const Xml_string& elemtag) const {}

     void saxx(SaxHandler& handler) const {}


     void AdjustPictScale();


     void updateGradientVectors();


     void moveImageInFrame(double newX, double newY);

     ObjAttrVector* getObjectAttributes();

     QList<ObjectAttribute> getObjectAttributes(QString attributeName) const;

     ObjectAttribute getObjectAttribute(QString) const;

     void setObjectAttributes(ObjAttrVector*);


     void SetFrameShape(int count, double *vals);

     void SetRectFrame();

     void SetOvalFrame();

     void SetFrameRound();

     QTransform getGroupTransform() const;

     void getTransform(QTransform& mat) const;

     QTransform getTransform() const;


     virtual void invalidateLayout() { invalid = true; }

     virtual void layout() {}

     PageItem * frameTextEnd();

     bool frameOverflows() const;

     bool frameUnderflows() const;

     int frameOverflowCount() const;

     int frameOverflowBlankCount() const;

     void drawOverflowMarker(ScPainter *p);

     int firstInFrame() const;

     int lastInFrame() const;


     bool frameDisplays(int textpos) const;

     const ParagraphStyle& currentStyle() const;

     ParagraphStyle& changeCurrentStyle();

     const CharStyle& currentCharStyle() const;

     void currentTextProps(ParagraphStyle& parStyle) const;

     // deprecated:

     double layoutGlyphs(const CharStyle& style, const QString& chars, LayoutFlags flags, GlyphLayout& layout);

     void SetQColor(QColor *tmp, QString farbe, double shad);

     void drawGlyphs(ScPainter *p, const CharStyle& style, LayoutFlags flags, GlyphLayout& glyphs );

     void DrawPolyL(QPainter *p, QPolygon pts);

     QString ExpandToken(uint base);

     const FPointArray shape() const { return PoLine; }

     void setShape(FPointArray val) { PoLine = val; }

     const FPointArray contour() const { return ContourLine; }

     void setContour(FPointArray val) { ContourLine = val; }

     bool flipPathText() const { return textPathFlipped; }

     void setFlipPathText(bool val) { textPathFlipped = val; }

     int pathTextType() const { return textPathType; }

     void setPathTextType(int val) { textPathType = val; }

     double pathTextBaseOffset() const { return BaseOffs; }

     void setPathTextBaseOffset(double val) { BaseOffs = val; }

     bool pathTextShowFrame() const { return PoShow; }

     void setPathTextShowFrame(bool val) { PoShow = val; }


     bool useEmbeddedImageProfile() const { return UseEmbedded; }

     void setUseEmbeddedImageProfile(bool val) { UseEmbedded = val; }

     QString embeddedImageProfile() const { return EmProfile; }

     void setEmbeddedImageProfile(QString val) { EmProfile = val; }

     bool drawFrame() { return ((m_ItemType == TextFrame && !m_sampleItem) || (m_ItemType == ImageFrame) || (m_ItemType == PathText)); }

     QString externalFile() const { return Pfile; }

     void setExternalFile(QString val);

     void setImagePagenumber(int num) { pixm.imgInfo.actualPageNumber = num; }

     void setResolution(int);


     //FIXME: maybe these should go into annotation?

     QString fileIconPressed() const { return Pfile2; }

     void setFileIconPressed(QString val);

     QString fileIconRollover() const { return Pfile3; }

     void setFileIconRollover(QString val);

     int  cmsRenderingIntent() const { return IRender; }

     void setCmsRenderingIntent(eRenderIntent val) { IRender = val; }

     QString cmsProfile() const { return IProfile; }

     void setCmsProfile(QString val) { IProfile = val; }

     void setOverrideCompressionMethod(bool val) { OverrideCompressionMethod = val; }

     void setCompressionMethodIndex(int val) { CompressionMethodIndex = val; }

     void setOverrideCompressionQuality(bool val) { OverrideCompressionQuality = val; }

     void setCompressionQualityIndex(int val) { CompressionQualityIndex = val; }

     PageItem* prevInChain() { return BackBox; }

     PageItem* nextInChain() { return NextBox; }

     const PageItem* prevInChain() const { return BackBox; }

     const PageItem* nextInChain() const { return NextBox; }

     //you can change all code for search first or last item in chain

     PageItem* firstInChain();

     PageItem* lastInChain();

     bool testLinkCandidate(PageItem* nextFrame);

     void unlink(bool createUndo = true);

     void link(PageItem* nextFrame, bool addPARSEP = true);

     void dropLinks();

     void unlinkWithText(bool);

     void setSampleItem(bool b) {m_sampleItem=b;}

     const QVector<double>& dashes() const { return DashValues; }

     QVector<double>& dashes() { return DashValues; }

     void setDashes(QVector<double> val) { DashValues = val; }

     double dashOffset() const { return DashOffset; }

     void setDashOffset(double val) { DashOffset = val; }

     virtual QList<PageItem*> getItemList();


     //<< ********* Attributes of the item *********

     //Position

     double xPos() const { return m_xPos; }

     double yPos() const { return m_yPos; }

     double visualXPos() const;

     double visualYPos() const;

     FPoint xyPos() const { return FPoint(m_xPos, m_yPos); }

     void setXPos(const double, bool drawingOnly=false);

     void setYPos(const double, bool drawingOnly=false);

     void setXYPos(const double, const double, bool drawingOnly=false);

     void moveBy(const double, const double, bool drawingOnly=false);

     //Size

     double width() const { return m_width; }

     double height() const { return m_height; }

     double visualWidth() const;

     double visualHeight() const;

     double visualLineWidth();

     void setWidth(const double);

     void setHeight(const double);

     void setWidthHeight(const double, const double, bool drawingOnly);

     void setWidthHeight(const double, const double);

     void resizeBy(const double, const double);

     //Rotation

     double rotation() const { return m_rotation; }

     void setRotation(const double, bool drawingOnly);

     void setRotation(const double r) { setRotation(r, false); }

     void rotateBy(const double);

     //Selection

     bool isSelected() const { return m_isSelected; }

     void setSelected(const bool);

     //Image Data

     double imageXScale() const { return m_imageXScale; }

     double imageYScale() const { return m_imageYScale; }

     void setImageXScale(const double);

     void setImageYScale(const double);

     void setImageXYScale(const double, const double);

     double imageXOffset() const { return m_imageXOffset; }

     double imageYOffset() const { return m_imageYOffset; }

     void setImageXOffset(const double);

     void setImageYOffset(const double);

     void moveImageXYOffsetBy(const double, const double);

     void setImageXYOffset(const double, const double);

     double imageRotation() const { return m_imageRotation; }

     void setImageRotation(const double newRotation);

     //Reverse

     bool reversed() const { return m_isReversed; }

     void setReversed(bool);

     //Rounded Corners

     double cornerRadius() const { return m_roundedCorderRadius; }

     void setCornerRadius(double);

     // PDF bookmark

     bool isPDFBookmark() const { return isBookmark; }

     void setIsPDFBookmark(bool val) { isBookmark = val; }


     int gradientType() const { return GrType; }

     void setGradientType(int val);

     double gradientStartX() const { return GrStartX; }

     void setGradientStartX(double val);

     double gradientStartY() const { return GrStartY; }

     void setGradientStartY(double val);

     double gradientEndX() const { return GrEndX; }

     void setGradientEndX(double val);

     double gradientEndY() const { return GrEndY; }

     void setGradientEndY(double val);

     double gradientFocalX() const { return GrFocalX; }

     void setGradientFocalX(double val);

     double gradientFocalY() const { return GrFocalY; }

     void setGradientFocalY(double val);

     double gradientScale() const { return GrScale; }

     void setGradientScale(double val);

     double gradientSkew() const { return GrSkew; }

     void setGradientSkew(double val);

     double gradientMaskStartX() const { return GrMaskStartX; }

     void setGradientMaskStartX(double val);

     double gradientMaskStartY() const { return GrMaskStartY; }

     void setGradientMaskStartY(double val);

     double gradientMaskEndX() const { return GrMaskEndX; }

     void setGradientMaskEndX(double val);

     double gradientMaskEndY() const { return GrMaskEndY; }

     void setGradientMaskEndY(double val);

     double gradientMaskFocalX() const { return GrMaskFocalX; }

     void setGradientMaskFocalX(double val);

     double gradientMaskFocalY() const { return GrMaskFocalY; }

     void setGradientMaskFocalY(double val);

     double gradientMaskScale() const { return GrMaskScale; }

     void setGradientMaskScale(double val);

     double gradientMaskSkew() const { return GrMaskSkew; }

     void setGradientMaskSkew(double val);

     FPoint gradientControl1() const { return GrControl1; }

     void setGradientControl1(FPoint val);

     FPoint gradientControl2() const { return GrControl2; }

     void setGradientControl2(FPoint val);

     FPoint gradientControl3() const { return GrControl3; }

     void setGradientControl3(FPoint val);

     FPoint gradientControl4() const { return GrControl4; }

     void setGradientControl4(FPoint val);

     FPoint gradientControl5() const { return GrControl5; }

     void setGradientControl5(FPoint val);

     double gradientStrokeScale() const { return GrStrokeScale; }

     void setGradientStrokeScale(double val);

     double gradientStrokeSkew() const { return GrStrokeSkew; }

     void setGradientStrokeSkew(double val);

     double gradientStrokeFocalX() const { return GrStrokeFocalX; }

     void setGradientStrokeFocalX(double val);

     double gradientStrokeFocalY() const { return GrStrokeFocalY; }

     void setGradientStrokeFocalY(double val);

     double gradientStrokeStartX() const { return GrStrokeStartX; }

     void setGradientStrokeStartX(double val);

     double gradientStrokeStartY() const { return GrStrokeStartY; }

     void setGradientStrokeStartY(double val);

     double gradientStrokeEndX() const { return GrStrokeEndX; }

     void setGradientStrokeEndX(double val);

     double gradientStrokeEndY() const { return GrStrokeEndY; }

     void setGradientStrokeEndY(double val);

     QString gradientCol1() const { return GrColorP1; }

     void setGradientCol1(QString val);

     QString gradientCol2() const { return GrColorP2; }

     void setGradientCol2(QString val);

     QString gradientCol3() const { return GrColorP3; }

     void setGradientCol3(QString val);

     QString gradientCol4() const { return GrColorP4; }

     void setGradientCol4(QString val);

     double gradientTransp1() const { return GrCol1transp; }

     void setGradientTransp1(double val);

     double gradientTransp2() const { return GrCol2transp; }

     void setGradientTransp2(double val);

     double gradientTransp3() const { return GrCol3transp; }

     void setGradientTransp3(double val);

     double gradientTransp4() const { return GrCol4transp; }

     void setGradientTransp4(double val);

     int gradientShade1() const { return GrCol1Shade; }

     void setGradientShade1(int val);

     int gradientShade2() const { return GrCol2Shade; }

     void setGradientShade2(int val);

     int gradientShade3() const { return GrCol3Shade; }

     void setGradientShade3(int val);

     int gradientShade4() const { return GrCol4Shade; }

     void setGradientShade4(int val);

     QColor gradientColor1() const { return GrColorP1QColor; }

     void setGradientColor1(QColor val);

     QColor gradientColor2() const { return GrColorP2QColor; }

     void setGradientColor2(QColor val);

     QColor gradientColor3() const { return GrColorP3QColor; }

     void setGradientColor3(QColor val);

     QColor gradientColor4() const { return GrColorP4QColor; }

     void setGradientColor4(QColor val);

     void setGradientExtend(VGradient::VGradientRepeatMethod val);

     void setStrokeGradientExtend(VGradient::VGradientRepeatMethod val);

     VGradient::VGradientRepeatMethod getGradientExtend();

     VGradient::VGradientRepeatMethod getStrokeGradientExtend();


     //>> ********* Attributes of the item *********


     bool getSnapToPatchGrid() const { return snapToPatchGrid; }

     void setSnapToPatchGrid(bool val);

     void setMaskGradient(VGradient grad);

     void setFillGradient(VGradient grad);

     void setStrokeGradient(VGradient grad);

     void set4ColorGeometry(FPoint c1, FPoint c2, FPoint c3, FPoint c4);

     void set4ColorTransparency(double t1, double t2, double t3, double t4);

     void set4ColorShade(int t1, int t2, int t3, int t4);

     void set4ColorColors(QString col1, QString col2, QString col3, QString col4);

     void get4ColorGeometry(FPoint &c1, FPoint &c2, FPoint &c3, FPoint &c4);

     void setDiamondGeometry(FPoint c1, FPoint c2, FPoint c3, FPoint c4, FPoint c5);

     void get4ColorTransparency(double &t1, double &t2, double &t3, double &t4);

     void get4ColorColors(QString &col1, QString &col2, QString &col3, QString &col4);

     void setMeshPointColor(int x, int y, QString color, int shade, double transparency, bool forPatch = false);

     void createGradientMesh(int rows, int cols);

     void resetGradientMesh();

     void meshToShape();

     void createConicalMesh();

     VColorStop computeInBetweenStop(VColorStop* last, VColorStop* actual, double t);

     void gradientVector(double& startX, double& startY, double& endX, double& endY, double &focalX, double &focalY, double &scale, double &skew) const;

     void setGradientVector(double startX, double startY, double endX, double endY, double focalX, double focalY, double scale, double skew);


     int strokeGradientType() const { return GrTypeStroke; }

     void setStrokeGradientType(int val);

     void strokeGradientVector(double& startX, double& startY, double& endX, double& endY, double &focalX, double &focalY, double &scale, double &skew) const;

     void setStrokeGradientVector(double startX, double startY, double endX, double endY, double focalX, double focalY, double scale, double skew);


     int maskType() const { return GrMask; }

     void setMaskType(int val);

     void setGradientMask(const QString &newMask);

     void setPatternMask(const QString &newMask);

     QString gradientMask() const { return gradientMaskVal; }

     QString patternMask() const { return patternMaskVal; }

     void maskVector(double& startX, double& startY, double& endX, double& endY, double &focalX, double &focalY, double &scale, double &skew) const;

     void setMaskVector(double startX, double startY, double endX, double endY, double focalX, double focalY, double scale, double skew);

     void maskTransform(double &scaleX, double &scaleY, double &offsetX, double &offsetY, double &rotation, double &skewX, double &skewY) const;

     void setMaskTransform(double scaleX, double scaleY, double offsetX, double offsetY, double rotation, double skewX, double skewY);

     void setMaskFlip(bool flipX, bool flipY);

     void maskFlip(bool &flipX, bool &flipY);

     //

     bool fillEvenOdd() const { return fillRule; }

     void setFillEvenOdd(bool val) { fillRule = val; }

     //

     bool overprint() const { return doOverprint; }

     void setOverprint(bool val);


     // soft shadow

     void setHasSoftShadow(bool val);

     bool hasSoftShadow() { return m_hasSoftShadow; }


     void setSoftShadowColor(const QString &val);

     QString softShadowColor() { return m_softShadowColor; }


     void setSoftShadowShade(int val);

     int softShadowShade() { return m_softShadowShade; }


     void setSoftShadowBlurRadius(double val);

     double softShadowBlurRadius() { return m_softShadowBlurRadius; }


     void setSoftShadowXOffset(double val);

     double softShadowXOffset() { return m_softShadowXOffset; }


     void setSoftShadowYOffset(double val);

     double softShadowYOffset() { return m_softShadowYOffset; }


     void setSoftShadowOpacity(double val);

     double softShadowOpacity() { return m_softShadowOpacity; }


     void setSoftShadowBlendMode(int val);

     double softShadowBlendMode() { return m_softShadowBlendMode; }


     void setSoftShadowErasedByObject(bool val);

     bool softShadowErasedByObject() { return m_softShadowErasedByObject; }


     void setSoftShadowHasObjectTransparency(bool val);

     bool softShadowHasObjectTransparency() { return m_softShadowHasObjectTransparency; }


     int frameType() const { return FrameType; }

     void setFrameType(int val) { FrameType = val; }

     //

     bool hasDefaultShape() const { return !ClipEdited; }

     void setHasDefaultShape(bool val) { ClipEdited = !val; }

     //

     bool isAutoFrame() const { return isAutoText; }

     void setIsAutoFrame(bool val) { isAutoText = val; }

     //

     bool keepAspectRatio() const { return AspectRatio; }

     void setKeepAspectRatio(bool val) { AspectRatio = val; }

     //

     bool fitImageToFrame() const { return !ScaleType; }

     void setFitImageToFrame(bool val) { ScaleType = !val; }

     bool isImageInline() const { return isInlineImage; }

     void setImageInline(bool val) { isInlineImage = val; }

     void setInlineExt(QString val) { inlineExt = val; }

     void setInlineData(QString data);

     void makeImageInline();

     void makeImageExternal(QString path);


     //Text Data - Move to PageItem_TextFrame at some point? --- no, to FrameStyle, av

     double textToFrameDistLeft() const { return m_textDistanceMargins.left(); }

     double textToFrameDistRight() const { return m_textDistanceMargins.right(); }

     double textToFrameDistTop() const { return m_textDistanceMargins.top(); }

     double textToFrameDistBottom() const { return m_textDistanceMargins.bottom(); }

     int columns() const { return Cols; }

     double columnGap() const { return ColGap; }

     double gridOffset() const;

     double gridDistance() const;

     int verticalAlignment();

     void setTextToFrameDistLeft(double);

     void setTextToFrameDistRight(double);

     void setTextToFrameDistTop(double);

     void setTextToFrameDistBottom(double);

     void setColumns(int);

     void setColumnGap(double);

     void setGridOffset(double);

     void setGridDistance(double);

     void setVerticalAlignment(int);

     FirstLineOffsetPolicy firstLineOffset()const;

     void setFirstLineOffset(FirstLineOffsetPolicy);

     void setTextToFrameDist(double newLeft, double newRight, double newTop, double newBottom);


     QString itemName() const { return AnName; }

     void setItemName(const QString& newName);


     QString gradient() const { return gradientVal; }


     void setGradient(const QString &newGradient);


     QString strokeGradient() const { return gradientStrokeVal; }


     void setStrokeGradient(const QString &newGradient);


     QString pattern() const { return patternVal; }


     void patternTransform(double &scaleX, double &scaleY, double &offsetX, double &offsetY, double &rotation, double &skewX, double &skewY) const;


     void setPattern(const QString &newPattern);


     void setPatternTransform(double scaleX, double scaleY, double offsetX, double offsetY, double rotation, double skewX, double skewY);

     void setPatternFlip(bool flipX, bool flipY);

     void patternFlip(bool &flipX, bool &flipY);


     QString fillColor() const { return fillColorVal; }

     void setFillColor(const QString &newColor);


     double fillShade() const { return fillShadeVal; }

     void setFillShade(double newShade);


     double fillTransparency() const { return fillTransparencyVal; }

     void setFillTransparency(double newTransparency);


     int fillBlendmode() const { return fillBlendmodeVal; }

     void setFillBlendmode(int newBlendmode);


     int lineBlendmode() const { return lineBlendmodeVal; }

     void setLineBlendmode(int newBlendmode);


     QString lineColor() const { return lineColorVal; }

     void setLineColor(const QString &newColor);


     double lineShade() const { return lineShadeVal; }

     void setLineShade(double newShade);


     double lineTransparency() const { return lineTransparencyVal; }

     void setLineTransparency(double newTransparency);


     void setHatchParameters(int mode, double distance, double angle, bool useBackground, QString background, QString foreground);


     QString strokePattern() const { return patternStrokeVal; }


     void strokePatternTransform(double &scaleX, double &scaleY, double &offsetX, double &offsetY, double &rotation, double &skewX, double &skewY, double &space) const;


     void setStrokePattern(const QString &newPattern);


     void setStrokePatternTransform(double scaleX, double scaleY, double offsetX, double offsetY, double rotation, double skewX, double skewY, double space);

     void setStrokePatternFlip(bool flipX, bool flipY);

     void strokePatternFlip(bool &flipX, bool &flipY);

     void setStrokePatternToPath(bool enable);

     bool isStrokePatternToPath();


     void setLineQColor();

     void setFillQColor();


     Qt::PenStyle lineStyle() const { return PLineArt; }

     void setLineStyle(Qt::PenStyle newStyle);


     double lineWidth() const { return m_lineWidth; }

     void setLineWidth(double newWidth);


     Qt::PenCapStyle lineEnd() const { return PLineEnd; }

     void setLineEnd(Qt::PenCapStyle newStyle);


     Qt::PenJoinStyle lineJoin() const { return PLineJoin; }

     void setLineJoin(Qt::PenJoinStyle newStyle);


     QString customLineStyle() const { return NamedLStyle; }

     void setCustomLineStyle(const QString& newStyle);


     int startArrowIndex() const { return m_startArrowIndex; }

     void setStartArrowIndex(int newIndex);


     int endArrowIndex() const { return m_endArrowIndex; }

     void setEndArrowIndex(int newIndex);


     int startArrowScale() const { return m_startArrowScale; }

     void setStartArrowScale(int newScale);


     int endArrowScale() const { return m_endArrowScale; }

     void setEndArrowScale(int newScale);


     bool imageFlippedH() const { return m_ImageIsFlippedH; }

     void setImageFlippedH(bool flipped);

     void flipImageH();


     bool imageFlippedV() const { return m_ImageIsFlippedV; }

     void setImageFlippedV(bool flipped);

     void flipImageV();


     void setImageScalingMode(bool freeScale, bool keepRatio);


     void toggleLock();

     bool locked() const { return m_Locked; }

     void setLocked(bool isLocked);


     void toggleSizeLock();

     bool sizeLocked() const { return m_SizeLocked; }

     bool sizeHLocked() const { return m_SizeHLocked || m_SizeLocked; }

     bool sizeVLocked() const { return m_SizeVLocked || m_SizeLocked; }

     void setSizeLocked(bool isLocked);

     void setSizeHLocked(bool isLocked) { m_SizeHLocked = isLocked; }

     void setSizeVLocked(bool isLocked) { m_SizeVLocked = isLocked; }


     TextFlowMode textFlowMode() const { return textFlowModeVal; }


     void setTextFlowMode(TextFlowMode mode);


     bool textFlowAroundObject() const { return (textFlowModeVal != TextFlowDisabled); }


     bool textFlowUsesFrameShape() const { return (textFlowModeVal == TextFlowUsesFrameShape); }


     bool textFlowUsesBoundingBox() const { return (textFlowModeVal == TextFlowUsesBoundingBox); }


     bool textFlowUsesContourLine() const { return (textFlowModeVal == TextFlowUsesContourLine); }


     bool textFlowUsesImageClipping() const { return (textFlowModeVal == TextFlowUsesImageClipping); }


     void checkTextFlowInteractions(bool allItems = false);


     ItemType itemType() const { return m_ItemType; }

     virtual ItemType realItemType() const { return m_ItemType; }

     void convertTo(ItemType newType);


     virtual void setLayer(int layerId);


     void checkChanges(bool force = false);

     void moveUndoAction();

     void resizeUndoAction();

     void rotateUndoAction();

     void changeImageOffsetUndoAction();

     void changeImageScaleUndoAction();

     void restore(UndoState *state, bool isUndo);


     virtual void getNamedResources(ResourceCollection& lists) const;

     virtual void replaceNamedResources(ResourceCollection& newNames);


     QString generateUniqueCopyName(const QString originalName, bool prependCopy = true) const;

     bool printEnabled() const { return m_PrintEnabled; }

     void setPrintEnabled(bool toPrint);


     void togglePrintEnabled();


     bool isTagged() const { return tagged; }

     void setTagged(bool);


     bool loadImage(const QString& filename, const bool reload, const int gsResolution=-1, bool showMsg = false);


     bool connectToGUI();

     bool disconnectFromGUI();

     void emitAllToGUI();


     ScribusDoc* doc() const { return m_Doc; }


     bool isAnnotation() const { return m_isAnnotation; }

     void setIsAnnotation(bool);

     void setIsBookMark(bool);

     void setAnnotation(const Annotation& ad);

     Annotation& annotation() { return m_annotation; }

     const Annotation& annotation() const { return m_annotation; }


     bool imageVisible() const { return m_imageVisible; }

     void setImageVisible(bool);


     void updateConstants();

     bool isWelded()  {return !weldList.isEmpty(); }  //true if to this item some other items are welded (weldList is list of these items)

     void weldTo(PageItem* item);

     QList<PageItem*> itemsWeldedTo(PageItem* except = NULL);

     void unWeld();

     void addWelded(PageItem* item);

     void moveWelded(double dX, double dY, int weld);

     void moveWelded(double dX, double dY, PageItem* except = NULL);

     void rotateWelded(double dR, double oldRot);

     void setWeldPoint(double dX, double dY, PageItem *pItem);

     QString getItemTextSaxed(int selStart, int selLength);

     bool groupClipping() { return m_groupClips; }

     void setGroupClipping(bool val) { m_groupClips = val; }

     bool hasFill() { return ((fillColor() != CommonStrings::None) || (GrType != 0)); }

     bool hasStroke() { return ((lineColor() != CommonStrings::None) || (GrTypeStroke != 0) || (!NamedLStyle.isEmpty()) || (!patternStrokeVal.isEmpty())); }


         // End public functions


 public: // Start public variables

     int maxCharsInFrame();

     bool AutoName;

     double gXpos;

     double gYpos;

     double gWidth;

     double gHeight;

     int GrType;

     double GrStartX;

     double GrStartY;

     double GrEndX;

     double GrEndY;

     double GrFocalX;

     double GrFocalY;

     double GrScale;

     double GrSkew;

     VGradient::VGradientRepeatMethod GrExtend;

     FPoint GrControl1;

     FPoint GrControl2;

     FPoint GrControl3;

     FPoint GrControl4;

     FPoint GrControl5;

     QString GrColorP1;

     QString GrColorP2;

     QString GrColorP3;

     QString GrColorP4;

     double GrCol1transp;

     double GrCol2transp;

     double GrCol3transp;

     double GrCol4transp;

     int GrCol1Shade;

     int GrCol2Shade;

     int GrCol3Shade;

     int GrCol4Shade;

     QList<meshGradientPatch> meshGradientPatches;

     QList<QList<meshPoint> > meshGradientArray;

     int selectedMeshPointX;

     int selectedMeshPointY;

     int selectedMeshControlPoint;

     bool snapToPatchGrid;

     int Cols;

     double ColGap;

     double gridOffset_;

     double gridValue_;

     int m_startArrowIndex;

     int m_endArrowIndex;

     int m_startArrowScale;

     int m_endArrowScale;

     Qt::PenStyle PLineArt;

     Qt::PenCapStyle PLineEnd;

     Qt::PenJoinStyle PLineJoin;

     QString NamedLStyle;

     QPolygon Clip;


     FPointArray PoLine;

     FPointArray ContourLine;

     FPointArray imageClip;

     QList<uint> Segments;

     ScImageEffectList effectsInUse;

     bool PoShow;

     double BaseOffs;

     int textPathType;

     bool textPathFlipped;

     bool ClipEdited;

     int FrameType;

     uint uniqueNr;

     int OwnPage;

     int oldOwnPage;

     int savedOwnPage;

     ScImage pixm;

     QString Pfile;

     QString Pfile2;

     QString Pfile3;

     QString IProfile;

     bool UseEmbedded;

     QString EmProfile;

     eRenderIntent IRender;

     bool OverrideCompressionMethod;

     int CompressionMethodIndex;

     bool OverrideCompressionQuality;

     int CompressionQualityIndex;

     bool imageIsAvailable;

     int OrigW;

     int OrigH;

     double BBoxX;

     double BBoxH;

     double CurX;

     double CurY;

     StoryText itemText;

     TextLayout textLayout;

     bool isBookmark;

     bool Dirty;

     bool invalid;

     bool HasSel;

     bool FrameOnly;

     bool isAutoText;

     PageItem *Parent;

     bool inPdfArticle;

     bool isRaster;

     double OldB;

     double OldH;

     double OldB2;

     double OldH2;

     bool Sizing;

     int  LayerID;

     bool ScaleType;

     bool AspectRatio;

     QVector<double> DashValues;

     double DashOffset;

     VGradient fill_gradient;

     bool fillRule;

     bool doOverprint;

     bool m_hasSoftShadow;

     QString m_softShadowColor;

     int m_softShadowShade;

     double m_softShadowBlurRadius;

     double m_softShadowXOffset;

     double m_softShadowYOffset;

     double m_softShadowOpacity;

     int m_softShadowBlendMode;

     bool m_softShadowErasedByObject;

     bool m_softShadowHasObjectTransparency;

     /* Additions for Table Support */

     /* now deprecated with the new PageItem_Table */

         PageItem* LeftLink;

         PageItem* RightLink;

         PageItem* TopLink;

         PageItem* BottomLink;

         int LeftLinkID;

         int RightLinkID;

         int TopLinkID;

         int BottomLinkID;

         bool LeftLine;

         bool RightLine;

         bool TopLine;

         bool BottomLine;

         bool isTableItem;

     /* end deprecated vars */

         bool isSingleSel;

         QList<PageItem*> groupItemList;

         double groupWidth;

         double groupHeight;

         double BoundingX;

         double BoundingY;

         double BoundingW;

         double BoundingH;

         bool ChangedMasterItem;

         QString OnMasterPage;

         bool isEmbedded;

         int inlineCharID;

         QString inlineExt;

         double m_roundedCorderRadius;


         //Undo Data

         double oldXpos;

         double oldYpos;

         double oldWidth;

         double oldHeight;

         double oldRot;

         double oldLocalScX;

         double oldLocalScY;

         double oldLocalX;

         double oldLocalY;


         ScribusDoc *m_Doc;


         bool m_isAnnotation;

         Annotation m_annotation;


         bool m_imageVisible;


         double m_lineWidth; //< Line width

         double Oldm_lineWidth;


         QString patternStrokeVal;

         double patternStrokeScaleX;

         double patternStrokeScaleY;

         double patternStrokeOffsetX;

         double patternStrokeOffsetY;

         double patternStrokeRotation;

         double patternStrokeSkewX;

         double patternStrokeSkewY;

         double patternStrokeSpace;

         bool patternStrokeMirrorX;

         bool patternStrokeMirrorY;

         bool patternStrokePath;


         QString gradientStrokeVal;

         VGradient stroke_gradient;


         int GrTypeStroke;

         double GrStrokeStartX;

         double GrStrokeStartY;

         double GrStrokeEndX;

         double GrStrokeEndY;

         double GrStrokeFocalX;

         double GrStrokeFocalY;

         double GrStrokeScale;

         double GrStrokeSkew;

         VGradient::VGradientRepeatMethod GrStrokeExtend;


         int GrMask;

         double GrMaskStartX;

         double GrMaskStartY;

         double GrMaskEndX;

         double GrMaskEndY;

         double GrMaskFocalX;

         double GrMaskFocalY;

         double GrMaskScale;

         double GrMaskSkew;

         double patternMaskScaleX;

         double patternMaskScaleY;

         double patternMaskOffsetX;

         double patternMaskOffsetY;

         double patternMaskRotation;

         double patternMaskSkewX;

         double patternMaskSkewY;

         bool patternMaskMirrorX;

         bool patternMaskMirrorY;

         QString patternMaskVal;

         QString gradientMaskVal;

         VGradient mask_gradient;


         bool isInlineImage;

         bool isTempFile;

         //items welding (item follows while item moves which they are connected with)

         struct WeldingInfo

         {

             PageItem *weldItem;

             FPoint weldPoint;

             int weldID;

         };

         QList<WeldingInfo> weldList;

         double hatchAngle;

         double hatchDistance;

         int hatchType;              // 0 = single 1 = double 2 = triple

         bool hatchUseBackground;

         QString hatchBackground;

         QString hatchForeground;


         // End public variables


 protected: // Start protected functions

     PageItem(const PageItem & other);

     void DrawObj_ImageFrame(ScPainter *p, double sc);

     void DrawObj_Polygon(ScPainter *p);

     void DrawObj_PolyLine(ScPainter *p);

     void DrawObj_PathText(ScPainter *p, double sc);

     void drawLockedMarker(ScPainter *p);

     void drawArrow(ScPainter *p, QTransform &arrowTrans, int arrowIndex);


     UndoManager * const undoManager;


     bool checkGradientUndoRedo(SimpleState *state, bool isUndo);


     void restoreAppMode(SimpleState *state, bool isUndo);

     void restoreArc(SimpleState *state,bool isUndo);

     void restoreArrow(SimpleState *state, bool isUndo, bool isStart);

     void restoreBottomTextFrameDist(SimpleState *state, bool isUndo);

     void restoreCharStyle(SimpleState *state, bool isUndo);

     void restoreClearImage(UndoState *state, bool isUndo);

     void restoreColumns(SimpleState *state, bool isUndo);

     void restoreColumnsGap(SimpleState *state, bool isUndo);

     void restoreConnectPath(SimpleState *state, bool isUndo);

     void restoreContourLine(SimpleState *state, bool isUndo);

     void restoreCornerRadius(SimpleState *state, bool isUndo);

     void restoreCreateMeshGrad(SimpleState *state, bool isUndo);

     void restoreCustomLineStyle(SimpleState *state, bool isUndo);

     void restoreDefaultParagraphStyle(SimpleState *state, bool isUndo);

     void restoreDeleteFrameText(SimpleState *state, bool isUndo);

     void restoreDropLinks(UndoState *state, bool isUndo);

     void restoreEndArrowScale(SimpleState *state, bool isUndo);

     void restoreFill(SimpleState *state, bool isUndo);

     void restoreFillGradient(SimpleState *state, bool isUndo);

     void restoreFillTP(SimpleState *state, bool isUndo);

     void restoreFirstLineOffset(SimpleState *state, bool isUndo);

     void restoreGetImage(UndoState *state, bool isUndo);

     void restoreGradPos(SimpleState *state,bool isUndo);

     void restoreGradientCol1(SimpleState *state, bool isUndo);

     void restoreGradientCol2(SimpleState *state, bool isUndo);

     void restoreGradientCol3(SimpleState *state, bool isUndo);

     void restoreGradientCol4(SimpleState *state, bool isUndo);

     void restoreGradientColor1(SimpleState *state, bool isUndo);

     void restoreGradientColor2(SimpleState *state, bool isUndo);

     void restoreGradientColor3(SimpleState *state, bool isUndo);

     void restoreGradientColor4(SimpleState *state, bool isUndo);

     void restoreGradientControl1(SimpleState *state, bool isUndo);

     void restoreGradientControl2(SimpleState *state, bool isUndo);

     void restoreGradientControl3(SimpleState *state, bool isUndo);

     void restoreGradientControl4(SimpleState *state, bool isUndo);

     void restoreGradientControl5(SimpleState *state, bool isUndo);

     void restoreGradientEndX(SimpleState *state, bool isUndo);

     void restoreGradientEndY(SimpleState *state, bool isUndo);

     void restoreGradientFocalX(SimpleState *state, bool isUndo);

     void restoreGradientFocalY(SimpleState *state, bool isUndo);

     void restoreGradientMaskEndX(SimpleState *state, bool isUndo);

     void restoreGradientMaskEndY(SimpleState *state, bool isUndo);

     void restoreGradientMaskFocalX(SimpleState *state, bool isUndo);

     void restoreGradientMaskFocalY(SimpleState *state, bool isUndo);

     void restoreGradientMaskScale(SimpleState *state, bool isUndo);

     void restoreGradientMaskSkew(SimpleState *state, bool isUndo);

     void restoreGradientMaskStartX(SimpleState *state, bool isUndo);

     void restoreGradientMaskStartY(SimpleState *state, bool isUndo);

     void restoreGradientMeshColor(SimpleState *state, bool isUndo);

     void restoreGradientScale(SimpleState *state, bool isUndo);

     void restoreGradientShade1(SimpleState *state, bool isUndo);

     void restoreGradientShade2(SimpleState *state, bool isUndo);

     void restoreGradientShade3(SimpleState *state, bool isUndo);

     void restoreGradientShade4(SimpleState *state, bool isUndo);

     void restoreGradientSkew(SimpleState *state, bool isUndo);

     void restoreGradientStartX(SimpleState *state, bool isUndo);

     void restoreGradientStartY(SimpleState *state, bool isUndo);

     void restoreGradientStrokeEndX(SimpleState *state, bool isUndo);

     void restoreGradientStrokeEndY(SimpleState *state, bool isUndo);

     void restoreGradientStrokeFocalX(SimpleState *state, bool isUndo);

     void restoreGradientStrokeFocalY(SimpleState *state, bool isUndo);

     void restoreGradientStrokeScale(SimpleState *state, bool isUndo);

     void restoreGradientStrokeSkew(SimpleState *state, bool isUndo);

     void restoreGradientStrokeStartX(SimpleState *state, bool isUndo);

     void restoreGradientStrokeStartY(SimpleState *state, bool isUndo);

     void restoreGradientTrans1(SimpleState *state, bool isUndo);

     void restoreGradientTrans2(SimpleState *state, bool isUndo);

     void restoreGradientTrans3(SimpleState *state, bool isUndo);

     void restoreGradientTrans4(SimpleState *state, bool isUndo);

     void restoreGradientType(SimpleState *state, bool isUndo);

     void restoreGradientTypeStroke(SimpleState *state, bool isUndo);

     void restoreImageEffects(UndoState *state, bool isUndo);

     void restoreImageNbr(SimpleState *state,bool isUndo);

     void restoreImageOffsetChange(SimpleState *state, bool isUndo);

     void restoreImageRotation(SimpleState *state, bool isUndo);

     void restoreImageScaleChange(SimpleState *state, bool isUndo);

     void restoreImageScaleMode(SimpleState *state, bool isUndo);

     void restoreInsertFrameText(SimpleState *state, bool isUndo);

     void restoreLayer(SimpleState *state, bool isUndo);

     void restoreLeftTextFrameDist(SimpleState *state, bool isUndo);

     void restoreLineColor(SimpleState *state, bool isUndo);

     void restoreLineEnd(SimpleState *state, bool isUndo);

     void restoreLineJoin(SimpleState *state, bool isUndo);

     void restoreLineShade(SimpleState *state, bool isUndo);

     void restoreLineStyle(SimpleState *state, bool isUndo);

     void restoreLineTP(SimpleState *state, bool isUndo);

     void restoreLineWidth(SimpleState *state, bool isUndo);

     void restoreLinkTextFrame(UndoState *state, bool isUndo);

     void restoreMarkString(SimpleState *state, bool isUndo);

     void restoreMaskGradient(SimpleState *state, bool isUndo);

     void restoreMaskType(SimpleState *state,bool isUndo);

     void restoreMove(SimpleState *state, bool isUndo);

     void restoreMoveMeshGrad(SimpleState *state, bool isUndo);

     void restoreMoveMeshPatch(SimpleState *state, bool isUndo);

     void restoreName(SimpleState *state, bool isUndo);

     void restorePStyle(SimpleState *state, bool isUndo);

     void restoreParagraphStyle(SimpleState *state, bool isUndo);

     void restorePasteInline(SimpleState *state, bool isUndo);

     void restorePasteText(SimpleState *state, bool isUndo);

     void restorePathOperation(UndoState *state, bool isUndo);

     void restorePoly(SimpleState *state, bool isUndo, bool isContour);

     void restorePolygon(SimpleState *state,bool isUndo);

     void restoreRemoveMeshPatch(SimpleState *state, bool isUndo);

     void restoreResTyp(SimpleState *state, bool isUndo);

     void restoreResetMeshGrad(SimpleState *state, bool isUndo);

     void restoreResize(SimpleState *state, bool isUndo);

     void restoreReverseText(UndoState *state, bool isUndo);

     void restoreRightTextFrameDist(SimpleState *state, bool isUndo);

     void restoreRotate(SimpleState *state, bool isUndo);

     void restoreSetCharStyle(SimpleState *state, bool isUndo);

     void restoreSetParagraphStyle(SimpleState *state, bool isUndo);

     void restoreShade(SimpleState *state, bool isUndo);

     void restoreShapeContour(UndoState *state, bool isUndo);

     void restoreShapeType(SimpleState *state, bool isUndo);

     void restoreShowImage(SimpleState *state, bool isUndo);

     void restoreSnapToPatchGrid(SimpleState *state, bool isUndo);

     void restoreSpiral(SimpleState *state, bool isUndo);

     void restoreSplitItem(SimpleState *state, bool isUndo);

     void restoreStartArrowScale(SimpleState *state, bool isUndo);

     void restoreStrokeGradient(SimpleState *state, bool isUndo);

     void restoreTextFlowing(SimpleState *state, bool isUndo);

     void restoreTopTextFrameDist(SimpleState *state, bool isUndo);

     void restoreTransform(SimpleState *state,bool isUndo);

     void restoreType(SimpleState *state, bool isUndo);

     void restoreUnWeldItem(SimpleState *state, bool isUndo);

     void restoreUniteItem(SimpleState *state, bool isUndo);

     void restoreUnlinkTextFrame(UndoState *state, bool isUndo);

     void restoreVerticalAlign(SimpleState *state, bool isUndo);

     void restoreWeldItems(SimpleState *state, bool isUndo);

     void restoreSoftShadow(SimpleState *state, bool isUndo);

     void restoreSoftShadowColor(SimpleState *state, bool isUndo);

     void restoreSoftShadowShade(SimpleState *state, bool isUndo);

     void restoreSoftShadowBlurRadius(SimpleState *state, bool isUndo);

     void restoreSoftShadowXOffset(SimpleState *state, bool isUndo);

     void restoreSoftShadowYOffset(SimpleState *state, bool isUndo);

     void restoreSoftShadowOpacity(SimpleState *state, bool isUndo);

     void restoreSoftShadowBlendMode(SimpleState *state, bool isUndo);

     void restoreSoftShadowErasedByObject(SimpleState *state, bool isUndo);

     void restoreSoftShadowHasObjectTransparency(SimpleState *state, bool isUndo);


     bool shouldCheck();

     void select();


         // End protected functions


 protected: // Start protected variables

     PageItem *BackBox;

     PageItem *NextBox;

     uint firstChar;

     uint MaxChars;

     bool m_sampleItem;

     MarginStruct m_textDistanceMargins;

     int verticalAlign;

     ItemType m_ItemType;


     QString AnName;


     QString gradientVal;


     QString patternVal;

     double patternScaleX;

     double patternScaleY;

     double patternOffsetX;

     double patternOffsetY;

     double patternRotation;

     double patternSkewX;

     double patternSkewY;

     bool patternMirrorX;

     bool patternMirrorY;


     QString fillColorVal;


     QString lineColorVal;


     double lineShadeVal;


     double fillShadeVal;


     double fillTransparencyVal;


     double lineTransparencyVal;


     int fillBlendmodeVal;


     int lineBlendmodeVal;


     bool m_ImageIsFlippedH;


     bool m_ImageIsFlippedV;


     bool m_Locked;


     bool m_SizeLocked;


     bool m_SizeHLocked;

     bool m_SizeVLocked;

     TextFlowMode textFlowModeVal;


     ObjAttrVector pageItemAttributes;


     bool m_PrintEnabled;


     bool tagged;


     bool no_fill;

     bool no_stroke;


     QColor fillQColor;

     QColor strokeQColor;

     QColor GrColorP1QColor;

     QColor GrColorP2QColor;

     QColor GrColorP3QColor;

     QColor GrColorP4QColor;


     double m_xPos;

     double m_yPos;

     double m_width;

     double m_height;

     double m_rotation;

     bool m_isSelected;

     double m_imageXScale;

     double m_imageYScale;

     double m_imageXOffset;

     double m_imageYOffset;

     double m_imageRotation;

     bool m_isReversed;

     FirstLineOffsetPolicy firstLineOffsetP;

     bool m_groupClips;

     QColor hatchBackgroundQ;

     QColor hatchForegroundQ;


             // End protected variables


 private:    // Start private functions

     QString getImageEffectsModifier() const;


             // End private functions


 private:    // Start private variables

             // End private variables


 signals:

     //Frame signals

     void myself(PageItem *);

     void frameType(int);

     //void frameLocked(bool); ///< Frame lock

     //void frameSizeLocked(bool); ///< Frame size lock

     //Shape signals

     //void cornerRadius(double); ///< Corner radius of the shape

     //Frame text signals

     //void lineSpacing(double);

     //void textKerning(double);

     void textStyle(int);

     //void textFont(const QString&);

     //void textSize(double);

     //void textToFrameDistances(double, double, double, double); //left, top, bottom, right: Extra, TExtra, BExtra, RExtra

     //FIXME: columns, grid ?


 };


 Q_DECLARE_METATYPE(PageItem*)


 bool compareItemLevel(const PageItem* item1, const PageItem* item2);


 #endif

PageItem::CurY
double CurY
Zeichen Y-Position.
Definition: pageitem.h:1295

PageItem::startArrowScale
int startArrowScale() const
Get start arrow scale.
Definition: pageitem.h:962

PageItem::m_imageRotation
double m_imageRotation
Image rotation in frame.
Definition: pageitem.h:1819

PageItem_NoteFrame
Definition: pageitem_noteframe.h:8

PageItem::lineShadeVal
double lineShadeVal
Line shade.
Definition: pageitem.h:1712

PageItem::asArc
virtual PageItem_Arc * asArc()
Return self if Arc item, otherwise null.
Definition: pageitem.h:223

StoryText
Definition: storytext.h:71

PageItem_Spiral
Definition: pageitem_spiral.h:34

PageItem::asOSGFrame
virtual PageItem_OSGFrame * asOSGFrame()
Return self if OSG item, otherwise null.
Definition: pageitem.h:229

PageItem::oldLocalScX
double oldLocalScX
Stores the old LocalScX value for undo action. Is used to detect image scale actions.
Definition: pageitem.h:1368

PageItem::isAutoNoteFrame
virtual bool isAutoNoteFrame() const
Return true if Auto Note item, otherwise false.
Definition: pageitem.h:240

PageItem::gradientStrokeVal
QString gradientStrokeVal
Stroke gradient name.
Definition: pageitem.h:1409

PageItem::WeldingInfo
Definition: pageitem.h:1455

CharStyle
Definition: charstyle.h:78

PageItem::oldYpos
double oldYpos
Stores the old Y-position for undo action. Is used to detect move actions.
Definition: pageitem.h:1364

PageItem::endArrowScale
int endArrowScale() const
Get end arrow scale.
Definition: pageitem.h:972

PageItem::isPolygon
virtual bool isPolygon() const
Return true if Polygon item, otherwise false.
Definition: pageitem.h:249

PageItem::patternScaleX
double patternScaleX
Fill pattern transformation matrix.
Definition: pageitem.h:1686

PageItem_Line
Definition: pageitem_line.h:34

PageItem::strokePattern
QString strokePattern() const
Get the name of the stroke pattern of the object.
Definition: pageitem.h:871

PageItem::saxx
void saxx(SaxHandler &handler, const Xml_string &elemtag) const
Definition: pageitem.h:339

PageItem::DrawOption
DrawOption
Draw options for DrawObj_toImage()
Definition: pageitem.h:162

PageItem::isTagged
bool isTagged() const
Tells if the frame is tagged or not.
Definition: pageitem.h:1150

PageItem::realItemType
virtual ItemType realItemType() const
Get the subclass item type.
Definition: pageitem.h:1082

VColorStop
Definition: vgradient.h:36

PageItem::setRotation
void setRotation(const double r)
needed for deSaXe
Definition: pageitem.h:492

MarginStruct
Pagemargins and bleeds.
Definition: margins.h:25

PageItem::textFlowUsesBoundingBox
bool textFlowUsesBoundingBox() const
If text should flow around bounding box.
Definition: pageitem.h:1047

PageItem::gradientVal
QString gradientVal
Fill gradient name.
Definition: pageitem.h:1676

PageItem::asPolyLine
virtual PageItem_PolyLine * asPolyLine()
Return self if Poly Line item, otherwise null.
Definition: pageitem.h:231

PageItem_Symbol
Definition: pageitem_symbol.h:34

PageItem::isLatexFrame
virtual bool isLatexFrame() const
Return true if Render frame item, otherwise false.
Definition: pageitem.h:243

PageItem::textFlowUsesImageClipping
bool textFlowUsesImageClipping() const
If text should flow around image clipping path.
Definition: pageitem.h:1059

PageItem::oldWidth
double oldWidth
Stores the old width for undo action. Is used to detect resize actions.
Definition: pageitem.h:1365

SaxHandler
Definition: saxhandler.h:21

PageItem_PathText
Definition: pageitem_pathtext.h:33

PageItem::fillTransparencyVal
double fillTransparencyVal
Fill transparency.
Definition: pageitem.h:1724

PageItem::fillBlendmodeVal
int fillBlendmodeVal
Fill transparency blendmode.
Definition: pageitem.h:1736

PageItem_TextFrame
Definition: pageitem_textframe.h:45

PageItem::lineWidth
double lineWidth() const
Get the width of the line.
Definition: pageitem.h:906

PageItem_LatexFrame
Displays all kinds of content generated by external programs. Named LatexFrame because it initally on...
Definition: pageitem_latexframe.h:43

PageItem::itemText
StoryText itemText
Text of element.
Definition: pageitem.h:1296

PageItem::customLineStyle
QString customLineStyle() const
Get name of active custom line style.
Definition: pageitem.h:932

PageItem::doc
ScribusDoc * doc() const
Get the document that this item belongs to.
Definition: pageitem.h:1178

PageItem::m_isAnnotation
bool m_isAnnotation
Flag to tell if this item is a PDF annotation item.
Definition: pageitem.h:1376

PageItem::lineJoin
Qt::PenJoinStyle lineJoin() const
Get the join style of multi-segment lines.
Definition: pageitem.h:923

PageItem_ImageFrame
Definition: pageitem_imageframe.h:34

PageItem::HasSel
bool HasSel
Flag for text selection.
Definition: pageitem.h:1301

PageItem::invalidateLayout
virtual void invalidateLayout()
invalidates current layout information
Definition: pageitem.h:381

ObjectAttribute
Definition: pagestructs.h:15

PageItem::textFlowAroundObject
bool textFlowAroundObject() const
If text should flow around object frame.
Definition: pageitem.h:1035

PageItem::fillShadeVal
double fillShadeVal
Fill shade.
Definition: pageitem.h:1718

PageItem::isTextFrame
virtual bool isTextFrame() const
Return true if Text item, otherwise false.
Definition: pageitem.h:254

TextLayout
Definition: textlayout.h:58

PageItem::undoManager
UndoManager *const undoManager
Manages undostack and is where all undo actions/states are sent.
Definition: pageitem.h:1481

PageItem::pattern
QString pattern() const
Get the name of the pattern of the object.
Definition: pageitem.h:786

PageItem::isTable
virtual bool isTable() const
Return true if Table item, otherwise false.
Definition: pageitem.h:253

PageItem::uniqueNr
uint uniqueNr
Internal unique Item-Number, used for the undo system.
Definition: pageitem.h:1273

UndoState
UndoState describes an undoable state (action).
Definition: undostate.h:59

PageItem::isPathText
virtual bool isPathText() const
Return true if Text Path Text, otherwise false.
Definition: pageitem.h:247

PageItem::saxx
void saxx(SaxHandler &handler) const
Definition: pageitem.h:340

PageItem::isBookmark
bool isBookmark
Flag for PDF Bookmark.
Definition: pageitem.h:1298

PageItem::tagged
bool tagged
Is this item set to have an action done to it, eg deleted.
Definition: pageitem.h:1797

PageItem::layout
virtual void layout()
creates valid layout information
Definition: pageitem.h:383

SingleObservable
Definition: observable.h:159

PageItem::oldLocalY
double oldLocalY
Stores the old LocalY value for undo action. Is used to detect image offset actions.
Definition: pageitem.h:1371

PageItem::fillShade
double fillShade() const
Get the shade of the fill color.
Definition: pageitem.h:813

PageItem::TextFlowMode
TextFlowMode
Text flow mode.
Definition: pageitem.h:198

PageItem::lineStyle
Qt::PenStyle lineStyle() const
Get the style of line.
Definition: pageitem.h:897

PageItem::BBoxH
double BBoxH
Bounding Box-H.
Definition: pageitem.h:1293

PageItem::m_xPos
double m_xPos
X position on the page.
Definition: pageitem.h:1809

PageItem::textFlowMode
TextFlowMode textFlowMode() const
Does text flow around this object and how.
Definition: pageitem.h:1022

ScImage
Definition: scimage.h:36

PageItem::pageItemAttributes
ObjAttrVector pageItemAttributes
Stores the attributes of the pageitem (NOT properties, the user defined ATTRIBUTES) ...
Definition: pageitem.h:1785

PageItem::lineColor
QString lineColor() const
Get the line color of the object.
Definition: pageitem.h:845

VGradient
Definition: vgradient.h:78

PageItem::m_imageYOffset
double m_imageYOffset
Image Y Offset to frame.
Definition: pageitem.h:1818

ParagraphStyle
Definition: paragraphstyle.h:27

PageItem::imageFlippedV
bool imageFlippedV() const
Is the image flipped vertically?
Definition: pageitem.h:987

PageItem::m_annotation
Annotation m_annotation
PDF annotation data.
Definition: pageitem.h:1377

PageItem::OwnPage
int OwnPage
page this element belongs to
Definition: pageitem.h:1274

FPoint
A point with floating point precision.
Definition: fpoint.h:43

PageItem::m_imageVisible
bool m_imageVisible
Darstellungsart Bild/Titel.
Definition: pageitem.h:1379

PageItem::GrType
int GrType
used values 6 = linear, 7 = radial, 8 = pattern, 9 = 4 color gradient, 10 = diamond, 11,12,13 = mesh gradient, 14 = hatch
Definition: pageitem.h:1215

PageItem::asSpiral
virtual PageItem_Spiral * asSpiral()
Return self if Spiral item, otherwise null.
Definition: pageitem.h:234

PageItem::m_Doc
ScribusDoc * m_Doc
Document this item belongs to.
Definition: pageitem.h:1374

PageItem::CurX
double CurX
Zeichen X-Position.
Definition: pageitem.h:1294

PageItem::asTable
virtual PageItem_Table * asTable()
Return self if Table item, otherwise null.
Definition: pageitem.h:236

ScribusDoc
the Document Class
Definition: scribusdoc.h:90

PageItem::textFlowUsesFrameShape
bool textFlowUsesFrameShape() const
If text should flow around object frame.
Definition: pageitem.h:1041

PageItem::asImageFrame
virtual PageItem_ImageFrame * asImageFrame()
Return self if Image item, otherwise null.
Definition: pageitem.h:225

PageItem::asNoteFrame
virtual PageItem_NoteFrame * asNoteFrame()
Return self if Note item, otherwise null.
Definition: pageitem.h:228

ScPainter
Definition: scpainter.h:33

PageItem::endArrowIndex
int endArrowIndex() const
Get end arrow index.
Definition: pageitem.h:952

PageItem::lineBlendmodeVal
int lineBlendmodeVal
Line stroke transparency blendmode.
Definition: pageitem.h:1742

PageItem::itemName
QString itemName() const
Get name of the item.
Definition: pageitem.h:756

PageItem::isNoteFrame
virtual bool isNoteFrame() const
Return true if Note item, otherwise false.
Definition: pageitem.h:245

PageItem::oldRot
double oldRot
Stores the old rotation value for undo action. Is used to detect rotation actions.
Definition: pageitem.h:1367

PageItem::ItemFrameType
ItemFrameType
Frame Type.
Definition: pageitem.h:208

PageItem::asLine
virtual PageItem_Line * asLine()
Return self if Line item, otherwise null.
Definition: pageitem.h:227

PageItem::Pfile
QString Pfile
Dateiname des Bildes.
Definition: pageitem.h:1278

PageItem::locked
bool locked() const
is the item locked ?
Definition: pageitem.h:1003

PageItem::asLatexFrame
virtual PageItem_LatexFrame * asLatexFrame()
Return self if Render frame item, otherwise null.
Definition: pageitem.h:226

PageItem::fillColorVal
QString fillColorVal
Fill color name.
Definition: pageitem.h:1700

PageItem::fillTransparency
double fillTransparency() const
Get the transparency of the fill color.
Definition: pageitem.h:821

PageItem::imageFlippedH
bool imageFlippedH() const
Is the image flipped horizontally?
Definition: pageitem.h:980

PageItem_PolyLine
Definition: pageitem_polyline.h:33

PageItem::isArc
virtual bool isArc() const
Return true if Arc item, otherwise false.
Definition: pageitem.h:239

PageItem::printEnabled
bool printEnabled() const
Is this item printed?
Definition: pageitem.h:1134

PageItem::textFlowModeVal
TextFlowMode textFlowModeVal
Should text flow around the item.
Definition: pageitem.h:1779

PageItem::gradientType
int gradientType() const
0=none, 1,2,3,4=linear, 5=radial, 6=free linear, 7=free radial, 8=pattern
Definition: pageitem.h:521

PageItem::lineTransparencyVal
double lineTransparencyVal
Line stroke transparency.
Definition: pageitem.h:1730

PageItem::oldOwnPage
int oldOwnPage
Old page number tracked for the move undo action.
Definition: pageitem.h:1275

PageItem::lineColorVal
QString lineColorVal
Line color name.
Definition: pageitem.h:1706

PageItem::isLine
virtual bool isLine() const
Return true if Line item, otherwise false.
Definition: pageitem.h:244

PageItem::fillBlendmode
int fillBlendmode() const
Get the blendmode of the fill color.
Definition: pageitem.h:829

PageItem_RegularPolygon
Definition: pageitem_regularpolygon.h:34

PageItem::isPolyLine
virtual bool isPolyLine() const
Return true if Poly Line item, otherwise false.
Definition: pageitem.h:248

PageItem::FrameType
int FrameType
Don't know exactly what this is, but it's not the same as itemType.
Definition: pageitem.h:1272

PageItem::itemType
ItemType itemType() const
Get the frame type.
Definition: pageitem.h:1074

PageItem::lineShade
double lineShade() const
Get the line color shade.
Definition: pageitem.h:853

UndoObject
Superclass for all objects that are wanted to have undoable actions.
Definition: undoobject.h:59

SaxIO
Definition: saxio.h:26

Geom::distance
Coord distance(Point const &a, Point const &b)
Definition: point.h:205

PageItem::m_sampleItem
bool m_sampleItem
Used to not draw the frame for sample items.
Definition: pageitem.h:1654

PageItem::m_textDistanceMargins
MarginStruct m_textDistanceMargins
Left, Top, Bottom, Right distances of text from the frame.
Definition: pageitem.h:1655

PageItem::Dirty
bool Dirty
Flag for redraw in EditMode.
Definition: pageitem.h:1299

PageItem::patternStrokeScaleX
double patternStrokeScaleX
Stroke pattern transformation matrix.
Definition: pageitem.h:1392

PageItem::m_yPos
double m_yPos
Y position on the page.
Definition: pageitem.h:1810

PageItem::m_imageXOffset
double m_imageXOffset
Image X Offset to frame.
Definition: pageitem.h:1817

PageItem::asSymbolFrame
virtual PageItem_Symbol * asSymbolFrame()
Return self if Symbol item, otherwise null.
Definition: pageitem.h:235

PageItem::fillColor
QString fillColor() const
Get the (name of the) fill color of the object.
Definition: pageitem.h:805

PageItem::imageIsAvailable
bool imageIsAvailable
Flag to hiold image file availability.
Definition: pageitem.h:1289

PageItem::clearContents
virtual void clearContents()
Clear the contents of a frame. WARNING: Currently they do not check if the user wants this...
Definition: pageitem.h:308

PageItem::oldLocalScY
double oldLocalScY
Stores the old LocalScY value for undo action. Is used to detect image scale actions.
Definition: pageitem.h:1369

PageItem_Arc
Definition: pageitem_arc.h:34

PageItem::BBoxX
double BBoxX
Bounding Box-X.
Definition: pageitem.h:1292

PageItem::PLineArt
Qt::PenStyle PLineArt
Linestyle.
Definition: pageitem.h:1256

PageItem::isInlineImage
bool isInlineImage
Definition: pageitem.h:1452

PageItem::frameType
int frameType() const
rect / oval / round / other
Definition: pageitem.h:699

PageItem::textFlowUsesContourLine
bool textFlowUsesContourLine() const
If text should flow around contour line.
Definition: pageitem.h:1053

PageItem::asGroupFrame
virtual PageItem_Group * asGroupFrame()
Return self if Group item, otherwise null.
Definition: pageitem.h:224

PageItem::ItemType
ItemType
Item Type.
Definition: pageitem.h:174

PageItem::lineEnd
Qt::PenCapStyle lineEnd() const
Get the end cap style of the line.
Definition: pageitem.h:914

PageItem::invalid
bool invalid
Flag indicates that layout has changed (eg. for textlayout)
Definition: pageitem.h:1300

PageItem::strokeGradient
QString strokeGradient() const
Get the name of the stroke gradient of the object.
Definition: pageitem.h:777

PageItem::m_isSelected
bool m_isSelected
Is the item selected?
Definition: pageitem.h:1814

PageItem::m_width
double m_width
Width of the item.
Definition: pageitem.h:1811

PageItem::isSpiral
virtual bool isSpiral() const
Return true if Spiral item, otherwise false.
Definition: pageitem.h:251

PageItem
Definition: pageitem.h:92

PageItem::sizeLocked
bool sizeLocked() const
Is the item's size locked?
Definition: pageitem.h:1010

PageItem::oldLocalX
double oldLocalX
Stores the old LocalX value for undo action. Is used to detect image offset actions.lo j.
Definition: pageitem.h:1370

PageItem::asPathText
virtual PageItem_PathText * asPathText()
Return self if Path Text item, otherwise null.
Definition: pageitem.h:230

Annotation
Definition: annotation.h:35

UndoManager
UndoManager handles the undo stack.
Definition: undomanager.h:81

PageItem::patternStrokeVal
QString patternStrokeVal
Stroke pattern name.
Definition: pageitem.h:1388

PageItem::asRegularPolygon
virtual PageItem_RegularPolygon * asRegularPolygon()
Return self if Regular Polygon item, otherwise null.
Definition: pageitem.h:233

FPointArray
Definition: fpointarray.h:42

PageItem::isRegularPolygon
virtual bool isRegularPolygon() const
Return true if Regular Polygon item, otherwise false.
Definition: pageitem.h:250

PageItem::isOSGFrame
virtual bool isOSGFrame() const
Return true if OSG item, otherwise false.
Definition: pageitem.h:246

PageItem::lineBlendmode
int lineBlendmode() const
Get the blendmode of the stroke color.
Definition: pageitem.h:837

PageItem::isGroup
virtual bool isGroup() const
Return true if Group item, otherwise false.
Definition: pageitem.h:241

PageItem::isImageFrame
virtual bool isImageFrame() const
Return true if Image item, otherwise false.
Definition: pageitem.h:242

PageItem::oldHeight
double oldHeight
Stores the old height for undo action. Is used to detect resize actions.
Definition: pageitem.h:1366

PageItem::m_ItemType
ItemType m_ItemType
Frame Type, eg line, text frame, etc.
Definition: pageitem.h:1663

ResourceCollection
Definition: resourcecollection.h:41

PageItem::oldXpos
double oldXpos
Stores the old X-position for undo action. Is used to detect move actions.
Definition: pageitem.h:1363

GlyphLayout
Definition: sctextstruct.h:54

PageItem::patternVal
QString patternVal
Fill pattern name.
Definition: pageitem.h:1682

PageItem::startArrowIndex
int startArrowIndex() const
Get start arrow index.
Definition: pageitem.h:942

PageItem_Table
Definition: pageitem_table.h:49

PageItem::lineTransparency
double lineTransparency() const
Get the line transparency.
Definition: pageitem.h:861

PageItem::asPolygon
virtual PageItem_Polygon * asPolygon()
Return self if Polygon item, otherwise null.
Definition: pageitem.h:232

PageItem::isSymbol
virtual bool isSymbol() const
Return true if Symbol item, otherwise false.
Definition: pageitem.h:252

PageItem::GrMask
int GrMask
Mask gradient variables.
Definition: pageitem.h:1429

PageItem::GrTypeStroke
int GrTypeStroke
Stroke gradient variables.
Definition: pageitem.h:1415

PageItem::FrameOnly
bool FrameOnly
avoid artefacts while moving
Definition: pageitem.h:1302

PageItem::AnName
QString AnName
Item name. Unicode. User visible (outline, property palette, etc).
Definition: pageitem.h:1670

PageItem::pixm
ScImage pixm
Darzustellendes Bild.
Definition: pageitem.h:1277

SimpleState
SimpleState provides a simple implementation of the UndoState.
Definition: undostate.h:145

PageItem::m_height
double m_height
Height of the item.
Definition: pageitem.h:1812

PageItem::Clip
QPolygon Clip
Defines clipping region of the elements.
Definition: pageitem.h:1260

UndoObject::restore
virtual void restore(UndoState *state, bool isUndo)=0
Method used when an undo/redo is requested.

PageItem::gradient
QString gradient() const
Get the name of the gradient of the object.
Definition: pageitem.h:768

PageItem_Polygon
Definition: pageitem_polygon.h:34

PageItem::asTextFrame
virtual PageItem_TextFrame * asTextFrame()
Return self if Text item, otherwise null.
Definition: pageitem.h:237

PageItem_Group
Definition: pageitem_group.h:34

PageItem_OSGFrame
Definition: pageitem_osgframe.h:38