sl@0: // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "directgdicontext.h"
sl@0: #include "directgdipaniccodes.h"
sl@0: #include "directgdifont.h"
sl@0: #include "directgdidriver.h"
sl@0: #include <graphics/directgdidrawablesource.h>
sl@0: #include <graphics/directgdiengine.h>
sl@0: #include <e32cmn.h>
sl@0: #include <s32mem.h>
sl@0: #include <shapeinfo.h>
sl@0: #include <fbs.h>
sl@0: #include <fntstore.h>
sl@0: 
sl@0: using namespace DirectGdi;
sl@0: 
sl@0: /**
sl@0: CDirectGdiContext InternalizeL/ExternalizeL - version numbers.
sl@0: Add new version numbers here. A reason of adding new version numbers may be adding new 
sl@0: CDirectGdiContext data members, which may have to be externalized/internalized. 
sl@0: When that happens:
sl@0: 1.Put a new enum item (like EDirectGDIContext_Ver01) with a version number, which is greater than
sl@0: the last version number, that was used. 
sl@0: 2.Document the new enum item.
sl@0: 3.Update KDirectGDIContext_VerNo value to be the new enum item value.
sl@0: 4.Update InternalizeL/ExternalizeL methods after adding the new version number.
sl@0: For example: If a new member is added to the class - TInt iSmth, when InternalizeL
sl@0: is called to operate on older archive, iSmth member won't be in the archive!
sl@0: So, in InternalizeL, there should be a check, something like:
sl@0: TUint16 archiveVerNo = 0;
sl@0: 	aReadStream >> archiveVerNo;
sl@0:     if(archiveVerNo < EDirectGDIContext_Ver02)   //EDirectGDIContext_Ver02 has been added, when iSmth has been added
sl@0: 		{
sl@0:       	//Do nothing - iSmth is not in the archive
sl@0:       	//Initialize it with some default value
sl@0:       	iSmth = KDefVal;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		aReadStream >> iSmth;
sl@0: 		}
sl@0: */
sl@0: enum
sl@0: 	{
sl@0: 	EDirectGDIContext_Ver01 = 1 //Base version number, when InternalizeL/ExternalizeL were added
sl@0: 	};
sl@0: 
sl@0: LOCAL_D const TUint16 KDirectGDIContext_VerNo = EDirectGDIContext_Ver01;
sl@0: 
sl@0: /**
sl@0: Static two-phase factory constuctor. Creates an object of this class.
sl@0: 
sl@0: @param	aDirectGdiDriver	The driver object which provides an abstract factory for creating a concrete drawing engine.
sl@0: 
sl@0: @pre	CDirectGdiDriver object has been initialised from the calling thread.
sl@0: @post	Instances of CDirectGdiContext and MDirectGdiEngine have been created.
sl@0: 
sl@0: @leave	Leaves if CDirectGdiDriver has not been initialised from the calling thread, or other errors occur during object construction.
sl@0: @return	Reference to constructed CDirectGdiContext.
sl@0: */
sl@0: EXPORT_C CDirectGdiContext* CDirectGdiContext::NewL(CDirectGdiDriver& aDirectGdiDriver)
sl@0: 	{
sl@0: 	CDirectGdiContext* result = new(ELeave) CDirectGdiContext(aDirectGdiDriver);
sl@0: 	CleanupStack::PushL(result);
sl@0: 
sl@0: 	// Cache a reference to the driver locally, so that we do not need to use
sl@0: 	// the singleton accessor all the time. The singleton accessor utilises TLS
sl@0: 	// and hence incurs a performance penalty.
sl@0: 	//
sl@0: 	result->ConstructL();
sl@0: 
sl@0: 	CleanupStack::Pop();
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Installs a rendering engine instance from the supplied driver, records
sl@0: a reference to the driver (for use by the destructor), and initialises it.
sl@0: 
sl@0: @pre	Invoked by NewL().
sl@0: @post	Instance of MDirectGdiEngine has been created.
sl@0: 
sl@0: @leave	If CDirectGdiDriver::CreateEngine() returns an error code.
sl@0: */
sl@0: void CDirectGdiContext::ConstructL()
sl@0: 	{
sl@0: 	User::LeaveIfError(iDriver.CreateEngine(iEngine));
sl@0: 	Reset();	// Initialise context and engine to default values.
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Object constructor. Declared private for better encapsulation. A factory method is 
sl@0: provided to instantiate this class. This class is not intended for derivation. Binary
sl@0: compatibility needs to be maintained.
sl@0: 
sl@0: @param	aDirectGdiDriver The driver that coordinates management of DirectGDI resources.
sl@0: 
sl@0: @pre	The driver must be initialised.
sl@0: @post	None.
sl@0: */
sl@0: EXPORT_C CDirectGdiContext::CDirectGdiContext(CDirectGdiDriver& aDirectGdiDriver) :
sl@0: 	iDriver(aDirectGdiDriver)	
sl@0: 	{	
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Unbind current target from drawing context and mark drawing engine for deletion.
sl@0: 
sl@0: @pre	None.
sl@0: @post	Rendering engine has had targets unbound and is marked for deletion.
sl@0: */
sl@0: EXPORT_C CDirectGdiContext::~CDirectGdiContext()
sl@0: 	{
sl@0: 	// If an engine has been bound, destroy it through the driver.
sl@0: 	if (iEngine)
sl@0: 		{
sl@0: 		iDriver.DestroyEngine(iEngine);
sl@0: 		}
sl@0: 
sl@0: 	CleanUpBrushPattern();
sl@0: 	iClippingRegion.Close();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Binds a rendering target to this drawing context.
sl@0: 
sl@0: Subsequent rendering operations after calling this method will apply to the new rendering
sl@0: target. The clipping region will be reset to none, in other words drawing will be clipped to the 
sl@0: full area of the new target by default, other context states such as pen or brush colour,
sl@0: font, etc. will remain unchanged.
sl@0: 
sl@0: This operation could fail, DirectGDI clients should always check the return value when 
sl@0: calling this method. The error state is not modified by this function.
sl@0: 
sl@0: @param	aTarget	DirectGDI rendering target.
sl@0: 
sl@0: @pre	Rendering target has been fully constructed.
sl@0: @post	The drawing context is bound to the new rendering target.
sl@0: 
sl@0: @return	KErrNone if successful, KErrNotSupported if target is incompatible with the drawing context,
sl@0: 		otherwise one of the system-wide error codes.
sl@0: */
sl@0: EXPORT_C TInt CDirectGdiContext::Activate(RDirectGdiImageTarget& aTarget)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::Activate");	
sl@0: 	TInt err = iEngine->Activate(aTarget);
sl@0: 	
sl@0: 	iActivated = EFalse;
sl@0: 	if (err == KErrNone)
sl@0: 		{
sl@0: 		iActivated = ETrue;
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Disables AutoUpdateJustification state. 
sl@0: 
sl@0: @see CDirectGdiContext::SetJustifyAutoUpdate
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::NoJustifyAutoUpdate()
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::NoJustifyAutoUpdate");
sl@0: 	iAutoUpdateJustification = EFalse;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Enables AutoUpdateJustification state. 
sl@0: During the text drawing, some text parameters which impact on positioning the text on the screen will be updated and applied 
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetJustifyAutoUpdate()
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::SetJustifyAutoUpdate");
sl@0: 	iAutoUpdateJustification = ETrue;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Draws the whole of a CFbsBitmap. Calls BitBlt() with a rectangle set to the extents of aBitmap.
sl@0: 
sl@0: No scaling or stretching is involved. The current clipping region and drawing mode apply. The
sl@0: source bitmap can reside in system memory or ROM. Bitmaps in system memory may be compressed
sl@0: using RLE or Palette compression, and can be in any supported display mode. Please refer to
sl@0: CFbsBitmap documentation for more details.
sl@0: 
sl@0: If the client modifies the content of the bitmap after issuing a BitBlt() command, the method
sl@0: does not guarantee whether the old bitmap content or the new one will be drawn. Clients must call
sl@0: Finish() on the driver before modifying the bitmap content if they want a guaranteed result that 
sl@0: the previously issued BitBlt() will draw the old bitmap content.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @see	void CDirectGdiContext::BitBlt(const TPoint& aPoint, const CFbsBitmap* aBitmap, const TRect& aSourceRect);
sl@0: @param	aDestPos		The position to draw the top left corner of the bitmap.
sl@0: @param	aSourceBitmap	The source bitmap. 
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw the bitmap content has been accepted. There is no guarantee that the request
sl@0: 		has been processed when the method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::BitBlt(const TPoint& aDestPos, const CFbsBitmap& aSourceBitmap)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::BitBlt(%d,%d)", aDestPos.iX, aDestPos.iY);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	
sl@0: 	if (ValidateBitmap (aSourceBitmap))
sl@0: 		{
sl@0: 		iEngine->BitBlt(aDestPos, aSourceBitmap, TRect(aSourceBitmap.SizeInPixels()));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** 
sl@0: Draws a particular rectangle from a CFbsBitmap via bitmap block image transfer. 
sl@0: The bitmap content is specified by the given source rectangle. The bitmap content is drawn 
sl@0: into the rendering target starting from the given destination position. To draw the content
sl@0: of the entire bitmap, a source rectangle TRect(TPoint(0,0), aBitmap.SizeInPixels()) is used. 
sl@0: 
sl@0: The source rectangle is intersected with the source bitmap’s full extent, and the intersection
sl@0: will become the effective value of the source rectangle.
sl@0: 
sl@0: No scaling or stretching is involved. The current clipping region and drawing mode apply. The
sl@0: source bitmap can reside in system memory or ROM. Bitmaps in system memory may be compressed
sl@0: using RLE or Palette compression, and can be in any supported display mode. Please refer to
sl@0: CFbsBitmap documentation for more details.
sl@0: 
sl@0: The bitmap is not guaranteed to continue to exist outside the implementation of this method, for example
sl@0: DirectGDI clients may delete the bitmap immediately after issuing a BitBlt() command. The adaptation
sl@0: must maintain its own copy by duplicating the bitmap if access to the bitmap data is required
sl@0: later on, for example outside this method implementation. Duplicating the bitmap will increase its
sl@0: reference counter and will prevent the object from being destroyed by Fbserv. The adaptation
sl@0: must make sure the bitmap copy is destroyed when it is no longer needed.
sl@0: 
sl@0: If the client modifies the content of the bitmap after issuing BitBlt() command, the method
sl@0: does not guarantee whether the old bitmap content or the new one will be drawn. Clients must call
sl@0: Finish() on the driver before modifying the bitmap content if they want a guaranteed result that 
sl@0: the previously issued BitBlt() will draw the old bitmap content.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @param	aDestPos		The position to draw the top left corner of the bitmap (destination position).
sl@0: @param	aSourceBitmap	The source bitmap.
sl@0: @param	aSourceRect		A rectangle defining the piece of the source to be drawn. No image data 
sl@0: 						is transferred if no intersection exists with the bitmap.  
sl@0: 						NOTE: The top and left hand edges are inclusive, the bottom and 
sl@0: 						right hand edge are exclusive.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw the bitmap content has been accepted. There is no guarantee that the request
sl@0: 		has been processed when the method returns.
sl@0: 
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::BitBlt(
sl@0: 		const TPoint& aDestPos, 
sl@0: 		const CFbsBitmap& aSourceBitmap, 
sl@0: 		const TRect& aSourceRect)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::BitBlt(%d,%d)", aDestPos.iX, aDestPos.iY);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	
sl@0: 	if (ValidateBitmap(aSourceBitmap))
sl@0: 		{
sl@0: 		TRect sourceRect = IntersectBitmapWithRect(aSourceBitmap, aSourceRect);		
sl@0: 		if (!sourceRect.IsEmpty())
sl@0: 			{
sl@0: 			iEngine->BitBlt(aDestPos, aSourceBitmap, sourceRect);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Validates a specified bitmap image. 
sl@0: The bitmap is deemed invalid if its associated handle equals KNullHandle or it 
sl@0: has a width or height of zero.
sl@0: 
sl@0: The following errors are set in iDirectGdiDriver if the associated conditions are met:
sl@0: 	- KErrBadHandle if the handle associated with the bitmap equals KNullHandle.
sl@0: 	- KErrArgument is the bitmaps width or height is zero.
sl@0: 
sl@0: @param aBitmap The bitmap to validate.
sl@0: 
sl@0: @return ETrue if the specified bitmap is valid, otherwise EFalse.
sl@0: */
sl@0: TBool CDirectGdiContext::ValidateBitmap(const CFbsBitmap& aBitmap)
sl@0: 	{
sl@0: 	TInt errorCode = KErrNone;
sl@0: 	TBool result = ETrue;
sl@0: 
sl@0: 	if (aBitmap.Handle() == KNullHandle)
sl@0: 		{
sl@0: 		errorCode = KErrBadHandle;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// Check that mask and source bitmap have width and height.
sl@0: 		const TSize bitmapSize = aBitmap.SizeInPixels();
sl@0: 		if (!bitmapSize.iWidth || !bitmapSize.iHeight)
sl@0: 			{
sl@0: 			errorCode = KErrArgument;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	if (errorCode != KErrNone)
sl@0: 		{
sl@0: 		iDriver.SetError(errorCode);	
sl@0: 		result = EFalse;
sl@0: 		}
sl@0: 
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: /*
sl@0: Returns a TRect that intersects both the CFbsBitmap and the passed-in TRect.
sl@0: 
sl@0: @param aBitmap The bitmap to intersect with.
sl@0: @param aRect The TRect object that is overlapping the bitmap.
sl@0: @return A TRect that represents the intersection of the two. If the two do not intersect,
sl@0:         it will be an empty TRect object.
sl@0: */
sl@0: TRect CDirectGdiContext::IntersectBitmapWithRect(const CFbsBitmap& aBitmap, const TRect& aRect) const
sl@0: 	{
sl@0: 	TRect result = TRect(aBitmap.SizeInPixels());
sl@0: 	
sl@0: 	if (aRect == result)
sl@0: 		return result;
sl@0: 	
sl@0: 	if (result.Intersects(aRect))
sl@0: 		{
sl@0: 		result.Intersection(aRect);
sl@0: 		return result;
sl@0: 		}
sl@0: 	
sl@0: 	return TRect(0,0,0,0);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: 
sl@0: Validates the specified source bitmap and mask pair.
sl@0: First validates the source and mask bitmaps individually, and then checks for valid
sl@0: bitmap pairings. The only pairing not supported is: EGray256 masks and sources with 
sl@0: an alpha-channel when using EDrawModeWriteAlpha.
sl@0:  
sl@0: @see CDirectGdiContext::ValidateBitmap()
sl@0: 
sl@0: The following errors are set in iDirectGdiDriver if the associated conditions are met:
sl@0: 	- KErrBadHandle if the handle associated with either bitmap equals KNullHandle.
sl@0: 	- KErrArgument if either bitmaps width or height is zero.
sl@0: 	- KErrArgument if the mask format is EGray256 and the source contains an alpha-channel and draw mode is EDrawModeWriteAlpha.
sl@0:  
sl@0: @param aSourceBitmap 	The source bitmap to validate.
sl@0: @param aMaskBitmap 		The mask to validate.
sl@0:  
sl@0: @return ETrue if the specified bitmaps is valid, otherwise EFalse.	
sl@0: */
sl@0: TBool CDirectGdiContext::ValidateSourceAndMaskBitmaps(const CFbsBitmap& aSourceBitmap, const CFbsBitmap& aMaskBitmap)
sl@0: 	{
sl@0: 	TInt errorCode = KErrNone;
sl@0: 	TBool result = ETrue;
sl@0: 	
sl@0: 	if (ValidateBitmap (aSourceBitmap) && ValidateBitmap (aMaskBitmap))
sl@0: 		{
sl@0: 		TDisplayMode sourceBitmapDisplayMode = aSourceBitmap.DisplayMode();
sl@0: 	
sl@0: 		// We do not currently support EGray256 masks and sources with an alpha-channel
sl@0: 		// with EDrawModeWriteAlpha.
sl@0: 		if ((iDrawMode == DirectGdi::EDrawModeWriteAlpha) &&
sl@0: 			(aMaskBitmap.DisplayMode() == EGray256) &&
sl@0: 			((sourceBitmapDisplayMode == EColor16MA) || (sourceBitmapDisplayMode == EColor16MAP)))
sl@0: 			{
sl@0: 			errorCode = KErrArgument;
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		result = EFalse;
sl@0: 		}
sl@0: 	
sl@0: 	if (errorCode != KErrNone)
sl@0: 		{
sl@0: 		iDriver.SetError(errorCode);	
sl@0: 		result = EFalse;
sl@0: 		}
sl@0: 	
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Helper method for performing BitBltMasked.
sl@0: Note that aInvertMask is ignored if aMaskPos is not at 0,0.
sl@0: 
sl@0: @see	CDirectGdiContext::BitBlt(const TPoint& aPoint, const CFbsBitmap& aBitmap, const TRect& aSourceRect);
sl@0: @see	CDirectGdiContext::BitBltMasked(const TPoint&, const CFbsBitmap&,const TRect&, const CFbsBitmap&, const TPoint&);
sl@0: 
sl@0: @param	aDestPos		The destination for the top left corner of the transferred bitmap. 
sl@0: 						It is relative to the top left corner of the destination bitmap, which may be the screen. 
sl@0: @param	aSourceBitmap	A memory-resident source bitmap.
sl@0: @param	aSourceRect		A rectangle defining the piece of the bitmap to be drawn, 
sl@0: 						with co-ordinates relative to the top left corner of the bitmap. 
sl@0: @param	aMaskBitmap		Mask bitmap.
sl@0: @param	aInvertMask		If EFalse, a source pixel that is masked by a black pixel is not transferred to 
sl@0: 						the destination rectangle. If ETrue, then a source pixel that is masked by a 
sl@0: 						white pixel is not transferred to the destination rectangle. If alpha blending
sl@0: 						is used instead of masking, this flag is ignored and no inversion takes place.
sl@0: 						Note that this parameter is ignored if aMaskPos does not equal TPoint(0,0).
sl@0: @param	aMaskPos		The point on the mask bitmap to use as the top left corner 
sl@0: */
sl@0: void CDirectGdiContext::DoBitBltMasked(
sl@0: 		const TPoint& aDestPos,
sl@0: 		const CFbsBitmap& aSourceBitmap,
sl@0: 		const TRect& aSourceRect,
sl@0: 		const CFbsBitmap& aMaskBitmap,
sl@0: 		TBool aInvertMask,
sl@0: 		const TPoint& aMaskPos)
sl@0: 	{
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	
sl@0: 	if (ValidateSourceAndMaskBitmaps(aSourceBitmap, aMaskBitmap))
sl@0: 		{
sl@0: 		// If the source rectangle does not intersect aBitmap, do nothing.
sl@0: 		TRect sourceRect = IntersectBitmapWithRect(aSourceBitmap, aSourceRect);
sl@0: 		if (!sourceRect.IsEmpty())
sl@0: 			{
sl@0: 			if (aMaskPos == TPoint(0, 0))
sl@0: 				{
sl@0: 				iEngine->BitBltMasked(aDestPos, aSourceBitmap, sourceRect, aMaskBitmap, aInvertMask);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				TSize maskSize = aMaskBitmap.SizeInPixels();
sl@0: 				// Convert negative or large mask offsets into sensible positive ones for tiling.
sl@0: 				TPoint maskOffset(aMaskPos.iX % maskSize.iWidth, aMaskPos.iY % maskSize.iHeight);
sl@0: 				if (maskOffset.iX < 0) 
sl@0: 					maskOffset.iX += maskSize.iWidth;
sl@0: 				if (maskOffset.iY < 0) 
sl@0: 					maskOffset.iY += maskSize.iHeight;
sl@0: 
sl@0: 				iEngine->BitBltMasked(aDestPos, aSourceBitmap, sourceRect, aMaskBitmap, maskOffset);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Performs a masked bitmap block transfer. Source rectangle operates in a similar way to BitBlt().
sl@0: 
sl@0: This function uses either a black and white (binary) mask bitmap, or if the mask's display mode is 
sl@0: EGray256, alpha blending is used. The result is undefined if the mask pixel value is neither black nor 
sl@0: white and the mask display mode is other than EGray256.
sl@0: 
sl@0: The mask is aligned with the source bitmap by aligning the first pixel of the mask and source bitmaps within
sl@0: the source rectangle. Tiling in both directions applies if the mask size is smaller than the source rectangle.
sl@0: Note that the mask is applied before the piece of the bitmap is defined - the mask is tiled relative to the 
sl@0: top left of the original source bitmap rather than the top left of the bitmap piece. If the mask has zero
sl@0: width or height, the error state is set to KErrArgument and no drawing is performed.
sl@0: 
sl@0: The mask bitmap can be used as either a positive or negative mask. Masked pixels are not mapped to the 
sl@0: destination rectangle.
sl@0: 
sl@0: If the client modifies the contents of the bitmap or the mask after issuing the BitBltMasked() command, the
sl@0: method does not guarantee whether the old bitmap or mask contents, or the new ones will be used. 
sl@0: Clients must call Finish() on the driver before modifying the bitmap or mask contents if they want a 
sl@0: guaranteed  result that the previously issued BitBltMasked() will be using the old bitmap or mask contents.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @see	CDirectGdiContext::BitBlt(const TPoint& aPoint, const CFbsBitmap& aBitmap, const TRect& aSourceRect);
sl@0: @see	CDirectGdiContext::BitBltMasked(const TPoint&, const CFbsBitmap&,const TRect&, const CFbsBitmap&, const TPoint&);
sl@0: 
sl@0: @param	aDestPos		The destination for the top left corner of the transferred bitmap. 
sl@0: 						It is relative to the top left corner of the destination bitmap, which may be the screen. 
sl@0: @param	aSourceBitmap	A memory-resident source bitmap.
sl@0: @param	aSourceRect		A rectangle defining the piece of the bitmap to be drawn, 
sl@0: 						with co-ordinates relative to the top left corner of the bitmap. 
sl@0: @param	aMaskBitmap		Mask bitmap.
sl@0: @param	aInvertMask		If EFalse, a source pixel that is masked by a black pixel is not transferred to 
sl@0: 						the destination rectangle. If ETrue, then a source pixel that is masked by a 
sl@0: 						white pixel is not transferred to the destination rectangle. If alpha blending
sl@0: 						is used instead of masking, this flag is ignored and no inversion takes place.
sl@0: 
sl@0: @pre	The rendering target has been activated. aBitmap and aMask hold valid handles.
sl@0: @post	Request to draw the masked bitmap content has been accepted. 
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::BitBltMasked(
sl@0: 		const TPoint& aDestPos,
sl@0: 		const CFbsBitmap& aSourceBitmap,
sl@0: 		const TRect& aSourceRect,
sl@0: 		const CFbsBitmap& aMaskBitmap,
sl@0: 		TBool aInvertMask)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::BitBltMasked(%d,%d)", aDestPos.iX, aDestPos.iY);
sl@0: 	DoBitBltMasked (aDestPos, aSourceBitmap, aSourceRect, aMaskBitmap, aInvertMask, TPoint(0, 0));
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Performs a masked bitmap block transfer. Source rectangle operates in a similar way to BitBlt().
sl@0: 
sl@0: This function uses either a black and white (binary) mask bitmap, or if aMaskBitmap's display mode is 
sl@0: EGray256, alpha blending is used. The result is undefined if the mask pixel value is neither black nor 
sl@0: white and the mask display mode is other than EGray256.
sl@0: 
sl@0: The source rectangle is intersected with the source bitmap’s full extent and the intersection
sl@0: will become the effective value. The mask bitmap is aligned with the source bitmap by aligning
sl@0: its pixel at the position specified in aMaskPt with the first pixel of the source bitmap
sl@0: within the source rectangle. The mask bitmap will be tiled if it is smaller than the source
sl@0: rectangle. If the mask has zero width or height, the error state is set to KErrArgument and 
sl@0: no drawing is performed.
sl@0: 
sl@0: If the client modifies the contents of the bitmap or the mask after issuing the BitBltMasked() command, the
sl@0: method does not guarantee whether the old bitmap or mask contents, or the new ones will be used. 
sl@0: Clients must call Finish() on the driver before modifying the bitmap or mask contents if they want a 
sl@0: guaranteed  result that the previously issued BitBltMasked() will be using the old bitmap or mask contents.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @see	CDirectGdiContext::BitBlt(const TPoint& aPoint, const CFbsBitmap& aBitmap, const TRect& aSourceRect);
sl@0: @see	CDirectGdiContext::BitBltMasked(const TPoint&, const CFbsBitmap&,const TRect&, const CFbsBitmap&, TBool);
sl@0: 
sl@0: @param	aDestPos		The destination for the top left corner of the transferred bitmap. 
sl@0: 						It is relative to the top left corner of the destination bitmap, which may be the screen. 
sl@0: @param	aSourceBitmap	A memory-resident source bitmap.
sl@0: @param	aSourceRect		A rectangle defining the piece of the bitmap to be drawn, 
sl@0: 						with co-ordinates relative to the top left corner of the bitmap. 
sl@0: @param	aMaskBitmap		Mask bitmap.
sl@0: @param	aMaskPos		The point on the mask bitmap to use as the top left corner 
sl@0: 
sl@0: @pre	The rendering target has been activated. aBitmap and aMask hold valid handles.
sl@0: @post	Request to draw the masked bitmap content has been accepted. 
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 
sl@0: @panic	DGDI 7, if no context is activated
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::BitBltMasked(
sl@0: 		const TPoint& aDestPos,
sl@0: 		const CFbsBitmap& aSourceBitmap,
sl@0: 		const TRect& aSourceRect,
sl@0: 		const CFbsBitmap& aMaskBitmap,
sl@0: 		const TPoint& aMaskPos)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::BitBltMasked(%d,%d)", aDestPos.iX, aDestPos.iY);
sl@0: 	DoBitBltMasked (aDestPos, aSourceBitmap, aSourceRect, aMaskBitmap, EFalse, aMaskPos);		
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Resets the current clipping region to none.
sl@0: 
sl@0: @see    CDirectGdiContext::SetClippingRegion(const TRegion&)
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Clipping region is reset to none. Subsequent rendering operations on current target will be clipped to the
sl@0: 		full area of the target.
sl@0: 
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::ResetClippingRegion()
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::ResetClippingRegion");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	iClippingRegion.Clear();
sl@0: 	iEngine->ResetClippingRegion();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Clears the entire target area with the current brush colour. The area is filled 
sl@0: as if ESolidBrush is used. Current clipping region and drawing mode apply.
sl@0: 
sl@0: @see	CDirectGdiContext::Clear(const TRect&)
sl@0: @see	CDirectGdiContext::SetBrushColor(TRgb)
sl@0: @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)
sl@0: @see	CDirectGdiContext::SetClippingRegion(const TRegion& aRegion)
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to clear given rectangular area (clipped to current clipping region) 
sl@0: 		has been accepted. There is no guarantee that the request has been processed 
sl@0: 		when the method returns.
sl@0: 
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::Clear()
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::Clear");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	iEngine->Clear();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Clears the given rectangular area with current brush colour. The area is filled 
sl@0: as if ESolidBrush is used. Current clipping region and drawing mode apply.
sl@0: 
sl@0: @see	CDirectGdiContext::Clear()
sl@0: @see	CDirectGdiContext::SetBrushColor(TRgb)
sl@0: @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)
sl@0: @see	CDirectGdiContext::SetClippingRegion(const TRegion&)
sl@0: 
sl@0: @param	aRect Area to be cleared.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to clear given rectangular area (clipped to current clipping region) has been accepted. 
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::Clear(const TRect& aRect)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::Clear(%d,%d)", aRect.Width(), aRect.Height());
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	if(aRect.Width() <= 0 || aRect.Height() <= 0)
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	iEngine->Clear(aRect);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Resets the bitmap brush pattern to none. If the current brush style is EPatternedBrush, the brush
sl@0: style will be set to ENullBrush.
sl@0: 
sl@0: @see	CDirectGdiContext::SetBrushPattern(const CFbsBitmap&)
sl@0: 
sl@0: @pre	None.
sl@0: @post	The bitmap brush pattern is no longer used.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::ResetBrushPattern()
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::ResetBrushPattern");
sl@0: 	CleanUpBrushPattern();
sl@0: 	if (iBrushStyle == DirectGdi::EPatternedBrush)
sl@0: 		{
sl@0: 		iBrushStyle = DirectGdi::ENullBrush;
sl@0: 		iEngine->SetBrushStyle(iBrushStyle);
sl@0: 		}
sl@0: 	iEngine->ResetBrushPattern();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Releases the selected font for this context.
sl@0: 
sl@0: @pre	None.
sl@0: @post	Internal resources previously allocated during SetFont() are released.
sl@0: 
sl@0: @see	CDirectGdiContext::SetFont()
sl@0: @see	CGraphicsContext::DiscardFont()
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::ResetFont()
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::ResetFont");
sl@0: 	iEngine->ResetFont();
sl@0: 	iFont.Reset();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws an arc. An arc is a segment of an ellipse which is defined by a given rectangle. The arc is drawn 
sl@0: anti-clockwise from the arc start point to the arc end point. The arc start point is the intersection  
sl@0: between vectors from the centre of the ellipse to the given start position and the ellipse. 
sl@0: Arc end point is defined in the same way.
sl@0: 
sl@0: @param	aRect	The rectangle which defines where to draw the ellipse.
sl@0: @param	aStart	Position to be used in defining the arc start point.
sl@0: @param	aEnd	Position to be used in defining the arc end point.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw an arc has been accepted. There is no guarantee that the request 
sl@0: 		has been processed when the method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: 
sl@0: @see	CDirectGdiContext::DrawPie(const TRect&, const TPoint&, const TPoint&)
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawArc");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	if (aRect.IsEmpty() || iPenStyle == DirectGdi::ENullPen || (iPenSize.iWidth == 0) || (iPenSize.iHeight == 0))
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	iEngine->DrawArc(aRect, aStart, aEnd);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws and fills a pie. A pie is a shape defined by an arc from the ellipse and straight lines 
sl@0: from the centre of the ellipse to the arc start and end position. 
sl@0: 
sl@0: @param	aRect	The rectangle which defines where to draw the ellipse
sl@0: @param	aStart	Position to be used in defining the arc start point
sl@0: @param	aEnd	Position to be used in defining the arc end point
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw a pie has been accepted. There is no guarantee that the request 
sl@0: 		has been processed when the method returns.
sl@0: 
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.
sl@0: 
sl@0: @see	CDirectGdiContext::DrawArc(const TRect&, const TPoint&, const TPoint&)
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawPie");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);
sl@0: 	
sl@0: 	if (aRect.IsEmpty())
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	iEngine->DrawPie(aRect, aStart, aEnd);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Draws the bitmap contents into the destination rectangle. Scaling applies when 
sl@0: the extents of the source bitmap and the destination rectangle do not match.
sl@0: If the source rectangle is not completely contained within the source 
sl@0: bitmap's extents, no drawing will take place.
sl@0: 
sl@0: If the client modifies the content of the bitmap after issuing a DrawBitmap() command,
sl@0: the method does not guarantee that the old bitmap content or the new one
sl@0: will be drawn. Clients must call Finish() on the driver before modifying the bitmap 
sl@0: content if they want a guarantee that the previously issued DrawBitmap() will draw the
sl@0: old bitmap content.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @see CDirectGdiContext::DrawBitmap(const TRect&, const CFbsBitmap&, const TRect&)
sl@0: 
sl@0: @param	aDestRect Destination rectangle.
sl@0: @param	aSourceBitmap Source bitmap.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw the bitmap content has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawBitmap(const TRect& aDestRect, const CFbsBitmap& aSourceBitmap)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::DrawBitmap(%d,%d)", aDestRect.iTl.iX, aDestRect.iTl.iY);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	if (ValidateBitmap (aSourceBitmap))
sl@0: 		{
sl@0: 		DrawBitmap(aDestRect, aSourceBitmap,TRect(TPoint(0, 0), aSourceBitmap.SizeInPixels()));		
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Draws the bitmap contents into the destination rectangle. Scaling applies when 
sl@0: the destination and source rectangles do not match. The source bitmap may be 
sl@0: compressed. The destination rectangle will be clipped with the current clipping 
sl@0: region. If the source rectangle is not completely contained within the source 
sl@0: bitmap's extents, no drawing will take place.
sl@0: 
sl@0: If the client modifies the content of the bitmap after issuing a DrawBitmap() command,
sl@0: the method does not guarantee that the old bitmap content or the new one
sl@0: will be drawn. Clients must call Finish() on the driver before modifying the bitmap 
sl@0: content if they want a guarantee that the previously issued DrawBitmap() will draw the
sl@0: old bitmap content.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @see CDirectGdiContext::DrawBitmap(const TRect&, const CFbsBitmap&)
sl@0: 
sl@0: @param	aDestRect		Destination rectangle.
sl@0: @param	aSourceBitmap	Source bitmap.
sl@0: @param	aSourceRect		Rectangle specifying the area of the source bitmap to be drawn.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw the bitmap content has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawBitmap(const TRect& aDestRect, const CFbsBitmap& aSourceBitmap, const TRect& aSourceRect)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::DrawBitmap(%d,%d)", aDestRect.iTl.iX, aDestRect.iTl.iY);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 
sl@0: 	if (ValidateBitmap(aSourceBitmap))
sl@0: 		{
sl@0: 		TSize sourceSize = aSourceBitmap.SizeInPixels();
sl@0: 		// If source rectangle is not fully contained by the extents of the source bitmap,
sl@0: 		// or the size of the source bitmap is zero, do nothing.
sl@0: 		if (aSourceRect.iTl.iX >= 0 &&
sl@0: 			aSourceRect.iTl.iY >= 0 &&
sl@0: 			aSourceRect.iBr.iX <= sourceSize.iWidth &&
sl@0: 			aSourceRect.iBr.iY <= sourceSize.iHeight &&
sl@0: 			!aDestRect.IsEmpty() && !aSourceRect.IsEmpty())
sl@0: 			{
sl@0: 			iEngine->DrawBitmap(aDestRect, aSourceBitmap, aSourceRect);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws bitmap content with masking. Scaling applies to both the source bitmap and the mask. 
sl@0: Both the source and the mask bitmap may be compressed. The destination and source rectangles
sl@0: operate in a similar way to DrawBitmap().
sl@0: 
sl@0: This function uses either a black and white (binary) mask bitmap, or if the mask's display mode is 
sl@0: EGray256, alpha blending is used. The result is undefined if the mask pixel value is neither black nor 
sl@0: white and the mask display mode is other than EGray256.
sl@0: 
sl@0: The mask is aligned with the source bitmap by aligning their first pixels within the source 
sl@0: rectangle. If the mask size is greater than or equal to the source bitmap size, it will be 
sl@0: scaled to fit the destination rectangle in the same way the source bitmap is scaled. 
sl@0: If the mask has zero width or height, the error state is set to KErrArgument and no drawing is performed.
sl@0: 
sl@0: If the mask is smaller than the source bitmap, it will be tiled to fit the source bitmap size, 
sl@0: and then scaled to fit the destination rectangle.
sl@0: 
sl@0: If the client modifies the content of the bitmap or mask after issuing a DrawBitmapMasked() command,
sl@0: the method does not guarantee whether the old bitmap or mask contents, or the new ones
sl@0: will be used. Clients must call Finish() on the driver before modifying the bitmap or mask contents 
sl@0: if they want a guaranteed result that the previously issued DrawBitmapMasked() will be using the old 
sl@0: bitmap or mask contents.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @param	aDestRect		Destination rectangle.
sl@0: @param	aSourceBitmap	Source bitmap.
sl@0: @param	aSourceRect		Rectangle specifying the area of the source bitmap to be drawn.
sl@0: @param	aMaskBitmap		Mask bitmap.
sl@0: @param	aInvertMask		If EFalse, a source pixel that is masked by a black pixel is not transferred to 
sl@0: 						the destination rectangle. If ETrue, then a source pixel that is masked by a 
sl@0: 						white pixel is not transferred to the destination rectangle. If alpha blending
sl@0: 						is used instead of masking, this flag is ignored and no inversion takes place.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw the bitmap content with masking has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawBitmapMasked(
sl@0: 		const TRect& aDestRect,
sl@0: 		const CFbsBitmap& aSourceBitmap,
sl@0: 		const TRect& aSourceRect,
sl@0: 		const CFbsBitmap& aMaskBitmap,
sl@0: 		TBool aInvertMask)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::DrawBitmapMasked(%d,%d)", aDestRect.iTl.iX, aDestRect.iTl.iY);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 
sl@0: 	if (ValidateSourceAndMaskBitmaps(aSourceBitmap, aMaskBitmap))
sl@0: 		{
sl@0: 		TSize sourceSize = aSourceBitmap.SizeInPixels();
sl@0: 		// Ensure source rect is fully within bounds of bitmap extents and
sl@0: 		// dest and source rect are not empty. 
sl@0: 		if (aSourceRect.iTl.iX >= 0 &&
sl@0: 			aSourceRect.iTl.iY >= 0 &&
sl@0: 			aSourceRect.iBr.iX <= sourceSize.iWidth &&
sl@0: 			aSourceRect.iBr.iY <= sourceSize.iHeight &&
sl@0: 			!aDestRect.IsEmpty() && !aSourceRect.IsEmpty())
sl@0: 			{
sl@0: 			iEngine->DrawBitmapMasked(aDestRect, aSourceBitmap, aSourceRect, aMaskBitmap, aInvertMask);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Draws and fills a rectangle with rounded corners. The corner is constructed as an arc of 
sl@0: an ellipse. The outline is drawn in the current pen colour, size and style if the pen 
sl@0: colour is not ENullPen. The area inside the rectangle is filled according to the current 
sl@0: brush colour and style.
sl@0: 
sl@0: If the corner size has zero width or height, a square-cornered rectangle is drawn. If the corner 
sl@0: size is greater than half the extents of the rectangle, an ellipse is drawn.
sl@0: 
sl@0: @param	aRect The rectangle.
sl@0: @param	aCornerSize The corner size.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenSize()
sl@0: @see	CDirectGdiContext::SetPenStyle()
sl@0: @see	CDirectGdiContext::SetPenColor()
sl@0: @see	CDirectGdiContext::SetBrushColor()
sl@0: @see	CDirectGdiContext::SetBrushStyle()
sl@0: @see	CDirectGdiContext::SetBrushPattern()
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw a rectangle with rounded corners has been accepted. There is no guarantee 
sl@0: 		that the request has been processed when the method returns.
sl@0: 		
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawRoundRect(const TRect& aRect, const TSize& aCornerSize)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawRoundRect");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);
sl@0: 			
sl@0: 	TSize ellsize(aCornerSize);
sl@0: 	ellsize.iWidth <<= 1;
sl@0: 	ellsize.iHeight <<= 1;
sl@0: 
sl@0: 	if (aRect.Width() > 0 && aRect.Height() > 0)
sl@0: 		{
sl@0: 		if (ellsize.iWidth < 3 || ellsize.iHeight < 3)
sl@0: 			{
sl@0: 			DrawRect(aRect);
sl@0: 			return;
sl@0: 			}	
sl@0: 		if (aRect.Width() < ellsize.iWidth && aRect.Height() < ellsize.iHeight)
sl@0: 			{
sl@0: 			DrawEllipse(aRect);
sl@0: 			return;
sl@0: 			}
sl@0: 		iEngine->DrawRoundRect(aRect, aCornerSize);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Draws a polyline using the points in an array. A polyline is a series of concatenated straight 
sl@0: lines joining a set of points. Current pen settings and drawing mode applies. If @c aPointList 
sl@0: has one element, a plot is performed.
sl@0: 
sl@0: @param	aPointList Array of points specifying points on the polyline.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw a polyline has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 		The internal drawing position is set to the last point in the array.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: 
sl@0: @see	CDirectGdiContext::DrawPolyLineNoEndPoint(const TArray<TPoint>&)
sl@0: @see	CDirectGdiContext::SetPenSize(const TSize&)
sl@0: @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawPolyLine(const TArray<TPoint>& aPointList)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawPolyLine");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	if ((aPointList.Count() < 1) || iPenStyle == DirectGdi::ENullPen || (iPenSize.iWidth == 0) || (iPenSize.iHeight == 0))
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	if (aPointList.Count() == 1)
sl@0: 		{
sl@0: 		Plot(aPointList[0]);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iEngine->DrawPolyLine(aPointList);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws a polyline using the points in an array. A polyline is a series of concatenated straight 
sl@0: lines joining a set of points. Current pen settings and drawing mode applies. If @c aPointList 
sl@0: has less than two elements, no drawing is performed. If @c aPointList has exactly two elements
sl@0: then a DrawLine is performed.
sl@0: 
sl@0: @param	aPointList Array of points specifying points on the polyline.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw a polyline has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 		The internal drawing position is set to the last point in the array.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: 
sl@0: @see	CDirectGdiContext::DrawPolyLine(const TArray<TPoint>&)
sl@0: @see	CDirectGdiContext::SetPenSize(const TSize&)
sl@0: @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawPolyLineNoEndPoint(const TArray<TPoint>& aPointList)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawPolyLineNoEndPoint");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 
sl@0: 	const TInt points = aPointList.Count();
sl@0: 
sl@0: 	if (points == 1)
sl@0: 		{
sl@0: 		Plot(aPointList[0]);
sl@0: 		}
sl@0: 	else if (points == 2)
sl@0: 		{
sl@0: 		DrawLine(aPointList[0], aPointList[1]);
sl@0: 		}
sl@0: 	else if (points > 2 && !(iPenStyle == DirectGdi::ENullPen || (iPenSize.iWidth == 0) || (iPenSize.iHeight == 0)))
sl@0: 		{
sl@0: 		iEngine->DrawPolyLineNoEndPoint(aPointList);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Draws and fills a polygon defined using an array of points. The first point in the array defines the 
sl@0: start of the first side of the polygon. The final side of the polygon is drawn using the last point 
sl@0: from the array, and the line is drawn to the start point of the first side. The outline of the polygon
sl@0: is drawn using the current pen settings and the area is filled with the current brush settings. 
sl@0: 
sl@0: Self-crossing polygons are filled according to the specified fill rule.
sl@0: 
sl@0: If @c aPointList is empty, no drawing is performed. If it has one element, the result is the same as Plot(). 
sl@0: If it has two elements, the result is the same as DrawLine().
sl@0: 
sl@0: The error state is set to KErrArgument if aFillRule is an invalid fill rule.
sl@0: 
sl@0: @param	aPointList Array of points specifying the vertices of the polygon.
sl@0: @param	aFillRule Polygon filling rule.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw a polygon has been accepted. There is no guarantee that the request has been processed
sl@0: 		when the method returns. The internal drawing position is set to the last point in the array.
sl@0: 		
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenSize(const TSize&)
sl@0: @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushStyle(DirectGdi::TBrushStyle)
sl@0: @see	CDirectGdiContext::SetBrushPattern(const CFbsBitmap&)
sl@0: @see	CDirectGdiContext::SetBrushOrigin(TPoint)
sl@0: @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)
sl@0: @see	DirectGdi::TFillRule
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawPolygon(const TArray<TPoint>& aPointList, DirectGdi::TFillRule aFillRule)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawPolygon");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);
sl@0: 	
sl@0: 	if (aFillRule != DirectGdi::EAlternate && aFillRule != DirectGdi::EWinding)
sl@0: 		{
sl@0: 		iDriver.SetError(KErrArgument);
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	if (aPointList.Count() == 0)
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	iEngine->DrawPolygon(aPointList, aFillRule);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws and fills an ellipse inside the given rectangle. Current pen and brush settings apply.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenSize(const TSize&)
sl@0: @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushStyle(DirectGdi::TBrushStyle)
sl@0: @see	CDirectGdiContext::SetBrushPattern(const CFbsBitmap&)
sl@0: 
sl@0: @param	aRect The rectangle in which to draw the ellipse.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw an ellipse has been accepted. 
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 		
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawEllipse(const TRect& aRect)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawEllipse");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);
sl@0: 	
sl@0: 	if (aRect.IsEmpty())
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	iEngine->DrawEllipse(aRect);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws a straight line from the start to the end position using current pen size, colour and style. 
sl@0: 
sl@0: @param	aStart	Start position.
sl@0: @param	aEnd	End position.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw a straight line with the current pen colour, size and style has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 		The internal drawing position is set to @c aEnd.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenSize(const TSize&)
sl@0: @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawLine(const TPoint& aStart, const TPoint& aEnd)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawLine");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 
sl@0: 	// Do not draw if start/end at the same point or pensize is 0
sl@0: 	if(aStart == aEnd || iPenStyle == DirectGdi::ENullPen || iPenSize.iWidth == 0 || iPenSize.iHeight == 0)
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	iEngine->DrawLine(aStart, aEnd);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws a straight line from the current internal drawing position to a point using the current pen size, colour and style.
sl@0: 
sl@0: @param	aPoint The end-point of the line.
sl@0: 
sl@0: @pre	Rendering target has been activated.
sl@0: @post	Request to draw a straight line to a specified point with the current pen colour, size and style has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 		Internal drawing position is set to @c aPoint.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenSize(const TSize&)
sl@0: @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)
sl@0: @see	CDirectGdiContext::MoveTo(TPoint)
sl@0: @see	CDirectGdiContext::MoveBy(TPoint)
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawLineTo(const TPoint& aPoint)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawLineTo");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	if(iPenStyle == DirectGdi::ENullPen || iPenSize.iWidth == 0 || iPenSize.iHeight == 0)
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	iEngine->DrawLineTo (aPoint);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws a straight line relative to the current internal drawing position, using a vector. 
sl@0: The start point of the line is the current internal drawing position. The vector @c aVector 
sl@0: is added to the internal drawing position to give the end point of the line.
sl@0: 
sl@0: @param	aVector	The vector to add to the current internal drawing position, giving the end point of the line.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	The request to draw a straight line using the vector with current pen colour, size and style has been
sl@0: 		accepted. There is no guarantee that the request has been processed when the method returns. 
sl@0: 		The internal drawing position is set to the end of the line.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenSize(const TSize&)
sl@0: @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)
sl@0: @see	CDirectGdiContext::MoveTo(TPoint)
sl@0: @see	CDirectGdiContext::MoveBy(TPoint)
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawLineBy(const TPoint& aVector)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawLineBy");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	if(iPenStyle == DirectGdi::ENullPen || iPenSize.iWidth == 0 || iPenSize.iHeight == 0)
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	if (aVector != TPoint(0,0))
sl@0: 		{
sl@0: 		iEngine->DrawLineBy(aVector);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws and fills a rectangle. The outlines are drawn according to the current pen colour, size and style.
sl@0: The area inside the rectangle is filled according to the current brush colour and style.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenSize(const TSize&)
sl@0: @see	CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle)
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushStyle(DirectGdi::TBrushStyle)
sl@0: @see	CDirectGdiContext::SetBrushPattern(const CFbsBitmap&)
sl@0: 
sl@0: @param	aRect The rectangle.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw a rectangle according to the current pen and brush settings has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 		
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: @panic  DGDI 9, if the brush style is EPatternedBrush but no pattern has been set.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawRect(const TRect& aRect)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawRect");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);
sl@0: 	
sl@0: 	if(aRect.IsEmpty())
sl@0: 		return;
sl@0: 	
sl@0: 	iEngine->DrawRect(aRect);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws text at the last print position.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushColor(TRgb)
sl@0: @see	CDirectGdiContext::SetFont(const CFont*)
sl@0: 
sl@0: @param	aText	The text string to be drawn.
sl@0: @param	aParam	Parameters used in drawing text.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw the text at the last text position using the current font and pen colour has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush
sl@0: 		style is neither ENullBrush nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawText");
sl@0: 	DrawText(aText, aParam, iLastPrintPosition, DirectGdi::ELeft, CFont::EHorizontal);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws text at the specified text position.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushColor(TRgb)
sl@0: @see	CDirectGdiContext::SetFont(const CFont*)
sl@0: 
sl@0: @param	aText		The text string to be drawn.
sl@0: @param	aParam		Parameters used in drawing text.
sl@0: @param	aPosition	The position to draw at.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw the text at the specified position using the current font and pen colour has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush
sl@0: 		style is neither ENullBrush nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TPoint& aPosition)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawText");
sl@0: 	DrawText(aText, aParam, aPosition, DirectGdi::ELeft, CFont::EHorizontal);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws text clipped to the specified rectangle.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushColor(TRgb)
sl@0: @see	CDirectGdiContext::SetFont(const CFont*)
sl@0: 
sl@0: @param	aText		The text string to be drawn.
sl@0: @param	aParam		Parameters used in drawing text.
sl@0: @param	aClipRect	The clipping rectangle.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @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.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and 
sl@0: 		the brush style is neither ENullBrush nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipRect)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawText");
sl@0: 	DrawText(aText, aParam, iLastPrintPosition, DirectGdi::ELeft, CFont::EHorizontal, &aClipRect);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws text clipped to the specified filled rectangle using a baseline offset,
sl@0: horizontal alignment and a margin.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetBrushColor(TRgb)
sl@0: @see	CDirectGdiContext::SetFont(const CFont*)
sl@0: 
sl@0: @param	aText			The text string to be drawn.
sl@0: @param	aParam		Parameters used in drawing text.
sl@0: @param	aClipFillRect	The clipping rectangle (this rect will also be filled before text is plotted).
sl@0: @param	aBaselineOffset	An offset in pixels for the baseline from the normal position (bottom of the rectangle minus the descent of the font).
sl@0: @param	aAlignment		Horizontal alignment option relative to the specified rectangle.
sl@0: @param	aMargin			Offset to add to the position as calculated using specified rectangle.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @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.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush
sl@0: 		style is neither ENullBrush nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipFillRect, TInt aBaselineOffset, DirectGdi::TTextAlign aAlignment, TInt aMargin)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawText");
sl@0: 	TPoint p(aClipFillRect.iTl);
sl@0: 	p.iY += aBaselineOffset;
sl@0: 	switch (aAlignment)
sl@0: 		{
sl@0: 		case DirectGdi::ELeft:
sl@0: 			{
sl@0: 			p.iX += aMargin;
sl@0: 			break;
sl@0: 			}
sl@0: 		case DirectGdi::ERight:
sl@0: 			{
sl@0: 			p.iX = aClipFillRect.iBr.iX - aMargin;
sl@0: 			break;
sl@0: 			}
sl@0: 		case DirectGdi::ECenter:
sl@0: 			{
sl@0: 			p.iX += (aClipFillRect.Width() >> 1) + aMargin;
sl@0: 			break;
sl@0: 			}
sl@0: 		default:
sl@0: 			{
sl@0: 			iDriver.SetError(KErrArgument);
sl@0: 			return;
sl@0: 			}		
sl@0: 		}
sl@0: 	DrawText(aText, aParam, p, aAlignment, CFont::EHorizontal, &aClipFillRect, &aClipFillRect);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: The private general DrawText routine that implements all the others.
sl@0: 
sl@0: @param	aText		The text to be drawn.
sl@0: @param	aParam		Parameters used in drawing text.
sl@0: @param	aPosition	The origin of the text.
sl@0: @param	aAlignment	Left, centred or right, around aPosition; not used if drawing vertically.
sl@0: @param	aDirection	Direction: left to right, right to left, or top to bottom.
sl@0: @param	aClipRect	If non-null, used as a clippingrect when the text is drawn.
sl@0: @param	aFillRect	If non-null, filled before the text is drawn.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush
sl@0: 		style is neither ENullBrush nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: void CDirectGdiContext::DrawText(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TPoint& aPosition, DirectGdi::TTextAlign aAlignment, 
sl@0: 	CFont::TTextDirection aDirection, const TRect* aClipRect, const TRect* aFillRect)
sl@0: 	{
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	// anything to do?
sl@0: 	if (aClipRect && aClipRect->IsEmpty())
sl@0: 		{
sl@0: 		iDriver.SetError(KErrArgument);
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iFont.Handle() != 0, EDirectGdiPanicNoFontSelected);
sl@0: 	// This next check actually covers both bitmap and open fonts
sl@0: 	const CBitmapFont* bitmap_font = iFont.Address();
sl@0: 	GRAPHICS_ASSERT_ALWAYS(bitmap_font != 0, EDirectGdiPanicNoFontSelected);
sl@0: 
sl@0: 	// measure the text
sl@0: 	CFont::TMeasureTextInput measure_text_input;
sl@0: 	measure_text_input.iCharJustNum = iCharJustNum;
sl@0: 	measure_text_input.iCharJustExcess = iCharJustExcess;
sl@0: 	measure_text_input.iWordJustNum = iWordJustNum;
sl@0: 	measure_text_input.iWordJustExcess = iWordJustExcess;
sl@0: 	measure_text_input.iFlags |= CFont::TMeasureTextInput::EFVisualOrder;
sl@0: 	if (aParam)
sl@0: 		{
sl@0: 		GRAPHICS_ASSERT_ALWAYS(aParam->iStart < aParam->iEnd ,EDirectGdiPanicBadParameter);
sl@0: 		measure_text_input.iStartInputChar = aParam->iStart;
sl@0: 		measure_text_input.iEndInputChar = Min(aText.Length(),aParam->iEnd);
sl@0: 		}
sl@0: 	CFont::TMeasureTextOutput measure_text_output;
sl@0: 	const TInt advance = iFont.MeasureText(aText, &measure_text_input, &measure_text_output);
sl@0: 	TRect text_bounds = measure_text_output.iBounds;
sl@0: 
sl@0: 	//for linked fonts need an adjustment to the underline postion
sl@0: 	TInt underlineStrikeoutOffset = BaselineCorrection();
sl@0: 
sl@0: 	if (iUnderline == DirectGdi::EUnderlineOn)
sl@0: 		{
sl@0: 		TInt underline_top = 0;
sl@0: 		TInt underline_bottom = 0;
sl@0: 		GetUnderlineMetrics(underline_top, underline_bottom);
sl@0: 		underline_top+=underlineStrikeoutOffset;
sl@0: 		underline_bottom+=underlineStrikeoutOffset;
sl@0: 		text_bounds.iTl.iY = Min(text_bounds.iTl.iY, underline_top);
sl@0: 		text_bounds.iBr.iY = Max(text_bounds.iBr.iY, underline_bottom);
sl@0: 		}
sl@0: 	if (iStrikethrough == DirectGdi::EStrikethroughOn)
sl@0: 		{
sl@0: 		TInt strike_top = 0;
sl@0: 		TInt strike_bottom = 0;
sl@0: 		GetStrikethroughMetrics(strike_top, strike_bottom);
sl@0: 		strike_top+=underlineStrikeoutOffset;
sl@0: 		strike_bottom+=underlineStrikeoutOffset;
sl@0: 		text_bounds.iTl.iY = Min(text_bounds.iTl.iY, strike_top);
sl@0: 		text_bounds.iBr.iY = Max(text_bounds.iBr.iY, strike_bottom);
sl@0: 		}
sl@0: 	if (iUnderline == DirectGdi::EUnderlineOn || iStrikethrough == DirectGdi::EStrikethroughOn)
sl@0: 		{
sl@0: 		if (aDirection == CFont::EHorizontal)
sl@0: 			{
sl@0: 			text_bounds.iTl.iX = Min(text_bounds.iTl.iX, 0);
sl@0: 			text_bounds.iBr.iX = Max(text_bounds.iBr.iX, advance);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			text_bounds.iTl.iY = Min(text_bounds.iTl.iY, 0);
sl@0: 			text_bounds.iBr.iY = Max(text_bounds.iBr.iY, advance);
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	// work out the text origin and new drawing position
sl@0: 	TPoint text_origin = aPosition;
sl@0: 	if (aDirection != CFont::EVertical)
sl@0: 		{
sl@0: 		const TInt leftSideBearing = Min(text_bounds.iTl.iX, 0);
sl@0: 		const TInt rightSideBearing = Max(text_bounds.iBr.iX, advance);
sl@0: 		switch (aAlignment)
sl@0: 			{
sl@0: 			// We are forbidding side-bearings to leak over the sides here,
sl@0: 			// but still keeping the start and end pen positions within bounds.
sl@0: 			case DirectGdi::ELeft:
sl@0: 				text_origin.iX -= leftSideBearing;
sl@0: 				break;
sl@0: 			case DirectGdi::ERight:
sl@0: 				text_origin.iX -= rightSideBearing;
sl@0: 				break;
sl@0: 			case DirectGdi::ECenter:
sl@0: 				// Centre is the average of left and right
sl@0: 				text_origin.iX -= (leftSideBearing + rightSideBearing) >> 1;
sl@0: 				break;
sl@0: 			default:
sl@0: 				iDriver.SetError(KErrArgument);
sl@0: 				return;
sl@0: 			}
sl@0: 		}
sl@0: 	iLastPrintPosition = text_origin;
sl@0: 	if (aDirection == CFont::EHorizontal)
sl@0: 		{
sl@0: 		iLastPrintPosition.iX += advance;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iLastPrintPosition.iY += advance;
sl@0: 		}
sl@0: 	text_origin.iY += bitmap_font->iAlgStyle.iBaselineOffsetInPixels;
sl@0: 	text_bounds.Move(text_origin);
sl@0: 	text_origin += iOrigin;
sl@0: 
sl@0: 	// determine clipping rectangle
sl@0: 	TRect clipRect = aClipRect ? *aClipRect : text_bounds;
sl@0: 
sl@0: 	// fill the box if necessary
sl@0: 	if (aFillRect && (iBrushStyle != DirectGdi::ENullBrush))
sl@0: 		{
sl@0: 		TRect fillBox = *aFillRect;
sl@0: 		if (fillBox.Intersects(clipRect))
sl@0: 			{
sl@0: 			fillBox.Intersection(clipRect);
sl@0: 			iEngine->SetPenStyle(DirectGdi::ENullPen);	// Fill box, don't outline it
sl@0: 			iEngine->DrawRect(fillBox);
sl@0: 			iEngine->SetPenStyle(iPenStyle);		// Put the pen style back
sl@0: 			}
sl@0: 		}
sl@0: 	if (!aText.Length())
sl@0: 		{		
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	clipRect.Move(iOrigin);
sl@0: 
sl@0: 	// decide which drawing routine to call
sl@0: 
sl@0: 	TOpenFontMetrics metrics;
sl@0: 	iFont.GetFontMetrics(metrics);
sl@0: 	const TInt maxwidth = metrics.MaxWidth();
sl@0: 	// extext will be TRUE, if font is underline/strikethrough/anti-aliased or it has shadow/outline effects ON.
sl@0: 	// Depending on these properties it will call the proper draw routine.
sl@0: 	TBool extext = EFalse;
sl@0: 	TBool normaltext = EFalse;
sl@0: 	const TBool antiAliased = (bitmap_font->GlyphBitmapType() == EAntiAliasedGlyphBitmap);
sl@0: 	const TBool outlineAndShadow = (bitmap_font->GlyphBitmapType() == EFourColourBlendGlyphBitmap);
sl@0: 	if (antiAliased || outlineAndShadow )
sl@0: 		{
sl@0: 		if ((outlineAndShadow) && !((iBrushStyle == DirectGdi::ENullBrush) || (iBrushStyle == DirectGdi::ESolidBrush)))
sl@0: 			{
sl@0: 			//For future compatibility it is better if brush style of ENullBrush or ESolidBrush is used 
sl@0: 			//when drawing outline and shadow fonts.
sl@0: 			GRAPHICS_PANIC_ALWAYS(EDirectGdiPanicInvalidBrushStyle);
sl@0: 			}
sl@0: 		extext = ETrue;
sl@0: 		}
sl@0: 	else if ((iUnderline == DirectGdi::EUnderlineOn) || (iStrikethrough == DirectGdi::EStrikethroughOn) || (iCharJustNum > 0) || (iWordJustNum > 0))
sl@0: 		extext = ETrue;
sl@0: 	else
sl@0: 		normaltext = ETrue;
sl@0: 
sl@0: 	const TInt charjustexcess = iCharJustExcess;
sl@0: 	const TInt charjustnum = iCharJustNum;
sl@0: 	const TInt wordjustexcess = iWordJustExcess;
sl@0: 	const TInt wordjustnum = iWordJustNum;
sl@0: 
sl@0: 	// Set up the parameter block for character positioning.
sl@0: 	CFont::TPositionParam param;
sl@0: 	param.iDirection = static_cast<TInt16>(aDirection);
sl@0: 	param.iText.Set(aText);
sl@0: 	TInt endDraw = aText.Length();
sl@0: 	if (aParam)
sl@0: 		{
sl@0: 		param.iPosInText = aParam->iStart;
sl@0: 		endDraw = Min(aText.Length(),aParam->iEnd);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		param.iPosInText = 0;
sl@0: 		}
sl@0: 	param.iPen = text_origin;
sl@0: 
sl@0: 	// Draw the text.
sl@0: 	if (normaltext)
sl@0: 		{
sl@0: 		DoDrawText(param, endDraw, clipRect);
sl@0: 		}
sl@0: 	else if (extext)
sl@0: 		{
sl@0: 		DoDrawTextEx(param, endDraw, clipRect,underlineStrikeoutOffset);
sl@0: 		}
sl@0: 
sl@0: 	// Reset the justification parameters to their original values.
sl@0: 	// These will be updated as required later in code.
sl@0: 	iCharJustExcess = charjustexcess;
sl@0: 	iCharJustNum = charjustnum;
sl@0: 	iWordJustExcess = wordjustexcess;
sl@0: 	iWordJustNum = wordjustnum;
sl@0: 
sl@0: 	if (iAutoUpdateJustification)
sl@0: 		UpdateJustification(aText, aParam);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Overridden  function which draws monochrome text within the given clip rectangle. No rotation applied.
sl@0: @param	aParam	Defines glyph code, ligature creation and diacritic placement.
sl@0: @param	aEnd	The end position within the text descriptor to draw.
sl@0: @param	aClipRect If not-empty, used as a clippingrect when the text is drawn.
sl@0: */
sl@0: void CDirectGdiContext::DoDrawText(CFont::TPositionParam& aParam, const TInt aEnd, const TRect& aClipRect)
sl@0: 	{
sl@0: 	iEngine->BeginDrawGlyph();
sl@0: 	RShapeInfo shapeInfo;
sl@0: 	while (aParam.iPosInText < aEnd)
sl@0: 		{
sl@0: 		if (iFont.GetCharacterPosition2(aParam, shapeInfo))
sl@0: 			{
sl@0: 			const CFont::TPositionParam::TOutput* output = aParam.iOutput;
sl@0: 			for (TInt i = 0; i < aParam.iOutputGlyphs; ++i, ++output)
sl@0: 				iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, EMonochromeGlyphBitmap, output->iBitmapSize, aClipRect); // All other parameters are default
sl@0: 			}
sl@0: 		}
sl@0: 	iEngine->EndDrawGlyph();
sl@0: 	
sl@0: 	if (shapeInfo.IsOpen())
sl@0: 		shapeInfo.Close();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Overridden  function which draws monochrome text within the given clip rectangle. 
sl@0: The current rotation and font style (strikethrough, underline) are applied.
sl@0: 
sl@0: @param	aParam	Defines glyph code, ligature creation and diacritic placement.
sl@0: @param	aEnd	The end position within the text descriptor to draw.
sl@0: @param	aClipRect If not-empty, used as a clipping rect when the text is drawn.
sl@0: @param  aUnderlineStrikethroughOffset the offset for the underline, passed to save calculating this value again
sl@0: */
sl@0: void CDirectGdiContext::DoDrawTextEx(CFont::TPositionParam& aParam, const TInt aEnd, const TRect& aClipRect, const TInt aUnderlineStrikethroughOffset)
sl@0: 	{
sl@0: 	TPoint startPen = aParam.iPen;
sl@0: 	const CBitmapFont* bitmap_font = iFont.Address();
sl@0: 	TInt underlineTop = 0;
sl@0: 	TInt underlineBottom = 0;
sl@0: 	if (iUnderline == DirectGdi::EUnderlineOn)
sl@0: 		{
sl@0: 		GetUnderlineMetrics(underlineTop, underlineBottom);
sl@0: 		underlineTop+=aUnderlineStrikethroughOffset;
sl@0: 		underlineBottom+=aUnderlineStrikethroughOffset;
sl@0: 		}
sl@0: 	TInt strikeTop = 0;
sl@0: 	TInt strikeBottom = 0;
sl@0: 	if (iStrikethrough == DirectGdi::EStrikethroughOn)
sl@0: 		{
sl@0: 		GetStrikethroughMetrics(strikeTop, strikeBottom);
sl@0: 		strikeTop+=aUnderlineStrikethroughOffset;
sl@0: 		strikeBottom+=aUnderlineStrikethroughOffset;
sl@0: 		}
sl@0: 
sl@0: 	iEngine->BeginDrawGlyph();
sl@0: 	RShapeInfo shapeInfo;
sl@0: 	while (aParam.iPosInText < aEnd)
sl@0: 		{
sl@0: 		if (!iFont.GetCharacterPosition2(aParam, shapeInfo))
sl@0: 			{
sl@0: 			continue;
sl@0: 			}
sl@0: 
sl@0: 		TInt adjustment = 0;
sl@0: 		if ((iCharJustExcess > 0) && (iCharJustNum > 0)) // character clipping/justification
sl@0: 			{
sl@0: 			adjustment = CGraphicsContext::JustificationInPixels(iCharJustExcess, iCharJustNum);
sl@0: 			}
sl@0: 
sl@0: 		const CFont::TPositionParam::TOutput* output = aParam.iOutput;
sl@0: 		for (TInt i = 0; i < aParam.iOutputGlyphs; ++i, ++output)
sl@0: 			{
sl@0: 			//get the character metrics for the glyph type
sl@0: 			TOpenFontCharMetrics characterParams;
sl@0: 			const TUint8* bitmap;
sl@0: 			TSize size;
sl@0: 			//note may now be using a glyph code, and not a character
sl@0: 			iFont.GetCharacterData(aParam.iOutput[i].iCode,characterParams,bitmap,size);
sl@0: 			TGlyphBitmapType glyphType = characterParams.GlyphType();
sl@0: 			
sl@0: 			switch (glyphType)
sl@0: 				{
sl@0: 				case EAntiAliasedGlyphBitmap:
sl@0: 				case EFourColourBlendGlyphBitmap:
sl@0: 				case EDefaultGlyphBitmap:
sl@0: 					iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, glyphType, output->iBitmapSize, aClipRect);
sl@0: 					break;
sl@0: 					
sl@0: 				default:
sl@0: 					//if the outline or shadow is not specified for the character, then use the font setting for the glyph bitmap type
sl@0: 					iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, 
sl@0: 									   bitmap_font->GlyphBitmapType(), output->iBitmapSize, aClipRect);		 
sl@0: 					break;
sl@0: 				}
sl@0: 			}
sl@0: 
sl@0: 		if (adjustment)
sl@0: 			{
sl@0: 			aParam.iPen.iX += adjustment;
sl@0: 			}
sl@0: 		if ((iWordJustExcess > 0) && (iWordJustNum > 0) && (aParam.iOutput[0].iCode == 0x0020)) // word justification
sl@0: 			{
sl@0: 			adjustment = CGraphicsContext::JustificationInPixels(iWordJustExcess, iWordJustNum);
sl@0: 			aParam.iPen.iX += adjustment;
sl@0: 			}
sl@0: 		}
sl@0: 	iEngine->EndDrawGlyph();
sl@0: 	if (shapeInfo.IsOpen())
sl@0: 		shapeInfo.Close();
sl@0: 
sl@0: 	if (iUnderline == DirectGdi::EUnderlineOn)
sl@0: 		{
sl@0: 		TRect underlineRect(startPen.iX, startPen.iY + underlineTop, aParam.iPen.iX, startPen.iY + underlineBottom);
sl@0: 		FillRect(underlineRect, iPenColor, aClipRect);
sl@0: 		}
sl@0: 
sl@0: 	if (iStrikethrough == DirectGdi::EStrikethroughOn)
sl@0: 		{
sl@0: 		TRect strikethroughRect(startPen.iX, startPen.iY + strikeTop, aParam.iPen.iX, startPen.iY + strikeBottom);
sl@0: 		FillRect(strikethroughRect, iPenColor, aClipRect);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Fills the given rectangle with the specified colour (subject to the clip rect).
sl@0: This function is internal and used by the text drawing routines.
sl@0: 
sl@0: @param	aRect	The rectangle to fill.
sl@0: @param	aColor	The colour to fill it with.
sl@0: @param	aClipRect	The clipping rect.
sl@0: */
sl@0: void CDirectGdiContext::FillRect(const TRect& aRect, const TRgb& aColor, const TRect& aClipRect)
sl@0: 	{
sl@0: 	TRect fillRect = aRect;
sl@0: 	if (fillRect.Intersects(aClipRect))
sl@0: 		{
sl@0: 		fillRect.Intersection(aClipRect);
sl@0: 		// Override the current settings temporarily
sl@0: 		iEngine->SetBrushColor(aColor);
sl@0: 		iEngine->SetBrushStyle(DirectGdi::ESolidBrush);
sl@0: 		iEngine->SetPenStyle(DirectGdi::ENullPen);	// Fill box, don't outline it
sl@0: 		fillRect.Move(-iOrigin);
sl@0: 		iEngine->DrawRect(fillRect);
sl@0: 		// Put things back
sl@0: 		iEngine->SetPenStyle(iPenStyle);
sl@0: 		iEngine->SetBrushStyle(iBrushStyle);
sl@0: 		iEngine->SetBrushColor(iBrushColor);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws text at the last print position and then rotates it into a vertical position.
sl@0: 
sl@0: @param	aText	The text string to be drawn.
sl@0: @param	aParam	Parameters used in drawing text.
sl@0: @param	aUp		If ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush
sl@0: 		style is neither ENullBrush nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, TBool aUp)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	// This next check covers both bitmap and open fonts
sl@0: 	const CBitmapFont* bitmapFont = iFont.Address();
sl@0: 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);
sl@0: 	TRect clipRect2(0, 0, 0, 0);
sl@0: 	TInt baselineOffset = 0;
sl@0: 	TInt margin = 0;
sl@0: 	CalculateClipRect2PlusBaselineOffsetAndMargin(aText, aParam, iLastPrintPosition, aUp, clipRect2, baselineOffset, margin);
sl@0: 	DrawTextVertical(aText, aParam, NULL, &clipRect2, NULL, baselineOffset, -1, aUp, DirectGdi::ELeft, margin); //-1 signifies that text will not be clipped
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws text vertically from the specified position.
sl@0: 
sl@0: @param	aText		The text string to be drawn.
sl@0: @param	aParam		Parameters used in drawing text.
sl@0: @param	aPosition	A point specifying the position of the left end of the text.
sl@0: @param	aUp			If ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither 
sl@0: 		ENullBrush nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TPoint& aPosition, TBool aUp)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	// This next check covers both bitmap and open fonts
sl@0: 	const CBitmapFont* bitmapFont = iFont.Address();
sl@0: 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);
sl@0: 	TRect clipRect2(0, 0, 0, 0);
sl@0: 	TInt baselineOffset = 0;
sl@0: 	TInt margin = 0;
sl@0: 	CalculateClipRect2PlusBaselineOffsetAndMargin(aText, aParam, aPosition, aUp, clipRect2, baselineOffset, margin);
sl@0: 	DrawTextVertical(aText, aParam, NULL, &clipRect2, NULL, baselineOffset, -1, aUp, DirectGdi::ELeft, margin);//-1 signifies that text will not be clipped
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws text clipped to the specified rectangle and then rotates it into a vertical position.
sl@0: 
sl@0: @param	aText		The text string to be drawn.
sl@0: @param	aParam		Parameters used in drawing text.
sl@0: @param	aClipRect	The clipping rectangle.
sl@0: @param	aUp			ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 
sl@0: 		nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipRect, TBool aUp)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);	
sl@0: 	// This next check covers both bitmap and open fonts
sl@0: 	const CBitmapFont* bitmapFont = iFont.Address();
sl@0: 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);
sl@0: 	TRect clipRect2(0, 0, 0, 0);
sl@0: 	TInt baselineOffset = 0;
sl@0: 	TInt margin = 0;
sl@0: 	CalculateClipRect2PlusBaselineOffsetAndMargin(aText, aParam, iLastPrintPosition, aUp, clipRect2, baselineOffset, margin);
sl@0: 	DrawTextVertical(aText, aParam, &aClipRect, &clipRect2, NULL, baselineOffset, -1, aUp, DirectGdi::ELeft, margin);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Private internal function for calculating several parameters needed by these routines.
sl@0: 
sl@0: @param	aText		The text string to be drawn.
sl@0: @param	aParam		Parameters used in drawing text.
sl@0: @param	aPosition	A point specifying the position of the left end of the text.
sl@0: @param	aUp			ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.
sl@0: @param	aClipRect2		On return, contains clipping rectangle.
sl@0: @param	aBaselineOffset	On return, contains baseline offset.
sl@0: @param	aMargin			On return, contains margin.
sl@0: */
sl@0: void CDirectGdiContext::CalculateClipRect2PlusBaselineOffsetAndMargin(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TPoint& aPosition, TBool aUp, TRect& aClipRect2, TInt& aBaselineOffset, TInt& aMargin)
sl@0: 	{
sl@0: 	TOpenFontMetrics metrics;
sl@0: 	iFont.GetFontMetrics(metrics);
sl@0: 	aBaselineOffset = metrics.MaxHeight();
sl@0: 	TInt height = aBaselineOffset + metrics.MaxDepth();
sl@0: 	// The next few lines do much the same as TextWidthInPixels but pass
sl@0: 	// the text in visual order instead of logical order and also take
sl@0: 	// full account of left and right side bearings on the text
sl@0: 	CFont::TMeasureTextOutput output;
sl@0: 	CFont::TMeasureTextInput input;
sl@0: 	input.iFlags = CFont::TMeasureTextInput::EFVisualOrder;
sl@0: 	if (aParam)
sl@0: 		{
sl@0: 		GRAPHICS_ASSERT_ALWAYS(aParam->iStart < aParam->iEnd ,EDirectGdiPanicBadParameter);
sl@0: 		input.iStartInputChar = aParam->iStart;
sl@0: 		input.iEndInputChar = Min(aText.Length(),aParam->iEnd);
sl@0: 		}
sl@0: 	TInt advance = iFont.MeasureText(aText, &input, &output);
sl@0: 	TInt leftBearing = output.iBounds.iTl.iX;
sl@0: 	TInt rightBearing = advance - output.iBounds.iBr.iX;
sl@0: 	aMargin = 0;
sl@0: 	if (aUp)
sl@0: 		{
sl@0: 		aClipRect2.iTl.iX = aPosition.iX - aBaselineOffset;
sl@0: 		aClipRect2.iTl.iY = aPosition.iY - advance;
sl@0: 		aClipRect2.iBr.iX = aPosition.iX + height - aBaselineOffset + 1;
sl@0: 		aClipRect2.iBr.iY = aPosition.iY;
sl@0: 		if (leftBearing < 0)
sl@0: 			{
sl@0: 			aClipRect2.iBr.iY -= leftBearing;
sl@0: 			aMargin = -leftBearing;
sl@0: 			}
sl@0: 		if (rightBearing < 0)
sl@0: 			{
sl@0: 			aClipRect2.iTl.iY += rightBearing;
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		aClipRect2.iTl.iX = aPosition.iX + aBaselineOffset- height;
sl@0: 		aClipRect2.iTl.iY = aPosition.iY;
sl@0: 		aClipRect2.iBr.iX = aPosition.iX + aBaselineOffset + 1;
sl@0: 		aClipRect2.iBr.iY = aPosition.iY + advance;
sl@0: 		if (leftBearing < 0)
sl@0: 			{
sl@0: 			aClipRect2.iTl.iY += leftBearing;
sl@0: 			aMargin = -leftBearing;
sl@0: 			}
sl@0: 		if (rightBearing < 0)
sl@0: 			{
sl@0: 			aClipRect2.iBr.iY -= rightBearing;
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws text vertically, clipped to a specified rectangle, using a baseline offset, alignment and margin.
sl@0: 
sl@0: @param	aText			The text string to be drawn.
sl@0: @param	aParam			Parameters used in drawing text.
sl@0: @param	aClipFillRect	The clipping rectangle (this rect will also be filled before text is plotted).
sl@0: @param	aBaselineOffset	Number of pixels to offset the baseline by.
sl@0: @param	aUp				ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.
sl@0: @param	aVert			Vertical alignment of the text relative to the specified rectangle.
sl@0: @param	aMargin			Offset of the text from the position within the rectangle, using the specified alignment.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 
sl@0: 		nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipFillRect, TInt aBaselineOffset,
sl@0: 												  TBool aUp, DirectGdi::TTextAlign aVert, TInt aMargin)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	// This next check covers both bitmap and open fonts
sl@0: 	const CBitmapFont* bitmapFont = iFont.Address();
sl@0: 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);
sl@0: 	DrawTextVertical(aText, aParam, NULL, &aClipFillRect, &aClipFillRect, aBaselineOffset, -1, aUp, aVert, aMargin);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws text vertically, clipped to a specified rectangle, using a baseline offset, alignment and margin.
sl@0: 
sl@0: @param	aText			The text string to be drawn.
sl@0: @param	aParam			Parameters used in drawing text.
sl@0: @param	aClipFillRect	The clipping rectangle (this rect will also be filled before text is plotted).
sl@0: @param	aBaselineOffset	Number of pixels to offset the baseline by.
sl@0: @param	aTextWidth		Number of pixels to clip the text to.
sl@0: @param	aUp				ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.
sl@0: @param	aVert			Vertical alignment of the text relative to the specified rectangle.
sl@0: @param	aMargin			Offset of the text from the position within the rectangle, using the specified alignment.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 
sl@0: 		nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect& aClipFillRect, TInt aBaselineOffset,
sl@0: 												  TInt aTextWidth, TBool aUp, DirectGdi::TTextAlign aVert, TInt aMargin)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawTextVertical");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	// This next check covers both bitmap and open fonts
sl@0: 	const CBitmapFont* bitmapFont = iFont.Address();
sl@0: 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);
sl@0: 	DrawTextVertical(aText, aParam, NULL, &aClipFillRect, &aClipFillRect, aBaselineOffset, aTextWidth, aUp, aVert, aMargin);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: The private general DrawTextVertical() routine that implements all the others.
sl@0: Two clipping rectangles received from different routines. The final rectangle will be calculated as intersection 
sl@0: of first and second clipping rectangle. If aClipRect2 is empty, the error state is set to KErrArgument.
sl@0: 
sl@0: @param	aText			The text string to be drawn.
sl@0: @param	aParam			Parameters used in drawing text.
sl@0: @param	aClipRect1		Pointer to first clipping rectangle.
sl@0: @param	aClipRect2		Pointer to second clipping rectangle. 
sl@0: @param	aFillRect		Pointer to rectangle to be filled before text plotting.
sl@0: @param	aBaselineOffset	Number of pixels to offset the baseline by.
sl@0: @param	aTextWidth		Number of pixels to clip the text to. If negative, the text will not be clipped
sl@0: @param	aUp				ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.
sl@0: @param	aVert			Vertical alignment of the text relative to the specified rectangle.
sl@0: @param	aMargin			Offset of the text from the position within the rectangle, using the specified alignment.
sl@0: 
sl@0: @panic	DGDI 10, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 
sl@0: 		nor ESolidBrush.
sl@0: @panic	DGDI 11, if a font has not been set prior to calling DrawText().
sl@0: @panic  DGDI 22, if aClipRect2 is NULL.
sl@0: */
sl@0: void CDirectGdiContext::DrawTextVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, const TRect* aClipRect1, const TRect* aClipRect2, const TRect* aFillRect,
sl@0: 		TInt aBaselineOffset, TInt aTextWidth, TBool aUp, DirectGdi::TTextAlign aVert, TInt aMargin)
sl@0: 	{
sl@0: 	GRAPHICS_ASSERT_ALWAYS(aClipRect2, EDirectGdiPanicBadParameter);
sl@0: 
sl@0: 	TRect clipRect2 = *aClipRect2;
sl@0: 	clipRect2.Move(iOrigin);
sl@0: 
sl@0: 	TRect clipRect(clipRect2);
sl@0: 	if (aClipRect1 != NULL)
sl@0: 		{
sl@0: 		if(aClipRect1->IsEmpty())
sl@0: 			{
sl@0: 			iDriver.SetError(KErrArgument);
sl@0: 			return;
sl@0: 			}
sl@0: 		TRect clipRect1 = *aClipRect1;
sl@0: 		clipRect1.Move(iOrigin);
sl@0: 		clipRect.Intersection(clipRect1);
sl@0: 		}
sl@0: 	
sl@0: 	if ((aFillRect != NULL) && (iBrushStyle != ENullBrush))
sl@0: 		{
sl@0: 		// fill the box if necessary
sl@0: 		TRect fillBox = *aFillRect;
sl@0: 		fillBox.Move(iOrigin);
sl@0: 		if (fillBox.Intersects(clipRect))
sl@0: 			{
sl@0: 			fillBox.Intersection(clipRect);
sl@0: 			iEngine->SetPenStyle(DirectGdi::ENullPen);	// Fill box, don't outline it
sl@0: 			iEngine->DrawRect(*aFillRect);
sl@0: 			iEngine->SetPenStyle(iPenStyle);		// Put the pen style back
sl@0: 			}
sl@0: 		}
sl@0: 	if (!aText.Length())
sl@0: 		{		
sl@0: 		return;
sl@0: 		}
sl@0: 	if (aClipRect2->IsEmpty())
sl@0: 		{
sl@0: 		iDriver.SetError(KErrArgument);
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	const CBitmapFont* bitmapFont = iFont.Address();
sl@0: 	GRAPHICS_ASSERT_ALWAYS(bitmapFont != 0, EDirectGdiPanicNoFontSelected);
sl@0: 
sl@0: 	CFont::TMeasureTextInput input;
sl@0: 	//CFont::TMeasureTextOutput
sl@0: 	if (aParam)
sl@0: 		{
sl@0: 		GRAPHICS_ASSERT_ALWAYS(aParam->iStart < aParam->iEnd ,EDirectGdiPanicBadParameter);
sl@0: 		input.iStartInputChar = aParam->iStart;
sl@0: 		input.iEndInputChar = Min(aText.Length(),aParam->iEnd);
sl@0: 		}
sl@0: 	TInt width = iFont.MeasureText(aText,&input);
sl@0: 	TOpenFontMetrics metrics;
sl@0: 	iFont.GetFontMetrics(metrics);
sl@0: 	
sl@0: 	if (aTextWidth < 0)
sl@0: 		{
sl@0: 		aTextWidth = width;
sl@0: 		}
sl@0: 	TPoint coords;
sl@0: 	coords.iX = clipRect2.iTl.iX;
sl@0: 	TInt directionalMultiplier = aUp ? -1 : 1;
sl@0: 	coords.iY = aUp ? clipRect2.iBr.iY - 1 : clipRect2.iTl.iY;
sl@0: 	//
sl@0: 	// iX calculation, for example: ascent(a)=18 descent(d)=2 size=boxwidth=fontheight(h)=20 baseline=ascent
sl@0: 	// pre: iX = 0
sl@0: 	//
sl@0: 	// hhhhhhhhhhhhhhhhhhhh
sl@0: 	// 01234567890123456789
sl@0: 	// aaaaaaaaaaaaaaaaaadd	aUp=ETrue
sl@0: 	//                   ^
sl@0: 	//                   iX = 18 (baseline)
sl@0: 	//
sl@0: 	// ddaaaaaaaaaaaaaaaaaa aUp=EFalse
sl@0: 	//  ^
sl@0: 	//  iX = 1 (instead of 2 ie 20-18-1 which is boxwidth-baseline-1)
sl@0: 	//
sl@0: 	coords.iX += aUp ? aBaselineOffset : clipRect2.Width() - aBaselineOffset - 1;
sl@0: 	switch (aVert)
sl@0: 		{
sl@0: 	case DirectGdi::ELeft:
sl@0: 		coords.iY += aMargin * directionalMultiplier;
sl@0: 		break;
sl@0: 	case DirectGdi::ECenter:
sl@0: 		coords.iY += (((clipRect2.iBr.iY - clipRect2.iTl.iY - aTextWidth) >> 1) + aMargin) * directionalMultiplier;
sl@0: 		break;
sl@0: 	case DirectGdi::ERight:
sl@0: 		coords.iY += (clipRect2.iBr.iY - clipRect2.iTl.iY - aTextWidth - aMargin) * directionalMultiplier;
sl@0: 		break;
sl@0: 	default:
sl@0: 		iDriver.SetError(KErrArgument);
sl@0: 		return;
sl@0: 		}
sl@0: 	iLastPrintPosition = coords;
sl@0: 	coords.iX += bitmapFont->iAlgStyle.iBaselineOffsetInPixels * directionalMultiplier;
sl@0: 	TInt prewidth = width + iCharJustExcess + iWordJustExcess;
sl@0: 	iLastPrintPosition.iY -= aUp ? prewidth - 1 : -prewidth;
sl@0: 	if (clipRect.IsEmpty() || !width)
sl@0: 		{
sl@0: 		if (iAutoUpdateJustification)
sl@0: 			{
sl@0: 			UpdateJustificationVertical(aText, aParam, aUp);
sl@0: 			}
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	/*
sl@0: 	Set up the parameter block for character positioning.
sl@0: 	Draw left to right, because although the text is being drawn vertically,
sl@0: 	it is done by rotating the baseline 90 degrees and drawing in the ordinary way, not by drawing
sl@0: 	the characters in their normal orientation but in a vertical column.
sl@0: 	*/
sl@0: 	CFont::TPositionParam param;
sl@0: 	param.iText.Set(aText);
sl@0: 	param.iPen = coords;
sl@0: 	TInt endDraw = aText.Length();
sl@0: 	if (aParam)
sl@0: 		{
sl@0: 		param.iPosInText = aParam->iStart;
sl@0: 		endDraw = Min(aText.Length(),aParam->iEnd);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		param.iPosInText = 0;
sl@0: 		}
sl@0: 
sl@0: 	// Draw the text.
sl@0: 	DoDrawTextVertical(param, aUp, endDraw, clipRect);
sl@0: 	if(iAutoUpdateJustification)
sl@0: 		{
sl@0: 		UpdateJustificationVertical(aText, aParam, aUp);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws vertical text within the clipping area
sl@0: 
sl@0: @param	aParam		Defines glyph code, ligature creation and diacritic placement 
sl@0: @param	aUp			ETrue, text is rotated 90 degrees anti-clockwise; EFalse, text is rotated 90 degrees clockwise.
sl@0: @param	aEnd		The end position within the text descriptor to draw.
sl@0: @param	aClipRect	The clipping rectangle.
sl@0: 
sl@0: @pre iFont is a valid CFont.
sl@0: 
sl@0: @panic	DGDI 13, if the active font is an outline and/or shadow font and the brush style is neither ENullBrush 
sl@0: 		nor ESolidBrush.
sl@0: */
sl@0: void CDirectGdiContext::DoDrawTextVertical(CFont::TPositionParam& aParam, TBool aUp, const TInt aEnd, TRect& aClipRect)
sl@0: 	{
sl@0: 	const CBitmapFont* bitmapFont = iFont.Address();
sl@0: 	if ((bitmapFont->GlyphBitmapType() == EFourColourBlendGlyphBitmap) && !((iBrushStyle == DirectGdi::ENullBrush) || (iBrushStyle == DirectGdi::ESolidBrush)))
sl@0: 		{
sl@0: 		//For future compatibility it is better if brush style of ENullBrush or ESolidBrush is used 
sl@0: 		//when drawing outline and shadow fonts.
sl@0: 		GRAPHICS_PANIC_ALWAYS(EDirectGdiPanicInvalidBrushStyle);
sl@0: 		}
sl@0: 
sl@0: 	TPoint startPen = aParam.iPen;
sl@0: 	TInt charClipping = aClipRect.iTl.iY;
sl@0: 	TInt underlineTop = 0;
sl@0: 	TInt underlineBottom = 0;
sl@0: 
sl@0: 	//for linked fonts need an adjustment to the underline postion
sl@0: 	TInt underlineStrikeoutOffset = BaselineCorrection();
sl@0: 
sl@0: 	if (iUnderline == DirectGdi::EUnderlineOn)
sl@0: 		{
sl@0: 		GetUnderlineMetrics(underlineTop, underlineBottom);
sl@0: 		underlineTop+=underlineStrikeoutOffset;
sl@0: 		underlineBottom+=underlineStrikeoutOffset;
sl@0: 		}
sl@0: 	TInt strikeTop = 0;
sl@0: 	TInt strikeBottom = 0;
sl@0: 	if (iStrikethrough == DirectGdi::EStrikethroughOn)
sl@0: 		{
sl@0: 		GetStrikethroughMetrics(strikeTop, strikeBottom);
sl@0: 		strikeTop+=underlineStrikeoutOffset;
sl@0: 		strikeBottom+=underlineStrikeoutOffset;
sl@0: 		}
sl@0: 
sl@0: 	const DirectGdi::TGraphicsRotation rotation = aUp ? DirectGdi::EGraphicsRotation270 : DirectGdi::EGraphicsRotation90;
sl@0: 	iEngine->BeginDrawGlyph();
sl@0: 	RShapeInfo shapeInfo;
sl@0: 	while (aParam.iPosInText < aEnd)
sl@0: 		{
sl@0: 		TPoint startPen2 = aParam.iPen;
sl@0: 		if (!iFont.GetCharacterPosition2(aParam, shapeInfo))
sl@0: 			{
sl@0: 			continue;
sl@0: 			}
sl@0: 		Rotate(aParam.iPen, startPen2, aUp);
sl@0: 		TInt adjustment = 0;
sl@0: 		if(iCharJustExcess && (iCharJustNum > 0)) // character clipping/justification
sl@0: 			{
sl@0: 			adjustment = CGraphicsContext::JustificationInPixels(iCharJustExcess, iCharJustNum);
sl@0: 			if (adjustment < 0)
sl@0: 				{
sl@0: 				aClipRect.iTl.iY = aParam.iPen.iY + (aUp ? -adjustment : adjustment);
sl@0: 				}
sl@0: 			}
sl@0: 
sl@0: 		CFont::TPositionParam::TOutput* output = aParam.iOutput;
sl@0: 		for (TInt i = 0; i < aParam.iOutputGlyphs; i++, output++)
sl@0: 			{
sl@0: 			Rotate(output->iBounds.iTl, startPen2, aUp);
sl@0: 
sl@0: 			//get the character metrics for the glyph type
sl@0: 			TOpenFontCharMetrics characterParams;
sl@0: 			const TUint8* bitmap;
sl@0: 			TSize size;
sl@0: 			//note may now be using a glyph code, and not a character
sl@0: 			iFont.GetCharacterData(aParam.iOutput[i].iCode,characterParams,bitmap,size);
sl@0: 			TGlyphBitmapType glyphType = characterParams.GlyphType();
sl@0: 			
sl@0: 			switch (glyphType)
sl@0: 				{
sl@0: 				case EAntiAliasedGlyphBitmap:
sl@0: 				case EFourColourBlendGlyphBitmap:
sl@0: 				case EDefaultGlyphBitmap:
sl@0: 					iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, glyphType, output->iBitmapSize, aClipRect, rotation);
sl@0: 					break;
sl@0: 
sl@0: 				default:
sl@0: 					//if the outline or shadow is not specified for the character, then use the font setting
sl@0: 					iEngine->DrawGlyph(output->iBounds.iTl, output->iCode, output->iBitmap, bitmapFont->GlyphBitmapType(), output->iBitmapSize, aClipRect, rotation);	 
sl@0: 					break;
sl@0: 				}			
sl@0: 			}
sl@0: 
sl@0: 		aClipRect.iTl.iY = charClipping;
sl@0: 		if (adjustment)
sl@0: 			{
sl@0: 			aParam.iPen.iY += aUp ? -adjustment : adjustment;
sl@0: 			}
sl@0: 		if ((iWordJustExcess > 0) && (iWordJustNum > 0) && (aParam.iOutput[0].iCode == 0x0020)) // word justification
sl@0: 			{
sl@0: 			adjustment = CGraphicsContext::JustificationInPixels(iWordJustExcess, iWordJustNum);
sl@0: 			aParam.iPen.iY += aUp ? -adjustment : adjustment;
sl@0: 			}
sl@0: 		}
sl@0: 	iEngine->EndDrawGlyph();
sl@0: 	if (shapeInfo.IsOpen())
sl@0: 		{
sl@0: 		shapeInfo.Close();
sl@0: 		}
sl@0: 
sl@0: 	if (iUnderline == DirectGdi::EUnderlineOn)
sl@0: 		{
sl@0: 		TRect underlineRect; // underline
sl@0: 		if (aUp)
sl@0: 			{
sl@0: 			underlineRect.SetRect(startPen.iX + underlineTop, aParam.iPen.iY, startPen.iX + underlineBottom, startPen.iY + 1);
sl@0: 			underlineRect.iTl.iY = underlineRect.iBr.iY - underlineRect.Height();
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			underlineRect.SetRect(startPen.iX - underlineBottom, startPen.iY, startPen.iX - underlineTop, aParam.iPen.iY);
sl@0: 			underlineRect.iBr.iY = underlineRect.iTl.iY + underlineRect.Height();
sl@0: 			underlineRect.iTl.iX++; // adjust for rect not including last line
sl@0: 			underlineRect.iBr.iX++;
sl@0: 			}
sl@0: 		FillRect(underlineRect, iPenColor, aClipRect);
sl@0: 		}
sl@0: 
sl@0: 	if (iStrikethrough == DirectGdi::EStrikethroughOn)
sl@0: 		{
sl@0: 		TRect strikethroughRect; // strikethrough
sl@0: 		if (aUp)
sl@0: 			{
sl@0: 			strikethroughRect.SetRect(startPen.iX + strikeTop, aParam.iPen.iY, startPen.iX + strikeBottom, startPen.iY + 1);
sl@0: 			strikethroughRect.iTl.iY = strikethroughRect.iBr.iY - strikethroughRect.Height();
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			strikethroughRect.SetRect(startPen.iX - strikeBottom, startPen.iY, startPen.iX - strikeTop, aParam.iPen.iY);
sl@0: 			strikethroughRect.iBr.iY = strikethroughRect.iTl.iY + strikethroughRect.Height();
sl@0: 			strikethroughRect.iTl.iX++;
sl@0: 			strikethroughRect.iBr.iX++;
sl@0: 			}
sl@0: 		FillRect(strikethroughRect, iPenColor, aClipRect);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Transform a vector, defined by a point relative to an origin, from left-to-right to up or down.
sl@0: 
sl@0: @param aPoint A point relative to the origin aOrigin.
sl@0: @param aOrigin The origin to use when transforming the point aPoint.
sl@0: @param aUp If ETrue, then transform the point from left-right to up, otherwise transform from 
sl@0: left-right to down.
sl@0: */
sl@0: void CDirectGdiContext::Rotate(TPoint& aPoint, const TPoint& aOrigin, TBool aUp)
sl@0: 	{
sl@0: 	TInt dx = aPoint.iX - aOrigin.iX;
sl@0: 	TInt dy = aPoint.iY - aOrigin.iY;
sl@0: 	if (aUp)
sl@0: 		{
sl@0: 		aPoint.iX = aOrigin.iX + dy;
sl@0: 		aPoint.iY = aOrigin.iY - dx;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		aPoint.iX = aOrigin.iX - dy;
sl@0: 		aPoint.iY = aOrigin.iY + dx;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Can be used to find out the top and bottom of an underline for the active font.
sl@0: This allows correct calculation of the area required in which to draw text with underline.
sl@0: 
sl@0: @param	aTop The top of the underline position.
sl@0: @param	aBottom The bottom of the underline position.
sl@0: */
sl@0: void CDirectGdiContext::GetUnderlineMetrics(TInt& aTop, TInt& aBottom)
sl@0: 	{
sl@0: 	const TInt width = Max((iFont.HeightInPixels() / 10), 1);
sl@0: 	aTop = 1 + (width >> 1);
sl@0: 	aBottom = aTop + width;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Get the top and bottom of a strikethrough line for the current font, relative to the baseline.
sl@0: 
sl@0: @param	aTop The top of the strikethrough position.
sl@0: @param	aBottom The bottom of the strikethrough position.
sl@0: */
sl@0: void CDirectGdiContext::GetStrikethroughMetrics(TInt& aTop, TInt& aBottom)
sl@0: 	{
sl@0: 	aTop = -(iFont.AscentInPixels() * 5/12) - 1;
sl@0: 	aBottom = aTop + Max((iFont.HeightInPixels() / 10), 1);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Moves the internal drawing position relative to the co-ordinate origin, without drawing a line.
sl@0: A subsequent call to DrawLineTo() or DrawLineBy() will then use the new internal drawing position
sl@0: as the start point for the line drawn. 
sl@0: 
sl@0: The operations DrawLine(), DrawLineTo(), DrawLineBy() and DrawPolyline() also change the internal drawing 
sl@0: position to the last point of the drawn line(s). The internal drawing position is set to the co-ordinate
sl@0: origin if no drawing or moving operations have yet taken place.
sl@0: 
sl@0: @see	CDirectGdiContext::MoveBy(const TPoint&)
sl@0: 
sl@0: @param	aPoint The point to move the internal drawing position to.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to move the internal drawing position to the specified point has been accepted. 
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::MoveTo(const TPoint& aPoint)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::MoveTo(%d,%d)", aPoint.iX, aPoint.iY);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	iEngine->MoveTo(aPoint);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Moves the internal drawing position by a vector, relative to the current position, without drawing a line.
sl@0: A subsequent call to DrawLineTo() or DrawLineBy() will then use the new internal drawing position
sl@0: as the start point for the line drawn.
sl@0: 
sl@0: The operations DrawLine(), DrawLineTo(), DrawLineBy() and DrawPolyline() also change the internal drawing 
sl@0: position to the last point of the drawn line(s). The internal drawing position is set to the co-ordinate
sl@0: origin if no drawing or moving operations have yet taken place.
sl@0: 
sl@0: @see	CDirectGdiContext::MoveTo(const TPoint&)
sl@0: 
sl@0: @param	aVector	The vector to move the internal position by.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to move the internal drawing position by a vector has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::MoveBy(const TPoint& aVector)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::MoveBy(%d,%d)", aVector.iX, aVector.iY);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	if (aVector != TPoint(0,0))
sl@0: 		{
sl@0: 		iEngine->MoveBy(aVector);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws a point at given location using current pen colour and size. 
sl@0: If the pen size is greater than 1x1 pixel, a filled circle/ellipse with current pen 
sl@0: colour should be drawn with the given position as the centre.
sl@0: 
sl@0: @param	aPoint The position to plot.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to draw a point or filled circle/ellipse has been accepted.
sl@0: 		There is no guarantee that the request has been processed when the method returns.
sl@0: 
sl@0: @panic 	DGDI 7, if the rendering context has not been activated.
sl@0: 
sl@0: @see	CDirectGdiContext::SetPenSize(const TSize&)
sl@0: @see	CDirectGdiContext::SetPenColor(TRgb)
sl@0: @see	CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode)
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::Plot(const TPoint& aPoint)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::Plot(%d,%d)", aPoint.iX, aPoint.iY);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	if (iPenStyle == DirectGdi::ENullPen || iPenSize.iWidth == 0 || iPenSize.iHeight == 0)
sl@0: 		{
sl@0: 		return;
sl@0: 		}	
sl@0: 	iEngine->Plot(aPoint);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Resets drawing state to its default settings. This operation does not unbind the current target. 
sl@0: @pre	None.
sl@0: @post	The drawing state is reset to default values. Subsequent drawing will use the default settings until they are changed to different values.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::Reset()
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::Reset");
sl@0: 	iEngine->Reset();
sl@0: 
sl@0: 	// Explicit calls are made to the engine to apply the defaults. 
sl@0: 	// Set() methods should generally not be used as they perform unnecessary checks, and may also 
sl@0: 	// block the call to the engine if the value being set is the same as the constructor's default.	
sl@0: 	// Clipping regions.
sl@0: 	iClippingRegion.Clear();
sl@0: 	iEngine->ResetClippingRegion();
sl@0: 	// Origin.
sl@0: 	iOrigin.SetXY(0,0);
sl@0: 	iEngine->SetOrigin(iOrigin);
sl@0: 	// Font.
sl@0: 	iEngine->ResetFont();
sl@0: 	iFont.Reset();
sl@0: 	// Text.
sl@0: 	iLastPrintPosition.SetXY(0,0);
sl@0: 	iAutoUpdateJustification = ETrue;
sl@0: 	SetCharJustification(0, 0);
sl@0: 	SetWordJustification(0, 0);
sl@0: 	SetStrikethroughStyle(DirectGdi::EStrikethroughOff);
sl@0: 	SetUnderlineStyle(DirectGdi::EUnderlineOff);
sl@0: 	// Pen colour.
sl@0: 	iPenColor = KRgbBlack;
sl@0: 	iEngine->SetPenColor(iPenColor);
sl@0: 	// Pen size.
sl@0: 	iPenSize = TSize(1,1);
sl@0: 	iEngine->SetPenSize(iPenSize);
sl@0: 	// Pen style.
sl@0: 	iPenStyle = DirectGdi::ESolidPen;
sl@0: 	iEngine->SetPenStyle(iPenStyle);
sl@0: 	// Draw mode.
sl@0: 	iDrawMode = DirectGdi::EDrawModePEN;
sl@0: 	iEngine->SetDrawMode(iDrawMode);
sl@0: 	// Text shadow colour.
sl@0: 	iTextShadowColor = KRgbGray;
sl@0: 	iEngine->SetTextShadowColor(iTextShadowColor);
sl@0: 	// Brush colour.
sl@0: 	iBrushColor = KRgbWhite;
sl@0: 	iEngine->SetBrushColor(iBrushColor);
sl@0: 	// Brush style.
sl@0: 	iBrushStyle = DirectGdi::ENullBrush;
sl@0: 	iEngine->SetBrushStyle(iBrushStyle);
sl@0: 	// Brush pattern.
sl@0: 	CleanUpBrushPattern();
sl@0: 	iEngine->ResetBrushPattern();
sl@0: 	iBrushPatternUsed = EFalse;
sl@0: 	// Brush origin.
sl@0: 	iBrushOrigin.SetXY(0,0);
sl@0: 	iEngine->SetBrushOrigin(iBrushOrigin);
sl@0: 	// Internal drawing position.
sl@0: 	iEngine->MoveTo(TPoint(0,0));
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the colour for clearing, filling the area of shapes and the background of text boxes.
sl@0: 
sl@0: The default brush colour is white. However, the default brush style is ENullBrush, so when drawing 
sl@0: to a target the default appears to be the target's background colour.
sl@0: 
sl@0: @see	CDirectGdiContext::Clear()
sl@0: @see	CDirectGdiContext::Clear(const TRect&)
sl@0: @see	CDirectGdiContext::DrawRect()
sl@0: @see	CDirectGdiContext::DrawRoundRect()
sl@0: @see	CDirectGdiContext::DrawPolygon()
sl@0: @see	CDirectGdiContext::DrawPie()
sl@0: 
sl@0: @param	aColor Brush colour.
sl@0: 
sl@0: @pre	None.
sl@0: @post	The new brush colour will be used on subsequent drawing operations if a brush style making 
sl@0: 		use of the brush colour is used. The new brush colour remains in effect until another SetBrushColor() 
sl@0: 		with a different parameter is called.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetBrushColor(const TRgb& aColor)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetBrushColor(%d)", aColor.Internal());
sl@0: 	if (aColor != iBrushColor)
sl@0: 		{	
sl@0: 		iBrushColor = aColor;
sl@0: 		iEngine->SetBrushColor(iBrushColor);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the brush pattern origin which specifies the start of a pattern tile. 
sl@0: Shapes can be considered as a view port into a continuous pattern tile covering the entire 
sl@0: area of rendering target. The default origin is TPoint(0,0).
sl@0: 
sl@0: @see	CDirectGdiContext::SetBrushPattern()
sl@0: 
sl@0: @param	aOrigin	An origin point for the brush. The coordinates are relative 
sl@0: 		to the rectangle to fill, i.e. specify TPoint(0,0) to align the pattern flush with 
sl@0: 		the top and left hand sides of the rectangle.
sl@0: 
sl@0: @pre	None.
sl@0: @post	New brush origin will be used when filling an area with a pattern is used on 
sl@0: 		subsequent drawing operations. It remains in effect until another SetBrushOrigin()
sl@0: 		with a different parameter is called.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetBrushOrigin(const TPoint& aOrigin)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::SetBrushOrigin(%d,%d)", aOrigin.iX, aOrigin.iY);
sl@0: 	if (aOrigin != iBrushOrigin)
sl@0: 		{
sl@0: 		iBrushOrigin = aOrigin;
sl@0: 		iEngine->SetBrushOrigin(iBrushOrigin);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the brush style used when filling the area of shapes and the background of text boxes.
sl@0: Use ENullBrush to draw the outline of a fillable shape on its own, without filling.
sl@0: 
sl@0: The error state is set to KErrArgument if aBrushStyle is an invalid brush style.
sl@0: 
sl@0: @see    DirectGdi::TBrushStyle
sl@0: 
sl@0: @param	aBrushStyle The brush style to set.
sl@0: 
sl@0: @pre	If aBrushStyle is EPatternedBrush, a pattern must have been set first using SetBrushPattern().
sl@0: @post	New brush style will be used for subsequent drawing operations, and remains in effect
sl@0: 		until another SetBrushStyle() with a different parameter is called.
sl@0: @panic  DGDI 9, if aBrushStyle is EPatternedBrush but no brush pattern has successfully been set.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetBrushStyle(DirectGdi::TBrushStyle aBrushStyle)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetBrushStyle(%d)", aBrushStyle);
sl@0: 	if (aBrushStyle < DirectGdi::ENullBrush || aBrushStyle > DirectGdi::EDiamondCrossHatchBrush)
sl@0: 		{
sl@0: 		iDriver.SetError(KErrArgument);
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	if (aBrushStyle != iBrushStyle)
sl@0: 		{
sl@0: 		GRAPHICS_ASSERT_ALWAYS(aBrushStyle != DirectGdi::EPatternedBrush || iBrushPatternUsed, EDirectGdiPanicBrushPatternNotSet);
sl@0: 		iBrushStyle = aBrushStyle;
sl@0: 		iEngine->SetBrushStyle(iBrushStyle);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets a clipping region which will be used to clip subsequent rendering operations on the current target.
sl@0: This operation is non-additive, any previous clipping region setting is replaced by the new one. A clipping
sl@0: region can contain one or more rectangles and is specified in absolute values in the target coordinate system.
sl@0: By default (when a target is activated for the first time) no clipping region is set and any drawing 
sl@0: operations will be clipped automatically to the full area of the rendering target.
sl@0: 
sl@0: In the event of a failure, the error state is set to KErrArgument if the given region is invalid or not 
sl@0: fully contained within the area of target, otherwise one of the system-wide error codes.
sl@0: 
sl@0: @see	CDirectGdiContext::ResetClippingRegion()
sl@0: 
sl@0: @param	aRegion	The new clipping region.
sl@0: 
sl@0: @pre	Region is not empty and is fully contained within the full area of the target.
sl@0: @post	Subsequent rendering operations will be clipped to the given region if there is no error 
sl@0: 		while performing the operation, otherwise previous clipping region settings will be retained.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetClippingRegion(const TRegion& aRegion)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::SetClippingRegion");
sl@0: 	if (aRegion.CheckError())
sl@0: 		{
sl@0: 		iDriver.SetError(KErrArgument);
sl@0: 		return;
sl@0: 		}
sl@0: 	iClippingRegion.Copy(aRegion);
sl@0: 	if (iClippingRegion.CheckError())
sl@0: 		{
sl@0: 		iDriver.SetError(KErrNoMemory);
sl@0: 		return;
sl@0: 		}
sl@0: 	iEngine->SetClippingRegion(iClippingRegion);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the drawing mode which will affect the way pen and brush colour are used in rendering operations.
sl@0: The default drawing mode is EDrawModePEN.
sl@0: 
sl@0: The error state is set to KErrArgument if aDrawMode is an invalid draw mode.
sl@0: 
sl@0: @see	DirectGdi::TDrawMode
sl@0: 
sl@0: @param	aDrawMode The drawing mode.
sl@0: 
sl@0: @pre	None.
sl@0: @post	The new drawing mode will be applied to subsequent rendering operations, and remains in effect
sl@0: 		until another SetDrawMode() with a different parameter is called.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetDrawMode(DirectGdi::TDrawMode aDrawMode)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetDrawMode(%d)", aDrawMode);
sl@0: 	if (aDrawMode != DirectGdi::EDrawModePEN && aDrawMode != DirectGdi::EDrawModeWriteAlpha)
sl@0: 		{
sl@0: 		iDriver.SetError(KErrArgument);
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	if (iDrawMode != aDrawMode)
sl@0: 		{
sl@0: 		iDrawMode = aDrawMode;
sl@0: 		iEngine->SetDrawMode(iDrawMode);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the origin of the drawing engine coordinate system. By default this is TPoint(0,0) and
sl@0: coincides with the origin of the target coordinate system which is at the top-left corner of
sl@0: the full area of target. The X value increases from left to right, and Y value increases from
sl@0: top to bottom. Integer values are used to represent the position within the coordinate system. 
sl@0: 
sl@0: All drawing operations are done relative to the engine’s origin. However, the clipping region
sl@0: is always specified in absolute coordinate values (using the target coordinate system) and is
sl@0: not affected by changes to the drawing engine’s coordinate system origin.
sl@0: 
sl@0: @param	aPoint The new origin for the drawing engine’s coordinate system.
sl@0: 
sl@0: @pre	None.
sl@0: @post	The origin of the drawing engine’s coordinate system is moved to the given position.
sl@0: 		All subsequent drawing operations will be done relative to the new origin. The new origin remains
sl@0: 		in effect until SetOrigin() is called again with a different parameter.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetOrigin(const TPoint& aPoint)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::SetOrigin(%d,%d)", aPoint.iX, aPoint.iY);
sl@0: 	if (aPoint != iOrigin)
sl@0: 		{	
sl@0: 		iOrigin = aPoint;
sl@0: 		iEngine->SetOrigin(iOrigin);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the colour that will be used for drawing lines, outlines of filled shapes and text. The 
sl@0: default pen colour is black. For outline and shadow fonts the alpha value of the pen colour will be 
sl@0: used for blending the font to the destination.
sl@0: 
sl@0: @see	CDirectGdiContext::Plot()
sl@0: @see	CDirectGdiContext::DrawLine()
sl@0: @see	CDirectGdiContext::DrawRoundRect()
sl@0: @see	CDirectGdiContext::DrawRect()
sl@0: @see	CDirectGdiContext::DrawPolyLine()
sl@0: @see	CDirectGdiContext::DrawPolyLineNoEndPoint()
sl@0: @see	CDirectGdiContext::DrawPolygon()
sl@0: @see	CDirectGdiContext::DrawPie()
sl@0: @see	CDirectGdiContext::DrawArc()
sl@0: @see	CDirectGdiContext::DrawText()
sl@0: 
sl@0: @param	aColor The pen colour.
sl@0: 
sl@0: @pre	None.
sl@0: @post	The new pen colour will be used for subsequent drawing of lines, outlines of filled shapes and text. 
sl@0: 		The new pen colour remains in effect until another SetPenColor() with a different parameter is called.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetPenColor(const TRgb& aColor)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetPenColor(%d)", aColor.Internal());
sl@0: 	if (aColor != iPenColor)
sl@0: 		{
sl@0: 		iPenColor = aColor;
sl@0: 		iEngine->SetPenColor(iPenColor);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the pen or line drawing style.
sl@0: 
sl@0: The pen style is used to draw lines and outlines of shapes. ENullPen can be used if border or 
sl@0: outlines are not required (when drawing a filled shape). The default pen style is ESolidPen.
sl@0: 
sl@0: The error state is set to KErrArgument if aPenStyle is an invalid pen style.
sl@0: 
sl@0: @see	CDirectGdiContext::Plot()
sl@0: @see	CDirectGdiContext::DrawLine()
sl@0: @see	CDirectGdiContext::DrawRoundRect()
sl@0: @see	CDirectGdiContext::DrawRect()
sl@0: @see	CDirectGdiContext::DrawPolyLine()
sl@0: @see	CDirectGdiContext::DrawPolyLineNoEndPoint()
sl@0: @see	CDirectGdiContext::DrawPolygon()
sl@0: @see	CDirectGdiContext::DrawPie()
sl@0: @see	CDirectGdiContext::DrawArc()
sl@0: @see	DirectGdi::TPenStyle
sl@0: 
sl@0: @param	aPenStyle The pen style.
sl@0: 
sl@0: @pre	None.
sl@0: @post	The new pen style will be applied for subsequent drawing lines and outlines of filled shapes.
sl@0: 		The new pen style remains in effect until another SetPenStyle() with a different parameter is called.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetPenStyle(DirectGdi::TPenStyle aPenStyle)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetPenStyle(%d)", aPenStyle);
sl@0: 	if (aPenStyle < DirectGdi::ENullPen || aPenStyle > DirectGdi::EDotDotDashPen)
sl@0: 		{
sl@0: 		iDriver.SetError(KErrArgument);
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	if (aPenStyle != iPenStyle)
sl@0: 		{
sl@0: 		iPenStyle = aPenStyle;
sl@0: 		iEngine->SetPenStyle(iPenStyle);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the pen size for drawing lines or the outlines of a filled shape. The default pen size is 1.
sl@0: Lines with pen size greater than 1 are drawn with rounded ends that extend beyond the end points
sl@0: and are always drawn using EDrawModePEN for compatibility reasons.
sl@0: 
sl@0: The error state is set to KErrArgument if the specified width or height is negative.
sl@0: 
sl@0: @see	CDirectGdiContext::Plot()
sl@0: @see	CDirectGdiContext::DrawLine()
sl@0: @see	CDirectGdiContext::DrawRoundRect()
sl@0: @see	CDirectGdiContext::DrawRect()
sl@0: @see	CDirectGdiContext::DrawPolyLine()
sl@0: @see	CDirectGdiContext::DrawPolyLineNoEndPoint()
sl@0: @see	CDirectGdiContext::DrawPolygon()
sl@0: @see	CDirectGdiContext::DrawPie()
sl@0: @see	CDirectGdiContext::DrawArc()
sl@0: 
sl@0: @param	aSize The pen size.
sl@0: 
sl@0: @pre	None.
sl@0: @post	The new pen size is used for subsequent drawing lines and outlines of filled shapes. The new 
sl@0: 		pen size remains in effect until another SetPenSize() with a different parameter is called.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetPenSize(const TSize& aSize)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::SetPenSize(%d,%d)", aSize.iWidth, aSize.iHeight);
sl@0: 	if ((aSize.iWidth < 0) || (aSize.iHeight < 0))
sl@0: 		{
sl@0: 		iDriver.SetError(KErrArgument);
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	if (aSize != iPenSize)
sl@0: 		{
sl@0: 		iPenSize = aSize;
sl@0: 		iEngine->SetPenSize(iPenSize);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the colour that will be used for drawing the shadow for shadowed text.
sl@0: 
sl@0: @param	aColor	The shadow colour.
sl@0: 
sl@0: @pre	None.
sl@0: @post	The new colour will be used for subsequent drawing of text which has a type EFourColourBlendGlyphBitmap. 
sl@0: 		The shadow component of the text will be filled with this colour.
sl@0: 		The new pen colour remains in effect until another SetTextShadowColor() with a different parameter is called.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetTextShadowColor(const TRgb& aColor)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetTextShadowColor(%d)", aColor.Internal());
sl@0: 	if (aColor != iTextShadowColor)
sl@0: 		{
sl@0: 		iTextShadowColor = aColor;
sl@0: 		iEngine->SetTextShadowColor(aColor);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the character justification.
sl@0: The function provides a concrete implementation of the pure virtual function CGraphicsContext::SetCharJustification().
sl@0: The function behaviour is the same as documented (in detail) in that class.
sl@0: 
sl@0: @param	aExcessWidth	The excess width (in pixels) to be distributed between the specified number of characters. 
sl@0: @param	aNumChars		The number of characters involved.
sl@0: 
sl@0: @see	CGraphicsContext::SetCharJustification()
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetCharJustification(TInt aExcessWidth, TInt aNumChars)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::SetCharJustification(%d,%d)", aExcessWidth, aNumChars);
sl@0: 	if (aExcessWidth == 0 || aNumChars <= 0)
sl@0: 		{
sl@0: 		iCharJustExcess = 0;
sl@0: 		iCharJustNum = 0;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iCharJustExcess = aExcessWidth;
sl@0: 		iCharJustNum = aNumChars;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the word justification.
sl@0: The function provides a concrete implementation of the pure virtual function CGraphicsContext::SetWordJustification().
sl@0: The function behaviour is the same as documented (in detail) in that class.
sl@0: 
sl@0: @param	aExcessWidth	The width (in pixels) to be distributed between the specified number of spaces.
sl@0: 						It may be positive, in which case the text is stretched, or negative, in which case it is shrunk. 
sl@0: @param	aNumGaps		The number of word spaces (characters with the code U+0020) over which the change in width is distributed.
sl@0: 
sl@0: @see CGraphicsContext::SetWordJustification()
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetWordJustification(TInt aExcessWidth, TInt aNumGaps)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE2("CDirectGdiContext::SetWordJustification(%d,%d)", aExcessWidth, aNumGaps);
sl@0: 	if (aExcessWidth <= 0 || aNumGaps <= 0)
sl@0: 		{
sl@0: 		iWordJustExcess = 0;
sl@0: 		iWordJustNum = 0;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iWordJustExcess = aExcessWidth;
sl@0: 		iWordJustNum = aNumGaps;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the underline style for all subsequently drawn text.
sl@0: The function provides a concrete implementation of the pure virtual function CGraphicsContext::SetUnderlineStyle().
sl@0: The function behaviour is the same as documented in that class.
sl@0: 
sl@0: @param	aUnderlineStyle	The underline style to be used.
sl@0: 
sl@0: @see	CGraphicsContext::SetUnderlineStyle()
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetUnderlineStyle(DirectGdi::TFontUnderline aUnderlineStyle)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetWordJustification(%d)", aUnderlineStyle);
sl@0: 	iUnderline = aUnderlineStyle;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the strikethrough style for all subsequently drawn text.
sl@0: The function provides a concrete implementation of the pure virtual function CGraphicsContext::SetStrikethroughStyle().
sl@0: The function behaviour is the same as documented in that class.
sl@0: 
sl@0: @param	aStrikethroughStyle	The strikethrough style to be used.
sl@0: 
sl@0: @see	CGraphicsContext::SetStrikethroughStyle()
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetStrikethroughStyle(DirectGdi::TFontStrikethrough aStrikethroughStyle)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetStrikethroughStyle(%d)", aStrikethroughStyle);
sl@0: 	iStrikethrough = aStrikethroughStyle;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the bitmap to be used as the brush pattern when EPatternedBrush is selected.
sl@0: The DirectGDI generic layer owns the bitmap and will keep the bitmap until ResetBrushPattern() is called.
sl@0: 
sl@0: The client may modify the content of the bitmap used as the brush pattern. If this is done after 
sl@0: issuing drawing commands there is no guarantee which bitmap content will be used as brush pattern.
sl@0: Clients must call Finish() on the driver before modifying the bitmap content if they want a guaranteed 
sl@0: result that the previously issued drawing commands will be drawn using the old bitmap brush pattern.
sl@0: 
sl@0: In the event of a failure, the error state is set to KErrCouldNotConnect if no connection to the font 
sl@0: and bitmap server could be made, KErrBadHandle if the handle of the bitmap is null, KErrUnknown if 
sl@0: no bitmap could be found with the specified handle number, otherwise one of the system-wide error codes.
sl@0: 
sl@0: @see	CDirectGdiContext::SetBrushStyle()
sl@0: @see	CDirectGdiContext::SetBrushOrigin()
sl@0: @see	CDirectGdiContext::ResetBrushPattern()
sl@0: 
sl@0: @param	aBitmap	Bitmap that will be used as the brush pattern.
sl@0: 
sl@0: @pre	Bitmap is fully constructed.
sl@0: @post	Bitmap will be used as the brush pattern for subsequent drawing operations when EPatternedBrush
sl@0: 		is selected. It remains in effect until ResetBrushPattern() is called.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetBrushPattern(const CFbsBitmap& aBitmap)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetBrushPattern(%d)", aBitmap.Handle());
sl@0: 	SetBrushPattern(aBitmap.Handle());
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the bitmap to be used as the brush pattern when EPatternedBrush is selected.
sl@0: The DirectGDI generic layer owns the bitmap and will keep the bitmap until ResetBrushPattern() is called.
sl@0: If the client modifies the content of the bitmap used as the brush pattern after issuing any drawing 
sl@0: commands that uses that brush pattern, the method does not guarantee whether the old bitmap 
sl@0: content or the new one will be used as brush pattern. Clients must call Finish() on the driver 
sl@0: before modifying the bitmap content if they want a guaranteed result that the previously issued 
sl@0: drawing commands will be drawn using the old bitmap brush pattern.
sl@0: 
sl@0: In the event of a failure, the error state is set to KErrCouldNotConnect if no connection to the font 
sl@0: and bitmap server could be made, KErrBadHandle if the handle is null, KErrUnknown if no bitmap could 
sl@0: be found with the specified handle number, otherwise one of the system-wide error codes.
sl@0: 
sl@0: @param	aFbsBitmapHandle Bitmap handle that will be used as the brush pattern.
sl@0: 
sl@0: @pre 	Bitmap belonging to the handle is fully constructed.
sl@0: @post 	Bitmap will be used as the brush pattern for subsequent drawing operations when EPatternedBrush
sl@0: 		is selected. It remains in effect until ResetBrushPattern() is called.
sl@0: @panic	DGDI 8, if aFbsBitmapHandle is 0.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetBrushPattern(TInt aFbsBitmapHandle)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE1("CDirectGdiContext::SetBrushPattern(%d)", aFbsBitmapHandle);
sl@0: 	if (aFbsBitmapHandle == KNullHandle)
sl@0: 		{
sl@0: 		iDriver.SetError(KErrBadHandle);
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	// Check we're not already using the passed brush pattern
sl@0: 	if (iBrushPattern.Handle() == aFbsBitmapHandle)
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	// Delete any previously saved brush pattern
sl@0: 	CleanUpBrushPattern();
sl@0: 
sl@0: 	TInt result = iBrushPattern.Duplicate(aFbsBitmapHandle);
sl@0: 	if (result == KErrNone)
sl@0: 		{
sl@0: 		result = iEngine->SetBrushPattern(iBrushPattern);
sl@0: 		}
sl@0: 	
sl@0: 	if (result == KErrNone)
sl@0: 		{
sl@0: 		iBrushPatternUsed = ETrue;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iDriver.SetError(result);
sl@0: 		}
sl@0: 
sl@0: 	return;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Selects the font to be used for text drawing.
sl@0: Notes:
sl@0: When the font is no longer required, use ResetFont() to free up the memory used. 
sl@0: If SetFont() is used again without using ResetFont() then the previous font is reset 
sl@0: automatically. If no font has been selected, and an attempt is made to draw text with 
sl@0: DrawText(), then a panic occurs.
sl@0: 
sl@0: @see	CDirectGdiContext::ResetFont()
sl@0: @see	CDirectGdiContext::DrawText()
sl@0: 
sl@0: @param	aFont The font to be used.
sl@0: 
sl@0: @panic	DGDI 12, if aFont has an invalid handle or is not a CFbsFont, or the font cannot be duplicated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetFont(const CFont* aFont)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::SetFont");
sl@0: 	// Note: We pass a ptr in, rather than a reference, because otherwise the caller would almost always have to do complex casting 
sl@0: 	GRAPHICS_ASSERT_ALWAYS(aFont->TypeUid() == KCFbsFontUid, EDirectGdiPanicInvalidFont);
sl@0: 	const CDirectGdiFont* font = reinterpret_cast<const CDirectGdiFont*>(aFont);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(font->Handle(), EDirectGdiPanicInvalidFont);
sl@0: 
sl@0: 	if (iFont.Handle() == font->Handle())
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	ResetFont();
sl@0: 	TInt err = iFont.Duplicate(font->Handle());
sl@0: 	GRAPHICS_ASSERT_ALWAYS(err == KErrNone, EDirectGdiPanicInvalidFont); // This may seem extreme but it is what BitGdi did
sl@0: 	iEngine->SetFont(iFont.Address()->UniqueFontId());
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Copies the content of a rectangular area on the target to another location.
sl@0: The source rect will be intersected with the target’s full extent.
sl@0: 
sl@0: @param	aOffset	Offset from the top left corner of the rectangle to be copied to the top left corner of the copy.
sl@0: @param	aRect Area to be copied.
sl@0: 
sl@0: @pre	The rendering target has been activated.
sl@0: @post	Request to copy an area has been accepted. There is no guarantee that the
sl@0: 		request has been processed when this method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::CopyRect(const TPoint& aOffset, const TRect& aRect)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::CopyRect");
sl@0: 	if (aRect.IsEmpty() || aOffset == TPoint(0,0))
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	iEngine->CopyRect(aOffset, aRect);
sl@0: 	}
sl@0: 
sl@0: /** 
sl@0: Copies all settings from the specified DirectGDI context.
sl@0: 
sl@0: @param aGc The DirectGDI context whose settings are to be copied. 
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::CopySettings(const CDirectGdiContext& aGc)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::CopySettings");
sl@0: 	SetOrigin(aGc.iOrigin);
sl@0: 	SetFont(&(aGc.iFont));
sl@0: 	SetCharJustification(aGc.iCharJustExcess, aGc.iCharJustNum);
sl@0: 	SetWordJustification(aGc.iWordJustExcess, aGc.iWordJustNum);
sl@0: 	iLastPrintPosition = aGc.iLastPrintPosition;
sl@0: 	SetStrikethroughStyle(aGc.iStrikethrough);
sl@0: 	SetUnderlineStyle(aGc.iUnderline);
sl@0: 	SetPenColor(aGc.iPenColor);
sl@0: 	SetPenSize(aGc.iPenSize);
sl@0: 	SetPenStyle(aGc.iPenStyle);
sl@0: 	SetDrawMode(aGc.iDrawMode);
sl@0: 	SetTextShadowColor(aGc.iTextShadowColor);
sl@0: 	SetBrushColor(aGc.iBrushColor);
sl@0: 	SetBrushStyle(aGc.iBrushStyle);
sl@0: 	if(aGc.iBrushPattern.Handle())
sl@0: 		{
sl@0: 		SetBrushPattern(aGc.iBrushPattern.Handle());
sl@0: 		}
sl@0: 	iBrushPatternUsed = aGc.iBrushPatternUsed;
sl@0: 	SetBrushOrigin(aGc.iBrushOrigin);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Updates the justification settings.
sl@0: This function assumes that NoJustifyAutoUpdate() has not been used.
sl@0: 
sl@0: @param	aText	The text for which justification is to be adjusted.
sl@0: @param	aParam	Parameters used in drawing text.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 13, if NoJustifyAutoUpdate() had been called prior to this.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::UpdateJustification(const TDesC& aText, const DirectGdi::TTextParameters* aParam)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::UpdateJustification");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iAutoUpdateJustification, EDirectGdiPanicAutoUpdateJustificationUsed);
sl@0: 	if (((iCharJustNum < 1) || (iCharJustExcess == 0)) && ((iWordJustNum < 1) || (iWordJustExcess < 1)))
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	TInt length = aText.Length();
sl@0: 	CFont::TPositionParam param;
sl@0: 	param.iText.Set(aText);	// Set the start of the string
sl@0: 	if (aParam)
sl@0: 		{
sl@0: 		length = aParam->iEnd;
sl@0: 		param.iPosInText = aParam->iStart;
sl@0: 		}
sl@0: 	TInt excess = 0;
sl@0: 	TInt glyphs = 0;
sl@0: 	RShapeInfo shapeInfo;
sl@0: 	for (TInt count = 0; count < length; count++)
sl@0: 		{
sl@0: 		if ((iCharJustNum > 0) && (iCharJustExcess != 0))
sl@0: 			{
sl@0: 			excess += CGraphicsContext::JustificationInPixels(iCharJustExcess, iCharJustNum);
sl@0: 			}
sl@0: 		if ((iWordJustNum > 0) && (iWordJustExcess > 0) && (aText[count] == ' '))
sl@0: 			{
sl@0: 			excess += CGraphicsContext::JustificationInPixels(iWordJustExcess, iWordJustNum);
sl@0: 			}
sl@0: 		if (iCharJustNum < (glyphs + length - count)) // there's at least 1 combined glyph to come
sl@0: 			{
sl@0: 			// otherwise we can skip this slow bit and just increment
sl@0: 			if (iFont.GetCharacterPosition2(param, shapeInfo))
sl@0: 				{
sl@0: 				count = param.iPosInText - 1;   // -1 'cos it gets incremented anyway
sl@0: 				}
sl@0: 			}
sl@0: 		glyphs++;
sl@0: 		}
sl@0: 	if (shapeInfo.IsOpen())
sl@0: 		{
sl@0: 		shapeInfo.Close();
sl@0: 		}
sl@0: 	iLastPrintPosition.iX += excess;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Updates the justification for vertical text.
sl@0: This function assumes that NoJustifyAutoUpdate() has not been used.
sl@0: 
sl@0: @param	aText	The text for which justification is to be adjusted.
sl@0: @param	aParam	Parameters used in drawing text.
sl@0: @param	aUp		ETrue, if text is to be justified upwards; EFalse, if text is to be justified downwards.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: @panic	DGDI 13, if NoJustifyAutoUpdate() had been called prior to this.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::UpdateJustificationVertical(const TDesC& aText, const DirectGdi::TTextParameters* aParam, TBool aUp)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::UpdateJustificationVertical");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iAutoUpdateJustification, EDirectGdiPanicAutoUpdateJustificationUsed);
sl@0: 
sl@0: 	if (((iCharJustNum < 1) || (iCharJustExcess == 0)) && ((iWordJustNum < 1) || (iWordJustExcess < 1)))
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	TInt length = aText.Length();
sl@0: 	CFont::TPositionParam param;
sl@0: 	param.iText.Set(aText);	// Set the start of the string
sl@0: 	if (aParam)
sl@0: 		{
sl@0: 		length = aParam->iEnd;
sl@0: 		param.iPosInText = aParam->iStart;
sl@0: 		}
sl@0: 	TInt excess = 0;
sl@0: 	TInt glyphs = 0;
sl@0: 	RShapeInfo shapeInfo;
sl@0: 	for (TInt count = 0; count < length; count++)
sl@0: 		{
sl@0: 		if ((iCharJustNum > 0) && (iCharJustExcess != 0))
sl@0: 			{
sl@0: 			excess += CGraphicsContext::JustificationInPixels(iCharJustExcess, iCharJustNum);
sl@0: 			}
sl@0: 		if ((iWordJustNum > 0) && (iWordJustExcess > 0) && (aText[count] == ' '))
sl@0: 			{
sl@0: 			excess += CGraphicsContext::JustificationInPixels(iWordJustExcess, iWordJustNum);
sl@0: 			}
sl@0: 		if (iCharJustNum < (glyphs + length - count)) // there's at least 1 combined glyph to come
sl@0: 			{
sl@0: 			// otherwise we can skip this slow bit and just increment
sl@0: 			if (iFont.GetCharacterPosition2(param, shapeInfo))
sl@0: 				{
sl@0: 				count = param.iPosInText - 1;   // -1 because it gets incremented anyway
sl@0: 				}
sl@0: 			}
sl@0: 		glyphs++;
sl@0: 		}
sl@0: 		if (shapeInfo.IsOpen())
sl@0: 			{
sl@0: 			shapeInfo.Close();
sl@0: 			}
sl@0: 
sl@0: 		if (aUp)
sl@0: 			{
sl@0: 			iLastPrintPosition.iY -= excess;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iLastPrintPosition.iY += excess;
sl@0: 			}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Selects a font for text drawing but does not take a copy. 
sl@0: The original must not be destroyed until SetFont(), SetFontNoDuplicate(), ResetFont() 
sl@0: or the destructor is called.
sl@0: 
sl@0: @param	aFont A pointer to the font to be used.
sl@0: @panic	DGDI 12, if aFont has no handle or is not a CFbsFont.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::SetFontNoDuplicate(const CDirectGdiFont* aFont)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::SetFontNoDuplicate");
sl@0: 	// Note: We pass a ptr in, rather than a reference, because otherwise the caller would almost always have to do complex casting 
sl@0: 	GRAPHICS_ASSERT_ALWAYS(aFont->TypeUid() == KCFbsFontUid, EDirectGdiPanicInvalidFont);
sl@0: 	GRAPHICS_ASSERT_ALWAYS(aFont->Handle(), EDirectGdiPanicInvalidFont);
sl@0: 
sl@0: 	if (iFont.Handle() == aFont->Handle())
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	ResetFont();
sl@0: 	iFont = *aFont;
sl@0: 	iEngine->SetFont(iFont.Address()->UniqueFontId());
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Checks to see if a brush pattern is currently set.
sl@0: 
sl@0: @return	ETrue is a brush pattern is currently set, EFalse if no brush pattern is currently set.
sl@0: */
sl@0: EXPORT_C TBool CDirectGdiContext::HasBrushPattern() const
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::HasBrushPattern");
sl@0: 	return iBrushPatternUsed;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Tests whether a font is used.
sl@0: 
sl@0: @return	ETrue, if a font is being used; EFalse, otherwise.
sl@0: */
sl@0: EXPORT_C TBool CDirectGdiContext::HasFont() const
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::HasFont");
sl@0: 	TBool result = EFalse;
sl@0: 	if (iFont.Handle() != KNullHandle)
sl@0: 		result = ETrue;
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Externalises the context and the drawing engine object to the write stream.
sl@0: It is important that the font and brush bitmap of the GC is maintained between
sl@0: calls to ExternalizeL() and InternalizeL().  The font handle and brush bitmap handle
sl@0: is externalised, not the underlying data.  This is done for performance reasons.
sl@0: 
sl@0: @param	aWriteStream Write stream.
sl@0: 
sl@0: @pre	None.
sl@0: @post	The context and drawing engine object states are written to the write stream.
sl@0: 
sl@0: @see	MDirectGdiEngine::InternalizeL
sl@0: @leave	If there was an error writing to the write stream.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::ExternalizeL(RWriteStream& aWriteStream)
sl@0: 	{	
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::ExternalizeL");
sl@0: 	aWriteStream << KDirectGDIContext_VerNo;
sl@0: 	iEngine->ExternalizeL(aWriteStream);
sl@0: 
sl@0: 	aWriteStream << iOrigin;
sl@0: 	aWriteStream.WriteInt32L(iFont.Handle());
sl@0: 	aWriteStream.WriteInt32L(iCharJustExcess);
sl@0: 	aWriteStream.WriteInt32L(iCharJustNum);
sl@0: 	aWriteStream.WriteInt32L(iWordJustExcess);
sl@0: 	aWriteStream.WriteInt32L(iWordJustNum);
sl@0: 	aWriteStream << iLastPrintPosition;
sl@0: 	aWriteStream.WriteUint8L(iStrikethrough); 
sl@0: 	aWriteStream.WriteUint8L(iUnderline);
sl@0: 	aWriteStream << iPenColor;
sl@0: 	aWriteStream.WriteUint32L(iPenSize.iWidth);
sl@0: 	aWriteStream.WriteUint32L(iPenSize.iHeight);
sl@0: 	aWriteStream.WriteUint8L(iPenStyle);
sl@0: 	aWriteStream.WriteUint8L(iDrawMode);
sl@0: 	aWriteStream << iTextShadowColor;
sl@0: 	aWriteStream << iBrushColor;
sl@0: 	aWriteStream.WriteInt32L(iBrushPattern.Handle());
sl@0: 	aWriteStream.WriteUint8L(iBrushStyle);
sl@0: 	aWriteStream.WriteUint8L(iBrushPatternUsed);
sl@0: 	aWriteStream << iBrushOrigin;
sl@0: 	aWriteStream.WriteUint8L(iAutoUpdateJustification);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Internalises the context and the drawing engine object from the read stream.
sl@0: It is important that the font and brush bitmap of the GC is maintained between
sl@0: calls to ExternalizeL() and InternalizeL().  The font handle and brush bitmap handle
sl@0: is externalised, not the underlying data.  This is done for performance reasons.
sl@0: 
sl@0: @param	aReadStream	Read stream.
sl@0: 
sl@0: @pre	The font has not been released since the last call of CDirectGdiContext::ExternalizeL on the stream
sl@0: @pre	The handle of the brush pattern bitmap has not been closed since the call to CDirectGdiContext::ExternalizeL on the stream.
sl@0: @post	The context and drawing engine object states are updated with the values from the read stream.
sl@0: 
sl@0: @see	MDirectGdiEngine::ExternalizeL
sl@0: @leave	If there was an error reading from the read stream.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::InternalizeL(RReadStream& aReadStream)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::InternalizeL");
sl@0: 	TUint16 archiveVerNo = 0;
sl@0: 	aReadStream >> archiveVerNo;
sl@0: 	iEngine->InternalizeL(aReadStream);
sl@0: 	
sl@0: 	TPoint origin;
sl@0: 	aReadStream >> origin;
sl@0: 	SetOrigin(origin);
sl@0: 	ResetFont();
sl@0: 	TInt fontHandle = aReadStream.ReadInt32L();
sl@0: 	if(fontHandle)
sl@0: 		{
sl@0: 		TInt res = iFont.Duplicate(fontHandle);
sl@0: 		if(res == KErrNone)
sl@0: 			{
sl@0: 			iEngine->SetFont(iFont.Address()->UniqueFontId());
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iDriver.SetError(res);
sl@0: 			}
sl@0: 		}
sl@0: 	iCharJustExcess = aReadStream.ReadUint32L();
sl@0: 	iCharJustNum = aReadStream.ReadUint32L();
sl@0: 	iWordJustExcess = aReadStream.ReadUint32L();
sl@0: 	iWordJustNum = aReadStream.ReadUint32L();
sl@0: 	aReadStream >> iLastPrintPosition;
sl@0: 	iStrikethrough = (DirectGdi::TFontStrikethrough)aReadStream.ReadUint8L(); 
sl@0: 	iUnderline = (DirectGdi::TFontUnderline)aReadStream.ReadUint8L();
sl@0: 	TRgb penColor;
sl@0: 	aReadStream >> penColor;
sl@0: 	SetPenColor(penColor);
sl@0: 	TSize penSize;
sl@0: 	penSize.iWidth = aReadStream.ReadUint32L();
sl@0: 	penSize.iHeight = aReadStream.ReadUint32L();
sl@0: 	SetPenSize(penSize);
sl@0: 	DirectGdi::TPenStyle penStyle = (DirectGdi::TPenStyle)aReadStream.ReadUint8L();
sl@0: 	SetPenStyle(penStyle);
sl@0: 	DirectGdi::TDrawMode drawMode = (DirectGdi::TDrawMode)aReadStream.ReadUint8L();
sl@0: 	SetDrawMode(drawMode);
sl@0: 	TRgb textShadowColor;
sl@0: 	aReadStream >> textShadowColor;
sl@0: 	SetTextShadowColor(textShadowColor);
sl@0: 	TRgb brushColor;
sl@0: 	aReadStream >> brushColor;
sl@0: 	SetBrushColor(brushColor);
sl@0: 	TInt patternHandle = aReadStream.ReadInt32L();
sl@0: 	if (patternHandle)
sl@0: 		{
sl@0: 		// Brush pattern must be set before style, otherwise there'll be a panic!
sl@0: 		SetBrushPattern(patternHandle);
sl@0: 		}
sl@0: 	DirectGdi::TBrushStyle brushStyle;
sl@0: 	brushStyle = (DirectGdi::TBrushStyle)aReadStream.ReadInt8L();
sl@0: 	SetBrushStyle(brushStyle);
sl@0: 	iBrushPatternUsed = (TBool)aReadStream.ReadUint8L();
sl@0: 	TPoint brushOrigin;
sl@0: 	aReadStream >> brushOrigin;
sl@0: 	SetBrushOrigin(brushOrigin);
sl@0: 	iAutoUpdateJustification = (TBool)aReadStream.ReadUint8L();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Retrieves the currently set brush colour.
sl@0: 
sl@0: @return	The current brush colour.
sl@0: */
sl@0: EXPORT_C TRgb CDirectGdiContext::BrushColor() const
sl@0: 	{	
sl@0: 	return iBrushColor;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Retrieves the currently set pen colour.
sl@0: 
sl@0: @return	The current pen colour.
sl@0: */
sl@0: EXPORT_C TRgb CDirectGdiContext::PenColor() const
sl@0: 	{
sl@0: 	return iPenColor;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves the currently set text shadow colour.
sl@0: 
sl@0: @return	The current text shadow colour.
sl@0: */
sl@0: EXPORT_C TRgb CDirectGdiContext::TextShadowColor() const
sl@0: 	{
sl@0: 	return iTextShadowColor;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Draws an image based resource which may be generated using non-native rendering API such as OpenGL ES 
sl@0: or OpenVG. The resource will be drawn at the specified position in its original size with orientation 
sl@0: according to the specified rotation parameter. The current clipping region applies. The resource can be
sl@0: drawn rotated using the DirectGdi::TGraphicsRotation enum which defines possible rotation values in 
sl@0: clockwise degrees.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @param	aPos		The position of the top-left corner of the resource.
sl@0: @param	aSource		The resource to be drawn.
sl@0: @param	aRotation	The rotation to be applied to the resource before it is drawn. The default value is DirectGdi::EGraphicsRotationNone.
sl@0: 
sl@0: @pre	Drawing context has been activated on a rendering target. The resource has been fully constructed.
sl@0: @post	Request to draw resource has been accepted. There is no guarantee that the request has been completed 
sl@0: 		when this method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawResource(
sl@0: 		const TPoint& aPos,
sl@0: 		const RDirectGdiDrawableSource& aSource,
sl@0: 		DirectGdi::TGraphicsRotation aRotation)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawResource");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	
sl@0: 	if (aSource.Handle() != KNullHandle)		
sl@0: 		{
sl@0: 		iEngine->DrawResource(aPos, aSource, aRotation);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iDriver.SetError(KErrBadHandle);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Draws an image based resource. The resource will be rendered to the given destination rectangle on 
sl@0: rendering target in its original dimensions with orientation according to the specified rotation parameter. 
sl@0: Drawing will be clipped to the given destination rectangle. The current clipping region applies. 
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @param	aDestRect	Destination rectangle to which the resource will be rendered.
sl@0: @param	aSource		The resource to be drawn.
sl@0: @param	aRotation	Rotation to be applied to the resource before it is drawn. Default value is DirectGdi::EGraphicsRotationNone.
sl@0: 
sl@0: @pre	Drawing context has been activated on a rendering target. The resource has been fully constructed.
sl@0: @post	Request to draw resource has been accepted. There is no guarantee that the request has been completed 
sl@0: 		when this method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawResource(const TRect& aDestRect,
sl@0: 											const RDirectGdiDrawableSource& aSource,
sl@0: 											DirectGdi::TGraphicsRotation aRotation)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawResource");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 
sl@0: 	if (aSource.Handle() != KNullHandle)		
sl@0: 		{	
sl@0: 		if ((aDestRect.Width() > 0) && (aDestRect.Height() > 0))
sl@0: 			{
sl@0: 			iEngine->DrawResource(aDestRect, aSource, aRotation);
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iDriver.SetError(KErrBadHandle);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws an image based resource. The resource is rendered into the given destination rectangle.
sl@0: Scaling (stretching or compression) applies if the destination rectangle is different from the
sl@0: source rectangle. The resource orientation is set based on the specified rotation parameter
sl@0: before scaling and drawing operations are performed.
sl@0: 
sl@0: If the user modifies the content of the resource after issuing a DrawResource() command (from the
sl@0: same thread), the adaptation must make sure that the user’s operations are serialised within
sl@0: that thread, for example, DrawResource() is processed before the modify operations. The adaptation
sl@0: does not guarantee the result if the resource modification is performed from threads other than
sl@0: the one that issued the DrawResource() command. To achieve a guaranteed result in that case, users
sl@0: must perform synchronisation between any threads that operate on the resource and issue Finish()
sl@0: on the driver whenever necessary. When using other renderers or mappings, synchronisation is needed 
sl@0: even when this is from within the same thread.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @param	aDestRect	The destination rectangle to which the resource will be rendered.
sl@0: @param	aSource		The resource to draw.
sl@0: @param	aSrcRect	The source rectangle specifying the area/sub-area of the resource to be rendered.
sl@0: @param	aRotation	Rotation to be applied to the resource before it is drawn
sl@0: 
sl@0: @pre	The rendering target has been activated. The resource has been fully constructed.
sl@0: @post	Request to draw an image based resource has been accepted. There is no guarantee that the
sl@0: 		request has been completed when this method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawResource(
sl@0: 		const TRect& aDestRect,
sl@0: 		const RDirectGdiDrawableSource& aSource,
sl@0: 		const TRect& aSrcRect,
sl@0: 		DirectGdi::TGraphicsRotation aRotation)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawResource");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);
sl@0: 	
sl@0: 	if (aSource.Handle() != KNullHandle)		
sl@0: 		{
sl@0: 		if ((aDestRect.Width() > 0) && (aDestRect.Height() > 0)
sl@0: 			&& (aSrcRect.Width() > 0) && (aSrcRect.Height() > 0))
sl@0: 			{
sl@0: 			iEngine->DrawResource(aDestRect, aSource, aSrcRect, aRotation);
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iDriver.SetError(KErrBadHandle);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Draws a non-image based resource. The resource will be rendered into the given destination rectangle.
sl@0: The current clipping region applies. The adaptation is free to interpret the parameters and may define
sl@0: their own rules on how to handle the rendering of a non-image based resource.
sl@0: 
sl@0: In the event of a failure, the error state is set to one of the system-wide error codes.
sl@0: 
sl@0: @param	aDestRect	The destination rectangle to which the resource will be rendered.
sl@0: @param	aSource		The resource.
sl@0: @param	aParam		Parameters specifying how to draw the resource. 
sl@0: 
sl@0: @pre	The rendering target has been activated. The resource has been fully constructed.
sl@0: @post	Request to draw a non-image based resource has been accepted. 
sl@0: 		There is no guarantee that the request has been completed when this method returns.
sl@0: 
sl@0: @panic	DGDI 7, if the rendering context has not been activated.
sl@0: */
sl@0: EXPORT_C void CDirectGdiContext::DrawResource(
sl@0: 		const TRect& aDestRect,
sl@0: 		const RDirectGdiDrawableSource& aSource,
sl@0: 		const TDesC8& aParam)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::DrawResource");
sl@0: 	GRAPHICS_ASSERT_ALWAYS(iActivated, EDirectGdiPanicContextNotActivated);	
sl@0: 	
sl@0: 	if (aSource.Handle() != KNullHandle)		
sl@0: 		{
sl@0: 		if ((aDestRect.Width() > 0) && (aDestRect.Height() > 0))
sl@0: 			{
sl@0: 			iEngine->DrawResource(aDestRect, aSource, aParam);
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iDriver.SetError(KErrBadHandle);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves a pointer to an instance of the appropriate extension interface implementation.
sl@0: 
sl@0: @param aInterfaceId Interface identifier of the interface to be retrieved.	
sl@0: @param aInterface On return, holds the specified interface, or NULL if the interface cannot be found.
sl@0: 
sl@0: @pre    None.
sl@0: @post   None.
sl@0: 
sl@0: @return KErrNone If the interface is supported, KErrNotSupported otherwise.
sl@0:  */
sl@0: EXPORT_C TInt CDirectGdiContext::GetInterface(TUid aInterfaceId, TAny*& aInterface)
sl@0: 	{
sl@0: 	GRAPHICS_TRACE("CDirectGdiContext::GetInterface");
sl@0: 	return iEngine->GetInterface(aInterfaceId, aInterface);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Release the brush pattern's handle, and mark it as no longer used.
sl@0: */
sl@0: void CDirectGdiContext::CleanUpBrushPattern()
sl@0: 	{
sl@0: 	iBrushPattern.Reset();
sl@0: 	iBrushPatternUsed = EFalse;	
sl@0: 	}
sl@0: 
sl@0: /** 
sl@0: @internalTechnology
sl@0: 
sl@0: Returns the baseline correction associated with this font.
sl@0: This value is used to alter the underline/strikethrough position applied to linked fonts.
sl@0: 
sl@0: @return The baseline correction value set by the rasterizer; or 0 if not set
sl@0: */	
sl@0: TInt CDirectGdiContext::BaselineCorrection()
sl@0: 	{
sl@0: 	TOpenFontMetrics metrics;
sl@0: 	if (iFont.GetFontMetrics(metrics))
sl@0: 		return metrics.BaselineCorrection();
sl@0: 	else
sl@0: 		return 0;
sl@0: 	}