author | Gareth Stockwell <gareth.stockwell@accenture.com> |
Fri, 22 Oct 2010 11:38:29 +0100 | |
branch | bug235_bringup_0 |
changeset 206 | c170e304623f |
parent 0 | 5d03bc08d59c |
permissions | -rw-r--r-- |
// 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_*/