document.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include <vcl/idle.hxx>
#include <comphelper/errcode.hxx>
#include <com/sun/star/uno/Reference.hxx>
#include <vcl/vclptr.hxx>
#include "patattr.hxx"
#include "scdllapi.h"
#include "interpretercontext.hxx"
#include "rangelst.hxx"
#include "rangenam.hxx"
#include "recursionhelper.hxx"
#include "tabopparams.hxx"
#include "types.hxx"
#include <formula/grammar.hxx>
#include <formula/types.hxx>
#include "typedstrdata.hxx"
#include "calcmacros.hxx"
#include "calcconfig.hxx"
#include "sheetlimits.hxx"
#include <o3tl/deleter.hxx>
#include <o3tl/sorted_vector.hxx>
#include <svl/hint.hxx>
#include <svl/typedwhich.hxx>
#include <svl/zforlist.hxx>
#include <tools/gen.hxx>
#include <tools/solar.h>
 
#include <cassert>
#include <memory>
#include <map>
#include <shared_mutex>
#include <optional>
#include <set>
#include <unordered_map>
#include <vector>
 
#include "markdata.hxx"
#include "drwlayer.hxx"
 
namespace com::sun::star::chart2 { class XChartDocument; }
 
class Timer;
 
enum class SvtScriptType : sal_uInt8;
enum class ScMF;
enum class FormulaError : sal_uInt16;
enum class CharCompressType;
enum class EEHorizontalTextDirection;
namespace editeng { class SvxBorderLine; }
namespace formula { struct VectorRefArray; }
namespace svl {
class SharedString;
class SharedStringPool;
}
 
namespace tools { class Guid; }
 
namespace sc {
 
struct BroadcasterState;
struct FormulaGroupContext;
class StartListeningContext;
class EndListeningContext;
class CopyFromClipContext;
class ColumnSpanSet;
class RangeColumnSpanSet;
struct ColumnBlockPosition;
struct RefUpdateContext;
class EditTextIterator;
struct NoteEntry;
class DocumentStreamAccess;
class DocumentLinkManager;
class CellValues;
class TableValues;
class RowHeightContext;
struct SetFormulaDirtyContext;
class RefMovedHint;
struct ReorderParam;
class FormulaGroupAreaListener;
class ColumnSet;
class UpdatedRangeNames;
class TableColumnBlockPositionSet;
class ColumnIterator;
class ExternalDataMapper;
class Sparkline;
class SparklineGroup;
class SparklineList;
 
}
 
class Fraction;
 
class OutputDevice;
class SdrObject;
class SfxBroadcaster;
class SfxListener;
class SfxItemSet;
class SfxObjectShell;
class SfxBindings;
class SfxPoolItem;
class SfxItemPool;
class SfxPrinter;
class SfxStyleSheetBase;
class SvMemoryStream;
class SvxBoxInfoItem;
class SvxBoxItem;
class SvxForbiddenCharactersTable;
namespace sfx2 {
    class LinkManager;
    }
class SvxSearchItem;
class XColorList;
 
class ScAutoFormatData;
class ScBroadcastAreaSlotMachine;
class ScChangeViewSettings;
class ScChartListenerCollection;
class ScClipOptions;
class ScColumn;
class ScConditionalFormat;
class ScConditionalFormatList;
class ScDBCollection;
class ScDBData;
class ScDetOpData;
class ScDetOpList;
class ScDocOptions;
class ScDocProtection;
class ScDocumentPool;
class ScDrawLayer;
class ScExtDocOptions;
class ScExternalRefManager;
class ScFormulaCell;
class ScMacroManager;
class ScOutlineTable;
class ScPrintRangeSaver;
class ScStyleSheet;
class ScStyleSheetPool;
class ScTable;
class ScTableProtection;
class ScTokenArray;
class ScValidationData;
class ScValidationDataList;
class ScViewOptions;
class ScChangeTrack;
class ScEditEngineDefaulter;
class ScFieldEditEngine;
class ScNoteEditEngine;
class ScDPObject;
class ScDPCollection;
class ScMatrix;
class ScScriptTypeData;
class ScPoolHelper;
struct ScSortParam;
class ScRefreshTimerControl;
class ScUnoListenerCalls;
class ScUnoRefList;
class ScRecursionHelper;
struct RowInfo;
struct ScTableInfo;
struct ScTabOpParam;
class VirtualDevice;
class ScAutoNameCache;
class ScTemporaryChartLock;
class ScLookupCache;
struct ScLookupCacheMap;
class ScSortedRangeCache;
struct ScSortedRangeCacheMap;
class ScUndoManager;
class ScFormulaParserPool;
struct ScClipParam;
class ScRowBreakIterator;
struct ScSetStringParam;
struct ScColWidthParam;
class ScSheetEvents;
class ScProgress;
class SvtListener;
class ScEditDataArray;
class EditTextObject;
struct ScRefCellValue;
class ScPostIt;
struct ScSubTotalParam;
struct ScQueryParam;
class ScHint;
class SvtBroadcaster;
enum class ScDBDataPortion;
enum class ScSheetEventId;
class BitmapEx;
class ScColumnsRange;
struct ScFilterEntries;
typedef o3tl::sorted_vector<sal_uInt32> ScCondFormatIndexes;
struct ScSheetLimits;
struct ScDataAreaExtras;
 
 
namespace sc {
 
typedef std::map<OUString, BitmapEx> IconSetBitmapMap;
 
}
 
namespace com::sun::star {
    namespace lang {
        struct EventObject;
    }
    namespace i18n {
        class XBreakIterator;
    }
    namespace util {
        class XModifyListener;
    }
    namespace embed {
        class XEmbeddedObject;
    }
    namespace script::vba {
        class XVBAEventProcessor;
    }
    namespace sheet {
        struct TablePageBreakData;
    }
}
 
namespace weld {
 
class Window;
 
}
 
#define SC_DOC_NEW          0xFFFF
 
#define SC_MACROCALL_ALLOWED        0
 
#define SC_ASIANKERNING_INVALID         0xff
 
enum ScDocumentMode
{
    SCDOCMODE_DOCUMENT,
    SCDOCMODE_CLIP,
    SCDOCMODE_UNDO,
    SCDOCMODE_FUNCTIONACCESS
};
 
enum CommentCaptionState
{
    ALLSHOWN,                   // All comments captions are shown
    ALLHIDDEN,                  // All comments captions are hidden
    MIXED                       // There are comments in shown and hidden.
};
 
enum RangeNameScope
{
    GLOBAL,                    // A range name can be defined
    SHEET                      // with two scope on Manage Names dialog.
};
 
enum class SheetGeomType
{
    SIZES,                     // Column widths or row heights.
    HIDDEN,                    // Hidden columns/rows.
    FILTERED,                  // Filtered columns/rows.
    GROUPS                     // Grouping of columns/rows.
};
 
struct ScDocStat
{
    OUString  aDocName;
    SCTAB   nTableCount;
    sal_uInt64  nCellCount;
    sal_uInt64  nFormulaCount;
    sal_uInt16  nPageCount;
    ScDocStat()
        : nTableCount(0)
        , nCellCount(0)
        , nFormulaCount(0)
        , nPageCount(0)
    {
    }
};
 
// DDE link modes
const sal_uInt8 SC_DDE_DEFAULT       = 0;
const sal_uInt8 SC_DDE_ENGLISH       = 1;
const sal_uInt8 SC_DDE_TEXT          = 2;
const sal_uInt8 SC_DDE_IGNOREMODE    = 255;       
 
// During threaded calculation fields being mutated are kept in this struct
struct ScDocumentThreadSpecific
{
    std::unique_ptr<ScRecursionHelper> xRecursionHelper; // information for recursive and iterative cell formulas
    ScInterpreterContext* pContext = nullptr;  // references the context passed around for easier access
};
 
enum ScMutationGuardFlags
{
    // Bit mask bits
    CORE = 0x0001, 
};
 
typedef std::unique_ptr<ScTable, o3tl::default_delete<ScTable>> ScTableUniquePtr;
 
class ScDocument
{
friend class ScValueIterator;
friend class ScHorizontalValueIterator;
friend class ScDBQueryDataIterator;
friend class ScCellIterator;
template< ScQueryCellIteratorAccess accessType, ScQueryCellIteratorType queryType >
friend class ScQueryCellIteratorBase;
template< ScQueryCellIteratorAccess accessType >
friend class ScQueryCellIteratorAccessSpecific;
friend class ScHorizontalCellIterator;
friend class ScHorizontalAttrIterator;
friend class ScDocAttrIterator;
friend class ScAttrRectIterator;
friend class ScDocShell;
friend class ScDocRowHeightUpdater;
friend class ScColumnTextWidthIterator;
friend class ScTable;
friend class ScColumn;
friend struct ScRefCellValue;
friend class ScDocumentImport;
friend class sc::EditTextIterator;
friend struct ScMutationGuard;
friend struct ScMutationDisable;
 
    typedef std::vector<ScTableUniquePtr> TableContainer;
 
public:
    enum class HardRecalcState
    {
        OFF,        
        TEMPORARY,  
        ETERNAL     
    };
 
private:
    rtl::Reference<ScPoolHelper> mxPoolHelper;
 
    std::shared_ptr<svl::SharedStringPool> mpCellStringPool;
    std::unique_ptr<sc::DocumentLinkManager> mpDocLinkMgr;
 
    std::shared_ptr<sc::FormulaGroupContext> mpFormulaGroupCxt;
    bool                mbFormulaGroupCxtBlockDiscard;
 
    ScCalcConfig        maCalcConfig;
 
    ScUndoManager*     mpUndoManager;
    std::unique_ptr<ScFieldEditEngine>  mpEditEngine;                   // uses pEditPool from xPoolHelper
    std::unique_ptr<ScNoteEditEngine>   mpNoteEngine;                   // uses pEditPool from xPoolHelper
    SfxObjectShell*     mpShell;
    VclPtr<SfxPrinter>  mpPrinter;
    VclPtr<VirtualDevice> mpVirtualDevice_100th_mm;
    std::unique_ptr<ScDrawLayer> mpDrawLayer;           // SdrModel
    rtl::Reference<XColorList> pColorList;
    std::unique_ptr<ScValidationDataList> pValidationList;              // validity
    SvNumberFormatterIndexTable* pFormatExchangeList;    // for application of number formats
    TableContainer maTabs;
    rtl::Reference<ScSheetLimits> mxSheetLimits;
    std::vector<OUString> maTabNames;               // for undo document, we need the information tab name <-> index
    mutable std::unique_ptr<ScRangeName>    pRangeName;
    std::unique_ptr<ScDBCollection>         pDBCollection;
    std::unique_ptr<ScDPCollection>         pDPCollection;
    std::unique_ptr< ScTemporaryChartLock > apTemporaryChartLock;
    std::unique_ptr<ScPatternAttr>          pSelectionAttr;                 // Attributes of a block
    ScFormulaCell*      pFormulaTree;                   // formula tree (start)
    ScFormulaCell*      pEOFormulaTree;                 // formula tree (end), last cell
    ScFormulaCell*      pFormulaTrack;                  // BroadcastTrack (start)
    ScFormulaCell*      pEOFormulaTrack;                // BroadcastTrack (end), last cell
    std::unique_ptr<ScBroadcastAreaSlotMachine> pBASM;                  // BroadcastAreas
    std::unique_ptr<ScChartListenerCollection> pChartListenerCollection;
    std::unique_ptr<SvMemoryStream>     pClipData;
    std::unique_ptr<ScDetOpList>        pDetOpList;
    std::unique_ptr<ScChangeTrack>      pChangeTrack;
    std::unique_ptr<SfxBroadcaster>     pUnoBroadcaster;
    std::unique_ptr<ScUnoListenerCalls> pUnoListenerCalls;
    std::unique_ptr<ScUnoRefList>       pUnoRefUndoList;
    std::unique_ptr<ScChangeViewSettings> pChangeViewSettings;
    std::unique_ptr<ScScriptTypeData>   pScriptTypeData;
    std::unique_ptr<ScRefreshTimerControl> pRefreshTimerControl;
    std::shared_ptr<SvxForbiddenCharactersTable> xForbiddenCharacters;
    std::unique_ptr<ScDBData>               mpAnonymousDBData;
    std::unique_ptr<sc::ExternalDataMapper> mpDataMapper;
 
    std::unique_ptr<ScFieldEditEngine>    pCacheFieldEditEngine;
 
    std::unique_ptr<ScDocProtection>      pDocProtection;
    std::unique_ptr<ScClipParam>          mpClipParam;
 
    std::unique_ptr<ScExternalRefManager> pExternalRefMgr;
    std::unique_ptr<ScMacroManager>       mpMacroMgr;
 
    // mutable for lazy construction
    mutable std::unique_ptr< ScFormulaParserPool >
                        mxFormulaParserPool;            
 
    OUString       aDocName;                       // optional: name of document
    OUString       aDocCodeName;                       // optional: name of document (twice?)
    OUString       maFileURL;      // file URL for copy & paste
    ScRangePairListRef  xColNameRanges;
    ScRangePairListRef  xRowNameRanges;
 
    std::unique_ptr<ScViewOptions>   pViewOptions;      // view options
    std::unique_ptr<ScDocOptions>    pDocOptions;       // document options
    std::unique_ptr<ScExtDocOptions> pExtDocOptions;    // for import etc.
    std::unique_ptr<ScClipOptions> mpClipOptions;       // clipboard options
    std::unique_ptr<ScConsolidateParam> pConsolidateDlgData;
 
    std::unique_ptr<ScAutoNameCache> pAutoNameCache;    // for automatic name lookup during CompileXML
 
    std::unique_ptr<SfxItemSet> pPreviewFont; // convert to std::unique_ptr or whatever
    ScStyleSheet*       pPreviewCellStyle;
    ScMarkData          maPreviewSelection;
    sal_Int64           nUnoObjectId;                   // counted up for UNO objects
 
    ErrCode             nRangeOverflowType;             // used in (xml) loading for overflow warnings
 
    ScRange             aEmbedRange;
    ScAddress           aCurTextWidthCalcPos;
 
    Idle                aTrackIdle;
 
    css::uno::Reference< css::script::vba::XVBAEventProcessor >
                        mxVbaEvents;
public:
    std::vector<ScInterpreterTableOpParams*> m_TableOpList;
    ScInterpreterTableOpParams  aLastTableOpParams;     // remember last params
 
private:
 
    LanguageType        eLanguage;                      // default language
    LanguageType        eCjkLanguage;                   // default language for asian text
    LanguageType        eCtlLanguage;                   // default language for complex text
    rtl_TextEncoding    eSrcSet;                        // during reading: source character set
 
    formula::FormulaGrammar::Grammar  eStorageGrammar;
 
    sal_uInt64              nFormulaCodeInTree;             // formula RPN in the formula tree
    sal_uInt64              nXMLImportedFormulaCount;       // progress count during XML import
    sal_uInt16              nInterpretLevel;                // >0 if in interpreter
    sal_uInt16              nMacroInterpretLevel;           // >0 if macro in interpreter
    sal_uInt16              nInterpreterTableOpLevel;       // >0 if in interpreter TableOp
 
    ScDocumentThreadSpecific maNonThreaded;
 
    // There can be only one ScDocument being calculated in a thread at a time, so we can use a
    // plain thread_local static member.
    thread_local static ScDocumentThreadSpecific maThreadSpecific;
 
    mutable ScInterpreterContext maInterpreterContext;
 
    std::shared_mutex mScLookupMutex; // protection for thread-unsafe parts of handling ScLookup
    std::unique_ptr<ScSortedRangeCacheMap> mxScSortedRangeCache; // cache for unsorted lookups
 
    static const sal_uInt16 nSrcVer;                        // file version (load/save)
    sal_uInt16              nFormulaTrackCount;
    HardRecalcState         eHardRecalcState;               // off, temporary, eternal
    SCTAB                   nVisibleTab;                    // for OLE etc., don't use inside ScDocument
    SCCOL                   nPosLeft;                       // for OLE etc., don't use inside ScDocument
    SCROW                   nPosTop;                        // for OLE etc., don't use inside ScDocument
 
    ScLkUpdMode         eLinkMode;
 
    bool                bAutoCalc;                      // calculate automatically
    bool                bAutoCalcShellDisabled;         // in/from/for ScDocShell disabled
    // are there ForcedFormulas which have to be calculated
    // in interaction with ScDocShell SetDocumentModified,
    // AutoCalcShellDisabled and TrackFormulas
    bool                bForcedFormulaPending;
    bool                bCalculatingFormulaTree;
    bool                bIsClip;
    bool                bIsUndo;
    bool                bIsFunctionAccess;
    bool                bIsVisible;                     // set from view ctor
 
    bool                bIsEmbedded;                    // display/adjust Embedded area?
 
    // no broadcast, construct no listener during insert from a different
    // Doc (per filter or the like ), not until CompileAll / CalcAfterLoad
    bool                bInsertingFromOtherDoc;
    bool                bLoadingMedium;
    bool                bImportingXML;      // special handling of formula text
    bool                bCalcingAfterLoad;              // in CalcAfterLoad TRUE
    // don't construct/destruct listeners temporarily
    bool                bNoListening;
    bool                mbIdleEnabled;
    bool                bInLinkUpdate;                  // TableLink or AreaLink
    bool                bChartListenerCollectionNeedsUpdate;
    // are/were there RC_FORCED formula cells in the document (if set once to TRUE then set forever)
    bool                bHasForcedFormulas;
    // is the Doc being destroyed? (no Notify-Tracking etc. needed anymore)
    bool                bInDtorClear;
    // expand reference if insert column/row takes place at the border
    // of a reference
    // is fetched in each UpdateReference from InputOptions,
    // assigned, and restored at the end of UpdateReference
    bool                bExpandRefs;
    // for detective update, is set for each change of a formula
    bool                bDetectiveDirty;
    // If the pointer is set, formula cells will not be automatically grouped into shared formula groups,
    // instead the range will be extended to contain all such cells.
    std::unique_ptr< ScRange > pDelayedFormulaGrouping;
    // If non-empty, ScColumn::StartListeningFormulaCells() calls may be delayed using this,
    // avoiding repeated calling for the same cells in the given range. The function will be called once
    // later for all the cells in the range.
    std::unordered_map< ScColumn*, std::pair<SCROW, SCROW>> pDelayedStartListeningFormulaCells;
    // Cells will not delete their broadcasters if delayed, avoiding possible extensive mdds vector changes.
    bool                bDelayedDeletingBroadcasters;
 
    bool                bLinkFormulaNeedingCheck; // valid only after loading, for ocDde and ocWebservice
 
    CharCompressType    nAsianCompression;
    sal_uInt8           nAsianKerning;
 
    bool                bPastingDrawFromOtherDoc;
 
    sal_uInt8           nInDdeLinkUpdate;   // originating DDE links (stacked bool)
 
    bool                bInUnoBroadcast;
    bool                bInUnoListenerCall;
    sal_uInt32          nAdjustHeightLock;
    formula::FormulaGrammar::Grammar  eGrammar;
 
    mutable bool        bStyleSheetUsageInvalid;
 
    bool                mbUndoEnabled:1;
    bool                mbExecuteLinkEnabled:1;
    bool                mbChangeReadOnlyEnabled:1;    // allow changes in read-only document (for API import filters)
    bool                mbStreamValidLocked:1;
    bool                mbUserInteractionEnabled:1;  // whether or not to launch any kind of interactive dialogs.
 
    sal_Int16           mnNamedRangesLockCount;
 
    std::set<ScFormulaCell*> maSubTotalCells;
 
 
    bool mbEmbedFonts : 1;
    bool mbEmbedUsedFontsOnly : 1;
    bool mbEmbedFontScriptLatin : 1;
    bool mbEmbedFontScriptAsian : 1;
    bool mbEmbedFontScriptComplex : 1;
 
    sal_Int32 mnImagePreferredDPI;
 
    std::unique_ptr<sc::IconSetBitmapMap> m_pIconSetBitmapMap;
 
    bool                mbTrackFormulasPending  : 1;
    bool                mbFinalTrackFormulas    : 1;
    // This indicates if a ScDocShell::DoRecalc() or ScDocShell::DoHardRecalc() is in progress.
    bool                mbDocShellRecalc        : 1;
    // This indicates if a ScOutputData::LayoutStrings() is in progress.
    bool                mbLayoutStrings         : 1;
 
    size_t              mnMutationGuardFlags;
 
public:
    bool                     IsCellInChangeTrack(const ScAddress &cell,Color *pColCellBorder);
    void                     GetCellChangeTrackNote(const ScAddress &cell, OUString &strTrackText, bool &pbLeftEdge);
 
    bool IsEmbedFonts() const { return mbEmbedFonts; }
    bool IsEmbedUsedFontsOnly() const { return mbEmbedUsedFontsOnly; }
    bool IsEmbedFontScriptLatin() const { return mbEmbedFontScriptLatin; }
    bool IsEmbedFontScriptAsian() const { return mbEmbedFontScriptAsian; }
    bool IsEmbedFontScriptComplex() const { return mbEmbedFontScriptComplex; }
 
    void SetEmbedFonts(bool bUse) { mbEmbedFonts = bUse; }
    void SetEmbedUsedFontsOnly(bool bUse) { mbEmbedUsedFontsOnly = bUse; }
    void SetEmbedFontScriptLatin(bool bUse) { mbEmbedFontScriptLatin = bUse; }
    void SetEmbedFontScriptAsian(bool bUse) { mbEmbedFontScriptAsian = bUse; }
    void SetEmbedFontScriptComplex(bool bUse) { mbEmbedFontScriptComplex = bUse; }
 
    void SetImagePreferredDPI(sal_Int32 nValue) { mnImagePreferredDPI = nValue; }
    sal_Int32 GetImagePreferredDPI() { return mnImagePreferredDPI; }
 
    SC_DLLPUBLIC sal_uInt64  GetCellCount() const;       // all cells
    SC_DLLPUBLIC sal_uInt64  GetFormulaGroupCount() const;       // all cells
    sal_uInt64               GetCodeCount() const;       // RPN-Code in formulas
    DECL_LINK( GetUserDefinedColor, sal_uInt16, Color* );
                                                                // number formatter
public:
    SC_DLLPUBLIC                ScDocument( ScDocumentMode eMode = SCDOCMODE_DOCUMENT,
                                            SfxObjectShell* pDocShell = nullptr );
    SC_DLLPUBLIC                ~ScDocument();
 
    void              SetName( const OUString& r ) { aDocName = r; }
    const OUString&   GetCodeName() const { return aDocCodeName; }
    void              SetCodeName( const OUString& r ) { aDocCodeName = r; }
    const OUString&   GetFileURL() const { return maFileURL; }
 
    void              GetDocStat( ScDocStat& rDocStat );
 
    SC_DLLPUBLIC void  InitDrawLayer( SfxObjectShell* pDocShell = nullptr );
 
    ScInterpreterContext& GetNonThreadedContext() const
    {
        assert(!IsThreadedGroupCalcInProgress());
        return maInterpreterContext;
    }
    // Uses thread_local.
    ScInterpreterContext& GetThreadedContext() const
    {
        return IsThreadedGroupCalcInProgress() ? *maThreadSpecific.pContext : GetNonThreadedContext();
    }
    void SetupContextFromNonThreadedContext( ScInterpreterContext& threadedContext, int threadNumber );
    void MergeContextBackIntoNonThreadedContext( ScInterpreterContext& threadedContext, int threadNumber );
    void SetThreadedGroupCalcInProgress( bool set ) { (void)this; ScGlobal::bThreadedGroupCalcInProgress = set; }
    bool IsThreadedGroupCalcInProgress() const { (void)this; return ScGlobal::bThreadedGroupCalcInProgress; }
 
    SC_DLLPUBLIC sfx2::LinkManager*       GetLinkManager();
    SC_DLLPUBLIC const sfx2::LinkManager* GetLinkManager() const;
 
    sc::DocumentLinkManager&       GetDocLinkManager();
    const sc::DocumentLinkManager& GetDocLinkManager() const;
 
    SC_DLLPUBLIC const ScDocOptions&    GetDocOptions() const;
    SC_DLLPUBLIC void                   SetDocOptions( const ScDocOptions& rOpt );
    SC_DLLPUBLIC const ScViewOptions&   GetViewOptions() const;
    SC_DLLPUBLIC void                   SetViewOptions( const ScViewOptions& rOpt );
    void                                SetPrintOptions();
 
    ScExtDocOptions*            GetExtDocOptions()  { return pExtDocOptions.get(); }
    SC_DLLPUBLIC void           SetExtDocOptions( std::unique_ptr<ScExtDocOptions> pNewOptions );
 
    ScClipOptions*              GetClipOptions()    { return mpClipOptions.get(); }
    void                        SetClipOptions(std::unique_ptr<ScClipOptions> pClipOptions);
 
    SC_DLLPUBLIC void           GetLanguage( LanguageType& rLatin, LanguageType& rCjk, LanguageType& rCtl ) const;
    void                        SetLanguage( LanguageType eLatin, LanguageType eCjk, LanguageType eCtl );
 
    void                        SetConsolidateDlgData( std::unique_ptr<ScConsolidateParam> pData );
    const ScConsolidateParam*   GetConsolidateDlgData() const { return pConsolidateDlgData.get(); }
 
    void                        Clear( bool bFromDestructor = false );
 
    std::unique_ptr<ScFieldEditEngine> CreateFieldEditEngine();
    void                        DisposeFieldEditEngine(std::unique_ptr<ScFieldEditEngine>& rpEditEngine);
 
    SC_DLLPUBLIC void          GetAllTabRangeNames(ScRangeName::TabNameCopyMap& rRangeNames) const;
    SC_DLLPUBLIC void          SetAllRangeNames(const std::map<OUString, ScRangeName>& rRangeMap);
    SC_DLLPUBLIC void          GetRangeNameMap(std::map<OUString, ScRangeName*>& rRangeName);
    SC_DLLPUBLIC ScRangeName*  GetRangeName(SCTAB nTab) const;
    SC_DLLPUBLIC ScRangeName*  GetRangeName() const;
    void                       SetRangeName(SCTAB nTab, std::unique_ptr<ScRangeName> pNew);
    void                       SetRangeName( std::unique_ptr<ScRangeName> pNewRangeName );
    bool                       IsAddressInRangeName( RangeNameScope eScope, const ScAddress& rAddress);
 
    ScRangeData* FindRangeNameBySheetAndIndex( SCTAB nTab, sal_uInt16 nIndex ) const;
 
    bool FindRangeNamesReferencingSheet( sc::UpdatedRangeNames& rIndexes,
            SCTAB nTokenTab, const sal_uInt16 nTokenIndex,
            SCTAB nGlobalRefTab, SCTAB nLocalRefTab, SCTAB nOldTokenTab, SCTAB nOldTokenTabReplacement,
            bool bSameDoc, int nRecursion ) const;
 
    bool CopyAdjustRangeName( SCTAB& rSheet, sal_uInt16& rIndex, ScRangeData*& rpRangeData, ScDocument& rNewDoc,
            const ScAddress& rNewPos, const ScAddress& rOldPos, const bool bGlobalNamesToLocal,
            const bool bUsedByFormula ) const;
 
    SC_DLLPUBLIC void PreprocessAllRangeNamesUpdate( const std::map<OUString, ScRangeName>& rRangeMap );
    SC_DLLPUBLIC void PreprocessRangeNameUpdate();
    SC_DLLPUBLIC void PreprocessDBDataUpdate();
    SC_DLLPUBLIC void CompileHybridFormula();
 
    bool InsertNewRangeName( const OUString& rName, const ScAddress& rPos, const OUString& rExpr );
 
    bool InsertNewRangeName( SCTAB nTab, const OUString& rName, const ScAddress& rPos, const OUString& rExpr );
 
    SC_DLLPUBLIC sal_Unicode GetSheetSeparator() const;
 
    SCTAB GetMaxTableNumber() const { return static_cast<SCTAB>(maTabs.size()) - 1; }
 
    ScRangePairList*    GetColNameRanges() { return xColNameRanges.get(); }
    ScRangePairList*    GetRowNameRanges() { return xRowNameRanges.get(); }
    ScRangePairListRef& GetColNameRangesRef() { return xColNameRanges; }
    ScRangePairListRef& GetRowNameRangesRef() { return xRowNameRanges; }
 
    SC_DLLPUBLIC SCCOL ClampToAllocatedColumns(SCTAB nTab, SCCOL nCol) const;
    SC_DLLPUBLIC SCCOL GetAllocatedColumnsCount(SCTAB nTab) const;
 
    SC_DLLPUBLIC ScDBCollection* GetDBCollection() const { return pDBCollection.get();}
    void                         SetDBCollection( std::unique_ptr<ScDBCollection> pNewDBCollection,
                                                  bool bRemoveAutoFilter = false );
    const ScDBData*              GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) const;
    ScDBData*                    GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion);
    SC_DLLPUBLIC const ScDBData* GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const;
    SC_DLLPUBLIC ScDBData*       GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
    void                         RefreshDirtyTableColumnNames();
    SC_DLLPUBLIC sc::ExternalDataMapper& GetExternalDataMapper();
 
    SC_DLLPUBLIC const ScRangeData* GetRangeAtBlock( const ScRange& rBlock, OUString& rName,
                                                     bool* pSheetLocal = nullptr ) const;
 
    SC_DLLPUBLIC bool                  HasPivotTable() const;
    SC_DLLPUBLIC ScDPCollection*       GetDPCollection();
    SC_DLLPUBLIC const ScDPCollection* GetDPCollection() const;
    SC_DLLPUBLIC ScDPObject*           GetDPAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab) const;
    SC_DLLPUBLIC ScDPObject*           GetDPAtCursor(ScAddress const& rAddress) const
    {
        return GetDPAtCursor(rAddress.Col(), rAddress.Row(), rAddress.Tab());
    }
    SC_DLLPUBLIC bool HasDataPilotAtPosition(ScAddress const& rAddress) const
    {
        return GetDPAtCursor(rAddress) != nullptr;
    }
    ScDPObject*                        GetDPAtBlock( const ScRange& rBlock ) const;
 
    void                               StopTemporaryChartLock();
 
    void                               EnsureGraphicNames();
 
    SdrObject*      GetObjectAtPoint( SCTAB nTab, const Point& rPos );
    bool            HasChartAtPoint( SCTAB nTab, const Point& rPos, OUString& rName );
 
    css::uno::Reference< css::chart2::XChartDocument > GetChartByName( std::u16string_view rChartName );
 
    SC_DLLPUBLIC void GetChartRanges( std::u16string_view rChartName, std::vector< ScRangeList >& rRanges, const ScDocument& rSheetNameDoc );
    void              SetChartRanges( std::u16string_view rChartName, const std::vector< ScRangeList >& rRanges );
 
    void              UpdateChartArea( const OUString& rChartName, const ScRange& rNewArea,
                                       bool bColHeaders, bool bRowHeaders, bool bAdd );
    void              UpdateChartArea( const OUString& rChartName,
                                       const ScRangeListRef& rNewList,
                                       bool bColHeaders, bool bRowHeaders, bool bAdd );
    void              GetOldChartParameters( std::u16string_view rName,
                                             ScRangeList& rRanges, bool& rColHeaders, bool& rRowHeaders );
    css::uno::Reference<
            css::embed::XEmbeddedObject >
                    FindOleObjectByName( std::u16string_view rName );
 
    SC_DLLPUBLIC void MakeTable( SCTAB nTab,bool _bNeedsNameCheck = true );
 
    SCTAB             GetVisibleTab() const       { return nVisibleTab; }
    SC_DLLPUBLIC void SetVisibleTab(SCTAB nTab)   { nVisibleTab = nTab; }
    SCCOL             GetPosLeft() const          { return nPosLeft; }
    SC_DLLPUBLIC void SetPosLeft(SCCOL nCol)      { nPosLeft = nCol; }
    SCROW             GetPosTop() const           { return nPosTop; }
    SC_DLLPUBLIC void SetPosTop(SCROW nRow)       { nPosTop = nRow; }
 
    SC_DLLPUBLIC bool HasTable( SCTAB nTab ) const;
    SC_DLLPUBLIC bool GetHashCode( SCTAB nTab, sal_Int64& rHashCode) const;
    SC_DLLPUBLIC bool GetName( SCTAB nTab, OUString& rName ) const;
    SC_DLLPUBLIC bool GetCodeName( SCTAB nTab, OUString& rName ) const;
    SC_DLLPUBLIC bool SetCodeName( SCTAB nTab, const OUString& rName );
    SC_DLLPUBLIC bool GetTable( const OUString& rName, SCTAB& rTab ) const;
    SC_DLLPUBLIC SCCOL MaxCol() const { return mxSheetLimits->mnMaxCol; }
    SC_DLLPUBLIC SCROW MaxRow() const { return mxSheetLimits->mnMaxRow; }
    SC_DLLPUBLIC SCCOL GetMaxColCount() const { return mxSheetLimits->GetMaxColCount(); }
    SC_DLLPUBLIC SCROW GetMaxRowCount() const { return mxSheetLimits->GetMaxRowCount(); }
    SC_DLLPUBLIC OUString MaxRowAsString() const { return mxSheetLimits->MaxRowAsString(); }
    SC_DLLPUBLIC OUString MaxColAsString() const { return mxSheetLimits->MaxColAsString(); }
    ScSheetLimits& GetSheetLimits() const { return *mxSheetLimits; }
    [[nodiscard]] bool ValidCol(SCCOL nCol) const { return ::ValidCol(nCol, mxSheetLimits->mnMaxCol); }
    [[nodiscard]] bool ValidRow(SCROW nRow) const { return ::ValidRow(nRow, mxSheetLimits->mnMaxRow); }
    [[nodiscard]] bool ValidColRow(SCCOL nCol, SCROW nRow) const { return ::ValidColRow(nCol, nRow, MaxCol(), MaxRow()); }
    [[nodiscard]] bool ValidColRowTab(SCCOL nCol, SCROW nRow, SCTAB nTab) const { return ::ValidColRowTab(nCol, nRow, nTab, MaxCol(), MaxRow()); }
    [[nodiscard]] bool ValidRange(const ScRange& rRange) const { return ::ValidRange(rRange, MaxCol(), MaxRow()); }
    [[nodiscard]] bool ValidAddress(const ScAddress& rAddress) const { return ::ValidAddress(rAddress, MaxCol(), MaxRow()); }
    [[nodiscard]] SCCOL SanitizeCol( SCCOL nCol ) const { return ::SanitizeCol(nCol, MaxCol()); }
    [[nodiscard]] SCROW SanitizeRow( SCROW nRow ) const { return ::SanitizeRow(nRow, MaxRow()); }
 
    SC_DLLPUBLIC std::vector<OUString> GetAllTableNames() const;
 
    OUString GetCopyTabName(SCTAB nTab) const;
 
    SC_DLLPUBLIC void      SetAnonymousDBData(SCTAB nTab, std::unique_ptr<ScDBData> pDBData);
    SC_DLLPUBLIC ScDBData* GetAnonymousDBData(SCTAB nTab);
 
    SC_DLLPUBLIC void             SetAnonymousDBData(std::unique_ptr<ScDBData> pDBData);
    SC_DLLPUBLIC ScDBData*        GetAnonymousDBData();
 
    SC_DLLPUBLIC SCTAB            GetTableCount() const;
    SvNumberFormatterIndexTable*  GetFormatExchangeList() const { return pFormatExchangeList; }
 
    SC_DLLPUBLIC ScDocProtection*      GetDocProtection() const;
    SC_DLLPUBLIC void                  SetDocProtection(const ScDocProtection* pProtect);
    SC_DLLPUBLIC bool                  IsDocProtected() const;
    bool                               IsDocEditable() const;
    SC_DLLPUBLIC bool                  IsTabProtected( SCTAB nTab ) const;
    SC_DLLPUBLIC const ScTableProtection* GetTabProtection(SCTAB nTab) const;
    SC_DLLPUBLIC void                  SetTabProtection(SCTAB nTab, const ScTableProtection* pProtect);
    void                               CopyTabProtection(SCTAB nTabSrc, SCTAB nTabDest);
 
    void            LockTable(SCTAB nTab);
    void            UnlockTable(SCTAB nTab);
 
    bool            IsBlockEditable( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
                                     SCCOL nEndCol, SCROW nEndRow,
                                     bool* pOnlyNotBecauseOfMatrix = nullptr,
                                     bool bNoMatrixAtAll = false ) const;
    bool            IsSelectionEditable( const ScMarkData& rMark,
                                         bool* pOnlyNotBecauseOfMatrix = nullptr ) const;
    bool            HasSelectedBlockMatrixFragment( SCCOL nStartCol, SCROW nStartRow,
                                                    SCCOL nEndCol, SCROW nEndRow,
                                                    const ScMarkData& rMark ) const;
 
    bool IsEditActionAllowed( sc::ColRowEditAction eAction, SCTAB nTab, SCCOLROW nStart, SCCOLROW nEnd ) const;
    bool IsEditActionAllowed( sc::ColRowEditAction eAction, const ScMarkData& rMark, SCCOLROW nStart, SCCOLROW nEnd ) const;
 
    SC_DLLPUBLIC bool GetMatrixFormulaRange( const ScAddress& rCellPos, ScRange& rMatrix );
 
    bool            IsEmbedded() const { return bIsEmbedded;}
    void            GetEmbedded( ScRange& rRange ) const;
    void            SetEmbedded( const ScRange& rRange );
    void            ResetEmbedded();
    tools::Rectangle       GetEmbeddedRect() const;                        // 1/100 mm
    void            SetEmbedded( SCTAB nTab, const tools::Rectangle& rRect );          // from VisArea (1/100 mm)
 
    static SC_DLLPUBLIC bool ValidTabName( const OUString& rName );
 
    SC_DLLPUBLIC bool           ValidNewTabName( const OUString& rName ) const;
    SC_DLLPUBLIC void           CreateValidTabName(OUString& rName) const;
    SC_DLLPUBLIC void           CreateValidTabNames(std::vector<OUString>& aNames, SCTAB nCount) const;
 
    void AppendTabOnLoad(const OUString& rName);
    void SetTabNameOnLoad(SCTAB nTab, const OUString& rName);
    void InvalidateStreamOnSave();
 
    SC_DLLPUBLIC bool           InsertTab( SCTAB nPos, const OUString& rName,
                                          bool bExternalDocument = false, bool bUndoDeleteTab = false );
 
    SC_DLLPUBLIC bool           InsertTabs( SCTAB nPos, const std::vector<OUString>& rNames,
                                            bool bNamesValid = false );
    SC_DLLPUBLIC bool           DeleteTabs( SCTAB nTab, SCTAB nSheets );
    SC_DLLPUBLIC bool           DeleteTab( SCTAB nTab );
    SC_DLLPUBLIC bool           RenameTab( SCTAB nTab, const OUString& rName,
                                           bool bExternalDocument = false );
    bool                        MoveTab( SCTAB nOldPos, SCTAB nNewPos, ScProgress* pProgress = nullptr );
    SC_DLLPUBLIC bool           CopyTab( SCTAB nOldPos, SCTAB nNewPos,
                                         const ScMarkData* pOnlyMarked = nullptr );
    SC_DLLPUBLIC sal_uLong      TransferTab(ScDocument& rSrcDoc, SCTAB nSrcPos, SCTAB nDestPos,
                                            bool bInsertNew = true,
                                            bool bResultsOnly = false );
    SC_DLLPUBLIC void           TransferDrawPage(const ScDocument& rSrcDoc, SCTAB nSrcPos, SCTAB nDestPos);
    SC_DLLPUBLIC void           SetVisible( SCTAB nTab, bool bVisible );
    SC_DLLPUBLIC bool           IsVisible( SCTAB nTab ) const;
    bool                        IsStreamValid( SCTAB nTab ) const;
    void                        SetStreamValid( SCTAB nTab, bool bSet, bool bIgnoreLock = false );
    void                        LockStreamValid( bool bLock );
    bool                        IsStreamValidLocked() const { return mbStreamValidLocked; }
    bool                        IsPendingRowHeights( SCTAB nTab ) const;
    void                        SetPendingRowHeights( SCTAB nTab, bool bSet );
    SC_DLLPUBLIC void           SetLayoutRTL( SCTAB nTab, bool bRTL, ScObjectHandling eObjectHandling = ScObjectHandling::RecalcPosMode);
    SC_DLLPUBLIC bool           IsLayoutRTL( SCTAB nTab ) const;
    SC_DLLPUBLIC bool           IsNegativePage( SCTAB nTab ) const;
    SC_DLLPUBLIC void           SetScenario( SCTAB nTab, bool bFlag );
    SC_DLLPUBLIC bool           IsScenario( SCTAB nTab ) const;
    SC_DLLPUBLIC void           GetScenarioData(SCTAB nTab, OUString& rComment,
                                                Color& rColor, ScScenarioFlags &rFlags) const;
    SC_DLLPUBLIC void           SetScenarioData(SCTAB nTab, const OUString& rComment,
                                                const Color& rColor, ScScenarioFlags nFlags);
    SC_DLLPUBLIC Color          GetTabBgColor( SCTAB nTab ) const;
    SC_DLLPUBLIC void           SetTabBgColor( SCTAB nTab, const Color& rColor );
    SC_DLLPUBLIC bool           IsDefaultTabBgColor( SCTAB nTab ) const;
    void                        GetScenarioFlags(SCTAB nTab, ScScenarioFlags &rFlags) const;
    SC_DLLPUBLIC bool           IsActiveScenario( SCTAB nTab ) const;
    SC_DLLPUBLIC void           SetActiveScenario( SCTAB nTab, bool bActive );      // only for Undo etc.
    SC_DLLPUBLIC formula::FormulaGrammar::AddressConvention GetAddressConvention() const;
    SC_DLLPUBLIC formula::FormulaGrammar::Grammar           GetGrammar() const { return eGrammar;}
    SC_DLLPUBLIC void                                       SetGrammar( formula::FormulaGrammar::Grammar eGram );
    SC_DLLPUBLIC ScLinkMode                                 GetLinkMode( SCTAB nTab ) const;
    bool                                                    IsLinked( SCTAB nTab ) const;
    SC_DLLPUBLIC OUString                                   GetLinkDoc( SCTAB nTab ) const;
    OUString                                                GetLinkFlt( SCTAB nTab ) const;
    OUString                                                GetLinkOpt( SCTAB nTab ) const;
    SC_DLLPUBLIC OUString                                   GetLinkTab( SCTAB nTab ) const;
    sal_uLong                                               GetLinkRefreshDelay( SCTAB nTab ) const;
    void                                                    SetLink( SCTAB nTab, ScLinkMode nMode, const OUString& rDoc,
                                                                     const OUString& rFilter, const OUString& rOptions,
                                                                     const OUString& rTabName, sal_uLong nRefreshDelay );
    bool                                                    HasLink( std::u16string_view rDoc,
                                                                     std::u16string_view rFilter, std::u16string_view rOptions ) const;
    SC_DLLPUBLIC bool                                       LinkExternalTab( SCTAB& nTab, const OUString& aDocTab,
                                                                             const OUString& aFileName,
                                                                             const OUString& aTabName );
 
    bool                               HasExternalRefManager() const { return bool(pExternalRefMgr); }
    SC_DLLPUBLIC ScExternalRefManager* GetExternalRefManager() const;
    bool                               IsInExternalReferenceMarking() const;
    void                               MarkUsedExternalReferences();
    bool                               MarkUsedExternalReferences( const ScTokenArray& rArr, const ScAddress& rPos );
 
    ScFormulaParserPool& GetFormulaParserPool() const;
 
    bool            HasAreaLinks() const;
    void            UpdateExternalRefLinks(weld::Window* pWin);
    void            UpdateAreaLinks();
 
                    // originating DDE links
    void            IncInDdeLinkUpdate() { if ( nInDdeLinkUpdate < 255 ) ++nInDdeLinkUpdate; }
    void            DecInDdeLinkUpdate() { if ( nInDdeLinkUpdate ) --nInDdeLinkUpdate; }
    bool            IsInDdeLinkUpdate() const   { return nInDdeLinkUpdate != 0; }
 
    SC_DLLPUBLIC void CopyDdeLinks( ScDocument& rDestDoc ) const;
 
    SC_DLLPUBLIC bool FindDdeLink( std::u16string_view rAppl, std::u16string_view rTopic,
                                   std::u16string_view rItem, sal_uInt8 nMode, size_t& rnDdePos );
 
    bool            GetDdeLinkData( size_t nDdePos, OUString& rAppl, OUString& rTopic, OUString& rItem ) const;
    bool            GetDdeLinkMode( size_t nDdePos, sal_uInt8& rnMode ) const;
    SC_DLLPUBLIC const ScMatrix* GetDdeLinkResultMatrix( size_t nDdePos ) const;
 
    SC_DLLPUBLIC bool            CreateDdeLink( const OUString& rAppl, const OUString& rTopic, const OUString& rItem, sal_uInt8 nMode, const ScMatrixRef& pResults );
    bool            SetDdeLinkResultMatrix( size_t nDdePos, const ScMatrixRef& pResults );
 
    SfxBindings*                    GetViewBindings();
    SfxObjectShell*                 GetDocumentShell() const    { return mpShell; }
    SC_DLLPUBLIC ScDrawLayer*       GetDrawLayer() { return mpDrawLayer.get();  }
    SC_DLLPUBLIC const ScDrawLayer* GetDrawLayer() const { return mpDrawLayer.get();  }
    SfxBroadcaster*                 GetDrawBroadcaster();       // to avoid header
    void                            BeginDrawUndo();
 
    void            BeginUnoRefUndo();
    bool            HasUnoRefUndo() const       { return ( pUnoRefUndoList != nullptr ); }
    [[nodiscard]]
    std::unique_ptr<ScUnoRefList> EndUnoRefUndo();            // must be deleted by caller!
    sal_Int64       GetNewUnoId() { return ++nUnoObjectId; }
    void            AddUnoRefChange( sal_Int64 nId, const ScRangeList& rOldRanges );
 
    static bool IsChart( const SdrObject* pObject );
 
    void              UpdateChartRef( UpdateRefMode eUpdateRefMode,
                                    SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
                                    SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
                                    SCCOL nDx, SCROW nDy, SCTAB nDz );
    void            SetChartRangeList( std::u16string_view rChartName,
                                       const ScRangeListRef& rNewRangeListRef );
 
    void            StartAnimations( SCTAB nTab );
 
    bool            HasBackgroundDraw( SCTAB nTab, const tools::Rectangle& rMMRect ) const;
    bool            HasAnyDraw( SCTAB nTab, const tools::Rectangle& rMMRect ) const;
 
    const ScSheetEvents* GetSheetEvents( SCTAB nTab ) const;
    void                 SetSheetEvents( SCTAB nTab, std::unique_ptr<ScSheetEvents> pNew );
    bool                 HasSheetEventScript( SCTAB nTab, ScSheetEventId nEvent, bool bWithVbaEvents = false ) const;
    bool                 HasAnySheetEventScript( ScSheetEventId nEvent, bool bWithVbaEvents = false ) const;  // on any sheet
 
    bool            HasAnyCalcNotification() const;
    bool            HasCalcNotification( SCTAB nTab ) const;
    void            SetCalcNotification( SCTAB nTab );
    void            ResetCalcNotifications();
 
    SC_DLLPUBLIC ScOutlineTable*    GetOutlineTable( SCTAB nTab, bool bCreate = false );
    bool                            SetOutlineTable( SCTAB nTab, const ScOutlineTable* pNewOutline );
 
    void                            DoAutoOutline( SCCOL nStartCol, SCROW nStartRow,
                                                   SCCOL nEndCol, SCROW nEndRow, SCTAB nTab );
 
    bool            DoSubTotals( SCTAB nTab, ScSubTotalParam& rParam );
    void            RemoveSubTotals( SCTAB nTab, ScSubTotalParam& rParam );
    bool            TestRemoveSubTotals( SCTAB nTab, const ScSubTotalParam& rParam );
    bool            HasSubTotalCells( const ScRange& rRange );
 
    SC_DLLPUBLIC void EnsureTable( SCTAB nTab );
 
                    //  return TRUE = number format is set
    SC_DLLPUBLIC bool SetString( SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString& rString,
                                 const ScSetStringParam * pParam = nullptr );
    SC_DLLPUBLIC bool SetString( const ScAddress& rPos, const OUString& rString,
                                 const ScSetStringParam* pParam = nullptr );
 
    SC_DLLPUBLIC bool  SetEditText( const ScAddress& rPos, std::unique_ptr<EditTextObject> pEditText );
    void               SetEditText( const ScAddress& rPos, const EditTextObject& rEditText, const SfxItemPool* pEditPool );
    SC_DLLPUBLIC void  SetEditText( const ScAddress& rPos, const OUString& rStr );
    SC_DLLPUBLIC SCROW GetFirstEditTextRow( const ScRange& rRange ) const;
 
    SC_DLLPUBLIC void SetTextCell( const ScAddress& rPos, const OUString& rStr );
    void              SetEmptyCell( const ScAddress& rPos );
    SC_DLLPUBLIC void SetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, const double& rVal );
    SC_DLLPUBLIC void SetValue( const ScAddress& rPos, double fVal );
    void              SetValues( const ScAddress& rPos, const std::vector<double>& rVals );
    void              SetError( SCCOL nCol, SCROW nRow, SCTAB nTab, const FormulaError nError);
    SC_DLLPUBLIC void SetFormula( const ScAddress& rPos, const ScTokenArray& rArray );
    SC_DLLPUBLIC void SetFormula( const ScAddress& rPos, const OUString& rFormula,
                                  formula::FormulaGrammar::Grammar eGram );
 
    SC_DLLPUBLIC ScFormulaCell*  SetFormulaCell( const ScAddress& rPos, ScFormulaCell* pCell );
    bool                         SetFormulaCells( const ScAddress& rPos, std::vector<ScFormulaCell*>& rCells );
 
    bool              HasFormulaCell( const ScRange& rRange ) const;
    SC_DLLPUBLIC void InsertMatrixFormula(SCCOL nCol1, SCROW nRow1,
                                        SCCOL nCol2, SCROW nRow2,
                                        const ScMarkData& rMark,
                                        const OUString& rFormula,
                                        const ScTokenArray* p = nullptr,
                                        const formula::FormulaGrammar::Grammar = formula::FormulaGrammar::GRAM_DEFAULT );
    SC_DLLPUBLIC void InsertTableOp(const ScTabOpParam& rParam,   // multi-operation
                                    SCCOL nCol1, SCROW nRow1,
                                    SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark);
 
    SC_DLLPUBLIC OUString GetString( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                     const ScInterpreterContext* pContext = nullptr ) const;
    SC_DLLPUBLIC OUString GetString( const ScAddress& rPos,
                                     const ScInterpreterContext* pContext = nullptr ) const;
 
    SC_DLLPUBLIC double*                      GetValueCell( const ScAddress& rPos );
 
    SC_DLLPUBLIC svl::SharedStringPool&       GetSharedStringPool();
    const svl::SharedStringPool&              GetSharedStringPool() const;
 
    svl::SharedString                         GetSharedString( const ScAddress& rPos ) const;
 
    std::shared_ptr<sc::FormulaGroupContext>& GetFormulaGroupContext();
    void                                      DiscardFormulaGroupContext();
    void                                      BlockFormulaGroupContextDiscard( bool block )
                                                  { mbFormulaGroupCxtBlockDiscard = block; }
 
    // Note that if pShared is set and a value is returned that way, the returned OUString is empty.
    SC_DLLPUBLIC OUString                     GetInputString( SCCOL nCol, SCROW nRow, SCTAB nTab, bool bForceSystemLocale = false ) const;
    FormulaError                              GetStringForFormula( const ScAddress& rPos, OUString& rString );
    SC_DLLPUBLIC double                       GetValue( const ScAddress& rPos ) const;
    SC_DLLPUBLIC double                       GetValue( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    SC_DLLPUBLIC const EditTextObject*        GetEditText( const ScAddress& rPos ) const;
    void                                      RemoveEditTextCharAttribs( const ScAddress& rPos, const ScPatternAttr& rAttr );
    SC_DLLPUBLIC double                       RoundValueAsShown( double fVal, sal_uInt32 nFormat, const ScInterpreterContext* pContext = nullptr ) const;
    SC_DLLPUBLIC sal_uInt32                   GetNumberFormat( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    sal_uInt32                                GetNumberFormat( const ScRange& rRange ) const;
    SC_DLLPUBLIC sal_uInt32                   GetNumberFormat( const ScInterpreterContext& rContext, const ScAddress& ) const;
    SC_DLLPUBLIC void                         SetNumberFormat( const ScAddress& rPos, sal_uInt32 nNumberFormat );
 
    void                                      GetNumberFormatInfo( const ScInterpreterContext& rContext, SvNumFormatType& nType, sal_uInt32& nIndex, const ScAddress& rPos ) const;
    SC_DLLPUBLIC const ScFormulaCell*         GetFormulaCell( const ScAddress& rPos ) const;
    SC_DLLPUBLIC ScFormulaCell*               GetFormulaCell( const ScAddress& rPos );
    SC_DLLPUBLIC OUString                     GetFormula( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    SC_DLLPUBLIC CellType                     GetCellType( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    SC_DLLPUBLIC CellType                     GetCellType( const ScAddress& rPos ) const;
 
    SC_DLLPUBLIC bool                         HasData( SCCOL nCol, SCROW nRow, SCTAB nTab );
    SC_DLLPUBLIC bool                         HasStringData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    SC_DLLPUBLIC bool                         HasValueData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    SC_DLLPUBLIC bool                         HasValueData( const ScAddress& rPos ) const;
    bool                                      HasStringCells( const ScRange& rRange ) const;
 
    bool            HasSelectionData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    bool            HasValidationData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
 
    sc::MultiDataCellState HasMultipleDataCells( const ScRange& rRange ) const;
 
    // Spaklines
    SC_DLLPUBLIC std::shared_ptr<sc::Sparkline> GetSparkline(ScAddress const & rPosition);
    SC_DLLPUBLIC bool HasSparkline(ScAddress const & rPosition);
    SC_DLLPUBLIC sc::Sparkline* CreateSparkline(ScAddress const & rPosition, std::shared_ptr<sc::SparklineGroup> const& pSparklineGroup);
    SC_DLLPUBLIC sc::SparklineList* GetSparklineList(SCTAB nTab);
    SC_DLLPUBLIC bool DeleteSparkline(ScAddress const& rPosition);
 
    SC_DLLPUBLIC bool GetSparklineGroupInRange(ScRange const& rRange, std::shared_ptr<sc::SparklineGroup>& rGroup);
    SC_DLLPUBLIC bool HasOneSparklineGroup(ScRange const& rRange);
    SC_DLLPUBLIC std::shared_ptr<sc::SparklineGroup> SearchSparklineGroup(tools::Guid const& rGuid);
 
    // Notes
    SC_DLLPUBLIC ScPostIt*       GetNote(const ScAddress& rPos);
    SC_DLLPUBLIC ScPostIt*       GetNote(SCCOL nCol, SCROW nRow, SCTAB nTab);
    void                         SetNote(const ScAddress& rPos, std::unique_ptr<ScPostIt> pNote);
    void                         SetNote(SCCOL nCol, SCROW nRow, SCTAB nTab, std::unique_ptr<ScPostIt> pNote);
    SC_DLLPUBLIC bool            HasNote(const ScAddress& rPos) const;
    bool                         HasNote(SCCOL nCol, SCROW nRow, SCTAB nTab) const;
    bool                         HasNote(SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow) const;
    SC_DLLPUBLIC bool            HasColNotes(SCCOL nCol, SCTAB nTab) const;
    SC_DLLPUBLIC bool            HasTabNotes(SCTAB nTab) const;
    bool                         HasNotes() const;
    SC_DLLPUBLIC std::unique_ptr<ScPostIt> ReleaseNote(const ScAddress& rPos);
    SC_DLLPUBLIC ScPostIt*       GetOrCreateNote(const ScAddress& rPos);
    SC_DLLPUBLIC ScPostIt*       CreateNote(const ScAddress& rPos);
    size_t                       GetNoteCount( SCTAB nTab, SCCOL nCol ) const;
 
    void                 CreateAllNoteCaptions();
    void                 ForgetNoteCaptions( const ScRangeList& rRanges, bool bPreserveData );
    CommentCaptionState  GetAllNoteCaptionsState( const ScRangeList& rRanges);
 
    ScAddress GetNotePosition( size_t nIndex ) const;
    ScAddress GetNotePosition( size_t nIndex, SCTAB nTab ) const;
    SCROW     GetNotePosition( SCTAB nTab, SCCOL nCol, size_t nIndex ) const;
 
    SC_DLLPUBLIC void GetAllNoteEntries( std::vector<sc::NoteEntry>& rNotes ) const;
    SC_DLLPUBLIC void GetAllNoteEntries( SCTAB nTab, std::vector<sc::NoteEntry>& rNotes ) const;
    void              GetNotesInRange( const ScRangeList& rRange, std::vector<sc::NoteEntry>& rNotes ) const;
 
    bool              ContainsNotesInRange( const ScRangeList& rRange ) const;
 
    SC_DLLPUBLIC void SetDrawPageSize(SCTAB nTab);
 
    bool              IsMerged( const ScAddress& rPos ) const;
 
    void              ExtendMergeSel( SCCOL nStartCol, SCROW nStartRow,
                                      SCCOL& rEndCol, SCROW& rEndRow, const ScMarkData& rMark,
                                      bool bRefresh = false );
    SC_DLLPUBLIC bool ExtendMerge( SCCOL nStartCol, SCROW nStartRow,
                                   SCCOL& rEndCol, SCROW& rEndRow, SCTAB nTab,
                                   bool bRefresh = false );
    bool              ExtendMerge( ScRange& rRange, bool bRefresh = false );
    SC_DLLPUBLIC void ExtendTotalMerge( ScRange& rRange ) const;
    SC_DLLPUBLIC void ExtendOverlapped( SCCOL& rStartCol, SCROW& rStartRow,
                                        SCCOL nEndCol, SCROW nEndRow, SCTAB nTab ) const;
    SC_DLLPUBLIC void ExtendOverlapped( ScRange& rRange ) const;
 
    bool              RefreshAutoFilter( SCCOL nStartCol, SCROW nStartRow,
                                         SCCOL nEndCol, SCROW nEndRow, SCTAB nTab );
 
    SC_DLLPUBLIC void DoMergeContents( SCCOL nStartCol, SCROW nStartRow,
                                       SCCOL nEndCol, SCROW nEndRow, SCTAB nTab );
    SC_DLLPUBLIC void DoEmptyBlock( SCCOL nStartCol, SCROW nStartRow,
                                    SCCOL nEndCol, SCROW nEndRow, SCTAB nTab );
                    //  without checking:
    SC_DLLPUBLIC void DoMerge( SCCOL nStartCol, SCROW nStartRow,
                               SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, bool bDeleteCaptions = true );
    void              RemoveMerge( SCCOL nCol, SCROW nRow, SCTAB nTab );
 
    // This also includes e.g. notes. Use IsEmptyData() for cell data only.
    bool              IsBlockEmpty( SCCOL nStartCol, SCROW nStartRow,
                                    SCCOL nEndCol, SCROW nEndRow, SCTAB nTab ) const;
    bool              IsPrintEmpty( SCCOL nStartCol, SCROW nStartRow,
                                    SCCOL nEndCol, SCROW nEndRow, SCTAB nTab,
                                    bool bLeftIsEmpty = false,
                                    ScRange* pLastRange = nullptr,
                                    tools::Rectangle* pLastMM = nullptr ) const;
 
    void            SkipOverlapped( SCCOL& rCol, SCROW& rRow, SCTAB nTab ) const;
    bool            IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    bool            IsVerOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                     SCROW* nStartRow = nullptr, SCROW* nEndRow = nullptr ) const;
 
    SC_DLLPUBLIC bool HasAttrib( SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
                                 SCCOL nCol2, SCROW nRow2, SCTAB nTab2, HasAttrFlags nMask ) const;
    SC_DLLPUBLIC bool HasAttrib( const ScRange& rRange, HasAttrFlags nMask ) const;
    bool              HasAttrib( SCCOL nCol, SCROW nRow, SCTAB nTab, HasAttrFlags nMask,
                                 SCROW* nStartRow = nullptr, SCROW* nEndRow = nullptr ) const;
 
    SC_DLLPUBLIC void GetBorderLines( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                    const ::editeng::SvxBorderLine** ppLeft,
                                    const ::editeng::SvxBorderLine** ppTop,
                                    const ::editeng::SvxBorderLine** ppRight,
                                    const ::editeng::SvxBorderLine** ppBottom ) const;
 
    void              ResetChanged( const ScRange& rRange );
 
    void              CheckVectorizationState();
    void              SetAllFormulasDirty( const sc::SetFormulaDirtyContext& rCxt );
    void              SetDirty( const ScRange&, bool bIncludeEmptyCells );
    void              SetTableOpDirty( const ScRange& );  // for Interpreter TableOp
    void              InterpretDirtyCells( const ScRangeList& rRanges );
    // Interprets cells that have NeedsInterpret(), i.e. the same like calling MaybeInterpret() on them.
    // Returns false if some couldn't be interpreted (i.e. they still have NeedsInterpret()).
    // Useful to ensure that the given cells will not need interpreting.
    bool              InterpretCellsIfNeeded( const ScRangeList& rRanges );
    SC_DLLPUBLIC void CalcAll();
    SC_DLLPUBLIC void CalcAfterLoad( bool bStartListening = true );
    void              CompileAll();
    void              CompileXML();
 
    bool CompileErrorCells(FormulaError nErrCode);
 
    ScAutoNameCache*     GetAutoNameCache()     { return pAutoNameCache.get(); }
    void                 SetPreviewFont( std::unique_ptr<SfxItemSet> pFontSet );
    SfxItemSet*          GetPreviewFont() { return pPreviewFont.get(); }
    SfxItemSet*          GetPreviewFont( SCCOL nCol, SCROW nRow, SCTAB nTab );
    const ScMarkData&    GetPreviewSelection() const { return maPreviewSelection; }
    void                 SetPreviewSelection( const ScMarkData& rSel );
    ScStyleSheet*        GetPreviewCellStyle() { return pPreviewCellStyle; }
    ScStyleSheet*        GetPreviewCellStyle( SCCOL nCol, SCROW nRow, SCTAB nTab );
    void                 SetPreviewCellStyle( ScStyleSheet* pStyle ) { pPreviewCellStyle = pStyle; }
    SC_DLLPUBLIC  void   SetAutoNameCache(  std::unique_ptr<ScAutoNameCache> pCache );
 
    ScLookupCache & GetLookupCache( const ScRange & rRange, ScInterpreterContext* pContext );
    ScSortedRangeCache & GetSortedRangeCache( const ScRange & rRange, const ScQueryParam& param,
                                              ScInterpreterContext* pContext );
    void            RemoveLookupCache( ScLookupCache & rCache );
    void            RemoveSortedRangeCache( ScSortedRangeCache & rCache );
    void            ClearLookupCaches();
 
                    // calculate automatically
    SC_DLLPUBLIC void SetAutoCalc( bool bNewAutoCalc );
    SC_DLLPUBLIC bool GetAutoCalc() const { return bAutoCalc; }
                    // calculate automatically in/from/for ScDocShell disabled
    void            SetAutoCalcShellDisabled( bool bNew ) { bAutoCalcShellDisabled = bNew; }
    bool            IsAutoCalcShellDisabled() const { return bAutoCalcShellDisabled; }
                    // ForcedFormulas are to be calculated
    void            SetForcedFormulaPending( bool bNew ) { bForcedFormulaPending = bNew; }
    bool            IsForcedFormulaPending() const { return bForcedFormulaPending; }
                    // if CalcFormulaTree() is currently running
    bool            IsCalculatingFormulaTree() const { return bCalculatingFormulaTree; }
    void            DelayFormulaGrouping( bool delay );
    bool            IsDelayedFormulaGrouping() const { return bool(pDelayedFormulaGrouping); }
    void            AddDelayedFormulaGroupingCell( const ScFormulaCell* cell );
    void            EnableDelayStartListeningFormulaCells( ScColumn* column, bool delay );
    bool            IsEnabledDelayStartListeningFormulaCells( ScColumn* column ) const;
    bool            CanDelayStartListeningFormulaCells( ScColumn* column, SCROW row1, SCROW row2 );
    void            EnableDelayDeletingBroadcasters(bool set);
    bool            IsDelayedDeletingBroadcasters() const { return bDelayedDeletingBroadcasters; }
 
    FormulaError    GetErrCode( const ScAddress& ) const;
 
    bool            ShrinkToDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow ) const;
 
    bool            ShrinkToUsedDataArea( bool& o_bShrunk,
                                          SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
                                          SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly,
                                          bool bStickyTopRow = false, bool bStickyLeftCol = false,
                                          ScDataAreaExtras* pDataAreaExtras = nullptr ) const;
 
    SC_DLLPUBLIC SCROW GetLastDataRow( SCTAB nTab, SCCOL nCol1, SCCOL nCol2, SCROW nLastRow ) const;
 
    SC_DLLPUBLIC void           GetDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
                                             SCCOL& rEndCol, SCROW& rEndRow,
                                             bool bIncludeOld, bool bOnlyDown ) const;
 
    bool                        GetDataAreaSubrange(ScRange& rRange) const;
 
    SC_DLLPUBLIC bool           GetCellArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const;
    SC_DLLPUBLIC bool           GetTableArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow,
                                              bool bCalcHiddens = false) const;
    SC_DLLPUBLIC bool           GetPrintArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow,
                                              bool bNotes = true) const;
    SC_DLLPUBLIC bool           GetPrintAreaHor( SCTAB nTab, SCROW nStartRow, SCROW nEndRow,
                                                 SCCOL& rEndCol ) const;
    SC_DLLPUBLIC bool           GetPrintAreaVer( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol,
                                                 SCROW& rEndRow, bool bNotes ) const;
    void                        InvalidateTableArea();
 
    SC_DLLPUBLIC void           GetTiledRenderingArea(SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow) const;
 
    SC_DLLPUBLIC bool           GetDataStart( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow ) const;
 
    void                        ExtendPrintArea( OutputDevice* pDev, SCTAB nTab,
                                                 SCCOL nStartCol, SCROW nStartRow,
                                                 SCCOL& rEndCol, SCROW nEndRow ) const;
    SC_DLLPUBLIC bool           IsEmptyData(SCCOL nStartCol, SCROW nStartRow,
                                            SCCOL nEndCol, SCROW nEndRow, SCTAB nTab) const;
    // I think this returns the number of empty cells starting from the given direction.
    SC_DLLPUBLIC SCSIZE         GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab,
                                                      SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab,
                                                      ScDirection eDir );
 
    void               FindAreaPos( SCCOL& rCol, SCROW& rRow, SCTAB nTab, ScMoveDirection eDirection ) const;
    SC_DLLPUBLIC void  GetNextPos( SCCOL& rCol, SCROW& rRow, SCTAB nTab, SCCOL nMovX, SCROW nMovY,
                                   bool bMarked, bool bUnprotected, const ScMarkData& rMark,
                                   SCCOL nTabStartCol = SC_TABSTART_NONE ) const;
 
    bool               GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, SCTAB nTab,
                                          const ScMarkData& rMark );
 
    void               LimitChartArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
                                       SCCOL& rEndCol, SCROW& rEndRow );
    void               LimitChartIfAll( ScRangeListRef& rRangeList );
 
    bool               InsertRow( SCCOL nStartCol, SCTAB nStartTab,
                                  SCCOL nEndCol,   SCTAB nEndTab,
                                  SCROW nStartRow, SCSIZE nSize, ScDocument* pRefUndoDoc = nullptr,
                                  const ScMarkData* pTabMark = nullptr );
    SC_DLLPUBLIC bool  InsertRow( const ScRange& rRange );
    void               DeleteRow( SCCOL nStartCol, SCTAB nStartTab,
                                  SCCOL nEndCol,   SCTAB nEndTab,
                                  SCROW nStartRow, SCSIZE nSize,
                                  ScDocument* pRefUndoDoc = nullptr, bool* pUndoOutline = nullptr,
                                  const ScMarkData* pTabMark = nullptr );
    SC_DLLPUBLIC void  DeleteRow( const ScRange& rRange );
    bool               InsertCol( SCROW nStartRow, SCTAB nStartTab,
                                  SCROW nEndRow,   SCTAB nEndTab,
                                  SCCOL nStartCol, SCSIZE nSize, ScDocument* pRefUndoDoc = nullptr,
                                  const ScMarkData* pTabMark = nullptr );
    SC_DLLPUBLIC bool  InsertCol( const ScRange& rRange );
    void               DeleteCol( SCROW nStartRow, SCTAB nStartTab,
                                  SCROW nEndRow, SCTAB nEndTab,
                                  SCCOL nStartCol, SCSIZE nSize,
                                  ScDocument* pRefUndoDoc = nullptr, bool* pUndoOutline = nullptr,
                                  const ScMarkData* pTabMark = nullptr );
    void               DeleteCol( const ScRange& rRange );
 
    bool               CanInsertRow( const ScRange& rRange ) const;
    bool               CanInsertCol( const ScRange& rRange ) const;
 
    void               FitBlock( const ScRange& rOld, const ScRange& rNew, bool bClear = true );
    bool               CanFitBlock( const ScRange& rOld, const ScRange& rNew );
 
    bool               IsClipOrUndo() const                        { return bIsClip || bIsUndo; }
    bool               IsUndo() const                              { return bIsUndo; }
    bool               IsClipboard() const                         { return bIsClip; }
    bool               IsUndoEnabled() const                       { return mbUndoEnabled; }
    SC_DLLPUBLIC void  EnableUndo( bool bVal );
    bool                IsFunctionAccess() const        { return bIsFunctionAccess; }
 
    bool                         IsAdjustHeightLocked() const               { return nAdjustHeightLock != 0; }
    void                         LockAdjustHeight()                          { ++nAdjustHeightLock; }
    SC_DLLPUBLIC void            UnlockAdjustHeight();
    bool                         IsExecuteLinkEnabled() const                { return mbExecuteLinkEnabled; }
    void                         EnableExecuteLink( bool bVal )              { mbExecuteLinkEnabled = bVal; }
    bool                         IsChangeReadOnlyEnabled() const             { return mbChangeReadOnlyEnabled; }
    void                         EnableChangeReadOnly( bool bVal )           { mbChangeReadOnlyEnabled = bVal; }
    SC_DLLPUBLIC bool            IsUserInteractionEnabled() const { return mbUserInteractionEnabled;}
    SC_DLLPUBLIC void            EnableUserInteraction( bool bVal );
    SC_DLLPUBLIC sal_Int16       GetNamedRangesLockCount() const             { return mnNamedRangesLockCount; }
    void                         SetNamedRangesLockCount( sal_Int16 nCount ) { mnNamedRangesLockCount = nCount; }
    SC_DLLPUBLIC void            ResetClip( ScDocument* pSourceDoc, const ScMarkData* pMarks );
    SC_DLLPUBLIC void            ResetClip( ScDocument* pSourceDoc, SCTAB nTab );
    void                         SetCutMode( bool bCut );
    bool                         IsCutMode();
    void                         SetClipArea( const ScRange& rArea, bool bCut = false );
 
    SC_DLLPUBLIC bool            IsDocVisible() const                        { return bIsVisible; }
    SC_DLLPUBLIC void            SetDocVisible( bool bSet );
 
    bool                         HasOLEObjectsInArea( const ScRange& rRange, const ScMarkData* pTabMark = nullptr );
 
    void                         DeleteObjectsInArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                                                      const ScMarkData& rMark, bool bAnchored = false );
    void                         DeleteObjectsInSelection( const ScMarkData& rMark );
 
    SC_DLLPUBLIC void            DeleteArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark,
                                             InsertDeleteFlags nDelFlag, bool bBroadcast = true,
                                             sc::ColumnSpanSet* pBroadcastSpans = nullptr );
 
    SC_DLLPUBLIC void            DeleteAreaTab(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                                               SCTAB nTab, InsertDeleteFlags nDelFlag);
    void                         DeleteAreaTab(const ScRange& rRange, InsertDeleteFlags nDelFlag);
 
    SC_DLLPUBLIC void            CopyToClip( const ScClipParam& rClipParam, ScDocument* pClipDoc,
                                             const ScMarkData* pMarks, bool bKeepScenarioFlags,
                                             bool bIncludeObjects );
 
    SC_DLLPUBLIC void CopyStaticToDocument(const ScRange& rSrcRange, SCTAB nDestTab, ScDocument& rDestDoc);
 
    void CopyCellToDocument( const ScAddress& rSrcPos, const ScAddress& rDestPos, ScDocument& rDestDoc );
 
    void CopyTabToClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                        SCTAB nTab, ScDocument* pClipDoc);
 
    SC_DLLPUBLIC bool InitColumnBlockPosition( sc::ColumnBlockPosition& rBlockPos, SCTAB nTab, SCCOL nCol );
 
    void DeleteBeforeCopyFromClip( sc::CopyFromClipContext& rCxt, const ScMarkData& rMark,
                                   sc::ColumnSpanSet& rBroadcastSpans );
 
    SC_DLLPUBLIC bool CopyOneCellFromClip(sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1,
                             SCCOL nCol2, SCROW nRow2 );
    void CopyBlockFromClip( sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1,
                            SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark,
                            SCCOL nDx, SCROW nDy );
    SCROW CopyNonFilteredFromClip(sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1,
                                  SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark, SCCOL nDx,
                                  SCROW& rClipStartRow, SCROW nClipEndRow);
 
    void StartListeningFromClip(
        sc::StartListeningContext& rStartCxt, sc::EndListeningContext& rEndCxt,
        SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );
    void StartListeningFromClip( SCCOL nCol1, SCROW nRow1,
                                 SCCOL nCol2, SCROW nRow2,
                                 const ScMarkData& rMark, InsertDeleteFlags nInsFlag );
 
    void SetDirtyFromClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                           const ScMarkData& rMark,  InsertDeleteFlags nInsFlag,
                           sc::ColumnSpanSet& rBroadcastSpans );
 
    SC_DLLPUBLIC void CopyFromClip(
        const ScRange& rDestRange, const ScMarkData& rMark, InsertDeleteFlags nInsFlag,
        ScDocument* pRefUndoDoc, ScDocument* pClipDoc,
        bool bResetCut = true, bool bAsLink = false,
        bool bIncludeFiltered = true, bool bSkipEmptyCells = false,
        const ScRangeList* pDestRanges = nullptr );
 
    void                CopyMultiRangeFromClip(const ScAddress& rDestPos, const ScMarkData& rMark,
                                               InsertDeleteFlags nInsFlag, ScDocument* pClipDoc,
                                               bool bResetCut = true, bool bAsLink = false,
                                               bool bIncludeFiltered = true,
                                               bool bSkipAttrForEmpty = false);
 
    void                GetClipArea(SCCOL& nClipX, SCROW& nClipY, bool bIncludeFiltered);
    void                GetClipStart(SCCOL& nClipX, SCROW& nClipY);
 
    bool                HasClipFilteredRows();
 
    bool                IsClipboardSource() const;
 
    SC_DLLPUBLIC void TransposeClip(ScDocument* pTransClip, InsertDeleteFlags nFlags, bool bAsLink,
                                    bool bIncludeFiltered);
 
    ScClipParam&        GetClipParam();
    void                SetClipParam(const ScClipParam& rParam);
 
    void            ClosingClipboardSource();
 
    void            MixDocument( const ScRange& rRange, ScPasteFunc nFunction, bool bSkipEmpty,
                                 ScDocument& rSrcDoc );
 
    void            FillTab( const ScRange& rSrcArea, const ScMarkData& rMark,
                                InsertDeleteFlags nFlags, ScPasteFunc nFunction,
                                bool bSkipEmpty, bool bAsLink );
    void            FillTabMarked( SCTAB nSrcTab, const ScMarkData& rMark,
                                InsertDeleteFlags nFlags, ScPasteFunc nFunction,
                                bool bSkipEmpty, bool bAsLink );
 
    void            TransliterateText( const ScMarkData& rMultiMark, TransliterationFlags nType );
 
    SC_DLLPUBLIC void           InitUndo( const ScDocument& rSrcDoc, SCTAB nTab1, SCTAB nTab2,
                                bool bColInfo = false, bool bRowInfo = false );
    void            AddUndoTab( SCTAB nTab1, SCTAB nTab2,
                                bool bColInfo = false, bool bRowInfo = false );
    SC_DLLPUBLIC void           InitUndoSelected( const ScDocument& rSrcDoc, const ScMarkData& rTabSelection,
                                bool bColInfo = false, bool bRowInfo = false );
 
                    //  don't use anymore:
    void            CopyToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
                                SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
                                InsertDeleteFlags nFlags, bool bMarked, ScDocument& rDestDoc,
                                const ScMarkData* pMarks = nullptr, bool bColRowFlags = true);
    void            UndoToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
                                SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
                                InsertDeleteFlags nFlags, bool bMarked, ScDocument& rDestDoc);
 
    SC_DLLPUBLIC void           CopyToDocument(const ScRange& rRange,
                                InsertDeleteFlags nFlags, bool bMarked, ScDocument& rDestDoc,
                                const ScMarkData* pMarks = nullptr, bool bColRowFlags = true);
    void            UndoToDocument(const ScRange& rRange,
                                InsertDeleteFlags nFlags, bool bMarked, ScDocument& rDestDoc);
 
    void            CopyScenario( SCTAB nSrcTab, SCTAB nDestTab, bool bNewScenario = false );
    bool            TestCopyScenario( SCTAB nSrcTab, SCTAB nDestTab ) const;
    void            MarkScenario(SCTAB nSrcTab, SCTAB nDestTab,
                                ScMarkData& rDestMark, bool bResetMark = true,
                                ScScenarioFlags nNeededBits = ScScenarioFlags::NONE) const;
    bool            HasScenarioRange( SCTAB nTab, const ScRange& rRange ) const;
    SC_DLLPUBLIC const ScRangeList* GetScenarioRanges( SCTAB nTab ) const;
 
    SC_DLLPUBLIC void  CopyUpdated( ScDocument* pPosDoc, ScDocument* pDestDoc );
 
    void               UpdateReference( sc::RefUpdateContext& rCxt,  ScDocument*
                                        pUndoDoc = nullptr, bool bIncludeDraw = true,
                                        bool bUpdateNoteCaptionPos = true );
    SC_DLLPUBLIC void  UpdateTranspose( const ScAddress& rDestPos, ScDocument* pClipDoc,
                                        const ScMarkData& rMark, ScDocument* pUndoDoc );
 
    void               UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY );
 
    SC_DLLPUBLIC void   Fill(   SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                                ScProgress* pProgress, const ScMarkData& rMark,
                                sal_uInt64 nFillCount, FillDir eFillDir = FILL_TO_BOTTOM,
                                FillCmd eFillCmd = FILL_LINEAR, FillDateCmd eFillDateCmd = FILL_DAY,
                                double nStepValue = 1.0, double nMaxValue = 1E307 );
    OUString            GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY );
 
    bool                GetSelectionFunction( ScSubTotalFunc eFunc,
                                              const ScAddress& rCursor, const ScMarkData& rMark,
                                              double& rResult );
 
    SC_DLLPUBLIC const SfxPoolItem*         GetAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich ) const;
    template<class T> const T*              GetAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, TypedWhichId<T> nWhich ) const
    {
        return static_cast<const T*>(GetAttr(nCol, nRow, nTab, sal_uInt16(nWhich)));
    }
    SC_DLLPUBLIC const SfxPoolItem*         GetAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich,
                                                     SCROW& nStartRow, SCROW& nEndRow ) const;
    template<class T> const T*              GetAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, TypedWhichId<T> nWhich,
                                                     SCROW& nStartRow, SCROW& nEndRow ) const
    {
        return static_cast<const T*>(GetAttr(nCol, nRow, nTab, sal_uInt16(nWhich), nStartRow, nEndRow));
    }
    SC_DLLPUBLIC const SfxPoolItem*         GetAttr( const ScAddress& rPos, sal_uInt16 nWhich ) const;
    template<class T> const T*              GetAttr( const ScAddress& rPos, TypedWhichId<T> nWhich ) const
    {
        return static_cast<const T*>(GetAttr(rPos, sal_uInt16(nWhich)));
    }
    SC_DLLPUBLIC const ScPatternAttr*       GetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    SC_DLLPUBLIC const ScPatternAttr*       GetPattern( const ScAddress& rPos ) const;
    SC_DLLPUBLIC const ScPatternAttr*       GetMostUsedPattern( SCCOL nCol, SCROW nStartRow, SCROW nEndRow, SCTAB nTab ) const;
    const ScPatternAttr*                    GetSelectionPattern( const ScMarkData& rMark );
    std::unique_ptr<ScPatternAttr>          CreateSelectionPattern( const ScMarkData& rMark, bool bDeep = true );
    SC_DLLPUBLIC void                       AddCondFormatData( const ScRangeList& rRange, SCTAB nTab, sal_uInt32 nIndex );
    void                                    RemoveCondFormatData( const ScRangeList& rRange, SCTAB nTab, sal_uInt32 nIndex );
 
    SC_DLLPUBLIC ScConditionalFormat*       GetCondFormat( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    // pCell is an optimization, must point to rPos
    SC_DLLPUBLIC const SfxItemSet*          GetCondResult( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                                           ScRefCellValue* pCell = nullptr ) const;
    const SfxItemSet*                       GetCondResult( ScRefCellValue& rCell, const ScAddress& rPos,
                                                           const ScConditionalFormatList& rList,
                                                           const ScCondFormatIndexes& rIndex ) const;
    const SfxPoolItem*                      GetEffItem( SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich ) const;
    template<class T> const T*              GetEffItem( SCCOL nCol, SCROW nRow, SCTAB nTab, TypedWhichId<T> nWhich ) const
    {
        return static_cast<const T*>(GetEffItem(nCol, nRow, nTab, sal_uInt16(nWhich)));
    }
 
    SC_DLLPUBLIC const css::uno::Reference< css::i18n::XBreakIterator >& GetBreakIterator();
    bool                        HasStringWeakCharacters( const OUString& rString );
    SC_DLLPUBLIC SvtScriptType  GetStringScriptType( const OUString& rString );
    // pCell is an optimization, must point to rPos
    SC_DLLPUBLIC SvtScriptType  GetCellScriptType( const ScAddress& rPos, sal_uInt32 nNumberFormat,
                                                   const ScRefCellValue* pCell = nullptr );
    // pCell is an optimization, must point to nCol,nRow,nTab
    SC_DLLPUBLIC SvtScriptType  GetScriptType( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                               const ScRefCellValue* pCell = nullptr );
    SvtScriptType               GetRangeScriptType( sc::ColumnBlockPosition& rBlockPos, const ScAddress& rPos, SCROW nLength );
    SvtScriptType               GetRangeScriptType( const ScRangeList& rRanges );
 
    bool            HasDetectiveOperations() const;
    void            AddDetectiveOperation( const ScDetOpData& rData );
    void            ClearDetectiveOperations();
    ScDetOpList*    GetDetOpList() const { return pDetOpList.get(); }
    void            SetDetOpList(std::unique_ptr<ScDetOpList> pNew);
 
    bool            HasDetectiveObjects(SCTAB nTab) const;
 
    void            GetSelectionFrame( const ScMarkData& rMark,
                                       SvxBoxItem&      rLineOuter,
                                       SvxBoxInfoItem&  rLineInner );
    void            ApplySelectionFrame(const ScMarkData& rMark,
                                        const SvxBoxItem& rLineOuter,
                                        const SvxBoxInfoItem* pLineInner);
    void            ApplyFrameAreaTab(const ScRange& rRange,
                                      const SvxBoxItem& rLineOuter,
                                      const SvxBoxInfoItem& rLineInner);
 
    void            ClearSelectionItems( const sal_uInt16* pWhich, const ScMarkData& rMark );
    void            ChangeSelectionIndent( bool bIncrement, const ScMarkData& rMark );
 
    SC_DLLPUBLIC sal_uLong  AddCondFormat( std::unique_ptr<ScConditionalFormat> pNew, SCTAB nTab );
    void                    DeleteConditionalFormat( sal_uLong nIndex, SCTAB nTab );
 
    void                                    SetCondFormList( ScConditionalFormatList* pList, SCTAB nTab );
    SC_DLLPUBLIC sal_uLong                  AddValidationEntry( const ScValidationData& rNew );
    SC_DLLPUBLIC const ScValidationData*    GetValidationEntry( sal_uInt32 nIndex ) const;
 
    SC_DLLPUBLIC ScConditionalFormatList*   GetCondFormList( SCTAB nTab ) const;
 
    const ScValidationDataList*             GetValidationList() const { return pValidationList.get();}
    ScValidationDataList*                   GetValidationList() { return pValidationList.get();}
 
    SC_DLLPUBLIC void           ApplyAttr( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                           const SfxPoolItem& rAttr );
    SC_DLLPUBLIC void           ApplyPattern( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                              const ScPatternAttr& rAttr );
    SC_DLLPUBLIC void           ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow,
                                                  SCCOL nEndCol, SCROW nEndRow,
                                                  const ScMarkData& rMark, const ScPatternAttr& rAttr,
                                                  ScEditDataArray* pDataArray = nullptr,
                                                  bool* const pIsChanged = nullptr );
    SC_DLLPUBLIC void           ApplyPatternAreaTab( SCCOL nStartCol, SCROW nStartRow,
                                                     SCCOL nEndCol, SCROW nEndRow, SCTAB nTab,
                                                     const ScPatternAttr& rAttr );
 
    SC_DLLPUBLIC void           ApplyPatternIfNumberformatIncompatible( const ScRange& rRange,
                                                                        const ScMarkData& rMark,
                                                                        const ScPatternAttr& rPattern,
                                                                        SvNumFormatType nNewType );
 
    void               ApplyStyle( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                   const ScStyleSheet& rStyle);
    void               ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow,
                                       SCCOL nEndCol, SCROW nEndRow,
                                       const ScMarkData& rMark, const ScStyleSheet& rStyle);
    SC_DLLPUBLIC void  ApplyStyleAreaTab( SCCOL nStartCol, SCROW nStartRow,
                                          SCCOL nEndCol, SCROW nEndRow, SCTAB nTab,
                                          const ScStyleSheet& rStyle);
 
    SC_DLLPUBLIC void  ApplySelectionStyle( const ScStyleSheet& rStyle, const ScMarkData& rMark );
    void               ApplySelectionLineStyle( const ScMarkData& rMark,
                                                const ::editeng::SvxBorderLine* pLine, bool bColorOnly );
 
    const ScStyleSheet* GetStyle( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
    const ScStyleSheet* GetSelectionStyle( const ScMarkData& rMark ) const;
 
    void                StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, bool bRemoved,
                                           OutputDevice* pDev,
                                           double nPPTX, double nPPTY,
                                           const Fraction& rZoomX, const Fraction& rZoomY );
 
    bool                 IsStyleSheetUsed( const ScStyleSheet& rStyle ) const;
 
    SC_DLLPUBLIC bool    ApplyFlagsTab( SCCOL nStartCol, SCROW nStartRow,
                                        SCCOL nEndCol, SCROW nEndRow,
                                        SCTAB nTab, ScMF nFlags );
    SC_DLLPUBLIC bool    RemoveFlagsTab( SCCOL nStartCol, SCROW nStartRow,
                                         SCCOL nEndCol, SCROW nEndRow,
                                         SCTAB nTab, ScMF nFlags );
 
    SC_DLLPUBLIC void    SetPattern( const ScAddress&, const ScPatternAttr& rAttr );
    SC_DLLPUBLIC const ScPatternAttr* SetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab, std::unique_ptr<ScPatternAttr> pAttr );
    SC_DLLPUBLIC const ScPatternAttr* SetPattern( const ScAddress& rPos, std::unique_ptr<ScPatternAttr> pAttr );
    SC_DLLPUBLIC void    SetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScPatternAttr& rAttr );
 
    void                 AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                                     sal_uInt16 nFormatNo, const ScMarkData& rMark );
    void                 GetAutoFormatData( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                                            ScAutoFormatData& rData );
    bool                 SearchAndReplace( const SvxSearchItem& rSearchItem,
                                           SCCOL& rCol, SCROW& rRow, SCTAB& rTab,
                                           const ScMarkData& rMark, ScRangeList& rMatchedRanges,
                                           OUString& rUndoStr, ScDocument* pUndoDoc, bool& bMatchedRangesWereClamped );
    static bool          IsEmptyCellSearch( const SvxSearchItem& rSearchItem );
 
                    // determine Col/Row of subsequent calls
                    // (e.g. not found from the beginning, or subsequent tables)
                    // meaning of explanation in "()" was already unclear in German
    void            GetSearchAndReplaceStart( const SvxSearchItem& rSearchItem,
                                              SCCOL& rCol, SCROW& rRow );
 
    bool            Solver( SCCOL nFCol, SCROW nFRow, SCTAB nFTab,
                            SCCOL nVCol, SCROW nVRow, SCTAB nVTab,
                            const OUString& sValStr, double& nX);
 
    SC_DLLPUBLIC void           ApplySelectionPattern( const ScPatternAttr& rAttr, const ScMarkData& rMark,
                                                       ScEditDataArray* pDataArray = nullptr, bool* pIsChanged = nullptr );
    SC_DLLPUBLIC void           DeleteSelection( InsertDeleteFlags nDelFlag, const ScMarkData& rMark, bool bBroadcast = true );
    void                        DeleteSelectionTab( SCTAB nTab, InsertDeleteFlags nDelFlag, const ScMarkData& rMark );
 
    SC_DLLPUBLIC void           SetColWidth( SCCOL nCol, SCTAB nTab, sal_uInt16 nNewWidth );
    SC_DLLPUBLIC void           SetColWidthOnly( SCCOL nCol, SCTAB nTab, sal_uInt16 nNewWidth );
    SC_DLLPUBLIC void           SetRowHeight( SCROW nRow, SCTAB nTab, sal_uInt16 nNewHeight );
    SC_DLLPUBLIC void           SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, SCTAB nTab,
                                                   sal_uInt16 nNewHeight );
 
    SC_DLLPUBLIC void           SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, SCTAB nTab,
                                                  sal_uInt16 nNewHeight );
    SC_DLLPUBLIC void           SetManualHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bManual );
 
    SC_DLLPUBLIC sal_uInt16         GetColWidth( SCCOL nCol, SCTAB nTab, bool bHiddenAsZero = true ) const;
    SC_DLLPUBLIC tools::Long        GetColWidth( SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab ) const;
    SC_DLLPUBLIC sal_uInt16         GetRowHeight( SCROW nRow, SCTAB nTab, bool bHiddenAsZero = true ) const;
    SC_DLLPUBLIC sal_uInt16         GetRowHeight( SCROW nRow, SCTAB nTab, SCROW* pStartRow, SCROW* pEndRow, bool bHiddenAsZero = true ) const;
    SC_DLLPUBLIC tools::Long        GetRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bHiddenAsZero = true ) const;
 
    SCROW                       GetRowForHeight( SCTAB nTab, tools::Long nHeight ) const;
    tools::Long                 GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, double fScale ) const;
    SC_DLLPUBLIC tools::Long    GetColOffset( SCCOL nCol, SCTAB nTab, bool bHiddenAsZero = true ) const;
    SC_DLLPUBLIC tools::Long    GetRowOffset( SCROW nRow, SCTAB nTab, bool bHiddenAsZero = true ) const;
 
    SC_DLLPUBLIC sal_uInt16     GetOriginalWidth( SCCOL nCol, SCTAB nTab ) const;
    SC_DLLPUBLIC sal_uInt16     GetOriginalHeight( SCROW nRow, SCTAB nTab ) const;
 
    sal_uInt16                  GetCommonWidth( SCCOL nEndCol, SCTAB nTab ) const;
 
    SCROW                       GetHiddenRowCount( SCROW nRow, SCTAB nTab ) const;
 
    sal_uInt16                  GetOptimalColWidth( SCCOL nCol, SCTAB nTab, OutputDevice* pDev,
                                                    double nPPTX, double nPPTY,
                                                    const Fraction& rZoomX, const Fraction& rZoomY,
                                                    bool bFormula,
                                                    const ScMarkData* pMarkData = nullptr,
                                                    const ScColWidthParam* pParam = nullptr );
 
    SC_DLLPUBLIC bool           SetOptimalHeight( sc::RowHeightContext& rCxt, SCROW nStartRow,
                                                  SCROW nEndRow, SCTAB nTab, bool bApi );
 
    void                        UpdateAllRowHeights( sc::RowHeightContext& rCxt, const ScMarkData* pTabMark );
 
    tools::Long                        GetNeededSize( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                               OutputDevice* pDev,
                                               double nPPTX, double nPPTY,
                                               const Fraction& rZoomX, const Fraction& rZoomY,
                                               bool bWidth, bool bTotalSize = false,
                                               bool bInPrintTwips = false );
 
    SC_DLLPUBLIC void           ShowCol(SCCOL nCol, SCTAB nTab, bool bShow);
    SC_DLLPUBLIC void           ShowRow(SCROW nRow, SCTAB nTab, bool bShow);
    SC_DLLPUBLIC void           ShowRows(SCROW nRow1, SCROW nRow2, SCTAB nTab, bool bShow);
    SC_DLLPUBLIC void           SetRowFlags( SCROW nRow, SCTAB nTab, CRFlags nNewFlags );
    SC_DLLPUBLIC void           SetRowFlags( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, CRFlags nNewFlags );
 
    SC_DLLPUBLIC CRFlags        GetColFlags( SCCOL nCol, SCTAB nTab ) const;
    SC_DLLPUBLIC CRFlags        GetRowFlags( SCROW nRow, SCTAB nTab ) const;
 
    SC_DLLPUBLIC void           GetAllRowBreaks(std::set<SCROW>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const;
    SC_DLLPUBLIC void           GetAllColBreaks(std::set<SCCOL>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const;
    SC_DLLPUBLIC ScBreakType    HasRowBreak(SCROW nRow, SCTAB nTab) const;
    SC_DLLPUBLIC ScBreakType    HasColBreak(SCCOL nCol, SCTAB nTab) const;
    SC_DLLPUBLIC void           SetRowBreak(SCROW nRow, SCTAB nTab, bool bPage, bool bManual);
    SC_DLLPUBLIC void           SetColBreak(SCCOL nCol, SCTAB nTab, bool bPage, bool bManual);
    void                        RemoveRowBreak(SCROW nRow, SCTAB nTab, bool bPage, bool bManual);
    void                        RemoveColBreak(SCCOL nCol, SCTAB nTab, bool bPage, bool bManual);
    css::uno::Sequence<
        css::sheet::TablePageBreakData> GetRowBreakData(SCTAB nTab) const;
 
    SC_DLLPUBLIC bool           RowHidden(SCROW nRow, SCTAB nTab, SCROW* pFirstRow = nullptr, SCROW* pLastRow = nullptr) const;
    SC_DLLPUBLIC bool           HasHiddenRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const;
    SC_DLLPUBLIC bool           ColHidden(SCCOL nCol, SCTAB nTab, SCCOL* pFirstCol = nullptr, SCCOL* pLastCol = nullptr) const;
    SC_DLLPUBLIC void           SetRowHidden(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bHidden);
    SC_DLLPUBLIC void           SetColHidden(SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bHidden);
    SC_DLLPUBLIC SCROW          FirstVisibleRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const;
    SC_DLLPUBLIC SCROW          LastVisibleRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const;
    SCROW                       CountVisibleRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const;
 
    SC_DLLPUBLIC bool           RowFiltered(SCROW nRow, SCTAB nTab, SCROW* pFirstRow = nullptr, SCROW* pLastRow = nullptr) const;
    bool                        HasFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const;
    bool                        ColFiltered(SCCOL nCol, SCTAB nTab) const;
    SC_DLLPUBLIC void           SetRowFiltered(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bFiltered);
    SCROW                       FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const;
    SCROW                       LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const;
    SCROW                       CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const;
 
    SC_DLLPUBLIC bool           IsManualRowHeight(SCROW nRow, SCTAB nTab) const;
 
    bool                        HasUniformRowHeight( SCTAB nTab, SCROW nRow1, SCROW nRow2 ) const;
 
    void                        SyncColRowFlags();
 
    SC_DLLPUBLIC SCROW          GetLastFlaggedRow( SCTAB nTab ) const;
 
    SCCOL           GetLastChangedColFlagsWidth( SCTAB nTab ) const;
    SCROW           GetLastChangedRowFlagsWidth( SCTAB nTab ) const;
 
    SCCOL           GetNextDifferentChangedColFlagsWidth( SCTAB nTab, SCCOL nStart) const;
 
    SCROW           GetNextDifferentChangedRowFlagsWidth( SCTAB nTab, SCROW nStart) const;
 
    // returns whether to export a Default style for this col or not
    // nDefault is set to one position in the current row where the Default style is
    void            GetColDefault( SCTAB nTab, SCCOL nCol, SCROW nLastRow, SCROW& nDefault);
 
    bool            UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bShow );
    bool            UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bShow );
 
    void            StripHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2, SCTAB nTab );
    void            ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2, SCTAB nTab );
 
    SC_DLLPUBLIC ScPatternAttr*     GetDefPattern() const;
    SC_DLLPUBLIC ScDocumentPool*    GetPool();
    SC_DLLPUBLIC ScStyleSheetPool*  GetStyleSheetPool() const;
    void GetUnprotectedCells( ScRangeList& rRange, SCTAB nTab ) const;
 
    // PageStyle:
    SC_DLLPUBLIC OUString GetPageStyle( SCTAB nTab ) const;
    SC_DLLPUBLIC void     SetPageStyle( SCTAB nTab, const OUString& rName );
    Size            GetPageSize( SCTAB nTab ) const;
    void            SetPageSize( SCTAB nTab, const Size& rSize );
    void            SetRepeatArea( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow );
    void            InvalidatePageBreaks(SCTAB nTab);
    void            UpdatePageBreaks( SCTAB nTab, const ScRange* pUserArea = nullptr );
    void            RemoveManualBreaks( SCTAB nTab );
    bool            HasManualBreaks( SCTAB nTab ) const;
 
    bool            IsPageStyleInUse( std::u16string_view rStrPageStyle, SCTAB* pInTab );
    bool            RemovePageStyleInUse( std::u16string_view rStrPageStyle );
    bool            RenamePageStyleInUse( std::u16string_view rOld, const OUString& rNew );
    void            ModifyStyleSheet( SfxStyleSheetBase& rPageStyle,
                                      const SfxItemSet&  rChanges );
 
    void            PageStyleModified( SCTAB nTab, const OUString& rNewName );
 
    SC_DLLPUBLIC bool           NeedPageResetAfterTab( SCTAB nTab ) const;
 
    // Was stored in PageStyle previously. Now it exists for every table:
    SC_DLLPUBLIC bool           HasPrintRange();
    SC_DLLPUBLIC sal_uInt16     GetPrintRangeCount( SCTAB nTab );
    SC_DLLPUBLIC const ScRange* GetPrintRange( SCTAB nTab, sal_uInt16 nPos );
    SC_DLLPUBLIC std::optional<ScRange> GetRepeatColRange( SCTAB nTab );
    SC_DLLPUBLIC std::optional<ScRange> GetRepeatRowRange( SCTAB nTab );
    bool                        IsPrintEntireSheet( SCTAB nTab ) const;
 
    SC_DLLPUBLIC void            ClearPrintRanges( SCTAB nTab );
    SC_DLLPUBLIC void            AddPrintRange( SCTAB nTab, const ScRange& rNew );
    SC_DLLPUBLIC void            SetPrintEntireSheet( SCTAB nTab );
    SC_DLLPUBLIC void            SetRepeatColRange( SCTAB nTab, std::optional<ScRange> oNew );
    SC_DLLPUBLIC void            SetRepeatRowRange( SCTAB nTab, std::optional<ScRange> oNew );
    std::unique_ptr<ScPrintRangeSaver> CreatePrintRangeSaver() const;
    void                         RestorePrintRanges( const ScPrintRangeSaver& rSaver );
 
    SC_DLLPUBLIC tools::Rectangle       GetMMRect( SCCOL nStartCol, SCROW nStartRow,
                                            SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, bool bHiddenAsZero = true ) const;
    SC_DLLPUBLIC ScRange         GetRange( SCTAB nTab, const tools::Rectangle& rMMRect, bool bHiddenAsZero = true ) const;
 
    void                         UpdStlShtPtrsFrmNms();
    void                         StylesToNames();
 
    SC_DLLPUBLIC void            CopyStdStylesFrom( const ScDocument& rSrcDoc );
 
    static sal_uInt16            GetSrcVersion() { return nSrcVer; }
 
    void                         SetSrcCharSet( rtl_TextEncoding eNew )   { eSrcSet = eNew; }
    void                         UpdateFontCharSet();
 
    void                         FillInfo( ScTableInfo& rTabInfo, SCCOL nCol1, SCROW nRow1,
                                           SCCOL nCol2, SCROW nRow2, SCTAB nTab, double fColScale,
                                           double fRowScale, bool bPageMode, bool bFormulaMode,
                                           const ScMarkData* pMarkData = nullptr );
 
    SC_DLLPUBLIC SvNumberFormatter* GetFormatTable() const;
 
    void               Sort( SCTAB nTab, const ScSortParam& rSortParam,
                             bool bKeepQuery, bool bUpdateRefs,
                             ScProgress* pProgress, sc::ReorderParam* pUndo );
 
    void               Reorder( const sc::ReorderParam& rParam );
 
    void               PrepareQuery( SCTAB nTab, ScQueryParam& rQueryParam );
    SCSIZE             Query( SCTAB nTab, const ScQueryParam& rQueryParam, bool bKeepSub );
    SC_DLLPUBLIC bool  CreateQueryParam( const ScRange& rRange, ScQueryParam& rQueryParam );
    OUString           GetUpperCellString(SCCOL nCol, SCROW nRow, SCTAB nTab);
 
    void              GetFilterEntries( SCCOL nCol, SCROW nRow,
                                        SCTAB nTab, ScFilterEntries& rFilterEntries );
 
    SC_DLLPUBLIC void GetFilterEntriesArea( SCCOL nCol, SCROW nStartRow, SCROW nEndRow,
                                            SCTAB nTab, bool bCaseSens,
                                            ScFilterEntries& rFilterEntries );
 
    void              GetDataEntries( SCCOL nCol, SCROW nRow, SCTAB nTab,
                                      std::vector<ScTypedStrData>& rStrings, bool bValidation = false );
    void              GetFormulaEntries( ScTypedCaseStrSet& rStrings );
 
    bool               HasAutoFilter( SCCOL nCol, SCROW nRow, SCTAB nTab );
    void               GetFilterSelCount( SCCOL nCol, SCROW nRow, SCTAB nTab, SCSIZE& nSelected, SCSIZE& nTotal );
 
    SC_DLLPUBLIC bool  HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                                     SCTAB nTab );
    SC_DLLPUBLIC bool  HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                                     SCTAB nTab );
 
    SfxPrinter*                 GetPrinter( bool bCreateIfNotExist = true );
    void                        SetPrinter( VclPtr<SfxPrinter> const & pNewPrinter );
    VirtualDevice*              GetVirtualDevice_100th_mm();
    SC_DLLPUBLIC OutputDevice*  GetRefDevice(); // WYSIWYG: Printer, otherwise VirtualDevice...
 
    bool            GetNextSpellingCell( SCCOL& nCol, SCROW& nRow, SCTAB nTab,
                                         bool bInSel, const ScMarkData& rMark) const;
 
    void            ReplaceStyle( const SvxSearchItem& rSearchItem,
                                  SCCOL nCol, SCROW nRow, SCTAB nTab,
                                  const ScMarkData& rMark);
 
    void            InvalidateTextWidth( std::u16string_view rStyleName );
    void            InvalidateTextWidth( SCTAB nTab );
    void            InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo, bool bNumFormatChanged );
 
    bool            IdleCalcTextWidth();
 
    void            RepaintRange( const ScRange& rRange );
    void            RepaintRange( const ScRangeList& rRange );
 
    bool            IsIdleEnabled() const { return mbIdleEnabled; }
    void            EnableIdle(bool bDo) { mbIdleEnabled = bDo; }
 
    bool            IsDetectiveDirty() const     { return bDetectiveDirty; }
    void            SetDetectiveDirty(bool bSet) { bDetectiveDirty = bSet; }
 
    bool            HasLinkFormulaNeedingCheck() const      { return bLinkFormulaNeedingCheck; }
    void            SetLinkFormulaNeedingCheck(bool bSet)   { bLinkFormulaNeedingCheck = bSet; }
    SC_DLLPUBLIC void CheckLinkFormulaNeedingCheck( const ScTokenArray& rCode );
 
    void            SetRangeOverflowType(ErrCode nType)  { nRangeOverflowType = nType; }
    bool            HasRangeOverflow() const             { return nRangeOverflowType != ERRCODE_NONE; }
    SC_DLLPUBLIC const ErrCode& GetRangeOverflowType() const    { return nRangeOverflowType; }
 
    // for broadcasting/listening
    void            SetInsertingFromOtherDoc( bool bVal ) { bInsertingFromOtherDoc = bVal; }
    bool            IsInsertingFromOtherDoc() const { return bInsertingFromOtherDoc; }
    void            SetLoadingMedium( bool bVal );
    SC_DLLPUBLIC void SetImportingXML( bool bVal );
    bool            IsImportingXML() const { return bImportingXML; }
    bool            IsCalcingAfterLoad() const { return bCalcingAfterLoad; }
    void            SetNoListening( bool bVal ) { bNoListening = bVal; }
    bool            GetNoListening() const { return bNoListening; }
    ScBroadcastAreaSlotMachine* GetBASM() const { return pBASM.get(); }
 
    SC_DLLPUBLIC ScChartListenerCollection* GetChartListenerCollection() const { return pChartListenerCollection.get(); }
    void                  SetChartListenerCollection( std::unique_ptr<ScChartListenerCollection>,
                                                       bool bSetChartRangeLists );
    void                  UpdateChart( const OUString& rName );
    void                  RestoreChartListener( const OUString& rName );
    SC_DLLPUBLIC void     UpdateChartListenerCollection();
    bool                  IsChartListenerCollectionNeedsUpdate() const { return bChartListenerCollectionNeedsUpdate; }
    void                  SetChartListenerCollectionNeedsUpdate( bool bFlg ) { bChartListenerCollectionNeedsUpdate = bFlg; }
    void                  AddOLEObjectToCollection(const OUString& rName);
 
    ScChangeViewSettings* GetChangeViewSettings() const     { return pChangeViewSettings.get(); }
    SC_DLLPUBLIC void     SetChangeViewSettings(const ScChangeViewSettings& rNew);
 
    const std::shared_ptr<SvxForbiddenCharactersTable>& GetForbiddenCharacters() const;
    void            SetForbiddenCharacters(const std::shared_ptr<SvxForbiddenCharactersTable>& rNew);
 
    CharCompressType GetAsianCompression() const;
    bool             IsValidAsianCompression() const;
    void             SetAsianCompression(CharCompressType nNew);
 
    bool            GetAsianKerning() const;
    bool            IsValidAsianKerning() const;
    void            SetAsianKerning(bool bNew);
    void            ApplyAsianEditSettings(ScEditEngineDefaulter& rEngine);
 
    EEHorizontalTextDirection       GetEditTextDirection(SCTAB nTab) const; // EEHorizontalTextDirection values
 
    SC_DLLPUBLIC ScLkUpdMode        GetLinkMode() const             { return eLinkMode ;}
    void                            SetLinkMode( ScLkUpdMode nSet ) {   eLinkMode  = nSet;}
 
    SC_DLLPUBLIC ScMacroManager*    GetMacroManager();
 
    void                            FillMatrix( ScMatrix& rMat, SCTAB nTab, SCCOL nCol1,
                                                SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                                                svl::SharedStringPool* pPool = nullptr) const;
 
    void SC_DLLPUBLIC SetFormulaResults( const ScAddress& rTopPos, const double* pResults, size_t nLen );
 
    void CalculateInColumnInThread( ScInterpreterContext& rContext, const ScRange& rCalcRange, unsigned nThisThread, unsigned nThreadsTotal);
    void HandleStuffAfterParallelCalculation( SCCOL nColStart, SCCOL nColEnd, SCROW nRow, size_t nLen, SCTAB nTab, ScInterpreter* pInterpreter );
 
    void TransferCellValuesTo( const ScAddress& rTopPos, size_t nLen, sc::CellValues& rDest );
    void CopyCellValuesFrom( const ScAddress& rTopPos, const sc::CellValues& rSrc );
 
    std::set<Color>       GetDocColors();
    sc::IconSetBitmapMap& GetIconSetBitmapMap();
 
    std::set<SCCOL> QueryColumnsWithFormulaCells( SCTAB nTab ) const;
 
    void CheckIntegrity( SCTAB nTab ) const;
 
private:
    ScDocument(const ScDocument& r) = delete;
 
    void                FindMaxRotCol( SCTAB nTab, RowInfo* pRowInfo, SCSIZE nArrCount,
                                       SCCOL nX1, SCCOL nX2 ) const;
 
    sal_uInt16          RowDifferences( SCROW nThisRow, SCTAB nThisTab,
                                        ScDocument& rOtherDoc,
                                        SCROW nOtherRow, SCTAB nOtherTab,
                                        SCCOL nMaxCol, const SCCOLROW* pOtherCols );
    sal_uInt16          ColDifferences( SCCOL nThisCol, SCTAB nThisTab,
                                        ScDocument& rOtherDoc,
                                        SCCOL nOtherCol, SCTAB nOtherTab,
                                        SCROW nMaxRow, const SCCOLROW* pOtherRows );
    void                FindOrder( SCCOLROW* pOtherRows, SCCOLROW nThisEndRow, SCCOLROW nOtherEndRow,
                                        bool bColumns,
                                        ScDocument& rOtherDoc, SCTAB nThisTab, SCTAB nOtherTab,
                                        SCCOLROW nEndCol, const SCCOLROW* pTranslate,
                                        ScProgress* pProgress, sal_uInt64 nProAdd );
 
    DECL_LINK(TrackTimeHdl, Timer *, void);
 
    bool                LimitRangeToAvailableSheets( const ScRange& rRange, ScRange& o_rRange,
                                                     bool& o_bEntirelyOutOfBounds ) const;
 
public:
    void StartListeningArea( const ScRange& rRange, bool bGroupListening, SvtListener* pListener );
 
    void EndListeningArea( const ScRange& rRange, bool bGroupListening, SvtListener* pListener );
    void                Broadcast( const ScHint& rHint );
 
    void BroadcastCells( const ScRange& rRange, SfxHintId nHint, bool bBroadcastSingleBroadcasters = true );
 
    void                AreaBroadcast( const ScHint& rHint );
    void                DelBroadcastAreasInRange( const ScRange& rRange );
    void                UpdateBroadcastAreas( UpdateRefMode eUpdateRefMode,
                                            const ScRange& rRange,
                                            SCCOL nDx, SCROW nDy, SCTAB nDz );
 
    void                StartListeningCell( const ScAddress& rAddress,
                                            SvtListener* pListener );
    void                EndListeningCell( const ScAddress& rAddress,
                                            SvtListener* pListener );
 
    void StartListeningCell( sc::StartListeningContext& rCxt, const ScAddress& rPos, SvtListener& rListener );
    void EndListeningCell( sc::EndListeningContext& rCxt, const ScAddress& rPos, SvtListener& rListener );
 
    void EndListeningFormulaCells( std::vector<ScFormulaCell*>& rCells );
 
    sc::BroadcasterState GetBroadcasterState() const;
 
    void                PutInFormulaTree( ScFormulaCell* pCell );
    void                RemoveFromFormulaTree( ScFormulaCell* pCell );
 
    SC_DLLPUBLIC void   CalcFormulaTree( bool bOnlyForced = false, bool bProgressBar = true, bool bSetAllDirty = true );
    void                ClearFormulaTree();
    void                AppendToFormulaTrack( ScFormulaCell* pCell );
    void                RemoveFromFormulaTrack( ScFormulaCell* pCell );
    void                TrackFormulas( SfxHintId nHintId = SfxHintId::ScDataChanged );
    void                SetTrackFormulasPending() { mbTrackFormulasPending = true; }
    bool                IsTrackFormulasPending() const { return mbTrackFormulasPending; }
    void                FinalTrackFormulas( SfxHintId nHintId );
    bool                IsFinalTrackFormulas() const { return mbFinalTrackFormulas; }
    inline bool         IsInFormulaTree( const ScFormulaCell* pCell ) const;
    inline bool         IsInFormulaTrack( const ScFormulaCell* pCell ) const;
    HardRecalcState     GetHardRecalcState() const { return eHardRecalcState; }
    void                SetHardRecalcState( HardRecalcState eVal ) { eHardRecalcState = eVal; }
    void                StartAllListeners();
    void                StartNeededListeners();
    void                StartNeededListeners( const std::shared_ptr<const sc::ColumnSet>& rpColSet );
    SC_DLLPUBLIC void   StartAllListeners( const ScRange& rRange );
 
    void                SetForcedFormulas( bool bVal ) { bHasForcedFormulas = bVal; }
    sal_uInt64          GetFormulaCodeInTree() const { return nFormulaCodeInTree; }
 
    bool                IsInInterpreter() const { return nInterpretLevel != 0; }
 
    void                IncInterpretLevel()
                            {
                                assert(!IsThreadedGroupCalcInProgress());
                                if ( nInterpretLevel < USHRT_MAX )
                                    nInterpretLevel++;
                            }
    void                DecInterpretLevel()
                            {
                                assert(!IsThreadedGroupCalcInProgress());
                                if ( nInterpretLevel )
                                    nInterpretLevel--;
                            }
    sal_uInt16          GetMacroInterpretLevel() const { return nMacroInterpretLevel; }
    void                IncMacroInterpretLevel()
                            {
                                assert(!IsThreadedGroupCalcInProgress());
                                if ( nMacroInterpretLevel < USHRT_MAX )
                                    nMacroInterpretLevel++;
                            }
    void                DecMacroInterpretLevel()
                            {
                                assert(!IsThreadedGroupCalcInProgress());
                                if ( nMacroInterpretLevel )
                                    nMacroInterpretLevel--;
                            }
    bool                IsInInterpreterTableOp() const { return nInterpreterTableOpLevel != 0; }
    void                IncInterpreterTableOpLevel()
                            {
                                if ( nInterpreterTableOpLevel < USHRT_MAX )
                                    nInterpreterTableOpLevel++;
                            }
    void                DecInterpreterTableOpLevel()
                            {
                                if ( nInterpreterTableOpLevel )
                                    nInterpreterTableOpLevel--;
                            }
 
    // add a formula to be remembered for TableOp broadcasts
    void                AddTableOpFormulaCell( ScFormulaCell* );
    void                InvalidateLastTableOpParams() { aLastTableOpParams.bValid = false; }
    ScRecursionHelper&  GetRecursionHelper();
    bool                IsInDtorClear() const { return bInDtorClear; }
    void                SetExpandRefs( bool bVal );
    bool                IsExpandRefs() const { return bExpandRefs; }
 
    sal_uInt64          GetXMLImportedFormulaCount() const { return nXMLImportedFormulaCount; }
    void                IncXMLImportedFormulaCount( sal_uInt64 nVal )
                            {
                                if ( nXMLImportedFormulaCount + nVal > nXMLImportedFormulaCount )
                                    nXMLImportedFormulaCount += nVal;
                            }
    void                DecXMLImportedFormulaCount( sal_uInt64 nVal )
                            {
                                if ( nVal <= nXMLImportedFormulaCount )
                                    nXMLImportedFormulaCount -= nVal;
                                else
                                    nXMLImportedFormulaCount = 0;
                            }
 
    void                StartTrackTimer();
 
    void                CompileDBFormula();
    void                CompileColRowNameFormula();
 
    sal_Int32       GetMaxStringLen( SCTAB nTab, SCCOL nCol,
                                     SCROW nRowStart, SCROW nRowEnd,
                                     rtl_TextEncoding eCharSet ) const;
    sal_Int32       GetMaxNumberStringLen( sal_uInt16& nPrecision,
                                           SCTAB nTab, SCCOL nCol,
                                           SCROW nRowStart, SCROW nRowEnd ) const;
 
    void            KeyInput();      // TimerDelays etc.
 
    ScChangeTrack*  GetChangeTrack() const { return pChangeTrack.get(); }
 
    SC_DLLPUBLIC void  SetChangeTrack( std::unique_ptr<ScChangeTrack> pTrack );
 
    void               StartChangeTracking();
    void               EndChangeTracking();
 
    SC_DLLPUBLIC void  CompareDocument( ScDocument& rOtherDoc );
 
    void               AddUnoObject( SfxListener& rObject );
    void               RemoveUnoObject( SfxListener& rObject );
    void               BroadcastUno( const SfxHint &rHint );
    void               AddUnoListenerCall( const css::uno::Reference<
                                           css::util::XModifyListener >& rListener,
                                           const css::lang::EventObject& rEvent );
 
    void                           SetInLinkUpdate(bool bSet);             // TableLink or AreaLink
    bool                           IsInLinkUpdate() const;                 // including DdeLink
 
    SC_DLLPUBLIC SfxItemPool*       GetEditPool() const;
    SC_DLLPUBLIC SfxItemPool*       GetEnginePool() const;
    SC_DLLPUBLIC ScFieldEditEngine& GetEditEngine();
    SC_DLLPUBLIC ScNoteEditEngine&  GetNoteEngine();
 
    std::unique_ptr<EditTextObject> CreateSharedStringTextObject( const svl::SharedString& rSS );
 
    std::unique_ptr<ScRefreshTimerControl> const & GetRefreshTimerControlAddress() const
                                       { return pRefreshTimerControl; }
 
    void              SetPastingDrawFromOtherDoc( bool bVal )
                          { bPastingDrawFromOtherDoc = bVal; }
    bool              PastingDrawFromOtherDoc() const
                          { return bPastingDrawFromOtherDoc; }
 
    sal_uInt32        GetDocumentID() const;
 
    void              InvalidateStyleSheetUsage() { bStyleSheetUsageInvalid = true; }
    void SC_DLLPUBLIC GetSortParam( ScSortParam& rParam, SCTAB nTab );
    void SC_DLLPUBLIC SetSortParam( const ScSortParam& rParam, SCTAB nTab );
 
    void SetVbaEventProcessor( const css::uno::Reference< css::script::vba::XVBAEventProcessor >& rxVbaEvents )
                        { mxVbaEvents = rxVbaEvents; }
    const css::uno::Reference< css::script::vba::XVBAEventProcessor >& GetVbaEventProcessor() const { return mxVbaEvents; }
 
    void                              SetStorageGrammar( formula::FormulaGrammar::Grammar eGrammar );
    formula::FormulaGrammar::Grammar  GetStorageGrammar() const { return eStorageGrammar; }
 
    SC_DLLPUBLIC ScUndoManager* GetUndoManager();
    bool                         IsInVBAMode() const;
    ScRowBreakIterator*          GetRowBreakIterator(SCTAB nTab) const;
 
    void                         AddSubTotalCell(ScFormulaCell* pCell);
    void                         RemoveSubTotalCell(ScFormulaCell* pCell);
    void                         SetSubTotalCellsDirty(const ScRange& rDirtyRange);
 
    sal_uInt16                   GetTextWidth( const ScAddress& rPos ) const;
 
    SvtScriptType                GetScriptType( const ScAddress& rPos ) const;
    void                         SetScriptType( const ScAddress& rPos, SvtScriptType nType );
    void                         UpdateScriptTypes( const ScAddress& rPos, SCCOL nColSize, SCROW nRowSize );
 
    void UnshareFormulaCells( SCTAB nTab, SCCOL nCol, std::vector<SCROW>& rRows );
    void RegroupFormulaCells( SCTAB nTab, SCCOL nCol );
    SC_DLLPUBLIC void RegroupFormulaCells( const ScRange& range );
 
    formula::FormulaTokenRef ResolveStaticReference( const ScAddress& rPos );
    formula::FormulaTokenRef ResolveStaticReference( const ScRange& rRange );
 
    formula::VectorRefArray FetchVectorRefArray( const ScAddress& rPos, SCROW nLength );
    bool HandleRefArrayForParallelism( const ScAddress& rPos, SCROW nLength, const ScFormulaCellGroupRef& mxGroup );
#ifdef DBG_UTIL
    void AssertNoInterpretNeeded( const ScAddress& rPos, SCROW nLength );
#endif
 
    void PrepareFormulaCalc();
 
    SC_DLLPUBLIC bool EnsureFormulaCellResults( const ScRange& rRange, bool bSkipRunning = false );
 
    SvtBroadcaster*         GetBroadcaster( const ScAddress& rPos );
    const SvtBroadcaster*   GetBroadcaster( const ScAddress& rPos ) const;
    void                    DeleteBroadcasters( sc::ColumnBlockPosition& rBlockPos, const ScAddress& rTopPos, SCROW nLength );
 
    std::optional<sc::ColumnIterator> GetColumnIterator( SCTAB nTab, SCCOL nCol, SCROW nRow1, SCROW nRow2 ) const;
    void CreateColumnIfNotExists( SCTAB nTab, SCCOL nCol );
 
    SC_DLLPUBLIC void StoreTabToCache(SCTAB nTab, SvStream& rStrm) const;
    SC_DLLPUBLIC void RestoreTabFromCache(SCTAB nTab, SvStream& rStream);
 
#if DUMP_COLUMN_STORAGE
    SC_DLLPUBLIC void DumpColumnStorage( SCTAB nTab, SCCOL nCol ) const;
#endif
 
    SC_DLLPUBLIC void   SetCalcConfig( const ScCalcConfig& rConfig );
    const ScCalcConfig& GetCalcConfig() const { return maCalcConfig; }
    void                ConvertFormulaToValue( const ScRange& rRange, sc::TableValues* pUndo );
    void                SwapNonEmpty( sc::TableValues& rValues );
    void                finalizeOutlineImport();
    bool                TableExists( SCTAB nTab ) const;
 
    // Returns the given column range, first allocating all the columns if necessary.
    SC_DLLPUBLIC ScColumnsRange GetWritableColumnsRange(SCTAB nTab, SCCOL nColBegin, SCCOL nColEnd);
    // Returns a column range, clamped to the allocated columns.
    SC_DLLPUBLIC ScColumnsRange GetAllocatedColumnsRange(SCTAB nTab, SCCOL nColBegin, SCCOL nColEnd) const;
    // Returns the given range, without any adjustments. One of the variants above may return
    // a smaller range (better performance) if the use case is known.
    SC_DLLPUBLIC ScColumnsRange GetColumnsRange(SCTAB nTab, SCCOL nColBegin, SCCOL nColEnd) const;
 
    bool IsInDocShellRecalc() const   { return mbDocShellRecalc; }
    void SetDocShellRecalc(bool bSet) { mbDocShellRecalc = bSet; }
 
    bool IsInLayoutStrings() const   { return mbLayoutStrings; }
    void SetLayoutStrings(bool bSet) { mbLayoutStrings = bSet; }
 
    OString dumpSheetGeomData(SCTAB nTab, bool bColumns, SheetGeomType eGeomType);
 
    SCCOL GetLOKFreezeCol(SCTAB nTab) const;
    SCROW GetLOKFreezeRow(SCTAB nTab) const;
    bool  SetLOKFreezeCol(SCCOL nFreezeCol, SCTAB nTab);
    bool  SetLOKFreezeRow(SCROW nFreezeRow, SCTAB nTab);
 
private:
 
    class NumFmtMergeHandler
    {
    public:
        explicit NumFmtMergeHandler(ScDocument& rDoc, const ScDocument& rSrcDoc);
        ~NumFmtMergeHandler();
 
    private:
        ScDocument& mrDoc;
    };
 
    void    MergeNumberFormatter(const ScDocument& rSrcDoc);
 
    void    ImplCreateOptions(); // Suggestion: switch to on-demand?
    void    ImplDeleteOptions();
 
    SC_DLLPUBLIC bool   DrawGetPrintArea( ScRange& rRange, bool bSetHor, bool bSetVer ) const;
 
    void    UpdateDrawPrinter();
    void    UpdateDrawLanguages();
    SC_DLLPUBLIC void   InitClipPtrs( ScDocument* pSourceDoc );
 
    void    LoadDdeLinks(SvStream& rStream);
    void    SaveDdeLinks(SvStream& rStream) const;
 
    void    DeleteAreaLinksOnTab( SCTAB nTab );
    void    UpdateRefAreaLinks( UpdateRefMode eUpdateRefMode,
                             const ScRange& r, SCCOL nDx, SCROW nDy, SCTAB nDz );
 
    void    CopyRangeNamesToClip(ScDocument* pClipDoc, const ScRange& rClipRange, const ScMarkData* pMarks);
 
    bool    HasPartOfMerged( const ScRange& rRange );
 
public:
    SC_DLLPUBLIC ScTable* FetchTable( SCTAB nTab );
    const ScTable* FetchTable( SCTAB nTab ) const;
 
    ScRefCellValue GetRefCellValue( const ScAddress& rPos );
private:
    ScRefCellValue GetRefCellValue( const ScAddress& rPos, sc::ColumnBlockPosition& rBlockPos );
 
    std::map< SCTAB, ScSortParam > mSheetSortParams;
 
    SCSIZE GetPatternCount( SCTAB nTab, SCCOL nCol ) const;
    SCSIZE GetPatternCount( SCTAB nTab, SCCOL nCol, SCROW nRow1, SCROW nRow2 ) const;
    void   ReservePatternCount( SCTAB nTab, SCCOL nCol, SCSIZE nReserve );
 
    void SharePooledResources( const ScDocument* pSrcDoc );
 
    void EndListeningIntersectedGroup(
        sc::EndListeningContext& rCxt, const ScAddress& rPos, std::vector<ScAddress>* pGroupPos );
 
    void EndListeningIntersectedGroups(
        sc::EndListeningContext& rCxt, const ScRange& rRange, std::vector<ScAddress>* pGroupPos );
 
    void EndListeningGroups( const std::vector<ScAddress>& rPosArray );
    void SetNeedsListeningGroups( const std::vector<ScAddress>& rPosArray );
 
    bool BroadcastHintInternal( const ScHint &rHint );
};
 
typedef std::unique_ptr<ScDocument, o3tl::default_delete<ScDocument>> ScDocumentUniquePtr;
 
struct ScMutationDisable
{
#ifndef NDEBUG
    ScMutationDisable(ScDocument& rDocument, ScMutationGuardFlags nFlags)
        : mnFlagRestore(rDocument.mnMutationGuardFlags)
        , mrDocument(rDocument)
    {
        assert((mnFlagRestore & nFlags) == 0);
        mrDocument.mnMutationGuardFlags |= static_cast<size_t>(nFlags);
    }
    ~ScMutationDisable()
    {
        mrDocument.mnMutationGuardFlags = mnFlagRestore;
    }
    size_t mnFlagRestore;
    ScDocument& mrDocument;
#else
    ScMutationDisable(ScDocument& rDocument, ScMutationGuardFlags nFlags)
    {
        (void)rDocument; (void)nFlags;
    }
#endif
};
 
struct ScMutationGuard
{
#ifndef NDEBUG
    ScMutationGuard(ScDocument& rDocument, ScMutationGuardFlags nFlags)
        : mnFlags(static_cast<size_t>(nFlags))
        , mrDocument(rDocument)
    {
        assert((mrDocument.mnMutationGuardFlags & mnFlags) == 0);
    }
 
    ~ScMutationGuard()
    {
        assert((mrDocument.mnMutationGuardFlags & mnFlags) == 0);
    }
    size_t mnFlags;
    ScDocument& mrDocument;
#else
    ScMutationGuard(ScDocument& rDocument, ScMutationGuardFlags nFlags)
    {
        (void)rDocument; (void)nFlags;
    }
#endif
};
 
class ScDocShellRecalcGuard
{
    ScDocument& mrDoc;
 
public:
    ScDocShellRecalcGuard(ScDocument& rDoc)
        : mrDoc(rDoc)
    {
        assert(!mrDoc.IsInDocShellRecalc());
        mrDoc.SetDocShellRecalc(true);
    }
 
    ~ScDocShellRecalcGuard()
    {
        mrDoc.SetDocShellRecalc(false);
    }
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */