summaryrefslogtreecommitdiffstats
path: root/include/svx/svdobj.hxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--include/svx/svdobj.hxx1099
1 files changed, 1099 insertions, 0 deletions
diff --git a/include/svx/svdobj.hxx b/include/svx/svdobj.hxx
new file mode 100644
index 000000000..de4ebc3f9
--- /dev/null
+++ b/include/svx/svdobj.hxx
@@ -0,0 +1,1099 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SVX_SVDOBJ_HXX
+#define INCLUDED_SVX_SVDOBJ_HXX
+
+#include <memory>
+#include <com/sun/star/uno/Any.hxx>
+#include <cppuhelper/weakref.hxx>
+#include <rtl/ustring.hxx>
+#include <vcl/outdev.hxx>
+#include <svl/lstner.hxx>
+#include <svl/poolitem.hxx>
+#include <svl/typedwhich.hxx>
+#include <svx/DiagramDataInterface.hxx>
+#include <svx/svdtypes.hxx>
+#include <svx/svxdllapi.h>
+#include <svx/shapeproperty.hxx>
+#include <tools/link.hxx>
+#include <tools/weakbase.h>
+#include <tools/gen.hxx>
+#include <osl/diagnose.h>
+#include <typeinfo>
+
+#include <unordered_set>
+
+class SfxBroadcaster;
+class AutoTimer;
+class OutlinerParaObject;
+class Outliner;
+class SdrOutliner;
+class SdrDragStat;
+class SdrHdl;
+class SdrHdlList;
+class SdrItemPool;
+class SdrModel;
+class SdrObjList;
+class SdrObject;
+class SdrPage;
+class SdrPageView;
+class SdrView;
+class SfxItemSet;
+class SfxGrabBagItem;
+class SfxSetItem;
+class SfxStyleSheet;
+class SfxUndoAction;
+class XFillAttrSetItem;
+class XLineAttrSetItem;
+class SfxItemPool;
+namespace tools { class PolyPolygon; }
+class SfxPoolItem;
+class SdrVirtObj;
+class SdrDragView;
+class SdrObjUserDataList;
+class SdrObjPlusData;
+class SdrGluePoint;
+class SdrGluePointList;
+class SdrLayerIDSet;
+class Fraction;
+enum class PointerStyle;
+
+namespace basegfx
+{
+ class B2DPoint;
+ class B2DPolyPolygon;
+ class B2DHomMatrix;
+}
+
+namespace sdr
+{
+ namespace properties
+ {
+ class BaseProperties;
+ }
+
+ class ObjectUser;
+}
+
+namespace sdr
+{
+ namespace contact
+ {
+ class ViewContact;
+ } // end of namespace contact
+}
+
+namespace svx
+{
+ class PropertyChangeNotifier;
+}
+
+class SvxShape;
+class SdrObject;
+struct SVXCORE_DLLPUBLIC SdrObjectFreeOp;
+
+// helper for constructing std::unique_ptr for SdrObjects where a
+// deleter is needed - here, SdrObject::Free needs to be used.
+typedef std::unique_ptr< SdrObject, SdrObjectFreeOp > SdrObjectUniquePtr;
+
+enum SdrObjKind {
+ OBJ_NONE = 0, /// abstract object (SdrObject)
+ OBJ_GRUP = 1, /// object group
+ OBJ_LINE = 2, /// line
+ OBJ_RECT = 3, /// rectangle (round corners optional)
+ OBJ_CIRC = 4, /// circle, ellipse
+ OBJ_SECT = 5, /// circle section
+ OBJ_CARC = 6, /// circle arc
+ OBJ_CCUT = 7, /// circle cut
+ OBJ_POLY = 8, /// polygon, PolyPolygon
+ OBJ_PLIN = 9, /// PolyLine
+ OBJ_PATHLINE =10, /// open Bezier-curve
+ OBJ_PATHFILL =11, /// closed Bezier-curve
+ OBJ_FREELINE =12, /// open free-hand line
+ OBJ_FREEFILL =13, /// closed free-hand line
+ OBJ_SPLNLINE =14, /// natural cubic Spline (ni)
+ OBJ_SPLNFILL =15, /// periodic cubic Spline (ni)
+ OBJ_TEXT =16, /// text object
+ OBJ_TITLETEXT =20, /// TitleText, special text object for StarDraw
+ OBJ_OUTLINETEXT=21, /// OutlineText, special text object for StarDraw
+ OBJ_GRAF =22, /// foreign graphic (StarView Graphic)
+ OBJ_OLE2 =23, /// OLE object
+ OBJ_EDGE =24, /// connector object
+ OBJ_CAPTION =25, /// caption object
+ OBJ_PATHPOLY =26, /// Polygon/PolyPolygon represented by SdrPathObj
+ OBJ_PATHPLIN =27, /// Polyline represented by SdrPathObj
+ OBJ_PAGE =28, /// object that represents a SdrPage
+ OBJ_MEASURE =29, /// measurement object
+ OBJ_FRAME =31, /// continuously activated OLE (PlugIn-Frame or similar)
+ OBJ_UNO =32, /// Universal Network Object packed into SvDraw object
+ OBJ_CUSTOMSHAPE=33, /// custom shape
+ OBJ_MEDIA =34, /// media shape
+ OBJ_TABLE =35, /// table
+ OBJ_MAXI
+};
+
+enum class SdrInventor : sal_uInt32 {
+ Unknown = 0,
+ BasicDialog = sal_uInt32( 'D' | ('L' << 8) | ('G' << 16) | ('1' << 24) ),
+ Default = sal_uInt32( 'S' | ('V' << 8) | ('D' << 16) | ('r' << 24) ),
+ E3d = sal_uInt32( 'E' | ('3' << 8) | ('D' << 16) | ('1' << 24) ),
+ FmForm = sal_uInt32( 'F' | ('M' << 8) | ('0' << 16) | ('1' << 24) ),
+ IMap = sal_uInt32( 'I' | ('M' << 8) | ('A' << 16) | ('P' << 24) ),
+ ReportDesign = sal_uInt32( 'R' | ('P' << 8) | ('T' << 16) | ('1' << 24) ),
+ ScOrSwDraw = sal_uInt32( 'S' | ('C' << 8) | ('3' << 16) | ('0' << 24) ), // Used in sc/ and sw/
+ SgaImap = sal_uInt32( 'S' | ('D' << 8) | ('U' << 16) | ('D' << 24) ),
+ StarDrawUserData = sal_uInt32( 'S' | ('D' << 8) | ('U' << 16) | ('D' << 24) ),
+ Swg = sal_uInt32( 'S' | ('W' << 8) | ('G' << 16) ),
+};
+
+enum class SdrUserCallType {
+ MoveOnly, // only moved, size unchanged
+ Resize, // size and maybe position changed
+ ChangeAttr, // attribute changed. Eventually new size, because of line width
+ Delete, // object is going to be deleted soon, no attributes anymore
+ Inserted, // inserted into an object list (e.g. Page)
+ Removed, // removed from an object list
+ ChildMoveOnly, // a child within a group has changed
+ ChildResize, // a child within a group has changed
+ ChildChangeAttr, // a child within a group has changed
+ ChildDelete, // a child within a group has changed
+ ChildInserted, // a child within a group has changed
+ ChildRemoved // a child within a group has changed
+};
+
+class SVXCORE_DLLPUBLIC SdrObjUserCall
+{
+public:
+ virtual ~SdrObjUserCall();
+ virtual void Changed(const SdrObject& rObj, SdrUserCallType eType, const tools::Rectangle& rOldBoundRect);
+};
+
+class SVXCORE_DLLPUBLIC SdrObjMacroHitRec
+{
+public:
+ Point aPos;
+ const SdrLayerIDSet* pVisiLayer;
+ const SdrPageView* pPageView;
+ sal_uInt16 nTol;
+
+ SdrObjMacroHitRec();
+};
+
+/**
+ * User data of a drawing object, e.g. application specific data.
+ * Every drawing object can have an arbitrary amount of such records (SV list).
+ * Whoever wants to save data here, must inherit from this and set a corresponding link in the factory.
+ */
+class SVXCORE_DLLPUBLIC SdrObjUserData
+{
+ SdrInventor nInventor;
+ sal_uInt16 nIdentifier;
+
+ void operator=(const SdrObjUserData& rData) = delete;
+ bool operator==(const SdrObjUserData& rData) const = delete;
+ bool operator!=(const SdrObjUserData& rData) const = delete;
+
+public:
+ SdrObjUserData(SdrInventor nInv, sal_uInt16 nId);
+ SdrObjUserData(const SdrObjUserData& rData);
+ virtual ~SdrObjUserData();
+
+ virtual std::unique_ptr<SdrObjUserData> Clone(SdrObject* pObj1) const = 0; // #i71039# NULL -> 0
+ SdrInventor GetInventor() const { return nInventor;}
+ sal_uInt16 GetId() const { return nIdentifier;}
+};
+
+/**
+ * All geometrical data of an arbitrary object for use in undo/redo
+ */
+class SAL_DLLPUBLIC_RTTI SdrObjGeoData
+{
+public:
+ tools::Rectangle aBoundRect;
+ Point aAnchor;
+ std::unique_ptr<SdrGluePointList>
+ pGPL;
+ bool bMovProt;
+ bool bSizProt;
+ bool bNoPrint;
+ bool bClosedObj;
+ bool mbVisible;
+ SdrLayerID mnLayerID;
+
+public:
+ SdrObjGeoData();
+ virtual ~SdrObjGeoData();
+};
+
+/**
+ * Provides information about various ZObject properties
+ */
+class SVXCORE_DLLPUBLIC SdrObjTransformInfoRec
+{
+public:
+ bool bMoveAllowed : 1; // if false, object cannot be moved
+ bool bResizeFreeAllowed : 1; // if false, object cannot be resized freely
+ bool bResizePropAllowed : 1; // if false, object cannot even be resized proportionally
+ bool bRotateFreeAllowed : 1; // if false, object cannot be rotated freely
+ bool bRotate90Allowed : 1; // if false, object cannot even be rotated in 90 degree steps
+ bool bMirrorFreeAllowed : 1; // if false, object cannot be mirrored freely
+ bool bMirror45Allowed : 1; // if false, object cannot even be mirrored over axes in a 45 degree raster
+ bool bMirror90Allowed : 1; // if false, object cannot even be mirrored over axes in a 90 degree raster
+ bool bTransparenceAllowed : 1; // if false, object does not have an interactive transparence control
+ bool bShearAllowed : 1; // if false, object cannot be sheared
+ bool bEdgeRadiusAllowed : 1;
+ bool bNoOrthoDesired : 1; // is true for Rect; is false for BMP, MTF
+ bool bNoContortion : 1; // if false, contortion not possible (for crook, only true for PathObj and grouped PathObjs)
+ bool bCanConvToPath : 1; // if false, no conversion into PathObj possible
+ bool bCanConvToPoly : 1; // if false, no conversion into PolyObj possible
+ bool bCanConvToContour : 1; // if false, no conversion down to whole contour possible
+ bool bCanConvToPathLineToArea : 1; // if false, no conversion into PathObj with transformation from LineToArea possible
+ bool bCanConvToPolyLineToArea : 1; // if false, no conversion into PolyObj with transformation from LineToArea possible
+
+ SdrObjTransformInfoRec();
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// SdrObject
+// SdrAttrObj
+// E3dObject
+// E3dCompoundObject
+// E3dCubeObj
+// E3dExtrudeObj
+// E3dLatheObj
+// E3dPolygonObj
+// E3dSphereObj
+// E3dScene
+// SdrTextObj
+// SdrObjCustomShape
+// OCustomShape
+// SdrEdgeObj
+// SdrMeasureObj
+// SdrPathObj
+// SdrRectObj
+// SdrCaptionObj
+// SdrCircObj
+// SdrGrafObj
+// SdrMediaObj
+// SdrOle2Obj
+// OOle2Obj
+// SdrUnoObj
+// DlgEdObj
+// DlgEdForm
+// OUnoObject
+// FmFormObj
+// SdrTableObj
+// SdrObjGroup
+// SdrPageObj
+// SdrVirtObj
+// SwDrawVirtObj
+// SwVirtFlyDrawObj
+// SwFlyDrawObj
+
+/// Abstract DrawObject
+class SVXCORE_DLLPUBLIC SdrObject : public SfxListener, public tools::WeakBase
+{
+private:
+ friend class SdrObjListIter;
+ friend class SdrVirtObj;
+ friend class SdrRectObj;
+
+ // OperationSmiley: Allow at each SdrObject to set a FillGeometryDefiningShape,
+ // so that for SdrObjects where this is set, the definition of a defined FillStyle
+ // will use this, but the local geometry will be filled. This allows to fill
+ // multiple shapes with a unified fill, e.g think about CustomShapes.
+ // Currently this is *only* used for CustomShapes, but may be developed to get a
+ // common mechanism - usages for it are easy to be found. The current limitation
+ // to CustomShapes allows to think about these SdrObjects to 'vanish' during the
+ // lifetime of 'this' - the SdrObjects without SdrPage and SdrModel are used as helper
+ // objects for SdrObjCustomShape and thus their lifetime is limited to the lifetime
+ // of this local object. For unifying this mechanism, some weak reference of
+ // SdrObjects would have to be thought about (not easy with the current implementation).
+ // So - allow *only* EnhancedCustomShape2d (which creates the visualizations for
+ // SdrObjCustomShape) to set this. Already allow unified read to use it - thus already
+ // allowing to implement as standard case for all kinds of SdrObjects.
+ friend class EnhancedCustomShape2d;
+ const SdrObject* mpFillGeometryDefiningShape;
+ void setFillGeometryDefiningShape(const SdrObject* pNew) { mpFillGeometryDefiningShape = pNew; }
+public:
+ const SdrObject* getFillGeometryDefiningShape() const { return mpFillGeometryDefiningShape; }
+
+private:
+ // the SdrModel this objects was created with, unchanged during SdrObject lifetime
+ SdrModel& mrSdrModelFromSdrObject;
+
+public:
+ // A SdrObject always needs a SdrModel for lifetime (Pool, ...)
+ SdrObject(SdrModel& rSdrModel);
+
+ // SdrModel/SdrPage access on SdrObject level
+ SdrPage* getSdrPageFromSdrObject() const;
+ SdrModel& getSdrModelFromSdrObject() const;
+
+ // access to possible children (SdrObjGroup/E3dScene)
+ virtual SdrObjList* getChildrenOfSdrObject() const;
+
+ // access to parent
+ SdrObjList* getParentSdrObjListFromSdrObject() const;
+ SdrObject* getParentSdrObjectFromSdrObject() const;
+
+private:
+ // only allow SetParentAtSdrObjectFromSdrObjList to call setParentOfSdrObject
+ friend void SetParentAtSdrObjectFromSdrObjList(SdrObject& rSdrObject, SdrObjList* pNew);
+ SVX_DLLPRIVATE void setParentOfSdrObject(SdrObjList* pNew);
+
+public:
+ // react on model/page change
+ virtual void handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage);
+
+ void AddObjectUser(sdr::ObjectUser& rNewUser);
+ void RemoveObjectUser(sdr::ObjectUser& rOldUser);
+
+ sdr::contact::ViewContact& GetViewContact() const;
+
+ virtual sdr::properties::BaseProperties& GetProperties() const;
+
+ // DrawContact support: Methods for handling Object changes
+ void ActionChanged() const;
+
+ static SdrItemPool& GetGlobalDrawObjectItemPool();
+ void SetRelativeWidth( double nValue );
+ void SetRelativeWidthRelation( sal_Int16 eValue );
+ void SetRelativeHeight( double nValue );
+ void SetRelativeHeightRelation( sal_Int16 eValue );
+ const double* GetRelativeWidth() const;
+ sal_Int16 GetRelativeWidthRelation() const;
+ const double* GetRelativeHeight() const;
+ sal_Int16 GetRelativeHeightRelation() const;
+
+ void SetDiagramData(std::shared_ptr<DiagramDataInterface> pDiagramData);
+ std::shared_ptr<DiagramDataInterface> GetDiagramData() const;
+
+ /// @param bNotMyself = true: set only ObjList to dirty, don't mark this object as dirty.
+ ///
+ /// This is needed for instance for NbcMove, because usually one moves SnapRect and aOutRect
+ /// at the same time to avoid recomputation.
+ virtual void SetRectsDirty(bool bNotMyself = false, bool bRecursive = true);
+
+ // frees the SdrObject pointed to by the argument
+ // In case the object has an SvxShape, which has the ownership of the object, it
+ // is actually *not* deleted.
+ static void Free( SdrObject*& _rpObject );
+
+ // this method is only for access from Property objects
+ virtual void SetBoundRectDirty();
+
+ SfxItemPool & GetObjectItemPool() const;
+
+ void AddListener(SfxListener& rListener);
+ void RemoveListener(SfxListener& rListener);
+
+ void AddReference(SdrVirtObj& rVrtObj);
+ void DelReference(SdrVirtObj& rVrtObj);
+ virtual SdrInventor GetObjInventor() const;
+ virtual sal_uInt16 GetObjIdentifier() const;
+ virtual void TakeObjInfo(SdrObjTransformInfoRec& rInfo) const;
+
+ // Layer interface
+ virtual SdrLayerID GetLayer() const;
+ virtual void NbcSetLayer(SdrLayerID nLayer);
+ virtual void SetLayer(SdrLayerID nLayer);
+ // renaming GetSdrLayerIDSet -> getMergedHierarchySdrLayerIDSet to make clear what happens here. rSet needs to be empty.
+ void getMergedHierarchySdrLayerIDSet(SdrLayerIDSet& rSet) const;
+
+ void SendUserCall(SdrUserCallType eUserCall, const tools::Rectangle& rBoundRect) const;
+
+ // #i68101#
+ // An object may have a user-set Name (Get/SetName()), e.g SdrGrafObj, SdrObjGroup
+ // or SdrOle2Obj.
+ // It may also have a Title and a Description for accessibility purposes.
+ void SetName(const OUString& rStr);
+ OUString GetName() const;
+ void MakeNameUnique();
+ void MakeNameUnique(std::unordered_set<OUString>& rNameSet);
+ void SetTitle(const OUString& rStr);
+ OUString GetTitle() const;
+ void SetDescription(const OUString& rStr);
+ OUString GetDescription() const;
+
+ // for group objects
+ bool IsGroupObject() const;
+ virtual SdrObjList* GetSubList() const;
+
+ /// The order number (aka ZOrder, aka z-index) determines whether a
+ /// SdrObject is located above or below another. Objects are painted from
+ /// lowest to highest order number. If the order of SdrObjects in the
+ /// SdrObjList is changed, the bObjOrdNumsDirty flag is set on the SdrPage
+ /// and the next GetOrdNum() call recalculates the order number of all
+ /// SdrObjects in the SdrObjList.
+ sal_uInt32 GetOrdNum() const;
+
+ // setting the order number should only happen from the model or from the page
+ void SetOrdNum(sal_uInt32 nNum);
+
+ // GrabBagItem for interim interop purposes
+ void GetGrabBagItem(css::uno::Any& rVal) const;
+
+ void SetGrabBagItem(const css::uno::Any& rVal);
+
+ // Return the position in the navigation order for the called object.
+ // Note that this method may update the navigation position of the
+ // called and of other SdrObjects. Therefore this method can not be
+ // const.
+ // @return
+ // If no navigation position has been explicitly defined then the
+ // result of GetOrdNum() is returned.
+ sal_uInt32 GetNavigationPosition() const;
+
+ // To make clearer that this method may trigger RecalcBoundRect and thus may be
+ // expensive and sometimes problematic (inside a bigger object change You will get
+ // non-useful BoundRects sometimes) i rename that method from GetBoundRect() to
+ // GetCurrentBoundRect().
+ virtual const tools::Rectangle& GetCurrentBoundRect() const;
+
+ // To have a possibility to get the last calculated BoundRect e.g for producing
+ // the first rectangle for repaints (old and new need to be used) without forcing
+ // a RecalcBoundRect (which may be problematical and expensive sometimes) i add here
+ // a new method for accessing the last BoundRect.
+ virtual const tools::Rectangle& GetLastBoundRect() const;
+
+ virtual void RecalcBoundRect();
+
+ void BroadcastObjectChange() const;
+
+ const SfxBroadcaster* GetBroadcaster() const;
+
+ // set modified-flag in the model
+ virtual void SetChanged();
+
+ // Tooling for painting a single object to an OutputDevice. This will be needed as long
+ // as not all painting is changed to use DrawContact objects.
+ void SingleObjectPainter(OutputDevice& rOut) const;
+ bool LineGeometryUsageIsNecessary() const;
+
+ // RotGrfFlyFrame: If true, this SdrObject supports only limited rotation, that
+ // means no change of the rotation point (only centered) and no shear allowed
+ virtual bool HasLimitedRotation() const;
+
+ // Returns a copy of the object. Every inherited class must reimplement this (in class Foo
+ // it should be sufficient to do "virtual Foo* CloneSdrObject(...) const { return CloneHelper< Foo >(); }".
+ // Note that this function uses operator= internally.
+ virtual SdrObject* CloneSdrObject(SdrModel& rTargetModel) const;
+
+ // implemented mainly for the purposes of CloneSdrObject()
+ SdrObject& operator=(const SdrObject& rObj);
+
+ // TakeObjName...() is for the display in the UI, e.g. "3 frames selected"
+ virtual OUString TakeObjNameSingul() const;
+ virtual OUString TakeObjNamePlural() const;
+
+ /// The Xor-Polygon is required by the View to drag the object.
+ /// All polygons within the PolyPolygon are interpreted as PolyLine.
+ /// To get a closed Polygon, close it explicitly.
+ virtual basegfx::B2DPolyPolygon TakeXorPoly() const;
+
+ /// contour for TextToContour
+ virtual basegfx::B2DPolyPolygon TakeContour() const;
+
+ /// Via GetHdlCount the number of Handles can be retrieved.
+ /// Normally 8, if it's a line 2.
+ /// For Polygon objects (Polygon/Spline/Bezier) the number may be much
+ /// larger. Polygon objects are also allowed to select a point of a
+ /// selected object. The handle of that point will then be replaced by
+ /// a new set of handles (PlusHdl). For a Polygon this would be a simple
+ /// selection Handle, for a Bezier curve this may be up to 3 Handles
+ /// (including Weights).
+ /// GetHdl() and GetPlusHdl() must create Handle instances with new!
+ /// An object that returns true from HasSpacialDrag() must provide these
+ /// methods (incl. FillHdlList()).
+ virtual sal_uInt32 GetHdlCount() const;
+ virtual void AddToPlusHdlList(SdrHdlList& rHdlList, SdrHdl& rHdl) const;
+ virtual void AddToHdlList(SdrHdlList& rHdlList) const;
+ virtual void addCropHandles(SdrHdlList& rTarget) const;
+
+ /// The standard transformations (Move,Resize,Rotate,Mirror,Shear) are
+ /// taken over by the View (TakeXorPoly(),...).
+ /// Object type specific dragging like corner radius of Rectangle,
+ /// control points of Splines, weights of Bezier curves, pointer of
+ /// Label objects must be handled by the object itself.
+ /// To keep the Model free of state, the state is kept in the View
+ /// and then passed to the object. EndDrag usually returns true for success,
+ /// false may be returned if the dragging did not modify the object,
+ /// where the View already handles the case that the pointer was not
+ /// moved at all.
+ virtual bool hasSpecialDrag() const;
+ virtual bool beginSpecialDrag(SdrDragStat& rDrag) const;
+ virtual bool applySpecialDrag(SdrDragStat& rDrag);
+ virtual OUString getSpecialDragComment(const SdrDragStat& rDrag) const;
+ virtual basegfx::B2DPolyPolygon getSpecialDragPoly(const SdrDragStat& rDrag) const;
+
+ // FullDrag support. This is for standard interactions and for SdrObjOwn
+ // support. If supportsFullDrag() returns true, getFullDragClone has to
+ // return a cloned SdrObject (who's ownership it loses) at which modifications
+ // like Move(), Scale(), etc or applySpecialDrag() will be executed. That
+ // object will be visualized on overlay for full drag, but should not be
+ // part of the model, thus not changing anything since it's only a temporary
+ // helper object for interaction
+ virtual bool supportsFullDrag() const;
+ virtual SdrObjectUniquePtr getFullDragClone() const;
+
+ /// Every object must be able to create itself interactively.
+ /// On MouseDown first an object is created, and its BegCreate() method
+ /// is called. On every MouseMove, MovCreate() is called. BrkCreate()
+ /// is called if the user cancels the interactive object creation.
+ /// EndCreate() is called on the MouseUp event. If EndCreate() returns
+ /// true, the creation is finished; the object is inserted into the
+ /// corresponding list. Otherwise it is assumed that further points
+ /// are necessary to create the object (Polygon, ...). The parameter
+ /// eCmd contains the number of mouse clicks (if the application
+ /// provides it).
+ /// BckCreate() will undo the previous EndCreate(), e.g. to delete the
+ /// last point of the Polygon. If BckCreate() returns false, creation
+ /// is cancelled.
+ virtual bool BegCreate(SdrDragStat& rStat);
+ virtual bool MovCreate(SdrDragStat& rStat); // if true, Xor needs to be repainted
+ virtual bool EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd);
+ virtual bool BckCreate(SdrDragStat& rStat);
+ virtual void BrkCreate(SdrDragStat& rStat);
+
+ /// get the cursor/pointer that signals creating this object
+ virtual PointerStyle GetCreatePointer() const;
+
+ /// Polygon dragged by the user when creating the object
+ virtual basegfx::B2DPolyPolygon TakeCreatePoly(const SdrDragStat& rDrag) const;
+
+ /// The methods Move, Resize, Rotate, Mirror, Shear, SetSnapRect and
+ /// SetLogicRect call the corresponding Nbc-methods, send a Repaint
+ /// broadcast and set the Modified state on the Model.
+ /// Derived classes should usually only override the Nbc methods.
+ /// Nbc means "no broadcast".
+ virtual void NbcMove (const Size& rSiz);
+ virtual void NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact);
+ virtual void NbcCrop (const basegfx::B2DPoint& rRef, double fxFact, double fyFact);
+ virtual void NbcRotate(const Point& rRef, long nAngle, double sn, double cs);
+ virtual void NbcMirror(const Point& rRef1, const Point& rRef2);
+ virtual void NbcShear (const Point& rRef, long nAngle, double tn, bool bVShear);
+
+ virtual void Move (const Size& rSiz);
+ virtual void Resize(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bUnsetRelative = true);
+ virtual void Crop (const basegfx::B2DPoint& rRef, double fxFact, double fyFact);
+ virtual void Rotate(const Point& rRef, long nAngle, double sn, double cs);
+ virtual void Mirror(const Point& rRef1, const Point& rRef2);
+ virtual void Shear (const Point& rRef, long nAngle, double tn, bool bVShear);
+
+ /// The relative position of a SdrObject is the distance of the upper
+ /// left corner of the logic bounding rectangle (SnapRect) to the anchor.
+ virtual void NbcSetRelativePos(const Point& rPnt);
+ virtual void SetRelativePos(const Point& rPnt);
+ virtual Point GetRelativePos() const;
+ void ImpSetAnchorPos(const Point& rPnt);
+ virtual void NbcSetAnchorPos(const Point& rPnt);
+ virtual void SetAnchorPos(const Point& rPnt);
+
+ /// Snap is not done on the BoundRect but if possible on logic coordinates
+ /// (i.e. without considering stroke width, ...)
+ /// SetSnapRect() tries to size the Object so that it fits into the
+ /// passed Rect (without stroke width, ...)
+ virtual void RecalcSnapRect();
+ virtual const tools::Rectangle& GetSnapRect() const;
+ virtual void SetSnapRect(const tools::Rectangle& rRect);
+ virtual void NbcSetSnapRect(const tools::Rectangle& rRect);
+
+ // Logic Rect: for the Rect for instance without regard to rotation angle, shear, ...
+ virtual const tools::Rectangle& GetLogicRect() const;
+ virtual void SetLogicRect(const tools::Rectangle& rRect);
+ virtual void NbcSetLogicRect(const tools::Rectangle& rRect);
+
+ // the default is to set the logic rect to the given rectangle rMaxRect. If the shape
+ // has an intrinsic aspect ratio it may set the logic rect so the aspect
+ // ratio is kept but still inside the rectangle rMaxRect.
+ // If bShrinkOnly is set to true, the size of the current logic rect will not
+ // be changed if it is smaller than the given rectangle rMaxRect.
+ virtual void AdjustToMaxRect( const tools::Rectangle& rMaxRect, bool bShrinkOnly = false );
+
+ // rotation and shear angle
+ virtual long GetRotateAngle() const;
+ virtual long GetShearAngle(bool bVertical = false) const;
+
+ /// snap to special points of an Object (polygon points, center of circle)
+ virtual sal_uInt32 GetSnapPointCount() const;
+ virtual Point GetSnapPoint(sal_uInt32 i) const;
+
+ // For objects, whose points can be moved individually.
+ // (e.g. polygons, polylines, lines)
+ // The points of those objects are selected (if necessary multiselection),
+ // deleted, inserted, or as a multiselection moved or rotated...
+ // Only such objects can have PlusHandles (e.g. the weights of a Bezier curve).
+ virtual bool IsPolyObj() const;
+ virtual sal_uInt32 GetPointCount() const;
+ virtual Point GetPoint(sal_uInt32 i) const;
+ void SetPoint(const Point& rPnt, sal_uInt32 i);
+ virtual void NbcSetPoint(const Point& rPnt, sal_uInt32 i);
+
+ // get all geometrical data for undo/redo
+ virtual SdrObjGeoData* GetGeoData() const;
+ virtual void SetGeoData(const SdrObjGeoData& rGeo);
+
+ // ItemSet access
+ const SfxItemSet& GetMergedItemSet() const;
+ void SetMergedItem(const SfxPoolItem& rItem);
+ void ClearMergedItem(const sal_uInt16 nWhich = 0);
+ void SetMergedItemSet(const SfxItemSet& rSet, bool bClearAllItems = false);
+ const SfxPoolItem& GetMergedItem(const sal_uInt16 nWhich) const;
+ template<class T>
+ const T& GetMergedItem( TypedWhichId<T> nWhich ) const
+ {
+ return static_cast<const T&>(GetMergedItem(sal_uInt16(nWhich)));
+ }
+
+ // syntactical sugar for ItemSet accesses
+ void SetMergedItemSetAndBroadcast(const SfxItemSet& rSet, bool bClearAllItems = false);
+
+ // NotPersistAttr for Layer, ObjName, geometrical transformations etc.
+ void TakeNotPersistAttr(SfxItemSet& rAttr) const;
+ void ApplyNotPersistAttr(const SfxItemSet& rAttr);
+ void NbcApplyNotPersistAttr(const SfxItemSet& rAttr);
+
+ // if bDontRemoveHardAttr is false, set all attributes, which were set in the style sheet, to their default value
+ // if true, all hard attributes keep their values
+ void SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr);
+ virtual void NbcSetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr);
+ SfxStyleSheet* GetStyleSheet() const;
+
+ virtual bool HasTextEdit() const;
+
+ // keep text in outliner's format
+ // SetOutlinerParaObject: transfer ownership of *pTextObject!
+ void SetOutlinerParaObject(std::unique_ptr<OutlinerParaObject> pTextObject);
+ virtual void NbcSetOutlinerParaObject(std::unique_ptr<OutlinerParaObject> pTextObject);
+ virtual OutlinerParaObject* GetOutlinerParaObject() const;
+ virtual void NbcReformatText();
+
+ void BurnInStyleSheetAttributes();
+
+ // macro abilities, e.g. a rectangle as PushButton.
+ virtual bool HasMacro() const;
+ virtual SdrObject* CheckMacroHit (const SdrObjMacroHitRec& rRec) const;
+ virtual PointerStyle GetMacroPointer (const SdrObjMacroHitRec& rRec) const;
+ virtual void PaintMacro (OutputDevice& rOut, const tools::Rectangle& rDirtyRect, const SdrObjMacroHitRec& rRec) const;
+ virtual bool DoMacro (const SdrObjMacroHitRec& rRec);
+ bool IsMacroHit(const SdrObjMacroHitRec& rRec) const;
+
+ // Connectors
+ // (see also documentation in SvdoEdge.hxx, SdrEdgeObj, as well as SvdGlue.hxx and SvdGlEV.hxx)
+ //
+ // There are nodes and edges. In theory an edge can also be a node, but this isn't implemented yet.
+ // A node has a number of glue points, onto which edges can glued to
+ // An edge can be either
+ // - without any connection to any node,
+ // - or connected on one end to a node, while the other end is not connected,
+ // - or connected on both ends with exactly one node each.
+ // The edge is listener for its up to two nodes.
+ // Whenever a node is moved or resized, all its connected edges follow.
+ // This is also true for SetGluePoint()... on the node.
+ // On the other hand, moving/resizing an edge breaks the connection.
+
+ // automatic glue points:
+ // a node object must provide four vertex and corner positions
+ // usually 0: top, 1: right, 2: bottom, 3: left
+ virtual SdrGluePoint GetVertexGluePoint(sal_uInt16 nNum) const;
+
+ // usually:
+ // 0: top-left, 1: top-right, 2: bottom-right, 3: bottom-left
+ virtual SdrGluePoint GetCornerGluePoint(sal_uInt16 nNum) const;
+
+ // list of all glue points, can be NULL
+ virtual const SdrGluePointList* GetGluePointList() const;
+
+ // after changing the GluePointList, one has to call the object's SendRepaintBroadcast!
+ virtual SdrGluePointList* ForceGluePointList();
+
+ // to be set temporarily when transforming related object(?)
+ void SetGlueReallyAbsolute(bool bOn);
+ void NbcRotateGluePoints(const Point& rRef, long nAngle, double sn, double cs);
+ void NbcMirrorGluePoints(const Point& rRef1, const Point& rRef2);
+ void NbcShearGluePoints (const Point& rRef, double tn, bool bVShear);
+
+ // if bTail1 is true, line start, otherwise line end
+ // if pObj is null disconnect
+ virtual void ConnectToNode(bool bTail1, SdrObject* pObj);
+ virtual void DisconnectFromNode(bool bTail1);
+ virtual SdrObject* GetConnectedNode(bool bTail1) const;
+
+ // sets the writing mode of the object's context
+ // Objects which itself do not support different writing modes will ignore this call.
+ // Objects which support different writing modes, but have an own, explicit writing mode set,
+ // will also ignore this call.
+ // Objects which support different writing modes, and whose own mode is set to css.text.WritingMode2.CONTEXT,
+ // will use the given writing mode to calculate their "effective writing mode".
+ // The behaviour of this method is undefined if you pass css.text.WritingMode2.CONTEXT.
+ // @param _nContextWritingMode
+ // the effective writing mode of the context of the object
+ virtual void SetContextWritingMode( const sal_Int16 _nContextWritingMode );
+
+ // If an object is able to convert itself into a polygon or into a Bezier curve (or into both),
+ // then the following methods should be overridden.
+ // E.g., convert a RectObj with line width 10, SOLID_PEN into a polygon:
+ // In the bLineToArea=false mode a PolyObj with four supporting points,
+ // line width 10 and SOLID_PEN shall be created.
+ // On the contrary in the bLineToArea=true mode the generated object should
+ // still have a line attribute NULL_PEN, and the line (also line pattern)
+ // itself should be emulated by the polygon area, which thereby can be
+ // manipulated by the user afterwards.
+ // The RectObj therefore can only convert correctly if it has an area attribute NULL_BRUSH.
+ // In this case it would have to:
+ // - set SOLID_BRUSH with the color of the given pen,
+ // - set NULL_PEN, and
+ // - generate tools::PolyPolygon with two polygons with four supporting points each.
+ // In each case the return value is a SdrObject*, because it is also
+ // allowed to return group objects (e.g. for SdrTextObj).
+ // In the case of the conversion from TextObj to PathObj,
+ // both modi (bLineToArea=true/false) would be identical.
+ // The methods' default implementations report "I'm unable to do this" (false/null).
+ virtual SdrObjectUniquePtr DoConvertToPolyObj(bool bBezier, bool bAddText) const;
+ SdrObjectUniquePtr ConvertToPolyObj(bool bBezier, bool bLineToArea) const;
+
+ // convert this path object to contour object; bForceLineDash converts even
+ // when there is no filled new polygon created from line-to-polygon conversion,
+ // specially used for XLINE_DASH and 3D conversion
+ SdrObject* ConvertToContourObj(SdrObject* pRet, bool bForceLineDash = false) const;
+private:
+ SdrObject* ImpConvertToContourObj(bool bForceLineDash);
+public:
+
+ // if true, reference onto an object
+ bool IsVirtualObj() const { return bVirtObj;}
+
+ // is true, if object can probably be filled
+ // is false, if object has probably line ends
+ // is invalid, if this is a group object
+ bool IsClosedObj() const { return bClosedObj;}
+
+ // tdf#118662 reorganize inserted state, no local bool needed anymore,
+ // it depends on being a member of a SdrObjList
+ void InsertedStateChange();
+ bool IsInserted() const { return nullptr != getParentSdrObjListFromSdrObject(); }
+
+ bool IsEdgeObj() const { return bIsEdge;}
+ bool Is3DObj() const { return bIs3DObj;}
+ bool IsUnoObj() const { return bIsUnoObj;}
+ void SetMoveProtect(bool bProt);
+ bool IsMoveProtect() const { return bMovProt;}
+ void SetResizeProtect(bool bProt);
+ bool IsResizeProtect() const { return bSizProt;}
+ void SetPrintable(bool bPrn);
+ bool IsPrintable() const { return !bNoPrint;}
+ void SetVisible(bool bVisible);
+ bool IsVisible() const { return mbVisible;}
+ void SetMarkProtect(bool bProt);
+ bool IsMarkProtect() const { return bMarkProt;}
+
+ /// Whether the aspect ratio should be kept by default when resizing.
+ virtual bool shouldKeepAspectRatio() const { return false; }
+
+ // application specific data
+ sal_uInt16 GetUserDataCount() const;
+ SdrObjUserData* GetUserData(sal_uInt16 nNum) const;
+
+ void AppendUserData(std::unique_ptr<SdrObjUserData> pData);
+
+ // removes the record from the list and performs delete (FreeMem+Dtor).
+ void DeleteUserData(sal_uInt16 nNum);
+
+ // access to the UNO representation of the shape
+ virtual css::uno::Reference< css::uno::XInterface > getUnoShape();
+
+ static SdrObject* getSdrObjectFromXShape( const css::uno::Reference< css::uno::XInterface >& xInt );
+
+ // retrieves the instance responsible for notifying changes in the properties of the shape associated with
+ // the SdrObject
+ //
+ // @precond
+ // There already exists an SvxShape instance associated with the SdrObject
+ // @throws css::uno::RuntimeException
+ // if there does nt yet exists an SvxShape instance associated with the SdrObject.
+ svx::PropertyChangeNotifier& getShapePropertyChangeNotifier();
+
+ // notifies a change in the given property, to all applicable listeners registered at the associated SvxShape
+ //
+ // This method is equivalent to calling getShapePropertyChangeNotifier().notifyPropertyChange( _eProperty ),
+ // exception that it is allowed to be called when there does not yet exist an associated SvxShape - in which
+ // case the method will silently return without doing anything.
+ void notifyShapePropertyChange( const svx::ShapeProperty _eProperty ) const;
+
+ // transformation interface for StarOfficeAPI. This implements support for
+ // homogen 3x3 matrices containing the transformation of the SdrObject. At the
+ // moment it contains a shearX, rotation and translation, but for setting all linear
+ // transforms like Scale, ShearX, ShearY, Rotate and Translate are supported.
+ //
+ // gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon
+ // with the base geometry and returns TRUE. Otherwise it returns FALSE.
+ virtual bool TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& rPolyPolygon) const;
+
+ // sets the base geometry of the object using infos contained in the homogen 3x3 matrix.
+ // If it's an SdrPathObj it will use the provided geometry information. The Polygon has
+ // to use (0,0) as upper left and will be scaled to the given size in the matrix.
+ virtual void TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& rPolyPolygon);
+
+ // give info if object is in destruction
+ bool IsInDestruction() const;
+
+ // return if fill is != XFILL_NONE
+ bool HasFillStyle() const;
+ bool HasLineStyle() const;
+
+ // on import of OLE object from MS documents the BLIP size might be retrieved,
+ // the following methods are used to control it;
+ // usually this data makes no sense after the import is finished, since the object
+ // might be resized
+ const tools::Rectangle& GetBLIPSizeRectangle() const { return maBLIPSizeRectangle;}
+ void SetBLIPSizeRectangle( const tools::Rectangle& aRect );
+
+ // #i121917#
+ virtual bool HasText() const;
+
+ bool Equals(const SdrObject&) const;
+
+ virtual void dumpAsXml(xmlTextWriterPtr pWriter) const;
+
+ /// Is this a textbox of a drawinglayer shape?
+ virtual bool IsTextBox() const;
+
+ void SetEmptyPresObj(bool bEpt);
+ bool IsEmptyPresObj() const { return bEmptyPresObj;}
+ void SetNotVisibleAsMaster(bool bFlg);
+ bool IsNotVisibleAsMaster() const { return bNotVisibleAsMaster;}
+ void SetUserCall(SdrObjUserCall* pUser);
+ SdrObjUserCall* GetUserCall() const { return pUserCall;}
+ /// @see mbDoNotInsertIntoPageAutomatically
+ void SetDoNotInsertIntoPageAutomatically(bool bSet);
+ /// @see mbDoNotInsertIntoPageAutomatically
+ bool IsDoNotInsertIntoPageAutomatically() const { return mbDoNotInsertIntoPageAutomatically;}
+
+ // Warning: this method should only be used if you really know what you're doing
+ sal_uInt32 GetOrdNumDirect() const { return nOrdNum;}
+
+ // #i25616#
+ bool DoesSupportTextIndentingOnLineWidthChange() const { return mbSupportTextIndentingOnLineWidthChange;}
+
+ const Point& GetAnchorPos() const;
+
+ // #i25616#
+ bool LineIsOutsideGeometry() const { return mbLineIsOutsideGeometry;}
+
+ // Set the position in the navigation position to the given value.
+ // This method is typically used only by the model after a change to
+ // the navigation order.
+ // This method does not change the navigation position of other
+ // objects.
+ // Use SdrObjList::SetObjectNavigationPosition() instead.
+ void SetNavigationPosition (const sal_uInt32 nPosition);
+
+ // sets a new UNO representation of the shape
+ // This is only a public interface function. The actual work is
+ // done by impl_setUnoShape().
+ // Calling this function is only allowed for the UNO representation
+ // itself!
+ void setUnoShape( const css::uno::Reference<css::uno::XInterface>& _rxUnoShape);
+
+ const css::uno::WeakReference< css::uno::XInterface >& getWeakUnoShape() const { return maWeakUnoShape; }
+
+ void setSuitableOutlinerBg(Outliner& rOutliner) const;
+
+protected:
+ tools::Rectangle aOutRect; // surrounding rectangle for Paint (incl. LineWidth, ...)
+ Point aAnchor; // anchor position (Writer)
+ SdrObjUserCall* pUserCall;
+ std::unique_ptr<SdrObjPlusData>
+ pPlusData; // Broadcaster, UserData, connectors, ... (this is the Bitsack)
+ // object is only pointing to another one
+ bool bVirtObj : 1;
+ bool bSnapRectDirty : 1;
+ // the following flags will be streamed
+ bool bMovProt : 1; // if true, the position is protected
+ bool bSizProt : 1; // if true, the size is protected
+ // If bEmptyPresObj is true, it is a presentation object that has no content yet.
+ // The flag's default value is false.
+ // The management is done by the application.
+ // Neither assign operator nor cloning copies the flag!
+ // The flag is persistent.
+ bool bEmptyPresObj : 1; // empty presentation object (Draw)
+ // if true, object is invisible as object of the MasterPage
+ bool bNotVisibleAsMaster : 1;
+ // if true, the object is closed, i.e. no line, arc...
+ bool bClosedObj : 1;
+ bool bIsEdge : 1;
+ bool bIs3DObj : 1;
+ bool bIsUnoObj : 1;
+ // #i25616#
+ bool mbLineIsOutsideGeometry : 1;
+ // #i25616#
+ bool mbSupportTextIndentingOnLineWidthChange : 1;
+
+ virtual ~SdrObject() override;
+
+ virtual std::unique_ptr<sdr::properties::BaseProperties> CreateObjectSpecificProperties();
+
+ virtual std::unique_ptr<sdr::contact::ViewContact> CreateObjectSpecificViewContact();
+
+ tools::Rectangle ImpDragCalcRect(const SdrDragStat& rDrag) const;
+
+ // for GetDragComment
+ OUString ImpGetDescriptionStr(const char* pStrCacheID) const;
+
+ void ImpForcePlusData();
+
+ OUString GetMetrStr(long nVal) const;
+
+ /// A derived class must override these 3 methods if it has own geometric
+ /// data that must be saved for Undo.
+ /// NewGeoData() creates an empty instance of a class derived from
+ /// SdrObjGeoData.
+ virtual SdrObjGeoData* NewGeoData() const;
+ virtual void SaveGeoData(SdrObjGeoData& rGeo) const;
+ virtual void RestGeoData(const SdrObjGeoData& rGeo);
+
+ // internal versions
+ const SfxItemSet& GetObjectItemSet() const;
+ void SetObjectItem(const SfxPoolItem& rItem);
+ void SetObjectItemSet(const SfxItemSet& rSet);
+ const SfxPoolItem& GetObjectItem(const sal_uInt16 nWhich) const;
+ template<class T> const T& GetObjectItem( TypedWhichId<T> nWhich ) const
+ {
+ return static_cast<const T&>(GetObjectItem(sal_uInt16(nWhich)));
+ }
+
+ /// Sets a new UNO shape
+ ///
+ /// The default implementation of this function sets the new UNO
+ /// shape. Derived classes should override the function to handle
+ /// any other actions that are needed when the shape is being
+ /// changed.
+ ///
+ /// The implementation _must_ call the same method of its parent
+ /// class (preferably as the first step)!
+ virtual void impl_setUnoShape( const css::uno::Reference< css::uno::XInterface >& _rxUnoShape );
+
+ // helper function for reimplementing Clone().
+ template< typename T > T* CloneHelper(SdrModel& rTargetModel) const;
+
+private:
+ struct Impl;
+ std::unique_ptr<Impl> mpImpl;
+ SdrObjList* mpParentOfSdrObject; // list that includes this object
+ sal_uInt32 nOrdNum; // order number of the object in the list
+ std::unique_ptr<SfxGrabBagItem> pGrabBagItem; // holds the GrabBagItem property
+ // Position in the navigation order. SAL_MAX_UINT32 when not used.
+ sal_uInt32 mnNavigationPosition;
+ SdrLayerID mnLayerID;
+ bool bNoPrint : 1; // if true, the object is not printed.
+ bool mbVisible : 1; // if false, the object is not visible on screen (but maybe on printer, depending on bNoprint
+ bool bMarkProt : 1; // marking forbidden, persistent
+ // on import of OLE object from MS documents the BLIP size might be retrieved,
+ // in this case the following member is initialized as nonempty rectangle
+ tools::Rectangle maBLIPSizeRectangle;
+ std::unique_ptr<sdr::properties::BaseProperties>
+ mpProperties;
+ std::unique_ptr<sdr::contact::ViewContact>
+ mpViewContact;
+
+ // global static ItemPool for not-yet-inserted items
+ static SdrItemPool* mpGlobalItemPool;
+
+ // do not use directly, always use getSvxShape() if you have to!
+ SvxShape* mpSvxShape;
+ css::uno::WeakReference< css::uno::XInterface >
+ maWeakUnoShape;
+ // HACK: Do not automatically insert newly created object into a page.
+ // The user needs to do it manually later.
+ bool mbDoNotInsertIntoPageAutomatically;
+
+ // only for internal use!
+ SvxShape* getSvxShape();
+
+ SdrObject( const SdrObject& ) = delete;
+};
+
+struct SVXCORE_DLLPUBLIC SdrObjectFreeOp
+{
+ void operator()(SdrObject* obj)
+ {
+ SdrObject::Free(obj);
+ }
+};
+
+struct SdrObjCreatorParams
+{
+ SdrInventor nInventor;
+ sal_uInt16 nObjIdentifier;
+ SdrModel& rSdrModel;
+};
+
+/**
+ * Whoever creates his own objects must set a link in the SdrObjFactory class.
+ * The handler must have the following signature:
+ * void Hdl(SdrObjFactory*)
+ * He must take a look at the referenced instance's nInventor and nIdentifier values,
+ * and must create a new drawing object instance accordingly.
+ * He must also make the pNewObj pointer reference to this instance.
+ */
+class SVXCORE_DLLPUBLIC SdrObjFactory
+{
+public:
+ static SdrObject* MakeNewObject(
+ SdrModel& rSdrModel,
+ SdrInventor nInventor,
+ sal_uInt16 nObjIdentifier,
+ const tools::Rectangle* pSnapRect = nullptr);
+
+ static void InsertMakeObjectHdl(Link<SdrObjCreatorParams, SdrObject*> const & rLink);
+ static void RemoveMakeObjectHdl(Link<SdrObjCreatorParams, SdrObject*> const & rLink);
+
+private:
+ static SVX_DLLPRIVATE SdrObject* CreateObjectFromFactory(
+ SdrModel& rSdrModel,
+ SdrInventor nInventor,
+ sal_uInt16 nIdentifier);
+
+ SdrObjFactory() = delete;
+};
+
+template< typename T > T* SdrObject::CloneHelper(SdrModel& rTargetModel) const
+{
+ OSL_ASSERT( typeid( T ) == typeid( *this ));
+ T* pObj = dynamic_cast< T* >(
+ SdrObjFactory::MakeNewObject(
+ rTargetModel,
+ GetObjInventor(),
+ GetObjIdentifier()));
+
+ if(nullptr != pObj)
+ {
+ // use ::operator=()
+ *pObj = *static_cast< const T* >( this );
+ }
+
+ return pObj;
+}
+
+#endif // INCLUDED_SVX_SVDOBJ_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */