LCOV - code coverage report
Current view: top level - sc/source/core/data - documen4.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 705 0.0 %
Date: 2014-04-14 Functions: 0 36 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             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <svl/intitem.hxx>
      21             : #include <svl/zforlist.hxx>
      22             : #include <formula/token.hxx>
      23             : 
      24             : #include "document.hxx"
      25             : #include "table.hxx"
      26             : #include "globstr.hrc"
      27             : #include "subtotal.hxx"
      28             : #include "docoptio.hxx"
      29             : #include "interpre.hxx"
      30             : #include "markdata.hxx"
      31             : #include "validat.hxx"
      32             : #include "scitems.hxx"
      33             : #include "stlpool.hxx"
      34             : #include "poolhelp.hxx"
      35             : #include "detdata.hxx"
      36             : #include "patattr.hxx"
      37             : #include "chgtrack.hxx"
      38             : #include "progress.hxx"
      39             : #include "paramisc.hxx"
      40             : #include "compiler.hxx"
      41             : #include "externalrefmgr.hxx"
      42             : #include "colorscale.hxx"
      43             : #include "attrib.hxx"
      44             : #include "formulacell.hxx"
      45             : #include "tokenarray.hxx"
      46             : #include "scmatrix.hxx"
      47             : #include <tokenstringcontext.hxx>
      48             : 
      49             : using namespace formula;
      50             : 
      51             : 
      52             : /** (Goal Seek) Find a value of x that is a root of f(x)
      53             : 
      54             :     This function is used internally for the goal seek operation.  It uses the
      55             :     Regula Falsi (aka false position) algorithm to find a root of f(x).  The
      56             :     start value and the target value are to be given by the user in the
      57             :     goal seek dialog.  The f(x) in this case is defined as the formula in the
      58             :     formula cell minus target value.  This function may also perform additional
      59             :     search in the horizontal directions when the f(x) is discrete in order to
      60             :     ensure a non-zero slope necessary for deriving a subsequent x that is
      61             :     reasonably close to the root of interest.
      62             : 
      63             :     @change 24.10.2004 by Kohei Yoshida (kohei@openoffice.org)
      64             : 
      65             :     @see #i28955#
      66             : 
      67             :     @change 6 Aug 2013, fdo37341
      68             : */
      69           0 : bool ScDocument::Solver(SCCOL nFCol, SCROW nFRow, SCTAB nFTab,
      70             :                         SCCOL nVCol, SCROW nVRow, SCTAB nVTab,
      71             :                         const OUString& sValStr, double& nX)
      72             : {
      73           0 :     bool bRet = false;
      74           0 :     nX = 0.0;
      75           0 :     if ( ValidColRow( nFCol, nFRow ) && ValidTab( nFTab ) &&
      76           0 :          ValidColRow( nVCol, nVRow ) && ValidTab( nVTab ) &&
      77           0 :          nFTab < static_cast<SCTAB>( maTabs.size() ) && maTabs[nFTab] &&
      78           0 :          nVTab < static_cast<SCTAB>( maTabs.size() ) && maTabs[nVTab] )
      79             :     {
      80             :         CellType eFType, eVType;
      81           0 :         GetCellType(nFCol, nFRow, nFTab, eFType);
      82           0 :         GetCellType(nVCol, nVRow, nVTab, eVType);
      83             :         // #i108005# convert target value to number using default format,
      84             :         // as previously done in ScInterpreter::GetDouble
      85           0 :         double fTargetVal = 0.0;
      86           0 :         sal_uInt32 nFIndex = 0;
      87           0 :         if ( eFType == CELLTYPE_FORMULA && eVType == CELLTYPE_VALUE &&
      88           0 :              GetFormatTable()->IsNumberFormat( sValStr, nFIndex, fTargetVal ) )
      89             :         {
      90           0 :             bool bDoneIteration = false;
      91           0 :             ScAddress aValueAdr( nVCol, nVRow, nVTab );
      92           0 :             ScAddress aFormulaAdr( nFCol, nFRow, nFTab );
      93           0 :             double* pVCell = GetValueCell( aValueAdr );
      94             : 
      95           0 :             ScRange aVRange( aValueAdr, aValueAdr );    // for SetDirty
      96             :             // Original value to be restored later if necessary
      97           0 :             double fSaveVal = *pVCell;
      98             : 
      99           0 :             const sal_uInt16 nMaxIter = 100;
     100           0 :             const double fEps = 1E-10;
     101           0 :             const double fDelta = 1E-6;
     102             : 
     103             :             double fBestX, fXPrev;
     104             :             double fBestF, fFPrev;
     105           0 :             fBestX = fXPrev = fSaveVal;
     106             : 
     107           0 :             ScFormulaCell* pFormula = GetFormulaCell( aFormulaAdr );
     108           0 :             pFormula->Interpret();
     109           0 :             bool bError = ( pFormula->GetErrCode() != 0 );
     110             :             // bError always corresponds with fF
     111             : 
     112           0 :             fFPrev = pFormula->GetValue() - fTargetVal;
     113             : 
     114           0 :             fBestF = fabs( fFPrev );
     115           0 :             if ( fBestF < fDelta )
     116           0 :                 bDoneIteration = true;
     117             : 
     118           0 :             double fX = fXPrev + fEps;
     119           0 :             double fF = fFPrev;
     120             :             double fSlope;
     121             : 
     122           0 :             sal_uInt16 nIter = 0;
     123             : 
     124           0 :             bool bHorMoveError = false;
     125             :             // Conform Regula Falsi Method
     126           0 :             while ( !bDoneIteration && ( nIter++ < nMaxIter ) )
     127             :             {
     128           0 :                 *pVCell = fX;
     129           0 :                 SetDirty( aVRange );
     130           0 :                 pFormula->Interpret();
     131           0 :                 bError = ( pFormula->GetErrCode() != 0 );
     132           0 :                 fF = pFormula->GetValue() - fTargetVal;
     133             : 
     134           0 :                 if ( fF == fFPrev && !bError )
     135             :                 {
     136             :                     // HORIZONTAL SEARCH: Keep moving x in both directions until the f(x)
     137             :                     // becomes different from the previous f(x).  This routine is needed
     138             :                     // when a given function is discrete, in which case the resulting slope
     139             :                     // may become zero which ultimately causes the goal seek operation
     140             :                     // to fail. #i28955#
     141             : 
     142           0 :                     sal_uInt16 nHorIter = 0;
     143           0 :                     const double fHorStepAngle = 5.0;
     144           0 :                     const double fHorMaxAngle = 80.0;
     145           0 :                     int nHorMaxIter = static_cast<int>( fHorMaxAngle / fHorStepAngle );
     146           0 :                     bool bDoneHorMove = false;
     147             : 
     148           0 :                     while ( !bDoneHorMove && !bHorMoveError && nHorIter++ < nHorMaxIter )
     149             :                     {
     150           0 :                         double fHorAngle = fHorStepAngle * static_cast<double>( nHorIter );
     151           0 :                         double fHorTangent = ::rtl::math::tan( fHorAngle * F_PI / 180 );
     152             : 
     153           0 :                         sal_uInt16 nIdx = 0;
     154           0 :                         while( nIdx++ < 2 && !bDoneHorMove )
     155             :                         {
     156             :                             double fHorX;
     157           0 :                             if ( nIdx == 1 )
     158           0 :                                 fHorX = fX + fabs( fF ) * fHorTangent;
     159             :                             else
     160           0 :                                 fHorX = fX - fabs( fF ) * fHorTangent;
     161             : 
     162           0 :                             *pVCell = fHorX;
     163           0 :                             SetDirty( aVRange );
     164           0 :                             pFormula->Interpret();
     165           0 :                             bHorMoveError = ( pFormula->GetErrCode() != 0 );
     166           0 :                             if ( bHorMoveError )
     167           0 :                                 break;
     168             : 
     169           0 :                             fF = pFormula->GetValue() - fTargetVal;
     170           0 :                             if ( fF != fFPrev )
     171             :                             {
     172           0 :                                 fX = fHorX;
     173           0 :                                 bDoneHorMove = true;
     174             :                             }
     175             :                         }
     176             :                     }
     177           0 :                     if ( !bDoneHorMove )
     178           0 :                         bHorMoveError = true;
     179             :                 }
     180             : 
     181           0 :                 if ( bError )
     182             :                 {
     183             :                     // move closer to last valid value (fXPrev), keep fXPrev & fFPrev
     184           0 :                     double fDiff = ( fXPrev - fX ) / 2;
     185           0 :                     if ( fabs( fDiff ) < fEps )
     186           0 :                         fDiff = ( fDiff < 0.0 ? - fEps : fEps );
     187           0 :                     fX += fDiff;
     188             :                 }
     189           0 :                 else if ( bHorMoveError )
     190           0 :                     break;
     191           0 :                 else if ( fabs(fF) < fDelta )
     192             :                 {
     193             :                     // converged to root
     194           0 :                     fBestX = fX;
     195           0 :                     bDoneIteration = true;
     196             :                 }
     197             :                 else
     198             :                 {
     199           0 :                     if ( fabs(fF) + fDelta < fBestF )
     200             :                     {
     201           0 :                         fBestX = fX;
     202           0 :                         fBestF = fabs( fF );
     203             :                     }
     204             : 
     205           0 :                     if ( ( fXPrev - fX ) != 0 )
     206             :                     {
     207           0 :                         fSlope = ( fFPrev - fF ) / ( fXPrev - fX );
     208           0 :                         if ( fabs( fSlope ) < fEps )
     209           0 :                             fSlope = fSlope < 0.0 ? -fEps : fEps;
     210             :                     }
     211             :                     else
     212           0 :                         fSlope = fEps;
     213             : 
     214           0 :                     fXPrev = fX;
     215           0 :                     fFPrev = fF;
     216           0 :                     fX = fX - ( fF / fSlope );
     217             :                 }
     218             :             }
     219             : 
     220             :             // Try a nice rounded input value if possible.
     221           0 :             const double fNiceDelta = ( bDoneIteration && fabs( fBestX ) >= 1e-3 ? 1e-3 : fDelta );
     222           0 :             nX = ::rtl::math::approxFloor( ( fBestX / fNiceDelta ) + 0.5 ) * fNiceDelta;
     223             : 
     224           0 :             if ( bDoneIteration )
     225             :             {
     226           0 :                 *pVCell = nX;
     227           0 :                 SetDirty( aVRange );
     228           0 :                 pFormula->Interpret();
     229           0 :                 if ( fabs( pFormula->GetValue() - fTargetVal ) > fabs( fF ) )
     230           0 :                     nX = fBestX;
     231           0 :                 bRet = true;
     232             :             }
     233           0 :             else if ( bError || bHorMoveError )
     234             :             {
     235           0 :                 nX = fBestX;
     236             :             }
     237           0 :             *pVCell = fSaveVal;
     238           0 :             SetDirty( aVRange );
     239           0 :             pFormula->Interpret();
     240           0 :             if ( !bDoneIteration )
     241             :             {
     242           0 :                 SetError( nVCol, nVRow, nVTab, NOTAVAILABLE );
     243             :             }
     244             :         }
     245             :         else
     246             :         {
     247           0 :             SetError( nVCol, nVRow, nVTab, NOTAVAILABLE );
     248             :         }
     249             :     }
     250           0 :     return bRet;
     251             : }
     252             : 
     253           0 : void ScDocument::InsertMatrixFormula(SCCOL nCol1, SCROW nRow1,
     254             :                                      SCCOL nCol2, SCROW nRow2,
     255             :                                      const ScMarkData& rMark,
     256             :                                      const OUString& rFormula,
     257             :                                      const ScTokenArray* pArr,
     258             :                                      const formula::FormulaGrammar::Grammar eGram,
     259             :                                      bool bDirtyFlag )
     260             : {
     261           0 :     PutInOrder(nCol1, nCol2);
     262           0 :     PutInOrder(nRow1, nRow2);
     263           0 :     nCol2 = std::min<SCCOL>(nCol2, MAXCOL);
     264           0 :     nRow2 = std::min<SCROW>(nRow2, MAXROW);
     265           0 :     if (!rMark.GetSelectCount())
     266             :     {
     267             :         SAL_WARN("sc", "ScDocument::InsertMatrixFormula: No table marked");
     268           0 :         return;
     269             :     }
     270             : 
     271           0 :     SCTAB nTab1 = *rMark.begin();
     272             : 
     273             :     ScFormulaCell* pCell;
     274           0 :     ScAddress aPos( nCol1, nRow1, nTab1 );
     275           0 :     if (pArr)
     276           0 :         pCell = new ScFormulaCell(this, aPos, *pArr, eGram, MM_FORMULA);
     277             :     else
     278           0 :         pCell = new ScFormulaCell( this, aPos, rFormula, eGram, MM_FORMULA );
     279           0 :     pCell->SetMatColsRows( nCol2 - nCol1 + 1, nRow2 - nRow1 + 1, bDirtyFlag );
     280           0 :     ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
     281           0 :     SCTAB nMax = static_cast<SCTAB>(maTabs.size());
     282           0 :     for (; itr != itrEnd && *itr < nMax; ++itr)
     283             :     {
     284           0 :         if (!maTabs[*itr])
     285           0 :             continue;
     286             : 
     287           0 :         if (*itr == nTab1)
     288             :         {
     289           0 :             pCell = maTabs[*itr]->SetFormulaCell(nCol1, nRow1, pCell);
     290             :             assert(pCell);  //NULL if nCol1/nRow1 is invalid, which it can't be here
     291           0 :             if (!pCell)
     292           0 :                 break;
     293             :         }
     294             :         else
     295           0 :             maTabs[*itr]->SetFormulaCell(
     296             :                 nCol1, nRow1,
     297             :                 new ScFormulaCell(
     298           0 :                     *pCell, *this, ScAddress(nCol1, nRow1, *itr), SC_CLONECELL_STARTLISTENING));
     299             :     }
     300             : 
     301           0 :     ScAddress aBasePos(nCol1, nRow1, nTab1);
     302             :     ScSingleRefData aRefData;
     303           0 :     aRefData.InitFlags();
     304           0 :     aRefData.SetColRel( true );
     305           0 :     aRefData.SetRowRel( true );
     306           0 :     aRefData.SetTabRel( true );
     307           0 :     aRefData.SetAddress(aBasePos, aBasePos);
     308             : 
     309           0 :     ScTokenArray aArr; // consists only of one single reference token.
     310           0 :     ScToken* t = static_cast<ScToken*>(aArr.AddMatrixSingleReference( aRefData));
     311             : 
     312           0 :     itr = rMark.begin();
     313           0 :     for (; itr != itrEnd && *itr < nMax; ++itr)
     314             :     {
     315           0 :         SCTAB nTab = *itr;
     316           0 :         ScTable* pTab = FetchTable(nTab);
     317           0 :         if (!pTab)
     318           0 :             continue;
     319             : 
     320           0 :         if (nTab != nTab1)
     321             :         {
     322           0 :             aRefData.SetRelTab(nTab - aBasePos.Tab());
     323           0 :             t->GetSingleRef() = aRefData;
     324             :         }
     325             : 
     326           0 :         for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
     327             :         {
     328           0 :             for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
     329             :             {
     330           0 :                 if (nCol == nCol1 && nRow == nRow1)
     331             :                     // Skip the base position.
     332           0 :                     continue;
     333             : 
     334             :                 // Token array must be cloned so that each formula cell receives its own copy.
     335           0 :                 aPos = ScAddress(nCol, nRow, nTab);
     336             :                 // Reference in each cell must point to the origin cell relative to the current cell.
     337           0 :                 aRefData.SetAddress(aBasePos, aPos);
     338           0 :                 t->GetSingleRef() = aRefData;
     339           0 :                 boost::scoped_ptr<ScTokenArray> pTokArr(aArr.Clone());
     340           0 :                 pCell = new ScFormulaCell(this, aPos, *pTokArr, eGram, MM_REFERENCE);
     341           0 :                 pTab->SetFormulaCell(nCol, nRow, pCell);
     342           0 :             }
     343             :         }
     344           0 :     }
     345             : }
     346             : 
     347           0 : void ScDocument::InsertTableOp(const ScTabOpParam& rParam,      // Mehrfachoperation
     348             :                                SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
     349             :                                const ScMarkData& rMark)
     350             : {
     351           0 :     PutInOrder(nCol1, nCol2);
     352           0 :     PutInOrder(nRow1, nRow2);
     353             :     SCTAB i, nTab1;
     354             :     SCCOL j;
     355             :     SCROW k;
     356           0 :     i = 0;
     357           0 :     bool bStop = false;
     358           0 :     SCTAB nMax = static_cast<SCTAB>(maTabs.size());
     359           0 :     ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
     360           0 :     for (; itr != itrEnd && *itr < nMax; ++itr)
     361             :     {
     362           0 :         if (maTabs[*itr])
     363             :         {
     364           0 :             i = *itr;
     365           0 :             bStop = true;
     366           0 :             break;
     367             :         }
     368             :     }
     369           0 :     nTab1 = i;
     370           0 :     if (!bStop)
     371             :     {
     372             :         OSL_FAIL("ScDocument::InsertTableOp: No table marked");
     373           0 :         return;
     374             :     }
     375             : 
     376           0 :     ScRefAddress aRef;
     377           0 :     OUStringBuffer aForString('=');
     378           0 :     aForString.append(ScCompiler::GetNativeSymbol(ocTableOp));
     379           0 :     aForString.append(ScCompiler::GetNativeSymbol( ocOpen));
     380             : 
     381           0 :     const OUString& sSep = ScCompiler::GetNativeSymbol( ocSep);
     382           0 :     if (rParam.meMode == ScTabOpParam::Column) // column only
     383             :     {
     384           0 :         aRef.Set( rParam.aRefFormulaCell.GetAddress(), true, false, false );
     385           0 :         aForString.append(aRef.GetRefString(this, nTab1));
     386           0 :         aForString.append(sSep);
     387           0 :         aForString.append(rParam.aRefColCell.GetRefString(this, nTab1));
     388           0 :         aForString.append(sSep);
     389           0 :         aRef.Set( nCol1, nRow1, nTab1, false, true, true );
     390           0 :         aForString.append(aRef.GetRefString(this, nTab1));
     391           0 :         nCol1++;
     392           0 :         nCol2 = std::min( nCol2, (SCCOL)(rParam.aRefFormulaEnd.Col() -
     393           0 :                     rParam.aRefFormulaCell.Col() + nCol1 + 1));
     394             :     }
     395           0 :     else if (rParam.meMode == ScTabOpParam::Row) // row only
     396             :     {
     397           0 :         aRef.Set( rParam.aRefFormulaCell.GetAddress(), false, true, false );
     398           0 :         aForString.append(aRef.GetRefString(this, nTab1));
     399           0 :         aForString.append(sSep);
     400           0 :         aForString.append(rParam.aRefRowCell.GetRefString(this, nTab1));
     401           0 :         aForString.append(sSep);
     402           0 :         aRef.Set( nCol1, nRow1, nTab1, true, false, true );
     403           0 :         aForString.append(aRef.GetRefString(this, nTab1));
     404           0 :         nRow1++;
     405           0 :         nRow2 = std::min( nRow2, (SCROW)(rParam.aRefFormulaEnd.Row() -
     406           0 :                     rParam.aRefFormulaCell.Row() + nRow1 + 1));
     407             :     }
     408             :     else // both
     409             :     {
     410           0 :         aForString.append(rParam.aRefFormulaCell.GetRefString(this, nTab1));
     411           0 :         aForString.append(sSep);
     412           0 :         aForString.append(rParam.aRefColCell.GetRefString(this, nTab1));
     413           0 :         aForString.append(sSep);
     414           0 :         aRef.Set( nCol1, nRow1 + 1, nTab1, false, true, true );
     415           0 :         aForString.append(aRef.GetRefString(this, nTab1));
     416           0 :         aForString.append(sSep);
     417           0 :         aForString.append(rParam.aRefRowCell.GetRefString(this, nTab1));
     418           0 :         aForString.append(sSep);
     419           0 :         aRef.Set( nCol1 + 1, nRow1, nTab1, true, false, true );
     420           0 :         aForString.append(aRef.GetRefString(this, nTab1));
     421           0 :         nCol1++; nRow1++;
     422             :     }
     423           0 :     aForString.append(ScCompiler::GetNativeSymbol( ocClose ));
     424             : 
     425             :     ScFormulaCell aRefCell( this, ScAddress( nCol1, nRow1, nTab1 ), aForString.makeStringAndClear(),
     426           0 :            formula::FormulaGrammar::GRAM_NATIVE, MM_NONE );
     427           0 :     for( j = nCol1; j <= nCol2; j++ )
     428           0 :         for( k = nRow1; k <= nRow2; k++ )
     429           0 :             for (i = 0; i < static_cast<SCTAB>(maTabs.size()); i++)
     430             :             {
     431           0 :                 itr = rMark.begin();
     432           0 :                 for (; itr != itrEnd && *itr < nMax; ++itr)
     433           0 :                 if( maTabs[*itr] )
     434           0 :                     maTabs[*itr]->SetFormulaCell(
     435           0 :                         j, k, new ScFormulaCell(aRefCell, *this, ScAddress(j, k, *itr), SC_CLONECELL_STARTLISTENING));
     436           0 :             }
     437             : }
     438             : 
     439             : namespace {
     440             : 
     441           0 : bool setCacheTableReferenced(ScToken& rToken, ScExternalRefManager& rRefMgr, const ScAddress& rPos)
     442             : {
     443           0 :     switch (rToken.GetType())
     444             :     {
     445             :         case svExternalSingleRef:
     446             :             return rRefMgr.setCacheTableReferenced(
     447           0 :                 rToken.GetIndex(), rToken.GetString().getString(), 1);
     448             :         case svExternalDoubleRef:
     449             :         {
     450           0 :             const ScComplexRefData& rRef = rToken.GetDoubleRef();
     451           0 :             ScRange aAbs = rRef.toAbs(rPos);
     452           0 :             size_t nSheets = aAbs.aEnd.Tab() - aAbs.aStart.Tab() + 1;
     453             :             return rRefMgr.setCacheTableReferenced(
     454           0 :                     rToken.GetIndex(), rToken.GetString().getString(), nSheets);
     455             :         }
     456             :         case svExternalName:
     457             :             /* TODO: external names aren't supported yet, but would
     458             :              * have to be marked as well, if so. Mechanism would be
     459             :              * different. */
     460             :             OSL_FAIL("ScDocument::MarkUsedExternalReferences: implement the svExternalName case!");
     461             :         default:
     462             :             ;
     463             :     }
     464           0 :     return false;
     465             : }
     466             : 
     467             : }
     468             : 
     469           0 : bool ScDocument::MarkUsedExternalReferences( ScTokenArray& rArr, const ScAddress& rPos )
     470             : {
     471           0 :     if (!rArr.GetLen())
     472           0 :         return false;
     473             : 
     474           0 :     ScExternalRefManager* pRefMgr = NULL;
     475           0 :     rArr.Reset();
     476           0 :     ScToken* t = NULL;
     477           0 :     bool bAllMarked = false;
     478           0 :     while (!bAllMarked && (t = static_cast<ScToken*>(rArr.GetNextReferenceOrName())) != NULL)
     479             :     {
     480           0 :         if (t->IsExternalRef())
     481             :         {
     482           0 :             if (!pRefMgr)
     483           0 :                 pRefMgr = GetExternalRefManager();
     484             : 
     485           0 :             bAllMarked = setCacheTableReferenced(*t, *pRefMgr, rPos);
     486             :         }
     487           0 :         else if (t->GetType() == svIndex)
     488             :         {
     489             :             // this is a named range.  Check if the range contains an external
     490             :             // reference.
     491           0 :             ScRangeData* pRangeData = GetRangeName()->findByIndex(t->GetIndex());
     492           0 :             if (!pRangeData)
     493           0 :                 continue;
     494             : 
     495           0 :             ScTokenArray* pArray = pRangeData->GetCode();
     496           0 :             for (t = static_cast<ScToken*>(pArray->First()); t; t = static_cast<ScToken*>(pArray->Next()))
     497             :             {
     498           0 :                 if (!t->IsExternalRef())
     499           0 :                     continue;
     500             : 
     501           0 :                 if (!pRefMgr)
     502           0 :                     pRefMgr = GetExternalRefManager();
     503             : 
     504           0 :                 bAllMarked = setCacheTableReferenced(*t, *pRefMgr, rPos);
     505             :             }
     506             :         }
     507             :     }
     508           0 :     return bAllMarked;
     509             : }
     510             : 
     511           0 : bool ScDocument::GetNextSpellingCell(SCCOL& nCol, SCROW& nRow, SCTAB nTab,
     512             :                         bool bInSel, const ScMarkData& rMark) const
     513             : {
     514           0 :     if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     515           0 :         return maTabs[nTab]->GetNextSpellingCell( nCol, nRow, bInSel, rMark );
     516             :     else
     517           0 :         return false;
     518             : }
     519             : 
     520           0 : bool ScDocument::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, SCTAB nTab,
     521             :                                         const ScMarkData& rMark )
     522             : {
     523           0 :     if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     524           0 :         return maTabs[nTab]->GetNextMarkedCell( rCol, rRow, rMark );
     525             :     else
     526           0 :         return false;
     527             : }
     528             : 
     529           0 : bool ScDocument::ReplaceStyle(const SvxSearchItem& rSearchItem,
     530             :                               SCCOL nCol, SCROW nRow, SCTAB nTab,
     531             :                               ScMarkData& rMark,
     532             :                               bool bIsUndoP)
     533             : {
     534           0 :     if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     535           0 :         return maTabs[nTab]->ReplaceStyle(rSearchItem, nCol, nRow, rMark, bIsUndoP);
     536             :     else
     537           0 :         return false;
     538             : }
     539             : 
     540           0 : void ScDocument::CompileDBFormula()
     541             : {
     542           0 :     sc::CompileFormulaContext aCxt(this);
     543           0 :     TableContainer::iterator it = maTabs.begin();
     544           0 :     for (;it != maTabs.end(); ++it)
     545             :     {
     546           0 :         if (*it)
     547           0 :             (*it)->CompileDBFormula(aCxt);
     548           0 :     }
     549           0 : }
     550             : 
     551           0 : void ScDocument::CompileDBFormula( bool bCreateFormulaString )
     552             : {
     553           0 :     sc::CompileFormulaContext aCxt(this);
     554           0 :     TableContainer::iterator it = maTabs.begin();
     555           0 :     for (;it != maTabs.end(); ++it)
     556             :     {
     557           0 :         if (*it)
     558           0 :             (*it)->CompileDBFormula(aCxt, bCreateFormulaString);
     559           0 :     }
     560           0 : }
     561             : 
     562           0 : void ScDocument::CompileColRowNameFormula()
     563             : {
     564           0 :     sc::CompileFormulaContext aCxt(this);
     565           0 :     TableContainer::iterator it = maTabs.begin();
     566           0 :     for (;it != maTabs.end(); ++it)
     567             :     {
     568           0 :         if (*it)
     569           0 :             (*it)->CompileColRowNameFormula(aCxt);
     570           0 :     }
     571           0 : }
     572             : 
     573           0 : void ScDocument::InvalidateTableArea()
     574             : {
     575           0 :     TableContainer::iterator it = maTabs.begin();
     576           0 :     for (;it != maTabs.end() && *it; ++it)
     577             :     {
     578           0 :         (*it)->InvalidateTableArea();
     579           0 :         if ( (*it)->IsScenario() )
     580           0 :             (*it)->InvalidateScenarioRanges();
     581             :     }
     582           0 : }
     583             : 
     584           0 : sal_Int32 ScDocument::GetMaxStringLen( SCTAB nTab, SCCOL nCol,
     585             :         SCROW nRowStart, SCROW nRowEnd, rtl_TextEncoding eCharSet ) const
     586             : {
     587           0 :     if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     588           0 :         return maTabs[nTab]->GetMaxStringLen( nCol, nRowStart, nRowEnd, eCharSet );
     589             :     else
     590           0 :         return 0;
     591             : }
     592             : 
     593           0 : sal_Int32 ScDocument::GetMaxNumberStringLen( sal_uInt16& nPrecision, SCTAB nTab,
     594             :                                     SCCOL nCol,
     595             :                                     SCROW nRowStart, SCROW nRowEnd ) const
     596             : {
     597           0 :     if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     598           0 :         return maTabs[nTab]->GetMaxNumberStringLen( nPrecision, nCol,
     599           0 :             nRowStart, nRowEnd );
     600             :     else
     601           0 :         return 0;
     602             : }
     603             : 
     604           0 : bool ScDocument::GetSelectionFunction( ScSubTotalFunc eFunc,
     605             :                                         const ScAddress& rCursor, const ScMarkData& rMark,
     606             :                                         double& rResult )
     607             : {
     608           0 :     ScFunctionData aData(eFunc);
     609             : 
     610           0 :     ScMarkData aMark(rMark);
     611           0 :     aMark.MarkToMulti();
     612           0 :     if (!aMark.IsMultiMarked())
     613           0 :         aMark.SetMarkArea(rCursor);
     614             : 
     615           0 :     SCTAB nMax = static_cast<SCTAB>(maTabs.size());
     616           0 :     ScMarkData::const_iterator itr = aMark.begin(), itrEnd = aMark.end();
     617             : 
     618           0 :     for (; itr != itrEnd && *itr < nMax && !aData.bError; ++itr)
     619           0 :         if (maTabs[*itr])
     620           0 :             maTabs[*itr]->UpdateSelectionFunction(aData, aMark);
     621             : 
     622             :             //! rMark an UpdateSelectionFunction uebergeben !!!!!
     623             : 
     624           0 :     if (!aData.bError)
     625           0 :         switch (eFunc)
     626             :         {
     627             :             case SUBTOTAL_FUNC_SUM:
     628           0 :                 rResult = aData.nVal;
     629           0 :                 break;
     630             :             case SUBTOTAL_FUNC_SELECTION_COUNT:
     631           0 :                 rResult = aData.nCount;
     632           0 :                 break;
     633             :             case SUBTOTAL_FUNC_CNT:
     634             :             case SUBTOTAL_FUNC_CNT2:
     635           0 :                 rResult = aData.nCount;
     636           0 :                 break;
     637             :             case SUBTOTAL_FUNC_AVE:
     638           0 :                 if (aData.nCount)
     639           0 :                     rResult = aData.nVal / (double) aData.nCount;
     640             :                 else
     641           0 :                     aData.bError = true;
     642           0 :                 break;
     643             :             case SUBTOTAL_FUNC_MAX:
     644             :             case SUBTOTAL_FUNC_MIN:
     645           0 :                 if (aData.nCount)
     646           0 :                     rResult = aData.nVal;
     647             :                 else
     648           0 :                     aData.bError = true;
     649           0 :                 break;
     650             :             default:
     651             :             {
     652             :                 // added to avoid warnings
     653             :             }
     654             :         }
     655             : 
     656           0 :     if (aData.bError)
     657           0 :         rResult = 0.0;
     658             : 
     659           0 :     return !aData.bError;
     660             : }
     661             : 
     662           0 : double ScDocument::RoundValueAsShown( double fVal, sal_uInt32 nFormat ) const
     663             : {
     664             :     short nType;
     665           0 :     if ( (nType = GetFormatTable()->GetType( nFormat )) != NUMBERFORMAT_DATE
     666           0 :       && nType != NUMBERFORMAT_TIME && nType != NUMBERFORMAT_DATETIME )
     667             :     {
     668             :         short nPrecision;
     669           0 :         if ((nFormat % SV_COUNTRY_LANGUAGE_OFFSET) != 0)
     670             :         {
     671           0 :             nPrecision = (short)GetFormatTable()->GetFormatPrecision( nFormat );
     672           0 :             switch ( nType )
     673             :             {
     674             :                 case NUMBERFORMAT_PERCENT:      // 0,41% == 0,0041
     675           0 :                     nPrecision += 2;
     676           0 :                     break;
     677             :                 case NUMBERFORMAT_SCIENTIFIC:   // 1,23e-3 == 0,00123
     678             :                 {
     679           0 :                     if ( fVal > 0.0 )
     680           0 :                         nPrecision = sal::static_int_cast<short>( nPrecision - (short)floor( log10( fVal ) ) );
     681           0 :                     else if ( fVal < 0.0 )
     682           0 :                         nPrecision = sal::static_int_cast<short>( nPrecision - (short)floor( log10( -fVal ) ) );
     683           0 :                     break;
     684             :                 }
     685             :             }
     686             :         }
     687             :         else
     688             :         {
     689           0 :             nPrecision = (short)GetDocOptions().GetStdPrecision();
     690             :             // #i115512# no rounding for automatic decimals
     691           0 :             if (nPrecision == static_cast<short>(SvNumberFormatter::UNLIMITED_PRECISION))
     692           0 :                 return fVal;
     693             :         }
     694           0 :         double fRound = ::rtl::math::round( fVal, nPrecision );
     695           0 :         if ( ::rtl::math::approxEqual( fVal, fRound ) )
     696           0 :             return fVal;        // durch Rundung hoechstens Fehler
     697             :         else
     698           0 :             return fRound;
     699             :     }
     700             :     else
     701           0 :         return fVal;
     702             : }
     703             : 
     704             : 
     705             : //          bedingte Formate und Gueltigkeitsbereiche
     706             : 
     707             : 
     708           0 : sal_uLong ScDocument::AddCondFormat( ScConditionalFormat* pNew, SCTAB nTab )
     709             : {
     710           0 :     if(!pNew)
     711           0 :         return 0;
     712             : 
     713           0 :     if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     714           0 :         return maTabs[nTab]->AddCondFormat( pNew );
     715             : 
     716           0 :     return 0;
     717             : }
     718             : 
     719           0 : sal_uLong ScDocument::AddValidationEntry( const ScValidationData& rNew )
     720             : {
     721           0 :     if (rNew.IsEmpty())
     722           0 :         return 0;                   // leer ist immer 0
     723             : 
     724           0 :     if (!pValidationList)
     725           0 :         pValidationList = new ScValidationDataList;
     726             : 
     727           0 :     sal_uLong nMax = 0;
     728           0 :     for( ScValidationDataList::iterator it = pValidationList->begin(); it != pValidationList->end(); ++it )
     729             :     {
     730           0 :         const ScValidationData* pData = *it;
     731           0 :         sal_uLong nKey = pData->GetKey();
     732           0 :         if ( pData->EqualEntries( rNew ) )
     733           0 :             return nKey;
     734           0 :         if ( nKey > nMax )
     735           0 :             nMax = nKey;
     736             :     }
     737             : 
     738             :     // Der Aufruf kann aus ScPatternAttr::PutInPool kommen, darum Clone (echte Kopie)
     739             : 
     740           0 :     sal_uLong nNewKey = nMax + 1;
     741           0 :     ScValidationData* pInsert = rNew.Clone(this);
     742           0 :     pInsert->SetKey( nNewKey );
     743           0 :     pValidationList->InsertNew( pInsert );
     744           0 :     return nNewKey;
     745             : }
     746             : 
     747           0 : const SfxPoolItem* ScDocument::GetEffItem(
     748             :                         SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich ) const
     749             : {
     750           0 :     const ScPatternAttr* pPattern = GetPattern( nCol, nRow, nTab );
     751           0 :     if ( pPattern )
     752             :     {
     753           0 :         const SfxItemSet& rSet = pPattern->GetItemSet();
     754             :         const SfxPoolItem* pItem;
     755           0 :         if ( rSet.GetItemState( ATTR_CONDITIONAL, true, &pItem ) == SFX_ITEM_SET )
     756             :         {
     757           0 :             const std::vector<sal_uInt32>& rIndex = static_cast<const ScCondFormatItem&>(pPattern->GetItem(ATTR_CONDITIONAL)).GetCondFormatData();
     758           0 :             ScConditionalFormatList* pCondFormList = GetCondFormList( nTab );
     759           0 :             if (!rIndex.empty() && pCondFormList)
     760             :             {
     761           0 :                 for(std::vector<sal_uInt32>::const_iterator itr = rIndex.begin(), itrEnd = rIndex.end();
     762             :                         itr != itrEnd; ++itr)
     763             :                 {
     764           0 :                     const ScConditionalFormat* pForm = pCondFormList->GetFormat( *itr );
     765           0 :                     if ( pForm )
     766             :                     {
     767           0 :                         ScAddress aPos(nCol, nRow, nTab);
     768           0 :                         ScRefCellValue aCell;
     769           0 :                         aCell.assign(const_cast<ScDocument&>(*this), aPos);
     770           0 :                         OUString aStyle = pForm->GetCellStyle(aCell, aPos);
     771           0 :                         if (!aStyle.isEmpty())
     772             :                         {
     773           0 :                             SfxStyleSheetBase* pStyleSheet = xPoolHelper->GetStylePool()->Find(
     774           0 :                                     aStyle, SFX_STYLE_FAMILY_PARA );
     775           0 :                             if ( pStyleSheet && pStyleSheet->GetItemSet().GetItemState(
     776           0 :                                         nWhich, true, &pItem ) == SFX_ITEM_SET )
     777           0 :                                 return pItem;
     778           0 :                         }
     779             :                     }
     780             :                 }
     781             :             }
     782             :         }
     783           0 :         return &rSet.Get( nWhich );
     784             :     }
     785             :     OSL_FAIL("no pattern");
     786           0 :     return NULL;
     787             : }
     788             : 
     789           0 : const SfxItemSet* ScDocument::GetCondResult( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
     790             : {
     791           0 :     ScConditionalFormatList* pFormatList = GetCondFormList(nTab);
     792           0 :     if (!pFormatList)
     793           0 :         return NULL;
     794             : 
     795           0 :     ScAddress aPos(nCol, nRow, nTab);
     796           0 :     ScRefCellValue aCell;
     797           0 :     aCell.assign(const_cast<ScDocument&>(*this), aPos);
     798           0 :     const ScPatternAttr* pPattern = GetPattern( nCol, nRow, nTab );
     799             :     const std::vector<sal_uInt32>& rIndex =
     800           0 :         static_cast<const ScCondFormatItem&>(pPattern->GetItem(ATTR_CONDITIONAL)).GetCondFormatData();
     801             : 
     802           0 :     return GetCondResult(aCell, aPos, *pFormatList, rIndex);
     803             : }
     804             : 
     805           0 : const SfxItemSet* ScDocument::GetCondResult(
     806             :     ScRefCellValue& rCell, const ScAddress& rPos, const ScConditionalFormatList& rList,
     807             :     const std::vector<sal_uInt32>& rIndex ) const
     808             : {
     809           0 :     std::vector<sal_uInt32>::const_iterator itr = rIndex.begin(), itrEnd = rIndex.end();
     810           0 :     for (; itr != itrEnd; ++itr)
     811             :     {
     812           0 :         const ScConditionalFormat* pForm = rList.GetFormat(*itr);
     813           0 :         if (!pForm)
     814           0 :             continue;
     815             : 
     816           0 :         const OUString& aStyle = pForm->GetCellStyle(rCell, rPos);
     817           0 :         if (!aStyle.isEmpty())
     818             :         {
     819             :             SfxStyleSheetBase* pStyleSheet =
     820           0 :                 xPoolHelper->GetStylePool()->Find(aStyle, SFX_STYLE_FAMILY_PARA);
     821             : 
     822           0 :             if (pStyleSheet)
     823           0 :                 return &pStyleSheet->GetItemSet();
     824             : 
     825             :             // if style is not there, treat like no condition
     826             :         }
     827             :     }
     828             : 
     829           0 :     return NULL;
     830             : }
     831             : 
     832           0 : ScConditionalFormat* ScDocument::GetCondFormat(
     833             :                             SCCOL nCol, SCROW nRow, SCTAB nTab ) const
     834             : {
     835           0 :     sal_uInt32 nIndex = 0;
     836           0 :     const std::vector<sal_uInt32>& rCondFormats = static_cast<const ScCondFormatItem*>(GetAttr(nCol, nRow, nTab, ATTR_CONDITIONAL))->GetCondFormatData();
     837             : 
     838           0 :     if(!rCondFormats.empty())
     839           0 :         nIndex = rCondFormats[0];
     840             : 
     841           0 :     if (nIndex)
     842             :     {
     843           0 :         ScConditionalFormatList* pCondFormList = GetCondFormList(nTab);
     844           0 :         if (pCondFormList)
     845           0 :             return pCondFormList->GetFormat( nIndex );
     846             :         else
     847             :         {
     848             :             OSL_FAIL("pCondFormList is 0");
     849             :         }
     850             :     }
     851             : 
     852           0 :     return NULL;
     853             : }
     854             : 
     855           0 : ScConditionalFormatList* ScDocument::GetCondFormList(SCTAB nTab) const
     856             : {
     857           0 :     if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     858           0 :         return maTabs[nTab]->GetCondFormList();
     859             : 
     860           0 :     return NULL;
     861             : }
     862             : 
     863           0 : void ScDocument::SetCondFormList( ScConditionalFormatList* pList, SCTAB nTab )
     864             : {
     865           0 :     if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     866           0 :         maTabs[nTab]->SetCondFormList(pList);
     867           0 : }
     868             : 
     869             : 
     870           0 : const ScValidationData* ScDocument::GetValidationEntry( sal_uLong nIndex ) const
     871             : {
     872           0 :     if ( pValidationList )
     873           0 :         return pValidationList->GetData( nIndex );
     874             :     else
     875           0 :         return NULL;
     876             : }
     877             : 
     878           0 : void ScDocument::DeleteConditionalFormat(sal_uLong nOldIndex, SCTAB nTab)
     879             : {
     880           0 :     if(ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     881           0 :         maTabs[nTab]->DeleteConditionalFormat(nOldIndex);
     882           0 : }
     883             : 
     884           0 : bool ScDocument::HasDetectiveOperations() const
     885             : {
     886           0 :     return pDetOpList && pDetOpList->Count();
     887             : }
     888             : 
     889           0 : void ScDocument::AddDetectiveOperation( const ScDetOpData& rData )
     890             : {
     891           0 :     if (!pDetOpList)
     892           0 :         pDetOpList = new ScDetOpList;
     893             : 
     894           0 :     pDetOpList->Append( new ScDetOpData( rData ) );
     895           0 : }
     896             : 
     897           0 : void ScDocument::ClearDetectiveOperations()
     898             : {
     899           0 :     delete pDetOpList;      // loescht auch die Eintraege
     900           0 :     pDetOpList = NULL;
     901           0 : }
     902             : 
     903           0 : void ScDocument::SetDetOpList(ScDetOpList* pNew)
     904             : {
     905           0 :     delete pDetOpList;      // loescht auch die Eintraege
     906           0 :     pDetOpList = pNew;
     907           0 : }
     908             : 
     909             : //      Vergleich von Dokumenten
     910             : 
     911             : //  Pfriemel-Faktoren
     912             : #define SC_DOCCOMP_MAXDIFF  256
     913             : #define SC_DOCCOMP_MINGOOD  128
     914             : #define SC_DOCCOMP_COLUMNS  10
     915             : #define SC_DOCCOMP_ROWS     100
     916             : 
     917             : 
     918           0 : sal_uInt16 ScDocument::RowDifferences( SCROW nThisRow, SCTAB nThisTab,
     919             :                                     ScDocument& rOtherDoc, SCROW nOtherRow, SCTAB nOtherTab,
     920             :                                     SCCOL nMaxCol, SCCOLROW* pOtherCols )
     921             : {
     922           0 :     sal_uLong nDif = 0;
     923           0 :     sal_uLong nUsed = 0;
     924           0 :     for (SCCOL nThisCol=0; nThisCol<=nMaxCol; nThisCol++)
     925             :     {
     926             :         SCCOL nOtherCol;
     927           0 :         if ( pOtherCols )
     928           0 :             nOtherCol = static_cast<SCCOL>(pOtherCols[nThisCol]);
     929             :         else
     930           0 :             nOtherCol = nThisCol;
     931             : 
     932           0 :         if (ValidCol(nOtherCol))    // nur Spalten vergleichen, die in beiden Dateien sind
     933             :         {
     934           0 :             ScRefCellValue aThisCell, aOtherCell;
     935           0 :             aThisCell.assign(*this, ScAddress(nThisCol, nThisRow, nThisTab));
     936           0 :             aOtherCell.assign(rOtherDoc, ScAddress(nOtherCol, nOtherRow, nOtherTab));
     937           0 :             if (!aThisCell.equalsWithoutFormat(aOtherCell))
     938             :             {
     939           0 :                 if (!aThisCell.isEmpty() && !aOtherCell.isEmpty())
     940           0 :                     nDif += 3;
     941             :                 else
     942           0 :                     nDif += 4;      // Inhalt <-> leer zaehlt mehr
     943             :             }
     944             : 
     945           0 :             if (!aThisCell.isEmpty() || !aOtherCell.isEmpty())
     946           0 :                 ++nUsed;
     947             :         }
     948             :     }
     949             : 
     950           0 :     if (nUsed > 0)
     951           0 :         return static_cast<sal_uInt16>((nDif*64)/nUsed);            // max.256 (SC_DOCCOMP_MAXDIFF)
     952             : 
     953             :     OSL_ENSURE(!nDif,"Diff withoud Used");
     954           0 :     return 0;
     955             : }
     956             : 
     957           0 : sal_uInt16 ScDocument::ColDifferences( SCCOL nThisCol, SCTAB nThisTab,
     958             :                                     ScDocument& rOtherDoc, SCCOL nOtherCol, SCTAB nOtherTab,
     959             :                                     SCROW nMaxRow, SCCOLROW* pOtherRows )
     960             : {
     961             :     //! optimieren mit Iterator oder so
     962             : 
     963           0 :     sal_uLong nDif = 0;
     964           0 :     sal_uLong nUsed = 0;
     965           0 :     for (SCROW nThisRow=0; nThisRow<=nMaxRow; nThisRow++)
     966             :     {
     967             :         SCROW nOtherRow;
     968           0 :         if ( pOtherRows )
     969           0 :             nOtherRow = pOtherRows[nThisRow];
     970             :         else
     971           0 :             nOtherRow = nThisRow;
     972             : 
     973           0 :         if (ValidRow(nOtherRow))    // nur Zeilen vergleichen, die in beiden Dateien sind
     974             :         {
     975           0 :             ScRefCellValue aThisCell, aOtherCell;
     976           0 :             aThisCell.assign(*this, ScAddress(nThisCol, nThisRow, nThisTab));
     977           0 :             aOtherCell.assign(rOtherDoc, ScAddress(nOtherCol, nOtherRow, nOtherTab));
     978           0 :             if (!aThisCell.equalsWithoutFormat(aOtherCell))
     979             :             {
     980           0 :                 if (!aThisCell.isEmpty() && !aOtherCell.isEmpty())
     981           0 :                     nDif += 3;
     982             :                 else
     983           0 :                     nDif += 4;      // Inhalt <-> leer zaehlt mehr
     984             :             }
     985             : 
     986           0 :             if (!aThisCell.isEmpty() || !aOtherCell.isEmpty())
     987           0 :                 ++nUsed;
     988             :         }
     989             :     }
     990             : 
     991           0 :     if (nUsed > 0)
     992           0 :         return static_cast<sal_uInt16>((nDif*64)/nUsed);    // max.256
     993             : 
     994             :     OSL_ENSURE(!nDif,"Diff without Used");
     995           0 :     return 0;
     996             : }
     997             : 
     998           0 : void ScDocument::FindOrder( SCCOLROW* pOtherRows, SCCOLROW nThisEndRow, SCCOLROW nOtherEndRow,
     999             :                             bool bColumns, ScDocument& rOtherDoc, SCTAB nThisTab, SCTAB nOtherTab,
    1000             :                             SCCOLROW nEndCol, SCCOLROW* pTranslate, ScProgress* pProgress, sal_uLong nProAdd )
    1001             : {
    1002             :     //  bColumns=true: Zeilen sind Spalten und umgekehrt
    1003             : 
    1004             :     SCCOLROW nMaxCont;                      // wieviel weiter
    1005             :     SCCOLROW nMinGood;                      // was ist ein Treffer (incl.)
    1006           0 :     if ( bColumns )
    1007             :     {
    1008           0 :         nMaxCont = SC_DOCCOMP_COLUMNS;      // 10 Spalten
    1009           0 :         nMinGood = SC_DOCCOMP_MINGOOD;
    1010             :         //! Extra Durchgang mit nMinGood = 0 ????
    1011             :     }
    1012             :     else
    1013             :     {
    1014           0 :         nMaxCont = SC_DOCCOMP_ROWS;         // 100 Zeilen
    1015           0 :         nMinGood = SC_DOCCOMP_MINGOOD;
    1016             :     }
    1017           0 :     bool bUseTotal = bColumns && !pTranslate;       // nur beim ersten Durchgang
    1018             : 
    1019             : 
    1020           0 :     SCCOLROW nOtherRow = 0;
    1021             :     sal_uInt16 nComp;
    1022             :     SCCOLROW nThisRow;
    1023           0 :     bool bTotal = false;        // ueber verschiedene nThisRow beibehalten
    1024           0 :     SCCOLROW nUnknown = 0;
    1025           0 :     for (nThisRow = 0; nThisRow <= nThisEndRow; nThisRow++)
    1026             :     {
    1027           0 :         SCCOLROW nTempOther = nOtherRow;
    1028           0 :         bool bFound = false;
    1029           0 :         sal_uInt16 nBest = SC_DOCCOMP_MAXDIFF;
    1030           0 :         SCCOLROW nMax = std::min( nOtherEndRow, static_cast<SCCOLROW>(( nTempOther + nMaxCont + nUnknown )) );
    1031           0 :         for (SCCOLROW i=nTempOther; i<=nMax && nBest>0; i++)    // bei 0 abbrechen
    1032             :         {
    1033           0 :             if (bColumns)
    1034           0 :                 nComp = ColDifferences( static_cast<SCCOL>(nThisRow), nThisTab, rOtherDoc, static_cast<SCCOL>(i), nOtherTab, nEndCol, pTranslate );
    1035             :             else
    1036           0 :                 nComp = RowDifferences( nThisRow, nThisTab, rOtherDoc, i, nOtherTab, static_cast<SCCOL>(nEndCol), pTranslate );
    1037           0 :             if ( nComp < nBest && ( nComp <= nMinGood || bTotal ) )
    1038             :             {
    1039           0 :                 nTempOther = i;
    1040           0 :                 nBest = nComp;
    1041           0 :                 bFound = true;
    1042             :             }
    1043           0 :             if ( nComp < SC_DOCCOMP_MAXDIFF || bFound )
    1044           0 :                 bTotal = false;
    1045           0 :             else if ( i == nTempOther && bUseTotal )
    1046           0 :                 bTotal = true;                          // nur ganz oben
    1047             :         }
    1048           0 :         if ( bFound )
    1049             :         {
    1050           0 :             pOtherRows[nThisRow] = nTempOther;
    1051           0 :             nOtherRow = nTempOther + 1;
    1052           0 :             nUnknown = 0;
    1053             :         }
    1054             :         else
    1055             :         {
    1056           0 :             pOtherRows[nThisRow] = SCROW_MAX;
    1057           0 :             ++nUnknown;
    1058             :         }
    1059             : 
    1060           0 :         if (pProgress)
    1061           0 :             pProgress->SetStateOnPercent(nProAdd+static_cast<sal_uLong>(nThisRow));
    1062             :     }
    1063             : 
    1064             :     //  Bloecke ohne Uebereinstimmung ausfuellen
    1065             : 
    1066           0 :     SCROW nFillStart = 0;
    1067           0 :     SCROW nFillPos = 0;
    1068           0 :     bool bInFill = false;
    1069           0 :     for (nThisRow = 0; nThisRow <= nThisEndRow+1; nThisRow++)
    1070             :     {
    1071           0 :         SCROW nThisOther = ( nThisRow <= nThisEndRow ) ? pOtherRows[nThisRow] : (nOtherEndRow+1);
    1072           0 :         if ( ValidRow(nThisOther) )
    1073             :         {
    1074           0 :             if ( bInFill )
    1075             :             {
    1076           0 :                 if ( nThisOther > nFillStart )      // ist was zu verteilen da?
    1077             :                 {
    1078           0 :                     SCROW nDiff1 = nThisOther - nFillStart;
    1079           0 :                     SCROW nDiff2 = nThisRow   - nFillPos;
    1080           0 :                     SCROW nMinDiff = std::min(nDiff1, nDiff2);
    1081           0 :                     for (SCROW i=0; i<nMinDiff; i++)
    1082           0 :                         pOtherRows[nFillPos+i] = nFillStart+i;
    1083             :                 }
    1084             : 
    1085           0 :                 bInFill = false;
    1086             :             }
    1087           0 :             nFillStart = nThisOther + 1;
    1088           0 :             nFillPos = nThisRow + 1;
    1089             :         }
    1090             :         else
    1091           0 :             bInFill = true;
    1092             :     }
    1093           0 : }
    1094             : 
    1095           0 : void ScDocument::CompareDocument( ScDocument& rOtherDoc )
    1096             : {
    1097           0 :     if (!pChangeTrack)
    1098           0 :         return;
    1099             : 
    1100           0 :     SCTAB nThisCount = GetTableCount();
    1101           0 :     SCTAB nOtherCount = rOtherDoc.GetTableCount();
    1102           0 :     SCTAB* pOtherTabs = new SCTAB[nThisCount];
    1103             :     SCTAB nThisTab;
    1104             : 
    1105             :     //  Tabellen mit gleichen Namen vergleichen
    1106           0 :     OUString aThisName;
    1107           0 :     OUString aOtherName;
    1108           0 :     for (nThisTab=0; nThisTab<nThisCount; nThisTab++)
    1109             :     {
    1110           0 :         SCTAB nOtherTab = SCTAB_MAX;
    1111           0 :         if (!IsScenario(nThisTab))  // Szenarien weglassen
    1112             :         {
    1113           0 :             GetName( nThisTab, aThisName );
    1114           0 :             for (SCTAB nTemp=0; nTemp<nOtherCount && nOtherTab>MAXTAB; nTemp++)
    1115           0 :                 if (!rOtherDoc.IsScenario(nTemp))
    1116             :                 {
    1117           0 :                     rOtherDoc.GetName( nTemp, aOtherName );
    1118           0 :                     if ( aThisName.equals(aOtherName) )
    1119           0 :                         nOtherTab = nTemp;
    1120             :                 }
    1121             :         }
    1122           0 :         pOtherTabs[nThisTab] = nOtherTab;
    1123             :     }
    1124             :     //  auffuellen, damit einzeln umbenannte Tabellen nicht wegfallen
    1125           0 :     SCTAB nFillStart = 0;
    1126           0 :     SCTAB nFillPos = 0;
    1127           0 :     bool bInFill = false;
    1128           0 :     for (nThisTab = 0; nThisTab <= nThisCount; nThisTab++)
    1129             :     {
    1130           0 :         SCTAB nThisOther = ( nThisTab < nThisCount ) ? pOtherTabs[nThisTab] : nOtherCount;
    1131           0 :         if ( ValidTab(nThisOther) )
    1132             :         {
    1133           0 :             if ( bInFill )
    1134             :             {
    1135           0 :                 if ( nThisOther > nFillStart )      // ist was zu verteilen da?
    1136             :                 {
    1137           0 :                     SCTAB nDiff1 = nThisOther - nFillStart;
    1138           0 :                     SCTAB nDiff2 = nThisTab   - nFillPos;
    1139           0 :                     SCTAB nMinDiff = std::min(nDiff1, nDiff2);
    1140           0 :                     for (SCTAB i=0; i<nMinDiff; i++)
    1141           0 :                         if ( !IsScenario(nFillPos+i) && !rOtherDoc.IsScenario(nFillStart+i) )
    1142           0 :                             pOtherTabs[nFillPos+i] = nFillStart+i;
    1143             :                 }
    1144             : 
    1145           0 :                 bInFill = false;
    1146             :             }
    1147           0 :             nFillStart = nThisOther + 1;
    1148           0 :             nFillPos = nThisTab + 1;
    1149             :         }
    1150             :         else
    1151           0 :             bInFill = true;
    1152             :     }
    1153             : 
    1154             : 
    1155             :     //  Tabellen in der gefundenen Reihenfolge vergleichen
    1156             : 
    1157             : 
    1158           0 :     for (nThisTab=0; nThisTab<nThisCount; nThisTab++)
    1159             :     {
    1160           0 :         SCTAB nOtherTab = pOtherTabs[nThisTab];
    1161           0 :         if ( ValidTab(nOtherTab) )
    1162             :         {
    1163           0 :             SCCOL nThisEndCol = 0;
    1164           0 :             SCROW nThisEndRow = 0;
    1165           0 :             SCCOL nOtherEndCol = 0;
    1166           0 :             SCROW nOtherEndRow = 0;
    1167           0 :             GetCellArea( nThisTab, nThisEndCol, nThisEndRow );
    1168           0 :             rOtherDoc.GetCellArea( nOtherTab, nOtherEndCol, nOtherEndRow );
    1169           0 :             SCCOL nEndCol = std::max(nThisEndCol, nOtherEndCol);
    1170           0 :             SCROW nEndRow = std::max(nThisEndRow, nOtherEndRow);
    1171             :             SCCOL nThisCol;
    1172             :             SCROW nThisRow;
    1173             :             sal_uLong n1,n2;    // fuer AppendDeleteRange
    1174             : 
    1175             :             //! ein Progress ueber alle Tabellen ???
    1176           0 :             OUString aTabName;
    1177           0 :             GetName( nThisTab, aTabName );
    1178           0 :             OUString aTemplate = ScGlobal::GetRscString(STR_PROGRESS_COMPARING);
    1179           0 :             sal_Int32 nIndex = 0;
    1180           0 :             OUStringBuffer aProText = aTemplate.getToken( 0, '#', nIndex );
    1181           0 :             aProText.append(aTabName);
    1182           0 :             nIndex = 0;
    1183           0 :             aProText.append(aTemplate.getToken( 1, '#', nIndex ));
    1184             :             ScProgress aProgress( GetDocumentShell(),
    1185           0 :                                         aProText.makeStringAndClear(), 3*nThisEndRow );  // 2x FindOrder, 1x hier
    1186           0 :             long nProgressStart = 2*nThisEndRow;                    // start fuer hier
    1187             : 
    1188           0 :             SCCOLROW* pTempRows = new SCCOLROW[nThisEndRow+1];
    1189           0 :             SCCOLROW* pOtherRows = new SCCOLROW[nThisEndRow+1];
    1190           0 :             SCCOLROW* pOtherCols = new SCCOLROW[nThisEndCol+1];
    1191             : 
    1192             :             //  eingefuegte/geloeschte Spalten/Zeilen finden:
    1193             :             //  Zwei Versuche:
    1194             :             //  1) Original Zeilen vergleichen                          (pTempRows)
    1195             :             //  2) Original Spalten vergleichen                         (pOtherCols)
    1196             :             //     mit dieser Spaltenreihenfolge Zeilen vergleichen     (pOtherRows)
    1197             : 
    1198             :             //! Spalten vergleichen zweimal mit unterschiedlichem nMinGood ???
    1199             : 
    1200             :             // 1
    1201             :             FindOrder( pTempRows, nThisEndRow, nOtherEndRow, false,
    1202           0 :                         rOtherDoc, nThisTab, nOtherTab, nEndCol, NULL, &aProgress, 0 );
    1203             :             // 2
    1204             :             FindOrder( pOtherCols, nThisEndCol, nOtherEndCol, true,
    1205           0 :                         rOtherDoc, nThisTab, nOtherTab, nEndRow, NULL, NULL, 0 );
    1206             :             FindOrder( pOtherRows, nThisEndRow, nOtherEndRow, false,
    1207             :                         rOtherDoc, nThisTab, nOtherTab, nThisEndCol,
    1208           0 :                         pOtherCols, &aProgress, nThisEndRow );
    1209             : 
    1210           0 :             sal_uLong nMatch1 = 0;  // pTempRows, keine Spalten
    1211           0 :             for (nThisRow = 0; nThisRow<=nThisEndRow; nThisRow++)
    1212           0 :                 if (ValidRow(pTempRows[nThisRow]))
    1213           0 :                     nMatch1 += SC_DOCCOMP_MAXDIFF -
    1214           0 :                                RowDifferences( nThisRow, nThisTab, rOtherDoc, pTempRows[nThisRow],
    1215           0 :                                                 nOtherTab, nEndCol, NULL );
    1216             : 
    1217           0 :             sal_uLong nMatch2 = 0;  // pOtherRows, pOtherCols
    1218           0 :             for (nThisRow = 0; nThisRow<=nThisEndRow; nThisRow++)
    1219           0 :                 if (ValidRow(pOtherRows[nThisRow]))
    1220           0 :                     nMatch2 += SC_DOCCOMP_MAXDIFF -
    1221           0 :                                RowDifferences( nThisRow, nThisTab, rOtherDoc, pOtherRows[nThisRow],
    1222           0 :                                                 nOtherTab, nThisEndCol, pOtherCols );
    1223             : 
    1224           0 :             if ( nMatch1 >= nMatch2 )           // ohne Spalten ?
    1225             :             {
    1226             :                 //  Spalten zuruecksetzen
    1227           0 :                 for (nThisCol = 0; nThisCol<=nThisEndCol; nThisCol++)
    1228           0 :                     pOtherCols[nThisCol] = nThisCol;
    1229             : 
    1230             :                 //  Zeilenarrays vertauschen (geloescht werden sowieso beide)
    1231           0 :                 SCCOLROW* pSwap = pTempRows;
    1232           0 :                 pTempRows = pOtherRows;
    1233           0 :                 pOtherRows = pSwap;
    1234             :             }
    1235             :             else
    1236             :             {
    1237             :                 //  bleibt bei pOtherCols, pOtherRows
    1238             :             }
    1239             : 
    1240             : 
    1241             :             //  Change-Actions erzeugen
    1242             :             //  1) Spalten von rechts
    1243             :             //  2) Zeilen von unten
    1244             :             //  3) einzelne Zellen in normaler Reihenfolge
    1245             : 
    1246             :             //  Actions fuer eingefuegte/geloeschte Spalten
    1247             : 
    1248           0 :             SCCOL nLastOtherCol = static_cast<SCCOL>(nOtherEndCol + 1);
    1249             :             //  nThisEndCol ... 0
    1250           0 :             for ( nThisCol = nThisEndCol+1; nThisCol > 0; )
    1251             :             {
    1252           0 :                 --nThisCol;
    1253           0 :                 SCCOL nOtherCol = static_cast<SCCOL>(pOtherCols[nThisCol]);
    1254           0 :                 if ( ValidCol(nOtherCol) && nOtherCol+1 < nLastOtherCol )
    1255             :                 {
    1256             :                     // Luecke -> geloescht
    1257             :                     ScRange aDelRange( nOtherCol+1, 0, nOtherTab,
    1258           0 :                                         nLastOtherCol-1, MAXROW, nOtherTab );
    1259           0 :                     pChangeTrack->AppendDeleteRange( aDelRange, &rOtherDoc, n1, n2 );
    1260             :                 }
    1261           0 :                 if ( nOtherCol > MAXCOL )                       // eingefuegt
    1262             :                 {
    1263             :                     //  zusammenfassen
    1264           0 :                     if ( nThisCol == nThisEndCol || ValidCol(static_cast<SCCOL>(pOtherCols[nThisCol+1])) )
    1265             :                     {
    1266           0 :                         SCCOL nFirstNew = static_cast<SCCOL>(nThisCol);
    1267           0 :                         while ( nFirstNew > 0 && pOtherCols[nFirstNew-1] > MAXCOL )
    1268           0 :                             --nFirstNew;
    1269           0 :                         SCCOL nDiff = nThisCol - nFirstNew;
    1270             :                         ScRange aRange( nLastOtherCol, 0, nOtherTab,
    1271           0 :                                         nLastOtherCol+nDiff, MAXROW, nOtherTab );
    1272           0 :                         pChangeTrack->AppendInsert( aRange );
    1273             :                     }
    1274             :                 }
    1275             :                 else
    1276           0 :                     nLastOtherCol = nOtherCol;
    1277             :             }
    1278           0 :             if ( nLastOtherCol > 0 )                            // ganz oben geloescht
    1279             :             {
    1280             :                 ScRange aDelRange( 0, 0, nOtherTab,
    1281           0 :                                     nLastOtherCol-1, MAXROW, nOtherTab );
    1282           0 :                 pChangeTrack->AppendDeleteRange( aDelRange, &rOtherDoc, n1, n2 );
    1283             :             }
    1284             : 
    1285             :             //  Actions fuer eingefuegte/geloeschte Zeilen
    1286             : 
    1287           0 :             SCROW nLastOtherRow = nOtherEndRow + 1;
    1288             :             //  nThisEndRow ... 0
    1289           0 :             for ( nThisRow = nThisEndRow+1; nThisRow > 0; )
    1290             :             {
    1291           0 :                 --nThisRow;
    1292           0 :                 SCROW nOtherRow = pOtherRows[nThisRow];
    1293           0 :                 if ( ValidRow(nOtherRow) && nOtherRow+1 < nLastOtherRow )
    1294             :                 {
    1295             :                     // Luecke -> geloescht
    1296             :                     ScRange aDelRange( 0, nOtherRow+1, nOtherTab,
    1297           0 :                                         MAXCOL, nLastOtherRow-1, nOtherTab );
    1298           0 :                     pChangeTrack->AppendDeleteRange( aDelRange, &rOtherDoc, n1, n2 );
    1299             :                 }
    1300           0 :                 if ( nOtherRow > MAXROW )                       // eingefuegt
    1301             :                 {
    1302             :                     //  zusammenfassen
    1303           0 :                     if ( nThisRow == nThisEndRow || ValidRow(pOtherRows[nThisRow+1]) )
    1304             :                     {
    1305           0 :                         SCROW nFirstNew = nThisRow;
    1306           0 :                         while ( nFirstNew > 0 && pOtherRows[nFirstNew-1] > MAXROW )
    1307           0 :                             --nFirstNew;
    1308           0 :                         SCROW nDiff = nThisRow - nFirstNew;
    1309             :                         ScRange aRange( 0, nLastOtherRow, nOtherTab,
    1310           0 :                                         MAXCOL, nLastOtherRow+nDiff, nOtherTab );
    1311           0 :                         pChangeTrack->AppendInsert( aRange );
    1312             :                     }
    1313             :                 }
    1314             :                 else
    1315           0 :                     nLastOtherRow = nOtherRow;
    1316             :             }
    1317           0 :             if ( nLastOtherRow > 0 )                            // ganz oben geloescht
    1318             :             {
    1319             :                 ScRange aDelRange( 0, 0, nOtherTab,
    1320           0 :                                     MAXCOL, nLastOtherRow-1, nOtherTab );
    1321           0 :                 pChangeTrack->AppendDeleteRange( aDelRange, &rOtherDoc, n1, n2 );
    1322             :             }
    1323             : 
    1324             :             //  Zeilen durchgehen um einzelne Zellen zu finden
    1325             : 
    1326           0 :             for (nThisRow = 0; nThisRow <= nThisEndRow; nThisRow++)
    1327             :             {
    1328           0 :                 SCROW nOtherRow = pOtherRows[nThisRow];
    1329           0 :                 for (nThisCol = 0; nThisCol <= nThisEndCol; nThisCol++)
    1330             :                 {
    1331           0 :                     SCCOL nOtherCol = static_cast<SCCOL>(pOtherCols[nThisCol]);
    1332           0 :                     ScAddress aThisPos( nThisCol, nThisRow, nThisTab );
    1333           0 :                     ScCellValue aThisCell;
    1334           0 :                     aThisCell.assign(*this, aThisPos);
    1335           0 :                     ScCellValue aOtherCell; // start empty
    1336           0 :                     if ( ValidCol(nOtherCol) && ValidRow(nOtherRow) )
    1337             :                     {
    1338           0 :                         ScAddress aOtherPos( nOtherCol, nOtherRow, nOtherTab );
    1339           0 :                         aOtherCell.assign(*this, aOtherPos);
    1340             :                     }
    1341             : 
    1342           0 :                     if (!aThisCell.equalsWithoutFormat(aOtherCell))
    1343             :                     {
    1344           0 :                         ScRange aRange( aThisPos );
    1345           0 :                         ScChangeActionContent* pAction = new ScChangeActionContent( aRange );
    1346           0 :                         pAction->SetOldValue(aOtherCell, &rOtherDoc, this);
    1347           0 :                         pAction->SetNewValue(aThisCell, this);
    1348           0 :                         pChangeTrack->Append( pAction );
    1349             :                     }
    1350           0 :                 }
    1351           0 :                 aProgress.SetStateOnPercent(nProgressStart+nThisRow);
    1352             :             }
    1353             : 
    1354           0 :             delete[] pOtherCols;
    1355           0 :             delete[] pOtherRows;
    1356           0 :             delete[] pTempRows;
    1357             :         }
    1358             :     }
    1359             : 
    1360             :     //! Inhalt von eingefuegten / geloeschten Tabellen ???
    1361             :     //! Aktionen fuer eingefuegte / geloeschte Tabellen ???
    1362             : 
    1363           0 :     delete[] pOtherTabs;
    1364           0 : }
    1365             : 
    1366             : 
    1367             : 
    1368             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10