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, 473 insertions, 0 deletions

diff --git a/sc/inc/dociter.hxx b/sc/inc/dociter.hxx
new file mode 100644
index 000000000..274149806
--- /dev/null
+++ b/sc/inc/dociter.hxx
@@ -0,0 +1,473 @@
+/* -*- 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 "address.hxx"
+#include "formulagroup.hxx"
+#include "global.hxx"
+#include "scdllapi.h"
+#include "cellvalue.hxx"
+#include "mtvelements.hxx"
+#include "queryparam.hxx"
+#include <vcl/outdev.hxx>
+#include <vcl/vclptr.hxx>
+
+#include <memory>
+#include <set>
+#include <vector>
+
+class ScDocument;
+class ScPatternAttr;
+class ScAttrArray;
+class ScAttrIterator;
+class ScFlatBoolRowSegments;
+class ScMatrix;
+struct ScDBQueryParamBase;
+struct ScQueryParam;
+struct ScDBQueryParamInternal;
+struct ScDBQueryParamMatrix;
+class ScFormulaCell;
+class OutputDevice;
+struct ScInterpreterContext;
+enum class SvNumFormatType : sal_Int16;
+
+class ScValueIterator            // walk through all values in an area
+{
+    typedef sc::CellStoreType::const_position_type PositionType;
+
+    ScDocument&     mrDoc;
+    ScInterpreterContext& mrContext;
+    const ScAttrArray*  pAttrArray;
+    sal_uInt32      nNumFormat;     // for CalcAsShown
+    sal_uInt32      nNumFmtIndex;
+    ScAddress       maStartPos;
+    ScAddress       maEndPos;
+    SCCOL           mnCol;
+    SCTAB           mnTab;
+    SCROW           nAttrEndRow;
+    SubtotalFlags   mnSubTotalFlags;
+    SvNumFormatType nNumFmtType;
+    bool            bNumValid;
+    bool            bCalcAsShown;
+    bool            bTextAsZero;
+
+    const sc::CellStoreType* mpCells;
+    PositionType maCurPos;
+
+    SCROW GetRow() const;
+    void IncBlock();
+    void IncPos();
+
+    /**
+     * See if the cell at the current position is a non-empty cell. If not,
+     * move to the next non-empty cell position.
+     */
+    bool GetThis( double& rValue, FormulaError& rErr );
+
+public:
+
+    ScValueIterator(ScInterpreterContext& rContext,
+        ScDocument& rDocument, const ScRange& rRange, SubtotalFlags nSubTotalFlags = SubtotalFlags::NONE,
+        bool bTextAsZero = false );
+
+    void GetCurNumFmtInfo( const ScInterpreterContext& rContext, SvNumFormatType& nType, sal_uInt32& nIndex );
+
+    /// Does NOT reset rValue if no value found!
+    bool GetFirst( double& rValue, FormulaError& rErr );
+
+    /// Does NOT reset rValue if no value found!
+    bool GetNext( double& rValue, FormulaError& rErr );
+};
+
+class ScDBQueryDataIterator
+{
+public:
+    struct Value
+    {
+        OUString        maString;
+        double          mfValue;
+        FormulaError    mnError;
+        bool            mbIsNumber;
+
+        Value();
+    };
+
+private:
+    static const sc::CellStoreType* GetColumnCellStore(ScDocument& rDoc, SCTAB nTab, SCCOL nCol);
+    static const ScAttrArray* GetAttrArrayByCol(ScDocument& rDoc, SCTAB nTab, SCCOL nCol);
+    static bool IsQueryValid(ScDocument& rDoc, const ScQueryParam& rParam, SCTAB nTab, SCROW nRow, const ScRefCellValue* pCell);
+
+    class DataAccess
+    {
+    public:
+        DataAccess();
+        virtual ~DataAccess() = 0;
+        virtual bool getCurrent(Value& rValue) = 0;
+        virtual bool getFirst(Value& rValue) = 0;
+        virtual bool getNext(Value& rValue) = 0;
+    };
+
+    class DataAccessInternal final : public DataAccess
+    {
+        typedef std::pair<sc::CellStoreType::const_iterator,size_t> PositionType;
+    public:
+        DataAccessInternal(ScDBQueryParamInternal* pParam, ScDocument& rDoc, const ScInterpreterContext& rContext);
+        virtual ~DataAccessInternal() override;
+        virtual bool getCurrent(Value& rValue) override;
+        virtual bool getFirst(Value& rValue) override;
+        virtual bool getNext(Value& rValue) override;
+
+    private:
+        void incBlock();
+        void incPos();
+
+        const sc::CellStoreType* mpCells;
+        PositionType maCurPos;
+        ScDBQueryParamInternal* mpParam;
+        ScDocument&         mrDoc;
+        const ScInterpreterContext& mrContext;
+        const ScAttrArray*  pAttrArray;
+        sal_uInt32          nNumFormat;     // for CalcAsShown
+        sal_uInt32          nNumFmtIndex;
+        SCCOL               nCol;
+        SCROW               nRow;
+        SCROW               nAttrEndRow;
+        SCTAB               nTab;
+        SvNumFormatType     nNumFmtType;
+        bool                bCalcAsShown;
+    };
+
+    class DataAccessMatrix final : public DataAccess
+    {
+    public:
+        DataAccessMatrix(ScDBQueryParamMatrix* pParam);
+        virtual ~DataAccessMatrix() override;
+        virtual bool getCurrent(Value& rValue) override;
+        virtual bool getFirst(Value& rValue) override;
+        virtual bool getNext(Value& rValue) override;
+
+    private:
+        bool isValidQuery(SCROW mnRow, const ScMatrix& rMat) const;
+
+        ScDBQueryParamMatrix* mpParam;
+        SCROW mnCurRow;
+        SCROW mnRows;
+    };
+
+    ::std::unique_ptr<ScDBQueryParamBase> mpParam;
+    ::std::unique_ptr<DataAccess>         mpData;
+
+public:
+                    ScDBQueryDataIterator(ScDocument& rDocument, const ScInterpreterContext& rContext, std::unique_ptr<ScDBQueryParamBase> pParam);
+    /// Does NOT reset rValue if no value found!
+    bool            GetFirst(Value& rValue);
+    /// Does NOT reset rValue if no value found!
+    bool            GetNext(Value& rValue);
+};
+
+class ScFormulaGroupIterator
+{
+private:
+    ScDocument& mrDoc;
+    SCTAB mnTab;
+    SCCOL mnCol;
+    bool mbNullCol;
+    size_t mnIndex;
+    std::vector<sc::FormulaGroupEntry> maEntries;
+
+public:
+    ScFormulaGroupIterator( ScDocument& rDoc );
+
+    sc::FormulaGroupEntry* first();
+    sc::FormulaGroupEntry* next();
+};
+
+/**
+ * Walk through all cells in an area. For SubTotal and Aggregate depending on mnSubTotalFlags.
+ **/
+class ScCellIterator
+{
+    typedef std::pair<sc::CellStoreType::const_iterator, size_t> PositionType;
+
+    ScDocument&   mrDoc;
+    ScAddress     maStartPos;
+    ScAddress     maEndPos;
+    ScAddress     maCurPos;
+
+    PositionType  maCurColPos;
+    SubtotalFlags mnSubTotalFlags;
+
+    ScRefCellValue maCurCell;
+
+    void incBlock();
+    void incPos();
+    void setPos(size_t nPos);
+
+    const ScColumn* getColumn() const;
+
+    void init();
+    bool getCurrent();
+
+public:
+    ScCellIterator( ScDocument& rDoc, const ScRange& rRange, SubtotalFlags nSubTotalFlags = SubtotalFlags::NONE );
+
+    const ScAddress& GetPos() const { return maCurPos; }
+
+    CellType getType() const { return maCurCell.meType;}
+    OUString getString() const;
+    const EditTextObject* getEditText() const { return maCurCell.mpEditText;}
+    ScFormulaCell* getFormulaCell() { return maCurCell.mpFormula;}
+    const ScFormulaCell* getFormulaCell() const { return maCurCell.mpFormula;}
+    ScCellValue getCellValue() const;
+    const ScRefCellValue& getRefCellValue() const { return maCurCell;}
+
+    bool hasString() const;
+    bool isEmpty() const;
+    bool equalsWithoutFormat( const ScAddress& rPos ) const;
+
+    bool first();
+    bool next();
+};
+
+class ScDocAttrIterator             // all attribute areas
+{
+private:
+    ScDocument&     rDoc;
+    SCTAB           nTab;
+    SCCOL           nEndCol;
+    SCROW           nStartRow;
+    SCROW           nEndRow;
+    SCCOL           nCol;
+    std::unique_ptr<ScAttrIterator>
+                    pColIter;
+
+public:
+                    ScDocAttrIterator(ScDocument& rDocument, SCTAB nTable,
+                                    SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
+                    ~ScDocAttrIterator();
+
+    const ScPatternAttr*    GetNext( SCCOL& rCol, SCROW& rRow1, SCROW& rRow2 );
+};
+
+class ScAttrRectIterator            // all attribute areas, including areas stretching
+                                    // across more than one column
+{
+private:
+    ScDocument&     rDoc;
+    SCTAB           nTab;
+    SCCOL           nEndCol;
+    SCROW           nStartRow;
+    SCROW           nEndRow;
+    SCCOL           nIterStartCol;
+    SCCOL           nIterEndCol;
+    std::unique_ptr<ScAttrIterator>
+                    pColIter;
+
+public:
+                    ScAttrRectIterator(ScDocument& rDocument, SCTAB nTable,
+                                    SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
+                    ~ScAttrRectIterator();
+
+    void                    DataChanged();
+    const ScPatternAttr*    GetNext( SCCOL& rCol1, SCCOL& rCol2, SCROW& rRow1, SCROW& rRow2 );
+};
+
+class ScHorizontalCellIterator      // walk through all non empty cells in an area
+{                                   // row by row
+    struct ColParam
+    {
+        sc::CellStoreType::const_iterator maPos;
+        sc::CellStoreType::const_iterator maEnd;
+        SCCOL mnCol;
+    };
+
+    std::vector<ColParam>::iterator maColPos;
+    std::vector<ColParam> maColPositions;
+
+    ScDocument&     rDoc;
+    SCTAB           mnTab;
+    SCCOL           nStartCol;
+    SCCOL           nEndCol;
+    SCROW           nStartRow;
+    SCROW           nEndRow;
+    SCCOL           mnCol;
+    SCROW           mnRow;
+    ScRefCellValue  maCurCell;
+    bool            mbMore;
+
+public:
+    ScHorizontalCellIterator(ScDocument& rDocument, SCTAB nTable,
+                    SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
+    ~ScHorizontalCellIterator();
+
+    ScRefCellValue* GetNext( SCCOL& rCol, SCROW& rRow );
+    bool            GetPos( SCCOL& rCol, SCROW& rRow );
+    /// Set a(nother) sheet and (re)init.
+    void            SetTab( SCTAB nTab );
+
+private:
+    void            Advance();
+    void            SkipInvalid();
+    bool            SkipInvalidInRow();
+    SCROW           FindNextNonEmptyRow();
+};
+
+/** Row-wise value iterator. */
+class ScHorizontalValueIterator
+{
+private:
+    ScDocument&               rDoc;
+    const ScAttrArray*        pAttrArray;
+    std::unique_ptr<ScHorizontalCellIterator>
+                              pCellIter;
+    sal_uInt32                nNumFormat;     // for CalcAsShown
+    SCTAB                     nEndTab;
+    SCCOL                     nCurCol;
+    SCROW                     nCurRow;
+    SCTAB                     nCurTab;
+    SCROW                     nAttrEndRow;
+    bool                      bCalcAsShown;
+
+public:
+
+                    ScHorizontalValueIterator( ScDocument& rDocument,
+                                               const ScRange& rRange );
+                    ~ScHorizontalValueIterator();
+    /// Does NOT reset rValue if no value found!
+    bool            GetNext( double& rValue, FormulaError& rErr );
+};
+
+class ScHorizontalAttrIterator
+{
+private:
+    ScDocument&             rDoc;
+    SCTAB                   nTab;
+    SCCOL                   nStartCol;
+    SCROW                   nStartRow;
+    SCCOL                   nEndCol;
+    SCROW                   nEndRow;
+
+    std::unique_ptr<SCROW[]>  pNextEnd;
+    std::unique_ptr<SCCOL[]>  pHorizEnd;
+    std::unique_ptr<SCSIZE[]> pIndices;
+    std::unique_ptr<const ScPatternAttr*[]>
+                              ppPatterns;
+    SCCOL                   nCol;
+    SCROW                   nRow;
+    SCROW                   nMinNextEnd;
+
+    void InitForNextRow(bool bInitialization);
+
+public:
+            ScHorizontalAttrIterator( ScDocument& rDocument, SCTAB nTable,
+                                    SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );
+            ~ScHorizontalAttrIterator();
+
+    const ScPatternAttr*    GetNext( SCCOL& rCol1, SCCOL& rCol2, SCROW& rRow );
+};
+
+//  returns non-empty cells and areas with formatting (horizontal)
+
+class SC_DLLPUBLIC ScUsedAreaIterator
+{
+private:
+    ScHorizontalCellIterator    aCellIter;
+    ScHorizontalAttrIterator    aAttrIter;
+
+    SCCOL                   nNextCol;
+    SCROW                   nNextRow;
+
+    SCCOL                   nCellCol;
+    SCROW                   nCellRow;
+    ScRefCellValue*         pCell;
+    SCCOL                   nAttrCol1;
+    SCCOL                   nAttrCol2;
+    SCROW                   nAttrRow;
+    const ScPatternAttr*    pPattern;
+
+    SCCOL                   nFoundStartCol;         // results after GetNext
+    SCCOL                   nFoundEndCol;
+    SCROW                   nFoundRow;
+    const ScPatternAttr*    pFoundPattern;
+
+    ScRefCellValue maFoundCell;
+
+public:
+            ScUsedAreaIterator( ScDocument& rDocument, SCTAB nTable,
+                                SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );
+            ~ScUsedAreaIterator();
+
+    bool    GetNext();
+
+    SCCOL                   GetStartCol() const     { return nFoundStartCol; }
+    SCCOL                   GetEndCol() const       { return nFoundEndCol; }
+    SCROW                   GetRow() const          { return nFoundRow; }
+    const ScPatternAttr*    GetPattern() const      { return pFoundPattern; }
+    const ScRefCellValue&   GetCell() const { return maFoundCell;}
+};
+
+class ScRowBreakIterator
+{
+public:
+    static constexpr SCROW NOT_FOUND = -1;
+
+    explicit ScRowBreakIterator(::std::set<SCROW>& rBreaks);
+    SCROW first();
+    SCROW next();
+
+private:
+    ::std::set<SCROW>& mrBreaks;
+    ::std::set<SCROW>::const_iterator maItr;
+    ::std::set<SCROW>::const_iterator maEnd;
+};
+
+class ScDocRowHeightUpdater
+{
+public:
+    struct TabRanges
+    {
+        SCTAB mnTab;
+        ScFlatBoolRowSegments maRanges;
+
+        TabRanges(SCTAB nTab, SCROW nMaxRow);
+    };
+
+    /**
+     * Passing a NULL pointer to pTabRangesArray forces the heights of all
+     * rows in all tables to be updated.
+     */
+    explicit ScDocRowHeightUpdater(
+        ScDocument& rDoc, OutputDevice* pOutDev, double fPPTX, double fPPTY,
+        const ::std::vector<TabRanges>* pTabRangesArray);
+
+    void update();
+
+private:
+    void updateAll();
+
+private:
+    ScDocument& mrDoc;
+    VclPtr<OutputDevice> mpOutDev;
+    double mfPPTX;
+    double mfPPTY;
+    const ::std::vector<TabRanges>* mpTabRangesArray;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */