sc/html/document_8hxx_source.html

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

    sal_uInt16 GetSheetOptimalMinRowHeight(SCTAB nTab) const;

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


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

ValidColRow
bool ValidColRow(SCCOL nCol, SCROW nRow, SCCOL nMaxCol, SCROW nMaxRow)
Definition: address.hxx:121

SanitizeRow
SCROW SanitizeRow(SCROW nRow, SCROW nMaxRow)
Definition: address.hxx:139

ValidAddress
bool ValidAddress(const ScAddress &rAddress, SCCOL nMaxCol, SCROW nMaxRow)
Definition: address.hxx:488

ValidRange
bool ValidRange(const ScRange &rRange, SCCOL nMaxCol, SCROW nMaxRow)
Definition: address.hxx:786

SC_TABSTART_NONE
const SCCOL SC_TABSTART_NONE
Definition: address.hxx:95

SanitizeCol
SCCOL SanitizeCol(SCCOL nCol, SCCOL nMaxCol)
Definition: address.hxx:133

SCSIZE
size_t SCSIZE
size_t typedef to be able to find places where code was changed from USHORT to size_t and is used to ...
Definition: address.hxx:44

ValidColRowTab
bool ValidColRowTab(SCCOL nCol, SCROW nRow, SCTAB nTab, SCCOL nMaxCol, SCROW nMaxRow)
Definition: address.hxx:127

ValidRow
bool ValidRow(SCROW nRow, SCROW nMaxRow)
Definition: address.hxx:105

ValidCol
bool ValidCol(SCCOL nCol, SCCOL nMaxCol)
Definition: address.hxx:99

CharCompressType
CharCompressType

ScMF
ScMF
Definition: attrib.hxx:34

calcconfig.hxx

calcmacros.hxx

BitmapEx

Color

EditTextObject

ErrCode

Fraction

Idle

Point

ScAddress
Definition: address.hxx:207

ScAddress::Tab
SCTAB Tab() const
Definition: address.hxx:283

ScAddress::Row
SCROW Row() const
Definition: address.hxx:274

ScAddress::Col
SCCOL Col() const
Definition: address.hxx:279

ScAttrRectIterator
Definition: dociter.hxx:271

ScAutoFormatData
Definition: autoform.hxx:113

ScAutoNameCache
Cache for faster lookup of automatic names during CompileXML (during CompileXML, no document content ...
Definition: autonamecache.hxx:32

ScBroadcastAreaSlotMachine
BroadcastAreaSlots and their management, once per document.
Definition: bcaslot.hxx:249

ScCellIterator
Walk through all cells in an area.
Definition: dociter.hxx:206

ScChangeTrack
Definition: chgtrack.hxx:814

ScChangeViewSettings
Definition: chgviset.hxx:32

ScChartListenerCollection
Definition: chartlis.hxx:123

ScClipOptions
Stores options which are only relevant for clipboard documents.
Definition: clipoptions.hxx:22

ScColumnTextWidthIterator
Definition: columniterator.hxx:23

ScColumn
Definition: column.hxx:182

ScColumnsRange
Definition: table.hxx:124

ScConditionalFormatList
Definition: conditio.hxx:628

ScConditionalFormat
Definition: conditio.hxx:540

ScDBCollection
Definition: dbdata.hxx:235

ScDBData
Definition: dbdata.hxx:66

ScDBQueryDataIterator
Definition: dociter.hxx:100

ScDPCollection
Definition: dpobject.hxx:284

ScDPObject
Definition: dpobject.hxx:84

ScDetOpData
Definition: detdata.hxx:36

ScDetOpList
Definition: detdata.hxx:59

ScDocAttrIterator
Definition: dociter.hxx:250

ScDocOptions
Definition: docoptio.hxx:28

ScDocProtection
Definition: tabprotection.hxx:96

ScDocRowHeightUpdater
Definition: dociter.hxx:442

ScDocShellRecalcGuard
Definition: document.hxx:2785

ScDocShellRecalcGuard::ScDocShellRecalcGuard
ScDocShellRecalcGuard(ScDocument &rDoc)
Definition: document.hxx:2789

ScDocShellRecalcGuard::mrDoc
ScDocument & mrDoc
Definition: document.hxx:2786

ScDocShellRecalcGuard::~ScDocShellRecalcGuard
~ScDocShellRecalcGuard()
Definition: document.hxx:2796

ScDocShell
Definition: docsh.hxx:81

ScDocumentImport
Accessor class to ScDocument.
Definition: documentimport.hxx:41

ScDocumentPool
Definition: docpool.hxx:30

ScDocument::NumFmtMergeHandler
Use this class as a locale variable to merge number formatter from another document,...
Definition: document.hxx:2661

ScDocument::NumFmtMergeHandler::mrDoc
ScDocument & mrDoc
Definition: document.hxx:2667

ScDocument::NumFmtMergeHandler::NumFmtMergeHandler
NumFmtMergeHandler(ScDocument &rDoc, const ScDocument &rSrcDoc)
Definition: document.cxx:2446

ScDocument::NumFmtMergeHandler::~NumFmtMergeHandler
~NumFmtMergeHandler()
Definition: document.cxx:2452

ScDocument
Definition: document.hxx:323

ScDocument::InsertTab
SC_DLLPUBLIC bool InsertTab(SCTAB nPos, const OUString &rName, bool bExternalDocument=false, bool bUndoDeleteTab=false)
Definition: document.cxx:485

ScDocument::StartAllListeners
void StartAllListeners()
Definition: documen7.cxx:582

ScDocument::IsInFormulaTree
bool IsInFormulaTree(const ScFormulaCell *pCell) const
Definition: formulacell.hxx:515

ScDocument::ResetChanged
void ResetChanged(const ScRange &rRange)
Definition: document.cxx:4074

ScDocument::IsScenario
SC_DLLPUBLIC bool IsScenario(SCTAB nTab) const
Definition: documen3.cxx:432

ScDocument::CountNonFilteredRows
SCROW CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
Definition: document.cxx:4516

ScDocument::SetEmptyCell
void SetEmptyCell(const ScAddress &rPos)
Definition: document.cxx:3471

ScDocument::GetAllocatedColumnsCount
SC_DLLPUBLIC SCCOL GetAllocatedColumnsCount(SCTAB nTab) const
Definition: documen3.cxx:2139

ScDocument::GetMaxNumberStringLen
sal_Int32 GetMaxNumberStringLen(sal_uInt16 &nPrecision, SCTAB nTab, SCCOL nCol, SCROW nRowStart, SCROW nRowEnd) const
Maximum string length of numerical cells of a column, e.g.
Definition: documen4.cxx:594

ScDocument::UpdateAreaLinks
void UpdateAreaLinks()
Definition: documen8.cxx:1044

ScDocument::IsValidAsianKerning
bool IsValidAsianKerning() const
Definition: documen9.cxx:640

ScDocument::mpDataMapper
std::unique_ptr< sc::ExternalDataMapper > mpDataMapper
Definition: document.hxx:403

ScDocument::TrackFormulas
void TrackFormulas(SfxHintId nHintId=SfxHintId::ScDataChanged)
Definition: documen7.cxx:524

ScDocument::CompileAll
void CompileAll()
Definition: document.cxx:3963

ScDocument::GetEnginePool
SC_DLLPUBLIC SfxItemPool * GetEnginePool() const
Definition: documen2.cxx:478

ScDocument::FinalTrackFormulas
void FinalTrackFormulas(SfxHintId nHintId)
Definition: documen7.cxx:503

ScDocument::SanitizeRow
SCROW SanitizeRow(SCROW nRow) const
Definition: document.hxx:906

ScDocument::CountVisibleRows
SCROW CountVisibleRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
Definition: document.cxx:4468

ScDocument::SetThreadedGroupCalcInProgress
void SetThreadedGroupCalcInProgress(bool set)
Definition: document.hxx:629

ScDocument::SetEditText
SC_DLLPUBLIC bool SetEditText(const ScAddress &rPos, std::unique_ptr< EditTextObject > pEditText)
This method manages the lifecycle of the passed edit text object.
Definition: document.cxx:3422

ScDocument::IsCalculatingFormulaTree
bool IsCalculatingFormulaTree() const
Definition: document.hxx:1421

ScDocument::RemoveFlagsTab
SC_DLLPUBLIC bool RemoveFlagsTab(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, ScMF nFlags)
Definition: document.cxx:4980

ScDocument::GetSheetLimits
ScSheetLimits & GetSheetLimits() const
Definition: document.hxx:898

ScDocument::GetSelectionStyle
const ScStyleSheet * GetSelectionStyle(const ScMarkData &rMark) const
Definition: document.cxx:4875

ScDocument::IsUndo
bool IsUndo() const
Definition: document.hxx:1593

ScDocument::GetWritableColumnsRange
SC_DLLPUBLIC ScColumnsRange GetWritableColumnsRange(SCTAB nTab, SCCOL nColBegin, SCCOL nColEnd)
Definition: document.cxx:2525

ScDocument::GetVisibleTab
SCTAB GetVisibleTab() const
Definition: document.hxx:879

ScDocument::bAutoCalc
bool bAutoCalc
Definition: document.hxx:487

ScDocument::SetDdeLinkResultMatrix
bool SetDdeLinkResultMatrix(size_t nDdePos, const ScMatrixRef &pResults)
Sets a result matrix for the specified DDE link.
Definition: documen8.cxx:1019

ScDocument::mpCellStringPool
std::shared_ptr< svl::SharedStringPool > mpCellStringPool
Definition: document.hxx:360

ScDocument::nPosTop
SCROW nPosTop
Definition: document.hxx:483

ScDocument::GetRowHeight
SC_DLLPUBLIC sal_uInt16 GetRowHeight(SCROW nRow, SCTAB nTab, bool bHiddenAsZero=true) const
Definition: document.cxx:4161

ScDocument::UpdateGrow
void UpdateGrow(const ScRange &rArea, SCCOL nGrowX, SCROW nGrowY)
Definition: documen3.cxx:1143

ScDocument::GetSparkline
SC_DLLPUBLIC std::shared_ptr< sc::Sparkline > GetSparkline(ScAddress const &rPosition)
Returns sparkline at the address if it exists.
Definition: document.cxx:6495

ScDocument::IsAddressInRangeName
bool IsAddressInRangeName(RangeNameScope eScope, const ScAddress &rAddress)
Definition: documen3.cxx:196

ScDocument::SetTrackFormulasPending
void SetTrackFormulasPending()
Definition: document.hxx:2396

ScDocument::IsEmbedUsedFontsOnly
bool IsEmbedUsedFontsOnly() const
Definition: document.hxx:584

ScDocument::CopyFromClip
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)
Paste data from a clipboard document into this document.
Definition: document.cxx:2814

ScDocument::bDelayedDeletingBroadcasters
bool bDelayedDeletingBroadcasters
Definition: document.hxx:531

ScDocument::mxSheetLimits
rtl::Reference< ScSheetLimits > mxSheetLimits
Definition: document.hxx:379

ScDocument::ModifyStyleSheet
void ModifyStyleSheet(SfxStyleSheetBase &rPageStyle, const SfxItemSet &rChanges)
Definition: documen8.cxx:210

ScDocument::FirstNonFilteredRow
SCROW FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
Definition: document.cxx:4502

ScDocument::~ScDocument
SC_DLLPUBLIC ~ScDocument()
Definition: documen2.cxx:346

ScDocument::GetNumberFormat
SC_DLLPUBLIC sal_uInt32 GetNumberFormat(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: document.cxx:3640

ScDocument::GetRangeNameMap
SC_DLLPUBLIC void GetRangeNameMap(std::map< OUString, ScRangeName * > &rRangeName)
Definition: documen3.cxx:149

ScDocument::UpdateOutlineCol
bool UpdateOutlineCol(SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bShow)
Adapt Outline.
Definition: documen3.cxx:1415

ScDocument::QueryColumnsWithFormulaCells
std::set< SCCOL > QueryColumnsWithFormulaCells(SCTAB nTab) const
Definition: document10.cxx:1088

ScDocument::GetChartByName
css::uno::Reference< css::chart2::XChartDocument > GetChartByName(std::u16string_view rChartName)
Definition: documen5.cxx:138

ScDocument::IsPrintEmpty
bool IsPrintEmpty(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, bool bLeftIsEmpty=false, ScRange *pLastRange=nullptr, tools::Rectangle *pLastMM=nullptr) const
Definition: documen9.cxx:423

ScDocument::HasMultipleDataCells
sc::MultiDataCellState HasMultipleDataCells(const ScRange &rRange) const
Check if the specified range contains either: 1) one non-empty cell, 2) more than one non-empty cells...
Definition: document10.cxx:43

ScDocument::DumpColumnStorage
SC_DLLPUBLIC void DumpColumnStorage(SCTAB nTab, SCCOL nCol) const

ScDocument::pCacheFieldEditEngine
std::unique_ptr< ScFieldEditEngine > pCacheFieldEditEngine
Definition: document.hxx:405

ScDocument::GetAutoFormatData
void GetAutoFormatData(SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScAutoFormatData &rData)
Definition: documen3.cxx:1202

ScDocument::maFileURL
OUString maFileURL
Definition: document.hxx:419

ScDocument::GetAsianKerning
bool GetAsianKerning() const
Definition: documen9.cxx:645

ScDocument::BroadcastHintInternal
bool BroadcastHintInternal(const ScHint &rHint)
Definition: documen7.cxx:137

ScDocument::EnableDelayStartListeningFormulaCells
void EnableDelayStartListeningFormulaCells(ScColumn *column, bool delay)
If set, ScColumn::StartListeningFormulaCells() calls may be delayed using CanDelayStartListeningFormu...
Definition: document10.cxx:401

ScDocument::IsCellInChangeTrack
bool IsCellInChangeTrack(const ScAddress &cell, Color *pColCellBorder)
Definition: documen2.cxx:1317

ScDocument::IsInFormulaTrack
bool IsInFormulaTrack(const ScFormulaCell *pCell) const
Definition: formulacell.hxx:516

ScDocument::IncInterpreterTableOpLevel
void IncInterpreterTableOpLevel()
Definition: document.hxx:2440

ScDocument::pFormulaTree
ScFormulaCell * pFormulaTree
Definition: document.hxx:386

ScDocument::InvalidateTextWidth
void InvalidateTextWidth(std::u16string_view rStyleName)
Definition: documen8.cxx:295

ScDocument::AddOLEObjectToCollection
void AddOLEObjectToCollection(const OUString &rName)
Definition: documen5.cxx:646

ScDocument::IsHorOverlapped
bool IsHorOverlapped(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: document.cxx:5717

ScDocument::GetThreadedContext
ScInterpreterContext & GetThreadedContext() const
Definition: document.hxx:623

ScDocument::GetMatrixFormulaRange
SC_DLLPUBLIC bool GetMatrixFormulaRange(const ScAddress &rCellPos, ScRange &rMatrix)
Definition: document.cxx:5416

ScDocument::SetFormulaResults
void SC_DLLPUBLIC SetFormulaResults(const ScAddress &rTopPos, const double *pResults, size_t nLen)
Set an array of numerical formula results to a group of contiguous formula cells.
Definition: documen8.cxx:402

ScDocument::UndoToDocument
void UndoToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, InsertDeleteFlags nFlags, bool bMarked, ScDocument &rDestDoc)
Definition: document.cxx:2053

ScDocument::pClipData
std::unique_ptr< SvMemoryStream > pClipData
Definition: document.hxx:392

ScDocument::bInLinkUpdate
bool bInLinkUpdate
Definition: document.hxx:510

ScDocument::pConsolidateDlgData
std::unique_ptr< ScConsolidateParam > pConsolidateDlgData
Definition: document.hxx:427

ScDocument::GetRange
SC_DLLPUBLIC ScRange GetRange(SCTAB nTab, const tools::Rectangle &rMMRect, bool bHiddenAsZero=true) const
Definition: documen3.cxx:1797

ScDocument::GetFileURL
const OUString & GetFileURL() const
Definition: document.hxx:611

ScDocument::RefreshAutoFilter
bool RefreshAutoFilter(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab)
Definition: document.cxx:5660

ScDocument::IsStreamValidLocked
bool IsStreamValidLocked() const
Definition: document.hxx:990

ScDocument::SetChangeTrack
SC_DLLPUBLIC void SetChangeTrack(std::unique_ptr< ScChangeTrack > pTrack)
only for import filter, deletes any existing ChangeTrack via EndChangeTracking() and takes ownership ...
Definition: documen2.cxx:294

ScDocument::eLinkMode
ScLkUpdMode eLinkMode
Definition: document.hxx:485

ScDocument::GetEmbeddedRect
tools::Rectangle GetEmbeddedRect() const
Definition: documen3.cxx:1708

ScDocument::SetFormulaCell
SC_DLLPUBLIC ScFormulaCell * SetFormulaCell(const ScAddress &rPos, ScFormulaCell *pCell)
Set formula cell, and transfer its ownership to the document.
Definition: documen2.cxx:1149

ScDocument::bForcedFormulaPending
bool bForcedFormulaPending
Definition: document.hxx:492

ScDocument::IncMacroInterpretLevel
void IncMacroInterpretLevel()
Definition: document.hxx:2427

ScDocument::CreateValidTabNames
SC_DLLPUBLIC void CreateValidTabNames(std::vector< OUString > &aNames, SCTAB nCount) const
Definition: document.cxx:420

ScDocument::LinkExternalTab
SC_DLLPUBLIC bool LinkExternalTab(SCTAB &nTab, const OUString &aDocTab, const OUString &aFileName, const OUString &aTabName)
Definition: documen3.cxx:566

ScDocument::GetBroadcaster
SvtBroadcaster * GetBroadcaster(const ScAddress &rPos)
Definition: document.cxx:2464

ScDocument::IsCalcingAfterLoad
bool IsCalcingAfterLoad() const
Definition: document.hxx:2228

ScDocument::GetColWidth
SC_DLLPUBLIC sal_uInt16 GetColWidth(SCCOL nCol, SCTAB nTab, bool bHiddenAsZero=true) const
Definition: document.cxx:4122

ScDocument::GetCellCount
SC_DLLPUBLIC sal_uInt64 GetCellCount() const
Definition: document.cxx:6125

ScDocument::ClosingClipboardSource
void ClosingClipboardSource()
To be called at the clipboard document when closing a document that is the current clipboard source t...
Definition: documen2.cxx:338

ScDocument::LoadDdeLinks
void LoadDdeLinks(SvStream &rStream)
Definition: documen8.cxx:747

ScDocument::bPastingDrawFromOtherDoc
bool bPastingDrawFromOtherDoc
Definition: document.hxx:538

ScDocument::GetDefPattern
SC_DLLPUBLIC ScPatternAttr * GetDefPattern() const
Definition: document.cxx:6045

ScDocument::IsInInterpreterTableOp
bool IsInInterpreterTableOp() const
Definition: document.hxx:2439

ScDocument::SetValues
void SetValues(const ScAddress &rPos, const std::vector< double > &rVals)
Definition: document10.cxx:160

ScDocument::GetSrcVersion
static sal_uInt16 GetSrcVersion()
Definition: document.hxx:2137

ScDocument::GetValueCell
SC_DLLPUBLIC double * GetValueCell(const ScAddress &rPos)
Return a pointer to the double value stored in value cell.
Definition: document.cxx:3519

ScDocument::IsInDocShellRecalc
bool IsInDocShellRecalc() const
Definition: document.hxx:2632

ScDocument::GetSortParam
void SC_DLLPUBLIC GetSortParam(ScSortParam &rParam, SCTAB nTab)
Definition: documen3.cxx:2124

ScDocument::mpEditEngine
std::unique_ptr< ScFieldEditEngine > mpEditEngine
Definition: document.hxx:369

ScDocument::SetAllRangeNames
SC_DLLPUBLIC void SetAllRangeNames(const std::map< OUString, ScRangeName > &rRangeMap)
Definition: documen3.cxx:126

ScDocument::GetLinkTab
SC_DLLPUBLIC OUString GetLinkTab(SCTAB nTab) const
Definition: documen3.cxx:530

ScDocument::DeleteBroadcasters
void DeleteBroadcasters(sc::ColumnBlockPosition &rBlockPos, const ScAddress &rTopPos, SCROW nLength)
Definition: document.cxx:2482

ScDocument::ValidRow
bool ValidRow(SCROW nRow) const
Definition: document.hxx:900

ScDocument::GetTabProtection
SC_DLLPUBLIC const ScTableProtection * GetTabProtection(SCTAB nTab) const
Definition: documen3.cxx:1914

ScDocument::UpdateRefAreaLinks
void UpdateRefAreaLinks(UpdateRefMode eUpdateRefMode, const ScRange &r, SCCOL nDx, SCROW nDy, SCTAB nDz)
Definition: documen8.cxx:1078

ScDocument::UpdateDrawPrinter
void UpdateDrawPrinter()
Definition: documen9.cxx:193

ScDocument::Clear
void Clear(bool bFromDestructor=false)
Definition: documen9.cxx:489

ScDocument::GetAllNoteCaptionsState
CommentCaptionState GetAllNoteCaptionsState(const ScRangeList &rRanges)
Definition: document.cxx:6742

ScDocument::EnableUserInteraction
SC_DLLPUBLIC void EnableUserInteraction(bool bVal)
Definition: document.cxx:6472

ScDocument::GetBroadcasterState
sc::BroadcasterState GetBroadcasterState() const
Definition: document10.cxx:1106

ScDocument::SetLayoutRTL
SC_DLLPUBLIC void SetLayoutRTL(SCTAB nTab, bool bRTL, ScObjectHandling eObjectHandling=ScObjectHandling::RecalcPosMode)
Definition: document.cxx:937

ScDocument::HasPartOfMerged
bool HasPartOfMerged(const ScRange &rRange)
Definition: document.cxx:1723

ScDocument::RemovePageStyleInUse
bool RemovePageStyleInUse(std::u16string_view rStrPageStyle)
Definition: documen8.cxx:325

ScDocument::UpdatePageBreaks
void UpdatePageBreaks(SCTAB nTab, const ScRange *pUserArea=nullptr)
Definition: document.cxx:6210

ScDocument::nVisibleTab
SCTAB nVisibleTab
Definition: document.hxx:481

ScDocument::ApplyFrameAreaTab
void ApplyFrameAreaTab(const ScRange &rRange, const SvxBoxItem &rLineOuter, const SvxBoxInfoItem &rLineInner)
Definition: document.cxx:5851

ScDocument::CopyUpdated
SC_DLLPUBLIC void CopyUpdated(ScDocument *pPosDoc, ScDocument *pDestDoc)
From this document this method copies the cells of positions at which there are also cells in pPosDoc...
Definition: documen3.cxx:803

ScDocument::FindRangeNamesReferencingSheet
bool FindRangeNamesReferencingSheet(sc::UpdatedRangeNames &rIndexes, SCTAB nTokenTab, const sal_uInt16 nTokenIndex, SCTAB nGlobalRefTab, SCTAB nLocalRefTab, SCTAB nOldTokenTab, SCTAB nOldTokenTabReplacement, bool bSameDoc, int nRecursion) const
Recursively find all named expressions that directly or indirectly (nested) reference a given sheet,...
Definition: document10.cxx:594

ScDocument::GetColDefault
void GetColDefault(SCTAB nTab, SCCOL nCol, SCROW nLastRow, SCROW &nDefault)
Definition: document.cxx:4623

ScDocument::bInDtorClear
bool bInDtorClear
Definition: document.hxx:515

ScDocument::SetOutlineTable
bool SetOutlineTable(SCTAB nTab, const ScOutlineTable *pNewOutline)
Definition: documen3.cxx:754

ScDocument::CanInsertCol
bool CanInsertCol(const ScRange &rRange) const
Definition: document.cxx:1456

ScDocument::GetRangeName
SC_DLLPUBLIC ScRangeName * GetRangeName() const
Definition: documen3.cxx:178

ScDocument::TransferTab
SC_DLLPUBLIC sal_uLong TransferTab(ScDocument &rSrcDoc, SCTAB nSrcPos, SCTAB nDestPos, bool bInsertNew=true, bool bResultsOnly=false)
Definition: documen2.cxx:946

ScDocument::FetchTable
SC_DLLPUBLIC ScTable * FetchTable(SCTAB nTab)
Definition: document.cxx:2509

ScDocument::GetFormulaParserPool
ScFormulaParserPool & GetFormulaParserPool() const
Returns the pool containing external formula parsers.
Definition: documen3.cxx:654

ScDocument::IsDocProtected
SC_DLLPUBLIC bool IsDocProtected() const
Definition: documen3.cxx:1894

ScDocument::IsFinalTrackFormulas
bool IsFinalTrackFormulas() const
Definition: document.hxx:2399

ScDocument::SetRangeName
void SetRangeName(SCTAB nTab, std::unique_ptr< ScRangeName > pNew)
Definition: documen3.cxx:185

ScDocument::pUnoListenerCalls
std::unique_ptr< ScUnoListenerCalls > pUnoListenerCalls
Definition: document.hxx:396

ScDocument::HasSelectionData
bool HasSelectionData(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Returns true, if there is any data to create a selection list for rPos.
Definition: document.cxx:3781

ScDocument::Fill
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)
Definition: documen3.cxx:1156

ScDocument::GetSharedString
svl::SharedString GetSharedString(const ScAddress &rPos) const
Definition: document.cxx:3526

ScDocument::ExtendMerge
SC_DLLPUBLIC bool ExtendMerge(SCCOL nStartCol, SCROW nStartRow, SCCOL &rEndCol, SCROW &rEndRow, SCTAB nTab, bool bRefresh=false)
Definition: document.cxx:5556

ScDocument::IsDetectiveDirty
bool IsDetectiveDirty() const
Definition: document.hxx:2210

ScDocument::SetFormula
SC_DLLPUBLIC void SetFormula(const ScAddress &rPos, const ScTokenArray &rArray)
Definition: documen2.cxx:1135

ScDocument::SetNote
void SetNote(const ScAddress &rPos, std::unique_ptr< ScPostIt > pNote)
Definition: document.cxx:6599

ScDocument::SetLOKFreezeCol
bool SetLOKFreezeCol(SCCOL nFreezeCol, SCTAB nTab)
Definition: document10.cxx:1070

ScDocument::InsertMatrixFormula
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)
Definition: documen4.cxx:259

ScDocument::CopyBlockFromClip
void CopyBlockFromClip(sc::CopyFromClipContext &rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData &rMark, SCCOL nDx, SCROW nDy)
Definition: document.cxx:2635

ScDocument::TransliterateText
void TransliterateText(const ScMarkData &rMultiMark, TransliterationFlags nType)
Definition: documen8.cxx:1205

ScDocument::GetClipParam
ScClipParam & GetClipParam()
Definition: document.cxx:2564

ScDocument::UpdateChartListenerCollection
SC_DLLPUBLIC void UpdateChartListenerCollection()
Definition: documen5.cxx:571

ScDocument::GetColOffset
SC_DLLPUBLIC tools::Long GetColOffset(SCCOL nCol, SCTAB nTab, bool bHiddenAsZero=true) const
Definition: document.cxx:4224

ScDocument::CopyNonFilteredFromClip
SCROW CopyNonFilteredFromClip(sc::CopyFromClipContext &rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData &rMark, SCCOL nDx, SCROW &rClipStartRow, SCROW nClipEndRow)
Definition: document.cxx:2736

ScDocument::InsertTabs
SC_DLLPUBLIC bool InsertTabs(SCTAB nPos, const std::vector< OUString > &rNames, bool bNamesValid=false)
Definition: document.cxx:573

ScDocument::mpClipOptions
std::unique_ptr< ScClipOptions > mpClipOptions
Definition: document.hxx:426

ScDocument::GetTabBgColor
SC_DLLPUBLIC Color GetTabBgColor(SCTAB nTab) const
Definition: documen3.cxx:449

ScDocument::GetCalcConfig
const ScCalcConfig & GetCalcConfig() const
Definition: document.hxx:2619

ScDocument::bLinkFormulaNeedingCheck
bool bLinkFormulaNeedingCheck
Definition: document.hxx:533

ScDocument::PrepareQuery
void PrepareQuery(SCTAB nTab, ScQueryParam &rQueryParam)
Definition: documen3.cxx:1458

ScDocument::GetTable
SC_DLLPUBLIC bool GetTable(const OUString &rName, SCTAB &rTab) const
Definition: document.cxx:244

ScDocument::aCurTextWidthCalcPos
ScAddress aCurTextWidthCalcPos
Definition: document.hxx:439

ScDocument::GetDPAtCursor
SC_DLLPUBLIC ScDPObject * GetDPAtCursor(ScAddress const &rAddress) const
Definition: document.hxx:844

ScDocument::pDocOptions
std::unique_ptr< ScDocOptions > pDocOptions
Definition: document.hxx:424

ScDocument::mpPrinter
VclPtr< SfxPrinter > mpPrinter
Definition: document.hxx:372

ScDocument::GetEditTextDirection
EEHorizontalTextDirection GetEditTextDirection(SCTAB nTab) const
Definition: documen8.cxx:355

ScDocument::GetAllocatedColumnsRange
SC_DLLPUBLIC ScColumnsRange GetAllocatedColumnsRange(SCTAB nTab, SCCOL nColBegin, SCCOL nColEnd) const
Definition: document.cxx:2534

ScDocument::HasStringWeakCharacters
bool HasStringWeakCharacters(const OUString &rString)
Definition: documen6.cxx:51

ScDocument::InsertTableOp
SC_DLLPUBLIC void InsertTableOp(const ScTabOpParam &rParam, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData &rMark)
Definition: documen4.cxx:356

ScDocument::GetScaledRowHeight
tools::Long GetScaledRowHeight(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, double fScale) const
Definition: document.cxx:4198

ScDocument::mpAnonymousDBData
std::unique_ptr< ScDBData > mpAnonymousDBData
Definition: document.hxx:402

ScDocument::InvalidateTableArea
void InvalidateTableArea()
Definition: documen4.cxx:574

ScDocument::BeginDrawUndo
void BeginDrawUndo()
Definition: documen9.cxx:61

ScDocument::CompileHybridFormula
SC_DLLPUBLIC void CompileHybridFormula()
Call this immediately after updating named ranges.
Definition: document10.cxx:319

ScDocument::CompileErrorCells
bool CompileErrorCells(FormulaError nErrCode)
Re-compile formula cells with error.
Definition: document.cxx:4016

ScDocument::IsTabProtected
SC_DLLPUBLIC bool IsTabProtected(SCTAB nTab) const
Definition: documen3.cxx:1905

ScDocument::InitDrawLayer
SC_DLLPUBLIC void InitDrawLayer(SfxObjectShell *pDocShell=nullptr)
Definition: documen9.cxx:105

ScDocument::GetFormulaCodeInTree
sal_uInt64 GetFormulaCodeInTree() const
Definition: document.hxx:2410

ScDocument::HasColNotes
SC_DLLPUBLIC bool HasColNotes(SCCOL nCol, SCTAB nTab) const
Definition: document.cxx:6652

ScDocument::SetDetectiveDirty
void SetDetectiveDirty(bool bSet)
Definition: document.hxx:2211

ScDocument::IsIdleEnabled
bool IsIdleEnabled() const
Definition: document.hxx:2207

ScDocument::eCtlLanguage
LanguageType eCtlLanguage
Definition: document.hxx:454

ScDocument::GetUnprotectedCells
void GetUnprotectedCells(ScRangeList &rRange, SCTAB nTab) const
Definition: document.cxx:6864

ScDocument::aEmbedRange
ScRange aEmbedRange
Definition: document.hxx:438

ScDocument::ValidNewTabName
SC_DLLPUBLIC bool ValidNewTabName(const OUString &rName) const
Definition: document.cxx:357

ScDocument::GetRowNameRanges
ScRangePairList * GetRowNameRanges()
Definition: document.hxx:820

ScDocument::EndListeningArea
void EndListeningArea(const ScRange &rRange, bool bGroupListening, SvtListener *pListener)
Definition: documen7.cxx:61

ScDocument::pPreviewCellStyle
ScStyleSheet * pPreviewCellStyle
Definition: document.hxx:432

ScDocument::SetColHidden
SC_DLLPUBLIC void SetColHidden(SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bHidden)
Definition: document.cxx:4448

ScDocument::MarkScenario
void MarkScenario(SCTAB nSrcTab, SCTAB nDestTab, ScMarkData &rDestMark, bool bResetMark=true, ScScenarioFlags nNeededBits=ScScenarioFlags::NONE) const
Definition: documen3.cxx:854

ScDocument::RemoveSubTotals
void RemoveSubTotals(SCTAB nTab, ScSubTotalParam &rParam)
Definition: documen3.cxx:773

ScDocument::IsEditActionAllowed
bool IsEditActionAllowed(sc::ColRowEditAction eAction, SCTAB nTab, SCCOLROW nStart, SCCOLROW nEnd) const
Definition: document10.cxx:966

ScDocument::ShrinkToDataArea
bool ShrinkToDataArea(SCTAB nTab, SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow) const
Shrink a range to only include data area.
Definition: document.cxx:1018

ScDocument::DecInterpreterTableOpLevel
void DecInterpreterTableOpLevel()
Definition: document.hxx:2445

ScDocument::bChartListenerCollectionNeedsUpdate
bool bChartListenerCollectionNeedsUpdate
Definition: document.hxx:511

ScDocument::EnableDelayDeletingBroadcasters
void EnableDelayDeletingBroadcasters(bool set)
If set, cells will not delete their empty broadcasters, avoiding possible extensive mdds vector chang...
Definition: document10.cxx:449

ScDocument::InvalidatePageBreaks
void InvalidatePageBreaks(SCTAB nTab)
Definition: document.cxx:6204

ScDocument::SetFormulaCells
bool SetFormulaCells(const ScAddress &rPos, std::vector< ScFormulaCell * > &rCells)
Definition: documen2.cxx:1158

ScDocument::IsSelectionEditable
bool IsSelectionEditable(const ScMarkData &rMark, bool *pOnlyNotBecauseOfMatrix=nullptr) const
Definition: document.cxx:5340

ScDocument::maNonThreaded
ScDocumentThreadSpecific maNonThreaded
Definition: document.hxx:467

ScDocument::MaxCol
SC_DLLPUBLIC SCCOL MaxCol() const
Definition: document.hxx:892

ScDocument::SetVbaEventProcessor
void SetVbaEventProcessor(const css::uno::Reference< css::script::vba::XVBAEventProcessor > &rxVbaEvents)
Definition: document.hxx:2537

ScDocument::IncInDdeLinkUpdate
void IncInDdeLinkUpdate()
Definition: document.hxx:1043

ScDocument::mbFinalTrackFormulas
bool mbFinalTrackFormulas
Definition: document.hxx:571

ScDocument::pPreviewFont
std::unique_ptr< SfxItemSet > pPreviewFont
Definition: document.hxx:431

ScDocument::SetVisibleTab
SC_DLLPUBLIC void SetVisibleTab(SCTAB nTab)
Definition: document.hxx:880

ScDocument::GetDPAtBlock
ScDPObject * GetDPAtBlock(const ScRange &rBlock) const
Definition: documen3.cxx:391

ScDocument::pDPCollection
std::unique_ptr< ScDPCollection > pDPCollection
Definition: document.hxx:383

ScDocument::finalizeOutlineImport
void finalizeOutlineImport()
Definition: document10.cxx:585

ScDocument::SetNeedsListeningGroups
void SetNeedsListeningGroups(const std::vector< ScAddress > &rPosArray)
Definition: document10.cxx:520

ScDocument::nInterpreterTableOpLevel
sal_uInt16 nInterpreterTableOpLevel
Definition: document.hxx:465

ScDocument::SetScenarioData
SC_DLLPUBLIC void SetScenarioData(SCTAB nTab, const OUString &rComment, const Color &rColor, ScScenarioFlags nFlags)
Definition: documen3.cxx:438

ScDocument::GetValidationEntry
SC_DLLPUBLIC const ScValidationData * GetValidationEntry(sal_uInt32 nIndex) const
Definition: documen4.cxx:873

ScDocument::TableContainer
std::vector< ScTableUniquePtr > TableContainer
Definition: document.hxx:347

ScDocument::GetPrintAreaVer
SC_DLLPUBLIC bool GetPrintAreaVer(SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol, SCROW &rEndRow, bool bNotes) const
Definition: documen2.cxx:657

ScDocument::GetNoteCount
size_t GetNoteCount(SCTAB nTab, SCCOL nCol) const
Definition: document.cxx:6711

ScDocument::SharePooledResources
void SharePooledResources(const ScDocument *pSrcDoc)
Definition: document10.cxx:330

ScDocument::IsClipboard
bool IsClipboard() const
Definition: document.hxx:1594

ScDocument::GetDBAtCursor
const ScDBData * GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) const
Definition: documen3.cxx:322

ScDocument::HasUniformRowHeight
bool HasUniformRowHeight(SCTAB nTab, SCROW nRow1, SCROW nRow2) const
Definition: document10.cxx:346

ScDocument::GetLastFlaggedRow
SC_DLLPUBLIC SCROW GetLastFlaggedRow(SCTAB nTab) const
Definition: document.cxx:4539

ScDocument::HasManualBreaks
bool HasManualBreaks(SCTAB nTab) const
Definition: document.cxx:6222

ScDocument::mxScSortedRangeCache
std::unique_ptr< ScSortedRangeCacheMap > mxScSortedRangeCache
Definition: document.hxx:476

ScDocument::RenameTab
SC_DLLPUBLIC bool RenameTab(SCTAB nTab, const OUString &rName, bool bExternalDocument=false)
Definition: document.cxx:837

ScDocument::GetSheetEvents
const ScSheetEvents * GetSheetEvents(SCTAB nTab) const
Definition: documen3.cxx:661

ScDocument::aLastTableOpParams
ScInterpreterTableOpParams aLastTableOpParams
Definition: document.hxx:448

ScDocument::EnsureGraphicNames
void EnsureGraphicNames()
Definition: documen9.cxx:381

ScDocument::mxFormulaParserPool
std::unique_ptr< ScFormulaParserPool > mxFormulaParserPool
Definition: document.hxx:415

ScDocument::GetMaxRowCount
SC_DLLPUBLIC SCROW GetMaxRowCount() const
Definition: document.hxx:895

ScDocument::RowDifferences
sal_uInt16 RowDifferences(SCROW nThisRow, SCTAB nThisTab, ScDocument &rOtherDoc, SCROW nOtherRow, SCTAB nOtherTab, SCCOL nMaxCol, const SCCOLROW *pOtherCols)
Definition: documen4.cxx:918

ScDocument::DoMergeContents
SC_DLLPUBLIC void DoMergeContents(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab)
Definition: documen3.cxx:2026

ScDocument::nSrcVer
static const sal_uInt16 nSrcVer
Definition: document.hxx:478

ScDocument::AppendTabOnLoad
void AppendTabOnLoad(const OUString &rName)
Definition: document.cxx:453

ScDocument::GetHardRecalcState
HardRecalcState GetHardRecalcState() const
Definition: document.hxx:2402

ScDocument::SetEmbedFontScriptComplex
void SetEmbedFontScriptComplex(bool bUse)
Definition: document.hxx:593

ScDocument::eGrammar
formula::FormulaGrammar::Grammar eGrammar
Definition: document.hxx:545

ScDocument::GetLinkOpt
OUString GetLinkOpt(SCTAB nTab) const
Definition: documen3.cxx:523

ScDocument::HasFilteredRows
bool HasFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
Definition: document.cxx:4482

ScDocument::RowFiltered
SC_DLLPUBLIC bool RowFiltered(SCROW nRow, SCTAB nTab, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) const
Definition: document.cxx:4475

ScDocument::FetchVectorRefArray
formula::VectorRefArray FetchVectorRefArray(const ScAddress &rPos, SCROW nLength)
Definition: document.cxx:1763

ScDocument::SetOptimalHeight
SC_DLLPUBLIC bool SetOptimalHeight(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bApi)
Definition: document.cxx:4267

ScDocument::mxPoolHelper
rtl::Reference< ScPoolHelper > mxPoolHelper
Definition: document.hxx:358

ScDocument::GetMacroManager
SC_DLLPUBLIC ScMacroManager * GetMacroManager()
Definition: documen8.cxx:377

ScDocument::DiscardFormulaGroupContext
void DiscardFormulaGroupContext()
Definition: document.cxx:3542

ScDocument::CopyStaticToDocument
SC_DLLPUBLIC void CopyStaticToDocument(const ScRange &rSrcRange, SCTAB nDestTab, ScDocument &rDestDoc)
Copy only raw cell values to another document.
Definition: document.cxx:2214

ScDocument::AddPrintRange
SC_DLLPUBLIC void AddPrintRange(SCTAB nTab, const ScRange &rNew)
Adds a new print ranges.
Definition: document.cxx:6297

ScDocument::GetRowForHeight
SCROW GetRowForHeight(SCTAB nTab, tools::Long nHeight) const
Given the height i.e.
Definition: document.cxx:4193

ScDocument::FillTabMarked
void FillTabMarked(SCTAB nSrcTab, const ScMarkData &rMark, InsertDeleteFlags nFlags, ScPasteFunc nFunction, bool bSkipEmpty, bool bAsLink)
Definition: document.cxx:3325

ScDocument::nAsianKerning
sal_uInt8 nAsianKerning
Definition: document.hxx:536

ScDocument::SetTextCell
SC_DLLPUBLIC void SetTextCell(const ScAddress &rPos, const OUString &rStr)
Call this if you are not sure whether to put this as an edit text or a simple text.
Definition: document.cxx:3452

ScDocument::InsertNewRangeName
bool InsertNewRangeName(const OUString &rName, const ScAddress &rPos, const OUString &rExpr)
Insert a new named expression to the global scope.
Definition: documen3.cxx:218

ScDocument::SetSrcCharSet
void SetSrcCharSet(rtl_TextEncoding eNew)
Definition: document.hxx:2139

ScDocument::nInterpretLevel
sal_uInt16 nInterpretLevel
Definition: document.hxx:463

ScDocument::maInterpreterContext
ScInterpreterContext maInterpreterContext
Definition: document.hxx:473

ScDocument::ValidTabName
static SC_DLLPUBLIC bool ValidTabName(const OUString &rName)
Definition: document.cxx:318

ScDocument::GetPool
SC_DLLPUBLIC ScDocumentPool * GetPool()
Definition: document.cxx:6050

ScDocument::EnsureTable
SC_DLLPUBLIC void EnsureTable(SCTAB nTab)
Definition: documen2.cxx:577

ScDocument::mnImagePreferredDPI
sal_Int32 mnImagePreferredDPI
Definition: document.hxx:566

ScDocument::DECL_LINK
DECL_LINK(TrackTimeHdl, Timer *, void)

ScDocument::IsCutMode
bool IsCutMode()
Definition: document.cxx:2030

ScDocument::ApplyPatternAreaTab
SC_DLLPUBLIC void ApplyPatternAreaTab(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, const ScPatternAttr &rAttr)
Definition: document.cxx:4770

ScDocument::GetSearchAndReplaceStart
void GetSearchAndReplaceStart(const SvxSearchItem &rSearchItem, SCCOL &rCol, SCROW &rRow)
Definition: documen3.cxx:1213

ScDocument::ValidAddress
bool ValidAddress(const ScAddress &rAddress) const
Definition: document.hxx:904

ScDocument::GetEffItem
const SfxPoolItem * GetEffItem(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich) const
Definition: documen4.cxx:751

ScDocument::InvalidateLastTableOpParams
void InvalidateLastTableOpParams()
Definition: document.hxx:2453

ScDocument::SetExpandRefs
void SetExpandRefs(bool bVal)
Definition: documen2.cxx:327

ScDocument::SetCalcNotification
void SetCalcNotification(SCTAB nTab)
Definition: documen3.cxx:722

ScDocument::DecXMLImportedFormulaCount
void DecXMLImportedFormulaCount(sal_uInt64 nVal)
Definition: document.hxx:2465

ScDocument::GetAddressConvention
SC_DLLPUBLIC formula::FormulaGrammar::AddressConvention GetAddressConvention() const
Definition: documen3.cxx:492

ScDocument::FindRangeNameBySheetAndIndex
ScRangeData * FindRangeNameBySheetAndIndex(SCTAB nTab, sal_uInt16 nIndex) const
Find a named expression / range name in either global or a local scope.
Definition: documen3.cxx:269

ScDocument::pBASM
std::unique_ptr< ScBroadcastAreaSlotMachine > pBASM
Definition: document.hxx:390

ScDocument::MaxRow
SC_DLLPUBLIC SCROW MaxRow() const
Definition: document.hxx:893

ScDocument::GetStyle
const ScStyleSheet * GetStyle(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: document.cxx:4868

ScDocument::IsAdjustHeightLocked
bool IsAdjustHeightLocked() const
Definition: document.hxx:1599

ScDocument::HasPivotTable
SC_DLLPUBLIC bool HasPivotTable() const
Definition: documen3.cxx:360

ScDocument::ColFiltered
bool ColFiltered(SCCOL nCol, SCTAB nTab) const
Definition: document.cxx:4489

ScDocument::ValidColRowTab
bool ValidColRowTab(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: document.hxx:902

ScDocument::ClearPrintRanges
SC_DLLPUBLIC void ClearPrintRanges(SCTAB nTab)
Removes all print ranges.
Definition: document.cxx:6291

ScDocument::BeginUnoRefUndo
void BeginUnoRefUndo()
Definition: documen3.cxx:990

ScDocument::CompareDocument
SC_DLLPUBLIC void CompareDocument(ScDocument &rOtherDoc)
Definition: documen4.cxx:1095

ScDocument::IsPageStyleInUse
bool IsPageStyleInUse(std::u16string_view rStrPageStyle, SCTAB *pInTab)
Definition: documen8.cxx:310

ScDocument::ShowRow
SC_DLLPUBLIC void ShowRow(SCROW nRow, SCTAB nTab, bool bShow)
Definition: document.cxx:4303

ScDocument::CopyStdStylesFrom
SC_DLLPUBLIC void CopyStdStylesFrom(const ScDocument &rSrcDoc)
Definition: documen8.cxx:288

ScDocument::RemoveFromFormulaTree
void RemoveFromFormulaTree(ScFormulaCell *pCell)
Definition: documen7.cxx:281

ScDocument::pChangeViewSettings
std::unique_ptr< ScChangeViewSettings > pChangeViewSettings
Definition: document.hxx:398

ScDocument::GetValidationList
ScValidationDataList * GetValidationList()
Definition: document.hxx:1880

ScDocument::CheckLinkFormulaNeedingCheck
SC_DLLPUBLIC void CheckLinkFormulaNeedingCheck(const ScTokenArray &rCode)
Check token array and set link check if ocDde/ocWebservice is contained.
Definition: documen8.cxx:1149

ScDocument::ScDocument
SC_DLLPUBLIC ScDocument(ScDocumentMode eMode=SCDOCMODE_DOCUMENT, SfxObjectShell *pDocShell=nullptr)
Definition: documen2.cxx:114

ScDocument::GetAnonymousDBData
SC_DLLPUBLIC ScDBData * GetAnonymousDBData()
Definition: document.cxx:313

ScDocument::GetFormulaGroupContext
std::shared_ptr< sc::FormulaGroupContext > & GetFormulaGroupContext()
Definition: document.cxx:3533

ScDocument::GetChartRanges
SC_DLLPUBLIC void GetChartRanges(std::u16string_view rChartName, std::vector< ScRangeList > &rRanges, const ScDocument &rSheetNameDoc)
Definition: documen5.cxx:168

ScDocument::GetEditEngine
SC_DLLPUBLIC ScFieldEditEngine & GetEditEngine()
Definition: documen2.cxx:483

ScDocument::GetRowBreakData
css::uno::Sequence< css::sheet::TablePageBreakData > GetRowBreakData(SCTAB nTab) const
Definition: document.cxx:4408

ScDocument::GetDetOpList
ScDetOpList * GetDetOpList() const
Definition: document.hxx:1852

ScDocument::HasLink
bool HasLink(std::u16string_view rDoc, std::u16string_view rFilter, std::u16string_view rOptions) const
Definition: documen3.cxx:552

ScDocument::pColorList
rtl::Reference< XColorList > pColorList
Definition: document.hxx:375

ScDocument::mpMacroMgr
std::unique_ptr< ScMacroManager > mpMacroMgr
Definition: document.hxx:411

ScDocument::GetLastChangedRowFlagsWidth
SCROW GetLastChangedRowFlagsWidth(SCTAB nTab) const
Definition: document.cxx:4553

ScDocument::AddUnoRefChange
void AddUnoRefChange(sal_Int64 nId, const ScRangeList &rOldRanges)
Definition: documen3.cxx:1002

ScDocument::SetTableOpDirty
void SetTableOpDirty(const ScRange &)
Definition: document.cxx:3862

ScDocument::CalcAfterLoad
SC_DLLPUBLIC void CalcAfterLoad(bool bStartListening=true)
Definition: document.cxx:4029

ScDocument::m_TableOpList
std::vector< ScInterpreterTableOpParams * > m_TableOpList
list of ScInterpreterTableOpParams currently in use
Definition: document.hxx:447

ScDocument::DoMerge
SC_DLLPUBLIC void DoMerge(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, bool bDeleteCaptions=true)
Definition: documen3.cxx:2063

ScDocument::mbEmbedUsedFontsOnly
bool mbEmbedUsedFontsOnly
Definition: document.hxx:561

ScDocument::GetValue
SC_DLLPUBLIC double GetValue(const ScAddress &rPos) const
Definition: document.cxx:3626

ScDocument::GetAllTableNames
SC_DLLPUBLIC std::vector< OUString > GetAllTableNames() const
Definition: document.cxx:270

ScDocument::GetChartListenerCollection
SC_DLLPUBLIC ScChartListenerCollection * GetChartListenerCollection() const
Definition: document.hxx:2233

ScDocument::ContainsNotesInRange
bool ContainsNotesInRange(const ScRangeList &rRange) const
Definition: document.cxx:6870

ScDocument::UpdateReference
void UpdateReference(sc::RefUpdateContext &rCxt, ScDocument *pUndoDoc=nullptr, bool bIncludeDraw=true, bool bUpdateNoteCaptionPos=true)
Definition: documen3.cxx:1008

ScDocument::BroadcastCells
void BroadcastCells(const ScRange &rRange, SfxHintId nHint, bool bBroadcastSingleBroadcasters=true)
Definition: documen7.cxx:158

ScDocument::GetNote
SC_DLLPUBLIC ScPostIt * GetNote(const ScAddress &rPos)
Definition: document.cxx:6587

ScDocument::DoSubTotals
bool DoSubTotals(SCTAB nTab, ScSubTotalParam &rParam)
Definition: documen3.cxx:779

ScDocument::GetSortedRangeCache
ScSortedRangeCache & GetSortedRangeCache(const ScRange &rRange, const ScQueryParam &param, ScInterpreterContext *pContext)
Definition: documen2.cxx:1237

ScDocument::IsEmbedFonts
bool IsEmbedFonts() const
Definition: document.hxx:583

ScDocument::HasDetectiveOperations
bool HasDetectiveOperations() const
Definition: documen4.cxx:887

ScDocument::AddDetectiveOperation
void AddDetectiveOperation(const ScDetOpData &rData)
Definition: documen4.cxx:892

ScDocument::Solver
bool Solver(SCCOL nFCol, SCROW nFRow, SCTAB nFTab, SCCOL nVCol, SCROW nVRow, SCTAB nVTab, const OUString &sValStr, double &nX)
(Goal Seek) Find a value of x that is a root of f(x)
Definition: documen4.cxx:72

ScDocument::bHasForcedFormulas
bool bHasForcedFormulas
Definition: document.hxx:513

ScDocument::GetRefreshTimerControlAddress
std::unique_ptr< ScRefreshTimerControl > const & GetRefreshTimerControlAddress() const
Definition: document.hxx:2522

ScDocument::mbFormulaGroupCxtBlockDiscard
bool mbFormulaGroupCxtBlockDiscard
Definition: document.hxx:364

ScDocument::CreateSparkline
SC_DLLPUBLIC sc::Sparkline * CreateSparkline(ScAddress const &rPosition, std::shared_ptr< sc::SparklineGroup > const &pSparklineGroup)
Definition: document.cxx:6508

ScDocument::DeleteConditionalFormat
void DeleteConditionalFormat(sal_uLong nIndex, SCTAB nTab)
Definition: documen4.cxx:881

ScDocument::CompileXML
void CompileXML()
Definition: document.cxx:3976

ScDocument::GetDrawLayer
SC_DLLPUBLIC const ScDrawLayer * GetDrawLayer() const
Definition: document.hxx:1085

ScDocument::pAutoNameCache
std::unique_ptr< ScAutoNameCache > pAutoNameCache
Definition: document.hxx:429

ScDocument::HasClipFilteredRows
bool HasClipFilteredRows()
Definition: document.cxx:3216

ScDocument::GetNextDifferentChangedRowFlagsWidth
SCROW GetNextDifferentChangedRowFlagsWidth(SCTAB nTab, SCROW nStart) const
Definition: document.cxx:4580

ScDocument::TransposeClip
SC_DLLPUBLIC void TransposeClip(ScDocument *pTransClip, InsertDeleteFlags nFlags, bool bAsLink, bool bIncludeFiltered)
Definition: document.cxx:2295

ScDocument::SetPrintEntireSheet
SC_DLLPUBLIC void SetPrintEntireSheet(SCTAB nTab)
Marks the specified sheet to be printed completely.
Definition: document.cxx:6303

ScDocument::CreateDdeLink
SC_DLLPUBLIC bool CreateDdeLink(const OUString &rAppl, const OUString &rTopic, const OUString &rItem, sal_uInt8 nMode, const ScMatrixRef &pResults)
Tries to find a DDE link or creates a new, if not extant.
Definition: documen8.cxx:988

ScDocument::GetAsianCompression
CharCompressType GetAsianCompression() const
Definition: documen9.cxx:623

ScDocument::CreateColumnIfNotExists
void CreateColumnIfNotExists(SCTAB nTab, SCCOL nCol)
Definition: document10.cxx:992

ScDocument::GetDBAtArea
SC_DLLPUBLIC const ScDBData * GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
Definition: documen3.cxx:338

ScDocument::FillInfo
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)
Definition: fillinfo.cxx:355

ScDocument::GetNamedRangesLockCount
SC_DLLPUBLIC sal_Int16 GetNamedRangesLockCount() const
Definition: document.hxx:1608

ScDocument::IsInDdeLinkUpdate
bool IsInDdeLinkUpdate() const
Definition: document.hxx:1045

ScDocument::GetPrintRange
SC_DLLPUBLIC const ScRange * GetPrintRange(SCTAB nTab, sal_uInt16 nPos)
Definition: document.cxx:6268

ScDocument::InitColumnBlockPosition
SC_DLLPUBLIC bool InitColumnBlockPosition(sc::ColumnBlockPosition &rBlockPos, SCTAB nTab, SCCOL nCol)
Definition: document.cxx:2628

ScDocument::EnableUndo
SC_DLLPUBLIC void EnableUndo(bool bVal)
Definition: document.cxx:6456

ScDocument::GetViewBindings
SfxBindings * GetViewBindings()
Definition: documen8.cxx:1183

ScDocument::GetEffItem
const T * GetEffItem(SCCOL nCol, SCROW nRow, SCTAB nTab, TypedWhichId< T > nWhich) const
Definition: document.hxx:1832

ScDocument::pSelectionAttr
std::unique_ptr< ScPatternAttr > pSelectionAttr
Definition: document.hxx:385

ScDocument::GetDocColors
std::set< Color > GetDocColors()
Definition: document10.cxx:187

ScDocument::GetLookupCache
ScLookupCache & GetLookupCache(const ScRange &rRange, ScInterpreterContext *pContext)
Creates a ScLookupCache cache for the range if it doesn't already exist.
Definition: documen2.cxx:1214

ScDocument::GetAutoNameCache
ScAutoNameCache * GetAutoNameCache()
Definition: document.hxx:1388

ScDocument::pUnoBroadcaster
std::unique_ptr< SfxBroadcaster > pUnoBroadcaster
Definition: document.hxx:395

ScDocument::IsDelayedDeletingBroadcasters
bool IsDelayedDeletingBroadcasters() const
Definition: document.hxx:1439

ScDocument::PrepareFormulaCalc
void PrepareFormulaCalc()
Call this before any operations that might trigger one or more formula cells to get calculated.
Definition: document.cxx:2458

ScDocument::KeyInput
void KeyInput()
Definition: documen8.cxx:1175

ScDocument::MergeContextBackIntoNonThreadedContext
void MergeContextBackIntoNonThreadedContext(ScInterpreterContext &threadedContext, int threadNumber)
Definition: document.cxx:6915

ScDocument::DeleteSelection
SC_DLLPUBLIC void DeleteSelection(InsertDeleteFlags nDelFlag, const ScMarkData &rMark, bool bBroadcast=true)
Definition: document.cxx:5921

ScDocument::HasFormulaCell
bool HasFormulaCell(const ScRange &rRange) const
Check if there is at least one formula cell in specified range.
Definition: document10.cxx:462

ScDocument::GetSheetOptimalMinRowHeight
sal_uInt16 GetSheetOptimalMinRowHeight(SCTAB nTab) const
Definition: document.cxx:928

ScDocument::PageStyleModified
void PageStyleModified(SCTAB nTab, const OUString &rNewName)
Definition: document.cxx:6164

ScDocument::PreprocessDBDataUpdate
SC_DLLPUBLIC void PreprocessDBDataUpdate()
Definition: document10.cxx:307

ScDocument::SetDocOptions
SC_DLLPUBLIC void SetDocOptions(const ScDocOptions &rOpt)
Definition: documen3.cxx:1942

ScDocument::HasScenarioRange
bool HasScenarioRange(SCTAB nTab, const ScRange &rRange) const
Definition: documen3.cxx:866

ScDocument::SetColBreak
SC_DLLPUBLIC void SetColBreak(SCCOL nCol, SCTAB nTab, bool bPage, bool bManual)
Definition: document.cxx:4390

ScDocument::AddTableOpFormulaCell
void AddTableOpFormulaCell(ScFormulaCell *)
Definition: document.cxx:3919

ScDocument::IsNegativePage
SC_DLLPUBLIC bool IsNegativePage(SCTAB nTab) const
Definition: document.cxx:982

ScDocument::ApplySelectionStyle
SC_DLLPUBLIC void ApplySelectionStyle(const ScStyleSheet &rStyle, const ScMarkData &rMark)
Definition: document.cxx:4830

ScDocument::SetStorageGrammar
void SetStorageGrammar(formula::FormulaGrammar::Grammar eGrammar)
Should only be GRAM_PODF or GRAM_ODFF.
Definition: documen2.cxx:251

ScDocument::mbExecuteLinkEnabled
bool mbExecuteLinkEnabled
Definition: document.hxx:550

ScDocument::DelayFormulaGrouping
void DelayFormulaGrouping(bool delay)
If set, joining cells into shared formula groups will be delayed until reset again (RegroupFormulaCel...
Definition: document10.cxx:380

ScDocument::ApplyFlagsTab
SC_DLLPUBLIC bool ApplyFlagsTab(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, ScMF nFlags)
Definition: document.cxx:4970

ScDocument::RepaintRange
void RepaintRange(const ScRange &rRange)
Definition: documen8.cxx:689

ScDocument::RoundValueAsShown
SC_DLLPUBLIC double RoundValueAsShown(double fVal, sal_uInt32 nFormat, const ScInterpreterContext *pContext=nullptr) const
Definition: documen4.cxx:627

ScDocument::GetLastDataRow
SC_DLLPUBLIC SCROW GetLastDataRow(SCTAB nTab, SCCOL nCol1, SCCOL nCol2, SCROW nLastRow) const
Return the last non-empty row position in given columns that's no greater than the initial last row p...
Definition: document.cxx:1063

ScDocument::GetNonThreadedContext
ScInterpreterContext & GetNonThreadedContext() const
Definition: document.hxx:617

ScDocument::PreprocessRangeNameUpdate
SC_DLLPUBLIC void PreprocessRangeNameUpdate()
Definition: document10.cxx:295

ScDocument::SetLayoutStrings
void SetLayoutStrings(bool bSet)
Definition: document.hxx:2636

ScDocument::SetClipArea
void SetClipArea(const ScRange &rArea, bool bCut=false)
Definition: document.cxx:3132

ScDocument::IsEmbedFontScriptComplex
bool IsEmbedFontScriptComplex() const
Definition: document.hxx:587

ScDocument::HasDetectiveObjects
bool HasDetectiveObjects(SCTAB nTab) const
Definition: documen9.cxx:504

ScDocument::GetStorageGrammar
formula::FormulaGrammar::Grammar GetStorageGrammar() const
Definition: document.hxx:2543

ScDocument::pValidationList
std::unique_ptr< ScValidationDataList > pValidationList
Definition: document.hxx:376

ScDocument::CopyScenario
void CopyScenario(SCTAB nSrcTab, SCTAB nDestTab, bool bNewScenario=false)
Definition: documen3.cxx:811

ScDocument::IsDocEditable
bool IsDocEditable() const
Definition: documen3.cxx:1899

ScDocument::SetConsolidateDlgData
void SetConsolidateDlgData(std::unique_ptr< ScConsolidateParam > pData)
Definition: documen2.cxx:1168

ScDocument::ShrinkToUsedDataArea
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
Shrink a range to only include used data area.
Definition: document.cxx:1049

ScDocument::RemoveLookupCache
void RemoveLookupCache(ScLookupCache &rCache)
Only ScLookupCache dtor uses RemoveLookupCache(), do not use elsewhere!
Definition: documen2.cxx:1271

ScDocument::HasRowBreak
SC_DLLPUBLIC ScBreakType HasRowBreak(SCROW nRow, SCTAB nTab) const
Definition: document.cxx:4355

ScDocument::xRowNameRanges
ScRangePairListRef xRowNameRanges
Definition: document.hxx:421

ScDocument::GetRowBreakIterator
ScRowBreakIterator * GetRowBreakIterator(SCTAB nTab) const
Definition: document.cxx:6379

ScDocument::SetSubTotalCellsDirty
void SetSubTotalCellsDirty(const ScRange &rDirtyRange)
Definition: document.cxx:6412

ScDocument::GetStringScriptType
SC_DLLPUBLIC SvtScriptType GetStringScriptType(const OUString &rString)
Definition: documen6.cxx:76

ScDocument::bImportingXML
bool bImportingXML
Definition: document.hxx:505

ScDocument::GetExternalRefManager
SC_DLLPUBLIC ScExternalRefManager * GetExternalRefManager() const
Definition: documen3.cxx:625

ScDocument::GetOriginalHeight
SC_DLLPUBLIC sal_uInt16 GetOriginalHeight(SCROW nRow, SCTAB nTab) const
Definition: document.cxx:4153

ScDocument::IsInLayoutStrings
bool IsInLayoutStrings() const
Definition: document.hxx:2635

ScDocument::GetMaxStringLen
sal_Int32 GetMaxStringLen(SCTAB nTab, SCCOL nCol, SCROW nRowStart, SCROW nRowEnd, rtl_TextEncoding eCharSet) const
Maximum string length of a column, e.g.
Definition: documen4.cxx:586

ScDocument::GetRefDevice
SC_DLLPUBLIC OutputDevice * GetRefDevice()
Definition: documen8.cxx:199

ScDocument::MaxRowAsString
SC_DLLPUBLIC OUString MaxRowAsString() const
Definition: document.hxx:896

ScDocument::SetTabNameOnLoad
void SetTabNameOnLoad(SCTAB nTab, const OUString &rName)
Definition: document.cxx:465

ScDocument::GetTiledRenderingArea
SC_DLLPUBLIC void GetTiledRenderingArea(SCTAB nTab, SCCOL &rEndCol, SCROW &rEndRow) const
Return the number of columns / rows that should be visible for the tiled rendering.
Definition: documen2.cxx:702

ScDocument::UpdateExternalRefLinks
void UpdateExternalRefLinks(weld::Window *pWin)
Definition: documen8.cxx:789

ScDocument::DeleteSparkline
SC_DLLPUBLIC bool DeleteSparkline(ScAddress const &rPosition)
Definition: document.cxx:6516

ScDocument::SetChangeViewSettings
SC_DLLPUBLIC void SetChangeViewSettings(const ScChangeViewSettings &rNew)
Definition: documen2.cxx:1173

ScDocument::mnMutationGuardFlags
size_t mnMutationGuardFlags
Definition: document.hxx:577

ScDocument::SetAutoNameCache
SC_DLLPUBLIC void SetAutoNameCache(std::unique_ptr< ScAutoNameCache > pCache)
Definition: document.cxx:6886

ScDocument::EndUnoRefUndo
std::unique_ptr< ScUnoRefList > EndUnoRefUndo()
Definition: documen3.cxx:996

ScDocument::GetScenarioData
SC_DLLPUBLIC void GetScenarioData(SCTAB nTab, OUString &rComment, Color &rColor, ScScenarioFlags &rFlags) const
Definition: documen3.cxx:469

ScDocument::GetAllTabRangeNames
SC_DLLPUBLIC void GetAllTabRangeNames(ScRangeName::TabNameCopyMap &rRangeNames) const
Get all range names that are local to each table.
Definition: documen3.cxx:107

ScDocument::HasOLEObjectsInArea
bool HasOLEObjectsInArea(const ScRange &rRange, const ScMarkData *pTabMark=nullptr)
Definition: documen9.cxx:264

ScDocument::IsEmbedded
bool IsEmbedded() const
Definition: document.hxx:952

ScDocument::mpDocLinkMgr
std::unique_ptr< sc::DocumentLinkManager > mpDocLinkMgr
Definition: document.hxx:361

ScDocument::IsDelayedFormulaGrouping
bool IsDelayedFormulaGrouping() const
Definition: document.hxx:1425

ScDocument::nAdjustHeightLock
sal_uInt32 nAdjustHeightLock
Definition: document.hxx:544

ScDocument::EnableExecuteLink
void EnableExecuteLink(bool bVal)
Definition: document.hxx:1603

ScDocument::LimitChartArea
void LimitChartArea(SCTAB nTab, SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow)
Definition: document.cxx:1091

ScDocument::pEOFormulaTree
ScFormulaCell * pEOFormulaTree
Definition: document.hxx:387

ScDocument::EnsureFormulaCellResults
SC_DLLPUBLIC bool EnsureFormulaCellResults(const ScRange &rRange, bool bSkipRunning=false)
Make sure all of the formula cells in the specified range have been fully calculated.
Definition: document10.cxx:1001

ScDocument::RemoveMerge
void RemoveMerge(SCCOL nCol, SCROW nRow, SCTAB nTab)
Definition: documen3.cxx:2080

ScDocument::EndListeningGroups
void EndListeningGroups(const std::vector< ScAddress > &rPosArray)
Definition: document10.cxx:505

ScDocument::GetHiddenRowCount
SCROW GetHiddenRowCount(SCROW nRow, SCTAB nTab) const
Definition: document.cxx:4216

ScDocument::mbIdleEnabled
bool mbIdleEnabled
Definition: document.hxx:509

ScDocument::GetFilterEntriesArea
SC_DLLPUBLIC void GetFilterEntriesArea(SCCOL nCol, SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bCaseSens, ScFilterEntries &rFilterEntries)
Entries for Filter dialog.
Definition: documen3.cxx:1608

ScDocument::GetRowNameRangesRef
ScRangePairListRef & GetRowNameRangesRef()
Definition: document.hxx:822

ScDocument::CopyTabProtection
void CopyTabProtection(SCTAB nTabSrc, SCTAB nTabDest)
Definition: documen3.cxx:1928

ScDocument::UnshareFormulaCells
void UnshareFormulaCells(SCTAB nTab, SCCOL nCol, std::vector< SCROW > &rRows)
Make specified formula cells non-grouped.
Definition: document10.cxx:355

ScDocument::SetStreamValid
void SetStreamValid(SCTAB nTab, bool bSet, bool bIgnoreLock=false)
Definition: document.cxx:904

ScDocument::AddDelayedFormulaGroupingCell
void AddDelayedFormulaGroupingCell(const ScFormulaCell *cell)
To be used only by SharedFormulaUtil::joinFormulaCells().
Definition: document10.cxx:395

ScDocument::GetCopyTabName
OUString GetCopyTabName(SCTAB nTab) const
Definition: document.cxx:215

ScDocument::StylesToNames
void StylesToNames()
Definition: document.cxx:6112

ScDocument::ReservePatternCount
void ReservePatternCount(SCTAB nTab, SCCOL nCol, SCSIZE nReserve)
Definition: documen3.cxx:2118

ScDocument::FillTab
void FillTab(const ScRange &rSrcArea, const ScMarkData &rMark, InsertDeleteFlags nFlags, ScPasteFunc nFunction, bool bSkipEmpty, bool bAsLink)
Definition: document.cxx:3257

ScDocument::CopyToClip
SC_DLLPUBLIC void CopyToClip(const ScClipParam &rClipParam, ScDocument *pClipDoc, const ScMarkData *pMarks, bool bKeepScenarioFlags, bool bIncludeObjects)
Definition: document.cxx:2142

ScDocument::IsInLinkUpdate
bool IsInLinkUpdate() const
Definition: documen8.cxx:784

ScDocument::mbTrackFormulasPending
bool mbTrackFormulasPending
Definition: document.hxx:570

ScDocument::ScDocument
ScDocument(const ScDocument &r)=delete

ScDocument::GetViewOptions
SC_DLLPUBLIC const ScViewOptions & GetViewOptions() const
Definition: documen3.cxx:1951

ScDocument::DoEmptyBlock
SC_DLLPUBLIC void DoEmptyBlock(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab)
Definition: documen3.cxx:2050

ScDocument::GetDdeLinkResultMatrix
SC_DLLPUBLIC const ScMatrix * GetDdeLinkResultMatrix(size_t nDdePos) const
Returns the result matrix of the specified DDE link.
Definition: documen8.cxx:982

ScDocument::AddUnoObject
void AddUnoObject(SfxListener &rObject)
Definition: documen3.cxx:901

ScDocument::SetLOKFreezeRow
bool SetLOKFreezeRow(SCROW nFreezeRow, SCTAB nTab)
Definition: document10.cxx:1079

ScDocument::SetRowHeightRange
SC_DLLPUBLIC void SetRowHeightRange(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt16 nNewHeight)
Definition: document.cxx:4104

ScDocument::IsUserInteractionEnabled
SC_DLLPUBLIC bool IsUserInteractionEnabled() const
Definition: document.hxx:1606

ScDocument::UpdStlShtPtrsFrmNms
void UpdStlShtPtrsFrmNms()
Definition: document.cxx:6099

ScDocument::GetNoListening
bool GetNoListening() const
Definition: document.hxx:2230

ScDocument::SetDocShellRecalc
void SetDocShellRecalc(bool bSet)
Definition: document.hxx:2633

ScDocument::AddSubTotalCell
void AddSubTotalCell(ScFormulaCell *pCell)
Definition: document.cxx:6386

ScDocument::GetRecursionHelper
ScRecursionHelper & GetRecursionHelper()
Definition: document.cxx:6893

ScDocument::mbUserInteractionEnabled
bool mbUserInteractionEnabled
Definition: document.hxx:553

ScDocument::ApplyPattern
SC_DLLPUBLIC void ApplyPattern(SCCOL nCol, SCROW nRow, SCTAB nTab, const ScPatternAttr &rAttr)
Definition: document.cxx:4747

ScDocument::ResetCalcNotifications
void ResetCalcNotifications()
Definition: documen3.cxx:729

ScDocument::SetChartListenerCollection
void SetChartListenerCollection(std::unique_ptr< ScChartListenerCollection >, bool bSetChartRangeLists)
Definition: documen3.cxx:412

ScDocument::HasLinkFormulaNeedingCheck
bool HasLinkFormulaNeedingCheck() const
Definition: document.hxx:2213

ScDocument::SetInLinkUpdate
void SetInLinkUpdate(bool bSet)
Definition: documen8.cxx:776

ScDocument::SetEmbedFontScriptAsian
void SetEmbedFontScriptAsian(bool bUse)
Definition: document.hxx:592

ScDocument::GetEditPool
SC_DLLPUBLIC SfxItemPool * GetEditPool() const
Definition: documen2.cxx:473

ScDocument::pDetOpList
std::unique_ptr< ScDetOpList > pDetOpList
Definition: document.hxx:393

ScDocument::SetCondFormList
void SetCondFormList(ScConditionalFormatList *pList, SCTAB nTab)
Definition: documen4.cxx:867

ScDocument::CreateFieldEditEngine
std::unique_ptr< ScFieldEditEngine > CreateFieldEditEngine()
Definition: documen2.cxx:1181

ScDocument::ShowCol
SC_DLLPUBLIC void ShowCol(SCCOL nCol, SCTAB nTab, bool bShow)
Definition: document.cxx:4297

ScDocument::Broadcast
void Broadcast(const ScHint &rHint)
Broadcast wrapper, calls rHint.GetCell()->Broadcast() and AreaBroadcast() and TrackFormulas() Preferr...
Definition: documen7.cxx:117

ScDocument::CreateQueryParam
SC_DLLPUBLIC bool CreateQueryParam(const ScRange &rRange, ScQueryParam &rQueryParam)
Definition: documen3.cxx:1485

ScDocument::GetAutoCalc
SC_DLLPUBLIC bool GetAutoCalc() const
Definition: document.hxx:1413

ScDocument::GetLastChangedColFlagsWidth
SCCOL GetLastChangedColFlagsWidth(SCTAB nTab) const
Definition: document.cxx:4546

ScDocument::GetUpperCellString
OUString GetUpperCellString(SCCOL nCol, SCROW nRow, SCTAB nTab)
Definition: documen3.cxx:1477

ScDocument::HasStringData
SC_DLLPUBLIC bool HasStringData(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: document.cxx:3743

ScDocument::SetCodeName
void SetCodeName(const OUString &r)
Definition: document.hxx:610

ScDocument::GetAllNoteEntries
SC_DLLPUBLIC void GetAllNoteEntries(std::vector< sc::NoteEntry > &rNotes) const
Definition: document.cxx:6837

ScDocument::IsValidAsianCompression
bool IsValidAsianCompression() const
Definition: documen9.cxx:618

ScDocument::SetEmbedFonts
void SetEmbedFonts(bool bUse)
Definition: document.hxx:589

ScDocument::IsInVBAMode
bool IsInVBAMode() const
Definition: document.cxx:6477

ScDocument::GetMostUsedPattern
SC_DLLPUBLIC const ScPatternAttr * GetMostUsedPattern(SCCOL nCol, SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
Definition: document.cxx:4734

ScDocument::SetLanguage
void SetLanguage(LanguageType eLatin, LanguageType eCjk, LanguageType eCtl)
Definition: documen3.cxx:1970

ScDocument::CreateSelectionPattern
std::unique_ptr< ScPatternAttr > CreateSelectionPattern(const ScMarkData &rMark, bool bDeep=true)
Definition: document.cxx:5015

ScDocument::InitUndoSelected
SC_DLLPUBLIC void InitUndoSelected(const ScDocument &rSrcDoc, const ScMarkData &rTabSelection, bool bColInfo=false, bool bRowInfo=false)
Definition: document.cxx:1943

ScDocument::CalcFormulaTree
SC_DLLPUBLIC void CalcFormulaTree(bool bOnlyForced=false, bool bProgressBar=true, bool bSetAllDirty=true)
Calculate formula cells that are on the formula tree either partially, or in full.
Definition: documen7.cxx:328

ScDocument::IsStyleSheetUsed
bool IsStyleSheetUsed(const ScStyleSheet &rStyle) const
Definition: document.cxx:4938

ScDocument::bLoadingMedium
bool bLoadingMedium
Definition: document.hxx:504

ScDocument::GetChangeViewSettings
ScChangeViewSettings * GetChangeViewSettings() const
Definition: document.hxx:2243

ScDocument::pExtDocOptions
std::unique_ptr< ScExtDocOptions > pExtDocOptions
Definition: document.hxx:425

ScDocument::HasRangeOverflow
bool HasRangeOverflow() const
Definition: document.hxx:2219

ScDocument::ReleaseNote
SC_DLLPUBLIC std::unique_ptr< ScPostIt > ReleaseNote(const ScAddress &rPos)
Definition: document.cxx:6689

ScDocument::SetNumberFormat
SC_DLLPUBLIC void SetNumberFormat(const ScAddress &rPos, sal_uInt32 nNumberFormat)
Definition: document.cxx:3682

ScDocument::SetString
SC_DLLPUBLIC bool SetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString &rString, const ScSetStringParam *pParam=nullptr)
Definition: document.cxx:3391

ScDocument::StartTrackTimer
void StartTrackTimer()
Definition: documen2.cxx:332

ScDocument::RestorePrintRanges
void RestorePrintRanges(const ScPrintRangeSaver &rSaver)
Definition: document.cxx:6331

ScDocument::ReplaceStyle
void ReplaceStyle(const SvxSearchItem &rSearchItem, SCCOL nCol, SCROW nRow, SCTAB nTab, const ScMarkData &rMark)
Definition: documen4.cxx:546

ScDocument::GetColNameRanges
ScRangePairList * GetColNameRanges()
Definition: document.hxx:819

ScDocument::GetFilterEntries
void GetFilterEntries(SCCOL nCol, SCROW nRow, SCTAB nTab, ScFilterEntries &rFilterEntries)
Get a list of unique strings to use in filtering criteria.
Definition: documen3.cxx:1556

ScDocument::StartChangeTracking
void StartChangeTracking()
Definition: documen2.cxx:277

ScDocument::bExpandRefs
bool bExpandRefs
Definition: document.hxx:520

ScDocument::ApplySelectionLineStyle
void ApplySelectionLineStyle(const ScMarkData &rMark, const ::editeng::SvxBorderLine *pLine, bool bColorOnly)
Definition: document.cxx:4852

ScDocument::maTabs
TableContainer maTabs
Definition: document.hxx:378

ScDocument::HasSparkline
SC_DLLPUBLIC bool HasSparkline(ScAddress const &rPosition)
Definition: document.cxx:6503

ScDocument::GetExtDocOptions
ScExtDocOptions * GetExtDocOptions()
Definition: document.hxx:644

ScDocument::GetLOKFreezeCol
SCCOL GetLOKFreezeCol(SCTAB nTab) const
Definition: document10.cxx:1053

ScDocument::EndListeningIntersectedGroups
void EndListeningIntersectedGroups(sc::EndListeningContext &rCxt, const ScRange &rRange, std::vector< ScAddress > *pGroupPos)
Definition: document10.cxx:490

ScDocument::GetExternalDataMapper
SC_DLLPUBLIC sc::ExternalDataMapper & GetExternalDataMapper()
Definition: document10.cxx:1018

ScDocument::HasData
SC_DLLPUBLIC bool HasData(SCCOL nCol, SCROW nRow, SCTAB nTab)
Definition: documen5.cxx:529

ScDocument::GetPageStyle
SC_DLLPUBLIC OUString GetPageStyle(SCTAB nTab) const
Definition: document.cxx:6176

ScDocument::SetName
void SetName(const OUString &r)
Definition: document.hxx:608

ScDocument::SetGrammar
SC_DLLPUBLIC void SetGrammar(formula::FormulaGrammar::Grammar eGram)
Definition: documen3.cxx:497

ScDocument::HasAnyCalcNotification
bool HasAnyCalcNotification() const
Definition: documen3.cxx:706

ScDocument::eLanguage
LanguageType eLanguage
Definition: document.hxx:452

ScDocument::bIsClip
bool bIsClip
Definition: document.hxx:494

ScDocument::IsStreamValid
bool IsStreamValid(SCTAB nTab) const
Definition: document.cxx:897

ScDocument::LimitChartIfAll
void LimitChartIfAll(ScRangeListRef &rRangeList)
Definition: document.cxx:1098

ScDocument::InitUndo
SC_DLLPUBLIC void InitUndo(const ScDocument &rSrcDoc, SCTAB nTab1, SCTAB nTab2, bool bColInfo=false, bool bRowInfo=false)
Definition: document.cxx:1975

ScDocument::IsFunctionAccess
bool IsFunctionAccess() const
Definition: document.hxx:1597

ScDocument::CopyOneCellFromClip
SC_DLLPUBLIC bool CopyOneCellFromClip(sc::CopyFromClipContext &rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
Definition: document10.cxx:83

ScDocument::CopyRangeNamesToClip
void CopyRangeNamesToClip(ScDocument *pClipDoc, const ScRange &rClipRange, const ScMarkData *pMarks)
Definition: document.cxx:2427

ScDocument::HasPrintRange
SC_DLLPUBLIC bool HasPrintRange()
Definition: document.cxx:6239

ScDocument::SetAsianKerning
void SetAsianKerning(bool bNew)
Definition: documen9.cxx:653

ScDocument::bDetectiveDirty
bool bDetectiveDirty
Definition: document.hxx:522

ScDocument::DeleteSelectionTab
void DeleteSelectionTab(SCTAB nTab, InsertDeleteFlags nDelFlag, const ScMarkData &rMark)
Definition: document.cxx:5979

ScDocument::GetCellChangeTrackNote
void GetCellChangeTrackNote(const ScAddress &cell, OUString &strTrackText, bool &pbLeftEdge)
Definition: documen2.cxx:1380

ScDocument::mbLayoutStrings
bool mbLayoutStrings
Definition: document.hxx:575

ScDocument::DeleteArea
SC_DLLPUBLIC void DeleteArea(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData &rMark, InsertDeleteFlags nDelFlag, bool bBroadcast=true, sc::ColumnSpanSet *pBroadcastSpans=nullptr)
Definition: document.cxx:1859

ScDocument::HasColHeader
SC_DLLPUBLIC bool HasColHeader(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab)
Definition: documen3.cxx:1526

ScDocument::pExternalRefMgr
std::unique_ptr< ScExternalRefManager > pExternalRefMgr
Definition: document.hxx:410

ScDocument::SetAllFormulasDirty
void SetAllFormulasDirty(const sc::SetFormulaDirtyContext &rCxt)
Definition: document.cxx:3819

ScDocument::UpdateOutlineRow
bool UpdateOutlineRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bShow)
Definition: documen3.cxx:1424

ScDocument::eStorageGrammar
formula::FormulaGrammar::Grammar eStorageGrammar
The compiler grammar used in document storage.
Definition: document.hxx:459

ScDocument::DeleteRow
void DeleteRow(SCCOL nStartCol, SCTAB nStartTab, SCCOL nEndCol, SCTAB nEndTab, SCROW nStartRow, SCSIZE nSize, ScDocument *pRefUndoDoc=nullptr, bool *pUndoOutline=nullptr, const ScMarkData *pTabMark=nullptr)
Definition: document.cxx:1345

ScDocument::ExtendTotalMerge
SC_DLLPUBLIC void ExtendTotalMerge(ScRange &rRange) const
Definition: document.cxx:5606

ScDocument::DelBroadcastAreasInRange
void DelBroadcastAreasInRange(const ScRange &rRange)
Definition: documen7.cxx:215

ScDocument::GetCommonWidth
sal_uInt16 GetCommonWidth(SCCOL nEndCol, SCTAB nTab) const
Definition: document.cxx:4145

ScDocument::GetErrCode
FormulaError GetErrCode(const ScAddress &) const
Definition: document.cxx:4066

ScDocument::GetPrintAreaHor
SC_DLLPUBLIC bool GetPrintAreaHor(SCTAB nTab, SCROW nStartRow, SCROW nEndRow, SCCOL &rEndCol) const
Definition: documen2.cxx:635

ScDocument::GetDocumentID
sal_uInt32 GetDocumentID() const
an ID unique to each document instance
Definition: documen2.cxx:268

ScDocument::nInDdeLinkUpdate
sal_uInt8 nInDdeLinkUpdate
Definition: document.hxx:540

ScDocument::GetBASM
ScBroadcastAreaSlotMachine * GetBASM() const
Definition: document.hxx:2231

ScDocument::GetSelectionFrame
void GetSelectionFrame(const ScMarkData &rMark, SvxBoxItem &rLineOuter, SvxBoxInfoItem &rLineInner)
Definition: document.cxx:5064

ScDocument::SetViewOptions
SC_DLLPUBLIC void SetViewOptions(const ScViewOptions &rOpt)
Definition: documen3.cxx:1957

ScDocument::HasColBreak
SC_DLLPUBLIC ScBreakType HasColBreak(SCCOL nCol, SCTAB nTab) const
Definition: document.cxx:4369

ScDocument::GetVbaEventProcessor
const css::uno::Reference< css::script::vba::XVBAEventProcessor > & GetVbaEventProcessor() const
Definition: document.hxx:2539

ScDocument::SetDrawPageSize
SC_DLLPUBLIC void SetDrawPageSize(SCTAB nTab)
Definition: documen9.cxx:203

ScDocument::DeleteObjectsInSelection
void DeleteObjectsInSelection(const ScMarkData &rMark)
Definition: documen9.cxx:256

ScDocument::GetDrawLayer
SC_DLLPUBLIC ScDrawLayer * GetDrawLayer()
Definition: document.hxx:1084

ScDocument::ApplySelectionPattern
SC_DLLPUBLIC void ApplySelectionPattern(const ScPatternAttr &rAttr, const ScMarkData &rMark, ScEditDataArray *pDataArray=nullptr, bool *pIsChanged=nullptr)
Definition: document.cxx:5864

ScDocument::GetHashCode
SC_DLLPUBLIC bool GetHashCode(SCTAB nTab, sal_Int64 &rHashCode) const
Definition: document.cxx:194

ScDocument::ShowRows
SC_DLLPUBLIC void ShowRows(SCROW nRow1, SCROW nRow2, SCTAB nTab, bool bShow)
Definition: document.cxx:4309

ScDocument::LastNonFilteredRow
SCROW LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
Definition: document.cxx:4509

ScDocument::IsPendingRowHeights
bool IsPendingRowHeights(SCTAB nTab) const
Definition: document.cxx:915

ScDocument::GetOptimalColWidth
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)
Definition: document.cxx:4240

ScDocument::RowHidden
SC_DLLPUBLIC bool RowHidden(SCROW nRow, SCTAB nTab, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) const
Definition: document.cxx:4416

ScDocument::bIsFunctionAccess
bool bIsFunctionAccess
Definition: document.hxx:496

ScDocument::RemoveFromFormulaTrack
void RemoveFromFormulaTrack(ScFormulaCell *pCell)
Definition: documen7.cxx:469

ScDocument::ExtendMergeSel
void ExtendMergeSel(SCCOL nStartCol, SCROW nStartRow, SCCOL &rEndCol, SCROW &rEndRow, const ScMarkData &rMark, bool bRefresh=false)
Definition: document.cxx:5528

ScDocument::bAutoCalcShellDisabled
bool bAutoCalcShellDisabled
Definition: document.hxx:488

ScDocument::CreateValidTabName
SC_DLLPUBLIC void CreateValidTabName(OUString &rName) const
Definition: document.cxx:375

ScDocument::eHardRecalcState
HardRecalcState eHardRecalcState
Definition: document.hxx:480

ScDocument::HasAnyDraw
bool HasAnyDraw(SCTAB nTab, const tools::Rectangle &rMMRect) const
Definition: documen9.cxx:356

ScDocument::ExtendHidden
void ExtendHidden(SCCOL &rX1, SCROW &rY1, SCCOL &rX2, SCROW &rY2, SCTAB nTab)
Definition: document.cxx:4676

ScDocument::SetDetOpList
void SetDetOpList(std::unique_ptr< ScDetOpList > pNew)
Definition: documen4.cxx:905

ScDocument::GetImagePreferredDPI
sal_Int32 GetImagePreferredDPI()
Definition: document.hxx:596

ScDocument::GetDataEntries
void GetDataEntries(SCCOL nCol, SCROW nRow, SCTAB nTab, std::vector< ScTypedStrData > &rStrings, bool bValidation=false)
Entries for selection list listbox (no numbers/formulas)
Definition: documen3.cxx:1622

ScDocument::GetRowFlags
SC_DLLPUBLIC CRFlags GetRowFlags(SCROW nRow, SCTAB nTab) const
Definition: document.cxx:4335

ScDocument::CreateSharedStringTextObject
std::unique_ptr< EditTextObject > CreateSharedStringTextObject(const svl::SharedString &rSS)
Definition: documen2.cxx:514

ScDocument::pChangeTrack
std::unique_ptr< ScChangeTrack > pChangeTrack
Definition: document.hxx:394

ScDocument::SetPrinter
void SetPrinter(VclPtr< SfxPrinter > const &pNewPrinter)
Definition: documen8.cxx:142

ScDocument::SearchSparklineGroup
SC_DLLPUBLIC std::shared_ptr< sc::SparklineGroup > SearchSparklineGroup(tools::Guid const &rGuid)
Definition: document.cxx:6566

ScDocument::GetNotePosition
ScAddress GetNotePosition(size_t nIndex) const
Definition: document.cxx:6775

ScDocument::DisposeFieldEditEngine
void DisposeFieldEditEngine(std::unique_ptr< ScFieldEditEngine > &rpEditEngine)
Definition: documen2.cxx:1203

ScDocument::HasNote
SC_DLLPUBLIC bool HasNote(const ScAddress &rPos) const
Definition: document.cxx:6618

ScDocument::GetScenarioRanges
SC_DLLPUBLIC const ScRangeList * GetScenarioRanges(SCTAB nTab) const
Definition: documen3.cxx:872

ScDocument::GetCondFormat
SC_DLLPUBLIC ScConditionalFormat * GetCondFormat(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: documen4.cxx:837

ScDocument::DoAutoOutline
void DoAutoOutline(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab)
Definition: documen3.cxx:760

ScDocument::GetForbiddenCharacters
const std::shared_ptr< SvxForbiddenCharactersTable > & GetForbiddenCharacters() const
Definition: documen9.cxx:604

ScDocument::pFormatExchangeList
SvNumberFormatterIndexTable * pFormatExchangeList
Definition: document.hxx:377

ScDocument::mpUndoManager
ScUndoManager * mpUndoManager
Definition: document.hxx:368

ScDocument::GetAllColBreaks
SC_DLLPUBLIC void GetAllColBreaks(std::set< SCCOL > &rBreaks, SCTAB nTab, bool bPage, bool bManual) const
Definition: document.cxx:4349

ScDocument::SetRepeatRowRange
SC_DLLPUBLIC void SetRepeatRowRange(SCTAB nTab, std::optional< ScRange > oNew)
Definition: document.cxx:6315

ScDocument::SetRowBreak
SC_DLLPUBLIC void SetRowBreak(SCROW nRow, SCTAB nTab, bool bPage, bool bManual)
Definition: document.cxx:4384

ScDocument::GetNumberFormatInfo
void GetNumberFormatInfo(const ScInterpreterContext &rContext, SvNumFormatType &nType, sal_uInt32 &nIndex, const ScAddress &rPos) const
Definition: document.cxx:3690

ScDocument::dumpSheetGeomData
OString dumpSheetGeomData(SCTAB nTab, bool bColumns, SheetGeomType eGeomType)
Serializes the specified sheet's geometry data.
Definition: document10.cxx:1044

ScDocument::m_pIconSetBitmapMap
std::unique_ptr< sc::IconSetBitmapMap > m_pIconSetBitmapMap
Definition: document.hxx:568

ScDocument::IsExecuteLinkEnabled
bool IsExecuteLinkEnabled() const
Definition: document.hxx:1602

ScDocument::SetCalcConfig
SC_DLLPUBLIC void SetCalcConfig(const ScCalcConfig &rConfig)
Definition: document10.cxx:205

ScDocument::HasAttrib
SC_DLLPUBLIC bool HasAttrib(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, HasAttrFlags nMask) const
Definition: document.cxx:5161

ScDocument::SetSortParam
void SC_DLLPUBLIC SetSortParam(const ScSortParam &rParam, SCTAB nTab)
Definition: documen3.cxx:2129

ScDocument::AddUndoTab
void AddUndoTab(SCTAB nTab1, SCTAB nTab2, bool bColInfo=false, bool bRowInfo=false)
Definition: document.cxx:2000

ScDocument::GetGrammar
SC_DLLPUBLIC formula::FormulaGrammar::Grammar GetGrammar() const
Definition: document.hxx:1010

ScDocument::GetColFlags
SC_DLLPUBLIC CRFlags GetColFlags(SCCOL nCol, SCTAB nTab) const
Definition: document.cxx:4327

ScDocument::InvalidateStreamOnSave
void InvalidateStreamOnSave()
Definition: document.cxx:476

ScDocument::UpdateScriptTypes
void UpdateScriptTypes(const ScAddress &rPos, SCCOL nColSize, SCROW nRowSize)
Definition: document10.cxx:337

ScDocument::Reorder
void Reorder(const sc::ReorderParam &rParam)
Definition: documen3.cxx:1446

ScDocument::IdleCalcTextWidth
bool IdleCalcTextWidth()
Definition: documen8.cxx:532

ScDocument::RegroupFormulaCells
void RegroupFormulaCells(SCTAB nTab, SCCOL nCol)
Definition: document10.cxx:364

ScDocument::IsBlockEditable
bool IsBlockEditable(SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, bool *pOnlyNotBecauseOfMatrix=nullptr, bool bNoMatrixAtAll=false) const
Definition: document.cxx:5317

ScDocument::MarkUsedExternalReferences
void MarkUsedExternalReferences()
Definition: documen3.cxx:639

ScDocument::HardRecalcState
HardRecalcState
Definition: document.hxx:351

ScDocument::StartListeningArea
void StartListeningArea(const ScRange &rRange, bool bGroupListening, SvtListener *pListener)
Definition: documen7.cxx:35

ScDocument::IsEmbedFontScriptLatin
bool IsEmbedFontScriptLatin() const
Definition: document.hxx:585

ScDocument::SetRangeOverflowType
void SetRangeOverflowType(ErrCode nType)
Definition: document.hxx:2218

ScDocument::EndListeningFormulaCells
void EndListeningFormulaCells(std::vector< ScFormulaCell * > &rCells)
Definition: documen7.cxx:253

ScDocument::maThreadSpecific
static thread_local ScDocumentThreadSpecific maThreadSpecific
Definition: document.hxx:471

ScDocument::GetDrawBroadcaster
SfxBroadcaster * GetDrawBroadcaster()
Definition: documen9.cxx:56

ScDocument::SetDirtyFromClip
void SetDirtyFromClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData &rMark, InsertDeleteFlags nInsFlag, sc::ColumnSpanSet &rBroadcastSpans)
Definition: document.cxx:2611

ScDocument::EndListeningCell
void EndListeningCell(const ScAddress &rAddress, SvtListener *pListener)
Definition: documen7.cxx:230

ScDocument::GetTableArea
SC_DLLPUBLIC bool GetTableArea(SCTAB nTab, SCCOL &rEndCol, SCROW &rEndRow, bool bCalcHiddens=false) const
Definition: document.cxx:1008

ScDocument::pUnoRefUndoList
std::unique_ptr< ScUnoRefList > pUnoRefUndoList
Definition: document.hxx:397

ScDocument::GetRangeAtBlock
SC_DLLPUBLIC const ScRangeData * GetRangeAtBlock(const ScRange &rBlock, OUString &rName, bool *pSheetLocal=nullptr) const
Definition: documen3.cxx:238

ScDocument::HasUnoRefUndo
bool HasUnoRefUndo() const
Definition: document.hxx:1090

ScDocument::GetEmbedded
void GetEmbedded(ScRange &rRange) const
Definition: documen3.cxx:1703

ScDocument::mScLookupMutex
std::shared_mutex mScLookupMutex
Definition: document.hxx:475

ScDocument::IsClipOrUndo
bool IsClipOrUndo() const
Definition: document.hxx:1592

ScDocument::SetPreviewSelection
void SetPreviewSelection(const ScMarkData &rSel)
Definition: documen2.cxx:1473

ScDocument::GetInputString
SC_DLLPUBLIC OUString GetInputString(SCCOL nCol, SCROW nRow, SCTAB nTab, bool bForceSystemLocale=false) const
Definition: document.cxx:3549

ScDocument::DeleteObjectsInArea
void DeleteObjectsInArea(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData &rMark, bool bAnchored=false)
Definition: documen9.cxx:240

ScDocument::SetImportingXML
SC_DLLPUBLIC void SetImportingXML(bool bVal)
Definition: documen9.cxx:581

ScDocument::GetLOKFreezeRow
SCROW GetLOKFreezeRow(SCTAB nTab) const
Definition: document10.cxx:1061

ScDocument::HasCalcNotification
bool HasCalcNotification(SCTAB nTab) const
Definition: documen3.cxx:715

ScDocument::SetError
void SetError(SCCOL nCol, SCROW nRow, SCTAB nTab, const FormulaError nError)
Definition: documen2.cxx:1129

ScDocument::CopyToDocument
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)
Definition: document.cxx:2041

ScDocument::ApplyPatternIfNumberformatIncompatible
SC_DLLPUBLIC void ApplyPatternIfNumberformatIncompatible(const ScRange &rRange, const ScMarkData &rMark, const ScPatternAttr &rPattern, SvNumFormatType nNewType)
Definition: document.cxx:4777

ScDocument::GetConsolidateDlgData
const ScConsolidateParam * GetConsolidateDlgData() const
Definition: document.hxx:654

ScDocument::SetDocVisible
SC_DLLPUBLIC void SetDocVisible(bool bSet)
Definition: documen2.cxx:261

ScDocument::PastingDrawFromOtherDoc
bool PastingDrawFromOtherDoc() const
Definition: document.hxx:2527

ScDocument::GetPatternCount
SCSIZE GetPatternCount(SCTAB nTab, SCCOL nCol) const
Definition: documen3.cxx:2103

ScDocument::nRangeOverflowType
ErrCode nRangeOverflowType
Definition: document.hxx:436

ScDocument::GetDBCollection
SC_DLLPUBLIC ScDBCollection * GetDBCollection() const
Definition: document.hxx:827

ScDocument::SetValue
SC_DLLPUBLIC void SetValue(SCCOL nCol, SCROW nRow, SCTAB nTab, const double &rVal)
Definition: document.cxx:3477

ScDocument::bIsEmbedded
bool bIsEmbedded
Definition: document.hxx:499

ScDocument::CopyDdeLinks
SC_DLLPUBLIC void CopyDdeLinks(ScDocument &rDestDoc) const
Definition: documen8.cxx:866

ScDocument::FindAreaPos
void FindAreaPos(SCCOL &rCol, SCROW &rRow, SCTAB nTab, ScMoveDirection eDirection) const
Definition: document.cxx:6078

ScDocument::GetXMLImportedFormulaCount
sal_uInt64 GetXMLImportedFormulaCount() const
Definition: document.hxx:2459

ScDocument::bIsUndo
bool bIsUndo
Definition: document.hxx:495

ScDocument::IsChangeReadOnlyEnabled
bool IsChangeReadOnlyEnabled() const
Definition: document.hxx:1604

ScDocument::GetDPAtCursor
SC_DLLPUBLIC ScDPObject * GetDPAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: documen3.cxx:377

ScDocument::GetDdeLinkMode
bool GetDdeLinkMode(size_t nDdePos, sal_uInt8 &rnMode) const
Returns the link mode of the specified DDE link.
Definition: documen8.cxx:972

ScDocument::FindOrder
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)
Definition: documen4.cxx:997

ScDocument::ApplyStyle
void ApplyStyle(SCCOL nCol, SCROW nRow, SCTAB nTab, const ScStyleSheet &rStyle)
Definition: document.cxx:4802

ScDocument::GetCodeName
const OUString & GetCodeName() const
Definition: document.hxx:609

ScDocument::ApplyPatternArea
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)
Definition: document.cxx:4753

ScDocument::IsEmbedFontScriptAsian
bool IsEmbedFontScriptAsian() const
Definition: document.hxx:586

ScDocument::GetDocStat
void GetDocStat(ScDocStat &rDocStat)
Definition: document.cxx:6231

ScDocument::MergeNumberFormatter
void MergeNumberFormatter(const ScDocument &rSrcDoc)
Definition: document.cxx:2548

ScDocument::ClearSelectionItems
void ClearSelectionItems(const sal_uInt16 *pWhich, const ScMarkData &rMark)
Definition: document.cxx:5909

ScDocument::CanInsertRow
bool CanInsertRow(const ScRange &rRange) const
Definition: document.cxx:1167

ScDocument::SetupContextFromNonThreadedContext
void SetupContextFromNonThreadedContext(ScInterpreterContext &threadedContext, int threadNumber)
Definition: document.cxx:6909

ScDocument::maPreviewSelection
ScMarkData maPreviewSelection
Definition: document.hxx:433

ScDocument::EnableIdle
void EnableIdle(bool bDo)
Definition: document.hxx:2208

ScDocument::ApplySelectionFrame
void ApplySelectionFrame(const ScMarkData &rMark, const SvxBoxItem &rLineOuter, const SvxBoxInfoItem *pLineInner)
Definition: document.cxx:5743

ScDocument::MakeTable
SC_DLLPUBLIC void MakeTable(SCTAB nTab, bool _bNeedsNameCheck=true)
Definition: document.cxx:171

ScDocument::SetColWidthOnly
SC_DLLPUBLIC void SetColWidthOnly(SCCOL nCol, SCTAB nTab, sal_uInt16 nNewWidth)
Definition: document.cxx:4092

ScDocument::IsInsertingFromOtherDoc
bool IsInsertingFromOtherDoc() const
Definition: document.hxx:2224

ScDocument::FitBlock
void FitBlock(const ScRange &rOld, const ScRange &rNew, bool bClear=true)
Definition: document.cxx:1827

ScDocument::RemoveSortedRangeCache
void RemoveSortedRangeCache(ScSortedRangeCache &rCache)
Definition: documen2.cxx:1290

ScDocument::SetPageSize
void SetPageSize(SCTAB nTab, const Size &rSize)
Definition: document.cxx:6183

ScDocument::nXMLImportedFormulaCount
sal_uInt64 nXMLImportedFormulaCount
Definition: document.hxx:462

ScDocument::TransferDrawPage
SC_DLLPUBLIC void TransferDrawPage(const ScDocument &rSrcDoc, SCTAB nSrcPos, SCTAB nDestPos)
Definition: documen9.cxx:67

ScDocument::StopTemporaryChartLock
void StopTemporaryChartLock()
Definition: documen3.cxx:406

ScDocument::IsForcedFormulaPending
bool IsForcedFormulaPending() const
Definition: document.hxx:1419

ScDocument::CopyTab
SC_DLLPUBLIC bool CopyTab(SCTAB nOldPos, SCTAB nNewPos, const ScMarkData *pOnlyMarked=nullptr)
Definition: documen2.cxx:804

ScDocument::ConvertFormulaToValue
void ConvertFormulaToValue(const ScRange &rRange, sc::TableValues *pUndo)
Definition: document10.cxx:211

ScDocument::ImplDeleteOptions
void ImplDeleteOptions()
Definition: documen8.cxx:107

ScDocument::UpdateBroadcastAreas
void UpdateBroadcastAreas(UpdateRefMode eUpdateRefMode,