--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/directgdiadaptation/hwsrc/vgengine.h	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,314 @@
+// 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_*/