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