Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 692 insertions, 0 deletions

diff --git a/sc/inc/conditio.hxx b/sc/inc/conditio.hxx
new file mode 100644
index 000000000..d47b841b0
--- /dev/null
+++ b/sc/inc/conditio.hxx
@@ -0,0 +1,692 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+#include <tools/solar.h>
+#include <tools/color.hxx>
+#include "address.hxx"
+#include <formula/grammar.hxx>
+#include "scdllapi.h"
+#include "rangelst.hxx"
+#include "tokenarray.hxx"
+
+#include <svl/listener.hxx>
+
+#include <com/sun/star/sheet/ConditionOperator.hpp>
+
+#include <rtl/math.hxx>
+#include <tools/date.hxx>
+#include <tools/link.hxx>
+
+#include <optional>
+#include <map>
+#include <memory>
+#include <set>
+
+class ScFormulaCell;
+class ScTokenArray;
+struct ScRefCellValue;
+
+namespace sc {
+
+struct RefUpdateContext;
+struct RefUpdateInsertTabContext;
+struct RefUpdateDeleteTabContext;
+struct RefUpdateMoveTabContext;
+
+}
+
+//  nOptions Flags
+#define SC_COND_NOBLANKS    1
+
+enum class ScConditionMode
+{
+    Equal,
+    Less,
+    Greater,
+    EqLess,
+    EqGreater,
+    NotEqual,
+    Between,
+    NotBetween,
+    Duplicate,
+    NotDuplicate,
+    Direct,
+    Top10,
+    Bottom10,
+    TopPercent,
+    BottomPercent,
+    AboveAverage,
+    BelowAverage,
+    AboveEqualAverage,
+    BelowEqualAverage,
+    Error,
+    NoError,
+    BeginsWith,
+    EndsWith,
+    ContainsText,
+    NotContainsText,
+    NONE
+};
+
+// For use in SAL_DEBUG etc. Output format not guaranteed to be stable.
+template<typename charT, typename traits>
+inline std::basic_ostream<charT, traits> & operator <<(std::basic_ostream<charT, traits> & stream, const ScConditionMode& rMode)
+{
+    switch (rMode)
+    {
+    case ScConditionMode::Equal:
+        stream << "EQUAL";
+        break;
+    case ScConditionMode::Less:
+        stream << "LESS";
+        break;
+    case ScConditionMode::Greater:
+        stream << "GREATER";
+        break;
+    case ScConditionMode::EqLess:
+        stream << "EQLESS";
+        break;
+    case ScConditionMode::EqGreater:
+        stream << "EQGREATER";
+        break;
+    case ScConditionMode::NotEqual:
+        stream << "NOTEQUAL";
+        break;
+    case ScConditionMode::Between:
+        stream << "BETWEEN";
+        break;
+    case ScConditionMode::NotBetween:
+        stream << "NOTBETWEEN";
+        break;
+    case ScConditionMode::Duplicate:
+        stream << "DUPLICATE";
+        break;
+    case ScConditionMode::NotDuplicate:
+        stream << "NOTDUPLICATE";
+        break;
+    case ScConditionMode::Direct:
+        stream << "DIRECT";
+        break;
+    case ScConditionMode::Top10:
+        stream << "TOP10";
+        break;
+    case ScConditionMode::Bottom10:
+        stream << "BOTTOM10";
+        break;
+    case ScConditionMode::TopPercent:
+        stream << "TOPPERCENT";
+        break;
+    case ScConditionMode::BottomPercent:
+        stream << "BOTTOMPERCENT";
+        break;
+    case ScConditionMode::AboveAverage:
+        stream << "ABOVEAVERAGE";
+        break;
+    case ScConditionMode::BelowAverage:
+        stream << "BELOWAVERAGE";
+        break;
+    case ScConditionMode::AboveEqualAverage:
+        stream << "ABOVEEQUALAVERAGE";
+        break;
+    case ScConditionMode::BelowEqualAverage:
+        stream << "BELOWEQUALAVERAGE";
+        break;
+    case ScConditionMode::Error:
+        stream << "ERROR";
+        break;
+    case ScConditionMode::NoError:
+        stream << "NOERROR";
+        break;
+    case ScConditionMode::BeginsWith:
+        stream << "BEGINSWITH";
+        break;
+    case ScConditionMode::EndsWith:
+        stream << "ENDSWITH";
+        break;
+    case ScConditionMode::ContainsText:
+        stream << "CONTAINSTEXT";
+        break;
+    case ScConditionMode::NotContainsText:
+        stream << "NOTCONTAINSTEXT";
+        break;
+    case ScConditionMode::NONE:
+        stream << "NONE";
+        break;
+    default:
+        stream << "?(" << static_cast<int>(rMode) << ")";
+        break;
+    }
+
+    return stream;
+}
+
+class ScFormulaListener final : public SvtListener
+{
+private:
+    mutable bool mbDirty;
+    ScDocument& mrDoc;
+    std::function<void()> maCallbackFunction;
+
+    void startListening(const ScTokenArray* pTokens, const ScRange& rPos);
+    void startListening(const ScRangeList& rPos);
+
+public:
+    explicit ScFormulaListener(ScFormulaCell* pCell);
+    explicit ScFormulaListener(ScDocument& rDoc);
+    explicit ScFormulaListener(ScDocument& rDoc, const ScRangeList& rRange);
+    virtual ~ScFormulaListener() override;
+
+    void Notify( const SfxHint& rHint ) override;
+
+    bool NeedsRepaint() const;
+
+    void addTokenArray(const ScTokenArray* pTokens, const ScRange& rRange);
+    void stopListening();
+    void setCallback(const std::function<void()>& aCallbackFunction);
+
+};
+
+class ScConditionalFormat;
+struct ScDataBarInfo;
+struct ScIconSetInfo;
+
+struct ScCondFormatData
+{
+    ScCondFormatData();
+    ScCondFormatData(ScCondFormatData&&);
+    ~ScCondFormatData();
+
+    std::optional<Color> mxColorScale;
+    std::unique_ptr<ScDataBarInfo> pDataBar;
+    std::unique_ptr<ScIconSetInfo> pIconSet;
+    OUString aStyleName;
+};
+
+class SC_DLLPUBLIC ScFormatEntry
+{
+public:
+    ScFormatEntry(ScDocument* pDoc);
+    virtual ~ScFormatEntry() {}
+
+    enum class Type
+    {
+        Condition,
+        ExtCondition,
+        Colorscale,
+        Databar,
+        Iconset,
+        Date
+    };
+
+    virtual Type GetType() const = 0;
+    virtual void UpdateReference( sc::RefUpdateContext& rCxt ) = 0;
+    virtual void UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt ) = 0;
+    virtual void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt ) = 0;
+    virtual void UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt ) = 0;
+
+    virtual ScFormatEntry* Clone( ScDocument* pDoc ) const = 0;
+
+    virtual void SetParent( ScConditionalFormat* pNew ) = 0;
+
+    bool operator==( const ScFormatEntry& ) const;
+    virtual bool IsEqual( const ScFormatEntry&, bool bIgnoreSrcPos ) const;
+
+    virtual void startRendering();
+    virtual void endRendering();
+protected:
+    ScDocument* mpDoc;
+
+};
+
+template<typename charT, typename traits>
+inline std::basic_ostream<charT, traits> & operator <<(std::basic_ostream<charT, traits> & stream, const ScFormatEntry::Type& rType)
+{
+    switch (rType)
+    {
+    case ScFormatEntry::Type::Condition:
+        stream << "Condition";
+        break;
+    case ScFormatEntry::Type::ExtCondition:
+        stream << "ExtCondition";
+        break;
+    case ScFormatEntry::Type::Colorscale:
+        stream << "Colorscale";
+        break;
+    case ScFormatEntry::Type::Databar:
+        stream << "Databar";
+        break;
+    case ScFormatEntry::Type::Iconset:
+        stream << "Iconset";
+        break;
+    case ScFormatEntry::Type::Date:
+        stream << "Date";
+        break;
+    default:
+        stream << "?(" << static_cast<int>(rType) << ")";
+        break;
+    }
+    return stream;
+}
+
+class approx_less
+{
+public:
+    bool operator() (double nVal1, double nVal2) const
+    {
+        if(nVal1 < nVal2 && !rtl::math::approxEqual(nVal1, nVal2))
+            return true;
+
+        return false;
+    }
+};
+
+class SC_DLLPUBLIC ScConditionEntry : public ScFormatEntry
+{
+                                        // stored data:
+    ScConditionMode     eOp;
+    sal_uInt16              nOptions;
+    double              nVal1;          // input or calculated
+    double              nVal2;
+    OUString              aStrVal1;       // input or calculated
+    OUString              aStrVal2;
+    const OUString      aStrNmsp1;      // namespace to be used on (re)compilation, e.g. in XML import
+    const OUString      aStrNmsp2;      // namespace to be used on (re)compilation, e.g. in XML import
+    const formula::FormulaGrammar::Grammar eTempGrammar1;  // grammar to be used on (re)compilation, e.g. in XML import
+    const formula::FormulaGrammar::Grammar eTempGrammar2;  // grammar to be used on (re)compilation, e.g. in XML import
+    bool                bIsStr1;        // for recognition of empty strings
+    bool                bIsStr2;
+    std::unique_ptr<ScTokenArray> pFormula1;      // entered formula
+    std::unique_ptr<ScTokenArray> pFormula2;
+    ScAddress           aSrcPos;        // source position for formulas
+                                        // temporary data:
+    OUString              aSrcString;     // formula source position as text during XML import
+    std::unique_ptr<ScFormulaCell>  pFCell1;
+    std::unique_ptr<ScFormulaCell>  pFCell2;
+    bool                bRelRef1;
+    bool                bRelRef2;
+    bool                bFirstRun;
+    std::unique_ptr<ScFormulaListener> mpListener;
+    Type eConditionType;                //It can be Condition or ExtCondition
+
+    static void SimplifyCompiledFormula( std::unique_ptr<ScTokenArray>& rFormula,
+                                     double& rVal,
+                                     bool& rIsStr,
+                                     OUString& rStrVal );
+
+    void    MakeCells( const ScAddress& rPos );
+    void    Compile( const OUString& rExpr1, const OUString& rExpr2,
+                        const OUString& rExprNmsp1, const OUString& rExprNmsp2,
+                        formula::FormulaGrammar::Grammar eGrammar1,
+                        formula::FormulaGrammar::Grammar eGrammar2,
+                        bool bTextToReal );
+    void    Interpret( const ScAddress& rPos );
+
+    bool    IsValid( double nArg, const ScAddress& rPos ) const;
+    bool    IsValidStr( const OUString& rArg, const ScAddress& rPos ) const;
+    void    StartListening();
+
+public:
+            ScConditionEntry( ScConditionMode eOper,
+                                const OUString& rExpr1, const OUString& rExpr2,
+                                ScDocument& rDocument, const ScAddress& rPos,
+                                const OUString& rExprNmsp1, const OUString& rExprNmsp2,
+                                formula::FormulaGrammar::Grammar eGrammar1,
+                                formula::FormulaGrammar::Grammar eGrammar2,
+                                Type eType = Type::Condition );
+            ScConditionEntry( ScConditionMode eOper,
+                                const ScTokenArray* pArr1, const ScTokenArray* pArr2,
+                                ScDocument& rDocument, const ScAddress& rPos );
+            ScConditionEntry( const ScConditionEntry& r );  // flat copy of formulas
+            // true copy of formulas (for Ref-Undo):
+            ScConditionEntry( ScDocument& rDocument, const ScConditionEntry& r );
+    virtual ~ScConditionEntry() override;
+
+    bool            IsEqual( const ScFormatEntry& r, bool bIgnoreSrcPos ) const override;
+
+    virtual void SetParent( ScConditionalFormat* pNew ) override;
+
+    bool IsCellValid( ScRefCellValue& rCell, const ScAddress& rPos ) const;
+
+    ScConditionMode GetOperation() const        { return eOp; }
+    void SetOperation(ScConditionMode eMode);
+    bool            IsIgnoreBlank() const       { return ( nOptions & SC_COND_NOBLANKS ) == 0; }
+    void            SetIgnoreBlank(bool bSet);
+    const OUString& GetSrcString() const         { return aSrcString; }
+    const ScAddress& GetSrcPos() const           { return aSrcPos; }
+
+    ScAddress       GetValidSrcPos() const;     // adjusted to allow textual representation of expressions
+
+    void            SetSrcString( const OUString& rNew );     // for XML import
+
+    void            SetFormula1( const ScTokenArray& rArray );
+    void            SetFormula2( const ScTokenArray& rArray );
+
+    OUString          GetExpression( const ScAddress& rCursor, sal_uInt16 nPos, sal_uInt32 nNumFmt = 0,
+                                    const formula::FormulaGrammar::Grammar eGrammar = formula::FormulaGrammar::GRAM_DEFAULT ) const;
+
+                    /** Create a flat copy using ScTokenArray copy-ctor with
+                        shared tokens. */
+    std::unique_ptr<ScTokenArray> CreateFlatCopiedTokenArray( sal_uInt16 nPos ) const;
+
+    void            CompileAll();
+    void            CompileXML();
+    virtual void UpdateReference( sc::RefUpdateContext& rCxt ) override;
+    virtual void UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt ) override;
+    virtual void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt ) override;
+    virtual void UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt ) override;
+
+    bool            MarkUsedExternalReferences() const;
+
+    virtual Type GetType() const override { return eConditionType; }
+
+    virtual ScFormatEntry* Clone(ScDocument* pDoc) const override;
+
+    static ScConditionMode GetModeFromApi(css::sheet::ConditionOperator nOperator);
+
+    virtual void endRendering() override;
+    virtual void startRendering() override;
+
+    bool NeedsRepaint() const;
+    void CalcAll();
+
+protected:
+    virtual void    DataChanged() const;
+    ScDocument*     GetDocument() const     { return mpDoc; }
+    ScConditionalFormat*    pCondFormat;
+
+private:
+
+    bool IsDuplicate(double nArg, const OUString& rStr) const;
+    bool IsTopNElement( double nArg ) const;
+    bool IsTopNPercent( double nArg ) const;
+    bool IsBottomNElement( double nArg ) const;
+    bool IsBottomNPercent( double nArg ) const;
+    bool IsAboveAverage( double nArg, bool bEqual ) const;
+    bool IsBelowAverage( double nArg, bool bEqual ) const;
+
+    bool IsError( const ScAddress& rPos ) const;
+
+    void FillCache() const;
+
+    struct ScConditionEntryCache
+    {
+        typedef std::map<OUString, sal_Int32> StringCacheType;
+        StringCacheType maStrings;
+        typedef std::map<double, sal_Int32, approx_less> ValueCacheType;
+        ValueCacheType maValues;
+
+        // cache them for easier access
+        size_t nValueItems;
+
+        ScConditionEntryCache():
+            nValueItems(0) {}
+    };
+
+    mutable std::unique_ptr<ScConditionEntryCache> mpCache;
+};
+
+//  single condition entry for conditional formatting
+class SC_DLLPUBLIC ScCondFormatEntry final : public ScConditionEntry
+{
+    OUString aStyleName;
+    Type eCondFormatType = Type::Condition;
+
+public:
+            ScCondFormatEntry( ScConditionMode eOper,
+                                const OUString& rExpr1, const OUString& rExpr2,
+                                ScDocument& rDocument, const ScAddress& rPos,
+                                const OUString& rStyle,
+                                const OUString& rExprNmsp1 = OUString(),
+                                const OUString& rExprNmsp2 = OUString(),
+                                formula::FormulaGrammar::Grammar eGrammar1 = formula::FormulaGrammar::GRAM_DEFAULT,
+                                formula::FormulaGrammar::Grammar eGrammar2 = formula::FormulaGrammar::GRAM_DEFAULT,
+                                Type eType = Type::Condition);
+            ScCondFormatEntry( ScConditionMode eOper,
+                                const ScTokenArray* pArr1, const ScTokenArray* pArr2,
+                                ScDocument& rDocument, const ScAddress& rPos,
+                                const OUString& rStyle );
+            ScCondFormatEntry( const ScCondFormatEntry& r );
+            ScCondFormatEntry( ScDocument& rDocument, const ScCondFormatEntry& r );
+    virtual ~ScCondFormatEntry() override;
+
+    bool            IsEqual( const ScFormatEntry& r, bool bIgnoreSrcPos ) const override;
+
+    const OUString&   GetStyle() const        { return aStyleName; }
+    void            UpdateStyleName(const OUString& rNew)  { aStyleName=rNew; }
+    virtual ScFormatEntry* Clone(ScDocument* pDoc) const override;
+    virtual Type GetType() const override { return eCondFormatType; }
+
+private:
+    virtual void    DataChanged() const override;
+};
+
+namespace condformat {
+
+enum ScCondFormatDateType
+{
+    TODAY,
+    YESTERDAY,
+    TOMORROW,
+    LAST7DAYS,
+    THISWEEK,
+    LASTWEEK,
+    NEXTWEEK,
+    THISMONTH,
+    LASTMONTH,
+    NEXTMONTH,
+    THISYEAR,
+    LASTYEAR,
+    NEXTYEAR
+};
+
+}
+
+class SC_DLLPUBLIC ScCondDateFormatEntry final : public ScFormatEntry
+{
+public:
+    ScCondDateFormatEntry(ScDocument* pDoc);
+    ScCondDateFormatEntry(ScDocument* pDoc, const ScCondDateFormatEntry& rEntry);
+
+    bool IsValid( const ScAddress& rPos ) const;
+
+    void SetDateType(condformat::ScCondFormatDateType eType);
+    condformat::ScCondFormatDateType GetDateType() const { return meType;}
+
+    const OUString& GetStyleName() const { return maStyleName;}
+    void SetStyleName( const OUString& rStyleName );
+
+    virtual Type GetType() const override { return Type::Date; }
+    virtual void UpdateReference( sc::RefUpdateContext& ) override {}
+    virtual void UpdateInsertTab( sc::RefUpdateInsertTabContext& ) override {}
+    virtual void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& ) override {}
+    virtual void UpdateMoveTab( sc::RefUpdateMoveTabContext& ) override {}
+
+    virtual ScFormatEntry* Clone( ScDocument* pDoc ) const override;
+
+    virtual void SetParent( ScConditionalFormat* ) override {}
+
+    virtual void startRendering() override;
+    virtual void endRendering() override;
+
+private:
+    condformat::ScCondFormatDateType meType;
+
+    mutable std::unique_ptr<Date> mpCache;
+
+    OUString maStyleName;
+};
+
+//  complete conditional formatting
+class SC_DLLPUBLIC ScConditionalFormat
+{
+    ScDocument*         pDoc;
+    sal_uInt32          nKey;               // Index in attributes
+
+    std::vector<std::unique_ptr<ScFormatEntry>> maEntries;
+    ScRangeList maRanges;            // Ranges for conditional format
+
+public:
+    ScConditionalFormat(sal_uInt32 nNewKey, ScDocument* pDocument);
+    ~ScConditionalFormat();
+     ScConditionalFormat(const ScConditionalFormat&) = delete;
+     const ScConditionalFormat& operator=(const ScConditionalFormat&) = delete;
+
+    // true copy of formulas (for Ref-Undo / between documents)
+    std::unique_ptr<ScConditionalFormat> Clone(ScDocument* pNewDoc = nullptr) const;
+
+    void            AddEntry( ScFormatEntry* pNew );
+    void RemoveEntry(size_t nIndex);
+    void            SetRange( const ScRangeList& rRanges );
+    const ScRangeList&  GetRange() const  { return maRanges; }
+    // don't use the same name as for the const version
+    ScRangeList& GetRangeList() { return maRanges; }
+
+    bool IsEmpty() const;
+    size_t size() const;
+
+    ScDocument* GetDocument();
+
+    void            CompileAll();
+    void            CompileXML();
+    void UpdateReference( sc::RefUpdateContext& rCxt, bool bCopyAsMove = false );
+    void UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt );
+    void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt );
+    void UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt );
+
+    void InsertRow(SCTAB nTab, SCCOL nColStart, SCCOL nColEnd, SCROW nRowStart, SCSIZE nSize);
+    void InsertCol(SCTAB nTab, SCROW nRowStart, SCROW nRowEnd, SCCOL nColStart, SCSIZE nSize);
+
+    void            DeleteArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );
+    void            RenameCellStyle( std::u16string_view rOld, const OUString& rNew );
+
+    const ScFormatEntry* GetEntry( sal_uInt16 nPos ) const;
+
+    OUString GetCellStyle( ScRefCellValue& rCell, const ScAddress& rPos ) const;
+
+    ScCondFormatData GetData( ScRefCellValue& rCell, const ScAddress& rPos ) const;
+
+    bool            EqualEntries( const ScConditionalFormat& r, bool bIgnoreSrcPos = false ) const;
+
+    void            DoRepaint();
+
+    sal_uInt32      GetKey() const          { return nKey; }
+    void            SetKey(sal_uInt32 nNew) { nKey = nNew; }    // only if not inserted!
+
+    bool            MarkUsedExternalReferences() const;
+
+    //  sorted (via std::set) by Index
+    bool operator < ( const ScConditionalFormat& r ) const  { return nKey <  r.nKey; }
+
+    void startRendering();
+    void endRendering();
+
+    // Forced recalculation for formulas
+    void CalcAll();
+};
+
+struct CompareScConditionalFormat
+{
+    using is_transparent = void;
+    bool operator()(std::unique_ptr<ScConditionalFormat> const& lhs,
+                    std::unique_ptr<ScConditionalFormat> const& rhs) const
+    {
+        return (*lhs) < (*rhs);
+    }
+    bool operator()(sal_uInt32 nKey, std::unique_ptr<ScConditionalFormat> const& rpFormat) const
+    {
+        return nKey < rpFormat->GetKey();
+    }
+    bool operator()(std::unique_ptr<ScConditionalFormat> const& rpFormat, sal_uInt32 nKey) const
+    {
+        return rpFormat->GetKey() < nKey;
+    }
+};
+
+//  List of all conditional formats in a sheet
+class SC_DLLPUBLIC ScConditionalFormatList
+{
+private:
+    typedef std::set<std::unique_ptr<ScConditionalFormat>,
+                CompareScConditionalFormat> ConditionalFormatContainer;
+    ConditionalFormatContainer m_ConditionalFormats;
+
+    void operator =(ScConditionalFormatList const &) = delete;
+
+public:
+    ScConditionalFormatList() {}
+    ScConditionalFormatList(const ScConditionalFormatList& rList);
+    ScConditionalFormatList(ScDocument& rDoc, const ScConditionalFormatList& rList);
+
+    void    InsertNew( std::unique_ptr<ScConditionalFormat> pNew );
+
+    /**
+     * Checks that all cond formats have a non empty range.
+     * Deletes empty cond formats. Optionally call rLink
+     * on the empty format before deleting it.
+     * @return true if all cond formats were valid
+     */
+    bool    CheckAllEntries(const Link<ScConditionalFormat*,void>& rLink = Link<ScConditionalFormat*,void>());
+
+    ScConditionalFormat* GetFormat( sal_uInt32 nKey );
+    const ScConditionalFormat* GetFormat( sal_uInt32 nKey ) const;
+
+    void    CompileAll();
+    void    CompileXML();
+    void UpdateReference( sc::RefUpdateContext& rCxt );
+    void UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt );
+    void UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt );
+    void UpdateMoveTab( sc::RefUpdateMoveTabContext& rCxt );
+
+    void InsertRow(SCTAB nTab, SCCOL nColStart, SCCOL nColEnd, SCROW nRowStart, SCSIZE nSize);
+    void InsertCol(SCTAB nTab, SCROW nRowStart, SCROW nRowEnd, SCCOL nColStart, SCSIZE nSize);
+
+    void    RenameCellStyle( std::u16string_view rOld, const OUString& rNew );
+    void    DeleteArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );
+
+    typedef ConditionalFormatContainer::iterator iterator;
+    typedef ConditionalFormatContainer::const_iterator const_iterator;
+
+    ScRangeList GetCombinedRange() const;
+
+    void RemoveFromDocument(ScDocument& rDoc) const;
+    void AddToDocument(ScDocument& rDoc) const;
+
+    iterator begin();
+    const_iterator begin() const;
+    iterator end();
+    const_iterator end() const;
+
+    size_t size() const;
+    bool empty() const;
+
+    void erase(sal_uLong nIndex);
+    void clear();
+
+    void startRendering();
+    void endRendering();
+
+    sal_uInt32 getMaxKey() const;
+
+    /// Forced recalculation of formulas
+    void CalcAll();
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */