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

 #include <vector>

 #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 <optional>

 #include <set>

 #include <memory>


 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 {


 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

     {

         std::vector<std::unique_ptr<ScColumn, o3tl::default_delete<ScColumn>>>::const_iterator maColIter;

     public:

         typedef std::input_iterator_tag iterator_category;

         typedef SCCOL value_type;

         typedef SCCOL difference_type;

         typedef const SCCOL* pointer;

         typedef SCCOL reference;


         explicit Iterator(const std::vector<std::unique_ptr<ScColumn, o3tl::default_delete<ScColumn>>>::const_iterator& colIter) : maColIter(colIter) {}


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

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


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

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

         SCCOL operator*() const {return (*maColIter)->GetCol();}

     };


     ScColumnsRange(const Iterator & rBegin, const Iterator & rEnd) : maBegin(rBegin), maEnd(rEnd) {}

     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;


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


     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::unique_ptr<ScRange> pRepeatColRange;

     std::unique_ptr<ScRange> pRepeatRowRange;


     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;


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

     bool            bPendingRowHeights:1;

     bool            bCalcNotification:1;

     bool            bGlobalKeepQuery:1;

     bool            bPrintEntireSheet:1;

     bool            bActiveScenario:1;

     bool            mbPageBreaksValid:1;

     bool            mbForceBreaks:1;


     // Default attributes for the unallocated columns.

     ScAttrArray     aDefaultColAttrArray;


 friend class ScDocument;                    // for FillInfo

 friend class ScColumn;

 friend class ScValueIterator;

 friend class ScHorizontalValueIterator;

 friend class ScDBQueryDataIterator;

 friend class ScFormulaGroupIterator;

 friend class ScCellIterator;

 friend class ScQueryCellIterator;

 friend class ScCountIfCellIterator;

 friend class ScHorizontalCellIterator;

 friend class ScHorizontalAttrIterator;

 friend class ScDocAttrIterator;

 friend class ScAttrRectIterator;

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

     {

         if ( nScCol >= aCol.size() )

             CreateColumnIfNotExistsImpl(nScCol);

         return aCol[nScCol];

     }

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

     void CreateColumnIfNotExistsImpl( const SCCOL nScCol ) const;

     sal_uLong       GetCellCount() const;

     sal_uLong       GetWeightedCount() const;

     sal_uLong       GetWeightedCount(SCROW nStartRow, SCROW nEndRow) const;

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


     bool        IsBlockEmpty( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bIgnoreNotes ) 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 );


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

     void        GetString( SCCOL nCol, SCROW nRow, OUString& rString,

                            const ScInterpreterContext* pContext = nullptr ) const;

     double*     GetValueCell( SCCOL nCol, SCROW nRow );

     void        GetInputString( SCCOL nCol, SCROW nRow, OUString& rString ) 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 );

     void GetFormula( SCCOL nCol, SCROW nRow, OUString& rFormula ) 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, SCROW nRow ) const;


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

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


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


     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( const ScTable* pDestTab ) const;

     bool        TestCopyScenarioTo( const ScTable* pDestTab ) const;

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

     bool        HasScenarioRange( const ScRange& rRange ) const;

     void        InvalidateScenarioRanges();

     const ScRangeList* GetScenarioRanges() const;


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


     void        InvalidateTableArea();

     void        InvalidatePageBreaks();


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

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

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

     bool        GetPrintAreaHor( SCROW nStartRow, SCROW nEndRow,

                                 SCCOL& rEndCol ) const;

     bool        GetPrintAreaVer( SCCOL nStartCol, SCCOL nEndCol,

                                 SCROW& rEndRow, bool bNotes ) const;


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


     void        ExtendPrintArea( OutputDevice* pDev,

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


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

                              bool bIncludeOld, bool bOnlyDown ) const;


     bool        GetDataAreaSubrange( ScRange& rRange ) const;


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

                                       SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly,

                                       bool bStickyTopRow, bool bStickyLeftCol, bool bConsiderCellNotes,

                                       bool bConsiderCellDrawObjects, bool bConsiderCellPatterns ) const;


     SCROW       GetLastDataRow( SCCOL nCol1, SCCOL nCol2, SCROW nLastRow, bool bConsiderCellNotes = false,

                                 bool bConsiderCellDrawObjects = false,

                                 bool bConsiderCellPatterns = false ) 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, ScHint& rHint );


     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_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,

                         double nStepValue, 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);


     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 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 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        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 ScRange*  GetRepeatColRange() const   { return pRepeatColRange.get(); }

     const ScRange*  GetRepeatRowRange() const   { return pRepeatRowRange.get(); }

     void            SetRepeatColRange( std::unique_ptr<ScRange> pNew );

     void            SetRepeatRowRange( std::unique_ptr<ScRange> pNew );


     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_uLong nProgressStart = 0 );


     void SetOptimalHeightOnly(

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

         ScProgress* pOuterProgress = nullptr, sal_uLong 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      GetColWidth( SCCOL nCol, bool bHiddenAsZero = true ) const;

     sal_uLong GetColWidth( SCCOL nStartCol, SCCOL nEndCol ) const;

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

     sal_uLong       GetRowHeight( SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero = true ) const;

     sal_uLong       GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, double fScale, const sal_uLong* pnMaxHeight = nullptr ) const;

     sal_uLong       GetColOffset( SCCOL nCol, bool bHiddenAsZero = true ) const;

     sal_uLong       GetRowOffset( SCROW nRow, bool bHiddenAsZero = true ) const;


     SCROW       GetRowForHeight(sal_uLong 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      GetLastChangedCol() const;

     SCROW      GetLastChangedRow() 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( const ::std::set<SCROW>& rBreaks );

     void        SetColManualBreaks( const ::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;

     sal_uInt32  GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero = true) 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;


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


     bool ValidQuery(

         SCROW nRow, const ScQueryParam& rQueryParam, const ScRefCellValue* pCell = nullptr,

         bool* pbTestEqualCondition = nullptr, const ScInterpreterContext* pContext = nullptr,

         sc::TableColumnBlockPositionSet* pBlockPos = nullptr );

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


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


 private:


     void FillFormulaVertical(

         const ScFormulaCell& rSrcCell,

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

         ScProgress* pProgress, sal_uLong& rProgress );


     void FillSeriesSimple(

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

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


     void FillAutoSimple(

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

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

         sal_uLong nActFormCnt, sal_uLong nMaxFormCnt,

         bool bHasFiltered, bool bVertical, bool bPositive,

         ScProgress* pProgress, sal_uLong& rProgress );


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

                                 sal_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd,

                                 FillDateCmd eFillDateCmd,

                                 double nStepValue, 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, 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_uLong 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);

     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        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 SortReorderByRow( ScSortInfoArray* pArray, SCCOL nCol1, SCCOL nCol2, ScProgress* pProgress );

     void SortReorderByRowRefUpdate( ScSortInfoArray* pArray, SCCOL nCol1, SCCOL nCol2, 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);

     void        GetUpperCellString(SCCOL nCol, SCROW nRow, OUString& rStr);


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

         ~VisibleDataCellIterator();


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

ScTokenArray
Definition: tokenarray.hxx:48

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

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

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

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

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

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

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

sc::ReorderParam
Definition: sortparam.hxx:83

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

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

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

nPPTY
constexpr double nPPTY
Definition: datatableview.cxx:35

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

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

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

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

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

sc::SetFormulaDirtyContext
Definition: refupdatecontext.hxx:151

color.hxx

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

ScTable::bStreamValid
bool bStreamValid
Definition: table.hxx:239

ScTable::GetLastChangedCol
SCCOL GetLastChangedCol() const
Definition: table2.cxx:3752

ScColumnsRange::Iterator::Iterator
Iterator(const std::vector< std::unique_ptr< ScColumn, o3tl::default_delete< ScColumn >>>::const_iterator &colIter)
Definition: table.hxx:132

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

ScTable::Fill
void Fill(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd, double nStepValue, double nMaxValue, ScProgress *pProgress)
Definition: table4.cxx:2488

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

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

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

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

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

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

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

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

ScTable
Definition: table.hxx:152

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

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

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

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

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

ScFormulaCell
Definition: formulacell.hxx:108

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

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

ScTable::GetWeightedCount
sal_uLong GetWeightedCount() const
Definition: table3.cxx:3598

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

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

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

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

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

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

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

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

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

RowInfo
Definition: fillinfo.hxx:172

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

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

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

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

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

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

com::sun::star

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

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

HasAttrFlags
HasAttrFlags
Definition: global.hxx:192

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

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

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

ScDBData
Definition: dbdata.hxx:60

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

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

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

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

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

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

SfxItemPoolCache

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

FillDir
FillDir
Definition: global.hxx:317

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

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

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

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

column.hxx

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

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

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

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

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

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

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

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

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

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

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

formula

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

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

ScColWidthParam
Definition: docparam.hxx:17

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

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

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

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

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

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

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

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

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

ScObjectHandling
ScObjectHandling
Definition: drwlayer.hxx:89

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

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

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

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

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

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

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

ScScenarioFlags
ScScenarioFlags
Definition: global.hxx:235

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

ScAutoFormatData
Definition: autoform.hxx:111

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

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

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

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

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

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

ScMergePatternState
Definition: attarray.hxx:66

sal_uLong
sal_uIntPtr sal_uLong

tools::Long
long Long

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

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

ScDocAttrIterator
Definition: dociter.hxx:394

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

sortparam.hxx

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ScColumnsRange::Iterator
Definition: table.hxx:122

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

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

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

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

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

ScFlatBoolRowSegments
Definition: segmenttree.hxx:29

ScDrawObjData
Definition: userdat.hxx:31

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

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

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

ScInterpreter
Definition: interpre.hxx:136

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

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

ScRangeName
Definition: rangenam.hxx:183

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

ScEditDataArray
Definition: editdataarray.hxx:30

document.hxx

SfxItemPool

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

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

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

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

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

ScOutlineTable
Definition: olinetab.hxx:148

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

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

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

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

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

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

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

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

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

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

sc::RefUpdateInsertTabContext
Definition: refupdatecontext.hxx:119

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

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

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

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

ScRange
Definition: address.hxx:496

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

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

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

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

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

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

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

ScPrintSaverTab
Definition: prnsave.hxx:26

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

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

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

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

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

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

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

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

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

ScTable::GetRowForHeight
SCROW GetRowForHeight(sal_uLong 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:4122

ScColumnsRange::Iterator::maColIter
std::vector< std::unique_ptr< ScColumn, o3tl::default_delete< ScColumn > > >::const_iterator maColIter
Definition: table.hxx:124

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

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

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

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

ScTable::SetRepeatColRange
void SetRepeatColRange(std::unique_ptr< ScRange > pNew)
Definition: table1.cxx:2206

sc::RefUpdateDeleteTabContext
Definition: refupdatecontext.hxx:129

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

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

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

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

sheet
exports com.sun.star. sheet

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

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

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

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

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

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

ScAttrArray
Definition: attarray.hxx:86

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

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

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

ScCountIfCellIterator
Definition: dociter.hxx:371

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

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

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

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

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

sc::MultiDataCellState
Definition: types.hxx:97

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

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

ScValueIterator
Definition: dociter.hxx:51

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

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

ScTable::GetColOffset
sal_uLong GetColOffset(SCCOL nCol, bool bHiddenAsZero=true) const
Definition: table2.cxx:4189

ScHint
Definition: brdcst.hxx:24

colcontainer.hxx

ScConditionalFormat
Definition: conditio.hxx:539

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

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

sc::RowHeightContext
Definition: rowheightcontext.hxx:25

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

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

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

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

ScPatternAttr
Definition: patattr.hxx:52

sc::RefUpdateMoveTabContext
Definition: refupdatecontext.hxx:139

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

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

sc::MixDocContext
Definition: clipcontext.hxx:157

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

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

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

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

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

SvtBroadcaster

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

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

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

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

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

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

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

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

ScTable::GetFormula
void GetFormula(SCCOL nCol, SCROW nRow, OUString &rFormula) const
Definition: table2.cxx:1789

ScTable::GetScaledRowHeight
sal_uLong GetScaledRowHeight(SCROW nStartRow, SCROW nEndRow, double fScale, const sal_uLong *pnMaxHeight=nullptr) const
Definition: table2.cxx:3432

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

FillDateCmd
FillDateCmd
Definition: global.hxx:342

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

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

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

sc::ColumnBlockConstPosition
Definition: mtvelements.hxx:129

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

ScRangeList
Definition: rangelst.hxx:31

ScColumn
Definition: column.hxx:111

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

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

sc::CopyToClipContext
Definition: clipcontext.hxx:134

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

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

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

ScLinkMode
ScLinkMode
Definition: global.hxx:224

CollatorWrapper

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

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

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

ScAttrRectIterator
Definition: dociter.hxx:414

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

ScColumnsRange::Iterator::iterator_category
std::input_iterator_tag iterator_category
Definition: table.hxx:126

ScSortInfoArray
Definition: table3.cxx:235

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

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

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

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

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

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

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

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

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

ScFlatBoolColSegments
Definition: segmenttree.hxx:88

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

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

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

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

ScTable::ValidQuery
bool ValidQuery(SCROW nRow, const ScQueryParam &rQueryParam, const ScRefCellValue *pCell=nullptr, bool *pbTestEqualCondition=nullptr, const ScInterpreterContext *pContext=nullptr, sc::TableColumnBlockPositionSet *pBlockPos=nullptr)
Definition: table3.cxx:2762

attarray.hxx

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ScQueryParam
Definition: queryparam.hxx:133

Fraction

ScTable::SetRepeatRowRange
void SetRepeatRowRange(std::unique_ptr< ScRange > pNew)
Definition: table1.cxx:2215

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

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

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

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

ScConditionalFormatList
Definition: conditio.hxx:625

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

formula::FormulaGrammar::Grammar
Grammar

nPPTX
constexpr double nPPTX
Definition: datatableview.cxx:34

types.hxx

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::SetOutlineTable
bool SetOutlineTable(const ScOutlineTable *pNewOutline)
Definition: table2.cxx:91

Size

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

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

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

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

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

ScPasteFunc
ScPasteFunc
Definition: global.hxx:188

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

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

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

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

ScFlatUInt16RowSegments
Definition: segmenttree.hxx:118

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

ScTable::ShrinkToUsedDataArea
bool ShrinkToUsedDataArea(bool &o_bShrunk, SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow, bool bColumnsOnly, bool bStickyTopRow, bool bStickyLeftCol, bool bConsiderCellNotes, bool bConsiderCellDrawObjects, bool bConsiderCellPatterns) const
Definition: table1.cxx:977

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

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

ScSheetEvents
Definition: sheetevents.hxx:32

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

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

SvtScriptType
SvtScriptType

FillCmd
FillCmd
Definition: global.hxx:325

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

sc::TableColumnBlockPositionSet
Set of column block positions only for one table.
Definition: mtvelements.hxx:158

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

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

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

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

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

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

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

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

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

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

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

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

ScTable::pRepeatColRange
std::unique_ptr< ScRange > pRepeatColRange
Definition: table.hxx:216

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

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

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

ScMoveDirection
ScMoveDirection
Definition: global.hxx:334

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

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

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

SCCOL
sal_Int16 SCCOL
Definition: types.hxx:21

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

InsertDeleteFlags
InsertDeleteFlags
Definition: global.hxx:157

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

ScTable::GetRepeatRowRange
const ScRange * GetRepeatRowRange() const
Definition: table.hxx:770

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

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

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

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

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

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

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

ScInterpreterContext
Definition: interpretercontext.hxx:53

utl

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

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

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

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

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

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

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

SvNumberFormatterMergeMap
::std::map< sal_uInt32, sal_uInt32 > SvNumberFormatterMergeMap

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

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

sc
Definition: celltextattr.cxx:13

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

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

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

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

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

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

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

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

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

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

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

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

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

CELLTYPE_NONE
Definition: global.hxx:282

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

OutputDevice

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

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

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

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

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

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

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

ScTable::VisibleDataCellIterator::~VisibleDataCellIterator
~VisibleDataCellIterator()
Definition: table1.cxx:2287

ScSubTotalParam
Definition: subtotalparam.hxx:15

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

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

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

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

SvNumFormatType
SvNumFormatType

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

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

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

ScQueryCellIterator
Definition: dociter.hxx:251

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

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

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

ScHorizontalAttrIterator
Definition: dociter.hxx:504

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

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

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

cellvalue.hxx

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

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

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

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

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

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

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

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

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

SfxStyleSheetBase

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

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

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

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

ScStyleSheet
Definition: stlsheet.hxx:28

CommentCaptionState
CommentCaptionState
Definition: document.hxx:253

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

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

ScProgress
Definition: progress.hxx:39

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

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

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

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

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

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

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

sc::FormulaGroupAreaListener
Definition: grouparealistener.hxx:26

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

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

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

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

FormulaError
FormulaError

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

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

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

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

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

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

SfxPoolItem

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

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

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

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

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

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

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

SvxBoxItem

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

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

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

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

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

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

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

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

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

ScAddress
Definition: address.hxx:193

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

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

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

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

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

gen.hxx

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

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

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

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

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

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

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

SfxItemSet

UpdateRefMode
UpdateRefMode
Definition: global.hxx:309

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

CRFlags
CRFlags
Definition: global.hxx:134

SCROW
sal_Int32 SCROW
Definition: types.hxx:17

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

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

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

sc::StartListeningContext
Definition: listenercontext.hxx:25

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

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

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

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

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

svl::SharedString

sc::ColRowEditAction
ColRowEditAction
Definition: global.hxx:435

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

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

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

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

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

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

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

ScMF
ScMF
Definition: attrib.hxx:34

ScObjectHandling::RecalcPosMode

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

calcmacros.hxx

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

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

o3tl::default_delete

ScTable::GetTotalRowHeight
sal_uInt32 GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero=true) const
Definition: table5.cxx:788

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

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

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

ScColumnsRange
Definition: table.hxx:119

ScTable::GetCellValue
ScRefCellValue GetCellValue(SCCOL nCol, SCROW nRow) const
Definition: table2.cxx:1929

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

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

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

ScTable::GetLastDataRow
SCROW GetLastDataRow(SCCOL nCol1, SCCOL nCol2, SCROW nLastRow, bool bConsiderCellNotes=false, bool bConsiderCellDrawObjects=false, bool bConsiderCellPatterns=false) const
Definition: table1.cxx:1095

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

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

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

CellType
CellType
Definition: global.hxx:280

ScTable::BroadcastBroadcasters
bool BroadcastBroadcasters(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScHint &rHint)
Broadcast single broadcasters in range, without explicitly setting anything dirty, not doing area broadcasts.
Definition: table2.cxx:2069

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

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

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

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

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

ScTable::GetCellCount
sal_uLong GetCellCount() const
Definition: table3.cxx:3588

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

ScTable::DumpColumnStorage
void DumpColumnStorage(SCCOL nCol) const

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

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

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

ScTable::GetLastChangedRow
SCROW GetLastChangedRow() const
Definition: table2.cxx:3767

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

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

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

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

ScColumnTextWidthIterator
Definition: columniterator.hxx:22

svl::SharedStringPool

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

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

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

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

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

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

ScTable::GetInputString
void GetInputString(SCCOL nCol, SCROW nRow, OUString &rString) const
Definition: table2.cxx:1758

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

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

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

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

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

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

sc::CompileFormulaContext
Definition: tokenstringcontext.hxx:48

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

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

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

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

nType
QPRO_FUNC_TYPE nType
Definition: qproform.cxx:400

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

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

Color

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

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

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

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

ScFilterEntries
Definition: filterentries.hxx:18

ScTable::FillSeries
void FillSeries(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd, double nStepValue, double nMaxValue, sal_uInt16 nMinDigits, bool bAttribs, ScProgress *pProgress, bool bSkipOverlappedCells=false, std::vector< sal_Int32 > *pNonOverlappedCellIdx=nullptr)
Definition: table4.cxx:2042

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

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

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

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

drwlayer.hxx

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

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

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

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

ScColContainer
Definition: colcontainer.hxx:28

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

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

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

TypedWhichId

ScLinkMode::NONE

ScTable::GetCodeCount
sal_uLong GetCodeCount() const
Definition: table3.cxx:3618

SvtListener

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

ScTable::pRepeatRowRange
std::unique_ptr< ScRange > pRepeatRowRange
Definition: table.hxx:217

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

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

sc::EndListeningContext
Definition: listenercontext.hxx:43

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

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

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

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

ScSortParam
Definition: sortparam.hxx:40

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

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

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

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

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

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

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

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

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

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

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

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

ScDirection
ScDirection
Definition: global.hxx:351

ScTable::GetRowOffset
sal_uLong GetRowOffset(SCROW nRow, bool bHiddenAsZero=true) const
Definition: table2.cxx:4099

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

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

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

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

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

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

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

formula::VectorRefArray

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

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

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

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

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

errorcodes.hxx

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ScColumnsRange::ScColumnsRange
ScColumnsRange(const Iterator &rBegin, const Iterator &rEnd)
Definition: table.hxx:142

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

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

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

ScTable::GetRepeatColRange
const ScRange * GetRepeatColRange() const
Definition: table.hxx:769

SvxSearchItem

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

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

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

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

ScDocument
Definition: document.hxx:313

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

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

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

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

ScFormulaGroupIterator
Definition: dociter.hxx:187

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

ScTable::GetUpperCellString
void GetUpperCellString(SCCOL nCol, SCROW nRow, OUString &rStr)
Definition: table2.cxx:4047

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

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

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

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

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

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

ScTable::aDefaultColAttrArray
ScAttrArray aDefaultColAttrArray
Definition: table.hxx:249

ScHorizontalCellIterator
Definition: dociter.hxx:437

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

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

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

EditTextObject

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

sc::CopyFromClipContext
Definition: clipcontext.hxx:45

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

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

ScDBQueryDataIterator
Definition: dociter.hxx:101

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

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

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

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

sc::CopyToDocContext
Definition: clipcontext.hxx:145

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

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

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

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

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

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

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

SCTAB
sal_Int16 SCTAB
Definition: types.hxx:22

ScLineFlags
Definition: attarray.hxx:53

SvxBoxInfoItem

o3tl::sorted_vector< sal_uInt32 >

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

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

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

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

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

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

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

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

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

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

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

SvStream

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

TextSearch