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