sc/source/core/data/columnspanset.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 #include "columnspanset.hxx"
  11 #include "stlalgorithm.hxx"
  12 #include "column.hxx"
  13 #include "table.hxx"
  14 #include "document.hxx"
  15 #include "mtvfunctions.hxx"
  16 #include "markdata.hxx"
  17 #include "rangelst.hxx"
  18
  19 #include <algorithm>
  20
  21 namespace sc {
  22
  23 ColumnSpanSet::ColumnType::ColumnType(SCROW nStart, SCROW nEnd, bool bInit) :
  24     maSpans(nStart, nEnd+1, bInit), miPos(maSpans.begin()) {}
  25
  26 ColumnSpanSet::Action::~Action() {}
  27 void ColumnSpanSet::Action::startColumn(SCTAB /*nTab*/, SCCOL /*nCol*/) {}
  28
  29 ColumnSpanSet::ColumnAction::~ColumnAction() {}
  30
  31 ColumnSpanSet::ColumnSpanSet(bool bInit) : mbInit(bInit) {}
  32
  33 ColumnSpanSet::~ColumnSpanSet()
  34 {
  35     DocType::iterator itTab = maDoc.begin(), itTabEnd = maDoc.end();
  36     for (; itTab != itTabEnd; ++itTab)
  37     {
  38         TableType* pTab = *itTab;
  39         if (!pTab)
  40             continue;
  41
  42         std::for_each(pTab->begin(), pTab->end(), ScDeleteObjectByPtr<ColumnType>());
  43         delete pTab;
  44     }
  45 }
  46
  47 ColumnSpanSet::ColumnType& ColumnSpanSet::getColumn(SCTAB nTab, SCCOL nCol)
  48 {
  49     if (static_cast<size_t>(nTab) >= maDoc.size())
  50         maDoc.resize(nTab+1, NULL);
  51
  52     if (!maDoc[nTab])
  53         maDoc[nTab] = new TableType;
  54
  55     TableType& rTab = *maDoc[nTab];
  56     if (static_cast<size_t>(nCol) >= rTab.size())
  57         rTab.resize(nCol+1, NULL);
  58
  59     if (!rTab[nCol])
  60         rTab[nCol] = new ColumnType(0, MAXROW, mbInit);
  61
  62     return *rTab[nCol];
  63 }
  64
  65 void ColumnSpanSet::set(SCTAB nTab, SCCOL nCol, SCROW nRow, bool bVal)
  66 {
  67     if (!ValidTab(nTab) || !ValidCol(nCol) || !ValidRow(nRow))
  68         return;
  69
  70     ColumnType& rCol = getColumn(nTab, nCol);
  71     rCol.miPos = rCol.maSpans.insert(rCol.miPos, nRow, nRow+1, bVal).first;
  72 }
  73
  74 void ColumnSpanSet::set(SCTAB nTab, SCCOL nCol, SCROW nRow1, SCROW nRow2, bool bVal)
  75 {
  76     if (!ValidTab(nTab) || !ValidCol(nCol) || !ValidRow(nRow1) || !ValidRow(nRow2))
  77         return;
  78
  79     ColumnType& rCol = getColumn(nTab, nCol);
  80     rCol.miPos = rCol.maSpans.insert(rCol.miPos, nRow1, nRow2+1, bVal).first;
  81 }
  82
  83 void ColumnSpanSet::set(const ScRange& rRange, bool bVal)
  84 {
  85     for (SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); ++nTab)
  86     {
  87         for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
  88         {
  89             ColumnType& rCol = getColumn(nTab, nCol);
  90             rCol.miPos = rCol.maSpans.insert(rCol.miPos, rRange.aStart.Row(), rRange.aEnd.Row()+1, bVal).first;
  91         }
  92     }
  93 }
  94
  95 void ColumnSpanSet::executeAction(Action& ac) const
  96 {
  97     for (size_t nTab = 0; nTab < maDoc.size(); ++nTab)
  98     {
  99         if (!maDoc[nTab])
 100             continue;
 101
 102         const TableType& rTab = *maDoc[nTab];
 103         for (size_t nCol = 0; nCol < rTab.size(); ++nCol)
 104         {
 105             if (!rTab[nCol])
 106                 continue;
 107
 108             ac.startColumn(nTab, nCol);
 109             ColumnType& rCol = *rTab[nCol];
 110             ColumnSpansType::const_iterator it = rCol.maSpans.begin(), itEnd = rCol.maSpans.end();
 111             SCROW nRow1, nRow2;
 112             nRow1 = it->first;
 113             bool bVal = it->second;
 114             for (++it; it != itEnd; ++it)
 115             {
 116                 nRow2 = it->first-1;
 117                 ac.execute(ScAddress(nCol, nRow1, nTab), nRow2-nRow1+1, bVal);
 118
 119                 nRow1 = nRow2+1; // for the next iteration.
 120                 bVal = it->second;
 121             }
 122         }
 123     }
 124 }
 125
 126 void ColumnSpanSet::executeColumnAction(ScDocument& rDoc, ColumnAction& ac) const
 127 {
 128     for (size_t nTab = 0; nTab < maDoc.size(); ++nTab)
 129     {
 130         if (!maDoc[nTab])
 131             continue;
 132
 133         const TableType& rTab = *maDoc[nTab];
 134         for (size_t nCol = 0; nCol < rTab.size(); ++nCol)
 135         {
 136             if (!rTab[nCol])
 137                 continue;
 138
 139             ScTable* pTab = rDoc.FetchTable(nTab);
 140             if (!pTab)
 141                 continue;
 142
 143             if (!ValidCol(nCol))
 144             {
 145                 // End the loop.
 146                 nCol = rTab.size();
 147                 continue;
 148             }
 149
 150             ScColumn& rColumn = pTab->aCol[nCol];
 151             ac.startColumn(&rColumn);
 152             ColumnType& rCol = *rTab[nCol];
 153             ColumnSpansType::const_iterator it = rCol.maSpans.begin(), itEnd = rCol.maSpans.end();
 154             SCROW nRow1, nRow2;
 155             nRow1 = it->first;
 156             bool bVal = it->second;
 157             for (++it; it != itEnd; ++it)
 158             {
 159                 nRow2 = it->first-1;
 160                 ac.execute(nRow1, nRow2, bVal);
 161
 162                 nRow1 = nRow2+1; // for the next iteration.
 163                 bVal = it->second;
 164             }
 165         }
 166     }
 167 }
 168
 169 namespace {
 170
 171 class Scanner
 172 {
 173     SingleColumnSpanSet::ColumnSpansType& mrRanges;
 174 public:
 175     Scanner(SingleColumnSpanSet::ColumnSpansType& rRanges) : mrRanges(rRanges) {}
 176
 177     void operator() (const sc::CellStoreType::value_type& node, size_t nOffset, size_t nDataSize)
 178     {
 179         if (node.type == sc::element_type_empty)
 180             return;
 181
 182         size_t nRow = node.position + nOffset;
 183         size_t nEndRow = nRow + nDataSize; // Last row of current block plus 1
 184         mrRanges.insert_back(nRow, nEndRow, true);
 185     }
 186 };
 187
 188 }
 189
 190 SingleColumnSpanSet::SingleColumnSpanSet() : maSpans(0, MAXROWCOUNT, false) {}
 191
 192 void SingleColumnSpanSet::scan(const ScColumn& rColumn)
 193 {
 194     const CellStoreType& rCells = rColumn.maCells;
 195     sc::CellStoreType::const_iterator it = rCells.begin(), itEnd = rCells.end();
 196     SCROW nCurRow = 0;
 197     for (;it != itEnd; ++it)
 198     {
 199         SCROW nEndRow = nCurRow + it->size; // Last row of current block plus 1.
 200         if (it->type != sc::element_type_empty)
 201             maSpans.insert_back(nCurRow, nEndRow, true);
 202
 203         nCurRow = nEndRow;
 204     }
 205 }
 206
 207 void SingleColumnSpanSet::scan(const ScColumn& rColumn, SCROW nStart, SCROW nEnd)
 208 {
 209     const CellStoreType& rCells = rColumn.maCells;
 210     Scanner aScanner(maSpans);
 211     sc::ParseBlock(rCells.begin(), rCells, aScanner, nStart, nEnd);
 212 }
 213
 214 void SingleColumnSpanSet::scan(
 215     ColumnBlockConstPosition& rBlockPos, const ScColumn& rColumn, SCROW nStart, SCROW nEnd)
 216 {
 217     const CellStoreType& rCells = rColumn.maCells;
 218     Scanner aScanner(maSpans);
 219     rBlockPos.miCellPos = sc::ParseBlock(rBlockPos.miCellPos, rCells, aScanner, nStart, nEnd);
 220 }
 221
 222 void SingleColumnSpanSet::scan(const ScMarkData& rMark, SCTAB nTab, SCCOL nCol)
 223 {
 224     if (!rMark.GetTableSelect(nTab))
 225         // This table is not selected. Nothing to scan.
 226         return;
 227
 228     ScRangeList aRanges = rMark.GetMarkedRanges();
 229     for (size_t i = 0, n = aRanges.size(); i < n; ++i)
 230     {
 231         const ScRange* p = aRanges[i];
 232         if (nCol < p->aStart.Col() || p->aEnd.Col() < nCol)
 233             // This column is not in this range. Skip it.
 234             continue;
 235
 236         maSpans.insert_back(p->aStart.Row(), p->aEnd.Row()+1, true);
 237     }
 238 }
 239
 240 void SingleColumnSpanSet::set(SCROW nRow1, SCROW nRow2, bool bVal)
 241 {
 242     maSpans.insert_back(nRow1, nRow2+1, bVal);
 243 }
 244
 245 void SingleColumnSpanSet::getRows(std::vector<SCROW> &rRows) const
 246 {
 247     std::vector<SCROW> aRows;
 248
 249     SpansType aRanges;
 250     getSpans(aRanges);
 251     SpansType::const_iterator it = aRanges.begin(), itEnd = aRanges.end();
 252     for (; it != itEnd; ++it)
 253     {
 254         for (SCROW nRow = it->mnRow1; nRow <= it->mnRow2; ++nRow)
 255             aRows.push_back(nRow);
 256     }
 257
 258     rRows.swap(aRows);
 259 }
 260
 261 void SingleColumnSpanSet::getSpans(SpansType& rSpans) const
 262 {
 263     SpansType aSpans;
 264     ColumnSpansType::const_iterator it = maSpans.begin(), itEnd = maSpans.end();
 265     SCROW nLastRow = it->first;
 266     bool bLastVal = it->second;
 267     for (++it; it != itEnd; ++it)
 268     {
 269         SCROW nThisRow = it->first;
 270         bool bThisVal = it->second;
 271
 272         if (bLastVal)
 273             aSpans.push_back(Span(nLastRow, nThisRow-1));
 274
 275         nLastRow = nThisRow;
 276         bLastVal = bThisVal;
 277     }
 278
 279     rSpans.swap(aSpans);
 280 }
 281
 282 }
 283
 284 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */