LCOV - code coverage report
Current view: top level - sc/source/core/data - documentimport.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 274 0.0 %
Date: 2014-04-14 Functions: 0 33 0.0 %
Legend: Lines: hit not hit

          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 "documentimport.hxx"
      11             : #include "document.hxx"
      12             : #include "table.hxx"
      13             : #include "column.hxx"
      14             : #include "formulacell.hxx"
      15             : #include "docoptio.hxx"
      16             : #include "globalnames.hxx"
      17             : #include "mtvelements.hxx"
      18             : #include "tokenarray.hxx"
      19             : #include "stringutil.hxx"
      20             : #include "compiler.hxx"
      21             : #include "paramisc.hxx"
      22             : #include "listenercontext.hxx"
      23             : 
      24             : #include "svl/sharedstringpool.hxx"
      25             : 
      26           0 : struct ScDocumentImportImpl
      27             : {
      28             :     ScDocument& mrDoc;
      29             :     sc::StartListeningContext maListenCxt;
      30             :     sc::ColumnBlockPositionSet maBlockPosSet;
      31             :     sal_uInt16 mnDefaultScriptNumeric;
      32             : 
      33           0 :     ScDocumentImportImpl(ScDocument& rDoc) :
      34             :         mrDoc(rDoc),
      35             :         maListenCxt(rDoc),
      36             :         maBlockPosSet(rDoc),
      37           0 :         mnDefaultScriptNumeric(SC_SCRIPTTYPE_UNKNOWN) {}
      38             : };
      39             : 
      40           0 : ScDocumentImport::ScDocumentImport(ScDocument& rDoc) : mpImpl(new ScDocumentImportImpl(rDoc)) {}
      41           0 : ScDocumentImport::~ScDocumentImport()
      42             : {
      43           0 :     delete mpImpl;
      44           0 : }
      45             : 
      46           0 : ScDocument& ScDocumentImport::getDoc()
      47             : {
      48           0 :     return mpImpl->mrDoc;
      49             : }
      50             : 
      51           0 : const ScDocument& ScDocumentImport::getDoc() const
      52             : {
      53           0 :     return mpImpl->mrDoc;
      54             : }
      55             : 
      56           0 : void ScDocumentImport::setDefaultNumericScript(sal_uInt16 nScript)
      57             : {
      58           0 :     mpImpl->mnDefaultScriptNumeric = nScript;
      59           0 : }
      60             : 
      61           0 : void ScDocumentImport::setCellStyleToSheet(SCTAB nTab, const ScStyleSheet& rStyle)
      62             : {
      63           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(nTab);
      64           0 :     if (!pTab)
      65           0 :         return;
      66             : 
      67           0 :     pTab->ApplyStyleArea(0, 0, MAXCOL, MAXROW, rStyle);
      68             : }
      69             : 
      70           0 : SCTAB ScDocumentImport::getSheetIndex(const OUString& rName) const
      71             : {
      72           0 :     SCTAB nTab = -1;
      73           0 :     if (!mpImpl->mrDoc.GetTable(rName, nTab))
      74           0 :         return -1;
      75             : 
      76           0 :     return nTab;
      77             : }
      78             : 
      79           0 : SCTAB ScDocumentImport::getSheetCount() const
      80             : {
      81           0 :     return mpImpl->mrDoc.maTabs.size();
      82             : }
      83             : 
      84           0 : bool ScDocumentImport::appendSheet(const OUString& rName)
      85             : {
      86           0 :     SCTAB nTabCount = mpImpl->mrDoc.maTabs.size();
      87           0 :     if (!ValidTab(nTabCount))
      88           0 :         return false;
      89             : 
      90           0 :     mpImpl->mrDoc.maTabs.push_back(new ScTable(&mpImpl->mrDoc, nTabCount, rName));
      91           0 :     return true;
      92             : }
      93             : 
      94           0 : void ScDocumentImport::setOriginDate(sal_uInt16 nYear, sal_uInt16 nMonth, sal_uInt16 nDay)
      95             : {
      96           0 :     if (!mpImpl->mrDoc.pDocOptions)
      97           0 :         mpImpl->mrDoc.pDocOptions = new ScDocOptions;
      98             : 
      99           0 :     mpImpl->mrDoc.pDocOptions->SetDate(nDay, nMonth, nYear);
     100           0 : }
     101             : 
     102           0 : void ScDocumentImport::setAutoInput(const ScAddress& rPos, const OUString& rStr, ScSetStringParam* pStringParam)
     103             : {
     104           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(rPos.Tab());
     105           0 :     if (!pTab)
     106           0 :         return;
     107             : 
     108             :     sc::ColumnBlockPosition* pBlockPos =
     109           0 :         mpImpl->maBlockPosSet.getBlockPosition(rPos.Tab(), rPos.Col());
     110             : 
     111           0 :     if (!pBlockPos)
     112           0 :         return;
     113             : 
     114           0 :     ScCellValue aCell;
     115           0 :     pTab->aCol[rPos.Col()].ParseString(
     116           0 :         aCell, rPos.Row(), rPos.Tab(), rStr, mpImpl->mrDoc.GetAddressConvention(), pStringParam);
     117             : 
     118           0 :     sc::CellStoreType& rCells = pTab->aCol[rPos.Col()].maCells;
     119           0 :     switch (aCell.meType)
     120             :     {
     121             :         case CELLTYPE_STRING:
     122             :             // string is copied.
     123           0 :             pBlockPos->miCellPos = rCells.set(pBlockPos->miCellPos, rPos.Row(), *aCell.mpString);
     124           0 :         break;
     125             :         case CELLTYPE_EDIT:
     126             :             // Cell takes the ownership of the text object.
     127           0 :             pBlockPos->miCellPos = rCells.set(pBlockPos->miCellPos, rPos.Row(), aCell.mpEditText);
     128           0 :             aCell.mpEditText = NULL;
     129           0 :         break;
     130             :         case CELLTYPE_VALUE:
     131           0 :             pBlockPos->miCellPos = rCells.set(pBlockPos->miCellPos, rPos.Row(), aCell.mfValue);
     132           0 :         break;
     133             :         case CELLTYPE_FORMULA:
     134             :             // This formula cell instance is directly placed in the document without copying.
     135           0 :             pBlockPos->miCellPos = rCells.set(pBlockPos->miCellPos, rPos.Row(), aCell.mpFormula);
     136           0 :             aCell.mpFormula = NULL;
     137           0 :         break;
     138             :         default:
     139           0 :             pBlockPos->miCellPos = rCells.set_empty(pBlockPos->miCellPos, rPos.Row(), rPos.Row());
     140           0 :     }
     141             : }
     142             : 
     143           0 : void ScDocumentImport::setNumericCell(const ScAddress& rPos, double fVal)
     144             : {
     145           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(rPos.Tab());
     146           0 :     if (!pTab)
     147           0 :         return;
     148             : 
     149             :     sc::ColumnBlockPosition* pBlockPos =
     150           0 :         mpImpl->maBlockPosSet.getBlockPosition(rPos.Tab(), rPos.Col());
     151             : 
     152           0 :     if (!pBlockPos)
     153           0 :         return;
     154             : 
     155           0 :     sc::CellStoreType& rCells = pTab->aCol[rPos.Col()].maCells;
     156           0 :     pBlockPos->miCellPos = rCells.set(pBlockPos->miCellPos, rPos.Row(), fVal);
     157             : }
     158             : 
     159           0 : void ScDocumentImport::setStringCell(const ScAddress& rPos, const OUString& rStr)
     160             : {
     161           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(rPos.Tab());
     162           0 :     if (!pTab)
     163           0 :         return;
     164             : 
     165             :     sc::ColumnBlockPosition* pBlockPos =
     166           0 :         mpImpl->maBlockPosSet.getBlockPosition(rPos.Tab(), rPos.Col());
     167             : 
     168           0 :     if (!pBlockPos)
     169           0 :         return;
     170             : 
     171           0 :     svl::SharedString aSS = mpImpl->mrDoc.GetSharedStringPool().intern(rStr);
     172           0 :     if (!aSS.getData())
     173           0 :         return;
     174             : 
     175           0 :     sc::CellStoreType& rCells = pTab->aCol[rPos.Col()].maCells;
     176           0 :     pBlockPos->miCellPos = rCells.set(pBlockPos->miCellPos, rPos.Row(), aSS);
     177             : }
     178             : 
     179           0 : void ScDocumentImport::setEditCell(const ScAddress& rPos, EditTextObject* pEditText)
     180             : {
     181           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(rPos.Tab());
     182           0 :     if (!pTab)
     183           0 :         return;
     184             : 
     185             :     sc::ColumnBlockPosition* pBlockPos =
     186           0 :         mpImpl->maBlockPosSet.getBlockPosition(rPos.Tab(), rPos.Col());
     187             : 
     188           0 :     if (!pBlockPos)
     189           0 :         return;
     190             : 
     191           0 :     pEditText->NormalizeString(mpImpl->mrDoc.GetSharedStringPool());
     192           0 :     sc::CellStoreType& rCells = pTab->aCol[rPos.Col()].maCells;
     193           0 :     pBlockPos->miCellPos = rCells.set(pBlockPos->miCellPos, rPos.Row(), pEditText);
     194             : }
     195             : 
     196           0 : void ScDocumentImport::setFormulaCell(
     197             :     const ScAddress& rPos, const OUString& rFormula, formula::FormulaGrammar::Grammar eGrammar)
     198             : {
     199           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(rPos.Tab());
     200           0 :     if (!pTab)
     201           0 :         return;
     202             : 
     203             :     sc::ColumnBlockPosition* pBlockPos =
     204           0 :         mpImpl->maBlockPosSet.getBlockPosition(rPos.Tab(), rPos.Col());
     205             : 
     206           0 :     if (!pBlockPos)
     207           0 :         return;
     208             : 
     209           0 :     sc::CellStoreType& rCells = pTab->aCol[rPos.Col()].maCells;
     210           0 :     pBlockPos->miCellPos =
     211           0 :         rCells.set(pBlockPos->miCellPos, rPos.Row(), new ScFormulaCell(&mpImpl->mrDoc, rPos, rFormula, eGrammar));
     212             : }
     213             : 
     214           0 : void ScDocumentImport::setFormulaCell(const ScAddress& rPos, ScTokenArray* pArray)
     215             : {
     216           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(rPos.Tab());
     217           0 :     if (!pTab)
     218           0 :         return;
     219             : 
     220             :     sc::ColumnBlockPosition* pBlockPos =
     221           0 :         mpImpl->maBlockPosSet.getBlockPosition(rPos.Tab(), rPos.Col());
     222             : 
     223           0 :     if (!pBlockPos)
     224           0 :         return;
     225             : 
     226           0 :     sc::CellStoreType& rCells = pTab->aCol[rPos.Col()].maCells;
     227           0 :     pBlockPos->miCellPos =
     228           0 :         rCells.set(pBlockPos->miCellPos, rPos.Row(), new ScFormulaCell(&mpImpl->mrDoc, rPos, pArray));
     229             : }
     230             : 
     231           0 : void ScDocumentImport::setFormulaCell(const ScAddress& rPos, ScFormulaCell* pCell)
     232             : {
     233           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(rPos.Tab());
     234           0 :     if (!pTab)
     235           0 :         return;
     236             : 
     237             :     sc::ColumnBlockPosition* pBlockPos =
     238           0 :         mpImpl->maBlockPosSet.getBlockPosition(rPos.Tab(), rPos.Col());
     239             : 
     240           0 :     if (!pBlockPos)
     241           0 :         return;
     242             : 
     243           0 :     sc::CellStoreType& rCells = pTab->aCol[rPos.Col()].maCells;
     244           0 :     pBlockPos->miCellPos =
     245           0 :         rCells.set(pBlockPos->miCellPos, rPos.Row(), pCell);
     246             : }
     247             : 
     248           0 : void ScDocumentImport::setMatrixCells(
     249             :     const ScRange& rRange, const ScTokenArray& rArray, formula::FormulaGrammar::Grammar eGram)
     250             : {
     251           0 :     const ScAddress& rBasePos = rRange.aStart;
     252             : 
     253           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(rBasePos.Tab());
     254           0 :     if (!pTab)
     255           0 :         return;
     256             : 
     257             :     sc::ColumnBlockPosition* pBlockPos =
     258           0 :         mpImpl->maBlockPosSet.getBlockPosition(rBasePos.Tab(), rBasePos.Col());
     259             : 
     260           0 :     if (!pBlockPos)
     261           0 :         return;
     262             : 
     263           0 :     sc::CellStoreType& rCells = pTab->aCol[rBasePos.Col()].maCells;
     264             : 
     265             :     // Set the master cell.
     266           0 :     ScFormulaCell* pCell = new ScFormulaCell(&mpImpl->mrDoc, rBasePos, rArray, eGram, MM_FORMULA);
     267             : 
     268           0 :     pBlockPos->miCellPos =
     269           0 :         rCells.set(pBlockPos->miCellPos, rBasePos.Row(), pCell);
     270             : 
     271             :     // Matrix formulas currently need re-calculation on import.
     272             :     pCell->SetMatColsRows(
     273           0 :         rRange.aEnd.Col()-rRange.aStart.Col()+1, rRange.aEnd.Row()-rRange.aStart.Row()+1, true);
     274             : 
     275             :     // Set the reference cells.
     276             :     ScSingleRefData aRefData;
     277           0 :     aRefData.InitFlags();
     278           0 :     aRefData.SetColRel(true);
     279           0 :     aRefData.SetRowRel(true);
     280           0 :     aRefData.SetTabRel(true);
     281           0 :     aRefData.SetAddress(rBasePos, rBasePos);
     282             : 
     283           0 :     ScTokenArray aArr; // consists only of one single reference token.
     284           0 :     ScToken* t = static_cast<ScToken*>(aArr.AddMatrixSingleReference(aRefData));
     285             : 
     286           0 :     ScAddress aPos = rBasePos;
     287           0 :     for (SCROW nRow = rRange.aStart.Row()+1; nRow <= rRange.aEnd.Row(); ++nRow)
     288             :     {
     289             :         // Token array must be cloned so that each formula cell receives its own copy.
     290           0 :         aPos.SetRow(nRow);
     291             :         // Reference in each cell must point to the origin cell relative to the current cell.
     292           0 :         aRefData.SetAddress(rBasePos, aPos);
     293           0 :         t->GetSingleRef() = aRefData;
     294           0 :         boost::scoped_ptr<ScTokenArray> pTokArr(aArr.Clone());
     295           0 :         pCell = new ScFormulaCell(&mpImpl->mrDoc, aPos, *pTokArr, eGram, MM_REFERENCE);
     296           0 :         pBlockPos->miCellPos =
     297           0 :             rCells.set(pBlockPos->miCellPos, aPos.Row(), pCell);
     298           0 :     }
     299             : 
     300           0 :     for (SCCOL nCol = rRange.aStart.Col()+1; nCol <= rRange.aEnd.Col(); ++nCol)
     301             :     {
     302           0 :         pBlockPos = mpImpl->maBlockPosSet.getBlockPosition(rBasePos.Tab(), nCol);
     303           0 :         if (!pBlockPos)
     304           0 :             return;
     305             : 
     306           0 :         sc::CellStoreType& rColCells = pTab->aCol[nCol].maCells;
     307             : 
     308           0 :         aPos.SetCol(nCol);
     309           0 :         for (SCROW nRow = rRange.aStart.Row(); nRow <= rRange.aEnd.Row(); ++nRow)
     310             :         {
     311           0 :             aPos.SetRow(nRow);
     312           0 :             aRefData.SetAddress(rBasePos, aPos);
     313           0 :             t->GetSingleRef() = aRefData;
     314           0 :             boost::scoped_ptr<ScTokenArray> pTokArr(aArr.Clone());
     315           0 :             pCell = new ScFormulaCell(&mpImpl->mrDoc, aPos, *pTokArr, eGram, MM_REFERENCE);
     316           0 :             pBlockPos->miCellPos =
     317           0 :                 rColCells.set(pBlockPos->miCellPos, aPos.Row(), pCell);
     318           0 :         }
     319           0 :     }
     320             : }
     321             : 
     322           0 : void ScDocumentImport::setTableOpCells(const ScRange& rRange, const ScTabOpParam& rParam)
     323             : {
     324           0 :     SCTAB nTab = rRange.aStart.Tab();
     325           0 :     SCCOL nCol1 = rRange.aStart.Col();
     326           0 :     SCROW nRow1 = rRange.aStart.Row();
     327           0 :     SCCOL nCol2 = rRange.aEnd.Col();
     328           0 :     SCROW nRow2 = rRange.aEnd.Row();
     329             : 
     330           0 :     ScTable* pTab = mpImpl->mrDoc.FetchTable(nTab);
     331           0 :     if (!pTab)
     332           0 :         return;
     333             : 
     334           0 :     ScDocument* pDoc = &mpImpl->mrDoc;
     335           0 :     ScRefAddress aRef;
     336           0 :     OUStringBuffer aFormulaBuf('=');
     337           0 :     aFormulaBuf.append(ScCompiler::GetNativeSymbol(ocTableOp));
     338           0 :     aFormulaBuf.append(ScCompiler::GetNativeSymbol(ocOpen));
     339             : 
     340           0 :     OUString aSep = ScCompiler::GetNativeSymbol(ocSep);
     341           0 :     if (rParam.meMode == ScTabOpParam::Column) // column only
     342             :     {
     343           0 :         aRef.Set(rParam.aRefFormulaCell.GetAddress(), true, false, false);
     344           0 :         aFormulaBuf.append(aRef.GetRefString(pDoc, nTab));
     345           0 :         aFormulaBuf.append(aSep);
     346           0 :         aFormulaBuf.append(rParam.aRefColCell.GetRefString(pDoc, nTab));
     347           0 :         aFormulaBuf.append(aSep);
     348           0 :         aRef.Set(nCol1, nRow1, nTab, false, true, true);
     349           0 :         aFormulaBuf.append(aRef.GetRefString(pDoc, nTab));
     350           0 :         nCol1++;
     351           0 :         nCol2 = std::min( nCol2, (SCCOL)(rParam.aRefFormulaEnd.Col() -
     352           0 :                     rParam.aRefFormulaCell.Col() + nCol1 + 1));
     353             :     }
     354           0 :     else if (rParam.meMode == ScTabOpParam::Row) // row only
     355             :     {
     356           0 :         aRef.Set(rParam.aRefFormulaCell.GetAddress(), false, true, false);
     357           0 :         aFormulaBuf.append(aRef.GetRefString(pDoc, nTab));
     358           0 :         aFormulaBuf.append(aSep);
     359           0 :         aFormulaBuf.append(rParam.aRefRowCell.GetRefString(pDoc, nTab));
     360           0 :         aFormulaBuf.append(aSep);
     361           0 :         aRef.Set(nCol1, nRow1, nTab, true, false, true);
     362           0 :         aFormulaBuf.append(aRef.GetRefString(pDoc, nTab));
     363           0 :         ++nRow1;
     364             :         nRow2 = std::min(
     365           0 :             nRow2, rParam.aRefFormulaEnd.Row() - rParam.aRefFormulaCell.Row() + nRow1 + 1);
     366             :     }
     367             :     else // both
     368             :     {
     369           0 :         aFormulaBuf.append(rParam.aRefFormulaCell.GetRefString(pDoc, nTab));
     370           0 :         aFormulaBuf.append(aSep);
     371           0 :         aFormulaBuf.append(rParam.aRefColCell.GetRefString(pDoc, nTab));
     372           0 :         aFormulaBuf.append(aSep);
     373           0 :         aRef.Set(nCol1, nRow1 + 1, nTab, false, true, true);
     374           0 :         aFormulaBuf.append(aRef.GetRefString(pDoc, nTab));
     375           0 :         aFormulaBuf.append(aSep);
     376           0 :         aFormulaBuf.append(rParam.aRefRowCell.GetRefString(pDoc, nTab));
     377           0 :         aFormulaBuf.append(aSep);
     378           0 :         aRef.Set(nCol1 + 1, nRow1, nTab, true, false, true);
     379           0 :         aFormulaBuf.append(aRef.GetRefString(pDoc, nTab));
     380           0 :         ++nCol1;
     381           0 :         ++nRow1;
     382             :     }
     383             : 
     384           0 :     aFormulaBuf.append(ScCompiler::GetNativeSymbol(ocClose));
     385             : 
     386             :     ScFormulaCell aRefCell(
     387             :         pDoc, ScAddress(nCol1, nRow1, nTab), aFormulaBuf.makeStringAndClear(),
     388           0 :         formula::FormulaGrammar::GRAM_NATIVE, MM_NONE);
     389             : 
     390           0 :     for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
     391             :     {
     392             :         sc::ColumnBlockPosition* pBlockPos =
     393           0 :             mpImpl->maBlockPosSet.getBlockPosition(nTab, nCol);
     394             : 
     395           0 :         if (!pBlockPos)
     396             :             // Something went horribly wrong.
     397           0 :             return;
     398             : 
     399           0 :         sc::CellStoreType& rColCells = pTab->aCol[nCol].maCells;
     400             : 
     401           0 :         for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
     402             :         {
     403           0 :             ScAddress aPos(nCol, nRow, nTab);
     404           0 :             ScFormulaCell* pCell = new ScFormulaCell(aRefCell, *pDoc, aPos);
     405           0 :             pBlockPos->miCellPos =
     406           0 :                 rColCells.set(pBlockPos->miCellPos, nRow, pCell);
     407             :         }
     408           0 :     }
     409             : }
     410             : 
     411             : namespace {
     412             : 
     413           0 : class CellStoreInitializer
     414             : {
     415             :     // The pimpl pattern here is intentional.
     416             :     //
     417             :     // The problem with having the attributes in CellStoreInitializer
     418             :     // directly is that, as a functor, it might be copied around. In
     419             :     // that case miPos in _copied_ object points ot maAttrs in the
     420             :     // original object, not in the copy. So later, deep in mdds, we end
     421             :     // up comparing iterators from different sequences.
     422             :     //
     423             :     // This could be solved by defining copy constructor and operator=,
     424             :     // but given the limited usage of the class, I think it is simpler
     425             :     // to let copies share the state.
     426           0 :     struct Impl
     427             :     {
     428             :         sc::CellTextAttrStoreType maAttrs;
     429             :         sc::CellTextAttrStoreType::iterator miPos;
     430             :         sal_uInt16 mnScriptNumeric;
     431             : 
     432           0 :         Impl(const sal_uInt32 nMaxRowCount, const sal_uInt16 nScriptNumeric)
     433           0 :             : maAttrs(nMaxRowCount), miPos(maAttrs.begin()), mnScriptNumeric(nScriptNumeric)
     434           0 :         {}
     435             :     };
     436             : 
     437             :     ScDocument& mrDoc;
     438             :     sc::StartListeningContext& mrListenCxt;
     439             : 
     440             : public:
     441           0 :     CellStoreInitializer(ScDocument& rDoc, sc::StartListeningContext& rCxt, sal_uInt16 nScriptNumeric) :
     442             :         mrDoc(rDoc),
     443             :         mrListenCxt(rCxt),
     444           0 :         mpImpl(new Impl(MAXROWCOUNT, nScriptNumeric))
     445           0 :     {}
     446             : 
     447             :     boost::shared_ptr<Impl> mpImpl;
     448             : 
     449           0 :     void operator() (const sc::CellStoreType::value_type& node)
     450             :     {
     451           0 :         if (node.type == sc::element_type_empty)
     452           0 :             return;
     453             : 
     454             :         // Fill with default values for non-empty cell segments.
     455           0 :         sc::CellTextAttr aDefault;
     456           0 :         if (node.type == sc::element_type_numeric)
     457           0 :             aDefault.mnScriptType = mpImpl->mnScriptNumeric;
     458           0 :         std::vector<sc::CellTextAttr> aDefaults(node.size, aDefault);
     459           0 :         mpImpl->miPos = mpImpl->maAttrs.set(mpImpl->miPos, node.position, aDefaults.begin(), aDefaults.end());
     460             : 
     461           0 :         if (node.type == sc::element_type_formula)
     462             :         {
     463             :             // Have all formula cells start listening to the document.
     464           0 :             sc::formula_block::iterator it = sc::formula_block::begin(*node.data);
     465           0 :             sc::formula_block::iterator itEnd = sc::formula_block::end(*node.data);
     466           0 :             for (; it != itEnd; ++it)
     467             :             {
     468           0 :                 ScFormulaCell& rFC = **it;
     469           0 :                 rFC.StartListeningTo(mrListenCxt);
     470             :             }
     471           0 :         }
     472             :     }
     473             : 
     474           0 :     void swap(sc::CellTextAttrStoreType& rAttrs)
     475             :     {
     476           0 :         mpImpl->maAttrs.swap(rAttrs);
     477           0 :     }
     478             : };
     479             : 
     480             : }
     481             : 
     482           0 : void ScDocumentImport::finalize()
     483             : {
     484             :     // Populate the text width and script type arrays in all columns. Also
     485             :     // activate all formula cells.
     486           0 :     ScDocument::TableContainer::iterator itTab = mpImpl->mrDoc.maTabs.begin(), itTabEnd = mpImpl->mrDoc.maTabs.end();
     487           0 :     for (; itTab != itTabEnd; ++itTab)
     488             :     {
     489           0 :         if (!*itTab)
     490           0 :             continue;
     491             : 
     492           0 :         ScTable& rTab = **itTab;
     493           0 :         ScColumn* pCol = &rTab.aCol[0];
     494           0 :         ScColumn* pColEnd = pCol + static_cast<size_t>(MAXCOLCOUNT);
     495           0 :         for (; pCol != pColEnd; ++pCol)
     496           0 :             initColumn(*pCol);
     497             :     }
     498           0 : }
     499             : 
     500           0 : void ScDocumentImport::initColumn(ScColumn& rCol)
     501             : {
     502           0 :     CellStoreInitializer aFunc(mpImpl->mrDoc, mpImpl->maListenCxt, mpImpl->mnDefaultScriptNumeric);
     503           0 :     std::for_each(rCol.maCells.begin(), rCol.maCells.end(), aFunc);
     504           0 :     aFunc.swap(rCol.maCellTextAttrs);
     505           0 :     rCol.RegroupFormulaCells();
     506           0 :     rCol.CellStorageModified();
     507           0 : }
     508             : 
     509             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10