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