sc/source/core/data/documen4.cxx

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