diff options
Diffstat (limited to '')
| -rw-r--r-- | sw/inc/doc.hxx | 1683 |
1 files changed, 1683 insertions, 0 deletions
diff --git a/sw/inc/doc.hxx b/sw/inc/doc.hxx new file mode 100644 index 000000000..ac257a843 --- /dev/null +++ b/sw/inc/doc.hxx @@ -0,0 +1,1683 @@ +/* -*- 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_SW_INC_DOC_HXX +#define INCLUDED_SW_INC_DOC_HXX + +// SwDoc interfaces +#include <o3tl/deleter.hxx> +#include <o3tl/sorted_vector.hxx> +#include <vcl/idle.hxx> +#include "swdllapi.h" +#include "swtypes.hxx" +#include "toxe.hxx" +#include "flyenum.hxx" +#include "flypos.hxx" +#include "swdbdata.hxx" +#include <sfx2/objsh.hxx> +#include <svl/style.hxx> +#include <editeng/numitem.hxx> +#include "tox.hxx" +#include "frmfmt.hxx" +#include "charfmt.hxx" +#include "docary.hxx" +#include "pagedesc.hxx" +#include "tblenum.hxx" +#include "ndarr.hxx" +#include "ndtyp.hxx" +#include <atomic> +#include <memory> +#include <set> +#include <unordered_map> +#include <vector> + +namespace editeng { class SvxBorderLine; } + +class SwExtTextInput; +class EditFieldInfo; +class Outliner; +class OutputDevice; +class Point; +class SbxArray; +class SdrObject; +class SdrUndoAction; +class SvNumberFormatter; +class SvxMacro; +class SwAutoCompleteWord; +class SwAutoCorrExceptWord; +class SwCellFrame; +class SwCellStyleTable; +class SwCursorShell; +class SwCursor; +class SwDocShell; +class SwDrawView; +class SwEditShell; +class SwFormat; +class SwFormatINetFormat; +class SwFormatRefMark; +class SwFootnoteIdxs; +class SwFootnoteInfo; +class SwEndNoteInfo; +class SwLineNumberInfo; +class SwDBManager; +class SwNodeIndex; +class SwNodeRange; +class SwNumRule; +class SwPagePreviewPrtData; +class SwRootFrame; +class SwRubyListEntry; +class SwSectionFormat; +class SwSectionData; +class SwSelBoxes; +class SwTableAutoFormatTable; +class SwTOXBaseSection; +class SwTabCols; +class SwTable; +class SwTableAutoFormat; +class SwTableBox; +class SwTableBoxFormat; +class SwTableFormat; +class SwTableLineFormat; +class SwTableNode; +class SwTextBlocks; +class SwURLStateChanged; +class SwUnoCursor; +class SwViewShell; +class SwDrawContact; +class SdrView; +class SdrMarkList; +class SwAuthEntry; +class SwLayoutCache; +class IStyleAccess; +struct SwCallMouseEvent; +struct SwDocStat; +struct SwSortOptions; +struct SwDefTOXBase_Impl; +class SwPrintUIOptions; +struct SwConversionArgs; +class IGrammarContact; +class SwRenderData; +class IDocumentUndoRedo; +class IDocumentSettingAccess; +class IDocumentDeviceAccess; +class IDocumentDrawModelAccess; +class IDocumentChartDataProviderAccess; +class IDocumentTimerAccess; +class IDocumentLinksAdministration; +class IDocumentListItems; +class IDocumentListsAccess; +class IDocumentOutlineNodes; +class IDocumentContentOperations; +class IDocumentRedlineAccess; +class IDocumentStatistics; +class IDocumentState; +class IDocumentLayoutAccess; +class IDocumentStylePoolAccess; +class IDocumentExternalData; +class IDocumentMarkAccess; +class SetGetExpFields; +struct SwInsertTableOptions; +enum class SvMacroItemId : sal_uInt16; +enum class SvxFrameDirection; +enum class RndStdIds; + +namespace sw::mark { class MarkManager; } +namespace sw { + enum class RedlineMode; + class MetaFieldManager; + class UndoManager; + class IShellCursorSupplier; + class DocumentSettingManager; + class DocumentDeviceManager; + class DocumentDrawModelManager; + class DocumentChartDataProviderManager; + class DocumentTimerManager; + class DocumentLinksAdministrationManager; + class DocumentListItemsManager; + class DocumentListsManager; + class DocumentOutlineNodesManager; + class DocumentContentOperationsManager; + class DocumentRedlineManager; + class DocumentFieldsManager; + class DocumentStatisticsManager; + class DocumentStateManager; + class DocumentLayoutManager; + class DocumentStylePoolManager; + class DocumentExternalDataManager; +} + +namespace com::sun::star { + namespace container { + class XNameContainer; //< for getXForms()/isXForms()/initXForms() methods + } + namespace embed { class XStorage; } + namespace linguistic2 { class XHyphenatedWord; } + namespace linguistic2 { class XProofreadingIterator; } + namespace linguistic2 { class XSpellChecker1; } + namespace script::vba { class XVBAEventProcessor; } +} + +namespace sfx2 { + class IXmlIdRegistry; +} + +void SetAllScriptItem( SfxItemSet& rSet, const SfxPoolItem& rItem ); + +using SwRubyList = std::vector<std::unique_ptr<SwRubyListEntry>>; + +// Represents the model of a Writer document. +class SW_DLLPUBLIC SwDoc final +{ + friend class ::sw::DocumentContentOperationsManager; + + friend void InitCore(); + friend void FinitCore(); + + // private Member + std::unique_ptr<SwNodes> m_pNodes; //< document content (Nodes Array) + SwAttrPool* mpAttrPool; //< the attribute pool + SwPageDescs m_PageDescs; //< PageDescriptors + Link<bool,void> maOle2Link; //< OLE 2.0-notification + /* @@@MAINTAINABILITY-HORROR@@@ + Timer should not be members of the model + */ + Idle maOLEModifiedIdle; //< Timer for update modified OLE-Objects + SwDBData maDBData; //< database descriptor + OUString msTOIAutoMarkURL; //< URL of table of index AutoMark file + std::vector<OUString> m_PatternNames; //< Array for names of document-templates + css::uno::Reference<css::container::XNameContainer> + mxXForms; //< container with XForms models + mutable css::uno::Reference< css::linguistic2::XProofreadingIterator > m_xGCIterator; + + const std::unique_ptr< ::sw::mark::MarkManager> mpMarkManager; + const std::unique_ptr< ::sw::MetaFieldManager > m_pMetaFieldManager; + const std::unique_ptr< ::sw::DocumentDrawModelManager > m_pDocumentDrawModelManager; + const std::unique_ptr< ::sw::DocumentRedlineManager > m_pDocumentRedlineManager; + const std::unique_ptr< ::sw::DocumentStateManager > m_pDocumentStateManager; + const std::unique_ptr< ::sw::UndoManager > m_pUndoManager; + const std::unique_ptr< ::sw::DocumentSettingManager > m_pDocumentSettingManager; + const std::unique_ptr< ::sw::DocumentChartDataProviderManager > m_pDocumentChartDataProviderManager; + std::unique_ptr< ::sw::DocumentDeviceManager > m_pDeviceAccess; + const std::unique_ptr< ::sw::DocumentTimerManager > m_pDocumentTimerManager; + const std::unique_ptr< ::sw::DocumentLinksAdministrationManager > m_pDocumentLinksAdministrationManager; + const std::unique_ptr< ::sw::DocumentListItemsManager > m_pDocumentListItemsManager; + const std::unique_ptr< ::sw::DocumentListsManager > m_pDocumentListsManager; + const std::unique_ptr< ::sw::DocumentOutlineNodesManager > m_pDocumentOutlineNodesManager; + const std::unique_ptr< ::sw::DocumentContentOperationsManager > m_pDocumentContentOperationsManager; + const std::unique_ptr< ::sw::DocumentFieldsManager > m_pDocumentFieldsManager; + const std::unique_ptr< ::sw::DocumentStatisticsManager > m_pDocumentStatisticsManager; + const std::unique_ptr< ::sw::DocumentLayoutManager > m_pDocumentLayoutManager; + const std::unique_ptr< ::sw::DocumentStylePoolManager > m_pDocumentStylePoolManager; + const std::unique_ptr< ::sw::DocumentExternalDataManager > m_pDocumentExternalDataManager; + + // Pointer + std::unique_ptr<SwFrameFormat> mpDfltFrameFormat; //< Default formats. + std::unique_ptr<SwFrameFormat> mpEmptyPageFormat; //< Format for the default empty page + std::unique_ptr<SwFrameFormat> mpColumnContFormat; //< Format for column container + std::unique_ptr<SwCharFormat> mpDfltCharFormat; + std::unique_ptr<SwTextFormatColl> mpDfltTextFormatColl; //< Defaultformatcollections + std::unique_ptr<SwGrfFormatColl> mpDfltGrfFormatColl; + + std::unique_ptr<SwFrameFormats> mpFrameFormatTable; //< Format table + std::unique_ptr<SwCharFormats> mpCharFormatTable; + std::unique_ptr<SwFrameFormats> mpSpzFrameFormatTable; + std::unique_ptr<SwSectionFormats> mpSectionFormatTable; + std::unique_ptr<SwFrameFormats> mpTableFrameFormatTable; //< For tables + std::unique_ptr<SwTextFormatColls> mpTextFormatCollTable; //< FormatCollections + std::unique_ptr<SwGrfFormatColls> mpGrfFormatCollTable; + + std::unique_ptr<SwTOXTypes> mpTOXTypes; //< Tables/indices + std::unique_ptr<SwDefTOXBase_Impl> mpDefTOXBases; //< defaults of SwTOXBase's + + std::unique_ptr<SwDBManager, o3tl::default_delete<SwDBManager>> m_pOwnDBManager; //< own DBManager + SwDBManager * m_pDBManager; //< DBManager for evaluation of DB-fields. + + SwNumRule *mpOutlineRule; + std::unique_ptr<SwFootnoteInfo> mpFootnoteInfo; + std::unique_ptr<SwEndNoteInfo> mpEndNoteInfo; + std::unique_ptr<SwLineNumberInfo> mpLineNumberInfo; + std::unique_ptr<SwFootnoteIdxs> mpFootnoteIdxs; + + SwDocShell *mpDocShell; //< Ptr to SfxDocShell of Doc. + SfxObjectShellLock mxTmpDocShell; //< A temporary shell that is used to copy OLE-Nodes + + std::unique_ptr<SwAutoCorrExceptWord> mpACEWord; /**< For the automated takeover of + auto-corrected words that are "re-corrected". */ + std::unique_ptr<SwURLStateChanged> mpURLStateChgd; //< SfxClient for changes in INetHistory + std::atomic<SvNumberFormatter*> mpNumberFormatter; //< NumFormatter for tables / fields + + mutable std::unique_ptr<SwNumRuleTable> mpNumRuleTable; //< List of all named NumRules. + + // Hash map to find numrules by name + mutable std::unordered_map<OUString, SwNumRule *> maNumRuleMap; + + std::unique_ptr<SwPagePreviewPrtData> m_pPgPViewPrtData; //< Indenting / spacing for printing of page view. + SwExtTextInput *mpExtInputRing; + + std::unique_ptr<IStyleAccess> mpStyleAccess; //< handling of automatic styles + std::unique_ptr<SwLayoutCache> mpLayoutCache; /**< Layout cache to read and save with the + document for a faster formatting */ + + std::unique_ptr<IGrammarContact> mpGrammarContact; //< for grammar checking in paragraphs during editing + + css::uno::Reference< css::script::vba::XVBAEventProcessor > mxVbaEvents; + css::uno::Reference<css::container::XNameContainer> m_xTemplateToProjectCache; + + /// Table styles (autoformats that are applied with table changes). + std::unique_ptr<SwTableAutoFormatTable> m_pTableStyles; + /// Cell Styles not assigned to a Table Style + std::unique_ptr<SwCellStyleTable> mpCellStyles; +private: + std::unique_ptr< ::sfx2::IXmlIdRegistry > m_pXmlIdRegistry; + + // other + + sal_uInt32 mnRsid; //< current session ID of the document + sal_uInt32 mnRsidRoot; //< session ID when the document was created + + oslInterlockedCount mReferenceCount; + + bool mbDtor : 1; /**< TRUE: is in SwDoc DTOR. + and unfortunately temporarily also in + SwSwgReader::InLayout() when flawed + frames need deletion. */ + bool mbCopyIsMove : 1; //< TRUE: Copy is a hidden Move. + bool mbInReading : 1; //< TRUE: Document is in the process of being read. + bool mbInWriting : 1; //< TRUE: Document is in the process of being written. + bool mbInMailMerge : 1; //< TRUE: Document is in the process of being written by mail merge. + bool mbInXMLImport : 1; //< TRUE: During xml import, attribute portion building is not necessary. + bool mbInWriterfilterImport : 1; //< TRUE: writerfilter import (DOCX,RTF) + bool mbUpdateTOX : 1; //< TRUE: After loading document, update TOX. + bool mbInLoadAsynchron : 1; //< TRUE: Document is in the process of being loaded asynchronously. + bool mbIsAutoFormatRedline : 1; //< TRUE: Redlines are recorded by Autoformat. + bool mbOLEPrtNotifyPending : 1; /**< TRUE: Printer has changed. At creation of View + notification of OLE-Objects PrtOLENotify() is required. */ + bool mbAllOLENotify : 1; //< True: Notification of all objects is required. + bool mbInsOnlyTextGlssry : 1; //< True: insert 'only text' glossary into doc + bool mbContains_MSVBasic : 1; //< True: MS-VBasic exist is in our storage + bool mbClipBoard : 1; //< TRUE: this document represents the clipboard + bool mbColumnSelection : 1; //< TRUE: this content has been created by a column selection (clipboard docs only) + bool mbIsPrepareSelAll : 1; + + enum MissingDictionary { False = -1, Undefined = 0, True = 1 }; + MissingDictionary meDictionaryMissing; + + // true: Document contains at least one anchored object, which is anchored AT_PAGE with a content position. + // Thus, certain adjustment needed during formatting for these kind of anchored objects. + bool mbContainsAtPageObjWithContentAnchor : 1; + + static SwAutoCompleteWord *s_pAutoCompleteWords; //< List of all words for AutoComplete + + // private methods + SwFlyFrameFormat* MakeFlySection_( const SwPosition& rAnchPos, + const SwContentNode& rNode, RndStdIds eRequestId, + const SfxItemSet* pFlyAttrSet, + SwFrameFormat* ); + sal_Int8 SetFlyFrameAnchor( SwFrameFormat& rFlyFormat, SfxItemSet& rSet, bool bNewFrames ); + + typedef SwFormat* (SwDoc:: *FNCopyFormat)( const OUString&, SwFormat*, bool, bool ); + SwFormat* CopyFormat( const SwFormat& rFormat, const SwFormatsBase& rFormatArr, + FNCopyFormat fnCopyFormat, const SwFormat& rDfltFormat ); + void CopyFormatArr( const SwFormatsBase& rSourceArr, SwFormatsBase const & rDestArr, + FNCopyFormat fnCopyFormat, SwFormat& rDfltFormat ); + void CopyPageDescHeaderFooterImpl( bool bCpyHeader, + const SwFrameFormat& rSrcFormat, SwFrameFormat& rDestFormat ); + + SwDoc( const SwDoc &) = delete; + + // Database fields: + void AddUsedDBToList( std::vector<OUString>& rDBNameList, + const std::vector<OUString>& rUsedDBNames ); + void AddUsedDBToList( std::vector<OUString>& rDBNameList, const OUString& rDBName ); + static bool IsNameInArray( const std::vector<OUString>& rOldNames, const OUString& rName ); + void GetAllDBNames( std::vector<OUString>& rAllDBNames ); + static OUString ReplaceUsedDBs( const std::vector<OUString>& rUsedDBNames, + const OUString& rNewName, const OUString& rFormula ); + static std::vector<OUString>& FindUsedDBs( const std::vector<OUString>& rAllDBNames, + const OUString& rFormula, + std::vector<OUString>& rUsedDBNames ); + + void EnsureNumberFormatter(); + + bool UnProtectTableCells( SwTable& rTable ); + + /** Create sub-documents according to the given collection. + If no collection is given, take chapter style of the 1st level. */ + bool SplitDoc( sal_uInt16 eDocType, const OUString& rPath, bool bOutline, + const SwTextFormatColl* pSplitColl, int nOutlineLevel = 0 ); + + // Update charts of given table. + void UpdateCharts_( const SwTable& rTable, SwViewShell const & rVSh ) const; + + static bool SelectNextRubyChars( SwPaM& rPam, SwRubyListEntry& rRubyEntry ); + + // CharTimer calls this method. + void DoUpdateAllCharts(); + DECL_LINK( DoUpdateModifiedOLE, Timer *, void ); + +public: + SwFormat *MakeCharFormat_(const OUString &, SwFormat *, bool, bool ); + SwFormat *MakeFrameFormat_(const OUString &, SwFormat *, bool, bool ); + +private: + SwFormat *MakeTextFormatColl_(const OUString &, SwFormat *, bool, bool ); + +private: + OUString msDocAccTitle; + + void InitTOXTypes(); + +public: + enum DocumentType { + DOCTYPE_NATIVE, + DOCTYPE_MSWORD // This doc model comes from MS Word + }; + DocumentType meDocType; + DocumentType GetDocumentType() const { return meDocType; } + void SetDocumentType( DocumentType eDocType ) { meDocType = eDocType; } + + // Life cycle + SwDoc(); + ~SwDoc(); + + bool IsInDtor() const { return mbDtor; } + + /* @@@MAINTAINABILITY-HORROR@@@ + Implementation details made public. + */ + SwNodes & GetNodes() { return *m_pNodes; } + SwNodes const& GetNodes() const { return *m_pNodes; } + +private: + friend class ::rtl::Reference<SwDoc>; + + /** Acquire a reference to an instance. A caller shall release + the instance by calling 'release' when it is no longer needed. + 'acquire' and 'release' calls need to be balanced. + + @returns + the current reference count of the instance for debugging purposes. + */ + sal_Int32 acquire(); + /** Releases a reference to an instance. A caller has to call + 'release' when a before acquired reference to an instance + is no longer needed. 'acquire' and 'release' calls need to + be balanced. + + @returns + the current reference count of the instance for debugging purposes. + */ + sal_Int32 release(); + /** Returns the current reference count. This method should be used for + debugging purposes. Using it otherwise is a signal of a design flaw. + */ +public: + sal_Int32 getReferenceCount() const; + + // IDocumentSettingAccess + IDocumentSettingAccess const & getIDocumentSettingAccess() const; //The IDocumentSettingAccess interface + IDocumentSettingAccess & getIDocumentSettingAccess(); + ::sw::DocumentSettingManager & GetDocumentSettingManager(); //The implementation of the interface with some additional methods + ::sw::DocumentSettingManager const& GetDocumentSettingManager() const; + sal_uInt32 getRsid() const; + void setRsid( sal_uInt32 nVal ); + sal_uInt32 getRsidRoot() const; + void setRsidRoot( sal_uInt32 nVal ); + + // IDocumentDeviceAccess + IDocumentDeviceAccess const & getIDocumentDeviceAccess() const; + IDocumentDeviceAccess & getIDocumentDeviceAccess(); + + // IDocumentMarkAccess + IDocumentMarkAccess* getIDocumentMarkAccess(); + const IDocumentMarkAccess* getIDocumentMarkAccess() const; + + // IDocumentRedlineAccess + IDocumentRedlineAccess const& getIDocumentRedlineAccess() const; + IDocumentRedlineAccess& getIDocumentRedlineAccess(); + + ::sw::DocumentRedlineManager const& GetDocumentRedlineManager() const; + ::sw::DocumentRedlineManager& GetDocumentRedlineManager(); + + // IDocumentUndoRedo + IDocumentUndoRedo & GetIDocumentUndoRedo(); + IDocumentUndoRedo const& GetIDocumentUndoRedo() const; + + // IDocumentLinksAdministration + IDocumentLinksAdministration const & getIDocumentLinksAdministration() const; + IDocumentLinksAdministration & getIDocumentLinksAdministration(); + + ::sw::DocumentLinksAdministrationManager const & GetDocumentLinksAdministrationManager() const; + ::sw::DocumentLinksAdministrationManager & GetDocumentLinksAdministrationManager(); + + // IDocumentFieldsAccess + IDocumentFieldsAccess const & getIDocumentFieldsAccess() const; + IDocumentFieldsAccess & getIDocumentFieldsAccess(); + + ::sw::DocumentFieldsManager & GetDocumentFieldsManager(); + + // Returns 0 if the field cannot hide para, or a positive integer indicating the field type + // "weight" when several hiding fields' FieldHidesPara() give conflicting results + int FieldCanHideParaWeight(SwFieldIds eFieldId) const; + bool FieldHidesPara(const SwField& rField) const; + + // IDocumentContentOperations + IDocumentContentOperations const & getIDocumentContentOperations() const; + IDocumentContentOperations & getIDocumentContentOperations(); + ::sw::DocumentContentOperationsManager const & GetDocumentContentOperationsManager() const; + ::sw::DocumentContentOperationsManager & GetDocumentContentOperationsManager(); + + bool UpdateParRsid( SwTextNode *pTextNode, sal_uInt32 nVal = 0 ); + void UpdateRsid( const SwPaM &rRg, sal_Int32 nLen ); + + // IDocumentStylePoolAccess + IDocumentStylePoolAccess const & getIDocumentStylePoolAccess() const; + IDocumentStylePoolAccess & getIDocumentStylePoolAccess(); + + // SwLineNumberInfo + const SwLineNumberInfo& GetLineNumberInfo() const; + void SetLineNumberInfo(const SwLineNumberInfo& rInfo); + + // IDocumentStatistics + IDocumentStatistics const & getIDocumentStatistics() const; + IDocumentStatistics & getIDocumentStatistics(); + + ::sw::DocumentStatisticsManager const & GetDocumentStatisticsManager() const; + ::sw::DocumentStatisticsManager & GetDocumentStatisticsManager(); + + // IDocumentState + IDocumentState const & getIDocumentState() const; + IDocumentState & getIDocumentState(); + + // IDocumentDrawModelAccess + void AddDrawUndo( std::unique_ptr<SdrUndoAction> ); + IDocumentDrawModelAccess const & getIDocumentDrawModelAccess() const; + IDocumentDrawModelAccess & getIDocumentDrawModelAccess(); + + ::sw::DocumentDrawModelManager const & GetDocumentDrawModelManager() const; + ::sw::DocumentDrawModelManager & GetDocumentDrawModelManager(); + + // IDocumentLayoutAccess + IDocumentLayoutAccess const & getIDocumentLayoutAccess() const; + IDocumentLayoutAccess & getIDocumentLayoutAccess(); + + ::sw::DocumentLayoutManager const & GetDocumentLayoutManager() const; + ::sw::DocumentLayoutManager & GetDocumentLayoutManager(); + + // IDocumentTimerAccess + // Our own 'IdleTimer' calls the following method + IDocumentTimerAccess const & getIDocumentTimerAccess() const; + IDocumentTimerAccess & getIDocumentTimerAccess(); + + // IDocumentChartDataProviderAccess + IDocumentChartDataProviderAccess const & getIDocumentChartDataProviderAccess() const; + IDocumentChartDataProviderAccess & getIDocumentChartDataProviderAccess(); + + // IDocumentListItems + IDocumentListItems const & getIDocumentListItems() const; + IDocumentListItems & getIDocumentListItems(); + + // IDocumentOutlineNodes + IDocumentOutlineNodes const & getIDocumentOutlineNodes() const; + IDocumentOutlineNodes & getIDocumentOutlineNodes(); + + // IDocumentListsAccess + IDocumentListsAccess const & getIDocumentListsAccess() const; + IDocumentListsAccess & getIDocumentListsAccess(); + + //IDocumentExternalData + IDocumentExternalData const & getIDocumentExternalData() const; + IDocumentExternalData & getIDocumentExternalData(); + + //End of Interfaces + + void setDocAccTitle( const OUString& rTitle ) { msDocAccTitle = rTitle; } + const OUString& getDocAccTitle() const { return msDocAccTitle; } + + // INextInterface here + DECL_LINK(CalcFieldValueHdl, EditFieldInfo*, void); + + // OLE ??? + bool IsOLEPrtNotifyPending() const { return mbOLEPrtNotifyPending; } + inline void SetOLEPrtNotifyPending( bool bSet = true ); + void PrtOLENotify( bool bAll ); // All or only marked + + bool IsPrepareSelAll() const { return mbIsPrepareSelAll; } + void SetPrepareSelAll() { mbIsPrepareSelAll = true; } + + void SetContainsAtPageObjWithContentAnchor( const bool bFlag ) + { + mbContainsAtPageObjWithContentAnchor = bFlag; + } + bool DoesContainAtPageObjWithContentAnchor() + { + return mbContainsAtPageObjWithContentAnchor; + } + + /** Returns positions of all FlyFrames in the document. + If a Pam-Pointer is passed the FlyFrames attached to paragraphs + have to be surrounded completely by css::awt::Selection. + ( Start < Pos < End ) !!! + (Required for Writers.) */ + SwPosFlyFrames GetAllFlyFormats( const SwPaM*, + bool bDrawAlso, + bool bAsCharAlso = false ) const; + + SwFlyFrameFormat *MakeFlyFrameFormat (const OUString &rFormatName, SwFrameFormat *pDerivedFrom); + SwDrawFrameFormat *MakeDrawFrameFormat(const OUString &rFormatName, SwFrameFormat *pDerivedFrom); + + // From now on this interface has to be used for Flys. + // pAnchorPos must be set, if they are not attached to pages AND + // Anchor is not already set at valid ContentPos + // in FlySet/FrameFormat. + /* new parameter bCalledFromShell + + true: An existing adjust item at pAnchorPos is propagated to + the content node of the new fly section. That propagation only + takes place if there is no adjust item in the paragraph style + for the new fly section. + + false: no propagation + */ + SwFlyFrameFormat* MakeFlySection( RndStdIds eAnchorType, + const SwPosition* pAnchorPos, + const SfxItemSet* pSet = nullptr, + SwFrameFormat *pParent = nullptr, + bool bCalledFromShell = false ); + SwFlyFrameFormat* MakeFlyAndMove( const SwPaM& rPam, const SfxItemSet& rSet, + const SwSelBoxes* pSelBoxes, + SwFrameFormat *pParent ); + + // Helper that checks for unique items for DrawingLayer items of type NameOrIndex + // and evtl. corrects that items to ensure unique names for that type. This call may + // modify/correct entries inside of the given SfxItemSet, and it will apply a name to + // the items in question (what is essential to make the named slots associated with + // these items work for the UNO API and thus e.g. for ODF import/export) + void CheckForUniqueItemForLineFillNameOrIndex(SfxItemSet& rSet); + + bool SetFlyFrameAttr( SwFrameFormat& rFlyFormat, SfxItemSet& rSet ); + + bool SetFrameFormatToFly( SwFrameFormat& rFlyFormat, SwFrameFormat& rNewFormat, + SfxItemSet* pSet = nullptr, bool bKeepOrient = false ); + void SetFlyFrameTitle( SwFlyFrameFormat& rFlyFrameFormat, + const OUString& sNewTitle ); + void SetFlyFrameDescription( SwFlyFrameFormat& rFlyFrameFormat, + const OUString& sNewDescription ); + + // Footnotes + // Footnote information + const SwFootnoteInfo& GetFootnoteInfo() const { return *mpFootnoteInfo; } + void SetFootnoteInfo(const SwFootnoteInfo& rInfo); + const SwEndNoteInfo& GetEndNoteInfo() const { return *mpEndNoteInfo; } + void SetEndNoteInfo(const SwEndNoteInfo& rInfo); + SwFootnoteIdxs& GetFootnoteIdxs() { return *mpFootnoteIdxs; } + const SwFootnoteIdxs& GetFootnoteIdxs() const { return *mpFootnoteIdxs; } + /// change footnotes in range + bool SetCurFootnote( const SwPaM& rPam, const OUString& rNumStr, + bool bIsEndNote ); + + /** Operations on the content of the document e.g. + spell-checking/hyphenating/word-counting + */ + css::uno::Any + Spell( SwPaM&, css::uno::Reference< css::linguistic2::XSpellChecker1 > const &, + sal_uInt16* pPageCnt, sal_uInt16* pPageSt, bool bGrammarCheck, + SwRootFrame const* pLayout, // for grammar-check + SwConversionArgs *pConvArgs = nullptr ) const; + + css::uno::Reference< css::linguistic2::XHyphenatedWord > + Hyphenate( SwPaM *pPam, const Point &rCursorPos, + sal_uInt16* pPageCnt, sal_uInt16* pPageSt ); + + // count words in pam + static void CountWords( const SwPaM& rPaM, SwDocStat& rStat ); + + // Glossary Document + bool IsInsOnlyTextGlossary() const { return mbInsOnlyTextGlssry; } + + void Summary( SwDoc* pExtDoc, sal_uInt8 nLevel, sal_uInt8 nPara, bool bImpress ); + + void ChangeAuthorityData(const SwAuthEntry* pNewData); + + bool IsInHeaderFooter( const SwNodeIndex& rIdx ) const; + SvxFrameDirection GetTextDirection( const SwPosition& rPos, + const Point* pPt = nullptr ) const; + bool IsInVerticalText( const SwPosition& rPos ) const; + + // Database and DB-Manager + void SetDBManager( SwDBManager* pNewMgr ) { m_pDBManager = pNewMgr; } + SwDBManager* GetDBManager() const { return m_pDBManager; } + void ChangeDBFields( const std::vector<OUString>& rOldNames, + const OUString& rNewName ); + void SetInitDBFields(bool b); + + // Find out which databases are used by fields. + void GetAllUsedDB( std::vector<OUString>& rDBNameList, + const std::vector<OUString>* pAllDBNames = nullptr ); + + void ChgDBData( const SwDBData& rNewData ); + SwDBData const & GetDBData(); + const SwDBData& GetDBDesc(); + + // Some helper functions + OUString GetUniqueGrfName() const; + OUString GetUniqueOLEName() const; + OUString GetUniqueFrameName() const; + OUString GetUniqueShapeName() const; + OUString GetUniqueDrawObjectName() const; + + o3tl::sorted_vector<SwRootFrame*> GetAllLayouts(); + + void SetFlyName( SwFlyFrameFormat& rFormat, const OUString& rName ); + const SwFlyFrameFormat* FindFlyByName( const OUString& rName, SwNodeType nNdTyp = SwNodeType::NONE ) const; + + static void GetGrfNms( const SwFlyFrameFormat& rFormat, OUString* pGrfName, OUString* pFltName ); + + // Set a valid name for all Flys that have none (Called by Readers after reading). + void SetAllUniqueFlyNames(); + + /** Reset attributes. All TextHints and (if completely selected) all hard- + formatted stuff (auto-formats) are removed. + Introduce new optional parameter <bSendDataChangedEvents> in order to + control, if the side effect "send data changed events" is triggered or not. */ + void ResetAttrs( const SwPaM &rRg, + bool bTextAttr = true, + const std::set<sal_uInt16> &rAttrs = std::set<sal_uInt16>(), + const bool bSendDataChangedEvents = true, + SwRootFrame const* pLayout = nullptr); + void RstTextAttrs(const SwPaM &rRg, bool bInclRefToxMark = false, + bool bExactRange = false, SwRootFrame const* pLayout = nullptr); + + /** Set attribute in given format.1y + * If Undo is enabled, the old values is added to the Undo history. */ + void SetAttr( const SfxPoolItem&, SwFormat& ); + /** Set attribute in given format.1y + * If Undo is enabled, the old values is added to the Undo history. */ + void SetAttr( const SfxItemSet&, SwFormat& ); + + // method to reset a certain attribute at the given format + void ResetAttrAtFormat( const sal_uInt16 nWhichId, + SwFormat& rChangedFormat ); + + /** Set attribute as new default attribute in current document. + If Undo is activated, the old one is listed in Undo-History. */ + void SetDefault( const SfxPoolItem& ); + void SetDefault( const SfxItemSet& ); + + // Query default attribute in this document. + const SfxPoolItem& GetDefault( sal_uInt16 nFormatHint ) const; + template<class T> const T& GetDefault( TypedWhichId<T> nWhich ) const + { + return static_cast<const T&>(GetDefault(sal_uInt16(nWhich))); + } + + // Do not expand text attributes. + bool DontExpandFormat( const SwPosition& rPos, bool bFlag = true ); + + // Formats + const SwFrameFormats* GetFrameFormats() const { return mpFrameFormatTable.get(); } + SwFrameFormats* GetFrameFormats() { return mpFrameFormatTable.get(); } + const SwCharFormats* GetCharFormats() const { return mpCharFormatTable.get();} + SwCharFormats* GetCharFormats() { return mpCharFormatTable.get();} + + // LayoutFormats (frames, DrawObjects), sometimes const sometimes not + const SwFrameFormats* GetSpzFrameFormats() const { return mpSpzFrameFormatTable.get(); } + SwFrameFormats* GetSpzFrameFormats() { return mpSpzFrameFormatTable.get(); } + + const SwFrameFormat *GetDfltFrameFormat() const { return mpDfltFrameFormat.get(); } + SwFrameFormat *GetDfltFrameFormat() { return mpDfltFrameFormat.get(); } + const SwFrameFormat *GetEmptyPageFormat() const { return mpEmptyPageFormat.get(); } + SwFrameFormat *GetEmptyPageFormat() { return mpEmptyPageFormat.get(); } + const SwFrameFormat *GetColumnContFormat() const{ return mpColumnContFormat.get(); } + SwFrameFormat *GetColumnContFormat() { return mpColumnContFormat.get(); } + const SwCharFormat *GetDfltCharFormat() const { return mpDfltCharFormat.get();} + SwCharFormat *GetDfltCharFormat() { return mpDfltCharFormat.get();} + + // @return the interface of the management of (auto)styles + IStyleAccess& GetIStyleAccess() { return *mpStyleAccess; } + + // Remove all language dependencies from all existing formats + void RemoveAllFormatLanguageDependencies(); + + static SwFormat* FindFormatByName(const SwFormatsBase& rFormatArr, const OUString& rName); + + SwFrameFormat *MakeFrameFormat(const OUString &rFormatName, SwFrameFormat *pDerivedFrom, + bool bBroadcast = false, bool bAuto = true); + void DelFrameFormat( SwFrameFormat *pFormat, bool bBroadcast = false ); + SwFrameFormat* FindFrameFormatByName( const OUString& rName ) const; + + SwCharFormat *MakeCharFormat(const OUString &rFormatName, SwCharFormat *pDerivedFrom, + bool bBroadcast = false ); + void DelCharFormat(size_t nFormat, bool bBroadcast = false); + void DelCharFormat(SwCharFormat const * pFormat, bool bBroadcast = false); + SwCharFormat* FindCharFormatByName( const OUString& rName ) const + { return static_cast<SwCharFormat*>(FindFormatByName( *mpCharFormatTable, rName )); } + + // Formatcollections (styles) + // TXT + const SwTextFormatColl* GetDfltTextFormatColl() const { return mpDfltTextFormatColl.get(); } + SwTextFormatColl* GetDfltTextFormatColl() { return mpDfltTextFormatColl.get(); } + const SwTextFormatColls *GetTextFormatColls() const { return mpTextFormatCollTable.get(); } + SwTextFormatColls *GetTextFormatColls() { return mpTextFormatCollTable.get(); } + SwTextFormatColl *MakeTextFormatColl( const OUString &rFormatName, + SwTextFormatColl *pDerivedFrom, + bool bBroadcast = false); + SwConditionTextFormatColl* MakeCondTextFormatColl( const OUString &rFormatName, + SwTextFormatColl *pDerivedFrom, + bool bBroadcast = false); + void DelTextFormatColl(size_t nFormat, bool bBroadcast = false); + void DelTextFormatColl( SwTextFormatColl const * pColl, bool bBroadcast = false ); + /** Add 4th optional parameter <bResetListAttrs>. + 'side effect' of <SetTextFormatColl> with <bReset = true> is that the hard + attributes of the affected text nodes are cleared, except the break + attribute, the page description attribute and the list style attribute. + The new parameter <bResetListAttrs> indicates, if the list attributes + (list style, restart at and restart with) are cleared as well in case + that <bReset = true> and the paragraph style has a list style attribute set. */ + bool SetTextFormatColl(const SwPaM &rRg, SwTextFormatColl *pFormat, + const bool bReset = true, + const bool bResetListAttrs = false, + SwRootFrame const* pLayout = nullptr); + SwTextFormatColl* FindTextFormatCollByName( const OUString& rName ) const + { return static_cast<SwTextFormatColl*>(FindFormatByName( *mpTextFormatCollTable, rName )); } + + void ChkCondColls(); + + const SwGrfFormatColl* GetDfltGrfFormatColl() const { return mpDfltGrfFormatColl.get(); } + SwGrfFormatColl* GetDfltGrfFormatColl() { return mpDfltGrfFormatColl.get(); } + const SwGrfFormatColls *GetGrfFormatColls() const { return mpGrfFormatCollTable.get(); } + SwGrfFormatColl *MakeGrfFormatColl(const OUString &rFormatName, + SwGrfFormatColl *pDerivedFrom); + + // Table formatting + const SwFrameFormats* GetTableFrameFormats() const { return mpTableFrameFormatTable.get(); } + SwFrameFormats* GetTableFrameFormats() { return mpTableFrameFormatTable.get(); } + size_t GetTableFrameFormatCount( bool bUsed ) const; + SwFrameFormat& GetTableFrameFormat(size_t nFormat, bool bUsed ) const; + SwTableFormat* MakeTableFrameFormat(const OUString &rFormatName, SwFrameFormat *pDerivedFrom); + void DelTableFrameFormat( SwTableFormat* pFormat ); + SwTableFormat* FindTableFormatByName( const OUString& rName, bool bAll = false ) const; + + /** Access to frames. + Iterate over Flys - for Basic-Collections. */ + size_t GetFlyCount( FlyCntType eType, bool bIgnoreTextBoxes = false ) const; + SwFrameFormat* GetFlyNum(size_t nIdx, FlyCntType eType, bool bIgnoreTextBoxes = false ); + std::vector<SwFrameFormat const*> GetFlyFrameFormats( + FlyCntType eType, + bool bIgnoreTextBoxes); + + // Copy formats in own arrays and return them. + SwFrameFormat *CopyFrameFormat ( const SwFrameFormat& ); + SwCharFormat *CopyCharFormat( const SwCharFormat& ); + SwTextFormatColl* CopyTextColl( const SwTextFormatColl& rColl ); + SwGrfFormatColl* CopyGrfColl( const SwGrfFormatColl& rColl ); + + // Replace all styles with those from rSource. + void ReplaceStyles( const SwDoc& rSource, bool bIncludePageStyles = true ); + + // Replace all property defaults with those from rSource. + void ReplaceDefaults( const SwDoc& rSource ); + + // Replace all compatibility options with those from rSource. + void ReplaceCompatibilityOptions( const SwDoc& rSource ); + + /** Replace all user defined document properties with xSourceDocProps. + Convenience function used by ReplaceDocumentProperties to skip some UNO calls. + */ + void ReplaceUserDefinedDocumentProperties( const css::uno::Reference< css::document::XDocumentProperties >& xSourceDocProps ); + + /** Replace document properties with those from rSource. + + This includes the user defined document properties! + */ + void ReplaceDocumentProperties(const SwDoc& rSource, bool mailMerge = false); + + // Query if style (paragraph- / character- / frame- / page-) is used. + bool IsUsed( const SwModify& ) const; + /// Query if table style is used. + bool IsUsed( const SwTableAutoFormat& ) const; + static bool IsUsed( const SwNumRule& ); + + // Set name of newly loaded document template. + size_t SetDocPattern(const OUString& rPatternName); + + // @return name of document template. Can be 0! + const OUString* GetDocPattern(size_t nPos) const; + + // travel over PaM Ring + bool InsertGlossary( SwTextBlocks& rBlock, const OUString& rEntry, + SwPaM& rPaM, SwCursorShell* pShell = nullptr); + + /** get the set of printable pages for the XRenderable API by + evaluating the respective settings (see implementation) */ + static void CalculatePagesForPrinting( const SwRootFrame& rLayout, SwRenderData &rData, const SwPrintUIOptions &rOptions, bool bIsPDFExport, + sal_Int32 nDocPageCount ); + static void UpdatePagesForPrintingWithPostItData( SwRenderData &rData, const SwPrintUIOptions &rOptions, + sal_Int32 nDocPageCount ); + static void CalculatePagePairsForProspectPrinting( const SwRootFrame& rLayout, SwRenderData &rData, const SwPrintUIOptions &rOptions, + sal_Int32 nDocPageCount ); + static void CalculateNonBlankPages( const SwRootFrame& rLayout, sal_uInt16& nDocPageCount, sal_uInt16& nActualPage ); + + // PageDescriptor interface. + size_t GetPageDescCnt() const { return m_PageDescs.size(); } + const SwPageDesc& GetPageDesc(const size_t i) const { return *m_PageDescs[i]; } + SwPageDesc& GetPageDesc(size_t const i) { return *m_PageDescs[i]; } + SwPageDesc* FindPageDesc(const OUString& rName, size_t* pPos = nullptr) const; + // Just searches the pointer in the m_PageDescs vector! + bool ContainsPageDesc(const SwPageDesc *pDesc, size_t* pPos) const; + + /** Copy the complete PageDesc - beyond document and "deep"! + Optionally copying of PoolFormatId, -HlpId can be prevented. */ + void CopyPageDesc( const SwPageDesc& rSrcDesc, SwPageDesc& rDstDesc, + bool bCopyPoolIds = true ); + + /** Copy header (with contents) from SrcFormat to DestFormat + (can also be copied into other document). */ + void CopyHeader( const SwFrameFormat& rSrcFormat, SwFrameFormat& rDestFormat ) + { CopyPageDescHeaderFooterImpl( true, rSrcFormat, rDestFormat ); } + + /** Copy footer (with contents) from SrcFormat to DestFormat. + (can also be copied into other document). */ + void CopyFooter( const SwFrameFormat& rSrcFormat, SwFrameFormat& rDestFormat ) + { CopyPageDescHeaderFooterImpl( false, rSrcFormat, rDestFormat ); } + + // For Reader + void ChgPageDesc( const OUString & rName, const SwPageDesc& ); + void ChgPageDesc( size_t i, const SwPageDesc& ); + void DelPageDesc( const OUString & rName, bool bBroadcast = false); + void DelPageDesc( size_t i, bool bBroadcast = false ); + void PreDelPageDesc(SwPageDesc const * pDel); + SwPageDesc* MakePageDesc(const OUString &rName, const SwPageDesc* pCpy = nullptr, + bool bRegardLanguage = true, + bool bBroadcast = false); + void BroadcastStyleOperation(const OUString& rName, SfxStyleFamily eFamily, + SfxHintId nOp); + + /** The html import sometimes overwrites the page sizes set in + the page descriptions. This function is used to correct this. */ + void CheckDefaultPageFormat(); + + // Methods for tables/indices + static sal_uInt16 GetCurTOXMark( const SwPosition& rPos, SwTOXMarks& ); + void DeleteTOXMark( const SwTOXMark* pTOXMark ); + const SwTOXMark& GotoTOXMark( const SwTOXMark& rCurTOXMark, + SwTOXSearch eDir, bool bInReadOnly ); + + // Insert/Renew table/index + SwTOXBaseSection* InsertTableOf( const SwPosition& rPos, + const SwTOXBase& rTOX, + const SfxItemSet* pSet = nullptr, + bool bExpand = false, + SwRootFrame const* pLayout = nullptr); + SwTOXBaseSection* InsertTableOf( const SwPaM& aPam, + const SwTOXBase& rTOX, + const SfxItemSet* pSet = nullptr, + bool bExpand = false, + SwRootFrame const* pLayout = nullptr ); + void InsertTableOf( sal_uLong nSttNd, sal_uLong nEndNd, + const SwTOXBase& rTOX, + const SfxItemSet* pSet ); + static SwTOXBase* GetCurTOX( const SwPosition& rPos ); + static const SwAttrSet& GetTOXBaseAttrSet(const SwTOXBase& rTOX); + + bool DeleteTOX( const SwTOXBase& rTOXBase, bool bDelNodes ); + OUString GetUniqueTOXBaseName( const SwTOXType& rType, + const OUString& sChkStr ) const; + + bool SetTOXBaseName(const SwTOXBase& rTOXBase, const OUString& rName); + + // After reading file update all tables/indices + void SetUpdateTOX( bool bFlag ) { mbUpdateTOX = bFlag; } + bool IsUpdateTOX() const { return mbUpdateTOX; } + + const OUString& GetTOIAutoMarkURL() const {return msTOIAutoMarkURL;} + void SetTOIAutoMarkURL(const OUString& rSet) {msTOIAutoMarkURL = rSet;} + + bool IsInReading() const { return mbInReading; } + void SetInReading( bool bNew ) { mbInReading = bNew; } + + bool IsInWriting() const { return mbInWriting; } + void SetInWriting(bool bNew) { mbInWriting = bNew; } + + bool IsInMailMerge() const { return mbInMailMerge; } + void SetInMailMerge( bool bNew ) { mbInMailMerge = bNew; } + + bool IsClipBoard() const { return mbClipBoard; } + // N.B.: must be called right after constructor! (@see GetXmlIdRegistry) + void SetClipBoard( bool bNew ) { mbClipBoard = bNew; } + + bool IsColumnSelection() const { return mbColumnSelection; } + void SetColumnSelection( bool bNew ) { mbColumnSelection = bNew; } + + bool IsInXMLImport() const { return mbInXMLImport; } + void SetInXMLImport( bool bNew ) { mbInXMLImport = bNew; } + bool IsInWriterfilterImport() const { return mbInWriterfilterImport; } + void SetInWriterfilterImport(bool const b) { mbInWriterfilterImport = b; } + + // Manage types of tables/indices + sal_uInt16 GetTOXTypeCount( TOXTypes eTyp ) const; + const SwTOXType* GetTOXType( TOXTypes eTyp, sal_uInt16 nId ) const; + const SwTOXType* InsertTOXType( const SwTOXType& rTyp ); + const SwTOXTypes& GetTOXTypes() const { return *mpTOXTypes; } + + const SwTOXBase* GetDefaultTOXBase( TOXTypes eTyp, bool bCreate ); + void SetDefaultTOXBase(const SwTOXBase& rBase); + + // Key for management of index. + void GetTOIKeys(SwTOIKeyType eTyp, std::vector<OUString>& rArr, + SwRootFrame const& rLayout) const; + + // Sort table text. + bool SortTable(const SwSelBoxes& rBoxes, const SwSortOptions&); + bool SortText(const SwPaM&, const SwSortOptions&); + + // Correct the SwPosition-Objects that are registered with the document + // e. g. Bookmarks or tables/indices. + // If bMoveCursor is set move Cursor too. + + // Set everything in rOldNode on rNewPos + Offset. + void CorrAbs( + const SwNodeIndex& rOldNode, + const SwPosition& rNewPos, + const sal_Int32 nOffset = 0, + bool bMoveCursor = false ); + + // Set everything in the range of [rStartNode, rEndNode] to rNewPos. + static void CorrAbs( + const SwNodeIndex& rStartNode, + const SwNodeIndex& rEndNode, + const SwPosition& rNewPos, + bool bMoveCursor = false ); + + // Set everything in this range from rRange to rNewPos. + static void CorrAbs( + const SwPaM& rRange, + const SwPosition& rNewPos, + bool bMoveCursor = false ); + + // Set everything in rOldNode to relative Pos. + void CorrRel( + const SwNodeIndex& rOldNode, + const SwPosition& rNewPos, + const sal_Int32 nOffset = 0, + bool bMoveCursor = false ); + + // Query / set rules for Outline. + SwNumRule* GetOutlineNumRule() const + { + return mpOutlineRule; + } + void SetOutlineNumRule( const SwNumRule& rRule ); + void PropagateOutlineRule(); + + // Outline - promote / demote. + bool OutlineUpDown(const SwPaM& rPam, short nOffset, SwRootFrame const* pLayout = nullptr); + + /// Outline - move up / move down. + bool MoveOutlinePara( const SwPaM& rPam, SwOutlineNodes::difference_type nOffset); + + bool GotoOutline(SwPosition& rPos, const OUString& rName, SwRootFrame const* = nullptr) const; + + /** Accept changes of outline styles for OutlineRule. + @param bResetIndentAttrs Optional parameter - default value false: + If <bResetIndentAttrs> equals true, the indent attributes "before text" + and "first line indent" are additionally reset at the provided PaM, if + the list style makes use of the new list level attributes. + @param bCreateNewList indicates if a new list is created by applying the given list style. + @param sContinuedListId If bCreateNewList is false, may contain the + list Id of a list which has to be continued by applying the given list style + + @return the set ListId if bSetItem is true */ + OUString SetNumRule( const SwPaM&, + const SwNumRule&, + bool bCreateNewList, + SwRootFrame const* pLayout = nullptr, + const OUString& sContinuedListId = OUString(), + bool bSetItem = true, + const bool bResetIndentAttrs = false ); + void SetCounted(const SwPaM&, bool bCounted, SwRootFrame const* pLayout); + + void MakeUniqueNumRules(const SwPaM & rPaM); + + void SetNumRuleStart( const SwPosition& rPos, bool bFlag = true ); + void SetNodeNumStart( const SwPosition& rPos, sal_uInt16 nStt ); + + // sw_redlinehide: may set rPos to different node (the one with the NumRule) + static SwNumRule* GetNumRuleAtPos(SwPosition& rPos, SwRootFrame const* pLayout = nullptr); + + const SwNumRuleTable& GetNumRuleTable() const { return *mpNumRuleTable; } + + /** + Add numbering rule to document. + + @param pRule rule to add + */ + void AddNumRule(SwNumRule * pRule); + + // add optional parameter <eDefaultNumberFormatPositionAndSpaceMode> + sal_uInt16 MakeNumRule( const OUString &rName, + const SwNumRule* pCpy = nullptr, + bool bBroadcast = false, + const SvxNumberFormat::SvxNumPositionAndSpaceMode eDefaultNumberFormatPositionAndSpaceMode = + SvxNumberFormat::LABEL_WIDTH_AND_POSITION ); + sal_uInt16 FindNumRule( const OUString& rName ) const; + SwNumRule* FindNumRulePtr( const OUString& rName ) const; + + // Deletion only possible if Rule is not used! + bool RenameNumRule(const OUString & aOldName, const OUString & aNewName, + bool bBroadcast = false); + bool DelNumRule( const OUString& rName, bool bBroadCast = false ); + OUString GetUniqueNumRuleName( const OUString* pChkStr = nullptr, bool bAutoNum = true ) const; + + void UpdateNumRule(); // Update all invalids. + void ChgNumRuleFormats( const SwNumRule& rRule ); + bool ReplaceNumRule( const SwPosition& rPos, const OUString& rOldRule, + const OUString& rNewRule ); + + // Goto next/previous on same level. + static bool GotoNextNum( SwPosition&, SwRootFrame const* pLayout, + bool bOverUpper = true, + sal_uInt8* pUpper = nullptr, sal_uInt8* pLower = nullptr ); + static bool GotoPrevNum( SwPosition&, SwRootFrame const* pLayout, + bool bOverUpper = true ); + + /** Searches for a text node with a numbering rule. + + add optional parameter <bInvestigateStartNode> + add output parameter <sListId> + + \param rPos position to start search + \param bForward - true: search forward + - false: search backward + \param bNum - true: search for enumeration + - false: search for itemize + \param bOutline - true: search for outline numbering rule + - false: search for non-outline numbering rule + \param nNonEmptyAllowed number of non-empty paragraphs allowed between + rPos and found paragraph + + @param sListId + output parameter - in case a list style is found, <sListId> holds the + list id, to which the text node belongs, which applies the found list style. + + @param bInvestigateStartNode + input parameter - boolean, indicating, if start node, determined by given + start position has to be investigated or not. + */ + const SwNumRule * SearchNumRule(const SwPosition & rPos, + const bool bForward, + const bool bNum, + const bool bOutline, + int nNonEmptyAllowed, + OUString& sListId, + SwRootFrame const* pLayout, + const bool bInvestigateStartNode = false ); + + // Paragraphs without numbering but with indents. + bool NoNum( const SwPaM& ); + + // Delete, splitting of numbering list. + void DelNumRules(const SwPaM&, SwRootFrame const* pLayout = nullptr); + + // Invalidates all numrules + void InvalidateNumRules(); + + bool NumUpDown(const SwPaM&, bool bDown, SwRootFrame const* pLayout = nullptr); + + /** Move selected paragraphs (not only numberings) + according to offsets. (if negative: go to doc start). */ + bool MoveParagraph(SwPaM&, long nOffset, bool bIsOutlMv = false); + bool MoveParagraphImpl(SwPaM&, long nOffset, bool bIsOutlMv, SwRootFrame const*); + + bool NumOrNoNum( const SwNodeIndex& rIdx, bool bDel = false); + + void StopNumRuleAnimations( OutputDevice* ); + + /** Insert new table at position @param rPos (will be inserted before Node!). + For AutoFormat at input: columns have to be set at predefined width. + The array holds the positions of the columns (not their widths). + new @param bCalledFromShell: + true: called from shell -> propagate existing adjust item at + rPos to every new cell. A existing adjust item in the table + heading or table contents paragraph style prevent that + propagation. + false: do not propagate + */ + const SwTable* InsertTable( const SwInsertTableOptions& rInsTableOpts, // HeadlineNoBorder + const SwPosition& rPos, sal_uInt16 nRows, + sal_uInt16 nCols, sal_Int16 eAdjust, + const SwTableAutoFormat* pTAFormat = nullptr, + const std::vector<sal_uInt16> *pColArr = nullptr, + bool bCalledFromShell = false, + bool bNewModel = true ); + + // If index is in a table, return TableNode, else 0. + SwTableNode* IsIdxInTable( const SwNodeIndex& rIdx ); + inline const SwTableNode* IsIdxInTable( const SwNodeIndex& rIdx ) const; + + // Create a balanced table out of the selected range. + const SwTable* TextToTable( const SwInsertTableOptions& rInsTableOpts, // HeadlineNoBorder, + const SwPaM& rRange, sal_Unicode cCh, + sal_Int16 eAdjust, + const SwTableAutoFormat* ); + + // text to table conversion - API support + const SwTable* TextToTable( const std::vector< std::vector<SwNodeRange> >& rTableNodes ); + + bool TableToText( const SwTableNode* pTableNd, sal_Unicode cCh ); + + // Create columns / rows in table. + void InsertCol( const SwCursor& rCursor, + sal_uInt16 nCnt = 1, bool bBehind = true ); + bool InsertCol( const SwSelBoxes& rBoxes, + sal_uInt16 nCnt = 1, bool bBehind = true ); + void InsertRow( const SwCursor& rCursor, + sal_uInt16 nCnt = 1, bool bBehind = true ); + bool InsertRow( const SwSelBoxes& rBoxes, + sal_uInt16 nCnt = 1, bool bBehind = true ); + + // Delete Columns/Rows in table. + bool DeleteRowCol( const SwSelBoxes& rBoxes, bool bColumn = false ); + void DeleteRow( const SwCursor& rCursor ); + void DeleteCol( const SwCursor& rCursor ); + + // Split / concatenate boxes in table. + bool SplitTable( const SwSelBoxes& rBoxes, bool bVert, + sal_uInt16 nCnt, bool bSameHeight = false ); + + TableMergeErr MergeTable( SwPaM& rPam ); + OUString GetUniqueTableName() const; + bool IsInsTableFormatNum() const; + bool IsInsTableChangeNumFormat() const; + bool IsInsTableAlignNum() const; + bool IsSplitVerticalByDefault() const; + void SetSplitVerticalByDefault(bool value); + + // From FEShell (for Undo and BModified). + static void GetTabCols( SwTabCols &rFill, const SwCellFrame* pBoxFrame ); + void SetTabCols( const SwTabCols &rNew, bool bCurRowOnly, + const SwCellFrame* pBoxFrame ); + static void GetTabRows( SwTabCols &rFill, const SwCellFrame* pBoxFrame ); + void SetTabRows( const SwTabCols &rNew, bool bCurColOnly, + const SwCellFrame* pBoxFrame ); + + // Direct access for UNO. + void SetTabCols(SwTable& rTab, const SwTabCols &rNew, const SwTabCols &rOld, + const SwTableBox *pStart, bool bCurRowOnly); + + void SetRowsToRepeat( SwTable &rTable, sal_uInt16 nSet ); + + /// AutoFormat for table/table selection. + /// @param bResetDirect Reset direct formatting that might be applied to the cells. + bool SetTableAutoFormat(const SwSelBoxes& rBoxes, const SwTableAutoFormat& rNew, bool bResetDirect = false, bool isSetStyleName = false); + + // Query attributes. + bool GetTableAutoFormat( const SwSelBoxes& rBoxes, SwTableAutoFormat& rGet ); + + /// Return the available table styles. + SwTableAutoFormatTable& GetTableStyles(); + const SwTableAutoFormatTable& GetTableStyles() const + { + return const_cast<SwDoc*>(this)->GetTableStyles(); + } + /// Counts table styles without triggering lazy-load of them. + bool HasTableStyles() const { return m_pTableStyles != nullptr; } + // Create a new table style. Tracked by Undo. + SwTableAutoFormat* MakeTableStyle(const OUString& rName, bool bBroadcast = false); + // Delete table style named rName. Tracked by undo. + std::unique_ptr<SwTableAutoFormat> DelTableStyle(const OUString& rName, bool bBroadcast = false); + // Change (replace) a table style named rName. Tracked by undo. + void ChgTableStyle(const OUString& rName, const SwTableAutoFormat& rNewFormat); + + const SwCellStyleTable& GetCellStyles() const { return *mpCellStyles; } + SwCellStyleTable& GetCellStyles() { return *mpCellStyles; } + + void AppendUndoForInsertFromDB( const SwPaM& rPam, bool bIsTable ); + + bool SetColRowWidthHeight( SwTableBox& rCurrentBox, TableChgWidthHeightType eType, + SwTwips nAbsDiff, SwTwips nRelDiff ); + SwTableBoxFormat* MakeTableBoxFormat(); + SwTableLineFormat* MakeTableLineFormat(); + + // helper function: cleanup before checking number value + bool IsNumberFormat( const OUString& rString, sal_uInt32& F_Index, double& fOutNumber); + // Check if box has numerical value. Change format of box if required. + void ChkBoxNumFormat( SwTableBox& rCurrentBox, bool bCallUpdate ); + void SetTableBoxFormulaAttrs( SwTableBox& rBox, const SfxItemSet& rSet ); + void ClearBoxNumAttrs( const SwNodeIndex& rNode ); + void ClearLineNumAttrs( SwPosition const & rPos ); + + bool InsCopyOfTable( SwPosition& rInsPos, const SwSelBoxes& rBoxes, + const SwTable* pCpyTable, bool bCpyName = false, + bool bCorrPos = false ); + + void UnProtectCells( const OUString& rTableName ); + bool UnProtectCells( const SwSelBoxes& rBoxes ); + void UnProtectTables( const SwPaM& rPam ); + bool HasTableAnyProtection( const SwPosition* pPos, + const OUString* pTableName, + bool* pFullTableProtection ); + + // Split table at baseline position, i.e. create a new table. + bool SplitTable( const SwPosition& rPos, SplitTable_HeadlineOption eMode, + bool bCalcNewSize ); + + /** And vice versa: rPos must be in the table that remains. The flag indicates + whether the current table is merged with the one before or behind it. */ + bool MergeTable( const SwPosition& rPos, bool bWithPrev, + sal_uInt16 nMode = 0 ); + + // Make charts of given table update. + void UpdateCharts( const OUString &rName ) const; + + // Update all charts, for that exists any table. + void UpdateAllCharts() { DoUpdateAllCharts(); } + + // Table is renamed and refreshes charts. + void SetTableName( SwFrameFormat& rTableFormat, const OUString &rNewName ); + + // @return the reference in document that is set for name. + const SwFormatRefMark* GetRefMark( const OUString& rName ) const; + + // @return RefMark via index - for UNO. + const SwFormatRefMark* GetRefMark( sal_uInt16 nIndex ) const; + + /** @return names of all references that are set in document. + If array pointer is 0 return only whether a RefMark is set in document. */ + sal_uInt16 GetRefMarks( std::vector<OUString>* = nullptr ) const; + + // Insert label. If a FlyFormat is created, return it. + SwFlyFrameFormat* InsertLabel( const SwLabelType eType, const OUString &rText, const OUString& rSeparator, + const OUString& rNumberingSeparator, + const bool bBefore, const sal_uInt16 nId, const sal_uLong nIdx, + const OUString& rCharacterStyle, + const bool bCpyBrd ); + SwFlyFrameFormat* InsertDrawLabel( + const OUString &rText, const OUString& rSeparator, const OUString& rNumberSeparator, + const sal_uInt16 nId, const OUString& rCharacterStyle, SdrObject& rObj ); + + // Query attribute pool. + const SwAttrPool& GetAttrPool() const { return *mpAttrPool; } + SwAttrPool& GetAttrPool() { return *mpAttrPool; } + + // Search for an EditShell. + SwEditShell const * GetEditShell() const; + SwEditShell* GetEditShell(); + ::sw::IShellCursorSupplier * GetIShellCursorSupplier(); + + // OLE 2.0-notification. + void SetOle2Link(const Link<bool,void>& rLink) {maOle2Link = rLink;} + const Link<bool,void>& GetOle2Link() const {return maOle2Link;} + + // insert section (the ODF kind of section, not the nodesarray kind) + SwSection * InsertSwSection(SwPaM const& rRange, SwSectionData &, + std::pair<SwTOXBase const*, sw::RedlineMode> const* pTOXBase, + SfxItemSet const*const pAttr, bool const bUpdate = true); + static sal_uInt16 IsInsRegionAvailable( const SwPaM& rRange, + const SwNode** ppSttNd = nullptr ); + static SwSection* GetCurrSection( const SwPosition& rPos ); + SwSectionFormats& GetSections() { return *mpSectionFormatTable; } + const SwSectionFormats& GetSections() const { return *mpSectionFormatTable; } + SwSectionFormat *MakeSectionFormat(); + void DelSectionFormat( SwSectionFormat *pFormat, bool bDelNodes = false ); + void UpdateSection(size_t const nSect, SwSectionData &, + SfxItemSet const*const = nullptr, bool const bPreventLinkUpdate = false); + OUString GetUniqueSectionName( const OUString* pChkStr = nullptr ) const; + + /* @@@MAINTAINABILITY-HORROR@@@ + The model should not have anything to do with a shell. + Unnecessary compile/link time dependency. + */ + + // Pointer to SfxDocShell from Doc. Can be 0!! + SwDocShell* GetDocShell() { return mpDocShell; } + const SwDocShell* GetDocShell() const { return mpDocShell; } + void SetDocShell( SwDocShell* pDSh ); + + /** in case during copying of embedded object a new shell is created, + it should be set here and cleaned later */ + void SetTmpDocShell( SfxObjectShellLock rLock ) { mxTmpDocShell = rLock; } + const SfxObjectShellLock& GetTmpDocShell() const { return mxTmpDocShell; } + + // For Autotexts? (text modules) They have only one SVPersist at their disposal. + SfxObjectShell* GetPersist() const; + + // Pointer to storage of SfxDocShells. Can be 0!!! + css::uno::Reference< css::embed::XStorage > GetDocStorage(); + + // Query / set flag indicating if document is loaded asynchronously at this moment. + bool IsInLoadAsynchron() const { return mbInLoadAsynchron; } + void SetInLoadAsynchron( bool bFlag ) { mbInLoadAsynchron = bFlag; } + + // For Drag&Move: (e.g. allow "moving" of RefMarks) + bool IsCopyIsMove() const { return mbCopyIsMove; } + void SetCopyIsMove( bool bFlag ) { mbCopyIsMove = bFlag; } + + SwDrawContact* GroupSelection( SdrView& ); + void UnGroupSelection( SdrView& ); + bool DeleteSelection( SwDrawView& ); + + // Invalidates OnlineSpell-WrongLists. + void SpellItAgainSam( bool bInvalid, bool bOnlyWrong, bool bSmartTags ); + void InvalidateAutoCompleteFlag(); + + void SetCalcFieldValueHdl(Outliner* pOutliner); + + // Query if URL was visited. + // Query via Doc, if only a Bookmark has been given. + // In this case the document name has to be set in front. + bool IsVisitedURL( const OUString& rURL ); + + // Save current values for automatic registration of exceptions in Autocorrection. + void SetAutoCorrExceptWord( std::unique_ptr<SwAutoCorrExceptWord> pNew ); + SwAutoCorrExceptWord* GetAutoCorrExceptWord() { return mpACEWord.get(); } + void DeleteAutoCorrExceptWord(); + + const SwFormatINetFormat* FindINetAttr( const OUString& rName ) const; + + // Call into intransparent Basic; expect possible Return String. + void ExecMacro( const SvxMacro& rMacro, OUString* pRet, SbxArray* pArgs ); + + // Call into intransparent Basic / JavaScript. + sal_uInt16 CallEvent( SvMacroItemId nEvent, const SwCallMouseEvent& rCallEvent, + bool bChkPtr = false ); + + /** Adjust left margin via object bar (similar to adjustment of numerations). + One can either change the margin "by" adding or subtracting a given + offset or set it "to" this position (bModulus = true). */ + void MoveLeftMargin(const SwPaM& rPam, bool bRight, bool bModulus, + SwRootFrame const* pLayout = nullptr); + + // Query NumberFormatter. + SvNumberFormatter* GetNumberFormatter(bool bCreate = true) + { + if (bCreate) + EnsureNumberFormatter(); + return mpNumberFormatter; + } + + const SvNumberFormatter* GetNumberFormatter(bool bCreate = true) const + { + return const_cast<SwDoc*>(this)->GetNumberFormatter(bCreate); + } + + bool HasInvisibleContent() const; + // delete invisible content, like hidden sections and paragraphs + bool RemoveInvisibleContent(); + // restore the invisible content if it's available on the undo stack + bool RestoreInvisibleContent(); + + bool ConvertFieldsToText(SwRootFrame const& rLayout); + + // Create sub-documents according to given collection. + // If no collection is given, use chapter styles for 1st level. + bool GenerateGlobalDoc( const OUString& rPath, + const SwTextFormatColl* pSplitColl ); + bool GenerateGlobalDoc( const OUString& rPath, int nOutlineLevel ); + bool GenerateHTMLDoc( const OUString& rPath, + const SwTextFormatColl* pSplitColl ); + bool GenerateHTMLDoc( const OUString& rPath, int nOutlineLevel ); + + // Compare two documents. + long CompareDoc( const SwDoc& rDoc ); + + // Merge two documents. + long MergeDoc( const SwDoc& rDoc ); + + bool IsAutoFormatRedline() const { return mbIsAutoFormatRedline; } + void SetAutoFormatRedline( bool bFlag ) { mbIsAutoFormatRedline = bFlag; } + + // For AutoFormat: with Undo/Redlining. + void SetTextFormatCollByAutoFormat( const SwPosition& rPos, sal_uInt16 nPoolId, + const SfxItemSet* pSet ); + void SetFormatItemByAutoFormat( const SwPaM& rPam, const SfxItemSet& ); + + // Only for SW-textbloxks! Does not pay any attention to layout! + void ClearDoc(); // Deletes all content! + + // Query /set data for PagePreview. + const SwPagePreviewPrtData* GetPreviewPrtData() const { return m_pPgPViewPrtData.get(); } + + // If pointer == 0 destroy pointer in document. + // Else copy object. + // Pointer is not transferred to ownership by document! + void SetPreviewPrtData( const SwPagePreviewPrtData* pData ); + + /** update all modified OLE-Objects. The modification is called over the + StarOne - Interface */ + void SetOLEObjModified(); + + // Uno - Interfaces + std::shared_ptr<SwUnoCursor> CreateUnoCursor( const SwPosition& rPos, bool bTableCursor = false ); + + // FeShell - Interfaces + // !!! These assume always an existing layout !!! + bool ChgAnchor( const SdrMarkList& _rMrkList, + RndStdIds _eAnchorType, + const bool _bSameOnly, + const bool _bPosCorr ); + + void SetRowHeight( const SwCursor& rCursor, const SwFormatFrameSize &rNew ); + static std::unique_ptr<SwFormatFrameSize> GetRowHeight( const SwCursor& rCursor ); + void SetRowSplit( const SwCursor& rCursor, const SwFormatRowSplit &rNew ); + static std::unique_ptr<SwFormatRowSplit> GetRowSplit( const SwCursor& rCursor ); + + /// Adjustment of Rowheights. Determine via bTstOnly if more than one row is selected. + /// bOptimize: distribute current table height, instead of using the largest row. + /// Call again without bOptimize to ensure equal height in case some row's content didn't fit. + bool BalanceRowHeight( const SwCursor& rCursor, bool bTstOnly, const bool bOptimize ); + void SetRowBackground( const SwCursor& rCursor, const SvxBrushItem &rNew ); + static bool GetRowBackground( const SwCursor& rCursor, std::unique_ptr<SvxBrushItem>& rToFill ); + void SetTabBorders( const SwCursor& rCursor, const SfxItemSet& rSet ); + void SetTabLineStyle( const SwCursor& rCursor, + const Color* pColor, bool bSetLine, + const editeng::SvxBorderLine* pBorderLine ); + static void GetTabBorders( const SwCursor& rCursor, SfxItemSet& rSet ); + void SetBoxAttr( const SwCursor& rCursor, const SfxPoolItem &rNew ); + /** + Retrieves a box attribute from the given cursor. + + @return Whether the property is set over the current box selection. + + @remarks A property is 'set' if it's set to the same value over all boxes in the current selection. + The property value is retrieved from the first box in the current selection. It is then compared to + the values of the same property over any other boxes in the selection; if any value is different from + that of the first box, the property is unset (and false is returned). + */ + static bool GetBoxAttr( const SwCursor& rCursor, std::unique_ptr<SfxPoolItem>& rToFill ); + void SetBoxAlign( const SwCursor& rCursor, sal_uInt16 nAlign ); + static sal_uInt16 GetBoxAlign( const SwCursor& rCursor ); + /// Adjusts selected cell widths in such a way, that their content does not need to be wrapped (if possible). + /// bBalance evenly re-distributes the available space regardless of content or wrapping. + /// bNoShrink keeps table size the same by distributing excess space proportionately. + void AdjustCellWidth( const SwCursor& rCursor, const bool bBalance, const bool bNoShrink ); + + SwChainRet Chainable( const SwFrameFormat &rSource, const SwFrameFormat &rDest ); + SwChainRet Chain( SwFrameFormat &rSource, const SwFrameFormat &rDest ); + void Unchain( SwFrameFormat &rFormat ); + + // For Copy/Move from FrameShell. + SdrObject* CloneSdrObj( const SdrObject&, bool bMoveWithinDoc = false, + bool bInsInPage = true ); + + // FeShell - Interface end + + // Interface for TextInputData - for text input of Chinese and Japanese. + SwExtTextInput* CreateExtTextInput( const SwPaM& rPam ); + void DeleteExtTextInput( SwExtTextInput* pDel ); + SwExtTextInput* GetExtTextInput( const SwNode& rNd, + sal_Int32 nContentPos = -1) const; + SwExtTextInput* GetExtTextInput() const; + + // Interface for access to AutoComplete-List. + static SwAutoCompleteWord& GetAutoCompleteWords() { return *s_pAutoCompleteWords; } + + bool ContainsMSVBasic() const { return mbContains_MSVBasic; } + void SetContainsMSVBasic( bool bFlag ) { mbContains_MSVBasic = bFlag; } + + // Interface for the list of Ruby - texts/attributes + static sal_uInt16 FillRubyList( const SwPaM& rPam, SwRubyList& rList ); + void SetRubyList( const SwPaM& rPam, const SwRubyList& rList ); + + void ReadLayoutCache( SvStream& rStream ); + void WriteLayoutCache( SvStream& rStream ); + SwLayoutCache* GetLayoutCache() const { return mpLayoutCache.get(); } + + /** Checks if any of the text node contains hidden characters. + Used for optimization. Changing the view option 'view hidden text' + has to trigger a reformatting only if some of the text is hidden. + */ + bool ContainsHiddenChars() const; + + IGrammarContact* getGrammarContact() const { return mpGrammarContact.get(); } + + /** Marks/Unmarks a list level of a certain list + + levels of a certain lists are marked now + + @param sListId list Id of the list whose level has to be marked/unmarked + @param nListLevel level to mark + @param bValue - true mark the level + - false unmark the level + */ + void MarkListLevel( const OUString& sListId, + const int nListLevel, + const bool bValue ); + + // Change a format undoable. + void ChgFormat(SwFormat & rFormat, const SfxItemSet & rSet); + + void RenameFormat(SwFormat & rFormat, const OUString & sNewName, + bool bBroadcast = false); + + // Change a TOX undoable. + void ChangeTOX(SwTOXBase & rTOX, const SwTOXBase & rNew); + + /** + Returns a textual description of a PaM. + + @param rPaM the PaM to describe + + If rPaM only spans one paragraph the result is: + + '<text in the PaM>' + + <text in the PaM> is shortened to nUndoStringLength characters. + + If rPaM spans more than one paragraph the result is: + + paragraphs (STR_PARAGRAPHS) + + @return the textual description of rPaM + */ + static OUString GetPaMDescr(const SwPaM & rPaM); + + static bool IsFirstOfNumRuleAtPos(const SwPosition & rPos, SwRootFrame const& rLayout); + + // access methods for XForms model(s) + + // access container for XForms model; will be NULL if !isXForms() + const css::uno::Reference<css::container::XNameContainer>& + getXForms() const { return mxXForms;} + + css::uno::Reference< css::linguistic2::XProofreadingIterator > const & GetGCIterator() const; + + // #i31958# is this an XForms document? + bool isXForms() const; + + // #i31958# initialize XForms models; turn this into an XForms document + void initXForms( bool bCreateDefaultModel ); + + // #i113606# for disposing XForms + void disposeXForms( ); + + //Update all the page masters + void SetDefaultPageMode(bool bSquaredPageMode); + bool IsSquaredPageMode() const; + + css::uno::Reference< css::script::vba::XVBAEventProcessor > const & GetVbaEventProcessor(); + void SetVBATemplateToProjectCache( css::uno::Reference< css::container::XNameContainer > const & xCache ) { m_xTemplateToProjectCache = xCache; }; + const css::uno::Reference< css::container::XNameContainer >& GetVBATemplateToProjectCache() const { return m_xTemplateToProjectCache; }; + ::sfx2::IXmlIdRegistry& GetXmlIdRegistry(); + ::sw::MetaFieldManager & GetMetaFieldManager(); + ::sw::UndoManager & GetUndoManager(); + ::sw::UndoManager const& GetUndoManager() const; + + SfxObjectShell* CreateCopy(bool bCallInitNew, bool bEmpty) const; + SwNodeIndex AppendDoc(const SwDoc& rSource, sal_uInt16 nStartPageNumber, + bool bDeletePrevious, int physicalPageOffset, + const sal_uLong nDocNo); + + /** + * Dumps the entire nodes structure to the given destination (file nodes.xml in the current directory by default) + */ + void dumpAsXml(xmlTextWriterPtr = nullptr) const; + + std::set<Color> GetDocColors(); + std::vector< std::weak_ptr<SwUnoCursor> > mvUnoCursorTable; + + // Remove expired UnoCursor weak pointers the document keeps to notify about document death. + void cleanupUnoCursorTable() const + { + auto & rTable = const_cast<SwDoc*>(this)->mvUnoCursorTable; + // In most cases we'll remove most of the elements. + rTable.erase( std::remove_if(rTable.begin(), + rTable.end(), + [] (std::weak_ptr<SwUnoCursor> const & x) { return x.expired(); }), + rTable.end()); + } + + /** + * @param bSkipStart don't actually start the jobs, just check + * @returns true if new background checking jobs were started + */ + bool StartGrammarChecking( bool bSkipStart = false ); + + /// Use to notify if the dictionary can be found for a single content portion (has to be called for all portions) + void SetMissingDictionaries( bool bIsMissing ); + /// Returns true if no dictionary can be found for any content + bool IsDictionaryMissing() const { return meDictionaryMissing == MissingDictionary::True; } + +private: + // Copies master header to left / first one, if necessary - used by ChgPageDesc(). + void CopyMasterHeader(const SwPageDesc &rChged, const SwFormatHeader &rHead, SwPageDesc &pDesc, bool bLeft, bool bFirst); + // Copies master footer to left / first one, if necessary - used by ChgPageDesc(). + void CopyMasterFooter(const SwPageDesc &rChged, const SwFormatFooter &rFoot, SwPageDesc &pDesc, bool bLeft, bool bFirst); + +}; + +// This method is called in Dtor of SwDoc and deletes cache of ContourObjects. +void ClrContourCache(); + +inline const SwTableNode* SwDoc::IsIdxInTable( const SwNodeIndex& rIdx ) const +{ + return const_cast<SwDoc*>(this)->IsIdxInTable( rIdx ); +} + +inline void SwDoc::SetOLEPrtNotifyPending( bool bSet ) +{ + mbOLEPrtNotifyPending = bSet; + if( !bSet ) + mbAllOLENotify = false; +} + +bool sw_GetPostIts( IDocumentFieldsAccess const * pIDFA, SetGetExpFields * pSrtLst ); + +#endif //_DOC_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |