sc/source/ui/StatisticsDialogs/TableFillingAndNavigationTools.cxx

   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 #include <boost/scoped_ptr.hpp>
  12
  13 #include <editeng/editobj.hxx>
  14 #include <editeng/wghtitem.hxx>
  15 #include <editeng/eeitem.hxx>
  16
  17 #include "editutil.hxx"
  18
  19 #include "TableFillingAndNavigationTools.hxx"
  20
  21 FormulaTemplate::FormulaTemplate(ScDocument* pDoc) : mpDoc(pDoc) {}
  22
  23 void FormulaTemplate::setTemplate(const OUString& aTemplate)
  24 {
  25     mTemplate = aTemplate;
  26 }
  27
  28 void FormulaTemplate::setTemplate(const char* aTemplate)
  29 {
  30     mTemplate = OUString::createFromAscii(aTemplate);
  31 }
  32
  33 const OUString& FormulaTemplate::getTemplate()
  34 {
  35     RangeReplacementMap::iterator itRange;
  36     for (itRange = mRangeReplacementMap.begin(); itRange != mRangeReplacementMap.end(); ++itRange)
  37     {
  38         applyRange(itRange->first, itRange->second);
  39     }
  40     AddressReplacementMap::iterator itAddress;
  41     for (itAddress = mAddressReplacementMap.begin(); itAddress != mAddressReplacementMap.end(); ++itAddress)
  42     {
  43         applyAddress(itAddress->first, itAddress->second);
  44     }
  45     return mTemplate;
  46 }
  47
  48 void FormulaTemplate::autoReplaceRange(const OUString& aVariable, const ScRange& rRange)
  49 {
  50     mRangeReplacementMap.insert ( std::pair<OUString, ScRange>(aVariable, rRange) );
  51 }
  52
  53 void FormulaTemplate::autoReplaceAddress(const OUString& aVariable, ScAddress aAddress)
  54 {
  55     mAddressReplacementMap.insert ( std::pair<OUString, ScAddress>(aVariable, aAddress) );
  56 }
  57
  58 void FormulaTemplate::applyRange(const OUString& aVariable, const ScRange& aRange, bool b3D)
  59 {
  60     sal_uInt16 nFlag = b3D ? SCR_ABS_3D : SCR_ABS;
  61     OUString aString = aRange.Format(nFlag, mpDoc, mpDoc->GetAddressConvention());
  62     mTemplate = mTemplate.replaceAll(aVariable, aString);
  63 }
  64
  65 void FormulaTemplate::applyRangeList(const OUString& aVariable, const ScRangeList& aRangeList, bool b3D)
  66 {
  67     sal_uInt16 nFlag = b3D ? SCR_ABS_3D : SCR_ABS;
  68     OUString aString;
  69     aRangeList.Format(aString, nFlag, mpDoc, mpDoc->GetAddressConvention());
  70     mTemplate = mTemplate.replaceAll(aVariable, aString);
  71 }
  72
  73 void FormulaTemplate::applyAddress(const OUString& aVariable, const ScAddress& aAddress, bool b3D)
  74 {
  75     sal_uInt16 nFlag = b3D ? SCA_ABS_3D : SCA_ABS;
  76     OUString aString = aAddress.Format(nFlag, mpDoc, mpDoc->GetAddressConvention());
  77     mTemplate = mTemplate.replaceAll(aVariable, aString);
  78 }
  79
  80 void FormulaTemplate::applyString(const OUString& aVariable, const OUString& aValue)
  81 {
  82     mTemplate = mTemplate.replaceAll(aVariable, aValue);
  83 }
  84
  85 void FormulaTemplate::applyNumber(const OUString& aVariable, sal_Int32 aValue)
  86 {
  87     mTemplate = mTemplate.replaceAll(aVariable, OUString::number(aValue));
  88 }
  89
  90 AddressWalker::AddressWalker(ScAddress aInitialAddress, bool aTrackRange) :
  91     mCurrentAddress(aInitialAddress),
  92     mMinimumAddress(aInitialAddress),
  93     mMaximumAddress(aInitialAddress),
  94     mTrackRange(aTrackRange)
  95 {
  96     mAddressStack.push_back(mCurrentAddress);
  97 }
  98
  99 void AddressWalker::resetColumn()
 100 {
 101     mCurrentAddress.SetCol(mAddressStack.back().Col());
 102 }
 103
 104 void AddressWalker::resetRow()
 105 {
 106     mCurrentAddress.SetRow(mAddressStack.back().Row());
 107 }
 108
 109 void AddressWalker::reset()
 110 {
 111     mCurrentAddress = mAddressStack.back();
 112 }
 113
 114 void AddressWalker::newLine()
 115 {
 116     resetColumn();
 117     nextRow();
 118 }
 119
 120 ScAddress AddressWalker::current(SCCOL aRelCol, SCROW aRelRow, SCTAB aRelTab)
 121 {
 122     return ScAddress(
 123             mCurrentAddress.Col() + aRelCol,
 124             mCurrentAddress.Row() + aRelRow,
 125             mCurrentAddress.Tab() + aRelTab);
 126 }
 127
 128 void AddressWalker::nextColumn()
 129 {
 130     mCurrentAddress.IncCol();
 131
 132     if (mTrackRange)
 133     {
 134         if(mMaximumAddress.Col() < mCurrentAddress.Col())
 135             mMaximumAddress.SetCol(mCurrentAddress.Col());
 136     }
 137 }
 138
 139 void AddressWalker::nextRow()
 140 {
 141     mCurrentAddress.IncRow();
 142     if (mTrackRange)
 143     {
 144         if(mMaximumAddress.Row() < mCurrentAddress.Row())
 145             mMaximumAddress.SetRow(mCurrentAddress.Row());
 146     }
 147 }
 148
 149 void AddressWalker::push(SCCOL aRelativeCol, SCROW aRelativeRow, SCTAB aRelativeTab)
 150 {
 151     mCurrentAddress = current(aRelativeCol, aRelativeRow, aRelativeTab);
 152     mAddressStack.push_back(mCurrentAddress);
 153 }
 154
 155 AddressWalkerWriter::AddressWalkerWriter(ScAddress aInitialAddress, ScDocShell* pDocShell, ScDocument* pDocument,
 156         formula::FormulaGrammar::Grammar eGrammar ) :
 157     AddressWalker(aInitialAddress, true),
 158     mpDocShell(pDocShell),
 159     mpDocument(pDocument),
 160     meGrammar(eGrammar)
 161 {}
 162
 163 void AddressWalkerWriter::writeFormula(const OUString& aFormula)
 164 {
 165     mpDocShell->GetDocFunc().SetFormulaCell(mCurrentAddress,
 166             new ScFormulaCell(mpDocument, mCurrentAddress, aFormula, meGrammar), true);
 167 }
 168
 169 void AddressWalkerWriter::writeMatrixFormula(const OUString& aFormula)
 170 {
 171     ScRange aRange;
 172     aRange.aStart = mCurrentAddress;
 173     aRange.aEnd = mCurrentAddress;
 174     mpDocShell->GetDocFunc().EnterMatrix(aRange, NULL, NULL, aFormula, false, false, OUString(), meGrammar );
 175 }
 176
 177 void AddressWalkerWriter::writeString(const OUString& aString)
 178 {
 179     mpDocShell->GetDocFunc().SetStringCell(mCurrentAddress, aString, true);
 180 }
 181
 182 void AddressWalkerWriter::writeString(const char* aCharArray)
 183 {
 184     writeString(OUString::createFromAscii(aCharArray));
 185 }
 186
 187 void AddressWalkerWriter::writeBoldString(const OUString& aString)
 188 {
 189     ScFieldEditEngine& rEngine = mpDocument->GetEditEngine();
 190     rEngine.SetText(aString);
 191     SfxItemSet aItemSet = rEngine.GetEmptyItemSet();
 192     SvxWeightItem aWeight(WEIGHT_BOLD, EE_CHAR_WEIGHT);
 193     aItemSet.Put(aWeight);
 194     rEngine.QuickSetAttribs(aItemSet, ESelection(0, 0, 0, aString.getLength()) );
 195     boost::scoped_ptr<EditTextObject> pEditText(rEngine.CreateTextObject());
 196     mpDocShell->GetDocFunc().SetEditCell(mCurrentAddress, *pEditText, true);
 197 }
 198
 199 void AddressWalkerWriter::writeValue(double aValue)
 200 {
 201     mpDocShell->GetDocFunc().SetValueCell(mCurrentAddress, aValue, true);
 202 }
 203
 204 // DataCellIterator
 205
 206 DataCellIterator::DataCellIterator(ScRange aInputRange, bool aByColumn)
 207     : mInputRange(aInputRange)
 208     , mByColumn(aByColumn)
 209     , mCol(0)
 210     , mRow(0)
 211 {
 212     if(aByColumn)
 213         mCol = aInputRange.aStart.Col();
 214     else
 215         mRow = aInputRange.aStart.Row();
 216 }
 217
 218 DataCellIterator::~DataCellIterator()
 219 {}
 220
 221 bool DataCellIterator::hasNext()
 222 {
 223     if(mByColumn)
 224         return mCol <= mInputRange.aEnd.Col();
 225     else
 226         return mRow <= mInputRange.aEnd.Row();
 227 }
 228
 229 void DataCellIterator::next()
 230 {
 231     if(mByColumn)
 232         mCol++;
 233     else
 234         mRow++;
 235 }
 236
 237 ScAddress DataCellIterator::get()
 238 {
 239     return getRelative(0);
 240 }
 241
 242 ScAddress DataCellIterator::getRelative(int aDelta)
 243 {
 244     if(mByColumn)
 245     {
 246         SCCOL aNewColumn = mCol + aDelta;
 247         if(aNewColumn < mInputRange.aStart.Col() || aNewColumn > mInputRange.aEnd.Col())
 248         {
 249             ScAddress aResult;
 250             aResult.SetInvalid();
 251             return aResult;
 252         }
 253         return ScAddress(aNewColumn, mInputRange.aStart.Row(), mInputRange.aStart.Tab());
 254     }
 255     else
 256     {
 257         SCROW aNewRow = mRow + aDelta;
 258         if(aNewRow < mInputRange.aStart.Row() || aNewRow > mInputRange.aEnd.Row())
 259         {
 260             ScAddress aResult;
 261             aResult.SetInvalid();
 262             return aResult;
 263         }
 264         return ScAddress(mInputRange.aStart.Col(), aNewRow, mInputRange.aStart.Tab());
 265     }
 266 }
 267
 268 // DataRangeIterator
 269
 270 DataRangeIterator::DataRangeIterator(ScRange aInputRange) :
 271     mInputRange(aInputRange),
 272     mIndex(0)
 273 {}
 274
 275 DataRangeIterator::~DataRangeIterator()
 276 {}
 277
 278 sal_Int32 DataRangeIterator::index()
 279 {
 280     return mIndex;
 281 }
 282
 283 // DataRangeByColumnIterator
 284
 285 DataRangeByColumnIterator::DataRangeByColumnIterator(ScRange aInputRange) :
 286     DataRangeIterator(aInputRange),
 287     mCol(aInputRange.aStart.Col())
 288 {}
 289
 290 bool DataRangeByColumnIterator::hasNext()
 291 {
 292     return mCol <= mInputRange.aEnd.Col();
 293 }
 294
 295 void DataRangeByColumnIterator::next()
 296 {
 297     mCol++;
 298     mIndex++;
 299 }
 300
 301 ScRange DataRangeByColumnIterator::get()
 302 {
 303     return ScRange(
 304         ScAddress(mCol, mInputRange.aStart.Row(), mInputRange.aStart.Tab()),
 305         ScAddress(mCol, mInputRange.aEnd.Row(),   mInputRange.aEnd.Tab())
 306     );
 307 }
 308
 309 void DataRangeByColumnIterator::reset()
 310 {
 311     mCol = mInputRange.aStart.Col();
 312 }
 313
 314 DataCellIterator DataRangeByColumnIterator::iterateCells()
 315 {
 316     return DataCellIterator(get(), false);
 317 }
 318
 319 // DataRangeByRowIterator
 320
 321 DataRangeByRowIterator::DataRangeByRowIterator(ScRange aInputRange) :
 322     DataRangeIterator(aInputRange),
 323     mRow(aInputRange.aStart.Row())
 324 {}
 325
 326 bool DataRangeByRowIterator::hasNext()
 327 {
 328     return mRow <= mInputRange.aEnd.Row();
 329 }
 330
 331 void DataRangeByRowIterator::next()
 332 {
 333     mRow++;
 334     mIndex++;
 335 }
 336
 337 ScRange DataRangeByRowIterator::get()
 338 {
 339     return ScRange(
 340         ScAddress(mInputRange.aStart.Col(), mRow, mInputRange.aStart.Tab()),
 341         ScAddress(mInputRange.aEnd.Col(),   mRow, mInputRange.aEnd.Tab())
 342     );
 343 }
 344
 345 void DataRangeByRowIterator::reset()
 346 {
 347     mRow = mInputRange.aStart.Row();
 348 }
 349
 350 DataCellIterator DataRangeByRowIterator::iterateCells()
 351 {
 352     return DataCellIterator(get(), true);
 353 }
 354
 355 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */