xref: /aoo41x/main/sc/source/core/data/conditio.cxx (revision 6dfe295f)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sc.hxx"



//------------------------------------------------------------------

#include "scitems.hxx"
#include <sfx2/objsh.hxx>
#include <svl/itemset.hxx>
#include <svl/zforlist.hxx>
#include <rtl/math.hxx>
#include <unotools/collatorwrapper.hxx>

#include "conditio.hxx"
#include "cell.hxx"
#include "document.hxx"
#include "hints.hxx"
#include "compiler.hxx"
#include "rechead.hxx"
#include "rangelst.hxx"
#include "stlpool.hxx"
#include "rangenam.hxx"

using namespace formula;
//------------------------------------------------------------------------

SV_IMPL_OP_PTRARR_SORT( ScConditionalFormats_Impl, ScConditionalFormatPtr );

//------------------------------------------------------------------------

sal_Bool lcl_HasRelRef( ScDocument* pDoc, ScTokenArray* pFormula, sal_uInt16 nRecursion = 0 )
{
	if (pFormula)
	{
		pFormula->Reset();
		FormulaToken* t;
        for( t = pFormula->Next(); t; t = pFormula->Next() )
		{
            switch( t->GetType() )
            {
                case svDoubleRef:
                {
                    ScSingleRefData& rRef2 = static_cast<ScToken*>(t)->GetDoubleRef().Ref2;
                    if ( rRef2.IsColRel() || rRef2.IsRowRel() || rRef2.IsTabRel() )
                        return sal_True;
                }
                // fall through

                case svSingleRef:
                {
                    ScSingleRefData& rRef1 = static_cast<ScToken*>(t)->GetSingleRef();
                    if ( rRef1.IsColRel() || rRef1.IsRowRel() || rRef1.IsTabRel() )
                        return sal_True;
                }
                break;

                case svIndex:
                {
                    if( t->GetOpCode() == ocName )      // DB areas always absolute
                        if( ScRangeData* pRangeData = pDoc->GetRangeName()->FindIndex( t->GetIndex() ) )
                            if( (nRecursion < 42) && lcl_HasRelRef( pDoc, pRangeData->GetCode(), nRecursion + 1 ) )
                                return sal_True;
                }
                break;

                // #i34474# function result dependent on cell position
                case svByte:
                {
                    switch( t->GetOpCode() )
                    {
                        case ocRow:     // ROW() returns own row index
                        case ocColumn:  // COLUMN() returns own column index
                        case ocTable:   // SHEET() returns own sheet index
                        case ocCell:    // CELL() may return own cell address
                            return sal_True;
//                        break;
                        default:
                        {
                            // added to avoid warnings
                        }
                    }
                }
                break;

                default:
                {
                    // added to avoid warnings
                }
            }
		}
	}
	return sal_False;
}

ScConditionEntry::ScConditionEntry( const ScConditionEntry& r ) :
	eOp(r.eOp),
	nOptions(r.nOptions),
	nVal1(r.nVal1),
	nVal2(r.nVal2),
	aStrVal1(r.aStrVal1),
	aStrVal2(r.aStrVal2),
    aStrNmsp1(r.aStrNmsp1),
    aStrNmsp2(r.aStrNmsp2),
    eTempGrammar1(r.eTempGrammar1),
    eTempGrammar2(r.eTempGrammar2),
	bIsStr1(r.bIsStr1),
	bIsStr2(r.bIsStr2),
	pFormula1(NULL),
	pFormula2(NULL),
	aSrcPos(r.aSrcPos),
    aSrcString(r.aSrcString),
	pFCell1(NULL),
	pFCell2(NULL),
	pDoc(r.pDoc),
	bRelRef1(r.bRelRef1),
	bRelRef2(r.bRelRef2),
	bFirstRun(sal_True)
{
	//	ScTokenArray copy ctor erzeugt flache Kopie

	if (r.pFormula1)
		pFormula1 = new ScTokenArray( *r.pFormula1 );
	if (r.pFormula2)
		pFormula2 = new ScTokenArray( *r.pFormula2 );

	//	Formelzellen werden erst bei IsValid angelegt
}

ScConditionEntry::ScConditionEntry( ScDocument* pDocument, const ScConditionEntry& r ) :
	eOp(r.eOp),
	nOptions(r.nOptions),
	nVal1(r.nVal1),
	nVal2(r.nVal2),
	aStrVal1(r.aStrVal1),
	aStrVal2(r.aStrVal2),
    aStrNmsp1(r.aStrNmsp1),
    aStrNmsp2(r.aStrNmsp2),
    eTempGrammar1(r.eTempGrammar1),
    eTempGrammar2(r.eTempGrammar2),
	bIsStr1(r.bIsStr1),
	bIsStr2(r.bIsStr2),
	pFormula1(NULL),
	pFormula2(NULL),
	aSrcPos(r.aSrcPos),
    aSrcString(r.aSrcString),
	pFCell1(NULL),
	pFCell2(NULL),
	pDoc(pDocument),
	bRelRef1(r.bRelRef1),
	bRelRef2(r.bRelRef2),
	bFirstRun(sal_True)
{
	// echte Kopie der Formeln (fuer Ref-Undo)

	if (r.pFormula1)
		pFormula1 = r.pFormula1->Clone();
	if (r.pFormula2)
		pFormula2 = r.pFormula2->Clone();

	//	Formelzellen werden erst bei IsValid angelegt
	//!	im Clipboard nicht - dann vorher interpretieren !!!
}

ScConditionEntry::ScConditionEntry( ScConditionMode eOper,
        const String& rExpr1, const String& rExpr2, ScDocument* pDocument, const ScAddress& rPos,
        const String& rExprNmsp1, const String& rExprNmsp2,
        FormulaGrammar::Grammar eGrammar1, FormulaGrammar::Grammar eGrammar2 ) :
	eOp(eOper),
	nOptions(0),	// spaeter...
	nVal1(0.0),
	nVal2(0.0),
    aStrNmsp1(rExprNmsp1),
    aStrNmsp2(rExprNmsp2),
    eTempGrammar1(eGrammar1),
    eTempGrammar2(eGrammar2),
	bIsStr1(sal_False),
	bIsStr2(sal_False),
	pFormula1(NULL),
	pFormula2(NULL),
	aSrcPos(rPos),
	pFCell1(NULL),
	pFCell2(NULL),
	pDoc(pDocument),
	bRelRef1(sal_False),
	bRelRef2(sal_False),
	bFirstRun(sal_True)
{
    Compile( rExpr1, rExpr2, rExprNmsp1, rExprNmsp2, eGrammar1, eGrammar2, sal_False );

	//	Formelzellen werden erst bei IsValid angelegt
}

ScConditionEntry::ScConditionEntry( ScConditionMode eOper,
								const ScTokenArray* pArr1, const ScTokenArray* pArr2,
								ScDocument* pDocument, const ScAddress& rPos ) :
	eOp(eOper),
	nOptions(0),	// spaeter...
	nVal1(0.0),
	nVal2(0.0),
    eTempGrammar1(FormulaGrammar::GRAM_DEFAULT),
    eTempGrammar2(FormulaGrammar::GRAM_DEFAULT),
	bIsStr1(sal_False),
	bIsStr2(sal_False),
	pFormula1(NULL),
	pFormula2(NULL),
	aSrcPos(rPos),
	pFCell1(NULL),
	pFCell2(NULL),
	pDoc(pDocument),
	bRelRef1(sal_False),
	bRelRef2(sal_False),
	bFirstRun(sal_True)
{
	if ( pArr1 )
	{
		pFormula1 = new ScTokenArray( *pArr1 );
		if ( pFormula1->GetLen() == 1 )
		{
			// einzelne (konstante Zahl) ?
			FormulaToken* pToken = pFormula1->First();
			if ( pToken->GetOpCode() == ocPush )
			{
				if ( pToken->GetType() == svDouble )
				{
					nVal1 = pToken->GetDouble();
					DELETEZ(pFormula1);				// nicht als Formel merken
				}
				else if ( pToken->GetType() == svString )
				{
					bIsStr1 = sal_True;
					aStrVal1 = pToken->GetString();
					DELETEZ(pFormula1);				// nicht als Formel merken
				}
			}
		}
		bRelRef1 = lcl_HasRelRef( pDoc, pFormula1 );
	}
	if ( pArr2 )
	{
		pFormula2 = new ScTokenArray( *pArr2 );
		if ( pFormula2->GetLen() == 1 )
		{
			// einzelne (konstante Zahl) ?
			FormulaToken* pToken = pFormula2->First();
			if ( pToken->GetOpCode() == ocPush )
			{
				if ( pToken->GetType() == svDouble )
				{
					nVal2 = pToken->GetDouble();
					DELETEZ(pFormula2);				// nicht als Formel merken
				}
				else if ( pToken->GetType() == svString )
				{
					bIsStr2 = sal_True;
					aStrVal2 = pToken->GetString();
					DELETEZ(pFormula2);				// nicht als Formel merken
				}
			}
		}
		bRelRef2 = lcl_HasRelRef( pDoc, pFormula2 );
	}

	//	formula cells are created at IsValid
}

ScConditionEntry::~ScConditionEntry()
{
	delete pFCell1;
	delete pFCell2;

	delete pFormula1;
	delete pFormula2;
}

void ScConditionEntry::Compile( const String& rExpr1, const String& rExpr2,
        const String& rExprNmsp1, const String& rExprNmsp2,
        FormulaGrammar::Grammar eGrammar1, FormulaGrammar::Grammar eGrammar2, sal_Bool bTextToReal )
{
	if ( rExpr1.Len() || rExpr2.Len() )
	{
		ScCompiler aComp( pDoc, aSrcPos );

		if ( rExpr1.Len() )
		{
            aComp.SetGrammar( eGrammar1 );
			if ( pDoc->IsImportingXML() && !bTextToReal )
			{
				//	temporary formula string as string tokens
				//!	merge with lcl_ScDocFunc_CreateTokenArrayXML
				pFormula1 = new ScTokenArray;
				pFormula1->AddString( rExpr1 );
				// bRelRef1 is set when the formula is compiled again (CompileXML)
			}
			else
			{
                pFormula1 = aComp.CompileString( rExpr1, rExprNmsp1 );
				if ( pFormula1->GetLen() == 1 )
				{
					// einzelne (konstante Zahl) ?
					FormulaToken* pToken = pFormula1->First();
					if ( pToken->GetOpCode() == ocPush )
					{
						if ( pToken->GetType() == svDouble )
						{
							nVal1 = pToken->GetDouble();
							DELETEZ(pFormula1);				// nicht als Formel merken
						}
						else if ( pToken->GetType() == svString )
						{
							bIsStr1 = sal_True;
							aStrVal1 = pToken->GetString();
							DELETEZ(pFormula1);				// nicht als Formel merken
						}
					}
				}
				bRelRef1 = lcl_HasRelRef( pDoc, pFormula1 );
			}
		}

		if ( rExpr2.Len() )
		{
            aComp.SetGrammar( eGrammar2 );
			if ( pDoc->IsImportingXML() && !bTextToReal )
			{
				//	temporary formula string as string tokens
				//!	merge with lcl_ScDocFunc_CreateTokenArrayXML
				pFormula2 = new ScTokenArray;
				pFormula2->AddString( rExpr2 );
				// bRelRef2 is set when the formula is compiled again (CompileXML)
			}
			else
			{
                pFormula2 = aComp.CompileString( rExpr2, rExprNmsp2 );
				if ( pFormula2->GetLen() == 1 )
				{
					// einzelne (konstante Zahl) ?
					FormulaToken* pToken = pFormula2->First();
					if ( pToken->GetOpCode() == ocPush )
					{
						if ( pToken->GetType() == svDouble )
						{
							nVal2 = pToken->GetDouble();
							DELETEZ(pFormula2);				// nicht als Formel merken
						}
						else if ( pToken->GetType() == svString )
						{
							bIsStr2 = sal_True;
							aStrVal2 = pToken->GetString();
							DELETEZ(pFormula2);				// nicht als Formel merken
						}
					}
				}
				bRelRef2 = lcl_HasRelRef( pDoc, pFormula2 );
			}
		}
	}
}

void ScConditionEntry::MakeCells( const ScAddress& rPos )			// Formelzellen anlegen
{
	if ( !pDoc->IsClipOrUndo() )			// nie im Clipboard rechnen!
	{
		if ( pFormula1 && !pFCell1 && !bRelRef1 )
		{
			pFCell1 = new ScFormulaCell( pDoc, rPos, pFormula1 );
			pFCell1->StartListeningTo( pDoc );
		}

		if ( pFormula2 && !pFCell2 && !bRelRef2 )
		{
			pFCell2 = new ScFormulaCell( pDoc, rPos, pFormula2 );
			pFCell2->StartListeningTo( pDoc );
		}
	}
}

void ScConditionEntry::SetIgnoreBlank(sal_Bool bSet)
{
	//	Das Bit SC_COND_NOBLANKS wird gesetzt, wenn Blanks nicht ignoriert werden
	//	(nur bei Gueltigkeit)

	if (bSet)
		nOptions &= ~SC_COND_NOBLANKS;
	else
		nOptions |= SC_COND_NOBLANKS;
}

void ScConditionEntry::CompileAll()
{
	//	Formelzellen loeschen, dann wird beim naechsten IsValid neu kompiliert

	DELETEZ(pFCell1);
	DELETEZ(pFCell2);
}

void ScConditionEntry::CompileXML()
{
    //  #b4974740# First parse the formula source position if it was stored as text

    if ( aSrcString.Len() )
    {
        ScAddress aNew;
		/* XML is always in OOo:A1 format, although R1C1 would be more amenable
		 * to compression */
        if ( aNew.Parse( aSrcString, pDoc ) & SCA_VALID )
            aSrcPos = aNew;
        // if the position is invalid, there isn't much we can do at this time
        aSrcString.Erase();
    }

	//	Convert the text tokens that were created during XML import into real tokens.

    Compile( GetExpression(aSrcPos, 0, 0, eTempGrammar1),
             GetExpression(aSrcPos, 1, 0, eTempGrammar2),
             aStrNmsp1, aStrNmsp2, eTempGrammar1, eTempGrammar2, sal_True );
}

void ScConditionEntry::SetSrcString( const String& rNew )
{
    // aSrcString is only evaluated in CompileXML
    DBG_ASSERT( pDoc->IsImportingXML(), "SetSrcString is only valid for XML import" );

    aSrcString = rNew;
}

void ScConditionEntry::SetFormula1( const ScTokenArray& rArray )
{
    DELETEZ( pFormula1 );
    if( rArray.GetLen() > 0 )
    {
        pFormula1 = new ScTokenArray( rArray );
        bRelRef1 = lcl_HasRelRef( pDoc, pFormula1 );
    }
}

void ScConditionEntry::SetFormula2( const ScTokenArray& rArray )
{
    DELETEZ( pFormula2 );
    if( rArray.GetLen() > 0 )
    {
        pFormula2 = new ScTokenArray( rArray );
        bRelRef2 = lcl_HasRelRef( pDoc, pFormula2 );
    }
}

void lcl_CondUpdateInsertTab( ScTokenArray& rCode, SCTAB nInsTab, SCTAB nPosTab, sal_Bool& rChanged )
{
    //  Insert table: only update absolute table references.
    //  (Similar to ScCompiler::UpdateInsertTab with bIsName=sal_True, result is the same as for named ranges)
    //  For deleting, ScCompiler::UpdateDeleteTab is used because of the handling of invalid references.

    rCode.Reset();
    ScToken* p = static_cast<ScToken*>(rCode.GetNextReference());
    while( p )
    {
        ScSingleRefData& rRef1 = p->GetSingleRef();
        if ( !rRef1.IsTabRel() && nInsTab <= rRef1.nTab )
        {
            rRef1.nTab += 1;
            rRef1.nRelTab = rRef1.nTab - nPosTab;
            rChanged = sal_True;
        }
        if( p->GetType() == svDoubleRef )
        {
            ScSingleRefData& rRef2 = p->GetDoubleRef().Ref2;
            if ( !rRef2.IsTabRel() && nInsTab <= rRef2.nTab )
            {
                rRef2.nTab += 1;
                rRef2.nRelTab = rRef2.nTab - nPosTab;
                rChanged = sal_True;
            }
        }
        p = static_cast<ScToken*>(rCode.GetNextReference());
    }
}

void ScConditionEntry::UpdateReference( UpdateRefMode eUpdateRefMode,
								const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
{
	sal_Bool bInsertTab = ( eUpdateRefMode == URM_INSDEL && nDz == 1 );
	sal_Bool bDeleteTab = ( eUpdateRefMode == URM_INSDEL && nDz == -1 );

	sal_Bool bChanged1 = sal_False;
	sal_Bool bChanged2 = sal_False;

	if (pFormula1)
	{
		if ( bInsertTab )
			lcl_CondUpdateInsertTab( *pFormula1, rRange.aStart.Tab(), aSrcPos.Tab(), bChanged1 );
		else
		{
			ScCompiler aComp( pDoc, aSrcPos, *pFormula1 );
            aComp.SetGrammar(pDoc->GetGrammar());
			if ( bDeleteTab )
				aComp.UpdateDeleteTab( rRange.aStart.Tab(), sal_False, sal_True, bChanged1 );
			else
				aComp.UpdateNameReference( eUpdateRefMode, rRange, nDx, nDy, nDz, bChanged1 );
		}

		if (bChanged1)
			DELETEZ(pFCell1);		// is created again in IsValid
	}
	if (pFormula2)
	{
		if ( bInsertTab )
			lcl_CondUpdateInsertTab( *pFormula2, rRange.aStart.Tab(), aSrcPos.Tab(), bChanged2 );
		else
		{
			ScCompiler aComp( pDoc, aSrcPos, *pFormula2);
            aComp.SetGrammar(pDoc->GetGrammar());
			if ( bDeleteTab )
				aComp.UpdateDeleteTab( rRange.aStart.Tab(), sal_False, sal_True, bChanged2 );
			else
				aComp.UpdateNameReference( eUpdateRefMode, rRange, nDx, nDy, nDz, bChanged2 );
		}

		if (bChanged2)
			DELETEZ(pFCell2);		// is created again in IsValid
	}
}

void ScConditionEntry::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos )
{
	if (pFormula1)
	{
		ScCompiler aComp( pDoc, aSrcPos, *pFormula1);
        aComp.SetGrammar(pDoc->GetGrammar());
		aComp.UpdateMoveTab(nOldPos, nNewPos, sal_True );
		DELETEZ(pFCell1);
	}
	if (pFormula2)
	{
		ScCompiler aComp( pDoc, aSrcPos, *pFormula2);
        aComp.SetGrammar(pDoc->GetGrammar());
		aComp.UpdateMoveTab(nOldPos, nNewPos, sal_True );
		DELETEZ(pFCell2);
	}
}

//!	als Vergleichsoperator ans TokenArray ???

sal_Bool lcl_IsEqual( const ScTokenArray* pArr1, const ScTokenArray* pArr2 )
{
	//	verglichen wird nur das nicht-UPN Array

	if ( pArr1 && pArr2 )
	{
		sal_uInt16 nLen = pArr1->GetLen();
		if ( pArr2->GetLen() != nLen )
			return sal_False;

		FormulaToken** ppToken1 = pArr1->GetArray();
		FormulaToken** ppToken2 = pArr2->GetArray();
		for (sal_uInt16 i=0; i<nLen; i++)
		{
			if ( ppToken1[i] != ppToken2[i] &&
				 !(*ppToken1[i] == *ppToken2[i]) )
				return sal_False;						// Unterschied
		}
		return sal_True;					// alle Eintraege gleich
	}
	else
		return !pArr1 && !pArr2;		// beide 0 -> gleich
}

int ScConditionEntry::operator== ( const ScConditionEntry& r ) const
{
	sal_Bool bEq = (eOp == r.eOp && nOptions == r.nOptions &&
				lcl_IsEqual( pFormula1, r.pFormula1 ) &&
				lcl_IsEqual( pFormula2, r.pFormula2 ));
	if (bEq)
	{
        // for formulas, the reference positions must be compared, too
        // (including aSrcString, for inserting the entries during XML import)
        if ( ( pFormula1 || pFormula2 ) && ( aSrcPos != r.aSrcPos || aSrcString != r.aSrcString ) )
			bEq = sal_False;

		//	wenn keine Formeln, Werte vergleichen
		if ( !pFormula1 && ( nVal1 != r.nVal1 || aStrVal1 != r.aStrVal1 || bIsStr1 != r.bIsStr1 ) )
			bEq = sal_False;
		if ( !pFormula2 && ( nVal2 != r.nVal2 || aStrVal2 != r.aStrVal2 || bIsStr2 != r.bIsStr2 ) )
			bEq = sal_False;
	}

	return bEq;
}

void ScConditionEntry::Interpret( const ScAddress& rPos )
{
	//	Formelzellen anlegen
	//	dabei koennen neue Broadcaster (Note-Zellen) ins Dokument eingefuegt werden !!!!

	if ( ( pFormula1 && !pFCell1 ) || ( pFormula2 && !pFCell2 ) )
		MakeCells( rPos );

	//	Formeln auswerten

	sal_Bool bDirty = sal_False;		//! 1 und 2 getrennt ???

	ScFormulaCell* pTemp1 = NULL;
	ScFormulaCell* pEff1 = pFCell1;
	if ( bRelRef1 )
	{
		pTemp1 = new ScFormulaCell( pDoc, rPos, pFormula1 );	// ohne Listening
		pEff1 = pTemp1;
	}
	if ( pEff1 )
	{
		if (!pEff1->IsRunning())		// keine 522 erzeugen
		{
			//!	Changed statt Dirty abfragen !!!
			if (pEff1->GetDirty() && !bRelRef1 && pDoc->GetAutoCalc())
				bDirty = sal_True;
			if (pEff1->IsValue())
			{
				bIsStr1 = sal_False;
				nVal1 = pEff1->GetValue();
				aStrVal1.Erase();
			}
			else
			{
				bIsStr1 = sal_True;
				pEff1->GetString( aStrVal1 );
				nVal1 = 0.0;
			}
		}
	}
	delete pTemp1;

	ScFormulaCell* pTemp2 = NULL;
	ScFormulaCell* pEff2 = pFCell2; //@ 1!=2
	if ( bRelRef2 )
	{
		pTemp2 = new ScFormulaCell( pDoc, rPos, pFormula2 );	// ohne Listening
		pEff2 = pTemp2;
	}
	if ( pEff2 )
	{
		if (!pEff2->IsRunning())		// keine 522 erzeugen
		{
			if (pEff2->GetDirty() && !bRelRef2 && pDoc->GetAutoCalc())
				bDirty = sal_True;
			if (pEff2->IsValue())
			{
				bIsStr2 = sal_False;
				nVal2 = pEff2->GetValue();
				aStrVal2.Erase();
			}
			else
			{
				bIsStr2 = sal_True;
				pEff2->GetString( aStrVal2 );
				nVal2 = 0.0;
			}
		}
	}
	delete pTemp2;

	//	wenn IsRunning, bleiben die letzten Werte erhalten

	if (bDirty && !bFirstRun)
	{
		// 	bei bedingten Formaten neu painten

		DataChanged( NULL );	// alles
	}

	bFirstRun = sal_False;
}

sal_Bool ScConditionEntry::IsValid( double nArg ) const
{
	//	Interpret muss schon gerufen sein

	if ( bIsStr1 )
	{
		// wenn auf String getestet wird, bei Zahlen immer sal_False, ausser bei "ungleich"

		return ( eOp == SC_COND_NOTEQUAL );
	}

	if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
		if ( bIsStr2 )
			return sal_False;

	double nComp1 = nVal1;		// Kopie, damit vertauscht werden kann
	double nComp2 = nVal2;

	if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
		if ( nComp1 > nComp2 )
		{
			//	richtige Reihenfolge fuer Wertebereich
			double nTemp = nComp1; nComp1 = nComp2; nComp2 = nTemp;
		}

	//	Alle Grenzfaelle muessen per ::rtl::math::approxEqual getestet werden!

	sal_Bool bValid = sal_False;
	switch (eOp)
	{
		case SC_COND_NONE:
			break;					// immer sal_False;
		case SC_COND_EQUAL:
			bValid = ::rtl::math::approxEqual( nArg, nComp1 );
			break;
		case SC_COND_NOTEQUAL:
			bValid = !::rtl::math::approxEqual( nArg, nComp1 );
			break;
		case SC_COND_GREATER:
			bValid = ( nArg > nComp1 ) && !::rtl::math::approxEqual( nArg, nComp1 );
			break;
		case SC_COND_EQGREATER:
			bValid = ( nArg >= nComp1 ) || ::rtl::math::approxEqual( nArg, nComp1 );
			break;
		case SC_COND_LESS:
			bValid = ( nArg < nComp1 ) && !::rtl::math::approxEqual( nArg, nComp1 );
			break;
		case SC_COND_EQLESS:
			bValid = ( nArg <= nComp1 ) || ::rtl::math::approxEqual( nArg, nComp1 );
			break;
		case SC_COND_BETWEEN:
			bValid = ( nArg >= nComp1 && nArg <= nComp2 ) ||
					 ::rtl::math::approxEqual( nArg, nComp1 ) || ::rtl::math::approxEqual( nArg, nComp2 );
			break;
		case SC_COND_NOTBETWEEN:
			bValid = ( nArg < nComp1 || nArg > nComp2 ) &&
					 !::rtl::math::approxEqual( nArg, nComp1 ) && !::rtl::math::approxEqual( nArg, nComp2 );
			break;
		case SC_COND_DIRECT:
			bValid = !::rtl::math::approxEqual( nComp1, 0.0 );
			break;
		default:
			DBG_ERROR("unbekannte Operation bei ScConditionEntry");
			break;
	}
	return bValid;
}

sal_Bool ScConditionEntry::IsValidStr( const String& rArg ) const
{
	//	Interpret muss schon gerufen sein

	if ( eOp == SC_COND_DIRECT )				// Formel ist unabhaengig vom Inhalt
		return !::rtl::math::approxEqual( nVal1, 0.0 );

	//	Wenn Bedingung Zahl enthaelt, immer sal_False, ausser bei "ungleich"

	if ( !bIsStr1 )
		return ( eOp == SC_COND_NOTEQUAL );
	if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
		if ( !bIsStr2 )
			return sal_False;

	String aUpVal1( aStrVal1 );		//! als Member? (dann auch in Interpret setzen)
	String aUpVal2( aStrVal2 );

	if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN )
		if ( ScGlobal::GetCollator()->compareString( aUpVal1, aUpVal2 )
				== COMPARE_GREATER )
		{
			//	richtige Reihenfolge fuer Wertebereich
			String aTemp( aUpVal1 ); aUpVal1 = aUpVal2; aUpVal2 = aTemp;
		}

	sal_Bool bValid;
	switch ( eOp )
	{
		case SC_COND_EQUAL:
			bValid = (ScGlobal::GetCollator()->compareString(
				rArg, aUpVal1 ) == COMPARE_EQUAL);
		break;
		case SC_COND_NOTEQUAL:
			bValid = (ScGlobal::GetCollator()->compareString(
				rArg, aUpVal1 ) != COMPARE_EQUAL);
		break;
		default:
		{
			sal_Int32 nCompare = ScGlobal::GetCollator()->compareString(
				rArg, aUpVal1 );
			switch ( eOp )
			{
				case SC_COND_GREATER:
					bValid = ( nCompare == COMPARE_GREATER );
					break;
				case SC_COND_EQGREATER:
					bValid = ( nCompare == COMPARE_EQUAL || nCompare == COMPARE_GREATER );
					break;
				case SC_COND_LESS:
					bValid = ( nCompare == COMPARE_LESS );
					break;
				case SC_COND_EQLESS:
					bValid = ( nCompare == COMPARE_EQUAL || nCompare == COMPARE_LESS );
					break;
				case SC_COND_BETWEEN:
				case SC_COND_NOTBETWEEN:
					//	Test auf NOTBETWEEN:
					bValid = ( nCompare == COMPARE_LESS ||
						ScGlobal::GetCollator()->compareString( rArg,
						aUpVal2 ) == COMPARE_GREATER );
					if ( eOp == SC_COND_BETWEEN )
						bValid = !bValid;
					break;
				//	SC_COND_DIRECT schon oben abgefragt
				default:
					DBG_ERROR("unbekannte Operation bei ScConditionEntry");
					bValid = sal_False;
					break;
			}
		}
	}
	return bValid;
}

sal_Bool ScConditionEntry::IsCellValid( ScBaseCell* pCell, const ScAddress& rPos ) const
{
	((ScConditionEntry*)this)->Interpret(rPos);			// Formeln auswerten

	double nArg = 0.0;
	String aArgStr;
	sal_Bool bVal = sal_True;

	if ( pCell )
	{
		CellType eType = pCell->GetCellType();
		switch (eType)
		{
			case CELLTYPE_VALUE:
				nArg = ((ScValueCell*)pCell)->GetValue();
				break;
			case CELLTYPE_FORMULA:
				{
					ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
					bVal = pFCell->IsValue();
					if (bVal)
						nArg = pFCell->GetValue();
					else
						pFCell->GetString(aArgStr);
				}
				break;
			case CELLTYPE_STRING:
			case CELLTYPE_EDIT:
				bVal = sal_False;
				if ( eType == CELLTYPE_STRING )
					((ScStringCell*)pCell)->GetString(aArgStr);
				else
					((ScEditCell*)pCell)->GetString(aArgStr);
				break;

			default:
				pCell = NULL;			// Note-Zellen wie leere
				break;
		}
	}

	if (!pCell)
		if (bIsStr1)
			bVal = sal_False;				// leere Zellen je nach Bedingung

	if (bVal)
		return IsValid( nArg );
	else
		return IsValidStr( aArgStr );
}

String ScConditionEntry::GetExpression( const ScAddress& rCursor, sal_uInt16 nIndex,
										sal_uLong nNumFmt,
                                        const FormulaGrammar::Grammar eGrammar ) const
{
	String aRet;

    if ( FormulaGrammar::isEnglish( eGrammar) && nNumFmt == 0 )
		nNumFmt = pDoc->GetFormatTable()->GetStandardIndex( LANGUAGE_ENGLISH_US );

	if ( nIndex==0 )
	{
		if ( pFormula1 )
		{
			ScCompiler aComp(pDoc, rCursor, *pFormula1);
            aComp.SetGrammar(eGrammar);
			aComp.CreateStringFromTokenArray( aRet );
		}
		else if (bIsStr1)
		{
			aRet = '"';
			aRet += aStrVal1;
			aRet += '"';
		}
		else
			pDoc->GetFormatTable()->GetInputLineString(nVal1, nNumFmt, aRet);
	}
	else if ( nIndex==1 )
	{
		if ( pFormula2 )
		{
			ScCompiler aComp(pDoc, rCursor, *pFormula2);
            aComp.SetGrammar(eGrammar);
			aComp.CreateStringFromTokenArray( aRet );
		}
		else if (bIsStr2)
		{
			aRet = '"';
			aRet += aStrVal2;
			aRet += '"';
		}
		else
			pDoc->GetFormatTable()->GetInputLineString(nVal2, nNumFmt, aRet);
	}
	else
	{
		DBG_ERROR("GetExpression: falscher Index");
	}

	return aRet;
}

ScTokenArray* ScConditionEntry::CreateTokenArry( sal_uInt16 nIndex ) const
{
    ScTokenArray* pRet = NULL;
	ScAddress aAddr;

	if ( nIndex==0 )
	{
		if ( pFormula1 )
			pRet = new ScTokenArray( *pFormula1 );
		else
		{
			pRet = new ScTokenArray();
			if (bIsStr1)
				pRet->AddString( aStrVal1.GetBuffer() );
			else
				pRet->AddDouble( nVal1 );
		}
	}
	else if ( nIndex==1 )
	{
		if ( pFormula2 )
			pRet = new ScTokenArray( *pFormula2 );
		else
		{
			pRet = new ScTokenArray();
			if (bIsStr2)
				pRet->AddString( aStrVal2.GetBuffer() );
			else
				pRet->AddDouble( nVal2 );
		}
	}
	else
	{
		DBG_ERROR("GetExpression: falscher Index");
	}

	return pRet;
}

void ScConditionEntry::SourceChanged( const ScAddress& rChanged )
{
	for (sal_uInt16 nPass = 0; nPass < 2; nPass++)
	{
		ScTokenArray* pFormula = nPass ? pFormula2 : pFormula1;
		if (pFormula)
		{
			pFormula->Reset();
			ScToken* t;
            while ( ( t = static_cast<ScToken*>(pFormula->GetNextReference()) ) != NULL )
			{
				SingleDoubleRefProvider aProv( *t );
				if ( aProv.Ref1.IsColRel() || aProv.Ref1.IsRowRel() || aProv.Ref1.IsTabRel() ||
					 aProv.Ref2.IsColRel() || aProv.Ref2.IsRowRel() || aProv.Ref2.IsTabRel() )
				{
					//	absolut muss getroffen sein, relativ bestimmt Bereich

					sal_Bool bHit = sal_True;
                    SCsCOL nCol1;
                    SCsROW nRow1;
                    SCsTAB nTab1;
                    SCsCOL nCol2;
                    SCsROW nRow2;
                    SCsTAB nTab2;

					if ( aProv.Ref1.IsColRel() )
						nCol2 = rChanged.Col() - aProv.Ref1.nRelCol;
					else
					{
						bHit &= ( rChanged.Col() >= aProv.Ref1.nCol );
						nCol2 = MAXCOL;
					}
					if ( aProv.Ref1.IsRowRel() )
						nRow2 = rChanged.Row() - aProv.Ref1.nRelRow;
					else
					{
						bHit &= ( rChanged.Row() >= aProv.Ref1.nRow );
						nRow2 = MAXROW;
					}
					if ( aProv.Ref1.IsTabRel() )
						nTab2 = rChanged.Tab() - aProv.Ref1.nRelTab;
					else
					{
						bHit &= ( rChanged.Tab() >= aProv.Ref1.nTab );
						nTab2 = MAXTAB;
					}

					if ( aProv.Ref2.IsColRel() )
						nCol1 = rChanged.Col() - aProv.Ref2.nRelCol;
					else
					{
						bHit &= ( rChanged.Col() <= aProv.Ref2.nCol );
						nCol1 = 0;
					}
					if ( aProv.Ref2.IsRowRel() )
						nRow1 = rChanged.Row() - aProv.Ref2.nRelRow;
					else
					{
						bHit &= ( rChanged.Row() <= aProv.Ref2.nRow );
						nRow1 = 0;
					}
					if ( aProv.Ref2.IsTabRel() )
						nTab1 = rChanged.Tab() - aProv.Ref2.nRelTab;
					else
					{
						bHit &= ( rChanged.Tab() <= aProv.Ref2.nTab );
						nTab1 = 0;
					}

					if ( bHit )
					{
						//!	begrenzen

						ScRange aPaint( nCol1,nRow1,nTab1, nCol2,nRow2,nTab2 );

						//	kein Paint, wenn es nur die Zelle selber ist
						if ( aPaint.aStart != rChanged || aPaint.aEnd != rChanged )
							DataChanged( &aPaint );
					}
				}
			}
		}
	}
}

ScAddress ScConditionEntry::GetValidSrcPos() const
{
    // return a position that's adjusted to allow textual representation of expressions if possible

    SCTAB nMinTab = aSrcPos.Tab();
    SCTAB nMaxTab = nMinTab;

    for (sal_uInt16 nPass = 0; nPass < 2; nPass++)
    {
        ScTokenArray* pFormula = nPass ? pFormula2 : pFormula1;
        if (pFormula)
        {
            pFormula->Reset();
            ScToken* t;
            while ( ( t = static_cast<ScToken*>(pFormula->GetNextReference()) ) != NULL )
            {
                ScSingleRefData& rRef1 = t->GetSingleRef();
                if ( rRef1.IsTabRel() && !rRef1.IsTabDeleted() )
                {
                    if ( rRef1.nTab < nMinTab )
                        nMinTab = rRef1.nTab;
                    if ( rRef1.nTab > nMaxTab )
                        nMaxTab = rRef1.nTab;
                }
                if ( t->GetType() == svDoubleRef )
                {
                    ScSingleRefData& rRef2 = t->GetDoubleRef().Ref2;
                    if ( rRef2.IsTabRel() && !rRef2.IsTabDeleted() )
                    {
                        if ( rRef2.nTab < nMinTab )
                            nMinTab = rRef2.nTab;
                        if ( rRef2.nTab > nMaxTab )
                            nMaxTab = rRef2.nTab;
                    }
                }
            }
        }
    }

    ScAddress aValidPos = aSrcPos;
    SCTAB nTabCount = pDoc->GetTableCount();
    if ( nMaxTab >= nTabCount && nMinTab > 0 )
        aValidPos.SetTab( aSrcPos.Tab() - nMinTab );    // so the lowest tab ref will be on 0

    if ( aValidPos.Tab() >= nTabCount )
        aValidPos.SetTab( nTabCount - 1 );  // ensure a valid position even if some references will be invalid

    return aValidPos;
}

void ScConditionEntry::DataChanged( const ScRange* /* pModified */ ) const
{
	// nix
}

bool ScConditionEntry::MarkUsedExternalReferences() const
{
    bool bAllMarked = false;
    for (sal_uInt16 nPass = 0; !bAllMarked && nPass < 2; nPass++)
    {
        ScTokenArray* pFormula = nPass ? pFormula2 : pFormula1;
        if (pFormula)
            bAllMarked = pDoc->MarkUsedExternalReferences( *pFormula);
    }
    return bAllMarked;
}

//------------------------------------------------------------------------

ScCondFormatEntry::ScCondFormatEntry( ScConditionMode eOper,
										const String& rExpr1, const String& rExpr2,
										ScDocument* pDocument, const ScAddress& rPos,
										const String& rStyle,
                                        const String& rExprNmsp1, const String& rExprNmsp2,
                                        FormulaGrammar::Grammar eGrammar1,
                                        FormulaGrammar::Grammar eGrammar2 ) :
    ScConditionEntry( eOper, rExpr1, rExpr2, pDocument, rPos, rExprNmsp1, rExprNmsp2, eGrammar1, eGrammar2 ),
	aStyleName( rStyle ),
	pParent( NULL )
{
}

ScCondFormatEntry::ScCondFormatEntry( ScConditionMode eOper,
										const ScTokenArray* pArr1, const ScTokenArray* pArr2,
										ScDocument* pDocument, const ScAddress& rPos,
										const String& rStyle ) :
	ScConditionEntry( eOper, pArr1, pArr2, pDocument, rPos ),
	aStyleName( rStyle ),
	pParent( NULL )
{
}

ScCondFormatEntry::ScCondFormatEntry( const ScCondFormatEntry& r ) :
	ScConditionEntry( r ),
	aStyleName( r.aStyleName ),
	pParent( NULL )
{
}

ScCondFormatEntry::ScCondFormatEntry( ScDocument* pDocument, const ScCondFormatEntry& r ) :
	ScConditionEntry( pDocument, r ),
	aStyleName( r.aStyleName ),
	pParent( NULL )
{
}

int ScCondFormatEntry::operator== ( const ScCondFormatEntry& r ) const
{
	return ScConditionEntry::operator==( r ) &&
			aStyleName == r.aStyleName;

	//	Range wird nicht verglichen
}

ScCondFormatEntry::~ScCondFormatEntry()
{
}

void ScCondFormatEntry::DataChanged( const ScRange* pModified ) const
{
	if ( pParent )
		pParent->DoRepaint( pModified );
}

//------------------------------------------------------------------------

ScConditionalFormat::ScConditionalFormat(sal_uInt32 nNewKey, ScDocument* pDocument) :
	pDoc( pDocument ),
	pAreas( NULL ),
	nKey( nNewKey ),
	ppEntries( NULL ),
	nEntryCount( 0 )
{
}

ScConditionalFormat::ScConditionalFormat(const ScConditionalFormat& r) :
	pDoc( r.pDoc ),
	pAreas( NULL ),
	nKey( r.nKey ),
	ppEntries( NULL ),
	nEntryCount( r.nEntryCount )
{
	if (nEntryCount)
	{
		ppEntries = new ScCondFormatEntry*[nEntryCount];
		for (sal_uInt16 i=0; i<nEntryCount; i++)
		{
			ppEntries[i] = new ScCondFormatEntry(*r.ppEntries[i]);
			ppEntries[i]->SetParent(this);
		}
	}
}

ScConditionalFormat* ScConditionalFormat::Clone(ScDocument* pNewDoc) const
{
	// echte Kopie der Formeln (fuer Ref-Undo / zwischen Dokumenten)

	if (!pNewDoc)
		pNewDoc = pDoc;

	ScConditionalFormat* pNew = new ScConditionalFormat(nKey, pNewDoc);
	DBG_ASSERT(!pNew->ppEntries, "wo kommen die Eintraege her?");

	if (nEntryCount)
	{
		pNew->ppEntries = new ScCondFormatEntry*[nEntryCount];
		for (sal_uInt16 i=0; i<nEntryCount; i++)
		{
			pNew->ppEntries[i] = new ScCondFormatEntry( pNewDoc, *ppEntries[i] );
			pNew->ppEntries[i]->SetParent(pNew);
		}
		pNew->nEntryCount = nEntryCount;
	}

	return pNew;
}

sal_Bool ScConditionalFormat::EqualEntries( const ScConditionalFormat& r ) const
{
	if ( nEntryCount != r.nEntryCount )
		return sal_False;

	//!	auf gleiche Eintraege in anderer Reihenfolge testen ???

	for (sal_uInt16 i=0; i<nEntryCount; i++)
		if ( ! (*ppEntries[i] == *r.ppEntries[i]) )
			return sal_False;

	return sal_True;
}

void ScConditionalFormat::AddEntry( const ScCondFormatEntry& rNew )
{
	ScCondFormatEntry** ppNew = new ScCondFormatEntry*[nEntryCount+1];
	for (sal_uInt16 i=0; i<nEntryCount; i++)
		ppNew[i] = ppEntries[i];
	ppNew[nEntryCount] = new ScCondFormatEntry(rNew);
	ppNew[nEntryCount]->SetParent(this);
	++nEntryCount;
	delete[] ppEntries;
	ppEntries = ppNew;
}

ScConditionalFormat::~ScConditionalFormat()
{
	for (sal_uInt16 i=0; i<nEntryCount; i++)
		delete ppEntries[i];
	delete[] ppEntries;

	delete pAreas;
}

const ScCondFormatEntry* ScConditionalFormat::GetEntry( sal_uInt16 nPos ) const
{
	if ( nPos < nEntryCount )
		return ppEntries[nPos];
	else
		return NULL;
}

const String& ScConditionalFormat::GetCellStyle( ScBaseCell* pCell, const ScAddress& rPos ) const
{
	for (sal_uInt16 i=0; i<nEntryCount; i++)
		if ( ppEntries[i]->IsCellValid( pCell, rPos ) )
			return ppEntries[i]->GetStyle();

	return EMPTY_STRING;
}

void lcl_Extend( ScRange& rRange, ScDocument* pDoc, sal_Bool bLines )
{
	SCTAB nTab = rRange.aStart.Tab();
	DBG_ASSERT(rRange.aEnd.Tab() == nTab, "lcl_Extend - mehrere Tabellen?");

	SCCOL nStartCol = rRange.aStart.Col();
	SCROW nStartRow = rRange.aStart.Row();
	SCCOL nEndCol = rRange.aEnd.Col();
	SCROW nEndRow = rRange.aEnd.Row();

	sal_Bool bEx = pDoc->ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow, nTab );

	if (bLines)
	{
		if (nStartCol > 0)	  --nStartCol;
		if (nStartRow > 0)	  --nStartRow;
		if (nEndCol < MAXCOL) ++nEndCol;
		if (nEndRow < MAXROW) ++nEndRow;
	}

	if ( bEx || bLines )
	{
		rRange.aStart.Set( nStartCol, nStartRow, nTab );
		rRange.aEnd.Set( nEndCol, nEndRow, nTab );
	}
}

sal_Bool lcl_CutRange( ScRange& rRange, const ScRange& rOther )
{
	rRange.Justify();
	ScRange aCmpRange = rOther;
	aCmpRange.Justify();

	if ( rRange.aStart.Col() <= aCmpRange.aEnd.Col() &&
		 rRange.aEnd.Col() >= aCmpRange.aStart.Col() &&
		 rRange.aStart.Row() <= aCmpRange.aEnd.Row() &&
		 rRange.aEnd.Row() >= aCmpRange.aStart.Row() &&
		 rRange.aStart.Tab() <= aCmpRange.aEnd.Tab() &&
		 rRange.aEnd.Tab() >= aCmpRange.aStart.Tab() )
	{
		if ( rRange.aStart.Col() < aCmpRange.aStart.Col() )
			rRange.aStart.SetCol( aCmpRange.aStart.Col() );
		if ( rRange.aStart.Row() < aCmpRange.aStart.Row() )
			rRange.aStart.SetRow( aCmpRange.aStart.Row() );
		if ( rRange.aStart.Tab() < aCmpRange.aStart.Tab() )
			rRange.aStart.SetTab( aCmpRange.aStart.Tab() );
		if ( rRange.aEnd.Col() > aCmpRange.aEnd.Col() )
			rRange.aEnd.SetCol( aCmpRange.aEnd.Col() );
		if ( rRange.aEnd.Row() > aCmpRange.aEnd.Row() )
			rRange.aEnd.SetRow( aCmpRange.aEnd.Row() );
		if ( rRange.aEnd.Tab() > aCmpRange.aEnd.Tab() )
			rRange.aEnd.SetTab( aCmpRange.aEnd.Tab() );

		return sal_True;
	}

	return sal_False;		// ausserhalb
}

void ScConditionalFormat::DoRepaint( const ScRange* pModified )
{
	sal_uInt16 i;
	SfxObjectShell* pSh = pDoc->GetDocumentShell();
	if (pSh)
	{
		//	Rahmen/Schatten enthalten?
		//	(alle Bedingungen testen)
		sal_Bool bExtend = sal_False;
		sal_Bool bRotate = sal_False;
		sal_Bool bAttrTested = sal_False;

		if (!pAreas)		//	RangeList ggf. holen
		{
			pAreas = new ScRangeList;
			pDoc->FindConditionalFormat( nKey, *pAreas );
		}
		sal_uInt16 nCount = (sal_uInt16) pAreas->Count();
		for (i=0; i<nCount; i++)
		{
			ScRange aRange = *pAreas->GetObject(i);
			sal_Bool bDo = sal_True;
			if ( pModified )
			{
				if ( !lcl_CutRange( aRange, *pModified ) )
					bDo = sal_False;
			}
			if (bDo)
			{
			    if ( !bAttrTested )
			    {
			        // #116562# Look at the style's content only if the repaint is necessary
			        // for any condition, to avoid the time-consuming Find() if there are many
			        // conditional formats and styles.
            		for (sal_uInt16 nEntry=0; nEntry<nEntryCount; nEntry++)
            		{
            			String aStyle = ppEntries[nEntry]->GetStyle();
            			if (aStyle.Len())
            			{
            				SfxStyleSheetBase* pStyleSheet =
            					pDoc->GetStyleSheetPool()->Find( aStyle, SFX_STYLE_FAMILY_PARA );
            				if ( pStyleSheet )
            				{
            					const SfxItemSet& rSet = pStyleSheet->GetItemSet();
            					if (rSet.GetItemState( ATTR_BORDER, sal_True ) == SFX_ITEM_SET ||
            						rSet.GetItemState( ATTR_SHADOW, sal_True ) == SFX_ITEM_SET)
            					{
            						bExtend = sal_True;
            					}
            					if (rSet.GetItemState( ATTR_ROTATE_VALUE, sal_True ) == SFX_ITEM_SET ||
            						rSet.GetItemState( ATTR_ROTATE_MODE, sal_True ) == SFX_ITEM_SET)
            					{
            						bRotate = sal_True;
            					}
            				}
            			}
            		}
            		bAttrTested = sal_True;
			    }

				lcl_Extend( aRange, pDoc, bExtend );		// zusammengefasste und bExtend
				if ( bRotate )
				{
					aRange.aStart.SetCol(0);
					aRange.aEnd.SetCol(MAXCOL);		// gedreht: ganze Zeilen
				}

				// gedreht -> ganze Zeilen
				if ( aRange.aStart.Col() != 0 || aRange.aEnd.Col() != MAXCOL )
				{
					if ( pDoc->HasAttrib( 0,aRange.aStart.Row(),aRange.aStart.Tab(),
											MAXCOL,aRange.aEnd.Row(),aRange.aEnd.Tab(),
											HASATTR_ROTATE ) )
					{
						aRange.aStart.SetCol(0);
						aRange.aEnd.SetCol(MAXCOL);
					}
				}

                pDoc->RepaintRange( aRange );
			}
		}
	}
}

void ScConditionalFormat::InvalidateArea()
{
	delete pAreas;
	pAreas = NULL;
}

void ScConditionalFormat::CompileAll()
{
	for (sal_uInt16 i=0; i<nEntryCount; i++)
		ppEntries[i]->CompileAll();
}

void ScConditionalFormat::CompileXML()
{
	for (sal_uInt16 i=0; i<nEntryCount; i++)
		ppEntries[i]->CompileXML();
}

void ScConditionalFormat::UpdateReference( UpdateRefMode eUpdateRefMode,
								const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
{
	for (sal_uInt16 i=0; i<nEntryCount; i++)
		ppEntries[i]->UpdateReference(eUpdateRefMode, rRange, nDx, nDy, nDz);

	delete pAreas;		// aus dem AttrArray kommt beim Einfuegen/Loeschen kein Aufruf
	pAreas = NULL;
}

void ScConditionalFormat::RenameCellStyle(const String& rOld, const String& rNew)
{
    for (sal_uInt16 i=0; i<nEntryCount; i++)
        if ( ppEntries[i]->GetStyle() == rOld )
            ppEntries[i]->UpdateStyleName( rNew );
}

void ScConditionalFormat::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos )
{
	for (sal_uInt16 i=0; i<nEntryCount; i++)
		ppEntries[i]->UpdateMoveTab( nOldPos, nNewPos );

	delete pAreas;		// aus dem AttrArray kommt beim Einfuegen/Loeschen kein Aufruf
	pAreas = NULL;
}

void ScConditionalFormat::SourceChanged( const ScAddress& rAddr )
{
	for (sal_uInt16 i=0; i<nEntryCount; i++)
		ppEntries[i]->SourceChanged( rAddr );
}

bool ScConditionalFormat::MarkUsedExternalReferences() const
{
    bool bAllMarked = false;
	for (sal_uInt16 i=0; !bAllMarked && i<nEntryCount; i++)
		bAllMarked = ppEntries[i]->MarkUsedExternalReferences();
    return bAllMarked;
}

//------------------------------------------------------------------------

ScConditionalFormatList::ScConditionalFormatList(const ScConditionalFormatList& rList) :
    ScConditionalFormats_Impl()
{
	//	fuer Ref-Undo - echte Kopie mit neuen Tokens!

	sal_uInt16 nCount = rList.Count();

	for (sal_uInt16 i=0; i<nCount; i++)
		InsertNew( rList[i]->Clone() );

	//!		sortierte Eintraege aus rList schneller einfuegen ???
}

ScConditionalFormatList::ScConditionalFormatList(ScDocument* pNewDoc,
												const ScConditionalFormatList& rList)
{
	//	fuer neues Dokument - echte Kopie mit neuen Tokens!

	sal_uInt16 nCount = rList.Count();

	for (sal_uInt16 i=0; i<nCount; i++)
		InsertNew( rList[i]->Clone(pNewDoc) );

	//!		sortierte Eintraege aus rList schneller einfuegen ???
}

sal_Bool ScConditionalFormatList::operator==( const ScConditionalFormatList& r ) const
{
	// fuer Ref-Undo - interne Variablen werden nicht verglichen

	sal_uInt16 nCount = Count();
	sal_Bool bEqual = ( nCount == r.Count() );
	for (sal_uInt16 i=0; i<nCount && bEqual; i++)			// Eintraege sind sortiert
		if ( !(*this)[i]->EqualEntries(*r[i]) )			// Eintraege unterschiedlich ?
			bEqual = sal_False;

	return bEqual;
}

ScConditionalFormat* ScConditionalFormatList::GetFormat( sal_uInt32 nKey )
{
	//!	binaer suchen

	sal_uInt16 nCount = Count();
	for (sal_uInt16 i=0; i<nCount; i++)
		if ((*this)[i]->GetKey() == nKey)
			return (*this)[i];

	DBG_ERROR("ScConditionalFormatList: Eintrag nicht gefunden");
	return NULL;
}

void ScConditionalFormatList::CompileAll()
{
	sal_uInt16 nCount = Count();
	for (sal_uInt16 i=0; i<nCount; i++)
		(*this)[i]->CompileAll();
}

void ScConditionalFormatList::CompileXML()
{
	sal_uInt16 nCount = Count();
	for (sal_uInt16 i=0; i<nCount; i++)
		(*this)[i]->CompileXML();
}

void ScConditionalFormatList::UpdateReference( UpdateRefMode eUpdateRefMode,
								const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
{
	sal_uInt16 nCount = Count();
	for (sal_uInt16 i=0; i<nCount; i++)
		(*this)[i]->UpdateReference( eUpdateRefMode, rRange, nDx, nDy, nDz );
}

void ScConditionalFormatList::RenameCellStyle( const String& rOld, const String& rNew )
{
    sal_uLong nCount=Count();
    for (sal_uInt16 i=0; i<nCount; i++)
        (*this)[i]->RenameCellStyle(rOld,rNew);
}

void ScConditionalFormatList::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos )
{
	sal_uInt16 nCount = Count();
	for (sal_uInt16 i=0; i<nCount; i++)
		(*this)[i]->UpdateMoveTab( nOldPos, nNewPos );
}

void ScConditionalFormatList::SourceChanged( const ScAddress& rAddr )
{
	sal_uInt16 nCount = Count();
	for (sal_uInt16 i=0; i<nCount; i++)
		(*this)[i]->SourceChanged( rAddr );
}

bool ScConditionalFormatList::MarkUsedExternalReferences() const
{
    bool bAllMarked = false;
	sal_uInt16 nCount = Count();
	for (sal_uInt16 i=0; !bAllMarked && i<nCount; i++)
		bAllMarked = (*this)[i]->MarkUsedExternalReferences();
    return bAllMarked;
}