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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#include <gulsprite.h>

#include <gulgcmap.h>

#include "GULSTD.H"

const TInt KOffScreenValue = -1000;

/**

 * Creates and returns a pointer to a CSpriteSet object clipped to the parent aWindow. The

 * sprite set is initialized with aSpriteSetMember and the sprite set takes ownership of

 * this parameter.  aWs is the window session used.  aInvertMask specifies whether the

 * bitmap/mask pairs which will be added will use an inverted mask.

 */

EXPORT_C CSpriteSet* CSpriteSet::NewL(RWindowTreeNode& aWindow, RWsSession& aWs, CWsScreenDevice& aDevice, CGulIcon* aSpriteSetMember, TBool aInvertMask)

	{//static

	CSpriteSet* self = CSpriteSet::NewLC(aWindow,aWs,aDevice,aSpriteSetMember,aInvertMask);

	CleanupStack::Pop();

	return self;

	}

/**

 * Creates and returns a pointer to a CSpriteSet object clipped to the parent aWindow. The

 * sprite set is initialized with aSpriteSetMember and the sprite set takes ownership of

 * this parameter.  aWs is the window session used.  aInvertMask specifies whether the

 * bitmap/mask pairs which will be added will use an inverted mask.  Leaves the returned

 * pointer on the cleanup stack.

 */

EXPORT_C CSpriteSet* CSpriteSet::NewLC(RWindowTreeNode& aWindow, RWsSession& aWs, CWsScreenDevice& aDevice, CGulIcon* aSpriteSetMember, TBool aInvertMask)

	{//static

	CSpriteSet* self = new(ELeave) CSpriteSet(aInvertMask);

	CleanupStack::PushL(self);

	self->ConstructL(aWindow,aWs,aDevice);

	self->AddMemberL(aSpriteSetMember);

	return self;

	}

/**

 * Adds aSpriteSetMember to the sprite set.  Panics if a null member is passed in, or

 * if the argument does not include a bitmap and mask.

 */

EXPORT_C void CSpriteSet::AddMemberL(CGulIcon* aSpriteSetMember)

	{

	__ASSERT_ALWAYS(aSpriteSetMember != NULL, Panic(EEgulPanicAttemptToAppendNullMember));

	__ASSERT_ALWAYS(aSpriteSetMember->Bitmap() && aSpriteSetMember->Mask(), Panic(EEgulPanicAttemptToAppendIncompleteMember));

	User::LeaveIfError(iSourceMembers.Append(aSpriteSetMember));

	}

/**

 * Removes a member (indexed by aSpriteSetMemberIndex) from the array.

 * Panics if the member index is not within the existing array's range.

 */

EXPORT_C void CSpriteSet::RemoveMember(TInt aSpriteSetMemberIndex)

	{

	__ASSERT_ALWAYS((aSpriteSetMemberIndex >= 0) && (aSpriteSetMemberIndex < iSourceMembers.Count()),Panic(EEgulPanicInvalidSpriteIndex));

	delete iSourceMembers[aSpriteSetMemberIndex];

	iSourceMembers.Remove(aSpriteSetMemberIndex);

	}

/**

 * Prepares the sprite in the set of type aSpriteType to be displayed at

 * aSpritePos with size aSpriteSize.  The sprite will be resized as necessary under the

 * restriction of aSpriteResizeMode.

 */

EXPORT_C void CSpriteSet::PrepareSpriteForDisplayL(TInt aSpriteType, const TPoint& aSpritePos, const TSize& aSpriteSize, TSpriteResizeMode aSpriteResizeMode)

	{

	__ASSERT_DEBUG((aSpriteType >= 0) && (aSpriteType < iSourceMembers.Count()),Panic(EEgulPanicInvalidSpriteIndex));

	__ASSERT_DEBUG((aSpriteSize.iWidth >= 0) && (aSpriteSize.iHeight >= 0),Panic(EEgulPanicNegativeSpriteSize));

	iSpritePosition = aSpritePos;

	iMainFbsBitGc->SetOrigin(TPoint(0,0));

	TSize spriteSize(aSpriteSize);

	const TSize sourceSize(iSourceMembers[aSpriteType]->Bitmap()->SizeInPixels());

	AdjustSpriteSizeAccordingToResizeMode(spriteSize, sourceSize, aSpriteResizeMode);

	User::LeaveIfError(iMainBmpDevice->Resize(spriteSize));

	User::LeaveIfError(iMaskBmpDevice->Resize(spriteSize));

	iMainFbsBitGc->Resized();

	iMaskFbsBitGc->Resized();

	iMaskFbsBitGc->SetBrushColor(KRgbBlack);

	iMaskFbsBitGc->Clear();

	const TRect translatedClipRect(iClippingRect.iTl - aSpritePos, iClippingRect.Size());

	if(!translatedClipRect.IsEmpty())

		iMaskFbsBitGc->SetClippingRect(translatedClipRect);

	TInternalSpriteResizeMode resizeMode = EHSameVSame;

	ComputeInternalResizeMode(resizeMode,aSpriteResizeMode,sourceSize,spriteSize);

	RenderSprite(aSpriteType,resizeMode,sourceSize,spriteSize);

	iMaskFbsBitGc->CancelClippingRect();

	iMainFbsBitGc->SetOrigin(-aSpritePos);

	}

/**

 * Brings the sprite onto the visible area of the screen.  Must also call this

 * if the sprite set member which is being used has changed.

 */

EXPORT_C void CSpriteSet::StartDisplayingSpriteL()

	{

	iSprite.SetPosition(iSpritePosition);

	User::LeaveIfError(iSprite.UpdateMember(0,iSpriteMember));

	iFlags |= ESpriteIsCurrentlyDisplayed;

	}

/**

 * Stops the display of the sprite on the visible area of the screen.

 */

EXPORT_C void CSpriteSet::StopDisplayingSprite()

	{

	if(iFlags&ESpriteIsCurrentlyDisplayed)

		{

		iFlags |= (~ESpriteIsCurrentlyDisplayed);

		iSprite.SetPosition(TPoint(KOffScreenValue,KOffScreenValue));

		}

	}

/**

 * Allows use of the Gc which the sprite uses for it's drawing.  This enables the client

 * to effectively draw onto the sprite.

 */

EXPORT_C CWindowGc* CSpriteSet::SpriteGc() const

	{

	__ASSERT_DEBUG(iWindowToBitmapMappingGc,Panic(EEgulPanicNullPointer));

	return iWindowToBitmapMappingGc;

	}

/**

 * Method for moving the postion of the sprite by aSpritePos from the current position.

 */

EXPORT_C void CSpriteSet::TranslateSpritePosition(const TPoint& aSpritePos)

	{

	if(iFlags&ESpriteIsCurrentlyDisplayed)

		{

		iSpritePosition += aSpritePos;

		iSprite.SetPosition(iSpritePosition);

		}

	}

/**

 * Bounds the drawing of the sprite within aRect, stopping it drawing over surrounding

 * components.

 */

EXPORT_C void CSpriteSet::SetClippingRect(const TRect& aRect)

	{

	iClippingRect = aRect;

	}

CSpriteSet::~CSpriteSet()

	{

	iSprite.Close();

	delete iMainFbsBitGc;

	delete iMaskFbsBitGc;

	delete iMainBmpDevice;

	delete iMaskBmpDevice;

	iSourceMembers.ResetAndDestroy();

	iSourceMembers.Close();

	delete iTargetBitmap;

	delete iTargetMaskBitmap;

	delete iWindowToBitmapMappingGc;

	}

CSpriteSet::CSpriteSet(TBool aInvertMask)

	: iFlags((aInvertMask&EMaskIsInverted) & (~ESpriteIsCurrentlyDisplayed))

	{

	}

void CSpriteSet::ConstructL(RWindowTreeNode& aWindow, RWsSession& aWs, CWsScreenDevice& aDevice)

	{

    TInt grayscaleCapabilities;

	TInt colorCapabilities;

	const TDisplayMode mode=aWs.GetDefModeMaxNumColors(colorCapabilities,grayscaleCapabilities);

	iTargetBitmap = new (ELeave) CWsBitmap(aWs);

	const TSize zeroSize(0,0);

	User::LeaveIfError(iTargetBitmap->Create(zeroSize,mode));

	iTargetMaskBitmap = new (ELeave) CWsBitmap(aWs);

	User::LeaveIfError(iTargetMaskBitmap->Create(zeroSize,mode));

	iSprite=RWsSprite(aWs);

	User::LeaveIfError(iSprite.Construct(aWindow, TPoint(KOffScreenValue,KOffScreenValue), ESpriteNoChildClip));

	CreateSpriteMember();

	iSprite.AppendMember(iSpriteMember);

	iSprite.Activate();

	iMainFbsBitGc=CFbsBitGc::NewL();	// for the main bitmap

	iWindowToBitmapMappingGc = CWindowToBitmapMappingGc::NewL(aDevice,*iMainFbsBitGc);	// takes place of iMainFbsBitGc (not passing ownership of context here !)

	iMaskFbsBitGc=CFbsBitGc::NewL();	// for the mask bitmap

	iMainBmpDevice=CFbsBitmapDevice::NewL(iTargetBitmap);

	iMaskBmpDevice=CFbsBitmapDevice::NewL(iTargetMaskBitmap);

	iMainFbsBitGc->Activate(iMainBmpDevice);

	iMaskFbsBitGc->Activate(iMaskBmpDevice);

	}

void CSpriteSet::CreateSpriteMember()

	{

	iSpriteMember.iBitmap=iTargetBitmap;

	iSpriteMember.iMaskBitmap=iTargetMaskBitmap;

	iSpriteMember.iInvertMask=iFlags&EMaskIsInverted;

	iSpriteMember.iInterval=0;

	iSpriteMember.iOffset=TPoint(0,0);

	}

void CSpriteSet::AdjustSpriteSizeAccordingToResizeMode(TSize& aTargetSize, const TSize& aSourceSize, TSpriteResizeMode aSpriteResizeMode) const

	{

	// following switch statement limits the 'other' dimension from the stretch line

	switch(aSpriteResizeMode)

		{

	case ENoResizing:

		{

		aTargetSize = aSourceSize;

		break;

		}

	case EResizeHorizToFit:

		{

		aTargetSize.iHeight = aSourceSize.iHeight;

		break;

		}

	case EResizeVertToFit:

		{

		aTargetSize.iWidth = aSourceSize.iWidth;

		break;

		}

	case EResizeHorizAndVertToFit:

		{

		break;

		}

	default:

		Panic(EEgulPanicInvalidSpriteResizeMode);

		break;

		}

	}

void CSpriteSet::ComputeInternalResizeMode(TInternalSpriteResizeMode& aInternalSpriteResizeMode, TSpriteResizeMode aSpriteResizeMode, const TSize& aSourceSize, const TSize& aSpriteSize) const

	{

	switch(aSpriteResizeMode)

		{

	case ENoResizing:

		{

		aInternalSpriteResizeMode = EHSameVSame;

		break;

		}

	case EResizeHorizToFit:

		{

		if(aSpriteSize.iWidth > aSourceSize.iWidth)

			aInternalSpriteResizeMode = EHStretchVSame;

		else if(aSpriteSize.iWidth < aSourceSize.iWidth)

			aInternalSpriteResizeMode = EHShrinkVSame;

		else

			aInternalSpriteResizeMode = EHSameVSame;

		break;

		}

	case EResizeVertToFit:

		{

		if(aSpriteSize.iHeight > aSourceSize.iHeight)

			aInternalSpriteResizeMode = EHSameVStretch;

		else if(aSpriteSize.iHeight < aSourceSize.iHeight)

			aInternalSpriteResizeMode = EHSameVShrink;

		else

			aInternalSpriteResizeMode = EHSameVSame;

		break;

		}

	case EResizeHorizAndVertToFit:

		{

		if(aSpriteSize.iWidth > aSourceSize.iWidth)

			{

			if(aSpriteSize.iHeight > aSourceSize.iHeight)

				aInternalSpriteResizeMode = EHStretchVStretch;

			else if(aSpriteSize.iHeight < aSourceSize.iHeight)

				aInternalSpriteResizeMode = EHStretchVShrink;

			else

				aInternalSpriteResizeMode = EHStretchVSame;

			}

		else if(aSpriteSize.iWidth < aSourceSize.iWidth)

			{

			if(aSpriteSize.iHeight > aSourceSize.iHeight)

				aInternalSpriteResizeMode = EHShrinkVStretch;

			else if(aSpriteSize.iHeight < aSourceSize.iHeight)

				aInternalSpriteResizeMode = EHShrinkVShrink;

			else

				aInternalSpriteResizeMode = EHShrinkVSame;

			}

		else

			{

			if(aSpriteSize.iHeight > aSourceSize.iHeight)

				aInternalSpriteResizeMode = EHSameVStretch;

			else if(aSpriteSize.iHeight < aSourceSize.iHeight)

				aInternalSpriteResizeMode = EHSameVShrink;

			else

				aInternalSpriteResizeMode = EHSameVSame;

			}

		break;

		}

	default:

		Panic(EEgulPanicInvalidSpriteResizeMode);

		break;

		}

	}

void CSpriteSet::RenderSprite(TInt aSpriteType, TInternalSpriteResizeMode aInternalSpriteResizeMode, const TSize& aSourceSize, const TSize& aSpriteSize)

	{

	const TInt sourceWidth = aSourceSize.iWidth;

	const TInt sourceHeight = aSourceSize.iHeight;

	const TInt spriteWidth = aSpriteSize.iWidth;

	const TInt spriteHeight = aSpriteSize.iHeight;

	const TInt numOfHorizAddedLines = spriteHeight-sourceHeight;

	const TInt numOfVertAddedLines = spriteWidth-sourceWidth;

	const TPoint posZeroZero(0,0);	// cached for repeated use

	CGulIcon* spriteSetMember = iSourceMembers[aSpriteType];

	CFbsBitmap* bitmapToUse = spriteSetMember->Bitmap();

	CFbsBitmap* maskToUse = spriteSetMember->Mask();

	TRect fromRect;

	TPoint toPoint;

	switch(aInternalSpriteResizeMode)

		{

	case EHSameVSame:

		{

		fromRect.SetRect(0,0,sourceWidth,sourceHeight);

		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		break;

		}

	case EHSameVShrink:

		{

		const TInt halfSpriteHeight = spriteHeight/2;

		fromRect.SetRect(0,0,spriteWidth,halfSpriteHeight);

		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		fromRect.SetRect(0,sourceHeight - (halfSpriteHeight) - (spriteHeight%2),sourceWidth,sourceHeight);

		toPoint.SetXY(0,halfSpriteHeight);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		break;

		}

	case EHSameVStretch:

		{

		const TInt halfSourceHeight = sourceHeight/2;

		fromRect.SetRect(0,0,sourceWidth,halfSourceHeight);

		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		fromRect.SetRect(0,halfSourceHeight,sourceWidth,sourceHeight);

		toPoint.SetXY(0,spriteHeight-(halfSourceHeight)-(sourceHeight%2));

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		for(TInt i = 0; i < numOfHorizAddedLines;i++)

			{

			fromRect.SetRect(0,halfSourceHeight,sourceWidth,(halfSourceHeight)+1);

			toPoint.SetXY(0,(halfSourceHeight)+i);

			iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

			iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

			}

		break;

		}

	case EHShrinkVSame:

		{

		const TInt halfSpriteWidth = spriteWidth/2;

		fromRect.SetRect(0,0,halfSpriteWidth,spriteHeight);

		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidth%2),0,sourceWidth,sourceHeight);

		toPoint.SetXY(halfSpriteWidth,0);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		break;

		}

	case EHShrinkVShrink:

		{

		const TInt halfSpriteWidth = spriteWidth/2;

		const TInt halfSpriteHeight = spriteHeight/2;

		const TInt spriteHeightModTwo = spriteHeight%2;

		const TInt spriteWidthModTwo = spriteWidth%2;

		fromRect.SetRect(0,0,halfSpriteWidth,halfSpriteHeight);

		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidthModTwo),0,sourceWidth,halfSpriteHeight);

		toPoint.SetXY(halfSpriteWidth,0);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		fromRect.SetRect(0,sourceHeight - (halfSpriteHeight) - (spriteHeightModTwo),halfSpriteWidth,sourceHeight);

		toPoint.SetXY(0,halfSpriteHeight);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidthModTwo),sourceHeight - (halfSpriteHeight) - (spriteHeightModTwo),sourceWidth,sourceHeight);

		toPoint.SetXY(halfSpriteWidth,halfSpriteHeight);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		break;

		}

	case EHShrinkVStretch:

		{

		const TInt halfSourceHeight = sourceHeight/2;

		const TInt halfSpriteWidth = spriteWidth/2;

		const TInt sourceHeightModTwo = sourceHeight%2;

		const TInt spriteWidthModTwo = spriteWidth%2;

		fromRect.SetRect(0,0,halfSpriteWidth,halfSourceHeight);	

		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidthModTwo),0,sourceWidth,halfSourceHeight);

		toPoint.SetXY(halfSpriteWidth,0);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		fromRect.SetRect(0,sourceHeight - (halfSourceHeight) - (sourceHeightModTwo),halfSpriteWidth,sourceHeight);

		toPoint.SetXY(0,spriteHeight - (halfSourceHeight) - (sourceHeightModTwo));

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidthModTwo),sourceHeight - (halfSourceHeight) - (sourceHeightModTwo),sourceWidth,sourceHeight);

		toPoint.SetXY(halfSpriteWidth,spriteHeight - (halfSourceHeight) - (sourceHeightModTwo));

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		for(TInt j = 0; j < numOfHorizAddedLines;j++)

			{

			fromRect.SetRect(0,spriteHeight - (halfSourceHeight) - (sourceHeightModTwo),spriteWidth,spriteHeight - (halfSourceHeight) - (sourceHeightModTwo)+1);

			toPoint.SetXY(0,(halfSourceHeight)+j);

			iMainFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);

			iMaskFbsBitGc->BitBlt(toPoint,iTargetMaskBitmap,fromRect);

			}

		break;

		}

	case EHStretchVSame:

		{

		const TInt halfSourceWidth = sourceWidth/2;

		fromRect.SetRect(0,0,halfSourceWidth,sourceHeight);

		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		fromRect.SetRect(halfSourceWidth,0,sourceWidth,sourceHeight);

		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidth%2),0);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		for(TInt i = 0; i < numOfVertAddedLines;i++)

			{

			fromRect.SetRect(halfSourceWidth,0,(halfSourceWidth)+1,sourceHeight);

			toPoint.SetXY((halfSourceWidth)+i,0);

			iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

			iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

			}

		break;

		}

	case EHStretchVShrink:

		{

		const TInt halfSourceWidth = sourceWidth/2;

		const TInt halfSpriteHeight = spriteHeight/2;

		const TInt sourceWidthModTwo = sourceWidth%2;

		const TInt spriteHeightModTwo = spriteHeight%2;

		fromRect.SetRect(0,0,halfSourceWidth,halfSpriteHeight);

		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		fromRect.SetRect(sourceWidth - (halfSourceWidth) - (sourceWidthModTwo),0,sourceWidth,halfSpriteHeight);

		toPoint.SetXY(spriteWidth - (halfSourceWidth) - (sourceWidthModTwo),0);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		fromRect.SetRect(0,sourceHeight - (halfSpriteHeight) - (spriteHeightModTwo),halfSourceWidth,sourceHeight);

		toPoint.SetXY(0,halfSpriteHeight);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		fromRect.SetRect(sourceWidth - (halfSourceWidth) - (sourceWidthModTwo),sourceHeight - (halfSpriteHeight) - (spriteHeightModTwo),sourceWidth,sourceHeight);

		toPoint.SetXY(spriteWidth - (halfSourceWidth) - (sourceWidthModTwo),halfSpriteHeight);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		for(TInt j = 0; j < numOfVertAddedLines;j++)

			{

			fromRect.SetRect(spriteWidth - (halfSourceWidth) - (sourceWidthModTwo),0,spriteWidth - (halfSourceWidth) - (sourceWidthModTwo)+1,spriteHeight);

			toPoint.SetXY((halfSourceWidth)+j,0);

			iMainFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);

			iMaskFbsBitGc->BitBlt(toPoint,iTargetMaskBitmap,fromRect);

			}

		break;

		}

	case EHStretchVStretch:

		{

		const TInt halfSourceWidth = sourceWidth/2;

		const TInt halfSourceHeight = sourceHeight/2;

		const TInt sourceWidthModTwo = sourceWidth%2;

		const TInt sourceHeightModTwo = sourceHeight%2;

		fromRect.SetRect(0,0,halfSourceWidth,halfSourceHeight);

		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		iMainFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);

		fromRect.SetRect(0,halfSourceHeight,halfSourceWidth,sourceHeight);

		toPoint.SetXY(0,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo));

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		iMainFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		fromRect.SetRect(halfSourceWidth,0,sourceWidth,halfSourceHeight);

		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),0);

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		iMainFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		fromRect.SetRect(halfSourceWidth,halfSourceHeight,sourceWidth,sourceHeight);

		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),spriteHeight-(halfSourceHeight)-(sourceHeightModTwo));

		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		iMainFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);

		for(TInt h = 0; h < numOfVertAddedLines;h++)

			{

			fromRect.SetRect(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),0,spriteWidth-(halfSourceWidth)-(sourceWidthModTwo)+1,spriteHeight);

			toPoint.SetXY((halfSourceWidth)+h,0);

			iMainFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);

			iMaskFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);

			}

		for(TInt m = 0; m < numOfHorizAddedLines;m++)

			{

			fromRect.SetRect(0,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo),spriteWidth,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo)+1);

			toPoint.SetXY(0,(halfSourceHeight)+m);

			iMaskFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);

			}

		fromRect.SetRect(0,0,halfSourceWidth,halfSourceHeight);

		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);

		fromRect.SetRect(0,halfSourceHeight,halfSourceWidth,sourceHeight);

		toPoint.SetXY(0,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo));

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		fromRect.SetRect(halfSourceWidth,0,sourceWidth,halfSourceHeight);

		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),0);

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		fromRect.SetRect(halfSourceWidth,halfSourceHeight,sourceWidth,sourceHeight);

		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),spriteHeight-(halfSourceHeight)-(sourceHeightModTwo));

		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);

		for(TInt j = 0; j < numOfVertAddedLines;j++)

			{

			fromRect.SetRect(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),0,spriteWidth-(halfSourceWidth)-(sourceWidthModTwo)+1,spriteHeight);

			toPoint.SetXY((halfSourceWidth)+j,0);

			iMainFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);