/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#pragma once

#include <tools/gen.hxx>

#include <tools/color.hxx>

#include "attarray.hxx"

#include "column.hxx"

#include "colcontainer.hxx"

#include <sal/types.h>

#include "sortparam.hxx"

#include "types.hxx"

#include <formula/types.hxx>

#include "calcmacros.hxx"

#include <formula/errorcodes.hxx>

#include "document.hxx"

#include "drwlayer.hxx"

#include "SparklineList.hxx"

#include "SolverSettings.hxx"

#include "markdata.hxx"

#include "FilterData.hxx"

#include <algorithm>

#include <atomic>

#include <memory>

#include <optional>

#include <set>

#include <vector>

template <typename A, typename D> class ScBitMaskCompressedArray;

template <typename A, typename D> class ScCompressedArray;

namespace utl {

    class TextSearch;

}

namespace com::sun::star {

    namespace sheet {

        struct TablePageBreakData;

    }

}

namespace formula { struct VectorRefArray; }

namespace sc {

struct BroadcasterState;

class StartListeningContext;

class EndListeningContext;

class CopyFromClipContext;

class CopyToClipContext;

class CopyToDocContext;

class MixDocContext;

class ColumnSpanSet;

class RangeColumnSpanSet;

class ColumnSet;

struct ColumnBlockPosition;

struct RefUpdateContext;

struct RefUpdateInsertTabContext;

struct RefUpdateDeleteTabContext;

struct RefUpdateMoveTabContext;

struct NoteEntry;

class DocumentStreamAccess;

class CellValues;

class TableValues;

class RowHeightContext;

class CompileFormulaContext;

struct SetFormulaDirtyContext;

class ColumnIterator;

class SheetViewManager;

}

class SfxItemSet;

class SfxStyleSheetBase;

class SvxBoxInfoItem;

class SvxBoxItem;

class SvxSearchItem;

class ScAutoFormatData;

class ScEditDataArray;

class ScFormulaCell;

class ScOutlineTable;

class ScPrintSaverTab;

class ScProgress;

class ScRangeList;

class ScSheetEvents;

class ScConditionalFormat;

class ScConditionalFormatList;

class ScStyleSheet;

class ScTableProtection;

class ScUserListData;

struct RowInfo;

class ScFunctionData;

class CollatorWrapper;

class ScFlatUInt16RowSegments;

class ScFlatBoolRowSegments;

class ScFlatBoolColSegments;

struct ScSetStringParam;

struct ScColWidthParam;

class ScRangeName;

class ScDBData;

class ScPostIt;

struct ScInterpreterContext;

class ScColumnsRange final

{

 public:

    class Iterator final

    {

        SCCOL mCol;

    public:

        typedef std::bidirectional_iterator_tag iterator_category;

        typedef SCCOL value_type;

        typedef SCCOL difference_type;

        typedef const SCCOL* pointer;

        typedef SCCOL reference;

        explicit Iterator(SCCOL nCol) : mCol(nCol) {}

        Iterator& operator++() { ++mCol; return *this;}

        Iterator& operator--() { --mCol; return *this;}

        // Comparing iterators from different containers is undefined, so comparing mCol is enough.

        bool operator==(const Iterator & rOther) const {return mCol == rOther.mCol;}

        SCCOL operator*() const {return mCol;}

    };

    ScColumnsRange(SCCOL nBegin, SCCOL nEnd) : maBegin(nBegin), maEnd(nEnd) {}

    const Iterator & begin() { return maBegin; }

    const Iterator & end() { return maEnd; }

    std::reverse_iterator<Iterator> rbegin() { return std::reverse_iterator<Iterator>(maEnd); }

    std::reverse_iterator<Iterator> rend() { return std::reverse_iterator<Iterator>(maBegin); }

private:

    const Iterator maBegin;

    const Iterator maEnd;

};

template <typename T>

concept ColumnDataApply = std::is_invocable_v<T, ScColumnData&, SCROW, SCROW>;

class ScTable

{

private:

    typedef ::std::vector< ScRange > ScRangeVec;

    SCTAB           nTab;

    ScDocument&     rDocument;

    ScColContainer aCol;

    OUString aName;

    OUString aCodeName;

    OUString aComment;

    OUString        aLinkDoc;

    OUString        aLinkFlt;

    OUString        aLinkOpt;

    OUString        aLinkTab;

    sal_Int32       nLinkRefreshDelay;

    ScLinkMode      nLinkMode;

    // page style template

    OUString        aPageStyle;

    Size            aPageSizeTwips;                 // size of the print-page

    SCCOL           nRepeatStartX;                  // repeating rows/columns

    SCCOL           nRepeatEndX;                    // REPEAT_NONE, if not used

    SCROW           nRepeatStartY;

    SCROW           nRepeatEndY;

    // Standard row height for this sheet - benefits XLSX because default height defined per sheet

    sal_uInt16 mnOptimalMinRowHeight; // in Twips

    std::unique_ptr<ScTableProtection> pTabProtection;

    std::unique_ptr<ScCompressedArray<SCCOL, sal_uInt16>> mpColWidth;

    std::unique_ptr<ScFlatUInt16RowSegments> mpRowHeights;

    std::unique_ptr<ScBitMaskCompressedArray<SCCOL, CRFlags>> mpColFlags;

    std::unique_ptr<ScBitMaskCompressedArray< SCROW, CRFlags>> pRowFlags;

    FilterData maFilterData;

    ::std::set<SCROW>                      maRowPageBreaks;

    ::std::set<SCROW>                      maRowManualBreaks;

    ::std::set<SCCOL>                      maColPageBreaks;

    ::std::set<SCCOL>                      maColManualBreaks;

    std::unique_ptr<ScOutlineTable> pOutlineTable;

    std::unique_ptr<ScSheetEvents>  pSheetEvents;

    mutable SCCOL nTableAreaX;

    mutable SCROW nTableAreaY;

    mutable SCCOL nTableAreaVisibleX;

    mutable SCROW nTableAreaVisibleY;

    std::unique_ptr<utl::TextSearch> pSearchText;

    mutable OUString aUpperName;             // #i62977# filled only on demand, reset in SetName

    // sort parameter to minimize stack size of quicksort

    ScSortParam     aSortParam;

    CollatorWrapper*    pSortCollator;

    ScRangeVec      aPrintRanges;

    std::optional<ScRange> moRepeatColRange;

    std::optional<ScRange> moRepeatRowRange;

    sal_uInt16          nLockCount;

    std::unique_ptr<ScRangeList> pScenarioRanges;

    Color           aScenarioColor;

    Color           aTabBgColor;

    ScScenarioFlags nScenarioFlags;

    std::unique_ptr<ScDBData> pDBDataNoName;

    mutable std::unique_ptr<ScRangeName> mpRangeName;

    std::unique_ptr<ScConditionalFormatList> mpCondFormatList;

    sc::SparklineList maSparklineList;

    ScAddress       maLOKFreezeCell;

    bool            bScenario:1;

    bool            bLayoutRTL:1;

    bool            bLoadingRTL:1;

    bool            bPageSizeValid:1;

    mutable bool    bTableAreaValid:1;

    mutable bool    bTableAreaVisibleValid:1;

    bool            bVisible:1;

    bool            bPendingRowHeights:1;

    bool            bCalcNotification:1;

    bool            bGlobalKeepQuery:1;

    bool            bPrintEntireSheet:1;

    bool            bActiveScenario:1;

    bool            mbPageBreaksValid:1;

    bool            mbForceBreaks:1;

    bool            mbTotalsRowBelow:1;

    sc::SheetViewID mnSheetViewID = sc::InvalidSheetViewID;

    ScTable* mpSheetViewFor = nullptr;

    /** this is touched from formula group threading context */

    std::atomic<bool> bStreamValid;

    // Solver settings in current tab

    std::shared_ptr<sc::SolverSettings> m_pSolverSettings;

    // Default attributes for the unallocated columns.

    ScColumnData    aDefaultColData;

    std::shared_ptr<sc::SheetViewManager> mpSheetViewManager;

friend class ScDocument;                    // for FillInfo

friend class ScColumn;

friend class ScValueIterator;

friend class ScHorizontalValueIterator;

friend class ScDBQueryDataIterator;

friend class ScFormulaGroupIterator;

friend class ScCellIterator;

template< ScQueryCellIteratorAccess accessType, ScQueryCellIteratorType queryType >

friend class ScQueryCellIteratorBase;

template< ScQueryCellIteratorAccess accessType >

friend class ScQueryCellIteratorAccessSpecific;

friend class ScHorizontalCellIterator;

friend class ScColumnTextWidthIterator;

friend class ScDocumentImport;

friend class sc::DocumentStreamAccess;

friend class sc::ColumnSpanSet;

friend class sc::RangeColumnSpanSet;

friend class sc::EditTextIterator;

friend class sc::FormulaGroupAreaListener;

friend class sc::TableContentCopier;

public:

                ScTable( ScDocument& rDoc, SCTAB nNewTab, const OUString& rNewName,

                         bool bColInfo = true, bool bRowInfo = true );

                ~ScTable();

                ScTable(const ScTable&) = delete;

    ScTable&    operator=(const ScTable&) = delete;

    ScDocument& GetDoc() { return rDocument;}

    const ScDocument& GetDoc() const { return rDocument;}

    SCTAB GetTab() const { return nTab; }

    ScOutlineTable* GetOutlineTable()               { return pOutlineTable.get(); }

    ScColumn& CreateColumnIfNotExists( const SCCOL nScCol )

    {

        if ( nScCol >= aCol.size() )

            CreateColumnIfNotExistsImpl(nScCol);

        return aCol[nScCol];

    }

    // out-of-line the cold part of the function

    void CreateColumnIfNotExistsImpl( const SCCOL nScCol );

    const ScColumnData& GetColumnData( SCCOL nCol ) const { return nCol < aCol.size() ? aCol[ nCol ] : aDefaultColData; }

    ScColumnData& GetColumnData( SCCOL nCol ) { return nCol < aCol.size() ? aCol[ nCol ] : aDefaultColData; }

    sal_uInt64      GetCellCount() const;

    sal_uInt64      GetWeightedCount() const;

    sal_uInt64      GetWeightedCount(SCROW nStartRow, SCROW nEndRow) const;

    sal_uInt64      GetCodeCount() const;       // RPN code in formula

    sal_uInt16 GetTextWidth(SCCOL nCol, SCROW nRow) const;

    bool        SetOutlineTable( const ScOutlineTable* pNewOutline );

    void        StartOutlineTable();

    void        DoAutoOutline( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow );

    bool        TestRemoveSubTotals( const ScSubTotalParam& rParam );

    void        RemoveSubTotals( ScSubTotalParam& rParam );

    void        RemoveSimpleSubTotals( ScSubTotalParam& rParam, const ScSubTotalParam& rOldParam );

    bool        DoSubTotals( ScSubTotalParam& rParam );

    bool        DoSimpleSubTotals( ScSubTotalParam& rParam );

    const ScSheetEvents* GetSheetEvents() const              { return pSheetEvents.get(); }

    void        SetSheetEvents( std::unique_ptr<ScSheetEvents> pNew );

    bool        IsVisible() const                            { return bVisible; }

    void        SetVisible( bool bVis );

    bool        IsStreamValid() const                        { return bStreamValid; }

    void        SetStreamValid( bool bSet, bool bIgnoreLock = false );

    [[nodiscard]] bool IsColValid( const SCCOL nScCol ) const

    {

        return nScCol >= static_cast< SCCOL >( 0 ) && nScCol < aCol.size();

    }

    [[nodiscard]] bool IsColRowValid( const SCCOL nScCol, const SCROW nScRow ) const

    {

        return IsColValid( nScCol ) && GetDoc().ValidRow( nScRow );

    }

    [[nodiscard]] bool IsColRowTabValid( const SCCOL nScCol, const SCROW nScRow, const SCTAB nScTab ) const

    {

        return IsColValid( nScCol ) && GetDoc().ValidRow( nScRow ) && ValidTab( nScTab );

    }

    [[nodiscard]] bool ValidCol(SCCOL nCol) const { return GetDoc().ValidCol(nCol); }

    [[nodiscard]] bool ValidRow(SCROW nRow) const { return GetDoc().ValidRow(nRow); }

    [[nodiscard]] bool ValidColRow(SCCOL nCol, SCROW nRow) const { return GetDoc().ValidColRow(nCol, nRow); }

    bool        IsPendingRowHeights() const                  { return bPendingRowHeights; }

    void        SetPendingRowHeights( bool bSet );

    bool        GetCalcNotification() const                  { return bCalcNotification; }

    void        SetCalcNotification( bool bSet );

    bool        IsLayoutRTL() const                          { return bLayoutRTL; }

    bool        IsLoadingRTL() const                         { return bLoadingRTL; }

    void        SetLayoutRTL( bool bSet );

    void        SetLoadingRTL( bool bSet );

    bool        IsScenario() const                           { return bScenario; }

    void        SetScenario( bool bFlag );

    void        GetScenarioComment( OUString& rComment) const  { rComment = aComment; }

    void        SetScenarioComment( const OUString& rComment ) { aComment = rComment; }

    const Color& GetScenarioColor() const                    { return aScenarioColor; }

    void         SetScenarioColor(const Color& rNew)         { aScenarioColor = rNew; }

    const Color& GetTabBgColor() const                       { return aTabBgColor; }

    void         SetTabBgColor(const Color& rColor);

    ScScenarioFlags GetScenarioFlags() const                 { return nScenarioFlags; }

    void        SetScenarioFlags(ScScenarioFlags nNew)       { nScenarioFlags = nNew; }

    void        SetActiveScenario(bool bSet)                 { bActiveScenario = bSet; }

    bool        IsActiveScenario() const                     { return bActiveScenario; }

    ScLinkMode  GetLinkMode() const                          { return nLinkMode; }

    bool        IsLinked() const                             { return nLinkMode != ScLinkMode::NONE; }

    const OUString& GetLinkDoc() const                       { return aLinkDoc; }

    const OUString& GetLinkFlt() const                       { return aLinkFlt; }

    const OUString& GetLinkOpt() const                       { return aLinkOpt; }

    const OUString& GetLinkTab() const                       { return aLinkTab; }

    sal_Int32  GetLinkRefreshDelay() const                  { return nLinkRefreshDelay; }

    void        SetLink( ScLinkMode nMode, const OUString& rDoc, const OUString& rFlt,

                        const OUString& rOpt, const OUString& rTab, sal_Int32 nRefreshDelay );

    sal_Int64   GetHashCode () const;

    const OUString& GetName() const { return aName; }

    void        SetName( const OUString& rNewName );

    void        SetAnonymousDBData(std::unique_ptr<ScDBData> pDBData);

    ScDBData*   GetAnonymousDBData() { return pDBDataNoName.get();}

    const ScDBData* GetAnonymousDBData() const { return pDBDataNoName.get(); }

    const OUString& GetCodeName() const { return aCodeName; }

    void        SetCodeName( const OUString& rNewName ) { aCodeName = rNewName; }

    bool        GetTotalsRowBelow() const { return mbTotalsRowBelow; }

    void        SetTotalsRowBelow( bool bNewVal ) { mbTotalsRowBelow = bNewVal; }

    const OUString& GetUpperName() const;

    const OUString&   GetPageStyle() const                    { return aPageStyle; }

    void            SetPageStyle( const OUString& rName );

    void            PageStyleModified( const OUString& rNewName );

    bool            IsProtected() const;

    void            SetProtection(const ScTableProtection* pProtect);

    const ScTableProtection* GetProtection() const;

    void            GetUnprotectedCells( ScRangeList& rRangeList ) const;

    bool            IsEditActionAllowed( sc::EditAction eAction, SCCOL nStartCol, SCROW nStartRow,

                                         SCCOL nEndCol, SCROW nEndRow ) const;

    Size            GetPageSize() const;

    void            SetPageSize( const Size& rSize );

    void            SetRepeatArea( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow );

    void        LockTable();

    void        UnlockTable();

    bool        IsBlockEditable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2,

                        SCROW nRow2, bool* pOnlyNotBecauseOfMatrix = nullptr,

                        bool bNoMatrixAtAll = false ) const;

    bool        IsSelectionEditable( const ScMarkData& rMark,

                        bool* pOnlyNotBecauseOfMatrix = nullptr ) const;

    bool        HasBlockMatrixFragment( const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2,

                                        bool bNoMatrixAtAll = false ) const;

    bool        HasSelectionMatrixFragment( const ScMarkData& rMark ) const;

    // This also includes e.g. notes. Use IsEmptyData() for cell data only.

    bool        IsBlockEmpty( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const;

    bool        IsNotesBlockEmpty( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const;

    bool        SetString( SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString& rString,

                           const ScSetStringParam * pParam = nullptr );

    bool SetEditText( SCCOL nCol, SCROW nRow, std::unique_ptr<EditTextObject> pEditText );

    void SetEditText( SCCOL nCol, SCROW nRow, const EditTextObject& rEditText, const SfxItemPool* pEditPool );

    SCROW GetFirstEditTextRow( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const;

    void SetEmptyCell( SCCOL nCol, SCROW nRow );

    void SetFormula(

        SCCOL nCol, SCROW nRow, const ScTokenArray& rArray, formula::FormulaGrammar::Grammar eGram );

    void SetFormula(

        SCCOL nCol, SCROW nRow, const OUString& rFormula, formula::FormulaGrammar::Grammar eGram );

    SC_DLLPUBLIC const std::shared_ptr<sc::SolverSettings> & GetSolverSettings();

    // tdf#156815 Sets the solver settings object to nullptr to force reloading Solver settings the

    // next time the dialog is opened. This is required when sheets are renamed

    void ResetSolverSettings() { m_pSolverSettings.reset(); }

    /**

     * Takes ownership of pCell

     *

     * @return pCell if it was successfully inserted, NULL otherwise. pCell

     *         is deleted automatically on failure to insert.

     */

    ScFormulaCell* SetFormulaCell( SCCOL nCol, SCROW nRow, ScFormulaCell* pCell );

    bool SetFormulaCells( SCCOL nCol, SCROW nRow, std::vector<ScFormulaCell*>& rCells );

    bool HasFormulaCell( const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2 ) const;

    svl::SharedString GetSharedString( SCCOL nCol, SCROW nRow ) const;

    void        SetValue( SCCOL nCol, SCROW nRow, const double& rVal );

    void        SetValues( const SCCOL nCol, const SCROW nRow, const std::vector<double>& rVals );

    void        SetError( SCCOL nCol, SCROW nRow, FormulaError nError);

    SCSIZE      GetPatternCount( SCCOL nCol ) const;

    SCSIZE      GetPatternCount( SCCOL nCol, SCROW nRow1, SCROW nRow2 ) const;

    bool        ReservePatternCount( SCCOL nCol, SCSIZE nReserve );

    void        SetRawString( SCCOL nCol, SCROW nRow, const svl::SharedString& rStr );

    OUString    GetString( SCCOL nCol, SCROW nRow, ScInterpreterContext* pContext = nullptr ) const;

    double*     GetValueCell( SCCOL nCol, SCROW nRow );

    // Note that if pShared is set and a value is returned that way, the returned OUString is empty.

    OUString    GetInputString( SCCOL nCol, SCROW nRow, bool bForceSystemLocale = false ) const;

    double      GetValue( SCCOL nCol, SCROW nRow ) const;

    const EditTextObject* GetEditText( SCCOL nCol, SCROW nRow ) const;

    void RemoveEditTextCharAttribs( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr );

    OUString GetFormula( SCCOL nCol, SCROW nRow ) const;

    const ScFormulaCell* GetFormulaCell( SCCOL nCol, SCROW nRow ) const;

    ScFormulaCell* GetFormulaCell( SCCOL nCol, SCROW nRow );

    CellType    GetCellType( SCCOL nCol, SCROW nRow ) const;

    ScRefCellValue GetCellValue( SCCOL nCol, sc::ColumnBlockPosition& rBlockPos, SCROW nRow );

    ScRefCellValue GetCellValue( SCCOL nCol, SCROW nRow ) const;

    void        GetFirstDataPos(SCCOL& rCol, SCROW& rRow) const;

    void        GetLastDataPos(SCCOL& rCol, SCROW& rRow) const;

    // Sparklines

    std::shared_ptr<sc::Sparkline> GetSparkline(SCCOL nCol, SCROW nRow);

    sc::Sparkline* CreateSparkline(SCCOL nCol, SCROW nRow, std::shared_ptr<sc::SparklineGroup> const& pSparklineGroup);

    bool DeleteSparkline(SCCOL nCol, SCROW nRow);

    sc::SparklineList& GetSparklineList();

    void CopySparklinesToTable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable* pDestTab);

    void FillSparkline(bool bVertical, SCCOLROW nFixed, SCCOLROW nIteratingStart, SCCOLROW nIteratingEnd, SCCOLROW nFillStart, SCCOLROW nFillEnd);

    // Notes / Comments

    std::unique_ptr<ScPostIt> ReleaseNote( SCCOL nCol, SCROW nRow );

    ScPostIt*                 GetNote( SCCOL nCol, SCROW nRow );

    void                      SetNote( SCCOL nCol, SCROW nRow, std::unique_ptr<ScPostIt> pNote );

    size_t GetNoteCount( SCCOL nCol ) const;

    SCROW GetNotePosition( SCCOL nCol, size_t nIndex ) const;

    void CreateAllNoteCaptions();

    void ForgetNoteCaptions( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bPreserveData );

    void CommentNotifyAddressChange(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);

    void GetAllNoteEntries( std::vector<sc::NoteEntry>& rNotes ) const;

    void GetNotesInRange( const ScRange& rRange, std::vector<sc::NoteEntry>& rNotes ) const;

    CommentCaptionState GetAllNoteCaptionsState( const ScRange& rRange, std::vector<sc::NoteEntry>& rNotes );

    bool ContainsNotesInRange( const ScRange& rRange ) const;

    bool TestInsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize ) const;

    void        InsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize );

    void DeleteRow(

        const sc::ColumnSet& rRegroupCols, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize,

        bool* pUndoOutline, std::vector<ScAddress>* pGroupPos );

    bool        TestInsertCol( SCROW nStartRow, SCROW nEndRow, SCSIZE nSize ) const;

    void InsertCol(

        const sc::ColumnSet& rRegroupCols, SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize );

    void DeleteCol(

        const sc::ColumnSet& rRegroupCols, SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize, bool* pUndoOutline );

    void DeleteArea(

        SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, InsertDeleteFlags nDelFlag,

        bool bBroadcast = true, sc::ColumnSpanSet* pBroadcastSpans = nullptr );

    void CopyToClip( sc::CopyToClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable* pTable );

    void CopyToClip( sc::CopyToClipContext& rCxt, const ScRangeList& rRanges, ScTable* pTable );

    void CopyStaticToDocument(

        SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const SvNumberFormatterMergeMap& rMap,

        ScTable* pDestTab );

    void CopyCellToDocument( SCCOL nSrcCol, SCROW nSrcRow, SCCOL nDestCol, SCROW nDestRow, ScTable& rDestTab );

    bool InitColumnBlockPosition( sc::ColumnBlockPosition& rBlockPos, SCCOL nCol );

    void DeleteBeforeCopyFromClip(

        sc::CopyFromClipContext& rCxt, const ScTable& rClipTab, sc::ColumnSpanSet& rBroadcastSpans );

    void CopyOneCellFromClip(

        sc::CopyFromClipContext& rCxt, const SCCOL nCol1, const SCROW nRow1,

        const SCCOL nCol2, const SCROW nRow2,

        const SCROW nSrcRow, const ScTable* pSrcTab );

    void CopyFromClip(

        sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,

        SCCOL nDx, SCROW nDy, ScTable* pTable );

    void StartListeningFormulaCells(

        sc::StartListeningContext& rStartCxt, sc::EndListeningContext& rEndCxt,

        SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );

    void SetDirtyFromClip(

        SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sc::ColumnSpanSet& rBroadcastSpans );

    void CopyToTable(

        sc::CopyToDocContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,

        InsertDeleteFlags nFlags, bool bMarked, ScTable* pDestTab,

        const ScMarkData* pMarkData, bool bAsLink, bool bColRowFlags,

        ScCloneFlags nCloneFlags, bool bCopyCaptions );

    void CopyCaptionsToTable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable* pDestTab, bool bCloneCaption );

    void UndoToTable(

        sc::CopyToDocContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,

        InsertDeleteFlags nFlags, bool bMarked, ScTable* pDestTab );

    void        CopyConditionalFormat( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,

                            SCCOL nDx, SCROW nDy, const ScTable* pTable);

    /**

     * @param nCombinedStartRow start row of the combined range;

     * used for transposed multi range selection with row direction;

     * for other cases than multi range row selection this it equal to nRow1

     * @param nRowDestOffset adjustment of destination row position;

     * used for transposed multi range selection with row direction, otherwise 0

     */

    void TransposeClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCROW nCombinedStartRow,

                       SCROW nRowDestOffset, ScTable* pTransClip, InsertDeleteFlags nFlags,

                       bool bAsLink, bool bIncludeFiltered);

    // mark of this document

    void MixMarked(

        sc::MixDocContext& rCxt, const ScMarkData& rMark, ScPasteFunc nFunction,

        bool bSkipEmpty, const ScTable* pSrcTab );

    void MixData(

        sc::MixDocContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,

        ScPasteFunc nFunction, bool bSkipEmpty, const ScTable* pSrcTab );

    void        CopyData( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,

                            SCCOL nDestCol, SCROW nDestRow, SCTAB nDestTab );

    void        CopyScenarioFrom( const ScTable* pSrcTab );

    void        CopyScenarioTo( ScTable* pDestTab ) const;

    bool        TestCopyScenarioTo( const ScTable* pDestTab ) const;

    void        MarkScenarioIn(ScMarkData& rMark, ScScenarioFlags nNeededBits) const;

    bool        HasScenarioRange( const ScRange& rRange ) const;

    void        InvalidateScenarioRanges();

    const ScRangeList* GetScenarioRanges() const;

    void        CopyUpdated( const ScTable* pPosTab, ScTable* pDestTab ) const;

    void        InvalidateTableArea();

    void        InvalidatePageBreaks();

    bool        GetCellArea( SCCOL& rEndCol, SCROW& rEndRow ) const;            // FALSE = empty

    bool        GetTableArea( SCCOL& rEndCol, SCROW& rEndRow, bool bCalcHiddens = false) const;

    bool        GetPrintArea( SCCOL& rEndCol, SCROW& rEndRow, bool bNotes, bool bCalcHiddens = false) const;

    bool        GetPrintAreaHor( SCROW nStartRow, SCROW nEndRow,

                                SCCOL& rEndCol ) const;

    bool        GetPrintAreaVer( SCCOL nStartCol, SCCOL nEndCol,

                                SCROW& rEndRow, bool bNotes ) const;

    bool        GetDataStart( SCCOL& rStartCol, SCROW& rStartRow ) const;

    void        ExtendPrintArea( OutputDevice* pDev,

                        SCCOL nStartCol, SCROW nStartRow, SCCOL& rEndCol, SCROW nEndRow );

    void        GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow,

                             bool bIncludeOld, bool bOnlyDown ) const;

    bool        GetDataAreaSubrange( ScRange& rRange ) const;

    bool        ShrinkToUsedDataArea( bool& o_bShrunk, SCCOL& rStartCol, SCROW& rStartRow,

                                      SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly,

                                      bool bStickyTopRow, bool bStickyLeftCol,

                                      ScDataAreaExtras* pDataAreaExtras ) const;

    SCROW       GetLastDataRow( SCCOL nCol1, SCCOL nCol2, SCROW nLastRow,

                                ScDataAreaExtras* pDataAreaExtras = nullptr ) const;

    bool        IsEmptyData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow) const;

    SCSIZE      GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow,

                                        SCCOL nEndCol, SCROW nEndRow, ScDirection eDir ) const;

    void        FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection ) const;

    void        GetNextPos( SCCOL& rCol, SCROW& rRow, SCCOL nMovX, SCROW nMovY,

                            bool bMarked, bool bUnprotected, const ScMarkData& rMark, SCCOL nTabStartCol ) const;

    bool        SkipRow( const SCCOL rCol, SCROW& rRow, const SCROW nMovY, const ScMarkData& rMark,

                         const bool bUp, const SCROW nUsedY, const bool bMarked, const bool bSheetProtected ) const;

    void        LimitChartArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow ) const;

    bool        HasData( SCCOL nCol, SCROW nRow ) const;

    bool        HasStringData( SCCOL nCol, SCROW nRow ) const;

    bool        HasValueData( SCCOL nCol, SCROW nRow ) const;

    bool        HasStringCells( SCCOL nStartCol, SCROW nStartRow,

                                SCCOL nEndCol, SCROW nEndRow ) const;

    sc::MultiDataCellState HasMultipleDataCells( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const;

    FormulaError    GetErrCode( const ScAddress& rPos ) const

                    {

                        return IsColRowValid(rPos.Col(),rPos.Row()) ?

                            aCol[rPos.Col()].GetErrCode( rPos.Row() ) :

                            FormulaError::NONE;

                    }

    void        ResetChanged( const ScRange& rRange );

    void CheckVectorizationState();

    void SetAllFormulasDirty( const sc::SetFormulaDirtyContext& rCxt );

    void        SetDirty( const ScRange&, ScColumn::BroadcastMode );

    void        SetDirtyAfterLoad();

    void        SetDirtyVar();

    void        SetTableOpDirty( const ScRange& );

    void        CalcAll();

    void CalcAfterLoad( sc::CompileFormulaContext& rCxt, bool bStartListening );

    void CompileAll( sc::CompileFormulaContext& rCxt );

    void CompileXML( sc::CompileFormulaContext& rCxt, ScProgress& rProgress );

    /** Broadcast single broadcasters in range, without explicitly setting

        anything dirty, not doing area broadcasts.

        @param rHint address is modified to adapt to the actual broadcasted

                position on each iteration and upon return points to the last

                position broadcasted. */

    bool BroadcastBroadcasters( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SfxHintId nHint );

    bool CompileErrorCells( sc::CompileFormulaContext& rCxt, FormulaError nErrCode );

    void UpdateReference(

        sc::RefUpdateContext& rCxt, ScDocument* pUndoDoc = nullptr,

        bool bIncludeDraw = true, bool bUpdateNoteCaptionPos = true );

    void        UpdateDrawRef( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1,

                                    SCCOL nCol2, SCROW nRow2, SCTAB nTab2,

                                    SCCOL nDx, SCROW nDy, SCTAB nDz, bool bUpdateNoteCaptionPos = true );

    void        UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,

                                    ScDocument* pUndoDoc );

    void        UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY );

    void UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt );

    void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt );

    void UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt, SCTAB nTabNo, ScProgress* pProgress );

    void        UpdateCompile( bool bForceIfNameInUse = false );

    void        SetTabNo(SCTAB nNewTab);

    void        FindRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,

                                 sc::UpdatedRangeNames& rIndexes) const;

    void        Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,

                        sal_uInt64 nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,

                        double nStepValue, const tools::Duration& rDurationStep,

                        double nMaxValue, ScProgress* pProgress);

    OUString    GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY );

    void UpdateSelectionFunction( ScFunctionData& rData, const ScMarkData& rMark );

    void        AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,

                                    sal_uInt16 nFormatNo, ScProgress* pProgress );

    bool        SearchAndReplace(

        const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark,

        ScRangeList& rMatchedRanges, OUString& rUndoStr, ScDocument* pUndoDoc, bool& bMatchedRangesWereClamped);

    void        FindMaxRotCol( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2 );

    bool        HasAttrib( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, HasAttrFlags nMask ) const;

    bool        HasAttribSelection( const ScMarkData& rMark, HasAttrFlags nMask ) const;

    bool        HasAttrib( SCCOL nCol, SCROW nRow, HasAttrFlags nMask,

                           SCROW* nStartRow = nullptr, SCROW* nEndRow = nullptr ) const;

    bool IsMerged( SCCOL nCol, SCROW nRow ) const;

    bool        ExtendMerge( SCCOL nStartCol, SCROW nStartRow,

                                SCCOL& rEndCol, SCROW& rEndRow,

                                bool bRefresh );

    void SetMergedCells( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );

    const SfxPoolItem*      GetAttr( SCCOL nCol, SCROW nRow, sal_uInt16 nWhich ) const;

    template<class T> const T* GetAttr( SCCOL nCol, SCROW nRow, TypedWhichId<T> nWhich ) const

    {

        return static_cast<const T*>(GetAttr(nCol, nRow, sal_uInt16(nWhich)));

    }

Unexecuted instantiation: ScMergeFlagAttr const* ScTable::GetAttr<ScMergeFlagAttr>(short, int, TypedWhichId<ScMergeFlagAttr>) const

Unexecuted instantiation: SfxUInt32Item const* ScTable::GetAttr<SfxUInt32Item>(short, int, TypedWhichId<SfxUInt32Item>) const

    const SfxPoolItem*      GetAttr( SCCOL nCol, SCROW nRow, sal_uInt16 nWhich, SCROW& nStartRow, SCROW& nEndRow ) const;

    template<class T> const T* GetAttr( SCCOL nCol, SCROW nRow, TypedWhichId<T> nWhich, SCROW& nStartRow, SCROW& nEndRow ) const

    {

        return static_cast<const T*>(GetAttr(nCol, nRow, sal_uInt16(nWhich), nStartRow, nEndRow));

    }

    const ScPatternAttr*    GetPattern( SCCOL nCol, SCROW nRow ) const;

    const ScPatternAttr*    GetMostUsedPattern( SCCOL nCol, SCROW nStartRow, SCROW nEndRow ) const;

    sal_uInt32 GetNumberFormat( const ScInterpreterContext& rContext, const ScAddress& rPos ) const;

    sal_uInt32 GetNumberFormat( SCCOL nCol, SCROW nRow ) const;

    sal_uInt32 GetNumberFormat( SCCOL nCol, SCROW nStartRow, SCROW nEndRow ) const;

    void SetNumberFormat( SCCOL nCol, SCROW nRow, sal_uInt32 nNumberFormat );

    void                    MergeSelectionPattern( ScMergePatternState& rState,

                                                const ScMarkData& rMark, bool bDeep ) const;

    void                    MergePatternArea( ScMergePatternState& rState, SCCOL nCol1, SCROW nRow1,

                                                SCCOL nCol2, SCROW nRow2, bool bDeep ) const;

    void                    MergeBlockFrame( SvxBoxItem* pLineOuter, SvxBoxInfoItem* pLineInner,

                                            ScLineFlags& rFlags,

                                            SCCOL nStartCol, SCROW nStartRow,

                                            SCCOL nEndCol, SCROW nEndRow ) const;

    void                    ApplyBlockFrame(const SvxBoxItem& rLineOuter,

                                            const SvxBoxInfoItem* pLineInner,

                                            SCCOL nStartCol, SCROW nStartRow,

                                            SCCOL nEndCol, SCROW nEndRow );

    void        ApplyAttr( SCCOL nCol, SCROW nRow, const SfxPoolItem& rAttr );

    void        ApplyPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr );

    void        ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,

                                  const ScPatternAttr& rAttr, ScEditDataArray* pDataArray = nullptr,

                                  bool* const pIsChanged = nullptr );

    void        SetAttrEntries( SCCOL nStartCol, SCCOL nEndCol, std::vector<ScAttrEntry> && vNewData);

    void        SetPattern( const ScAddress& rPos, const ScPatternAttr& rAttr );

    void        SetPattern( SCCOL nCol, SCROW nRow, const CellAttributeHolder& rHolder );

    void        SetPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr );

    void        ApplyPatternIfNumberformatIncompatible( const ScRange& rRange,

                            const ScPatternAttr& rPattern, SvNumFormatType nNewType );

    void        AddCondFormatData( const ScRangeList& rRange, sal_uInt32 nIndex );

    void        RemoveCondFormatData( const ScRangeList& rRange, sal_uInt32 nIndex );

    void        SetPatternAreaCondFormat( SCCOL nCol, SCROW nStartRow, SCROW nEndRow,

                    const ScPatternAttr& rAttr, const ScCondFormatIndexes& rCondFormatIndexes );

    void        ApplyStyle( SCCOL nCol, SCROW nRow, const ScStyleSheet* rStyle );

    void        ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScStyleSheet& rStyle );

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

    const ScStyleSheet* GetSelectionStyle( const ScMarkData& rMark, bool& rFound ) const;

    const ScStyleSheet* GetAreaStyle( bool& rFound, SCCOL nCol1, SCROW nRow1,

                                                    SCCOL nCol2, SCROW nRow2 ) const;

    void        StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, bool bRemoved,

                                    OutputDevice* pDev,

                                    double nPPTX, double nPPTY,

                                    double fZoomX, double fZoomY );

    bool        IsStyleSheetUsed( const ScStyleSheet& rStyle ) const;

    bool        ApplyFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScMF nFlags );

    bool        RemoveFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScMF nFlags );

    void        ApplySelectionCache( ScItemPoolCache& rCache, const ScMarkData& rMark, ScEditDataArray* pDataArray = nullptr, bool* const pIsChanged = nullptr );

    void        DeleteSelection( InsertDeleteFlags nDelFlag, const ScMarkData& rMark, bool bBroadcast = true );

    void        ClearSelectionItems( const sal_uInt16* pWhich, const ScMarkData& rMark );

    void        ChangeSelectionIndent( bool bIncrement, const ScMarkData& rMark );

    const std::optional<ScRange>& GetRepeatColRange() const { return moRepeatColRange; }

    const std::optional<ScRange>& GetRepeatRowRange() const { return moRepeatRowRange; }

    void            SetRepeatColRange( std::optional<ScRange> oNew );

    void            SetRepeatRowRange( std::optional<ScRange> oNew );

    sal_uInt16          GetPrintRangeCount() const          { return static_cast< sal_uInt16 >( aPrintRanges.size() ); }

    const ScRange*  GetPrintRange(sal_uInt16 nPos) const;

    /** Returns true, if the sheet is always printed. */

    bool            IsPrintEntireSheet() const          { return bPrintEntireSheet; }

    /** Removes all print ranges. */

    void            ClearPrintRanges();

    /** Adds a new print ranges. */

    void            AddPrintRange( const ScRange& rNew );

    // Removes all named ranges used for print ranges

    void            ClearPrintNamedRanges();

    /** Marks the specified sheet to be printed completely. Deletes old print ranges! */

    void            SetPrintEntireSheet();

    void            FillPrintSaver( ScPrintSaverTab& rSaveTab ) const;

    void            RestorePrintRanges( const ScPrintSaverTab& rSaveTab );

    sal_uInt16      GetOptimalColWidth( SCCOL nCol, OutputDevice* pDev,

                                    double nPPTX, double nPPTY,

                                    double fZoomX, double fZoomY,

                                    bool bFormula, const ScMarkData* pMarkData,

                                    const ScColWidthParam* pParam );

    bool SetOptimalHeight(

        sc::RowHeightContext& rCxt, SCROW nStartRow, SCROW nEndRow, bool bApi,

        ScProgress* pOuterProgress = nullptr, sal_uInt64 nProgressStart = 0 );

    void SetOptimalHeightOnly(

        sc::RowHeightContext& rCxt, SCROW nStartRow, SCROW nEndRow,

        ScProgress* pOuterProgress = nullptr, sal_uInt64 nProgressStart = 0 );

    tools::Long        GetNeededSize( SCCOL nCol, SCROW nRow,

                                    OutputDevice* pDev,

                                    double nPPTX, double nPPTY,

                                    double fZoomX, double fZoomY,

                                    bool bWidth, bool bTotalSize,

                                    bool bInPrintTwips = false);

    void        SetColWidth( SCCOL nCol, sal_uInt16 nNewWidth );

    void        SetColWidthOnly( SCCOL nCol, sal_uInt16 nNewWidth );

    void        SetRowHeight( SCROW nRow, sal_uInt16 nNewHeight );

    bool        SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight,

                                   double nPPTY, bool bApi );

    /**

     * Set specified row height to specified ranges.  Don't check for drawing

     * objects etc.  Just set the row height.  Nothing else.

     *

     * Note that setting a new row height via this function will not

     * invalidate page breaks.

     */

    void        SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight );

                        // nPPT to test for modification

    void        SetManualHeight( SCROW nStartRow, SCROW nEndRow, bool bManual );

    sal_uInt16 GetOptimalMinRowHeight() const

    {

        if (!mnOptimalMinRowHeight)

            return ScGlobal::nStdRowHeight;

        return mnOptimalMinRowHeight;

    };

    void SetOptimalMinRowHeight(sal_uInt16 nSet) { mnOptimalMinRowHeight = nSet; }

    sal_uInt16      GetColWidth( SCCOL nCol, bool bHiddenAsZero = true ) const;

    tools::Long     GetColWidth( SCCOL nStartCol, SCCOL nEndCol ) const;

    sal_uInt16 GetRowHeight( SCROW nRow, SCROW* pStartRow, SCROW* pEndRow, bool bHiddenAsZero = true ) const;

    tools::Long     GetRowHeight( SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero = true ) const;

    tools::Long     GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, double fScale ) const;

    tools::Long     GetColOffset( SCCOL nCol, bool bHiddenAsZero = true ) const;

    tools::Long     GetRowOffset( SCROW nRow, bool bHiddenAsZero = true ) const;

    /**

     * Get the last row such that the height of row 0 to the end row is as

     * high as possible without exceeding the specified height value.

     *

     * @param nHeight maximum desired height

     *

     * @return SCROW last row of the range within specified height.

     */

    SCROW       GetRowForHeight(tools::Long nHeight) 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.

     * Note that this variant uses pixels, not twips.

     * @param nStartRow the row to start searching at.

     * @param rStartRowHeightPx this is both the height at nStartRow, and returns the height of the first row

     *        which has height > nHeight

     */

    SCROW       GetRowForHeightPixels( SCROW nStartRow, tools::Long& rStartRowHeightPx, tools::Long nHeightPx, double fPPTY ) const;

    sal_uInt16      GetOriginalWidth( SCCOL nCol ) const;

    sal_uInt16      GetOriginalHeight( SCROW nRow ) const;

    sal_uInt16      GetCommonWidth( SCCOL nEndCol ) const;

    SCROW       GetHiddenRowCount( SCROW nRow ) const;

    void        ShowCol(SCCOL nCol, bool bShow);

    void        ShowRow(SCROW nRow, bool bShow);

    void        DBShowRow(SCROW nRow, bool bShow);

    void        ShowRows(SCROW nRow1, SCROW nRow2, bool bShow);

    void        DBShowRows(SCROW nRow1, SCROW nRow2, bool bShow);

    void        SetRowFlags( SCROW nRow, CRFlags nNewFlags );

    void        SetRowFlags( SCROW nStartRow, SCROW nEndRow, CRFlags nNewFlags );

                /// @return  the index of the last row with any set flags (auto-pagebreak is ignored).

    SCROW      GetLastFlaggedRow() const;

    /// @return  the index of the last changed column (flags and column width, auto pagebreak is ignored).

    SCCOL      GetLastChangedColFlagsWidth() const;

    /// @return  the index of the last changed row (flags and row height, auto pagebreak is ignored).

    SCROW      GetLastChangedRowFlagsWidth() const;

    bool       IsDataFiltered(SCCOL nColStart, SCROW nRowStart, SCCOL nColEnd, SCROW nRowEnd) const;

    bool       IsDataFiltered(const ScRange& rRange) const;

    CRFlags    GetColFlags( SCCOL nCol ) const;

    CRFlags    GetRowFlags( SCROW nRow ) const;

    const ScBitMaskCompressedArray< SCROW, CRFlags> * GetRowFlagsArray() const

                    { return pRowFlags.get(); }

    bool        UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, bool bShow );

    bool        UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, bool bShow );

    void        UpdatePageBreaks( const ScRange* pUserArea );

    void        RemoveManualBreaks();

    bool        HasManualBreaks() const;

    void        SetRowManualBreaks( ::std::set<SCROW>&& rBreaks );

    void        SetColManualBreaks( ::std::set<SCCOL>&& rBreaks );

    void        GetAllRowBreaks(::std::set<SCROW>& rBreaks, bool bPage, bool bManual) const;

    void        GetAllColBreaks(::std::set<SCCOL>& rBreaks, bool bPage, bool bManual) const;

    bool        HasRowPageBreak(SCROW nRow) const;

    bool        HasColPageBreak(SCCOL nCol) const;

    bool        HasRowManualBreak(SCROW nRow) const;

    bool        HasColManualBreak(SCCOL nCol) const;

    /**

     * Get the row position of the next manual break that occurs at or below

     * specified row.  When no more manual breaks are present at or below

     * the specified row, -1 is returned.

     *

     * @param nRow row at which the search begins.

     *

     * @return SCROW next row position with manual page break, or -1 if no

     *         more manual breaks are present.

     */

    SCROW       GetNextManualBreak(SCROW nRow) const;

    void        RemoveRowPageBreaks(SCROW nStartRow, SCROW nEndRow);

    void        RemoveRowBreak(SCROW nRow, bool bPage, bool bManual);

    void        RemoveColBreak(SCCOL nCol, bool bPage, bool bManual);

    void        SetRowBreak(SCROW nRow, bool bPage, bool bManual);

    void        SetColBreak(SCCOL nCol, bool bPage, bool bManual);

    css::uno::Sequence<

        css::sheet::TablePageBreakData> GetRowBreakData() const;

    void updateObjectsForColsChanged(SCCOL nStartCol, SCCOL nEndCol, bool bHidden, bool bChanged);

    void updateObjectsForRowsChanged(SCROW nStartRow, SCROW nEndRow, bool bHidden, bool bChanged);

    bool        RowHidden(SCROW nRow, SCROW* pFirstRow = nullptr, SCROW* pLastRow = nullptr) const;

    bool        RowHiddenLeaf(SCROW nRow, SCROW* pFirstRow = nullptr, SCROW* pLastRow = nullptr) const;

    bool        HasHiddenRows(SCROW nStartRow, SCROW nEndRow) const;

    bool        ColHidden(SCCOL nCol, SCCOL* pFirstCol = nullptr, SCCOL* pLastCol = nullptr) const;

    bool        SetRowHidden(SCROW nStartRow, SCROW nEndRow, bool bHidden);

    void        SetColHidden(SCCOL nStartCol, SCCOL nEndCol, bool bHidden);

    void        CopyColHidden(const ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol);

    void        CopyRowHidden(const ScTable& rTable, SCROW nStartRow, SCROW nEndRow);

    void        CopyRowHeight(const ScTable& rSrcTable, SCROW nStartRow, SCROW nEndRow, SCROW nSrcOffset);

    SCROW       FirstVisibleRow(SCROW nStartRow, SCROW nEndRow) const;

    SCROW       LastVisibleRow(SCROW nStartRow, SCROW nEndRow) const;

    SCROW       CountVisibleRows(SCROW nStartRow, SCROW nEndRow) const;

    tools::Long GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero = true) const;

    SCCOL       CountVisibleCols(SCCOL nStartCol, SCCOL nEndCol) const;

    SCCOLROW    LastHiddenColRow(SCCOLROW nPos, bool bCol) const;

    FilterData& getFilterData() { return maFilterData; }

    FilterData const& getFilterData() const { return maFilterData; }

    Color GetCellBackgroundColor(ScAddress aPos) const;

    Color GetCellTextColor(ScAddress aPos) const;

    bool IsManualRowHeight(SCROW nRow) const;

    bool HasUniformRowHeight( SCROW nRow1, SCROW nRow2 ) const;

    void        SyncColRowFlags();

    void        StripHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 );

    void        ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 );

    /** Sort a range of data. */

    void Sort(

        const ScSortParam& rSortParam, bool bKeepQuery, bool bUpdateRefs,

        ScProgress* pProgress, sc::ReorderParam* pUndo );

    void Reorder( const sc::ReorderParam& rParam );

    // For ValidQuery() see ScQueryEvalutor class.

    void        TopTenQuery( ScQueryParam& );

    void        PrepareQuery( ScQueryParam& rQueryParam );

    SCSIZE      Query(const ScQueryParam& rQueryParam, bool bKeepSub, bool bKeepTotals = false);

    bool        CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam);

    void GetFilterEntries(SCCOL nCol, SCROW nRow1, SCROW nRow2, ScFilterEntries& rFilterEntries, bool bFiltering = false);

    void GetFilteredFilterEntries(SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScQueryParam& rParam, ScFilterEntries& rFilterEntries, bool bFiltering );

    [[nodiscard]]

    bool GetDataEntries(SCCOL nCol, SCROW nRow, std::set<ScTypedStrData>& rStrings);

    bool        HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ) const;

    bool        HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ) const;

    sal_Int32   GetMaxStringLen( SCCOL nCol,

                                    SCROW nRowStart, SCROW nRowEnd, rtl_TextEncoding eCharSet ) const;

    sal_Int32  GetMaxNumberStringLen( sal_uInt16& nPrecision,

                                       SCCOL nCol,

                                       SCROW nRowStart, SCROW nRowEnd ) const;

    bool        IsSortCollatorGlobal() const;

    void        InitSortCollator( const ScSortParam& rPar );

    void        DestroySortCollator();

    void        SetDrawPageSize( bool bResetStreamValid = true, bool bUpdateNoteCaptionPos = true,

                                 const ScObjectHandling eObjectHandling = ScObjectHandling::RecalcPosMode);

    void SetRangeName(std::unique_ptr<ScRangeName> pNew);

    SC_DLLPUBLIC ScRangeName* GetRangeName() const;

    void PreprocessRangeNameUpdate(

        sc::EndListeningContext& rEndListenCxt, sc::CompileFormulaContext& rCompileCxt );

    void CompileHybridFormula(

        sc::StartListeningContext& rStartListenCxt, sc::CompileFormulaContext& rCompileCxt );

    void PreprocessDBDataUpdate(

        sc::EndListeningContext& rEndListenCxt, sc::CompileFormulaContext& rCompileCxt );

    ScConditionalFormatList* GetCondFormList();

    const ScConditionalFormatList* GetCondFormList() const;

    void SetCondFormList( ScConditionalFormatList* pList );

    void DeleteConditionalFormat(sal_uLong nOldIndex);

    sal_uInt32          AddCondFormat( std::unique_ptr<ScConditionalFormat> pNew );

    SvtScriptType GetScriptType( SCCOL nCol, SCROW nRow ) const;

    void SetScriptType( SCCOL nCol, SCROW nRow, SvtScriptType nType );

    void UpdateScriptTypes( const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2 );

    SvtScriptType GetRangeScriptType( sc::ColumnBlockPosition& rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2 );

    formula::FormulaTokenRef ResolveStaticReference( SCCOL nCol, SCROW nRow );

    formula::FormulaTokenRef ResolveStaticReference( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );

    formula::VectorRefArray FetchVectorRefArray( SCCOL nCol, SCROW nRow1, SCROW nRow2 );

    bool HandleRefArrayForParallelism( SCCOL nCol, SCROW nRow1, SCROW nRow2,

                                       const ScFormulaCellGroupRef& mxGroup, ScAddress* pDirtiedAddress );

#ifdef DBG_UTIL

    void AssertNoInterpretNeeded( SCCOL nCol, SCROW nRow1, SCROW nRow2 );

#endif

    void SplitFormulaGroups( SCCOL nCol, std::vector<SCROW>& rRows );

    void UnshareFormulaCells( SCCOL nCol, std::vector<SCROW>& rRows );

    void RegroupFormulaCells( SCCOL nCol );

    ScRefCellValue GetRefCellValue( SCCOL nCol, SCROW nRow );

    ScRefCellValue GetRefCellValue( SCCOL nCol, SCROW nRow, sc::ColumnBlockPosition& rBlockPos );

    SvtBroadcaster* GetBroadcaster( SCCOL nCol, SCROW nRow );

    const SvtBroadcaster* GetBroadcaster( SCCOL nCol, SCROW nRow ) const;

    void DeleteBroadcasters( sc::ColumnBlockPosition& rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2 );

    void DeleteEmptyBroadcasters();

    void FillMatrix( ScMatrix& rMat, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, svl::SharedStringPool* pPool ) const;

    void InterpretDirtyCells( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );

    bool InterpretCellsIfNeeded( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );

    void SetFormulaResults( SCCOL nCol, SCROW nRow, const double* pResults, size_t nLen );

    void CalculateInColumnInThread( ScInterpreterContext& rContext, SCCOL nColStart, SCCOL nColEnd,

                                    SCROW nRowStart, SCROW nRowEnd, unsigned nThisThread, unsigned nThreadsTotal);

    void HandleStuffAfterParallelCalculation( SCCOL nColStart, SCCOL nColEnd, SCROW nRow, size_t nLen, ScInterpreter* pInterpreter);

    /**

     * Either start all formula cells as listeners unconditionally, or start

     * those that are marked "needs listening".

     *

     * @param rCxt context object.

     * @param bAll when true, start all formula cells as listeners. When

     *             false, only start those that are marked "needs listening".

     */

    void StartListeners( sc::StartListeningContext& rCxt, bool bAll );