/**************************************************************
 * 
 * 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 <rtl/math.hxx>
#include <unotools/textsearch.hxx>
#include <svl/zforlist.hxx>
#include <svl/zformat.hxx>
#include <unotools/charclass.hxx>
#include <unotools/collatorwrapper.hxx>
#include <com/sun/star/i18n/CollatorOptions.hpp>
#include <stdlib.h>
#include <unotools/transliterationwrapper.hxx>

#include "table.hxx"
#include "scitems.hxx"
#include "collect.hxx"
#include "attrib.hxx"
#include "cell.hxx"
#include "document.hxx"
#include "globstr.hrc"
#include "global.hxx"
#include "stlpool.hxx"
#include "compiler.hxx"
#include "patattr.hxx"
#include "subtotal.hxx"
#include "docoptio.hxx"
#include "markdata.hxx"
#include "rangelst.hxx"
#include "attarray.hxx"
#include "userlist.hxx"
#include "progress.hxx"
#include "cellform.hxx"
#include "postit.hxx"
#include "queryparam.hxx"
#include "segmenttree.hxx"
#include "drwlayer.hxx"

#include <vector>

// STATIC DATA -----------------------------------------------------------

const sal_uInt16 nMaxSorts = 3;		// maximale Anzahl Sortierkriterien in aSortParam

struct ScSortInfo
{
	ScBaseCell*		pCell;
	SCCOLROW		nOrg;
	DECL_FIXEDMEMPOOL_NEWDEL( ScSortInfo );
};
const sal_uInt16 nMemPoolSortInfo = (0x8000 - 64) / sizeof(ScSortInfo);
IMPL_FIXEDMEMPOOL_NEWDEL( ScSortInfo, nMemPoolSortInfo, nMemPoolSortInfo )

// END OF STATIC DATA -----------------------------------------------------


class ScSortInfoArray
{
private:
	ScSortInfo**	pppInfo[nMaxSorts];
	SCSIZE			nCount;
	SCCOLROW		nStart;
	sal_uInt16			nUsedSorts;

public:
				ScSortInfoArray( sal_uInt16 nSorts, SCCOLROW nInd1, SCCOLROW nInd2 ) :
						nCount( nInd2 - nInd1 + 1 ), nStart( nInd1 ),
						nUsedSorts( Min( nSorts, nMaxSorts ) )
					{
						for ( sal_uInt16 nSort = 0; nSort < nUsedSorts; nSort++ )
						{
							ScSortInfo** ppInfo = new ScSortInfo* [nCount];
							for ( SCSIZE j = 0; j < nCount; j++ )
								ppInfo[j] = new ScSortInfo;
							pppInfo[nSort] = ppInfo;
						}
					}
				~ScSortInfoArray()
					{
						for ( sal_uInt16 nSort = 0; nSort < nUsedSorts; nSort++ )
						{
							ScSortInfo** ppInfo = pppInfo[nSort];
							for ( SCSIZE j = 0; j < nCount; j++ )
								delete ppInfo[j];
							delete [] ppInfo;
						}
					}
	ScSortInfo*	Get( sal_uInt16 nSort, SCCOLROW nInd )
					{ return (pppInfo[nSort])[ nInd - nStart ]; }
	void		Swap( SCCOLROW nInd1, SCCOLROW nInd2 )
					{
						SCSIZE n1 = static_cast<SCSIZE>(nInd1 - nStart);
						SCSIZE n2 = static_cast<SCSIZE>(nInd2 - nStart);
						for ( sal_uInt16 nSort = 0; nSort < nUsedSorts; nSort++ )
						{
							ScSortInfo** ppInfo = pppInfo[nSort];
							ScSortInfo* pTmp = ppInfo[n1];
							ppInfo[n1] = ppInfo[n2];
							ppInfo[n2] = pTmp;
						}
					}
	sal_uInt16		GetUsedSorts() { return nUsedSorts; }
	ScSortInfo**	GetFirstArray() { return pppInfo[0]; }
	SCCOLROW	GetStart() { return nStart; }
	SCSIZE		GetCount() { return nCount; }
};

ScSortInfoArray* ScTable::CreateSortInfoArray( SCCOLROW nInd1, SCCOLROW nInd2 )
{
	sal_uInt16 nUsedSorts = 1;
	while ( nUsedSorts < nMaxSorts && aSortParam.bDoSort[nUsedSorts] )
		nUsedSorts++;
	ScSortInfoArray* pArray = new ScSortInfoArray( nUsedSorts, nInd1, nInd2 );
	if ( aSortParam.bByRow )
	{
		for ( sal_uInt16 nSort = 0; nSort < nUsedSorts; nSort++ )
		{
			SCCOL nCol = static_cast<SCCOL>(aSortParam.nField[nSort]);
			ScColumn* pCol = &aCol[nCol];
			for ( SCROW nRow = nInd1; nRow <= nInd2; nRow++ )
			{
//2do: FillSortInfo an ScColumn und Array abklappern statt Search in GetCell
				ScSortInfo* pInfo = pArray->Get( nSort, nRow );
				pInfo->pCell = pCol->GetCell( nRow );
				pInfo->nOrg = nRow;
			}
		}
	}
	else
	{
		for ( sal_uInt16 nSort = 0; nSort < nUsedSorts; nSort++ )
		{
			SCROW nRow = aSortParam.nField[nSort];
			for ( SCCOL nCol = static_cast<SCCOL>(nInd1);
                    nCol <= static_cast<SCCOL>(nInd2); nCol++ )
			{
				ScSortInfo* pInfo = pArray->Get( nSort, nCol );
				pInfo->pCell = GetCell( nCol, nRow );
				pInfo->nOrg = nCol;
			}
		}
	}
	return pArray;
}


sal_Bool ScTable::IsSortCollatorGlobal() const
{
	return	pSortCollator == ScGlobal::GetCollator() ||
			pSortCollator == ScGlobal::GetCaseCollator();
}


void ScTable::InitSortCollator( const ScSortParam& rPar )
{
	if ( rPar.aCollatorLocale.Language.getLength() )
	{
		if ( !pSortCollator || IsSortCollatorGlobal() )
			pSortCollator = new CollatorWrapper( pDocument->GetServiceManager() );
		pSortCollator->loadCollatorAlgorithm( rPar.aCollatorAlgorithm,
			rPar.aCollatorLocale, (rPar.bCaseSens ? 0 : SC_COLLATOR_IGNORES) );
	}
	else
	{	// SYSTEM
		DestroySortCollator();
		pSortCollator = (rPar.bCaseSens ? ScGlobal::GetCaseCollator() :
			ScGlobal::GetCollator());
	}
}


void ScTable::DestroySortCollator()
{
	if ( pSortCollator )
	{
		if ( !IsSortCollatorGlobal() )
			delete pSortCollator;
		pSortCollator = NULL;
	}
}


void ScTable::SortReorder( ScSortInfoArray* pArray, ScProgress& rProgress )
{
	sal_Bool bByRow = aSortParam.bByRow;
	SCSIZE nCount = pArray->GetCount();
    SCCOLROW nStart = pArray->GetStart();
	ScSortInfo** ppInfo = pArray->GetFirstArray();
    ::std::vector<ScSortInfo*> aTable(nCount);
	SCSIZE nPos;
	for ( nPos = 0; nPos < nCount; nPos++ )
        aTable[ppInfo[nPos]->nOrg - nStart] = ppInfo[nPos];

    SCCOLROW nDest = nStart;
	for ( nPos = 0; nPos < nCount; nPos++, nDest++ )
	{
		SCCOLROW nOrg = ppInfo[nPos]->nOrg;
		if ( nDest != nOrg )
		{
			if ( bByRow )
				SwapRow( nDest, nOrg );
			else
				SwapCol( static_cast<SCCOL>(nDest), static_cast<SCCOL>(nOrg) );
			// neue Position des weggeswapten eintragen
			ScSortInfo* p = ppInfo[nPos];
			p->nOrg = nDest;
            ::std::swap(p, aTable[nDest-nStart]);
			p->nOrg = nOrg;
            ::std::swap(p, aTable[nOrg-nStart]);
			DBG_ASSERT( p == ppInfo[nPos], "SortReorder: nOrg MisMatch" );
		}
		rProgress.SetStateOnPercent( nPos );
	}
}

short ScTable::CompareCell( sal_uInt16 nSort,
			ScBaseCell* pCell1, SCCOL nCell1Col, SCROW nCell1Row,
			ScBaseCell* pCell2, SCCOL nCell2Col, SCROW nCell2Row )
{
	short nRes = 0;

    CellType eType1 = CELLTYPE_NONE, eType2 = CELLTYPE_NONE;
	if (pCell1)
	{
		eType1 = pCell1->GetCellType();
		if (eType1 == CELLTYPE_NOTE)
			pCell1 = NULL;
	}
	if (pCell2)
	{
		eType2 = pCell2->GetCellType();
		if (eType2 == CELLTYPE_NOTE)
			pCell2 = NULL;
	}

	if (pCell1)
	{
		if (pCell2)
		{
			sal_Bool bStr1 = ( eType1 != CELLTYPE_VALUE );
			if ( eType1 == CELLTYPE_FORMULA && ((ScFormulaCell*)pCell1)->IsValue() )
				bStr1 = sal_False;
			sal_Bool bStr2 = ( eType2 != CELLTYPE_VALUE );
			if ( eType2 == CELLTYPE_FORMULA && ((ScFormulaCell*)pCell2)->IsValue() )
				bStr2 = sal_False;

			if ( bStr1 && bStr2 )			// nur Strings untereinander als String vergleichen!
			{
				String aStr1;
				String aStr2;
				if (eType1 == CELLTYPE_STRING)
					((ScStringCell*)pCell1)->GetString(aStr1);
				else
					GetString(nCell1Col, nCell1Row, aStr1);
				if (eType2 == CELLTYPE_STRING)
					((ScStringCell*)pCell2)->GetString(aStr2);
				else
					GetString(nCell2Col, nCell2Row, aStr2);
				sal_Bool bUserDef = aSortParam.bUserDef;
				if (bUserDef)
				{
					ScUserListData* pData =
						(ScUserListData*)(ScGlobal::GetUserList()->At(
						aSortParam.nUserIndex));
					if (pData)
					{
						if ( aSortParam.bCaseSens )
                            nRes = sal::static_int_cast<short>( pData->Compare(aStr1, aStr2) );
						else
                            nRes = sal::static_int_cast<short>( pData->ICompare(aStr1, aStr2) );
					}
					else
						bUserDef = sal_False;

				}
				if (!bUserDef)
					nRes = (short) pSortCollator->compareString( aStr1, aStr2 );
			}
			else if ( bStr1 )				// String <-> Zahl
				nRes = 1;					// Zahl vorne
			else if ( bStr2 )				// Zahl <-> String
				nRes = -1;					// Zahl vorne
			else							// Zahlen untereinander
			{
				double nVal1;
				double nVal2;
				if (eType1 == CELLTYPE_VALUE)
					nVal1 = ((ScValueCell*)pCell1)->GetValue();
				else if (eType1 == CELLTYPE_FORMULA)
					nVal1 = ((ScFormulaCell*)pCell1)->GetValue();
				else
					nVal1 = 0;
				if (eType2 == CELLTYPE_VALUE)
					nVal2 = ((ScValueCell*)pCell2)->GetValue();
				else if (eType2 == CELLTYPE_FORMULA)
					nVal2 = ((ScFormulaCell*)pCell2)->GetValue();
				else
					nVal2 = 0;
				if (nVal1 < nVal2)
					nRes = -1;
				else if (nVal1 > nVal2)
					nRes = 1;
			}
			if ( !aSortParam.bAscending[nSort] )
				nRes = -nRes;
		}
		else
			nRes = -1;
	}
	else
	{
		if ( pCell2 )
			nRes = 1;
		else
			nRes = 0;					// beide leer
	}
	return nRes;
}

short ScTable::Compare( ScSortInfoArray* pArray, SCCOLROW nIndex1, SCCOLROW nIndex2 )
{
    short nRes;
    sal_uInt16 nSort = 0;
    do
    {
        ScSortInfo* pInfo1 = pArray->Get( nSort, nIndex1 );
        ScSortInfo* pInfo2 = pArray->Get( nSort, nIndex2 );
        if ( aSortParam.bByRow )
            nRes = CompareCell( nSort,
                pInfo1->pCell, static_cast<SCCOL>(aSortParam.nField[nSort]), pInfo1->nOrg,
                pInfo2->pCell, static_cast<SCCOL>(aSortParam.nField[nSort]), pInfo2->nOrg );
        else
            nRes = CompareCell( nSort,
                pInfo1->pCell, static_cast<SCCOL>(pInfo1->nOrg), aSortParam.nField[nSort],
                pInfo2->pCell, static_cast<SCCOL>(pInfo2->nOrg), aSortParam.nField[nSort] );
    } while ( nRes == 0 && ++nSort < pArray->GetUsedSorts() );
    if( nRes == 0 )
    {
        ScSortInfo* pInfo1 = pArray->Get( 0, nIndex1 );
        ScSortInfo* pInfo2 = pArray->Get( 0, nIndex2 );
        if( pInfo1->nOrg < pInfo2->nOrg )
            nRes = -1;
        else if( pInfo1->nOrg > pInfo2->nOrg )
            nRes = 1;
    }
    return nRes;
}

void ScTable::QuickSort( ScSortInfoArray* pArray, SCsCOLROW nLo, SCsCOLROW nHi )
{
	if ((nHi - nLo) == 1)
	{
		if (Compare(pArray, nLo, nHi) > 0)
			pArray->Swap( nLo, nHi );
	}
	else
	{
		SCsCOLROW ni = nLo;
		SCsCOLROW nj = nHi;
		do
		{
			while ((ni <= nHi) && (Compare(pArray, ni, nLo)) < 0)
				ni++;
			while ((nj >= nLo) && (Compare(pArray, nLo, nj)) < 0)
				nj--;
			if (ni <= nj)
			{
				if (ni != nj)
					pArray->Swap( ni, nj );
				ni++;
				nj--;
			}
		} while (ni < nj);
		if ((nj - nLo) < (nHi - ni))
		{
			if (nLo < nj)
				QuickSort(pArray, nLo, nj);
			if (ni < nHi)
				QuickSort(pArray, ni, nHi);
		}
		else
		{
			if (ni < nHi)
				QuickSort(pArray, ni, nHi);
			if (nLo < nj)
				QuickSort(pArray, nLo, nj);
		}
	}
}

void ScTable::SwapCol(SCCOL nCol1, SCCOL nCol2)
{
	for (SCROW nRow = aSortParam.nRow1; nRow <= aSortParam.nRow2; nRow++)
	{
		aCol[nCol1].SwapCell(nRow, aCol[nCol2]);
		if (aSortParam.bIncludePattern)
		{
			const ScPatternAttr* pPat1 = GetPattern(nCol1, nRow);
			const ScPatternAttr* pPat2 = GetPattern(nCol2, nRow);
			if (pPat1 != pPat2)
			{
				SetPattern(nCol1, nRow, *pPat2, sal_True);
				SetPattern(nCol2, nRow, *pPat1, sal_True);
			}
		}
	}
}

void ScTable::SwapRow(SCROW nRow1, SCROW nRow2)
{
	for (SCCOL nCol = aSortParam.nCol1; nCol <= aSortParam.nCol2; nCol++)
	{
		aCol[nCol].SwapRow(nRow1, nRow2);
		if (aSortParam.bIncludePattern)
		{
			const ScPatternAttr* pPat1 = GetPattern(nCol, nRow1);
			const ScPatternAttr* pPat2 = GetPattern(nCol, nRow2);
			if (pPat1 != pPat2)
			{
				SetPattern(nCol, nRow1, *pPat2, sal_True);
				SetPattern(nCol, nRow2, *pPat1, sal_True);
			}
		}
	}
	if (bGlobalKeepQuery)
	{
        bool bRow1Hidden = RowHidden(nRow1);
        bool bRow2Hidden = RowHidden(nRow2);
        SetRowHidden(nRow1, nRow1, bRow2Hidden);
        SetRowHidden(nRow2, nRow2, bRow1Hidden);

        bool bRow1Filtered = RowFiltered(nRow1);
        bool bRow2Filtered = RowFiltered(nRow2);
        SetRowFiltered(nRow1, nRow1, bRow2Filtered);
        SetRowFiltered(nRow2, nRow2, bRow1Filtered);
	}
}

short ScTable::Compare(SCCOLROW nIndex1, SCCOLROW nIndex2)
{
	short nRes;
	sal_uInt16 nSort = 0;
	if (aSortParam.bByRow)
	{
		do
		{
			SCCOL nCol = static_cast<SCCOL>(aSortParam.nField[nSort]);
			ScBaseCell* pCell1 = aCol[nCol].GetCell( nIndex1 );
			ScBaseCell* pCell2 = aCol[nCol].GetCell( nIndex2 );
			nRes = CompareCell( nSort, pCell1, nCol, nIndex1, pCell2, nCol, nIndex2 );
		} while ( nRes == 0 && ++nSort < nMaxSorts && aSortParam.bDoSort[nSort] );
	}
	else
	{
		do
		{
			SCROW nRow = aSortParam.nField[nSort];
			ScBaseCell* pCell1 = aCol[nIndex1].GetCell( nRow );
			ScBaseCell* pCell2 = aCol[nIndex2].GetCell( nRow );
            nRes = CompareCell( nSort, pCell1, static_cast<SCCOL>(nIndex1),
                    nRow, pCell2, static_cast<SCCOL>(nIndex2), nRow );
		} while ( nRes == 0 && ++nSort < nMaxSorts && aSortParam.bDoSort[nSort] );
	}
	return nRes;
}

sal_Bool ScTable::IsSorted( SCCOLROW nStart, SCCOLROW nEnd )    // ueber aSortParam
{
	for (SCCOLROW i=nStart; i<nEnd; i++)
	{
		if (Compare( i, i+1 ) > 0)
			return sal_False;
	}
	return sal_True;
}

void ScTable::DecoladeRow( ScSortInfoArray* pArray, SCROW nRow1, SCROW nRow2 )
{
	SCROW nRow;
	SCROW nMax = nRow2 - nRow1;
	for (SCROW i = nRow1; (i + 4) <= nRow2; i += 4)
	{
		nRow = rand() % nMax;
		pArray->Swap(i, nRow1 + nRow);
	}
}

void ScTable::Sort(const ScSortParam& rSortParam, sal_Bool bKeepQuery)
{
	aSortParam = rSortParam;
	InitSortCollator( rSortParam );
	bGlobalKeepQuery = bKeepQuery;
	if (rSortParam.bByRow)
	{
		SCROW nLastRow = 0;
		for (SCCOL nCol = aSortParam.nCol1; nCol <= aSortParam.nCol2; nCol++)
			nLastRow = Max(nLastRow, aCol[nCol].GetLastDataPos());
		nLastRow = Min(nLastRow, aSortParam.nRow2);
		SCROW nRow1 = (rSortParam.bHasHeader ?
			aSortParam.nRow1 + 1 : aSortParam.nRow1);
		if (!IsSorted(nRow1, nLastRow))
		{
			ScProgress aProgress( pDocument->GetDocumentShell(),
									ScGlobal::GetRscString(STR_PROGRESS_SORTING), nLastRow - nRow1 );
			ScSortInfoArray* pArray = CreateSortInfoArray( nRow1, nLastRow );
			if ( nLastRow - nRow1 > 255 )
				DecoladeRow( pArray, nRow1, nLastRow );
			QuickSort( pArray, nRow1, nLastRow );
			SortReorder( pArray, aProgress );
			delete pArray;
            // #158377# #i59745# update position of caption objects of cell notes
            ScNoteUtil::UpdateCaptionPositions( *pDocument, ScRange( aSortParam.nCol1, nRow1, nTab, aSortParam.nCol2, nLastRow, nTab ) );
		}
	}
	else
	{
		SCCOL nLastCol;
		for (nLastCol = aSortParam.nCol2;
			 (nLastCol > aSortParam.nCol1) && aCol[nLastCol].IsEmptyBlock(aSortParam.nRow1, aSortParam.nRow2); nLastCol--)
		{
		}
		SCCOL nCol1 = (rSortParam.bHasHeader ?
			aSortParam.nCol1 + 1 : aSortParam.nCol1);
		if (!IsSorted(nCol1, nLastCol))
		{
			ScProgress aProgress( pDocument->GetDocumentShell(),
									ScGlobal::GetRscString(STR_PROGRESS_SORTING), nLastCol - nCol1 );
			ScSortInfoArray* pArray = CreateSortInfoArray( nCol1, nLastCol );
			QuickSort( pArray, nCol1, nLastCol );
			SortReorder( pArray, aProgress );
			delete pArray;
            // #158377# #i59745# update position of caption objects of cell notes
            ScNoteUtil::UpdateCaptionPositions( *pDocument, ScRange( nCol1, aSortParam.nRow1, nTab, nLastCol, aSortParam.nRow2, nTab ) );
		}
	}
	DestroySortCollator();
}


//		Testen, ob beim Loeschen von Zwischenergebnissen andere Daten mit geloescht werden
//		(fuer Hinweis-Box)

sal_Bool ScTable::TestRemoveSubTotals( const ScSubTotalParam& rParam )
{
	SCCOL nStartCol = rParam.nCol1;
	SCROW nStartRow = rParam.nRow1 + 1;		// Header
	SCCOL nEndCol   = rParam.nCol2;
	SCROW nEndRow	 = rParam.nRow2;

	SCCOL nCol;
	SCROW nRow;
	ScBaseCell* pCell;

	sal_Bool bWillDelete = sal_False;
	for ( nCol=nStartCol; nCol<=nEndCol && !bWillDelete; nCol++ )
	{
		ScColumnIterator aIter( &aCol[nCol],nStartRow,nEndRow );
		while ( aIter.Next( nRow, pCell ) && !bWillDelete )
		{
			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
				if (((ScFormulaCell*)pCell)->IsSubTotal())
				{
					for (SCCOL nTestCol=0; nTestCol<=MAXCOL; nTestCol++)
						if (nTestCol<nStartCol || nTestCol>nEndCol)
							if (aCol[nTestCol].HasDataAt(nRow))
								bWillDelete = sal_True;
				}
		}
	}
	return bWillDelete;
}

//		alte Ergebnisse loeschen
//		rParam.nRow2 wird veraendert !

void ScTable::RemoveSubTotals( ScSubTotalParam& rParam )
{
	SCCOL nStartCol = rParam.nCol1;
	SCROW nStartRow = rParam.nRow1 + 1;		// Header
	SCCOL nEndCol   = rParam.nCol2;
	SCROW nEndRow	 = rParam.nRow2;			// wird veraendert

	SCCOL nCol;
	SCROW nRow;
	ScBaseCell* pCell;

	for ( nCol=nStartCol; nCol<=nEndCol; nCol++ )
	{
		ScColumnIterator aIter( &aCol[nCol],nStartRow,nEndRow );
		while ( aIter.Next( nRow, pCell ) )
		{
			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
				if (((ScFormulaCell*)pCell)->IsSubTotal())
				{
                    RemoveRowBreak(nRow+1, false, true);
					pDocument->DeleteRow( 0,nTab, MAXCOL,nTab, nRow, 1 );
					--nEndRow;
					aIter = ScColumnIterator( &aCol[nCol],nRow,nEndRow );
				}
		}
	}

	rParam.nRow2 = nEndRow;					// neues Ende
}

//	harte Zahlenformate loeschen (fuer Ergebnisformeln)

void lcl_RemoveNumberFormat( ScTable* pTab, SCCOL nCol, SCROW nRow )
{
	const ScPatternAttr* pPattern = pTab->GetPattern( nCol, nRow );
	if ( pPattern->GetItemSet().GetItemState( ATTR_VALUE_FORMAT, sal_False )
			== SFX_ITEM_SET )
	{
		ScPatternAttr aNewPattern( *pPattern );
		SfxItemSet& rSet = aNewPattern.GetItemSet();
		rSet.ClearItem( ATTR_VALUE_FORMAT );
		rSet.ClearItem( ATTR_LANGUAGE_FORMAT );
		pTab->SetPattern( nCol, nRow, aNewPattern, sal_True );
	}
}


// at least MSC needs this at linkage level to be able to use it in a template
typedef struct lcl_ScTable_DoSubTotals_RowEntry
{
    sal_uInt16  nGroupNo;
    SCROW   nSubStartRow;
    SCROW   nDestRow;
    SCROW   nFuncStart;
    SCROW   nFuncEnd;
} RowEntry;

//		neue Zwischenergebnisse
//		rParam.nRow2 wird veraendert !

sal_Bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
{
	SCCOL nStartCol = rParam.nCol1;
	SCROW nStartRow = rParam.nRow1 + 1;		// Header
	SCCOL nEndCol   = rParam.nCol2;
	SCROW nEndRow	 = rParam.nRow2;			// wird veraendert
	sal_uInt16 i;

	//	Leerzeilen am Ende weglassen,
	//	damit alle Ueberlaeufe (MAXROW) bei InsertRow gefunden werden (#35180#)
	//	Wenn sortiert wurde, sind alle Leerzeilen am Ende.
	SCSIZE nEmpty = GetEmptyLinesInBlock( nStartCol, nStartRow, nEndCol, nEndRow, DIR_BOTTOM );
	nEndRow -= nEmpty;

	sal_uInt16 nLevelCount = 0;				// Anzahl Gruppierungen
	sal_Bool bDoThis = sal_True;
	for (i=0; i<MAXSUBTOTAL && bDoThis; i++)
		if (rParam.bGroupActive[i])
			nLevelCount = i+1;
		else
			bDoThis = sal_False;

	if (nLevelCount==0)					// nichts tun
		return sal_True;

	SCCOL*			nGroupCol = rParam.nField;	// Spalten nach denen
												// gruppiert wird

	//	#44444# Durch (leer) als eigene Kategorie muss immer auf
	//	Teilergebniszeilen aus den anderen Spalten getestet werden
	//	(frueher nur, wenn eine Spalte mehrfach vorkam)
	sal_Bool bTestPrevSub = ( nLevelCount > 1 );

	String	aSubString;
	String	aOutString;

	sal_Bool bIgnoreCase = !rParam.bCaseSens;

	String *pCompString[MAXSUBTOTAL];				// Pointer wegen Compiler-Problemen
	for (i=0; i<MAXSUBTOTAL; i++)
		pCompString[i] = new String;

								//! sortieren?

	ScStyleSheet* pStyle = (ScStyleSheet*) pDocument->GetStyleSheetPool()->Find(
								ScGlobal::GetRscString(STR_STYLENAME_RESULT), SFX_STYLE_FAMILY_PARA );

	sal_Bool bSpaceLeft = sal_True;											// Erfolg beim Einfuegen?

    // #90279# For performance reasons collect formula entries so their
    // references don't have to be tested for updates each time a new row is
    // inserted
    RowEntry aRowEntry;
    ::std::vector< RowEntry > aRowVector;

	for (sal_uInt16 nLevel=0; nLevel<=nLevelCount && bSpaceLeft; nLevel++)		// incl. Gesamtergebnis
	{
		sal_Bool bTotal = ( nLevel == nLevelCount );
		aRowEntry.nGroupNo = bTotal ? 0 : (nLevelCount-nLevel-1);

        // how many results per level
        SCCOL nResCount         = rParam.nSubTotals[aRowEntry.nGroupNo];
        // result functions
        ScSubTotalFunc* eResFunc = rParam.pFunctions[aRowEntry.nGroupNo];

		if (nResCount > 0)										// sonst nur sortieren
		{
			for (i=0; i<=aRowEntry.nGroupNo; i++)
			{
				GetString( nGroupCol[i], nStartRow, aSubString );
                if ( bIgnoreCase )
                    *pCompString[i] = ScGlobal::pCharClass->upper( aSubString );
                else
                    *pCompString[i] = aSubString;
			}													// aSubString bleibt auf dem letzten stehen

			sal_Bool bBlockVis = sal_False;				// Gruppe eingeblendet?
			aRowEntry.nSubStartRow = nStartRow;
			for (SCROW nRow=nStartRow; nRow<=nEndRow+1 && bSpaceLeft; nRow++)
			{
                sal_Bool bChanged;
				if (nRow>nEndRow)
					bChanged = sal_True;
				else
				{
					bChanged = sal_False;
					if (!bTotal)
					{
                        String aString;
						for (i=0; i<=aRowEntry.nGroupNo && !bChanged; i++)
						{
							GetString( nGroupCol[i], nRow, aString );
							if (bIgnoreCase)
								ScGlobal::pCharClass->toUpper( aString );
							//	#41427# wenn sortiert, ist "leer" eine eigene Gruppe
							//	sonst sind leere Zellen unten erlaubt
							bChanged = ( ( aString.Len() || rParam.bDoSort ) &&
											aString != *pCompString[i] );
						}
						if ( bChanged && bTestPrevSub )
						{
                            // No group change on rows that will contain subtotal formulas
                            for ( ::std::vector< RowEntry >::const_iterator
                                    iEntry( aRowVector.begin());
                                    iEntry != aRowVector.end(); ++iEntry)
                            {
                                if ( iEntry->nDestRow == nRow )
                                {
                                    bChanged = sal_False;
                                    break;
                                }
                            }
						}
					}
				}
				if ( bChanged )
				{
					aRowEntry.nDestRow   = nRow;
					aRowEntry.nFuncStart = aRowEntry.nSubStartRow;
					aRowEntry.nFuncEnd   = nRow-1;

                    bSpaceLeft = pDocument->InsertRow( 0, nTab, MAXCOL, nTab,
                            aRowEntry.nDestRow, 1 );
					DBShowRow( aRowEntry.nDestRow, bBlockVis );
					bBlockVis = sal_False;
                    if ( rParam.bPagebreak && nRow < MAXROW &&
                            aRowEntry.nSubStartRow != nStartRow && nLevel == 0)
                        SetRowBreak(aRowEntry.nSubStartRow, false, true);

					if (bSpaceLeft)
					{
                        for ( ::std::vector< RowEntry >::iterator iMove(
                                    aRowVector.begin() );
                                iMove != aRowVector.end(); ++iMove)
                        {
                            if ( aRowEntry.nDestRow <= iMove->nSubStartRow )
                                ++iMove->nSubStartRow;
                            if ( aRowEntry.nDestRow <= iMove->nDestRow )
                                ++iMove->nDestRow;
                            if ( aRowEntry.nDestRow <= iMove->nFuncStart )
                                ++iMove->nFuncStart;
                            if ( aRowEntry.nDestRow <= iMove->nFuncEnd )
                                ++iMove->nFuncEnd;
                        }
                        // collect formula positions
                        aRowVector.push_back( aRowEntry );

						if (bTotal)		// "Gesamtergebnis"
							aOutString = ScGlobal::GetRscString( STR_TABLE_GESAMTERGEBNIS );
						else
						{				// " Ergebnis"
							aOutString = aSubString;
							if (!aOutString.Len())
								aOutString = ScGlobal::GetRscString( STR_EMPTYDATA );
							aOutString += ' ';
							sal_uInt16 nStrId = STR_TABLE_ERGEBNIS;
							if ( nResCount == 1 )
								switch ( eResFunc[0] )
								{
									case SUBTOTAL_FUNC_AVE:		nStrId = STR_FUN_TEXT_AVG;		break;
									case SUBTOTAL_FUNC_CNT:
									case SUBTOTAL_FUNC_CNT2:	nStrId = STR_FUN_TEXT_COUNT;	break;
									case SUBTOTAL_FUNC_MAX:		nStrId = STR_FUN_TEXT_MAX;		break;
									case SUBTOTAL_FUNC_MIN:		nStrId = STR_FUN_TEXT_MIN;		break;
									case SUBTOTAL_FUNC_PROD:	nStrId = STR_FUN_TEXT_PRODUCT;	break;
									case SUBTOTAL_FUNC_STD:
									case SUBTOTAL_FUNC_STDP:	nStrId = STR_FUN_TEXT_STDDEV;	break;
									case SUBTOTAL_FUNC_SUM:		nStrId = STR_FUN_TEXT_SUM;		break;
									case SUBTOTAL_FUNC_VAR:
									case SUBTOTAL_FUNC_VARP:	nStrId = STR_FUN_TEXT_VAR;		break;
                                    default:
                                    {
                                        // added to avoid warnings
                                    }
								}
							aOutString += ScGlobal::GetRscString( nStrId );
						}
						SetString( nGroupCol[aRowEntry.nGroupNo], aRowEntry.nDestRow, nTab, aOutString );
						ApplyStyle( nGroupCol[aRowEntry.nGroupNo], aRowEntry.nDestRow, *pStyle );

						++nRow;
						++nEndRow;
						aRowEntry.nSubStartRow = nRow;
						for (i=0; i<=aRowEntry.nGroupNo; i++)
						{
							GetString( nGroupCol[i], nRow, aSubString );
                            if ( bIgnoreCase )
                                *pCompString[i] = ScGlobal::pCharClass->upper( aSubString );
                            else
                                *pCompString[i] = aSubString;
						}
					}
				}
                bBlockVis = !RowFiltered(nRow);
			}
		}
		else
		{
//			DBG_ERROR( "nSubTotals==0 bei DoSubTotals" );
		}
	}

    // now insert the formulas
    ScComplexRefData aRef;
    aRef.InitFlags();
    aRef.Ref1.nTab = nTab;
    aRef.Ref2.nTab = nTab;
    for ( ::std::vector< RowEntry >::const_iterator iEntry( aRowVector.begin());
            iEntry != aRowVector.end(); ++iEntry)
    {
        SCCOL nResCount         = rParam.nSubTotals[iEntry->nGroupNo];
        SCCOL* nResCols         = rParam.pSubTotals[iEntry->nGroupNo];
        ScSubTotalFunc* eResFunc = rParam.pFunctions[iEntry->nGroupNo];
        for ( SCCOL nResult=0; nResult < nResCount; ++nResult )
        {
            aRef.Ref1.nCol = nResCols[nResult];
            aRef.Ref1.nRow = iEntry->nFuncStart;
            aRef.Ref2.nCol = nResCols[nResult];
            aRef.Ref2.nRow = iEntry->nFuncEnd;

            ScTokenArray aArr;
            aArr.AddOpCode( ocSubTotal );
            aArr.AddOpCode( ocOpen );
            aArr.AddDouble( (double) eResFunc[nResult] );
            aArr.AddOpCode( ocSep );
            aArr.AddDoubleReference( aRef );
            aArr.AddOpCode( ocClose );
            aArr.AddOpCode( ocStop );
            ScBaseCell* pCell = new ScFormulaCell( pDocument, ScAddress(
                        nResCols[nResult], iEntry->nDestRow, nTab), &aArr );
            PutCell( nResCols[nResult], iEntry->nDestRow, pCell );

            if ( nResCols[nResult] != nGroupCol[iEntry->nGroupNo] )
            {
                ApplyStyle( nResCols[nResult], iEntry->nDestRow, *pStyle );

                //	Zahlformat loeschen
                lcl_RemoveNumberFormat( this, nResCols[nResult], iEntry->nDestRow );
            }
        }

    }

	//!		je nach Einstellung Zwischensummen-Zeilen nach oben verschieben ?

	//!		Outlines direkt erzeugen?

	if (bSpaceLeft)
		DoAutoOutline( nStartCol, nStartRow, nEndCol, nEndRow );

	for (i=0; i<MAXSUBTOTAL; i++)
		delete pCompString[i];

	rParam.nRow2 = nEndRow;					// neues Ende
	return bSpaceLeft;
}


sal_Bool ScTable::ValidQuery(SCROW nRow, const ScQueryParam& rParam,
        sal_Bool* pSpecial /* =NULL */ , ScBaseCell* pCell /* =NULL */ ,
        sal_Bool* pbTestEqualCondition /* = NULL */ )
{
	if (!rParam.GetEntry(0).bDoQuery)
		return sal_True;

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

	const SCSIZE nFixedBools = 32;
	sal_Bool aBool[nFixedBools];
    sal_Bool aTest[nFixedBools];
	SCSIZE nEntryCount = rParam.GetEntryCount();
    sal_Bool* pPasst = ( nEntryCount <= nFixedBools ? &aBool[0] : new sal_Bool[nEntryCount] );
    sal_Bool* pTest = ( nEntryCount <= nFixedBools ? &aTest[0] : new sal_Bool[nEntryCount] );

	long	nPos = -1;
	SCSIZE	i	 = 0;
	sal_Bool	bMatchWholeCell = pDocument->GetDocOptions().IsMatchWholeCell();
	CollatorWrapper* pCollator = (rParam.bCaseSens ? ScGlobal::GetCaseCollator() :
		ScGlobal::GetCollator());
    ::utl::TransliterationWrapper* pTransliteration = (rParam.bCaseSens ?
        ScGlobal::GetCaseTransliteration() : ScGlobal::GetpTransliteration());

	while ( (i < nEntryCount) && rParam.GetEntry(i).bDoQuery )
	{
		ScQueryEntry& rEntry = rParam.GetEntry(i);
        // we can only handle one single direct query
        if ( !pCell || i > 0 )
            pCell = GetCell( static_cast<SCCOL>(rEntry.nField), nRow );

		sal_Bool bOk = sal_False;
        sal_Bool bTestEqual = sal_False;

		if ( pSpecial && pSpecial[i] )
		{
			if (rEntry.nVal == SC_EMPTYFIELDS)
				bOk = !( aCol[rEntry.nField].HasDataAt( nRow ) );
			else // if (rEntry.nVal == SC_NONEMPTYFIELDS)
				bOk = aCol[rEntry.nField].HasDataAt( nRow );
		}
        else if ( !rEntry.bQueryByString && (pCell ? pCell->HasValueData() :
                    HasValueData( static_cast<SCCOL>(rEntry.nField), nRow)))
		{	// by Value
            double nCellVal;
            if ( pCell )
            {
                switch ( pCell->GetCellType() )
                {
                    case CELLTYPE_VALUE :
                        nCellVal = ((ScValueCell*)pCell)->GetValue();
                    break;
                    case CELLTYPE_FORMULA :
                        nCellVal = ((ScFormulaCell*)pCell)->GetValue();
                    break;
                    default:
                        nCellVal = 0.0;
                }

            }
            else
                nCellVal = GetValue( static_cast<SCCOL>(rEntry.nField), nRow );

            /* NOTE: lcl_PrepareQuery() prepares a filter query such that if a 
             * date+time format was queried rEntry.bQueryByDate is not set. In 
             * case other queries wanted to use this mechanism they should do 
             * the same, in other words only if rEntry.nVal is an integer value 
             * rEntry.bQueryByDate should be true and the time fraction be 
             * stripped here. */
            if (rEntry.bQueryByDate)
            {
                sal_uInt32 nNumFmt = GetNumberFormat(static_cast<SCCOL>(rEntry.nField), nRow);
                const SvNumberformat* pEntry = pDocument->GetFormatTable()->GetEntry(nNumFmt);
                if (pEntry)
                {
                    short nNumFmtType = pEntry->GetType();
                    /* NOTE: Omitting the check for absence of 
                     * NUMBERFORMAT_TIME would include also date+time formatted 
                     * values of the same day. That may be desired in some 
                     * cases, querying all time values of a day, but confusing 
                     * in other cases. A user can always setup a standard 
                     * filter query for x >= date AND x < date+1 */
                    if ((nNumFmtType & NUMBERFORMAT_DATE) && !(nNumFmtType & NUMBERFORMAT_TIME))
                    {
                        // The format is of date type.  Strip off the time 
                        // element.
                        nCellVal = ::rtl::math::approxFloor(nCellVal);
                    }
                }
            }

			switch (rEntry.eOp)
			{
				case SC_EQUAL :
                    bOk = ::rtl::math::approxEqual( nCellVal, rEntry.nVal );
					break;
				case SC_LESS :
					bOk = (nCellVal < rEntry.nVal) && !::rtl::math::approxEqual( nCellVal, rEntry.nVal );
					break;
				case SC_GREATER :
					bOk = (nCellVal > rEntry.nVal) && !::rtl::math::approxEqual( nCellVal, rEntry.nVal );
					break;
				case SC_LESS_EQUAL :
					bOk = (nCellVal < rEntry.nVal) || ::rtl::math::approxEqual( nCellVal, rEntry.nVal );
                    if ( bOk && pbTestEqualCondition )
                        bTestEqual = ::rtl::math::approxEqual( nCellVal, rEntry.nVal );
					break;
				case SC_GREATER_EQUAL :
					bOk = (nCellVal > rEntry.nVal) || ::rtl::math::approxEqual( nCellVal, rEntry.nVal );
                    if ( bOk && pbTestEqualCondition )
                        bTestEqual = ::rtl::math::approxEqual( nCellVal, rEntry.nVal );
					break;
				case SC_NOT_EQUAL :
                    bOk = !::rtl::math::approxEqual( nCellVal, rEntry.nVal );
					break;
                default:
                {
                    // added to avoid warnings
                }
			}
		}
        else if ( (rEntry.eOp == SC_EQUAL || rEntry.eOp == SC_NOT_EQUAL) ||
                  (rEntry.eOp == SC_CONTAINS || rEntry.eOp == SC_DOES_NOT_CONTAIN || 
                   rEntry.eOp == SC_BEGINS_WITH || rEntry.eOp == SC_ENDS_WITH ||
                   rEntry.eOp == SC_DOES_NOT_BEGIN_WITH || rEntry.eOp == SC_DOES_NOT_END_WITH) ||
                (rEntry.bQueryByString && (pCell ? pCell->HasStringData() :
                                           HasStringData(
                                               static_cast<SCCOL>(rEntry.nField),
                                               nRow))))
		{	// by String
			String	aCellStr;
            if( rEntry.eOp == SC_CONTAINS || rEntry.eOp == SC_DOES_NOT_CONTAIN
                || rEntry.eOp == SC_BEGINS_WITH || rEntry.eOp == SC_ENDS_WITH
                || rEntry.eOp == SC_DOES_NOT_BEGIN_WITH || rEntry.eOp == SC_DOES_NOT_END_WITH )
                bMatchWholeCell = sal_False;
            if ( pCell )
            {
                if (pCell->GetCellType() != CELLTYPE_NOTE)
                {
                    sal_uLong nFormat = GetNumberFormat( static_cast<SCCOL>(rEntry.nField), nRow );
                    ScCellFormat::GetInputString( pCell, nFormat, aCellStr, *(pDocument->GetFormatTable()) );
                }
            }
            else
                GetInputString( static_cast<SCCOL>(rEntry.nField), nRow, aCellStr );

            sal_Bool bRealRegExp = (rParam.bRegExp && ((rEntry.eOp == SC_EQUAL)
                || (rEntry.eOp == SC_NOT_EQUAL) || (rEntry.eOp == SC_CONTAINS) 
                || (rEntry.eOp == SC_DOES_NOT_CONTAIN) || (rEntry.eOp == SC_BEGINS_WITH)
                || (rEntry.eOp == SC_ENDS_WITH) || (rEntry.eOp == SC_DOES_NOT_BEGIN_WITH)
                || (rEntry.eOp == SC_DOES_NOT_END_WITH)));
            sal_Bool bTestRegExp = (pbTestEqualCondition && rParam.bRegExp
                && ((rEntry.eOp == SC_LESS_EQUAL)
                    || (rEntry.eOp == SC_GREATER_EQUAL)));
            if ( bRealRegExp || bTestRegExp )
            {
				xub_StrLen nStart = 0;
				xub_StrLen nEnd   = aCellStr.Len();
                
				// from 614 on, nEnd is behind the found text
                sal_Bool bMatch = sal_False;
                if ( rEntry.eOp == SC_ENDS_WITH || rEntry.eOp == SC_DOES_NOT_END_WITH )
                {
                    nEnd = 0;
                    nStart = aCellStr.Len();
                    bMatch = (sal_Bool) rEntry.GetSearchTextPtr( rParam.bCaseSens )
                        ->SearchBkwrd( aCellStr, &nStart, &nEnd );
                } 
                else
                {
                    bMatch = (sal_Bool) rEntry.GetSearchTextPtr( rParam.bCaseSens )
                        ->SearchFrwrd( aCellStr, &nStart, &nEnd );
                }
                if ( bMatch && bMatchWholeCell
						&& (nStart != 0 || nEnd != aCellStr.Len()) )
                    bMatch = sal_False;    // RegExp must match entire cell string
                if ( bRealRegExp )
                    switch (rEntry.eOp)
                {
                    case SC_EQUAL:
                    case SC_CONTAINS:
                        bOk = bMatch;
                        break;
                    case SC_NOT_EQUAL:
                    case SC_DOES_NOT_CONTAIN:
                        bOk = !bMatch;
                        break;
                    case SC_BEGINS_WITH:
                        bOk = ( bMatch && (nStart == 0) );
                        break;
                    case SC_DOES_NOT_BEGIN_WITH:
                        bOk = !( bMatch && (nStart == 0) );
                        break;
                    case SC_ENDS_WITH:
                        bOk = ( bMatch && (nEnd == aCellStr.Len()) );
                        break;
                    case SC_DOES_NOT_END_WITH:
                        bOk = !( bMatch && (nEnd == aCellStr.Len()) );
                        break;
                    default:
                        {
                            // added to avoid warnings
                        }
                }
                else
                    bTestEqual = bMatch;
            }
            if ( !bRealRegExp )
			{
                if ( rEntry.eOp == SC_EQUAL || rEntry.eOp == SC_NOT_EQUAL
                    || rEntry.eOp == SC_CONTAINS || rEntry.eOp == SC_DOES_NOT_CONTAIN
                    || rEntry.eOp == SC_BEGINS_WITH || rEntry.eOp == SC_ENDS_WITH
                    || rEntry.eOp == SC_DOES_NOT_BEGIN_WITH || rEntry.eOp == SC_DOES_NOT_END_WITH )
				{
                    if ( !rEntry.bQueryByString && rEntry.pStr->Len() == 0 )
                    {
                        // #i18374# When used from functions (match, countif, sumif, vlookup, hlookup, lookup),
                        // the query value is assigned directly, and the string is empty. In that case,
                        // don't find any string (isEqual would find empty string results in formula cells).
                        bOk = sal_False;
                        if ( rEntry.eOp == SC_NOT_EQUAL )
                            bOk = !bOk;
                    }
                    else if ( bMatchWholeCell )
                    {
                        bOk = pTransliteration->isEqual( aCellStr, *rEntry.pStr );
                        if ( rEntry.eOp == SC_NOT_EQUAL )
                            bOk = !bOk;
                    }
					else
					{
                        String aCell( pTransliteration->transliterate(
                            aCellStr, ScGlobal::eLnge, 0, aCellStr.Len(),
                            NULL ) );
                        String aQuer( pTransliteration->transliterate(
                            *rEntry.pStr, ScGlobal::eLnge, 0, rEntry.pStr->Len(),
                            NULL ) );
                        xub_StrLen nIndex = (rEntry.eOp == SC_ENDS_WITH 
                            || rEntry.eOp == SC_DOES_NOT_END_WITH)? (aCell.Len()-aQuer.Len()):0;
                        xub_StrLen nStrPos = aCell.Search( aQuer, nIndex );
                        switch (rEntry.eOp)
                        {
                        case SC_EQUAL:
                        case SC_CONTAINS:
                            bOk = ( nStrPos != STRING_NOTFOUND );
                            break;
                        case SC_NOT_EQUAL:
                        case SC_DOES_NOT_CONTAIN:
                            bOk = ( nStrPos == STRING_NOTFOUND );
                            break;
                        case SC_BEGINS_WITH:
                            bOk = ( nStrPos == 0 );
                            break;
                        case SC_DOES_NOT_BEGIN_WITH:
                            bOk = ( nStrPos != 0 );
                            break;
                        case SC_ENDS_WITH:
                            bOk = ( nStrPos + aQuer.Len() == aCell.Len() );
                            break;
                        case SC_DOES_NOT_END_WITH:
                            bOk = ( nStrPos + aQuer.Len() != aCell.Len() );
                            break;
                        default:
                            {
                                // added to avoid warnings
                            }
                        }
					}
				}
				else
                {   // use collator here because data was probably sorted
					sal_Int32 nCompare = pCollator->compareString(
						aCellStr, *rEntry.pStr );
					switch (rEntry.eOp)
					{
						case SC_LESS :
                            bOk = (nCompare < 0);
							break;
						case SC_GREATER :
                            bOk = (nCompare > 0);
							break;
						case SC_LESS_EQUAL :
                            bOk = (nCompare <= 0);
                            if ( bOk && pbTestEqualCondition && !bTestEqual )
                                bTestEqual = (nCompare == 0);
							break;
						case SC_GREATER_EQUAL :
                            bOk = (nCompare >= 0);
                            if ( bOk && pbTestEqualCondition && !bTestEqual )
                                bTestEqual = (nCompare == 0);
							break;
                        default:
                        {
                            // added to avoid warnings
                        }
					}
				}
			}
		}
        else if (rParam.bMixedComparison)
        {
            if (rEntry.bQueryByString &&
                    (rEntry.eOp == SC_LESS || rEntry.eOp == SC_LESS_EQUAL) &&
                    (pCell ? pCell->HasValueData() :
                     HasValueData( static_cast<SCCOL>(rEntry.nField), nRow)))
            {
                bOk = sal_True;
            }
            else if (!rEntry.bQueryByString &&
                    (rEntry.eOp == SC_GREATER || rEntry.eOp == SC_GREATER_EQUAL) &&
                    (pCell ? pCell->HasStringData() :
                     HasStringData( static_cast<SCCOL>(rEntry.nField), nRow)))
            {
                bOk = sal_True;
            }
        }

		if (nPos == -1)
		{
			nPos++;
			pPasst[nPos] = bOk;
            pTest[nPos] = bTestEqual;
		}
		else
		{
			if (rEntry.eConnect == SC_AND)
            {
				pPasst[nPos] = pPasst[nPos] && bOk;
                pTest[nPos] = pTest[nPos] && bTestEqual;
            }
			else
			{
				nPos++;
				pPasst[nPos] = bOk;
                pTest[nPos] = bTestEqual;
			}
		}
		i++;
	}

	for ( long j=1; j <= nPos; j++ )
    {
		pPasst[0] = pPasst[0] || pPasst[j];
        pTest[0] = pTest[0] || pTest[j];
    }

	sal_Bool bRet = pPasst[0];
	if ( pPasst != &aBool[0] )
		delete [] pPasst;
    if ( pbTestEqualCondition )
        *pbTestEqualCondition = pTest[0];
    if ( pTest != &aTest[0] )
        delete [] pTest;

	return bRet;
}

void ScTable::TopTenQuery( ScQueryParam& rParam )
{
	sal_Bool bSortCollatorInitialized = sal_False;
	SCSIZE nEntryCount = rParam.GetEntryCount();
	SCROW nRow1 = (rParam.bHasHeader ? rParam.nRow1 + 1 : rParam.nRow1);
	SCSIZE nCount = static_cast<SCSIZE>(rParam.nRow2 - nRow1 + 1);
	for ( SCSIZE i=0; (i<nEntryCount) && (rParam.GetEntry(i).bDoQuery); i++ )
	{
		ScQueryEntry& rEntry = rParam.GetEntry(i);
		switch ( rEntry.eOp )
		{
			case SC_TOPVAL:
			case SC_BOTVAL:
			case SC_TOPPERC:
			case SC_BOTPERC:
			{
				ScSortParam aLocalSortParam( rParam, static_cast<SCCOL>(rEntry.nField) );
				aSortParam = aLocalSortParam;		// used in CreateSortInfoArray, Compare
				if ( !bSortCollatorInitialized )
				{
					bSortCollatorInitialized = sal_True;
					InitSortCollator( aLocalSortParam );
				}
				ScSortInfoArray* pArray = CreateSortInfoArray( nRow1, rParam.nRow2 );
				DecoladeRow( pArray, nRow1, rParam.nRow2 );
				QuickSort( pArray, nRow1, rParam.nRow2 );
				ScSortInfo** ppInfo = pArray->GetFirstArray();
				SCSIZE nValidCount = nCount;
				// keine Note-/Leerzellen zaehlen, sind ans Ende sortiert
                while ( nValidCount > 0 && ( ppInfo[nValidCount-1]->pCell == NULL ||
                                             ppInfo[nValidCount-1]->pCell->GetCellType() == CELLTYPE_NOTE ) )
					nValidCount--;
				// keine Strings zaehlen, sind zwischen Value und Leer
				while ( nValidCount > 0
				  && ppInfo[nValidCount-1]->pCell->HasStringData() )
					nValidCount--;
				if ( nValidCount > 0 )
				{
					if ( rEntry.bQueryByString )
					{	// dat wird nix
						rEntry.bQueryByString = sal_False;
						rEntry.nVal = 10;	// 10 bzw. 10%
					}
					SCSIZE nVal = (rEntry.nVal >= 1 ? static_cast<SCSIZE>(rEntry.nVal) : 1);
					SCSIZE nOffset = 0;
					switch ( rEntry.eOp )
					{
						case SC_TOPVAL:
						{
							rEntry.eOp = SC_GREATER_EQUAL;
							if ( nVal > nValidCount )
								nVal = nValidCount;
							nOffset = nValidCount - nVal;	// 1 <= nVal <= nValidCount
						}
						break;
						case SC_BOTVAL:
						{
							rEntry.eOp = SC_LESS_EQUAL;
							if ( nVal > nValidCount )
								nVal = nValidCount;
							nOffset = nVal - 1;		// 1 <= nVal <= nValidCount
						}
						break;
						case SC_TOPPERC:
						{
							rEntry.eOp = SC_GREATER_EQUAL;
							if ( nVal > 100 )
								nVal = 100;
							nOffset = nValidCount - (nValidCount * nVal / 100);
							if ( nOffset >= nValidCount )
								nOffset = nValidCount - 1;
						}
						break;
						case SC_BOTPERC:
						{
							rEntry.eOp = SC_LESS_EQUAL;
							if ( nVal > 100 )
								nVal = 100;
							nOffset = (nValidCount * nVal / 100);
							if ( nOffset >= nValidCount )
								nOffset = nValidCount - 1;
						}
						break;
                        default:
                        {
                            // added to avoid warnings
                        }
					}
					ScBaseCell* pCell = ppInfo[nOffset]->pCell;
					if ( pCell->HasValueData() )
					{
						if ( pCell->GetCellType() == CELLTYPE_VALUE )
							rEntry.nVal = ((ScValueCell*)pCell)->GetValue();
						else
							rEntry.nVal = ((ScFormulaCell*)pCell)->GetValue();
					}
					else
					{
						DBG_ERRORFILE( "TopTenQuery: pCell kein ValueData" );
						rEntry.eOp = SC_GREATER_EQUAL;
						rEntry.nVal = 0;
					}
				}
				else
				{
					rEntry.eOp = SC_GREATER_EQUAL;
					rEntry.bQueryByString = sal_False;
					rEntry.nVal = 0;
				}
				delete pArray;
			}
            break;
            default:
            {
                // added to avoid warnings
            }
		}
	}
	if ( bSortCollatorInitialized )
		DestroySortCollator();
}

static void lcl_PrepareQuery( ScDocument* pDoc, ScTable* pTab, ScQueryParam& rParam, sal_Bool* pSpecial )
{
    bool bTopTen = false;
    SCSIZE nEntryCount = rParam.GetEntryCount();

    for ( SCSIZE i = 0; i < nEntryCount; ++i )
    {
        pSpecial[i] = sal_False;
        ScQueryEntry& rEntry = rParam.GetEntry(i);
        if ( rEntry.bDoQuery )
        {
            if ( rEntry.bQueryByString )
            {
                sal_uInt32 nIndex = 0;
                rEntry.bQueryByString = !( pDoc->GetFormatTable()->
                    IsNumberFormat( *rEntry.pStr, nIndex, rEntry.nVal ) );
                if (rEntry.bQueryByDate)
                {
                    if (!rEntry.bQueryByString && ((nIndex % SV_COUNTRY_LANGUAGE_OFFSET) != 0))
                    {
                        const SvNumberformat* pEntry = pDoc->GetFormatTable()->GetEntry(nIndex);
                        if (pEntry)
                        {
                            short nNumFmtType = pEntry->GetType();
                            if (!((nNumFmtType & NUMBERFORMAT_DATE) && !(nNumFmtType & NUMBERFORMAT_TIME)))
                                rEntry.bQueryByDate = false;    // not a date only
                        }
                        else
                            rEntry.bQueryByDate = false;    // what the ... not a date
                    }
                    else
                        rEntry.bQueryByDate = false;    // not a date
                }
            }
            else
            {
                // #58736# call from UNO or second call from autofilter
                if ( rEntry.nVal == SC_EMPTYFIELDS || rEntry.nVal == SC_NONEMPTYFIELDS )
                {
                    pSpecial[i] = sal_True;
                }
            }
            if ( !bTopTen )
            {
                switch ( rEntry.eOp )
                {
                    case SC_TOPVAL:
                    case SC_BOTVAL:
                    case SC_TOPPERC:
                    case SC_BOTPERC:
                    {
                        bTopTen = true;
                    }
                    break;
                    default:
                    {
                    }
                }
            }
        }
    }

    if ( bTopTen )
    {
        pTab->TopTenQuery( rParam );
    }
}

SCSIZE ScTable::Query(ScQueryParam& rParamOrg, sal_Bool bKeepSub)
{
    ScQueryParam    aParam( rParamOrg );
	ScStrCollection	aScStrCollection;
	StrData*		pStrData = NULL;

	sal_Bool	bStarted = sal_False;
	sal_Bool	bOldResult = sal_True;
	SCROW	nOldStart = 0;
	SCROW	nOldEnd = 0;

	SCSIZE nCount	= 0;
	SCROW nOutRow	= 0;
    SCROW nHeader   = aParam.bHasHeader ? 1 : 0;

    SCSIZE nEntryCount = aParam.GetEntryCount();
	sal_Bool* pSpecial = new sal_Bool[nEntryCount];
    lcl_PrepareQuery( pDocument, this, aParam, pSpecial );

	if (!aParam.bInplace)
	{
		nOutRow = aParam.nDestRow + nHeader;
		if (nHeader > 0)
			CopyData( aParam.nCol1, aParam.nRow1, aParam.nCol2, aParam.nRow1,
							aParam.nDestCol, aParam.nDestRow, aParam.nDestTab );
	}

    if (aParam.bInplace)
        IncRecalcLevel();       // #i116164# once for all entries

    // #i116164# If there are no drawing objects within the area, call SetRowHidden/SetRowFiltered for all rows at the end
    std::vector<ScShowRowsEntry> aEntries;
    ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
    bool bHasObjects = pDrawLayer && pDrawLayer->HasObjectsInRows( nTab, aParam.nRow1 + nHeader, aParam.nRow2, false );

	for (SCROW j=aParam.nRow1 + nHeader; j<=aParam.nRow2; j++)
	{
		sal_Bool bResult;									// Filterergebnis
		sal_Bool bValid = ValidQuery(j, aParam, pSpecial);
		if (!bValid && bKeepSub)						// Subtotals stehenlassen
		{
			for (SCCOL nCol=aParam.nCol1; nCol<=aParam.nCol2 && !bValid; nCol++)
			{
				ScBaseCell* pCell;
				pCell = GetCell( nCol, j );
				if ( pCell )
					if ( pCell->GetCellType() == CELLTYPE_FORMULA )
						if (((ScFormulaCell*)pCell)->IsSubTotal())
							if (RefVisible((ScFormulaCell*)pCell))
								bValid = sal_True;
			}
		}
		if (bValid)
		{
			if (aParam.bDuplicate)
				bResult = sal_True;
			else
			{
				String aStr;
				for (SCCOL k=aParam.nCol1; k <= aParam.nCol2; k++)
				{
					String aCellStr;
					GetString(k, j, aCellStr);
					aStr += aCellStr;
					aStr += (sal_Unicode)1;
				}
				pStrData = new StrData(aStr);

				sal_Bool bIsUnique = sal_True;
				if (pStrData)
					bIsUnique = aScStrCollection.Insert(pStrData);
				if (bIsUnique)
					bResult = sal_True;
				else
				{
					delete pStrData;
					bResult = sal_False;
				}
			}
		}
		else
			bResult = sal_False;

		if (aParam.bInplace)
		{
			if (bResult == bOldResult && bStarted)
				nOldEnd = j;
			else
			{
				if (bStarted)
                {
                    DBShowRows(nOldStart,nOldEnd, bOldResult, bHasObjects);
                    if (!bHasObjects)
                        aEntries.push_back(ScShowRowsEntry(nOldStart, nOldEnd, bOldResult));
                }
				nOldStart = nOldEnd = j;
				bOldResult = bResult;
			}
			bStarted = sal_True;
		}
		else
		{
			if (bResult)
			{
				CopyData( aParam.nCol1,j, aParam.nCol2,j, aParam.nDestCol,nOutRow,aParam.nDestTab );
				++nOutRow;
			}
		}
		if (bResult)
			++nCount;
	}

	if (aParam.bInplace && bStarted)
    {
        DBShowRows(nOldStart,nOldEnd, bOldResult, bHasObjects);
        if (!bHasObjects)
            aEntries.push_back(ScShowRowsEntry(nOldStart, nOldEnd, bOldResult));
    }

    // #i116164# execute the collected SetRowHidden/SetRowFiltered calls
    if (!bHasObjects)
    {
        std::vector<ScShowRowsEntry>::const_iterator aEnd = aEntries.end();
        std::vector<ScShowRowsEntry>::const_iterator aIter = aEntries.begin();
        if ( aIter != aEnd )
        {
            // do only one HeightChanged call with the final difference in heights
            long nOldHeight = 0;
            if ( pDrawLayer )
                nOldHeight = static_cast<long>(GetRowHeight(aParam.nRow1 + nHeader, aParam.nRow2));

            // clear the range first instead of many changes in the middle of the filled array
            SetRowHidden(aParam.nRow1 + nHeader, aParam.nRow2, false);
            SetRowFiltered(aParam.nRow1 + nHeader, aParam.nRow2, false);

            // insert from back, in case the filter range is large
            mpHiddenRows->setInsertFromBack(true);
            mpFilteredRows->setInsertFromBack(true);

            while (aIter != aEnd)
            {
                if (!aIter->mbShow)
                {
                    SCROW nStartRow = aIter->mnRow1;
                    SCROW nEndRow = aIter->mnRow2;
                    SetRowHidden(nStartRow, nEndRow, true);
                    SetRowFiltered(nStartRow, nEndRow, true);
                }
                ++aIter;
            }

            mpHiddenRows->setInsertFromBack(false);
            mpFilteredRows->setInsertFromBack(false);

            if ( pDrawLayer )
            {
                // if there are no objects in the filtered range, a single HeightChanged call is enough
                long nNewHeight = static_cast<long>(GetRowHeight(aParam.nRow1 + nHeader, aParam.nRow2));
                pDrawLayer->HeightChanged( nTab, aParam.nRow1 + nHeader, nNewHeight - nOldHeight );
            }
        }
    }

    if (aParam.bInplace)
        DecRecalcLevel();

	delete[] pSpecial;

	return nCount;
}

sal_Bool ScTable::CreateExcelQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam)
{
	sal_Bool	bValid = sal_True;
	SCCOL* pFields = new SCCOL[nCol2-nCol1+1];
	String	aCellStr;
	SCCOL	nCol = nCol1;
	DBG_ASSERT( rQueryParam.nTab != SCTAB_MAX, "rQueryParam.nTab no value, not bad but no good" );
	SCTAB	nDBTab = (rQueryParam.nTab == SCTAB_MAX ? nTab : rQueryParam.nTab);
	SCROW	nDBRow1 = rQueryParam.nRow1;
	SCCOL	nDBCol2 = rQueryParam.nCol2;
	// Erste Zeile muessen Spaltenkoepfe sein
	while (bValid && (nCol <= nCol2))
	{
		String aQueryStr;
		GetUpperCellString(nCol, nRow1, aQueryStr);
		sal_Bool bFound = sal_False;
		SCCOL i = rQueryParam.nCol1;
		while (!bFound && (i <= nDBCol2))
		{
			if ( nTab == nDBTab )
				GetUpperCellString(i, nDBRow1, aCellStr);
			else
				pDocument->GetUpperCellString(i, nDBRow1, nDBTab, aCellStr);
			bFound = (aCellStr == aQueryStr);
			if (!bFound) i++;
		}
		if (bFound)
			pFields[nCol - nCol1] = i;
		else
			bValid = sal_False;
		nCol++;
	}
	if (bValid)
	{
		sal_uLong nVisible = 0;
		for ( nCol=nCol1; nCol<=nCol2; nCol++ )
			nVisible += aCol[nCol].VisibleCount( nRow1+1, nRow2 );

		if ( nVisible > SCSIZE_MAX / sizeof(void*) )
		{
			DBG_ERROR("zu viele Filterkritierien");
			nVisible = 0;
		}

		SCSIZE nNewEntries = nVisible;
		rQueryParam.Resize( nNewEntries );

		SCSIZE nIndex = 0;
		SCROW nRow = nRow1 + 1;
		while (nRow <= nRow2)
		{
			nCol = nCol1;
			while (nCol <= nCol2)
			{
                GetInputString( nCol, nRow, aCellStr );
                ScGlobal::pCharClass->toUpper( aCellStr );
				if (aCellStr.Len() > 0)
				{
					if (nIndex < nNewEntries)
					{
						rQueryParam.GetEntry(nIndex).nField = pFields[nCol - nCol1];
						rQueryParam.FillInExcelSyntax(aCellStr, nIndex);
						nIndex++;
						if (nIndex < nNewEntries)
							rQueryParam.GetEntry(nIndex).eConnect = SC_AND;
					}
					else
						bValid = sal_False;
				}
				nCol++;
			}
			nRow++;
			if (nIndex < nNewEntries)
				rQueryParam.GetEntry(nIndex).eConnect = SC_OR;
		}
	}
	delete [] pFields;
	return bValid;
}

sal_Bool ScTable::CreateStarQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam)
{
    // A valid StarQuery must be at least 4 columns wide. To be precise it
    // should be exactly 4 columns ...
    // Additionally, if this wasn't checked, a formula pointing to a valid 1-3
    // column Excel style query range immediately left to itself would result
    // in a circular reference when the field name or operator or value (first
    // to third query range column) is obtained (#i58354#). Furthermore, if the
    // range wasn't sufficiently specified data changes wouldn't flag formula
    // cells for recalculation.
    if (nCol2 - nCol1 < 3)
        return sal_False;

	sal_Bool bValid;
	sal_Bool bFound;
	String aCellStr;
	SCSIZE nIndex = 0;
	SCROW nRow = nRow1;
	DBG_ASSERT( rQueryParam.nTab != SCTAB_MAX, "rQueryParam.nTab no value, not bad but no good" );
	SCTAB	nDBTab = (rQueryParam.nTab == SCTAB_MAX ? nTab : rQueryParam.nTab);
	SCROW	nDBRow1 = rQueryParam.nRow1;
	SCCOL	nDBCol2 = rQueryParam.nCol2;

	SCSIZE nNewEntries = static_cast<SCSIZE>(nRow2-nRow1+1);
	rQueryParam.Resize( nNewEntries );

	do
	{
		ScQueryEntry& rEntry = rQueryParam.GetEntry(nIndex);

		bValid = sal_False;
		// Erste Spalte UND/ODER
		if (nIndex > 0)
		{
			GetUpperCellString(nCol1, nRow, aCellStr);
			if ( aCellStr == ScGlobal::GetRscString(STR_TABLE_UND) )
			{
				rEntry.eConnect = SC_AND;
				bValid = sal_True;
			}
			else if ( aCellStr == ScGlobal::GetRscString(STR_TABLE_ODER) )
			{
				rEntry.eConnect = SC_OR;
				bValid = sal_True;
			}
		}
		// Zweite Spalte FeldName
		if ((nIndex < 1) || bValid)
		{
			bFound = sal_False;
			GetUpperCellString(nCol1 + 1, nRow, aCellStr);
			for (SCCOL i=rQueryParam.nCol1; (i <= nDBCol2) && (!bFound); i++)
			{
				String aFieldStr;
				if ( nTab == nDBTab )
					GetUpperCellString(i, nDBRow1, aFieldStr);
				else
					pDocument->GetUpperCellString(i, nDBRow1, nDBTab, aFieldStr);
				bFound = (aCellStr == aFieldStr);
				if (bFound)
				{
					rEntry.nField = i;
					bValid = sal_True;
				}
				else
					bValid = sal_False;
			}
		}
		// Dritte Spalte Operator =<>...
		if (bValid)
		{
			bFound = sal_False;
			GetUpperCellString(nCol1 + 2, nRow, aCellStr);
			if (aCellStr.GetChar(0) == '<')
			{
				if (aCellStr.GetChar(1) == '>')
					rEntry.eOp = SC_NOT_EQUAL;
				else if (aCellStr.GetChar(1) == '=')
					rEntry.eOp = SC_LESS_EQUAL;
				else
					rEntry.eOp = SC_LESS;
			}
			else if (aCellStr.GetChar(0) == '>')
			{
				if (aCellStr.GetChar(1) == '=')
					rEntry.eOp = SC_GREATER_EQUAL;
				else
					rEntry.eOp = SC_GREATER;
			}
			else if (aCellStr.GetChar(0) == '=')
				rEntry.eOp = SC_EQUAL;

		}
		// Vierte Spalte Wert
		if (bValid)
		{
			GetString(nCol1 + 3, nRow, *rEntry.pStr);
			rEntry.bDoQuery = sal_True;
		}
		nIndex++;
		nRow++;
	}
	while (bValid && (nRow <= nRow2) /* && (nIndex < MAXQUERY) */ );
	return bValid;
}

sal_Bool ScTable::CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam)
{
	SCSIZE i, nCount;
	PutInOrder(nCol1, nCol2);
	PutInOrder(nRow1, nRow2);

	nCount = rQueryParam.GetEntryCount();
	for (i=0; i < nCount; i++)
		rQueryParam.GetEntry(i).Clear();

	// Standard QueryTabelle
	sal_Bool bValid = CreateStarQuery(nCol1, nRow1, nCol2, nRow2, rQueryParam);
	// Excel QueryTabelle
	if (!bValid)
		bValid = CreateExcelQuery(nCol1, nRow1, nCol2, nRow2, rQueryParam);

	nCount = rQueryParam.GetEntryCount();
	if (bValid)
	{
		//	bQueryByString muss gesetzt sein
		for (i=0; i < nCount; i++)
			rQueryParam.GetEntry(i).bQueryByString = sal_True;
	}
	else
	{
		//	nix
		for (i=0; i < nCount; i++)
			rQueryParam.GetEntry(i).Clear();
	}
	return bValid;
}

sal_Bool ScTable::HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW /* nEndRow */ )
{
	for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
	{
		CellType eType = GetCellType( nCol, nStartRow );
		if (eType != CELLTYPE_STRING && eType != CELLTYPE_EDIT)
			return sal_False;
	}
	return sal_True;
}

sal_Bool ScTable::HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL /* nEndCol */, SCROW nEndRow )
{
	for (SCROW nRow=nStartRow; nRow<=nEndRow; nRow++)
	{
		CellType eType = GetCellType( nStartCol, nRow );
		if (eType != CELLTYPE_STRING && eType != CELLTYPE_EDIT)
			return sal_False;
	}
	return sal_True;
}

void ScTable::GetFilterEntries(SCCOL nCol, SCROW nRow1, SCROW nRow2, TypedScStrCollection& rStrings, bool& rHasDates)
{
    aCol[nCol].GetFilterEntries( nRow1, nRow2, rStrings, rHasDates );
}

void ScTable::GetFilteredFilterEntries(
    SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScQueryParam& rParam, TypedScStrCollection& rStrings, bool& rHasDates )
{
    // remove the entry for this column from the query parameter
    ScQueryParam aParam( rParam );
    SCSIZE nEntryCount = aParam.GetEntryCount();
    for ( SCSIZE i = 0; i < nEntryCount && aParam.GetEntry(i).bDoQuery; ++i )
    {
        ScQueryEntry& rEntry = aParam.GetEntry(i);
        if ( rEntry.nField == nCol )
        {
            aParam.DeleteQuery(i);
            break;
        }
    }
    nEntryCount = aParam.GetEntryCount();

    sal_Bool* pSpecial = new sal_Bool[nEntryCount];
    lcl_PrepareQuery( pDocument, this, aParam, pSpecial );
    bool bHasDates = false;
    for ( SCROW j = nRow1; j <= nRow2; ++j )
    {
        if ( ValidQuery( j, aParam, pSpecial ) )
        {
            bool bThisHasDates = false;
            aCol[nCol].GetFilterEntries( j, j, rStrings, bThisHasDates );
            bHasDates |= bThisHasDates;
        }
    }

    rHasDates = bHasDates;
    delete[] pSpecial;
}

sal_Bool ScTable::GetDataEntries(SCCOL nCol, SCROW nRow, TypedScStrCollection& rStrings, sal_Bool bLimit)
{
	return aCol[nCol].GetDataEntries( nRow, rStrings, bLimit );
}

SCSIZE ScTable::GetCellCount(SCCOL nCol) const
{
    return aCol[nCol].GetCellCount();
}

sal_uLong ScTable::GetCellCount() const
{
	sal_uLong nCellCount = 0;

	for ( SCCOL nCol=0; nCol<=MAXCOL; nCol++ )
		nCellCount += aCol[nCol].GetCellCount();

	return nCellCount;
}

sal_uLong ScTable::GetWeightedCount() const
{
	sal_uLong nCellCount = 0;

	for ( SCCOL nCol=0; nCol<=MAXCOL; nCol++ )
		if ( aCol[nCol].GetCellCount() )					// GetCellCount ist inline
			nCellCount += aCol[nCol].GetWeightedCount();

	return nCellCount;
}

sal_uLong ScTable::GetCodeCount() const
{
	sal_uLong nCodeCount = 0;

	for ( SCCOL nCol=0; nCol<=MAXCOL; nCol++ )
		if ( aCol[nCol].GetCellCount() )					// GetCellCount ist inline
			nCodeCount += aCol[nCol].GetCodeCount();

	return nCodeCount;
}

sal_Int32 ScTable::GetMaxStringLen( SCCOL nCol, SCROW nRowStart,
        SCROW nRowEnd, CharSet eCharSet ) const
{
	if ( ValidCol(nCol) )
		return aCol[nCol].GetMaxStringLen( nRowStart, nRowEnd, eCharSet );
	else
        return 0;
}

xub_StrLen ScTable::GetMaxNumberStringLen( 
    sal_uInt16& nPrecision, SCCOL nCol, SCROW nRowStart, SCROW nRowEnd ) const
{
    if ( ValidCol(nCol) )
        return aCol[nCol].GetMaxNumberStringLen( nPrecision, nRowStart, nRowEnd );
    else
        return 0;
}

void ScTable::UpdateSelectionFunction( ScFunctionData& rData,
						SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
						const ScMarkData& rMark )
{
	//	Cursor neben einer Markierung nicht beruecksichtigen:
	//!	nur noch MarkData uebergeben, Cursorposition ggf. hineinselektieren!!!
	sal_Bool bSingle = ( rMark.IsMarked() || !rMark.IsMultiMarked() );

	// Mehrfachselektion:

	SCCOL nCol;
	if ( rMark.IsMultiMarked() )
		for (nCol=0; nCol<=MAXCOL && !rData.bError; nCol++)
			if ( !pColFlags || !ColHidden(nCol) )
				aCol[nCol].UpdateSelectionFunction( rMark, rData, *mpHiddenRows,
													bSingle && ( nCol >= nStartCol && nCol <= nEndCol ),
													nStartRow, nEndRow );

	//	Einfachselektion (oder Cursor) nur wenn nicht negativ (und s.o.):

	if ( bSingle && !rMark.IsMarkNegative() )
		for (nCol=nStartCol; nCol<=nEndCol && !rData.bError; nCol++)
			if ( !pColFlags || !ColHidden(nCol) )
				aCol[nCol].UpdateAreaFunction( rData, *mpHiddenRows, nStartRow, nEndRow );
}

void ScTable::FindConditionalFormat( sal_uLong nKey, ScRangeList& rList )
{
	SCROW nStartRow = 0, nEndRow = 0;
	for (SCCOL nCol=0; nCol<=MAXCOL; nCol++)
	{
		ScAttrIterator* pIter = aCol[nCol].CreateAttrIterator( 0, MAXROW );
		const ScPatternAttr* pPattern = pIter->Next( nStartRow, nEndRow );
		while (pPattern)
		{
			if (((SfxUInt32Item&)pPattern->GetItem(ATTR_CONDITIONAL)).GetValue() == nKey)
				rList.Join( ScRange(nCol,nStartRow,nTab, nCol,nEndRow,nTab) );
			pPattern = pIter->Next( nStartRow, nEndRow );
		}
		delete pIter;
	}
}