/* -*- 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 <com/sun/star/frame/XModel.hpp>

#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>

#include <unordered_set>

class OutputDevice;

class SdrOutliner;

class SdrLayerAdmin;

class SdrObject;

class SdrPage;

class SdrTextObj;

class SdrUndoAction;

class SdrUndoGroup;

class SfxItemPool;

class SfxItemSet;

class SvxForbiddenCharactersTable;

class SdrOutlinerCache;

class SdrUndoFactory;

class TextChain;

enum class CharCompressType;

enum class SdrCompatibilityFlag;

namespace comphelper

{

    class IEmbeddedHelper;

    class LifecycleProxy;

}

namespace sfx2

{

    class LinkManager;

}

namespace com::sun::star::beans {

    struct PropertyValue;

}

namespace model

{

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

{

    // We need to keep track of all the SdrObjects linked to this SdrModel so that we can

    // shut them down cleanly, otherwise we end up with use-after-free issues.

    //

    // 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(SdrObject& rSdrObject, SdrModel& rSdrModel);

    friend void impRemoveIncarnatedSdrObjectToSdrModel(SdrObject& rSdrObject, SdrModel& rSdrModel);

    std::unordered_set< SdrObject* >  maAllIncarnatedObjects;

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

    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

    sal_uInt16          m_nPageNumsDirtyFrom = SAL_MAX_UINT16;

    sal_uInt16          m_nMasterPageNumsDirtyFrom = SAL_MAX_UINT16;

    bool                m_bIsWriter:1;        // to clean up pMyPool from 303a

    bool                m_bIsWriterIdle:1;

    bool                m_bThemedControls:1;  // If false UnoControls should not use theme colors

    bool                mbUndoEnabled:1;  // If false no undo is recorded or we are during the execution of an undo action

    bool                mbChanged: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?

    bool m_bIsPDFDocument:1;

    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:

    void implDtorClearModel();

    virtual css::uno::Reference< css::frame::XModel > 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::frame::XModel > mxUnoModel;

    // used to disable unique name checking during page move

    bool mbMakePageObjectsNamesUnique = true;

    bool m_bIsImpress = false;

    bool m_bShowMargin = true;

public:

    SVX_DLLPRIVATE virtual bool IsCreatingDataObj() const { return false; }

    bool     IsTransportContainer() const { return m_bTransportContainer; }

    bool     AreControlsThemed() { return m_bThemedControls; }

    bool     IsPasteResize() const        { return m_bPasteResize; }

    bool     IsImpress() const { return m_bIsImpress; }

    void     SetImpress(bool bIsImpress) { m_bIsImpress = bIsImpress; };

    bool     IsShowMargin() const { return m_bShowMargin; }

    void     SetShowMargin(bool bShowMargin) { m_bShowMargin = bShowMargin; }

    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);

    // 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_nPageNumsDirtyFrom != SAL_MAX_UINT16; }

    bool             IsMPgNumsDirty() const                     { return m_nMasterPageNumsDirtyFrom != SAL_MAX_UINT16; }

    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::shared_ptr<model::Theme> const& pTheme);

    std::shared_ptr<model::Theme> const& getTheme() const;

    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::frame::XModel > const & getUnoModel();

    void setUnoModel( const css::uno::Reference< css::frame::XModel >& 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; }

    void SetCompatibilityFlag(SdrCompatibilityFlag eFlag, bool bEnabled);

    /// @returns state of the SdrCompatibilityFlag

    bool GetCompatibilityFlag(SdrCompatibilityFlag eFlag) const;

    void ReformatAllTextObjects();

    std::unique_ptr<SdrOutliner> createOutliner( OutlinerMode nOutlinerMode );

    void disposeOutliner( std::unique_ptr<SdrOutliner> pOutliner );

    bool IsWriter() const { return m_bIsWriter; }

    void SetWriterIdle(bool bIsWriterIdle) { m_bIsWriterIdle = bIsWriterIdle; }

    bool IsWriterIdle() const { return m_bIsWriterIdle; }

    bool IsPDFDocument() const { return m_bIsPDFDocument; }

    void setPDFDocument(bool bIsPDFDocument)

    {

        m_bIsPDFDocument = bIsPDFDocument;

    }

    // 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& rNewModel );

    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: */