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

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #ifndef VGENGINE_H_

 #define VGENGINE_H_

 /**

 @file

 @internalComponent Reference implementation of Open VG hardware accelerated DirectGDI adaptation.

 */

 #include "directgdidriverimpl.h"

 #include "directgdiadapter.h"

 #include "clippingregionmanager.h"

 #include <bitdraworigin.h>

 #include <graphics/directgdiengine.h>

 #include <graphics/sgimage.h>

 #include <VG/openvg.h>

 #include <VG/vgu.h>

 #include <gdi.h>

 class CDirectGdiDriverImpl;

 #ifdef DRAWGLYPH_BUFFERED

 const TInt KMaxGlyphs = 64;

 typedef struct TDrawGlyphCommand_Tag

 {

 	TPoint pos;

 	TChar aChar;

 	TUint8* aGlyphImage;

 	TGlyphBitmapType aGlyphBitmapType;

 	TSize aGlyphImageSize;

 	TRect aClipRect;

 	DirectGdi::TGraphicsRotation aRotation;	

 	TBool SameGlyph(const TDrawGlyphCommand_Tag aOther)

 		{ 

 		return aGlyphImage == aOther.aGlyphImage && 

 				aChar == aOther.aChar && 

 				aGlyphImage == aOther.aGlyphImage && 

 				aGlyphBitmapType == aOther.aGlyphBitmapType && 

 				aGlyphImageSize == aOther.aGlyphImageSize;

 		}

 } TDrawGlyphCommand;

 #endif

 /**

 Concrete (reference) implementation of a MDirectGdiEngine.

 This class implements the rendering mechanism for DirectGDI. In this case,

 OpenVG is used to get things done, so hardware acceleration is used.

 */

 NONSHARABLE_CLASS(CVgEngine): public CBase, public MDirectGdiEngine, public MDrawDeviceOrigin

 	{

 public:

 	virtual ~CVgEngine();

 	CVgEngine(CDirectGdiDriverImpl& aDriver);

 	// from MDirectGdiEngine

 	TInt Activate(RDirectGdiImageTarget& aTarget);

 	void Deactivate();

 	void SetOrigin(const TPoint& aOrigin);

 	void SetClippingRegion(const TRegion& aRegion);

 	void ResetClippingRegion();

 	void SetDrawMode(DirectGdi::TDrawMode aMode);

 	void SetPenColor(const TRgb& aColor);

 	void SetPenStyle(DirectGdi::TPenStyle aStyle);

 	void SetPenSize(const TSize& aSize);

 	void SetTextShadowColor(const TRgb& aColor);

 	void SetBrushColor(const TRgb& aColor);

 	void SetBrushStyle(DirectGdi::TBrushStyle aStyle);

 	void SetBrushOrigin(const TPoint& aOrigin);

 	TInt SetBrushPattern(const CFbsBitmap& aPattern);

 	void ResetBrushPattern();

 	void SetFont(TUint32 aFontId);

 	void ResetFont();

 	void Reset();

 	void Clear(const TRect& aRect);

 	void Clear();

 	void MoveTo(const TPoint& aPoint);

 	void MoveBy(const TPoint& aVector);

 	void Plot(const TPoint& aPoint);

 	void DrawLine(const TPoint& aStart, const TPoint& aEnd);

 	void DrawLineTo(const TPoint& aPoint);

 	void DrawLineBy(const TPoint& aVector);

 	void DrawRect(const TRect& aRect);

 	void DrawRoundRect(const TRect& aRect, const TSize& aCornerSize);

 	void DrawPolyLine(const TArray<TPoint>& aPointList);

 	void DrawPolyLineNoEndPoint(const TArray<TPoint>& aPointList);

 	void DrawPolygon(const TArray<TPoint>& aPoints,	DirectGdi::TFillRule aRule);

 	void DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd);

 	void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd);

 	void DrawEllipse(const TRect& aRect);

 	void BitBlt(const TPoint& aDestPos, const CFbsBitmap& aSourceBitmap, const TRect& aSourceRect);

 	void BitBltMasked(

 			const TPoint& aDestPos,				

 			const CFbsBitmap& aSourceBitmap,

 			const TRect& aSourceRect,				

 			const CFbsBitmap& aMaskBitmap, 

 			TBool aInvertMask);

 	void BitBltMasked(const TPoint& aDestPt,

 			const CFbsBitmap& aSourceBitmap, const TRect& aSourceRect,				

 			const CFbsBitmap& aMaskBitmap, const TPoint& aMaskPos);

 	void DrawBitmap(const TRect& aDestRect, const CFbsBitmap& aSourceBitmap,

 			const TRect& aSrcRect);

 	void DrawBitmapMasked(const TRect& aDestRect,				

 			const CFbsBitmap& aSourceBitmap,const TRect& aSourceRect,				

 			const CFbsBitmap& aMaskBitmap, TBool aInvertMask);

 	void DrawResource(const TPoint& aPos, 

 			const RDirectGdiDrawableSource& aSource, 

 			DirectGdi::TGraphicsRotation aRotation);	

 	void DrawResource(const TRect& aDestRect,

 			const RDirectGdiDrawableSource& aSource,

 			DirectGdi::TGraphicsRotation aRotation);

 	void DrawResource(const TRect& aDestRect,				

 			const RDirectGdiDrawableSource& aSource, 

 			const TRect& aSrcRect,

 			DirectGdi::TGraphicsRotation aRotation);

 	void DrawResource(

 			const TRect& aDestRect,				

 			const RDirectGdiDrawableSource& aSource,

 			const TDesC8& aParam);

 	void DrawGlyph(const TPoint& aPos, const TChar aChar, const TUint8* aGlyphImage,

 			const TGlyphBitmapType aGlyphBitmapType, const TSize& aGlyphImageSize, const TRect& aClipRect,

 			const DirectGdi::TGraphicsRotation aRotation = DirectGdi::EGraphicsRotationNone);

 	void CopyRect(const TPoint& aOffset, const TRect& aRect);

 	void ExternalizeL(RWriteStream& aWriteStream);

 	void InternalizeL(RReadStream& aReadStream);

 	TInt GetInterface(TUid aInterfaceId, TAny*& aInterface);

 	void BeginDrawGlyph();

 	void EndDrawGlyph();

 	//from MDrawDeviceOrigin

 	TInt Set(const TPoint& aDrawOrigin);

 	void Get(TPoint& aDrawOrigin);

 private:

 	TRect SgMetricsToVgTRect (const TPoint& aCoord, const TInt width, const TInt height) const;

 	const TPoint ConvertToVgCoords(const TPoint& aPoint);

 	const TPoint ConvertToVgCoords(const TRect& aRect);

 	void ResetVgMatrix();

 	void ResetVgMatrix(const VGMatrixMode aMatrixMode);

 	// Path (line) creation commands

 	TBool PreparePath(VGPath& aPath, TInt aExpectedCommandCount);

 	void AppendPathCommand(VGubyte aCommand);

 	void AppendPathCommand(VGubyte aCommand, VGfloat aCoord);

 	void AppendPathCommand(VGubyte aCommand, VGfloat aCoord1, VGfloat aCoord2);

 	TInt PrepareForPathCommand(TInt aCommandCount, TInt aCoordCount);

 	void FinishPath(VGPath aPath);	

 	TInt AllocPathCommands(TInt aCommandCount);

 	TInt AllocPathCoords(TInt aCoordCount);

 	TBool ConvertBitmapToVgImage(const CFbsBitmap& aBitmap, VGImage& aImage, TBool aIsMask = EFalse, const TPoint& aOrigin = TPoint(0,0));

 	VGImage CreateSourceVGImage(const CFbsBitmap& aSource, TBool aFlipY = EFalse, const TPoint& aOrigin = TPoint(0,0));	

 	TInt CreateStandardBrush(TSize& aPatternSize, VGbyte* aBrushPattern);

 	TBool NonZeroBrushPatternOrigin();

 	TInt CopyCurrentBrushPatternForNonZeroOrigin();	

 	inline VGfloat* Identity (void) {return iIdentityMatrix;}

 	void SetVgState();

 	void SetVguError(VGUErrorCode aErr);

 	TBool GetCurrentBrushPattern(VGImage& aBrush, TSize& aSize, VGImageFormat& aFormat) const;

 	TReal GetAngleFromXAxisAnticlockwise(const TReal aOriginX, const TReal aOriginY, const TReal aPointX, const TReal aPointY, const TReal aWidth, const TReal aHeight);

 	void DoDrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd, VGUArcType aArcType);

 	void DoDrawPoly(const TArray<TPoint>& aPointList, TBool aClosed);

 	TBool MakeEngineCurrent();

 	void DoBitBltMasked (

 		const TPoint& aDestPos,

 		const CFbsBitmap& aSourceBitmap,

 		const TRect& aSourceRect,

 		const CFbsBitmap& aMaskBitmap,

 		TBool aInvertMask,

 		const TPoint& aMaskPos);

 	void DoVgImageDraw (

 		const TRect& aDestRect, 

 		const CFbsBitmap& aSourceBitmap, 

 		const TRect& aSourceRect);

 	void DoVgMaskedImageDraw(

 		const TPoint& aDestPos,

 		VGImage aSourceImage,

 		const TRect& aSourceImageSize,

 		const TRect& aSourceRect,

 		const VGImage aMaskImage,

 		const TSize& srcMaskSize,

 		const TSize& aDestSize,

 		TBool aInvertMask);

 	inline TBool IntersectsClippingRegion (const TRect& aRect);

 	void DoDrawResource(const TRect& aDestRect, CDirectGdiImageSourceImpl* aSource, DirectGdi::TGraphicsRotation aRotation);	

 	void DoDrawResource(const TRect& aDestRect, CDirectGdiImageSourceImpl* aSource, const TRect& aSrcRect, DirectGdi::TGraphicsRotation aRotation);

 	VGImage DoVgCreateImage(VGImageFormat aFormat, VGint aWidth, VGint aHeight, VGbitfield aAllowedQuality);

 	void SetVgPaintColor(VGPaint& aPaint, const TRgb& aColor);

 private:	

 	CDirectGdiDriverImpl& iDriver;

 	RClippingRegionManager iRegionManager;

 	CDirectGdiImageTargetImpl* iRenderingTarget;

 	TRegionFix<1> iTargetRegion;	/**< The region which the rendering target occupies.*/

 	TSize iSize;	/**< The size of the rendering target.*/

 	TPoint iOrigin;		/**< The origin of the drawing engine coordinate system.*/

 	TPoint iDrawOrigin; /**< The origin of all drawing, affected by app mode offset */

 	VGPaint iPen;		/**< VGPaint object for all pen operations (Stroke operations in OpenVG).*/

 	TSize iPenSize;		/**< The current pen size.*/

 	TRgb iPenColor;		/**< The current pen colour.*/

 	TRgb iTextShadowColor;	/**< The current colour for blending text shadow.*/

 	DirectGdi::TPenStyle iPenStyle;	/**< The current pen style.*/

 	VGPaint iBrush;		/**< VGPaint object for all brush operations (Fill operations in OpenVG).*/

 	VGPaint iClearBrush;	/**< VGPaint object for Clear() operations only.*/

 	TRgb iBrushColor;	/**< The current brush colour.*/

 	VGPath iVgPath;		/**< OpenVG path used for all path drawing.*/

 	TUint32 iFontId;	/**< The id of the current font.*/

 	VGPaint iTextBrush; /**< VGPaint object used to draw text. */

 	/**

 	VGImage for holding the current user brush pattern (i.e when 

 	DirectGdi::TBrushStyle::EPatternedBrush is selected).

 	*/

 	VGImage iBrushPatternUser;

 	/**

 	VGImage for holding the current standard brush pattern (i.e. when one of 

 	DirectGdi::TBrushStyle::EVerticalHatchBrush to DirectGdi::TBrushStyle::EDiamondCrossHatchBrush

 	brush styles are selected).

 	*/

 	VGImage iBrushPatternStandard;

 	VGImage iBrushPatternStandardRegion; /**< VGImage for holding a sub-region of iBrushPatternStandard.*/

 	TInt iBrushPatternStandardId;	/**< The id of the currently loaded standard brush pattern. This is initialised to -1 inside Activate().*/

 	DirectGdi::TBrushStyle iBrushStyle;	/**< The current brush style.*/

 	TPoint iBrushOrigin;	/**< The current brush origin.*/

 	/**

 	This VGImage should always hold the current brush pattern if iBrushOrigin is not (0,0).

 	This could be a shifted version of either iBrushPatternUser or iBrushPatternStandard.

 	*/

 	VGImage iBrushPatternNonZeroOrigin;

 	VGbitfield iPaintMode;	/**< The current paint mode.*/

 	// The following members variables are used when drawing paths

 	VGubyte* iPathCommands;	/**< Pointer to list of stored commands to be used in a VGPath.*/

 	VGfloat* iPathCoords;	/**< Pointer to list of stored coordinates to be used in a VGPath.*/

 	TInt iPathCommandCount; /**< The number of commands to be used in a VGPath.*/

 	TInt iPathCoordCount;	/**< The number of coordinates to be used in a VGPath.*/

 	TInt iCurrentMaxCommands;	/**< The current maximum number of commands which can be entered in a VGPath.*/

 	TInt iCurrentMaxCoords;	/**< The current maximum number of coordinates which can be entered in a VGPath.*/

 	TPoint iLinePos;	/**< The current line position. Can be changed using MoveTo(), MoveBy(), DrawLineTo(), DrawLineBy() and DrawPolyline().*/

 	DirectGdi::TDrawMode iDrawMode;	/**< The current drawing mode.*/

 	VGfloat iIdentityMatrix[9];	/**< The matrix used to convert coordinate systems.*/

 	// Brush sizes. We'll remember them instead of doing potentially expensive vgGets

 	TSize iBrushPatternStandardRegionSize;	/**< The size of the current sub-region of the standard brush pattern.*/

 	TSize iBrushPatternStandardSize;	/**< The size of the current standard brush pattern.*/

 	TSize iBrushPatternUserSize;	/**< The size of the curent  user brush pattern.*/

 	TInt iBrushPatternUserBitmapHandle;	/**< Stores the bitmap handle to recreate the iBrushPatternUser VGImage.*/

 	MFontGlyphImageStorage* iFontGlyphImageStorage;	/**< Interface which deals with glyph cache images.*/

 #ifdef	DRAWGLYPH_BUFFERED

 	TInt iDrawGlyphCount;

 	TDrawGlyphCommand iDrawGlyphCommand[KMaxGlyphs];

 	void FlushDrawGlyphs();

 #endif

 	};

 inline TBool CVgEngine::NonZeroBrushPatternOrigin()

 	{

 	return ((iBrushOrigin.iX != 0) || (iBrushOrigin.iY != 0));

 	}

 /**

 Helper method to determine if a specified rectangle intersects with the current clipping region.

 If the current clipping region is a null pointer then intersection is assumed.

 @param 	aRect Rectangle to check for intersection with clipping region.

 @return ETrue if aRect intersects with clipping region, else EFalse.

  */

 inline TBool CVgEngine::IntersectsClippingRegion (const TRect& aRect)

 	{

 	if(iRegionManager.ClippingRegion().IsEmpty())

 		{

 		return (aRect.Intersects(iTargetRegion.BoundingRect()));

 		}

 	else 

 		{

 		return (iRegionManager.ClippingRegion().Intersects(aRect));

 		}

 	}

 #endif /*VGENGINE_H_*/