Line data    Source code

       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 <table.hxx>
      11             : #include <clipcontext.hxx>
      12             : #include <document.hxx>
      13             : #include <clipparam.hxx>
      14             : #include <bcaslot.hxx>
      15             : #include <segmenttree.hxx>
      16             : #include <sharedformula.hxx>
      17             : #include <cellvalues.hxx>
      18             : 
      19           6 : bool ScTable::IsMerged( SCCOL nCol, SCROW nRow ) const
      20             : {
      21           6 :     if (!ValidCol(nCol))
      22           0 :         return false;
      23             : 
      24           6 :     return aCol[nCol].IsMerged(nRow);
      25             : }
      26             : 
      27           4 : void ScTable::DeleteBeforeCopyFromClip( sc::CopyFromClipContext& rCxt, const ScTable& rClipTab )
      28             : {
      29           4 :     sc::CopyFromClipContext::Range aRange = rCxt.getDestRange();
      30           4 :     if (!ValidCol(aRange.mnCol1) || !ValidCol(aRange.mnCol2))
      31           4 :         return;
      32             : 
      33             :     // Pass some stuff to the columns via context.
      34           4 :     rCxt.setTableProtected(IsProtected());
      35           4 :     rCxt.setCondFormatList(mpCondFormatList.get());
      36             : 
      37           4 :     ScRange aClipRange = rCxt.getClipDoc()->GetClipParam().getWholeRange();
      38           4 :     SCCOL nClipCol = aClipRange.aStart.Col();
      39             :     {
      40           4 :         ScBulkBroadcast aBulkBroadcast(pDocument->GetBASM());
      41             : 
      42          12 :         for (SCCOL nCol = aRange.mnCol1; nCol <= aRange.mnCol2; ++nCol, ++nClipCol)
      43             :         {
      44           8 :             if (nClipCol > aClipRange.aEnd.Col())
      45           0 :                 nClipCol = aClipRange.aStart.Col(); // loop through columns.
      46             : 
      47           8 :             const ScColumn& rClipCol = rClipTab.aCol[nClipCol];
      48           8 :             aCol[nCol].DeleteBeforeCopyFromClip(rCxt, rClipCol);
      49           4 :         }
      50             :     }
      51             : 
      52           4 :     SetStreamValid(false);
      53             : }
      54             : 
      55           6 : void ScTable::CopyOneCellFromClip(
      56             :     sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
      57             : {
      58          12 :     for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
      59           6 :         aCol[nCol].CopyOneCellFromClip(rCxt, nRow1, nRow2);
      60           6 : }
      61             : 
      62           0 : void ScTable::SetValues( SCCOL nCol, SCROW nRow, const std::vector<double>& rVals )
      63             : {
      64           0 :     if (!ValidCol(nCol))
      65           0 :         return;
      66             : 
      67           0 :     aCol[nCol].SetValues(nRow, rVals);
      68             : }
      69             : 
      70           0 : void ScTable::TransferCellValuesTo( SCCOL nCol, SCROW nRow, size_t nLen, sc::CellValues& rDest )
      71             : {
      72           0 :     if (!ValidCol(nCol))
      73           0 :         return;
      74             : 
      75           0 :     aCol[nCol].TransferCellValuesTo(nRow, nLen, rDest);
      76             : }
      77             : 
      78           0 : void ScTable::CopyCellValuesFrom( SCCOL nCol, SCROW nRow, const sc::CellValues& rSrc )
      79             : {
      80           0 :     if (!ValidCol(nCol))
      81           0 :         return;
      82             : 
      83           0 :     aCol[nCol].CopyCellValuesFrom(nRow, rSrc);
      84             : }
      85             : 
      86           4 : void ScTable::ConvertFormulaToValue(
      87             :     sc::EndListeningContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
      88             :     sc::TableValues* pUndo )
      89             : {
      90           4 :     if (!ValidCol(nCol1) || !ValidCol(nCol2) || nCol1 > nCol2)
      91           4 :         return;
      92             : 
      93          10 :     for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
      94           6 :         aCol[nCol].ConvertFormulaToValue(rCxt, nRow1, nRow2, pUndo);
      95             : }
      96             : 
      97           8 : void ScTable::SwapNonEmpty(
      98             :     sc::TableValues& rValues, sc::StartListeningContext& rStartCxt, sc::EndListeningContext& rEndCxt )
      99             : {
     100           8 :     const ScRange& rRange = rValues.getRange();
     101             :     assert(rRange.IsValid());
     102          22 :     for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
     103          14 :         aCol[nCol].SwapNonEmpty(rValues, rStartCxt, rEndCxt);
     104           8 : }
     105             : 
     106         140 : void ScTable::PreprocessRangeNameUpdate(
     107             :     sc::EndListeningContext& rEndListenCxt, sc::CompileFormulaContext& rCompileCxt )
     108             : {
     109      143500 :     for (SCCOL i = 0; i <= MAXCOL; ++i)
     110      143360 :         aCol[i].PreprocessRangeNameUpdate(rEndListenCxt, rCompileCxt);
     111         140 : }
     112             : 
     113          22 : void ScTable::PreprocessDBDataUpdate(
     114             :     sc::EndListeningContext& rEndListenCxt, sc::CompileFormulaContext& rCompileCxt )
     115             : {
     116       22550 :     for (SCCOL i = 0; i <= MAXCOL; ++i)
     117       22528 :         aCol[i].PreprocessDBDataUpdate(rEndListenCxt, rCompileCxt);
     118          22 : }
     119             : 
     120         162 : void ScTable::CompileHybridFormula(
     121             :     sc::StartListeningContext& rStartListenCxt, sc::CompileFormulaContext& rCompileCxt )
     122             : {
     123      166050 :     for (SCCOL i = 0; i <= MAXCOL; ++i)
     124      165888 :         aCol[i].CompileHybridFormula(rStartListenCxt, rCompileCxt);
     125         162 : }
     126             : 
     127        1154 : void ScTable::UpdateScriptTypes( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
     128             : {
     129        1154 :     if (!ValidCol(nCol1) || !ValidCol(nCol2) || nCol1 > nCol2)
     130        1154 :         return;
     131             : 
     132     1137932 :     for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
     133     1136778 :         aCol[nCol].UpdateScriptTypes(nRow1, nRow2);
     134             : }
     135             : 
     136          46 : bool ScTable::HasUniformRowHeight( SCROW nRow1, SCROW nRow2 ) const
     137             : {
     138          46 :     if (!ValidRow(nRow1) || !ValidRow(nRow2) || nRow1 > nRow2)
     139           0 :         return false;
     140             : 
     141             :     ScFlatUInt16RowSegments::RangeData aData;
     142          46 :     if (!mpRowHeights->getRangeData(nRow1, aData))
     143             :         // Search failed.
     144           0 :         return false;
     145             : 
     146          46 :     return nRow2 <= aData.mnRow2;
     147             : }
     148             : 
     149        2214 : void ScTable::SplitFormulaGroups( SCCOL nCol, std::vector<SCROW>& rRows )
     150             : {
     151        2214 :     if (!ValidCol(nCol))
     152        2214 :         return;
     153             : 
     154        2214 :     sc::SharedFormulaUtil::splitFormulaCellGroups(aCol[nCol].maCells, rRows);
     155             : }
     156             : 
     157          10 : void ScTable::UnshareFormulaCells( SCCOL nCol, std::vector<SCROW>& rRows )
     158             : {
     159          10 :     if (!ValidCol(nCol))
     160          10 :         return;
     161             : 
     162          10 :     sc::SharedFormulaUtil::unshareFormulaCells(aCol[nCol].maCells, rRows);
     163             : }
     164             : 
     165          10 : void ScTable::RegroupFormulaCells( SCCOL nCol )
     166             : {
     167          10 :     if (!ValidCol(nCol))
     168          10 :         return;
     169             : 
     170          10 :     aCol[nCol].RegroupFormulaCells();
     171             : }
     172             : 
     173          12 : void ScTable::CollectListeners(
     174             :     std::vector<SvtListener*>& rListeners, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
     175             : {
     176          12 :     if (nCol2 < nCol1 || !ValidCol(nCol1) || !ValidCol(nCol2))
     177          12 :         return;
     178             : 
     179          26 :     for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
     180          14 :         aCol[nCol].CollectListeners(rListeners, nRow1, nRow2);
     181             : }
     182             : 
     183           0 : bool ScTable::HasFormulaCell( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const
     184             : {
     185           0 :     if (nCol2 < nCol1 || !ValidCol(nCol1) || !ValidCol(nCol2))
     186           0 :         return false;
     187             : 
     188           0 :     for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
     189           0 :         if (aCol[nCol].HasFormulaCell(nRow1, nRow2))
     190           0 :             return true;
     191             : 
     192           0 :     return false;
     193         228 : }
     194             : 
     195             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */