diff options
Diffstat (limited to 'sc/inc/document.hxx')
| -rw-r--r-- | sc/inc/document.hxx | 2816 |
1 files changed, 2816 insertions, 0 deletions
diff --git a/sc/inc/document.hxx b/sc/inc/document.hxx new file mode 100644 index 0000000000..09747bb2c0 --- /dev/null +++ b/sc/inc/document.hxx @@ -0,0 +1,2816 @@ +/* -*- 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; +enum class ScConditionMode; + + +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. +}; + +/// Represents the type of sheet geometry data. +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; /// For usage in FindDdeLink() only! + +// 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 +}; + +/// Enumeration to determine which pieces of the code should not be mutated when set. +enum ScMutationGuardFlags +{ + // Bit mask bits + CORE = 0x0001, /// Core calc data structures should not be mutated +}; + +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, /// normal calculation of dependencies + TEMPORARY, /// CalcAll() without broadcast/notify but setting up new listeners + ETERNAL /// no new listeners are setup, no broadcast/notify + }; + +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 + ScDocShell* 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; /// Pool for all external formula parsers used by this document. + + 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<ScConditionMode> pConditionalFormatDialogMode; + + 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: + /// list of ScInterpreterTableOpParams currently in use + 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 + + /** The compiler grammar used in document storage. GRAM_PODF for ODF 1.1 + documents, GRAM_ODFF for ODF 1.2 documents. */ + 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, + ScDocShell* 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( ScDocShell* 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 SetEasyConditionalFormatDialogData(std::unique_ptr<ScConditionMode> pMode); + const ScConditionMode* GetEasyConditionalFormatDialogData() const { return pConditionalFormatDialogMode.get(); } + + void Clear( bool bFromDestructor = false ); + + std::unique_ptr<ScFieldEditEngine> CreateFieldEditEngine(); + void DisposeFieldEditEngine(std::unique_ptr<ScFieldEditEngine>& rpEditEngine); + + /** + * Get all range names that are local to each table. It only returns + * non-empty range name set. + */ + 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); + + /** Find a named expression / range name in either global or a local scope. + @param nTab + If <0 search nIndex in global scope, if >=0 search nIndex in scope of nTab. + @param nIndex + Index of named expression / range name. + @return nullptr if indexed name not found. + */ + ScRangeData* FindRangeNameBySheetAndIndex( SCTAB nTab, sal_uInt16 nIndex ) const; + + /** Recursively find all named expressions that directly or indirectly + (nested) reference a given sheet, starting from a given named + expression nTokenTab/nTokenIndex. + + Used to collect all named expressions/ranges that will need to be + copied along when copying sheets. + + The different tab/sheets passed cater for the situation that a sheet is + copied and was already inserted and global names are already adjusted + but the sheet-local names of the shifted original sheet are not yet. If + no sheet was inserted and global and local names' references not + updated yet, then all 4 tab arguments would be identical. + + @param nTokenTab + Tab/sheet on which to find the name, -1 if global scope. + For example obtained from ocName token. + + @param nTokenIndex + Index of named expression. For example obtained from ocName token. + + @param nGlobalRefTab + Tab to check if used in global names. + + @param nLocalRefTab + Tab to check if used in sheet-local names. + + @param nOldTokenTab + The original tab of the copied sheet, used as sheet-local + base position for relative references. + + @param nOldTokenTabReplacement + The replacement to use for relative references if the name + encountered uses nOldTokenTab as base position. + + @param bSameDoc + FALSE if collecting names for a sheet to be copied to another + document. Then all names encountered are considered to be + referencing the sheet. Else TRUE if collecting names to be + copied into the same document. + + @param nRecursion + Recursion guard, initialize with 0. + */ + bool FindRangeNamesReferencingSheet( sc::UpdatedRangeNames& rIndexes, + SCTAB nTokenTab, const sal_uInt16 nTokenIndex, + SCTAB nGlobalRefTab, SCTAB nLocalRefTab, SCTAB nOldTokenTab, SCTAB nOldTokenTabReplacement, + bool bSameDoc, int nRecursion ) const; + + /** If necessary (name references sheet rOldPos.Tab()) copy and adjust + named expression/range from sheet-local to sheet-local, or global to + sheet-local if bGlobalNamesToLocal==true. + + Also copies nested names and adjusts the ocName tokens of the calling name. + + @param rSheet + On entry, the original sheet of the named expression/range, <0 global. + On return TRUE, the new sheet. Else unchanged. + + @param rIndex + On entry, the original index of the named expression/range. + On return TRUE, the new index, or 0 if a new copied name couldn't be inserted. Else unchanged. + + @param rpRangeData + On entry, the pointer to the original named expression/range. + On return TRUE, the pointer to the new copied name, or nullptr if hits happened. + + @param rNewPos + New position of formula cell if called for that, else new base + position of a to be created new name adjusted for Tab. + rNewPos.nTab MUST point to the new sheet copied to. + + @param rOldPos + Old position of formula cell if called for that, else base + position of the existing name adjusted for Tab. + rOldPos.nTab MUST point to the old sheet copied from. + + @param bGlobalNamesToLocal + If TRUE, affected global names are copied to sheet-local names. + If FALSE, global names are copied to global names in another document. + + @param bUsedByFormula + If TRUE, forces a global name to be affected/used. + If FALSE, a global name is only affected if it evaluates to be + referencing the sheet. + + @return TRUE if copied and caller may need to evaluate rpRangeData and rSheet and rIndex. + FALSE if nothing to be done. + */ + bool CopyAdjustRangeName( SCTAB& rSheet, sal_uInt16& rIndex, ScRangeData*& rpRangeData, ScDocument& rNewDoc, + const ScAddress& rNewPos, const ScAddress& rOldPos, const bool bGlobalNamesToLocal, + const bool bUsedByFormula ) const; + + /** + * Call this immediately before updating all named ranges. + */ + SC_DLLPUBLIC void PreprocessAllRangeNamesUpdate( const std::map<OUString, ScRangeName>& rRangeMap ); + SC_DLLPUBLIC void PreprocessRangeNameUpdate(); + SC_DLLPUBLIC void PreprocessDBDataUpdate(); + /** + * Call this immediately after updating named ranges. + */ + SC_DLLPUBLIC void CompileHybridFormula(); + + /** + * Insert a new named expression to the global scope. + * + * @param rName name for the expression. + * @param rPos base position. + * @param rExpr formula expression to be associated with the name. The + * current grammar is used to compile this expression. + * + * @return true if inserted successfully, false otherwise. + */ + bool InsertNewRangeName( const OUString& rName, const ScAddress& rPos, const OUString& rExpr ); + + /** + * Insert a new named expression to a sheet-local scope. + * + * @param nTab sheet for local scope. + * @param rName name for the expression. + * @param rPos base position. + * @param rExpr formula expression to be associated with the name. The + * current grammar is used to compile this expression. + * + * @return true if inserted successfully, false otherwise. + */ + bool InsertNewRangeName( SCTAB nTab, const OUString& rName, const ScAddress& rPos, const OUString& rExpr ); + + /** Obtain the sheet separator corresponding to the document's grammar. + + @return '.' for our own grammars, '!' for Excel grammars. + */ + 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); + + /** One document global anonymous database range for temporary operations, + used if the corresponding sheet-local anonymous database range is + already used with AutoFilter and range differs. Not stored in document + files. */ + 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 ); + + /** Returns the pool containing external formula parsers. Creates the pool + on first call. */ + 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; + + /** Tries to find a DDE link with the specified connection data. + @param rnDdePos (out-param) Returns the index of the DDE link (does not include other links from link manager). + @return true = DDE link found, rnDdePos valid. */ + SC_DLLPUBLIC bool FindDdeLink( std::u16string_view rAppl, std::u16string_view rTopic, + std::u16string_view rItem, sal_uInt8 nMode, size_t& rnDdePos ); + + /** Returns the connection data of the specified DDE link. + @param nDdePos Index of the DDE link (does not include other links from link manager). + @param rAppl (out-param) The application name. + @param rTopic (out-param) The DDE topic. + @param rItem (out-param) The DDE item. + @return true = DDE link found, out-parameters valid. */ + bool GetDdeLinkData( size_t nDdePos, OUString& rAppl, OUString& rTopic, OUString& rItem ) const; + /** Returns the link mode of the specified DDE link. + @param nDdePos Index of the DDE link (does not include other links from link manager). + @param rnMode (out-param) The link mode of the specified DDE link. + @return true = DDE link found, rnMode valid. */ + bool GetDdeLinkMode( size_t nDdePos, sal_uInt8& rnMode ) const; + /** Returns the result matrix of the specified DDE link. + @param nDdePos Index of the DDE link (does not include other links from link manager). + @return The result matrix, if the DDE link has been found, 0 otherwise. */ + SC_DLLPUBLIC const ScMatrix* GetDdeLinkResultMatrix( size_t nDdePos ) const; + + /** Tries to find a DDE link or creates a new, if not extant. + @param pResults If not 0, sets the matrix as DDE link result matrix (also for existing links). + @return true = DDE link found; false = Unpredictable error occurred, no DDE link created. */ + SC_DLLPUBLIC bool CreateDdeLink( const OUString& rAppl, const OUString& rTopic, const OUString& rItem, sal_uInt8 nMode, const ScMatrixRef& pResults ); + /** Sets a result matrix for the specified DDE link. + @param nDdePos Index of the DDE link (does not include other links from link manager). + @param pResults The array containing all results of the DDE link (intrusive-ref-counted, do not delete). + @return true = DDE link found and matrix set. */ + bool SetDdeLinkResultMatrix( size_t nDdePos, const ScMatrixRef& pResults ); + + SfxBindings* GetViewBindings(); + ScDocShell* 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 ); + //! only assigns the new RangeList, no ChartListener or the like + 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 ); + + /** + * This method manages the lifecycle of the passed edit text object. When + * the text is successfully inserted, the cell takes over the ownership of + * the text object. If not, the text object gets deleted. + * + * <p>The caller must ensure that the passed edit text object <i>uses the + * SfxItemPool instance returned from ScDocument::GetEditPool()</i>. + * This is very important.</p> + */ + 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; + + /** + * Call this if you are not sure whether to put this as an edit text or a + * simple text. + */ + 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 ); + + /** + * Set formula cell, and transfer its ownership to the document. This call + * attempts to group the passed formula cell with the adjacent cells or + * cell groups if appropriate. + * + * @return pCell if it was successfully inserted, NULL otherwise. pCell + * is deleted automatically on failure to insert. + */ + SC_DLLPUBLIC ScFormulaCell* SetFormulaCell( const ScAddress& rPos, ScFormulaCell* pCell ); + bool SetFormulaCells( const ScAddress& rPos, std::vector<ScFormulaCell*>& rCells ); + + /** + * Check if there is at least one formula cell in specified range. + */ + 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; + + /** + * Return a pointer to the double value stored in value cell. + * + * @param rPos cell position + * + * @return pointer to the double value stored in a numeric cell, or NULL + * if the cell at specified position is not a numeric cell. + */ + 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; + + /** Returns true, if there is any data to create a selection list for rPos. */ + bool HasSelectionData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; + bool HasValidationData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; + + /** + * Check if the specified range contains either: 1) one non-empty cell, 2) + * more than one non-empty cells, or 3) totally empty. In case the range + * contains at least one non-empty cell, specify the position of the first + * non-empty cell. + */ + sc::MultiDataCellState HasMultipleDataCells( const ScRange& rRange ) const; + + // Spaklines + /** Returns sparkline at the address if it exists */ + 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); + + /** + * Returns true if the whole range covers one and the same sparkline + * group and returns the group via out parameter + */ + 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; + + /** + * Ensure that all note objects have an associated sdr object. The export + * code uses sdr objects to export note data. + */ + 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(); + + /** + * Re-compile formula cells with error. + * + * @param nErrCode specified error code to match. Only those cells with + * this error code will be re-compiled. If this value is + * 0, cells with any error values will be re-compiled. + * + * @return true if at least one cell is re-compiled, false if no cells are + * re-compiled. + */ + 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 ); + + /** Creates a ScLookupCache cache for the range if it + doesn't already exist. */ + ScLookupCache & GetLookupCache( const ScRange & rRange, ScInterpreterContext* pContext ); + ScSortedRangeCache & GetSortedRangeCache( const ScRange & rRange, const ScQueryParam& param, + ScInterpreterContext* pContext ); + /** Only ScLookupCache dtor uses RemoveLookupCache(), do + not use elsewhere! */ + void RemoveLookupCache( ScLookupCache & rCache ); + void RemoveSortedRangeCache( ScSortedRangeCache & rCache ); + /** Zap all caches. */ + 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; } + /// If set, joining cells into shared formula groups will be delayed until reset again + /// (RegroupFormulaCells() will be called as needed). + void DelayFormulaGrouping( bool delay ); + bool IsDelayedFormulaGrouping() const { return bool(pDelayedFormulaGrouping); } + /// To be used only by SharedFormulaUtil::joinFormulaCells(). + void AddDelayedFormulaGroupingCell( const ScFormulaCell* cell ); + /// If set, ScColumn::StartListeningFormulaCells() calls may be delayed using + /// CanDelayStartListeningFormulaCells() until reset again, at which point the function will + /// be called as necessary. + void EnableDelayStartListeningFormulaCells( ScColumn* column, bool delay ); + bool IsEnabledDelayStartListeningFormulaCells( ScColumn* column ) const; + /// If true is returned, ScColumn::StartListeningFormulaCells() for the given cells will be performed + /// later. If false is returned, it needs to be done explicitly. + bool CanDelayStartListeningFormulaCells( ScColumn* column, SCROW row1, SCROW row2 ); + /// If set, cells will not delete their empty broadcasters, avoiding possible extensive mdds + /// vector changes. Disabling delay will collect and delete all empty broadcasters. + void EnableDelayDeletingBroadcasters(bool set); + bool IsDelayedDeletingBroadcasters() const { return bDelayedDeletingBroadcasters; } + + FormulaError GetErrCode( const ScAddress& ) const; + + /** Shrink a range to only include data area. + + This is not the actually used area within the + selection, but the bounds of the sheet's data area + instead. + + @returns TRUE if the area passed intersected the data + area, FALSE if not, in which case the values + obtained may be out of bounds, not in order or + unmodified. TRUE does not mean that there + actually is any data within the selection. + */ + bool ShrinkToDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow ) const; + + /** Shrink a range to only include used data area. + + @param o_bShrunk + Out parameter, true if area was shrunk, false if not. + @param bColumnsOnly + If TRUE, shrink only by columns, not rows. + @param bStickyTopRow + If TRUE, do not adjust the top row. + @param bStickyLeftCol + If TRUE, do not adjust the left column. + @param pDataAreaExtras + Consider additional area attributes like cell + formatting, cell notes and draw objects. The + possibly larger area than the actual cell + content data area is returned within the + struct. + + @returns true if there is any data, false if not. + */ + 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; + + /** + * Return the last non-empty row position in given columns that's no + * greater than the initial last row position, or 0 if the columns are + * empty. A negative value is returned if the given sheet or column + * positions are invalid. + * + * <p>It starts from the specified last row position, and finds the first + * non-empty row position in the upward direction if the start row + * position is empty.</p> + */ + SC_DLLPUBLIC SCROW GetLastDataRow( SCTAB nTab, SCCOL nCol1, SCCOL nCol2, SCROW nLastRow ) const; + + /** + * Return the smallest area containing at least all contiguous cells + * having data. This area is a square containing also empty cells. It may + * shrink or extend the area given as input Flags as modifiers: + * + * @param bIncludeOld when true, ensure that the returned area contains at + * least the initial area even if the actual data area + * is smaller than the initial area. + * + * @param bOnlyDown when true, extend / shrink the data area only in a + * downward direction i.e. only modify the end row + * position. + */ + SC_DLLPUBLIC void GetDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, + SCCOL& rEndCol, SCROW& rEndRow, + bool bIncludeOld, bool bOnlyDown ) const; + + /** + * Return the extended area containing at least all contiguous cells + * having background color. + */ + SC_DLLPUBLIC void GetBackColorArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, + SCCOL& rEndCol, SCROW& rEndRow ) const; + + /** + * Returns true if there is a non-empty subrange in the range given as input. + * In that case it also modifies rRange to largest subrange that does not + * have empty col/row inrange-segments in the beginning/end. + * It returns false if rRange is completely empty and in this case rRange is + * left unmodified. + */ + 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(); + + /// Return the number of columns / rows that should be visible for the tiled rendering. + SC_DLLPUBLIC void GetTiledRenderingArea(SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow) const; + + SC_DLLPUBLIC bool GetDataStart( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow ) const; + + /** + * Find the maximum column position that contains printable data for the + * specified row range. The final column position must be equal or less + * than the initial value of rEndCol. + */ + 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 ); + + /** + * Copy only raw cell values to another document. Formula cells are + * converted to raw cells. No formatting info are copied except for + * number formats. + * + * @param rSrcRange source range in the source document + * @param nDestTab table in the clip document to copy to. + * @param rDestDoc document to copy to + */ + SC_DLLPUBLIC void CopyStaticToDocument(const ScRange& rSrcRange, SCTAB nDestTab, ScDocument& rDestDoc); + + /** + * Copy only cell, nothing but cell to another document. + * + * @param rSrcPos source cell position + * @param rDestPos destination cell position + * @param rDestDoc destination document + */ + 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 ); + /** + * @return the number of non-filtered rows. + */ + 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 ); + + /** + * Paste data from a clipboard document into this document. + * + * @param rDestRange destination range. + * @param pClipDoc pointer to the clipboard document to copy data from. + * @param bSkipEmptyCells if this flag is set, empty cells in the source + * range in the clipboard document will not overwrite + * the target destination cells. + * @param pDestRanges If pDestRanges is given it overrides rDestRange, where + * rDestRange becomes the overall encompassing range. + */ + 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); + + /** To be called at the clipboard document when closing a document that is + the current clipboard source to decouple things from the originating + document. Done in ScDocument dtor after determining + IsClipboardSource(). + */ + 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 ); + /** + * @param pClipDoc original clipboard doc, i.e. non-transposed + * This clip doc is used to check references pointing to cut cells. + */ + 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; + + /** + * Given the height i.e. total vertical distance from the top of the sheet + * grid, return the first visible row whose top position is below the + * specified height. + */ + 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; + + /** + * Write all column row flags to table's flag data, because not all column + * row attributes are stored in the flag data members. This is necessary + * for ods export. + */ + void SyncColRowFlags(); + + /// @return the index of the last row with any set flags (auto-pagebreak is ignored). + SC_DLLPUBLIC SCROW GetLastFlaggedRow( SCTAB nTab ) const; + + /// @return the index of the last changed column (flags and column width, auto pagebreak is ignored). + SCCOL GetLastChangedColFlagsWidth( SCTAB nTab ) const; + /// @return the index of the last changed row (flags and row height, auto pagebreak is ignored). + 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 ); + /** Returns true, if the specified sheet is always printed. */ + bool IsPrintEntireSheet( SCTAB nTab ) const; + + /** Removes all print ranges. */ + SC_DLLPUBLIC void ClearPrintRanges( SCTAB nTab ); + /** Adds a new print ranges. */ + SC_DLLPUBLIC void AddPrintRange( SCTAB nTab, const ScRange& rNew ); + // Removes all named ranges used for print ranges in a given tab + SC_DLLPUBLIC void ClearPrintNamedRanges( SCTAB nTab ); + /** Marks the specified sheet to be printed completely. Deletes old print ranges on the sheet! */ + 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; + + /** Sort a range of data. */ + 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); + + /** + * Get a list of unique strings to use in filtering criteria. The string + * values are sorted, and there are no duplicate values in the list. The + * data range to use to populate the filter entries is inferred from the + * database range that contains the specified cell position. + */ + 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(bool bForceVirtDev = false); // 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; } + /** Check token array and set link check if ocDde/ocWebservice is contained. */ + 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; + + /** + * Set an array of numerical formula results to a group of contiguous + * formula cells. + * + * @param rTopPos position of the top formula cell of a group. + * @param pResults array of numeric results. + * @param nLen length of numeric results. + */ + 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 ); + + /** + * Transfer a series of contiguous cell values from specified position to + * the passed container. The specified segment will become empty after the + * transfer. + */ + 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; + + /** + * Check the integrity of the internal table state. Useful from testing + * code. It throws an exception upon first failure. + * + * Feel free to add more checks as needed. + */ + 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); + + /** Adjust a range to available sheets. + + Used to start and stop listening on a sane range. Both o_rRange and + o_bEntirelyOutOfBounds are set only if needed and don't have to be + initialized by the caller. + + @param o_bEntirelyOutOfBounds + <TRUE/> if both sheets in the range point outside the + available sheet range, in which case no adjustment is done and + o_rRange is not modified. + + @return <TRUE/> if any adjustment was done or o_bEntirelyOutOfBounds + was set <TRUE/>. + <FALSE/> if rRange was within the available sheets. + */ + 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 ); + /** Broadcast wrapper, calls + rHint.GetCell()->Broadcast() and AreaBroadcast() + and TrackFormulas() + Preferred. + */ + void Broadcast( const ScHint& rHint ); + + void BroadcastCells( const ScRange& rRange, SfxHintId nHint, bool bBroadcastSingleBroadcasters = true ); + + /// only area, no cell broadcast + 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 ); + +/** + * Calculate formula cells that are on the formula tree either partially, + * or in full. + * + * @param bOnlyForced when true, it only calculates those formula cells + * that are marked "recalc forced". + * @param bProgressBar whether or not to use progress bar. + * @param bSetAllDirty when true, it marks all formula cells currently on + * the formula tree dirty, which forces all of them to + * be recalculated. When false, only those cells + * that are marked dirty prior to this call get + * recalculated. + */ + 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(); + + /** Maximum string length of a column, e.g. for dBase export. + @return String length in octets (!) of the destination encoding. In + case of non-octet encodings (e.g. UCS2) the length in code + points times sizeof(sal_Unicode) is returned. */ + sal_Int32 GetMaxStringLen( SCTAB nTab, SCCOL nCol, + SCROW nRowStart, SCROW nRowEnd, + rtl_TextEncoding eCharSet ) const; + /** Maximum string length of numerical cells of a column, e.g. for dBase export. + @return String length in characters (!) including the decimal + separator, and the decimal precision needed. */ + 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(); } + + //! only for import filter, deletes any existing ChangeTrack via + //! EndChangeTracking() and takes ownership of new ChangeTrack pTrack + 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; } + + /// an ID unique to each document instance + 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; } + + /** Should only be GRAM_PODF or GRAM_ODFF. */ + 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 ); + + /** + * Make specified formula cells non-grouped. + * + * @param nTab sheet index + * @param nCol column index + * @param rRows list of row indices at which formula cells are to be + * unshared. This call sorts the passed row indices and + * removes duplicates, which is why the caller must pass it + * as reference. + */ + 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, ScAddress* pDirtiedAddress ); +#ifdef DBG_UTIL + void AssertNoInterpretNeeded( const ScAddress& rPos, SCROW nLength ); +#endif + + /** + * Call this before any operations that might trigger one or more formula + * cells to get calculated. + */ + void PrepareFormulaCalc(); + + /** + * Make sure all of the formula cells in the specified range have been + * fully calculated. This method only re-calculates those formula cells + * that have been flagged dirty. In case of formula-groups, this calculates + * only the dirty subspans along with the dependents in the same way + * recursively. + * + * @param rRange range in which to potentially calculate the formula + * cells. + * @param bSkipRunning flag to skip evaluation of formula-cells that are + * marked as already being evaluated. + * @return true if at least one formula-cell in the specified range was dirty + * else returns false. + */ + 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; } + + /** + * Serializes the specified sheet's geometry data. + * + * @param nTab is the index of the sheet to operate on. + * @param bColumns - if true it dumps the data for columns, else it does for rows. + * @param eGeomType indicates the type of data to be dumped for rows/columns. + * @return the serialization of the specified sheet's geometry data as an OString. + */ + 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: + + /** + * Use this class as a locale variable to merge number formatter from + * another document, and set NULL pointer to pFormatExchangeList when + * done. + */ + 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; + +/** + * Instantiate this to ensure that subsequent modification of + * the document will cause an assertion failure while this is + * in-scope. + */ +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 +}; + +/** + * A pretty assertion that checks that the relevant bits in + * the @nFlags are not set on the document at entry and exit. + * + * Its primary use is for debugging threading. As such, an + * @ScMutationDisable is created to forbid mutation, and this + * condition is then asserted on at prominent sites that + * mutate @nFlags. + */ +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: */ |