// Copyright (c) 2007-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 "directgdicontext.h"

 #include "directgdipaniccodes.h"

 #include "directgdifont.h"

 #include "directgdidriver.h"

 #include <graphics/directgdidrawablesource.h>

 #include <graphics/directgdiengine.h>

 #include <e32cmn.h>

 #include <s32mem.h>

 #include <shapeinfo.h>

 #include <fbs.h>

 #include <fntstore.h>

 using namespace DirectGdi;

 /**

 CDirectGdiContext InternalizeL/ExternalizeL - version numbers.

 Add new version numbers here. A reason of adding new version numbers may be adding new 

 CDirectGdiContext data members, which may have to be externalized/internalized. 

 When that happens:

 1.Put a new enum item (like EDirectGDIContext_Ver01) with a version number, which is greater than

 the last version number, that was used. 

 2.Document the new enum item.

 3.Update KDirectGDIContext_VerNo value to be the new enum item value.

 4.Update InternalizeL/ExternalizeL methods after adding the new version number.

 For example: If a new member is added to the class - TInt iSmth, when InternalizeL

 is called to operate on older archive, iSmth member won't be in the archive!

 So, in InternalizeL, there should be a check, something like:

 TUint16 archiveVerNo = 0;

 	aReadStream >> archiveVerNo;

     if(archiveVerNo < EDirectGDIContext_Ver02)   //EDirectGDIContext_Ver02 has been added, when iSmth has been added

 		{

       	//Do nothing - iSmth is not in the archive

       	//Initialize it with some default value

       	iSmth = KDefVal;

 		}

 	else

 		{

 		aReadStream >> iSmth;

 		}

 */

 enum

 	{

 	EDirectGDIContext_Ver01 = 1 //Base version number, when InternalizeL/ExternalizeL were added

 	};

 LOCAL_D const TUint16 KDirectGDIContext_VerNo = EDirectGDIContext_Ver01;

 /**

 Static two-phase factory constuctor. Creates an object of this class.

 @param	aDirectGdiDriver	The driver object which provides an abstract factory for creating a concrete drawing engine.

 @pre	CDirectGdiDriver object has been initialised from the calling thread.

 @post	Instances of CDirectGdiContext and MDirectGdiEngine have been created.

 @leave	Leaves if CDirectGdiDriver has not been initialised from the calling thread, or other errors occur during object construction.

 @return	Reference to constructed CDirectGdiContext.

 */

 EXPORT_C CDirectGdiContext* CDirectGdiContext::NewL(CDirectGdiDriver& aDirectGdiDriver)

 	{

 	CDirectGdiContext* result = new(ELeave) CDirectGdiContext(aDirectGdiDriver);

 	CleanupStack::PushL(result);

 	// Cache a reference to the driver locally, so that we do not need to use

 	// the singleton accessor all the time. The singleton accessor utilises TLS

 	// and hence incurs a performance penalty.

 	//

 	result->ConstructL();

 	CleanupStack::Pop();

 	return result;

 	}

 /**

 Installs a rendering engine instance from the supplied driver, records

 a reference to the driver (for use by the destructor), and initialises it.

 @pre	Invoked by NewL().

 @post	Instance of MDirectGdiEngine has been created.

 @leave	If CDirectGdiDriver::CreateEngine() returns an error code.

 */

 void CDirectGdiContext::ConstructL()

 	{

 	User::LeaveIfError(iDriver.CreateEngine(iEngine));

 	Reset();	// Initialise context and engine to default values.

 	}

 /**

 Object constructor. Declared private for better encapsulation. A factory method is 

 provided to instantiate this class. This class is not intended for derivation. Binary

 compatibility needs to be maintained.

 @param	aDirectGdiDriver The driver that coordinates management of DirectGDI resources.

 @pre	The driver must be initialised.

 @post	None.

 */

 EXPORT_C CDirectGdiContext::CDirectGdiContext(CDirectGdiDriver& aDirectGdiDriver) :

 	iDriver(aDirectGdiDriver)	

 	{	

 	}

 /**

 Unbind current target from drawing context and mark drawing engine for deletion.

 @pre	None.

 @post	Rendering engine has had targets unbound and is marked for deletion.

 */

 EXPORT_C CDirectGdiContext::~CDirectGdiContext()

 	{

 	// If an engine has been bound, destroy it through the driver.

 	if (iEngine)

 		{

 		iDriver.DestroyEngine(iEngine);

 		}

 	CleanUpBrushPattern();

 	iClippingRegion.Close();

 	}

 /**

 Binds a rendering target to this drawing context.

 Subsequent rendering operations after calling this method will apply to the new rendering

 target. The clipping region will be reset to none, in other words drawing will be clipped to the 

 full area of the new target by default, other context states such as pen or brush colour,

 font, etc. will remain unchanged.

 This operation could fail, DirectGDI clients should always check the return value when 

 calling this method. The error state is not modified by this function.

 @param	aTarget	DirectGDI rendering target.

 @pre	Rendering target has been fully constructed.

 @post	The drawing context is bound to the new rendering target.

 @return	KErrNone if successful, KErrNotSupported if target is incompatible with the drawing context,

 		otherwise one of the system-wide error codes.

 */

 EXPORT_C TInt CDirectGdiContext::Activate(RDirectGdiImageTarget& aTarget)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::Activate");	

 	TInt err = iEngine->Activate(aTarget);

 	iActivated = EFalse;

 	if (err == KErrNone)

 		{

 		iActivated = ETrue;

 		}

 	return err;

 	}

 /**

 Disables AutoUpdateJustification state. 

 @see CDirectGdiContext::SetJustifyAutoUpdate

 */

 EXPORT_C void CDirectGdiContext::NoJustifyAutoUpdate()

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::NoJustifyAutoUpdate");

 	iAutoUpdateJustification = EFalse;

 	}

 /**

 Enables AutoUpdateJustification state. 

 During the text drawing, some text parameters which impact on positioning the text on the screen will be updated and applied 

 */

 EXPORT_C void CDirectGdiContext::SetJustifyAutoUpdate()

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::SetJustifyAutoUpdate");

 	iAutoUpdateJustification = ETrue;

 	}

 /**

 Draws the whole of a CFbsBitmap. Calls BitBlt() with a rectangle set to the extents of aBitmap.

 No scaling or stretching is involved. The current clipping region and drawing mode apply. The

 source bitmap can reside in system memory or ROM. Bitmaps in system memory may be compressed

 using RLE or Palette compression, and can be in any supported display mode. Please refer to

 CFbsBitmap documentation for more details.

 If the client modifies the content of the bitmap after issuing a BitBlt() command, the method

 does not guarantee whether the old bitmap content or the new one will be drawn. Clients must call

 Finish() on the driver before modifying the bitmap content if they want a guaranteed result that 

 the previously issued BitBlt() will draw the old bitmap content.

 In the event of a failure, the error state is set to one of the system-wide error codes.

 @see	void CDirectGdiContext::BitBlt(const TPoint& aPoint, const CFbsBitmap* aBitmap, const TRect& aSourceRect);

 @param	aDestPos		The position to draw the top left corner of the bitmap.

 @param	aSourceBitmap	The source bitmap. 

 @pre	The rendering target has been activated.

 @post	Request to draw the bitmap content has been accepted. There is no guarantee that the request

 		has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::BitBlt(const TPoint& aDestPos, const CFbsBitmap& aSourceBitmap)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::BitBlt(%d,%d)", aDestPos.iX, aDestPos.iY);

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if (ValidateBitmap (aSourceBitmap))

 		{

 		iEngine->BitBlt(aDestPos, aSourceBitmap, TRect(aSourceBitmap.SizeInPixels()));

 		}

 	}

 /** 

 Draws a particular rectangle from a CFbsBitmap via bitmap block image transfer. 

 The bitmap content is specified by the given source rectangle. The bitmap content is drawn 

 into the rendering target starting from the given destination position. To draw the content

 of the entire bitmap, a source rectangle TRect(TPoint(0,0), aBitmap.SizeInPixels()) is used. 

 The source rectangle is intersected with the source bitmap’s full extent, and the intersection

 will become the effective value of the source rectangle.

 No scaling or stretching is involved. The current clipping region and drawing mode apply. The

 source bitmap can reside in system memory or ROM. Bitmaps in system memory may be compressed

 using RLE or Palette compression, and can be in any supported display mode. Please refer to

 CFbsBitmap documentation for more details.

 The bitmap is not guaranteed to continue to exist outside the implementation of this method, for example

 DirectGDI clients may delete the bitmap immediately after issuing a BitBlt() command. The adaptation

 must maintain its own copy by duplicating the bitmap if access to the bitmap data is required

 later on, for example outside this method implementation. Duplicating the bitmap will increase its

 reference counter and will prevent the object from being destroyed by Fbserv. The adaptation

 must make sure the bitmap copy is destroyed when it is no longer needed.

 If the client modifies the content of the bitmap after issuing BitBlt() command, the method

 does not guarantee whether the old bitmap content or the new one will be drawn. Clients must call

 Finish() on the driver before modifying the bitmap content if they want a guaranteed result that 

 the previously issued BitBlt() will draw the old bitmap content.

 In the event of a failure, the error state is set to one of the system-wide error codes.

 @param	aDestPos		The position to draw the top left corner of the bitmap (destination position).

 @param	aSourceBitmap	The source bitmap.

 @param	aSourceRect		A rectangle defining the piece of the source to be drawn. No image data 

 						is transferred if no intersection exists with the bitmap.  

 						NOTE: The top and left hand edges are inclusive, the bottom and 

 						right hand edge are exclusive.

 @pre	The rendering target has been activated.

 @post	Request to draw the bitmap content has been accepted. There is no guarantee that the request

 		has been processed when the method returns.

 @panic 	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::BitBlt(

 		const TPoint& aDestPos, 

 		const CFbsBitmap& aSourceBitmap, 

 		const TRect& aSourceRect)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::BitBlt(%d,%d)", aDestPos.iX, aDestPos.iY);

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if (ValidateBitmap(aSourceBitmap))

 		{

 		TRect sourceRect = IntersectBitmapWithRect(aSourceBitmap, aSourceRect);		

 		if (!sourceRect.IsEmpty())

 			{

 			iEngine->BitBlt(aDestPos, aSourceBitmap, sourceRect);

 			}

 		}

 	}

 /**

 Validates a specified bitmap image. 

 The bitmap is deemed invalid if its associated handle equals KNullHandle or it 

 has a width or height of zero.

 The following errors are set in iDirectGdiDriver if the associated conditions are met:

 	- KErrBadHandle if the handle associated with the bitmap equals KNullHandle.

 	- KErrArgument is the bitmaps width or height is zero.

 @param aBitmap The bitmap to validate.

 @return ETrue if the specified bitmap is valid, otherwise EFalse.

 */

 TBool CDirectGdiContext::ValidateBitmap(const CFbsBitmap& aBitmap)

 	{

 	TInt errorCode = KErrNone;

 	TBool result = ETrue;

 	if (aBitmap.Handle() == KNullHandle)

 		{

 		errorCode = KErrBadHandle;

 		}

 	else

 		{

 		// Check that mask and source bitmap have width and height.

 		const TSize bitmapSize = aBitmap.SizeInPixels();

 		if (!bitmapSize.iWidth || !bitmapSize.iHeight)

 			{

 			errorCode = KErrArgument;

 			}

 		}

 	if (errorCode != KErrNone)

 		{

 		iDriver.SetError(errorCode);	

 		result = EFalse;

 		}

 	return result;

 	}

 /*

 Returns a TRect that intersects both the CFbsBitmap and the passed-in TRect.

 @param aBitmap The bitmap to intersect with.

 @param aRect The TRect object that is overlapping the bitmap.

 @return A TRect that represents the intersection of the two. If the two do not intersect,

         it will be an empty TRect object.

 */

 TRect CDirectGdiContext::IntersectBitmapWithRect(const CFbsBitmap& aBitmap, const TRect& aRect) const

 	{

 	TRect result = TRect(aBitmap.SizeInPixels());

 	if (aRect == result)

 		return result;

 	if (result.Intersects(aRect))

 		{

 		result.Intersection(aRect);

 		return result;

 		}

 	return TRect(0,0,0,0);

 	}

 /**

 Validates the specified source bitmap and mask pair.

 First validates the source and mask bitmaps individually, and then checks for valid

 bitmap pairings. The only pairing not supported is: EGray256 masks and sources with 

 an alpha-channel when using EDrawModeWriteAlpha.

 @see CDirectGdiContext::ValidateBitmap()

 The following errors are set in iDirectGdiDriver if the associated conditions are met:

 	- KErrBadHandle if the handle associated with either bitmap equals KNullHandle.

 	- KErrArgument if either bitmaps width or height is zero.

 	- KErrArgument if the mask format is EGray256 and the source contains an alpha-channel and draw mode is EDrawModeWriteAlpha.

 @param aSourceBitmap 	The source bitmap to validate.

 @param aMaskBitmap 		The mask to validate.

 @return ETrue if the specified bitmaps is valid, otherwise EFalse.	

 */

 TBool CDirectGdiContext::ValidateSourceAndMaskBitmaps(const CFbsBitmap& aSourceBitmap, const CFbsBitmap& aMaskBitmap)

 	{

 	TInt errorCode = KErrNone;

 	TBool result = ETrue;

 	if (ValidateBitmap (aSourceBitmap) && ValidateBitmap (aMaskBitmap))

 		{

 		TDisplayMode sourceBitmapDisplayMode = aSourceBitmap.DisplayMode();

 		// We do not currently support EGray256 masks and sources with an alpha-channel

 		// with EDrawModeWriteAlpha.

 		if ((iDrawMode == DirectGdi::EDrawModeWriteAlpha) &&

 			(aMaskBitmap.DisplayMode() == EGray256) &&

 			((sourceBitmapDisplayMode == EColor16MA) || (sourceBitmapDisplayMode == EColor16MAP)))

 			{

 			errorCode = KErrArgument;

 			}

 		}

 	else

 		{

 		result = EFalse;

 		}

 	if (errorCode != KErrNone)

 		{

 		iDriver.SetError(errorCode);	

 		result = EFalse;

 		}

 	return result;

 	}

 /**

 Helper method for performing BitBltMasked.

 Note that aInvertMask is ignored if aMaskPos is not at 0,0.

 @see	CDirectGdiContext::BitBlt(const TPoint& aPoint, const CFbsBitmap& aBitmap, const TRect& aSourceRect);

 @see	CDirectGdiContext::BitBltMasked(const TPoint&, const CFbsBitmap&,const TRect&, const CFbsBitmap&, const TPoint&);

 @param	aDestPos		The destination for the top left corner of the transferred bitmap. 

 						It is relative to the top left corner of the destination bitmap, which may be the screen. 

 @param	aSourceBitmap	A memory-resident source bitmap.

 @param	aSourceRect		A rectangle defining the piece of the bitmap to be drawn, 

 						with co-ordinates relative to the top left corner of the bitmap. 

 @param	aMaskBitmap		Mask bitmap.

 @param	aInvertMask		If EFalse, a source pixel that is masked by a black pixel is not transferred to 

 						the destination rectangle. If ETrue, then a source pixel that is masked by a 

 						white pixel is not transferred to the destination rectangle. If alpha blending

 						is used instead of masking, this flag is ignored and no inversion takes place.

 						Note that this parameter is ignored if aMaskPos does not equal TPoint(0,0).

 @param	aMaskPos		The point on the mask bitmap to use as the top left corner 

 */

 void CDirectGdiContext::DoBitBltMasked(

 		const TPoint& aDestPos,

 		const CFbsBitmap& aSourceBitmap,

 		const TRect& aSourceRect,

 		const CFbsBitmap& aMaskBitmap,

 		TBool aInvertMask,

 		const TPoint& aMaskPos)

 	{

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if (ValidateSourceAndMaskBitmaps(aSourceBitmap, aMaskBitmap))

 		{

 		// If the source rectangle does not intersect aBitmap, do nothing.

 		TRect sourceRect = IntersectBitmapWithRect(aSourceBitmap, aSourceRect);

 		if (!sourceRect.IsEmpty())

 			{

 			if (aMaskPos == TPoint(0, 0))

 				{

 				iEngine->BitBltMasked(aDestPos, aSourceBitmap, sourceRect, aMaskBitmap, aInvertMask);

 				}

 			else

 				{

 				TSize maskSize = aMaskBitmap.SizeInPixels();

 				// Convert negative or large mask offsets into sensible positive ones for tiling.

 				TPoint maskOffset(aMaskPos.iX % maskSize.iWidth, aMaskPos.iY % maskSize.iHeight);

 				if (maskOffset.iX < 0) 

 					maskOffset.iX += maskSize.iWidth;

 				if (maskOffset.iY < 0) 

 					maskOffset.iY += maskSize.iHeight;

 				iEngine->BitBltMasked(aDestPos, aSourceBitmap, sourceRect, aMaskBitmap, maskOffset);

 				}

 			}

 		}

 	}

 /**

 Performs a masked bitmap block transfer. Source rectangle operates in a similar way to BitBlt().

 This function uses either a black and white (binary) mask bitmap, or if the mask's display mode is 

 EGray256, alpha blending is used. The result is undefined if the mask pixel value is neither black nor 

 white and the mask display mode is other than EGray256.

 The mask is aligned with the source bitmap by aligning the first pixel of the mask and source bitmaps within

 the source rectangle. Tiling in both directions applies if the mask size is smaller than the source rectangle.

 Note that the mask is applied before the piece of the bitmap is defined - the mask is tiled relative to the 

 top left of the original source bitmap rather than the top left of the bitmap piece. If the mask has zero

 width or height, the error state is set to KErrArgument and no drawing is performed.

 The mask bitmap can be used as either a positive or negative mask. Masked pixels are not mapped to the 

 destination rectangle.

 If the client modifies the contents of the bitmap or the mask after issuing the BitBltMasked() command, the

 method does not guarantee whether the old bitmap or mask contents, or the new ones will be used. 

 Clients must call Finish() on the driver before modifying the bitmap or mask contents if they want a 

 guaranteed  result that the previously issued BitBltMasked() will be using the old bitmap or mask contents.

 In the event of a failure, the error state is set to one of the system-wide error codes.

 @see	CDirectGdiContext::BitBlt(const TPoint& aPoint, const CFbsBitmap& aBitmap, const TRect& aSourceRect);

 @see	CDirectGdiContext::BitBltMasked(const TPoint&, const CFbsBitmap&,const TRect&, const CFbsBitmap&, const TPoint&);

 @param	aDestPos		The destination for the top left corner of the transferred bitmap. 

 						It is relative to the top left corner of the destination bitmap, which may be the screen. 

 @param	aSourceBitmap	A memory-resident source bitmap.

 @param	aSourceRect		A rectangle defining the piece of the bitmap to be drawn, 

 						with co-ordinates relative to the top left corner of the bitmap. 

 @param	aMaskBitmap		Mask bitmap.

 @param	aInvertMask		If EFalse, a source pixel that is masked by a black pixel is not transferred to 

 						the destination rectangle. If ETrue, then a source pixel that is masked by a 

 						white pixel is not transferred to the destination rectangle. If alpha blending

 						is used instead of masking, this flag is ignored and no inversion takes place.

 @pre	The rendering target has been activated. aBitmap and aMask hold valid handles.

 @post	Request to draw the masked bitmap content has been accepted. 

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::BitBltMasked(

 		const TPoint& aDestPos,

 		const CFbsBitmap& aSourceBitmap,

 		const TRect& aSourceRect,

 		const CFbsBitmap& aMaskBitmap,

 		TBool aInvertMask)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::BitBltMasked(%d,%d)", aDestPos.iX, aDestPos.iY);

 	DoBitBltMasked (aDestPos, aSourceBitmap, aSourceRect, aMaskBitmap, aInvertMask, TPoint(0, 0));

 	}

 /**

 Performs a masked bitmap block transfer. Source rectangle operates in a similar way to BitBlt().

 This function uses either a black and white (binary) mask bitmap, or if aMaskBitmap's display mode is 

 EGray256, alpha blending is used. The result is undefined if the mask pixel value is neither black nor 

 white and the mask display mode is other than EGray256.

 The source rectangle is intersected with the source bitmap’s full extent and the intersection

 will become the effective value. The mask bitmap is aligned with the source bitmap by aligning

 its pixel at the position specified in aMaskPt with the first pixel of the source bitmap

 within the source rectangle. The mask bitmap will be tiled if it is smaller than the source

 rectangle. If the mask has zero width or height, the error state is set to KErrArgument and 

 no drawing is performed.

 If the client modifies the contents of the bitmap or the mask after issuing the BitBltMasked() command, the

 method does not guarantee whether the old bitmap or mask contents, or the new ones will be used. 

 Clients must call Finish() on the driver before modifying the bitmap or mask contents if they want a 

 guaranteed  result that the previously issued BitBltMasked() will be using the old bitmap or mask contents.

 In the event of a failure, the error state is set to one of the system-wide error codes.

 @see	CDirectGdiContext::BitBlt(const TPoint& aPoint, const CFbsBitmap& aBitmap, const TRect& aSourceRect);

 @see	CDirectGdiContext::BitBltMasked(const TPoint&, const CFbsBitmap&,const TRect&, const CFbsBitmap&, TBool);

 @param	aDestPos		The destination for the top left corner of the transferred bitmap. 

 						It is relative to the top left corner of the destination bitmap, which may be the screen. 

 @param	aSourceBitmap	A memory-resident source bitmap.

 @param	aSourceRect		A rectangle defining the piece of the bitmap to be drawn, 

 						with co-ordinates relative to the top left corner of the bitmap. 

 @param	aMaskBitmap		Mask bitmap.

 @param	aMaskPos		The point on the mask bitmap to use as the top left corner 

 @pre	The rendering target has been activated. aBitmap and aMask hold valid handles.

 @post	Request to draw the masked bitmap content has been accepted. 

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if no context is activated

 */

 EXPORT_C void CDirectGdiContext::BitBltMasked(

 		const TPoint& aDestPos,

 		const CFbsBitmap& aSourceBitmap,

 		const TRect& aSourceRect,

 		const CFbsBitmap& aMaskBitmap,

 		const TPoint& aMaskPos)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::BitBltMasked(%d,%d)", aDestPos.iX, aDestPos.iY);

 	DoBitBltMasked (aDestPos, aSourceBitmap, aSourceRect, aMaskBitmap, EFalse, aMaskPos);		

 	}

 /**

 Resets the current clipping region to none.

 @see    CDirectGdiContext::SetClippingRegion(const TRegion&)

 @pre	The rendering target has been activated.

 @post	Clipping region is reset to none. Subsequent rendering operations on current target will be clipped to the

 		full area of the target.

 @panic 	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::ResetClippingRegion()

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::ResetClippingRegion");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	iClippingRegion.Clear();

 	iEngine->ResetClippingRegion();

 	}

 /**

 Clears the entire target area with the current brush colour. The area is filled 

 as if ESolidBrush is used. Current clipping region and drawing mode apply.

 @see	CDirectGdiContext::Clear(const TRect&)

 @see	CDirectGdiContext::SetBrushColor(TRgb)

 @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)

 @see	CDirectGdiContext::SetClippingRegion(const TRegion& aRegion)

 @pre	The rendering target has been activated.

 @post	Request to clear given rectangular area (clipped to current clipping region) 

 		has been accepted. There is no guarantee that the request has been processed 

 		when the method returns.

 @panic 	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::Clear()

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::Clear");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	iEngine->Clear();

 	}

 /**

 Clears the given rectangular area with current brush colour. The area is filled 

 as if ESolidBrush is used. Current clipping region and drawing mode apply.

 @see	CDirectGdiContext::Clear()

 @see	CDirectGdiContext::SetBrushColor(TRgb)

 @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)

 @see	CDirectGdiContext::SetClippingRegion(const TRegion&)

 @param	aRect Area to be cleared.

 @pre	The rendering target has been activated.

 @post	Request to clear given rectangular area (clipped to current clipping region) has been accepted. 

 		There is no guarantee that the request has been processed when the method returns.

 @panic 	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::Clear(const TRect& aRect)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::Clear(%d,%d)", aRect.Width(), aRect.Height());

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if(aRect.Width() <= 0 || aRect.Height() <= 0)

 		{

 		return;

 		}

 	iEngine->Clear(aRect);

 	}

 /**

 Resets the bitmap brush pattern to none. If the current brush style is EPatternedBrush, the brush

 style will be set to ENullBrush.

 @see	CDirectGdiContext::SetBrushPattern(const CFbsBitmap&)

 @pre	None.

 @post	The bitmap brush pattern is no longer used.

 */

 EXPORT_C void CDirectGdiContext::ResetBrushPattern()

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::ResetBrushPattern");

 	CleanUpBrushPattern();

 	if (iBrushStyle == DirectGdi::EPatternedBrush)

 		{

 		iBrushStyle = DirectGdi::ENullBrush;

 		iEngine->SetBrushStyle(iBrushStyle);

 		}

 	iEngine->ResetBrushPattern();

 	}

 /**

 Releases the selected font for this context.

 @pre	None.

 @post	Internal resources previously allocated during SetFont() are released.

 @see	CDirectGdiContext::SetFont()

 @see	CGraphicsContext::DiscardFont()

 */

 EXPORT_C void CDirectGdiContext::ResetFont()

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::ResetFont");

 	iEngine->ResetFont();

 	iFont.Reset();

 	}

 /**

 Draws an arc. An arc is a segment of an ellipse which is defined by a given rectangle. The arc is drawn 

 anti-clockwise from the arc start point to the arc end point. The arc start point is the intersection  

 between vectors from the centre of the ellipse to the given start position and the ellipse. 

 Arc end point is defined in the same way.

 @param	aRect	The rectangle which defines where to draw the ellipse.

 @param	aStart	Position to be used in defining the arc start point.

 @param	aEnd	Position to be used in defining the arc end point.

 @pre	The rendering target has been activated.

 @post	Request to draw an arc has been accepted. There is no guarantee that the request 

 		has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 @see	CDirectGdiContext::DrawPie(const TRect&, const TPoint&, const TPoint&)

 */

 EXPORT_C void CDirectGdiContext::DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawArc");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if (aRect.IsEmpty() || iPenStyle == DirectGdi::ENullPen || (iPenSize.iWidth == 0) || (iPenSize.iHeight == 0))

 		{

 		return;

 		}

 	iEngine->DrawArc(aRect, aStart, aEnd);

 	}

 /**

 Draws and fills a pie. A pie is a shape defined by an arc from the ellipse and straight lines 

 from the centre of the ellipse to the arc start and end position. 

 @param	aRect	The rectangle which defines where to draw the ellipse

 @param	aStart	Position to be used in defining the arc start point

 @param	aEnd	Position to be used in defining the arc end point

 @pre	The rendering target has been activated.

 @post	Request to draw a pie has been accepted. There is no guarantee that the request 

 		has been processed when the method returns.

 @panic 	DGDI 7, if the rendering context has not been activated.

 @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.

 @see	CDirectGdiContext::DrawArc(const TRect&, const TPoint&, const TPoint&)

 */

 EXPORT_C void CDirectGdiContext::DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawPie");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);

 	if (aRect.IsEmpty())

 		{

 		return;

 		}

 	iEngine->DrawPie(aRect, aStart, aEnd);

 	}

 /**

 Draws the bitmap contents into the destination rectangle. Scaling applies when 

 the extents of the source bitmap and the destination rectangle do not match.

 If the source rectangle is not completely contained within the source 

 bitmap's extents, no drawing will take place.

 If the client modifies the content of the bitmap after issuing a DrawBitmap() command,

 the method does not guarantee that the old bitmap content or the new one

 will be drawn. Clients must call Finish() on the driver before modifying the bitmap 

 content if they want a guarantee that the previously issued DrawBitmap() will draw the

 old bitmap content.

 In the event of a failure, the error state is set to one of the system-wide error codes.

 @see CDirectGdiContext::DrawBitmap(const TRect&, const CFbsBitmap&, const TRect&)

 @param	aDestRect Destination rectangle.

 @param	aSourceBitmap Source bitmap.

 @pre	The rendering target has been activated.

 @post	Request to draw the bitmap content has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::DrawBitmap(const TRect& aDestRect, const CFbsBitmap& aSourceBitmap)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::DrawBitmap(%d,%d)", aDestRect.iTl.iX, aDestRect.iTl.iY);

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if (ValidateBitmap (aSourceBitmap))

 		{

 		DrawBitmap(aDestRect, aSourceBitmap,TRect(TPoint(0, 0), aSourceBitmap.SizeInPixels()));		

 		}

 	}

 /**

 Draws the bitmap contents into the destination rectangle. Scaling applies when 

 the destination and source rectangles do not match. The source bitmap may be 

 compressed. The destination rectangle will be clipped with the current clipping 

 region. If the source rectangle is not completely contained within the source 

 bitmap's extents, no drawing will take place.

 If the client modifies the content of the bitmap after issuing a DrawBitmap() command,

 the method does not guarantee that the old bitmap content or the new one

 will be drawn. Clients must call Finish() on the driver before modifying the bitmap 

 content if they want a guarantee that the previously issued DrawBitmap() will draw the

 old bitmap content.

 In the event of a failure, the error state is set to one of the system-wide error codes.

 @see CDirectGdiContext::DrawBitmap(const TRect&, const CFbsBitmap&)

 @param	aDestRect		Destination rectangle.

 @param	aSourceBitmap	Source bitmap.

 @param	aSourceRect		Rectangle specifying the area of the source bitmap to be drawn.

 @pre	The rendering target has been activated.

 @post	Request to draw the bitmap content has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::DrawBitmap(const TRect& aDestRect, const CFbsBitmap& aSourceBitmap, const TRect& aSourceRect)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::DrawBitmap(%d,%d)", aDestRect.iTl.iX, aDestRect.iTl.iY);

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if (ValidateBitmap(aSourceBitmap))

 		{

 		TSize sourceSize = aSourceBitmap.SizeInPixels();

 		// If source rectangle is not fully contained by the extents of the source bitmap,

 		// or the size of the source bitmap is zero, do nothing.

 		if (aSourceRect.iTl.iX >= 0 &&

 			aSourceRect.iTl.iY >= 0 &&

 			aSourceRect.iBr.iX <= sourceSize.iWidth &&

 			aSourceRect.iBr.iY <= sourceSize.iHeight &&

 			!aDestRect.IsEmpty() && !aSourceRect.IsEmpty())

 			{

 			iEngine->DrawBitmap(aDestRect, aSourceBitmap, aSourceRect);

 			}

 		}

 	}

 /**

 Draws bitmap content with masking. Scaling applies to both the source bitmap and the mask. 

 Both the source and the mask bitmap may be compressed. The destination and source rectangles

 operate in a similar way to DrawBitmap().

 This function uses either a black and white (binary) mask bitmap, or if the mask's display mode is 

 EGray256, alpha blending is used. The result is undefined if the mask pixel value is neither black nor 

 white and the mask display mode is other than EGray256.

 The mask is aligned with the source bitmap by aligning their first pixels within the source 

 rectangle. If the mask size is greater than or equal to the source bitmap size, it will be 

 scaled to fit the destination rectangle in the same way the source bitmap is scaled. 

 If the mask has zero width or height, the error state is set to KErrArgument and no drawing is performed.

 If the mask is smaller than the source bitmap, it will be tiled to fit the source bitmap size, 

 and then scaled to fit the destination rectangle.

 If the client modifies the content of the bitmap or mask after issuing a DrawBitmapMasked() command,

 the method does not guarantee whether the old bitmap or mask contents, or the new ones

 will be used. Clients must call Finish() on the driver before modifying the bitmap or mask contents 

 if they want a guaranteed result that the previously issued DrawBitmapMasked() will be using the old 

 bitmap or mask contents.

 In the event of a failure, the error state is set to one of the system-wide error codes.

 @param	aDestRect		Destination rectangle.

 @param	aSourceBitmap	Source bitmap.

 @param	aSourceRect		Rectangle specifying the area of the source bitmap to be drawn.

 @param	aMaskBitmap		Mask bitmap.

 @param	aInvertMask		If EFalse, a source pixel that is masked by a black pixel is not transferred to 

 						the destination rectangle. If ETrue, then a source pixel that is masked by a 

 						white pixel is not transferred to the destination rectangle. If alpha blending

 						is used instead of masking, this flag is ignored and no inversion takes place.

 @pre	The rendering target has been activated.

 @post	Request to draw the bitmap content with masking has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::DrawBitmapMasked(

 		const TRect& aDestRect,

 		const CFbsBitmap& aSourceBitmap,

 		const TRect& aSourceRect,

 		const CFbsBitmap& aMaskBitmap,

 		TBool aInvertMask)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::DrawBitmapMasked(%d,%d)", aDestRect.iTl.iX, aDestRect.iTl.iY);

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if (ValidateSourceAndMaskBitmaps(aSourceBitmap, aMaskBitmap))

 		{

 		TSize sourceSize = aSourceBitmap.SizeInPixels();

 		// Ensure source rect is fully within bounds of bitmap extents and

 		// dest and source rect are not empty. 

 		if (aSourceRect.iTl.iX >= 0 &&

 			aSourceRect.iTl.iY >= 0 &&

 			aSourceRect.iBr.iX <= sourceSize.iWidth &&

 			aSourceRect.iBr.iY <= sourceSize.iHeight &&

 			!aDestRect.IsEmpty() && !aSourceRect.IsEmpty())

 			{

 			iEngine->DrawBitmapMasked(aDestRect, aSourceBitmap, aSourceRect, aMaskBitmap, aInvertMask);

 			}

 		}

 	}

 /**

 Draws and fills a rectangle with rounded corners. The corner is constructed as an arc of 

 an ellipse. The outline is drawn in the current pen colour, size and style if the pen 

 colour is not ENullPen. The area inside the rectangle is filled according to the current 

 brush colour and style.

 If the corner size has zero width or height, a square-cornered rectangle is drawn. If the corner 

 size is greater than half the extents of the rectangle, an ellipse is drawn.

 @param	aRect The rectangle.

 @param	aCornerSize The corner size.

 @see	CDirectGdiContext::SetPenSize()

 @see	CDirectGdiContext::SetPenStyle()

 @see	CDirectGdiContext::SetPenColor()

 @see	CDirectGdiContext::SetBrushColor()

 @see	CDirectGdiContext::SetBrushStyle()

 @see	CDirectGdiContext::SetBrushPattern()

 @pre	The rendering target has been activated.

 @post	Request to draw a rectangle with rounded corners has been accepted. There is no guarantee 

 		that the request has been processed when the method returns.

 @panic 	DGDI 7, if the rendering context has not been activated.

 @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.

 */

 EXPORT_C void CDirectGdiContext::DrawRoundRect(const TRect& aRect, const TSize& aCornerSize)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawRoundRect");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);

 	TSize ellsize(aCornerSize);

 	ellsize.iWidth <<= 1;

 	ellsize.iHeight <<= 1;

 	if (aRect.Width() > 0 && aRect.Height() > 0)

 		{

 		if (ellsize.iWidth < 3 || ellsize.iHeight < 3)

 			{

 			DrawRect(aRect);

 			return;

 			}	

 		if (aRect.Width() < ellsize.iWidth && aRect.Height() < ellsize.iHeight)

 			{

 			DrawEllipse(aRect);

 			return;

 			}

 		iEngine->DrawRoundRect(aRect, aCornerSize);

 		}

 	}

 /**

 Draws a polyline using the points in an array. A polyline is a series of concatenated straight 

 lines joining a set of points. Current pen settings and drawing mode applies. If @c aPointList 

 has one element, a plot is performed.

 @param	aPointList Array of points specifying points on the polyline.

 @pre	The rendering target has been activated.

 @post	Request to draw a polyline has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 		The internal drawing position is set to the last point in the array.

 @panic	DGDI 7, if the rendering context has not been activated.

 @see	CDirectGdiContext::DrawPolyLineNoEndPoint(const TArray<TPoint>&)

 @see	CDirectGdiContext::SetPenSize(const TSize&)

 @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)

 */

 EXPORT_C void CDirectGdiContext::DrawPolyLine(const TArray<TPoint>& aPointList)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawPolyLine");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if ((aPointList.Count() < 1) || iPenStyle == DirectGdi::ENullPen || (iPenSize.iWidth == 0) || (iPenSize.iHeight == 0))

 		{

 		return;

 		}

 	if (aPointList.Count() == 1)

 		{

 		Plot(aPointList[0]);

 		}

 	else

 		{

 		iEngine->DrawPolyLine(aPointList);

 		}

 	}

 /**

 Draws a polyline using the points in an array. A polyline is a series of concatenated straight 

 lines joining a set of points. Current pen settings and drawing mode applies. If @c aPointList 

 has less than two elements, no drawing is performed. If @c aPointList has exactly two elements

 then a DrawLine is performed.

 @param	aPointList Array of points specifying points on the polyline.

 @pre	The rendering target has been activated.

 @post	Request to draw a polyline has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 		The internal drawing position is set to the last point in the array.

 @panic	DGDI 7, if the rendering context has not been activated.

 @see	CDirectGdiContext::DrawPolyLine(const TArray<TPoint>&)

 @see	CDirectGdiContext::SetPenSize(const TSize&)

 @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)

 */

 EXPORT_C void CDirectGdiContext::DrawPolyLineNoEndPoint(const TArray<TPoint>& aPointList)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawPolyLineNoEndPoint");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	const TInt points = aPointList.Count();

 	if (points == 1)

 		{

 		Plot(aPointList[0]);

 		}

 	else if (points == 2)

 		{

 		DrawLine(aPointList[0], aPointList[1]);

 		}

 	else if (points > 2 && !(iPenStyle == DirectGdi::ENullPen || (iPenSize.iWidth == 0) || (iPenSize.iHeight == 0)))

 		{

 		iEngine->DrawPolyLineNoEndPoint(aPointList);

 		}

 	}

 /**

 Draws and fills a polygon defined using an array of points. The first point in the array defines the 

 start of the first side of the polygon. The final side of the polygon is drawn using the last point 

 from the array, and the line is drawn to the start point of the first side. The outline of the polygon

 is drawn using the current pen settings and the area is filled with the current brush settings. 

 Self-crossing polygons are filled according to the specified fill rule.

 If @c aPointList is empty, no drawing is performed. If it has one element, the result is the same as Plot(). 

 If it has two elements, the result is the same as DrawLine().

 The error state is set to KErrArgument if aFillRule is an invalid fill rule.

 @param	aPointList Array of points specifying the vertices of the polygon.

 @param	aFillRule Polygon filling rule.

 @pre	The rendering target has been activated.

 @post	Request to draw a polygon has been accepted. There is no guarantee that the request has been processed

 		when the method returns. The internal drawing position is set to the last point in the array.

 @panic 	DGDI 7, if the rendering context has not been activated.

 @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.

 @see	CDirectGdiContext::SetPenSize(const TSize&)

 @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetBrushColor(TRgb)

 @see	CDirectGdiContext::SetBrushStyle(DirectGdi::TBrushStyle)

 @see	CDirectGdiContext::SetBrushPattern(const CFbsBitmap&)

 @see	CDirectGdiContext::SetBrushOrigin(TPoint)

 @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)

 @see	DirectGdi::TFillRule

 */

 EXPORT_C void CDirectGdiContext::DrawPolygon(const TArray<TPoint>& aPointList, DirectGdi::TFillRule aFillRule)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawPolygon");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);

 	if (aFillRule != DirectGdi::EAlternate && aFillRule != DirectGdi::EWinding)

 		{

 		iDriver.SetError(KErrArgument);

 		return;

 		}

 	if (aPointList.Count() == 0)

 		{

 		return;

 		}

 	iEngine->DrawPolygon(aPointList, aFillRule);

 	}

 /**

 Draws and fills an ellipse inside the given rectangle. Current pen and brush settings apply.

 @see	CDirectGdiContext::SetPenSize(const TSize&)

 @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetBrushColor(TRgb)

 @see	CDirectGdiContext::SetBrushStyle(DirectGdi::TBrushStyle)

 @see	CDirectGdiContext::SetBrushPattern(const CFbsBitmap&)

 @param	aRect The rectangle in which to draw the ellipse.

 @pre	The rendering target has been activated.

 @post	Request to draw an ellipse has been accepted. 

 		There is no guarantee that the request has been processed when the method returns.

 @panic 	DGDI 7, if the rendering context has not been activated.

 @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.

 */

 EXPORT_C void CDirectGdiContext::DrawEllipse(const TRect& aRect)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawEllipse");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);

 	if (aRect.IsEmpty())

 		{

 		return;

 		}

 	iEngine->DrawEllipse(aRect);

 	}

 /**

 Draws a straight line from the start to the end position using current pen size, colour and style. 

 @param	aStart	Start position.

 @param	aEnd	End position.

 @pre	The rendering target has been activated.

 @post	Request to draw a straight line with the current pen colour, size and style has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 		The internal drawing position is set to @c aEnd.

 @panic	DGDI 7, if the rendering context has not been activated.

 @see	CDirectGdiContext::SetPenSize(const TSize&)

 @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)

 */

 EXPORT_C void CDirectGdiContext::DrawLine(const TPoint& aStart, const TPoint& aEnd)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawLine");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	// Do not draw if start/end at the same point or pensize is 0

 	if(aStart == aEnd || iPenStyle == DirectGdi::ENullPen || iPenSize.iWidth == 0 || iPenSize.iHeight == 0)

 		{

 		return;

 		}

 	iEngine->DrawLine(aStart, aEnd);

 	}

 /**

 Draws a straight line from the current internal drawing position to a point using the current pen size, colour and style.

 @param	aPoint The end-point of the line.

 @pre	Rendering target has been activated.

 @post	Request to draw a straight line to a specified point with the current pen colour, size and style has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 		Internal drawing position is set to @c aPoint.

 @panic	DGDI 7, if the rendering context has not been activated.

 @see	CDirectGdiContext::SetPenSize(const TSize&)

 @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)

 @see	CDirectGdiContext::MoveTo(TPoint)

 @see	CDirectGdiContext::MoveBy(TPoint)

 */

 EXPORT_C void CDirectGdiContext::DrawLineTo(const TPoint& aPoint)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawLineTo");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if(iPenStyle == DirectGdi::ENullPen || iPenSize.iWidth == 0 || iPenSize.iHeight == 0)

 		{

 		return;

 		}

 	iEngine->DrawLineTo (aPoint);

 	}

 /**

 Draws a straight line relative to the current internal drawing position, using a vector. 

 The start point of the line is the current internal drawing position. The vector @c aVector 

 is added to the internal drawing position to give the end point of the line.

 @param	aVector	The vector to add to the current internal drawing position, giving the end point of the line.

 @pre	The rendering target has been activated.

 @post	The request to draw a straight line using the vector with current pen colour, size and style has been

 		accepted. There is no guarantee that the request has been processed when the method returns. 

 		The internal drawing position is set to the end of the line.

 @panic	DGDI 7, if the rendering context has not been activated.

 @see	CDirectGdiContext::SetPenSize(const TSize&)

 @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)

 @see	CDirectGdiContext::MoveTo(TPoint)

 @see	CDirectGdiContext::MoveBy(TPoint)

 */

 EXPORT_C void CDirectGdiContext::DrawLineBy(const TPoint& aVector)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawLineBy");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if(iPenStyle == DirectGdi::ENullPen || iPenSize.iWidth == 0 || iPenSize.iHeight == 0)

 		{

 		return;

 		}

 	if (aVector != TPoint(0,0))

 		{

 		iEngine->DrawLineBy(aVector);

 		}

 	}

 /**

 Draws and fills a rectangle. The outlines are drawn according to the current pen colour, size and style.

 The area inside the rectangle is filled according to the current brush colour and style.

 @see	CDirectGdiContext::SetPenSize(const TSize&)

 @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetBrushColor(TRgb)

 @see	CDirectGdiContext::SetBrushStyle(DirectGdi::TBrushStyle)

 @see	CDirectGdiContext::SetBrushPattern(const CFbsBitmap&)

 @param	aRect The rectangle.

 @pre	The rendering target has been activated.

 @post	Request to draw a rectangle according to the current pen and brush settings has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic 	DGDI 7, if the rendering context has not been activated.

 @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.

 */

 EXPORT_C void CDirectGdiContext::DrawRect(const TRect& aRect)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawRect");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);

 	if(aRect.IsEmpty())

 		return;

 	iEngine->DrawRect(aRect);

 	}

 /**

 Draws text at the last print position.

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetBrushColor(TRgb)

 @see	CDirectGdiContext::SetFont(const CFont*)

 @param	aText	The text string to be drawn.

 @param	aParam	Parameters used in drawing text.

 @pre	The rendering target has been activated.

 @post	Request to draw the text at the last text position using the current font and pen colour has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush

 		style is neither ENullBrush nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 EXPORT_C void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawText");

 	DrawText(aText, aParam, iLastPrintPosition, DirectGdi::ELeft, CFont::EHorizontal);

 	}

 /**

 Draws text at the specified text position.

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetBrushColor(TRgb)

 @see	CDirectGdiContext::SetFont(const CFont*)

 @param	aText		The text string to be drawn.

 @param	aParam		Parameters used in drawing text.

 @param	aPosition	The position to draw at.

 @pre	The rendering target has been activated.

 @post	Request to draw the text at the specified position using the current font and pen colour has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush

 		style is neither ENullBrush nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 EXPORT_C void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TPoint& aPosition)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawText");

 	DrawText(aText, aParam, aPosition, DirectGdi::ELeft, CFont::EHorizontal);

 	}

 /**

 Draws text clipped to the specified rectangle.

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetBrushColor(TRgb)

 @see	CDirectGdiContext::SetFont(const CFont*)

 @param	aText		The text string to be drawn.

 @param	aParam		Parameters used in drawing text.

 @param	aClipRect	The clipping rectangle.

 @pre	The rendering target has been activated.

 @post	Request to draw the text at the last text position using the current font and pen colour, clipped to the specified rectangle has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and 

 		the brush style is neither ENullBrush nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 EXPORT_C void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipRect)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawText");

 	DrawText(aText, aParam, iLastPrintPosition, DirectGdi::ELeft, CFont::EHorizontal, &aClipRect);

 	}

 /**

 Draws text clipped to the specified filled rectangle using a baseline offset,

 horizontal alignment and a margin.

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetBrushColor(TRgb)

 @see	CDirectGdiContext::SetFont(const CFont*)

 @param	aText			The text string to be drawn.

 @param	aParam		Parameters used in drawing text.

 @param	aClipFillRect	The clipping rectangle (this rect will also be filled before text is plotted).

 @param	aBaselineOffset	An offset in pixels for the baseline from the normal position (bottom of the rectangle minus the descent of the font).

 @param	aAlignment		Horizontal alignment option relative to the specified rectangle.

 @param	aMargin			Offset to add to the position as calculated using specified rectangle.

 @pre	The rendering target has been activated.

 @post	Request to draw the text within the filled rectangle using the current font and pen colour, offset and clipped to the specified rectangle has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush

 		style is neither ENullBrush nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 EXPORT_C void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipFillRect, TInt aBaselineOffset, DirectGdi::TTextAlign aAlignment, TInt aMargin)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawText");

 	TPoint p(aClipFillRect.iTl);

 	p.iY += aBaselineOffset;

 	switch (aAlignment)

 		{

 		case DirectGdi::ELeft:

 			{

 			p.iX += aMargin;

 			break;

 			}

 		case DirectGdi::ERight:

 			{

 			p.iX = aClipFillRect.iBr.iX - aMargin;

 			break;

 			}

 		case DirectGdi::ECenter:

 			{

 			p.iX += (aClipFillRect.Width() >> 1) + aMargin;

 			break;

 			}

 		default:

 			{

 			iDriver.SetError(KErrArgument);

 			return;

 			}		

 		}

 	DrawText(aText, aParam, p, aAlignment, CFont::EHorizontal, &aClipFillRect, &aClipFillRect);

 	}

 /**

 The private general DrawText routine that implements all the others.

 @param	aText		The text to be drawn.

 @param	aParam		Parameters used in drawing text.

 @param	aPosition	The origin of the text.

 @param	aAlignment	Left, centred or right, around aPosition; not used if drawing vertically.

 @param	aDirection	Direction: left to right, right to left, or top to bottom.

 @param	aClipRect	If non-null, used as a clippingrect when the text is drawn.

 @param	aFillRect	If non-null, filled before the text is drawn.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush

 		style is neither ENullBrush nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TPoint& aPosition, DirectGdi::TTextAlign aAlignment, 

 	CFont::TTextDirection aDirection, const TRect* aClipRect, const TRect* aFillRect)

 	{

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	// anything to do?

 	if (aClipRect && aClipRect->IsEmpty())

 		{

 		iDriver.SetError(KErrArgument);

 		return;

 		}

 	GRAPHICS_ASSERT_ALWAYS(iFont.Handle() != 0, EDirectGdiPanicNoFontSelected);

 	// This next check actually covers both bitmap and open fonts

 	const CBitmapFont* bitmap_font = iFont.Address();

 	GRAPHICS_ASSERT_ALWAYS(bitmap_font != 0, EDirectGdiPanicNoFontSelected);

 	// measure the text

 	CFont::TMeasureTextInput measure_text_input;

 	measure_text_input.iCharJustNum = iCharJustNum;

 	measure_text_input.iCharJustExcess = iCharJustExcess;

 	measure_text_input.iWordJustNum = iWordJustNum;

 	measure_text_input.iWordJustExcess = iWordJustExcess;

 	measure_text_input.iFlags |= CFont::TMeasureTextInput::EFVisualOrder;

 	if (aParam)

 		{

 		GRAPHICS_ASSERT_ALWAYS(aParam->iStart < aParam->iEnd ,EDirectGdiPanicBadParameter);

 		measure_text_input.iStartInputChar = aParam->iStart;

 		measure_text_input.iEndInputChar = Min(aText.Length(),aParam->iEnd);

 		}

 	CFont::TMeasureTextOutput measure_text_output;

 	const TInt advance = iFont.MeasureText(aText, &measure_text_input, &measure_text_output);

 	TRect text_bounds = measure_text_output.iBounds;

 	//for linked fonts need an adjustment to the underline postion

 	TInt underlineStrikeoutOffset = BaselineCorrection();

 	if (iUnderline == DirectGdi::EUnderlineOn)

 		{

 		TInt underline_top = 0;

 		TInt underline_bottom = 0;

 		GetUnderlineMetrics(underline_top, underline_bottom);

 		underline_top+=underlineStrikeoutOffset;

 		underline_bottom+=underlineStrikeoutOffset;

 		text_bounds.iTl.iY = Min(text_bounds.iTl.iY, underline_top);

 		text_bounds.iBr.iY = Max(text_bounds.iBr.iY, underline_bottom);

 		}

 	if (iStrikethrough == DirectGdi::EStrikethroughOn)

 		{

 		TInt strike_top = 0;

 		TInt strike_bottom = 0;

 		GetStrikethroughMetrics(strike_top, strike_bottom);

 		strike_top+=underlineStrikeoutOffset;

 		strike_bottom+=underlineStrikeoutOffset;

 		text_bounds.iTl.iY = Min(text_bounds.iTl.iY, strike_top);

 		text_bounds.iBr.iY = Max(text_bounds.iBr.iY, strike_bottom);

 		}

 	if (iUnderline == DirectGdi::EUnderlineOn || iStrikethrough == DirectGdi::EStrikethroughOn)

 		{

 		if (aDirection == CFont::EHorizontal)

 			{

 			text_bounds.iTl.iX = Min(text_bounds.iTl.iX, 0);

 			text_bounds.iBr.iX = Max(text_bounds.iBr.iX, advance);

 			}

 		else

 			{

 			text_bounds.iTl.iY = Min(text_bounds.iTl.iY, 0);

 			text_bounds.iBr.iY = Max(text_bounds.iBr.iY, advance);

 			}

 		}

 	// work out the text origin and new drawing position

 	TPoint text_origin = aPosition;

 	if (aDirection != CFont::EVertical)

 		{

 		const TInt leftSideBearing = Min(text_bounds.iTl.iX, 0);

 		const TInt rightSideBearing = Max(text_bounds.iBr.iX, advance);

 		switch (aAlignment)

 			{

 			// We are forbidding side-bearings to leak over the sides here,

 			// but still keeping the start and end pen positions within bounds.

 			case DirectGdi::ELeft:

 				text_origin.iX -= leftSideBearing;

 				break;

 			case DirectGdi::ERight:

 				text_origin.iX -= rightSideBearing;

 				break;

 			case DirectGdi::ECenter:

 				// Centre is the average of left and right

 				text_origin.iX -= (leftSideBearing + rightSideBearing) >> 1;

 				break;

 			default:

 				iDriver.SetError(KErrArgument);

 				return;

 			}

 		}

 	iLastPrintPosition = text_origin;

 	if (aDirection == CFont::EHorizontal)

 		{

 		iLastPrintPosition.iX += advance;

 		}

 	else

 		{

 		iLastPrintPosition.iY += advance;

 		}

 	text_origin.iY += bitmap_font->iAlgStyle.iBaselineOffsetInPixels;

 	text_bounds.Move(text_origin);

 	text_origin += iOrigin;

 	// determine clipping rectangle

 	TRect clipRect = aClipRect ? *aClipRect : text_bounds;

 	// fill the box if necessary

 	if (aFillRect && (iBrushStyle != DirectGdi::ENullBrush))

 		{

 		TRect fillBox = *aFillRect;

 		if (fillBox.Intersects(clipRect))

 			{

 			fillBox.Intersection(clipRect);

 			iEngine->SetPenStyle(DirectGdi::ENullPen);	// Fill box, don't outline it

 			iEngine->DrawRect(fillBox);

 			iEngine->SetPenStyle(iPenStyle);		// Put the pen style back

 			}

 		}

 	if (!aText.Length())

 		{		

 		return;

 		}

 	clipRect.Move(iOrigin);

 	// decide which drawing routine to call

 	TOpenFontMetrics metrics;

 	iFont.GetFontMetrics(metrics);

 	const TInt maxwidth = metrics.MaxWidth();

 	// extext will be TRUE, if font is underline/strikethrough/anti-aliased or it has shadow/outline effects ON.

 	// Depending on these properties it will call the proper draw routine.

 	TBool extext = EFalse;

 	TBool normaltext = EFalse;

 	const TBool antiAliased = (bitmap_font->GlyphBitmapType() == EAntiAliasedGlyphBitmap);

 	const TBool outlineAndShadow = (bitmap_font->GlyphBitmapType() == EFourColourBlendGlyphBitmap);

 	if (antiAliased || outlineAndShadow )

 		{

 		if ((outlineAndShadow) && !((iBrushStyle == DirectGdi::ENullBrush) || (iBrushStyle == DirectGdi::ESolidBrush)))

 			{

 			//For future compatibility it is better if brush style of ENullBrush or ESolidBrush is used 

 			//when drawing outline and shadow fonts.

 			GRAPHICS_PANIC_ALWAYS(EDirectGdiPanicInvalidBrushStyle);

 			}

 		extext = ETrue;

 		}

 	else if ((iUnderline == DirectGdi::EUnderlineOn) || (iStrikethrough == DirectGdi::EStrikethroughOn) || (iCharJustNum > 0) || (iWordJustNum > 0))

 		extext = ETrue;

 	else

 		normaltext = ETrue;

 	const TInt charjustexcess = iCharJustExcess;

 	const TInt charjustnum = iCharJustNum;

 	const TInt wordjustexcess = iWordJustExcess;

 	const TInt wordjustnum = iWordJustNum;

 	// Set up the parameter block for character positioning.

 	CFont::TPositionParam param;

 	param.iDirection = static_cast<TInt16>(aDirection);

 	param.iText.Set(aText);

 	TInt endDraw = aText.Length();

 	if (aParam)

 		{

 		param.iPosInText = aParam->iStart;

 		endDraw = Min(aText.Length(),aParam->iEnd);

 		}

 	else

 		{

 		param.iPosInText = 0;

 		}

 	param.iPen = text_origin;

 	// Draw the text.

 	if (normaltext)

 		{

 		DoDrawText(param, endDraw, clipRect);

 		}

 	else if (extext)

 		{

 		DoDrawTextEx(param, endDraw, clipRect,underlineStrikeoutOffset);

 		}

 	// Reset the justification parameters to their original values.

 	// These will be updated as required later in code.

 	iCharJustExcess = charjustexcess;

 	iCharJustNum = charjustnum;

 	iWordJustExcess = wordjustexcess;

 	iWordJustNum = wordjustnum;

 	if (iAutoUpdateJustification)

 		UpdateJustification(aText, aParam);

 	}

 /**

 Overridden  function which draws monochrome text within the given clip rectangle. No rotation applied.

 @param	aParam	Defines glyph code, ligature creation and diacritic placement.

 @param	aEnd	The end position within the text descriptor to draw.

 @param	aClipRect If not-empty, used as a clippingrect when the text is drawn.

 */

 void CDirectGdiContext::DoDrawText(CFont::TPositionParam& aParam, const TInt aEnd, const TRect& aClipRect)

 	{

 	iEngine->BeginDrawGlyph();

 	RShapeInfo shapeInfo;

 	while (aParam.iPosInText < aEnd)

 		{

 		if (iFont.GetCharacterPosition2(aParam, shapeInfo))

 			{

 			const CFont::TPositionParam::TOutput* output = aParam.iOutput;

 			for (TInt i = 0; i < aParam.iOutputGlyphs; ++i, ++output)

 				iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, EMonochromeGlyphBitmap, output->iBitmapSize, aClipRect); // All other parameters are default

 			}

 		}

 	iEngine->EndDrawGlyph();

 	if (shapeInfo.IsOpen())

 		shapeInfo.Close();

 	}

 /**

 Overridden  function which draws monochrome text within the given clip rectangle. 

 The current rotation and font style (strikethrough, underline) are applied.

 @param	aParam	Defines glyph code, ligature creation and diacritic placement.

 @param	aEnd	The end position within the text descriptor to draw.

 @param	aClipRect If not-empty, used as a clipping rect when the text is drawn.

 @param  aUnderlineStrikethroughOffset the offset for the underline, passed to save calculating this value again

 */

 void CDirectGdiContext::DoDrawTextEx(CFont::TPositionParam& aParam, const TInt aEnd, const TRect& aClipRect, const TInt aUnderlineStrikethroughOffset)

 	{

 	TPoint startPen = aParam.iPen;

 	const CBitmapFont* bitmap_font = iFont.Address();

 	TInt underlineTop = 0;

 	TInt underlineBottom = 0;

 	if (iUnderline == DirectGdi::EUnderlineOn)

 		{

 		GetUnderlineMetrics(underlineTop, underlineBottom);

 		underlineTop+=aUnderlineStrikethroughOffset;

 		underlineBottom+=aUnderlineStrikethroughOffset;

 		}

 	TInt strikeTop = 0;

 	TInt strikeBottom = 0;

 	if (iStrikethrough == DirectGdi::EStrikethroughOn)

 		{

 		GetStrikethroughMetrics(strikeTop, strikeBottom);

 		strikeTop+=aUnderlineStrikethroughOffset;

 		strikeBottom+=aUnderlineStrikethroughOffset;

 		}

 	iEngine->BeginDrawGlyph();

 	RShapeInfo shapeInfo;

 	while (aParam.iPosInText < aEnd)

 		{

 		if (!iFont.GetCharacterPosition2(aParam, shapeInfo))

 			{

 			continue;

 			}

 		TInt adjustment = 0;

 		if ((iCharJustExcess > 0) && (iCharJustNum > 0)) // character clipping/justification

 			{

 			adjustment = CGraphicsContext::JustificationInPixels(iCharJustExcess, iCharJustNum);

 			}

 		const CFont::TPositionParam::TOutput* output = aParam.iOutput;

 		for (TInt i = 0; i < aParam.iOutputGlyphs; ++i, ++output)

 			{

 			//get the character metrics for the glyph type

 			TOpenFontCharMetrics characterParams;

 			const TUint8* bitmap;

 			TSize size;

 			//note may now be using a glyph code, and not a character

 			iFont.GetCharacterData(aParam.iOutput[i].iCode,characterParams,bitmap,size);

 			TGlyphBitmapType glyphType = characterParams.GlyphType();

 			switch (glyphType)

 				{

 				case EAntiAliasedGlyphBitmap:

 				case EFourColourBlendGlyphBitmap:

 				case EDefaultGlyphBitmap:

 					iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, glyphType, output->iBitmapSize, aClipRect);

 					break;

 				default:

 					//if the outline or shadow is not specified for the character, then use the font setting for the glyph bitmap type

 					iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, 

 									   bitmap_font->GlyphBitmapType(), output->iBitmapSize, aClipRect);		 

 					break;

 				}

 			}

 		if (adjustment)

 			{

 			aParam.iPen.iX += adjustment;

 			}

 		if ((iWordJustExcess > 0) && (iWordJustNum > 0) && (aParam.iOutput[0].iCode == 0x0020)) // word justification

 			{

 			adjustment = CGraphicsContext::JustificationInPixels(iWordJustExcess, iWordJustNum);

 			aParam.iPen.iX += adjustment;

 			}

 		}

 	iEngine->EndDrawGlyph();

 	if (shapeInfo.IsOpen())

 		shapeInfo.Close();

 	if (iUnderline == DirectGdi::EUnderlineOn)

 		{

 		TRect underlineRect(startPen.iX, startPen.iY + underlineTop, aParam.iPen.iX, startPen.iY + underlineBottom);

 		FillRect(underlineRect, iPenColor, aClipRect);

 		}

 	if (iStrikethrough == DirectGdi::EStrikethroughOn)

 		{

 		TRect strikethroughRect(startPen.iX, startPen.iY + strikeTop, aParam.iPen.iX, startPen.iY + strikeBottom);

 		FillRect(strikethroughRect, iPenColor, aClipRect);

 		}

 	}

 /**

 Fills the given rectangle with the specified colour (subject to the clip rect).

 This function is internal and used by the text drawing routines.

 @param	aRect	The rectangle to fill.

 @param	aColor	The colour to fill it with.

 @param	aClipRect	The clipping rect.

 */

 void CDirectGdiContext::FillRect(const TRect& aRect, const TRgb& aColor, const TRect& aClipRect)

 	{

 	TRect fillRect = aRect;

 	if (fillRect.Intersects(aClipRect))

 		{

 		fillRect.Intersection(aClipRect);

 		// Override the current settings temporarily

 		iEngine->SetBrushColor(aColor);

 		iEngine->SetBrushStyle(DirectGdi::ESolidBrush);

 		iEngine->SetPenStyle(DirectGdi::ENullPen);	// Fill box, don't outline it

 		fillRect.Move(-iOrigin);

 		iEngine->DrawRect(fillRect);

 		// Put things back

 		iEngine->SetPenStyle(iPenStyle);

 		iEngine->SetBrushStyle(iBrushStyle);

 		iEngine->SetBrushColor(iBrushColor);

 		}

 	}

 /**

 Draws text at the last print position and then rotates it into a vertical position.

 @param	aText	The text string to be drawn.

 @param	aParam	Parameters used in drawing text.

 @param	aUp		If ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush

 		style is neither ENullBrush nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, TBool aUp)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	// This next check covers both bitmap and open fonts

 	const CBitmapFont* bitmapFont = iFont.Address();

 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);

 	TRect clipRect2(0, 0, 0, 0);

 	TInt baselineOffset = 0;

 	TInt margin = 0;

 	CalculateClipRect2PlusBaselineOffsetAndMargin(aText, aParam, iLastPrintPosition, aUp, clipRect2, baselineOffset, margin);

 	DrawTextVertical(aText, aParam, NULL, &clipRect2, NULL, baselineOffset, -1, aUp, DirectGdi::ELeft, margin); //-1 signifies that text will not be clipped

 	}

 /**

 Draws text vertically from the specified position.

 @param	aText		The text string to be drawn.

 @param	aParam		Parameters used in drawing text.

 @param	aPosition	A point specifying the position of the left end of the text.

 @param	aUp			If ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither 

 		ENullBrush nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TPoint& aPosition, TBool aUp)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	// This next check covers both bitmap and open fonts

 	const CBitmapFont* bitmapFont = iFont.Address();

 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);

 	TRect clipRect2(0, 0, 0, 0);

 	TInt baselineOffset = 0;

 	TInt margin = 0;

 	CalculateClipRect2PlusBaselineOffsetAndMargin(aText, aParam, aPosition, aUp, clipRect2, baselineOffset, margin);

 	DrawTextVertical(aText, aParam, NULL, &clipRect2, NULL, baselineOffset, -1, aUp, DirectGdi::ELeft, margin);//-1 signifies that text will not be clipped

 	}

 /**

 Draws text clipped to the specified rectangle and then rotates it into a vertical position.

 @param	aText		The text string to be drawn.

 @param	aParam		Parameters used in drawing text.

 @param	aClipRect	The clipping rectangle.

 @param	aUp			ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 

 		nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipRect, TBool aUp)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);	

 	// This next check covers both bitmap and open fonts

 	const CBitmapFont* bitmapFont = iFont.Address();

 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);

 	TRect clipRect2(0, 0, 0, 0);

 	TInt baselineOffset = 0;

 	TInt margin = 0;

 	CalculateClipRect2PlusBaselineOffsetAndMargin(aText, aParam, iLastPrintPosition, aUp, clipRect2, baselineOffset, margin);

 	DrawTextVertical(aText, aParam, &aClipRect, &clipRect2, NULL, baselineOffset, -1, aUp, DirectGdi::ELeft, margin);

 	}

 /**

 Private internal function for calculating several parameters needed by these routines.

 @param	aText		The text string to be drawn.

 @param	aParam		Parameters used in drawing text.

 @param	aPosition	A point specifying the position of the left end of the text.

 @param	aUp			ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.

 @param	aClipRect2		On return, contains clipping rectangle.

 @param	aBaselineOffset	On return, contains baseline offset.

 @param	aMargin			On return, contains margin.

 */

 void CDirectGdiContext::CalculateClipRect2PlusBaselineOffsetAndMargin(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TPoint& aPosition, TBool aUp, TRect& aClipRect2, TInt& aBaselineOffset, TInt& aMargin)

 	{

 	TOpenFontMetrics metrics;

 	iFont.GetFontMetrics(metrics);

 	aBaselineOffset = metrics.MaxHeight();

 	TInt height = aBaselineOffset + metrics.MaxDepth();

 	// The next few lines do much the same as TextWidthInPixels but pass

 	// the text in visual order instead of logical order and also take

 	// full account of left and right side bearings on the text

 	CFont::TMeasureTextOutput output;

 	CFont::TMeasureTextInput input;

 	input.iFlags = CFont::TMeasureTextInput::EFVisualOrder;

 	if (aParam)

 		{

 		GRAPHICS_ASSERT_ALWAYS(aParam->iStart < aParam->iEnd ,EDirectGdiPanicBadParameter);

 		input.iStartInputChar = aParam->iStart;

 		input.iEndInputChar = Min(aText.Length(),aParam->iEnd);

 		}

 	TInt advance = iFont.MeasureText(aText, &input, &output);

 	TInt leftBearing = output.iBounds.iTl.iX;

 	TInt rightBearing = advance - output.iBounds.iBr.iX;

 	aMargin = 0;

 	if (aUp)

 		{

 		aClipRect2.iTl.iX = aPosition.iX - aBaselineOffset;

 		aClipRect2.iTl.iY = aPosition.iY - advance;

 		aClipRect2.iBr.iX = aPosition.iX + height - aBaselineOffset + 1;

 		aClipRect2.iBr.iY = aPosition.iY;

 		if (leftBearing < 0)

 			{

 			aClipRect2.iBr.iY -= leftBearing;

 			aMargin = -leftBearing;

 			}

 		if (rightBearing < 0)

 			{

 			aClipRect2.iTl.iY += rightBearing;

 			}

 		}

 	else

 		{

 		aClipRect2.iTl.iX = aPosition.iX + aBaselineOffset- height;

 		aClipRect2.iTl.iY = aPosition.iY;

 		aClipRect2.iBr.iX = aPosition.iX + aBaselineOffset + 1;

 		aClipRect2.iBr.iY = aPosition.iY + advance;

 		if (leftBearing < 0)

 			{

 			aClipRect2.iTl.iY += leftBearing;

 			aMargin = -leftBearing;

 			}

 		if (rightBearing < 0)

 			{

 			aClipRect2.iBr.iY -= rightBearing;

 			}

 		}

 	}

 /**

 Draws text vertically, clipped to a specified rectangle, using a baseline offset, alignment and margin.

 @param	aText			The text string to be drawn.

 @param	aParam			Parameters used in drawing text.

 @param	aClipFillRect	The clipping rectangle (this rect will also be filled before text is plotted).

 @param	aBaselineOffset	Number of pixels to offset the baseline by.

 @param	aUp				ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.

 @param	aVert			Vertical alignment of the text relative to the specified rectangle.

 @param	aMargin			Offset of the text from the position within the rectangle, using the specified alignment.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 

 		nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipFillRect, TInt aBaselineOffset,

 												  TBool aUp, DirectGdi::TTextAlign aVert, TInt aMargin)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	// This next check covers both bitmap and open fonts

 	const CBitmapFont* bitmapFont = iFont.Address();

 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);

 	DrawTextVertical(aText, aParam, NULL, &aClipFillRect, &aClipFillRect, aBaselineOffset, -1, aUp, aVert, aMargin);

 	}

 /**

 Draws text vertically, clipped to a specified rectangle, using a baseline offset, alignment and margin.

 @param	aText			The text string to be drawn.

 @param	aParam			Parameters used in drawing text.

 @param	aClipFillRect	The clipping rectangle (this rect will also be filled before text is plotted).

 @param	aBaselineOffset	Number of pixels to offset the baseline by.

 @param	aTextWidth		Number of pixels to clip the text to.

 @param	aUp				ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.

 @param	aVert			Vertical alignment of the text relative to the specified rectangle.

 @param	aMargin			Offset of the text from the position within the rectangle, using the specified alignment.

 @panic	DGDI 7, if the rendering context has not been activated.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 

 		nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 */

 EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipFillRect, TInt aBaselineOffset,

 												  TInt aTextWidth, TBool aUp, DirectGdi::TTextAlign aVert, TInt aMargin)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	// This next check covers both bitmap and open fonts

 	const CBitmapFont* bitmapFont = iFont.Address();

 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);

 	DrawTextVertical(aText, aParam, NULL, &aClipFillRect, &aClipFillRect, aBaselineOffset, aTextWidth, aUp, aVert, aMargin);

 	}

 /**

 The private general DrawTextVertical() routine that implements all the others.

 Two clipping rectangles received from different routines. The final rectangle will be calculated as intersection 

 of first and second clipping rectangle. If aClipRect2 is empty, the error state is set to KErrArgument.

 @param	aText			The text string to be drawn.

 @param	aParam			Parameters used in drawing text.

 @param	aClipRect1		Pointer to first clipping rectangle.

 @param	aClipRect2		Pointer to second clipping rectangle. 

 @param	aFillRect		Pointer to rectangle to be filled before text plotting.

 @param	aBaselineOffset	Number of pixels to offset the baseline by.

 @param	aTextWidth		Number of pixels to clip the text to. If negative, the text will not be clipped

 @param	aUp				ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.

 @param	aVert			Vertical alignment of the text relative to the specified rectangle.

 @param	aMargin			Offset of the text from the position within the rectangle, using the specified alignment.

 @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 

 		nor ESolidBrush.

 @panic	DGDI 11, if a font has not been set prior to calling DrawText().

 @panic  DGDI 22, if aClipRect2 is NULL.

 */

 void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect* aClipRect1, const TRect* aClipRect2, const TRect* aFillRect,

 		TInt aBaselineOffset, TInt aTextWidth, TBool aUp, DirectGdi::TTextAlign aVert, TInt aMargin)

 	{

 	GRAPHICS_ASSERT_ALWAYS(aClipRect2, EDirectGdiPanicBadParameter);

 	TRect clipRect2 = *aClipRect2;

 	clipRect2.Move(iOrigin);

 	TRect clipRect(clipRect2);

 	if (aClipRect1 != NULL)

 		{

 		if(aClipRect1->IsEmpty())

 			{

 			iDriver.SetError(KErrArgument);

 			return;

 			}

 		TRect clipRect1 = *aClipRect1;

 		clipRect1.Move(iOrigin);

 		clipRect.Intersection(clipRect1);

 		}

 	if ((aFillRect != NULL) && (iBrushStyle != ENullBrush))

 		{

 		// fill the box if necessary

 		TRect fillBox = *aFillRect;

 		fillBox.Move(iOrigin);

 		if (fillBox.Intersects(clipRect))

 			{

 			fillBox.Intersection(clipRect);

 			iEngine->SetPenStyle(DirectGdi::ENullPen);	// Fill box, don't outline it

 			iEngine->DrawRect(*aFillRect);

 			iEngine->SetPenStyle(iPenStyle);		// Put the pen style back

 			}

 		}

 	if (!aText.Length())

 		{		

 		return;

 		}

 	if (aClipRect2->IsEmpty())

 		{

 		iDriver.SetError(KErrArgument);

 		return;

 		}

 	const CBitmapFont* bitmapFont = iFont.Address();

 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);

 	CFont::TMeasureTextInput input;

 	//CFont::TMeasureTextOutput

 	if (aParam)

 		{

 		GRAPHICS_ASSERT_ALWAYS(aParam->iStart < aParam->iEnd ,EDirectGdiPanicBadParameter);

 		input.iStartInputChar = aParam->iStart;

 		input.iEndInputChar = Min(aText.Length(),aParam->iEnd);

 		}

 	TInt width = iFont.MeasureText(aText,&input);

 	TOpenFontMetrics metrics;

 	iFont.GetFontMetrics(metrics);

 	if (aTextWidth < 0)

 		{

 		aTextWidth = width;

 		}

 	TPoint coords;

 	coords.iX = clipRect2.iTl.iX;

 	TInt directionalMultiplier = aUp ? -1 : 1;

 	coords.iY = aUp ? clipRect2.iBr.iY - 1 : clipRect2.iTl.iY;

 	//

 	// iX calculation, for example: ascent(a)=18 descent(d)=2 size=boxwidth=fontheight(h)=20 baseline=ascent

 	// pre: iX = 0

 	//

 	// hhhhhhhhhhhhhhhhhhhh

 	// 01234567890123456789

 	// aaaaaaaaaaaaaaaaaadd	aUp=ETrue

 	//                   ^

 	//                   iX = 18 (baseline)

 	//

 	// ddaaaaaaaaaaaaaaaaaa aUp=EFalse

 	//  ^

 	//  iX = 1 (instead of 2 ie 20-18-1 which is boxwidth-baseline-1)

 	//

 	coords.iX += aUp ? aBaselineOffset : clipRect2.Width() - aBaselineOffset - 1;

 	switch (aVert)

 		{

 	case DirectGdi::ELeft:

 		coords.iY += aMargin * directionalMultiplier;

 		break;

 	case DirectGdi::ECenter:

 		coords.iY += (((clipRect2.iBr.iY - clipRect2.iTl.iY - aTextWidth) >> 1) + aMargin) * directionalMultiplier;

 		break;

 	case DirectGdi::ERight:

 		coords.iY += (clipRect2.iBr.iY - clipRect2.iTl.iY - aTextWidth - aMargin) * directionalMultiplier;

 		break;

 	default:

 		iDriver.SetError(KErrArgument);

 		return;

 		}

 	iLastPrintPosition = coords;

 	coords.iX += bitmapFont->iAlgStyle.iBaselineOffsetInPixels * directionalMultiplier;

 	TInt prewidth = width + iCharJustExcess + iWordJustExcess;

 	iLastPrintPosition.iY -= aUp ? prewidth - 1 : -prewidth;

 	if (clipRect.IsEmpty() || !width)

 		{

 		if (iAutoUpdateJustification)

 			{

 			UpdateJustificationVertical(aText, aParam, aUp);

 			}

 		return;

 		}

 	/*

 	Set up the parameter block for character positioning.

 	Draw left to right, because although the text is being drawn vertically,

 	it is done by rotating the baseline 90 degrees and drawing in the ordinary way, not by drawing

 	the characters in their normal orientation but in a vertical column.

 	*/

 	CFont::TPositionParam param;

 	param.iText.Set(aText);

 	param.iPen = coords;

 	TInt endDraw = aText.Length();

 	if (aParam)

 		{

 		param.iPosInText = aParam->iStart;

 		endDraw = Min(aText.Length(),aParam->iEnd);

 		}

 	else

 		{

 		param.iPosInText = 0;

 		}

 	// Draw the text.

 	DoDrawTextVertical(param, aUp, endDraw, clipRect);

 	if(iAutoUpdateJustification)

 		{

 		UpdateJustificationVertical(aText, aParam, aUp);

 		}

 	}

 /**

 Draws vertical text within the clipping area

 @param	aParam		Defines glyph code, ligature creation and diacritic placement 

 @param	aUp			ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.

 @param	aEnd		The end position within the text descriptor to draw.

 @param	aClipRect	The clipping rectangle.

 @pre iFont is a valid CFont.

 @panic	DGDI 13, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 

 		nor ESolidBrush.

 */

 void CDirectGdiContext::DoDrawTextVertical(CFont::TPositionParam& aParam, TBool aUp, const TInt aEnd, TRect& aClipRect)

 	{

 	const CBitmapFont* bitmapFont = iFont.Address();

 	if ((bitmapFont->GlyphBitmapType() == EFourColourBlendGlyphBitmap) && !((iBrushStyle == DirectGdi::ENullBrush) || (iBrushStyle == DirectGdi::ESolidBrush)))

 		{

 		//For future compatibility it is better if brush style of ENullBrush or ESolidBrush is used 

 		//when drawing outline and shadow fonts.

 		GRAPHICS_PANIC_ALWAYS(EDirectGdiPanicInvalidBrushStyle);

 		}

 	TPoint startPen = aParam.iPen;

 	TInt charClipping = aClipRect.iTl.iY;

 	TInt underlineTop = 0;

 	TInt underlineBottom = 0;

 	//for linked fonts need an adjustment to the underline postion

 	TInt underlineStrikeoutOffset = BaselineCorrection();

 	if (iUnderline == DirectGdi::EUnderlineOn)

 		{

 		GetUnderlineMetrics(underlineTop, underlineBottom);

 		underlineTop+=underlineStrikeoutOffset;

 		underlineBottom+=underlineStrikeoutOffset;

 		}

 	TInt strikeTop = 0;

 	TInt strikeBottom = 0;

 	if (iStrikethrough == DirectGdi::EStrikethroughOn)

 		{

 		GetStrikethroughMetrics(strikeTop, strikeBottom);

 		strikeTop+=underlineStrikeoutOffset;

 		strikeBottom+=underlineStrikeoutOffset;

 		}

 	const DirectGdi::TGraphicsRotation rotation = aUp ? DirectGdi::EGraphicsRotation270 : DirectGdi::EGraphicsRotation90;

 	iEngine->BeginDrawGlyph();

 	RShapeInfo shapeInfo;

 	while (aParam.iPosInText < aEnd)

 		{

 		TPoint startPen2 = aParam.iPen;

 		if (!iFont.GetCharacterPosition2(aParam, shapeInfo))

 			{

 			continue;

 			}

 		Rotate(aParam.iPen, startPen2, aUp);

 		TInt adjustment = 0;

 		if(iCharJustExcess && (iCharJustNum > 0)) // character clipping/justification

 			{

 			adjustment = CGraphicsContext::JustificationInPixels(iCharJustExcess, iCharJustNum);

 			if (adjustment < 0)

 				{

 				aClipRect.iTl.iY = aParam.iPen.iY + (aUp ? -adjustment : adjustment);

 				}

 			}

 		CFont::TPositionParam::TOutput* output = aParam.iOutput;

 		for (TInt i = 0; i < aParam.iOutputGlyphs; i++, output++)

 			{

 			Rotate(output->iBounds.iTl, startPen2, aUp);

 			//get the character metrics for the glyph type

 			TOpenFontCharMetrics characterParams;

 			const TUint8* bitmap;

 			TSize size;

 			//note may now be using a glyph code, and not a character

 			iFont.GetCharacterData(aParam.iOutput[i].iCode,characterParams,bitmap,size);

 			TGlyphBitmapType glyphType = characterParams.GlyphType();

 			switch (glyphType)

 				{

 				case EAntiAliasedGlyphBitmap:

 				case EFourColourBlendGlyphBitmap:

 				case EDefaultGlyphBitmap:

 					iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, glyphType, output->iBitmapSize, aClipRect, rotation);

 					break;

 				default:

 					//if the outline or shadow is not specified for the character, then use the font setting

 					iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, bitmapFont->GlyphBitmapType(), output->iBitmapSize, aClipRect, rotation);	 

 					break;

 				}			

 			}

 		aClipRect.iTl.iY = charClipping;

 		if (adjustment)

 			{

 			aParam.iPen.iY += aUp ? -adjustment : adjustment;

 			}

 		if ((iWordJustExcess > 0) && (iWordJustNum > 0) && (aParam.iOutput[0].iCode == 0x0020)) // word justification

 			{

 			adjustment = CGraphicsContext::JustificationInPixels(iWordJustExcess, iWordJustNum);

 			aParam.iPen.iY += aUp ? -adjustment : adjustment;

 			}

 		}

 	iEngine->EndDrawGlyph();

 	if (shapeInfo.IsOpen())

 		{

 		shapeInfo.Close();

 		}

 	if (iUnderline == DirectGdi::EUnderlineOn)

 		{

 		TRect underlineRect; // underline

 		if (aUp)

 			{

 			underlineRect.SetRect(startPen.iX + underlineTop, aParam.iPen.iY, startPen.iX + underlineBottom, startPen.iY + 1);

 			underlineRect.iTl.iY = underlineRect.iBr.iY - underlineRect.Height();

 			}

 		else

 			{

 			underlineRect.SetRect(startPen.iX - underlineBottom, startPen.iY, startPen.iX - underlineTop, aParam.iPen.iY);

 			underlineRect.iBr.iY = underlineRect.iTl.iY + underlineRect.Height();

 			underlineRect.iTl.iX++; // adjust for rect not including last line

 			underlineRect.iBr.iX++;

 			}

 		FillRect(underlineRect, iPenColor, aClipRect);

 		}

 	if (iStrikethrough == DirectGdi::EStrikethroughOn)

 		{

 		TRect strikethroughRect; // strikethrough

 		if (aUp)

 			{

 			strikethroughRect.SetRect(startPen.iX + strikeTop, aParam.iPen.iY, startPen.iX + strikeBottom, startPen.iY + 1);

 			strikethroughRect.iTl.iY = strikethroughRect.iBr.iY - strikethroughRect.Height();

 			}

 		else

 			{

 			strikethroughRect.SetRect(startPen.iX - strikeBottom, startPen.iY, startPen.iX - strikeTop, aParam.iPen.iY);

 			strikethroughRect.iBr.iY = strikethroughRect.iTl.iY + strikethroughRect.Height();

 			strikethroughRect.iTl.iX++;

 			strikethroughRect.iBr.iX++;

 			}

 		FillRect(strikethroughRect, iPenColor, aClipRect);

 		}

 	}

 /**

 Transform a vector, defined by a point relative to an origin, from left-to-right to up or down.

 @param aPoint A point relative to the origin aOrigin.

 @param aOrigin The origin to use when transforming the point aPoint.

 @param aUp If ETrue, then transform the point from left-right to up, otherwise transform from 

 left-right to down.

 */

 void CDirectGdiContext::Rotate(TPoint& aPoint, const TPoint& aOrigin, TBool aUp)

 	{

 	TInt dx = aPoint.iX - aOrigin.iX;

 	TInt dy = aPoint.iY - aOrigin.iY;

 	if (aUp)

 		{

 		aPoint.iX = aOrigin.iX + dy;

 		aPoint.iY = aOrigin.iY - dx;

 		}

 	else

 		{

 		aPoint.iX = aOrigin.iX - dy;

 		aPoint.iY = aOrigin.iY + dx;

 		}

 	}

 /**

 Can be used to find out the top and bottom of an underline for the active font.

 This allows correct calculation of the area required in which to draw text with underline.

 @param	aTop The top of the underline position.

 @param	aBottom The bottom of the underline position.

 */

 void CDirectGdiContext::GetUnderlineMetrics(TInt& aTop, TInt& aBottom)

 	{

 	const TInt width = Max((iFont.HeightInPixels() / 10), 1);

 	aTop = 1 + (width >> 1);

 	aBottom = aTop + width;

 	}

 /**

 Get the top and bottom of a strikethrough line for the current font, relative to the baseline.

 @param	aTop The top of the strikethrough position.

 @param	aBottom The bottom of the strikethrough position.

 */

 void CDirectGdiContext::GetStrikethroughMetrics(TInt& aTop, TInt& aBottom)

 	{

 	aTop = -(iFont.AscentInPixels() * 5/12) - 1;

 	aBottom = aTop + Max((iFont.HeightInPixels() / 10), 1);

 	}

 /**

 Moves the internal drawing position relative to the co-ordinate origin, without drawing a line.

 A subsequent call to DrawLineTo() or DrawLineBy() will then use the new internal drawing position

 as the start point for the line drawn. 

 The operations DrawLine(), DrawLineTo(), DrawLineBy() and DrawPolyline() also change the internal drawing 

 position to the last point of the drawn line(s). The internal drawing position is set to the co-ordinate

 origin if no drawing or moving operations have yet taken place.

 @see	CDirectGdiContext::MoveBy(const TPoint&)

 @param	aPoint The point to move the internal drawing position to.

 @pre	The rendering target has been activated.

 @post	Request to move the internal drawing position to the specified point has been accepted. 

 		There is no guarantee that the request has been processed when the method returns.

 @panic 	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::MoveTo(const TPoint& aPoint)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::MoveTo(%d,%d)", aPoint.iX, aPoint.iY);

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	iEngine->MoveTo(aPoint);

 	}

 /**

 Moves the internal drawing position by a vector, relative to the current position, without drawing a line.

 A subsequent call to DrawLineTo() or DrawLineBy() will then use the new internal drawing position

 as the start point for the line drawn.

 The operations DrawLine(), DrawLineTo(), DrawLineBy() and DrawPolyline() also change the internal drawing 

 position to the last point of the drawn line(s). The internal drawing position is set to the co-ordinate

 origin if no drawing or moving operations have yet taken place.

 @see	CDirectGdiContext::MoveTo(const TPoint&)

 @param	aVector	The vector to move the internal position by.

 @pre	The rendering target has been activated.

 @post	Request to move the internal drawing position by a vector has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic	DGDI 7, if the rendering context has not been activated.

 */

 EXPORT_C void CDirectGdiContext::MoveBy(const TPoint& aVector)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::MoveBy(%d,%d)", aVector.iX, aVector.iY);

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if (aVector != TPoint(0,0))

 		{

 		iEngine->MoveBy(aVector);

 		}

 	}

 /**

 Draws a point at given location using current pen colour and size. 

 If the pen size is greater than 1x1 pixel, a filled circle/ellipse with current pen 

 colour should be drawn with the given position as the centre.

 @param	aPoint The position to plot.

 @pre	The rendering target has been activated.

 @post	Request to draw a point or filled circle/ellipse has been accepted.

 		There is no guarantee that the request has been processed when the method returns.

 @panic 	DGDI 7, if the rendering context has not been activated.

 @see	CDirectGdiContext::SetPenSize(const TSize&)

 @see	CDirectGdiContext::SetPenColor(TRgb)

 @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)

 */

 EXPORT_C void CDirectGdiContext::Plot(const TPoint& aPoint)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::Plot(%d,%d)", aPoint.iX, aPoint.iY);

 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);

 	if (iPenStyle == DirectGdi::ENullPen || iPenSize.iWidth == 0 || iPenSize.iHeight == 0)

 		{

 		return;

 		}	

 	iEngine->Plot(aPoint);

 	}

 /**

 Resets drawing state to its default settings. This operation does not unbind the current target. 

 @pre	None.

 @post	The drawing state is reset to default values. Subsequent drawing will use the default settings until they are changed to different values.

 */

 EXPORT_C void CDirectGdiContext::Reset()

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::Reset");

 	iEngine->Reset();

 	// Explicit calls are made to the engine to apply the defaults. 

 	// Set() methods should generally not be used as they perform unnecessary checks, and may also 

 	// block the call to the engine if the value being set is the same as the constructor's default.	

 	// Clipping regions.

 	iClippingRegion.Clear();

 	iEngine->ResetClippingRegion();

 	// Origin.

 	iOrigin.SetXY(0,0);

 	iEngine->SetOrigin(iOrigin);

 	// Font.

 	iEngine->ResetFont();

 	iFont.Reset();

 	// Text.

 	iLastPrintPosition.SetXY(0,0);

 	iAutoUpdateJustification = ETrue;

 	SetCharJustification(0, 0);

 	SetWordJustification(0, 0);

 	SetStrikethroughStyle(DirectGdi::EStrikethroughOff);

 	SetUnderlineStyle(DirectGdi::EUnderlineOff);

 	// Pen colour.

 	iPenColor = KRgbBlack;

 	iEngine->SetPenColor(iPenColor);

 	// Pen size.

 	iPenSize = TSize(1,1);

 	iEngine->SetPenSize(iPenSize);

 	// Pen style.

 	iPenStyle = DirectGdi::ESolidPen;

 	iEngine->SetPenStyle(iPenStyle);

 	// Draw mode.

 	iDrawMode = DirectGdi::EDrawModePEN;

 	iEngine->SetDrawMode(iDrawMode);

 	// Text shadow colour.

 	iTextShadowColor = KRgbGray;

 	iEngine->SetTextShadowColor(iTextShadowColor);

 	// Brush colour.

 	iBrushColor = KRgbWhite;

 	iEngine->SetBrushColor(iBrushColor);

 	// Brush style.

 	iBrushStyle = DirectGdi::ENullBrush;

 	iEngine->SetBrushStyle(iBrushStyle);

 	// Brush pattern.

 	CleanUpBrushPattern();

 	iEngine->ResetBrushPattern();

 	iBrushPatternUsed = EFalse;

 	// Brush origin.

 	iBrushOrigin.SetXY(0,0);

 	iEngine->SetBrushOrigin(iBrushOrigin);

 	// Internal drawing position.

 	iEngine->MoveTo(TPoint(0,0));

 	}

 /**

 Sets the colour for clearing, filling the area of shapes and the background of text boxes.

 The default brush colour is white. However, the default brush style is ENullBrush, so when drawing 

 to a target the default appears to be the target's background colour.

 @see	CDirectGdiContext::Clear()

 @see	CDirectGdiContext::Clear(const TRect&)

 @see	CDirectGdiContext::DrawRect()

 @see	CDirectGdiContext::DrawRoundRect()

 @see	CDirectGdiContext::DrawPolygon()

 @see	CDirectGdiContext::DrawPie()

 @param	aColor Brush colour.

 @pre	None.

 @post	The new brush colour will be used on subsequent drawing operations if a brush style making 

 		use of the brush colour is used. The new brush colour remains in effect until another SetBrushColor() 

 		with a different parameter is called.

 */

 EXPORT_C void CDirectGdiContext::SetBrushColor(const TRgb& aColor)

 	{

 	GRAPHICS_TRACE1("CDirectGdiContext::SetBrushColor(%d)", aColor.Internal());

 	if (aColor != iBrushColor)

 		{	

 		iBrushColor = aColor;

 		iEngine->SetBrushColor(iBrushColor);

 		}

 	}

 /**

 Sets the brush pattern origin which specifies the start of a pattern tile. 

 Shapes can be considered as a view port into a continuous pattern tile covering the entire 

 area of rendering target. The default origin is TPoint(0,0).

 @see	CDirectGdiContext::SetBrushPattern()

 @param	aOrigin	An origin point for the brush. The coordinates are relative 

 		to the rectangle to fill, i.e. specify TPoint(0,0) to align the pattern flush with 

 		the top and left hand sides of the rectangle.

 @pre	None.

 @post	New brush origin will be used when filling an area with a pattern is used on 

 		subsequent drawing operations. It remains in effect until another SetBrushOrigin()

 		with a different parameter is called.

 */

 EXPORT_C void CDirectGdiContext::SetBrushOrigin(const TPoint& aOrigin)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::SetBrushOrigin(%d,%d)", aOrigin.iX, aOrigin.iY);

 	if (aOrigin != iBrushOrigin)

 		{

 		iBrushOrigin = aOrigin;

 		iEngine->SetBrushOrigin(iBrushOrigin);

 		}

 	}

 /**

 Sets the brush style used when filling the area of shapes and the background of text boxes.

 Use ENullBrush to draw the outline of a fillable shape on its own, without filling.

 The error state is set to KErrArgument if aBrushStyle is an invalid brush style.

 @see    DirectGdi::TBrushStyle

 @param	aBrushStyle The brush style to set.

 @pre	If aBrushStyle is EPatternedBrush, a pattern must have been set first using SetBrushPattern().

 @post	New brush style will be used for subsequent drawing operations, and remains in effect

 		until another SetBrushStyle() with a different parameter is called.

 @panic  DGDI 9, if aBrushStyle is EPatternedBrush but no brush pattern has successfully been set.

 */

 EXPORT_C void CDirectGdiContext::SetBrushStyle(DirectGdi::TBrushStyle aBrushStyle)

 	{

 	GRAPHICS_TRACE1("CDirectGdiContext::SetBrushStyle(%d)", aBrushStyle);

 	if (aBrushStyle < DirectGdi::ENullBrush || aBrushStyle > DirectGdi::EDiamondCrossHatchBrush)

 		{

 		iDriver.SetError(KErrArgument);

 		return;

 		}

 	if (aBrushStyle != iBrushStyle)

 		{

 		GRAPHICS_ASSERT_ALWAYS(aBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);

 		iBrushStyle = aBrushStyle;

 		iEngine->SetBrushStyle(iBrushStyle);

 		}

 	}

 /**

 Sets a clipping region which will be used to clip subsequent rendering operations on the current target.

 This operation is non-additive, any previous clipping region setting is replaced by the new one. A clipping

 region can contain one or more rectangles and is specified in absolute values in the target coordinate system.

 By default (when a target is activated for the first time) no clipping region is set and any drawing 

 operations will be clipped automatically to the full area of the rendering target.

 In the event of a failure, the error state is set to KErrArgument if the given region is invalid or not 

 fully contained within the area of target, otherwise one of the system-wide error codes.

 @see	CDirectGdiContext::ResetClippingRegion()

 @param	aRegion	The new clipping region.

 @pre	Region is not empty and is fully contained within the full area of the target.

 @post	Subsequent rendering operations will be clipped to the given region if there is no error 

 		while performing the operation, otherwise previous clipping region settings will be retained.

 */

 EXPORT_C void CDirectGdiContext::SetClippingRegion(const TRegion& aRegion)

 	{

 	GRAPHICS_TRACE("CDirectGdiContext::SetClippingRegion");

 	if (aRegion.CheckError())

 		{

 		iDriver.SetError(KErrArgument);

 		return;

 		}

 	iClippingRegion.Copy(aRegion);

 	if (iClippingRegion.CheckError())

 		{

 		iDriver.SetError(KErrNoMemory);

 		return;

 		}

 	iEngine->SetClippingRegion(iClippingRegion);

 	}

 /**

 Sets the drawing mode which will affect the way pen and brush colour are used in rendering operations.

 The default drawing mode is EDrawModePEN.

 The error state is set to KErrArgument if aDrawMode is an invalid draw mode.

 @see	DirectGdi::TDrawMode

 @param	aDrawMode The drawing mode.

 @pre	None.

 @post	The new drawing mode will be applied to subsequent rendering operations, and remains in effect

 		until another SetDrawMode() with a different parameter is called.

 */

 EXPORT_C void CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode aDrawMode)

 	{

 	GRAPHICS_TRACE1("CDirectGdiContext::SetDrawMode(%d)", aDrawMode);

 	if (aDrawMode != DirectGdi::EDrawModePEN && aDrawMode != DirectGdi::EDrawModeWriteAlpha)

 		{

 		iDriver.SetError(KErrArgument);

 		return;

 		}

 	if (iDrawMode != aDrawMode)

 		{

 		iDrawMode = aDrawMode;

 		iEngine->SetDrawMode(iDrawMode);

 		}

 	}

 /**

 Sets the origin of the drawing engine coordinate system. By default this is TPoint(0,0) and

 coincides with the origin of the target coordinate system which is at the top-left corner of

 the full area of target. The X value increases from left to right, and Y value increases from

 top to bottom. Integer values are used to represent the position within the coordinate system. 

 All drawing operations are done relative to the engine’s origin. However, the clipping region

 is always specified in absolute coordinate values (using the target coordinate system) and is

 not affected by changes to the drawing engine’s coordinate system origin.

 @param	aPoint The new origin for the drawing engine’s coordinate system.

 @pre	None.

 @post	The origin of the drawing engine’s coordinate system is moved to the given position.

 		All subsequent drawing operations will be done relative to the new origin. The new origin remains

 		in effect until SetOrigin() is called again with a different parameter.

 */

 EXPORT_C void CDirectGdiContext::SetOrigin(const TPoint& aPoint)

 	{

 	GRAPHICS_TRACE2("CDirectGdiContext::SetOrigin(%d,%d)", aPoint.iX, aPoint.iY);

 	if (aPoint != iOrigin)

 		{	

 		iOrigin = aPoint;

 		iEngine->SetOrigin(iOrigin);

 		}

 	}

 /**

 Sets the colour that will be used for drawing lines, outlines of filled shapes and text. The 

 default pen colour is black. For outline and shadow fonts the alpha value of the pen colour will be 

 used for blending the font to the destination.