sc/html/table_8hxx_source.html

/* -*- 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 "sortparam.hxx"

#include "types.hxx"

#include "cellvalue.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 <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;

class TableColumnBlockPositionSet;

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 ScDrawObjData;

}


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 ScSortInfoArray;

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 ScHint;

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;}

        bool operator!=(const Iterator & rOther) const {return !(*this == rOther);}

        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;

};


class ScTable

{

private:

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


    ScColContainer aCol;


    OUString aName;

    OUString aCodeName;

    OUString aComment;


    OUString        aLinkDoc;

    OUString        aLinkFlt;

    OUString        aLinkOpt;

    OUString        aLinkTab;

    sal_uLong       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;


    // last used col and row

    bool            mbCellAreaDirty;

    bool            mbCellAreaEmpty;

    SCCOL           mnEndCol;

    SCROW           mnEndRow;


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

    std::unique_ptr<ScFlatBoolColSegments>  mpHiddenCols;

    std::unique_ptr<ScFlatBoolRowSegments>  mpHiddenRows;

    std::unique_ptr<ScFlatBoolColSegments>  mpFilteredCols;

    std::unique_ptr<ScFlatBoolRowSegments>  mpFilteredRows;


    ::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;


    SCTAB           nTab;

    ScDocument&     rDocument;

    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;

    std::atomic<bool> bStreamValid;


    // Solver settings in current tab

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


    // Default attributes for the unallocated columns.

    ScColumnData    aDefaultColData;


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;


public:

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

                         bool bColInfo = true, bool bRowInfo = true );

                ~ScTable() COVERITY_NOEXCEPT_FALSE;

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


    ScColumnData& GetColumnData( SCCOL nCol )

    {

        if( nCol >= aCol.size())

            return aDefaultColData;

        return aCol[nCol];

    }


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

    bool        DoSubTotals( 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_uLong   GetLinkRefreshDelay() const                  { return nLinkRefreshDelay; }


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

                        const OUString& rOpt, const OUString& rTab, sal_uLong 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 OUString& GetCodeName() const { return aCodeName; }

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


    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::ColRowEditAction eAction, SCCOLROW nStart, SCCOLROW nEnd ) 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        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 std::shared_ptr<sc::SolverSettings> GetSolverSettings();


    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, const 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( const ScAddress& rPos ) const

                    {

                        if (!GetDoc().ValidColRow(rPos.Col(),rPos.Row()))

                            return CELLTYPE_NONE;

                        if (rPos.Col() >= aCol.size())

                            return CELLTYPE_NONE;

                        return aCol[rPos.Col()].GetCellType( rPos.Row() );

                    }

    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 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,

        bool bGlobalNamesToLocal, 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);

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


    void        InvalidateCellArea() { mbCellAreaDirty = true; }

    bool        GetCellArea( SCCOL& rEndCol, SCROW& rEndRow );            // 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 );


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

    void        GetAutoFormatData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScAutoFormatData& rData);

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

    }

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

    const ScPatternAttr* SetPattern( SCCOL nCol, SCROW nRow, std::unique_ptr<ScPatternAttr> );

    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,

                                    const Fraction& rZoomX, const Fraction& rZoomY );


    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( SfxItemPoolCache* pCache, 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;

    bool            IsPrintEntireSheet() const          { return bPrintEntireSheet; }


    void            ClearPrintRanges();

    void            AddPrintRange( const ScRange& rNew );

    void            SetPrintEntireSheet();


    void            FillPrintSaver( ScPrintSaverTab& rSaveTab ) const;

    void            RestorePrintRanges( const ScPrintSaverTab& rSaveTab );


    sal_uInt16      GetOptimalColWidth( SCCOL nCol, OutputDevice* pDev,

                                    double nPPTX, double nPPTY,

                                    const Fraction& rZoomX, const Fraction& rZoomY,

                                    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,

                                    const Fraction& rZoomX, const Fraction& rZoomY,

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


    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;


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


    SCROW      GetLastFlaggedRow() const;


    SCCOL      GetLastChangedColFlagsWidth() const;

    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;


    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;


    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;


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

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

    bool        HasFilteredRows(SCROW nStartRow, SCROW nEndRow) const;

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

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

    void        SetRowFiltered(SCROW nStartRow, SCROW nEndRow, bool bFiltered);

    void        SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, bool bFiltered);

    SCROW       FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const;

    SCROW       LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const;

    SCROW       CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow) const;


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


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

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

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


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


    void SetDirtyIfPostponed();


    void BroadcastRecalcOnRefMove();


    void TransferCellValuesTo( const SCCOL nCol, SCROW nRow, size_t nLen, sc::CellValues& rDest );

    void CopyCellValuesFrom( const SCCOL nCol, SCROW nRow, const sc::CellValues& rSrc );


    std::optional<sc::ColumnIterator> GetColumnIterator( SCCOL nCol, SCROW nRow1, SCROW nRow2 ) const;


    bool EnsureFormulaCellResults( const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2, bool bSkipRunning = false );


    void ConvertFormulaToValue(

        sc::EndListeningContext& rCxt,

        const SCCOL nCol1, const SCROW nRow1, const SCCOL nCol2, const SCROW nRow2,

        sc::TableValues* pUndo );


    void SwapNonEmpty(

        sc::TableValues& rValues, sc::StartListeningContext& rStartCxt, sc::EndListeningContext& rEndCxt );


    void finalizeOutlineImport();


    void StoreToCache(SvStream& rStrm) const;


    void RestoreFromCache(SvStream& rStrm);


#if DUMP_COLUMN_STORAGE

    void DumpColumnStorage( SCCOL nCol ) const;

#endif


    static void UpdateSearchItemAddressForReplace( const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow );


    ScColumnsRange GetWritableColumnsRange(SCCOL begin, SCCOL end);

    ScColumnsRange GetAllocatedColumnsRange(SCCOL begin, SCCOL end) const;

    ScColumnsRange GetColumnsRange(SCCOL begin, SCCOL end) const;

    SCCOL ClampToAllocatedColumns(SCCOL nCol) const { return std::min(nCol, static_cast<SCCOL>(aCol.size() - 1)); }

    SCCOL GetAllocatedColumnsCount() const { return aCol.size(); }


    OString dumpSheetGeomData(bool bColumns, SheetGeomType eGeomType);


    std::set<SCCOL> QueryColumnsWithFormulaCells() const;


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


    void CheckIntegrity() const;


    void CollectBroadcasterState(sc::BroadcasterState& rState) const;


private:


    void FillFormulaVertical(

        const ScFormulaCell& rSrcCell,

        SCCOLROW& rInner, SCCOL nCol, SCROW nRow1, SCROW nRow2,

        ScProgress* pProgress, sal_uInt64& rProgress );


    void FillSeriesSimple(

        const ScCellValue& rSrcCell, SCCOLROW& rInner, SCCOLROW nIMin, SCCOLROW nIMax,

        const SCCOLROW& rCol, const SCCOLROW& rRow, bool bVertical, ScProgress* pProgress, sal_uInt64& rProgress );


    void FillAutoSimple(

        SCCOLROW nISrcStart, SCCOLROW nISrcEnd, SCCOLROW nIStart, SCCOLROW nIEnd,

        SCCOLROW& rInner, const SCCOLROW& rCol, const SCCOLROW& rRow,

        sal_uInt64 nActFormCnt, sal_uInt64 nMaxFormCnt,

        bool bHasFiltered, bool bVertical, bool bPositive,

        ScProgress* pProgress, sal_uInt64& rProgress );


    void        FillSeries( 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, sal_uInt16 nMinDigits,

                                bool bAttribs, ScProgress* pProgress,

                                bool bSkipOverlappedCells = false,

                                std::vector<sal_Int32>* pNonOverlappedCellIdx = nullptr);

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

                                FillCmd& rCmd, FillDateCmd& rDateCmd,

                                double& rInc, tools::Duration& rDuration, sal_uInt16& rMinDigits,

                                ScUserListData*& rListData, sal_uInt16& rListIndex,

                                bool bHasFiltered, bool& rSkipOverlappedCells,

                                std::vector<sal_Int32>& rNonOverlappedCellIdx );

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

                        sal_uInt64 nFillCount, FillDir eFillDir, ScProgress* pProgress );


    bool        ValidNextPos( SCCOL nCol, SCROW nRow, const ScMarkData& rMark,

                                bool bMarked, bool bUnprotected ) const;


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

                                const ScPatternAttr& rAttr, sal_uInt16 nFormatNo);

    void        GetAutoFormatAttr(SCCOL nCol, SCROW nRow, sal_uInt16 nIndex, ScAutoFormatData& rData);

    void        GetAutoFormatFrame(SCCOL nCol, SCROW nRow, sal_uInt16 nFlags, sal_uInt16 nIndex, ScAutoFormatData& rData);

    bool        SearchCell(const SvxSearchItem& rSearchItem, SCCOL nCol, sc::ColumnBlockConstPosition& rBlockPos, SCROW nRow,

                           const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc);

    bool        Search(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,

                       const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc);

    bool        Search(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,

                       SCCOL nLastCol, SCROW nLastRow,

                       const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc,

                       std::vector< sc::ColumnBlockConstPosition >& blockPos);

    bool        SearchAll(const SvxSearchItem& rSearchItem, const ScMarkData& rMark,

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

    bool        Replace(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,

                        const ScMarkData& rMark, OUString& rUndoStr, ScDocument* pUndoDoc);

    bool        ReplaceAll(

        const SvxSearchItem& rSearchItem, const ScMarkData& rMark, ScRangeList& rMatchedRanges,

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


    bool        SearchStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,

                            const ScMarkData& rMark);

    bool        ReplaceStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,

                             const ScMarkData& rMark, bool bIsUndo);

    bool        SearchAllStyle(

        const SvxSearchItem& rSearchItem, const ScMarkData& rMark, ScRangeList& rMatchedRanges);

    bool        ReplaceAllStyle(

        const SvxSearchItem& rSearchItem, const ScMarkData& rMark, ScRangeList& rMatchedRanges,

        ScDocument* pUndoDoc);

    bool        SearchAndReplaceEmptyCells(

                    const SvxSearchItem& rSearchItem,

                    SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark, ScRangeList& rMatchedRanges,

                    OUString& rUndoStr, ScDocument* pUndoDoc);

    bool        SearchRangeForEmptyCell(const ScRange& rRange,

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

                    OUString& rUndoStr);

    bool        SearchRangeForAllEmptyCells(

        const ScRange& rRange, const SvxSearchItem& rSearchItem,

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


                                // use the global sort parameter:

    bool        IsSorted(SCCOLROW nStart, SCCOLROW nEnd) const;

    static void DecoladeRow( ScSortInfoArray*, SCROW nRow1, SCROW nRow2 );

    short CompareCell(

        sal_uInt16 nSort,

        ScRefCellValue& rCell1, SCCOL nCell1Col, SCROW nCell1Row,

        ScRefCellValue& rCell2, SCCOL nCell2Col, SCROW nCell2Row ) const;

    short       Compare(SCCOLROW nIndex1, SCCOLROW nIndex2) const;

    short       Compare( ScSortInfoArray*, SCCOLROW nIndex1, SCCOLROW nIndex2) const;

    std::unique_ptr<ScSortInfoArray> CreateSortInfoArray( const sc::ReorderParam& rParam );

    std::unique_ptr<ScSortInfoArray> CreateSortInfoArray(

        const ScSortParam& rSortParam, SCCOLROW nInd1, SCCOLROW nInd2,

        bool bKeepQuery, bool bUpdateRefs );

    void        QuickSort( ScSortInfoArray*, SCCOLROW nLo, SCCOLROW nHi);

    void        SortReorderByColumn( const ScSortInfoArray* pArray, SCROW nRow1, SCROW nRow2,

                                     bool bPattern, ScProgress* pProgress );

    void        SortReorderAreaExtrasByColumn( const ScSortInfoArray* pArray, SCROW nDataRow1, SCROW nDataRow2,

                                               const ScDataAreaExtras& rDataAreaExtras, ScProgress* pProgress );


    void        SortReorderByRow( ScSortInfoArray* pArray, SCCOL nCol1, SCCOL nCol2,

                                  ScProgress* pProgress, bool bOnlyDataAreaExtras );

    void        SortReorderByRowRefUpdate( ScSortInfoArray* pArray, SCCOL nCol1, SCCOL nCol2,

                                           ScProgress* pProgress );

    void        SortReorderAreaExtrasByRow( ScSortInfoArray* pArray, SCCOL nDataCol1, SCCOL nDataCol2,

                                            const ScDataAreaExtras& rDataAreaExtras, ScProgress* pProgress );


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

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

    OUString    GetUpperCellString(SCCOL nCol, SCROW nRow);


    bool        RefVisible(const ScFormulaCell* pCell);


    bool        IsEmptyLine(SCROW nRow, SCCOL nStartCol, SCCOL nEndCol) const;


    void        IncDate(double& rVal, sal_uInt16& nDayOfMonth, double nStep, FillDateCmd eCmd);

    void FillFormula(

        const ScFormulaCell* pSrcCell, SCCOL nDestCol, SCROW nDestRow, bool bLast );

    void        UpdateInsertTabAbs(SCTAB nNewPos);

    bool        GetNextSpellingCell(SCCOL& rCol, SCROW& rRow, bool bInSel,

                                    const ScMarkData& rMark) const;

    bool        GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark ) const;

    void        TestTabRefAbs(SCTAB nTable) const;

    void CompileDBFormula( sc::CompileFormulaContext& rCxt );

    void CompileColRowNameFormula( sc::CompileFormulaContext& rCxt );


    void        StartListening( const ScAddress& rAddress, SvtListener* pListener );

    void        EndListening( const ScAddress& rAddress, SvtListener* pListener );

    void StartListening( sc::StartListeningContext& rCxt, const ScAddress& rAddress, SvtListener& rListener );

    void EndListening( sc::EndListeningContext& rCxt, const ScAddress& rAddress, SvtListener& rListener );


    void AttachFormulaCells( sc::StartListeningContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );

    void DetachFormulaCells( sc::EndListeningContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );


    void        SetLoadingMedium(bool bLoading);


    SCSIZE      FillMaxRot( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2,

                            SCCOL nCol, SCROW nAttrRow1, SCROW nAttrRow2, SCSIZE nArrY,

                            const ScPatternAttr* pPattern, const SfxItemSet* pCondSet );


    // idle calculation of OutputDevice text width for cell

    // also invalidates script type, broadcasts for "calc as shown"

    void        InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,

                                     bool bNumFormatChanged, bool bBroadcast );


    void        SkipFilteredRows(SCROW& rRow, SCROW& rLastNonFilteredRow, bool bForward);


    void        MaybeAddExtraColumn(SCCOL& rCol, SCROW nRow, OutputDevice* pDev, double nPPTX, double nPPTY);


    void        CopyPrintRange(const ScTable& rTable);


    SCCOL       FindNextVisibleColWithContent(SCCOL nCol, bool bRight, SCROW nRow) const;


    SCCOL       FindNextVisibleCol(SCCOL nCol, bool bRight) const;


    void TransposeColPatterns(ScTable* pTransClip, SCCOL nCol1, SCCOL nCol, SCROW nRow1,

                              SCROW nRow2, SCROW nCombinedStartRow, bool bIncludeFiltered,

                              const std::vector<SCROW>& rFilteredRows, SCROW nRowDestOffset);


    void TransposeColNotes(ScTable* pTransClip, SCCOL nCol1, SCCOL nCol, SCROW nRow1, SCROW nRow2,

                           SCROW nCombinedStartRow, bool bIncludeFiltered, SCROW nRowDestOffset);


    ScColumn* FetchColumn( SCCOL nCol );

    const ScColumn* FetchColumn( SCCOL nCol ) const;


    void EndListeningIntersectedGroup(

        sc::EndListeningContext& rCxt, SCCOL nCol, SCROW nRow, std::vector<ScAddress>* pGroupPos );


    void EndListeningIntersectedGroups(

        sc::EndListeningContext& rCxt, const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2,

        std::vector<ScAddress>* pGroupPos );


    void EndListeningGroup( sc::EndListeningContext& rCxt, const SCCOL nCol, SCROW nRow );

    void SetNeedsListeningGroup( SCCOL nCol, SCROW nRow );


    OString dumpColumnRowSizes(bool bColumns);

    OString dumpHiddenFiltered(bool bColumns, bool bHidden);

    OString dumpColumnRowGroups(bool bColumns) const;


    SCCOL GetLOKFreezeCol() const;

    SCROW GetLOKFreezeRow() const;

    bool  SetLOKFreezeCol(SCCOL nFreezeCol);

    bool  SetLOKFreezeRow(SCROW nFreezeRow);


    class VisibleDataCellIterator

    {

        static constexpr SCROW ROW_NOT_FOUND = -1;


    public:

        explicit VisibleDataCellIterator(const ScDocument& rDoc, ScFlatBoolRowSegments& rRowSegs, ScColumn& rColumn);


        ScRefCellValue reset(SCROW nRow);


        ScRefCellValue next();


        SCROW getRow() const { return mnCurRow;}


    private:

        const ScDocument& mrDocument;

        ScFlatBoolRowSegments& mrRowSegs;

        ScColumn& mrColumn;

        ScRefCellValue maCell;

        SCROW mnCurRow;

        SCROW mnUBound;

    };


};


/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

SolverSettings.hxx

SparklineList.hxx

ValidTab
bool ValidTab(SCTAB nTab)
Definition: address.hxx:111

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

attarray.hxx

ScMF
ScMF
Definition: attrib.hxx:34

calcmacros.hxx

cellvalue.hxx

CollatorWrapper

Color

EditTextObject

Fraction

ScAddress
Definition: address.hxx:207

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

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

ScAutoFormatData
Definition: autoform.hxx:113

ScBitMaskCompressedArray
The data type represents bits, manageable by bitwise operations.
Definition: compressedarray.hxx:184

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

ScColContainer
Definition: colcontainer.hxx:29

ScColContainer::size
SCCOL size() const
Definition: colcontainer.hxx:46

ScColumnData
Definition: column.hxx:116

ScColumnTextWidthIterator
Definition: columniterator.hxx:23

ScColumn
Definition: column.hxx:182

ScColumn::BroadcastMode
BroadcastMode
Broadcast mode for SetDirty(SCROW,SCROW,BroadcastMode).
Definition: column.hxx:243

ScColumnsRange::Iterator
Definition: table.hxx:127

ScColumnsRange::Iterator::reference
SCCOL reference
Definition: table.hxx:134

ScColumnsRange::Iterator::operator*
SCCOL operator*() const
Definition: table.hxx:144

ScColumnsRange::Iterator::value_type
SCCOL value_type
Definition: table.hxx:131

ScColumnsRange::Iterator::iterator_category
std::bidirectional_iterator_tag iterator_category
Definition: table.hxx:130

ScColumnsRange::Iterator::pointer
const SCCOL * pointer
Definition: table.hxx:133

ScColumnsRange::Iterator::difference_type
SCCOL difference_type
Definition: table.hxx:132

ScColumnsRange::Iterator::operator--
Iterator & operator--()
Definition: table.hxx:139

ScColumnsRange::Iterator::Iterator
Iterator(SCCOL nCol)
Definition: table.hxx:136

ScColumnsRange::Iterator::operator++
Iterator & operator++()
Definition: table.hxx:138

ScColumnsRange::Iterator::operator==
bool operator==(const Iterator &rOther) const
Definition: table.hxx:142

ScColumnsRange::Iterator::mCol
SCCOL mCol
Definition: table.hxx:128

ScColumnsRange::Iterator::operator!=
bool operator!=(const Iterator &rOther) const
Definition: table.hxx:143

ScColumnsRange
Definition: table.hxx:124

ScColumnsRange::maBegin
const Iterator maBegin
Definition: table.hxx:153

ScColumnsRange::end
const Iterator & end()
Definition: table.hxx:149

ScColumnsRange::rbegin
std::reverse_iterator< Iterator > rbegin()
Definition: table.hxx:150

ScColumnsRange::rend
std::reverse_iterator< Iterator > rend()
Definition: table.hxx:151

ScColumnsRange::begin
const Iterator & begin()
Definition: table.hxx:148

ScColumnsRange::ScColumnsRange
ScColumnsRange(SCCOL nBegin, SCCOL nEnd)
Definition: table.hxx:147

ScColumnsRange::maEnd
const Iterator maEnd
Definition: table.hxx:154

ScCompressedArray
Compressed array of row (or column) entries, e.g.
Definition: compressedarray.hxx:46

ScConditionalFormatList
Definition: conditio.hxx:628

ScConditionalFormat
Definition: conditio.hxx:540

ScDBData
Definition: dbdata.hxx:66

ScDBQueryDataIterator
Definition: dociter.hxx:100

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

ScDocument
Definition: document.hxx:323

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

ScDocument::ValidCol
bool ValidCol(SCCOL nCol) const
Definition: document.hxx:899

ScDocument::ValidColRow
bool ValidColRow(SCCOL nCol, SCROW nRow) const
Definition: document.hxx:901

ScDrawObjData
Definition: userdat.hxx:32

ScEditDataArray
Definition: editdataarray.hxx:31

ScFlatBoolColSegments
Definition: segmenttree.hxx:89

ScFlatBoolRowSegments
Definition: segmenttree.hxx:30

ScFlatUInt16RowSegments
Definition: segmenttree.hxx:119

ScFormulaCell
Definition: formulacell.hxx:121

ScFormulaGroupIterator
Definition: dociter.hxx:186

ScFunctionData
To calculate a single subtotal function.
Definition: subtotal.hxx:61

ScGlobal::nStdRowHeight
static SC_DLLPUBLIC sal_uInt16 nStdRowHeight
Definition: global.hxx:596

ScHint
Definition: brdcst.hxx:25

ScHorizontalCellIterator
Definition: dociter.hxx:293

ScHorizontalValueIterator
Row-wise value iterator.
Definition: dociter.hxx:334

ScInterpreter
Definition: interpre.hxx:138

ScMarkData
todo: It should be possible to have MarkArrays for each table, in order to enable "search all" across...
Definition: markdata.hxx:43

ScMatrix
Matrix data type that can store values of mixed types.
Definition: scmatrix.hxx:101

ScOutlineTable
Definition: olinetab.hxx:149

ScPatternAttr
Definition: patattr.hxx:54

ScPostIt
Additional class containing cell annotation data.
Definition: postit.hxx:58

ScPrintSaverTab
Definition: prnsave.hxx:30

ScProgress
Definition: progress.hxx:40

ScQueryCellIteratorAccessSpecific
Definition: queryiter.hxx:56

ScQueryCellIteratorBase
Definition: queryiter.hxx:142

ScRangeList
Definition: rangelst.hxx:32

ScRangeName
Definition: rangenam.hxx:186

ScRange
Definition: address.hxx:495

ScSheetEvents
Definition: sheetevents.hxx:33

ScSortInfoArray
Definition: table3.cxx:232

ScStyleSheet
Definition: stlsheet.hxx:29

ScTableProtection
sheet protection state container
Definition: tabprotection.hxx:167

ScTable::VisibleDataCellIterator
Use this to iterate through non-empty visible cells in a single column.
Definition: table.hxx:1391

ScTable::VisibleDataCellIterator::ROW_NOT_FOUND
static constexpr SCROW ROW_NOT_FOUND
Definition: table.hxx:1392

ScTable::VisibleDataCellIterator::VisibleDataCellIterator
VisibleDataCellIterator(const ScDocument &rDoc, ScFlatBoolRowSegments &rRowSegs, ScColumn &rColumn)
Definition: table1.cxx:2364

ScTable::VisibleDataCellIterator::mrRowSegs
ScFlatBoolRowSegments & mrRowSegs
Definition: table.hxx:1423

ScTable::VisibleDataCellIterator::maCell
ScRefCellValue maCell
Definition: table.hxx:1425

ScTable::VisibleDataCellIterator::next
ScRefCellValue next()
Find the next visible data cell position.
Definition: table1.cxx:2417

ScTable::VisibleDataCellIterator::mnCurRow
SCROW mnCurRow
Definition: table.hxx:1426

ScTable::VisibleDataCellIterator::mnUBound
SCROW mnUBound
Definition: table.hxx:1427

ScTable::VisibleDataCellIterator::mrColumn
ScColumn & mrColumn
Definition: table.hxx:1424

ScTable::VisibleDataCellIterator::mrDocument
const ScDocument & mrDocument
Definition: table.hxx:1422

ScTable::VisibleDataCellIterator::getRow
SCROW getRow() const
Get the current row position.
Definition: table.hxx:1419

ScTable::VisibleDataCellIterator::reset
ScRefCellValue reset(SCROW nRow)
Set the start row position.
Definition: table1.cxx:2373

ScTable
Definition: table.hxx:158

ScTable::mpHiddenCols
std::unique_ptr< ScFlatBoolColSegments > mpHiddenCols
Definition: table.hxx:199

ScTable::mnEndCol
SCCOL mnEndCol
Definition: table.hxx:186

ScTable::GetAttr
const T * GetAttr(SCCOL nCol, SCROW nRow, TypedWhichId< T > nWhich, SCROW &nStartRow, SCROW &nEndRow) const
Definition: table.hxx:752

ScTable::CopyScenarioFrom
void CopyScenarioFrom(const ScTable *pSrcTab)
Definition: table2.cxx:1576

ScTable::CreateExcelQuery
bool CreateExcelQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam &rQueryParam)
Definition: table3.cxx:2731

ScTable::GetSelectionStyle
const ScStyleSheet * GetSelectionStyle(const ScMarkData &rMark, bool &rFound) const
Definition: table2.cxx:3067

ScTable::CreateSortInfoArray
std::unique_ptr< ScSortInfoArray > CreateSortInfoArray(const sc::ReorderParam &rParam)
Definition: table3.cxx:461

ScTable::aPageSizeTwips
Size aPageSizeTwips
Definition: table.hxx:177

ScTable::GetLOKFreezeCol
SCCOL GetLOKFreezeCol() const
Definition: table7.cxx:587

ScTable::aPageStyle
OUString aPageStyle
Definition: table.hxx:176

ScTable::ApplySelectionCache
void ApplySelectionCache(SfxItemPoolCache *pCache, const ScMarkData &rMark, ScEditDataArray *pDataArray=nullptr, bool *const pIsChanged=nullptr)
Definition: table2.cxx:3207

ScTable::Sort
void Sort(const ScSortParam &rSortParam, bool bKeepQuery, bool bUpdateRefs, ScProgress *pProgress, sc::ReorderParam *pUndo)
Sort a range of data.
Definition: table3.cxx:1820

ScTable::LastHiddenColRow
SCCOLROW LastHiddenColRow(SCCOLROW nPos, bool bCol) const
Definition: table5.cxx:824

ScTable::GetRangeName
ScRangeName * GetRangeName() const
Definition: table2.cxx:4258

ScTable::UnlockTable
void UnlockTable()
Definition: table2.cxx:2812

ScTable::bTableAreaVisibleValid
bool bTableAreaVisibleValid
Definition: table.hxx:252

ScTable::ValidCol
bool ValidCol(SCCOL nCol) const
Definition: table.hxx:356

ScTable::UpdateInsertTab
void UpdateInsertTab(sc::RefUpdateInsertTabContext &rCxt)
Definition: table1.cxx:1970

ScTable::ApplyStyleArea
void ApplyStyleArea(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScStyleSheet &rStyle)
Definition: table2.cxx:3013

ScTable::FindNextVisibleCol
SCCOL FindNextVisibleCol(SCCOL nCol, bool bRight) const
Definition: table1.cxx:1296

ScTable::GetOriginalHeight
sal_uInt16 GetOriginalHeight(SCROW nRow) const
Definition: table2.cxx:3661

ScTable::UpdateOutlineCol
bool UpdateOutlineCol(SCCOL nStartCol, SCCOL nEndCol, bool bShow)
Definition: table2.cxx:3951

ScTable::IsBlockEditable
bool IsBlockEditable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool *pOnlyNotBecauseOfMatrix=nullptr, bool bNoMatrixAtAll=false) const
Definition: table2.cxx:2641

ScTable::CountVisibleCols
SCCOL CountVisibleCols(SCCOL nStartCol, SCCOL nEndCol) const
Definition: table5.cxx:802

ScTable::nLinkMode
ScLinkMode nLinkMode
Definition: table.hxx:173

ScTable::GetCellValue
ScRefCellValue GetCellValue(SCCOL nCol, sc::ColumnBlockPosition &rBlockPos, SCROW nRow)
Definition: table2.cxx:2030

ScTable::DecoladeRow
static void DecoladeRow(ScSortInfoArray *, SCROW nRow1, SCROW nRow2)
Definition: table3.cxx:1809

ScTable::ApplySelectionLineStyle
void ApplySelectionLineStyle(const ScMarkData &rMark, const ::editeng::SvxBorderLine *pLine, bool bColorOnly)
Definition: table2.cxx:3050

ScTable::AddCondFormatData
void AddCondFormatData(const ScRangeList &rRange, sal_uInt32 nIndex)
Definition: table2.cxx:2955

ScTable::UpdateDrawRef
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)
Definition: table1.cxx:1815

ScTable::Fill
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)
Definition: table4.cxx:2629

ScTable::SearchRangeForAllEmptyCells
bool SearchRangeForAllEmptyCells(const ScRange &rRange, const SvxSearchItem &rSearchItem, ScRangeList &rMatchedRanges, OUString &rUndoStr, ScDocument *pUndoDoc)
Definition: table6.cxx:1074

ScTable::SkipRow
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
Definition: table1.cxx:1481

ScTable::FillMatrix
void FillMatrix(ScMatrix &rMat, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, svl::SharedStringPool *pPool) const
Definition: table1.cxx:2609

ScTable::HasBlockMatrixFragment
bool HasBlockMatrixFragment(const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2, bool bNoMatrixAtAll=false) const
Definition: table2.cxx:2528

ScTable::GetNumberFormat
sal_uInt32 GetNumberFormat(const ScInterpreterContext &rContext, const ScAddress &rPos) const
Definition: table2.cxx:2254

ScTable::SetColHidden
void SetColHidden(SCCOL nStartCol, SCCOL nEndCol, bool bHidden)
Definition: table5.cxx:629

ScTable::CompileDBFormula
void CompileDBFormula(sc::CompileFormulaContext &rCxt)
Definition: table4.cxx:2985

ScTable::AssertNoInterpretNeeded
void AssertNoInterpretNeeded(SCCOL nCol, SCROW nRow1, SCROW nRow2)
Definition: table1.cxx:2546

ScTable::IsActiveScenario
bool IsActiveScenario() const
Definition: table.hxx:382

ScTable::SetAllFormulasDirty
void SetAllFormulasDirty(const sc::SetFormulaDirtyContext &rCxt)
Definition: table2.cxx:2116

ScTable::PrepareQuery
void PrepareQuery(ScQueryParam &rQueryParam)
Definition: table3.cxx:2623

ScTable::mpFilteredRows
std::unique_ptr< ScFlatBoolRowSegments > mpFilteredRows
Definition: table.hxx:202

ScTable::GetRefCellValue
ScRefCellValue GetRefCellValue(SCCOL nCol, SCROW nRow)
Definition: table1.cxx:2570

ScTable::GetAllocatedColumnsRange
ScColumnsRange GetAllocatedColumnsRange(SCCOL begin, SCCOL end) const
Definition: table1.cxx:2719

ScTable::bPageSizeValid
bool bPageSizeValid
Definition: table.hxx:250

ScTable::LastVisibleRow
SCROW LastVisibleRow(SCROW nStartRow, SCROW nEndRow) const
Definition: table5.cxx:735

ScTable::ReplaceStyle
bool ReplaceStyle(const SvxSearchItem &rSearchItem, SCCOL &rCol, SCROW &rRow, const ScMarkData &rMark, bool bIsUndo)
Definition: table6.cxx:716

ScTable::GetUpperName
const OUString & GetUpperName() const
Definition: table1.cxx:367

ScTable::SortReorderByColumn
void SortReorderByColumn(const ScSortInfoArray *pArray, SCROW nRow1, SCROW nRow2, bool bPattern, ScProgress *pProgress)
Definition: table3.cxx:945

ScTable::ShowRow
void ShowRow(SCROW nRow, bool bShow)
Definition: table2.cxx:3707

ScTable::SetAttrEntries
void SetAttrEntries(SCCOL nStartCol, SCCOL nEndCol, std::vector< ScAttrEntry > &&vNewData)
Definition: table2.cxx:2914

ScTable::IsScenario
bool IsScenario() const
Definition: table.hxx:371

ScTable::StyleSheetChanged
void StyleSheetChanged(const SfxStyleSheetBase *pStyleSheet, bool bRemoved, OutputDevice *pDev, double nPPTX, double nPPTY, const Fraction &rZoomX, const Fraction &rZoomY)
Definition: table2.cxx:3134

ScTable::CopyStaticToDocument
void CopyStaticToDocument(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const SvNumberFormatterMergeMap &rMap, ScTable *pDestTab)
Definition: table2.cxx:551

ScTable::UpdateDeleteTab
void UpdateDeleteTab(sc::RefUpdateDeleteTabContext &rCxt)
Definition: table1.cxx:1999

ScTable::UpdateGrow
void UpdateGrow(const ScRange &rArea, SCCOL nGrowX, SCROW nGrowY)
Definition: table1.cxx:1964

ScTable::ApplyAttr
void ApplyAttr(SCCOL nCol, SCROW nRow, const SfxPoolItem &rAttr)
Definition: table2.cxx:3201

ScTable::GetColumnsRange
ScColumnsRange GetColumnsRange(SCCOL begin, SCCOL end) const
Definition: table1.cxx:2729

ScTable::FetchColumn
ScColumn * FetchColumn(SCCOL nCol)
Definition: table2.cxx:1236

ScTable::HasFormulaCell
bool HasFormulaCell(const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2) const
Definition: table7.cxx:292

ScTable::HasAttrib
bool HasAttrib(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, HasAttrFlags nMask) const
Definition: table2.cxx:2296

ScTable::GetAutoFormatFrame
void GetAutoFormatFrame(SCCOL nCol, SCROW nRow, sal_uInt16 nFlags, sal_uInt16 nIndex, ScAutoFormatData &rData)
Definition: table4.cxx:2801

ScTable::GetPrintAreaHor
bool GetPrintAreaHor(SCROW nStartRow, SCROW nEndRow, SCCOL &rEndCol) const
Definition: table1.cxx:717

ScTable::GetErrCode
FormulaError GetErrCode(const ScAddress &rPos) const
Definition: table.hxx:670

ScTable::GetCellArea
bool GetCellArea(SCCOL &rEndCol, SCROW &rEndRow)
Definition: table1.cxx:521

ScTable::DeleteSelection
void DeleteSelection(InsertDeleteFlags nDelFlag, const ScMarkData &rMark, bool bBroadcast=true)
Definition: table2.cxx:456

ScTable::CopyCellToDocument
void CopyCellToDocument(SCCOL nSrcCol, SCROW nSrcRow, SCCOL nDestCol, SCROW nDestRow, ScTable &rDestTab)
Definition: table2.cxx:589

ScTable::ColFiltered
bool ColFiltered(SCCOL nCol, SCCOL *pFirstCol=nullptr, SCCOL *pLastCol=nullptr) const
Definition: table5.cxx:866

ScTable::InvalidateTableArea
void InvalidateTableArea()
Definition: table2.cxx:1557

ScTable::aLinkFlt
OUString aLinkFlt
Definition: table.hxx:169

ScTable::aTabBgColor
Color aTabBgColor
Definition: table.hxx:237

ScTable::CopyData
void CopyData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCCOL nDestCol, SCROW nDestRow, SCTAB nDestTab)
Definition: table2.cxx:4141

ScTable::aUpperName
OUString aUpperName
Definition: table.hxx:222

ScTable::HasRowHeader
bool HasRowHeader(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow) const
Definition: table3.cxx:2984

ScTable::ShowCol
void ShowCol(SCCOL nCol, bool bShow)
Definition: table2.cxx:3687

ScTable::EndListeningGroup
void EndListeningGroup(sc::EndListeningContext &rCxt, const SCCOL nCol, SCROW nRow)
Definition: table7.cxx:326

ScTable::SetLink
void SetLink(ScLinkMode nMode, const OUString &rDoc, const OUString &rFlt, const OUString &rOpt, const OUString &rTab, sal_uLong nRefreshDelay)
Definition: table1.cxx:420

ScTable::SetDrawPageSize
void SetDrawPageSize(bool bResetStreamValid=true, bool bUpdateNoteCaptionPos=true, const ScObjectHandling eObjectHandling=ScObjectHandling::RecalcPosMode)
Definition: table2.cxx:4221

ScTable::CalcAll
void CalcAll()
Definition: table2.cxx:2178

ScTable::pDBDataNoName
std::unique_ptr< ScDBData > pDBDataNoName
Definition: table.hxx:239

ScTable::dumpColumnRowSizes
OString dumpColumnRowSizes(bool bColumns)
Returns list-of-spans representation of the column-widths/row-heights in twips encoded as an OString.
Definition: table7.cxx:516

ScTable::SetDirty
void SetDirty(const ScRange &, ScColumn::BroadcastMode)
Definition: table2.cxx:2124

ScTable::mpCondFormatList
std::unique_ptr< ScConditionalFormatList > mpCondFormatList
Definition: table.hxx:242

ScTable::SetTabBgColor
void SetTabBgColor(const Color &rColor)
Definition: table1.cxx:405

ScTable::TestCopyScenarioTo
bool TestCopyScenarioTo(const ScTable *pDestTab) const
Definition: table2.cxx:1639

ScTable::SetRowFiltered
void SetRowFiltered(SCROW nStartRow, SCROW nEndRow, bool bFiltered)
Definition: table5.cxx:928

ScTable::DoAutoOutline
void DoAutoOutline(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow)
Definition: table2.cxx:4069

ScTable::HasSelectionMatrixFragment
bool HasSelectionMatrixFragment(const ScMarkData &rMark) const
Definition: table2.cxx:2624

ScTable::pSortCollator
CollatorWrapper * pSortCollator
Definition: table.hxx:226

ScTable::SetNote
void SetNote(SCCOL nCol, SCROW nRow, std::unique_ptr< ScPostIt > pNote)
Definition: table2.cxx:1905

ScTable::UpdateSelectionFunction
void UpdateSelectionFunction(ScFunctionData &rData, const ScMarkData &rMark)
Definition: table3.cxx:3117

ScTable::bVisible
bool bVisible
Definition: table.hxx:253

ScTable::GetCalcNotification
bool GetCalcNotification() const
Definition: table.hxx:363

ScTable::AutoFormat
void AutoFormat(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, sal_uInt16 nFormatNo)
Definition: table4.cxx:2652

ScTable::FirstVisibleRow
SCROW FirstVisibleRow(SCROW nStartRow, SCROW nEndRow) const
Definition: table5.cxx:712

ScTable::GetAreaStyle
const ScStyleSheet * GetAreaStyle(bool &rFound, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
Definition: table2.cxx:3093

ScTable::DeleteRow
void DeleteRow(const sc::ColumnSet &rRegroupCols, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize, bool *pUndoOutline, std::vector< ScAddress > *pGroupPos)
Definition: table2.cxx:202

ScTable::GetLinkRefreshDelay
sal_uLong GetLinkRefreshDelay() const
Definition: table.hxx:390

ScTable::IsDataFiltered
bool IsDataFiltered(SCCOL nColStart, SCROW nRowStart, SCCOL nColEnd, SCROW nRowEnd) const
Definition: table2.cxx:3830

ScTable::DetachFormulaCells
void DetachFormulaCells(sc::EndListeningContext &rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
Definition: table2.cxx:1280

ScTable::GetLinkTab
const OUString & GetLinkTab() const
Definition: table.hxx:389

ScTable::InvalidatePageBreaks
void InvalidatePageBreaks()
Definition: table2.cxx:1563

ScTable::FillAuto
void FillAuto(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uInt64 nFillCount, FillDir eFillDir, ScProgress *pProgress)
Definition: table4.cxx:814

ScTable::HasScenarioRange
bool HasScenarioRange(const ScRange &rRange) const
Definition: table2.cxx:1597

ScTable::GetAttr
const T * GetAttr(SCCOL nCol, SCROW nRow, TypedWhichId< T > nWhich) const
Definition: table.hxx:747

ScTable::GetRepeatRowRange
const std::optional< ScRange > & GetRepeatRowRange() const
Definition: table.hxx:823

ScTable::FillAnalyse
void FillAnalyse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, FillCmd &rCmd, FillDateCmd &rDateCmd, double &rInc, tools::Duration &rDuration, sal_uInt16 &rMinDigits, ScUserListData *&rListData, sal_uInt16 &rListIndex, bool bHasFiltered, bool &rSkipOverlappedCells, std::vector< sal_Int32 > &rNonOverlappedCellIdx)
Definition: table4.cxx:230

ScTable::GetAllRowBreaks
void GetAllRowBreaks(::std::set< SCROW > &rBreaks, bool bPage, bool bManual) const
Definition: table5.cxx:339

ScTable::EndListening
void EndListening(const ScAddress &rAddress, SvtListener *pListener)
Definition: table5.cxx:1214

ScTable::InterpretCellsIfNeeded
bool InterpretCellsIfNeeded(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
Definition: table1.cxx:2624

ScTable::RowHiddenLeaf
bool RowHiddenLeaf(SCROW nRow, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) const
Definition: table5.cxx:517

ScTable::bPendingRowHeights
bool bPendingRowHeights
Definition: table.hxx:254

ScTable::SearchAllStyle
bool SearchAllStyle(const SvxSearchItem &rSearchItem, const ScMarkData &rMark, ScRangeList &rMatchedRanges)
Definition: table6.cxx:741

ScTable::FillSeriesSimple
void FillSeriesSimple(const ScCellValue &rSrcCell, SCCOLROW &rInner, SCCOLROW nIMin, SCCOLROW nIMax, const SCCOLROW &rCol, const SCCOLROW &rRow, bool bVertical, ScProgress *pProgress, sal_uInt64 &rProgress)
Definition: table4.cxx:1793

ScTable::SearchAll
bool SearchAll(const SvxSearchItem &rSearchItem, const ScMarkData &rMark, ScRangeList &rMatchedRanges, OUString &rUndoStr, ScDocument *pUndoDoc)
Definition: table6.cxx:520

ScTable::~ScTable
~ScTable() COVERITY_NOEXCEPT_FALSE
Definition: table1.cxx:325

ScTable::TransposeColPatterns
void TransposeColPatterns(ScTable *pTransClip, SCCOL nCol1, SCCOL nCol, SCROW nRow1, SCROW nRow2, SCROW nCombinedStartRow, bool bIncludeFiltered, const std::vector< SCROW > &rFilteredRows, SCROW nRowDestOffset)
Transpose clipboard patterns.
Definition: table2.cxx:1050

ScTable::GetPatternCount
SCSIZE GetPatternCount(SCCOL nCol) const
Definition: table4.cxx:2997

ScTable::CompileXML
void CompileXML(sc::CompileFormulaContext &rCxt, ScProgress &rProgress)
Definition: table2.cxx:2195

ScTable::IsBlockEmpty
bool IsBlockEmpty(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
Definition: table2.cxx:2360

ScTable::maColManualBreaks
::std::set< SCCOL > maColManualBreaks
Definition: table.hxx:207

ScTable::SearchAndReplaceEmptyCells
bool SearchAndReplaceEmptyCells(const SvxSearchItem &rSearchItem, SCCOL &rCol, SCROW &rRow, const ScMarkData &rMark, ScRangeList &rMatchedRanges, OUString &rUndoStr, ScDocument *pUndoDoc)
Definition: table6.cxx:862

ScTable::GetColWidth
sal_uInt16 GetColWidth(SCCOL nCol, bool bHiddenAsZero=true) const
Definition: table2.cxx:3455

ScTable::CopyRowFiltered
void CopyRowFiltered(const ScTable &rTable, SCROW nStartRow, SCROW nEndRow)
Definition: table5.cxx:914

ScTable::GetPageSize
Size GetPageSize() const
Definition: table5.cxx:1185

ScTable::GetPageStyle
const OUString & GetPageStyle() const
Definition: table.hxx:408

ScTable::GetRowHeight
sal_uInt16 GetRowHeight(SCROW nRow, SCROW *pStartRow, SCROW *pEndRow, bool bHiddenAsZero=true) const
Definition: table2.cxx:3553

ScTable::SetFormulaCell
ScFormulaCell * SetFormulaCell(SCCOL nCol, SCROW nRow, ScFormulaCell *pCell)
Takes ownership of pCell.
Definition: table2.cxx:1736

ScTable::mnOptimalMinRowHeight
sal_uInt16 mnOptimalMinRowHeight
Definition: table.hxx:190

ScTable::aCol
ScColContainer aCol
Definition: table.hxx:162

ScTable::GetAllColBreaks
void GetAllColBreaks(::std::set< SCCOL > &rBreaks, bool bPage, bool bManual) const
Definition: table5.cxx:351

ScTable::SetColWidthOnly
void SetColWidthOnly(SCCOL nCol, sal_uInt16 nNewWidth)
Definition: table2.cxx:3300

ScTable::CreateStarQuery
bool CreateStarQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam &rQueryParam)
Definition: table3.cxx:2809

ScTable::UndoToTable
void UndoToTable(sc::CopyToDocContext &rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, InsertDeleteFlags nFlags, bool bMarked, ScTable *pDestTab)
Definition: table2.cxx:1498

ScTable::SetDirtyAfterLoad
void SetDirtyAfterLoad()
Definition: table2.cxx:2141

ScTable::MixData
void MixData(sc::MixDocContext &rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScPasteFunc nFunction, bool bSkipEmpty, const ScTable *pSrcTab)
Definition: table2.cxx:785

ScTable::ValidColRow
bool ValidColRow(SCCOL nCol, SCROW nRow) const
Definition: table.hxx:358

ScTable::pRowFlags
std::unique_ptr< ScBitMaskCompressedArray< SCROW, CRFlags > > pRowFlags
Definition: table.hxx:198

ScTable::GetAutoFormatAttr
void GetAutoFormatAttr(SCCOL nCol, SCROW nRow, sal_uInt16 nIndex, ScAutoFormatData &rData)
Definition: table4.cxx:2788

ScTable::GetOriginalWidth
sal_uInt16 GetOriginalWidth(SCCOL nCol) const
Definition: table2.cxx:3492

ScTable::GetAllNoteCaptionsState
CommentCaptionState GetAllNoteCaptionsState(const ScRange &rRange, std::vector< sc::NoteEntry > &rNotes)
Definition: table2.cxx:1961

ScTable::FillSeries
void FillSeries(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, sal_uInt16 nMinDigits, bool bAttribs, ScProgress *pProgress, bool bSkipOverlappedCells=false, std::vector< sal_Int32 > *pNonOverlappedCellIdx=nullptr)
Definition: table4.cxx:2167

ScTable::SetLoadingRTL
void SetLoadingRTL(bool bSet)
Definition: table1.cxx:400

ScTable::HandleRefArrayForParallelism
bool HandleRefArrayForParallelism(SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScFormulaCellGroupRef &mxGroup)
Definition: table1.cxx:2554

ScTable::RemoveEditTextCharAttribs
void RemoveEditTextCharAttribs(SCCOL nCol, SCROW nRow, const ScPatternAttr &rAttr)
Definition: table2.cxx:1814

ScTable::FindMaxRotCol
void FindMaxRotCol(RowInfo *pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2)
Definition: table2.cxx:2453

ScTable::IsColRowTabValid
bool IsColRowTabValid(const SCCOL nScCol, const SCROW nScRow, const SCTAB nScTab) const
Definition: table.hxx:352

ScTable::UpdateInsertTabAbs
void UpdateInsertTabAbs(SCTAB nNewPos)
Definition: table4.cxx:2939

ScTable::SetOutlineTable
bool SetOutlineTable(const ScOutlineTable *pNewOutline)
Definition: table2.cxx:91

ScTable::GetString
OUString GetString(SCCOL nCol, SCROW nRow, const ScInterpreterContext *pContext=nullptr) const
Definition: table2.cxx:1775

ScTable::HasData
bool HasData(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:2064

ScTable::RemoveCondFormatData
void RemoveCondFormatData(const ScRangeList &rRange, sal_uInt32 nIndex)
Definition: table2.cxx:2972

ScTable::SetRangeName
void SetRangeName(std::unique_ptr< ScRangeName > pNew)
Definition: table2.cxx:4250

ScTable::IsEditActionAllowed
bool IsEditActionAllowed(sc::ColRowEditAction eAction, SCCOLROW nStart, SCCOLROW nEnd) const
Definition: table7.cxx:342

ScTable::GetCommonWidth
sal_uInt16 GetCommonWidth(SCCOL nEndCol) const
Definition: table2.cxx:3502

ScTable::GetLinkMode
ScLinkMode GetLinkMode() const
Definition: table.hxx:384

ScTable::UpdateScriptTypes
void UpdateScriptTypes(const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2)
Definition: table7.cxx:244

ScTable::PageStyleModified
void PageStyleModified(const OUString &rNewName)
Definition: table5.cxx:1284

ScTable::FillPrintSaver
void FillPrintSaver(ScPrintSaverTab &rSaveTab) const
Definition: table1.cxx:2347

ScTable::SetRowFlags
void SetRowFlags(SCROW nRow, CRFlags nNewFlags)
Definition: table2.cxx:3854

ScTable::MergeSelectionPattern
void MergeSelectionPattern(ScMergePatternState &rState, const ScMarkData &rMark, bool bDeep) const
Definition: table2.cxx:2822

ScTable::GetEditText
const EditTextObject * GetEditText(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:1806

ScTable::GetMostUsedPattern
const ScPatternAttr * GetMostUsedPattern(SCCOL nCol, SCROW nStartRow, SCROW nEndRow) const
Definition: table2.cxx:2289

ScTable::bScenario
bool bScenario
Definition: table.hxx:247

ScTable::CreateColumnIfNotExists
ScColumn & CreateColumnIfNotExists(const SCCOL nScCol)
Definition: table.hxx:303

ScTable::ColumnData
const ScColumnData & ColumnData(SCCOL nCol) const
Definition: table.hxx:1177

ScTable::FillAutoSimple
void FillAutoSimple(SCCOLROW nISrcStart, SCCOLROW nISrcEnd, SCCOLROW nIStart, SCCOLROW nIEnd, SCCOLROW &rInner, const SCCOLROW &rCol, const SCCOLROW &rRow, sal_uInt64 nActFormCnt, sal_uInt64 nMaxFormCnt, bool bHasFiltered, bool bVertical, bool bPositive, ScProgress *pProgress, sal_uInt64 &rProgress)
Definition: table4.cxx:1873

ScTable::IsEmptyLine
bool IsEmptyLine(SCROW nRow, SCCOL nStartCol, SCCOL nEndCol) const
Definition: table1.cxx:1257

ScTable::mbPageBreaksValid
bool mbPageBreaksValid
Definition: table.hxx:259

ScTable::nRepeatEndY
SCROW nRepeatEndY
Definition: table.hxx:181

ScTable::GetDataStart
bool GetDataStart(SCCOL &rStartCol, SCROW &rStartRow) const
Definition: table1.cxx:815

ScTable::maRowPageBreaks
::std::set< SCROW > maRowPageBreaks
Definition: table.hxx:204

ScTable::GetAllNoteEntries
void GetAllNoteEntries(std::vector< sc::NoteEntry > &rNotes) const
Definition: table2.cxx:1944

ScTable::GetFormulaCell
const ScFormulaCell * GetFormulaCell(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:1830

ScTable::SetEditText
bool SetEditText(SCCOL nCol, SCROW nRow, std::unique_ptr< EditTextObject > pEditText)
Definition: table2.cxx:1664

ScTable::QuickSort
void QuickSort(ScSortInfoArray *, SCCOLROW nLo, SCCOLROW nHi)
Definition: table3.cxx:1720

ScTable::TransposeColNotes
void TransposeColNotes(ScTable *pTransClip, SCCOL nCol1, SCCOL nCol, SCROW nRow1, SCROW nRow2, SCROW nCombinedStartRow, bool bIncludeFiltered, SCROW nRowDestOffset)
Transpose clipboard notes.
Definition: table2.cxx:1121

ScTable::SetCodeName
void SetCodeName(const OUString &rNewName)
Definition: table.hxx:404

ScTable::IsColValid
bool IsColValid(const SCCOL nScCol) const
Definition: table.hxx:344

ScTable::CopyUpdated
void CopyUpdated(const ScTable *pPosTab, ScTable *pDestTab) const
Definition: table2.cxx:1550

ScTable::mpColFlags
std::unique_ptr< ScBitMaskCompressedArray< SCCOL, CRFlags > > mpColFlags
Definition: table.hxx:197

ScTable::SetStreamValid
void SetStreamValid(bool bSet, bool bIgnoreLock=false)
Definition: table1.cxx:382

ScTable::GetSheetEvents
const ScSheetEvents * GetSheetEvents() const
Definition: table.hxx:335

ScTable::CopyRowHeight
void CopyRowHeight(const ScTable &rSrcTable, SCROW nStartRow, SCROW nEndRow, SCROW nSrcOffset)
Definition: table5.cxx:692

ScTable::m_pSolverSettings
std::shared_ptr< sc::SolverSettings > m_pSolverSettings
Definition: table.hxx:265

ScTable::GetDataArea
void GetDataArea(SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow, bool bIncludeOld, bool bOnlyDown) const
Definition: table1.cxx:891

ScTable::SetDirtyVar
void SetDirtyVar()
Definition: table2.cxx:2102

ScTable::GetLastChangedColFlagsWidth
SCCOL GetLastChangedColFlagsWidth() const
Definition: table2.cxx:3920

ScTable::SortReorderAreaExtrasByColumn
void SortReorderAreaExtrasByColumn(const ScSortInfoArray *pArray, SCROW nDataRow1, SCROW nDataRow2, const ScDataAreaExtras &rDataAreaExtras, ScProgress *pProgress)
Definition: table3.cxx:925

ScTable::bLoadingRTL
bool bLoadingRTL
Definition: table.hxx:249

ScTable::GetNoteCount
size_t GetNoteCount(SCCOL nCol) const
Definition: table2.cxx:1913

ScTable::DeleteSparkline
bool DeleteSparkline(SCCOL nCol, SCROW nRow)
Definition: table2.cxx:1873

ScTable::GetDataEntries
bool GetDataEntries(SCCOL nCol, SCROW nRow, std::set< ScTypedStrData > &rStrings)
Definition: table3.cxx:3051

ScTable::CopyScenarioTo
void CopyScenarioTo(ScTable *pDestTab) const
Definition: table2.cxx:1568

ScTable::GetScaledRowHeight
tools::Long GetScaledRowHeight(SCROW nStartRow, SCROW nEndRow, double fScale) const
Definition: table2.cxx:3620

ScTable::SetTableOpDirty
void SetTableOpDirty(const ScRange &)
Definition: table2.cxx:2133

ScTable::SearchStyle
bool SearchStyle(const SvxSearchItem &rSearchItem, SCCOL &rCol, SCROW &rRow, const ScMarkData &rMark)
Definition: table6.cxx:624

ScTable::CheckIntegrity
void CheckIntegrity() const
Definition: table7.cxx:644

ScTable::GetWeightedCount
sal_uInt64 GetWeightedCount() const
Definition: table3.cxx:3068

ScTable::SetRowHidden
bool SetRowHidden(SCROW nStartRow, SCROW nEndRow, bool bHidden)
Definition: table5.cxx:579

ScTable::nLinkRefreshDelay
sal_uLong nLinkRefreshDelay
Definition: table.hxx:172

ScTable::bTableAreaValid
bool bTableAreaValid
Definition: table.hxx:251

ScTable::bActiveScenario
bool bActiveScenario
Definition: table.hxx:258

ScTable::CalculateInColumnInThread
void CalculateInColumnInThread(ScInterpreterContext &rContext, SCCOL nColStart, SCCOL nColEnd, SCROW nRowStart, SCROW nRowEnd, unsigned nThisThread, unsigned nThreadsTotal)
Definition: table1.cxx:2642

ScTable::DeleteCol
void DeleteCol(const sc::ColumnSet &rRegroupCols, SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize, bool *pUndoOutline)
Definition: table2.cxx:356

ScTable::ApplyStyle
void ApplyStyle(SCCOL nCol, SCROW nRow, const ScStyleSheet *rStyle)
Definition: table2.cxx:3006

ScTable::moRepeatRowRange
std::optional< ScRange > moRepeatRowRange
Definition: table.hxx:231

ScTable::SetPageSize
void SetPageSize(const Size &rSize)
Definition: table5.cxx:1157

ScTable::SearchAndReplace
bool SearchAndReplace(const SvxSearchItem &rSearchItem, SCCOL &rCol, SCROW &rRow, const ScMarkData &rMark, ScRangeList &rMatchedRanges, OUString &rUndoStr, ScDocument *pUndoDoc, bool &bMatchedRangesWereClamped)
Definition: table6.cxx:800

ScTable::mpFilteredCols
std::unique_ptr< ScFlatBoolColSegments > mpFilteredCols
Definition: table.hxx:201

ScTable::FindAreaPos
void FindAreaPos(SCCOL &rCol, SCROW &rRow, ScMoveDirection eDirection) const
Definition: table1.cxx:1383

ScTable::SetCondFormList
void SetCondFormList(ScConditionalFormatList *pList)
Definition: table1.cxx:2691

ScTable::SyncColRowFlags
void SyncColRowFlags()
Definition: table5.cxx:1136

ScTable::GetRowOffset
tools::Long GetRowOffset(SCROW nRow, bool bHiddenAsZero=true) const
Definition: table2.cxx:4265

ScTable::GetRepeatColRange
const std::optional< ScRange > & GetRepeatColRange() const
Definition: table.hxx:822

ScTable::nRepeatStartX
SCCOL nRepeatStartX
Definition: table.hxx:178

ScTable::GetRowBreakData
css::uno::Sequence< css::sheet::TablePageBreakData > GetRowBreakData() const
Definition: table5.cxx:471

ScTable::SetDirtyIfPostponed
void SetDirtyIfPostponed()
Mark formula cells dirty that have the mbPostponedDirty flag set or contain named ranges with relativ...
Definition: table2.cxx:2148

ScTable::GetUnprotectedCells
void GetUnprotectedCells(ScRangeList &rRangeList) const
Definition: table2.cxx:1994

ScTable::ExtendMerge
bool ExtendMerge(SCCOL nStartCol, SCROW nStartRow, SCCOL &rEndCol, SCROW &rEndRow, bool bRefresh)
Definition: table2.cxx:2326

ScTable::SetColBreak
void SetColBreak(SCCOL nCol, bool bPage, bool bManual)
Definition: table5.cxx:456

ScTable::RestorePrintRanges
void RestorePrintRanges(const ScPrintSaverTab &rSaveTab)
Definition: table1.cxx:2353

ScTable::nLockCount
sal_uInt16 nLockCount
Definition: table.hxx:233

ScTable::CheckVectorizationState
void CheckVectorizationState()
Definition: table2.cxx:2108

ScTable::CreateColumnIfNotExistsImpl
void CreateColumnIfNotExistsImpl(const SCCOL nScCol)
Definition: table1.cxx:2740

ScTable::GetColumnIterator
std::optional< sc::ColumnIterator > GetColumnIterator(SCCOL nCol, SCROW nRow1, SCROW nRow2) const
Definition: table7.cxx:423

ScTable::IsPendingRowHeights
bool IsPendingRowHeights() const
Definition: table.hxx:360

ScTable::GetStyle
const ScStyleSheet * GetStyle(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:3060

ScTable::SetScriptType
void SetScriptType(SCCOL nCol, SCROW nRow, SvtScriptType nType)
Definition: table1.cxx:2481

ScTable::SetColWidth
void SetColWidth(SCCOL nCol, sal_uInt16 nNewWidth)
Definition: table2.cxx:3279

ScTable::SetMergedCells
void SetMergedCells(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
Definition: table2.cxx:2345

ScTable::SetFormulaCells
bool SetFormulaCells(SCCOL nCol, SCROW nRow, std::vector< ScFormulaCell * > &rCells)
Definition: table2.cxx:1747

ScTable::GetNote
ScPostIt * GetNote(SCCOL nCol, SCROW nRow)
Definition: table2.cxx:1898

ScTable::CopyToTable
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, bool bGlobalNamesToLocal, bool bCopyCaptions)
Definition: table2.cxx:1311

ScTable::MergeBlockFrame
void MergeBlockFrame(SvxBoxItem *pLineOuter, SvxBoxInfoItem *pLineInner, ScLineFlags &rFlags, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow) const
Definition: table2.cxx:2846

ScTable::CopyConditionalFormat
void CopyConditionalFormat(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCCOL nDx, SCROW nDy, const ScTable *pTable)
Definition: table2.cxx:636

ScTable::HasRowPageBreak
bool HasRowPageBreak(SCROW nRow) const
Definition: table5.cxx:363

ScTable::CountNonFilteredRows
SCROW CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow) const
Definition: table5.cxx:990

ScTable::AddPrintRange
void AddPrintRange(const ScRange &rNew)
Adds a new print ranges.
Definition: table1.cxx:2322

ScTable::GetPrintArea
bool GetPrintArea(SCCOL &rEndCol, SCROW &rEndRow, bool bNotes, bool bCalcHiddens=false) const
Definition: table1.cxx:608

ScTable::SetRowHeight
void SetRowHeight(SCROW nRow, sal_uInt16 nNewHeight)
Definition: table2.cxx:3312

ScTable::aLinkTab
OUString aLinkTab
Definition: table.hxx:171

ScTable::UpdateTranspose
void UpdateTranspose(const ScRange &rSource, const ScAddress &rDest, ScDocument *pUndoDoc)
Definition: table1.cxx:1957

ScTable::SetPatternAreaCondFormat
void SetPatternAreaCondFormat(SCCOL nCol, SCROW nStartRow, SCROW nEndRow, const ScPatternAttr &rAttr, const ScCondFormatIndexes &rCondFormatIndexes)
Definition: table2.cxx:2989

ScTable::RemoveRowPageBreaks
void RemoveRowPageBreaks(SCROW nStartRow, SCROW nEndRow)
Definition: table5.cxx:401

ScTable::TestInsertRow
bool TestInsertRow(SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize) const
Definition: table2.cxx:135

ScTable::GetColFlags
CRFlags GetColFlags(SCCOL nCol) const
Definition: table2.cxx:3874

ScTable::DeleteConditionalFormat
void DeleteConditionalFormat(sal_uLong nOldIndex)
Definition: table1.cxx:2686

ScTable::nTableAreaX
SCCOL nTableAreaX
Definition: table.hxx:213

ScTable::SortReorderAreaExtrasByRow
void SortReorderAreaExtrasByRow(ScSortInfoArray *pArray, SCCOL nDataCol1, SCCOL nDataCol2, const ScDataAreaExtras &rDataAreaExtras, ScProgress *pProgress)
Definition: table3.cxx:898

ScTable::HasColPageBreak
bool HasColPageBreak(SCCOL nCol) const
Definition: table5.cxx:371

ScTable::nTableAreaVisibleY
SCROW nTableAreaVisibleY
Definition: table.hxx:216

ScTable::mbForceBreaks
bool mbForceBreaks
Definition: table.hxx:260

ScTable::CompileErrorCells
bool CompileErrorCells(sc::CompileFormulaContext &rCxt, FormulaError nErrCode)
Definition: table2.cxx:2209

ScTable::ColHidden
bool ColHidden(SCCOL nCol, SCCOL *pFirstCol=nullptr, SCCOL *pLastCol=nullptr) const
Definition: table5.cxx:562

ScTable::aLinkDoc
OUString aLinkDoc
Definition: table.hxx:168

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

ScTable::HasColHeader
bool HasColHeader(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow) const
Definition: table3.cxx:2955

ScTable::nTab
SCTAB nTab
Definition: table.hxx:218

ScTable::HasUniformRowHeight
bool HasUniformRowHeight(SCROW nRow1, SCROW nRow2) const
Definition: table7.cxx:255

ScTable::pScenarioRanges
std::unique_ptr< ScRangeList > pScenarioRanges
Definition: table.hxx:235

ScTable::SetRepeatArea
void SetRepeatArea(SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow)
Definition: table5.cxx:1193

ScTable::GetPrintAreaVer
bool GetPrintAreaVer(SCCOL nStartCol, SCCOL nEndCol, SCROW &rEndRow, bool bNotes) const
Definition: table1.cxx:762

ScTable::GetCodeCount
sal_uInt64 GetCodeCount() const
Definition: table3.cxx:3088

ScTable::IsLayoutRTL
bool IsLayoutRTL() const
Definition: table.hxx:366

ScTable::bCalcNotification
bool bCalcNotification
Definition: table.hxx:255

ScTable::pOutlineTable
std::unique_ptr< ScOutlineTable > pOutlineTable
Definition: table.hxx:209

ScTable::SetValue
void SetValue(SCCOL nCol, SCROW nRow, const double &rVal)
Definition: table2.cxx:1763

ScTable::MergePatternArea
void MergePatternArea(ScMergePatternState &rState, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bDeep) const
Definition: table2.cxx:2836

ScTable::RemoveFlags
bool RemoveFlags(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScMF nFlags)
Definition: table2.cxx:3170

ScTable::GetTotalRowHeight
tools::Long GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero=true) const
Definition: table5.cxx:779

ScTable::StartListening
void StartListening(const ScAddress &rAddress, SvtListener *pListener)
Definition: table5.cxx:1206

ScTable::GetPrintRangeCount
sal_uInt16 GetPrintRangeCount() const
Definition: table.hxx:827

ScTable::FirstNonFilteredRow
SCROW FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const
Definition: table5.cxx:944

ScTable::ReleaseNote
std::unique_ptr< ScPostIt > ReleaseNote(SCCOL nCol, SCROW nRow)
Definition: table2.cxx:1890

ScTable::aScenarioColor
Color aScenarioColor
Definition: table.hxx:236

ScTable::FetchVectorRefArray
formula::VectorRefArray FetchVectorRefArray(SCCOL nCol, SCROW nRow1, SCROW nRow2)
Definition: table1.cxx:2534

ScTable::DumpColumnStorage
void DumpColumnStorage(SCCOL nCol) const

ScTable::GetLOKFreezeRow
SCROW GetLOKFreezeRow() const
Definition: table7.cxx:592

ScTable::GetHiddenRowCount
SCROW GetHiddenRowCount(SCROW nRow) const
Definition: table2.cxx:3673

ScTable::HasMultipleDataCells
sc::MultiDataCellState HasMultipleDataCells(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
Definition: table7.cxx:35

ScTable::StartListeners
void StartListeners(sc::StartListeningContext &rCxt, bool bAll)
Either start all formula cells as listeners unconditionally, or start those that are marked "needs li...
Definition: table2.cxx:1252

ScTable::InterpretDirtyCells
void InterpretDirtyCells(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
Definition: table1.cxx:2617

ScTable::IsLinked
bool IsLinked() const
Definition: table.hxx:385

ScTable::SetNumberFormat
void SetNumberFormat(SCCOL nCol, SCROW nRow, sal_uInt32 nNumberFormat)
Definition: table2.cxx:2274

ScTable::aName
OUString aName
Definition: table.hxx:164

ScTable::ReservePatternCount
bool ReservePatternCount(SCCOL nCol, SCSIZE nReserve)
Definition: table4.cxx:3013

ScTable::GetTextWidth
sal_uInt16 GetTextWidth(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:86

ScTable::Compare
short Compare(SCCOLROW nIndex1, SCCOLROW nIndex2) const
Definition: table3.cxx:1762

ScTable::UpdateMoveTab
void UpdateMoveTab(sc::RefUpdateMoveTabContext &rCxt, SCTAB nTabNo, ScProgress *pProgress)
Definition: table1.cxx:2028

ScTable::InvalidateTextWidth
void InvalidateTextWidth(const ScAddress *pAdrFrom, const ScAddress *pAdrTo, bool bNumFormatChanged, bool bBroadcast)
Definition: table5.cxx:1290

ScTable::DestroySortCollator
void DestroySortCollator()
Definition: table3.cxx:644

ScTable::AttachFormulaCells
void AttachFormulaCells(sc::StartListeningContext &rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
Definition: table2.cxx:1272

ScTable::PreprocessRangeNameUpdate
void PreprocessRangeNameUpdate(sc::EndListeningContext &rEndListenCxt, sc::CompileFormulaContext &rCompileCxt)
Definition: table7.cxx:223

ScTable::SetNeedsListeningGroup
void SetNeedsListeningGroup(SCCOL nCol, SCROW nRow)
Definition: table7.cxx:334

ScTable::HasStringData
bool HasStringData(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:2072

ScTable::GetLastFlaggedRow
SCROW GetLastFlaggedRow() const
Definition: table2.cxx:3890

ScTable::SetManualHeight
void SetManualHeight(SCROW nStartRow, SCROW nEndRow, bool bManual)
Definition: table2.cxx:3440

ScTable::CopyOneCellFromClip
void CopyOneCellFromClip(sc::CopyFromClipContext &rCxt, const SCCOL nCol1, const SCROW nRow1, const SCCOL nCol2, const SCROW nRow2, const SCROW nSrcRow, const ScTable *pSrcTab)
Definition: table7.cxx:126

ScTable::IsColRowValid
bool IsColRowValid(const SCCOL nScCol, const SCROW nScRow) const
Definition: table.hxx:348

ScTable::maLOKFreezeCell
ScAddress maLOKFreezeCell
Definition: table.hxx:245

ScTable::IsProtected
bool IsProtected() const
Definition: table5.cxx:1171

ScTable::IsStreamValid
bool IsStreamValid() const
Definition: table.hxx:341

ScTable::SetRawString
void SetRawString(SCCOL nCol, SCROW nRow, const svl::SharedString &rStr)
Definition: table2.cxx:1769

ScTable::GetFilteredFilterEntries
void GetFilteredFilterEntries(SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScQueryParam &rParam, ScFilterEntries &rFilterEntries, bool bFiltering)
Definition: table3.cxx:3023

ScTable::SetColFiltered
void SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, bool bFiltered)
Definition: table5.cxx:936

ScTable::IsSorted
bool IsSorted(SCCOLROW nStart, SCCOLROW nEnd) const
Definition: table3.cxx:1799

ScTable::SetValues
void SetValues(const SCCOL nCol, const SCROW nRow, const std::vector< double > &rVals)
Definition: table7.cxx:179

ScTable::DeleteBeforeCopyFromClip
void DeleteBeforeCopyFromClip(sc::CopyFromClipContext &rCxt, const ScTable &rClipTab, sc::ColumnSpanSet &rBroadcastSpans)
Definition: table7.cxx:98

ScTable::SetRepeatColRange
void SetRepeatColRange(std::optional< ScRange > oNew)
Definition: table1.cxx:2294

ScTable::SetFormulaResults
void SetFormulaResults(SCCOL nCol, SCROW nRow, const double *pResults, size_t nLen)
Definition: table1.cxx:2634

ScTable::GetAnonymousDBData
ScDBData * GetAnonymousDBData()
Definition: table.hxx:401

ScTable::CompileAll
void CompileAll(sc::CompileFormulaContext &rCxt)
Definition: table2.cxx:2186

ScTable::GetTabBgColor
const Color & GetTabBgColor() const
Definition: table.hxx:377

ScTable::GetSolverSettings
SC_DLLPUBLIC std::shared_ptr< sc::SolverSettings > GetSolverSettings()
Definition: table7.cxx:656

ScTable::GetAutoFillPreview
OUString GetAutoFillPreview(const ScRange &rSource, SCCOL nEndX, SCROW nEndY)
Definition: table4.cxx:1296

ScTable::HasHiddenRows
bool HasHiddenRows(SCROW nStartRow, SCROW nEndRow) const
Definition: table5.cxx:547

ScTable::LimitChartArea
void LimitChartArea(SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow) const
Definition: table1.cxx:1271

ScTable::FillFormulaVertical
void FillFormulaVertical(const ScFormulaCell &rSrcCell, SCCOLROW &rInner, SCCOL nCol, SCROW nRow1, SCROW nRow2, ScProgress *pProgress, sal_uInt64 &rProgress)
Definition: table4.cxx:1728

ScTable::GetInputString
OUString GetInputString(SCCOL nCol, SCROW nRow, bool bForceSystemLocale=false) const
Definition: table2.cxx:1791

ScTable::SetError
void SetError(SCCOL nCol, SCROW nRow, FormulaError nError)
Definition: table4.cxx:2933

ScTable::GetNextSpellingCell
bool GetNextSpellingCell(SCCOL &rCol, SCROW &rRow, bool bInSel, const ScMarkData &rMark) const
Definition: table4.cxx:2945

ScTable::dumpSheetGeomData
OString dumpSheetGeomData(bool bColumns, SheetGeomType eGeomType)
Serializes the sheet's geometry data.
Definition: table7.cxx:483

ScTable::FillSparkline
void FillSparkline(bool bVertical, SCCOLROW nFixed, SCCOLROW nIteratingStart, SCCOLROW nIteratingEnd, SCCOLROW nFillStart, SCCOLROW nFillEnd)
Definition: table4.cxx:1245

ScTable::ContainsNotesInRange
bool ContainsNotesInRange(const ScRange &rRange) const
Definition: table2.cxx:2000

ScTable::SetFormula
void SetFormula(SCCOL nCol, SCROW nRow, const ScTokenArray &rArray, formula::FormulaGrammar::Grammar eGram)
Definition: table2.cxx:1718

ScTable::MaybeAddExtraColumn
void MaybeAddExtraColumn(SCCOL &rCol, SCROW nRow, OutputDevice *pDev, double nPPTX, double nPPTY)
In case the cell text goes beyond the column width, move the max column position to the right.
Definition: table1.cxx:2167

ScTable::bLayoutRTL
bool bLayoutRTL
Definition: table.hxx:248

ScTable::GetLastDataPos
void GetLastDataPos(SCCOL &rCol, SCROW &rRow) const
Definition: table2.cxx:2053

ScTable::GetOptimalColWidth
sal_uInt16 GetOptimalColWidth(SCCOL nCol, OutputDevice *pDev, double nPPTX, double nPPTY, const Fraction &rZoomX, const Fraction &rZoomY, bool bFormula, const ScMarkData *pMarkData, const ScColWidthParam *pParam)
Definition: table1.cxx:434

ScTable::TransposeClip
void TransposeClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCROW nCombinedStartRow, SCROW nRowDestOffset, ScTable *pTransClip, InsertDeleteFlags nFlags, bool bAsLink, bool bIncludeFiltered)
Definition: table2.cxx:988

ScTable::SkipFilteredRows
void SkipFilteredRows(SCROW &rRow, SCROW &rLastNonFilteredRow, bool bForward)
Definition: table6.cxx:274

ScTable::ReplaceAll
bool ReplaceAll(const SvxSearchItem &rSearchItem, const ScMarkData &rMark, ScRangeList &rMatchedRanges, OUString &rUndoStr, ScDocument *pUndoDoc, bool &bMatchedRangesWereClamped)
Definition: table6.cxx:584

ScTable::GetTableArea
bool GetTableArea(SCCOL &rEndCol, SCROW &rEndRow, bool bCalcHiddens=false) const
Definition: table1.cxx:580

ScTable::RemoveRowBreak
void RemoveRowBreak(SCROW nRow, bool bPage, bool bManual)
Definition: table5.cxx:411

ScTable::BroadcastRecalcOnRefMove
void BroadcastRecalcOnRefMove()
Broadcast dirty formula cells that contain functions such as CELL(), COLUMN() or ROW() which may chan...
Definition: table2.cxx:2156

ScTable::GetScenarioColor
const Color & GetScenarioColor() const
Definition: table.hxx:375

ScTable::HasAttribSelection
bool HasAttribSelection(const ScMarkData &rMark, HasAttrFlags nMask) const
Definition: table2.cxx:2311

ScTable::GetNeededSize
tools::Long GetNeededSize(SCCOL nCol, SCROW nRow, OutputDevice *pDev, double nPPTX, double nPPTY, const Fraction &rZoomX, const Fraction &rZoomY, bool bWidth, bool bTotalSize, bool bInPrintTwips=false)
Definition: table1.cxx:447

ScTable::HandleStuffAfterParallelCalculation
void HandleStuffAfterParallelCalculation(SCCOL nColStart, SCCOL nColEnd, SCROW nRow, size_t nLen, ScInterpreter *pInterpreter)
Definition: table1.cxx:2659

ScTable::IsSortCollatorGlobal
bool IsSortCollatorGlobal() const
Definition: table3.cxx:622

ScTable::GetSparkline
std::shared_ptr< sc::Sparkline > GetSparkline(SCCOL nCol, SCROW nRow)
Definition: table2.cxx:1848

ScTable::IsVisible
bool IsVisible() const
Definition: table.hxx:338

ScTable::nTableAreaY
SCROW nTableAreaY
Definition: table.hxx:214

ScTable::ScTable
ScTable(ScDocument &rDoc, SCTAB nNewTab, const OUString &rNewName, bool bColInfo=true, bool bRowInfo=true)
Definition: table1.cxx:237

ScTable::TestInsertCol
bool TestInsertCol(SCROW nStartRow, SCROW nEndRow, SCSIZE nSize) const
Definition: table2.cxx:260

ScTable::HasValueData
bool HasValueData(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:2080

ScTable::UpdateCompile
void UpdateCompile(bool bForceIfNameInUse=false)
Definition: table1.cxx:2056

ScTable::DoSubTotals
bool DoSubTotals(ScSubTotalParam &rParam)
Definition: table3.cxx:2119

ScTable::aDefaultColData
ScColumnData aDefaultColData
Definition: table.hxx:268

ScTable::UnshareFormulaCells
void UnshareFormulaCells(SCCOL nCol, std::vector< SCROW > &rRows)
Definition: table7.cxx:276

ScTable::GetColumnData
ScColumnData & GetColumnData(SCCOL nCol)
Definition: table.hxx:312

ScTable::GetWritableColumnsRange
ScColumnsRange GetWritableColumnsRange(SCCOL begin, SCCOL end)
Definition: table1.cxx:2709

ScTable::GetCondFormList
ScConditionalFormatList * GetCondFormList()
Definition: table1.cxx:2696

ScTable::mnEndRow
SCROW mnEndRow
Definition: table.hxx:187

ScTable::dumpColumnRowGroups
OString dumpColumnRowGroups(bool bColumns) const
Returns list-of-spans representation of the column/row groupings encoded as an OString.
Definition: table7.cxx:576

ScTable::DBShowRows
void DBShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
Definition: table2.cxx:3756

ScTable::CreateAllNoteCaptions
void CreateAllNoteCaptions()
Definition: table2.cxx:1929

ScTable::StartOutlineTable
void StartOutlineTable()
Definition: table2.cxx:115

ScTable::SetRowHeightRange
bool SetRowHeightRange(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight, double nPPTY, bool bApi)
Definition: table2.cxx:3373

ScTable::CollectBroadcasterState
void CollectBroadcasterState(sc::BroadcasterState &rState) const
Definition: table7.cxx:650

ScTable::LockTable
void LockTable()
Definition: table2.cxx:2807

ScTable::BroadcastBroadcasters
bool BroadcastBroadcasters(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SfxHintId nHint)
Broadcast single broadcasters in range, without explicitly setting anything dirty,...
Definition: table2.cxx:2163

ScTable::SetProtection
void SetProtection(const ScTableProtection *pProtect)
Definition: table5.cxx:1173

ScTable::InsertRow
void InsertRow(SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize)
Definition: table2.cxx:153

ScTable::EndListeningIntersectedGroups
void EndListeningIntersectedGroups(sc::EndListeningContext &rCxt, const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2, std::vector< ScAddress > *pGroupPos)
Definition: table7.cxx:315

ScTable::bGlobalKeepQuery
bool bGlobalKeepQuery
Definition: table.hxx:256

ScTable::IsLoadingRTL
bool IsLoadingRTL() const
Definition: table.hxx:367

ScTable::HasFilteredRows
bool HasFilteredRows(SCROW nStartRow, SCROW nEndRow) const
Definition: table5.cxx:884

ScTable::ResolveStaticReference
formula::FormulaTokenRef ResolveStaticReference(SCCOL nCol, SCROW nRow)
Definition: table1.cxx:2499

ScTable::ShowRows
void ShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
Definition: table2.cxx:3788

ScTable::SetString
bool SetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString &rString, const ScSetStringParam *pParam=nullptr)
Definition: table2.cxx:1652

ScTable::ApplyBlockFrame
void ApplyBlockFrame(const SvxBoxItem &rLineOuter, const SvxBoxInfoItem *pLineInner, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow)
Definition: table2.cxx:2860

ScTable::SetLoadingMedium
void SetLoadingMedium(bool bLoading)
Definition: table2.cxx:2173

ScTable::RowHidden
bool RowHidden(SCROW nRow, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) const
Definition: table5.cxx:487

ScTable::SortReorderByRow
void SortReorderByRow(ScSortInfoArray *pArray, SCCOL nCol1, SCCOL nCol2, ScProgress *pProgress, bool bOnlyDataAreaExtras)
Definition: table3.cxx:1087

ScTable::GetOutlineTable
ScOutlineTable * GetOutlineTable()
Definition: table.hxx:301

ScTable::HasColManualBreak
bool HasColManualBreak(SCCOL nCol) const
Definition: table5.cxx:387

ScTable::SetRowBreak
void SetRowBreak(SCROW nRow, bool bPage, bool bManual)
Definition: table5.cxx:441

ScTable::DBShowRow
void DBShowRow(SCROW nRow, bool bShow)
Definition: table2.cxx:3730

ScTable::GetRowFlagsArray
const ScBitMaskCompressedArray< SCROW, CRFlags > * GetRowFlagsArray() const
Definition: table.hxx:935

ScTable::RemoveManualBreaks
void RemoveManualBreaks()
Definition: table5.cxx:311

ScTable::nRepeatEndX
SCCOL nRepeatEndX
Definition: table.hxx:179

ScTable::aPrintRanges
ScRangeVec aPrintRanges
Definition: table.hxx:228

ScTable::IsEmptyData
bool IsEmptyData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow) const
Definition: table1.cxx:1197

ScTable::maRowManualBreaks
::std::set< SCROW > maRowManualBreaks
Definition: table.hxx:205

ScTable::GetEmptyLinesInBlock
SCSIZE GetEmptyLinesInBlock(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScDirection eDir) const
Definition: table1.cxx:1206

ScTable::GetNextManualBreak
SCROW GetNextManualBreak(SCROW nRow) const
Get the row position of the next manual break that occurs at or below specified row.
Definition: table5.cxx:395

ScTable::mbCellAreaEmpty
bool mbCellAreaEmpty
Definition: table.hxx:185

ScTable::FillFormula
void FillFormula(const ScFormulaCell *pSrcCell, SCCOL nDestCol, SCROW nDestRow, bool bLast)
Definition: table4.cxx:772

ScTable::GetOptimalMinRowHeight
sal_uInt16 GetOptimalMinRowHeight() const
Definition: table.hxx:879

ScTable::SetAnonymousDBData
void SetAnonymousDBData(std::unique_ptr< ScDBData > pDBData)
Definition: table1.cxx:2455

ScTable::LastNonFilteredRow
SCROW LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const
Definition: table5.cxx:967

ScTable::SetPendingRowHeights
void SetPendingRowHeights(bool bSet)
Definition: table1.cxx:390

ScTable::mpColWidth
std::unique_ptr< ScCompressedArray< SCCOL, sal_uInt16 > > mpColWidth
Definition: table.hxx:194

ScTable::RestoreFromCache
void RestoreFromCache(SvStream &rStrm)
Definition: table7.cxx:473

ScTable::GetLinkFlt
const OUString & GetLinkFlt() const
Definition: table.hxx:387

ScTable::ShrinkToUsedDataArea
bool ShrinkToUsedDataArea(bool &o_bShrunk, SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow, bool bColumnsOnly, bool bStickyTopRow, bool bStickyLeftCol, ScDataAreaExtras *pDataAreaExtras) const
Definition: table1.cxx:1055

ScTable::CreateSparkline
sc::Sparkline * CreateSparkline(SCCOL nCol, SCROW nRow, std::shared_ptr< sc::SparklineGroup > const &pSparklineGroup)
Definition: table2.cxx:1860

ScTable::aComment
OUString aComment
Definition: table.hxx:166

ScTable::CopyFromClip
void CopyFromClip(sc::CopyFromClipContext &rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCCOL nDx, SCROW nDy, ScTable *pTable)
Definition: table2.cxx:724

ScTable::GetAllocatedColumnsCount
SCCOL GetAllocatedColumnsCount() const
Definition: table.hxx:1164

ScTable::CopyColFiltered
void CopyColFiltered(const ScTable &rTable, SCCOL nStartCol, SCCOL nEndCol)
Definition: table5.cxx:899

ScTable::GetLinkOpt
const OUString & GetLinkOpt() const
Definition: table.hxx:388

ScTable::CopyToClip
void CopyToClip(sc::CopyToClipContext &rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable *pTable)
Definition: table2.cxx:492

ScTable::SetVisible
void SetVisible(bool bVis)
Definition: table1.cxx:374

ScTable::nRepeatStartY
SCROW nRepeatStartY
Definition: table.hxx:180

ScTable::GetDoc
const ScDocument & GetDoc() const
Definition: table.hxx:298

ScTable::InitColumnBlockPosition
bool InitColumnBlockPosition(sc::ColumnBlockPosition &rBlockPos, SCCOL nCol)
Definition: table2.cxx:713

ScTable::GetFormula
OUString GetFormula(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:1822

ScTable::GetHashCode
sal_Int64 GetHashCode() const
Definition: table1.cxx:354

ScTable::aCodeName
OUString aCodeName
Definition: table.hxx:165

ScTable::GetDataAreaSubrange
bool GetDataAreaSubrange(ScRange &rRange) const
Definition: table1.cxx:1014

ScTable::SetOptimalHeightOnly
void SetOptimalHeightOnly(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, ScProgress *pOuterProgress=nullptr, sal_uInt64 nProgressStart=0)
Definition: table1.cxx:497

ScTable::ConvertFormulaToValue
void ConvertFormulaToValue(sc::EndListeningContext &rCxt, const SCCOL nCol1, const SCROW nRow1, const SCCOL nCol2, const SCROW nRow2, sc::TableValues *pUndo)
Definition: table7.cxx:203

ScTable::SetDirtyFromClip
void SetDirtyFromClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sc::ColumnSpanSet &rBroadcastSpans)
Definition: table2.cxx:1288

ScTable::ExtendPrintArea
void ExtendPrintArea(OutputDevice *pDev, SCCOL nStartCol, SCROW nStartRow, SCCOL &rEndCol, SCROW nEndRow)
Definition: table1.cxx:2078

ScTable::ResetChanged
void ResetChanged(const ScRange &rRange)
Definition: table2.cxx:2227

ScTable::SplitFormulaGroups
void SplitFormulaGroups(SCCOL nCol, std::vector< SCROW > &rRows)
Definition: table7.cxx:268

ScTable::SetLayoutRTL
void SetLayoutRTL(bool bSet)
Definition: table1.cxx:395

ScTable::AddCondFormat
sal_uLong AddCondFormat(std::unique_ptr< ScConditionalFormat > pNew)
Definition: table1.cxx:2460

ScTable::CreateQueryParam
bool CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam &rQueryParam)
Definition: table3.cxx:2915

ScTable::SetRowHeightOnly
void SetRowHeightOnly(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight)
Set specified row height to specified ranges.
Definition: table2.cxx:3429

ScTable::UpdatePageBreaks
void UpdatePageBreaks(const ScRange *pUserArea)
Definition: table5.cxx:59

ScTable::EnsureFormulaCellResults
bool EnsureFormulaCellResults(const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2, bool bSkipRunning=false)
Definition: table7.cxx:431

ScTable::InvalidateScenarioRanges
void InvalidateScenarioRanges()
Definition: table2.cxx:1620

ScTable::SwapNonEmpty
void SwapNonEmpty(sc::TableValues &rValues, sc::StartListeningContext &rStartCxt, sc::EndListeningContext &rEndCxt)
Definition: table7.cxx:214

ScTable::GetRowFlags
CRFlags GetRowFlags(SCROW nRow) const
Definition: table2.cxx:3882

ScTable::aLinkOpt
OUString aLinkOpt
Definition: table.hxx:170

ScTable::CompileColRowNameFormula
void CompileColRowNameFormula(sc::CompileFormulaContext &rCxt)
Definition: table4.cxx:2991

ScTable::mpHiddenRows
std::unique_ptr< ScFlatBoolRowSegments > mpHiddenRows
Definition: table.hxx:200

ScTable::GetTab
SCTAB GetTab() const
Definition: table.hxx:299

ScTable::finalizeOutlineImport
void finalizeOutlineImport()
Definition: table7.cxx:449

ScTable::UpdateSearchItemAddressForReplace
static void UpdateSearchItemAddressForReplace(const SvxSearchItem &rSearchItem, SCCOL &rCol, SCROW &rRow)
Replace behaves differently to the Search; adjust the rCol and rRow accordingly.
Definition: table6.cxx:550

ScTable::maSparklineList
sc::SparklineList maSparklineList
Definition: table.hxx:243

ScTable::GetScenarioFlags
ScScenarioFlags GetScenarioFlags() const
Definition: table.hxx:379

ScTable::SortReorderByRowRefUpdate
void SortReorderByRowRefUpdate(ScSortInfoArray *pArray, SCCOL nCol1, SCCOL nCol2, ScProgress *pProgress)
Definition: table3.cxx:1249

ScTable::RowFiltered
bool RowFiltered(SCROW nRow, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) const
Definition: table5.cxx:848

ScTable::QueryColumnsWithFormulaCells
std::set< SCCOL > QueryColumnsWithFormulaCells() const
Definition: table7.cxx:631

ScTable::GetSharedString
svl::SharedString GetSharedString(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:1755

ScTable::PreprocessDBDataUpdate
void PreprocessDBDataUpdate(sc::EndListeningContext &rEndListenCxt, sc::CompileFormulaContext &rCompileCxt)
Definition: table7.cxx:230

ScTable::HasStringCells
bool HasStringCells(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow) const
Definition: table2.cxx:2088

ScTable::mpRowHeights
std::unique_ptr< ScFlatUInt16RowSegments > mpRowHeights
Definition: table.hxx:195

ScTable::CountVisibleRows
SCROW CountVisibleRows(SCROW nStartRow, SCROW nEndRow) const
Definition: table5.cxx:758

ScTable::GetCellBackgroundColor
Color GetCellBackgroundColor(ScAddress aPos) const
Definition: table5.cxx:1011

ScTable::GetCellType
CellType GetCellType(const ScAddress &rPos) const
Definition: table.hxx:487

ScTable::SetScenarioComment
void SetScenarioComment(const OUString &rComment)
Definition: table.hxx:374

ScTable::TransferCellValuesTo
void TransferCellValuesTo(const SCCOL nCol, SCROW nRow, size_t nLen, sc::CellValues &rDest)
Definition: table7.cxx:187

ScTable::IsSelectionEditable
bool IsSelectionEditable(const ScMarkData &rMark, bool *pOnlyNotBecauseOfMatrix=nullptr) const
Definition: table2.cxx:2723

ScTable::MixMarked
void MixMarked(sc::MixDocContext &rCxt, const ScMarkData &rMark, ScPasteFunc nFunction, bool bSkipEmpty, const ScTable *pSrcTab)
Definition: table2.cxx:794

ScTable::ForgetNoteCaptions
void ForgetNoteCaptions(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bPreserveData)
Definition: table2.cxx:1935

ScTable::FillMaxRot
SCSIZE FillMaxRot(RowInfo *pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2, SCCOL nCol, SCROW nAttrRow1, SCROW nAttrRow2, SCSIZE nArrY, const ScPatternAttr *pPattern, const SfxItemSet *pCondSet)
Definition: table2.cxx:2384

ScTable::GetNextMarkedCell
bool GetNextMarkedCell(SCCOL &rCol, SCROW &rRow, const ScMarkData &rMark) const
Definition: table1.cxx:1763

ScTable::GetSparklineList
sc::SparklineList & GetSparklineList()
Definition: table2.cxx:1883

ScTable::mpRangeName
std::unique_ptr< ScRangeName > mpRangeName
Definition: table.hxx:240

ScTable::RemoveSubTotals
void RemoveSubTotals(ScSubTotalParam &rParam)
Definition: table3.cxx:2016

ScTable::GetRangeScriptType
SvtScriptType GetRangeScriptType(sc::ColumnBlockPosition &rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2)
Definition: table1.cxx:2489

ScTable::RemoveColBreak
void RemoveColBreak(SCCOL nCol, bool bPage, bool bManual)
Definition: table5.cxx:426

ScTable::AutoFormatArea
void AutoFormatArea(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScPatternAttr &rAttr, sal_uInt16 nFormatNo)
Definition: table4.cxx:2641

ScTable::Replace
bool Replace(const SvxSearchItem &rSearchItem, SCCOL &rCol, SCROW &rRow, const ScMarkData &rMark, OUString &rUndoStr, ScDocument *pUndoDoc)
Definition: table6.cxx:568

ScTable::GetMaxStringLen
sal_Int32 GetMaxStringLen(SCCOL nCol, SCROW nRowStart, SCROW nRowEnd, rtl_TextEncoding eCharSet) const
Definition: table3.cxx:3099

ScTable::nScenarioFlags
ScScenarioFlags nScenarioFlags
Definition: table.hxx:238

ScTable::GetBroadcaster
SvtBroadcaster * GetBroadcaster(SCCOL nCol, SCROW nRow)
Definition: table1.cxx:2586

ScTable::InvalidateCellArea
void InvalidateCellArea()
Definition: table.hxx:623

ScTable::GetPattern
const ScPatternAttr * GetPattern(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:2282

ScTable::aSortParam
ScSortParam aSortParam
Definition: table.hxx:225

ScTable::SetOptimalHeight
bool SetOptimalHeight(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, bool bApi, ScProgress *pOuterProgress=nullptr, sal_uInt64 nProgressStart=0)
Definition: table1.cxx:464

ScTable::ScRangeVec
::std::vector< ScRange > ScRangeVec
Definition: table.hxx:160

ScTable::CopyCellValuesFrom
void CopyCellValuesFrom(const SCCOL nCol, SCROW nRow, const sc::CellValues &rSrc)
Definition: table7.cxx:195

ScTable::ExtendHidden
void ExtendHidden(SCCOL &rX1, SCROW &rY1, SCCOL &rX2, SCROW &rY2)
Definition: table2.cxx:3969

ScTable::nTableAreaVisibleX
SCCOL nTableAreaVisibleX
Definition: table.hxx:215

ScTable::FindRangeNamesInUse
void FindRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sc::UpdatedRangeNames &rIndexes) const
Definition: table1.cxx:2071

ScTable::SetCalcNotification
void SetCalcNotification(bool bSet)
Definition: table2.cxx:130

ScTable::GetAttr
const SfxPoolItem * GetAttr(SCCOL nCol, SCROW nRow, sal_uInt16 nWhich) const
Definition: table2.cxx:2240

ScTable::GetMaxNumberStringLen
sal_Int32 GetMaxNumberStringLen(sal_uInt16 &nPrecision, SCCOL nCol, SCROW nRowStart, SCROW nRowEnd) const
Definition: table3.cxx:3108

ScTable::CompileHybridFormula
void CompileHybridFormula(sc::StartListeningContext &rStartListenCxt, sc::CompileFormulaContext &rCompileCxt)
Definition: table7.cxx:237

ScTable::GetColOffset
tools::Long GetColOffset(SCCOL nCol, bool bHiddenAsZero=true) const
Definition: table2.cxx:4355

ScTable::SetScenario
void SetScenario(bool bFlag)
Definition: table1.cxx:415

ScTable::IsPrintEntireSheet
bool IsPrintEntireSheet() const
Returns true, if the sheet is always printed.
Definition: table.hxx:830

ScTable::CopyPrintRange
void CopyPrintRange(const ScTable &rTable)
Definition: table1.cxx:2267

ScTable::SetPrintEntireSheet
void SetPrintEntireSheet()
Marks the specified sheet to be printed completely.
Definition: table1.cxx:2333

ScTable::bPrintEntireSheet
bool bPrintEntireSheet
Definition: table.hxx:257

ScTable::ClampToAllocatedColumns
SCCOL ClampToAllocatedColumns(SCCOL nCol) const
Definition: table.hxx:1163

ScTable::GetProtection
const ScTableProtection * GetProtection() const
Definition: table5.cxx:1183

ScTable::GetCellCount
sal_uInt64 GetCellCount() const
Definition: table3.cxx:3058

ScTable::EndListeningIntersectedGroup
void EndListeningIntersectedGroup(sc::EndListeningContext &rCxt, SCCOL nCol, SCROW nRow, std::vector< ScAddress > *pGroupPos)
Definition: table7.cxx:306

ScTable::rDocument
ScDocument & rDocument
Definition: table.hxx:219

ScTable::RegroupFormulaCells
void RegroupFormulaCells(SCCOL nCol)
Definition: table7.cxx:284

ScTable::SetPattern
void SetPattern(const ScAddress &rPos, const ScPatternAttr &rAttr)
Definition: table2.cxx:3182

ScTable::SetColManualBreaks
void SetColManualBreaks(::std::set< SCCOL > &&rBreaks)
Definition: table5.cxx:332

ScTable::SetActiveScenario
void SetActiveScenario(bool bSet)
Definition: table.hxx:381

ScTable::StripHidden
void StripHidden(SCCOL &rX1, SCROW &rY1, SCCOL &rX2, SCROW &rY2)
Definition: table2.cxx:3999

ScTable::FindNextVisibleColWithContent
SCCOL FindNextVisibleColWithContent(SCCOL nCol, bool bRight, SCROW nRow) const
Definition: table1.cxx:1320

ScTable::ApplyFlags
bool ApplyFlags(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScMF nFlags)
Definition: table2.cxx:3160

ScTable::CopyColHidden
void CopyColHidden(const ScTable &rTable, SCCOL nStartCol, SCCOL nEndCol)
Definition: table5.cxx:663

ScTable::GetFirstEditTextRow
SCROW GetFirstEditTextRow(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
Definition: table2.cxx:1683

ScTable::GetScenarioRanges
const ScRangeList * GetScenarioRanges() const
Definition: table2.cxx:1625

ScTable::GetFilterEntries
void GetFilterEntries(SCCOL nCol, SCROW nRow1, SCROW nRow2, ScFilterEntries &rFilterEntries, bool bFiltering=false)
Definition: table3.cxx:3013

ScTable::SetScenarioColor
void SetScenarioColor(const Color &rNew)
Definition: table.hxx:376

ScTable::MarkScenarioIn
void MarkScenarioIn(ScMarkData &rMark, ScScenarioFlags nNeededBits) const
Definition: table2.cxx:1586

ScTable::GetScenarioComment
void GetScenarioComment(OUString &rComment) const
Definition: table.hxx:373

ScTable::Reorder
void Reorder(const sc::ReorderParam &rParam)
Definition: table3.cxx:1907

ScTable::GetScriptType
SvtScriptType GetScriptType(SCCOL nCol, SCROW nRow) const
Definition: table1.cxx:2473

ScTable::ValidNextPos
bool ValidNextPos(SCCOL nCol, SCROW nRow, const ScMarkData &rMark, bool bMarked, bool bUnprotected) const
Definition: table1.cxx:1445

ScTable::HasManualBreaks
bool HasManualBreaks() const
Definition: table5.cxx:320

ScTable::IsManualRowHeight
bool IsManualRowHeight(SCROW nRow) const
Definition: table5.cxx:1083

ScTable::GetDoc
ScDocument & GetDoc()
Definition: table.hxx:297

ScTable::ReplaceAllStyle
bool ReplaceAllStyle(const SvxSearchItem &rSearchItem, const ScMarkData &rMark, ScRangeList &rMatchedRanges, ScDocument *pUndoDoc)
Definition: table6.cxx:773

ScTable::StoreToCache
void StoreToCache(SvStream &rStrm) const
Definition: table7.cxx:457

ScTable::GetCellTextColor
Color GetCellTextColor(ScAddress aPos) const
Definition: table5.cxx:1052

ScTable::GetNextPos
void GetNextPos(SCCOL &rCol, SCROW &rRow, SCCOL nMovX, SCROW nMovY, bool bMarked, bool bUnprotected, const ScMarkData &rMark, SCCOL nTabStartCol) const
Definition: table1.cxx:1518

ScTable::GetLastDataRow
SCROW GetLastDataRow(SCCOL nCol1, SCCOL nCol2, SCROW nLastRow, ScDataAreaExtras *pDataAreaExtras=nullptr) const
Definition: table1.cxx:1179

ScTable::dumpHiddenFiltered
OString dumpHiddenFiltered(bool bColumns, bool bHidden)
Returns list-of-spans representation of hidden/filtered states of columns/rows encoded as an OString.
Definition: table7.cxx:556

ScTable::GetUpperCellString
OUString GetUpperCellString(SCCOL nCol, SCROW nRow)
Definition: table2.cxx:4214

ScTable::ApplySelectionStyle
void ApplySelectionStyle(const ScStyleSheet &rStyle, const ScMarkData &rMark)
Definition: table2.cxx:3044

ScTable::GetValue
double GetValue(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:1799

ScTable::GetCodeName
const OUString & GetCodeName() const
Definition: table.hxx:403

ScTable::GetPrintRange
const ScRange * GetPrintRange(sal_uInt16 nPos) const
Definition: table1.cxx:2342

ScTable::SetSheetEvents
void SetSheetEvents(std::unique_ptr< ScSheetEvents > pNew)
Definition: table2.cxx:121

ScTable::SetName
void SetName(const OUString &rNewName)
Definition: table1.cxx:359

ScTable::CopyCaptionsToTable
void CopyCaptionsToTable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable *pDestTab, bool bCloneCaption)
Definition: table2.cxx:1484

ScTable::DeleteBroadcasters
void DeleteBroadcasters(sc::ColumnBlockPosition &rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2)
Definition: table1.cxx:2594

ScTable::RefVisible
bool RefVisible(const ScFormulaCell *pCell)
Definition: table2.cxx:4192

ScTable::GetRowForHeight
SCROW GetRowForHeight(tools::Long nHeight) const
Get the last row such that the height of row 0 to the end row is as high as possible without exceedin...
Definition: table2.cxx:4288

ScTable::ApplyPatternIfNumberformatIncompatible
void ApplyPatternIfNumberformatIncompatible(const ScRange &rRange, const ScPatternAttr &rPattern, SvNumFormatType nNewType)
Definition: table2.cxx:2945

ScTable::DeleteArea
void DeleteArea(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, InsertDeleteFlags nDelFlag, bool bBroadcast=true, sc::ColumnSpanSet *pBroadcastSpans=nullptr)
Definition: table2.cxx:424

ScTable::SetLOKFreezeCol
bool SetLOKFreezeCol(SCCOL nFreezeCol)
Definition: table7.cxx:597

ScTable::StartListeningFormulaCells
void StartListeningFormulaCells(sc::StartListeningContext &rStartCxt, sc::EndListeningContext &rEndCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
Definition: table2.cxx:1299

ScTable::SetLOKFreezeRow
bool SetLOKFreezeRow(SCROW nFreezeRow)
Definition: table7.cxx:614

ScTable::CopySparklinesToTable
void CopySparklinesToTable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable *pDestTab)
Definition: table2.cxx:1472

ScTable::TestTabRefAbs
void TestTabRefAbs(SCTAB nTable) const
Definition: table4.cxx:2978

ScTable::SetScenarioFlags
void SetScenarioFlags(ScScenarioFlags nNew)
Definition: table.hxx:380

ScTable::GetLastChangedRowFlagsWidth
SCROW GetLastChangedRowFlagsWidth() const
Definition: table2.cxx:3934

ScTable::pTabProtection
std::unique_ptr< ScTableProtection > pTabProtection
Definition: table.hxx:192

ScTable::IncDate
void IncDate(double &rVal, sal_uInt16 &nDayOfMonth, double nStep, FillDateCmd eCmd)
Definition: table4.cxx:1599

ScTable::ClearSelectionItems
void ClearSelectionItems(const sal_uInt16 *pWhich, const ScMarkData &rMark)
Definition: table2.cxx:3254

ScTable::UpdateOutlineRow
bool UpdateOutlineRow(SCROW nStartRow, SCROW nEndRow, bool bShow)
Definition: table2.cxx:3961

ScTable::GetName
const OUString & GetName() const
Definition: table.hxx:397

ScTable::CopyRowHidden
void CopyRowHidden(const ScTable &rTable, SCROW nStartRow, SCROW nEndRow)
Definition: table5.cxx:678

ScTable::InitSortCollator
void InitSortCollator(const ScSortParam &rPar)
Definition: table3.cxx:628

ScTable::maColPageBreaks
::std::set< SCCOL > maColPageBreaks
Definition: table.hxx:206

ScTable::IsStyleSheetUsed
bool IsStyleSheetUsed(const ScStyleSheet &rStyle) const
Definition: table2.cxx:3119

ScTable::GetFirstDataPos
void GetFirstDataPos(SCCOL &rCol, SCROW &rRow) const
Definition: table2.cxx:2038

ScTable::moRepeatColRange
std::optional< ScRange > moRepeatColRange
Definition: table.hxx:230

ScTable::CompareCell
short CompareCell(sal_uInt16 nSort, ScRefCellValue &rCell1, SCCOL nCell1Col, SCROW nCell1Row, ScRefCellValue &rCell2, SCCOL nCell2Col, SCROW nCell2Row) const
Definition: table3.cxx:1525

ScTable::SetTabNo
void SetTabNo(SCTAB nNewTab)
Definition: table1.cxx:2064

ScTable::TopTenQuery
void TopTenQuery(ScQueryParam &)
Definition: table3.cxx:2381

ScTable::HasRowManualBreak
bool HasRowManualBreak(SCROW nRow) const
Definition: table5.cxx:379

ScTable::Search
bool Search(const SvxSearchItem &rSearchItem, SCCOL &rCol, SCROW &rRow, const ScMarkData &rMark, OUString &rUndoStr, ScDocument *pUndoDoc)
Definition: table6.cxx:310

ScTable::CalcAfterLoad
void CalcAfterLoad(sc::CompileFormulaContext &rCxt, bool bStartListening)
Definition: table2.cxx:2221

ScTable::SetPageStyle
void SetPageStyle(const OUString &rName)
Definition: table5.cxx:1242

ScTable::bStreamValid
std::atomic< bool > bStreamValid
this is touched from formula group threading context
Definition: table.hxx:262

ScTable::SetRowManualBreaks
void SetRowManualBreaks(::std::set< SCROW > &&rBreaks)
Definition: table5.cxx:325

ScTable::ChangeSelectionIndent
void ChangeSelectionIndent(bool bIncrement, const ScMarkData &rMark)
Definition: table2.cxx:3231

ScTable::GetNotePosition
SCROW GetNotePosition(SCCOL nCol, size_t nIndex) const
Definition: table2.cxx:1921

ScTable::DeleteEmptyBroadcasters
void DeleteEmptyBroadcasters()
Definition: table1.cxx:2603

ScTable::GetValueCell
double * GetValueCell(SCCOL nCol, SCROW nRow)
Definition: table2.cxx:1783

ScTable::IsMerged
bool IsMerged(SCCOL nCol, SCROW nRow) const
Definition: table7.cxx:27

ScTable::GetAutoFormatData
void GetAutoFormatData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScAutoFormatData &rData)
Definition: table4.cxx:2861

ScTable::SetEmptyCell
void SetEmptyCell(SCCOL nCol, SCROW nRow)
Definition: table2.cxx:1710

ScTable::pSearchText
std::unique_ptr< utl::TextSearch > pSearchText
Definition: table.hxx:220

ScTable::InsertCol
void InsertCol(const sc::ColumnSet &rRegroupCols, SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize)
Definition: table2.cxx:277

ScTable::ClearPrintRanges
void ClearPrintRanges()
Removes all print ranges.
Definition: table1.cxx:2312

ScTable::pSheetEvents
std::unique_ptr< ScSheetEvents > pSheetEvents
Definition: table.hxx:211

ScTable::ValidRow
bool ValidRow(SCROW nRow) const
Definition: table.hxx:357

ScTable::SearchRangeForEmptyCell
bool SearchRangeForEmptyCell(const ScRange &rRange, const SvxSearchItem &rSearchItem, SCCOL &rCol, SCROW &rRow, OUString &rUndoStr)
Definition: table6.cxx:964

ScTable::mbCellAreaDirty
bool mbCellAreaDirty
Definition: table.hxx:184

ScTable::ApplyPatternArea
void ApplyPatternArea(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScPatternAttr &rAttr, ScEditDataArray *pDataArray=nullptr, bool *const pIsChanged=nullptr)
Definition: table2.cxx:2880

ScTable::Query
SCSIZE Query(const ScQueryParam &rQueryParam, bool bKeepSub)
Definition: table3.cxx:2628

ScTable::ApplyPattern
void ApplyPattern(SCCOL nCol, SCROW nRow, const ScPatternAttr &rAttr)
Definition: table2.cxx:2874

ScTable::SetRepeatRowRange
void SetRepeatRowRange(std::optional< ScRange > oNew)
Definition: table1.cxx:2303

ScTable::GetLinkDoc
const OUString & GetLinkDoc() const
Definition: table.hxx:386

ScTable::SearchCell
bool SearchCell(const SvxSearchItem &rSearchItem, SCCOL nCol, sc::ColumnBlockConstPosition &rBlockPos, SCROW nRow, const ScMarkData &rMark, OUString &rUndoStr, ScDocument *pUndoDoc)
Definition: table6.cxx:47

ScTable::SetOptimalMinRowHeight
void SetOptimalMinRowHeight(sal_uInt16 nSet)
Definition: table.hxx:885

ScTable::TestRemoveSubTotals
bool TestRemoveSubTotals(const ScSubTotalParam &rParam)
Definition: table3.cxx:1982

ScTable::GetNotesInRange
void GetNotesInRange(const ScRange &rRange, std::vector< sc::NoteEntry > &rNotes) const
Definition: table2.cxx:1950

ScTokenArray
Definition: tokenarray.hxx:49

ScUserListData
Stores individual user-defined sort list.
Definition: userlist.hxx:32

ScValueIterator
Definition: dociter.hxx:52

SfxItemSet

SfxPoolItem

SfxStyleSheetBase

Size

SvStream

SvtBroadcaster

SvtListener

SvxBoxInfoItem

SvxBoxItem

SvxSearchItem

TextSearch

TypedWhichId

formula::FormulaGrammar::Grammar
Grammar

o3tl::sorted_vector< sal_uInt32 >

sc::CellValues
Think of this as a mini-ScColumn like storage that only stores cell values in a column.
Definition: cellvalues.hxx:42

sc::ColumnSet
Simple container to keep track of sheet - column pair.
Definition: columnset.hxx:24

sc::ColumnSpanSet
Structure that stores segments of boolean flags per column, and perform custom action on those segmen...
Definition: columnspanset.hxx:50

sc::CompileFormulaContext
Definition: tokenstringcontext.hxx:49

sc::CopyFromClipContext
Definition: clipcontext.hxx:48

sc::CopyToClipContext
Definition: clipcontext.hxx:162

sc::CopyToDocContext
Definition: clipcontext.hxx:173

sc::DocumentStreamAccess
Provides methods to allow direct shifting of document content without broadcasting or shifting of bro...
Definition: documentstreamaccess.hxx:28

sc::EditTextIterator
Iterate through all edit text cells in a given sheet.
Definition: edittextiterator.hxx:28

sc::EndListeningContext
Definition: listenercontext.hxx:44

sc::FormulaGroupAreaListener
Definition: grouparealistener.hxx:27

sc::MixDocContext
Definition: clipcontext.hxx:185

sc::RangeColumnSpanSet
Optimized ColumnSpanSet version that operates on a single ScRange.
Definition: columnspanset.hxx:163

sc::RowHeightContext
Definition: rowheightcontext.hxx:26

sc::SparklineList
Tracks and gathers all created sparklines and sparkline groups.
Definition: SparklineList.hxx:28

sc::Sparkline
Sparkline data, used for rendering the content of a cell.
Definition: Sparkline.hxx:29

sc::StartListeningContext
Definition: listenercontext.hxx:26

sc::TableValues
Stores cell values for multiple tables.
Definition: cellvalues.hxx:89

sc::UpdatedRangeNames
Keep track of all named expressions that have been updated during reference update.
Definition: refupdatecontext.hxx:33

svl::SharedString

tools::Duration

colcontainer.hxx

color.hxx

column.hxx

nPPTX
constexpr double nPPTX
Definition: datatableview.cxx:33

nPPTY
constexpr double nPPTY
Definition: datatableview.cxx:34

document.hxx

SheetGeomType
SheetGeomType
Represents the type of sheet geometry data.
Definition: document.hxx:277

CommentCaptionState
CommentCaptionState
Definition: document.hxx:263

drwlayer.hxx

ScObjectHandling
ScObjectHandling
Definition: drwlayer.hxx:91

ScObjectHandling::RecalcPosMode
@ RecalcPosMode

errorcodes.hxx

FormulaError
FormulaError

gen.hxx

ScMoveDirection
ScMoveDirection
Definition: global.hxx:326

CellType
CellType
Definition: global.hxx:272

CELLTYPE_NONE
@ CELLTYPE_NONE
Definition: global.hxx:273

UpdateRefMode
UpdateRefMode
Definition: global.hxx:301

ScPasteFunc
ScPasteFunc
Definition: global.hxx:181

InsertDeleteFlags
InsertDeleteFlags
Definition: global.hxx:149

HasAttrFlags
HasAttrFlags
Definition: global.hxx:185

FillDateCmd
FillDateCmd
Definition: global.hxx:334

ScLinkMode
ScLinkMode
Definition: global.hxx:215

ScLinkMode::NONE
@ NONE

ScScenarioFlags
ScScenarioFlags
Definition: global.hxx:226

ScDirection
ScDirection
Definition: global.hxx:343

CRFlags
CRFlags
Definition: global.hxx:125

FillCmd
FillCmd
Definition: global.hxx:317

FillDir
FillDir
Definition: global.hxx:309

SfxHintId
SfxHintId

SvtScriptType
SvtScriptType

com::sun::star

formula

formula::FormulaTokenRef
::boost::intrusive_ptr< FormulaToken > FormulaTokenRef

sc
CAUTION! The following defines must be in the same namespace as the respective type.
Definition: broadcast.cxx:15

sc::ColRowEditAction
ColRowEditAction
Definition: global.hxx:427

tools::Long
long Long

utl

nType
QPRO_FUNC_TYPE nType
Definition: qproform.cxx:398

SC_DLLPUBLIC
#define SC_DLLPUBLIC
Definition: scdllapi.h:27

sal_uLong
sal_uIntPtr sal_uLong

sortparam.hxx

OutputDevice

RowInfo
Definition: fillinfo.hxx:192

ScCellValue
Store arbitrary cell value of any kind.
Definition: cellvalue.hxx:32

ScColWidthParam
Definition: docparam.hxx:18

ScDataAreaExtras
Struct to hold non-data extended area, used with ScDocument::ShrinkToUsedDataArea().
Definition: sortparam.hxx:53

ScFilterEntries
Definition: filterentries.hxx:18

ScInterpreterContext
Definition: interpretercontext.hxx:54

ScLineFlags
Definition: attarray.hxx:55

ScMergePatternState
Definition: attarray.hxx:68

ScQueryParam
Definition: queryparam.hxx:134

ScRefCellValue
This is very similar to ScCellValue, except that it references the original value instead of copying ...
Definition: cellvalue.hxx:108

ScSetStringParam
Store parameters used in the ScDocument::SetString() method.
Definition: stringutil.hxx:35

ScSortParam
Definition: sortparam.hxx:113

ScSubTotalParam
Definition: subtotalparam.hxx:16

SfxItemPoolCache

SfxItemPool

formula::VectorRefArray

sc::BroadcasterState
Definition: broadcast.hxx:26

sc::ColumnBlockConstPosition
Definition: mtvelements.hxx:169

sc::ColumnBlockPosition
Store position data for column array storage.
Definition: mtvelements.hxx:158

sc::MultiDataCellState
Definition: types.hxx:98

sc::RefUpdateContext
Context for reference update during shifting, moving or copying of cell ranges.
Definition: refupdatecontext.hxx:53

sc::RefUpdateDeleteTabContext
Definition: refupdatecontext.hxx:130

sc::RefUpdateInsertTabContext
Definition: refupdatecontext.hxx:120

sc::RefUpdateMoveTabContext
Definition: refupdatecontext.hxx:140

sc::ReorderParam
Definition: sortparam.hxx:154

sc::SetFormulaDirtyContext
Definition: refupdatecontext.hxx:152

svl::SharedStringPool

types.hxx

SCCOLROW
sal_Int32 SCCOLROW
a type capable of holding either SCCOL or SCROW
Definition: types.hxx:23

SCTAB
sal_Int16 SCTAB
Definition: types.hxx:22

ScFormulaCellGroupRef
::boost::intrusive_ptr< ScFormulaCellGroup > ScFormulaCellGroupRef
Definition: types.hxx:43

SCCOL
sal_Int16 SCCOL
Definition: types.hxx:21

SCROW
sal_Int32 SCROW
Definition: types.hxx:17

SvNumFormatType
SvNumFormatType

SvNumberFormatterMergeMap
std::unordered_map< sal_uInt32, sal_uInt32 > SvNumberFormatterMergeMap