summaryrefslogtreecommitdiffstats
path: root/include/svx/svdmodel.hxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--include/svx/svdmodel.hxx641
1 files changed, 641 insertions, 0 deletions
diff --git a/include/svx/svdmodel.hxx b/include/svx/svdmodel.hxx
new file mode 100644
index 000000000..62c9be034
--- /dev/null
+++ b/include/svx/svdmodel.hxx
@@ -0,0 +1,641 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <editeng/forbiddencharacterstable.hxx>
+#include <editeng/outliner.hxx>
+#include <rtl/ustring.hxx>
+#include <tools/weakbase.h>
+#include <svl/SfxBroadcaster.hxx>
+#include <tools/degree.hxx>
+#include <tools/fldunit.hxx>
+#include <tools/fract.hxx>
+#include <svl/hint.hxx>
+#include <o3tl/enumarray.hxx>
+
+#include <svl/style.hxx>
+#include <svx/xtable.hxx>
+
+#include <svx/svdtypes.hxx>
+#include <svx/svxdllapi.h>
+
+#include <rtl/ref.hxx>
+#include <deque>
+
+#ifdef DBG_UTIL
+// SdrObjectLifetimeWatchDog
+#include <unordered_set>
+#endif
+
+class OutputDevice;
+class SdrOutliner;
+class SdrLayerAdmin;
+class SdrObjList;
+class SdrObject;
+class SdrPage;
+class SdrPageView;
+class SdrTextObj;
+class SdrUndoAction;
+class SdrUndoGroup;
+class AutoTimer;
+class SfxItemPool;
+class SfxItemSet;
+class SfxRepeatTarget;
+class SfxStyleSheet;
+class SfxUndoAction;
+class SfxUndoManager;
+class XBitmapList;
+class XColorList;
+class XDashList;
+class XGradientList;
+class XHatchList;
+class XLineEndList;
+class SvxForbiddenCharactersTable;
+class SvNumberFormatter;
+class SdrOutlinerCache;
+class SdrUndoFactory;
+class ImageMap;
+class TextChain;
+enum class CharCompressType;
+namespace comphelper
+{
+ class IEmbeddedHelper;
+ class LifecycleProxy;
+}
+namespace sfx2
+{
+ class LinkManager;
+}
+namespace com::sun::star::beans {
+ struct PropertyValue;
+}
+
+namespace svx
+{
+class Theme;
+}
+
+constexpr const sal_Unicode DEGREE_CHAR = u'\x00B0'; /* U+00B0 DEGREE SIGN */
+
+
+enum class SdrHintKind
+{
+ LayerChange, // changed layer definition
+ LayerOrderChange, // order of layer changed (Insert/Remove/ChangePos)
+ PageOrderChange, // order of pages (object pages or master pages) changed (Insert/Remove/ChangePos)
+ ObjectChange, // object changed
+ ObjectInserted, // new object inserted
+ ObjectRemoved, // symbol object removed from list
+ ModelCleared, // deleted the whole model (no pages exist anymore). not impl.
+ RefDeviceChange, // RefDevice changed
+ DefaultTabChange, // Default tabulator width changed
+ SwitchToPage, // #94278# UNDO/REDO at an object evtl. on another page
+ BeginEdit, // Is called after the object has entered text edit mode
+ EndEdit // Is called after the object has left text edit mode
+};
+
+class SVXCORE_DLLPUBLIC SdrHint final : public SfxHint
+{
+private:
+ SdrHintKind meHint;
+ const SdrObject* mpObj;
+ const SdrPage* mpPage;
+
+public:
+ explicit SdrHint(SdrHintKind eNewHint);
+ explicit SdrHint(SdrHintKind eNewHint, const SdrObject& rNewObj);
+ explicit SdrHint(SdrHintKind eNewHint, const SdrPage* pPage);
+ explicit SdrHint(SdrHintKind eNewHint, const SdrObject& rNewObj, const SdrPage* pPage);
+
+ const SdrPage* GetPage() const { return mpPage;}
+ const SdrObject* GetObject() const { return mpObj;}
+ SdrHintKind GetKind() const { return meHint;}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// SdrModel
+// DlgEdModel
+// FmFormModel
+// ScDrawLayer
+// SdDrawDocument
+// SwDrawModel
+// OReportModel
+
+struct SdrModelImpl;
+
+class SVXCORE_DLLPUBLIC SdrModel : public SfxBroadcaster, public tools::WeakBase
+{
+private:
+#ifdef DBG_UTIL
+ // SdrObjectLifetimeWatchDog:
+ // Use maAllIncarnatedObjects to keep track of all SdrObjects incarnated using this SdrModel
+ // (what is now possible after the paradigm change that a SdrObject stays at a single SdrModel
+ // for it's whole lifetime).
+ // The two methods are exclusive, debug-only, only-accessible-by SdrObject accesses to else
+ // hidden/non-existing maAllIncarnatedObjects.
+ // SdrObject::SdrObject uses impAddIncarnatedSdrObjectToSdrModel, while SdrObject::~SdrObject
+ // uses impRemoveIncarnatedSdrObjectToSdrModel.
+ // There are two places which may trigger SAL_WARN warnings:
+ // - impRemoveIncarnatedSdrObjectToSdrModel when the to-be-removed SdrObject is not member of SdrModel
+ // - SdrModel::~SdrModel after all SdrObjects *should* be cleaned-up.
+ // SdrModel::~SdrModel will also - for convenience - Free the non-deleted SdrObjects if there
+ // are any.
+ // Using std::unordered_set will use quasi constant access times, so this watchdog will not
+ // be expensive. Nonetheless, only use with debug code. It may be seductive to use this in
+ // product code, too, especially if it will indeed trigger - but its intention is clearly
+ // to find/identify MemoryLeaks caused by SdrObjects
+ friend void impAddIncarnatedSdrObjectToSdrModel(const SdrObject& rSdrObject, SdrModel& rSdrModel);
+ friend void impRemoveIncarnatedSdrObjectToSdrModel(const SdrObject& rSdrObject, SdrModel& rSdrModel);
+ std::unordered_set< const SdrObject* > maAllIncarnatedObjects;
+#endif
+protected:
+ std::vector<rtl::Reference<SdrPage>> maMasterPages;
+ std::vector<rtl::Reference<SdrPage>> maPages;
+ std::function<void(std::unique_ptr<SdrUndoAction>)> m_aUndoLink; // link to a NotifyUndo-Handler
+ Size m_aMaxObjSize; // e.g. for auto-growing text
+ Fraction m_aObjUnit; // description of the coordinate units for ClipBoard, Drag&Drop, ...
+ MapUnit m_eObjUnit; // see above
+ FieldUnit m_eUIUnit; // unit, scale (e.g. 1/1000) for the UI (status bar) is set by ImpSetUIUnit()
+ Fraction m_aUIScale; // see above
+ OUString m_aUIUnitStr; // see above
+ Fraction m_aUIUnitFact; // see above
+ int m_nUIUnitDecimalMark; // see above
+
+ std::unique_ptr<SdrLayerAdmin> m_pLayerAdmin;
+ rtl::Reference<SfxItemPool> m_pItemPool;
+ comphelper::IEmbeddedHelper* m_pEmbeddedHelper; // helper for embedded objects to get rid of the SfxObjectShell
+ std::unique_ptr<SdrOutliner> m_pDrawOutliner; // an Outliner for outputting text
+ std::unique_ptr<SdrOutliner> m_pHitTestOutliner;// an Outliner for the HitTest
+ std::unique_ptr<SdrOutliner> m_pChainingOutliner; // an Outliner for chaining overflowing text
+ sal_Int32 mnDefTextHgt; // Default text height in logical units
+ VclPtr<OutputDevice> m_pRefOutDev; // ReferenceDevice for the EditEngine
+ rtl::Reference< SfxStyleSheetBasePool > mxStyleSheetPool;
+ SfxStyleSheet* m_pDefaultStyleSheet;
+ SfxStyleSheet* mpDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj; // #i119287#
+ sfx2::LinkManager* m_pLinkManager; // LinkManager
+ std::deque<std::unique_ptr<SfxUndoAction>> m_aUndoStack;
+ std::deque<std::unique_ptr<SfxUndoAction>> m_aRedoStack;
+ std::unique_ptr<SdrUndoGroup> m_pCurrentUndoGroup; // For multi-level
+ sal_uInt16 m_nUndoLevel; // undo nesting
+ bool m_bIsWriter:1; // to clean up pMyPool from 303a
+ bool mbUndoEnabled:1; // If false no undo is recorded or we are during the execution of an undo action
+ bool mbChanged:1;
+ bool m_bPagNumsDirty:1;
+ bool m_bMPgNumsDirty:1;
+ bool m_bTransportContainer:1; // doc is temporary object container, no display (e.g. clipboard)
+ bool m_bReadOnly:1;
+ bool m_bTransparentTextFrames:1;
+ bool m_bSwapGraphics:1;
+ bool m_bPasteResize:1; // Objects are being resized due to Paste with different MapMode
+ bool m_bStarDrawPreviewMode:1;
+ bool mbDisableTextEditUsesCommonUndoManager:1;
+ bool mbVOCInvalidationIsReliable:1; // does the app reliably invalidate the VOC, or do we need to rebuild the primitives on every render?
+ sal_uInt16 m_nDefaultTabulator;
+ sal_uInt32 m_nMaxUndoCount;
+
+ std::unique_ptr<TextChain> m_pTextChain;
+
+
+public:
+ std::shared_ptr<SvxForbiddenCharactersTable> mpForbiddenCharactersTable;
+
+ std::unique_ptr<SdrOutlinerCache> mpOutlinerCache;
+ //get a vector of all the SdrOutliner belonging to the model
+ std::vector<SdrOutliner*> GetActiveOutliners() const;
+ std::unique_ptr<SdrModelImpl> mpImpl;
+ CharCompressType mnCharCompressType;
+ sal_uInt16 mnHandoutPageCount;
+ bool mbModelLocked;
+ bool mbKernAsianPunctuation;
+ bool mbAddExtLeading;
+ bool mbInDestruction;
+
+ // Color, Dash, Line-End, Hatch, Gradient, Bitmap property lists ...
+ o3tl::enumarray<XPropertyListType, XPropertyListRef> maProperties;
+
+ sal_uInt16 getHandoutPageCount() const { return mnHandoutPageCount; }
+ void setHandoutPageCount( sal_uInt16 nHandoutPageCount ) { mnHandoutPageCount = nHandoutPageCount; }
+
+ // Adapt to given Size and Borders scaling all contained data, maybe
+ // including PresObj's in higher derivations
+ virtual void adaptSizeAndBorderForAllPages(
+ const Size& rNewSize,
+ tools::Long nLeft = 0,
+ tools::Long nRight = 0,
+ tools::Long nUpper = 0,
+ tools::Long nLower = 0);
+
+protected:
+ virtual css::uno::Reference< css::uno::XInterface > createUnoModel();
+
+private:
+ SdrModel(const SdrModel& rSrcModel) = delete;
+ void operator=(const SdrModel& rSrcModel) = delete;
+ bool operator==(const SdrModel& rCmpModel) const = delete;
+ SVX_DLLPRIVATE void ImpPostUndoAction(std::unique_ptr<SdrUndoAction> pUndo);
+ SVX_DLLPRIVATE void ImpSetUIUnit();
+ SVX_DLLPRIVATE void ImpSetOutlinerDefaults( SdrOutliner* pOutliner, bool bInit = false );
+ SVX_DLLPRIVATE void ImpReformatAllTextObjects();
+ SVX_DLLPRIVATE void ImpReformatAllEdgeObjects();
+ SVX_DLLPRIVATE void ImpCreateTables(bool bDisablePropertyFiles);
+
+ // this is a weak reference to a possible living api wrapper for this model
+ css::uno::Reference< css::uno::XInterface > mxUnoModel;
+
+ // used to disable unique name checking during page move
+ bool mbMakePageObjectsNamesUnique = true;
+
+public:
+ SVX_DLLPRIVATE virtual bool IsCreatingDataObj() const { return false; }
+ bool IsTransportContainer() const { return m_bTransportContainer; }
+ bool IsPasteResize() const { return m_bPasteResize; }
+ void SetPasteResize(bool bOn) { m_bPasteResize=bOn; }
+ // If a custom Pool is put here, the class will call methods
+ // on it (Put(), Remove()). On disposal of SdrModel the pool
+ // will be deleted with delete.
+ // If you give NULL instead, it will create an own pool (SdrItemPool)
+ // which will also be disposed in the destructor.
+ // If you do use a custom Pool, make sure you inherit from SdrItemPool,
+ // if you want to use symbol objects inherited from SdrAttrObj.
+ // If, however, you use objects inheriting from SdrObject you are free
+ // to choose a pool of your liking.
+ //
+ // tdf#118731 a bDisablePropertyFiles of true will disable ability to load
+ // XPropertyFiles describing defaults. Useful for UI preview widgets
+ explicit SdrModel(
+ SfxItemPool* pPool = nullptr,
+ ::comphelper::IEmbeddedHelper* pPers = nullptr,
+ bool bDisablePropertyFiles = false);
+ virtual ~SdrModel() override;
+ void ClearModel(bool bCalledFromDestructor);
+
+ // Override this to enable the Swap/LoadOnDemand of graphics.
+ // If rbDeleteAfterUse is set to sal_True the SvStream instance from
+ // the caller will be disposed after use.
+ // If this method returns NULL, a temporary file will be allocated for
+ // swapping.
+ // The stream from which the model was loaded or in which is was saved last
+ // needs to be delivered
+ virtual css::uno::Reference<
+ css::embed::XStorage> GetDocumentStorage() const;
+ css::uno::Reference<
+ css::io::XInputStream >
+ GetDocumentStream(OUString const& rURL,
+ ::comphelper::LifecycleProxy const & rProxy) const;
+ // Change the template attributes of the symbol objects to hard attributes
+ void BurnInStyleSheetAttributes();
+ // If you inherit from SdrPage you also need to inherit from SdrModel
+ // and implement both VM AllocPage() and AllocModel()...
+ virtual rtl::Reference<SdrPage> AllocPage(bool bMasterPage);
+ virtual SdrModel* AllocModel() const;
+
+ // Changes on the layers set the modified flag and broadcast on the model!
+ const SdrLayerAdmin& GetLayerAdmin() const { return *m_pLayerAdmin; }
+ SdrLayerAdmin& GetLayerAdmin() { return *m_pLayerAdmin; }
+
+ const SfxItemPool& GetItemPool() const { return *m_pItemPool; }
+ SfxItemPool& GetItemPool() { return *m_pItemPool; }
+
+ SdrOutliner& GetDrawOutliner(const SdrTextObj* pObj=nullptr) const;
+
+ SdrOutliner& GetHitTestOutliner() const { return *m_pHitTestOutliner; }
+ const SdrTextObj* GetFormattingTextObj() const;
+ // put the TextDefaults (Font,Height,Color) in a Set
+ void SetTextDefaults() const;
+ static void SetTextDefaults( SfxItemPool* pItemPool, sal_Int32 nDefTextHgt );
+
+ SdrOutliner& GetChainingOutliner(const SdrTextObj* pObj) const;
+ TextChain * GetTextChain() const;
+
+ // ReferenceDevice for the EditEngine
+ void SetRefDevice(OutputDevice* pDev);
+ OutputDevice* GetRefDevice() const { return m_pRefOutDev.get(); }
+ // If a new MapMode is set on the RefDevice (or similar)
+ void RefDeviceChanged(); // not yet implemented
+ // default font height in logical units
+ void SetDefaultFontHeight(sal_Int32 nVal);
+ // default tabulator width for the EditEngine
+ void SetDefaultTabulator(sal_uInt16 nVal);
+ sal_uInt16 GetDefaultTabulator() const { return m_nDefaultTabulator; }
+
+ // The DefaultStyleSheet will be used in every symbol object which is inserted
+ // in this model and does not have a StyleSheet set.
+ SfxStyleSheet* GetDefaultStyleSheet() const { return m_pDefaultStyleSheet; }
+ void SetDefaultStyleSheet(SfxStyleSheet* pDefSS) { m_pDefaultStyleSheet = pDefSS; }
+
+ // #i119287# default StyleSheet for SdrGrafObj and SdrOle2Obj
+ SfxStyleSheet* GetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj() const { return mpDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj; }
+ void SetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj(SfxStyleSheet* pDefSS) { mpDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj = pDefSS; }
+
+ sfx2::LinkManager* GetLinkManager() { return m_pLinkManager; }
+ void SetLinkManager( sfx2::LinkManager* pLinkMgr ) { m_pLinkManager = pLinkMgr; }
+
+ ::comphelper::IEmbeddedHelper* GetPersist() const { return m_pEmbeddedHelper; }
+ void SetPersist( ::comphelper::IEmbeddedHelper *p ) { m_pEmbeddedHelper = p; }
+
+ // Unit for the symbol coordination
+ // Default is 1 logical unit = 1/100mm (Unit=MapUnit::Map100thMM, Fract=(1,1)).
+ // Examples:
+ // MapUnit::MapPoint, Fraction(72,1) : 1 log Einh = 72 Point = 1 Inch
+ // MapUnit::MapPoint, Fraction(1,20) : 1 log Einh = 1/20 Point = 1 Twip
+ // MapUnit::MapTwip, Fraction(1,1) : 1 log Einh = 1 Twip
+ // MapUnit::Map100thMM, Fraction(1,10) : 1 log Einh = 1/1000mm
+ // MapUnit::MapMM, Fraction(1000,1) : 1 log Einh = 1000mm = 1m
+ // MapUnit::MapCM, Fraction(100,1) : 1 log Einh = 100cm = 1m
+ // MapUnit::MapCM, Fraction(100000,1): 1 log Einh = 100000cm = 1km
+ // (FWIW: you cannot represent light years).
+ // The scaling unit is needed for the Engine to serve the Clipboard
+ // with the correct sizes.
+ MapUnit GetScaleUnit() const { return m_eObjUnit; }
+ void SetScaleUnit(MapUnit eMap);
+ const Fraction& GetScaleFraction() const { return m_aObjUnit; }
+ void SetScaleFraction(const Fraction& rFrac);
+ // Setting both simultaneously performs a little better
+ void SetScaleUnit(MapUnit eMap, const Fraction& rFrac);
+
+ // maximal size e.g. for auto growing texts
+ const Size& GetMaxObjSize() const { return m_aMaxObjSize; }
+ void SetMaxObjSize(const Size& rSiz) { m_aMaxObjSize=rSiz; }
+
+ // For the View! to display sane numbers in the status bar: Default is mm.
+ void SetUIUnit(FieldUnit eUnit);
+ FieldUnit GetUIUnit() const { return m_eUIUnit; }
+ // The scale of the drawing. Default 1/1.
+ void SetUIScale(const Fraction& rScale);
+ const Fraction& GetUIScale() const { return m_aUIScale; }
+ // Setting both simultaneously performs a little better
+ void SetUIUnit(FieldUnit eUnit, const Fraction& rScale);
+
+ static OUString GetUnitString(FieldUnit eUnit);
+ OUString GetMetricString(tools::Long nVal, bool bNoUnitChars = false, sal_Int32 nNumDigits = -1) const;
+ static OUString GetAngleString(Degree100 nAngle);
+ static OUString GetPercentString(const Fraction& rVal);
+
+ // RecalcPageNums is ordinarily only called by the Page.
+ bool IsPagNumsDirty() const { return m_bPagNumsDirty; };
+ bool IsMPgNumsDirty() const { return m_bMPgNumsDirty; };
+ void RecalcPageNums(bool bMaster);
+ // After the Insert the Page belongs to the SdrModel.
+ virtual void InsertPage(SdrPage* pPage, sal_uInt16 nPos=0xFFFF);
+ virtual void DeletePage(sal_uInt16 nPgNum);
+ // Remove means transferring ownership to the caller (opposite of Insert)
+ virtual rtl::Reference<SdrPage> RemovePage(sal_uInt16 nPgNum);
+ virtual void MovePage(sal_uInt16 nPgNum, sal_uInt16 nNewPos);
+ const SdrPage* GetPage(sal_uInt16 nPgNum) const;
+ SdrPage* GetPage(sal_uInt16 nPgNum);
+ sal_uInt16 GetPageCount() const;
+ virtual void PageListChanged();
+
+ // Masterpages
+ virtual void InsertMasterPage(SdrPage* pPage, sal_uInt16 nPos=0xFFFF);
+ void DeleteMasterPage(sal_uInt16 nPgNum);
+ // Remove means transferring ownership to the caller (opposite of Insert)
+ virtual rtl::Reference<SdrPage> RemoveMasterPage(sal_uInt16 nPgNum);
+ void MoveMasterPage(sal_uInt16 nPgNum, sal_uInt16 nNewPos);
+ const SdrPage* GetMasterPage(sal_uInt16 nPgNum) const;
+ SdrPage* GetMasterPage(sal_uInt16 nPgNum);
+ sal_uInt16 GetMasterPageCount() const;
+ virtual void MasterPageListChanged();
+
+ // modified flag. Is set automatically when something changes on the Pages
+ // symbol objects. You need to reset it yourself, however, e.g. on Save().
+ bool IsChanged() const { return mbChanged; }
+ virtual void SetChanged(bool bFlg = true);
+
+ // If set to sal_True, graphics from graphics objects will:
+ // - not be loaded immediately when loading a document,
+ // but only once they are needed (e.g. displayed).
+ // - be pruned from memory if they are not needed.
+ // For that to work, override the virtual method GetDocumentStream().
+ // Default=FALSE. Flag is not persistent.
+ bool IsSwapGraphics() const { return m_bSwapGraphics; }
+ void SetSwapGraphics();
+
+ // Text frames without filling can be select with a mouse click by default (sal_False).
+ // With this flag set to true you can hit them only in the area in which text is to be
+ // found.
+ bool IsPickThroughTransparentTextFrames() const { return m_bTransparentTextFrames; }
+ void SetPickThroughTransparentTextFrames(bool bOn) { m_bTransparentTextFrames=bOn; }
+
+ // Can the model be changed at all?
+ // Is only evaluated by the possibility methods of the View.
+ // Direct manipulations on the model, ... do not respect this flag.
+ // Override this and return the appropriate ReadOnly status
+ // of the files, i.e. true or false. (Method is called multiple
+ // times, so use one flag only!)
+ virtual bool IsReadOnly() const;
+ void SetReadOnly(bool bYes);
+
+ // Mixing two SdrModels. Mind that rSourceModel is not const.
+ // The pages will not be copied but moved, when inserted.
+ // rSourceModel may very well be empty afterwards.
+ // nFirstPageNum,nLastPageNum: The pages to take from rSourceModel
+ // nDestPos..................: position to insert
+ // bMergeMasterPages.........: sal_True = needed MasterPages will be taken
+ // from rSourceModel
+ // sal_False= the MasterPageDescriptors of
+ // the pages of the rSourceModel will be
+ // mapped on the existing MasterPages.
+ // bUndo.....................: An undo action is generated for the merging.
+ // Undo is only for the target model, not for the
+ // rSourceModel.
+ // bTreadSourceAsConst.......: sal_True=the SourceModel will not be changed,
+ // so pages will be copied.
+ virtual void Merge(SdrModel& rSourceModel,
+ sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum,
+ sal_uInt16 nDestPos,
+ bool bMergeMasterPages, bool bAllMasterPages,
+ bool bUndo = true, bool bTreadSourceAsConst = false);
+
+ // Behaves like Merge(SourceModel=DestModel,nFirst,nLast,nDest,sal_False,sal_False,bUndo,!bMoveNoCopy);
+ void CopyPages(sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum,
+ sal_uInt16 nDestPos,
+ bool bUndo, bool bMoveNoCopy);
+
+ // BegUndo() / EndUndo() enables you to group arbitrarily many UndoActions
+ // arbitrarily deeply. As comment for the UndoAction the first BegUndo(String) of all
+ // nestings will be used.
+ // In that case the NotifyUndoActionHdl will be called on the last EndUndo().
+ // No UndoAction will be generated for an empty group.
+ // All direct modifications on the SdrModel do not create an UndoActions.
+ // Actions on the SdrView however do generate those.
+ void BegUndo(); // open Undo group
+ void BegUndo(const OUString& rComment); // open Undo group
+ void BegUndo(const OUString& rComment, const OUString& rObjDescr, SdrRepeatFunc eFunc); // open Undo group
+ void EndUndo(); // close Undo group
+ void AddUndo(std::unique_ptr<SdrUndoAction> pUndo);
+ sal_uInt16 GetUndoBracketLevel() const { return m_nUndoLevel; }
+ // only after the first BegUndo or before the last EndUndo:
+ void SetUndoComment(const OUString& rComment);
+ void SetUndoComment(const OUString& rComment, const OUString& rObjDescr);
+
+ // The Undo management is only done if NotifyUndoAction-Handler is not set.
+ // Default is 16. Minimal MaxUndoActionCount is 1.
+ void SetMaxUndoActionCount(sal_uInt32 nCount);
+ void ClearUndoBuffer();
+
+ bool HasUndoActions() const;
+ bool HasRedoActions() const;
+ void Undo();
+ void Redo();
+ void Repeat(SfxRepeatTarget&);
+
+ // The application can set a handler here which collects the UndoActions einsammelt.
+ // The handler has the following signature:
+ // void NotifyUndoActionHdl(SfxUndoAction* pUndoAction);
+ // When calling the handler ownership is transferred;
+ // The UndoAction belongs to the Handler, not the SdrModel.
+ void SetNotifyUndoActionHdl(const std::function<void(std::unique_ptr<SdrUndoAction>)>& rLink) { m_aUndoLink=rLink; }
+
+ /** application can set its own undo manager, BegUndo, EndUndo and AddUndoAction
+ calls are routed to this interface if given */
+ void SetSdrUndoManager( SfxUndoManager* pUndoManager );
+ SfxUndoManager* GetSdrUndoManager() const;
+
+ /** applications can set their own undo factory to override creation of
+ undo actions. The SdrModel will become owner of the given SdrUndoFactory
+ and delete it upon its destruction. */
+ void SetSdrUndoFactory( SdrUndoFactory* pUndoFactory );
+
+ /** returns the models undo factory. This must be used to create
+ undo actions for this model. */
+ SdrUndoFactory& GetSdrUndoFactory() const;
+
+ // Accessor methods for Palettes, Lists and Tables
+ // FIXME: this badly needs re-factoring...
+ const XPropertyListRef& GetPropertyList( XPropertyListType t ) const { return maProperties[ t ]; }
+ void SetPropertyList( XPropertyListRef const & p ) { maProperties[ p->Type() ] = p; }
+
+ // friendlier helpers
+ XDashListRef GetDashList() const { return XPropertyList::AsDashList(GetPropertyList( XPropertyListType::Dash )); }
+ XHatchListRef GetHatchList() const { return XPropertyList::AsHatchList(GetPropertyList( XPropertyListType::Hatch )); }
+ XColorListRef GetColorList() const { return XPropertyList::AsColorList(GetPropertyList( XPropertyListType::Color )); }
+ XBitmapListRef GetBitmapList() const { return XPropertyList::AsBitmapList(GetPropertyList( XPropertyListType::Bitmap )); }
+ XPatternListRef GetPatternList() const { return XPropertyList::AsPatternList(GetPropertyList( XPropertyListType::Pattern )); }
+ XLineEndListRef GetLineEndList() const { return XPropertyList::AsLineEndList(GetPropertyList( XPropertyListType::LineEnd )); }
+ XGradientListRef GetGradientList() const { return XPropertyList::AsGradientList(GetPropertyList( XPropertyListType::Gradient )); }
+
+ // The DrawingEngine only references the StyleSheetPool, whoever
+ // made it needs to delete it.
+ SfxStyleSheetBasePool* GetStyleSheetPool() const { return mxStyleSheetPool.get(); }
+ void SetStyleSheetPool(SfxStyleSheetBasePool* pPool) { mxStyleSheetPool=pPool; }
+
+ void SetTheme(std::unique_ptr<svx::Theme> pTheme);
+ svx::Theme* GetTheme();
+
+ void SetStarDrawPreviewMode(bool bPreview);
+ bool IsStarDrawPreviewMode() const { return m_bStarDrawPreviewMode; }
+
+ bool GetDisableTextEditUsesCommonUndoManager() const { return mbDisableTextEditUsesCommonUndoManager; }
+ void SetDisableTextEditUsesCommonUndoManager(bool bNew) { mbDisableTextEditUsesCommonUndoManager = bNew; }
+
+ css::uno::Reference< css::uno::XInterface > const & getUnoModel();
+ void setUnoModel( const css::uno::Reference< css::uno::XInterface >& xModel );
+
+ // these functions are used by the api to disable repaints during a
+ // set of api calls.
+ bool isLocked() const { return mbModelLocked; }
+ void setLock( bool bLock );
+
+ void SetForbiddenCharsTable( const std::shared_ptr<SvxForbiddenCharactersTable>& xForbiddenChars );
+ const std::shared_ptr<SvxForbiddenCharactersTable>& GetForbiddenCharsTable() const { return mpForbiddenCharactersTable;}
+
+ void SetCharCompressType( CharCompressType nType );
+ CharCompressType GetCharCompressType() const { return mnCharCompressType; }
+
+ void SetKernAsianPunctuation( bool bEnabled );
+ bool IsKernAsianPunctuation() const { return mbKernAsianPunctuation; }
+
+ void SetAddExtLeading( bool bEnabled );
+ bool IsAddExtLeading() const { return mbAddExtLeading; }
+
+ // tdf#99729 compatibility flag
+ void SetAnchoredTextOverflowLegacy(bool bEnabled);
+ bool IsAnchoredTextOverflowLegacy() const;
+
+ void ReformatAllTextObjects();
+
+ std::unique_ptr<SdrOutliner> createOutliner( OutlinerMode nOutlinerMode );
+ void disposeOutliner( std::unique_ptr<SdrOutliner> pOutliner );
+
+ bool IsWriter() const { return m_bIsWriter; }
+
+ // Used as a fallback in *::ReadUserDataSequence() to process common properties
+ void ReadUserDataSequenceValue(const css::beans::PropertyValue *pValue);
+ void WriteUserDataSequence(css::uno::Sequence < css::beans::PropertyValue >& rValues);
+
+ /** returns the numbering type that is used to format page fields in drawing shapes */
+ virtual SvxNumType GetPageNumType() const;
+
+ /** copies the items from the source set to the destination set. Both sets must have
+ same ranges but can have different pools. */
+ static void MigrateItemSet( const SfxItemSet* pSourceSet, SfxItemSet* pDestSet, SdrModel* pNewModel );
+
+ bool IsInDestruction() const { return mbInDestruction;}
+
+ static const css::uno::Sequence< sal_Int8 >& getUnoTunnelId();
+
+ /** enables (true) or disables (false) recording of undo actions
+ If undo actions are added while undo is disabled, they are deleted.
+ Disabling undo does not clear the current undo buffer! */
+ void EnableUndo( bool bEnable );
+
+ /** returns true if undo is currently enabled
+ This returns false if undo was disabled using EnableUndo( false ) and
+ also during the runtime of the Undo() and Redo() methods. */
+ bool IsUndoEnabled() const;
+
+ // used to prevent object name change during page move
+ bool DoesMakePageObjectsNamesUnique() const { return mbMakePageObjectsNamesUnique; }
+ void DoMakePageObjectsNamesUnique(bool bDo) { mbMakePageObjectsNamesUnique = bDo; }
+
+ virtual sal_Int32 getImagePreferredDPI() const { return 0; }
+
+ virtual void dumpAsXml(xmlTextWriterPtr pWriter) const;
+
+ bool IsVOCInvalidationIsReliable() const { return mbVOCInvalidationIsReliable; }
+ void SetVOCInvalidationIsReliable(bool b) { mbVOCInvalidationIsReliable = b; }
+};
+
+/*
+ +-----------+
+ | SdrModel |
+ +--+------+-+
+ | +-----------+
+ +----+-----+ |
+ | ... | |
+ +----+---+ +----+---+ +-----+--------+
+ |SdrPage | |SdrPage | |SdrLayerAdmin |
+ +---+----+ +-+--+--++ +---+-------+--+
+ | | | | | +-------------------+
+ +----+----+ +-----+-----+ +-------+-------+
+ | ... | | ... | | ... |
++---+---+ +---+---+ +----+----+ +----+----+ +-----+------+ +------+-----+
+|SdrObj | |SdrObj | |SdrLayer | |SdrLayer | |SdrLayerSet | |SdrLayerSet |
++-------+ +-------+ +---------+ +---------+ +------------+ +------------+
+This class: SdrModel is the head of the data models for the StarView Drawing Engine.
+
+///////////////////////////////////////////////////////////////////////////////////////////////// */
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */