sc/source/core/data/conditio.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: conditio.cxx,v $
  10  * $Revision: 1.25.30.5 $
  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 //------------------------------------------------------------------
  37
  38 #include "scitems.hxx"
  39 #include <sfx2/objsh.hxx>
  40 #include <svtools/itemset.hxx>
  41 #include <svtools/zforlist.hxx>
  42 #include <rtl/math.hxx>
  43 #include <unotools/collatorwrapper.hxx>
  44
  45 #include "conditio.hxx"
  46 #include "cell.hxx"
  47 #include "document.hxx"
  48 #include "hints.hxx"
  49 #include "compiler.hxx"
  50 #include "rechead.hxx"
  51 #include "rangelst.hxx"
  52 #include "stlpool.hxx"
  53 #include "rangenam.hxx"
  54
  55 using namespace formula;
  56 //------------------------------------------------------------------------
  57
  58 SV_IMPL_OP_PTRARR_SORT( ScConditionalFormats_Impl, ScConditionalFormatPtr );
  59
  60 //------------------------------------------------------------------------
  61
  62 BOOL lcl_HasRelRef( ScDocument* pDoc, ScTokenArray* pFormula, USHORT nRecursion = 0 )
  63 {
  64     if (pFormula)
  65     {
  66         pFormula->Reset();
  67         FormulaToken* t;
  68         for( t = pFormula->Next(); t; t = pFormula->Next() )
  69         {
  70             switch( t->GetType() )
  71             {
  72                 case svDoubleRef:
  73                 {
  74                     ScSingleRefData& rRef2 = static_cast<ScToken*>(t)->GetDoubleRef().Ref2;
  75                     if ( rRef2.IsColRel() || rRef2.IsRowRel() || rRef2.IsTabRel() )
  76                         return TRUE;
  77                 }
  78                 // fall through
  79
  80                 case svSingleRef:
  81                 {
  82                     ScSingleRefData& rRef1 = static_cast<ScToken*>(t)->GetSingleRef();
  83                     if ( rRef1.IsColRel() || rRef1.IsRowRel() || rRef1.IsTabRel() )
  84                         return TRUE;
  85                 }
  86                 break;
  87
  88                 case svIndex:
  89                 {
  90                     if( t->GetOpCode() == ocName )      // DB areas always absolute
  91                         if( ScRangeData* pRangeData = pDoc->GetRangeName()->FindIndex( t->GetIndex() ) )
  92                             if( (nRecursion < 42) && lcl_HasRelRef( pDoc, pRangeData->GetCode(), nRecursion + 1 ) )
  93                                 return TRUE;
  94                 }
  95                 break;
  96
  97                 // #i34474# function result dependent on cell position
  98                 case svByte:
  99                 {
 100                     switch( t->GetOpCode() )
 101                     {
 102                         case ocRow:     // ROW() returns own row index
 103                         case ocColumn:  // COLUMN() returns own column index
 104                         case ocTable:   // SHEET() returns own sheet index
 105                         case ocCell:    // CELL() may return own cell address
 106                             return TRUE;
 107 //                        break;
 108                         default:
 109                         {
 110                             // added to avoid warnings
 111                         }
 112                     }
 113                 }
 114                 break;
 115
 116                 default:
 117                 {
 118                     // added to avoid warnings
 119                 }
 120             }
 121         }
 122     }
 123     return FALSE;
 124 }
 125
 126 ScConditionEntry::ScConditionEntry( const ScConditionEntry& r ) :
 127     eOp(r.eOp),
 128     nOptions(r.nOptions),
 129     nVal1(r.nVal1),
 130     nVal2(r.nVal2),
 131     aStrVal1(r.aStrVal1),
 132     aStrVal2(r.aStrVal2),
 133     aStrNmsp1(r.aStrNmsp1),
 134     aStrNmsp2(r.aStrNmsp2),
 135     eTempGrammar1(r.eTempGrammar1),
 136     eTempGrammar2(r.eTempGrammar2),
 137     bIsStr1(r.bIsStr1),
 138     bIsStr2(r.bIsStr2),
 139     pFormula1(NULL),
 140     pFormula2(NULL),
 141     aSrcPos(r.aSrcPos),
 142     aSrcString(r.aSrcString),
 143     pFCell1(NULL),
 144     pFCell2(NULL),
 145     pDoc(r.pDoc),
 146     bRelRef1(r.bRelRef1),
 147     bRelRef2(r.bRelRef2),
 148     bFirstRun(TRUE)
 149 {
 150     //  ScTokenArray copy ctor erzeugt flache Kopie
 151
 152     if (r.pFormula1)
 153         pFormula1 = new ScTokenArray( *r.pFormula1 );
 154     if (r.pFormula2)
 155         pFormula2 = new ScTokenArray( *r.pFormula2 );
 156
 157     //  Formelzellen werden erst bei IsValid angelegt
 158 }
 159
 160 ScConditionEntry::ScConditionEntry( ScDocument* pDocument, const ScConditionEntry& r ) :
 161     eOp(r.eOp),
 162     nOptions(r.nOptions),
 163     nVal1(r.nVal1),
 164     nVal2(r.nVal2),
 165     aStrVal1(r.aStrVal1),
 166     aStrVal2(r.aStrVal2),
 167     aStrNmsp1(r.aStrNmsp1),
 168     aStrNmsp2(r.aStrNmsp2),
 169     eTempGrammar1(r.eTempGrammar1),
 170     eTempGrammar2(r.eTempGrammar2),
 171     bIsStr1(r.bIsStr1),
 172     bIsStr2(r.bIsStr2),
 173     pFormula1(NULL),
 174     pFormula2(NULL),
 175     aSrcPos(r.aSrcPos),
 176     aSrcString(r.aSrcString),
 177     pFCell1(NULL),
 178     pFCell2(NULL),
 179     pDoc(pDocument),
 180     bRelRef1(r.bRelRef1),
 181     bRelRef2(r.bRelRef2),
 182     bFirstRun(TRUE)
 183 {
 184     // echte Kopie der Formeln (fuer Ref-Undo)
 185
 186     if (r.pFormula1)
 187         pFormula1 = r.pFormula1->Clone();
 188     if (r.pFormula2)
 189         pFormula2 = r.pFormula2->Clone();
 190
 191     //  Formelzellen werden erst bei IsValid angelegt
 192     //! im Clipboard nicht - dann vorher interpretieren !!!
 193 }
 194
 195 ScConditionEntry::ScConditionEntry( ScConditionMode eOper,
 196         const String& rExpr1, const String& rExpr2, ScDocument* pDocument, const ScAddress& rPos,
 197         const String& rExprNmsp1, const String& rExprNmsp2,
 198         FormulaGrammar::Grammar eGrammar1, FormulaGrammar::Grammar eGrammar2 ) :
 199     eOp(eOper),
 200     nOptions(0),        // spaeter...
 201     nVal1(0.0),
 202     nVal2(0.0),
 203     aStrNmsp1(rExprNmsp1),
 204     aStrNmsp2(rExprNmsp2),
 205     eTempGrammar1(eGrammar1),
 206     eTempGrammar2(eGrammar2),
 207     bIsStr1(FALSE),
 208     bIsStr2(FALSE),
 209     pFormula1(NULL),
 210     pFormula2(NULL),
 211     aSrcPos(rPos),
 212     pFCell1(NULL),
 213     pFCell2(NULL),
 214     pDoc(pDocument),
 215     bRelRef1(FALSE),
 216     bRelRef2(FALSE),
 217     bFirstRun(TRUE)
 218 {
 219     Compile( rExpr1, rExpr2, rExprNmsp1, rExprNmsp2, eGrammar1, eGrammar2, FALSE );
 220
 221     //  Formelzellen werden erst bei IsValid angelegt
 222 }
 223
 224 ScConditionEntry::ScConditionEntry( ScConditionMode eOper,
 225                                 const ScTokenArray* pArr1, const ScTokenArray* pArr2,
 226                                 ScDocument* pDocument, const ScAddress& rPos ) :
 227     eOp(eOper),
 228     nOptions(0),        // spaeter...
 229     nVal1(0.0),
 230     nVal2(0.0),
 231     eTempGrammar1(FormulaGrammar::GRAM_DEFAULT),
 232     eTempGrammar2(FormulaGrammar::GRAM_DEFAULT),
 233     bIsStr1(FALSE),
 234     bIsStr2(FALSE),
 235     pFormula1(NULL),
 236     pFormula2(NULL),
 237     aSrcPos(rPos),
 238     pFCell1(NULL),
 239     pFCell2(NULL),
 240     pDoc(pDocument),
 241     bRelRef1(FALSE),
 242     bRelRef2(FALSE),
 243     bFirstRun(TRUE)
 244 {
 245     if ( pArr1 )
 246     {
 247         pFormula1 = new ScTokenArray( *pArr1 );
 248         if ( pFormula1->GetLen() == 1 )
 249         {
 250             // einzelne (konstante Zahl) ?
 251             FormulaToken* pToken = pFormula1->First();
 252             if ( pToken->GetOpCode() == ocPush )
 253             {
 254                 if ( pToken->GetType() == svDouble )
 255                 {
 256                     nVal1 = pToken->GetDouble();
 257                     DELETEZ(pFormula1);                         // nicht als Formel merken
 258                 }
 259                 else if ( pToken->GetType() == svString )
 260                 {
 261                     bIsStr1 = TRUE;
 262                     aStrVal1 = pToken->GetString();
 263                     DELETEZ(pFormula1);                         // nicht als Formel merken
 264                 }
 265             }
 266         }
 267         bRelRef1 = lcl_HasRelRef( pDoc, pFormula1 );
 268     }
 269     if ( pArr2 )
 270     {
 271         pFormula2 = new ScTokenArray( *pArr2 );
 272         if ( pFormula2->GetLen() == 1 )
 273         {
 274             // einzelne (konstante Zahl) ?
 275             FormulaToken* pToken = pFormula2->First();
 276             if ( pToken->GetOpCode() == ocPush )
 277             {
 278                 if ( pToken->GetType() == svDouble )
 279                 {
 280                     nVal2 = pToken->GetDouble();
 281                     DELETEZ(pFormula2);                         // nicht als Formel merken
 282                 }
 283                 else if ( pToken->GetType() == svString )
 284                 {
 285                     bIsStr2 = TRUE;
 286                     aStrVal2 = pToken->GetString();
 287                     DELETEZ(pFormula2);                         // nicht als Formel merken
 288                 }
 289             }
 290         }
 291         bRelRef2 = lcl_HasRelRef( pDoc, pFormula2 );
 292     }
 293
 294     //  formula cells are created at IsValid
 295 }
 296
 297 ScConditionEntry::~ScConditionEntry()
 298 {
 299     delete pFCell1;
 300     delete pFCell2;
 301
 302     delete pFormula1;
 303     delete pFormula2;
 304 }
 305
 306 void ScConditionEntry::Compile( const String& rExpr1, const String& rExpr2,
 307         const String& rExprNmsp1, const String& rExprNmsp2,
 308         FormulaGrammar::Grammar eGrammar1, FormulaGrammar::Grammar eGrammar2, BOOL bTextToReal )
 309 {
 310     if ( rExpr1.Len() || rExpr2.Len() )
 311     {
 312         ScCompiler aComp( pDoc, aSrcPos );
 313
 314         if ( rExpr1.Len() )
 315         {
 316             aComp.SetGrammar( eGrammar1 );
 317             if ( pDoc->IsImportingXML() && !bTextToReal )
 318             {
 319                 //      temporary formula string as string tokens
 320                 //!     merge with lcl_ScDocFunc_CreateTokenArrayXML
 321                 pFormula1 = new ScTokenArray;
 322                 pFormula1->AddString( rExpr1 );
 323                 // bRelRef1 is set when the formula is compiled again (CompileXML)
 324             }
 325             else
 326             {
 327                 pFormula1 = aComp.CompileString( rExpr1, rExprNmsp1 );
 328                 if ( pFormula1->GetLen() == 1 )
 329                 {
 330                     // einzelne (konstante Zahl) ?
 331                     FormulaToken* pToken = pFormula1->First();
 332                     if ( pToken->GetOpCode() == ocPush )
 333                     {
 334                         if ( pToken->GetType() == svDouble )
 335                         {
 336                             nVal1 = pToken->GetDouble();
 337                             DELETEZ(pFormula1);                         // nicht als Formel merken
 338                         }
 339                         else if ( pToken->GetType() == svString )
 340                         {
 341                             bIsStr1 = TRUE;
 342                             aStrVal1 = pToken->GetString();
 343                             DELETEZ(pFormula1);                         // nicht als Formel merken
 344                         }
 345                     }
 346                 }
 347                 bRelRef1 = lcl_HasRelRef( pDoc, pFormula1 );
 348             }
 349         }
 350
 351         if ( rExpr2.Len() )
 352         {
 353             aComp.SetGrammar( eGrammar2 );
 354             if ( pDoc->IsImportingXML() && !bTextToReal )
 355             {
 356                 //      temporary formula string as string tokens
 357                 //!     merge with lcl_ScDocFunc_CreateTokenArrayXML
 358                 pFormula2 = new ScTokenArray;
 359                 pFormula2->AddString( rExpr2 );
 360                 // bRelRef2 is set when the formula is compiled again (CompileXML)
 361             }
 362             else
 363             {
 364                 pFormula2 = aComp.CompileString( rExpr2, rExprNmsp2 );
 365                 if ( pFormula2->GetLen() == 1 )
 366                 {
 367                     // einzelne (konstante Zahl) ?
 368                     FormulaToken* pToken = pFormula2->First();
 369                     if ( pToken->GetOpCode() == ocPush )
 370                     {
 371                         if ( pToken->GetType() == svDouble )
 372                         {
 373                             nVal2 = pToken->GetDouble();
 374                             DELETEZ(pFormula2);                         // nicht als Formel merken
 375                         }
 376                         else if ( pToken->GetType() == svString )
 377                         {
 378                             bIsStr2 = TRUE;
 379                             aStrVal2 = pToken->GetString();
 380                             DELETEZ(pFormula2);                         // nicht als Formel merken
 381                         }
 382                     }
 383                 }
 384                 bRelRef2 = lcl_HasRelRef( pDoc, pFormula2 );
 385             }
 386         }
 387     }
 388 }
 389
 390 void ScConditionEntry::MakeCells( const ScAddress& rPos )                       // Formelzellen anlegen
 391 {
 392     if ( !pDoc->IsClipOrUndo() )                        // nie im Clipboard rechnen!
 393     {
 394         if ( pFormula1 && !pFCell1 && !bRelRef1 )
 395         {
 396             pFCell1 = new ScFormulaCell( pDoc, rPos, pFormula1 );
 397             pFCell1->StartListeningTo( pDoc );
 398         }
 399
 400         if ( pFormula2 && !pFCell2 && !bRelRef2 )
 401         {
 402             pFCell2 = new ScFormulaCell( pDoc, rPos, pFormula2 );
 403             pFCell2->StartListeningTo( pDoc );
 404         }
 405     }
 406 }
 407
 408 void ScConditionEntry::SetIgnoreBlank(BOOL bSet)
 409 {
 410     //  Das Bit SC_COND_NOBLANKS wird gesetzt, wenn Blanks nicht ignoriert werden
 411     //  (nur bei Gueltigkeit)
 412
 413     if (bSet)
 414         nOptions &= ~SC_COND_NOBLANKS;
 415     else
 416         nOptions |= SC_COND_NOBLANKS;
 417 }
 418
 419 void ScConditionEntry::CompileAll()
 420 {
 421     //  Formelzellen loeschen, dann wird beim naechsten IsValid neu kompiliert
 422
 423     DELETEZ(pFCell1);
 424     DELETEZ(pFCell2);
 425 }
 426
 427 void ScConditionEntry::CompileXML()
 428 {
 429     //  #b4974740# First parse the formula source position if it was stored as text
 430
 431     if ( aSrcString.Len() )
 432     {
 433         ScAddress aNew;
 434         /* XML is always in OOo:A1 format, although R1C1 would be more amenable
 435          * to compression */
 436         if ( aNew.Parse( aSrcString, pDoc ) & SCA_VALID )
 437             aSrcPos = aNew;
 438         // if the position is invalid, there isn't much we can do at this time
 439         aSrcString.Erase();
 440     }
 441
 442     //  Convert the text tokens that were created during XML import into real tokens.
 443
 444     Compile( GetExpression(aSrcPos, 0, 0, eTempGrammar1),
 445              GetExpression(aSrcPos, 1, 0, eTempGrammar2),
 446              aStrNmsp1, aStrNmsp2, eTempGrammar1, eTempGrammar2, TRUE );
 447 }
 448
 449 void ScConditionEntry::SetSrcString( const String& rNew )
 450 {
 451     // aSrcString is only evaluated in CompileXML
 452     DBG_ASSERT( pDoc->IsImportingXML(), "SetSrcString is only valid for XML import" );
 453
 454     aSrcString = rNew;
 455 }
 456
 457 void ScConditionEntry::SetFormula1( const ScTokenArray& rArray )
 458 {
 459     DELETEZ( pFormula1 );
 460     if( rArray.GetLen() > 0 )
 461     {
 462         pFormula1 = new ScTokenArray( rArray );
 463         bRelRef1 = lcl_HasRelRef( pDoc, pFormula1 );
 464     }
 465 }
 466
 467 void ScConditionEntry::SetFormula2( const ScTokenArray& rArray )
 468 {
 469     DELETEZ( pFormula2 );
 470     if( rArray.GetLen() > 0 )
 471     {
 472         pFormula2 = new ScTokenArray( rArray );
 473         bRelRef2 = lcl_HasRelRef( pDoc, pFormula2 );
 474     }
 475 }
 476
 477 void lcl_CondUpdateInsertTab( ScTokenArray& rCode, SCTAB nInsTab, SCTAB nPosTab, BOOL& rChanged )
 478 {
 479     //  Insert table: only update absolute table references.
 480     //  (Similar to ScCompiler::UpdateInsertTab with bIsName=TRUE, result is the same as for named ranges)
 481     //  For deleting, ScCompiler::UpdateDeleteTab is used because of the handling of invalid references.
 482
 483     rCode.Reset();
 484     ScToken* p = static_cast<ScToken*>(rCode.GetNextReference());
 485     while( p )
 486     {
 487         ScSingleRefData& rRef1 = p->GetSingleRef();
 488         if ( !rRef1.IsTabRel() && nInsTab <= rRef1.nTab )
 489         {
 490             rRef1.nTab += 1;
 491             rRef1.nRelTab = rRef1.nTab - nPosTab;
 492             rChanged = TRUE;
 493         }
 494         if( p->GetType() == svDoubleRef )
 495         {
 496             ScSingleRefData& rRef2 = p->GetDoubleRef().Ref2;
 497             if ( !rRef2.IsTabRel() && nInsTab <= rRef2.nTab )
 498             {
 499                 rRef2.nTab += 1;
 500                 rRef2.nRelTab = rRef2.nTab - nPosTab;
 501                 rChanged = TRUE;
 502             }
 503         }
 504         p = static_cast<ScToken*>(rCode.GetNextReference());
 505     }
 506 }
 507
 508 void ScConditionEntry::UpdateReference( UpdateRefMode eUpdateRefMode,
 509                                 const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
 510 {
 511     BOOL bInsertTab = ( eUpdateRefMode == URM_INSDEL && nDz == 1 );
 512     BOOL bDeleteTab = ( eUpdateRefMode == URM_INSDEL && nDz == -1 );
 513
 514     BOOL bChanged1 = FALSE;
 515     BOOL bChanged2 = FALSE;
 516
 517     if (pFormula1)
 518     {
 519         if ( bInsertTab )
 520             lcl_CondUpdateInsertTab( *pFormula1, rRange.aStart.Tab(), aSrcPos.Tab(), bChanged1 );
 521         else
 522         {
 523             ScCompiler aComp( pDoc, aSrcPos, *pFormula1 );
 524             aComp.SetGrammar(pDoc->GetGrammar());
 525             if ( bDeleteTab )
 526                 aComp.UpdateDeleteTab( rRange.aStart.Tab(), FALSE, TRUE, bChanged1 );
 527             else
 528                 aComp.UpdateNameReference( eUpdateRefMode, rRange, nDx, nDy, nDz, bChanged1 );
 529         }
 530
 531         if (bChanged1)
 532             DELETEZ(pFCell1);           // is created again in IsValid
 533     }
 534     if (pFormula2)
 535     {
 536         if ( bInsertTab )
 537             lcl_CondUpdateInsertTab( *pFormula2, rRange.aStart.Tab(), aSrcPos.Tab(), bChanged2 );
 538         else
 539         {
 540             ScCompiler aComp( pDoc, aSrcPos, *pFormula2);
 541             aComp.SetGrammar(pDoc->GetGrammar());
 542             if ( bDeleteTab )
 543                 aComp.UpdateDeleteTab( rRange.aStart.Tab(), FALSE, TRUE, bChanged2 );
 544             else
 545                 aComp.UpdateNameReference( eUpdateRefMode, rRange, nDx, nDy, nDz, bChanged2 );
 546         }
 547
 548         if (bChanged2)
 549             DELETEZ(pFCell2);           // is created again in IsValid
 550     }
 551 }
 552
 553 void ScConditionEntry::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos )
 554 {
 555     if (pFormula1)
 556     {
 557         ScCompiler aComp( pDoc, aSrcPos, *pFormula1);
 558         aComp.SetGrammar(pDoc->GetGrammar());
 559         aComp.UpdateMoveTab(nOldPos, nNewPos, TRUE );
 560         DELETEZ(pFCell1);
 561     }
 562     if (pFormula2)
 563     {
 564         ScCompiler aComp( pDoc, aSrcPos, *pFormula2);
 565         aComp.SetGrammar(pDoc->GetGrammar());
 566         aComp.UpdateMoveTab(nOldPos, nNewPos, TRUE );
 567         DELETEZ(pFCell2);
 568     }
 569 }
 570
 571 //!     als Vergleichsoperator ans TokenArray ???
 572
 573 BOOL lcl_IsEqual( const ScTokenArray* pArr1, const ScTokenArray* pArr2 )
 574 {
 575     //  verglichen wird nur das nicht-UPN Array
 576
 577     if ( pArr1 && pArr2 )
 578     {
 579         USHORT nLen = pArr1->GetLen();
 580         if ( pArr2->GetLen() != nLen )
 581             return FALSE;
 582
 583         FormulaToken** ppToken1 = pArr1->GetArray();
 584         FormulaToken** ppToken2 = pArr2->GetArray();
 585         for (USHORT i=0; i<nLen; i++)
 586         {
 587             if ( ppToken1[i] != ppToken2[i] &&
 588                  !(*ppToken1[i] == *ppToken2[i]) )
 589                 return FALSE;                                           // Unterschied
 590         }
 591         return TRUE;                                    // alle Eintraege gleich
 592     }
 593     else
 594         return !pArr1 && !pArr2;                // beide 0 -> gleich
 595 }
 596
 597 int ScConditionEntry::operator== ( const ScConditionEntry& r ) const
 598 {
 599     BOOL bEq = (eOp == r.eOp && nOptions == r.nOptions &&
 600                 lcl_IsEqual( pFormula1, r.pFormula1 ) &&
 601                 lcl_IsEqual( pFormula2, r.pFormula2 ));
 602     if (bEq)
 603     {
 604         // for formulas, the reference positions must be compared, too
 605         // (including aSrcString, for inserting the entries during XML import)
 606         if ( ( pFormula1 || pFormula2 ) && ( aSrcPos != r.aSrcPos || aSrcString != r.aSrcString ) )
 607             bEq = FALSE;
 608
 609         //      wenn keine Formeln, Werte vergleichen
 610         if ( !pFormula1 && ( nVal1 != r.nVal1 || aStrVal1 != r.aStrVal1 || bIsStr1 != r.bIsStr1 ) )
 611             bEq = FALSE;
 612         if ( !pFormula2 && ( nVal2 != r.nVal2 || aStrVal2 != r.aStrVal2 || bIsStr2 != r.bIsStr2 ) )
 613             bEq = FALSE;
 614     }
 615
 616     return bEq;
 617 }
 618
 619 void ScConditionEntry::Interpret( const ScAddress& rPos )
 620 {
 621     //  Formelzellen anlegen
 622     //  dabei koennen neue Broadcaster (Note-Zellen) ins Dokument eingefuegt werden !!!!
 623
 624     if ( ( pFormula1 && !pFCell1 ) || ( pFormula2 && !pFCell2 ) )
 625         MakeCells( rPos );
 626
 627     //  Formeln auswerten
 628
 629     BOOL bDirty = FALSE;                //! 1 und 2 getrennt ???
 630
 631     ScFormulaCell* pTemp1 = NULL;
 632     ScFormulaCell* pEff1 = pFCell1;
 633     if ( bRelRef1 )
 634     {
 635         pTemp1 = new ScFormulaCell( pDoc, rPos, pFormula1 );    // ohne Listening
 636         pEff1 = pTemp1;
 637     }
 638     if ( pEff1 )
 639     {
 640         if (!pEff1->IsRunning())                // keine 522 erzeugen
 641         {
 642             //! Changed statt Dirty abfragen !!!
 643             if (pEff1->GetDirty() && !bRelRef1)
 644                 bDirty = TRUE;
 645             if (pEff1->IsValue())
 646             {
 647                 bIsStr1 = FALSE;
 648                 nVal1 = pEff1->GetValue();
 649                 aStrVal1.Erase();
 650             }
 651             else
 652             {
 653                 bIsStr1 = TRUE;
 654                 pEff1->GetString( aStrVal1 );
 655                 nVal1 = 0.0;
 656             }
 657         }
 658     }
 659     delete pTemp1;
 660
 661     ScFormulaCell* pTemp2 = NULL;
 662     ScFormulaCell* pEff2 = pFCell2; //@ 1!=2
 663     if ( bRelRef2 )
 664     {
 665         pTemp2 = new ScFormulaCell( pDoc, rPos, pFormula2 );    // ohne Listening
 666         pEff2 = pTemp2;
 667     }
 668     if ( pEff2 )
 669     {
 670         if (!pEff2->IsRunning())                // keine 522 erzeugen
 671         {
 672             if (pEff2->GetDirty() && !bRelRef2)
 673                 bDirty = TRUE;
 674             if (pEff2->IsValue())
 675             {
 676                 bIsStr2 = FALSE;
 677                 nVal2 = pEff2->GetValue();
 678                 aStrVal2.Erase();
 679             }
 680             else
 681             {
 682                 bIsStr2 = TRUE;
 683                 pEff2->GetString( aStrVal2 );
 684                 nVal2 = 0.0;
 685             }
 686         }
 687     }
 688     delete pTemp2;
 689
 690     //  wenn IsRunning, bleiben die letzten Werte erhalten
 691
 692     if (bDirty && !bFirstRun)
 693     {
 694         //      bei bedingten Formaten neu painten
 695
 696         DataChanged( NULL );    // alles
 697     }
 698
 699     bFirstRun = FALSE;
 700 }
 701
 702 BOOL ScConditionEntry::IsValid( double nArg ) const
 703 {
 704     //  Interpret muss schon gerufen sein
 705
 706     if ( bIsStr1 )
 707     {
 708         // wenn auf String getestet wird, bei Zahlen immer FALSE, ausser bei "ungleich"
 709
 710         return ( eOp == SC_COND_NOTEQUAL );
 711     }
 712
 713     if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
 714         if ( bIsStr2 )
 715             return FALSE;
 716
 717     double nComp1 = nVal1;              // Kopie, damit vertauscht werden kann
 718     double nComp2 = nVal2;
 719
 720     if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
 721         if ( nComp1 > nComp2 )
 722         {
 723             //  richtige Reihenfolge fuer Wertebereich
 724             double nTemp = nComp1; nComp1 = nComp2; nComp2 = nTemp;
 725         }
 726
 727     //  Alle Grenzfaelle muessen per ::rtl::math::approxEqual getestet werden!
 728
 729     BOOL bValid = FALSE;
 730     switch (eOp)
 731     {
 732         case SC_COND_NONE:
 733             break;                                      // immer FALSE;
 734         case SC_COND_EQUAL:
 735             bValid = ::rtl::math::approxEqual( nArg, nComp1 );
 736             break;
 737         case SC_COND_NOTEQUAL:
 738             bValid = !::rtl::math::approxEqual( nArg, nComp1 );
 739             break;
 740         case SC_COND_GREATER:
 741             bValid = ( nArg > nComp1 ) && !::rtl::math::approxEqual( nArg, nComp1 );
 742             break;
 743         case SC_COND_EQGREATER:
 744             bValid = ( nArg >= nComp1 ) || ::rtl::math::approxEqual( nArg, nComp1 );
 745             break;
 746         case SC_COND_LESS:
 747             bValid = ( nArg < nComp1 ) && !::rtl::math::approxEqual( nArg, nComp1 );
 748             break;
 749         case SC_COND_EQLESS:
 750             bValid = ( nArg <= nComp1 ) || ::rtl::math::approxEqual( nArg, nComp1 );
 751             break;
 752         case SC_COND_BETWEEN:
 753             bValid = ( nArg >= nComp1 && nArg <= nComp2 ) ||
 754                      ::rtl::math::approxEqual( nArg, nComp1 ) || ::rtl::math::approxEqual( nArg, nComp2 );
 755             break;
 756         case SC_COND_NOTBETWEEN:
 757             bValid = ( nArg < nComp1 || nArg > nComp2 ) &&
 758                      !::rtl::math::approxEqual( nArg, nComp1 ) && !::rtl::math::approxEqual( nArg, nComp2 );
 759             break;
 760         case SC_COND_DIRECT:
 761             bValid = !::rtl::math::approxEqual( nComp1, 0.0 );
 762             break;
 763         default:
 764             DBG_ERROR("unbekannte Operation bei ScConditionEntry");
 765             break;
 766     }
 767     return bValid;
 768 }
 769
 770 BOOL ScConditionEntry::IsValidStr( const String& rArg ) const
 771 {
 772     //  Interpret muss schon gerufen sein
 773
 774     if ( eOp == SC_COND_DIRECT )                                // Formel ist unabhaengig vom Inhalt
 775         return !::rtl::math::approxEqual( nVal1, 0.0 );
 776
 777     //  Wenn Bedingung Zahl enthaelt, immer FALSE, ausser bei "ungleich"
 778
 779     if ( !bIsStr1 )
 780         return ( eOp == SC_COND_NOTEQUAL );
 781     if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
 782         if ( !bIsStr2 )
 783             return FALSE;
 784
 785     String aUpVal1( aStrVal1 );         //! als Member? (dann auch in Interpret setzen)
 786     String aUpVal2( aStrVal2 );
 787
 788     if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
 789         if ( ScGlobal::pCollator->compareString( aUpVal1, aUpVal2 )
 790                 == COMPARE_GREATER )
 791         {
 792             //  richtige Reihenfolge fuer Wertebereich
 793             String aTemp( aUpVal1 ); aUpVal1 = aUpVal2; aUpVal2 = aTemp;
 794         }
 795
 796     BOOL bValid;
 797     switch ( eOp )
 798     {
 799         case SC_COND_EQUAL:
 800             bValid = (ScGlobal::pCollator->compareString(
 801                 rArg, aUpVal1 ) == COMPARE_EQUAL);
 802         break;
 803         case SC_COND_NOTEQUAL:
 804             bValid = (ScGlobal::pCollator->compareString(
 805                 rArg, aUpVal1 ) != COMPARE_EQUAL);
 806         break;
 807         default:
 808         {
 809             sal_Int32 nCompare = ScGlobal::pCollator->compareString(
 810                 rArg, aUpVal1 );
 811             switch ( eOp )
 812             {
 813                 case SC_COND_GREATER:
 814                     bValid = ( nCompare == COMPARE_GREATER );
 815                     break;
 816                 case SC_COND_EQGREATER:
 817                     bValid = ( nCompare == COMPARE_EQUAL || nCompare == COMPARE_GREATER );
 818                     break;
 819                 case SC_COND_LESS:
 820                     bValid = ( nCompare == COMPARE_LESS );
 821                     break;
 822                 case SC_COND_EQLESS:
 823                     bValid = ( nCompare == COMPARE_EQUAL || nCompare == COMPARE_LESS );
 824                     break;
 825                 case SC_COND_BETWEEN:
 826                 case SC_COND_NOTBETWEEN:
 827                     //  Test auf NOTBETWEEN:
 828                     bValid = ( nCompare == COMPARE_LESS ||
 829                         ScGlobal::pCollator->compareString( rArg,
 830                         aUpVal2 ) == COMPARE_GREATER );
 831                     if ( eOp == SC_COND_BETWEEN )
 832                         bValid = !bValid;
 833                     break;
 834                 //      SC_COND_DIRECT schon oben abgefragt
 835                 default:
 836                     DBG_ERROR("unbekannte Operation bei ScConditionEntry");
 837                     bValid = FALSE;
 838                     break;
 839             }
 840         }
 841     }
 842     return bValid;
 843 }
 844
 845 BOOL ScConditionEntry::IsCellValid( ScBaseCell* pCell, const ScAddress& rPos ) const
 846 {
 847     ((ScConditionEntry*)this)->Interpret(rPos);                 // Formeln auswerten
 848
 849     double nArg = 0.0;
 850     String aArgStr;
 851     BOOL bVal = TRUE;
 852
 853     if ( pCell )
 854     {
 855         CellType eType = pCell->GetCellType();
 856         switch (eType)
 857         {
 858             case CELLTYPE_VALUE:
 859                 nArg = ((ScValueCell*)pCell)->GetValue();
 860                 break;
 861             case CELLTYPE_FORMULA:
 862                 {
 863                     ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
 864                     bVal = pFCell->IsValue();
 865                     if (bVal)
 866                         nArg = pFCell->GetValue();
 867                     else
 868                         pFCell->GetString(aArgStr);
 869                 }
 870                 break;
 871             case CELLTYPE_STRING:
 872             case CELLTYPE_EDIT:
 873                 bVal = FALSE;
 874                 if ( eType == CELLTYPE_STRING )
 875                     ((ScStringCell*)pCell)->GetString(aArgStr);
 876                 else
 877                     ((ScEditCell*)pCell)->GetString(aArgStr);
 878                 break;
 879
 880             default:
 881                 pCell = NULL;                   // Note-Zellen wie leere
 882                 break;
 883         }
 884     }
 885
 886     if (!pCell)
 887         if (bIsStr1)
 888             bVal = FALSE;                               // leere Zellen je nach Bedingung
 889
 890     if (bVal)
 891         return IsValid( nArg );
 892     else
 893         return IsValidStr( aArgStr );
 894 }
 895
 896 String ScConditionEntry::GetExpression( const ScAddress& rCursor, USHORT nIndex,
 897                                         ULONG nNumFmt,
 898                                         const FormulaGrammar::Grammar eGrammar ) const
 899 {
 900     String aRet;
 901
 902     if ( FormulaGrammar::isEnglish( eGrammar) && nNumFmt == 0 )
 903         nNumFmt = pDoc->GetFormatTable()->GetStandardIndex( LANGUAGE_ENGLISH_US );
 904
 905     if ( nIndex==0 )
 906     {
 907         if ( pFormula1 )
 908         {
 909             ScCompiler aComp(pDoc, rCursor, *pFormula1);
 910             aComp.SetGrammar(eGrammar);
 911             aComp.CreateStringFromTokenArray( aRet );
 912         }
 913         else if (bIsStr1)
 914         {
 915             aRet = '"';
 916             aRet += aStrVal1;
 917             aRet += '"';
 918         }
 919         else
 920             pDoc->GetFormatTable()->GetInputLineString(nVal1, nNumFmt, aRet);
 921     }
 922     else if ( nIndex==1 )
 923     {
 924         if ( pFormula2 )
 925         {
 926             ScCompiler aComp(pDoc, rCursor, *pFormula2);
 927             aComp.SetGrammar(eGrammar);
 928             aComp.CreateStringFromTokenArray( aRet );
 929         }
 930         else if (bIsStr2)
 931         {
 932             aRet = '"';
 933             aRet += aStrVal2;
 934             aRet += '"';
 935         }
 936         else
 937             pDoc->GetFormatTable()->GetInputLineString(nVal2, nNumFmt, aRet);
 938     }
 939     else
 940     {
 941         DBG_ERROR("GetExpression: falscher Index");
 942     }
 943
 944     return aRet;
 945 }
 946
 947 ScTokenArray* ScConditionEntry::CreateTokenArry( USHORT nIndex ) const
 948 {
 949     ScTokenArray* pRet = NULL;
 950     ScAddress aAddr;
 951
 952     if ( nIndex==0 )
 953     {
 954         if ( pFormula1 )
 955             pRet = new ScTokenArray( *pFormula1 );
 956         else
 957         {
 958             pRet = new ScTokenArray();
 959             if (bIsStr1)
 960                 pRet->AddString( aStrVal1.GetBuffer() );
 961             else
 962                 pRet->AddDouble( nVal1 );
 963         }
 964     }
 965     else if ( nIndex==1 )
 966     {
 967         if ( pFormula2 )
 968             pRet = new ScTokenArray( *pFormula2 );
 969         else
 970         {
 971             pRet = new ScTokenArray();
 972             if (bIsStr2)
 973                 pRet->AddString( aStrVal2.GetBuffer() );
 974             else
 975                 pRet->AddDouble( nVal2 );
 976         }
 977     }
 978     else
 979     {
 980         DBG_ERROR("GetExpression: falscher Index");
 981     }
 982
 983     return pRet;
 984 }
 985
 986 void ScConditionEntry::SourceChanged( const ScAddress& rChanged )
 987 {
 988     for (USHORT nPass = 0; nPass < 2; nPass++)
 989     {
 990         ScTokenArray* pFormula = nPass ? pFormula2 : pFormula1;
 991         if (pFormula)
 992         {
 993             pFormula->Reset();
 994             ScToken* t;
 995             while ( ( t = static_cast<ScToken*>(pFormula->GetNextReference()) ) != NULL )
 996             {
 997                 SingleDoubleRefProvider aProv( *t );
 998                 if ( aProv.Ref1.IsColRel() || aProv.Ref1.IsRowRel() || aProv.Ref1.IsTabRel() ||
 999                      aProv.Ref2.IsColRel() || aProv.Ref2.IsRowRel() || aProv.Ref2.IsTabRel() )
1000                 {
1001                     //  absolut muss getroffen sein, relativ bestimmt Bereich
1002
1003                     BOOL bHit = TRUE;
1004                     SCsCOL nCol1;
1005                     SCsROW nRow1;
1006                     SCsTAB nTab1;
1007                     SCsCOL nCol2;
1008                     SCsROW nRow2;
1009                     SCsTAB nTab2;
1010
1011                     if ( aProv.Ref1.IsColRel() )
1012                         nCol2 = rChanged.Col() - aProv.Ref1.nRelCol;
1013                     else
1014                     {
1015                         bHit &= ( rChanged.Col() >= aProv.Ref1.nCol );
1016                         nCol2 = MAXCOL;
1017                     }
1018                     if ( aProv.Ref1.IsRowRel() )
1019                         nRow2 = rChanged.Row() - aProv.Ref1.nRelRow;
1020                     else
1021                     {
1022                         bHit &= ( rChanged.Row() >= aProv.Ref1.nRow );
1023                         nRow2 = MAXROW;
1024                     }
1025                     if ( aProv.Ref1.IsTabRel() )
1026                         nTab2 = rChanged.Tab() - aProv.Ref1.nRelTab;
1027                     else
1028                     {
1029                         bHit &= ( rChanged.Tab() >= aProv.Ref1.nTab );
1030                         nTab2 = MAXTAB;
1031                     }
1032
1033                     if ( aProv.Ref2.IsColRel() )
1034                         nCol1 = rChanged.Col() - aProv.Ref2.nRelCol;
1035                     else
1036                     {
1037                         bHit &= ( rChanged.Col() <= aProv.Ref2.nCol );
1038                         nCol1 = 0;
1039                     }
1040                     if ( aProv.Ref2.IsRowRel() )
1041                         nRow1 = rChanged.Row() - aProv.Ref2.nRelRow;
1042                     else
1043                     {
1044                         bHit &= ( rChanged.Row() <= aProv.Ref2.nRow );
1045                         nRow1 = 0;
1046                     }
1047                     if ( aProv.Ref2.IsTabRel() )
1048                         nTab1 = rChanged.Tab() - aProv.Ref2.nRelTab;
1049                     else
1050                     {
1051                         bHit &= ( rChanged.Tab() <= aProv.Ref2.nTab );
1052                         nTab1 = 0;
1053                     }
1054
1055                     if ( bHit )
1056                     {
1057                         //!     begrenzen
1058
1059                         ScRange aPaint( nCol1,nRow1,nTab1, nCol2,nRow2,nTab2 );
1060
1061                         //      kein Paint, wenn es nur die Zelle selber ist
1062                         if ( aPaint.aStart != rChanged || aPaint.aEnd != rChanged )
1063                             DataChanged( &aPaint );
1064                     }
1065                 }
1066             }
1067         }
1068     }
1069 }
1070
1071 ScAddress ScConditionEntry::GetValidSrcPos() const
1072 {
1073     // return a position that's adjusted to allow textual representation of expressions if possible
1074
1075     SCTAB nMinTab = aSrcPos.Tab();
1076     SCTAB nMaxTab = nMinTab;
1077
1078     for (USHORT nPass = 0; nPass < 2; nPass++)
1079     {
1080         ScTokenArray* pFormula = nPass ? pFormula2 : pFormula1;
1081         if (pFormula)
1082         {
1083             pFormula->Reset();
1084             ScToken* t;
1085             while ( ( t = static_cast<ScToken*>(pFormula->GetNextReference()) ) != NULL )
1086             {
1087                 ScSingleRefData& rRef1 = t->GetSingleRef();
1088                 if ( rRef1.IsTabRel() && !rRef1.IsTabDeleted() )
1089                 {
1090                     if ( rRef1.nTab < nMinTab )
1091                         nMinTab = rRef1.nTab;
1092                     if ( rRef1.nTab > nMaxTab )
1093                         nMaxTab = rRef1.nTab;
1094                 }
1095                 if ( t->GetType() == svDoubleRef )
1096                 {
1097                     ScSingleRefData& rRef2 = t->GetDoubleRef().Ref2;
1098                     if ( rRef2.IsTabRel() && !rRef2.IsTabDeleted() )
1099                     {
1100                         if ( rRef2.nTab < nMinTab )
1101                             nMinTab = rRef2.nTab;
1102                         if ( rRef2.nTab > nMaxTab )
1103                             nMaxTab = rRef2.nTab;
1104                     }
1105                 }
1106             }
1107         }
1108     }
1109
1110     ScAddress aValidPos = aSrcPos;
1111     SCTAB nTabCount = pDoc->GetTableCount();
1112     if ( nMaxTab >= nTabCount && nMinTab > 0 )
1113         aValidPos.SetTab( aSrcPos.Tab() - nMinTab );    // so the lowest tab ref will be on 0
1114
1115     if ( aValidPos.Tab() >= nTabCount )
1116         aValidPos.SetTab( nTabCount - 1 );  // ensure a valid position even if some references will be invalid
1117
1118     return aValidPos;
1119 }
1120
1121 void ScConditionEntry::DataChanged( const ScRange* /* pModified */ ) const
1122 {
1123     // nix
1124 }
1125
1126 bool ScConditionEntry::MarkUsedExternalReferences() const
1127 {
1128     bool bAllMarked = false;
1129     for (USHORT nPass = 0; !bAllMarked && nPass < 2; nPass++)
1130     {
1131         ScTokenArray* pFormula = nPass ? pFormula2 : pFormula1;
1132         if (pFormula)
1133             bAllMarked = pDoc->MarkUsedExternalReferences( *pFormula);
1134     }
1135     return bAllMarked;
1136 }
1137
1138 //------------------------------------------------------------------------
1139
1140 ScCondFormatEntry::ScCondFormatEntry( ScConditionMode eOper,
1141                                         const String& rExpr1, const String& rExpr2,
1142                                         ScDocument* pDocument, const ScAddress& rPos,
1143                                         const String& rStyle,
1144                                         const String& rExprNmsp1, const String& rExprNmsp2,
1145                                         FormulaGrammar::Grammar eGrammar1,
1146                                         FormulaGrammar::Grammar eGrammar2 ) :
1147     ScConditionEntry( eOper, rExpr1, rExpr2, pDocument, rPos, rExprNmsp1, rExprNmsp2, eGrammar1, eGrammar2 ),
1148     aStyleName( rStyle ),
1149     pParent( NULL )
1150 {
1151 }
1152
1153 ScCondFormatEntry::ScCondFormatEntry( ScConditionMode eOper,
1154                                         const ScTokenArray* pArr1, const ScTokenArray* pArr2,
1155                                         ScDocument* pDocument, const ScAddress& rPos,
1156                                         const String& rStyle ) :
1157     ScConditionEntry( eOper, pArr1, pArr2, pDocument, rPos ),
1158     aStyleName( rStyle ),
1159     pParent( NULL )
1160 {
1161 }
1162
1163 ScCondFormatEntry::ScCondFormatEntry( const ScCondFormatEntry& r ) :
1164     ScConditionEntry( r ),
1165     aStyleName( r.aStyleName ),
1166     pParent( NULL )
1167 {
1168 }
1169
1170 ScCondFormatEntry::ScCondFormatEntry( ScDocument* pDocument, const ScCondFormatEntry& r ) :
1171     ScConditionEntry( pDocument, r ),
1172     aStyleName( r.aStyleName ),
1173     pParent( NULL )
1174 {
1175 }
1176
1177 int ScCondFormatEntry::operator== ( const ScCondFormatEntry& r ) const
1178 {
1179     return ScConditionEntry::operator==( r ) &&
1180             aStyleName == r.aStyleName;
1181
1182     //  Range wird nicht verglichen
1183 }
1184
1185 ScCondFormatEntry::~ScCondFormatEntry()
1186 {
1187 }
1188
1189 void ScCondFormatEntry::DataChanged( const ScRange* pModified ) const
1190 {
1191     if ( pParent )
1192         pParent->DoRepaint( pModified );
1193 }
1194
1195 //------------------------------------------------------------------------
1196
1197 ScConditionalFormat::ScConditionalFormat(sal_uInt32 nNewKey, ScDocument* pDocument) :
1198     pDoc( pDocument ),
1199     pAreas( NULL ),
1200     nKey( nNewKey ),
1201     ppEntries( NULL ),
1202     nEntryCount( 0 )
1203 {
1204 }
1205
1206 ScConditionalFormat::ScConditionalFormat(const ScConditionalFormat& r) :
1207     pDoc( r.pDoc ),
1208     pAreas( NULL ),
1209     nKey( r.nKey ),
1210     ppEntries( NULL ),
1211     nEntryCount( r.nEntryCount )
1212 {
1213     if (nEntryCount)
1214     {
1215         ppEntries = new ScCondFormatEntry*[nEntryCount];
1216         for (USHORT i=0; i<nEntryCount; i++)
1217         {
1218             ppEntries[i] = new ScCondFormatEntry(*r.ppEntries[i]);
1219             ppEntries[i]->SetParent(this);
1220         }
1221     }
1222 }
1223
1224 ScConditionalFormat* ScConditionalFormat::Clone(ScDocument* pNewDoc) const
1225 {
1226     // echte Kopie der Formeln (fuer Ref-Undo / zwischen Dokumenten)
1227
1228     if (!pNewDoc)
1229         pNewDoc = pDoc;
1230
1231     ScConditionalFormat* pNew = new ScConditionalFormat(nKey, pNewDoc);
1232     DBG_ASSERT(!pNew->ppEntries, "wo kommen die Eintraege her?");
1233
1234     if (nEntryCount)
1235     {
1236         pNew->ppEntries = new ScCondFormatEntry*[nEntryCount];
1237         for (USHORT i=0; i<nEntryCount; i++)
1238         {
1239             pNew->ppEntries[i] = new ScCondFormatEntry( pNewDoc, *ppEntries[i] );
1240             pNew->ppEntries[i]->SetParent(pNew);
1241         }
1242         pNew->nEntryCount = nEntryCount;
1243     }
1244
1245     return pNew;
1246 }
1247
1248 BOOL ScConditionalFormat::EqualEntries( const ScConditionalFormat& r ) const
1249 {
1250     if ( nEntryCount != r.nEntryCount )
1251         return FALSE;
1252
1253     //! auf gleiche Eintraege in anderer Reihenfolge testen ???
1254
1255     for (USHORT i=0; i<nEntryCount; i++)
1256         if ( ! (*ppEntries[i] == *r.ppEntries[i]) )
1257             return FALSE;
1258
1259     return TRUE;
1260 }
1261
1262 void ScConditionalFormat::AddEntry( const ScCondFormatEntry& rNew )
1263 {
1264     ScCondFormatEntry** ppNew = new ScCondFormatEntry*[nEntryCount+1];
1265     for (USHORT i=0; i<nEntryCount; i++)
1266         ppNew[i] = ppEntries[i];
1267     ppNew[nEntryCount] = new ScCondFormatEntry(rNew);
1268     ppNew[nEntryCount]->SetParent(this);
1269     ++nEntryCount;
1270     delete[] ppEntries;
1271     ppEntries = ppNew;
1272 }
1273
1274 ScConditionalFormat::~ScConditionalFormat()
1275 {
1276     for (USHORT i=0; i<nEntryCount; i++)
1277         delete ppEntries[i];
1278     delete[] ppEntries;
1279
1280     delete pAreas;
1281 }
1282
1283 const ScCondFormatEntry* ScConditionalFormat::GetEntry( USHORT nPos ) const
1284 {
1285     if ( nPos < nEntryCount )
1286         return ppEntries[nPos];
1287     else
1288         return NULL;
1289 }
1290
1291 const String& ScConditionalFormat::GetCellStyle( ScBaseCell* pCell, const ScAddress& rPos ) const
1292 {
1293     for (USHORT i=0; i<nEntryCount; i++)
1294         if ( ppEntries[i]->IsCellValid( pCell, rPos ) )
1295             return ppEntries[i]->GetStyle();
1296
1297     return EMPTY_STRING;
1298 }
1299
1300 void lcl_Extend( ScRange& rRange, ScDocument* pDoc, BOOL bLines )
1301 {
1302     SCTAB nTab = rRange.aStart.Tab();
1303     DBG_ASSERT(rRange.aEnd.Tab() == nTab, "lcl_Extend - mehrere Tabellen?");
1304
1305     SCCOL nStartCol = rRange.aStart.Col();
1306     SCROW nStartRow = rRange.aStart.Row();
1307     SCCOL nEndCol = rRange.aEnd.Col();
1308     SCROW nEndRow = rRange.aEnd.Row();
1309
1310     BOOL bEx = pDoc->ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow, nTab );
1311
1312     if (bLines)
1313     {
1314         if (nStartCol > 0)        --nStartCol;
1315         if (nStartRow > 0)        --nStartRow;
1316         if (nEndCol < MAXCOL) ++nEndCol;
1317         if (nEndRow < MAXROW) ++nEndRow;
1318     }
1319
1320     if ( bEx || bLines )
1321     {
1322         rRange.aStart.Set( nStartCol, nStartRow, nTab );
1323         rRange.aEnd.Set( nEndCol, nEndRow, nTab );
1324     }
1325 }
1326
1327 BOOL lcl_CutRange( ScRange& rRange, const ScRange& rOther )
1328 {
1329     rRange.Justify();
1330     ScRange aCmpRange = rOther;
1331     aCmpRange.Justify();
1332
1333     if ( rRange.aStart.Col() <= aCmpRange.aEnd.Col() &&
1334          rRange.aEnd.Col() >= aCmpRange.aStart.Col() &&
1335          rRange.aStart.Row() <= aCmpRange.aEnd.Row() &&
1336          rRange.aEnd.Row() >= aCmpRange.aStart.Row() &&
1337          rRange.aStart.Tab() <= aCmpRange.aEnd.Tab() &&
1338          rRange.aEnd.Tab() >= aCmpRange.aStart.Tab() )
1339     {
1340         if ( rRange.aStart.Col() < aCmpRange.aStart.Col() )
1341             rRange.aStart.SetCol( aCmpRange.aStart.Col() );
1342         if ( rRange.aStart.Row() < aCmpRange.aStart.Row() )
1343             rRange.aStart.SetRow( aCmpRange.aStart.Row() );
1344         if ( rRange.aStart.Tab() < aCmpRange.aStart.Tab() )
1345             rRange.aStart.SetTab( aCmpRange.aStart.Tab() );
1346         if ( rRange.aEnd.Col() > aCmpRange.aEnd.Col() )
1347             rRange.aEnd.SetCol( aCmpRange.aEnd.Col() );
1348         if ( rRange.aEnd.Row() > aCmpRange.aEnd.Row() )
1349             rRange.aEnd.SetRow( aCmpRange.aEnd.Row() );
1350         if ( rRange.aEnd.Tab() > aCmpRange.aEnd.Tab() )
1351             rRange.aEnd.SetTab( aCmpRange.aEnd.Tab() );
1352
1353         return TRUE;
1354     }
1355
1356     return FALSE;               // ausserhalb
1357 }
1358
1359 void ScConditionalFormat::DoRepaint( const ScRange* pModified )
1360 {
1361     USHORT i;
1362     SfxObjectShell* pSh = pDoc->GetDocumentShell();
1363     if (pSh)
1364     {
1365         //      Rahmen/Schatten enthalten?
1366         //      (alle Bedingungen testen)
1367         BOOL bExtend = FALSE;
1368         BOOL bRotate = FALSE;
1369         BOOL bAttrTested = FALSE;
1370
1371         if (!pAreas)            //      RangeList ggf. holen
1372         {
1373             pAreas = new ScRangeList;
1374             pDoc->FindConditionalFormat( nKey, *pAreas );
1375         }
1376         USHORT nCount = (USHORT) pAreas->Count();
1377         for (i=0; i<nCount; i++)
1378         {
1379             ScRange aRange = *pAreas->GetObject(i);
1380             BOOL bDo = TRUE;
1381             if ( pModified )
1382             {
1383                 if ( !lcl_CutRange( aRange, *pModified ) )
1384                     bDo = FALSE;
1385             }
1386             if (bDo)
1387             {
1388                 if ( !bAttrTested )
1389                 {
1390                     // #116562# Look at the style's content only if the repaint is necessary
1391                     // for any condition, to avoid the time-consuming Find() if there are many
1392                     // conditional formats and styles.
1393                     for (USHORT nEntry=0; nEntry<nEntryCount; nEntry++)
1394                     {
1395                         String aStyle = ppEntries[nEntry]->GetStyle();
1396                         if (aStyle.Len())
1397                         {
1398                             SfxStyleSheetBase* pStyleSheet =
1399                                 pDoc->GetStyleSheetPool()->Find( aStyle, SFX_STYLE_FAMILY_PARA );
1400                             if ( pStyleSheet )
1401                             {
1402                                 const SfxItemSet& rSet = pStyleSheet->GetItemSet();
1403                                 if (rSet.GetItemState( ATTR_BORDER, TRUE ) == SFX_ITEM_SET ||
1404                                     rSet.GetItemState( ATTR_SHADOW, TRUE ) == SFX_ITEM_SET)
1405                                 {
1406                                     bExtend = TRUE;
1407                                 }
1408                                 if (rSet.GetItemState( ATTR_ROTATE_VALUE, TRUE ) == SFX_ITEM_SET ||
1409                                     rSet.GetItemState( ATTR_ROTATE_MODE, TRUE ) == SFX_ITEM_SET)
1410                                 {
1411                                     bRotate = TRUE;
1412                                 }
1413                             }
1414                         }
1415                     }
1416                     bAttrTested = TRUE;
1417                 }
1418
1419                 lcl_Extend( aRange, pDoc, bExtend );            // zusammengefasste und bExtend
1420                 if ( bRotate )
1421                 {
1422                     aRange.aStart.SetCol(0);
1423                     aRange.aEnd.SetCol(MAXCOL);         // gedreht: ganze Zeilen
1424                 }
1425
1426                 // gedreht -> ganze Zeilen
1427                 if ( aRange.aStart.Col() != 0 || aRange.aEnd.Col() != MAXCOL )
1428                 {
1429                     if ( pDoc->HasAttrib( 0,aRange.aStart.Row(),aRange.aStart.Tab(),
1430                                             MAXCOL,aRange.aEnd.Row(),aRange.aEnd.Tab(),
1431                                             HASATTR_ROTATE ) )
1432                     {
1433                         aRange.aStart.SetCol(0);
1434                         aRange.aEnd.SetCol(MAXCOL);
1435                     }
1436                 }
1437
1438                 pSh->Broadcast( ScPaintHint( aRange, PAINT_GRID ) );
1439             }
1440         }
1441     }
1442 }
1443
1444 void ScConditionalFormat::InvalidateArea()
1445 {
1446     delete pAreas;
1447     pAreas = NULL;
1448 }
1449
1450 void ScConditionalFormat::CompileAll()
1451 {
1452     for (USHORT i=0; i<nEntryCount; i++)
1453         ppEntries[i]->CompileAll();
1454 }
1455
1456 void ScConditionalFormat::CompileXML()
1457 {
1458     for (USHORT i=0; i<nEntryCount; i++)
1459         ppEntries[i]->CompileXML();
1460 }
1461
1462 void ScConditionalFormat::UpdateReference( UpdateRefMode eUpdateRefMode,
1463                                 const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
1464 {
1465     for (USHORT i=0; i<nEntryCount; i++)
1466         ppEntries[i]->UpdateReference(eUpdateRefMode, rRange, nDx, nDy, nDz);
1467
1468     delete pAreas;              // aus dem AttrArray kommt beim Einfuegen/Loeschen kein Aufruf
1469     pAreas = NULL;
1470 }
1471
1472 void ScConditionalFormat::RenameCellStyle(const String& rOld, const String& rNew)
1473 {
1474     for (USHORT i=0; i<nEntryCount; i++)
1475         if ( ppEntries[i]->GetStyle() == rOld )
1476             ppEntries[i]->UpdateStyleName( rNew );
1477 }
1478
1479 void ScConditionalFormat::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos )
1480 {
1481     for (USHORT i=0; i<nEntryCount; i++)
1482         ppEntries[i]->UpdateMoveTab( nOldPos, nNewPos );
1483
1484     delete pAreas;              // aus dem AttrArray kommt beim Einfuegen/Loeschen kein Aufruf
1485     pAreas = NULL;
1486 }
1487
1488 void ScConditionalFormat::SourceChanged( const ScAddress& rAddr )
1489 {
1490     for (USHORT i=0; i<nEntryCount; i++)
1491         ppEntries[i]->SourceChanged( rAddr );
1492 }
1493
1494 bool ScConditionalFormat::MarkUsedExternalReferences() const
1495 {
1496     bool bAllMarked = false;
1497     for (USHORT i=0; !bAllMarked && i<nEntryCount; i++)
1498         bAllMarked = ppEntries[i]->MarkUsedExternalReferences();
1499     return bAllMarked;
1500 }
1501
1502 //------------------------------------------------------------------------
1503
1504 ScConditionalFormatList::ScConditionalFormatList(const ScConditionalFormatList& rList) :
1505     ScConditionalFormats_Impl()
1506 {
1507     //  fuer Ref-Undo - echte Kopie mit neuen Tokens!
1508
1509     USHORT nCount = rList.Count();
1510
1511     for (USHORT i=0; i<nCount; i++)
1512         InsertNew( rList[i]->Clone() );
1513
1514     //!         sortierte Eintraege aus rList schneller einfuegen ???
1515 }
1516
1517 ScConditionalFormatList::ScConditionalFormatList(ScDocument* pNewDoc,
1518                                                 const ScConditionalFormatList& rList)
1519 {
1520     //  fuer neues Dokument - echte Kopie mit neuen Tokens!
1521
1522     USHORT nCount = rList.Count();
1523
1524     for (USHORT i=0; i<nCount; i++)
1525         InsertNew( rList[i]->Clone(pNewDoc) );
1526
1527     //!         sortierte Eintraege aus rList schneller einfuegen ???
1528 }
1529
1530 BOOL ScConditionalFormatList::operator==( const ScConditionalFormatList& r ) const
1531 {
1532     // fuer Ref-Undo - interne Variablen werden nicht verglichen
1533
1534     USHORT nCount = Count();
1535     BOOL bEqual = ( nCount == r.Count() );
1536     for (USHORT i=0; i<nCount && bEqual; i++)                   // Eintraege sind sortiert
1537         if ( !(*this)[i]->EqualEntries(*r[i]) )                 // Eintraege unterschiedlich ?
1538             bEqual = FALSE;
1539
1540     return bEqual;
1541 }
1542
1543 ScConditionalFormat* ScConditionalFormatList::GetFormat( sal_uInt32 nKey )
1544 {
1545     //! binaer suchen
1546
1547     USHORT nCount = Count();
1548     for (USHORT i=0; i<nCount; i++)
1549         if ((*this)[i]->GetKey() == nKey)
1550             return (*this)[i];
1551
1552     DBG_ERROR("ScConditionalFormatList: Eintrag nicht gefunden");
1553     return NULL;
1554 }
1555
1556 void ScConditionalFormatList::CompileAll()
1557 {
1558     USHORT nCount = Count();
1559     for (USHORT i=0; i<nCount; i++)
1560         (*this)[i]->CompileAll();
1561 }
1562
1563 void ScConditionalFormatList::CompileXML()
1564 {
1565     USHORT nCount = Count();
1566     for (USHORT i=0; i<nCount; i++)
1567         (*this)[i]->CompileXML();
1568 }
1569
1570 void ScConditionalFormatList::UpdateReference( UpdateRefMode eUpdateRefMode,
1571                                 const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
1572 {
1573     USHORT nCount = Count();
1574     for (USHORT i=0; i<nCount; i++)
1575         (*this)[i]->UpdateReference( eUpdateRefMode, rRange, nDx, nDy, nDz );
1576 }
1577
1578 void ScConditionalFormatList::RenameCellStyle( const String& rOld, const String& rNew )
1579 {
1580     ULONG nCount=Count();
1581     for (USHORT i=0; i<nCount; i++)
1582         (*this)[i]->RenameCellStyle(rOld,rNew);
1583 }
1584
1585 void ScConditionalFormatList::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos )
1586 {
1587     USHORT nCount = Count();
1588     for (USHORT i=0; i<nCount; i++)
1589         (*this)[i]->UpdateMoveTab( nOldPos, nNewPos );
1590 }
1591
1592 void ScConditionalFormatList::SourceChanged( const ScAddress& rAddr )
1593 {
1594     USHORT nCount = Count();
1595     for (USHORT i=0; i<nCount; i++)
1596         (*this)[i]->SourceChanged( rAddr );
1597 }
1598
1599 bool ScConditionalFormatList::MarkUsedExternalReferences() const
1600 {
1601     bool bAllMarked = false;
1602     USHORT nCount = Count();
1603     for (USHORT i=0; !bAllMarked && i<nCount; i++)
1604         bAllMarked = (*this)[i]->MarkUsedExternalReferences();
1605     return bAllMarked;
1606 }