sc/source/core/data/document10.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 <document.hxx>
  11 #include <clipcontext.hxx>
  12 #include <formulacell.hxx>
  13 #include <clipparam.hxx>
  14 #include <table.hxx>
  15 #include <tokenarray.hxx>
  16 #include <editutil.hxx>
  17 #include <listenercontext.hxx>
  18 #include <tokenstringcontext.hxx>
  19 #include <poolhelp.hxx>
  20 #include <bcaslot.hxx>
  21 #include <cellvalues.hxx>
  22 #include <docpool.hxx>
  23
  24 #include "dociter.hxx"
  25 #include "patattr.hxx"
  26 #include <svl/whiter.hxx>
  27 #include <editeng/colritem.hxx>
  28 #include "scitems.hxx"
  29
  30 // Add totally brand-new methods to this source file.
  31
  32 bool ScDocument::IsMerged( const ScAddress& rPos ) const
  33 {
  34     const ScTable* pTab = FetchTable(rPos.Tab());
  35     if (!pTab)
  36         return false;
  37
  38     return pTab->IsMerged(rPos.Col(), rPos.Row());
  39 }
  40
  41 void ScDocument::DeleteBeforeCopyFromClip(
  42     sc::CopyFromClipContext& rCxt, const ScMarkData& rMark, sc::ColumnSpanSet& rBroadcastSpans )
  43 {
  44     SCTAB nClipTab = 0;
  45     const TableContainer& rClipTabs = rCxt.getClipDoc()->maTabs;
  46     SCTAB nClipTabCount = rClipTabs.size();
  47
  48     for (SCTAB nTab = rCxt.getTabStart(); nTab <= rCxt.getTabEnd(); ++nTab)
  49     {
  50         ScTable* pTab = FetchTable(nTab);
  51         if (!pTab)
  52             continue;
  53
  54         if (!rMark.GetTableSelect(nTab))
  55             continue;
  56
  57         while (!rClipTabs[nClipTab])
  58             nClipTab = (nClipTab+1) % nClipTabCount;
  59
  60         pTab->DeleteBeforeCopyFromClip(rCxt, *rClipTabs[nClipTab], rBroadcastSpans);
  61
  62         nClipTab = (nClipTab+1) % nClipTabCount;
  63     }
  64 }
  65
  66 bool ScDocument::CopyOneCellFromClip(
  67     sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
  68 {
  69     ScDocument* pClipDoc = rCxt.getClipDoc();
  70     if (pClipDoc->GetClipParam().mbCutMode)
  71         // We don't handle cut and paste or moving of cells here.
  72         return false;
  73
  74     ScRange aClipRange = pClipDoc->GetClipParam().getWholeRange();
  75     if (aClipRange.aStart.Row() != aClipRange.aEnd.Row())
  76         // The source is not really a single row. Bail out.
  77         return false;
  78
  79     SCCOL nSrcColSize = aClipRange.aEnd.Col() - aClipRange.aStart.Col() + 1;
  80     SCCOL nDestColSize = nCol2 - nCol1 + 1;
  81     if (nDestColSize < nSrcColSize)
  82         return false;
  83
  84     ScAddress aSrcPos = aClipRange.aStart;
  85
  86     for (SCCOL nCol = aClipRange.aStart.Col(); nCol <= aClipRange.aEnd.Col(); ++nCol)
  87     {
  88         ScAddress aTestPos = aSrcPos;
  89         aTestPos.SetCol(nCol);
  90         if (pClipDoc->IsMerged(aTestPos))
  91             // We don't handle merged source cell for this.
  92             return false;
  93     }
  94
  95     ScTable* pSrcTab = pClipDoc->FetchTable(aSrcPos.Tab());
  96     if (!pSrcTab)
  97         return false;
  98
  99     rCxt.setSingleCellColumnSize(nSrcColSize);
 100
 101     for (SCCOL nColOffset = 0; nColOffset < nSrcColSize; ++nColOffset, aSrcPos.IncCol())
 102     {
 103         const ScPatternAttr* pAttr = pClipDoc->GetPattern(aSrcPos);
 104         rCxt.setSingleCellPattern(nColOffset, pAttr);
 105
 106         if ((rCxt.getInsertFlag() & (IDF_NOTE | IDF_ADDNOTES)) != IDF_NONE)
 107             rCxt.setSingleCellNote(nColOffset, pClipDoc->GetNote(aSrcPos));
 108
 109         ScColumn& rSrcCol = pSrcTab->aCol[aSrcPos.Col()];
 110         // Determine the script type of the copied single cell.
 111         rSrcCol.UpdateScriptTypes(aSrcPos.Row(), aSrcPos.Row());
 112         rCxt.setSingleCell(aSrcPos, rSrcCol);
 113     }
 114
 115     // All good. Proceed with the pasting.
 116
 117     SCTAB nTabEnd = rCxt.getTabEnd();
 118     for (SCTAB i = rCxt.getTabStart(); i <= nTabEnd && i < static_cast<SCTAB>(maTabs.size()); ++i)
 119     {
 120         maTabs[i]->CopyOneCellFromClip(rCxt, nCol1, nRow1, nCol2, nRow2);
 121         if (rCxt.getInsertFlag() & IDF_ATTRIB)
 122             for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
 123             {
 124                 maTabs[i]->CopyConditionalFormat(nCol1, nRow, nCol2, nRow, nCol1 - aClipRange.aStart.Col(),
 125                         nRow - aClipRange.aStart.Row(), pSrcTab);
 126             }
 127     }
 128
 129     return true;
 130 }
 131
 132 void ScDocument::SetValues( const ScAddress& rPos, const std::vector<double>& rVals )
 133 {
 134     ScTable* pTab = FetchTable(rPos.Tab());
 135     if (!pTab)
 136         return;
 137
 138     pTab->SetValues(rPos.Col(), rPos.Row(), rVals);
 139 }
 140
 141 void ScDocument::TransferCellValuesTo( const ScAddress& rTopPos, size_t nLen, sc::CellValues& rDest )
 142 {
 143     ScTable* pTab = FetchTable(rTopPos.Tab());
 144     if (!pTab)
 145         return;
 146
 147     pTab->TransferCellValuesTo(rTopPos.Col(), rTopPos.Row(), nLen, rDest);
 148 }
 149
 150 void ScDocument::CopyCellValuesFrom( const ScAddress& rTopPos, const sc::CellValues& rSrc )
 151 {
 152     ScTable* pTab = FetchTable(rTopPos.Tab());
 153     if (!pTab)
 154         return;
 155
 156     pTab->CopyCellValuesFrom(rTopPos.Col(), rTopPos.Row(), rSrc);
 157 }
 158
 159 std::set<Color> ScDocument::GetDocColors()
 160 {
 161     std::set<Color> aDocColors;
 162     ScDocumentPool *pPool = GetPool();
 163     const sal_uInt16 pAttribs[] = {ATTR_BACKGROUND, ATTR_FONT_COLOR};
 164     for (size_t i=0; i<SAL_N_ELEMENTS( pAttribs ); i++)
 165     {
 166         const sal_uInt16 nAttrib = pAttribs[i];
 167         const sal_uInt32 nCount = pPool->GetItemCount2(nAttrib);
 168         for (sal_uInt32 j=0; j<nCount; j++)
 169         {
 170             const SvxColorItem *pItem = static_cast<const SvxColorItem*>(pPool->GetItem2(nAttrib, j));
 171             if (pItem == 0)
 172                 continue;
 173             Color aColor( pItem->GetValue() );
 174             if (COL_AUTO != aColor.GetColor())
 175                 aDocColors.insert(aColor);
 176         }
 177     }
 178     return aDocColors;
 179 }
 180
 181 void ScDocument::SetCalcConfig( const ScCalcConfig& rConfig )
 182 {
 183     maCalcConfig = rConfig;
 184 }
 185
 186 void ScDocument::ConvertFormulaToValue( const ScRange& rRange, sc::TableValues* pUndo )
 187 {
 188     sc::EndListeningContext aCxt(*this);
 189
 190     for (SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); ++nTab)
 191     {
 192         ScTable* pTab = FetchTable(nTab);
 193         if (!pTab)
 194             continue;
 195
 196         pTab->ConvertFormulaToValue(
 197             aCxt, rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row(),
 198             pUndo);
 199     }
 200
 201     aCxt.purgeEmptyBroadcasters();
 202 }
 203
 204 void ScDocument::SwapNonEmpty( sc::TableValues& rValues )
 205 {
 206     const ScRange& rRange = rValues.getRange();
 207     if (!rRange.IsValid())
 208         return;
 209
 210     boost::shared_ptr<sc::ColumnBlockPositionSet> pPosSet(new sc::ColumnBlockPositionSet(*this));
 211     sc::StartListeningContext aStartCxt(*this, pPosSet);
 212     sc::EndListeningContext aEndCxt(*this, pPosSet);
 213
 214     for (SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); ++nTab)
 215     {
 216         ScTable* pTab = FetchTable(nTab);
 217         if (!pTab)
 218             continue;
 219
 220         pTab->SwapNonEmpty(rValues, aStartCxt, aEndCxt);
 221     }
 222
 223     aEndCxt.purgeEmptyBroadcasters();
 224 }
 225
 226 void ScDocument::PreprocessRangeNameUpdate()
 227 {
 228     sc::EndListeningContext aEndListenCxt(*this);
 229     sc::CompileFormulaContext aCompileCxt(this);
 230
 231     TableContainer::iterator it = maTabs.begin(), itEnd = maTabs.end();
 232     for (; it != itEnd; ++it)
 233     {
 234         ScTable* p = *it;
 235         p->PreprocessRangeNameUpdate(aEndListenCxt, aCompileCxt);
 236     }
 237 }
 238
 239 void ScDocument::PreprocessDBDataUpdate()
 240 {
 241     sc::EndListeningContext aEndListenCxt(*this);
 242     sc::CompileFormulaContext aCompileCxt(this);
 243
 244     TableContainer::iterator it = maTabs.begin(), itEnd = maTabs.end();
 245     for (; it != itEnd; ++it)
 246     {
 247         ScTable* p = *it;
 248         p->PreprocessDBDataUpdate(aEndListenCxt, aCompileCxt);
 249     }
 250 }
 251
 252 void ScDocument::CompileHybridFormula()
 253 {
 254     sc::StartListeningContext aStartListenCxt(*this);
 255     sc::CompileFormulaContext aCompileCxt(this);
 256     TableContainer::iterator it = maTabs.begin(), itEnd = maTabs.end();
 257     for (; it != itEnd; ++it)
 258     {
 259         ScTable* p = *it;
 260         p->CompileHybridFormula(aStartListenCxt, aCompileCxt);
 261     }
 262 }
 263
 264 void ScDocument::SharePooledResources( ScDocument* pSrcDoc )
 265 {
 266     xPoolHelper = pSrcDoc->xPoolHelper;
 267     mpCellStringPool = pSrcDoc->mpCellStringPool;
 268 }
 269
 270 void ScDocument::UpdateScriptTypes( const ScAddress& rPos, SCCOL nColSize, SCROW nRowSize )
 271 {
 272     ScTable* pTab = FetchTable(rPos.Tab());
 273     if (!pTab)
 274         return;
 275
 276     pTab->UpdateScriptTypes(rPos.Col(), rPos.Row(), rPos.Col()+nColSize-1, rPos.Row()+nRowSize-1);
 277 }
 278
 279 bool ScDocument::HasUniformRowHeight( SCTAB nTab, SCROW nRow1, SCROW nRow2 ) const
 280 {
 281     const ScTable* pTab = FetchTable(nTab);
 282     if (!pTab)
 283         return false;
 284
 285     return pTab->HasUniformRowHeight(nRow1, nRow2);
 286 }
 287
 288 void ScDocument::UnshareFormulaCells( SCTAB nTab, SCCOL nCol, std::vector<SCROW>& rRows )
 289 {
 290     ScTable* pTab = FetchTable(nTab);
 291     if (!pTab)
 292         return;
 293
 294     pTab->UnshareFormulaCells(nCol, rRows);
 295 }
 296
 297 void ScDocument::RegroupFormulaCells( SCTAB nTab, SCCOL nCol )
 298 {
 299     ScTable* pTab = FetchTable(nTab);
 300     if (!pTab)
 301         return;
 302
 303     pTab->RegroupFormulaCells(nCol);
 304 }
 305
 306 void ScDocument::CollectAllAreaListeners(
 307     std::vector<SvtListener*>& rListener, const ScRange& rRange, sc::AreaOverlapType eType )
 308 {
 309     if (!pBASM)
 310         return;
 311
 312     std::vector<sc::AreaListener> aAL = pBASM->GetAllListeners(rRange, eType);
 313     std::vector<sc::AreaListener>::iterator it = aAL.begin(), itEnd = aAL.end();
 314     for (; it != itEnd; ++it)
 315         rListener.push_back(it->mpListener);
 316 }
 317
 318 bool ScDocument::HasFormulaCell( const ScRange& rRange ) const
 319 {
 320     if (!rRange.IsValid())
 321         return false;
 322
 323     for (SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); ++nTab)
 324     {
 325         const ScTable* pTab = FetchTable(nTab);
 326         if (!pTab)
 327             continue;
 328
 329         if (pTab->HasFormulaCell(rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row()))
 330             return true;
 331     }
 332
 333     return false;
 334 }
 335
 336 void ScDocument::EndListeningIntersectedGroup(
 337     sc::EndListeningContext& rCxt, const ScAddress& rPos, std::vector<ScAddress>* pGroupPos )
 338 {
 339     ScTable* pTab = FetchTable(rPos.Tab());
 340     if (!pTab)
 341         return;
 342
 343     pTab->EndListeningIntersectedGroup(rCxt, rPos.Col(), rPos.Row(), pGroupPos);
 344 }
 345
 346 void ScDocument::EndListeningIntersectedGroups(
 347     sc::EndListeningContext& rCxt, const ScRange& rRange, std::vector<ScAddress>* pGroupPos )
 348 {
 349     for (SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); ++nTab)
 350     {
 351         ScTable* pTab = FetchTable(nTab);
 352         if (!pTab)
 353             continue;
 354
 355         pTab->EndListeningIntersectedGroups(
 356             rCxt, rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row(),
 357             pGroupPos);
 358     }
 359 }
 360
 361 void ScDocument::EndListeningGroups( const std::vector<ScAddress>& rPosArray )
 362 {
 363     sc::EndListeningContext aCxt(*this);
 364     std::vector<ScAddress>::const_iterator it = rPosArray.begin(), itEnd = rPosArray.end();
 365     for (; it != itEnd; ++it)
 366     {
 367         const ScAddress& rPos = *it;
 368         ScTable* pTab = FetchTable(rPos.Tab());
 369         if (!pTab)
 370             return;
 371
 372         pTab->EndListeningGroup(aCxt, rPos.Col(), rPos.Row());
 373     }
 374
 375     aCxt.purgeEmptyBroadcasters();
 376 }
 377
 378 void ScDocument::SetNeedsListeningGroups( const std::vector<ScAddress>& rPosArray )
 379 {
 380     std::vector<ScAddress>::const_iterator it = rPosArray.begin(), itEnd = rPosArray.end();
 381     for (; it != itEnd; ++it)
 382     {
 383         const ScAddress& rPos = *it;
 384         ScTable* pTab = FetchTable(rPos.Tab());
 385         if (!pTab)
 386             return;
 387
 388         pTab->SetNeedsListeningGroup(rPos.Col(), rPos.Row());
 389     }
 390 }
 391
 392 namespace {
 393
 394 class StartNeededListenersHandler : std::unary_function<ScTable*, void>
 395 {
 396     boost::shared_ptr<sc::StartListeningContext> mpCxt;
 397 public:
 398     StartNeededListenersHandler( ScDocument& rDoc ) : mpCxt(new sc::StartListeningContext(rDoc)) {}
 399
 400     void operator() (ScTable* p)
 401     {
 402         if (p)
 403             p->StartListeners(*mpCxt, false);
 404     }
 405 };
 406
 407 }
 408
 409 void ScDocument::StartNeededListeners()
 410 {
 411     std::for_each(maTabs.begin(), maTabs.end(), StartNeededListenersHandler(*this));
 412 }
 413
 414 void ScDocument::StartAllListeners( const ScRange& rRange )
 415 {
 416     boost::shared_ptr<sc::ColumnBlockPositionSet> pPosSet(new sc::ColumnBlockPositionSet(*this));
 417     sc::StartListeningContext aStartCxt(*this, pPosSet);
 418     sc::EndListeningContext aEndCxt(*this, pPosSet);
 419
 420     for (SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); ++nTab)
 421     {
 422         ScTable* pTab = FetchTable(nTab);
 423         if (!pTab)
 424             continue;
 425
 426         pTab->StartListeningFormulaCells(
 427             aStartCxt, aEndCxt,
 428             rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row());
 429     }
 430 }
 431
 432 void ScDocument::EndAllListeners( const ScRange& rRange )
 433 {
 434     sc::EndListeningContext aEndCxt(*this);
 435
 436     for (SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); ++nTab)
 437     {
 438         ScTable* pTab = FetchTable(nTab);
 439         if (!pTab)
 440             continue;
 441
 442         pTab->EndListeningFormulaCells(
 443             aEndCxt,
 444             rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row());
 445     }
 446 }
 447
 448 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */