/**************************************************************
 * 
 * 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 ---------------------------------------------------------------

#include <svl/zforlist.hxx>

#include "scitems.hxx"
#include "global.hxx"
#include "dociter.hxx"
#include "document.hxx"
#include "table.hxx"
#include "column.hxx"
#include "cell.hxx"
#include "attarray.hxx"
#include "patattr.hxx"
#include "docoptio.hxx"
#include "cellform.hxx"

#include <vector>

using ::rtl::math::approxEqual;
using ::std::vector;
using ::rtl::OUString;
using ::std::set;

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

namespace {

void lcl_toUpper(OUString& rStr)
{
    rStr = ScGlobal::pCharClass->toUpper(rStr.trim(), 0, static_cast<sal_uInt16>(rStr.getLength()));
}

}

ScDocumentIterator::ScDocumentIterator( ScDocument* pDocument,
							SCTAB nStartTable, SCTAB nEndTable ) :
	pDoc( pDocument ),
	nStartTab( nStartTable ),
	nEndTab( nEndTable )
{
	PutInOrder( nStartTab, nEndTab );
	if (!ValidTab(nStartTab)) nStartTab = MAXTAB;
	if (!ValidTab(nEndTab)) nEndTab = MAXTAB;

	pDefPattern = pDoc->GetDefPattern();

	nCol = 0;
	nRow = 0;
	nTab = nStartTab;

	nColPos = 0;
	nAttrPos = 0;
}

ScDocumentIterator::~ScDocumentIterator()
{
}

sal_Bool ScDocumentIterator::GetThisCol()
{
	ScTable*		pTab;
	while ( (pTab = pDoc->pTab[nTab]) == NULL )
	{
		if ( nTab == nEndTab )
		{
			nCol = MAXCOL;
			nRow = MAXROW;
			return sal_False;
		}
		++nTab;
	}
	ScColumn*		pCol = &pTab->aCol[nCol];
	ScAttrArray*	pAtt = pCol->pAttrArray;

	sal_Bool bFound = sal_False;
	do
	{
		SCROW nColRow;
		SCROW nAttrEnd;

		do
		{
			nAttrEnd = pAtt->pData[nAttrPos].nRow;
			if (nAttrEnd < nRow)
				++nAttrPos;
		}
		while (nAttrEnd < nRow);

		do
		{
			nColRow = (nColPos < pCol->nCount) ? pCol->pItems[nColPos].nRow : MAXROW+1;
			if (nColRow < nRow)
				++nColPos;
		}
		while (nColRow < nRow);

		if (nColRow == nRow)
		{
			bFound	 = sal_True;
			pCell	 = pCol->pItems[nColPos].pCell;
			pPattern = pAtt->pData[nAttrPos].pPattern;
		}
		else if ( pAtt->pData[nAttrPos].pPattern != pDefPattern )
		{
			bFound = sal_True;
			pCell = NULL;
			pPattern = pAtt->pData[nAttrPos].pPattern;
		}
		else
		{
			nRow = Min( (SCROW)nColRow, (SCROW)(nAttrEnd+1) );
		}
	}
	while (!bFound && nRow <= MAXROW);

	return bFound;
}

sal_Bool ScDocumentIterator::GetThis()
{
	sal_Bool bEnd = sal_False;
	sal_Bool bSuccess = sal_False;

	while ( !bSuccess && !bEnd )
	{
		if ( nRow > MAXROW )
			bSuccess = sal_False;
		else
			bSuccess = GetThisCol();

		if ( !bSuccess )
		{
			++nCol;
			if (nCol > MAXCOL)
			{
				nCol = 0;
				++nTab;
				if (nTab > nEndTab)
					bEnd = sal_True;
			}
			nRow = 0;
			nColPos = 0;
			nAttrPos = 0;
		}
	}

	return !bEnd;
}

sal_Bool ScDocumentIterator::GetFirst()
{
	nCol = 0;
	nTab = nStartTab;

	nRow = 0;
	nColPos = 0;
	nAttrPos = 0;

	return GetThis();
}

sal_Bool ScDocumentIterator::GetNext()
{
	++nRow;

	return GetThis();
}

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

ScBaseCell* ScDocumentIterator::GetCell()
{
	return pCell;
}

const ScPatternAttr* ScDocumentIterator::GetPattern()
{
	return pPattern;
}

void ScDocumentIterator::GetPos( SCCOL& rCol, SCROW& rRow, SCTAB& rTab )
{
	rCol = nCol;
	rRow = nRow;
	rTab = nTab;
}


//------------------------------------------------------------------------
//------------------------------------------------------------------------
void lcl_IterGetNumberFormat( sal_uLong& nFormat, const ScAttrArray*& rpArr,
		SCROW& nAttrEndRow, const ScAttrArray* pNewArr, SCROW nRow,
		ScDocument* pDoc )
{
	if ( rpArr != pNewArr || nAttrEndRow < nRow )
	{
		SCSIZE nPos;
		pNewArr->Search( nRow, nPos );	// nPos 0 gueltig wenn nicht gefunden
		const ScPatternAttr* pPattern = pNewArr->pData[nPos].pPattern;
		nFormat = pPattern->GetNumberFormat( pDoc->GetFormatTable() );
		rpArr = pNewArr;
		nAttrEndRow = pNewArr->pData[nPos].nRow;
	}
}

//UNUSED2008-05  ScValueIterator::ScValueIterator( ScDocument* pDocument,
//UNUSED2008-05                                    SCCOL nSCol, SCROW nSRow, SCTAB nSTab,
//UNUSED2008-05                                    SCCOL nECol, SCROW nERow, SCTAB nETab,
//UNUSED2008-05                                    sal_Bool bSTotal, sal_Bool bTextZero ) :
//UNUSED2008-05  pDoc( pDocument ),
//UNUSED2008-05  nNumFmtIndex(0),
//UNUSED2008-05  nStartCol( nSCol),
//UNUSED2008-05  nStartRow( nSRow),
//UNUSED2008-05  nStartTab( nSTab ),
//UNUSED2008-05  nEndCol( nECol ),
//UNUSED2008-05  nEndRow( nERow),
//UNUSED2008-05  nEndTab( nETab ),
//UNUSED2008-05  nNumFmtType( NUMBERFORMAT_UNDEFINED ),
//UNUSED2008-05  bNumValid( sal_False ),
//UNUSED2008-05  bSubTotal(bSTotal),
//UNUSED2008-05  bNextValid( sal_False ),
//UNUSED2008-05  bCalcAsShown( pDocument->GetDocOptions().IsCalcAsShown() ),
//UNUSED2008-05  bTextAsZero( bTextZero )
//UNUSED2008-05  {
//UNUSED2008-05      PutInOrder( nStartCol, nEndCol);
//UNUSED2008-05      PutInOrder( nStartRow, nEndRow);
//UNUSED2008-05      PutInOrder( nStartTab, nEndTab );
//UNUSED2008-05
//UNUSED2008-05      if (!ValidCol(nStartCol)) nStartCol = MAXCOL;
//UNUSED2008-05      if (!ValidCol(nEndCol)) nEndCol = MAXCOL;
//UNUSED2008-05      if (!ValidRow(nStartRow)) nStartRow = MAXROW;
//UNUSED2008-05      if (!ValidRow(nEndRow)) nEndRow = MAXROW;
//UNUSED2008-05      if (!ValidTab(nStartTab)) nStartTab = MAXTAB;
//UNUSED2008-05      if (!ValidTab(nEndTab)) nEndTab = MAXTAB;
//UNUSED2008-05
//UNUSED2008-05      nCol = nStartCol;
//UNUSED2008-05      nRow = nStartRow;
//UNUSED2008-05      nTab = nStartTab;
//UNUSED2008-05
//UNUSED2008-05      nColRow = 0;                    // wird bei GetFirst initialisiert
//UNUSED2008-05
//UNUSED2008-05      nNumFormat = 0;                 // werden bei GetNumberFormat initialisiert
//UNUSED2008-05      pAttrArray = 0;
//UNUSED2008-05      nAttrEndRow = 0;
//UNUSED2008-05  }

ScValueIterator::ScValueIterator( ScDocument* pDocument, const ScRange& rRange,
			sal_Bool bSTotal, sal_Bool bTextZero ) :
	pDoc( pDocument ),
	nNumFmtIndex(0),
	nStartCol( rRange.aStart.Col() ),
	nStartRow( rRange.aStart.Row() ),
	nStartTab( rRange.aStart.Tab() ),
	nEndCol( rRange.aEnd.Col() ),
	nEndRow( rRange.aEnd.Row() ),
	nEndTab( rRange.aEnd.Tab() ),
	nNumFmtType( NUMBERFORMAT_UNDEFINED ),
	bNumValid( sal_False ),
	bSubTotal(bSTotal),
	bNextValid( sal_False ),
	bCalcAsShown( pDocument->GetDocOptions().IsCalcAsShown() ),
	bTextAsZero( bTextZero )
{
	PutInOrder( nStartCol, nEndCol);
	PutInOrder( nStartRow, nEndRow);
	PutInOrder( nStartTab, nEndTab );

	if (!ValidCol(nStartCol)) nStartCol = MAXCOL;
	if (!ValidCol(nEndCol)) nEndCol = MAXCOL;
	if (!ValidRow(nStartRow)) nStartRow = MAXROW;
	if (!ValidRow(nEndRow)) nEndRow = MAXROW;
	if (!ValidTab(nStartTab)) nStartTab = MAXTAB;
	if (!ValidTab(nEndTab)) nEndTab = MAXTAB;

	nCol = nStartCol;
	nRow = nStartRow;
	nTab = nStartTab;

	nColRow = 0;					// wird bei GetFirst initialisiert

	nNumFormat = 0;					// werden bei GetNumberFormat initialisiert
	pAttrArray = 0;
	nAttrEndRow = 0;
}

sal_Bool ScValueIterator::GetThis(double& rValue, sal_uInt16& rErr)
{
	ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol];
	for (;;)
	{
		if ( nRow > nEndRow )
		{
			nRow = nStartRow;
			do
			{
				nCol++;
				if ( nCol > nEndCol )
				{
					nCol = nStartCol;
					nTab++;
					if ( nTab > nEndTab )
					{
						// rValue = 0.0;    //! do not change caller's value!
						rErr = 0;
						return sal_False;				// Ende und Aus
					}
				}
				pCol = &(pDoc->pTab[nTab])->aCol[nCol];
			} while ( pCol->nCount == 0 );
			pCol->Search( nRow, nColRow );
		}

		while (( nColRow < pCol->nCount ) && ( pCol->pItems[nColRow].nRow < nRow ))
			nColRow++;

		if ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow <= nEndRow )
		{
			nRow = pCol->pItems[nColRow].nRow + 1;
			if ( !bSubTotal || !pDoc->pTab[nTab]->RowFiltered( nRow-1 ) )
			{
				ScBaseCell* pCell = pCol->pItems[nColRow].pCell;
				++nColRow;
				switch (pCell->GetCellType())
				{
					case CELLTYPE_VALUE:
					{
						bNumValid = sal_False;
						rValue = ((ScValueCell*)pCell)->GetValue();
						rErr = 0;
						--nRow;
						if ( bCalcAsShown )
						{
							lcl_IterGetNumberFormat( nNumFormat, pAttrArray,
								nAttrEndRow, pCol->pAttrArray, nRow, pDoc );
							rValue = pDoc->RoundValueAsShown( rValue, nNumFormat );
						}
						//
						//	wenn in der selben Spalte gleich noch eine Value-Cell folgt, die
						//	auch noch im Block liegt, den Wert jetzt schon holen
						//
						if ( nColRow < pCol->nCount &&
							 pCol->pItems[nColRow].nRow <= nEndRow &&
							 pCol->pItems[nColRow].pCell->GetCellType() == CELLTYPE_VALUE &&
							 !bSubTotal )
						{
							fNextValue = ((ScValueCell*)pCol->pItems[nColRow].pCell)->GetValue();
							nNextRow = pCol->pItems[nColRow].nRow;
							bNextValid = sal_True;
							if ( bCalcAsShown )
							{
								lcl_IterGetNumberFormat( nNumFormat, pAttrArray,
									nAttrEndRow, pCol->pAttrArray, nNextRow, pDoc );
								fNextValue = pDoc->RoundValueAsShown( fNextValue, nNumFormat );
							}
						}

						return sal_True;									// gefunden
					}
//                    break;
					case CELLTYPE_FORMULA:
					{
						if (!bSubTotal || !((ScFormulaCell*)pCell)->IsSubTotal())
						{
							rErr = ((ScFormulaCell*)pCell)->GetErrCode();
							if ( rErr || ((ScFormulaCell*)pCell)->IsValue() )
							{
								rValue = ((ScFormulaCell*)pCell)->GetValue();
								nRow--;
								bNumValid = sal_False;
								return sal_True;							// gefunden
							}
                            else if ( bTextAsZero )
                            {
                                rValue = 0.0;
                                nRow--;
                                bNumValid = sal_False;
                                return sal_True;
                            }
						}
					}
					break;
					case CELLTYPE_STRING :
					case CELLTYPE_EDIT :
					{
						if ( bTextAsZero )
						{
							rErr = 0;
							rValue = 0.0;
							nNumFmtType = NUMBERFORMAT_NUMBER;
							nNumFmtIndex = 0;
							bNumValid = sal_True;
							--nRow;
							return sal_True;
						}
					}
					break;
                    default:
                    {
                        // added to avoid warnings
                    }
				}
			}
		}
		else
			nRow = nEndRow + 1;			// naechste Spalte
	}
}

void ScValueIterator::GetCurNumFmtInfo( short& nType, sal_uLong& nIndex )
{
	if (!bNumValid)
	{
		const ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol];
		nNumFmtIndex = pCol->GetNumberFormat( nRow );
		if ( (nNumFmtIndex % SV_COUNTRY_LANGUAGE_OFFSET) == 0 )
		{
			const ScBaseCell* pCell;
			SCSIZE nIdx = nColRow - 1;
			// there might be rearranged something, so be on the safe side
			if ( nIdx < pCol->nCount && pCol->pItems[nIdx].nRow == nRow )
				pCell = pCol->pItems[nIdx].pCell;
			else
			{
				if ( pCol->Search( nRow, nIdx ) )
					pCell = pCol->pItems[nIdx].pCell;
				else
					pCell = NULL;
			}
			if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA )
				((const ScFormulaCell*)pCell)->GetFormatInfo( nNumFmtType, nNumFmtIndex );
			else
				nNumFmtType = pDoc->GetFormatTable()->GetType( nNumFmtIndex );
		}
		else
			nNumFmtType = pDoc->GetFormatTable()->GetType( nNumFmtIndex );
		bNumValid = sal_True;
	}
	nType = nNumFmtType;
	nIndex = nNumFmtIndex;
}

sal_Bool ScValueIterator::GetFirst(double& rValue, sal_uInt16& rErr)
{
	nCol = nStartCol;
	nRow = nStartRow;
	nTab = nStartTab;

//	nColRow = 0;
	ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol];
	pCol->Search( nRow, nColRow );

	nNumFormat = 0;					// werden bei GetNumberFormat initialisiert
	pAttrArray = 0;
	nAttrEndRow = 0;

	return GetThis(rValue, rErr);
}

/*	ist inline:
sal_Bool ScValueIterator::GetNext(double& rValue, sal_uInt16& rErr)
{
	++nRow;
	return GetThis(rValue, rErr);
}
*/

// ============================================================================

ScDBQueryDataIterator::DataAccess::DataAccess(const ScDBQueryDataIterator* pParent) :
    mpParent(pParent)
{
}

ScDBQueryDataIterator::DataAccess::~DataAccess()
{
}

SCROW ScDBQueryDataIterator::GetRowByColEntryIndex(ScDocument& rDoc, SCTAB nTab, SCCOL nCol, SCSIZE nColRow)
{
    ScColumn* pCol = &rDoc.pTab[nTab]->aCol[nCol];
    return pCol->pItems[nColRow].nRow;
}

ScBaseCell* ScDBQueryDataIterator::GetCellByColEntryIndex(ScDocument& rDoc, SCTAB nTab, SCCOL nCol, SCSIZE nColRow)
{
    ScColumn* pCol = &rDoc.pTab[nTab]->aCol[nCol];
    return pCol->pItems[nColRow].pCell;
}

ScAttrArray* ScDBQueryDataIterator::GetAttrArrayByCol(ScDocument& rDoc, SCTAB nTab, SCCOL nCol)
{
    ScColumn* pCol = &rDoc.pTab[nTab]->aCol[nCol];
    return pCol->pAttrArray;
}

bool ScDBQueryDataIterator::IsQueryValid(ScDocument& rDoc, const ScQueryParam& rParam, SCTAB nTab, SCROW nRow, ScBaseCell* pCell)
{
    return rDoc.pTab[nTab]->ValidQuery(nRow, rParam, NULL, pCell);
}

SCSIZE ScDBQueryDataIterator::SearchColEntryIndex(ScDocument& rDoc, SCTAB nTab, SCROW nRow, SCCOL nCol)
{
    ScColumn* pCol = &rDoc.pTab[nTab]->aCol[nCol];
    SCSIZE nColRow;
    pCol->Search(nRow, nColRow);
    return nColRow;
}

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

ScDBQueryDataIterator::DataAccessInternal::DataAccessInternal(const ScDBQueryDataIterator* pParent, ScDBQueryParamInternal* pParam, ScDocument* pDoc) :
    DataAccess(pParent), 
    mpParam(pParam),
    mpDoc(pDoc),
    bCalcAsShown( pDoc->GetDocOptions().IsCalcAsShown() )
{
    nCol = mpParam->mnField;
    nRow = mpParam->nRow1;
    nTab = mpParam->nTab;

	nColRow = 0;					// wird bei GetFirst initialisiert
	SCSIZE i;
	SCSIZE nCount = mpParam->GetEntryCount();
	for (i=0; (i<nCount) && (mpParam->GetEntry(i).bDoQuery); i++)
	{
        ScQueryEntry& rEntry = mpParam->GetEntry(i);
		sal_uInt32 nIndex = 0;
		rEntry.bQueryByString =
            !(mpDoc->GetFormatTable()->IsNumberFormat(*rEntry.pStr, nIndex, rEntry.nVal));
	}
	nNumFormat = 0;					// werden bei GetNumberFormat initialisiert
	pAttrArray = 0;
    nAttrEndRow = 0;
}

ScDBQueryDataIterator::DataAccessInternal::~DataAccessInternal()
{
}

bool ScDBQueryDataIterator::DataAccessInternal::getCurrent(Value& rValue)
{
    SCCOLROW nFirstQueryField = mpParam->GetEntry(0).nField;
	for ( ;; )
	{
        if (nRow > mpParam->nRow2)
		{
            // Bottom of the range reached.  Bail out.
            rValue.mnError = 0;
            return false;
		}

        SCSIZE nCellCount = mpDoc->GetCellCount(nTab, nCol);
        SCROW nThisRow = ScDBQueryDataIterator::GetRowByColEntryIndex(*mpDoc, nTab, nCol, nColRow);
        while ( (nColRow < nCellCount) && (nThisRow < nRow) )
            nThisRow = ScDBQueryDataIterator::GetRowByColEntryIndex(*mpDoc, nTab, nCol, ++nColRow);

        if ( nColRow < nCellCount && nThisRow <= mpParam->nRow2 )
		{
            nRow = nThisRow;
            ScBaseCell* pCell = NULL;
            if (nCol == static_cast<SCCOL>(nFirstQueryField))
                pCell = ScDBQueryDataIterator::GetCellByColEntryIndex(*mpDoc, nTab, nCol, nColRow);

            if (ScDBQueryDataIterator::IsQueryValid(*mpDoc, *mpParam, nTab, nRow, pCell))
			{
                // #i109812# get cell here if it wasn't done above
                if (nCol != static_cast<SCCOL>(nFirstQueryField))
                    pCell = ScDBQueryDataIterator::GetCellByColEntryIndex(*mpDoc, nTab, nCol, nColRow);

                switch (pCell ? pCell->GetCellType() : CELLTYPE_NONE)
				{
					case CELLTYPE_VALUE:
						{
                            rValue.mfValue = ((ScValueCell*)pCell)->GetValue();
                            rValue.mbIsNumber = true;
							if ( bCalcAsShown )
							{
                                const ScAttrArray* pNewAttrArray = 
                                    ScDBQueryDataIterator::GetAttrArrayByCol(*mpDoc, nTab, nCol);
                                lcl_IterGetNumberFormat( nNumFormat, pAttrArray,
                                    nAttrEndRow, pNewAttrArray, nRow, mpDoc );
                                rValue.mfValue = mpDoc->RoundValueAsShown( rValue.mfValue, nNumFormat );
							}
							nNumFmtType = NUMBERFORMAT_NUMBER;
							nNumFmtIndex = 0;
                            rValue.mnError = 0;
							return sal_True;		// gefunden
						}
//                        break;
					case CELLTYPE_FORMULA:
						{
							if (((ScFormulaCell*)pCell)->IsValue())
							{
                                rValue.mfValue = ((ScFormulaCell*)pCell)->GetValue();
                                rValue.mbIsNumber = true;
                                mpDoc->GetNumberFormatInfo( nNumFmtType,
									nNumFmtIndex, ScAddress( nCol, nRow, nTab ),
									pCell );
                                rValue.mnError = ((ScFormulaCell*)pCell)->GetErrCode();
								return sal_True;	// gefunden
							}
							else
								nRow++;
						}
						break;
                    case CELLTYPE_STRING:
                    case CELLTYPE_EDIT:
                        if (mpParam->mbSkipString)
                            ++nRow;
                        else
                        {
                            rValue.maString = pCell->GetStringData();
                            rValue.mfValue = 0.0;
                            rValue.mnError = 0;
                            rValue.mbIsNumber = false;
                            return true;
                        }
                        break;
					default:
						nRow++;
						break;
				}
			}
			else
				nRow++;
		}
		else
            nRow = mpParam->nRow2 + 1; // Naechste Spalte
	}
// statement unreachable
//    return false;
}

bool ScDBQueryDataIterator::DataAccessInternal::getFirst(Value& rValue)
{
    if (mpParam->bHasHeader)
        nRow++;

    nColRow = ScDBQueryDataIterator::SearchColEntryIndex(*mpDoc, nTab, nRow, nCol);
    return getCurrent(rValue);
}

bool ScDBQueryDataIterator::DataAccessInternal::getNext(Value& rValue)
{
    ++nRow;
    return getCurrent(rValue);
}

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

ScDBQueryDataIterator::DataAccessMatrix::DataAccessMatrix(const ScDBQueryDataIterator* pParent, ScDBQueryParamMatrix* pParam) :
    DataAccess(pParent),
    mpParam(pParam)
{
    SCSIZE nC, nR;
    mpParam->mpMatrix->GetDimensions(nC, nR);
    mnRows = static_cast<SCROW>(nR);
    mnCols = static_cast<SCCOL>(nC);
}

ScDBQueryDataIterator::DataAccessMatrix::~DataAccessMatrix()
{
}

bool ScDBQueryDataIterator::DataAccessMatrix::getCurrent(Value& rValue)
{
    // Starting from row == mnCurRow, get the first row that satisfies all the
    // query parameters.
    for ( ;mnCurRow < mnRows; ++mnCurRow)
    {
        const ScMatrix& rMat = *mpParam->mpMatrix;
        if (rMat.IsEmpty(mpParam->mnField, mnCurRow))
            // Don't take empty values into account.
            continue;

        bool bIsStrVal = rMat.IsString(mpParam->mnField, mnCurRow);
        if (bIsStrVal && mpParam->mbSkipString)
            continue;

        if (isValidQuery(mnCurRow, rMat))
        {
            rValue.maString = rMat.GetString(mpParam->mnField, mnCurRow);
            rValue.mfValue = rMat.GetDouble(mpParam->mnField, mnCurRow);
            rValue.mbIsNumber = !bIsStrVal;
            rValue.mnError = 0;
            return true;
        }
    }
    return false;
}

bool ScDBQueryDataIterator::DataAccessMatrix::getFirst(Value& rValue)
{
    mnCurRow = mpParam->bHasHeader ? 1 : 0;
    return getCurrent(rValue);
}

bool ScDBQueryDataIterator::DataAccessMatrix::getNext(Value& rValue)
{
    ++mnCurRow;
    return getCurrent(rValue);
}

namespace {

bool lcl_isQueryByValue(const ScQueryEntry& rEntry, const ScMatrix& rMat, SCSIZE nCol, SCSIZE nRow)
{
    if (rEntry.bQueryByString)
        return false;

    if (!rMat.IsValueOrEmpty(nCol, nRow))
        return false;

    return true;
}

bool lcl_isQueryByString(const ScQueryEntry& rEntry, const ScMatrix& rMat, SCSIZE nCol, SCSIZE nRow)
{
    switch (rEntry.eOp)
    {
        case SC_EQUAL:
        case SC_NOT_EQUAL:
        case SC_CONTAINS:
        case SC_DOES_NOT_CONTAIN:
        case SC_BEGINS_WITH:
        case SC_ENDS_WITH:
        case SC_DOES_NOT_BEGIN_WITH:
        case SC_DOES_NOT_END_WITH:
            return true;
        default:
            ;
    }

    if (rEntry.bQueryByString && rMat.IsString(nCol, nRow))
        return true;

    return false;
}

}

bool ScDBQueryDataIterator::DataAccessMatrix::isValidQuery(SCROW nRow, const ScMatrix& rMat) const
{
    SCSIZE nEntryCount = mpParam->GetEntryCount();
    vector<bool> aResults;
    aResults.reserve(nEntryCount);

    const CollatorWrapper& rCollator = 
        mpParam->bCaseSens ? *ScGlobal::GetCaseCollator() : *ScGlobal::GetCollator();

    for (SCSIZE i = 0; i < nEntryCount; ++i)
    {
        const ScQueryEntry& rEntry = mpParam->GetEntry(i);
        if (!rEntry.bDoQuery)
            continue;

        switch (rEntry.eOp)
        {
            case SC_EQUAL:
            case SC_LESS:
            case SC_GREATER:
            case SC_LESS_EQUAL:
            case SC_GREATER_EQUAL:
            case SC_NOT_EQUAL:
                break;
            default:
                // Only the above operators are supported.
                continue;
        }

        bool bValid = false;

        SCSIZE nField = static_cast<SCSIZE>(rEntry.nField);
        if (lcl_isQueryByValue(rEntry, rMat, nField, nRow))
        {
            // By value
            double fMatVal = rMat.GetDouble(nField, nRow);
            bool bEqual = approxEqual(fMatVal, rEntry.nVal);
            switch (rEntry.eOp)
            {
                case SC_EQUAL:
                    bValid = bEqual;
                break;
                case SC_LESS:
                    bValid = (fMatVal < rEntry.nVal) && !bEqual;
                break;
                case SC_GREATER:
                    bValid = (fMatVal > rEntry.nVal) && !bEqual;
                break;
                case SC_LESS_EQUAL:
                    bValid = (fMatVal < rEntry.nVal) || bEqual;
                break;
                case SC_GREATER_EQUAL:
                    bValid = (fMatVal > rEntry.nVal) || bEqual;
                break;
                case SC_NOT_EQUAL:
                    bValid = !bEqual;
                break;
                default:
                    ;
            }
        }
        else if (lcl_isQueryByString(rEntry, rMat, nField, nRow))
        {
            // By string
            do
            {
                if (!rEntry.pStr)
                    break;

                // Equality check first.

                OUString aMatStr = rMat.GetString(nField, nRow);
                lcl_toUpper(aMatStr);
                OUString aQueryStr = *rEntry.pStr;
                lcl_toUpper(aQueryStr);
                bool bDone = false;
                switch (rEntry.eOp)
                {
                    case SC_EQUAL:
                        bValid = aMatStr.equals(aQueryStr);
                        bDone = true;
                    break;
                    case SC_NOT_EQUAL:
                        bValid = !aMatStr.equals(aQueryStr);
                        bDone = true;
                    break;
                    default:
                        ;
                }

                if (bDone)
                    break;

                // Unequality check using collator.

                sal_Int32 nCompare = rCollator.compareString(aMatStr, aQueryStr);
                switch (rEntry.eOp)
                {
                    case SC_LESS :
                        bValid = (nCompare < 0);
                    break;
                    case SC_GREATER :
                        bValid = (nCompare > 0);
                    break;
                    case SC_LESS_EQUAL :
                        bValid = (nCompare <= 0);
                    break;
                    case SC_GREATER_EQUAL :
                        bValid = (nCompare >= 0);
                    break;
                    default:
                        ;
                }
            }
            while (false);
        }
        else if (mpParam->bMixedComparison)
        {
            // Not used at the moment.
        }

        if (aResults.empty())
            // First query entry.
            aResults.push_back(bValid);
        else if (rEntry.eConnect == SC_AND)
        {
            // For AND op, tuck the result into the last result value.
            size_t n = aResults.size();    
            aResults[n-1] = aResults[n-1] && bValid;
        }
        else
            // For OR op, store its own result.
            aResults.push_back(bValid);
    }

    // Row is valid as long as there is at least one result being true.
    vector<bool>::const_iterator itr = aResults.begin(), itrEnd = aResults.end();
    for (; itr != itrEnd; ++itr)
        if (*itr)
            return true;

    return false;
}

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

ScDBQueryDataIterator::Value::Value() :
    mnError(0), mbIsNumber(true)
{
    ::rtl::math::setNan(&mfValue);
}

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

ScDBQueryDataIterator::ScDBQueryDataIterator(ScDocument* pDocument, ScDBQueryParamBase* pParam) :
    mpParam (pParam)
{
    switch (mpParam->GetType())
    {
        case ScDBQueryParamBase::INTERNAL:
        {
            ScDBQueryParamInternal* p = static_cast<ScDBQueryParamInternal*>(pParam);
            mpData.reset(new DataAccessInternal(this, p, pDocument));
        }
        break;
        case ScDBQueryParamBase::MATRIX:
        {
            ScDBQueryParamMatrix* p = static_cast<ScDBQueryParamMatrix*>(pParam);
            mpData.reset(new DataAccessMatrix(this, p));
        }
    }
}

bool ScDBQueryDataIterator::GetFirst(Value& rValue)
{
    return mpData->getFirst(rValue);
}

bool ScDBQueryDataIterator::GetNext(Value& rValue)
{
    return mpData->getNext(rValue);
}

// ============================================================================

ScCellIterator::ScCellIterator( ScDocument* pDocument,
								SCCOL nSCol, SCROW nSRow, SCTAB nSTab,
								SCCOL nECol, SCROW nERow, SCTAB nETab, sal_Bool bSTotal ) :
	pDoc( pDocument ),
	nStartCol( nSCol),
	nStartRow( nSRow),
	nStartTab( nSTab ),
	nEndCol( nECol ),
	nEndRow( nERow),
	nEndTab( nETab ),
	bSubTotal(bSTotal)

{
	PutInOrder( nStartCol, nEndCol);
	PutInOrder( nStartRow, nEndRow);
	PutInOrder( nStartTab, nEndTab );

	if (!ValidCol(nStartCol)) nStartCol = MAXCOL;
	if (!ValidCol(nEndCol)) nEndCol = MAXCOL;
	if (!ValidRow(nStartRow)) nStartRow = MAXROW;
	if (!ValidRow(nEndRow)) nEndRow = MAXROW;
	if (!ValidTab(nStartTab)) nStartTab = MAXTAB;
	if (!ValidTab(nEndTab)) nEndTab = MAXTAB;

	while (nEndTab>0 && !pDoc->pTab[nEndTab])
		--nEndTab;										// nur benutzte Tabellen
	if (nStartTab>nEndTab)
		nStartTab = nEndTab;

	nCol = nStartCol;
	nRow = nStartRow;
	nTab = nStartTab;
	nColRow = 0;					// wird bei GetFirst initialisiert

	if (!pDoc->pTab[nTab])
	{
		DBG_ERROR("Tabelle nicht gefunden");
		nStartCol = nCol = MAXCOL+1;
		nStartRow = nRow = MAXROW+1;
		nStartTab = nTab = MAXTAB+1;	// -> Abbruch bei GetFirst
	}
}

ScCellIterator::ScCellIterator
	( ScDocument* pDocument, const ScRange& rRange, sal_Bool bSTotal ) :
	pDoc( pDocument ),
	nStartCol( rRange.aStart.Col() ),
	nStartRow( rRange.aStart.Row() ),
	nStartTab( rRange.aStart.Tab() ),
	nEndCol( rRange.aEnd.Col() ),
	nEndRow( rRange.aEnd.Row() ),
	nEndTab( rRange.aEnd.Tab() ),
	bSubTotal(bSTotal)

{
	PutInOrder( nStartCol, nEndCol);
	PutInOrder( nStartRow, nEndRow);
	PutInOrder( nStartTab, nEndTab );

	if (!ValidCol(nStartCol)) nStartCol = MAXCOL;
	if (!ValidCol(nEndCol)) nEndCol = MAXCOL;
	if (!ValidRow(nStartRow)) nStartRow = MAXROW;
	if (!ValidRow(nEndRow)) nEndRow = MAXROW;
	if (!ValidTab(nStartTab)) nStartTab = MAXTAB;
	if (!ValidTab(nEndTab)) nEndTab = MAXTAB;

	while (nEndTab>0 && !pDoc->pTab[nEndTab])
		--nEndTab;										// nur benutzte Tabellen
	if (nStartTab>nEndTab)
		nStartTab = nEndTab;

	nCol = nStartCol;
	nRow = nStartRow;
	nTab = nStartTab;
	nColRow = 0;					// wird bei GetFirst initialisiert

	if (!pDoc->pTab[nTab])
	{
		DBG_ERROR("Tabelle nicht gefunden");
		nStartCol = nCol = MAXCOL+1;
		nStartRow = nRow = MAXROW+1;
		nStartTab = nTab = MAXTAB+1;	// -> Abbruch bei GetFirst
	}
}

ScBaseCell* ScCellIterator::GetThis()
{
	ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol];
	for ( ;; )
	{
		if ( nRow > nEndRow )
		{
			nRow = nStartRow;
			do
			{
				nCol++;
				if ( nCol > nEndCol )
				{
					nCol = nStartCol;
					nTab++;
					if ( nTab > nEndTab )
						return NULL;				// Ende und Aus
				}
				pCol = &(pDoc->pTab[nTab])->aCol[nCol];
			} while ( pCol->nCount == 0 );
			pCol->Search( nRow, nColRow );
		}

		while ( (nColRow < pCol->nCount) && (pCol->pItems[nColRow].nRow < nRow) )
			nColRow++;

		if ( nColRow < pCol->nCount	&& pCol->pItems[nColRow].nRow <= nEndRow )
		{
			nRow = pCol->pItems[nColRow].nRow;
			if ( !bSubTotal || !pDoc->pTab[nTab]->RowFiltered( nRow ) )
			{
				ScBaseCell* pCell = pCol->pItems[nColRow].pCell;

				if ( bSubTotal && pCell->GetCellType() == CELLTYPE_FORMULA
								&& ((ScFormulaCell*)pCell)->IsSubTotal() )
					nRow++;				// Sub-Total-Zeilen nicht
				else
					return pCell;		// gefunden
			}
			else
				nRow++;
		}
		else
			nRow = nEndRow + 1; // Naechste Spalte
	}
}

ScBaseCell* ScCellIterator::GetFirst()
{
	if ( !ValidTab(nTab) )
		return NULL;
	nCol = nStartCol;
	nRow = nStartRow;
	nTab = nStartTab;
//	nColRow = 0;
	ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol];
	pCol->Search( nRow, nColRow );
	return GetThis();
}

ScBaseCell* ScCellIterator::GetNext()
{
	++nRow;
	return GetThis();
}

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

ScQueryCellIterator::ScQueryCellIterator(ScDocument* pDocument, SCTAB nTable,
			 const ScQueryParam& rParam, sal_Bool bMod ) :
	aParam (rParam),
	pDoc( pDocument ),
	nTab( nTable),
    nStopOnMismatch( nStopOnMismatchDisabled ),
    nTestEqualCondition( nTestEqualConditionDisabled ),
    bAdvanceQuery( sal_False ),
    bIgnoreMismatchOnLeadingStrings( sal_False )
{
	nCol = aParam.nCol1;
	nRow = aParam.nRow1;
	nColRow = 0;					// wird bei GetFirst initialisiert
	SCSIZE i;
	if (bMod)								// sonst schon eingetragen
	{
		for (i=0; (i<MAXQUERY) && (aParam.GetEntry(i).bDoQuery); i++)
		{
			ScQueryEntry& rEntry = aParam.GetEntry(i);
			sal_uInt32 nIndex = 0;
			rEntry.bQueryByString =
					 !(pDoc->GetFormatTable()->IsNumberFormat(*rEntry.pStr,
															  nIndex, rEntry.nVal));
		}
	}
	nNumFormat = 0;					// werden bei GetNumberFormat initialisiert
	pAttrArray = 0;
	nAttrEndRow = 0;
}

ScBaseCell* ScQueryCellIterator::GetThis()
{
	ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol];
    const ScQueryEntry& rEntry = aParam.GetEntry(0);
    SCCOLROW nFirstQueryField = rEntry.nField;
    bool bAllStringIgnore = bIgnoreMismatchOnLeadingStrings &&
        !rEntry.bQueryByString;
    bool bFirstStringIgnore = bIgnoreMismatchOnLeadingStrings &&
        !aParam.bHasHeader && rEntry.bQueryByString &&
        ((aParam.bByRow && nRow == aParam.nRow1) ||
         (!aParam.bByRow && nCol == aParam.nCol1));
	for ( ;; )
	{
		if ( nRow > aParam.nRow2 )
		{
			nRow = aParam.nRow1;
			if (aParam.bHasHeader && aParam.bByRow)
				nRow++;
			do
			{
				if ( ++nCol > aParam.nCol2 )
					return NULL;				// Ende und Aus
				if ( bAdvanceQuery )
                {
					AdvanceQueryParamEntryField();
                    nFirstQueryField = rEntry.nField;
                }
				pCol = &(pDoc->pTab[nTab])->aCol[nCol];
			} while ( pCol->nCount == 0 );
			pCol->Search( nRow, nColRow );
            bFirstStringIgnore = bIgnoreMismatchOnLeadingStrings &&
                !aParam.bHasHeader && rEntry.bQueryByString &&
                aParam.bByRow;
		}

		while ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow < nRow )
			nColRow++;

        if ( nColRow < pCol->nCount &&
                (nRow = pCol->pItems[nColRow].nRow) <= aParam.nRow2 )
		{
            ScBaseCell* pCell = pCol->pItems[nColRow].pCell;
            if ( pCell->GetCellType() == CELLTYPE_NOTE )
                ++nRow;
            else if (bAllStringIgnore && pCell->HasStringData())
                ++nRow;
			else
			{
                sal_Bool bTestEqualCondition;
                if ( (pDoc->pTab[nTab])->ValidQuery( nRow, aParam, NULL,
                        (nCol == static_cast<SCCOL>(nFirstQueryField) ? pCell : NULL),
                        (nTestEqualCondition ? &bTestEqualCondition : NULL) ) )
                {
                    if ( nTestEqualCondition && bTestEqualCondition )
                        nTestEqualCondition |= nTestEqualConditionMatched;
                    return pCell;     // found
                }
                else if ( nStopOnMismatch )
                {
                    // Yes, even a mismatch may have a fulfilled equal
                    // condition if regular expressions were involved and
                    // SC_LESS_EQUAL or SC_GREATER_EQUAL were queried.
                    if ( nTestEqualCondition && bTestEqualCondition )
                    {
                        nTestEqualCondition |= nTestEqualConditionMatched;
                        nStopOnMismatch |= nStopOnMismatchOccured;
                        return NULL;
                    }
                    bool bStop;
                    if (bFirstStringIgnore)
                    {
                        if (pCell->HasStringData())
                        {
                            ++nRow;
                            bStop = false;
                        }
                        else
                            bStop = true;
                    }
                    else
                        bStop = true;
                    if (bStop)
                    {
                        nStopOnMismatch |= nStopOnMismatchOccured;
                        return NULL;
                    }
                }
				else
					nRow++;
			}
		}
		else
			nRow = aParam.nRow2 + 1; // Naechste Spalte
        bFirstStringIgnore = false;
	}
}

ScBaseCell* ScQueryCellIterator::GetFirst()
{
	nCol = aParam.nCol1;
	nRow = aParam.nRow1;
	if (aParam.bHasHeader)
		nRow++;
//	nColRow = 0;
	ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol];
	pCol->Search( nRow, nColRow );
	return GetThis();
}

ScBaseCell* ScQueryCellIterator::GetNext()
{
	++nRow;
    if ( nStopOnMismatch )
        nStopOnMismatch = nStopOnMismatchEnabled;
    if ( nTestEqualCondition )
        nTestEqualCondition = nTestEqualConditionEnabled;
	return GetThis();
}

void ScQueryCellIterator::AdvanceQueryParamEntryField()
{
	SCSIZE nEntries = aParam.GetEntryCount();
	for ( SCSIZE j = 0; j < nEntries; j++  )
	{
		ScQueryEntry& rEntry = aParam.GetEntry( j );
		if ( rEntry.bDoQuery )
		{
			if ( rEntry.nField < MAXCOL )
				rEntry.nField++;
			else
			{
				DBG_ERRORFILE( "AdvanceQueryParamEntryField: ++rEntry.nField > MAXCOL" );
			}
		}
		else
			break;	// for
	}
}


sal_Bool ScQueryCellIterator::FindEqualOrSortedLastInRange( SCCOL& nFoundCol,
        SCROW& nFoundRow, sal_Bool bSearchForEqualAfterMismatch,
        sal_Bool bIgnoreMismatchOnLeadingStringsP )
{
    nFoundCol = MAXCOL+1;
    nFoundRow = MAXROW+1;
    SetStopOnMismatch( sal_True );      // assume sorted keys
    SetTestEqualCondition( sal_True );
    bIgnoreMismatchOnLeadingStrings = bIgnoreMismatchOnLeadingStringsP;
    bool bRegExp = aParam.bRegExp && aParam.GetEntry(0).bQueryByString;
    bool bBinary = !bRegExp && aParam.bByRow && (aParam.GetEntry(0).eOp ==
            SC_LESS_EQUAL || aParam.GetEntry(0).eOp == SC_GREATER_EQUAL);
    if (bBinary ? (BinarySearch() ? GetThis() : 0) : GetFirst())
    {
        // First equal entry or last smaller than (greater than) entry.
        SCSIZE nColRowSave;
        ScBaseCell* pNext = 0;
        do
        {
            nFoundCol = GetCol();
            nFoundRow = GetRow();
            nColRowSave = nColRow;
        } while ( !IsEqualConditionFulfilled() && (pNext = GetNext()) != NULL );
        // There may be no pNext but equal condition fulfilled if regular
        // expressions are involved. Keep the found entry and proceed.
        if (!pNext && !IsEqualConditionFulfilled())
        {
            // Step back to last in range and adjust position markers for
            // GetNumberFormat() or similar.
            nCol = nFoundCol;
            nRow = nFoundRow;
            nColRow = nColRowSave;
        }
    }
    if ( IsEqualConditionFulfilled() )
    {
        // Position on last equal entry.
        SCSIZE nEntries = aParam.GetEntryCount();
        for ( SCSIZE j = 0; j < nEntries; j++  )
        {
            ScQueryEntry& rEntry = aParam.GetEntry( j );
            if ( rEntry.bDoQuery )
            {
                switch ( rEntry.eOp )
                {
                    case SC_LESS_EQUAL :
                    case SC_GREATER_EQUAL :
                        rEntry.eOp = SC_EQUAL;
                    break;
                    default:
                    {
                        // added to avoid warnings
                    }
                }
            }
            else
                break;  // for
        }
        SCSIZE nColRowSave;
        bIgnoreMismatchOnLeadingStrings = sal_False;
        SetTestEqualCondition( sal_False );
        do
        {
            nFoundCol = GetCol();
            nFoundRow = GetRow();
            nColRowSave = nColRow;
        } while (GetNext());
        // Step back conditions same as above
        nCol = nFoundCol;
        nRow = nFoundRow;
        nColRow = nColRowSave;
        return sal_True;
    }
    if ( (bSearchForEqualAfterMismatch || aParam.bRegExp) &&
            StoppedOnMismatch() )
    {
        // Assume found entry to be the last value less than respectively
        // greater than the query. But keep on searching for an equal match.
        SCSIZE nEntries = aParam.GetEntryCount();
        for ( SCSIZE j = 0; j < nEntries; j++  )
        {
            ScQueryEntry& rEntry = aParam.GetEntry( j );
            if ( rEntry.bDoQuery )
            {
                switch ( rEntry.eOp )
                {
                    case SC_LESS_EQUAL :
                    case SC_GREATER_EQUAL :
                        rEntry.eOp = SC_EQUAL;
                    break;
                    default:
                    {
                        // added to avoid warnings
                    }
                }
            }
            else
                break;  // for
        }
        SetStopOnMismatch( sal_False );
        SetTestEqualCondition( sal_False );
        if (GetNext())
        {
            // Last of a consecutive area, avoid searching the entire parameter
            // range as it is a real performance bottleneck in case of regular
            // expressions.
            SCSIZE nColRowSave;
            do
            {
                nFoundCol = GetCol();
                nFoundRow = GetRow();
                nColRowSave = nColRow;
                SetStopOnMismatch( sal_True );
            } while (GetNext());
            nCol = nFoundCol;
            nRow = nFoundRow;
            nColRow = nColRowSave;
        }
    }
    return (nFoundCol <= MAXCOL) && (nFoundRow <= MAXROW);
}


ScBaseCell* ScQueryCellIterator::BinarySearch()
{
	nCol = aParam.nCol1;
	ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol];
    if (!pCol->nCount)
        return 0;

    ScBaseCell* pCell;
    SCSIZE nHi, nLo;
	CollatorWrapper* pCollator = (aParam.bCaseSens ? ScGlobal::GetCaseCollator() :
		ScGlobal::GetCollator());
    SvNumberFormatter& rFormatter = *(pDoc->GetFormatTable());
    const ScQueryEntry& rEntry = aParam.GetEntry(0);
    bool bLessEqual = rEntry.eOp == SC_LESS_EQUAL;
    bool bByString = rEntry.bQueryByString;
    bool bAllStringIgnore = bIgnoreMismatchOnLeadingStrings && !bByString;
    bool bFirstStringIgnore = bIgnoreMismatchOnLeadingStrings &&
        !aParam.bHasHeader && bByString;

	nRow = aParam.nRow1;
	if (aParam.bHasHeader)
		nRow++;
    const ColEntry* pItems = pCol->pItems;
    if (pCol->Search( nRow, nLo ) && bFirstStringIgnore &&
            pItems[nLo].pCell->HasStringData())
    {
        String aCellStr;
        sal_uLong nFormat = pCol->GetNumberFormat( pItems[nLo].nRow);
        ScCellFormat::GetInputString( pItems[nLo].pCell, nFormat, aCellStr,
                rFormatter);
        sal_Int32 nTmp = pCollator->compareString( aCellStr, *rEntry.pStr);
        if ((rEntry.eOp == SC_LESS_EQUAL && nTmp > 0) ||
                (rEntry.eOp == SC_GREATER_EQUAL && nTmp < 0) ||
                (rEntry.eOp == SC_EQUAL && nTmp != 0))
            ++nLo;
    }
	if (!pCol->Search( aParam.nRow2, nHi ) && nHi>0)
        --nHi;
    while (bAllStringIgnore && nLo <= nHi && nLo < pCol->nCount &&
            pItems[nLo].pCell->HasStringData())
        ++nLo;

    // Bookkeeping values for breaking up the binary search in case the data
    // range isn't strictly sorted.
    SCSIZE nLastInRange = nLo;
    SCSIZE nFirstLastInRange = nLastInRange;
    double fLastInRangeValue = bLessEqual ?
        -(::std::numeric_limits<double>::max()) :
            ::std::numeric_limits<double>::max();
    String aLastInRangeString;
    if (!bLessEqual)
        aLastInRangeString.Assign( sal_Unicode(0xFFFF));
    if (nLastInRange < pCol->nCount)
    {
        pCell = pItems[nLastInRange].pCell;
        if (pCell->HasStringData())
        {
            sal_uLong nFormat = pCol->GetNumberFormat( pItems[nLastInRange].nRow);
            ScCellFormat::GetInputString( pCell, nFormat, aLastInRangeString,
                    rFormatter);
        }
        else
        {
            switch ( pCell->GetCellType() )
            {
                case CELLTYPE_VALUE :
                    fLastInRangeValue =
                        static_cast<ScValueCell*>(pCell)->GetValue();
                    break;
                case CELLTYPE_FORMULA :
                    fLastInRangeValue =
                        static_cast<ScFormulaCell*>(pCell)->GetValue();
                    break;
                default:
                {
                    // added to avoid warnings
                }
            }
        }
    }

    sal_Int32 nRes = 0;
    bool bFound = false;
    bool bDone = false;
    while (nLo <= nHi && !bDone)
    {
        SCSIZE nMid = (nLo+nHi)/2;
        SCSIZE i = nMid;
        while (i <= nHi && pItems[i].pCell->GetCellType() == CELLTYPE_NOTE)
            ++i;
        if (i > nHi)
        {
            if (nMid > 0)
                nHi = nMid - 1;
            else
                bDone = true;
            continue;   // while
        }
        sal_Bool bStr = pItems[i].pCell->HasStringData();
        nRes = 0;
        // compares are content<query:-1, content>query:1
        // Cell value comparison similar to ScTable::ValidQuery()
        if (!bStr && !bByString)
        {
            double nCellVal;
            pCell = pItems[i].pCell;
            switch ( pCell->GetCellType() )
            {
                case CELLTYPE_VALUE :
                    nCellVal = static_cast<ScValueCell*>(pCell)->GetValue();
                    break;
                case CELLTYPE_FORMULA :
                    nCellVal = static_cast<ScFormulaCell*>(pCell)->GetValue();
                    break;
                default:
                    nCellVal = 0.0;
            }
            if ((nCellVal < rEntry.nVal) && !::rtl::math::approxEqual(
                        nCellVal, rEntry.nVal))
            {
                nRes = -1;
                if (bLessEqual)
                {
                    if (fLastInRangeValue < nCellVal)
                    {
                        fLastInRangeValue = nCellVal;
                        nLastInRange = i;
                    }
                    else if (fLastInRangeValue > nCellVal)
                    {
                        // not strictly sorted, continue with GetThis()
                        nLastInRange = nFirstLastInRange;
                        bDone = true;
                    }
                }
            }
            else if ((nCellVal > rEntry.nVal) && !::rtl::math::approxEqual(
                        nCellVal, rEntry.nVal))
            {
                nRes = 1;
                if (!bLessEqual)
                {
                    if (fLastInRangeValue > nCellVal)
                    {
                        fLastInRangeValue = nCellVal;
                        nLastInRange = i;
                    }
                    else if (fLastInRangeValue < nCellVal)
                    {
                        // not strictly sorted, continue with GetThis()
                        nLastInRange = nFirstLastInRange;
                        bDone = true;
                    }
                }
            }
        }
        else if (bStr && bByString)
        {
            String aCellStr;
            sal_uLong nFormat = pCol->GetNumberFormat( pItems[i].nRow);
            ScCellFormat::GetInputString( pItems[i].pCell, nFormat, aCellStr,
                    rFormatter);
            nRes = pCollator->compareString( aCellStr, *rEntry.pStr);
            if (nRes < 0 && bLessEqual)
            {
                sal_Int32 nTmp = pCollator->compareString( aLastInRangeString,
                        aCellStr);
                if (nTmp < 0)
                {
                    aLastInRangeString = aCellStr;
                    nLastInRange = i;
                }
                else if (nTmp > 0)
                {
                    // not strictly sorted, continue with GetThis()
                    nLastInRange = nFirstLastInRange;
                    bDone = true;
                }
            }
            else if (nRes > 0 && !bLessEqual)
            {
                sal_Int32 nTmp = pCollator->compareString( aLastInRangeString,
                        aCellStr);
                if (nTmp > 0)
                {
                    aLastInRangeString = aCellStr;
                    nLastInRange = i;
                }
                else if (nTmp < 0)
                {
                    // not strictly sorted, continue with GetThis()
                    nLastInRange = nFirstLastInRange;
                    bDone = true;
                }
            }
        }
        else if (!bStr && bByString)
        {
            nRes = -1;  // numeric < string
            if (bLessEqual)
                nLastInRange = i;
        }
        else // if (bStr && !bByString)
        {
            nRes = 1;   // string > numeric
            if (!bLessEqual)
                nLastInRange = i;
        }
        if (nRes < 0)
        {
            if (bLessEqual)
                nLo = nMid + 1;
            else    // assumed to be SC_GREATER_EQUAL
            {
                if (nMid > 0)
                    nHi = nMid - 1;
                else
                    bDone = true;
            }
        }
        else if (nRes > 0)
        {
            if (bLessEqual)
            {
                if (nMid > 0)
                    nHi = nMid - 1;
                else
                    bDone = true;
            }
            else    // assumed to be SC_GREATER_EQUAL
                nLo = nMid + 1;
        }
        else
        {
            nLo = i;
            bDone = bFound = true;
        }
    }
    if (!bFound)
    {
        // If all hits didn't result in a moving limit there's something
        // strange, e.g. data range not properly sorted, or only identical
        // values encountered, which doesn't mean there aren't any others in
        // between.. leave it to GetThis(). The condition for this would be
        // if (nLastInRange == nFirstLastInRange) nLo = nFirstLastInRange;
        // Else, in case no exact match was found, we step back for a
        // subsequent GetThis() to find the last in range. Effectively this is
        // --nLo with nLastInRange == nLo-1. Both conditions combined yield:
        nLo = nLastInRange;
    }
    if (nLo < pCol->nCount && pCol->pItems[nLo].nRow <= aParam.nRow2)
    {
        nRow = pItems[nLo].nRow;
        pCell = pItems[nLo].pCell;
        nColRow = nLo;
    }
    else
    {
        nRow = aParam.nRow2 + 1;
        pCell = 0;
        nColRow = pCol->nCount - 1;
    }
    return pCell;
}


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

ScHorizontalCellIterator::ScHorizontalCellIterator(ScDocument* pDocument, SCTAB nTable,
									SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) :
	pDoc( pDocument ),
	nTab( nTable ),
	nStartCol( nCol1 ),
	nEndCol( nCol2 ),
	nStartRow( nRow1 ),
	nEndRow( nRow2 ),
	nCol( nCol1 ),
	nRow( nRow1 ),
	bMore( sal_True )
{

	pNextRows = new SCROW[ nCol2-nCol1+1 ];
	pNextIndices = new SCSIZE[ nCol2-nCol1+1 ];

	SetTab( nTab );
}

ScHorizontalCellIterator::~ScHorizontalCellIterator()
{
	delete [] pNextRows;
	delete [] pNextIndices;
}

void ScHorizontalCellIterator::SetTab( SCTAB nTabP )
{
	nTab = nTabP;
	nRow = nStartRow;
	nCol = nStartCol;
	bMore = sal_True;

	for (SCCOL i=nStartCol; i<=nEndCol; i++)
	{
		ScColumn* pCol = &pDoc->pTab[nTab]->aCol[i];

		SCSIZE nIndex;
		pCol->Search( nStartRow, nIndex );
		if ( nIndex < pCol->nCount )
		{
			pNextRows[i-nStartCol] = pCol->pItems[nIndex].nRow;
			pNextIndices[i-nStartCol] = nIndex;
		}
		else
		{
			pNextRows[i-nStartCol] = MAXROWCOUNT;		// nichts gefunden
			pNextIndices[i-nStartCol] = MAXROWCOUNT;
		}
	}

	if (pNextRows[0] != nStartRow)
		Advance();
}

ScBaseCell* ScHorizontalCellIterator::GetNext( SCCOL& rCol, SCROW& rRow )
{
	if ( bMore )
	{
		rCol = nCol;
		rRow = nRow;

		ScColumn* pCol = &pDoc->pTab[nTab]->aCol[nCol];
		SCSIZE nIndex = pNextIndices[nCol-nStartCol];
		DBG_ASSERT( nIndex < pCol->nCount, "ScHorizontalCellIterator::GetNext: nIndex out of range" );
		ScBaseCell* pCell = pCol->pItems[nIndex].pCell;
		if ( ++nIndex < pCol->nCount )
		{
			pNextRows[nCol-nStartCol] = pCol->pItems[nIndex].nRow;
			pNextIndices[nCol-nStartCol] = nIndex;
		}
		else
		{
			pNextRows[nCol-nStartCol] = MAXROWCOUNT;		// nichts gefunden
			pNextIndices[nCol-nStartCol] = MAXROWCOUNT;
		}

		Advance();
		return pCell;
	}
	else
		return NULL;
}

sal_Bool ScHorizontalCellIterator::ReturnNext( SCCOL& rCol, SCROW& rRow )
{
	rCol = nCol;
	rRow = nRow;
	return bMore;
}

void ScHorizontalCellIterator::Advance()
{
	sal_Bool bFound = sal_False;
	SCCOL i;

	for (i=nCol+1; i<=nEndCol && !bFound; i++)
		if (pNextRows[i-nStartCol] == nRow)
		{
			nCol = i;
			bFound = sal_True;
		}

	if (!bFound)
	{
		SCROW nMinRow = MAXROW+1;
		for (i=nStartCol; i<=nEndCol; i++)
			if (pNextRows[i-nStartCol] < nMinRow)
			{
				nCol = i;
				nMinRow = pNextRows[i-nStartCol];
			}

		if (nMinRow <= nEndRow)
		{
			nRow = nMinRow;
			bFound = sal_True;
		}
	}

	if ( !bFound )
		bMore = sal_False;
}

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

ScHorizontalValueIterator::ScHorizontalValueIterator( ScDocument* pDocument,
        const ScRange& rRange, bool bSTotal, bool bTextZero ) :
    pDoc( pDocument ),
    nNumFmtIndex(0),
    nEndTab( rRange.aEnd.Tab() ),
    nNumFmtType( NUMBERFORMAT_UNDEFINED ),
    bNumValid( false ),
    bSubTotal( bSTotal ),
    bCalcAsShown( pDocument->GetDocOptions().IsCalcAsShown() ),
    bTextAsZero( bTextZero )
{
	SCCOL nStartCol = rRange.aStart.Col();
    SCROW nStartRow = rRange.aStart.Row();
    SCTAB nStartTab = rRange.aStart.Tab();
    SCCOL nEndCol = rRange.aEnd.Col();
    SCROW nEndRow = rRange.aEnd.Row();
    PutInOrder( nStartCol, nEndCol);
    PutInOrder( nStartRow, nEndRow);
    PutInOrder( nStartTab, nEndTab );

    if (!ValidCol(nStartCol)) nStartCol = MAXCOL;
    if (!ValidCol(nEndCol)) nEndCol = MAXCOL;
    if (!ValidRow(nStartRow)) nStartRow = MAXROW;
    if (!ValidRow(nEndRow)) nEndRow = MAXROW;
    if (!ValidTab(nStartTab)) nStartTab = MAXTAB;
    if (!ValidTab(nEndTab)) nEndTab = MAXTAB;

    nCurCol = nStartCol;
    nCurRow = nStartRow;
    nCurTab = nStartTab;

    nNumFormat = 0;                 // will be initialized in GetNumberFormat()
    pAttrArray = 0;
    nAttrEndRow = 0;

    pCellIter = new ScHorizontalCellIterator( pDoc, nStartTab, nStartCol, 
            nStartRow, nEndCol, nEndRow );
}

ScHorizontalValueIterator::~ScHorizontalValueIterator()
{
    delete pCellIter;
}

bool ScHorizontalValueIterator::GetNext( double& rValue, sal_uInt16& rErr )
{
    bool bFound = false;
    while ( !bFound )
    {
        ScBaseCell* pCell = pCellIter->GetNext( nCurCol, nCurRow );
        while ( !pCell )
        {
            if ( nCurTab < nEndTab )
            {
                pCellIter->SetTab( ++nCurTab);
                pCell = pCellIter->GetNext( nCurCol, nCurRow );
            }
            else
                return false;
        }
        if ( !bSubTotal || !pDoc->pTab[nCurTab]->RowFiltered( nCurRow ) )
        {
            switch (pCell->GetCellType())
            {
                case CELLTYPE_VALUE:
                    {
                        bNumValid = false;
                        rValue = ((ScValueCell*)pCell)->GetValue();
                        rErr = 0;
                        if ( bCalcAsShown )
                        {
                            ScColumn* pCol = &pDoc->pTab[nCurTab]->aCol[nCurCol];
                            lcl_IterGetNumberFormat( nNumFormat, pAttrArray,
                                    nAttrEndRow, pCol->pAttrArray, nCurRow, pDoc );
                            rValue = pDoc->RoundValueAsShown( rValue, nNumFormat );
                        }
                        bFound = true;
                    }
                    break;
                case CELLTYPE_FORMULA:
                    {
                        if (!bSubTotal || !((ScFormulaCell*)pCell)->IsSubTotal())
                        {
                            rErr = ((ScFormulaCell*)pCell)->GetErrCode();
                            if ( rErr || ((ScFormulaCell*)pCell)->IsValue() )
                            {
                                rValue = ((ScFormulaCell*)pCell)->GetValue();
                                bNumValid = false;
                                bFound = true;
                            }
                            else if ( bTextAsZero )
                            {
                                rValue = 0.0;
                                bNumValid = false;
                                bFound = true;
                            }
                        }
                    }
                    break;
                case CELLTYPE_STRING :
                case CELLTYPE_EDIT :
                    {
                        if ( bTextAsZero )
                        {
                            rErr = 0;
                            rValue = 0.0;
                            nNumFmtType = NUMBERFORMAT_NUMBER;
                            nNumFmtIndex = 0;
                            bNumValid = true;
                            bFound = true;
                        }
                    }
                    break;
                default:
                    ;   // nothing
            }
        }
    }
    return bFound;
}

void ScHorizontalValueIterator::GetCurNumFmtInfo( short& nType, sal_uLong& nIndex )
{
    if (!bNumValid)
    {
        const ScColumn* pCol = &(pDoc->pTab[nCurTab])->aCol[nCurCol];
        nNumFmtIndex = pCol->GetNumberFormat( nCurRow );
        if ( (nNumFmtIndex % SV_COUNTRY_LANGUAGE_OFFSET) == 0 )
        {
            const ScBaseCell* pCell;
            SCSIZE nCurIndex;
            if ( pCol->Search( nCurRow, nCurIndex ) )
                pCell = pCol->pItems[nCurIndex].pCell;
            else
                pCell = NULL;
            if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA )
                ((const ScFormulaCell*)pCell)->GetFormatInfo( nNumFmtType, nNumFmtIndex );
            else
                nNumFmtType = pDoc->GetFormatTable()->GetType( nNumFmtIndex );
        }
        else
            nNumFmtType = pDoc->GetFormatTable()->GetType( nNumFmtIndex );
        bNumValid = true;
    }
    nType = nNumFmtType;
    nIndex = nNumFmtIndex;
}

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

ScHorizontalAttrIterator::ScHorizontalAttrIterator( ScDocument* pDocument, SCTAB nTable,
							SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) :
	pDoc( pDocument ),
	nTab( nTable ),
	nStartCol( nCol1 ),
	nStartRow( nRow1 ),
	nEndCol( nCol2 ),
	nEndRow( nRow2 )
{
	DBG_ASSERT( pDoc->pTab[nTab], "Tabelle nicht da" );

	SCCOL i;

	nRow = nStartRow;
	nCol = nStartCol;
	bRowEmpty = sal_False;

	pIndices	= new SCSIZE[nEndCol-nStartCol+1];
	pNextEnd	= new SCROW[nEndCol-nStartCol+1];
	ppPatterns	= new const ScPatternAttr*[nEndCol-nStartCol+1];

	SCROW nSkipTo = MAXROW;
	sal_Bool bEmpty = sal_True;
	for (i=nStartCol; i<=nEndCol; i++)
	{
		SCCOL nPos = i - nStartCol;
		ScAttrArray* pArray = pDoc->pTab[nTab]->aCol[i].pAttrArray;
		DBG_ASSERT( pArray, "pArray == 0" );

		SCSIZE nIndex;
		pArray->Search( nStartRow, nIndex );

		const ScPatternAttr* pPattern = pArray->pData[nIndex].pPattern;
		SCROW nThisEnd = pArray->pData[nIndex].nRow;
		if ( IsDefaultItem( pPattern ) )
		{
			pPattern = NULL;
			if ( nThisEnd < nSkipTo )
				nSkipTo = nThisEnd;			// nSkipTo kann gleich hier gesetzt werden
		}
		else
			bEmpty = sal_False;					// Attribute gefunden

		pIndices[nPos] = nIndex;
		pNextEnd[nPos] = nThisEnd;
		ppPatterns[nPos] = pPattern;
	}

	if (bEmpty)
		nRow = nSkipTo;						// bis zum naechsten Bereichsende ueberspringen
	bRowEmpty = bEmpty;
}

ScHorizontalAttrIterator::~ScHorizontalAttrIterator()
{
	delete[] (ScPatternAttr**)ppPatterns;
	delete[] pNextEnd;
	delete[] pIndices;
}

const ScPatternAttr* ScHorizontalAttrIterator::GetNext( SCCOL& rCol1, SCCOL& rCol2, SCROW& rRow )
{
	for (;;)
	{
		if (!bRowEmpty)
		{
			// in dieser Zeile suchen

			while ( nCol <= nEndCol && !ppPatterns[nCol-nStartCol] )
				++nCol;

			if ( nCol <= nEndCol )
			{
				const ScPatternAttr* pPat = ppPatterns[nCol-nStartCol];
				rRow = nRow;
				rCol1 = nCol;
				while ( nCol < nEndCol && ppPatterns[nCol+1-nStartCol] == pPat )
					++nCol;
				rCol2 = nCol;
				++nCol;					// hochzaehlen fuer naechsten Aufruf
				return pPat;			// gefunden
			}
		}

		// naechste Zeile

		++nRow;
		if ( nRow > nEndRow )		// schon am Ende?
			return NULL;			// nichts gefunden

		sal_Bool bEmpty = sal_True;
		SCCOL i;

		for ( i = nStartCol; i <= nEndCol; i++)
		{
			SCCOL nPos = i-nStartCol;
			if ( pNextEnd[nPos] < nRow )
			{
				ScAttrArray* pArray = pDoc->pTab[nTab]->aCol[i].pAttrArray;

				SCSIZE nIndex = ++pIndices[nPos];
				if ( nIndex < pArray->nCount )
				{
					const ScPatternAttr* pPattern = pArray->pData[nIndex].pPattern;
					SCROW nThisEnd = pArray->pData[nIndex].nRow;
					if ( IsDefaultItem( pPattern ) )
						pPattern = NULL;
					else
						bEmpty = sal_False;					// Attribute gefunden

					pNextEnd[nPos] = nThisEnd;
					ppPatterns[nPos] = pPattern;

					DBG_ASSERT( pNextEnd[nPos] >= nRow, "Reihenfolge durcheinander" );
				}
				else
				{
					DBG_ERROR("AttrArray reicht nicht bis MAXROW");
					pNextEnd[nPos] = MAXROW;
					ppPatterns[nPos] = NULL;
				}
			}
			else if ( ppPatterns[nPos] )
				bEmpty = sal_False;							// Bereich noch nicht zuende
		}

		if (bEmpty)
		{
			SCCOL nCount = nEndCol-nStartCol+1;
			SCROW nSkipTo = pNextEnd[0];				// naechstes Bereichsende suchen
			for (i=1; i<nCount; i++)
				if ( pNextEnd[i] < nSkipTo )
					nSkipTo = pNextEnd[i];
			nRow = nSkipTo;								// leere Zeilen ueberspringen
		}
		bRowEmpty = bEmpty;
		nCol = nStartCol;			// wieder links anfangen
	}

//    return NULL;
}

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

inline sal_Bool IsGreater( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
{
	return ( nRow1 > nRow2 ) || ( nRow1 == nRow2 && nCol1 > nCol2 );
}

ScUsedAreaIterator::ScUsedAreaIterator( ScDocument* pDocument, SCTAB nTable,
							SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) :
	aCellIter( pDocument, nTable, nCol1, nRow1, nCol2, nRow2 ),
	aAttrIter( pDocument, nTable, nCol1, nRow1, nCol2, nRow2 ),
	nNextCol( nCol1 ),
	nNextRow( nRow1 )
{
	pCell    = aCellIter.GetNext( nCellCol, nCellRow );
	pPattern = aAttrIter.GetNext( nAttrCol1, nAttrCol2, nAttrRow );
}

ScUsedAreaIterator::~ScUsedAreaIterator()
{
}

sal_Bool ScUsedAreaIterator::GetNext()
{
	//	Iteratoren weiterzaehlen

	if ( pCell && IsGreater( nNextCol, nNextRow, nCellCol, nCellRow ) )
		pCell = aCellIter.GetNext( nCellCol, nCellRow );

    while ( pCell && pCell->IsBlank() )
		pCell = aCellIter.GetNext( nCellCol, nCellRow );

	if ( pPattern && IsGreater( nNextCol, nNextRow, nAttrCol2, nAttrRow ) )
		pPattern = aAttrIter.GetNext( nAttrCol1, nAttrCol2, nAttrRow );

	if ( pPattern && nAttrRow == nNextRow && nAttrCol1 < nNextCol )
		nAttrCol1 = nNextCol;

	//	naechsten Abschnitt heraussuchen

	sal_Bool bFound = sal_True;
	sal_Bool bUseCell = sal_False;

	if ( pCell && pPattern )
	{
		if ( IsGreater( nCellCol, nCellRow, nAttrCol1, nAttrRow ) )		// vorne nur Attribute ?
		{
			pFoundCell = NULL;
			pFoundPattern = pPattern;
			nFoundRow = nAttrRow;
			nFoundStartCol = nAttrCol1;
			if ( nCellRow == nAttrRow && nCellCol <= nAttrCol2 )		// auch Zelle im Bereich ?
				nFoundEndCol = nCellCol - 1;							// nur bis vor der Zelle
			else
				nFoundEndCol = nAttrCol2;								// alles
		}
		else
		{
			bUseCell = sal_True;
			if ( nAttrRow == nCellRow && nAttrCol1 == nCellCol )		// Attribute auf der Zelle ?
				pFoundPattern = pPattern;
			else
				pFoundPattern = NULL;
		}
	}
	else if ( pCell )					// nur Zelle -> direkt uebernehmen
	{
		pFoundPattern = NULL;
		bUseCell = sal_True;				// Position von Zelle
	}
	else if ( pPattern )				// nur Attribute -> direkt uebernehmen
	{
		pFoundCell = NULL;
		pFoundPattern = pPattern;
		nFoundRow = nAttrRow;
		nFoundStartCol = nAttrCol1;
		nFoundEndCol = nAttrCol2;
	}
	else								// gar nichts
		bFound = sal_False;

	if ( bUseCell )						// Position von Zelle
	{
		pFoundCell = pCell;
		nFoundRow = nCellRow;
		nFoundStartCol = nFoundEndCol = nCellCol;
	}

	if (bFound)
	{
		nNextRow = nFoundRow;
		nNextCol = nFoundEndCol + 1;
	}

	return bFound;
}

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

ScDocAttrIterator::ScDocAttrIterator(ScDocument* pDocument, SCTAB nTable,
									SCCOL nCol1, SCROW nRow1,
									SCCOL nCol2, SCROW nRow2) :
	pDoc( pDocument ),
	nTab( nTable ),
	nEndCol( nCol2 ),
	nStartRow( nRow1 ),
	nEndRow( nRow2 ),
	nCol( nCol1 )
{
	if ( ValidTab(nTab) && pDoc->pTab[nTab] )
		pColIter = pDoc->pTab[nTab]->aCol[nCol].CreateAttrIterator( nStartRow, nEndRow );
	else
		pColIter = NULL;
}

ScDocAttrIterator::~ScDocAttrIterator()
{
	delete pColIter;
}

const ScPatternAttr* ScDocAttrIterator::GetNext( SCCOL& rCol, SCROW& rRow1, SCROW& rRow2 )
{
	while ( pColIter )
	{
		const ScPatternAttr* pPattern = pColIter->Next( rRow1, rRow2 );
		if ( pPattern )
		{
			rCol = nCol;
			return pPattern;
		}

		delete pColIter;
		++nCol;
		if ( nCol <= nEndCol )
			pColIter = pDoc->pTab[nTab]->aCol[nCol].CreateAttrIterator( nStartRow, nEndRow );
		else
			pColIter = NULL;
	}
	return NULL;		// is nix mehr
}

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

ScAttrRectIterator::ScAttrRectIterator(ScDocument* pDocument, SCTAB nTable,
									SCCOL nCol1, SCROW nRow1,
									SCCOL nCol2, SCROW nRow2) :
	pDoc( pDocument ),
	nTab( nTable ),
	nEndCol( nCol2 ),
	nStartRow( nRow1 ),
	nEndRow( nRow2 ),
	nIterStartCol( nCol1 ),
	nIterEndCol( nCol1 )
{
	if ( ValidTab(nTab) && pDoc->pTab[nTab] )
	{
		pColIter = pDoc->pTab[nTab]->aCol[nIterStartCol].CreateAttrIterator( nStartRow, nEndRow );
		while ( nIterEndCol < nEndCol &&
				pDoc->pTab[nTab]->aCol[nIterEndCol].IsAllAttrEqual(
					pDoc->pTab[nTab]->aCol[nIterEndCol+1], nStartRow, nEndRow ) )
			++nIterEndCol;
	}
	else
		pColIter = NULL;
}

ScAttrRectIterator::~ScAttrRectIterator()
{
	delete pColIter;
}

void ScAttrRectIterator::DataChanged()
{
	if (pColIter)
	{
		SCROW nNextRow = pColIter->GetNextRow();
		delete pColIter;
		pColIter = pDoc->pTab[nTab]->aCol[nIterStartCol].CreateAttrIterator( nNextRow, nEndRow );
	}
}

const ScPatternAttr* ScAttrRectIterator::GetNext( SCCOL& rCol1, SCCOL& rCol2,
													SCROW& rRow1, SCROW& rRow2 )
{
	while ( pColIter )
	{
		const ScPatternAttr* pPattern = pColIter->Next( rRow1, rRow2 );
		if ( pPattern )
		{
			rCol1 = nIterStartCol;
			rCol2 = nIterEndCol;
			return pPattern;
		}

		delete pColIter;
		nIterStartCol = nIterEndCol+1;
		if ( nIterStartCol <= nEndCol )
		{
			nIterEndCol = nIterStartCol;
			pColIter = pDoc->pTab[nTab]->aCol[nIterStartCol].CreateAttrIterator( nStartRow, nEndRow );
			while ( nIterEndCol < nEndCol &&
					pDoc->pTab[nTab]->aCol[nIterEndCol].IsAllAttrEqual(
						pDoc->pTab[nTab]->aCol[nIterEndCol+1], nStartRow, nEndRow ) )
				++nIterEndCol;
		}
		else
			pColIter = NULL;
	}
	return NULL;		// is nix mehr
}

// ============================================================================

SCROW ScRowBreakIterator::NOT_FOUND = -1;

ScRowBreakIterator::ScRowBreakIterator(set<SCROW>& rBreaks) : 
    mrBreaks(rBreaks),
    maItr(rBreaks.begin()), maEnd(rBreaks.end())
{
}

SCROW ScRowBreakIterator::first()
{
    maItr = mrBreaks.begin();
    return maItr == maEnd ? NOT_FOUND : *maItr;
}

SCROW ScRowBreakIterator::next()
{
    ++maItr;
    return maItr == maEnd ? NOT_FOUND : *maItr;
}