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