diff options
Diffstat (limited to 'sc/inc/dociter.hxx')
| -rw-r--r-- | sc/inc/dociter.hxx | 473 |
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: */ |