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