sw/inc/doc.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #ifndef INCLUDED_SW_INC_DOC_HXX
  20 #define INCLUDED_SW_INC_DOC_HXX
  21
  22 // SwDoc interfaces
  23 #include <o3tl/deleter.hxx>
  24 #include <vcl/idle.hxx>
  25 #include "swdllapi.h"
  26 #include "swtypes.hxx"
  27 #include "toxe.hxx"
  28 #include "flyenum.hxx"
  29 #include "flypos.hxx"
  30 #include "swdbdata.hxx"
  31 #include <sfx2/objsh.hxx>
  32 #include <svl/style.hxx>
  33 #include <editeng/numitem.hxx>
  34 #include "tox.hxx"
  35 #include "frmfmt.hxx"
  36 #include "charfmt.hxx"
  37 #include "docary.hxx"
  38 #include "pagedesc.hxx"
  39 #include "tblenum.hxx"
  40 #include "ndarr.hxx"
  41 #include "ndtyp.hxx"
  42 #include <atomic>
  43 #include <memory>
  44 #include <set>
  45 #include <unordered_map>
  46 #include <vector>
  47
  48 namespace editeng { class SvxBorderLine; }
  49
  50 class SwExtTextInput;
  51 class EditFieldInfo;
  52 class Outliner;
  53 class OutputDevice;
  54 class Point;
  55 class SbxArray;
  56 class SdrObject;
  57 class SdrUndoAction;
  58 class SvNumberFormatter;
  59 class SvxMacro;
  60 class SwAutoCompleteWord;
  61 class SwAutoCorrExceptWord;
  62 class SwCellFrame;
  63 class SwCellStyleTable;
  64 class SwCursorShell;
  65 class SwCursor;
  66 class SwDocShell;
  67 class SwDrawView;
  68 class SwEditShell;
  69 class SwFormat;
  70 class SwFormatINetFormat;
  71 class SwFormatRefMark;
  72 class SwFootnoteIdxs;
  73 class SwFootnoteInfo;
  74 class SwEndNoteInfo;
  75 class SwLineNumberInfo;
  76 class SwDBManager;
  77 class SwNodeIndex;
  78 class SwNodeRange;
  79 class SwNumRule;
  80 class SwPagePreviewPrtData;
  81 class SwRootFrame;
  82 class SwRubyListEntry;
  83 class SwSectionFormat;
  84 class SwSectionData;
  85 class SwSelBoxes;
  86 class SwTableAutoFormatTable;
  87 class SwTOXBaseSection;
  88 class SwTabCols;
  89 class SwTable;
  90 class SwTableAutoFormat;
  91 class SwTableBox;
  92 class SwTableBoxFormat;
  93 class SwTableFormat;
  94 class SwTableLineFormat;
  95 class SwTableNode;
  96 class SwTextBlocks;
  97 class SwURLStateChanged;
  98 class SwUnoCursor;
  99 class SwViewShell;
 100 class SwDrawContact;
 101 class SdrView;
 102 class SdrMarkList;
 103 class SwAuthEntry;
 104 class SwLayoutCache;
 105 class IStyleAccess;
 106 struct SwCallMouseEvent;
 107 struct SwDocStat;
 108 struct SwSortOptions;
 109 struct SwDefTOXBase_Impl;
 110 class SwPrintUIOptions;
 111 struct SwConversionArgs;
 112 class IGrammarContact;
 113 class SwRenderData;
 114 class IDocumentUndoRedo;
 115 class IDocumentSettingAccess;
 116 class IDocumentDeviceAccess;
 117 class IDocumentDrawModelAccess;
 118 class IDocumentChartDataProviderAccess;
 119 class IDocumentTimerAccess;
 120 class IDocumentLinksAdministration;
 121 class IDocumentListItems;
 122 class IDocumentListsAccess;
 123 class IDocumentOutlineNodes;
 124 class IDocumentContentOperations;
 125 class IDocumentRedlineAccess;
 126 class IDocumentStatistics;
 127 class IDocumentState;
 128 class IDocumentLayoutAccess;
 129 class IDocumentStylePoolAccess;
 130 class IDocumentExternalData;
 131 class IDocumentMarkAccess;
 132 class SetGetExpFields;
 133 struct SwInsertTableOptions;
 134 enum class SvMacroItemId : sal_uInt16;
 135 enum class SvxFrameDirection;
 136 enum class RndStdIds;
 137
 138 namespace sw { namespace mark {
 139     class MarkManager;
 140 }}
 141 namespace sw {
 142     enum class RedlineMode;
 143     class MetaFieldManager;
 144     class UndoManager;
 145     class IShellCursorSupplier;
 146     class DocumentSettingManager;
 147     class DocumentDeviceManager;
 148     class DocumentDrawModelManager;
 149     class DocumentChartDataProviderManager;
 150     class DocumentTimerManager;
 151     class DocumentLinksAdministrationManager;
 152     class DocumentListItemsManager;
 153     class DocumentListsManager;
 154     class DocumentOutlineNodesManager;
 155     class DocumentContentOperationsManager;
 156     class DocumentRedlineManager;
 157     class DocumentFieldsManager;
 158     class DocumentStatisticsManager;
 159     class DocumentStateManager;
 160     class DocumentLayoutManager;
 161     class DocumentStylePoolManager;
 162     class DocumentExternalDataManager;
 163 }
 164
 165 namespace com { namespace sun { namespace star {
 166 namespace container {
 167     class XNameContainer; //< for getXForms()/isXForms()/initXForms() methods
 168 }
 169 namespace embed { class XStorage; }
 170 namespace linguistic2 { class XHyphenatedWord; }
 171 namespace linguistic2 { class XProofreadingIterator; }
 172 namespace linguistic2 { class XSpellChecker1; }
 173 namespace script { namespace vba { class XVBAEventProcessor; } }
 174 }}}
 175
 176 namespace sfx2 {
 177     class IXmlIdRegistry;
 178 }
 179
 180 void SetAllScriptItem( SfxItemSet& rSet, const SfxPoolItem& rItem );
 181
 182 using SwRubyList = std::vector<std::unique_ptr<SwRubyListEntry>>;
 183
 184 // Represents the model of a Writer document.
 185 class SW_DLLPUBLIC SwDoc final
 186 {
 187     friend class ::sw::DocumentContentOperationsManager;
 188
 189     friend void InitCore();
 190     friend void FinitCore();
 191
 192     // private Member
 193     std::unique_ptr<SwNodes> m_pNodes;    //< document content (Nodes Array)
 194     SwAttrPool*              mpAttrPool;  //< the attribute pool
 195     SwPageDescs              m_PageDescs; //< PageDescriptors
 196     Link<bool,void>          maOle2Link;  //< OLE 2.0-notification
 197     /* @@@MAINTAINABILITY-HORROR@@@
 198        Timer should not be members of the model
 199     */
 200     Idle       maOLEModifiedIdle;        //< Timer for update modified OLE-Objects
 201     SwDBData    maDBData;                //< database descriptor
 202     OUString    msTOIAutoMarkURL;        //< URL of table of index AutoMark file
 203     std::vector<OUString> m_PatternNames; //< Array for names of document-templates
 204     css::uno::Reference<css::container::XNameContainer>
 205         mxXForms;                        //< container with XForms models
 206     mutable css::uno::Reference< css::linguistic2::XProofreadingIterator > m_xGCIterator;
 207
 208     const std::unique_ptr< ::sw::mark::MarkManager> mpMarkManager;
 209     const std::unique_ptr< ::sw::MetaFieldManager > m_pMetaFieldManager;
 210     const std::unique_ptr< ::sw::DocumentDrawModelManager > m_pDocumentDrawModelManager;
 211     const std::unique_ptr< ::sw::DocumentRedlineManager > m_pDocumentRedlineManager;
 212     const std::unique_ptr< ::sw::DocumentStateManager > m_pDocumentStateManager;
 213     const std::unique_ptr< ::sw::UndoManager > m_pUndoManager;
 214     const std::unique_ptr< ::sw::DocumentSettingManager > m_pDocumentSettingManager;
 215     const std::unique_ptr< ::sw::DocumentChartDataProviderManager > m_pDocumentChartDataProviderManager;
 216     std::unique_ptr< ::sw::DocumentDeviceManager > m_pDeviceAccess;
 217     const std::unique_ptr< ::sw::DocumentTimerManager > m_pDocumentTimerManager;
 218     const std::unique_ptr< ::sw::DocumentLinksAdministrationManager > m_pDocumentLinksAdministrationManager;
 219     const std::unique_ptr< ::sw::DocumentListItemsManager > m_pDocumentListItemsManager;
 220     const std::unique_ptr< ::sw::DocumentListsManager > m_pDocumentListsManager;
 221     const std::unique_ptr< ::sw::DocumentOutlineNodesManager > m_pDocumentOutlineNodesManager;
 222     const std::unique_ptr< ::sw::DocumentContentOperationsManager > m_pDocumentContentOperationsManager;
 223     const std::unique_ptr< ::sw::DocumentFieldsManager > m_pDocumentFieldsManager;
 224     const std::unique_ptr< ::sw::DocumentStatisticsManager > m_pDocumentStatisticsManager;
 225     const std::unique_ptr< ::sw::DocumentLayoutManager > m_pDocumentLayoutManager;
 226     const std::unique_ptr< ::sw::DocumentStylePoolManager > m_pDocumentStylePoolManager;
 227     const std::unique_ptr< ::sw::DocumentExternalDataManager > m_pDocumentExternalDataManager;
 228
 229     // Pointer
 230     std::unique_ptr<SwFrameFormat>     mpDfltFrameFormat;     //< Default formats.
 231     std::unique_ptr<SwFrameFormat>     mpEmptyPageFormat;     //< Format for the default empty page
 232     std::unique_ptr<SwFrameFormat>     mpColumnContFormat;    //< Format for column container
 233     std::unique_ptr<SwCharFormat>      mpDfltCharFormat;
 234     std::unique_ptr<SwTextFormatColl>  mpDfltTextFormatColl;  //< Defaultformatcollections
 235     std::unique_ptr<SwGrfFormatColl>   mpDfltGrfFormatColl;
 236
 237     std::unique_ptr<SwFrameFormats>    mpFrameFormatTable;    //< Format table
 238     std::unique_ptr<SwCharFormats>     mpCharFormatTable;
 239     std::unique_ptr<SwFrameFormats>    mpSpzFrameFormatTable;
 240     std::unique_ptr<SwSectionFormats>  mpSectionFormatTable;
 241     std::unique_ptr<SwFrameFormats>    mpTableFrameFormatTable; //< For tables
 242     std::unique_ptr<SwTextFormatColls> mpTextFormatCollTable;   //< FormatCollections
 243     std::unique_ptr<SwGrfFormatColls>  mpGrfFormatCollTable;
 244
 245     std::unique_ptr<SwTOXTypes>        mpTOXTypes;              //< Tables/indices
 246     std::unique_ptr<SwDefTOXBase_Impl> mpDefTOXBases;           //< defaults of SwTOXBase's
 247
 248     std::unique_ptr<SwDBManager, o3tl::default_delete<SwDBManager>> m_pOwnDBManager; //< own DBManager
 249     SwDBManager * m_pDBManager; //< DBManager for evaluation of DB-fields.
 250
 251     SwNumRule       *mpOutlineRule;
 252     std::unique_ptr<SwFootnoteInfo>   mpFootnoteInfo;
 253     std::unique_ptr<SwEndNoteInfo>    mpEndNoteInfo;
 254     std::unique_ptr<SwLineNumberInfo> mpLineNumberInfo;
 255     std::unique_ptr<SwFootnoteIdxs>   mpFootnoteIdxs;
 256
 257     SwDocShell      *mpDocShell;                   //< Ptr to SfxDocShell of Doc.
 258     SfxObjectShellLock mxTmpDocShell;              //< A temporary shell that is used to copy OLE-Nodes
 259
 260     std::unique_ptr<SwAutoCorrExceptWord> mpACEWord;               /**< For the automated takeover of
 261                                                    auto-corrected words that are "re-corrected". */
 262     std::unique_ptr<SwURLStateChanged> mpURLStateChgd;             //< SfxClient for changes in INetHistory
 263     std::atomic<SvNumberFormatter*> mpNumberFormatter;             //< NumFormatter for tables / fields
 264
 265     mutable std::unique_ptr<SwNumRuleTable> mpNumRuleTable;     //< List of all named NumRules.
 266
 267     // Hash map to find numrules by name
 268     mutable std::unordered_map<OUString, SwNumRule *> maNumRuleMap;
 269
 270     std::unique_ptr<SwPagePreviewPrtData> m_pPgPViewPrtData; //< Indenting / spacing for printing of page view.
 271     SwExtTextInput  *mpExtInputRing;
 272
 273     std::unique_ptr<IStyleAccess>  mpStyleAccess;                //< handling of automatic styles
 274     std::unique_ptr<SwLayoutCache> mpLayoutCache;                /**< Layout cache to read and save with the
 275                                                                     document for a faster formatting */
 276
 277     std::unique_ptr<IGrammarContact> mpGrammarContact;             //< for grammar checking in paragraphs during editing
 278
 279     css::uno::Reference< css::script::vba::XVBAEventProcessor > mxVbaEvents;
 280     css::uno::Reference<css::container::XNameContainer> m_xTemplateToProjectCache;
 281
 282     /// Table styles (autoformats that are applied with table changes).
 283     std::unique_ptr<SwTableAutoFormatTable> m_pTableStyles;
 284     /// Cell Styles not assigned to a Table Style
 285     std::unique_ptr<SwCellStyleTable> mpCellStyles;
 286 private:
 287     std::unique_ptr< ::sfx2::IXmlIdRegistry > m_pXmlIdRegistry;
 288
 289     // other
 290
 291     sal_uInt32  mnRsid;              //< current session ID of the document
 292     sal_uInt32  mnRsidRoot;          //< session ID when the document was created
 293
 294     oslInterlockedCount  mReferenceCount;
 295
 296     bool mbDtor                  : 1;    /**< TRUE: is in SwDoc DTOR.
 297                                                and unfortunately temporarily also in
 298                                                SwSwgReader::InLayout() when flawed
 299                                                frames need deletion. */
 300     bool mbCopyIsMove            : 1;    //< TRUE: Copy is a hidden Move.
 301     bool mbInReading             : 1;    //< TRUE: Document is in the process of being read.
 302     bool mbInMailMerge           : 1;    //< TRUE: Document is in the process of being written by mail merge.
 303     bool mbInXMLImport           : 1;    //< TRUE: During xml import, attribute portion building is not necessary.
 304     bool mbUpdateTOX             : 1;    //< TRUE: After loading document, update TOX.
 305     bool mbInLoadAsynchron       : 1;    //< TRUE: Document is in the process of being loaded asynchronously.
 306     bool mbIsAutoFormatRedline   : 1;    //< TRUE: Redlines are recorded by Autoformat.
 307     bool mbOLEPrtNotifyPending   : 1;    /**< TRUE: Printer has changed. At creation of View
 308                                                 notification of OLE-Objects PrtOLENotify() is required. */
 309     bool mbAllOLENotify          : 1;    //< True: Notification of all objects is required.
 310     bool mbInsOnlyTextGlssry     : 1;    //< True: insert 'only text' glossary into doc
 311     bool mbContains_MSVBasic     : 1;    //< True: MS-VBasic exist is in our storage
 312     bool mbClipBoard             : 1;    //< TRUE: this document represents the clipboard
 313     bool mbColumnSelection       : 1;    //< TRUE: this content has been created by a column selection (clipboard docs only)
 314     bool mbIsPrepareSelAll       : 1;
 315
 316     enum MissingDictionary { False = -1, Undefined = 0, True = 1 };
 317     MissingDictionary meDictionaryMissing;
 318
 319     // true: Document contains at least one anchored object, which is anchored AT_PAGE with a content position.
 320     //       Thus, certain adjustment needed during formatting for these kind of anchored objects.
 321     bool mbContainsAtPageObjWithContentAnchor : 1;
 322
 323     static SwAutoCompleteWord *s_pAutoCompleteWords;  //< List of all words for AutoComplete
 324
 325     // private methods
 326     SwFlyFrameFormat* MakeFlySection_( const SwPosition& rAnchPos,
 327                                 const SwContentNode& rNode, RndStdIds eRequestId,
 328                                 const SfxItemSet* pFlyAttrSet,
 329                                 SwFrameFormat* );
 330     sal_Int8 SetFlyFrameAnchor( SwFrameFormat& rFlyFormat, SfxItemSet& rSet, bool bNewFrames );
 331
 332     typedef SwFormat* (SwDoc:: *FNCopyFormat)( const OUString&, SwFormat*, bool, bool );
 333     SwFormat* CopyFormat( const SwFormat& rFormat, const SwFormatsBase& rFormatArr,
 334                         FNCopyFormat fnCopyFormat, const SwFormat& rDfltFormat );
 335     void CopyFormatArr( const SwFormatsBase& rSourceArr, SwFormatsBase const & rDestArr,
 336                         FNCopyFormat fnCopyFormat, SwFormat& rDfltFormat );
 337     void CopyPageDescHeaderFooterImpl( bool bCpyHeader,
 338                                 const SwFrameFormat& rSrcFormat, SwFrameFormat& rDestFormat );
 339     static SwFormat* FindFormatByName( const SwFormatsBase& rFormatArr, const OUString& rName );
 340
 341     SwDoc( const SwDoc &) = delete;
 342
 343     // Database fields:
 344     void AddUsedDBToList( std::vector<OUString>& rDBNameList,
 345                           const std::vector<OUString>& rUsedDBNames );
 346     void AddUsedDBToList( std::vector<OUString>& rDBNameList, const OUString& rDBName );
 347     static bool IsNameInArray( const std::vector<OUString>& rOldNames, const OUString& rName );
 348     void GetAllDBNames( std::vector<OUString>& rAllDBNames );
 349     static OUString ReplaceUsedDBs( const std::vector<OUString>& rUsedDBNames,
 350                              const OUString& rNewName, const OUString& rFormula );
 351     static std::vector<OUString>& FindUsedDBs( const std::vector<OUString>& rAllDBNames,
 352                                 const OUString& rFormula,
 353                                 std::vector<OUString>& rUsedDBNames );
 354
 355     void EnsureNumberFormatter();
 356
 357     bool UnProtectTableCells( SwTable& rTable );
 358
 359     /** Create sub-documents according to the given collection.
 360      If no collection is given, take chapter style of the 1st level. */
 361     bool SplitDoc( sal_uInt16 eDocType, const OUString& rPath, bool bOutline,
 362                         const SwTextFormatColl* pSplitColl, int nOutlineLevel = 0 );
 363
 364     // Update charts of given table.
 365     void UpdateCharts_( const SwTable& rTable, SwViewShell const & rVSh ) const;
 366
 367     static bool SelectNextRubyChars( SwPaM& rPam, SwRubyListEntry& rRubyEntry );
 368
 369     // CharTimer calls this method.
 370     void DoUpdateAllCharts();
 371     DECL_LINK( DoUpdateModifiedOLE, Timer *, void );
 372
 373 public:
 374     SwFormat *MakeCharFormat_(const OUString &, SwFormat *, bool, bool );
 375     SwFormat *MakeFrameFormat_(const OUString &, SwFormat *, bool, bool );
 376
 377 private:
 378     SwFormat *MakeTextFormatColl_(const OUString &, SwFormat *, bool, bool );
 379
 380 private:
 381     OUString msDocAccTitle;
 382
 383     void InitTOXTypes();
 384
 385 public:
 386     enum DocumentType {
 387         DOCTYPE_NATIVE,
 388         DOCTYPE_MSWORD              // This doc model comes from MS Word
 389         };
 390     DocumentType    meDocType;
 391     DocumentType    GetDocumentType(){ return meDocType; }
 392     void            SetDocumentType( DocumentType eDocType ) { meDocType = eDocType; }
 393
 394     // Life cycle
 395     SwDoc();
 396     ~SwDoc();
 397
 398     bool IsInDtor() const { return mbDtor; }
 399
 400     /* @@@MAINTAINABILITY-HORROR@@@
 401        Implementation details made public.
 402     */
 403     SwNodes      & GetNodes()       { return *m_pNodes; }
 404     SwNodes const& GetNodes() const { return *m_pNodes; }
 405
 406 private:
 407     friend class ::rtl::Reference<SwDoc>;
 408
 409     /** Acquire a reference to an instance. A caller shall release
 410         the instance by calling 'release' when it is no longer needed.
 411         'acquire' and 'release' calls need to be balanced.
 412
 413         @returns
 414         the current reference count of the instance for debugging purposes.
 415     */
 416     sal_Int32 acquire();
 417     /** Releases a reference to an instance. A caller has to call
 418         'release' when a before acquired reference to an instance
 419         is no longer needed. 'acquire' and 'release' calls need to
 420         be balanced.
 421
 422     @returns
 423         the current reference count of the instance for debugging purposes.
 424     */
 425     sal_Int32 release();
 426     /** Returns the current reference count. This method should be used for
 427         debugging purposes. Using it otherwise is a signal of a design flaw.
 428     */
 429 public:
 430     sal_Int32 getReferenceCount() const;
 431
 432     // IDocumentSettingAccess
 433     IDocumentSettingAccess const & getIDocumentSettingAccess() const; //The IDocumentSettingAccess interface
 434     IDocumentSettingAccess & getIDocumentSettingAccess();
 435     ::sw::DocumentSettingManager      & GetDocumentSettingManager(); //The implementation of the interface with some additional methods
 436     ::sw::DocumentSettingManager const& GetDocumentSettingManager() const;
 437     sal_uInt32 getRsid() const;
 438     void setRsid( sal_uInt32 nVal );
 439     sal_uInt32 getRsidRoot() const;
 440     void setRsidRoot( sal_uInt32 nVal );
 441
 442     // IDocumentDeviceAccess
 443     IDocumentDeviceAccess const & getIDocumentDeviceAccess() const;
 444     IDocumentDeviceAccess & getIDocumentDeviceAccess();
 445
 446     // IDocumentMarkAccess
 447     IDocumentMarkAccess* getIDocumentMarkAccess();
 448     const IDocumentMarkAccess* getIDocumentMarkAccess() const;
 449
 450     // IDocumentRedlineAccess
 451     IDocumentRedlineAccess const& getIDocumentRedlineAccess() const;
 452     IDocumentRedlineAccess& getIDocumentRedlineAccess();
 453
 454     ::sw::DocumentRedlineManager const& GetDocumentRedlineManager() const;
 455     ::sw::DocumentRedlineManager& GetDocumentRedlineManager();
 456
 457     // IDocumentUndoRedo
 458     IDocumentUndoRedo      & GetIDocumentUndoRedo();
 459     IDocumentUndoRedo const& GetIDocumentUndoRedo() const;
 460
 461     // IDocumentLinksAdministration
 462     IDocumentLinksAdministration const & getIDocumentLinksAdministration() const;
 463     IDocumentLinksAdministration & getIDocumentLinksAdministration();
 464
 465     ::sw::DocumentLinksAdministrationManager const & GetDocumentLinksAdministrationManager() const;
 466     ::sw::DocumentLinksAdministrationManager & GetDocumentLinksAdministrationManager();
 467
 468     // IDocumentFieldsAccess
 469     IDocumentFieldsAccess const & getIDocumentFieldsAccess() const;
 470     IDocumentFieldsAccess & getIDocumentFieldsAccess();
 471
 472     ::sw::DocumentFieldsManager & GetDocumentFieldsManager();
 473
 474     // Returns 0 if the field cannot hide para, or a positive integer indicating the field type
 475     // "weight" when several hiding fields' FieldHidesPara() give conflicting results
 476     int FieldCanHideParaWeight(SwFieldIds eFieldId) const;
 477     bool FieldHidesPara(const SwField& rField) const;
 478
 479     // IDocumentContentOperations
 480     IDocumentContentOperations const & getIDocumentContentOperations() const;
 481     IDocumentContentOperations & getIDocumentContentOperations();
 482     ::sw::DocumentContentOperationsManager const & GetDocumentContentOperationsManager() const;
 483     ::sw::DocumentContentOperationsManager & GetDocumentContentOperationsManager();
 484
 485     bool UpdateParRsid( SwTextNode *pTextNode, sal_uInt32 nVal = 0 );
 486     void UpdateRsid( const SwPaM &rRg, sal_Int32 nLen );
 487
 488     // IDocumentStylePoolAccess
 489     IDocumentStylePoolAccess const & getIDocumentStylePoolAccess() const;
 490     IDocumentStylePoolAccess & getIDocumentStylePoolAccess();
 491
 492     // SwLineNumberInfo
 493     const SwLineNumberInfo& GetLineNumberInfo() const;
 494     void SetLineNumberInfo(const SwLineNumberInfo& rInfo);
 495
 496     // IDocumentStatistics
 497     IDocumentStatistics const & getIDocumentStatistics() const;
 498     IDocumentStatistics & getIDocumentStatistics();
 499
 500     ::sw::DocumentStatisticsManager const & GetDocumentStatisticsManager() const;
 501     ::sw::DocumentStatisticsManager & GetDocumentStatisticsManager();
 502
 503     // IDocumentState
 504     IDocumentState const & getIDocumentState() const;
 505     IDocumentState & getIDocumentState();
 506
 507     // IDocumentDrawModelAccess
 508     void AddDrawUndo( std::unique_ptr<SdrUndoAction> );
 509     IDocumentDrawModelAccess const & getIDocumentDrawModelAccess() const;
 510     IDocumentDrawModelAccess & getIDocumentDrawModelAccess();
 511
 512     ::sw::DocumentDrawModelManager const & GetDocumentDrawModelManager() const;
 513     ::sw::DocumentDrawModelManager & GetDocumentDrawModelManager();
 514
 515     // IDocumentLayoutAccess
 516     IDocumentLayoutAccess const & getIDocumentLayoutAccess() const;
 517     IDocumentLayoutAccess & getIDocumentLayoutAccess();
 518
 519     ::sw::DocumentLayoutManager const & GetDocumentLayoutManager() const;
 520     ::sw::DocumentLayoutManager & GetDocumentLayoutManager();
 521
 522     // IDocumentTimerAccess
 523     // Our own 'IdleTimer' calls the following method
 524     IDocumentTimerAccess const & getIDocumentTimerAccess() const;
 525     IDocumentTimerAccess & getIDocumentTimerAccess();
 526
 527     // IDocumentChartDataProviderAccess
 528     IDocumentChartDataProviderAccess const & getIDocumentChartDataProviderAccess() const;
 529     IDocumentChartDataProviderAccess & getIDocumentChartDataProviderAccess();
 530
 531     // IDocumentListItems
 532     IDocumentListItems const & getIDocumentListItems() const;
 533     IDocumentListItems & getIDocumentListItems();
 534
 535     // IDocumentOutlineNodes
 536     IDocumentOutlineNodes const & getIDocumentOutlineNodes() const;
 537     IDocumentOutlineNodes & getIDocumentOutlineNodes();
 538
 539     // IDocumentListsAccess
 540     IDocumentListsAccess const & getIDocumentListsAccess() const;
 541     IDocumentListsAccess & getIDocumentListsAccess();
 542
 543     //IDocumentExternalData
 544     IDocumentExternalData const & getIDocumentExternalData() const;
 545     IDocumentExternalData & getIDocumentExternalData();
 546
 547     //End of Interfaces
 548
 549     void setDocAccTitle( const OUString& rTitle ) { msDocAccTitle = rTitle; }
 550     const OUString& getDocAccTitle() const { return msDocAccTitle; }
 551
 552     // INextInterface here
 553     DECL_LINK(CalcFieldValueHdl, EditFieldInfo*, void);
 554
 555     // OLE ???
 556     bool IsOLEPrtNotifyPending() const  { return mbOLEPrtNotifyPending; }
 557     inline void SetOLEPrtNotifyPending( bool bSet = true );
 558     void PrtOLENotify( bool bAll ); // All or only marked
 559
 560     bool IsPrepareSelAll() const { return mbIsPrepareSelAll; }
 561     void SetPrepareSelAll() { mbIsPrepareSelAll = true; }
 562
 563     void SetContainsAtPageObjWithContentAnchor( const bool bFlag )
 564     {
 565         mbContainsAtPageObjWithContentAnchor = bFlag;
 566     }
 567     bool DoesContainAtPageObjWithContentAnchor()
 568     {
 569         return mbContainsAtPageObjWithContentAnchor;
 570     }
 571
 572     /** Returns positions of all FlyFrames in the document.
 573      If a Pam-Pointer is passed the FlyFrames attached to paragraphes
 574      have to be surrounded completely by css::awt::Selection.
 575      ( Start < Pos < End ) !!!
 576      (Required for Writers.) */
 577     SwPosFlyFrames GetAllFlyFormats( const SwPaM*,
 578                         bool bDrawAlso,
 579                         bool bAsCharAlso = false ) const;
 580
 581     SwFlyFrameFormat  *MakeFlyFrameFormat (const OUString &rFormatName, SwFrameFormat *pDerivedFrom);
 582     SwDrawFrameFormat *MakeDrawFrameFormat(const OUString &rFormatName, SwFrameFormat *pDerivedFrom);
 583
 584     // From now on this interface has to be used for Flys.
 585     // pAnchorPos must be set, if they are not attached to pages AND
 586     // Anchor is not already set at valid ContentPos
 587     // in FlySet/FrameFormat.
 588     /* new parameter bCalledFromShell
 589
 590        true: An existing adjust item at pAnchorPos is propagated to
 591        the content node of the new fly section. That propagation only
 592        takes place if there is no adjust item in the paragraph style
 593        for the new fly section.
 594
 595        false: no propagation
 596     */
 597     SwFlyFrameFormat* MakeFlySection( RndStdIds eAnchorType,
 598                                  const SwPosition* pAnchorPos,
 599                                  const SfxItemSet* pSet = nullptr,
 600                                  SwFrameFormat *pParent = nullptr,
 601                                  bool bCalledFromShell = false );
 602     SwFlyFrameFormat* MakeFlyAndMove( const SwPaM& rPam, const SfxItemSet& rSet,
 603                                 const SwSelBoxes* pSelBoxes,
 604                                 SwFrameFormat *pParent );
 605
 606     // Helper that checks for unique items for DrawingLayer items of type NameOrIndex
 607     // and evtl. corrects that items to ensure unique names for that type. This call may
 608     // modify/correct entries inside of the given SfxItemSet, and it will apply a name to
 609     // the items in question (what is essential to make the named slots associated with
 610     // these items work for the UNO API and thus e.g. for ODF import/export)
 611     void CheckForUniqueItemForLineFillNameOrIndex(SfxItemSet& rSet);
 612
 613     bool SetFlyFrameAttr( SwFrameFormat& rFlyFormat, SfxItemSet& rSet );
 614
 615     bool SetFrameFormatToFly( SwFrameFormat& rFlyFormat, SwFrameFormat& rNewFormat,
 616                         SfxItemSet* pSet = nullptr, bool bKeepOrient = false );
 617     void SetFlyFrameTitle( SwFlyFrameFormat& rFlyFrameFormat,
 618                          const OUString& sNewTitle );
 619     void SetFlyFrameDescription( SwFlyFrameFormat& rFlyFrameFormat,
 620                                const OUString& sNewDescription );
 621
 622     // Footnotes
 623     // Footnote information
 624     const SwFootnoteInfo& GetFootnoteInfo() const         { return *mpFootnoteInfo; }
 625     void SetFootnoteInfo(const SwFootnoteInfo& rInfo);
 626     const SwEndNoteInfo& GetEndNoteInfo() const { return *mpEndNoteInfo; }
 627     void SetEndNoteInfo(const SwEndNoteInfo& rInfo);
 628           SwFootnoteIdxs& GetFootnoteIdxs()       { return *mpFootnoteIdxs; }
 629     const SwFootnoteIdxs& GetFootnoteIdxs() const { return *mpFootnoteIdxs; }
 630     /// change footnotes in range
 631     bool SetCurFootnote( const SwPaM& rPam, const OUString& rNumStr,
 632                     bool bIsEndNote );
 633
 634     /** Operations on the content of the document e.g.
 635         spell-checking/hyphenating/word-counting
 636     */
 637     css::uno::Any
 638             Spell( SwPaM&, css::uno::Reference< css::linguistic2::XSpellChecker1 > const &,
 639                    sal_uInt16* pPageCnt, sal_uInt16* pPageSt, bool bGrammarCheck,
 640                    SwRootFrame const* pLayout, // for grammar-check
 641                    SwConversionArgs *pConvArgs = nullptr ) const;
 642
 643     css::uno::Reference< css::linguistic2::XHyphenatedWord >
 644             Hyphenate( SwPaM *pPam, const Point &rCursorPos,
 645                          sal_uInt16* pPageCnt, sal_uInt16* pPageSt );
 646
 647     // count words in pam
 648     static void CountWords( const SwPaM& rPaM, SwDocStat& rStat );
 649
 650     // Glossary Document
 651     bool IsInsOnlyTextGlossary() const      { return mbInsOnlyTextGlssry; }
 652
 653     void Summary( SwDoc* pExtDoc, sal_uInt8 nLevel, sal_uInt8 nPara, bool bImpress );
 654
 655     void ChangeAuthorityData(const SwAuthEntry* pNewData);
 656
 657     bool IsInHeaderFooter( const SwNodeIndex& rIdx ) const;
 658     SvxFrameDirection GetTextDirection( const SwPosition& rPos,
 659                             const Point* pPt = nullptr ) const;
 660     bool IsInVerticalText( const SwPosition& rPos ) const;
 661
 662     // Database  and DB-Manager
 663     void SetDBManager( SwDBManager* pNewMgr )     { m_pDBManager = pNewMgr; }
 664     SwDBManager* GetDBManager() const             { return m_pDBManager; }
 665     void ChangeDBFields( const std::vector<OUString>& rOldNames,
 666                         const OUString& rNewName );
 667     void SetInitDBFields(bool b);
 668
 669     // Find out which databases are used by fields.
 670     void GetAllUsedDB( std::vector<OUString>& rDBNameList,
 671                        const std::vector<OUString>* pAllDBNames = nullptr );
 672
 673     void ChgDBData( const SwDBData& rNewData );
 674     SwDBData const & GetDBData();
 675     const SwDBData& GetDBDesc();
 676
 677     // Some helper functions
 678     OUString GetUniqueGrfName() const;
 679     OUString GetUniqueOLEName() const;
 680     OUString GetUniqueFrameName() const;
 681     OUString GetUniqueShapeName() const;
 682
 683     std::set<SwRootFrame*> GetAllLayouts();
 684
 685     void SetFlyName( SwFlyFrameFormat& rFormat, const OUString& rName );
 686     const SwFlyFrameFormat* FindFlyByName( const OUString& rName, SwNodeType nNdTyp = SwNodeType::NONE ) const;
 687
 688     static void GetGrfNms( const SwFlyFrameFormat& rFormat, OUString* pGrfName, OUString* pFltName );
 689
 690     // Set a valid name for all Flys that have none (Called by Readers after reading).
 691     void SetAllUniqueFlyNames();
 692
 693     /** Reset attributes. All TextHints and (if completely selected) all hard-
 694      formatted stuff (auto-formats) are removed.
 695      Introduce new optional parameter <bSendDataChangedEvents> in order to
 696      control, if the side effect "send data changed events" is triggered or not. */
 697     void ResetAttrs( const SwPaM &rRg,
 698                      bool bTextAttr = true,
 699                      const std::set<sal_uInt16> &rAttrs = std::set<sal_uInt16>(),
 700                      const bool bSendDataChangedEvents = true,
 701                      SwRootFrame const* pLayout = nullptr);
 702     void RstTextAttrs(const SwPaM &rRg, bool bInclRefToxMark = false,
 703             bool bExactRange = false, SwRootFrame const* pLayout = nullptr);
 704
 705     /** Set attribute in given format.1y
 706      *  If Undo is enabled, the old values is added to the Undo history. */
 707     void SetAttr( const SfxPoolItem&, SwFormat& );
 708     /** Set attribute in given format.1y
 709      *  If Undo is enabled, the old values is added to the Undo history. */
 710     void SetAttr( const SfxItemSet&, SwFormat& );
 711
 712     // method to reset a certain attribute at the given format
 713     void ResetAttrAtFormat( const sal_uInt16 nWhichId,
 714                             SwFormat& rChangedFormat );
 715
 716     /** Set attribute as new default attribute in current document.
 717      If Undo is activated, the old one is listed in Undo-History. */
 718     void SetDefault( const SfxPoolItem& );
 719     void SetDefault( const SfxItemSet& );
 720
 721     // Query default attribute in this document.
 722     const SfxPoolItem& GetDefault( sal_uInt16 nFormatHint ) const;
 723     template<class T> const T&  GetDefault( TypedWhichId<T> nWhich ) const
 724     {
 725         return static_cast<const T&>(GetDefault(sal_uInt16(nWhich)));
 726     }
 727
 728     // Do not expand text attributes.
 729     bool DontExpandFormat( const SwPosition& rPos, bool bFlag = true );
 730
 731     // Formats
 732     const SwFrameFormats* GetFrameFormats() const     { return mpFrameFormatTable.get(); }
 733           SwFrameFormats* GetFrameFormats()           { return mpFrameFormatTable.get(); }
 734     const SwCharFormats* GetCharFormats() const   { return mpCharFormatTable.get();}
 735           SwCharFormats* GetCharFormats()         { return mpCharFormatTable.get();}
 736
 737     // LayoutFormats (frames, DrawObjects), sometimes const sometimes not
 738     const SwFrameFormats* GetSpzFrameFormats() const   { return mpSpzFrameFormatTable.get(); }
 739           SwFrameFormats* GetSpzFrameFormats()         { return mpSpzFrameFormatTable.get(); }
 740
 741     const SwFrameFormat *GetDfltFrameFormat() const   { return mpDfltFrameFormat.get(); }
 742           SwFrameFormat *GetDfltFrameFormat()         { return mpDfltFrameFormat.get(); }
 743     const SwFrameFormat *GetEmptyPageFormat() const { return mpEmptyPageFormat.get(); }
 744           SwFrameFormat *GetEmptyPageFormat()       { return mpEmptyPageFormat.get(); }
 745     const SwFrameFormat *GetColumnContFormat() const{ return mpColumnContFormat.get(); }
 746           SwFrameFormat *GetColumnContFormat()      { return mpColumnContFormat.get(); }
 747     const SwCharFormat *GetDfltCharFormat() const { return mpDfltCharFormat.get();}
 748           SwCharFormat *GetDfltCharFormat()       { return mpDfltCharFormat.get();}
 749
 750     // @return the interface of the management of (auto)styles
 751     IStyleAccess& GetIStyleAccess() { return *mpStyleAccess; }
 752
 753     // Remove all language dependencies from all existing formats
 754     void RemoveAllFormatLanguageDependencies();
 755
 756     SwFrameFormat  *MakeFrameFormat(const OUString &rFormatName, SwFrameFormat *pDerivedFrom,
 757                           bool bBroadcast = false, bool bAuto = true);
 758     void       DelFrameFormat( SwFrameFormat *pFormat, bool bBroadcast = false );
 759     SwFrameFormat* FindFrameFormatByName( const OUString& rName ) const
 760         {   return static_cast<SwFrameFormat*>(FindFormatByName( static_cast<SwFormatsBase&>(*mpFrameFormatTable), rName )); }
 761
 762     SwCharFormat *MakeCharFormat(const OUString &rFormatName, SwCharFormat *pDerivedFrom,
 763                            bool bBroadcast = false );
 764     void       DelCharFormat(size_t nFormat, bool bBroadcast = false);
 765     void       DelCharFormat(SwCharFormat const * pFormat, bool bBroadcast = false);
 766     SwCharFormat* FindCharFormatByName( const OUString& rName ) const
 767         {   return static_cast<SwCharFormat*>(FindFormatByName( *mpCharFormatTable, rName )); }
 768
 769     // Formatcollections (styles)
 770     // TXT
 771     const SwTextFormatColl* GetDfltTextFormatColl() const { return mpDfltTextFormatColl.get(); }
 772     SwTextFormatColl* GetDfltTextFormatColl() { return mpDfltTextFormatColl.get(); }
 773     const SwTextFormatColls *GetTextFormatColls() const { return mpTextFormatCollTable.get(); }
 774     SwTextFormatColls *GetTextFormatColls() { return mpTextFormatCollTable.get(); }
 775     SwTextFormatColl *MakeTextFormatColl( const OUString &rFormatName,
 776                                   SwTextFormatColl *pDerivedFrom,
 777                                   bool bBroadcast = false);
 778     SwConditionTextFormatColl* MakeCondTextFormatColl( const OUString &rFormatName,
 779                                                SwTextFormatColl *pDerivedFrom,
 780                                                bool bBroadcast = false);
 781     void DelTextFormatColl(size_t nFormat, bool bBroadcast = false);
 782     void DelTextFormatColl( SwTextFormatColl const * pColl, bool bBroadcast = false );
 783     /** Add 4th optional parameter <bResetListAttrs>.
 784      'side effect' of <SetTextFormatColl> with <bReset = true> is that the hard
 785      attributes of the affected text nodes are cleared, except the break
 786      attribute, the page description attribute and the list style attribute.
 787      The new parameter <bResetListAttrs> indicates, if the list attributes
 788      (list style, restart at and restart with) are cleared as well in case
 789      that <bReset = true> and the paragraph style has a list style attribute set. */
 790     bool SetTextFormatColl(const SwPaM &rRg, SwTextFormatColl *pFormat,
 791                        const bool bReset = true,
 792                        const bool bResetListAttrs = false,
 793                        SwRootFrame const* pLayout = nullptr);
 794     SwTextFormatColl* FindTextFormatCollByName( const OUString& rName ) const
 795         {   return static_cast<SwTextFormatColl*>(FindFormatByName( *mpTextFormatCollTable, rName )); }
 796
 797     void ChkCondColls();
 798
 799     const SwGrfFormatColl* GetDfltGrfFormatColl() const   { return mpDfltGrfFormatColl.get(); }
 800     SwGrfFormatColl* GetDfltGrfFormatColl()  { return mpDfltGrfFormatColl.get(); }
 801     const SwGrfFormatColls *GetGrfFormatColls() const     { return mpGrfFormatCollTable.get(); }
 802     SwGrfFormatColl *MakeGrfFormatColl(const OUString &rFormatName,
 803                                     SwGrfFormatColl *pDerivedFrom);
 804
 805     // Table formatting
 806     const SwFrameFormats* GetTableFrameFormats() const  { return mpTableFrameFormatTable.get(); }
 807           SwFrameFormats* GetTableFrameFormats()        { return mpTableFrameFormatTable.get(); }
 808     size_t GetTableFrameFormatCount( bool bUsed ) const;
 809     SwFrameFormat& GetTableFrameFormat(size_t nFormat, bool bUsed ) const;
 810     SwTableFormat* MakeTableFrameFormat(const OUString &rFormatName, SwFrameFormat *pDerivedFrom);
 811     void        DelTableFrameFormat( SwTableFormat* pFormat );
 812     SwTableFormat* FindTableFormatByName( const OUString& rName, bool bAll = false ) const;
 813
 814     /** Access to frames.
 815     Iterate over Flys - for Basic-Collections. */
 816     size_t GetFlyCount( FlyCntType eType, bool bIgnoreTextBoxes = false ) const;
 817     SwFrameFormat* GetFlyNum(size_t nIdx, FlyCntType eType, bool bIgnoreTextBoxes = false );
 818     std::vector<SwFrameFormat const*> GetFlyFrameFormats(
 819             FlyCntType eType,
 820             bool bIgnoreTextBoxes);
 821
 822     // Copy formats in own arrays and return them.
 823     SwFrameFormat  *CopyFrameFormat ( const SwFrameFormat& );
 824     SwCharFormat *CopyCharFormat( const SwCharFormat& );
 825     SwTextFormatColl* CopyTextColl( const SwTextFormatColl& rColl );
 826     SwGrfFormatColl* CopyGrfColl( const SwGrfFormatColl& rColl );
 827
 828     // Replace all styles with those from rSource.
 829     void ReplaceStyles( const SwDoc& rSource, bool bIncludePageStyles = true );
 830
 831     // Replace all property defaults with those from rSource.
 832     void ReplaceDefaults( const SwDoc& rSource );
 833
 834     // Replace all compatibility options with those from rSource.
 835     void ReplaceCompatibilityOptions( const SwDoc& rSource );
 836
 837     /** Replace all user defined document properties with xSourceDocProps.
 838         Convenience function used by ReplaceDocumentProperties to skip some UNO calls.
 839      */
 840     void ReplaceUserDefinedDocumentProperties( const css::uno::Reference< css::document::XDocumentProperties >& xSourceDocProps );
 841
 842     /** Replace document properties with those from rSource.
 843
 844         This includes the user defined document properties!
 845      */
 846     void ReplaceDocumentProperties(const SwDoc& rSource, bool mailMerge = false);
 847
 848     // Query if style (paragraph- / character- / frame- / page-) is used.
 849     bool IsUsed( const SwModify& ) const;
 850     /// Query if table style is used.
 851     bool IsUsed( const SwTableAutoFormat& ) const;
 852     static bool IsUsed( const SwNumRule& );
 853
 854     // Set name of newly loaded document template.
 855     size_t SetDocPattern(const OUString& rPatternName);
 856
 857     // @return name of document template. Can be 0!
 858     const OUString* GetDocPattern(size_t nPos) const;
 859
 860     // travel over PaM Ring
 861     bool InsertGlossary( SwTextBlocks& rBlock, const OUString& rEntry,
 862                         SwPaM& rPaM, SwCursorShell* pShell = nullptr);
 863
 864     /** get the set of printable pages for the XRenderable API by
 865      evaluating the respective settings (see implementation) */
 866     static void CalculatePagesForPrinting( const SwRootFrame& rLayout, SwRenderData &rData, const SwPrintUIOptions &rOptions, bool bIsPDFExport,
 867             sal_Int32 nDocPageCount );
 868     static void UpdatePagesForPrintingWithPostItData( SwRenderData &rData, const SwPrintUIOptions &rOptions,
 869             sal_Int32 nDocPageCount );
 870     static void CalculatePagePairsForProspectPrinting( const SwRootFrame& rLayout, SwRenderData &rData, const SwPrintUIOptions &rOptions,
 871             sal_Int32 nDocPageCount );
 872
 873     // PageDescriptor interface.
 874     size_t GetPageDescCnt() const { return m_PageDescs.size(); }
 875     const SwPageDesc& GetPageDesc(const size_t i) const { return *m_PageDescs[i]; }
 876     SwPageDesc& GetPageDesc(size_t const i) { return *m_PageDescs[i]; }
 877     SwPageDesc* FindPageDesc(const OUString& rName, size_t* pPos = nullptr) const;
 878     // Just searches the pointer in the m_PageDescs vector!
 879     bool        ContainsPageDesc(const SwPageDesc *pDesc, size_t* pPos) const;
 880
 881     /** Copy the complete PageDesc - beyond document and "deep"!
 882      Optionally copying of PoolFormatId, -HlpId can be prevented. */
 883     void CopyPageDesc( const SwPageDesc& rSrcDesc, SwPageDesc& rDstDesc,
 884                         bool bCopyPoolIds = true );
 885
 886     /** Copy header (with contents) from SrcFormat to DestFormat
 887      (can also be copied into other document). */
 888     void CopyHeader( const SwFrameFormat& rSrcFormat, SwFrameFormat& rDestFormat )
 889         { CopyPageDescHeaderFooterImpl( true, rSrcFormat, rDestFormat ); }
 890
 891     /** Copy footer (with contents) from SrcFormat to DestFormat.
 892      (can also be copied into other document). */
 893     void CopyFooter( const SwFrameFormat& rSrcFormat, SwFrameFormat& rDestFormat )
 894         { CopyPageDescHeaderFooterImpl( false, rSrcFormat, rDestFormat ); }
 895
 896     // For Reader
 897     void ChgPageDesc( const OUString & rName, const SwPageDesc& );
 898     void ChgPageDesc( size_t i, const SwPageDesc& );
 899     void DelPageDesc( const OUString & rName, bool bBroadcast = false);
 900     void DelPageDesc( size_t i, bool bBroadcast = false );
 901     void PreDelPageDesc(SwPageDesc const * pDel);
 902     SwPageDesc* MakePageDesc(const OUString &rName, const SwPageDesc* pCpy = nullptr,
 903                              bool bRegardLanguage = true,
 904                              bool bBroadcast = false);
 905     void BroadcastStyleOperation(const OUString& rName, SfxStyleFamily eFamily,
 906                                  SfxHintId nOp);
 907
 908     /** The html import sometimes overwrites the page sizes set in
 909      the page descriptions. This function is used to correct this. */
 910     void CheckDefaultPageFormat();
 911
 912     // Methods for tables/indices
 913     static sal_uInt16 GetCurTOXMark( const SwPosition& rPos, SwTOXMarks& );
 914     void DeleteTOXMark( const SwTOXMark* pTOXMark );
 915     const SwTOXMark& GotoTOXMark( const SwTOXMark& rCurTOXMark,
 916                                 SwTOXSearch eDir, bool bInReadOnly );
 917
 918     // Insert/Renew table/index
 919     SwTOXBaseSection* InsertTableOf( const SwPosition& rPos,
 920                                             const SwTOXBase& rTOX,
 921                                             const SfxItemSet* pSet = nullptr,
 922                                             bool bExpand = false,
 923                                     SwRootFrame const* pLayout = nullptr);
 924     SwTOXBaseSection* InsertTableOf( const SwPaM& aPam,
 925                                             const SwTOXBase& rTOX,
 926                                             const SfxItemSet* pSet = nullptr,
 927                                             bool bExpand = false,
 928                                     SwRootFrame const* pLayout = nullptr );
 929     void              InsertTableOf( sal_uLong nSttNd, sal_uLong nEndNd,
 930                                             const SwTOXBase& rTOX,
 931                                             const SfxItemSet* pSet );
 932     static SwTOXBase* GetCurTOX( const SwPosition& rPos );
 933     static const SwAttrSet& GetTOXBaseAttrSet(const SwTOXBase& rTOX);
 934
 935     bool DeleteTOX( const SwTOXBase& rTOXBase, bool bDelNodes );
 936     OUString GetUniqueTOXBaseName( const SwTOXType& rType,
 937                                    const OUString& sChkStr ) const;
 938
 939     bool SetTOXBaseName(const SwTOXBase& rTOXBase, const OUString& rName);
 940
 941     // After reading file update all tables/indices
 942     void SetUpdateTOX( bool bFlag )            { mbUpdateTOX = bFlag; }
 943     bool IsUpdateTOX() const                   { return mbUpdateTOX; }
 944
 945     const OUString& GetTOIAutoMarkURL() const {return msTOIAutoMarkURL;}
 946     void            SetTOIAutoMarkURL(const OUString& rSet) {msTOIAutoMarkURL = rSet;}
 947
 948     bool IsInReading() const                    { return mbInReading; }
 949     void SetInReading( bool bNew )              { mbInReading = bNew; }
 950
 951     bool IsInMailMerge() const                  { return mbInMailMerge; }
 952     void SetInMailMerge( bool bNew )            { mbInMailMerge = bNew; }
 953
 954     bool IsClipBoard() const                    { return mbClipBoard; }
 955     // N.B.: must be called right after constructor! (@see GetXmlIdRegistry)
 956     void SetClipBoard( bool bNew )              { mbClipBoard = bNew; }
 957
 958     bool IsColumnSelection() const              { return mbColumnSelection; }
 959     void SetColumnSelection( bool bNew )        { mbColumnSelection = bNew; }
 960
 961     bool IsInXMLImport() const { return mbInXMLImport; }
 962     void SetInXMLImport( bool bNew ) { mbInXMLImport = bNew; }
 963
 964     // Manage types of tables/indices
 965     sal_uInt16 GetTOXTypeCount( TOXTypes eTyp ) const;
 966     const SwTOXType* GetTOXType( TOXTypes eTyp, sal_uInt16 nId ) const;
 967     const SwTOXType* InsertTOXType( const SwTOXType& rTyp );
 968     const SwTOXTypes& GetTOXTypes() const { return *mpTOXTypes; }
 969
 970     const SwTOXBase*    GetDefaultTOXBase( TOXTypes eTyp, bool bCreate );
 971     void                SetDefaultTOXBase(const SwTOXBase& rBase);
 972
 973     // Key for management of index.
 974     void GetTOIKeys(SwTOIKeyType eTyp, std::vector<OUString>& rArr,
 975             SwRootFrame const& rLayout) const;
 976
 977     // Sort table text.
 978     bool SortTable(const SwSelBoxes& rBoxes, const SwSortOptions&);
 979     bool SortText(const SwPaM&, const SwSortOptions&);
 980
 981     // Correct the SwPosition-Objects that are registered with the document
 982     // e. g. Bookmarks or tables/indices.
 983     // If bMoveCursor is set move Cursor too.
 984
 985     // Set everything in rOldNode on rNewPos + Offset.
 986     void CorrAbs(
 987         const SwNodeIndex& rOldNode,
 988         const SwPosition& rNewPos,
 989         const sal_Int32 nOffset = 0,
 990         bool bMoveCursor = false );
 991
 992     // Set everything in the range of [rStartNode, rEndNode] to rNewPos.
 993     static void CorrAbs(
 994         const SwNodeIndex& rStartNode,
 995         const SwNodeIndex& rEndNode,
 996         const SwPosition& rNewPos,
 997         bool bMoveCursor = false );
 998
 999     // Set everything in this range from rRange to rNewPos.
1000     static void CorrAbs(
1001         const SwPaM& rRange,
1002         const SwPosition& rNewPos,
1003         bool bMoveCursor = false );
1004
1005     // Set everything in rOldNode to relative Pos.
1006     void CorrRel(
1007         const SwNodeIndex& rOldNode,
1008         const SwPosition& rNewPos,
1009         const sal_Int32 nOffset = 0,
1010         bool bMoveCursor = false );
1011
1012     // Query / set rules for Outline.
1013     SwNumRule* GetOutlineNumRule() const
1014     {
1015         return mpOutlineRule;
1016     }
1017     void SetOutlineNumRule( const SwNumRule& rRule );
1018     void PropagateOutlineRule();
1019
1020     // Outline - promote / demote.
1021     bool OutlineUpDown(const SwPaM& rPam, short nOffset, SwRootFrame const* pLayout = nullptr);
1022
1023     /// Outline - move up / move down.
1024     bool MoveOutlinePara( const SwPaM& rPam, SwOutlineNodes::difference_type nOffset);
1025
1026     bool GotoOutline(SwPosition& rPos, const OUString& rName, SwRootFrame const* = nullptr) const;
1027
1028     /** Accept changes of outline styles for OutlineRule.
1029      @param bResetIndentAttrs Optional parameter - default value false:
1030       If <bResetIndentAttrs> equals true, the indent attributes "before text"
1031       and "first line indent" are additionally reset at the provided PaM, if
1032       the list style makes use of the new list level attributes.
1033      @param bCreateNewList indicates if a new list is created by applying the given list style.
1034      @param sContinuedListId If bCreateNewList is false, may contain the
1035       list Id of a list which has to be continued by applying the given list style
1036
1037      @return the set ListId if bSetItem is true */
1038     OUString SetNumRule( const SwPaM&,
1039                      const SwNumRule&,
1040                      bool bCreateNewList,
1041                      SwRootFrame const* pLayout = nullptr,
1042                      const OUString& sContinuedListId = OUString(),
1043                      bool bSetItem = true,
1044                      const bool bResetIndentAttrs = false );
1045     void SetCounted(const SwPaM&, bool bCounted, SwRootFrame const* pLayout);
1046
1047     void MakeUniqueNumRules(const SwPaM & rPaM);
1048
1049     void SetNumRuleStart( const SwPosition& rPos, bool bFlag = true );
1050     void SetNodeNumStart( const SwPosition& rPos, sal_uInt16 nStt );
1051
1052     // sw_redlinehide: may set rPos to different node (the one with the NumRule)
1053     static SwNumRule* GetNumRuleAtPos(SwPosition& rPos, SwRootFrame const* pLayout = nullptr);
1054
1055     const SwNumRuleTable& GetNumRuleTable() const { return *mpNumRuleTable; }
1056
1057     /**
1058        Add numbering rule to document.
1059
1060        @param pRule    rule to add
1061     */
1062     void AddNumRule(SwNumRule * pRule);
1063
1064     // add optional parameter <eDefaultNumberFormatPositionAndSpaceMode>
1065     sal_uInt16 MakeNumRule( const OUString &rName,
1066         const SwNumRule* pCpy = nullptr,
1067         bool bBroadcast = false,
1068         const SvxNumberFormat::SvxNumPositionAndSpaceMode eDefaultNumberFormatPositionAndSpaceMode =
1069             SvxNumberFormat::LABEL_WIDTH_AND_POSITION );
1070     sal_uInt16 FindNumRule( const OUString& rName ) const;
1071     SwNumRule* FindNumRulePtr( const OUString& rName ) const;
1072
1073     // Deletion only possible if Rule is not used!
1074     bool RenameNumRule(const OUString & aOldName, const OUString & aNewName,
1075                            bool bBroadcast = false);
1076     bool DelNumRule( const OUString& rName, bool bBroadCast = false );
1077     OUString GetUniqueNumRuleName( const OUString* pChkStr = nullptr, bool bAutoNum = true ) const;
1078
1079     void UpdateNumRule();   // Update all invalids.
1080     void ChgNumRuleFormats( const SwNumRule& rRule );
1081     bool ReplaceNumRule( const SwPosition& rPos, const OUString& rOldRule,
1082                         const OUString& rNewRule );
1083
1084     // Goto next/previous on same level.
1085     static bool GotoNextNum( SwPosition&, SwRootFrame const* pLayout,
1086                         bool bOverUpper = true,
1087                         sal_uInt8* pUpper = nullptr, sal_uInt8* pLower = nullptr );
1088     static bool GotoPrevNum( SwPosition&, SwRootFrame const* pLayout,
1089                         bool bOverUpper = true );
1090
1091     /** Searches for a text node with a numbering rule.
1092
1093        add optional parameter <bInvestigateStartNode>
1094        add output parameter <sListId>
1095
1096        \param rPos         position to start search
1097        \param bForward     - true:  search forward
1098                            - false: search backward
1099        \param bNum         - true:  search for enumeration
1100                            - false: search for itemize
1101        \param bOutline     - true:  search for outline numbering rule
1102                            - false: search for non-outline numbering rule
1103        \param nNonEmptyAllowed   number of non-empty paragraphs allowed between
1104                                  rPos and found paragraph
1105
1106         @param sListId
1107         output parameter - in case a list style is found, <sListId> holds the
1108         list id, to which the text node belongs, which applies the found list style.
1109
1110         @param bInvestigateStartNode
1111         input parameter - boolean, indicating, if start node, determined by given
1112         start position has to be investigated or not.
1113      */
1114     const SwNumRule * SearchNumRule(const SwPosition & rPos,
1115                                     const bool bForward,
1116                                     const bool bNum,
1117                                     const bool bOutline,
1118                                     int nNonEmptyAllowed,
1119                                     OUString& sListId,
1120                                     SwRootFrame const* pLayout,
1121                                     const bool bInvestigateStartNode = false );
1122
1123     // Paragraphs without numbering but with indents.
1124     bool NoNum( const SwPaM& );
1125
1126     // Delete, splitting of numbering list.
1127     void DelNumRules(const SwPaM&, SwRootFrame const* pLayout = nullptr);
1128
1129     // Invalidates all numrules
1130     void InvalidateNumRules();
1131
1132     bool NumUpDown(const SwPaM&, bool bDown, SwRootFrame const* pLayout = nullptr);
1133
1134     /** Move selected paragraphes (not only numberings)
1135      according to offsets. (if negative: go to doc start). */
1136     bool MoveParagraph(SwPaM&, long nOffset, bool bIsOutlMv = false);
1137     bool MoveParagraphImpl(SwPaM&, long nOffset, bool bIsOutlMv, SwRootFrame const*);
1138
1139     bool NumOrNoNum( const SwNodeIndex& rIdx, bool bDel = false);
1140
1141     void StopNumRuleAnimations( OutputDevice* );
1142
1143     /** Insert new table at position @param rPos (will be inserted before Node!).
1144      For AutoFormat at input: columns have to be set at predefined width.
1145      The array holds the positions of the columns (not their widths).
1146      new @param bCalledFromShell:
1147        true: called from shell -> propagate existing adjust item at
1148        rPos to every new cell. A existing adjust item in the table
1149        heading or table contents paragraph style prevent that
1150        propagation.
1151        false: do not propagate
1152     */
1153     const SwTable* InsertTable( const SwInsertTableOptions& rInsTableOpts,  // HeadlineNoBorder
1154                                 const SwPosition& rPos, sal_uInt16 nRows,
1155                                 sal_uInt16 nCols, sal_Int16 eAdjust,
1156                                 const SwTableAutoFormat* pTAFormat = nullptr,
1157                                 const std::vector<sal_uInt16> *pColArr = nullptr,
1158                                 bool bCalledFromShell = false,
1159                                 bool bNewModel = true );
1160
1161     // If index is in a table, return TableNode, else 0.
1162                  SwTableNode* IsIdxInTable( const SwNodeIndex& rIdx );
1163     inline const SwTableNode* IsIdxInTable( const SwNodeIndex& rIdx ) const;
1164
1165     // Create a balanced table out of the selected range.
1166     const SwTable* TextToTable( const SwInsertTableOptions& rInsTableOpts, // HeadlineNoBorder,
1167                                 const SwPaM& rRange, sal_Unicode cCh,
1168                                 sal_Int16 eAdjust,
1169                                 const SwTableAutoFormat* );
1170
1171     // text to table conversion - API support
1172     const SwTable* TextToTable( const std::vector< std::vector<SwNodeRange> >& rTableNodes );
1173
1174     bool TableToText( const SwTableNode* pTableNd, sal_Unicode cCh );
1175
1176     // Create columns / rows in table.
1177     void InsertCol( const SwCursor& rCursor,
1178                     sal_uInt16 nCnt = 1, bool bBehind = true );
1179     bool InsertCol( const SwSelBoxes& rBoxes,
1180                     sal_uInt16 nCnt = 1, bool bBehind = true );
1181     void InsertRow( const SwCursor& rCursor,
1182                     sal_uInt16 nCnt = 1, bool bBehind = true );
1183     bool InsertRow( const SwSelBoxes& rBoxes,
1184                     sal_uInt16 nCnt = 1, bool bBehind = true );
1185
1186     // Delete Columns/Rows in table.
1187     bool DeleteRowCol( const SwSelBoxes& rBoxes, bool bColumn = false );
1188     void DeleteRow( const SwCursor& rCursor );
1189     void DeleteCol( const SwCursor& rCursor );
1190
1191     // Split / concatenate boxes in table.
1192     bool SplitTable( const SwSelBoxes& rBoxes, bool bVert,
1193                        sal_uInt16 nCnt, bool bSameHeight = false );
1194
1195     TableMergeErr MergeTable( SwPaM& rPam );
1196     OUString GetUniqueTableName() const;
1197     bool IsInsTableFormatNum() const;
1198     bool IsInsTableChangeNumFormat() const;
1199     bool IsInsTableAlignNum() const;
1200     bool IsSplitVerticalByDefault() const;
1201     void SetSplitVerticalByDefault(bool value);
1202
1203     // From FEShell (for Undo and BModified).
1204     static void GetTabCols( SwTabCols &rFill, const SwCellFrame* pBoxFrame );
1205     void SetTabCols( const SwTabCols &rNew, bool bCurRowOnly,
1206                     const SwCellFrame* pBoxFrame );
1207     static void GetTabRows( SwTabCols &rFill, const SwCellFrame* pBoxFrame );
1208     void SetTabRows( const SwTabCols &rNew, bool bCurColOnly,
1209                     const SwCellFrame* pBoxFrame );
1210
1211     // Direct access for UNO.
1212     void SetTabCols(SwTable& rTab, const SwTabCols &rNew, const SwTabCols &rOld,
1213                                     const SwTableBox *pStart, bool bCurRowOnly);
1214
1215     void SetRowsToRepeat( SwTable &rTable, sal_uInt16 nSet );
1216
1217     /// AutoFormat for table/table selection.
1218     /// @param bResetDirect Reset direct formatting that might be applied to the cells.
1219     bool SetTableAutoFormat(const SwSelBoxes& rBoxes, const SwTableAutoFormat& rNew, bool bResetDirect = false, bool isSetStyleName = false);
1220
1221     // Query attributes.
1222     bool GetTableAutoFormat( const SwSelBoxes& rBoxes, SwTableAutoFormat& rGet );
1223
1224     /// Return the available table styles.
1225     SwTableAutoFormatTable& GetTableStyles();
1226     const SwTableAutoFormatTable& GetTableStyles() const
1227     {
1228         return const_cast<SwDoc*>(this)->GetTableStyles();
1229     }
1230     /// Counts table styles without triggering lazy-load of them.
1231     bool HasTableStyles() const { return m_pTableStyles != nullptr; }
1232     // Create a new table style. Tracked by Undo.
1233     SwTableAutoFormat* MakeTableStyle(const OUString& rName, bool bBroadcast = false);
1234     // Delete table style named rName. Tracked by undo.
1235     std::unique_ptr<SwTableAutoFormat> DelTableStyle(const OUString& rName, bool bBroadcast = false);
1236     // Change (replace) a table style named rName. Tracked by undo.
1237     void ChgTableStyle(const OUString& rName, const SwTableAutoFormat& rNewFormat);
1238
1239     const SwCellStyleTable& GetCellStyles() const  { return *mpCellStyles; }
1240           SwCellStyleTable& GetCellStyles()        { return *mpCellStyles; }
1241
1242     void AppendUndoForInsertFromDB( const SwPaM& rPam, bool bIsTable );
1243
1244     bool SetColRowWidthHeight( SwTableBox& rCurrentBox, TableChgWidthHeightType eType,
1245                                 SwTwips nAbsDiff, SwTwips nRelDiff );
1246     SwTableBoxFormat* MakeTableBoxFormat();
1247     SwTableLineFormat* MakeTableLineFormat();
1248
1249     // helper function: cleanup before checking number value
1250     bool IsNumberFormat( const OUString& rString, sal_uInt32& F_Index, double& fOutNumber);
1251     // Check if box has numerical value. Change format of box if required.
1252     void ChkBoxNumFormat( SwTableBox& rCurrentBox, bool bCallUpdate );
1253     void SetTableBoxFormulaAttrs( SwTableBox& rBox, const SfxItemSet& rSet );
1254     void ClearBoxNumAttrs( const SwNodeIndex& rNode );
1255     void ClearLineNumAttrs( SwPosition const & rPos );
1256
1257     bool InsCopyOfTable( SwPosition& rInsPos, const SwSelBoxes& rBoxes,
1258                         const SwTable* pCpyTable, bool bCpyName = false,
1259                         bool bCorrPos = false );
1260
1261     void UnProtectCells( const OUString& rTableName );
1262     bool UnProtectCells( const SwSelBoxes& rBoxes );
1263     void UnProtectTables( const SwPaM& rPam );
1264     bool HasTableAnyProtection( const SwPosition* pPos,
1265                               const OUString* pTableName,
1266                               bool* pFullTableProtection );
1267
1268     // Split table at baseline position, i.e. create a new table.
1269     bool SplitTable( const SwPosition& rPos, SplitTable_HeadlineOption eMode,
1270                         bool bCalcNewSize );
1271
1272     /** And vice versa: rPos must be in the table that remains. The flag indicates
1273      whether the current table is merged with the one before or behind it. */
1274     bool MergeTable( const SwPosition& rPos, bool bWithPrev,
1275                         sal_uInt16 nMode = 0 );
1276
1277     // Make charts of given table update.
1278     void UpdateCharts( const OUString &rName ) const;
1279
1280     // Update all charts, for that exists any table.
1281     void UpdateAllCharts()          { DoUpdateAllCharts(); }
1282
1283     // Table is renamed and refreshes charts.
1284     void SetTableName( SwFrameFormat& rTableFormat, const OUString &rNewName );
1285
1286     // @return the reference in document that is set for name.
1287     const SwFormatRefMark* GetRefMark( const OUString& rName ) const;
1288
1289     // @return RefMark via index - for UNO.
1290     const SwFormatRefMark* GetRefMark( sal_uInt16 nIndex ) const;
1291
1292     /** @return names of all references that are set in document.
1293      If array pointer is 0 return only whether a RefMark is set in document. */
1294     sal_uInt16 GetRefMarks( std::vector<OUString>* = nullptr ) const;
1295
1296     // Insert label. If a FlyFormat is created, return it.
1297     SwFlyFrameFormat* InsertLabel( const SwLabelType eType, const OUString &rText, const OUString& rSeparator,
1298                     const OUString& rNumberingSeparator,
1299                     const bool bBefore, const sal_uInt16 nId, const sal_uLong nIdx,
1300                     const OUString& rCharacterStyle,
1301                     const bool bCpyBrd );
1302     SwFlyFrameFormat* InsertDrawLabel(
1303         const OUString &rText, const OUString& rSeparator, const OUString& rNumberSeparator,
1304         const sal_uInt16 nId, const OUString& rCharacterStyle, SdrObject& rObj );
1305
1306     // Query attribute pool.
1307     const SwAttrPool& GetAttrPool() const   { return *mpAttrPool; }
1308           SwAttrPool& GetAttrPool()         { return *mpAttrPool; }
1309
1310     // Search for an EditShell.
1311     SwEditShell const * GetEditShell() const;
1312     SwEditShell* GetEditShell();
1313     ::sw::IShellCursorSupplier * GetIShellCursorSupplier();
1314
1315     // OLE 2.0-notification.
1316     void  SetOle2Link(const Link<bool,void>& rLink) {maOle2Link = rLink;}
1317     const Link<bool,void>& GetOle2Link() const {return maOle2Link;}
1318
1319     // insert section (the ODF kind of section, not the nodesarray kind)
1320     SwSection * InsertSwSection(SwPaM const& rRange, SwSectionData &,
1321             std::pair<SwTOXBase const*, sw::RedlineMode> const* pTOXBase,
1322             SfxItemSet const*const pAttr, bool const bUpdate = true);
1323     static sal_uInt16 IsInsRegionAvailable( const SwPaM& rRange,
1324                                 const SwNode** ppSttNd = nullptr );
1325     static SwSection* GetCurrSection( const SwPosition& rPos );
1326     SwSectionFormats& GetSections() { return *mpSectionFormatTable; }
1327     const SwSectionFormats& GetSections() const { return *mpSectionFormatTable; }
1328     SwSectionFormat *MakeSectionFormat();
1329     void DelSectionFormat( SwSectionFormat *pFormat, bool bDelNodes = false );
1330     void UpdateSection(size_t const nSect, SwSectionData &,
1331             SfxItemSet const*const = nullptr, bool const bPreventLinkUpdate = false);
1332     OUString GetUniqueSectionName( const OUString* pChkStr = nullptr ) const;
1333
1334     /* @@@MAINTAINABILITY-HORROR@@@
1335        The model should not have anything to do with a shell.
1336        Unnecessary compile/link time dependency.
1337     */
1338
1339     // Pointer to SfxDocShell from Doc. Can be 0!!
1340           SwDocShell* GetDocShell()         { return mpDocShell; }
1341     const SwDocShell* GetDocShell() const   { return mpDocShell; }
1342     void SetDocShell( SwDocShell* pDSh );
1343
1344     /** in case during copying of embedded object a new shell is created,
1345      it should be set here and cleaned later */
1346     void SetTmpDocShell( SfxObjectShellLock rLock )    { mxTmpDocShell = rLock; }
1347     const SfxObjectShellLock& GetTmpDocShell()    { return mxTmpDocShell; }
1348
1349     // For Autotexts? (text modules) They have only one SVPersist at their disposal.
1350     SfxObjectShell* GetPersist() const;
1351
1352     // Pointer to storage of SfxDocShells. Can be 0!!!
1353     css::uno::Reference< css::embed::XStorage > GetDocStorage();
1354
1355     // Query / set flag indicating if document is loaded asynchronously at this moment.
1356     bool IsInLoadAsynchron() const             { return mbInLoadAsynchron; }
1357     void SetInLoadAsynchron( bool bFlag )       { mbInLoadAsynchron = bFlag; }
1358
1359     // For Drag&Move: (e.g. allow "moving" of RefMarks)
1360     bool IsCopyIsMove() const              { return mbCopyIsMove; }
1361     void SetCopyIsMove( bool bFlag )        { mbCopyIsMove = bFlag; }
1362
1363     SwDrawContact* GroupSelection( SdrView& );
1364     void UnGroupSelection( SdrView& );
1365     bool DeleteSelection( SwDrawView& );
1366
1367     // Invalidates OnlineSpell-WrongLists.
1368     void SpellItAgainSam( bool bInvalid, bool bOnlyWrong, bool bSmartTags );
1369     void InvalidateAutoCompleteFlag();
1370
1371     void SetCalcFieldValueHdl(Outliner* pOutliner);
1372
1373     // Query if URL was visited.
1374     // Query via Doc, if only a Bookmark has been given.
1375     // In this case the document name has to be set in front.
1376     bool IsVisitedURL( const OUString& rURL );
1377
1378     // Save current values for automatic registration of exceptions in Autocorrection.
1379     void SetAutoCorrExceptWord( std::unique_ptr<SwAutoCorrExceptWord> pNew );
1380     SwAutoCorrExceptWord* GetAutoCorrExceptWord()       { return mpACEWord.get(); }
1381     void DeleteAutoCorrExceptWord();
1382
1383     const SwFormatINetFormat* FindINetAttr( const OUString& rName ) const;
1384
1385     // Call into intransparent Basic; expect possible Return String.
1386     void ExecMacro( const SvxMacro& rMacro, OUString* pRet, SbxArray* pArgs );
1387
1388     // Call into intransparent Basic / JavaScript.
1389     sal_uInt16 CallEvent( SvMacroItemId nEvent, const SwCallMouseEvent& rCallEvent,
1390                         bool bChkPtr = false );
1391
1392     /** Adjust left margin via object bar (similar to adjustment of numerations).
1393      One can either change the margin "by" adding or subtracting a given
1394      offset or set it "to" this position (bModulus = true). */
1395     void MoveLeftMargin(const SwPaM& rPam, bool bRight, bool bModulus,
1396             SwRootFrame const* pLayout = nullptr);
1397
1398     // Query NumberFormatter.
1399     SvNumberFormatter* GetNumberFormatter(bool bCreate = true)
1400     {
1401         if (bCreate)
1402             EnsureNumberFormatter();
1403         return mpNumberFormatter;
1404     }
1405
1406     const SvNumberFormatter* GetNumberFormatter(bool bCreate = true) const
1407     {
1408         return const_cast<SwDoc*>(this)->GetNumberFormatter(bCreate);
1409     }
1410
1411     bool HasInvisibleContent() const;
1412     // delete invisible content, like hidden sections and paragraphs
1413     bool RemoveInvisibleContent();
1414     // restore the invisible content if it's available on the undo stack
1415     bool RestoreInvisibleContent();
1416
1417     bool ConvertFieldsToText(SwRootFrame const& rLayout);
1418
1419     // Create sub-documents according to given collection.
1420     // If no collection is given, use chapter styles for 1st level.
1421     bool GenerateGlobalDoc( const OUString& rPath,
1422                                 const SwTextFormatColl* pSplitColl );
1423     bool GenerateGlobalDoc( const OUString& rPath, int nOutlineLevel );
1424     bool GenerateHTMLDoc( const OUString& rPath,
1425                                 const SwTextFormatColl* pSplitColl );
1426     bool GenerateHTMLDoc( const OUString& rPath, int nOutlineLevel );
1427
1428     //  Compare two documents.
1429     long CompareDoc( const SwDoc& rDoc );
1430
1431     // Merge two documents.
1432     long MergeDoc( const SwDoc& rDoc );
1433
1434     bool IsAutoFormatRedline() const           { return mbIsAutoFormatRedline; }
1435     void SetAutoFormatRedline( bool bFlag )    { mbIsAutoFormatRedline = bFlag; }
1436
1437     // For AutoFormat: with Undo/Redlining.
1438     void SetTextFormatCollByAutoFormat( const SwPosition& rPos, sal_uInt16 nPoolId,
1439                                 const SfxItemSet* pSet );
1440     void SetFormatItemByAutoFormat( const SwPaM& rPam, const SfxItemSet& );
1441
1442     // Only for SW-textbloxks! Does not pay any attention to layout!
1443     void ClearDoc();        // Deletes all content!
1444
1445     // Query /set data for PagePreview.
1446     const SwPagePreviewPrtData* GetPreviewPrtData() const { return m_pPgPViewPrtData.get(); }
1447
1448     // If pointer == 0 destroy pointer in document.
1449     // Else copy object.
1450     // Pointer is not transferred to ownership by document!
1451     void SetPreviewPrtData( const SwPagePreviewPrtData* pData );
1452
1453     /** update all modified OLE-Objects. The modification is called over the
1454      StarOne - Interface */
1455     void SetOLEObjModified();
1456
1457     // Uno - Interfaces
1458     std::shared_ptr<SwUnoCursor> CreateUnoCursor( const SwPosition& rPos, bool bTableCursor = false );
1459
1460     // FeShell - Interfaces
1461     // !!! These assume always an existing layout !!!
1462     bool ChgAnchor( const SdrMarkList& _rMrkList,
1463                         RndStdIds _eAnchorType,
1464                         const bool _bSameOnly,
1465                         const bool _bPosCorr );
1466
1467     void SetRowHeight( const SwCursor& rCursor, const SwFormatFrameSize &rNew );
1468     static std::unique_ptr<SwFormatFrameSize> GetRowHeight( const SwCursor& rCursor );
1469     void SetRowSplit( const SwCursor& rCursor, const SwFormatRowSplit &rNew );
1470     static std::unique_ptr<SwFormatRowSplit> GetRowSplit( const SwCursor& rCursor );
1471
1472     /// Adjustment of Rowheights. Determine via bTstOnly if more than one row is selected.
1473     /// bOptimize: distribute current table height, instead of using the largest row.
1474     ///   Call again without bOptimize to ensure equal height in case some row's content didn't fit.
1475     bool BalanceRowHeight( const SwCursor& rCursor, bool bTstOnly, const bool bOptimize );
1476     void SetRowBackground( const SwCursor& rCursor, const SvxBrushItem &rNew );
1477     static bool GetRowBackground( const SwCursor& rCursor, std::shared_ptr<SvxBrushItem>& rToFill );
1478     void SetTabBorders( const SwCursor& rCursor, const SfxItemSet& rSet );
1479     void SetTabLineStyle( const SwCursor& rCursor,
1480                           const Color* pColor, bool bSetLine,
1481                           const editeng::SvxBorderLine* pBorderLine );
1482     static void GetTabBorders( const SwCursor& rCursor, SfxItemSet& rSet );
1483     void SetBoxAttr( const SwCursor& rCursor, const SfxPoolItem &rNew );
1484     /**
1485     Retrieves a box attribute from the given cursor.
1486
1487     @return Whether the property is set over the current box selection.
1488
1489     @remarks A property is 'set' if it's set to the same value over all boxes in the current selection.
1490     The property value is retrieved from the first box in the current selection. It is then compared to
1491     the values of the same property over any other boxes in the selection; if any value is different from
1492     that of the first box, the property is unset (and false is returned).
1493     */
1494     static bool GetBoxAttr( const SwCursor& rCursor, std::shared_ptr<SfxPoolItem>& rToFill );
1495     void SetBoxAlign( const SwCursor& rCursor, sal_uInt16 nAlign );
1496     static sal_uInt16 GetBoxAlign( const SwCursor& rCursor );
1497     /// Adjusts selected cell widths in such a way, that their content does not need to be wrapped (if possible).
1498     /// bBalance evenly re-distributes the available space regardless of content or wrapping.
1499     /// bNoShrink keeps table size the same by distributing excess space proportionately.
1500     /// bColumnWidth tests the entire column for content width, not just selected cells.
1501     void AdjustCellWidth( const SwCursor& rCursor, const bool bBalance, const bool bNoShrink, const bool bColumnWidth );
1502
1503     SwChainRet Chainable( const SwFrameFormat &rSource, const SwFrameFormat &rDest );
1504     SwChainRet Chain( SwFrameFormat &rSource, const SwFrameFormat &rDest );
1505     void Unchain( SwFrameFormat &rFormat );
1506
1507     // For Copy/Move from FrameShell.
1508     SdrObject* CloneSdrObj( const SdrObject&, bool bMoveWithinDoc = false,
1509                             bool bInsInPage = true );
1510
1511     // FeShell - Interface end
1512
1513     // Interface for TextInputData - for text input of Chinese and Japanese.
1514     SwExtTextInput* CreateExtTextInput( const SwPaM& rPam );
1515     void DeleteExtTextInput( SwExtTextInput* pDel );
1516     SwExtTextInput* GetExtTextInput( const SwNode& rNd,
1517                                 sal_Int32 nContentPos = -1) const;
1518     SwExtTextInput* GetExtTextInput() const;
1519
1520     // Interface for access to AutoComplete-List.
1521     static SwAutoCompleteWord& GetAutoCompleteWords() { return *s_pAutoCompleteWords; }
1522
1523     bool ContainsMSVBasic() const          { return mbContains_MSVBasic; }
1524     void SetContainsMSVBasic( bool bFlag )  { mbContains_MSVBasic = bFlag; }
1525
1526     // Interface for the list of Ruby - texts/attributes
1527     static sal_uInt16 FillRubyList( const SwPaM& rPam, SwRubyList& rList );
1528     void SetRubyList( const SwPaM& rPam, const SwRubyList& rList );
1529
1530     void ReadLayoutCache( SvStream& rStream );
1531     void WriteLayoutCache( SvStream& rStream );
1532     SwLayoutCache* GetLayoutCache() const { return mpLayoutCache.get(); }
1533
1534     /** Checks if any of the text node contains hidden characters.
1535         Used for optimization. Changing the view option 'view hidden text'
1536         has to trigger a reformatting only if some of the text is hidden.
1537     */
1538     bool ContainsHiddenChars() const;
1539
1540     IGrammarContact* getGrammarContact() const { return mpGrammarContact.get(); }
1541
1542     /** Marks/Unmarks a list level of a certain list
1543
1544         levels of a certain lists are marked now
1545
1546         @param sListId    list Id of the list whose level has to be marked/unmarked
1547         @param nListLevel level to mark
1548         @param bValue     - true  mark the level
1549                           - false unmark the level
1550     */
1551     void MarkListLevel( const OUString& sListId,
1552                         const int nListLevel,
1553                         const bool bValue );
1554
1555     // Change a format undoable.
1556     void ChgFormat(SwFormat & rFormat, const SfxItemSet & rSet);
1557
1558     void RenameFormat(SwFormat & rFormat, const OUString & sNewName,
1559                    bool bBroadcast = false);
1560
1561     // Change a TOX undoable.
1562     void ChangeTOX(SwTOXBase & rTOX, const SwTOXBase & rNew);
1563
1564     /**
1565        Returns a textual description of a PaM.
1566
1567        @param rPaM     the PaM to describe
1568
1569        If rPaM only spans one paragraph the result is:
1570
1571             '<text in the PaM>'
1572
1573        <text in the PaM> is shortened to nUndoStringLength characters.
1574
1575        If rPaM spans more than one paragraph the result is:
1576
1577             paragraphs                               (STR_PARAGRAPHS)
1578
1579        @return the textual description of rPaM
1580      */
1581     static OUString GetPaMDescr(const SwPaM & rPaM);
1582
1583     static bool IsFirstOfNumRuleAtPos(const SwPosition & rPos, SwRootFrame const& rLayout);
1584
1585     // access methods for XForms model(s)
1586
1587     // access container for XForms model; will be NULL if !isXForms()
1588     const css::uno::Reference<css::container::XNameContainer>&
1589         getXForms() const { return mxXForms;}
1590
1591     css::uno::Reference< css::linguistic2::XProofreadingIterator > const & GetGCIterator() const;
1592
1593     // #i31958# is this an XForms document?
1594     bool isXForms() const;
1595
1596     // #i31958# initialize XForms models; turn this into an XForms document
1597     void initXForms( bool bCreateDefaultModel );
1598
1599     // #i113606# for disposing XForms
1600     void disposeXForms( );
1601
1602     //Update all the page masters
1603     void SetDefaultPageMode(bool bSquaredPageMode);
1604     bool IsSquaredPageMode() const;
1605
1606     css::uno::Reference< css::script::vba::XVBAEventProcessor > const & GetVbaEventProcessor();
1607     void SetVBATemplateToProjectCache( css::uno::Reference< css::container::XNameContainer > const & xCache ) { m_xTemplateToProjectCache = xCache; };
1608     const css::uno::Reference< css::container::XNameContainer >& GetVBATemplateToProjectCache() { return m_xTemplateToProjectCache; };
1609     ::sfx2::IXmlIdRegistry& GetXmlIdRegistry();
1610     ::sw::MetaFieldManager & GetMetaFieldManager();
1611     ::sw::UndoManager      & GetUndoManager();
1612     ::sw::UndoManager const& GetUndoManager() const;
1613
1614     SfxObjectShell* CreateCopy(bool bCallInitNew, bool bEmpty) const;
1615     SwNodeIndex AppendDoc(const SwDoc& rSource, sal_uInt16 nStartPageNumber,
1616                  bool bDeletePrevious, int physicalPageOffset,
1617                  const sal_uLong nDocNo);
1618
1619     /**
1620      * Dumps the entire nodes structure to the given destination (file nodes.xml in the current directory by default)
1621      */
1622     void dumpAsXml(xmlTextWriterPtr = nullptr) const;
1623
1624     std::set<Color> GetDocColors();
1625     std::vector< std::weak_ptr<SwUnoCursor> > mvUnoCursorTable;
1626
1627     // Remove expired UnoCursor weak pointers the document keeps to notify about document death.
1628     void cleanupUnoCursorTable() const
1629     {
1630         auto & rTable = const_cast<SwDoc*>(this)->mvUnoCursorTable;
1631         // In most cases we'll remove most of the elements.
1632         rTable.erase( std::remove_if(rTable.begin(),
1633                                      rTable.end(),
1634                                      [] (std::weak_ptr<SwUnoCursor> const & x) { return x.expired(); }),
1635                       rTable.end());
1636     }
1637
1638     /**
1639      * @param bSkipStart don't actually start the jobs, just check
1640      * @returns true if new background checking jobs were started
1641      */
1642     bool StartGrammarChecking( bool bSkipStart = false );
1643
1644     /// Use to notify if the dictionary can be found for a single content portion (has to be called for all portions)
1645     void SetMissingDictionaries( bool bIsMissing );
1646     /// Returns true if no dictionary can be found for any content
1647     bool IsDictionaryMissing() { return meDictionaryMissing == MissingDictionary::True; }
1648
1649 private:
1650     // Copies master header to left / first one, if necessary - used by ChgPageDesc().
1651     void CopyMasterHeader(const SwPageDesc &rChged, const SwFormatHeader &rHead, SwPageDesc &pDesc, bool bLeft, bool bFirst);
1652     // Copies master footer to left / first one, if necessary - used by ChgPageDesc().
1653     void CopyMasterFooter(const SwPageDesc &rChged, const SwFormatFooter &rFoot, SwPageDesc &pDesc, bool bLeft, bool bFirst);
1654
1655 };
1656
1657 // This method is called in Dtor of SwDoc and deletes cache of ContourObjects.
1658 void ClrContourCache();
1659
1660 inline const SwTableNode* SwDoc::IsIdxInTable( const SwNodeIndex& rIdx ) const
1661 {
1662     return const_cast<SwDoc*>(this)->IsIdxInTable( rIdx );
1663 }
1664
1665 inline void SwDoc::SetOLEPrtNotifyPending( bool bSet )
1666 {
1667     mbOLEPrtNotifyPending = bSet;
1668     if( !bSet )
1669         mbAllOLENotify = false;
1670 }
1671
1672 bool sw_GetPostIts( IDocumentFieldsAccess const * pIDFA, SetGetExpFields * pSrtLst );
1673
1674 #endif  //_DOC_HXX
1675
1676 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */