sc/source/core/data/cell2.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: cell2.cxx,v $
  10  * $Revision: 1.34.102.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35
  36 // INCLUDE ---------------------------------------------------------------
  37 #include <algorithm>
  38 #include <deque>
  39
  40 #include <boost/bind.hpp>
  41
  42 #include <vcl/mapmod.hxx>
  43 #include <svx/editobj.hxx>
  44 #include <svx/editstat.hxx>
  45
  46 #include "cell.hxx"
  47 #include "compiler.hxx"
  48 #include "formula/errorcodes.hxx"
  49 #include "document.hxx"
  50 #include "rangenam.hxx"
  51 #include "rechead.hxx"
  52 #include "refupdat.hxx"
  53 #include "scmatrix.hxx"
  54 #include "editutil.hxx"
  55 #include "chgtrack.hxx"
  56 #include "indexmap.hxx"
  57 #include "externalrefmgr.hxx"
  58 #include "scitems.hxx"
  59 #include "patattr.hxx"
  60
  61 using namespace formula;
  62
  63 // STATIC DATA -----------------------------------------------------------
  64
  65 #ifdef USE_MEMPOOL
  66 const USHORT nMemPoolEditCell = (0x1000 - 64) / sizeof(ScNoteCell);
  67 IMPL_FIXEDMEMPOOL_NEWDEL( ScEditCell, nMemPoolEditCell, nMemPoolEditCell )
  68 #endif
  69
  70 // ============================================================================
  71
  72 ScEditCell::ScEditCell( const EditTextObject* pObject, ScDocument* pDocP,
  73             const SfxItemPool* pFromPool )  :
  74         ScBaseCell( CELLTYPE_EDIT ),
  75         pString( NULL ),
  76         pDoc( pDocP )
  77 {
  78     SetTextObject( pObject, pFromPool );
  79 }
  80
  81 ScEditCell::ScEditCell( const ScEditCell& rCell, ScDocument& rDoc )  :
  82         ScBaseCell( rCell ),
  83         pString( NULL ),
  84         pDoc( &rDoc )
  85 {
  86     SetTextObject( rCell.pData, rCell.pDoc->GetEditPool() );
  87 }
  88
  89 ScEditCell::ScEditCell( const String& rString, ScDocument* pDocP )  :
  90         ScBaseCell( CELLTYPE_EDIT ),
  91         pString( NULL ),
  92         pDoc( pDocP )
  93 {
  94     DBG_ASSERT( rString.Search('\n') != STRING_NOTFOUND ||
  95                 rString.Search(CHAR_CR) != STRING_NOTFOUND,
  96                 "EditCell mit einfachem Text !?!?" );
  97
  98     EditEngine& rEngine = pDoc->GetEditEngine();
  99     rEngine.SetText( rString );
 100     pData = rEngine.CreateTextObject();
 101 }
 102
 103 ScEditCell::~ScEditCell()
 104 {
 105     delete pData;
 106     delete pString;
 107
 108 #ifdef DBG_UTIL
 109     eCellType = CELLTYPE_DESTROYED;
 110 #endif
 111 }
 112
 113 void ScEditCell::SetData( const EditTextObject* pObject,
 114             const SfxItemPool* pFromPool )
 115 {
 116     if ( pString )
 117     {
 118         delete pString;
 119         pString = NULL;
 120     }
 121     delete pData;
 122     SetTextObject( pObject, pFromPool );
 123 }
 124
 125 void ScEditCell::GetData( const EditTextObject*& rpObject ) const
 126 {
 127     rpObject = pData;
 128 }
 129
 130 void ScEditCell::GetString( String& rString ) const
 131 {
 132     if ( pString )
 133         rString = *pString;
 134     else if ( pData )
 135     {
 136         // auch Text von URL-Feldern, Doc-Engine ist eine ScFieldEditEngine
 137         EditEngine& rEngine = pDoc->GetEditEngine();
 138         rEngine.SetText( *pData );
 139         rString = ScEditUtil::GetMultilineString(rEngine); // string with line separators between paragraphs
 140         // kurze Strings fuer Formeln merken
 141         if ( rString.Len() < MAXSTRLEN )
 142             ((ScEditCell*)this)->pString = new String( rString );   //! non-const
 143     }
 144     else
 145         rString.Erase();
 146 }
 147
 148 bool ScEditCell::HasPhonetic() const
 149 {
 150     return false;
 151 }
 152
 153 void ScEditCell::RemoveCharAttribs( const ScPatternAttr& rAttr )
 154 {
 155     const struct {
 156         USHORT nAttrType;
 157         USHORT nCharType;
 158     } AttrTypeMap[] = {
 159         { ATTR_FONT,        EE_CHAR_FONTINFO },
 160         { ATTR_FONT_HEIGHT, EE_CHAR_FONTHEIGHT },
 161         { ATTR_FONT_WEIGHT, EE_CHAR_WEIGHT },
 162         { ATTR_FONT_COLOR,  EE_CHAR_COLOR }
 163     };
 164     USHORT nMapCount = sizeof(AttrTypeMap) / sizeof(AttrTypeMap[0]);
 165
 166     const SfxItemSet& rSet = rAttr.GetItemSet();
 167     const SfxPoolItem* pItem;
 168     for (USHORT i = 0; i < nMapCount; ++i)
 169     {
 170         if ( rSet.GetItemState(AttrTypeMap[i].nAttrType, false, &pItem) == SFX_ITEM_SET )
 171             pData->RemoveCharAttribs(AttrTypeMap[i].nCharType);
 172     }
 173 }
 174
 175 void ScEditCell::SetTextObject( const EditTextObject* pObject,
 176             const SfxItemPool* pFromPool )
 177 {
 178     if ( pObject )
 179     {
 180         if ( pFromPool && pDoc->GetEditPool() == pFromPool )
 181             pData = pObject->Clone();
 182         else
 183         {   //! anderer Pool
 184             // Leider gibt es keinen anderen Weg, um den Pool umzuhaengen,
 185             // als das Object durch eine entsprechende Engine zu schleusen..
 186             EditEngine& rEngine = pDoc->GetEditEngine();
 187             if ( pObject->HasOnlineSpellErrors() )
 188             {
 189                 ULONG nControl = rEngine.GetControlWord();
 190                 const ULONG nSpellControl = EE_CNTRL_ONLINESPELLING | EE_CNTRL_ALLOWBIGOBJS;
 191                 BOOL bNewControl = ( (nControl & nSpellControl) != nSpellControl );
 192                 if ( bNewControl )
 193                     rEngine.SetControlWord( nControl | nSpellControl );
 194                 rEngine.SetText( *pObject );
 195                 pData = rEngine.CreateTextObject();
 196                 if ( bNewControl )
 197                     rEngine.SetControlWord( nControl );
 198             }
 199             else
 200             {
 201                 rEngine.SetText( *pObject );
 202                 pData = rEngine.CreateTextObject();
 203             }
 204         }
 205     }
 206     else
 207         pData = NULL;
 208 }
 209
 210 ScEditDataArray::ScEditDataArray()
 211 {
 212 }
 213
 214 ScEditDataArray::~ScEditDataArray()
 215 {
 216 }
 217
 218 void ScEditDataArray::AddItem(SCTAB nTab, SCCOL nCol, SCROW nRow,
 219                               EditTextObject* pOldData, EditTextObject* pNewData)
 220 {
 221     maArray.push_back(Item(nTab, nCol, nRow, pOldData, pNewData));
 222 }
 223
 224 const ScEditDataArray::Item* ScEditDataArray::First()
 225 {
 226     maIter = maArray.begin();
 227     if (maIter == maArray.end())
 228         return NULL;
 229     return &(*maIter++);
 230 }
 231
 232 const ScEditDataArray::Item* ScEditDataArray::Next()
 233 {
 234     if (maIter == maArray.end())
 235         return NULL;
 236     return &(*maIter++);
 237 }
 238
 239 // ============================================================================
 240
 241 ScEditDataArray::Item::Item(SCTAB nTab, SCCOL nCol, SCROW nRow,
 242                             EditTextObject* pOldData, EditTextObject* pNewData) :
 243     mnTab(nTab),
 244     mnCol(nCol),
 245     mnRow(nRow)
 246 {
 247     mpOldData.reset(pOldData);
 248     mpNewData.reset(pNewData);
 249 }
 250
 251 ScEditDataArray::Item::~Item()
 252 {
 253 }
 254
 255 const EditTextObject* ScEditDataArray::Item::GetOldData() const
 256 {
 257     return mpOldData.get();
 258 }
 259
 260 const EditTextObject* ScEditDataArray::Item::GetNewData() const
 261 {
 262     return mpNewData.get();
 263 }
 264
 265 SCTAB ScEditDataArray::Item::GetTab() const
 266 {
 267     return mnTab;
 268 }
 269
 270 SCCOL ScEditDataArray::Item::GetCol() const
 271 {
 272     return mnCol;
 273 }
 274
 275 SCROW ScEditDataArray::Item::GetRow() const
 276 {
 277     return mnRow;
 278 }
 279
 280 // ============================================================================
 281
 282 namespace
 283 {
 284
 285 using std::deque;
 286
 287 typedef SCCOLROW(*DimensionSelector)(const ScSingleRefData&);
 288
 289
 290 static SCCOLROW lcl_GetCol(const ScSingleRefData& rData)
 291 {
 292     return rData.nCol;
 293 }
 294
 295
 296 static SCCOLROW lcl_GetRow(const ScSingleRefData& rData)
 297 {
 298     return rData.nRow;
 299 }
 300
 301
 302 static SCCOLROW lcl_GetTab(const ScSingleRefData& rData)
 303 {
 304     return rData.nTab;
 305 }
 306
 307
 308 /** Check if both references span the same range in selected dimension.
 309  */
 310 static bool
 311 lcl_checkRangeDimension(
 312         const SingleDoubleRefProvider& rRef1,
 313         const SingleDoubleRefProvider& rRef2,
 314         const DimensionSelector aWhich)
 315 {
 316     return
 317         aWhich(rRef1.Ref1) == aWhich(rRef2.Ref1)
 318         && aWhich(rRef1.Ref2) == aWhich(rRef2.Ref2);
 319 }
 320
 321
 322 static bool
 323 lcl_checkRangeDimensions(
 324         const SingleDoubleRefProvider& rRef1,
 325         const SingleDoubleRefProvider& rRef2,
 326         bool& bCol, bool& bRow, bool& bTab)
 327 {
 328     const bool bSameCols(lcl_checkRangeDimension(rRef1, rRef2, lcl_GetCol));
 329     const bool bSameRows(lcl_checkRangeDimension(rRef1, rRef2, lcl_GetRow));
 330     const bool bSameTabs(lcl_checkRangeDimension(rRef1, rRef2, lcl_GetTab));
 331
 332     // Test if exactly two dimensions are equal
 333     if (!(bSameCols ^ bSameRows ^ bSameTabs)
 334             && (bSameCols || bSameRows || bSameTabs))
 335     {
 336         bCol = !bSameCols;
 337         bRow = !bSameRows;
 338         bTab = !bSameTabs;
 339         return true;
 340     }
 341     return false;
 342 }
 343
 344
 345 /** Check if references in given reference list can possibly
 346     form a range. To do that, two of their dimensions must be the same.
 347  */
 348 static bool
 349 lcl_checkRangeDimensions(
 350         const deque<ScToken*>::const_iterator aBegin,
 351         const deque<ScToken*>::const_iterator aEnd,
 352         bool& bCol, bool& bRow, bool& bTab)
 353 {
 354     deque<ScToken*>::const_iterator aCur(aBegin);
 355     ++aCur;
 356     const SingleDoubleRefProvider aRef(**aBegin);
 357     bool bOk(false);
 358     {
 359         const SingleDoubleRefProvider aRefCur(**aCur);
 360         bOk = lcl_checkRangeDimensions(aRef, aRefCur, bCol, bRow, bTab);
 361     }
 362     while (bOk && aCur != aEnd)
 363     {
 364         const SingleDoubleRefProvider aRefCur(**aCur);
 365         bool bColTmp(false);
 366         bool bRowTmp(false);
 367         bool bTabTmp(false);
 368         bOk = lcl_checkRangeDimensions(aRef, aRefCur, bColTmp, bRowTmp, bTabTmp);
 369         bOk = bOk && (bCol == bColTmp && bRow == bRowTmp && bTab == bTabTmp);
 370         ++aCur;
 371     }
 372
 373     if (bOk && aCur == aEnd)
 374     {
 375         bCol = bCol;
 376         bRow = bRow;
 377         bTab = bTab;
 378         return true;
 379     }
 380     return false;
 381 }
 382
 383
 384 bool
 385 lcl_lessReferenceBy(
 386         const ScToken* const pRef1, const ScToken* const pRef2,
 387         const DimensionSelector aWhich)
 388 {
 389     const SingleDoubleRefProvider rRef1(*pRef1);
 390     const SingleDoubleRefProvider rRef2(*pRef2);
 391     return aWhich(rRef1.Ref1) < aWhich(rRef2.Ref1);
 392 }
 393
 394
 395 /** Returns true if range denoted by token pRef2 starts immediately after
 396     range denoted by token pRef1. Dimension, in which the comparison takes
 397     place, is given by aWhich.
 398  */
 399 bool
 400 lcl_isImmediatelyFollowing(
 401         const ScToken* const pRef1, const ScToken* const pRef2,
 402         const DimensionSelector aWhich)
 403 {
 404     const SingleDoubleRefProvider rRef1(*pRef1);
 405     const SingleDoubleRefProvider rRef2(*pRef2);
 406     return aWhich(rRef2.Ref1) - aWhich(rRef1.Ref2) == 1;
 407 }
 408
 409
 410 static bool
 411 lcl_checkIfAdjacent(
 412         const deque<ScToken*>& rReferences,
 413         const DimensionSelector aWhich)
 414 {
 415     typedef deque<ScToken*>::const_iterator Iter;
 416     Iter aBegin(rReferences.begin());
 417     Iter aEnd(rReferences.end());
 418     Iter aBegin1(aBegin);
 419     ++aBegin1, --aEnd;
 420     return std::equal(
 421             aBegin, aEnd, aBegin1,
 422             boost::bind(lcl_isImmediatelyFollowing, _1, _2, aWhich));
 423 }
 424
 425
 426 static void
 427 lcl_fillRangeFromRefList(
 428         const deque<ScToken*>& rReferences, ScRange& rRange)
 429 {
 430     const ScSingleRefData aStart(
 431             SingleDoubleRefProvider(*rReferences.front()).Ref1);
 432     rRange.aStart.Set(aStart.nCol, aStart.nRow, aStart.nTab);
 433     const ScSingleRefData aEnd(
 434             SingleDoubleRefProvider(*rReferences.back()).Ref2);
 435     rRange.aEnd.Set(aEnd.nCol, aEnd.nRow, aEnd.nTab);
 436 }
 437
 438
 439 static bool
 440 lcl_refListFormsOneRange(
 441         const ScAddress& aPos, deque<ScToken*>& rReferences,
 442         ScRange& rRange)
 443 {
 444     std::for_each(
 445             rReferences.begin(), rReferences.end(),
 446             bind(&ScToken::CalcAbsIfRel, _1, aPos))
 447         ;
 448     if (rReferences.size() == 1) {
 449         lcl_fillRangeFromRefList(rReferences, rRange);
 450         return true;
 451     }
 452
 453     bool bCell(false);
 454     bool bRow(false);
 455     bool bTab(false);
 456     if (lcl_checkRangeDimensions(rReferences.begin(), rReferences.end(),
 457             bCell, bRow, bTab))
 458     {
 459         DimensionSelector aWhich;
 460         if (bCell)
 461         {
 462             aWhich = lcl_GetCol;
 463         }
 464         else if (bRow)
 465         {
 466             aWhich = lcl_GetRow;
 467         }
 468         else if (bTab)
 469         {
 470             aWhich = lcl_GetTab;
 471         }
 472         else
 473         {
 474             OSL_ENSURE(false, "lcl_checkRangeDimensions shouldn't allow that!");
 475             aWhich = lcl_GetRow;    // initialize to avoid warning
 476         }
 477         // Sort the references by start of range
 478         std::sort(rReferences.begin(), rReferences.end(),
 479                 boost::bind(lcl_lessReferenceBy, _1, _2, aWhich));
 480         if (lcl_checkIfAdjacent(rReferences, aWhich))
 481         {
 482             lcl_fillRangeFromRefList(rReferences, rRange);
 483             return true;
 484         }
 485     }
 486     return false;
 487 }
 488
 489
 490 bool lcl_isReference(const FormulaToken& rToken)
 491 {
 492     return
 493         rToken.GetType() == svSingleRef ||
 494         rToken.GetType() == svDoubleRef;
 495 }
 496
 497 }
 498
 499 BOOL ScFormulaCell::IsEmpty()
 500 {
 501     if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc())
 502         Interpret();
 503     return aResult.GetCellResultType() == formula::svEmptyCell;
 504 }
 505
 506 BOOL ScFormulaCell::IsEmptyDisplayedAsString()
 507 {
 508     if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc())
 509         Interpret();
 510     return aResult.IsEmptyDisplayedAsString();
 511 }
 512
 513 BOOL ScFormulaCell::IsValue()
 514 {
 515     if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc())
 516         Interpret();
 517     return aResult.IsValue();
 518 }
 519
 520 double ScFormulaCell::GetValue()
 521 {
 522     if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc())
 523         Interpret();
 524     if ((!pCode->GetCodeError() || pCode->GetCodeError() == errDoubleRef) &&
 525             !aResult.GetResultError())
 526         return aResult.GetDouble();
 527     return 0.0;
 528 }
 529
 530 double ScFormulaCell::GetValueAlways()
 531 {
 532     // for goal seek: return result value even if error code is set
 533
 534     if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc())
 535         Interpret();
 536     return aResult.GetDouble();
 537 }
 538
 539 void ScFormulaCell::GetString( String& rString )
 540 {
 541     if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc())
 542         Interpret();
 543     if ((!pCode->GetCodeError() || pCode->GetCodeError() == errDoubleRef) &&
 544             !aResult.GetResultError())
 545         rString = aResult.GetString();
 546     else
 547         rString.Erase();
 548 }
 549
 550 const ScMatrix* ScFormulaCell::GetMatrix()
 551 {
 552     if ( pDocument->GetAutoCalc() )
 553     {
 554         // Was stored !bDirty but an accompanying matrix cell was bDirty?
 555         // => we need to get the matrix.
 556         if (!bDirty && cMatrixFlag == MM_FORMULA && !aResult.GetMatrix().Is())
 557             bDirty = TRUE;
 558         if ( IsDirtyOrInTableOpDirty() )
 559             Interpret();
 560     }
 561     return aResult.GetMatrix();
 562 }
 563
 564 BOOL ScFormulaCell::GetMatrixOrigin( ScAddress& rPos ) const
 565 {
 566     switch ( cMatrixFlag )
 567     {
 568         case MM_FORMULA :
 569             rPos = aPos;
 570             return TRUE;
 571 //        break;
 572         case MM_REFERENCE :
 573         {
 574             pCode->Reset();
 575             ScToken* t = static_cast<ScToken*>(pCode->GetNextReferenceRPN());
 576             if( t )
 577             {
 578                 ScSingleRefData& rRef = t->GetSingleRef();
 579                 rRef.CalcAbsIfRel( aPos );
 580                 if ( rRef.Valid() )
 581                 {
 582                     rPos.Set( rRef.nCol, rRef.nRow, rRef.nTab );
 583                     return TRUE;
 584                 }
 585             }
 586         }
 587         break;
 588     }
 589     return FALSE;
 590 }
 591
 592
 593 /*
 594  Edge-Values:
 595
 596    8
 597  4   16
 598    2
 599
 600  innerhalb: 1
 601  ausserhalb: 0
 602  (reserviert: offen: 32)
 603  */
 604
 605 USHORT ScFormulaCell::GetMatrixEdge( ScAddress& rOrgPos )
 606 {
 607     switch ( cMatrixFlag )
 608     {
 609         case MM_FORMULA :
 610         case MM_REFERENCE :
 611         {
 612             static SCCOL nC;
 613             static SCROW nR;
 614             ScAddress aOrg;
 615             if ( !GetMatrixOrigin( aOrg ) )
 616                 return 0;               // dumm gelaufen..
 617             if ( aOrg != rOrgPos )
 618             {   // erstes Mal oder andere Matrix als letztes Mal
 619                 rOrgPos = aOrg;
 620                 ScFormulaCell* pFCell;
 621                 if ( cMatrixFlag == MM_REFERENCE )
 622                     pFCell = (ScFormulaCell*) pDocument->GetCell( aOrg );
 623                 else
 624                     pFCell = this;      // this MM_FORMULA
 625                 // this gibt's nur einmal, kein Vergleich auf pFCell==this
 626                 if ( pFCell && pFCell->GetCellType() == CELLTYPE_FORMULA
 627                   && pFCell->cMatrixFlag == MM_FORMULA )
 628                 {
 629                     pFCell->GetMatColsRows( nC, nR );
 630                     if ( nC == 0 || nR == 0 )
 631                     {   // aus altem Dokument geladen, neu erzeugen
 632                         nC = 1;
 633                         nR = 1;
 634                         ScAddress aTmpOrg;
 635                         ScBaseCell* pCell;
 636                         ScAddress aAdr( aOrg );
 637                         aAdr.IncCol();
 638                         BOOL bCont = TRUE;
 639                         do
 640                         {
 641                             pCell = pDocument->GetCell( aAdr );
 642                             if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA
 643                               && ((ScFormulaCell*)pCell)->cMatrixFlag == MM_REFERENCE
 644                               && GetMatrixOrigin( aTmpOrg ) && aTmpOrg == aOrg )
 645                             {
 646                                 nC++;
 647                                 aAdr.IncCol();
 648                             }
 649                             else
 650                                 bCont = FALSE;
 651                         } while ( bCont );
 652                         aAdr = aOrg;
 653                         aAdr.IncRow();
 654                         bCont = TRUE;
 655                         do
 656                         {
 657                             pCell = pDocument->GetCell( aAdr );
 658                             if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA
 659                               && ((ScFormulaCell*)pCell)->cMatrixFlag == MM_REFERENCE
 660                               && GetMatrixOrigin( aTmpOrg ) && aTmpOrg == aOrg )
 661                             {
 662                                 nR++;
 663                                 aAdr.IncRow();
 664                             }
 665                             else
 666                                 bCont = FALSE;
 667                         } while ( bCont );
 668                         pFCell->SetMatColsRows( nC, nR );
 669                     }
 670                 }
 671                 else
 672                 {
 673 #ifndef PRODUCT
 674                     String aTmp;
 675                     ByteString aMsg( "broken Matrix, no MatFormula at origin, Pos: " );
 676                     aPos.Format( aTmp, SCA_VALID_COL | SCA_VALID_ROW, pDocument );
 677                     aMsg += ByteString( aTmp, RTL_TEXTENCODING_ASCII_US );
 678                     aMsg += ", MatOrg: ";
 679                     aOrg.Format( aTmp, SCA_VALID_COL | SCA_VALID_ROW, pDocument );
 680                     aMsg += ByteString( aTmp, RTL_TEXTENCODING_ASCII_US );
 681                     DBG_ERRORFILE( aMsg.GetBuffer() );
 682 #endif
 683                     return 0;           // bad luck ...
 684                 }
 685             }
 686             // here we are, healthy and clean, somewhere in between
 687             SCsCOL dC = aPos.Col() - aOrg.Col();
 688             SCsROW dR = aPos.Row() - aOrg.Row();
 689             USHORT nEdges = 0;
 690             if ( dC >= 0 && dR >= 0 && dC < nC && dR < nR )
 691             {
 692                 if ( dC == 0 )
 693                     nEdges |= 4;            // linke Kante
 694                 if ( dC+1 == nC )
 695                     nEdges |= 16;           // rechte Kante
 696                 if ( dR == 0 )
 697                     nEdges |= 8;            // obere Kante
 698                 if ( dR+1 == nR )
 699                     nEdges |= 2;            // untere Kante
 700                 if ( !nEdges )
 701                     nEdges = 1;             // mittendrin
 702             }
 703 #ifndef PRODUCT
 704             else
 705             {
 706                 String aTmp;
 707                 ByteString aMsg( "broken Matrix, Pos: " );
 708                 aPos.Format( aTmp, SCA_VALID_COL | SCA_VALID_ROW, pDocument );
 709                 aMsg += ByteString( aTmp, RTL_TEXTENCODING_ASCII_US );
 710                 aMsg += ", MatOrg: ";
 711                 aOrg.Format( aTmp, SCA_VALID_COL | SCA_VALID_ROW, pDocument );
 712                 aMsg += ByteString( aTmp, RTL_TEXTENCODING_ASCII_US );
 713                 aMsg += ", MatCols: ";
 714                 aMsg += ByteString::CreateFromInt32( nC );
 715                 aMsg += ", MatRows: ";
 716                 aMsg += ByteString::CreateFromInt32( nR );
 717                 aMsg += ", DiffCols: ";
 718                 aMsg += ByteString::CreateFromInt32( dC );
 719                 aMsg += ", DiffRows: ";
 720                 aMsg += ByteString::CreateFromInt32( dR );
 721                 DBG_ERRORFILE( aMsg.GetBuffer() );
 722             }
 723 #endif
 724             return nEdges;
 725 //            break;
 726         }
 727         default:
 728             return 0;
 729     }
 730 }
 731
 732 USHORT ScFormulaCell::GetErrCode()
 733 {
 734     if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc())
 735         Interpret();
 736     /* FIXME: If ScTokenArray::SetCodeError() was really only for code errors
 737      * and not also abused for signaling other error conditions we could bail
 738      * out even before attempting to interpret broken code. */
 739     USHORT nErr =  pCode->GetCodeError();
 740     if (nErr)
 741         return nErr;
 742     return aResult.GetResultError();
 743 }
 744
 745 USHORT ScFormulaCell::GetRawError()
 746 {
 747     USHORT nErr =  pCode->GetCodeError();
 748     if (nErr)
 749         return nErr;
 750     return aResult.GetResultError();
 751 }
 752
 753 BOOL ScFormulaCell::HasOneReference( ScRange& r ) const
 754 {
 755     pCode->Reset();
 756     ScToken* p = static_cast<ScToken*>(pCode->GetNextReferenceRPN());
 757     if( p && !pCode->GetNextReferenceRPN() )        // nur eine!
 758     {
 759         p->CalcAbsIfRel( aPos );
 760         SingleDoubleRefProvider aProv( *p );
 761         r.aStart.Set( aProv.Ref1.nCol,
 762                       aProv.Ref1.nRow,
 763                       aProv.Ref1.nTab );
 764         r.aEnd.Set( aProv.Ref2.nCol,
 765                     aProv.Ref2.nRow,
 766                     aProv.Ref2.nTab );
 767         return TRUE;
 768     }
 769     else
 770         return FALSE;
 771 }
 772
 773 bool
 774 ScFormulaCell::HasRefListExpressibleAsOneReference(ScRange& rRange) const
 775 {
 776     /* If there appears just one reference in the formula, it's the same
 777        as HasOneReference(). If there are more of them, they can denote
 778        one range if they are (sole) arguments of one function.
 779        Union of these references must form one range and their
 780        intersection must be empty set.
 781     */
 782     pCode->Reset();
 783     // Get first reference, if any
 784     ScToken* const pFirstReference(
 785             dynamic_cast<ScToken*>(pCode->GetNextReferenceRPN()));
 786     if (pFirstReference)
 787     {
 788         // Collect all consecutive references, starting by the one
 789         // already found
 790         std::deque<ScToken*> aReferences;
 791         aReferences.push_back(pFirstReference);
 792         FormulaToken* pToken(pCode->NextRPN());
 793         FormulaToken* pFunction(0);
 794         while (pToken)
 795         {
 796             if (lcl_isReference(*pToken))
 797             {
 798                 aReferences.push_back(dynamic_cast<ScToken*>(pToken));
 799                 pToken = pCode->NextRPN();
 800             }
 801             else
 802             {
 803                 if (pToken->IsFunction())
 804                 {
 805                     pFunction = pToken;
 806                 }
 807                 break;
 808             }
 809         }
 810         if (pFunction && !pCode->GetNextReferenceRPN()
 811                 && (pFunction->GetParamCount() == aReferences.size()))
 812         {
 813             return lcl_refListFormsOneRange(aPos, aReferences, rRange);
 814         }
 815     }
 816     return false;
 817 }
 818
 819 BOOL ScFormulaCell::HasRelNameReference() const
 820 {
 821     pCode->Reset();
 822     ScToken* t;
 823     while ( ( t = static_cast<ScToken*>(pCode->GetNextReferenceRPN()) ) != NULL )
 824     {
 825         if ( t->GetSingleRef().IsRelName() ||
 826                 (t->GetType() == formula::svDoubleRef &&
 827                 t->GetDoubleRef().Ref2.IsRelName()) )
 828             return TRUE;
 829     }
 830     return FALSE;
 831 }
 832
 833 BOOL ScFormulaCell::HasColRowName() const
 834 {
 835     pCode->Reset();
 836     return (pCode->GetNextColRowName() != NULL);
 837 }
 838
 839 void ScFormulaCell::UpdateReference(UpdateRefMode eUpdateRefMode,
 840                                     const ScRange& r,
 841                                     SCsCOL nDx, SCsROW nDy, SCsTAB nDz,
 842                                     ScDocument* pUndoDoc, const ScAddress* pUndoCellPos )
 843 {
 844     SCCOL nCol1 = r.aStart.Col();
 845     SCROW nRow1 = r.aStart.Row();
 846     SCTAB nTab1 = r.aStart.Tab();
 847     SCCOL nCol2 = r.aEnd.Col();
 848     SCROW nRow2 = r.aEnd.Row();
 849     SCTAB nTab2 = r.aEnd.Tab();
 850     SCCOL nCol = aPos.Col();
 851     SCROW nRow = aPos.Row();
 852     SCTAB nTab = aPos.Tab();
 853     ScAddress aUndoPos( aPos );         // position for undo cell in pUndoDoc
 854     if ( pUndoCellPos )
 855         aUndoPos = *pUndoCellPos;
 856     ScAddress aOldPos( aPos );
 857 //  BOOL bPosChanged = FALSE;           // ob diese Zelle bewegt wurde
 858     BOOL bIsInsert = FALSE;
 859     if (eUpdateRefMode == URM_INSDEL)
 860     {
 861         bIsInsert = (nDx >= 0 && nDy >= 0 && nDz >= 0);
 862         if ( nDx && nRow >= nRow1 && nRow <= nRow2 &&
 863             nTab >= nTab1 && nTab <= nTab2 )
 864         {
 865             if (nCol >= nCol1)
 866             {
 867                 nCol = sal::static_int_cast<SCCOL>( nCol + nDx );
 868                 if ((SCsCOL) nCol < 0)
 869                     nCol = 0;
 870                 else if ( nCol > MAXCOL )
 871                     nCol = MAXCOL;
 872                 aPos.SetCol( nCol );
 873 //              bPosChanged = TRUE;
 874             }
 875         }
 876         if ( nDy && nCol >= nCol1 && nCol <= nCol2 &&
 877             nTab >= nTab1 && nTab <= nTab2 )
 878         {
 879             if (nRow >= nRow1)
 880             {
 881                 nRow = sal::static_int_cast<SCROW>( nRow + nDy );
 882                 if ((SCsROW) nRow < 0)
 883                     nRow = 0;
 884                 else if ( nRow > MAXROW )
 885                     nRow = MAXROW;
 886                 aPos.SetRow( nRow );
 887 //              bPosChanged = TRUE;
 888             }
 889         }
 890         if ( nDz && nCol >= nCol1 && nCol <= nCol2 &&
 891             nRow >= nRow1 && nRow <= nRow2 )
 892         {
 893             if (nTab >= nTab1)
 894             {
 895                 SCTAB nMaxTab = pDocument->GetTableCount() - 1;
 896                 nTab = sal::static_int_cast<SCTAB>( nTab + nDz );
 897                 if ((SCsTAB) nTab < 0)
 898                     nTab = 0;
 899                 else if ( nTab > nMaxTab )
 900                     nTab = nMaxTab;
 901                 aPos.SetTab( nTab );
 902 //              bPosChanged = TRUE;
 903             }
 904         }
 905     }
 906     else if ( r.In( aPos ) )
 907     {
 908         aOldPos.Set( nCol - nDx, nRow - nDy, nTab - nDz );
 909 //      bPosChanged = TRUE;
 910     }
 911
 912     BOOL bHasRefs = FALSE;
 913     BOOL bHasColRowNames = FALSE;
 914     BOOL bOnRefMove = FALSE;
 915     if ( !pDocument->IsClipOrUndo() )
 916     {
 917         pCode->Reset();
 918         bHasRefs = (pCode->GetNextReferenceRPN() != NULL);
 919         if ( !bHasRefs || eUpdateRefMode == URM_COPY )
 920         {
 921             pCode->Reset();
 922             bHasColRowNames = (pCode->GetNextColRowName() != NULL);
 923             bHasRefs = bHasRefs || bHasColRowNames;
 924         }
 925         bOnRefMove = pCode->IsRecalcModeOnRefMove();
 926     }
 927     if( bHasRefs || bOnRefMove )
 928     {
 929         ScTokenArray* pOld = pUndoDoc ? pCode->Clone() : NULL;
 930         BOOL bValChanged;
 931         ScRangeData* pRangeData;
 932         BOOL bRangeModified;            // any range, not only shared formula
 933         BOOL bRefSizeChanged;
 934         if ( bHasRefs )
 935         {
 936             ScCompiler aComp(pDocument, aPos, *pCode);
 937             aComp.SetGrammar(pDocument->GetGrammar());
 938             pRangeData = aComp.UpdateReference(eUpdateRefMode, aOldPos, r,
 939                                              nDx, nDy, nDz,
 940                                              bValChanged, bRefSizeChanged);
 941             bRangeModified = aComp.HasModifiedRange();
 942         }
 943         else
 944         {
 945             bValChanged = FALSE;
 946             pRangeData = NULL;
 947             bRangeModified = FALSE;
 948             bRefSizeChanged = FALSE;
 949         }
 950         if ( bOnRefMove )
 951             bOnRefMove = (bValChanged || (aPos != aOldPos));
 952             // Cell may reference itself, e.g. ocColumn, ocRow without parameter
 953
 954         BOOL bColRowNameCompile, bHasRelName, bNewListening, bInDeleteUndo;
 955         if ( bHasRefs )
 956         {
 957             // Upon Insert ColRowNames have to be recompiled in case the
 958             // insertion occurs right in front of the range.
 959             bColRowNameCompile =
 960                 (eUpdateRefMode == URM_INSDEL && (nDx > 0 || nDy > 0));
 961             if ( bColRowNameCompile )
 962             {
 963                 bColRowNameCompile = FALSE;
 964                 ScToken* t;
 965                 ScRangePairList* pColList = pDocument->GetColNameRanges();
 966                 ScRangePairList* pRowList = pDocument->GetRowNameRanges();
 967                 pCode->Reset();
 968                 while ( !bColRowNameCompile && (t = static_cast<ScToken*>(pCode->GetNextColRowName())) != NULL )
 969                 {
 970                     ScSingleRefData& rRef = t->GetSingleRef();
 971                     if ( nDy > 0 && rRef.IsColRel() )
 972                     {   // ColName
 973                         rRef.CalcAbsIfRel( aPos );
 974                         ScAddress aAdr( rRef.nCol, rRef.nRow, rRef.nTab );
 975                         ScRangePair* pR = pColList->Find( aAdr );
 976                         if ( pR )
 977                         {   // definiert
 978                             if ( pR->GetRange(1).aStart.Row() == nRow1 )
 979                                 bColRowNameCompile = TRUE;
 980                         }
 981                         else
 982                         {   // on the fly
 983                             if ( rRef.nRow + 1 == nRow1 )
 984                                 bColRowNameCompile = TRUE;
 985                         }
 986                     }
 987                     if ( nDx > 0 && rRef.IsRowRel() )
 988                     {   // RowName
 989                         rRef.CalcAbsIfRel( aPos );
 990                         ScAddress aAdr( rRef.nCol, rRef.nRow, rRef.nTab );
 991                         ScRangePair* pR = pRowList->Find( aAdr );
 992                         if ( pR )
 993                         {   // definiert
 994                             if ( pR->GetRange(1).aStart.Col() == nCol1 )
 995                                 bColRowNameCompile = TRUE;
 996                         }
 997                         else
 998                         {   // on the fly
 999                             if ( rRef.nCol + 1 == nCol1 )
1000                                 bColRowNameCompile = TRUE;
1001                         }
1002                     }
1003                 }
1004             }
1005             else if ( eUpdateRefMode == URM_MOVE )
1006             {   // bei Move/D&D neu kompilieren wenn ColRowName verschoben wurde
1007                 // oder diese Zelle auf einen zeigt und verschoben wurde
1008                 bColRowNameCompile = bCompile;      // evtl. aus Copy-ctor
1009                 if ( !bColRowNameCompile )
1010                 {
1011                     BOOL bMoved = (aPos != aOldPos);
1012                     pCode->Reset();
1013                     ScToken* t = static_cast<ScToken*>(pCode->GetNextColRowName());
1014                     if ( t && bMoved )
1015                         bColRowNameCompile = TRUE;
1016                     while ( t && !bColRowNameCompile )
1017                     {
1018                         ScSingleRefData& rRef = t->GetSingleRef();
1019                         rRef.CalcAbsIfRel( aPos );
1020                         if ( rRef.Valid() )
1021                         {
1022                             ScAddress aAdr( rRef.nCol, rRef.nRow, rRef.nTab );
1023                             if ( r.In( aAdr ) )
1024                                 bColRowNameCompile = TRUE;
1025                         }
1026                         t = static_cast<ScToken*>(pCode->GetNextColRowName());
1027                     }
1028                 }
1029             }
1030             else if ( eUpdateRefMode == URM_COPY && bHasColRowNames && bValChanged )
1031             {
1032                 bColRowNameCompile = TRUE;
1033             }
1034             ScChangeTrack* pChangeTrack = pDocument->GetChangeTrack();
1035             if ( pChangeTrack && pChangeTrack->IsInDeleteUndo() )
1036                 bInDeleteUndo = TRUE;
1037             else
1038                 bInDeleteUndo = FALSE;
1039             // RelNameRefs are always moved
1040             bHasRelName = HasRelNameReference();
1041             // Reference changed and new listening needed?
1042             // Except in Insert/Delete without specialties.
1043             bNewListening = (bRangeModified || pRangeData || bColRowNameCompile
1044                     || (bValChanged && (eUpdateRefMode != URM_INSDEL ||
1045                             bInDeleteUndo || bRefSizeChanged)) ||
1046                     (bHasRelName && eUpdateRefMode != URM_COPY))
1047                 // #i36299# Don't duplicate action during cut&paste / drag&drop
1048                 // on a cell in the range moved, start/end listeners is done
1049                 // via ScDocument::DeleteArea() and ScDocument::CopyFromClip().
1050                 && !(eUpdateRefMode == URM_MOVE &&
1051                         pDocument->IsInsertingFromOtherDoc() && r.In(aPos));
1052             if ( bNewListening )
1053                 EndListeningTo( pDocument, pOld, aOldPos );
1054         }
1055         else
1056         {
1057             bColRowNameCompile = bHasRelName = bNewListening = bInDeleteUndo =
1058                 FALSE;
1059         }
1060
1061         BOOL bNeedDirty;
1062         // NeedDirty bei Aenderungen ausser Copy und Move/Insert ohne RelNames
1063         if ( bRangeModified || pRangeData || bColRowNameCompile ||
1064                 (bValChanged && eUpdateRefMode != URM_COPY &&
1065                  (eUpdateRefMode != URM_MOVE || bHasRelName) &&
1066                  (!bIsInsert || bHasRelName || bInDeleteUndo ||
1067                   bRefSizeChanged)) || bOnRefMove)
1068             bNeedDirty = TRUE;
1069         else
1070             bNeedDirty = FALSE;
1071         if (pUndoDoc && (bValChanged || pRangeData || bOnRefMove))
1072         {
1073             //  Copy the cell to aUndoPos, which is its current position in the document,
1074             //  so this works when UpdateReference is called before moving the cells
1075             //  (InsertCells/DeleteCells - aPos is changed above) as well as when UpdateReference
1076             //  is called after moving the cells (MoveBlock/PasteFromClip - aOldPos is changed).
1077
1078             // If there is already a formula cell in the undo document, don't overwrite it,
1079             // the first (oldest) is the important cell.
1080             if ( pUndoDoc->GetCellType( aUndoPos ) != CELLTYPE_FORMULA )
1081             {
1082                 ScFormulaCell* pFCell = new ScFormulaCell( pUndoDoc, aUndoPos,
1083                         pOld, eTempGrammar, cMatrixFlag );
1084                 pFCell->aResult.SetToken( NULL);  // to recognize it as changed later (Cut/Paste!)
1085                 pUndoDoc->PutCell( aUndoPos, pFCell );
1086             }
1087         }
1088         bValChanged = FALSE;
1089         if ( pRangeData )
1090         {   // Replace shared formula with own formula
1091             pDocument->RemoveFromFormulaTree( this );   // update formula count
1092             delete pCode;
1093             pCode = pRangeData->GetCode()->Clone();
1094             ScCompiler aComp2(pDocument, aPos, *pCode);
1095             aComp2.SetGrammar(pDocument->GetGrammar());
1096             aComp2.UpdateSharedFormulaReference( eUpdateRefMode, aOldPos, r,
1097                 nDx, nDy, nDz );
1098             bValChanged = TRUE;
1099             bNeedDirty = TRUE;
1100         }
1101         if ( ( bCompile = (bCompile || bValChanged || bRangeModified || bColRowNameCompile) ) != 0 )
1102         {
1103             CompileTokenArray( bNewListening ); // kein Listening
1104             bNeedDirty = TRUE;
1105         }
1106         if ( !bInDeleteUndo )
1107         {   // In ChangeTrack Delete-Reject listeners are established in
1108             // InsertCol/InsertRow
1109             if ( bNewListening )
1110             {
1111                 if ( eUpdateRefMode == URM_INSDEL )
1112                 {
1113                     // Inserts/Deletes re-establish listeners after all
1114                     // UpdateReference calls.
1115                     // All replaced shared formula listeners have to be
1116                     // established after an Insert or Delete. Do nothing here.
1117                     SetNeedsListening( TRUE);
1118                 }
1119                 else
1120                     StartListeningTo( pDocument );
1121             }
1122         }
1123         if ( bNeedDirty && (!(eUpdateRefMode == URM_INSDEL && bHasRelName) || pRangeData) )
1124         {   // Referenzen abgeschnitten, ungueltig o.ae.?
1125             BOOL bOldAutoCalc = pDocument->GetAutoCalc();
1126             // kein Interpret in SubMinimalRecalc wegen evtl. falscher Referenzen
1127             pDocument->SetAutoCalc( FALSE );
1128             SetDirty();
1129             pDocument->SetAutoCalc( bOldAutoCalc );
1130         }
1131
1132         delete pOld;
1133     }
1134
1135     pCode->Reset();
1136     for ( formula::FormulaToken* t = pCode->GetNextReferenceOrName(); t; t = pCode->GetNextReferenceOrName() )
1137     {
1138         StackVar sv = t->GetType();
1139         if (sv == svExternalSingleRef || sv == svExternalDoubleRef || sv == svExternalName)
1140         {
1141             pDocument->GetExternalRefManager()->updateRefCell(aOldPos, aPos, eUpdateRefMode == URM_COPY);
1142             break;
1143         }
1144     }
1145 }
1146
1147 void ScFormulaCell::UpdateInsertTab(SCTAB nTable)
1148 {
1149     BOOL bPosChanged = ( aPos.Tab() >= nTable ? TRUE : FALSE );
1150     pCode->Reset();
1151     if( pCode->GetNextReferenceRPN() && !pDocument->IsClipOrUndo() )
1152     {
1153         EndListeningTo( pDocument );
1154         // IncTab _nach_ EndListeningTo und _vor_ Compiler UpdateInsertTab !
1155         if ( bPosChanged )
1156             aPos.IncTab();
1157         ScRangeData* pRangeData;
1158         ScCompiler aComp(pDocument, aPos, *pCode);
1159         aComp.SetGrammar(pDocument->GetGrammar());
1160         pRangeData = aComp.UpdateInsertTab( nTable, FALSE );
1161         if (pRangeData)                     // Shared Formula gegen echte Formel
1162         {                                   // austauschen
1163             BOOL bRefChanged;
1164             pDocument->RemoveFromFormulaTree( this );   // update formula count
1165             delete pCode;
1166             pCode = new ScTokenArray( *pRangeData->GetCode() );
1167             ScCompiler aComp2(pDocument, aPos, *pCode);
1168             aComp2.SetGrammar(pDocument->GetGrammar());
1169             aComp2.MoveRelWrap(pRangeData->GetMaxCol(), pRangeData->GetMaxRow());
1170             aComp2.UpdateInsertTab( nTable, FALSE );
1171             // If the shared formula contained a named range/formula containing
1172             // an absolute reference to a sheet, those have to be readjusted.
1173             aComp2.UpdateDeleteTab( nTable, FALSE, TRUE, bRefChanged );
1174             bCompile = TRUE;
1175         }
1176         // kein StartListeningTo weil pTab[nTab] noch nicht existiert!
1177     }
1178     else if ( bPosChanged )
1179         aPos.IncTab();
1180 }
1181
1182 BOOL ScFormulaCell::UpdateDeleteTab(SCTAB nTable, BOOL bIsMove)
1183 {
1184     BOOL bRefChanged = FALSE;
1185     BOOL bPosChanged = ( aPos.Tab() > nTable ? TRUE : FALSE );
1186     pCode->Reset();
1187     if( pCode->GetNextReferenceRPN() && !pDocument->IsClipOrUndo() )
1188     {
1189         EndListeningTo( pDocument );
1190         // IncTab _nach_ EndListeningTo und _vor_ Compiler UpdateDeleteTab !
1191         if ( bPosChanged )
1192             aPos.IncTab(-1);
1193         ScRangeData* pRangeData;
1194         ScCompiler aComp(pDocument, aPos, *pCode);
1195         aComp.SetGrammar(pDocument->GetGrammar());
1196         pRangeData = aComp.UpdateDeleteTab(nTable, bIsMove, FALSE, bRefChanged);
1197         if (pRangeData)                     // Shared Formula gegen echte Formel
1198         {                                   // austauschen
1199             pDocument->RemoveFromFormulaTree( this );   // update formula count
1200             delete pCode;
1201             pCode = pRangeData->GetCode()->Clone();
1202             ScCompiler aComp2(pDocument, aPos, *pCode);
1203             aComp2.SetGrammar(pDocument->GetGrammar());
1204             aComp2.CompileTokenArray();
1205             aComp2.MoveRelWrap(pRangeData->GetMaxCol(), pRangeData->GetMaxRow());
1206             aComp2.UpdateDeleteTab( nTable, FALSE, FALSE, bRefChanged );
1207             // If the shared formula contained a named range/formula containing
1208             // an absolute reference to a sheet, those have to be readjusted.
1209             aComp2.UpdateInsertTab( nTable,TRUE );
1210             // bRefChanged kann beim letzten UpdateDeleteTab zurueckgesetzt worden sein
1211             bRefChanged = TRUE;
1212             bCompile = TRUE;
1213         }
1214         // kein StartListeningTo weil pTab[nTab] noch nicht korrekt!
1215     }
1216     else if ( bPosChanged )
1217         aPos.IncTab(-1);
1218
1219     return bRefChanged;
1220 }
1221
1222 void ScFormulaCell::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos, SCTAB nTabNo )
1223 {
1224     pCode->Reset();
1225     if( pCode->GetNextReferenceRPN() && !pDocument->IsClipOrUndo() )
1226     {
1227         EndListeningTo( pDocument );
1228         // SetTab _nach_ EndListeningTo und _vor_ Compiler UpdateMoveTab !
1229         aPos.SetTab( nTabNo );
1230         ScRangeData* pRangeData;
1231         ScCompiler aComp(pDocument, aPos, *pCode);
1232         aComp.SetGrammar(pDocument->GetGrammar());
1233         pRangeData = aComp.UpdateMoveTab( nOldPos, nNewPos, FALSE );
1234         if (pRangeData)                     // Shared Formula gegen echte Formel
1235         {                                   // austauschen
1236             pDocument->RemoveFromFormulaTree( this );   // update formula count
1237             delete pCode;
1238             pCode = pRangeData->GetCode()->Clone();
1239             ScCompiler aComp2(pDocument, aPos, *pCode);
1240             aComp2.SetGrammar(pDocument->GetGrammar());
1241             aComp2.CompileTokenArray();
1242             aComp2.MoveRelWrap(pRangeData->GetMaxCol(), pRangeData->GetMaxRow());
1243             aComp2.UpdateMoveTab( nOldPos, nNewPos, TRUE );
1244             bCompile = TRUE;
1245         }
1246         // kein StartListeningTo weil pTab[nTab] noch nicht korrekt!
1247     }
1248     else
1249         aPos.SetTab( nTabNo );
1250 }
1251
1252 void ScFormulaCell::UpdateInsertTabAbs(SCTAB nTable)
1253 {
1254     if( !pDocument->IsClipOrUndo() )
1255     {
1256         pCode->Reset();
1257         ScToken* p = static_cast<ScToken*>(pCode->GetNextReferenceRPN());
1258         while( p )
1259         {
1260             ScSingleRefData& rRef1 = p->GetSingleRef();
1261             if( !rRef1.IsTabRel() && (SCsTAB) nTable <= rRef1.nTab )
1262                 rRef1.nTab++;
1263             if( p->GetType() == formula::svDoubleRef )
1264             {
1265                 ScSingleRefData& rRef2 = p->GetDoubleRef().Ref2;
1266                 if( !rRef2.IsTabRel() && (SCsTAB) nTable <= rRef2.nTab )
1267                     rRef2.nTab++;
1268             }
1269             p = static_cast<ScToken*>(pCode->GetNextReferenceRPN());
1270         }
1271     }
1272 }
1273
1274 BOOL ScFormulaCell::TestTabRefAbs(SCTAB nTable)
1275 {
1276     BOOL bRet = FALSE;
1277     if( !pDocument->IsClipOrUndo() )
1278     {
1279         pCode->Reset();
1280         ScToken* p = static_cast<ScToken*>(pCode->GetNextReferenceRPN());
1281         while( p )
1282         {
1283             ScSingleRefData& rRef1 = p->GetSingleRef();
1284             if( !rRef1.IsTabRel() )
1285             {
1286                 if( (SCsTAB) nTable != rRef1.nTab )
1287                     bRet = TRUE;
1288                 else if (nTable != aPos.Tab())
1289                     rRef1.nTab = aPos.Tab();
1290             }
1291             if( p->GetType() == formula::svDoubleRef )
1292             {
1293                 ScSingleRefData& rRef2 = p->GetDoubleRef().Ref2;
1294                 if( !rRef2.IsTabRel() )
1295                 {
1296                     if( (SCsTAB) nTable != rRef2.nTab )
1297                         bRet = TRUE;
1298                     else if (nTable != aPos.Tab())
1299                         rRef2.nTab = aPos.Tab();
1300                 }
1301             }
1302             p = static_cast<ScToken*>(pCode->GetNextReferenceRPN());
1303         }
1304     }
1305     return bRet;
1306 }
1307
1308 void ScFormulaCell::UpdateCompile( BOOL bForceIfNameInUse )
1309 {
1310     if ( bForceIfNameInUse && !bCompile )
1311         bCompile = pCode->HasNameOrColRowName();
1312     if ( bCompile )
1313         pCode->SetCodeError( 0 );   // make sure it will really be compiled
1314     CompileTokenArray();
1315 }
1316
1317 //  Referenzen transponieren - wird nur in Clipboard-Dokumenten aufgerufen
1318
1319 void ScFormulaCell::TransposeReference()
1320 {
1321     BOOL bFound = FALSE;
1322     pCode->Reset();
1323     ScToken* t;
1324     while ( ( t = static_cast<ScToken*>(pCode->GetNextReference()) ) != NULL )
1325     {
1326         ScSingleRefData& rRef1 = t->GetSingleRef();
1327         if ( rRef1.IsColRel() && rRef1.IsRowRel() )
1328         {
1329             BOOL bDouble = (t->GetType() == formula::svDoubleRef);
1330             ScSingleRefData& rRef2 = (bDouble ? t->GetDoubleRef().Ref2 : rRef1);
1331             if ( !bDouble || (rRef2.IsColRel() && rRef2.IsRowRel()) )
1332             {
1333                 INT16 nTemp;
1334
1335                 nTemp = rRef1.nRelCol;
1336                 rRef1.nRelCol = static_cast<SCCOL>(rRef1.nRelRow);
1337                 rRef1.nRelRow = static_cast<SCROW>(nTemp);
1338
1339                 if ( bDouble )
1340                 {
1341                     nTemp = rRef2.nRelCol;
1342                     rRef2.nRelCol = static_cast<SCCOL>(rRef2.nRelRow);
1343                     rRef2.nRelRow = static_cast<SCROW>(nTemp);
1344                 }
1345
1346                 bFound = TRUE;
1347             }
1348         }
1349     }
1350
1351     if (bFound)
1352         bCompile = TRUE;
1353 }
1354
1355 void ScFormulaCell::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,
1356                                         ScDocument* pUndoDoc )
1357 {
1358     EndListeningTo( pDocument );
1359
1360     ScAddress aOldPos = aPos;
1361     BOOL bPosChanged = FALSE;           // ob diese Zelle bewegt wurde
1362
1363     ScRange aDestRange( rDest, ScAddress(
1364                 static_cast<SCCOL>(rDest.Col() + rSource.aEnd.Row() - rSource.aStart.Row()),
1365                 static_cast<SCROW>(rDest.Row() + rSource.aEnd.Col() - rSource.aStart.Col()),
1366                 rDest.Tab() + rSource.aEnd.Tab() - rSource.aStart.Tab() ) );
1367     if ( aDestRange.In( aOldPos ) )
1368     {
1369         //  Position zurueckrechnen
1370         SCsCOL nRelPosX = aOldPos.Col();
1371         SCsROW nRelPosY = aOldPos.Row();
1372         SCsTAB nRelPosZ = aOldPos.Tab();
1373         ScRefUpdate::DoTranspose( nRelPosX, nRelPosY, nRelPosZ, pDocument, aDestRange, rSource.aStart );
1374         aOldPos.Set( nRelPosX, nRelPosY, nRelPosZ );
1375         bPosChanged = TRUE;
1376     }
1377
1378     ScTokenArray* pOld = pUndoDoc ? pCode->Clone() : NULL;
1379     BOOL bRefChanged = FALSE;
1380     ScToken* t;
1381
1382     ScRangeData* pShared = NULL;
1383     pCode->Reset();
1384     while( (t = static_cast<ScToken*>(pCode->GetNextReferenceOrName())) != NULL )
1385     {
1386         if( t->GetOpCode() == ocName )
1387         {
1388             ScRangeData* pName = pDocument->GetRangeName()->FindIndex( t->GetIndex() );
1389             if (pName)
1390             {
1391                 if (pName->IsModified())
1392                     bRefChanged = TRUE;
1393                 if (pName->HasType(RT_SHAREDMOD))
1394                     pShared = pName;
1395             }
1396         }
1397         else if( t->GetType() != svIndex )
1398         {
1399             t->CalcAbsIfRel( aOldPos );
1400             BOOL bMod;
1401             {   // own scope for SingleDoubleRefModifier dtor if SingleRef
1402                 SingleDoubleRefModifier aMod( *t );
1403                 ScComplexRefData& rRef = aMod.Ref();
1404                 bMod = (ScRefUpdate::UpdateTranspose( pDocument, rSource,
1405                     rDest, rRef ) != UR_NOTHING || bPosChanged);
1406             }
1407             if ( bMod )
1408             {
1409                 t->CalcRelFromAbs( aPos );
1410                 bRefChanged = TRUE;
1411             }
1412         }
1413     }
1414
1415     if (pShared)            // Shared Formula gegen echte Formel austauschen
1416     {
1417         pDocument->RemoveFromFormulaTree( this );   // update formula count
1418         delete pCode;
1419         pCode = new ScTokenArray( *pShared->GetCode() );
1420         bRefChanged = TRUE;
1421         pCode->Reset();
1422         while( (t = static_cast<ScToken*>(pCode->GetNextReference())) != NULL )
1423         {
1424             if( t->GetType() != svIndex )
1425             {
1426                 t->CalcAbsIfRel( aOldPos );
1427                 BOOL bMod;
1428                 {   // own scope for SingleDoubleRefModifier dtor if SingleRef
1429                     SingleDoubleRefModifier aMod( *t );
1430                     ScComplexRefData& rRef = aMod.Ref();
1431                     bMod = (ScRefUpdate::UpdateTranspose( pDocument, rSource,
1432                         rDest, rRef ) != UR_NOTHING || bPosChanged);
1433                 }
1434                 if ( bMod )
1435                     t->CalcRelFromAbs( aPos );
1436             }
1437         }
1438     }
1439
1440     if (bRefChanged)
1441     {
1442         if (pUndoDoc)
1443         {
1444             ScFormulaCell* pFCell = new ScFormulaCell( pUndoDoc, aPos, pOld,
1445                     eTempGrammar, cMatrixFlag);
1446             pFCell->aResult.SetToken( NULL);  // to recognize it as changed later (Cut/Paste!)
1447             pUndoDoc->PutCell( aPos.Col(), aPos.Row(), aPos.Tab(), pFCell );
1448         }
1449
1450         bCompile = TRUE;
1451         CompileTokenArray();                // ruft auch StartListeningTo
1452         SetDirty();
1453     }
1454     else
1455         StartListeningTo( pDocument );      // Listener wie vorher
1456
1457     delete pOld;
1458 }
1459
1460 void ScFormulaCell::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
1461 {
1462     EndListeningTo( pDocument );
1463
1464     BOOL bRefChanged = FALSE;
1465     ScToken* t;
1466     ScRangeData* pShared = NULL;
1467
1468     pCode->Reset();
1469     while( (t = static_cast<ScToken*>(pCode->GetNextReferenceOrName())) != NULL )
1470     {
1471         if( t->GetOpCode() == ocName )
1472         {
1473             ScRangeData* pName = pDocument->GetRangeName()->FindIndex( t->GetIndex() );
1474             if (pName)
1475             {
1476                 if (pName->IsModified())
1477                     bRefChanged = TRUE;
1478                 if (pName->HasType(RT_SHAREDMOD))
1479                     pShared = pName;
1480             }
1481         }
1482         else if( t->GetType() != svIndex )
1483         {
1484             t->CalcAbsIfRel( aPos );
1485             BOOL bMod;
1486             {   // own scope for SingleDoubleRefModifier dtor if SingleRef
1487                 SingleDoubleRefModifier aMod( *t );
1488                 ScComplexRefData& rRef = aMod.Ref();
1489                 bMod = (ScRefUpdate::UpdateGrow( rArea,nGrowX,nGrowY,
1490                     rRef ) != UR_NOTHING);
1491             }
1492             if ( bMod )
1493             {
1494                 t->CalcRelFromAbs( aPos );
1495                 bRefChanged = TRUE;
1496             }
1497         }
1498     }
1499
1500     if (pShared)            // Shared Formula gegen echte Formel austauschen
1501     {
1502         pDocument->RemoveFromFormulaTree( this );   // update formula count
1503         delete pCode;
1504         pCode = new ScTokenArray( *pShared->GetCode() );
1505         bRefChanged = TRUE;
1506         pCode->Reset();
1507         while( (t = static_cast<ScToken*>(pCode->GetNextReference())) != NULL )
1508         {
1509             if( t->GetType() != svIndex )
1510             {
1511                 t->CalcAbsIfRel( aPos );
1512                 BOOL bMod;
1513                 {   // own scope for SingleDoubleRefModifier dtor if SingleRef
1514                     SingleDoubleRefModifier aMod( *t );
1515                     ScComplexRefData& rRef = aMod.Ref();
1516                     bMod = (ScRefUpdate::UpdateGrow( rArea,nGrowX,nGrowY,
1517                         rRef ) != UR_NOTHING);
1518                 }
1519                 if ( bMod )
1520                     t->CalcRelFromAbs( aPos );
1521             }
1522         }
1523     }
1524
1525     if (bRefChanged)
1526     {
1527         bCompile = TRUE;
1528         CompileTokenArray();                // ruft auch StartListeningTo
1529         SetDirty();
1530     }
1531     else
1532         StartListeningTo( pDocument );      // Listener wie vorher
1533 }
1534
1535 BOOL lcl_IsRangeNameInUse(USHORT nIndex, ScTokenArray* pCode, ScRangeName* pNames)
1536 {
1537     for (FormulaToken* p = pCode->First(); p; p = pCode->Next())
1538     {
1539         if (p->GetOpCode() == ocName)
1540         {
1541             if (p->GetIndex() == nIndex)
1542                 return TRUE;
1543             else
1544             {
1545                 //  RangeData kann Null sein in bestimmten Excel-Dateien (#31168#)
1546                 ScRangeData* pSubName = pNames->FindIndex(p->GetIndex());
1547                 if (pSubName && lcl_IsRangeNameInUse(nIndex,
1548                                     pSubName->GetCode(), pNames))
1549                     return TRUE;
1550             }
1551         }
1552     }
1553     return FALSE;
1554 }
1555
1556 BOOL ScFormulaCell::IsRangeNameInUse(USHORT nIndex) const
1557 {
1558     return lcl_IsRangeNameInUse( nIndex, pCode, pDocument->GetRangeName() );
1559 }
1560
1561 void lcl_FindRangeNamesInUse(std::set<USHORT>& rIndexes, ScTokenArray* pCode, ScRangeName* pNames)
1562 {
1563     for (FormulaToken* p = pCode->First(); p; p = pCode->Next())
1564     {
1565         if (p->GetOpCode() == ocName)
1566         {
1567             USHORT nTokenIndex = p->GetIndex();
1568             rIndexes.insert( nTokenIndex );
1569
1570             ScRangeData* pSubName = pNames->FindIndex(p->GetIndex());
1571             if (pSubName)
1572                 lcl_FindRangeNamesInUse(rIndexes, pSubName->GetCode(), pNames);
1573         }
1574     }
1575 }
1576
1577 void ScFormulaCell::FindRangeNamesInUse(std::set<USHORT>& rIndexes) const
1578 {
1579     lcl_FindRangeNamesInUse( rIndexes, pCode, pDocument->GetRangeName() );
1580 }
1581
1582 void ScFormulaCell::ReplaceRangeNamesInUse( const ScIndexMap& rMap )
1583 {
1584     for( FormulaToken* p = pCode->First(); p; p = pCode->Next() )
1585     {
1586         if( p->GetOpCode() == ocName )
1587         {
1588             USHORT nIndex = p->GetIndex();
1589             USHORT nNewIndex = rMap.Find( nIndex );
1590             if ( nIndex != nNewIndex )
1591             {
1592                 p->SetIndex( nNewIndex );
1593                 bCompile = TRUE;
1594             }
1595         }
1596     }
1597     if( bCompile )
1598         CompileTokenArray();
1599 }
1600
1601 void ScFormulaCell::ReplaceRangeNamesInUse( const ScRangeData::IndexMap& rMap )
1602 {
1603     for( FormulaToken* p = pCode->First(); p; p = pCode->Next() )
1604     {
1605         if( p->GetOpCode() == ocName )
1606         {
1607             sal_uInt16 nIndex = p->GetIndex();
1608             ScRangeData::IndexMap::const_iterator itr = rMap.find(nIndex);
1609             sal_uInt16 nNewIndex = itr == rMap.end() ? nIndex : nNewIndex;
1610             if ( nIndex != nNewIndex )
1611             {
1612                 p->SetIndex( nNewIndex );
1613                 bCompile = TRUE;
1614             }
1615         }
1616     }
1617     if( bCompile )
1618         CompileTokenArray();
1619 }
1620
1621 void ScFormulaCell::CompileDBFormula()
1622 {
1623     for( FormulaToken* p = pCode->First(); p; p = pCode->Next() )
1624     {
1625         if ( p->GetOpCode() == ocDBArea
1626             || (p->GetOpCode() == ocName && p->GetIndex() >= SC_START_INDEX_DB_COLL) )
1627         {
1628             bCompile = TRUE;
1629             CompileTokenArray();
1630             SetDirty();
1631             break;
1632         }
1633     }
1634 }
1635
1636 void ScFormulaCell::CompileDBFormula( BOOL bCreateFormulaString )
1637 {
1638     // zwei Phasen, muessen (!) nacheinander aufgerufen werden:
1639     // 1. FormelString mit alten Namen erzeugen
1640     // 2. FormelString mit neuen Namen kompilieren
1641     if ( bCreateFormulaString )
1642     {
1643         BOOL bRecompile = FALSE;
1644         pCode->Reset();
1645         for ( FormulaToken* p = pCode->First(); p && !bRecompile; p = pCode->Next() )
1646         {
1647             switch ( p->GetOpCode() )
1648             {
1649                 case ocBad:             // DB-Bereich evtl. zugefuegt
1650                 case ocColRowName:      // #36762# falls Namensgleichheit
1651                 case ocDBArea:          // DB-Bereich
1652                     bRecompile = TRUE;
1653                 break;
1654                 case ocName:
1655                     if ( p->GetIndex() >= SC_START_INDEX_DB_COLL )
1656                         bRecompile = TRUE;  // DB-Bereich
1657                 break;
1658                 default:
1659                     ; // nothing
1660             }
1661         }
1662         if ( bRecompile )
1663         {
1664             String aFormula;
1665             GetFormula( aFormula, formula::FormulaGrammar::GRAM_NATIVE);
1666             if ( GetMatrixFlag() != MM_NONE && aFormula.Len() )
1667             {
1668                 if ( aFormula.GetChar( aFormula.Len()-1 ) == '}' )
1669                     aFormula.Erase( aFormula.Len()-1 , 1 );
1670                 if ( aFormula.GetChar(0) == '{' )
1671                     aFormula.Erase( 0, 1 );
1672             }
1673             EndListeningTo( pDocument );
1674             pDocument->RemoveFromFormulaTree( this );
1675             pCode->Clear();
1676             SetHybridFormula( aFormula, formula::FormulaGrammar::GRAM_NATIVE);
1677         }
1678     }
1679     else if ( !pCode->GetLen() && aResult.GetHybridFormula().Len() )
1680     {
1681         Compile( aResult.GetHybridFormula(), FALSE, eTempGrammar );
1682         aResult.SetToken( NULL);
1683         SetDirty();
1684     }
1685 }
1686
1687 void ScFormulaCell::CompileNameFormula( BOOL bCreateFormulaString )
1688 {
1689     // zwei Phasen, muessen (!) nacheinander aufgerufen werden:
1690     // 1. FormelString mit alten RangeNames erzeugen
1691     // 2. FormelString mit neuen RangeNames kompilieren
1692     if ( bCreateFormulaString )
1693     {
1694         BOOL bRecompile = FALSE;
1695         pCode->Reset();
1696         for ( FormulaToken* p = pCode->First(); p && !bRecompile; p = pCode->Next() )
1697         {
1698             switch ( p->GetOpCode() )
1699             {
1700                 case ocBad:             // RangeName evtl. zugefuegt
1701                 case ocColRowName:      // #36762# falls Namensgleichheit
1702                     bRecompile = TRUE;
1703                 break;
1704                 default:
1705                     if ( p->GetType() == svIndex )
1706                         bRecompile = TRUE;  // RangeName
1707             }
1708         }
1709         if ( bRecompile )
1710         {
1711             String aFormula;
1712             GetFormula( aFormula, formula::FormulaGrammar::GRAM_NATIVE);
1713             if ( GetMatrixFlag() != MM_NONE && aFormula.Len() )
1714             {
1715                 if ( aFormula.GetChar( aFormula.Len()-1 ) == '}' )
1716                     aFormula.Erase( aFormula.Len()-1 , 1 );
1717                 if ( aFormula.GetChar(0) == '{' )
1718                     aFormula.Erase( 0, 1 );
1719             }
1720             EndListeningTo( pDocument );
1721             pDocument->RemoveFromFormulaTree( this );
1722             pCode->Clear();
1723             SetHybridFormula( aFormula, formula::FormulaGrammar::GRAM_NATIVE);
1724         }
1725     }
1726     else if ( !pCode->GetLen() && aResult.GetHybridFormula().Len() )
1727     {
1728         Compile( aResult.GetHybridFormula(), FALSE, eTempGrammar );
1729         aResult.SetToken( NULL);
1730         SetDirty();
1731     }
1732 }
1733
1734 void ScFormulaCell::CompileColRowNameFormula()
1735 {
1736     pCode->Reset();
1737     for ( FormulaToken* p = pCode->First(); p; p = pCode->Next() )
1738     {
1739         if ( p->GetOpCode() == ocColRowName )
1740         {
1741             bCompile = TRUE;
1742             CompileTokenArray();
1743             SetDirty();
1744             break;
1745         }
1746     }
1747 }
1748
1749 // ============================================================================
1750