/**************************************************************
 *
 * 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_editeng.hxx"

#include <editeng/txtrange.hxx>
#include <math.h>
#include <tools/poly.hxx>
#include <tools/debug.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>

/*************************************************************************
|*
|*    TextRanger::TextRanger()
|*
|*    Beschreibung
|*    Ersterstellung    20.01.97
|*    Letzte Aenderung  20.01.97 AMA
|*
*************************************************************************/

TextRanger::TextRanger( const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B2DPolyPolygon* pLinePolyPolygon,
	sal_uInt16 nCacheSz, sal_uInt16 nLft, sal_uInt16 nRght, sal_Bool bSimpl, sal_Bool bInnr,
	sal_Bool bVert ) :
	pBound( NULL ),
	nCacheSize( nCacheSz ),
	nCacheIdx( 0 ),
	nRight( nRght ),
	nLeft( nLft ),
	nUpper( 0 ),
	nLower( 0 ),
	nPointCount( 0 ),
	bSimple( bSimpl ),
	bInner( bInnr ),
	bVertical( bVert )
{
#ifdef DBG_UTIL
	bFlag3 = bFlag4 = bFlag5 = bFlag6 = bFlag7 = sal_False;
#endif
	pRangeArr = new Range[ nCacheSize ];
	pCache = new SvLongsPtr[ nCacheSize ];
	memset( pRangeArr, 0, nCacheSize * sizeof( Range ) );
	memset( pCache, 0, nCacheSize * sizeof( SvLongsPtr ) );
	sal_uInt32 nCount(rPolyPolygon.count());
	mpPolyPolygon = new PolyPolygon( (sal_uInt16)nCount );

	for(sal_uInt32 i(0L); i < nCount; i++)
	{
		const basegfx::B2DPolygon aCandidate(rPolyPolygon.getB2DPolygon(i).getDefaultAdaptiveSubdivision());
		nPointCount += aCandidate.count();
		mpPolyPolygon->Insert( Polygon(aCandidate), (sal_uInt16)i );
	}

	if( pLinePolyPolygon )
	{
		nCount = pLinePolyPolygon->count();
		mpLinePolyPolygon = new PolyPolygon();

		for(sal_uInt32 i(0L); i < nCount; i++)
		{
			const basegfx::B2DPolygon aCandidate(pLinePolyPolygon->getB2DPolygon(i).getDefaultAdaptiveSubdivision());
			nPointCount += aCandidate.count();
			mpLinePolyPolygon->Insert( Polygon(aCandidate), (sal_uInt16)i );
		}
	}
	else
		mpLinePolyPolygon = NULL;
}

/*************************************************************************
|*
|*    TextRanger::~TextRanger()
|*
|*    Beschreibung
|*    Ersterstellung    20.01.97
|*    Letzte Aenderung  20.01.97 AMA
|*
*************************************************************************/

TextRanger::~TextRanger()
{
	for( sal_uInt16 i = 0; i < nCacheSize; ++i )
		delete pCache[i];
	delete[] pCache;
	delete[] pRangeArr;
	delete mpPolyPolygon;
	delete mpLinePolyPolygon;
	delete pBound;
}

/*-----------------17.11.00 09:49-------------------
 * TextRanger::SetVertical(..)
 * If there's is a change in the writing direction,
 * the cache has to be cleared.
 * --------------------------------------------------*/

void TextRanger::SetVertical( sal_Bool bNew )
{
	if( IsVertical() != bNew )
	{
		bVertical = bNew;
		for( sal_uInt16 i = 0; i < nCacheSize; ++i )
			delete pCache[i];
		memset( pRangeArr, 0, nCacheSize * sizeof( Range ) );
		memset( pCache, 0, nCacheSize * sizeof( SvLongsPtr ) );
	}
}

/*************************************************************************
|*
|*    SvxBoundArgs
|*
|*    Beschreibung
|*    Ersterstellung    20.01.97
|*    Letzte Aenderung  20.01.97 AMA
|*
*************************************************************************/

class SvxBoundArgs
{
	SvBools aBoolArr;
	SvLongs *pLongArr;
	TextRanger *pTextRanger;
	long nMin;
	long nMax;
	long nTop;
	long nBottom;
	long nUpDiff;
	long nLowDiff;
	long nUpper;
	long nLower;
	long nStart;
	long nEnd;
	sal_uInt16 nCut;
	sal_uInt16 nLast;
	sal_uInt16 nNext;
	sal_uInt8 nAct;
	sal_uInt8 nFirst;
	sal_Bool bClosed : 1;
	sal_Bool bInner : 1;
	sal_Bool bMultiple : 1;
	sal_Bool bConcat : 1;
	sal_Bool bRotate : 1;
	void NoteRange( sal_Bool bToggle );
	long Cut( long nY, const Point& rPt1, const Point& rPt2 );
	void Add();
	void _NoteFarPoint( long nPx, long nPyDiff, long nDiff );
	void NoteFarPoint( long nPx, long nPyDiff, long nDiff )
		{ if( nDiff ) _NoteFarPoint( nPx, nPyDiff, nDiff ); }
	long CalcMax( const Point& rPt1, const Point& rPt2,	long nRange, long nFar );
	void CheckCut( const Point& rLst, const Point& rNxt );
	inline long A( const Point& rP ) const { return bRotate ? rP.Y() : rP.X(); }
	inline long B( const Point& rP ) const { return bRotate ? rP.X() : rP.Y(); }
public:
	SvxBoundArgs( TextRanger* pRanger, SvLongs *pLong, const Range& rRange );
	void NotePoint( const long nA ) { NoteMargin( nA - nStart, nA + nEnd ); }
	void NoteMargin( const long nL, const long nR )
		{ if( nMin > nL ) nMin = nL; if( nMax < nR ) nMax = nR; }
	sal_uInt16 Area( const Point& rPt );
	void NoteUpLow( long nA, const sal_uInt8 nArea );
	void Calc( const PolyPolygon& rPoly );
	void Concat( const PolyPolygon* pPoly );
	// inlines
	void NoteLast() { if( bMultiple ) NoteRange( nAct == nFirst ); }
	void SetClosed( const sal_Bool bNew ){ bClosed = bNew; }
	sal_Bool IsClosed() const { return bClosed; }
	void SetConcat( const sal_Bool bNew ){ bConcat = bNew; }
	sal_Bool IsConcat() const { return bConcat; }
	sal_uInt8 GetAct() const { return nAct; }
};

SvxBoundArgs::SvxBoundArgs( TextRanger* pRanger, SvLongs *pLong,
	const Range& rRange )
	: pLongArr( pLong ), pTextRanger( pRanger ),
	nTop( rRange.Min() ), nBottom( rRange.Max() ),
	bInner( pRanger->IsInner() ), bMultiple( bInner || !pRanger->IsSimple() ),
	bConcat( sal_False ), bRotate( pRanger->IsVertical() )
{
	if( bRotate )
	{
		nStart = pRanger->GetUpper();
		nEnd = pRanger->GetLower();
		nLowDiff = pRanger->GetLeft();
		nUpDiff = pRanger->GetRight();
	}
	else
	{
		nStart = pRanger->GetLeft();
		nEnd = pRanger->GetRight();
		nLowDiff = pRanger->GetUpper();
		nUpDiff = pRanger->GetLower();
	}
	nUpper = nTop - nUpDiff;
	nLower = nBottom + nLowDiff;
	pLongArr->Remove( 0, pLongArr->Count() );
}

long SvxBoundArgs::CalcMax( const Point& rPt1, const Point& rPt2,
	long nRange, long nFarRange )
{
	double nDa = Cut( nRange, rPt1, rPt2 ) - Cut( nFarRange, rPt1, rPt2 );
	double nB;
	if( nDa < 0 )
	{
		nDa = -nDa;
		nB = nEnd;
	}
	else
		nB = nStart;
	nB *= nB;
	nB += nDa * nDa;
	nB = nRange + nDa * ( nFarRange - nRange ) / sqrt( nB );

	sal_Bool bNote;
	if( nB < B(rPt2) )
		bNote = nB > B(rPt1);
	else
		bNote = nB < B(rPt1);
	if( bNote )
		return( long( nB ) );
	return 0;
}

void SvxBoundArgs::CheckCut( const Point& rLst, const Point& rNxt )
{
	if( nCut & 1 )
		NotePoint( Cut( nBottom, rLst, rNxt ) );
	if( nCut & 2 )
		NotePoint( Cut( nTop, rLst, rNxt ) );
	if( rLst.X() != rNxt.X() && rLst.Y() != rNxt.Y() )
	{
		long nYps;
		if( nLowDiff && ( ( nCut & 1 ) || nLast == 1 || nNext == 1 ) )
		{
			nYps = CalcMax( rLst, rNxt, nBottom, nLower );
			if( nYps )
				_NoteFarPoint( Cut( nYps, rLst, rNxt ), nLower-nYps, nLowDiff );
		}
		if( nUpDiff && ( ( nCut & 2 ) || nLast == 2 || nNext == 2 ) )
		{
			nYps = CalcMax( rLst, rNxt, nTop, nUpper );
			if( nYps )
				_NoteFarPoint( Cut( nYps, rLst, rNxt ), nYps-nUpper, nUpDiff );
		}
	}
}

void SvxBoundArgs::_NoteFarPoint( long nPa, long nPbDiff, long nDiff )
{
	long nTmpA;
	double nQuot = 2 * nDiff - nPbDiff;
	nQuot *= nPbDiff;
	nQuot = sqrt( nQuot );
	nQuot /= nDiff;
	nTmpA = nPa - long( nStart * nQuot );
	nPbDiff = nPa + long( nEnd * nQuot );
	NoteMargin( nTmpA, nPbDiff );
}

void SvxBoundArgs::NoteRange( sal_Bool bToggle )
{
	DBG_ASSERT( nMax >= nMin || bInner, "NoteRange: Min > Max?");
	if( nMax < nMin )
		return;
	if( !bClosed )
		bToggle = sal_False;
	sal_uInt16 nIdx = 0;
	sal_uInt16 nCount = pLongArr->Count();
	DBG_ASSERT( nCount == 2 * aBoolArr.size(), "NoteRange: Incompatible Sizes" );
	while( nIdx < nCount && (*pLongArr)[ nIdx ] < nMin )
		++nIdx;
	sal_Bool bOdd = nIdx % 2 ? sal_True : sal_False;
	// Kein Ueberlappung mit vorhandenen Intervallen?
	if( nIdx == nCount || ( !bOdd && nMax < (*pLongArr)[ nIdx ] ) )
	{	// Dann wird ein neues eingefuegt ...
		pLongArr->Insert( nMin, nIdx );
		pLongArr->Insert( nMax, nIdx + 1 );
		aBoolArr.insert( aBoolArr.begin() + nIdx / 2, bToggle );
	}
	else
	{   // ein vorhandes Intervall erweitern ...
		sal_uInt16 nMaxIdx = nIdx;
		// Wenn wir auf einer linken Intervallgrenze gelandet sind, muss diese
		// auf nMin gesenkt werden.
		if( bOdd )
			--nIdx;
		else
			(*pLongArr)[ nIdx ] = nMin;
		while( nMaxIdx < nCount && (*pLongArr)[ nMaxIdx ] < nMax )
			++nMaxIdx;
		DBG_ASSERT( nMaxIdx > nIdx || nMin == nMax, "NoteRange: Funny Situation." );
		if( nMaxIdx )
			--nMaxIdx;
		if( nMaxIdx < nIdx )
			nMaxIdx = nIdx;
		// Wenn wir auf einer rechten Intervallgrenze landen, muss diese
		// auf nMax angehoben werden.
		if( nMaxIdx % 2 )
			(*pLongArr)[ nMaxIdx-- ] = nMax;
		// Jetzt werden eventuell noch Intervalle verschmolzen
		sal_uInt16 nDiff = nMaxIdx - nIdx;
		nMaxIdx = nIdx / 2; // Ab hier ist nMaxIdx der Index im BoolArray.
		if( nDiff )
		{
			(*pLongArr).Remove( nIdx + 1, nDiff );
			nDiff /= 2;
			sal_uInt16 nStop = nMaxIdx + nDiff;
			for( sal_uInt16 i = nMaxIdx; i < nStop; ++i )
				bToggle ^= aBoolArr[ i ];
			aBoolArr.erase( aBoolArr.begin() + nMaxIdx, aBoolArr.begin() + (nMaxIdx + nDiff) );
		}
		DBG_ASSERT( nMaxIdx < aBoolArr.size(), "NoteRange: Too much deleted" );
		aBoolArr[ nMaxIdx ] ^= bToggle;
	}
}

void SvxBoundArgs::Calc( const PolyPolygon& rPoly )
{
	sal_uInt16 nCount;
	nAct = 0;
	for( sal_uInt16 i = 0; i < rPoly.Count(); ++i )
	{
		const Polygon& rPol = rPoly[ i ];
		nCount = rPol.GetSize();
		if( nCount )
		{
			const Point& rNull = rPol[ 0 ];
			SetClosed( IsConcat() || ( rNull == rPol[ nCount - 1 ] ) );
			nLast = Area( rNull );
			if( nLast & 12 )
			{
				nFirst = 3;
				if( bMultiple )
					nAct = 0;
			}
			else
			{
				// Der erste Punkt des Polygons liegt innerhalb der Zeile.
				if( nLast )
				{
					if( bMultiple || !nAct )
					{
						nMin = USHRT_MAX;
						nMax = 0;
					}
					if( nLast & 1 )
						NoteFarPoint( A(rNull), nLower - B(rNull), nLowDiff );
					else
						NoteFarPoint( A(rNull), B(rNull) - nUpper, nUpDiff );
				}
				else
				{
					if( bMultiple || !nAct )
					{
						nMin = A(rNull);
						nMax = nMin + nEnd;
						nMin -= nStart;
					}
					else
						NotePoint( A(rNull) );
				}
				nFirst = 0;	// In welcher Richtung wird die Zeile verlassen?
				nAct = 3;	// Wir sind z.Z. innerhalb der Zeile.
			}
			if( nCount > 1 )
			{
				sal_uInt16 nIdx = 1;
				while( sal_True )
				{
					const Point& rLast = rPol[ nIdx - 1 ];
					if( nIdx == nCount )
						nIdx = 0;
					const Point& rNext = rPol[ nIdx ];
					nNext = Area( rNext );
					nCut = nNext ^ nLast;
					sal_uInt16 nOldAct = nAct;
					if( nAct )
						CheckCut( rLast, rNext );
					if( nCut & 4 )
					{
						NoteUpLow( Cut( nLower, rLast, rNext ), 2 );
						if( nAct && nAct != nOldAct )
						{
							nOldAct = nAct;
							CheckCut( rLast, rNext );
						}
					}
					if( nCut & 8 )
					{
						NoteUpLow( Cut( nUpper, rLast, rNext ), 1 );
						if( nAct && nAct != nOldAct )
							CheckCut( rLast, rNext );
					}
					if( !nIdx )
					{
						if( !( nNext & 12 ) )
							NoteLast();
						break;
					}
					if( !( nNext & 12 ) )
					{
						if( !nNext )
							NotePoint( A(rNext) );
						else if( nNext & 1 )
							NoteFarPoint( A(rNext), nLower-B(rNext), nLowDiff );
						else
							NoteFarPoint( A(rNext), B(rNext)-nUpper, nUpDiff );
					}
					nLast = nNext;
					if( ++nIdx == nCount && !IsClosed() )
					{
						if( !( nNext & 12 ) )
							NoteLast();
						break;
					}
				}
			}
			if( bMultiple && IsConcat() )
			{
				Add();
				nAct = 0;
			}
		}
	}
	if( !bMultiple )
	{
		DBG_ASSERT( pLongArr->Count() == 0, "I said: Simple!" );
		if( nAct )
		{
			if( bInner )
			{
				long nTmpMin, nTmpMax;
				{
					nTmpMin = nMin + 2 * nStart;
					nTmpMax = nMax - 2 * nEnd;
					if( nTmpMin <= nTmpMax )
					{
						pLongArr->Insert( nTmpMin, 0 );
						pLongArr->Insert( nTmpMax, 1 );
					}
				}
			}
			else
			{
				pLongArr->Insert( nMin, 0 );
				pLongArr->Insert( nMax, 1 );
			}
		}
	}
	else if( !IsConcat() )
		Add();
}

void SvxBoundArgs::Add()
{
	sal_uInt16 nLongIdx = 1;
	size_t nCount = aBoolArr.size();
	if( nCount && ( !bInner || !pTextRanger->IsSimple() ) )
	{
		sal_Bool bDelete = aBoolArr.front();
		if( bInner )
			bDelete = !bDelete;
		for( size_t nBoolIdx = 1; nBoolIdx < nCount; ++nBoolIdx )
		{
			if( bDelete )
			{
				sal_uInt16 next = 2;
				while( nBoolIdx < nCount && !aBoolArr[ nBoolIdx++ ] &&
					   (!bInner || nBoolIdx < nCount ) )
					next += 2;
				pLongArr->Remove( nLongIdx, next );
				next /= 2;
				nBoolIdx = nBoolIdx - next;
				nCount = nCount - next;
				aBoolArr.erase( aBoolArr.begin() + nBoolIdx, aBoolArr.begin() + (nBoolIdx + next) );
				if( nBoolIdx )
					aBoolArr[ nBoolIdx - 1 ] = sal_False;
#if OSL_DEBUG_LEVEL > 1
				else
					++next;
#endif
			}
			bDelete = nBoolIdx < nCount && aBoolArr[ nBoolIdx ];
			nLongIdx += 2;
			DBG_ASSERT( nLongIdx == 2*nBoolIdx+1, "BoundArgs: Array-Idx Confusion" );
			DBG_ASSERT( aBoolArr.size()*2 == pLongArr->Count(),
						"BoundArgs: Array-Count: Confusion" );
		}
	}
	if( 0 != ( nCount = pLongArr->Count() ) )
	{
		if( bInner )
		{
			pLongArr->Remove( 0, 1 );
			pLongArr->Remove( pLongArr->Count() - 1, 1 );

			// Hier wird die Zeile beim "einfachen" Konturumfluss im Innern
			// in ein grosses Rechteck zusammengefasst.
			// Zur Zeit (April 1999) wertet die EditEngine nur das erste Rechteck
			// aus, falls sie eines Tages in der Lage ist, eine Zeile in mehreren
			// Teilen auszugeben, kann es sinnvoll sein, die folgenden Zeilen
			// zu loeschen.
			if( pTextRanger->IsSimple() && pLongArr->Count() > 2 )
				pLongArr->Remove( 1, pLongArr->Count() - 2 );

		}
	}
}

void SvxBoundArgs::Concat( const PolyPolygon* pPoly )
{
	SetConcat( sal_True );
	DBG_ASSERT( pPoly, "Nothing to do?" );
	SvLongs *pOld = pLongArr;
	pLongArr = new SvLongs( 2, 8 );
	aBoolArr.clear();
	bInner = sal_False;
	Calc( *pPoly );
	sal_uInt16 nCount = pLongArr->Count();
	sal_uInt16 nIdx = 0;
	sal_uInt16 i = 0;
	sal_Bool bSubtract = pTextRanger->IsInner();
	while( i < nCount )
	{
		sal_uInt16 nOldCount = pOld->Count();
		if( nIdx == nOldCount )
		{   // Am Ende des alten Arrays angelangt...
			if( !bSubtract )
				pOld->Insert( pLongArr, nIdx, i, USHRT_MAX );
			break;
		}
		long nLeft = (*pLongArr)[ i++ ];
		long nRight = (*pLongArr)[ i++ ];
		sal_uInt16 nLeftPos = nIdx + 1;
		while( nLeftPos < nOldCount && nLeft > (*pOld)[ nLeftPos ] )
			nLeftPos += 2;
		if( nLeftPos >= nOldCount )
		{	// Das aktuelle Intervall gehoert ans Ende des alten Arrays...
			if( !bSubtract )
				pOld->Insert( pLongArr, nOldCount, i - 2, USHRT_MAX );
			break;
		}
		sal_uInt16 nRightPos = nLeftPos - 1;
		while( nRightPos < nOldCount && nRight >= (*pOld)[ nRightPos ] )
			nRightPos += 2;
		if( nRightPos < nLeftPos )
		{   // Das aktuelle Intervall gehoert zwischen zwei alte Intervalle
			if( !bSubtract )
				pOld->Insert( pLongArr, nRightPos, i - 2, i );
			nIdx = nRightPos + 2;
		}
		else if( bSubtract ) // Subtrahieren ggf. Trennen
		{
			long nOld;
			if( nLeft > ( nOld = (*pOld)[ nLeftPos - 1 ] ) )
			{   // Jetzt spalten wir den linken Teil ab...
				if( nLeft - 1 > nOld )
				{
					pOld->Insert( nOld, nLeftPos - 1 );
					pOld->Insert( nLeft - 1, nLeftPos );
					nLeftPos += 2;
					nRightPos += 2;
				}
			}
			if( nRightPos - nLeftPos > 1 )
				pOld->Remove( nLeftPos, nRightPos - nLeftPos - 1 );
			if( ++nRight >= ( nOld = (*pOld)[ nLeftPos ] ) )
				pOld->Remove( nLeftPos - 1, 2 );
			else
				(*pOld)[ nLeftPos - 1 ] = nRight;
		}
		else // Verschmelzen
		{
			if( nLeft < (*pOld)[ nLeftPos - 1 ] )
				(*pOld)[ nLeftPos - 1 ] = nLeft;
			if( nRight > (*pOld)[ nRightPos - 1 ] )
				(*pOld)[ nRightPos - 1 ] = nRight;
			if( nRightPos - nLeftPos > 1 )
				pOld->Remove( nLeftPos, nRightPos - nLeftPos - 1 );

		}
		nIdx = nLeftPos - 1;
	}
	delete pLongArr;
}

/*************************************************************************
 * SvxBoundArgs::Area ermittelt den Bereich, in dem sich der Punkt befindet
 * 0 = innerhalb der Zeile
 * 1 = unterhalb, aber innerhalb der oberen Randes
 * 2 = oberhalb, aber innerhalb der unteren Randes
 * 5 = unterhalb des oberen Randes
 *10 = oberhalb des unteren Randes
 *************************************************************************/

sal_uInt16 SvxBoundArgs::Area( const Point& rPt )
{
	long nB = B( rPt );
	if( nB >= nBottom )
	{
		if( nB >= nLower )
			return 5;
		return 1;
	}
	if( nB <= nTop )
	{
		if( nB <= nUpper )
			return 10;
		return 2;
	}
	return 0;
}

/*************************************************************************
 * lcl_Cut berechnet die X-Koordinate der Strecke (Pt1-Pt2) auf der
 * Y-Koordinate nY.
 * Vorausgesetzt wird, dass einer der Punkte oberhalb und der andere
 * unterhalb der Y-Koordinate liegt.
 *************************************************************************/

long SvxBoundArgs::Cut( long nB, const Point& rPt1, const Point& rPt2 )
{
	if( pTextRanger->IsVertical() )
	{
		double nQuot = nB - rPt1.X();
		nQuot /= ( rPt2.X() - rPt1.X() );
		nQuot *= ( rPt2.Y() - rPt1.Y() );
		return long( rPt1.Y() + nQuot );
	}
	double nQuot = nB - rPt1.Y();
	nQuot /= ( rPt2.Y() - rPt1.Y() );
	nQuot *= ( rPt2.X() - rPt1.X() );
	return long( rPt1.X() + nQuot );
}

void SvxBoundArgs::NoteUpLow( long nA, const sal_uInt8 nArea )
{
	if( nAct )
	{
		NoteMargin( nA, nA );
		if( bMultiple )
		{
			NoteRange( nArea != nAct );
			nAct = 0;
		}
		if( !nFirst )
			nFirst = nArea;
	}
	else
	{
		nAct = nArea;
		nMin = nA;
		nMax = nA;
	}
}

SvLongsPtr TextRanger::GetTextRanges( const Range& rRange )
{
	DBG_ASSERT( rRange.Min() || rRange.Max(), "Zero-Range not allowed, Bye Bye" );
	sal_uInt16 nIndex = 0;
	while( nIndex < nCacheSize && rRange != pRangeArr[ nIndex ] )
		++nIndex;
	if( nIndex >= nCacheSize )
	{
		++nCacheIdx;
		nCacheIdx %= nCacheSize;
		pRangeArr[ nCacheIdx ] = rRange;
		if( !pCache[ nCacheIdx ] )
			pCache[ nCacheIdx ] = new SvLongs( 2, 8 );
		nIndex = nCacheIdx;
		SvxBoundArgs aArg( this, pCache[ nCacheIdx ], rRange );
		aArg.Calc( *mpPolyPolygon );
		if( mpLinePolyPolygon )
			aArg.Concat( mpLinePolyPolygon );
	}
	return pCache[ nIndex ];
}

const Rectangle& TextRanger::_GetBoundRect()
{
	DBG_ASSERT( 0 == pBound, "Don't call twice." );
	pBound = new Rectangle( mpPolyPolygon->GetBoundRect() );
	return *pBound;
}