sc/source/ui/inc/TableFillingAndNavigationTools.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  */
  10
  11 #pragma once
  12
  13 #include <address.hxx>
  14 #include <rangelst.hxx>
  15
  16 #include <map>
  17 #include <vector>
  18
  19 class FormulaTemplate
  20 {
  21 private:
  22     OUString            mTemplate;
  23     ScDocument*         mpDoc;
  24     bool                mbUse3D;
  25
  26     typedef std::map<OUString, ScRange>   RangeReplacementMap;
  27     typedef std::map<OUString, ScAddress> AddressReplacementMap;
  28
  29     AddressReplacementMap mAddressReplacementMap;
  30     RangeReplacementMap   mRangeReplacementMap;
  31
  32 public:
  33     FormulaTemplate(ScDocument* pDoc);
  34
  35     void      setTemplate(const OUString& aTemplate);
  36     void      setTemplate(const char* aTemplate);
  37     const OUString& getTemplate();
  38
  39     void      autoReplaceRange(const OUString& aVariable, const ScRange& rRange);
  40     void      autoReplaceAddress(const OUString& aVariable, ScAddress const & aAddress);
  41     void      autoReplaceUses3D(bool bUse3D) { mbUse3D = bUse3D; }
  42
  43     void      applyRange(std::u16string_view aVariable, const ScRange& aRange, bool b3D = true);
  44     void      applyRangeList(std::u16string_view aVariable, const ScRangeList& aRangeList, sal_Unicode cDelimiter );
  45     void      applyAddress(std::u16string_view aVariable, const ScAddress& aAddress, bool b3D = true);
  46     void      applyString(std::u16string_view aVariable, std::u16string_view aValue);
  47     void      applyNumber(std::u16string_view aVariable, sal_Int32 aValue);
  48 };
  49
  50 class AddressWalker
  51 {
  52 public:
  53     std::vector<ScAddress> mAddressStack;
  54
  55     ScAddress mCurrentAddress;
  56     ScAddress mMinimumAddress;
  57     ScAddress mMaximumAddress;
  58
  59     AddressWalker(const ScAddress& aInitialAddress);
  60
  61     ScAddress current(SCCOL aRelativeCol = 0, SCROW aRelativeRow = 0, SCTAB aRelativeTab = 0);
  62
  63     void reset();
  64     void resetColumn();
  65     void resetRow();
  66     void nextColumn();
  67     void nextRow();
  68     void newLine();
  69     void push(SCCOL aRelativeCol = 0, SCROW aRelativeRow = 0, SCTAB aRelativeTab = 0);
  70 };
  71
  72 class AddressWalkerWriter : public AddressWalker
  73 {
  74     ScDocShell*                         mpDocShell;
  75     ScDocument&                         mrDocument;
  76     formula::FormulaGrammar::Grammar    meGrammar;
  77
  78 public:
  79     AddressWalkerWriter(const ScAddress& aInitialAddress, ScDocShell* pDocShell, ScDocument& rDocument,
  80             formula::FormulaGrammar::Grammar eGrammar );
  81
  82     void writeFormula(const OUString& aFormula);
  83     void writeFormulas(const std::vector<OUString>& rFormulas);
  84     void writeMatrixFormula(const OUString& aFormula, SCCOL nCols = 1, SCROW nRows = 1);
  85     void writeString(const OUString& aString);
  86     void writeString(const char* aCharArray);
  87     void writeBoldString(const OUString& aString);
  88     void writeValue(double aValue);
  89 };
  90
  91 class DataCellIterator final
  92 {
  93 private:
  94     ScRange mInputRange;
  95     bool    mByColumn;
  96     SCCOL   mCol;
  97     SCROW   mRow;
  98
  99 public:
 100     DataCellIterator(const ScRange& aInputRange, bool aByColumn);
 101
 102     bool hasNext() const;
 103     ScAddress get();
 104     void next();
 105     ScAddress getRelative(int aDelta);
 106 };
 107
 108 class DataRangeIterator
 109 {
 110 protected:
 111     ScRange   mInputRange;
 112     sal_Int32 mIndex;
 113
 114 public:
 115     DataRangeIterator(const ScRange& aInputRange);
 116     virtual ~DataRangeIterator();
 117
 118     virtual bool hasNext() = 0;
 119     virtual ScRange get() = 0;
 120     virtual size_t size() = 0;
 121     virtual void next() = 0;
 122     virtual void reset() = 0;
 123
 124     sal_Int32 index();
 125
 126     virtual DataCellIterator iterateCells() = 0;
 127 };
 128
 129 class DataRangeByColumnIterator final : public DataRangeIterator
 130 {
 131     SCCOL mCol;
 132
 133 public:
 134     DataRangeByColumnIterator(const ScRange& aInputRange);
 135
 136     virtual bool hasNext() override;
 137     virtual void next() override;
 138     virtual ScRange get() override;
 139     virtual size_t size() override;
 140     virtual void reset() override;
 141     virtual DataCellIterator iterateCells() override;
 142 };
 143
 144 class DataRangeByRowIterator final : public DataRangeIterator
 145 {
 146     SCROW mRow;
 147
 148 public:
 149     DataRangeByRowIterator(const ScRange& aInputRange);
 150
 151     virtual bool hasNext() override;
 152     virtual void next() override;
 153     virtual ScRange get() override;
 154     virtual size_t size() override;
 155     virtual void reset() override;
 156     virtual DataCellIterator iterateCells() override;
 157 };
 158
 159 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */