// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\euser\us_regn.cpp

// 

//

#include "us_std.h"

NONSHARABLE_CLASS(TRectKey) : public TKey

	{

public:

	TRectKey(const TRect *aRectList,const TPoint &aOffset);

	virtual TInt Compare(TInt aLeft,TInt aRight) const;

private:

	const TRect *iRectList;

	TBool iDown;

	TBool iRight;

	};

NONSHARABLE_CLASS(TRectSwap) : public TSwap

	{

public:

	inline TRectSwap(TRect *aRectList);

	virtual void Swap(TInt aLeft,TInt aRight) const;

private:

	TRect *iRectList;

	};

inline TRectSwap::TRectSwap(TRect *aRectList)

	{iRectList=aRectList;}

enum {ERegionBufSize=8};

EXPORT_C TRegion::TRegion(TInt aAllocedRects)

//

// Constructor.

//

	: iCount(0),iError(EFalse),iAllocedRects(aAllocedRects)

	{}

EXPORT_C TBool TRegion::IsEmpty() const

/**

Tests whether the region is empty.

@return True, if the region is empty and its error flag is unset;

        false, otherwise.

*/

	{

	return(iCount==0 && !iError);

	}

#ifndef __REGIONS_MACHINE_CODED__

EXPORT_C TRect TRegion::BoundingRect() const

/**

Gets the minimal rectangle that bounds the entire region.

@return The region's minimal bounding rectangle.

*/

	{

	TRect bounds;

    const TRect *pRect;

	const TRect *pEnd;

	if (iCount>0)

		{

		pRect=RectangleList();

		bounds=(*pRect++);

		for (pEnd=pRect+(iCount-1);pRect<pEnd;pRect++)

			{

			if (pRect->iTl.iX<bounds.iTl.iX)

				bounds.iTl.iX=pRect->iTl.iX;

			if (pRect->iTl.iY<bounds.iTl.iY)

				bounds.iTl.iY=pRect->iTl.iY;

			if (pRect->iBr.iX>bounds.iBr.iX)

				bounds.iBr.iX=pRect->iBr.iX;

			if (pRect->iBr.iY>bounds.iBr.iY)

				bounds.iBr.iY=pRect->iBr.iY;

			}

		}

	return(bounds);

	}	

#endif

EXPORT_C const TRect &TRegion::operator[](TInt aIndex) const

/**

Gets a rectangle from the region.

@param aIndex The index of a rectangle within the region's array of rectangles. 

              Indexes are relative to zero.

@return The specified rectangle.              

@panic USER 81, if aIndex is greater than or equal to the number 

                of rectangles in the region.

*/

	{

	__ASSERT_ALWAYS((TUint)aIndex<(TUint)iCount,Panic(ETRegionOutOfRange));

    return(*(RectangleList()+aIndex));

    }

#ifndef __REGIONS_MACHINE_CODED__

EXPORT_C TBool TRegion::IsContainedBy(const TRect &aRect) const

/**

Tests whether the region is fully enclosed within the specified rectangle.

@param aRect The specified rectangle.

@return True, if the region is fully enclosed within the rectangle (their sides 

        may touch); false, otherwise.

*/

	{

    const TRect *pRect1;

    const TRect *pEnd1;

	for (pRect1=RectangleList(),pEnd1=pRect1+iCount;pRect1<pEnd1;pRect1++)

		{

		if (pRect1->iTl.iX<aRect.iTl.iX || pRect1->iBr.iX>aRect.iBr.iX || pRect1->iTl.iY<aRect.iTl.iY || pRect1->iBr.iY>aRect.iBr.iY)

			return(EFalse);

		}

	return(ETrue);

	}

EXPORT_C TBool TRegion::Intersects(const TRect &aRect) const

/**

Tests whether where there is any intersection between this region and the specified rectangle.

@param aRect The specified rectangle.

@return True, if there is an intersection; false, otherwise.

*/

	{

    const TRect *pRect1;

    const TRect *pEnd1;

	for (pRect1=RectangleList(),pEnd1=pRect1+iCount;pRect1<pEnd1;pRect1++)

		{

		if (aRect.Intersects(*pRect1))

			return ETrue;

		}

	return EFalse;

	}

EXPORT_C void TRegion::Copy(const TRegion &aRegion)

/**

Copies another region to this region.

The state of the specified region's error flag is also copied.

@param aRegion The region to be copied.

*/

	{

	if (aRegion.iError)

		{

		ForceError();

		}

	else

		{

		const TInt count = aRegion.iCount;

		if (count == 0)

			{ // release memory

			Clear();

			}

		else

			{

			if (iError)

				{

				Clear();

				}

			if (SetListSize(count))

				{

				iCount = count;

				Mem::Copy(RectangleListW(), aRegion.RectangleList(), sizeof(TRect)*count);

				}

			}

		}

	}

EXPORT_C void TRegion::Offset(const TPoint &aOffset)

/**

Moves the region by adding a TPoint offset to the co-ordinates of its corners.

The size of the region is not changed.

@param aOffset The offset by which the region is moved. The region is moved 

               horizontally by aOffset.iX pixels and vertically by aOffset.iY pixels.

*/

 	{

	TRect *pR=RectangleListW();

	const TRect *pE=pR+iCount;

	while (pR<pE)

		{

		pR->Move(aOffset);

		pR++;

		}

	}

EXPORT_C void TRegion::Offset(TInt aXoffset,TInt aYoffset)

/**

Moves the region by adding X and Y offsets to the co-ordinates of its corners.

The size of the region is not changed.

@param aXoffset The number of pixels by which to move the region horizontally. 

                If negative, the region moves leftwards. 

@param aYoffset The number of pixels by which to move the region vertically. 

                If negative, the region moves upwards.

*/

	{

	Offset(TPoint(aXoffset,aYoffset));

	}

EXPORT_C TBool TRegion::Contains(const TPoint &aPoint) const

/**

Tests whether a point is located within the region.

If the point is located on the top or left hand side of any rectangle in the 

region, it is considered to be within that rectangle and within the region. 

If the point is located on the right hand side or bottom of a rectangle, it 

is considered to be outside that rectangle, and may be outside the region.

@param aPoint The specified point. 

@return True, if the point is within the region; false, otherwise.

*/

	{

	const TRect *pR=RectangleList();

	const TRect *pE=pR+iCount;

	while (pR<pE)

		{

		if (pR->Contains(aPoint))

			return(ETrue);

		pR++;

		}

	return(EFalse);

	}

EXPORT_C void TRegion::SubRect(const TRect &aRect,TRegion *aSubtractedRegion)

/**

Removes a rectangle from this region.

If there is no intersection between the rectangle and this region, then this 

region is unaffected. 

@param aRect             The rectangular area to be removed from this region. 

@param aSubtractedRegion A pointer to a region. If this is supplied, the

                         removed rectangle is added to it. By default this

                         pointer is NULL.

*/

	{

	if (aRect.IsEmpty())

		return;

	TRect *prect=RectangleListW();

	TInt limit=iCount;

	for (TInt index=0;index<limit;)

		{

		if (prect->iBr.iX>aRect.iTl.iX && prect->iBr.iY>aRect.iTl.iY && prect->iTl.iX<aRect.iBr.iX && prect->iTl.iY<aRect.iBr.iY)

			{

			TRect rect(*prect);

			TRect inter(aRect);

			inter.Intersection(*prect);

			DeleteRect(prect);

			if (inter.iBr.iY!=rect.iBr.iY)

				AppendRect(TRect(rect.iTl.iX,inter.iBr.iY,rect.iBr.iX,rect.iBr.iY));

			if (inter.iTl.iY!=rect.iTl.iY)

				AppendRect(TRect(rect.iTl.iX,rect.iTl.iY,rect.iBr.iX,inter.iTl.iY));

			if (inter.iBr.iX!=rect.iBr.iX)

				AppendRect(TRect(inter.iBr.iX,inter.iTl.iY,rect.iBr.iX,inter.iBr.iY));

			if (inter.iTl.iX!=rect.iTl.iX)

				AppendRect(TRect(rect.iTl.iX,inter.iTl.iY,inter.iTl.iX,inter.iBr.iY));

			if (iError)

				break;

			if (aSubtractedRegion!=NULL)

				aSubtractedRegion->AddRect(inter);

			prect=RectangleListW()+index;		// List might have been re-allocated so re-get the pointer

			limit--;

			}

		else

			{

			index++;

			prect++;

			}

		}

	}

#endif

/**

Merges a rectangle with this region.

If requested it looks for a rectangle in the region that covers the new rectangle, if found method returns immediately.

Otherwise, or if an enclosing rectangle is not found, the new aRect is subtracted from all intersecting rectangles,

and then aRect is appended to the region.

@param aRect             The rectangular area to be added to this region.

@param aCovered          Whether to look for a rectangle in the region that covers the new aRect.

*/

void TRegion::MergeRect(const TRect &aRect, TBool aCovered)

	{

	TRect *prect=RectangleListW();

	TInt limit=iCount;

	TInt index=0;

	while (aCovered && (index < limit) )

		{

		if (prect->iBr.iX<=aRect.iTl.iX || prect->iBr.iY<=aRect.iTl.iY || prect->iTl.iX>=aRect.iBr.iX || prect->iTl.iY>=aRect.iBr.iY)

			{

			index++;

			prect++;

			}

		else

			{

			if (prect->iBr.iX>=aRect.iBr.iX && prect->iBr.iY>=aRect.iBr.iY && prect->iTl.iX<=aRect.iTl.iX && prect->iTl.iY<=aRect.iTl.iY)

				{ // region rectangle covers new aRect

				return;

				}

			break; // let the 2nd loop deal with this intersection

			}

		}

	while (index < limit)

		{

		if (prect->iBr.iX<=aRect.iTl.iX || prect->iBr.iY<=aRect.iTl.iY || prect->iTl.iX>=aRect.iBr.iX || prect->iTl.iY>=aRect.iBr.iY)

			{

			index++;

			prect++;

			}

		else

			{

			TRect rect(*prect);

			TRect inter(aRect);

			inter.Intersection(*prect);

			DeleteRect(prect);

			if (inter.iBr.iY!=rect.iBr.iY)

				AppendRect(TRect(rect.iTl.iX,inter.iBr.iY,rect.iBr.iX,rect.iBr.iY));

			if (inter.iTl.iY!=rect.iTl.iY)

				AppendRect(TRect(rect.iTl.iX,rect.iTl.iY,rect.iBr.iX,inter.iTl.iY));

			if (inter.iBr.iX!=rect.iBr.iX)

				AppendRect(TRect(inter.iBr.iX,inter.iTl.iY,rect.iBr.iX,inter.iBr.iY));

			if (inter.iTl.iX!=rect.iTl.iX)

				AppendRect(TRect(rect.iTl.iX,inter.iTl.iY,inter.iTl.iX,inter.iBr.iY));

			if (iError)

				return;

			prect=RectangleListW()+index;		// List might have been re-allocated so re-get the pointer

			limit--;

			}

		}

	AppendRect(aRect);

	}

EXPORT_C void TRegion::Union(const TRegion &aRegion)

/**

Replaces this region with the union of it and the specified region.

Note that if the error flag of either this region or the specified region is

set, then this region is cleared and its error flag is set. This frees up

allocated memory.

@param aRegion The region to be joined to this region.

*/

	{

	if (aRegion.iError)

		{

		ForceError();

		}

	else if (!iError && (aRegion.iCount != 0))

		{

		if (iCount == 0)

			{

			Copy(aRegion);

			}

		else

			{

			RRegionBuf<ERegionBufSize> temp;

			temp.Copy(aRegion);

			if (temp.iCount>iCount)

				{

				temp.AppendRegion(*this);

				Copy(temp);

				}

			else

				{

				AppendRegion(temp);

				}

			temp.Close();

			}

		}

	}

#ifndef __REGIONS_MACHINE_CODED__

EXPORT_C void TRegion::Intersection(const TRegion &aRegion1,const TRegion &aRegion2)

/**

Replaces this region with the area of intersection between two specified regions.

Notes:

1. If the error flag of either of the two specified regions is set, then this 

   region is cleared and its error flag is set. This frees up allocated memory.

2. If this region's error flag is already set, then the function has no effect.

@param aRegion1 The first region. 

@param aRegion2 The second region.

*/

    {

	if (aRegion1.iError || aRegion2.iError)

		ForceError();

	else

		{

		iCount=0;

		const TRect *pRect1,*pEnd1;

		const TRect *pRect2,*pEnd2;

		for (pRect1=aRegion1.RectangleList(),pEnd1=pRect1+aRegion1.iCount;pRect1<pEnd1;pRect1++)

			{

			for (pRect2=aRegion2.RectangleList(),pEnd2=pRect2+aRegion2.iCount;pRect2<pEnd2;pRect2++)

				{

				if (pRect1->iBr.iX>pRect2->iTl.iX && pRect1->iBr.iY>pRect2->iTl.iY && pRect1->iTl.iX<pRect2->iBr.iX && pRect1->iTl.iY<pRect2->iBr.iY)

					{

					TRect rect(*pRect2);

					rect.Intersection(*pRect1);

					AppendRect(rect);

					}

				}

			}

		}

	}

#endif

EXPORT_C void TRegion::Intersect(const TRegion &aRegion)

/**

Replaces this region with the area of intersection between it and the specified 

region.

Note that if the error flag of either this region or the specified region is

set, then this region is cleared and its error flag is set. This frees up

allocated memory.

@param aRegion The region to be intersected with this region.

*/

	{

	if (aRegion.iError)

		{

		ForceError();

		}

	else if (!iError && (iCount != 0))

		{

		if (aRegion.iCount == 0)

			{

			Clear();

			}

		else

			{

			RRegionBuf<ERegionBufSize> temp;

			temp.Copy(*this);

			Intersection(temp,aRegion);

			temp.Close();

			}

		}

	}

EXPORT_C void TRegion::AddRect(const TRect &aRect)

/**

Adds a rectangle to this region.

Notes:

1. If this region's error flag is already set, this function has no effect.