sc/inc/dociter.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #pragma once
  21
  22 #include "address.hxx"
  23 #include "formulagroup.hxx"
  24 #include "global.hxx"
  25 #include "scdllapi.h"
  26 #include "cellvalue.hxx"
  27 #include "mtvelements.hxx"
  28 #include "queryparam.hxx"
  29 #include <vcl/outdev.hxx>
  30 #include <vcl/vclptr.hxx>
  31
  32 #include <memory>
  33 #include <set>
  34 #include <vector>
  35
  36 class ScDocument;
  37 class ScPatternAttr;
  38 class ScAttrArray;
  39 class ScAttrIterator;
  40 class ScFlatBoolRowSegments;
  41 class ScMatrix;
  42 struct ScDBQueryParamBase;
  43 struct ScQueryParam;
  44 struct ScDBQueryParamInternal;
  45 struct ScDBQueryParamMatrix;
  46 class ScFormulaCell;
  47 class OutputDevice;
  48 struct ScInterpreterContext;
  49 enum class SvNumFormatType : sal_Int16;
  50
  51 class ScValueIterator            // walk through all values in an area
  52 {
  53     typedef sc::CellStoreType::const_position_type PositionType;
  54
  55     const ScDocument& mrDoc;
  56     ScInterpreterContext& mrContext;
  57     const ScAttrArray*  pAttrArray;
  58     sal_uInt32      nNumFormat;     // for CalcAsShown
  59     sal_uInt32      nNumFmtIndex;
  60     ScAddress       maStartPos;
  61     ScAddress       maEndPos;
  62     SCCOL           mnCol;
  63     SCTAB           mnTab;
  64     SCROW           nAttrEndRow;
  65     SubtotalFlags   mnSubTotalFlags;
  66     SvNumFormatType nNumFmtType;
  67     bool            bNumValid;
  68     bool            bCalcAsShown;
  69     bool            bTextAsZero;
  70
  71     const sc::CellStoreType* mpCells;
  72     PositionType maCurPos;
  73
  74     SCROW GetRow() const;
  75     void IncBlock();
  76     void IncPos();
  77
  78     /**
  79      * See if the cell at the current position is a non-empty cell. If not,
  80      * move to the next non-empty cell position.
  81      */
  82     bool GetThis( double& rValue, FormulaError& rErr );
  83
  84 public:
  85
  86     ScValueIterator(ScInterpreterContext& rContext,
  87         const ScRange& rRange, SubtotalFlags nSubTotalFlags = SubtotalFlags::NONE,
  88         bool bTextAsZero = false );
  89
  90     void GetCurNumFmtInfo( SvNumFormatType& nType, sal_uInt32& nIndex );
  91
  92     /// Does NOT reset rValue if no value found!
  93     bool GetFirst( double& rValue, FormulaError& rErr );
  94
  95     /// Does NOT reset rValue if no value found!
  96     bool GetNext( double& rValue, FormulaError& rErr );
  97 };
  98
  99 class ScDBQueryDataIterator
 100 {
 101 public:
 102     struct Value
 103     {
 104         OUString        maString;
 105         double          mfValue;
 106         FormulaError    mnError;
 107         bool            mbIsNumber;
 108
 109         Value();
 110     };
 111
 112 private:
 113     static const sc::CellStoreType* GetColumnCellStore(ScDocument& rDoc, SCTAB nTab, SCCOL nCol);
 114     static const ScAttrArray* GetAttrArrayByCol(ScDocument& rDoc, SCTAB nTab, SCCOL nCol);
 115     static bool IsQueryValid(ScDocument& rDoc, const ScQueryParam& rParam, SCTAB nTab, SCROW nRow, const ScRefCellValue* pCell);
 116
 117     class DataAccess
 118     {
 119     public:
 120         DataAccess();
 121         virtual ~DataAccess() = 0;
 122         virtual bool getCurrent(Value& rValue) = 0;
 123         virtual bool getFirst(Value& rValue) = 0;
 124         virtual bool getNext(Value& rValue) = 0;
 125     };
 126
 127     class DataAccessInternal final : public DataAccess
 128     {
 129         typedef std::pair<sc::CellStoreType::const_iterator,size_t> PositionType;
 130     public:
 131         DataAccessInternal(ScDBQueryParamInternal* pParam, ScDocument& rDoc, const ScInterpreterContext& rContext);
 132         virtual ~DataAccessInternal() override;
 133         virtual bool getCurrent(Value& rValue) override;
 134         virtual bool getFirst(Value& rValue) override;
 135         virtual bool getNext(Value& rValue) override;
 136
 137     private:
 138         void incBlock();
 139         void incPos();
 140
 141         const sc::CellStoreType* mpCells;
 142         PositionType maCurPos;
 143         ScDBQueryParamInternal* mpParam;
 144         ScDocument&         mrDoc;
 145         const ScInterpreterContext& mrContext;
 146         const ScAttrArray*  pAttrArray;
 147         sal_uInt32          nNumFormat;     // for CalcAsShown
 148         sal_uInt32          nNumFmtIndex;
 149         SCCOL               nCol;
 150         SCROW               nRow;
 151         SCROW               nAttrEndRow;
 152         SCTAB               nTab;
 153         SvNumFormatType     nNumFmtType;
 154         bool                bCalcAsShown;
 155     };
 156
 157     class DataAccessMatrix final : public DataAccess
 158     {
 159     public:
 160         DataAccessMatrix(ScDBQueryParamMatrix* pParam);
 161         virtual ~DataAccessMatrix() override;
 162         virtual bool getCurrent(Value& rValue) override;
 163         virtual bool getFirst(Value& rValue) override;
 164         virtual bool getNext(Value& rValue) override;
 165
 166     private:
 167         bool isValidQuery(SCROW mnRow, const ScMatrix& rMat) const;
 168
 169         ScDBQueryParamMatrix* mpParam;
 170         SCROW mnCurRow;
 171         SCROW mnRows;
 172     };
 173
 174     ::std::unique_ptr<ScDBQueryParamBase> mpParam;
 175     ::std::unique_ptr<DataAccess>         mpData;
 176
 177 public:
 178                     ScDBQueryDataIterator(ScDocument& rDocument, const ScInterpreterContext& rContext, std::unique_ptr<ScDBQueryParamBase> pParam);
 179     /// Does NOT reset rValue if no value found!
 180     bool            GetFirst(Value& rValue);
 181     /// Does NOT reset rValue if no value found!
 182     bool            GetNext(Value& rValue);
 183 };
 184
 185 class ScFormulaGroupIterator
 186 {
 187 private:
 188     ScDocument& mrDoc;
 189     SCTAB mnTab;
 190     SCCOL mnCol;
 191     bool mbNullCol;
 192     size_t mnIndex;
 193     std::vector<sc::FormulaGroupEntry> maEntries;
 194
 195 public:
 196     ScFormulaGroupIterator( ScDocument& rDoc );
 197
 198     sc::FormulaGroupEntry* first();
 199     sc::FormulaGroupEntry* next();
 200 };
 201
 202 /**
 203  * Walk through all cells in an area. For SubTotal and Aggregate depending on mnSubTotalFlags.
 204  **/
 205 class ScCellIterator
 206 {
 207     typedef std::pair<sc::CellStoreType::const_iterator, size_t> PositionType;
 208
 209     ScDocument&   mrDoc;
 210     ScAddress     maStartPos;
 211     ScAddress     maEndPos;
 212     ScAddress     maCurPos;
 213
 214     PositionType  maCurColPos;
 215     SubtotalFlags mnSubTotalFlags;
 216
 217     ScRefCellValue maCurCell;
 218
 219     void incBlock();
 220     void incPos();
 221     void setPos(size_t nPos);
 222
 223     const ScColumn* getColumn() const;
 224
 225     void init();
 226     bool getCurrent();
 227
 228 public:
 229     ScCellIterator( ScDocument& rDoc, const ScRange& rRange, SubtotalFlags nSubTotalFlags = SubtotalFlags::NONE );
 230
 231     const ScAddress& GetPos() const { return maCurPos; }
 232
 233     CellType getType() const { return maCurCell.getType();}
 234     OUString getString() const;
 235     const EditTextObject* getEditText() const { return maCurCell.getEditText();}
 236     ScFormulaCell* getFormulaCell() { return maCurCell.getFormula();}
 237     const ScFormulaCell* getFormulaCell() const { return maCurCell.getFormula();}
 238     ScCellValue getCellValue() const;
 239     const ScRefCellValue& getRefCellValue() const { return maCurCell;}
 240
 241     bool hasString() const;
 242     bool isEmpty() const;
 243     bool equalsWithoutFormat( const ScAddress& rPos ) const;
 244
 245     bool first();
 246     bool next();
 247 };
 248
 249 class ScDocAttrIterator             // all attribute areas
 250 {
 251 private:
 252     ScDocument&     rDoc;
 253     SCTAB           nTab;
 254     SCCOL           nEndCol;
 255     SCROW           nStartRow;
 256     SCROW           nEndRow;
 257     SCCOL           nCol;
 258     std::unique_ptr<ScAttrIterator>
 259                     pColIter;
 260
 261 public:
 262                     ScDocAttrIterator(ScDocument& rDocument, SCTAB nTable,
 263                                     SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
 264                     ~ScDocAttrIterator();
 265
 266     const ScPatternAttr*    GetNext( SCCOL& rCol, SCROW& rRow1, SCROW& rRow2 );
 267 };
 268
 269 class ScAttrRectIterator            // all attribute areas, including areas stretching
 270                                     // across more than one column
 271 {
 272 private:
 273     ScDocument&     rDoc;
 274     SCTAB           nTab;
 275     SCCOL           nEndCol;
 276     SCROW           nStartRow;
 277     SCROW           nEndRow;
 278     SCCOL           nIterStartCol;
 279     SCCOL           nIterEndCol;
 280     std::unique_ptr<ScAttrIterator>
 281                     pColIter;
 282
 283 public:
 284                     ScAttrRectIterator(ScDocument& rDocument, SCTAB nTable,
 285                                     SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
 286                     ~ScAttrRectIterator();
 287
 288     void                    DataChanged();
 289     const ScPatternAttr*    GetNext( SCCOL& rCol1, SCCOL& rCol2, SCROW& rRow1, SCROW& rRow2 );
 290 };
 291
 292 class ScHorizontalCellIterator      // walk through all non empty cells in an area
 293 {                                   // row by row
 294     struct ColParam
 295     {
 296         sc::CellStoreType::const_iterator maPos;
 297         sc::CellStoreType::const_iterator maEnd;
 298         SCCOL mnCol;
 299     };
 300
 301     std::vector<ColParam>::iterator maColPos;
 302     std::vector<ColParam> maColPositions;
 303
 304     ScDocument&     rDoc;
 305     SCTAB           mnTab;
 306     SCCOL           nStartCol;
 307     SCCOL           nEndCol;
 308     SCROW           nStartRow;
 309     SCROW           nEndRow;
 310     SCCOL           mnCol;
 311     SCROW           mnRow;
 312     ScRefCellValue  maCurCell;
 313     bool            mbMore;
 314
 315 public:
 316     ScHorizontalCellIterator(ScDocument& rDocument, SCTAB nTable,
 317                     SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
 318     ~ScHorizontalCellIterator();
 319
 320     ScRefCellValue* GetNext( SCCOL& rCol, SCROW& rRow );
 321     bool            GetPos( SCCOL& rCol, SCROW& rRow );
 322     /// Set a(nother) sheet and (re)init.
 323     void            SetTab( SCTAB nTab );
 324
 325 private:
 326     void            Advance();
 327     void            SkipInvalid();
 328     bool            SkipInvalidInRow();
 329     SCROW           FindNextNonEmptyRow();
 330 };
 331
 332 /** Row-wise value iterator. */
 333 class ScHorizontalValueIterator
 334 {
 335 private:
 336     ScDocument&               rDoc;
 337     const ScAttrArray*        pAttrArray;
 338     std::unique_ptr<ScHorizontalCellIterator>
 339                               pCellIter;
 340     sal_uInt32                nNumFormat;     // for CalcAsShown
 341     SCTAB                     nEndTab;
 342     SCCOL                     nCurCol;
 343     SCROW                     nCurRow;
 344     SCTAB                     nCurTab;
 345     SCROW                     nAttrEndRow;
 346     bool                      bCalcAsShown;
 347
 348 public:
 349
 350                     ScHorizontalValueIterator( ScDocument& rDocument,
 351                                                const ScRange& rRange );
 352                     ~ScHorizontalValueIterator();
 353     /// Does NOT reset rValue if no value found!
 354     bool            GetNext( double& rValue, FormulaError& rErr );
 355 };
 356
 357 class ScHorizontalAttrIterator
 358 {
 359 private:
 360     ScDocument&             rDoc;
 361     SCTAB                   nTab;
 362     SCCOL                   nStartCol;
 363     SCROW                   nStartRow;
 364     SCCOL                   nEndCol;
 365     SCROW                   nEndRow;
 366
 367     std::unique_ptr<SCROW[]>  pNextEnd;
 368     std::unique_ptr<SCCOL[]>  pHorizEnd;
 369     std::unique_ptr<SCSIZE[]> pIndices;
 370     std::unique_ptr<const ScPatternAttr*[]>
 371                               ppPatterns;
 372     SCCOL                   nCol;
 373     SCROW                   nRow;
 374     SCROW                   nMinNextEnd;
 375
 376     void InitForNextRow(bool bInitialization);
 377
 378 public:
 379             ScHorizontalAttrIterator( ScDocument& rDocument, SCTAB nTable,
 380                                     SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );
 381             ~ScHorizontalAttrIterator();
 382
 383     const ScPatternAttr*    GetNext( SCCOL& rCol1, SCCOL& rCol2, SCROW& rRow );
 384 };
 385
 386 //  returns non-empty cells and areas with formatting (horizontal)
 387
 388 class SC_DLLPUBLIC ScUsedAreaIterator
 389 {
 390 private:
 391     ScHorizontalCellIterator    aCellIter;
 392     ScHorizontalAttrIterator    aAttrIter;
 393
 394     SCCOL                   nNextCol;
 395     SCROW                   nNextRow;
 396
 397     SCCOL                   nCellCol;
 398     SCROW                   nCellRow;
 399     ScRefCellValue*         pCell;
 400     SCCOL                   nAttrCol1;
 401     SCCOL                   nAttrCol2;
 402     SCROW                   nAttrRow;
 403     const ScPatternAttr*    pPattern;
 404
 405     SCCOL                   nFoundStartCol;         // results after GetNext
 406     SCCOL                   nFoundEndCol;
 407     SCROW                   nFoundRow;
 408     const ScPatternAttr*    pFoundPattern;
 409
 410     ScRefCellValue maFoundCell;
 411
 412 public:
 413             ScUsedAreaIterator( ScDocument& rDocument, SCTAB nTable,
 414                                 SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 );
 415             ~ScUsedAreaIterator();
 416
 417     bool    GetNext();
 418
 419     SCCOL                   GetStartCol() const     { return nFoundStartCol; }
 420     SCCOL                   GetEndCol() const       { return nFoundEndCol; }
 421     SCROW                   GetRow() const          { return nFoundRow; }
 422     const ScPatternAttr*    GetPattern() const      { return pFoundPattern; }
 423     const ScRefCellValue&   GetCell() const { return maFoundCell;}
 424 };
 425
 426 class ScRowBreakIterator
 427 {
 428 public:
 429     static constexpr SCROW NOT_FOUND = -1;
 430
 431     explicit ScRowBreakIterator(::std::set<SCROW>& rBreaks);
 432     SCROW first();
 433     SCROW next();
 434
 435 private:
 436     ::std::set<SCROW>& mrBreaks;
 437     ::std::set<SCROW>::const_iterator maItr;
 438     ::std::set<SCROW>::const_iterator maEnd;
 439 };
 440
 441 class ScDocRowHeightUpdater
 442 {
 443 public:
 444     struct TabRanges
 445     {
 446         SCTAB mnTab;
 447         ScFlatBoolRowSegments maRanges;
 448
 449         TabRanges(SCTAB nTab, SCROW nMaxRow);
 450     };
 451
 452     /**
 453      * Passing a NULL pointer to pTabRangesArray forces the heights of all
 454      * rows in all tables to be updated.
 455      */
 456     explicit ScDocRowHeightUpdater(
 457         ScDocument& rDoc, OutputDevice* pOutDev, double fPPTX, double fPPTY,
 458         const ::std::vector<TabRanges>* pTabRangesArray);
 459
 460     void update();
 461
 462 private:
 463     void updateAll();
 464
 465 private:
 466     ScDocument& mrDoc;
 467     VclPtr<OutputDevice> mpOutDev;
 468     double mfPPTX;
 469     double mfPPTY;
 470     const ::std::vector<TabRanges>* mpTabRangesArray;
 471 };
 472
 473 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */