/*
* Copyright (c) 2002 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: Graphics Extension Library source file
*
*/
#include "Gfx2dGcOpenVG.h"
//#include "Gfx2dDevice.h"
#include "GfxLine2D.h"
#include "GfxStroke.h"
#include "GfxGeneralPath.h"
#include "GfxFlatteningPathIterator.h"
#include "GfxColor.h"
#include "GfxImageTransformer.h"
//#include "hal.h"
//#include "hal_data.h"
#include "gdi.h"
#include "biditext.h"
#include "GfxFloatFixPt.h"
#include "GfxShape.h"
#include "GfxEllipse2D.h"
#include "GfxRoundRectangle2D.h"
//#include "svgBackendStd.h"
//#include "gulutil.h"
#include <AknFontAccess.h>
//#include <AknUtils.h>
//#include <featmgr.h>
#include<e32cmn.h>
#include<e32uid.h>//NGA
#include <e32math.h>
// OpenVG Includes
#include <VG/vgu.h>
#include <vg/vgcontext.h>
// OpenVG API Binding Symbian specific
#include <vg/vgcontext_symbian.h>
// For allocating path segment type array
// Found 130 to be max size at bootup
const TInt KPathSegmentTypeInitialSize = 130;
const TInt KPathSegmentTypeMaxSize = 1000;
const TInt KRenderQualityLow = 1;
const TInt KRenderQualityHigh = 2;
_LIT( KDefaultFont, "serif" ); // Similar changes should be applied to \
//SvgTextElementImpl.cpp file
// --------------------------------------------------------------------------
// CGfx2dGcOpenVG::CGfx2dGcOpenVG() : iScale( 1 ),
// ---------------------------------------------------------------------------
CGfx2dGcOpenVG::CGfx2dGcOpenVG( TBool /* aIsMainContext */ ) :
iFillOpacity( 1 ),
iScale( 1 ),
iStrokeColor( 0 ),
iStrokeOpacity( 1 ),
iBackgroundColor( 0xffffff ),
iFontSize( 10 ),
iFontWeight( -1 ),
iFontStyle( -1 ),
iFamilies( NULL ),
iTextAnchor( EGfxTextAnchorNone ),
iTextDecoration( EGfxTextDecorationNone ),
iGraphicsContextCreated( EFalse ),
iRenderQuality(VG_RENDERING_QUALITY_BETTER),
iCurrentRendererType(ESVGRendererSW)
{
}
//
// ==========================================================================
// Create a new instance.
// ==========================================================================
// --------------------------------------------------------------------------
// CGfx2dGcOpenVG* CGfx2dGcOpenVG::NewL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )
// ---------------------------------------------------------------------------
CGfx2dGcOpenVG* CGfx2dGcOpenVG::NewL( const TSize aBufferSize, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider, TBool aIsMainContext )
{
CGfx2dGcOpenVG* self = new( ELeave ) CGfx2dGcOpenVG( aIsMainContext );
CleanupStack::PushL( self );
self->ConstructL( aBufferSize, aFontSpec, aSvgBitmapFontProvider);
CleanupStack::Pop();
return self;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::ConstructL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::ConstructL( const TSize aBufferSize, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider )
{
/* iApacAvailable = EFalse;
FeatureManager::InitializeLibL();
iApacAvailable = ( AknLayoutUtils::Variant() == EApacVariant );
FeatureManager::UnInitializeLib();*/
iFontSpec = aFontSpec;
if (iFontSpec.iTypeface.iName.Length() == 0)
{
//just for a safety check in case client didnt put it in
iFontSpec = TFontSpec(KDefaultFont, 100);
}
iSvgBitmapFontProvider = aSvgBitmapFontProvider ;
// Allocate path segment type array
iPathSegmentTypeCount = KPathSegmentTypeInitialSize;
iPathSegmentTypes = new (ELeave) VGubyte[KPathSegmentTypeInitialSize];
iDashArray = new ( ELeave ) CArrayFixFlat<VGfloat>( 32 );
iVgRenderer = CVGRenderer::NewL(ESVGRendererSW, 0);
iVgSurface = iVgRenderer->GetCurrentSurface();
ChangeBufferSizeL( aBufferSize );
}
//NGA
// --------------------------------------------------------------------------
// CGfx2dGcOpenVG* CGfx2dGcOpenVG::NewL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )
// ---------------------------------------------------------------------------
CGfx2dGcOpenVG* CGfx2dGcOpenVG::NewL( const TSize aBufferSize, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider,SVGRendererId aRendererType,TBool aIsMainContext )
{
CGfx2dGcOpenVG* self = new( ELeave ) CGfx2dGcOpenVG( aIsMainContext );
CleanupStack::PushL( self );
self->ConstructL( aBufferSize, aFontSpec, aSvgBitmapFontProvider,aRendererType);
CleanupStack::Pop();
return self;
}
//NGA
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::ConstructL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::ConstructL( const TSize aBufferSize, TFontSpec& aFontSpec, CSvgBitmapFontProvider* aSvgBitmapFontProvider,SVGRendererId aRendererType )
{
iFontSpec = aFontSpec;
if (iFontSpec.iTypeface.iName.Length() == 0)
{
//just for a safety check in case client didnt put it in
iFontSpec = TFontSpec(KDefaultFont, 100);
}
iSvgBitmapFontProvider = aSvgBitmapFontProvider ;
// Allocate path segment type array
iPathSegmentTypeCount = KPathSegmentTypeInitialSize;
iPathSegmentTypes = new (ELeave) VGubyte[KPathSegmentTypeInitialSize];
iDashArray = new ( ELeave ) CArrayFixFlat<VGfloat>( 32 );
iCurrentRendererType = aRendererType;
iVgRenderer = CVGRenderer::NewL(aRendererType, 0);
iVgSurface = iVgRenderer->GetCurrentSurface();
iVgSurface->InitializeSurface( aBufferSize, VGI_COLORSPACE_SRGB );
iVgSurface->CreateSurface(EColor16MA, 0, 0);
ChangeBufferSizeL( aBufferSize );
}
// ==========================================================================
// Destructor.
// ==========================================================================
// --------------------------------------------------------------------------
// CGfx2dGcOpenVG::~CGfx2dGcOpenVG()
// ---------------------------------------------------------------------------
CGfx2dGcOpenVG::~CGfx2dGcOpenVG()
{
if ( iDashArray )
{
delete iDashArray;
iDashArray = NULL;
}
// This is no longer needed, the Font is owned by TextElement
// now as each text element may have its own specific font
// and keeping one copy at Gc level will not work.
// Gc is just refering to the Font from Textelement, so
// now need to free it here.
//
//if (iFont && iWsScreenDevice)
// {
// iWsScreenDevice->ReleaseFont(iFont);
// iFont = NULL;
// }
DestroyContext();
iGroupOpacityImages.Close();
TInt bufferCount = iGroupOpacityBuffers.Count();
for ( TInt i = 0; i < bufferCount; i++ )
{
delete [] iGroupOpacityBuffers[i];
}
iGroupOpacityBuffers.Close();
if ( iPathSegmentTypes )
{
delete [] iPathSegmentTypes;
}
delete iVgRenderer;
}
// private method
void CGfx2dGcOpenVG::DestroyContext()
{
if ( iGraphicsContextCreated )
{
// Destroy OpenVG context
iVgSurface->TerminateSurface();
ResetContextHandle();
iFillOpacity = 1;
iScale = 1;
iStrokeOpacity = 1;
}
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetFrameBufferL( CFbsBitmap* aFrameBuffer )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::ChangeBufferSizeL( const TSize aBufferSize )
{
if ( aBufferSize.iWidth <= 0 || aBufferSize.iHeight <= 0 || aBufferSize == iColorBufferSize )
{
return;
}
iColorBufferSize = aBufferSize;
// First time: creating OpenVG context
if( !iGraphicsContextCreated )
{
// Create OpenVG context
TInt err = iVgSurface->InitializeSurface( iColorBufferSize, VGI_COLORSPACE_SRGB );
if (!((err == KErrNone) || (err == KErrAlreadyExists)))
{
#ifdef _DEBUG
RDebug::Printf("SVG can't initialize OpenVG Context %d", err);
#endif //_DEBUG
iGraphicsContextCreated = EFalse;
User::Leave(err);
}
iGraphicsContextCreated = ETrue;
// By default the Rendering quality is VG_RENDERING_QUALITY_BETTER
iVgRenderer->vgSeti( VG_RENDERING_QUALITY, iRenderQuality );
}
// Only need to update context with color-buffer info
// when frame buffer size changes
else
{
TInt err = iVgSurface->ResizeSurface( iColorBufferSize );
if( err != KErrNone )
{
if(err == KErrNoMemory )
{
#ifdef _DEBUG
RDebug::Printf("OpenVG Context destroyed %d", err);
#endif //_DEBUG
// This indicates that OpenVG has destroyed the current context handle
// and also the Path, StrokePaint and FillPaint handles are no more valid.
// Thus reinitialize them to 0, so that they can be recreated.
ResetContextHandle();
}
#ifdef _DEBUG
RDebug::Printf("SVG can't RESIZE OpenVG Context %d", err);
#endif //_DEBUG
User::Leave(err);
}
}
iRenderInfo.SetDevice( 0, /*this parameter will be ignored */
iColorBufferSize.iWidth,
iColorBufferSize.iHeight,
0 /*this parameter will be ignored */);
}
// --------------------------------------------------------------------------
// TInt CGfx2dGcOpenVG::OpenVGErrorToSymbianError( int aError )
// ---------------------------------------------------------------------------
TInt CGfx2dGcOpenVG::OpenVGErrorToSymbianError( TInt aError )
{
TInt error = KErrNone;
switch( aError )
{
case VGI_OK:
{
error = KErrNone;
break;
}
case VGU_OUT_OF_MEMORY_ERROR:
case VG_OUT_OF_MEMORY_ERROR:
case VGI_ERROR_OUT_OF_MEMORY:
{
error = KErrNoMemory;
break;
}
case VG_ILLEGAL_ARGUMENT_ERROR:
case VGI_ERROR_INVALID_ARGUMENTS:
case VGU_ILLEGAL_ARGUMENT_ERROR:
{
error = KErrArgument;
break;
}
case VGI_ERROR_ALREADY_EXISTS:
{
error = KErrAlreadyExists;
break;
}
case VG_UNSUPPORTED_PATH_FORMAT_ERROR:
case VGI_ERROR_COLORSPACE_NOT_SUPPORTED:
case VG_UNSUPPORTED_IMAGE_FORMAT_ERROR:
case VGI_ERROR_NOT_SUPPORTED:
{
error = KErrNotSupported;
break;
}
case VGI_ERROR_ILLEGAL_IMAGE_HANDLE:
{
error = KErrBadHandle;
break;
}
case VG_IMAGE_IN_USE_ERROR:
case VGI_ERROR_IMAGE_IN_USE:
{
error = KErrInUse;
break;
}
case VGI_ERROR_ILLEGAL_OPERATION:
{
error = KErrPermissionDenied;
break;
}
case VG_BAD_HANDLE_ERROR:
case VG_PATH_CAPABILITY_ERROR:
case VGU_PATH_CAPABILITY_ERROR:
case VGU_BAD_WARP_ERROR:
case VGU_BAD_HANDLE_ERROR:
{
error = KErrUnknown;
break;
}
default:
{
error = KErrUnknown;
}
}
return error;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::DoDrawL( MGfxShape* aShape )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::DoDrawL( MGfxShape* aShape )
{
VGbitfield drawMode = 0x0;
VGUErrorCode vguret;
// Do not render if both stroke and fill are none
if ( iStrokeColor.GetARGB() == KGfxColorNull && iFillColor == NULL )
return;
iVgRenderer->vgSeti( VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE );
if ( !iPath )
{
const float KScale = 1.0f / 65536.0f;
iPath = iVgRenderer->vgCreatePath( VG_PATH_FORMAT_STANDARD,
VG_PATH_DATATYPE_S_32, KScale, 0.0f, 0, 0,
VG_PATH_CAPABILITY_APPEND_TO );
if ( iPath == VG_INVALID_HANDLE )
{
VGErrorCode error = (VGErrorCode)iVgRenderer->vgGetError();
if (error == VG_OUT_OF_MEMORY_ERROR)
{
#ifdef _DEBUG
RDebug::Printf("OOM: vgCreatePath");
#endif
User::Leave(KErrNoMemory);
}
// handle other errors...
#ifdef _DEBUG
RDebug::Printf("SVG GFX2D Error: vgCreatePath");
#endif
}
}
if (iFillColor)
{
if(!iFillPaint)
{
iFillPaint = iVgRenderer->vgCreatePaint();
if ( iFillPaint == VG_INVALID_HANDLE )
{
VGErrorCode error = (VGErrorCode)iVgRenderer->vgGetError();
if (error == VG_OUT_OF_MEMORY_ERROR)
{
RDebug::Printf("SVG GFX2D Error OOMs: vgCreatePaint");
User::Leave(KErrNoMemory);
}
// handle other errors...
#ifdef _DEBUG
RDebug::Printf("SVG GFX2D Error: vgCreatePaint");
#endif
}
}
}
if(iStrokeColor.GetARGB() != KGfxColorNull)
{
if(!iStrokePaint)
{
iStrokePaint = iVgRenderer->vgCreatePaint();
if ( iStrokePaint == VG_INVALID_HANDLE )
{
VGErrorCode error = (VGErrorCode)iVgRenderer->vgGetError();
if (error == VG_OUT_OF_MEMORY_ERROR)
{
RDebug::Printf("SVGT CGfx2dGcOpenVG::DoDrawL vgCreatePaint OOM");
User::Leave(KErrNoMemory);
}
#ifdef _DEBUG
RDebug::Printf("SVGT CGfx2dGcOpenVG::DoDrawL vgCreatePaint failed %d", error);
#endif
}
}
}
TGfxRectangle2D bbRect;
TGfxAffineTransform identityMat;
//vgClear( 0, 0, VG_MAXINT, VG_MAXINT );
switch(aShape->ShapeType())
{
case MGfxShape::ERect:
{
TGfxRectangle2D* rect = (TGfxRectangle2D*)aShape;
rect->GetBounds( identityMat, bbRect );
drawMode = SetFillStroke(iFillPaint, iStrokePaint, bbRect);
vguret = (VGUErrorCode)iVgRenderer->vguRect(
iPath,
(VGfloat)rect->iX,
(VGfloat)rect->iY,
(VGfloat)rect->iWidth,
(VGfloat)rect->iHeight );
if( vguret != KErrNone )
{
User::LeaveIfError(OpenVGErrorToSymbianError(vguret));
}
iVgRenderer->vgDrawPath( iPath, drawMode );
}
break;
case MGfxShape::ERoundRect:
{
float rx, ry;
TGfxRoundRectangle2D* rect = (TGfxRoundRectangle2D*)aShape;
TFloatFixPt tWidth = rect->iArcWidth;
TFloatFixPt tHeight = rect->iArcHeight;
tWidth.iValue <<= 1;
tHeight.iValue <<= 1;
rx = (VGfloat)tWidth;
ry = (VGfloat)tHeight;
//If a properly specified value is provided for ry but not for rx,
// then the user agent must process the 'rect' element with the
// effective value for rx as equal to ry. However clamp to 0.
if ( rx <= 0 )
{
rx = ry;
}
if ( ry <= 0)
{
ry = rx;
}
if(rx < 0)
{
rx = 0;
}
if(ry < 0)
{
ry = 0;
}
rect->GetBounds( identityMat, bbRect );
drawMode = SetFillStroke(iFillPaint, iStrokePaint, bbRect);
// Rounded rectangle
if ( rx == 0.0f && ry == 0.0f )
{
vguret = (VGUErrorCode)iVgRenderer->vguRect(iPath,
(VGfloat)rect->iX, (VGfloat)rect->iY,
(VGfloat)rect->iWidth, (VGfloat)rect->iHeight );
}
else
{
vguret = (VGUErrorCode)iVgRenderer->vguRoundRect( iPath,
(VGfloat)rect->iX, (VGfloat)rect->iY,
(VGfloat)rect->iWidth, (VGfloat)rect->iHeight,
rx, ry );
}
if( vguret != KErrNone )
{
User::LeaveIfError(OpenVGErrorToSymbianError(vguret));
}
iVgRenderer->vgDrawPath( iPath, drawMode );
}
break;
case MGfxShape::EEllipse:
{
TGfxEllipse2D* ellipse = (TGfxEllipse2D*)aShape;
#ifdef SVG_FLOAT_BUILD
TFloatFixPt rx = ellipse->iWidth * TFloatFixPt(.5f);
TFloatFixPt ry = ellipse->iHeight * TFloatFixPt(.5f);
#else
TFloatFixPt rx = ellipse->iWidth >> 1; // rx = width / 2
TFloatFixPt ry = ellipse->iHeight >> 1; // ry = height / 2
#endif
ellipse->GetBounds( identityMat, bbRect );
drawMode = SetFillStroke(iFillPaint, iStrokePaint, bbRect);
// Element
vguret = (VGUErrorCode)iVgRenderer->vguEllipse(iPath,
(VGfloat)(ellipse->iX + rx),
(VGfloat)(ellipse->iY + ry),
(VGfloat)ellipse->iWidth,
(VGfloat)ellipse->iHeight);
if( vguret != KErrNone )
{
User::LeaveIfError(OpenVGErrorToSymbianError(vguret));
}
iVgRenderer->vgDrawPath(iPath,drawMode);
}
break;
case MGfxShape::EPath:
{
CGfxGeneralPath* gPath = (CGfxGeneralPath*)aShape;
RArray<TFloatFixPt>* coordArray = gPath->PointCoordsArrayAll();
if (coordArray->Count() > 0)
{
TFloatFixPt* coord = gPath->PointCoordsArray();
TUint8 count = gPath->Count();
RArray<TUint32>* type = gPath->PointTypeArray();
TInt typeCount = type->Count();
if(count && ( typeCount == count))
{
iVgRenderer->vgAppendPathData(iPath, count,gPath->PathSegmentTypeArray(),coord);
}
else
{
//RArray<TUint32>* type = gPath->PointTypeArray();
//TInt typeCount = type->Count();
// this is a multi path
// Using non-ELeave version and checking for NULL to avoid (ELeave) and TRAP
if ( iPathSegmentTypeCount < typeCount )
{
if ( iPathSegmentTypes )
{
delete [] iPathSegmentTypes;
iPathSegmentTypes = NULL;
}
iPathSegmentTypes = new VGubyte[typeCount];
iPathSegmentTypeCount = typeCount;
}
if ( !iPathSegmentTypes )
{
break;
}
for (TInt i=0; i < typeCount; i++)
{
iPathSegmentTypes[i] = (TGfxSegType) (*type)[i];
}
iVgRenderer->vgAppendPathData(iPath, typeCount, iPathSegmentTypes, coord);
}
gPath->GetBounds( identityMat, bbRect );
drawMode = SetFillStroke(iFillPaint, iStrokePaint, bbRect);
iVgRenderer->vgDrawPath(iPath,drawMode);
}
}
break;
case MGfxShape::ELine:
{
TGfxLine2D* line = (TGfxLine2D*)aShape;
// Force Stroke color... if not present
if(iFillColor && iStrokeColor.GetARGB() == KGfxColorNull)
{
iStrokeColor = iFillColor->GetColor();
}
line->GetBounds( identityMat, bbRect );
drawMode = SetFillStroke(iFillPaint, iStrokePaint, bbRect);
vguret = (VGUErrorCode)iVgRenderer->vguLine(
iPath,
(VGfloat)line->iX1,
(VGfloat)line->iY1,
(VGfloat)line->iX2,
(VGfloat)line->iY2);
if( vguret != KErrNone )
{
User::LeaveIfError(OpenVGErrorToSymbianError(vguret));
}
iVgRenderer->vgDrawPath(iPath,drawMode);
}
break;
}
iVgRenderer->vgClearPath( iPath, VG_PATH_CAPABILITY_APPEND_TO );
// Delete path segment type array to avoid large memory to persist,
// created by some content, but the larget size is not needed later.
if ( iPathSegmentTypeCount > KPathSegmentTypeMaxSize )
{
if ( iPathSegmentTypes )
{
delete [] iPathSegmentTypes;
iPathSegmentTypes = NULL;
iPathSegmentTypeCount = 0;
}
}
// Turn off any settings that are not needed by default
PostDraw();
}
void CGfx2dGcOpenVG::PostDraw()
{
if ( iDashArray && iDashArray->Count() > 0 )
{
iVgRenderer->vgSetfv(VG_STROKE_DASH_PATTERN, 0, NULL);
iDashArray->Reset();
}
}
// --------------------------------------------------------------------------
// VGbitfield CGfx2dGcOpenVG::SetFillStroke(VGPaint aFillPaint, VGPaint aStrokePaint, TGfxRectangle2D& bBox)
// ---------------------------------------------------------------------------
VGbitfield CGfx2dGcOpenVG::SetFillStroke(VGPaint aFillPaint, VGPaint aStrokePaint, TGfxRectangle2D& bBox)
{
VGbitfield returnVal = 0x0;
// Fill Color
if (iFillColor)
{
if( aFillPaint != VG_INVALID_HANDLE )
{
iFillColor->SetFill(aFillPaint, bBox, iFillOpacity, iVgRenderer);
returnVal |= VG_FILL_PATH;
}
}
//
// Color Correction for Symbian->OpenVG
// Symbian argb
// OpenVg rgba
//
// Stroke
//
if( iStrokeColor.GetARGB() != KGfxColorNull && iStrokeColor.GetARGB() != 0x1ffffff )
{
iVgRenderer->vgSetf( VG_STROKE_LINE_WIDTH, (VGfloat)iStroke.StrokeWidth() );
//SET LINECAP INFORMATION
SVGLineCap lineCap = (SVGLineCap)iStroke.StrokeCap();
if (lineCap == SVG_CAP_ROUND)
{
iVgRenderer->vgSeti( VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
}
else if ( lineCap == SVG_CAP_SQUARE )
{
iVgRenderer->vgSeti( VG_STROKE_CAP_STYLE, VG_CAP_SQUARE);
}
else
{
iVgRenderer->vgSeti( VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
}
//SET LINEJOIN INFORMATION
SVGLineJoin linejoin = (SVGLineJoin)iStroke.StrokeJoin();
if (linejoin == SVG_JOIN_ROUND)
{
iVgRenderer->vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
}
else if (linejoin == SVG_JOIN_BEVEL)
{
iVgRenderer->vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
}
else
{
iVgRenderer->vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
}
iVgRenderer->vgSetf( VG_STROKE_MITER_LIMIT, (VGfloat)iStroke.StrokeMiterLimit() );
if(aStrokePaint != VG_INVALID_HANDLE)
{
iVgRenderer->vgSetParameteri( aStrokePaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR );
TUint32 opacity = (TInt)(iStrokeOpacity * TFloatFixPt(255.0f));
iVgRenderer->vgSetColor( aStrokePaint, iStrokeColor.GetARGB() << 8 | opacity );
iVgRenderer->vgSetPaint( aStrokePaint, VG_STROKE_PATH );
returnVal |= VG_STROKE_PATH;
}
}
return returnVal;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetWindingRule( TGfxWindingRule aRule )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetWindingRule( TGfxWindingRule aRule )
{
if ( aRule == EGfxWindEvenOdd )
{
iVgRenderer->vgSeti(VG_FILL_RULE, VG_EVEN_ODD);
}
else
{
iVgRenderer->vgSeti(VG_FILL_RULE, VG_NON_ZERO);
}
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::Draw( MGfxShape* aShape )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::DrawL( MGfxShape* aShape )
{
DoDrawL( aShape );
}
// --------------------------------------------------------------------------
// TGfxColor CGfx2dGcOpenVG::ForegroundColor()
// ---------------------------------------------------------------------------
TGfxColor CGfx2dGcOpenVG::ForegroundColor()
{
return iStrokeColor;
}
// --------------------------------------------------------------------------
// MGfxPaint* CGfx2dGcOpenVG::Paint()
// ---------------------------------------------------------------------------
MGfxPaint* CGfx2dGcOpenVG::Paint()
{
return iFillColor;
}
// --------------------------------------------------------------------------
// TGfxRenderingHints* CGfx2dGcOpenVG::RenderingHints()
// ---------------------------------------------------------------------------
TGfxRenderingHints* CGfx2dGcOpenVG::RenderingHints()
{
//return &iRenderingHints;
return NULL;
}
// --------------------------------------------------------------------------
// TGfxStroke CGfx2dGcOpenVG::Stroke()
// ---------------------------------------------------------------------------
TGfxStroke CGfx2dGcOpenVG::Stroke()
{
return iStroke;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetDashOffset( TFloatFixPt aDashOffset )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetDashOffset( TFloatFixPt aDashOffset )
{
iDashOffset = aDashOffset;
iVgRenderer->vgSetf(VG_STROKE_DASH_PHASE, (VGfloat)iDashOffset);
// svgSetStrokeDashOffset(iHyb2dContext, svgScalarFromFloat(iDashOffset));
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetForegroundColor( const TGfxColor& aColor )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetForegroundColor( const TGfxColor& aColor )
{
// Both GDI and Gfx2D need to keep color value...
iStrokeColor = aColor;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetStrokeWidth( const TGfxStroke& aColor )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetStrokeWidth( const TFloatFixPt& aWidth )
{
// Both GDI and Gfx2D need to keep stroke-width value...
iStroke.SetStrokeWidth(aWidth);
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetBackgroundColor( const TGfxColor& aColor )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetBackgroundColor( const TGfxColor& aColor )
{
// Only Gfx2D need to keep background color value.
iBackgroundColor = aColor;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetPaint( MGfxPaint* aPaint )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetPaint( MGfxPaint* aPaint )
{
iFillColor = aPaint;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetStroke( TGfxStroke aStroke )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetStroke( TGfxStroke aStroke )
{
iStroke = aStroke;
iVgRenderer->vgSetf( VG_STROKE_LINE_WIDTH, (VGfloat)iStroke.StrokeWidth() );
//SET LINECAP INFORMATION
SVGLineCap lineCap = (SVGLineCap)iStroke.StrokeCap();
if (lineCap == SVG_CAP_ROUND)
{
iVgRenderer->vgSeti( VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
}
else if ( lineCap == SVG_CAP_SQUARE )
{
iVgRenderer->vgSeti( VG_STROKE_CAP_STYLE, VG_CAP_SQUARE);
}
else
{
iVgRenderer->vgSeti( VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
}
//SET LINEJOIN INFORMATION
SVGLineJoin linejoin = (SVGLineJoin)iStroke.StrokeJoin();
if (linejoin == SVG_JOIN_ROUND)
{
iVgRenderer->vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
}
else if (linejoin == SVG_JOIN_BEVEL)
{
iVgRenderer->vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
}
else
{
iVgRenderer->vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
}
iVgRenderer->vgSetf( VG_STROKE_MITER_LIMIT, (VGfloat)iStroke.StrokeMiterLimit() );
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetRenderingHints( const TGfxRenderingHints& aRenderingHints )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetRenderingHints( const TGfxRenderingHints& /*aRenderingHints*/ )
{
//iRenderingHints = aRenderingHints;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetTransform( const TGfxAffineTransform& aTransform )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetTransform( const TGfxAffineTransform& aTransform )
{
iTransform = aTransform;
// Calculate scale
TGfxPoint2D ep( 1, 0 ), org( 2, 0 );
iTransform.Transform( &ep, & ep, 1 );
iTransform.Transform( &org, & org, 1 );
ep.iX -= org.iX;
ep.iY -= org.iY;
iScale = TFloatFixPt::Sqrt( ep.iX * ep.iX + ep.iY * ep.iY );
// activate Graphics 2D engine
// set viewport coordinate system to map from canvas coordinates to pixels
// in order to provide resolution independent results
// SVGMatrix2x3 vmat;
// svgMatrix2x3Set( &vmat,
// iTransform.iM00.iValue,
// iTransform.iM01.iValue,
// iTransform.iM02.iValue,
// iTransform.iM10.iValue,
// iTransform.iM11.iValue,
// iTransform.iM12.iValue
// );
// svgSetViewportCoordinateSystem( iHyb2dContext, vmat.matrix );
ApplyTransform(iTransform);
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetClip( const TGfxRectangle2D& aClip )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetClip( const TGfxRectangle2D& aClip )
{
iClip = aClip;
TFloatFixPt newY = iColorBufferSize.iHeight - (TInt)aClip.iHeight - (TInt)aClip.iY;
VGint clipRect[4] =
{
(TInt)aClip.iX, (TInt)newY, (TInt)aClip.iWidth, (TInt)aClip.iHeight
};
// Set VG_SCISSORING to True
iVgRenderer->vgSeti(VG_SCISSORING, VG_TRUE);
// Set Clippling rectangle
iVgRenderer->vgSetiv(VG_SCISSOR_RECTS, 4,(const TInt*) clipRect);
}
void CGfx2dGcOpenVG::SetClipMediaElement( TSize aSize )
{
TFloatFixPt width = (TFloatFixPt)aSize.iWidth;
TFloatFixPt height = (TFloatFixPt)aSize.iHeight;
TFloatFixPt x = (TFloatFixPt)0;
TFloatFixPt y = (TFloatFixPt)0;
TGfxRectangle2D aClip(x,y,width,height);
iClipMain = iClip;
iClip = aClip;
// TFloatFixPt newY = aSize.iHeight - (TInt)aClip.iHeight - (TInt)aClip.iY;
VGint clipRect[4] =
{
(TInt)aClip.iX, (TInt)aClip.iY, (TInt)aClip.iWidth, (TInt)aClip.iHeight
};
// Set VG_SCISSORING to True
iVgRenderer->vgSeti(VG_SCISSORING, VG_TRUE);
// Set Clippling rectangle
iVgRenderer->vgSetiv(VG_SCISSOR_RECTS, 4, (const TInt*)clipRect);
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetDashArrayL( CArrayFix<TFloatFixPt>* aArray )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetDashArrayL( CArrayFix<TFloatFixPt>* aArray )
{
if ( !aArray || !iDashArray )
{
return;
}
TInt32 count = aArray->Count();
if ( count == 0 )
{
return;
}
if ( iDashArray->Count() > 0 )
{
iDashArray->Reset();
}
for ( TInt32 i = 0; i < count; i++ )
{
iDashArray->AppendL( (VGfloat)aArray->At( i ) );
}
if ( count & 0x00000001 )
{
//count was odd so we need to duplicate the current ones on the array
for (TInt32 i=0; i < count; i++)
{
iDashArray->AppendL( (VGfloat)aArray->At( i ) );
}
}
iVgRenderer->vgSetfv(VG_STROKE_DASH_PATTERN, iDashArray->Count(), (VGfloat*)&(*iDashArray)[0] );
}
// --------------------------------------------------------------------------
// TSize CGfx2dGcOpenVG::DeviceBounds()
// ---------------------------------------------------------------------------
TSize CGfx2dGcOpenVG::DeviceBounds()
{
return iColorBufferSize;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetAntialiasingMode( const TInt32 /*aAntialiasingEnable*/)
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetAntialiasingMode( const TInt32 aAntialiasingMode )
{
// JSR226 has two values for Render Quality
//--------------------------------------------------------------------------------
// JSR226/M2G Values : TInt Value : OpenVG Constants
//--------------------------------------------------------------------------------
// RENDERING_QUALITY_LOW : = 1 = : VG_RENDERING_QUALITY_NONANTIALIASED
// RENDERING_QUALITY_HIGH : = 2 = : VG_RENDERING_QUALITY_BETTER
//--------------------------------------------------------------------------------.
if( aAntialiasingMode == KRenderQualityLow ) // RENDERING_QUALITY_LOW
{
iRenderQuality = VG_RENDERING_QUALITY_NONANTIALIASED ;
}
else if( aAntialiasingMode == KRenderQualityHigh ) // RENDERING_QUALITY_HIGH
{
iRenderQuality = VG_RENDERING_QUALITY_BETTER ;
}
iVgRenderer->vgSeti(VG_RENDERING_QUALITY, iRenderQuality );
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetFont( const CFont* aFont )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetFont( const CFont* aFont )
{
iFont = (CFont*)aFont;
}
// --------------------------------------------------------------------------
// CFont* CGfx2dGcOpenVG::Font()
// ---------------------------------------------------------------------------
CFont* CGfx2dGcOpenVG::Font()
{
if (iFont == NULL)
{
iSvgBitmapFontProvider->GetNearestFontToDesignHeightInTwips( iFont, iFontSpec );
}
return iFont;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::GetSystemFontScaled(TFloatFixPt aHeight,
// const TDesC& aTypefaceName,
// CFont*& aFont,
// TFontSpec& aFontSpec )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::GetFontScaled( TFloatFixPt /* aHeight */,
const TDesC& /* aTypefaceName */,
CFont*& /* aFont */,
TFontSpec& /* aFontSpec */ )
{
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetFontSize( const TFloatFixPt aFontSize )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetFontSize( const TFloatFixPt aFontSize )
{
iFontSize = aFontSize;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetFontWeight( const TInt32 aFontWeight )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetFontWeight( const TInt32 aFontWeight )
{
iFontWeight = aFontWeight;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetFontStyle( const TInt32 aFontStyle )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetFontStyle( const TInt32 aFontStyle )
{
iFontStyle = aFontStyle;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetFontFamily( CDesCArrayFlat* aFamilies )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetFontFamily( CDesCArrayFlat* aFamilies )
{
iFamilies = aFamilies;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetTextanchor( const TInt32 aTextAnchor )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetTextanchor( const TInt32 aTextAnchor )
{
iTextAnchor = (TGfxTextAnchor)aTextAnchor;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetTextDecoration( const TInt32 aTextDecoration )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetTextDecoration( const TInt32 aTextDecoration )
{
iTextDecoration = (TGfxTextDecoration)aTextDecoration;
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::GetBBoxForSystemText( TSvgFourPointRect& aFourPointBbox )
// ---------------------------------------------------------------------------
TGfxRectangle2D CGfx2dGcOpenVG::GetBBoxForSystemText( const TDesC& aText,
TFloatFixPt aX,
TFloatFixPt aY )
{
//bbox for bitmap fonts
TGfxRectangle2D lBbox;
TGfxPoint2D pt(aX,aY);
//iScale = GetCurrentScale();
//scaled already for bitmap text...
TInt textAdvance = iFont->TextWidthInPixels( aText );
TInt fontMaxHeight = iFont->FontMaxHeight();
TFloatFixPt lascent = iFont->AscentInPixels();
TFloatFixPt ldescent = TFloatFixPt(fontMaxHeight) - (TFloatFixPt)iFont->AscentInPixels();
lBbox.iWidth = textAdvance;
lBbox.iHeight = fontMaxHeight;
//need to work in the rotation factor somehow...
//without doing the scaling again
//at this point the bbox already scaled,translated but not rotated
//should we create 1/scale factor or create with scale factor then get inverse
//iScale scaling factor from the graphics context
TReal32 linverseScale = 1.0/(TReal)iScale;
TGfxAffineTransform lInverseScaleMat = TGfxAffineTransform::GetScaleInstance(linverseScale, linverseScale);
//this is with scale and rotation
TGfxPoint2D transformedPoint( pt.iX, pt.iY );
const TGfxAffineTransform& ctm = iTransform;
ctm.Transform(&pt, &transformedPoint, 1);
//remove the double scaling effect that we would have
TGfxAffineTransform ctmWithoutScale = iTransform;
ctmWithoutScale.Concatenate(lInverseScaleMat);
TGfxPoint2D scaledPoint( pt.iX * iScale, pt.iY * iScale );
//set up the initial box with just scale in it and not rotation.
// The base line is position at x,y co-ordinate of the text, but
// the bottom of bound box would be further below by amount ldescent.
TGfxPoint2D lTopLeftCorner(scaledPoint.iX, scaledPoint.iY + ldescent );
TGfxPoint2D lTopRightCorner(scaledPoint.iX + lBbox.iWidth , scaledPoint.iY + ldescent );
TGfxPoint2D lBottomLeftCorner(scaledPoint.iX, scaledPoint.iY - lascent);
TGfxPoint2D lBottomRightCorner(scaledPoint.iX + lBbox.iWidth, scaledPoint.iY - lascent );
TGfxPoint2D lTransTopLeftCorner;
TGfxPoint2D lTransBottomLeftCorner;
TGfxPoint2D lTransTopRightCorner;
TGfxPoint2D lTransBottomRightCorner;
//applying current rotation transform without the scale.
ctmWithoutScale.Transform(&lTopLeftCorner, &lTransTopLeftCorner,1);
ctmWithoutScale.Transform(&lTopRightCorner, &lTransTopRightCorner,1);
ctmWithoutScale.Transform(&lBottomLeftCorner, &lTransBottomLeftCorner,1);
ctmWithoutScale.Transform(&lBottomRightCorner, &lTransBottomRightCorner,1);
TFloatFixPt lXTranslation = transformedPoint.iX - lTransTopLeftCorner.iX;
//TFixPt lXTranslation = transformedPoint.iX - iPoint.iX;
TFloatFixPt lYTranslation = transformedPoint.iY - lTransTopLeftCorner.iY;
//TFixPt lYTranslation = transformedPoint.iY - iPoint.iY;
// X position is affected by anchor
switch( iTextAnchor )
{
case EGfxTextAnchorMiddle:
lXTranslation = lXTranslation - ( lBbox.iWidth / TFloatFixPt( 2 ) );
break;
case EGfxTextAnchorEnd:
lXTranslation = lXTranslation - lBbox.iWidth;
break;
default:
//do nothing
break;
}
lTransTopLeftCorner.iX += lXTranslation;
lTransTopLeftCorner.iY += lYTranslation;
lTransTopRightCorner.iX += lXTranslation;
lTransTopRightCorner.iY += lYTranslation;
lTransBottomLeftCorner.iX += lXTranslation;
lTransBottomLeftCorner.iY += lYTranslation;
lTransBottomRightCorner.iX += lXTranslation;
lTransBottomRightCorner.iY += lYTranslation;
//at this point I have the exact path coordinates of the bbox
//aFourPointBbox.SetRectPoints(lTransTopLeftCorner, lTransTopRightCorner, lTransBottomLeftCorner, lTransBottomRightCorner);
return GetTRect(lTransTopLeftCorner, lTransTopRightCorner, lTransBottomLeftCorner, lTransBottomRightCorner);
}
TGfxRectangle2D CGfx2dGcOpenVG::GetTRect(TGfxPoint2D lTransTopLeftCorner,TGfxPoint2D lTransTopRightCorner,TGfxPoint2D lTransBottomLeftCorner,TGfxPoint2D lTransBottomRightCorner)
{
TFloatFixPt lMaxX = lTransTopLeftCorner.iX;
if (lTransTopRightCorner.iX > lMaxX)
{
lMaxX = lTransTopRightCorner.iX;
}
if (lTransBottomLeftCorner.iX > lMaxX)
{
lMaxX = lTransBottomLeftCorner.iX;
}
if (lTransBottomRightCorner.iX > lMaxX)
{
lMaxX = lTransBottomRightCorner.iX;
}
TFloatFixPt lMaxY = lTransTopLeftCorner.iY;
if (lTransTopRightCorner.iY > lMaxY)
{
lMaxY = lTransTopRightCorner.iY;
}
if (lTransBottomLeftCorner.iY > lMaxY)
{
lMaxY = lTransBottomLeftCorner.iY;
}
if (lTransBottomRightCorner.iY > lMaxY)
{
lMaxY = lTransBottomRightCorner.iY;
}
TFloatFixPt lMinX = lTransTopLeftCorner.iX;
if (lTransTopRightCorner.iX < lMinX)
{
lMinX = lTransTopRightCorner.iX;
}
if (lTransBottomLeftCorner.iX < lMinX)
{
lMinX = lTransBottomLeftCorner.iX;
}
if (lTransBottomRightCorner.iX < lMinX)
{
lMinX = lTransBottomRightCorner.iX;
}
TFloatFixPt lMinY = lTransTopLeftCorner.iY;
if (lTransTopRightCorner.iY < lMinY)
{
lMinY = lTransTopRightCorner.iY;
}
if (lTransBottomLeftCorner.iY < lMinY)
{
lMinY = lTransBottomLeftCorner.iY;
}
if (lTransBottomRightCorner.iY < lMinY)
{
lMinY = lTransBottomRightCorner.iY;
}
TGfxRectangle2D aRect;
aRect.iX = lMinX;
aRect.iY = lMinY;
aRect.iWidth = lMaxX - lMinX;
aRect.iHeight = lMaxY - lMinY;
return aRect;
}
// Text Drawing
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::DrawStringL( const TDesC& aDesc,
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::DrawStringL( const TDesC& aDesc,
TFloatFixPt aX,
TFloatFixPt aY,
TInt8 ,// aTextAnchor
TInt8 ,// aTextDecoration
CDesCArrayFlat*, // aFamilies,
TReal aWordSpacing,
TReal aLetterSpacing,
CArrayFix<TReal32>* aArrayRotate,
CArrayFix<TFloatFixPt>* aArrayX,
CArrayFix<TFloatFixPt>* aArrayY,
TSize& aBoundingBox,
CFont*& aFont,
TFontSpec& /* aFontSpec */ )
{
if ( iStrokeColor.GetARGB() == KGfxColorNull &&
iFillColor == NULL )
return;
if(iFillOpacity == TFloatFixPt(0))
return;
if ( aDesc.Length() <= 0 )
return;
TPtrC outputText;
if ( *( aDesc.Right( 1 ).Ptr() ) < ' ' )
outputText.Set( aDesc.Left( aDesc.Length() - 1 ) );
else
outputText.Set( aDesc );
TBool rtl=EFalse;
if(TBidiText::TextDirectionality(outputText) == TBidiText::ERightToLeft)
{
rtl=ETrue;
}
if ( aFont == NULL )
{
return;
}
iFont = aFont;
float aFloat = 0.5;
//put in .50 for rounding issues 10.99 was going to 10
// iFontSize has been initialised at the SetGCL time for the
// this specific text element in question.
TInt32 fontsize = (TInt32)( iScale * iFontSize + TFloatFixPt(aFloat) );
if ( fontsize == 0 )
{
return;
}
CFont::TMeasureTextOutput myTextOutput;
TInt textAdvance = iFont->TextWidthInPixels( outputText );
if ( textAdvance == 0 )
{
return;
}
TInt fontMaxHeight = iFont->FontMaxHeight() + 2; //Tweak factor needed
TInt fontMaxAscent = iFont->FontMaxAscent() + 1; //Tweak factor needed
TInt fontAscent = iFont->AscentInPixels();
TInt fontDescent = iFont->DescentInPixels();
TInt maxDescent = fontMaxHeight-fontMaxAscent; //iFont->FontMaxDescent();
TInt fontHeightInPixels = iFont->HeightInPixels();
//added to correct for text clipping that system font has
TInt fontTweakFactor = (TInt)(TFloatFixPt( 1.5f ) * iScale);
TInt fontHorizontalTweakFactor = (TInt)(TFloatFixPt( 5.0f ) * iScale);
TInt numSpaces = myTextOutput.iSpaces;
TInt numChars = myTextOutput.iChars;
TGfxRectangle2D tempRect( aX,
aY,
textAdvance,
fontMaxHeight );
/******************************************************************
* Boundary Check to see if the Text to be drawn is within Bounds. *
******************************************************************/
TGfxAffineTransform tMatrix;
tMatrix = iTransform;
TInt32 transx = tMatrix.TranslateX();
TInt32 transy = tMatrix.TranslateY();
TGfxRectangle2D aRect = GetBBoxForSystemText( outputText , aX , aY );
TInt32 rectmaxx = aRect.MaxX(); //+ (TFloatFixPt)transx;
TInt32 rectmaxy = aRect.MaxY();//- (TFloatFixPt)fontMaxAscent; //+ (TFloatFixPt)transy;
TInt32 rectminx = aRect.MinX(); //- (TFloatFixPt)transx;
TInt32 rectminy = aRect.MinY();// - (TFloatFixPt)fontMaxHeight;//- (TFloatFixPt)fontMaxAscent; //- (TFloatFixPt)transy;
TInt32 clipminx = iRenderInfo.iClipMinX;// + transx;
TInt32 clipmaxx = iRenderInfo.iClipMaxX;// + transx;
TInt32 clipmaxy = iRenderInfo.iClipMaxY;// + transy;
TInt32 clipminy = iRenderInfo.iClipMinY;// + transy;
TInt advanceWidth = 0;
TInt advanceX = 0;
TInt excessSpace = 0;
TInt aMultipleXY = 0;
//Checking for multiple XY values.
if ( aArrayX != NULL && aArrayY != NULL )
{
if ( ( aArrayX->Count() > 1 ) || ( aArrayY->Count() > 1 ) )
aMultipleXY = 1;
}
// setting the boundbox for simple text with no xy and rotate
//this is set here because bound box should get always set as it is used in GetBBoxForSystemText in TextElement.
if ( ( aArrayRotate == NULL ) &&
( aMultipleXY == 0 ) &&
( aLetterSpacing == 0.0 ) &&
( aWordSpacing == 0.0 ) )
{
aBoundingBox.iWidth = textAdvance;
aBoundingBox.iHeight = fontMaxHeight;
}
if( rectmaxx < clipminx || rectmaxy < clipminy ||
rectminx > clipmaxx || rectminy > clipmaxy )
return;
/****************************************************************************
* Code to Draw Simple Text with only x, y and transform values and return.*
****************************************************************************/
if ( ( aArrayRotate == NULL ) &&
( aMultipleXY == 0 ) &&
( aLetterSpacing == 0.0 ) &&
( aWordSpacing == 0.0 ) )
{
CFbsBitmap* offScreenBitmap = new ( ELeave ) CFbsBitmap();
User::LeaveIfError( offScreenBitmap->Create( TSize( textAdvance, fontMaxHeight), EGray256 ) );
// User::LeaveIfError( offScreenBitmap->Create( TSize( textAdvance + fontHorizontalTweakFactor, fontMaxHeight + fontTweakFactor ), EGray256 ) );
CleanupStack::PushL( offScreenBitmap );
CGraphicsContext* bitmapContext = NULL;
CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( offScreenBitmap );
CleanupStack::PushL( bitmapDevice );
User::LeaveIfError( bitmapDevice->CreateContext( bitmapContext ) );
CleanupStack::PushL( bitmapContext );
bitmapContext->SetBrushStyle( CGraphicsContext::ESolidBrush );
bitmapContext->SetBrushColor( 0x000000 );
bitmapContext->DrawRect( TRect( TPoint( 0, 0 ), offScreenBitmap->SizeInPixels() ) );
bitmapContext->UseFont( iFont );
bitmapContext->SetPenSize( TSize( 1, 1 ) );
bitmapContext->SetPenColor( 0xFFFFFF );
bitmapContext->SetPenStyle( CGraphicsContext::ESolidPen );
bitmapContext->SetBrushStyle( CGraphicsContext::ENullBrush );
if (iTextAnchor == EGfxTextAnchorEnd)
{
aX -= TFloatFixPt(textAdvance) / iScale;
}
if (iTextAnchor == EGfxTextAnchorMiddle)
{
aX -= (TFloatFixPt(textAdvance) / iScale) / TFloatFixPt(2);
}
// While drawing the text which has both arabic & normal left-to-right
// characters the DrawTextExtended should be used since there is no way
// to split the text according to the directionality.
CGraphicsContext::TDrawTextExtendedParam param;
param.iParRightToLeft = rtl;
bitmapContext->DrawTextExtended(outputText,
TPoint( 0, fontMaxAscent ), param);
VGint width = offScreenBitmap->SizeInPixels().iWidth;
VGint height = offScreenBitmap->SizeInPixels().iHeight;
/* The bilinear causes the text to blur a bit, but rotated (& scaled) text will look better, of course */
VGImage img = iVgRenderer->vgCreateImage( VG_A_8, width, height, VG_IMAGE_QUALITY_NONANTIALIASED );
//VGImage img = vgCreateImage( VG_A_8, width, height, VG_IMAGE_QUALITY_BETTER );
//VGImage img = vgCreateImage( VG_A_8, width, height, VG_IMAGE_QUALITY_FASTER );
VGPaint paint = iVgRenderer->vgCreatePaint();
if( img && paint )
{
offScreenBitmap->LockHeap();
/* OpenVG images have their y-axis flipped,
that is why when calling vgImageSubData we pass the address of offScreenBitmap's last scanline,
and use a negated stride value */
VGint stride = CFbsBitmap::ScanLineLength( width, EGray256 ); /* EGray256 == offScreenBitmap->DisplayMode() */
VGbyte *lastScanline = ( (VGbyte*)offScreenBitmap->DataAddress() ) + ( height - 1 ) * stride;
iVgRenderer->vgImageSubData( img, lastScanline, -stride, VG_A_8, 0, 0, width, height );
offScreenBitmap->UnlockHeap();
TGfxColor color( iFillColor ? iFillColor->GetColor() : iStrokeColor.GetColor() );
VGuint argb = color.GetARGB() | ( 0xff000000 ); /* set alpha to 255 */
VGfloat rgba_f[4];
int tr, tg, tb;
tr = (argb >> 16) & 0xff;
tg = (argb >> 8 ) & 0xff;
tb = (argb ) & 0xff;
rgba_f[0] = tr / 255.0f;
rgba_f[1] = tg / 255.0f;
rgba_f[2] = tb / 255.0f;
//rgba_f[3] = ( ( argb >> 24 ) & 0xff ) / 255.0f;
rgba_f[3] = 1.0f; /* was set to 255 */
if( paint != VG_INVALID_HANDLE )
{
iVgRenderer->vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR );
iVgRenderer->vgSetParameterfv( paint, VG_PAINT_COLOR, 4, rgba_f );
iVgRenderer->vgSetPaint( paint, VG_FILL_PATH );
}
// Get the current blend mode (set back at end of operation)
const TInt KBlendModeValue = iVgRenderer->vgGeti( VG_BLEND_MODE );
const TInt KImageModeValue = iVgRenderer->vgGeti( VG_IMAGE_MODE );
iVgRenderer->vgSeti( VG_BLEND_MODE, VG_BLEND_SRC_OVER );
iVgRenderer->vgSeti( VG_IMAGE_MODE, VG_DRAW_IMAGE_MULTIPLY );
VGfloat mat[9];
/* Retreive the Path transformation matrix */
GetMatrix( mat );
iVgRenderer->vgSeti( VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE );
iVgRenderer->vgSeti( VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE );
/* Since the text rendering has to match AA done by ext, we'll round the transformation.
Seems like Symbian does not have a 32-bit float round... */
TReal tx = mat[6], ty = mat[7];
Math::Round(tx, tx, 0); Math::Round(ty, ty, 0);
mat[6] = (VGfloat)tx;
mat[7] = (VGfloat)ty;
/* Load Path transformation matrix to Image transformation matrix */
/*nga vgLoadMatrix( mat );
// TFloatFixPt aY1( aY * iScale );
// aY -= ( iFont->AscentInPixels());
//vgTranslate( (VGfloat)aX, (VGfloat)aY + fontTweakFactor);
vgTranslate( (VGfloat)aX, (VGfloat)aY );
vgScale( 1.0f/(VGfloat)iScale, -1.0f/(VGfloat)iScale );
vgTranslate( (VGfloat)0, -(VGfloat)maxDescent);
vgDrawImage( img );
vgSeti( VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE );
vgLoadIdentity();
vgSeti( VG_IMAGE_MODE, KImageModeValue );
vgSeti( VG_BLEND_MODE, KBlendModeValue );*/
iVgRenderer->vgLoadMatrix( mat );
iVgRenderer->vgTranslate( (VGfloat)aX, (VGfloat)aY );
iVgRenderer->vgScale( 1.0f/(VGfloat)iScale, -1.0f/(VGfloat)iScale );
iVgRenderer->vgTranslate( (VGfloat)0, -(VGfloat)maxDescent);
iVgRenderer->vgDrawImage( img );
iVgRenderer->vgSeti( VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE );
iVgRenderer->vgLoadIdentity();
iVgRenderer->vgSeti( VG_IMAGE_MODE, KImageModeValue );
iVgRenderer->vgSeti( VG_BLEND_MODE, KBlendModeValue );
}
if( img )
{
iVgRenderer->vgDestroyImage( img );
}
if( paint )
{
iVgRenderer->vgDestroyPaint( paint );
}
bitmapContext->DiscardFont();
CleanupStack::PopAndDestroy( 3 );
if ( iTextDecoration == EGfxTextDecorationUnderLine )
{
TGfxLine2D aLine( aX,
aY,
(aX + ( TFloatFixPt )textAdvance / iScale ),
aY); //+ ( TFloatFixPt )(2));
DrawL( &aLine );
}
else if ( iTextDecoration == EGfxTextDecorationOverLine )
{
TGfxLine2D aLine( aX,
// aY - ( TFloatFixPt )fontMaxHeight / iScale,
aY,
(aX + ( TFloatFixPt )textAdvance / iScale ),
aY);// - ( TFloatFixPt )fontMaxHeight / iScale );
DrawL( &aLine );
}
else if ( iTextDecoration == EGfxTextDecorationLineThrough )
{
TGfxLine2D aLine( aX ,
aY - ( TFloatFixPt )( fontMaxHeight / 2 ) / iScale,
(aX + ( TFloatFixPt )textAdvance /iScale ),
aY - ( TFloatFixPt )( fontMaxHeight / 2 ) / iScale );
DrawL( &aLine );
}
//-----------------------------------------------------------------
return;
}
//Check Word/Letter Spacing.
if ( aWordSpacing > 0.0 )
excessSpace += ( TInt )
( aWordSpacing * ( TReal ) iScale ) * numSpaces;
if ( aLetterSpacing > 0.0 )
excessSpace += ( TInt )
( aLetterSpacing * ( TReal ) iScale ) * numChars;
textAdvance += excessSpace;
/*****************************************************************************
* Drawing one glyph(character) at a time for multiple XY and rotation Values.*
******************************************************************************/
if (rtl)
{
TBidiText* biditext = TBidiText::NewL(outputText,1);
biditext->WrapText(textAdvance,*iFont,0,1);
outputText.Set(biditext->DisplayText());
delete biditext;
biditext = NULL;
}
TLex aOutputText( outputText );
for ( TInt count = 0; count < outputText.Length() ; count++ )
{
TPtrC outputChar;
TChar ch( aOutputText.Get() );
outputChar.Set( &( outputText.operator[]( count ) ), 1 );
TInt charWidth = iFont->CharWidthInPixels( ch );
CFbsBitmap* offScreenBitmap = new ( ELeave ) CFbsBitmap();
User::LeaveIfError( offScreenBitmap->Create( TSize( charWidth,
fontMaxHeight + fontTweakFactor ),
EColor16MU ) );
CleanupStack::PushL( offScreenBitmap );
CGraphicsContext* bitmapContext = NULL;
CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( offScreenBitmap );
CleanupStack::PushL( bitmapDevice );
User::LeaveIfError( bitmapDevice->CreateContext( bitmapContext ) );
CleanupStack::PushL( bitmapContext );
TBool isWhite = EFalse;
if ( iFillColor != NULL )
{
if ( ( ( TGfxColor * ) iFillColor )->GetARGB() == 0xffffff )
isWhite = ETrue;
}
else
{
if ( iStrokeColor.GetARGB() == 0xffffff )
isWhite = ETrue;
}
if ( isWhite )
{
// Fill with black if text color is white
TRect bmprect( 0, 0, charWidth, fontMaxHeight );
bitmapContext->SetBrushStyle( CGraphicsContext::ESolidBrush );
bitmapContext->SetBrushColor( 0x000000 );
bitmapContext->SetPenColor( 0x000000 );
bitmapContext->DrawRect( bmprect );
}
bitmapContext->UseFont( iFont );
bitmapContext->SetPenSize( TSize( 1, 1 ) );
if ( iFillColor != NULL )
{
TGfxColor lColor(iFillColor->GetColor());
bitmapContext->SetBrushColor( lColor.GetABGR() );
bitmapContext->SetPenColor( lColor.GetABGR() );
}
else
{
bitmapContext->SetBrushColor( iStrokeColor.GetABGR() );
bitmapContext->SetPenColor( iStrokeColor.GetABGR() );
}
bitmapContext->SetPenStyle( CGraphicsContext::ESolidPen );
bitmapContext->SetBrushStyle( CGraphicsContext::ENullBrush );
if ( ( aArrayX != NULL ) && ( count < aArrayX->Count() ) )
aX = aArrayX->At( count );
if ( ( aArrayY != NULL ) && ( count < aArrayY->Count() ) )
aY = aArrayY->At( count );
TFloatFixPt aY1( aY * iScale ), aX1( aX * iScale );
TFloatFixPt ScaleAA;
TGfxAffineTransform tempMatrix;
tempMatrix = iTransform;
ScaleAA = 1;
#ifdef SVG_FLOAT_BUILD
tempMatrix.Scale( ( TFloatFixPt( 1 ) / ( iScale ) ),
( TFloatFixPt( 1 ) / ( iScale ) ));
#else
tempMatrix.Scale( ( TFloatFixPt( 0x10000,ETrue ) / ( iScale ) ),
( TFloatFixPt( 0x10000,ETrue ) / ( iScale ) ));
#endif
if ( aMultipleXY == 1 )
{
aX1 = aX1 + ( TFloatFixPt ) advanceX;
}
else
aX1 = aX1 + ( TFloatFixPt ) advanceWidth;
aY1 -= ( iFont->AscentInPixels() );
if ( aMultipleXY == 0 )
{
if ( iTextAnchor == EGfxTextAnchorMiddle )
{
aX1 -= textAdvance / 2;
}
else if ( iTextAnchor == EGfxTextAnchorEnd )
{
aX1 -= textAdvance;
}
}
TGfxPoint2D p( aX1, aY1 );
TFloatFixPt trnsx, trnsy;
trnsx = aX1 ;
trnsy = aY1 + ( TFloatFixPt ) ( (fontMaxHeight / 2) + fontDescent);
//"rotate" Attribute Implementation
// If only one value is present, it is applied to all the glyphs
//otherwise, one-to-one mapping is taken. Any extra values are ignored!
if ( aArrayRotate != NULL )
{
if(count < aArrayRotate->Count())
{
TFloatFixPt KZero;
tempMatrix.Translate( trnsx, trnsy );
TReal32 aAngle( ( TReal32 ) aArrayRotate->At( count ) );
tempMatrix.Rotate( aAngle * 3.1415926f / 180.0f );
TFloatFixPt negX( KZero - trnsx );
TFloatFixPt negY( KZero - trnsy );
tempMatrix.Translate( negX, negY );
}
}
TGfxImageTransformer imgtrns( &tempMatrix, iVgRenderer);
TRect clip(iClip.iX, iClip.iY,
iClip.iWidth + iClip.iX, iClip.iHeight + iClip.iY);
p.iY -= fontTweakFactor;
imgtrns.ImageBlend( offScreenBitmap,
p,
iRenderInfo.iWidth,
iRenderInfo.iHeight,
clip,
ETrue);
if (rtl) // IsRightToLeft(outputText)
{
CGraphicsContext::TDrawTextExtendedParam param;
param.iParRightToLeft = ETrue;
bitmapContext->DrawTextExtended(outputText,
TPoint( 0, fontHeightInPixels - fontDescent + fontTweakFactor ), param);
}
else
{
bitmapContext->DrawText( outputChar, TPoint( 0, fontMaxAscent ) );
// bitmapContext->DrawText( outputChar, TPoint( 0, fontHeightInPixels - fontDescent + fontTweakFactor ));
}
TGfxRectangle2D textRect(p.iX, p.iY, textAdvance, fontMaxHeight);
imgtrns.ImageBlend( offScreenBitmap,
p,
iRenderInfo.iWidth,
iRenderInfo.iHeight,
clip);
bitmapContext->DiscardFont();
CleanupStack::PopAndDestroy( 3 );
if ( aMultipleXY == 0 )
{
TInt aSpacing = 0;
if ( aLetterSpacing > 0.0 )
{
if ( ch != 0x0020 )
aSpacing += ( TInt )
( aLetterSpacing * ( TReal ) iScale ) ;
}
if ( aWordSpacing > 0.0 )
{
if ( ch == 0x0020 )
aSpacing += ( TInt ) ( aWordSpacing * ( TReal ) iScale ) ;
}
if ( iStrokeColor.GetARGB() == KGfxColorNull )
{
if ( iFillColor != NULL )
this->iStrokeColor = TGfxColor( iFillColor->GetColor() );
}
if ( iTextDecoration == EGfxTextDecorationUnderLine )
{
if ( iTextAnchor == EGfxTextAnchorMiddle )
{
TGfxLine2D aLine( aX + (ScaleAA *
( TFloatFixPt )
( advanceWidth - textAdvance / 2 ) /
iScale),
aY,
( aX + (ScaleAA * ( ( TFloatFixPt )
( advanceWidth + charWidth + aSpacing - textAdvance / 2 ) /
iScale ) ) ),
aY );
DrawL( &aLine );
}
else if ( iTextAnchor == EGfxTextAnchorEnd )
{
TGfxLine2D aLine( aX + (ScaleAA *
( TFloatFixPt )
( advanceWidth - textAdvance ) /
iScale),
aY,
( aX + (ScaleAA * ( ( TFloatFixPt )
( advanceWidth + charWidth + aSpacing - textAdvance ) /
iScale ) ) ),
aY );
DrawL( &aLine );
}
else //Start
{
TGfxLine2D aLine( aX + (ScaleAA *
( TFloatFixPt )
advanceWidth /
iScale),
aY,
( aX + (ScaleAA * ( ( TFloatFixPt )
( advanceWidth + charWidth + aSpacing ) /
iScale ) ) ),
aY );
DrawL( &aLine );
}
}
if ( iTextDecoration == EGfxTextDecorationOverLine )
{
if ( iTextAnchor == EGfxTextAnchorMiddle )
{
TGfxLine2D aLine( aX + (ScaleAA *
( TFloatFixPt )
( advanceWidth - textAdvance / 2 ) /
iScale),
aY -
( TFloatFixPt )
fontMaxHeight /
iScale,
( aX + (ScaleAA * ( ( TFloatFixPt )
( advanceWidth + charWidth + aSpacing - textAdvance / 2 ) /
iScale ) ) ),
aY -
( TFloatFixPt )
fontMaxHeight /
iScale );
DrawL( &aLine );
}
else if ( iTextAnchor == EGfxTextAnchorEnd )
{
TGfxLine2D aLine( aX + (ScaleAA *
( TFloatFixPt )
( advanceWidth - textAdvance ) /
iScale),
aY -
( TFloatFixPt )
fontMaxHeight /
iScale,
( aX + (ScaleAA * ( ( TFloatFixPt )
( advanceWidth + charWidth + aSpacing - textAdvance ) /
iScale ) ) ),
aY -
( TFloatFixPt )
fontMaxHeight /
iScale );
DrawL( &aLine );
}
else //Start
{
TGfxLine2D aLine( aX + (ScaleAA *
( TFloatFixPt )
advanceWidth /
iScale),
aY -
( TFloatFixPt )
fontMaxHeight /
iScale,
( aX + (ScaleAA * ( ( TFloatFixPt )
( advanceWidth + charWidth + aSpacing ) /
iScale ) ) ),
aY -
( TFloatFixPt )
fontMaxHeight /
iScale );
DrawL( &aLine );
}
}
if ( iTextDecoration == EGfxTextDecorationLineThrough )
{
if ( iTextAnchor == EGfxTextAnchorMiddle )
{
TGfxLine2D aLine( aX + (ScaleAA *
( TFloatFixPt )
( advanceWidth - (textAdvance >> 1) ) /
iScale),
aY -
( TFloatFixPt )
( fontMaxHeight >> 1 ) /
iScale,
( aX + (ScaleAA * ( ( TFloatFixPt )
( advanceWidth + charWidth + aSpacing - ( textAdvance >> 1 )) /
iScale ) ) ),
aY -
( TFloatFixPt )
( fontMaxHeight >> 1 ) /
iScale );
DrawL( &aLine );
}
else if ( iTextAnchor == EGfxTextAnchorEnd )
{
TGfxLine2D aLine( aX + (ScaleAA *
( TFloatFixPt )
( advanceWidth - textAdvance ) /
iScale),
aY -
( TFloatFixPt )
( fontMaxHeight >> 1 ) /
iScale,
( aX + (ScaleAA * ( ( TFloatFixPt )
( advanceWidth + charWidth + aSpacing - textAdvance ) /
iScale ) ) ),
aY -
( TFloatFixPt )
( fontMaxHeight >> 1 ) /
iScale );
DrawL( &aLine );
}
else //Start
{
TGfxLine2D aLine( aX + (ScaleAA *
( TFloatFixPt )
advanceWidth /
iScale),
aY -
( TFloatFixPt )
( fontMaxHeight >> 1 ) /
iScale,
( aX + (ScaleAA * ( ( TFloatFixPt )
( advanceWidth + charWidth + aSpacing ) /
iScale ) ) ),
aY -
( TFloatFixPt )
( fontMaxHeight >> 1 ) /
iScale );
DrawL( &aLine );
}
}
advanceWidth += charWidth + aSpacing;
}
if ( aMultipleXY == 1 )
{
if ( count >= aArrayX->Count() - 1 )
advanceX += charWidth;
}
} //end for(Drawing single glyph)
}
// Raster image drawing
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::DrawImage( CFbsBitmap* aImage,
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::DrawImage( CFbsBitmap* aImage,
const TGfxRectangle2D& aImageRect,
TBool aHasAlpha )
{
if ( !aImage )
return;
TSize imageSize = aImage->SizeInPixels();
aImage->LockHeap();
VGImage vgImage = CreateVGImage( aImage->DataAddress(), imageSize, aImage->DisplayMode(), EFalse );
aImage->UnlockHeap();
// Transform to flip drawing to be like screen drawing (from Cartesian)
TGfxAffineTransform flipTransform = TGfxAffineTransform::GetScaleInstance( 1.0f, -1.0f );
// Shift x=0 line to top of screen (buffer)
flipTransform.Translate( TFloatFixPt ( 0 ), TFloatFixPt ( -iColorBufferSize.iHeight ) );
// Application transformations from element
flipTransform.Concatenate( iTransform );
// Set the topleft corner of image to draw
flipTransform.Translate( aImageRect.iX, aImageRect.iY );
// Caller to DrawImage already check for image size zero
float scaleX = (VGfloat)( TFloatFixPt ( aImageRect.iWidth ) / TFloatFixPt ( imageSize.iWidth ) );
float scaleY = (VGfloat)( TFloatFixPt ( aImageRect.iHeight ) / TFloatFixPt ( imageSize.iHeight ) );
// Scale to fit image to drawing area
flipTransform.Scale( scaleX, scaleY );
VGfloat matrix[] = { (VGfloat)flipTransform.iM00, (VGfloat)flipTransform.iM10, 0,
(VGfloat)flipTransform.iM01, (VGfloat)flipTransform.iM11, 0,
(VGfloat)flipTransform.iM02, (VGfloat)flipTransform.iM12, 1 };
iVgRenderer->vgSeti( VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE );
iVgRenderer->vgLoadMatrix( matrix );
// Get current blend-mode
const TInt KBlendMode = iVgRenderer->vgGeti( VG_BLEND_MODE );
iVgRenderer->vgSeti( VG_BLEND_MODE, aHasAlpha ? VG_BLEND_SRC_OVER : VG_BLEND_SRC );
/* Disable bilinear filtering -> faster, but lower rendering quality */
iVgRenderer->vgSeti( VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_NONANTIALIASED );
iVgRenderer->vgDrawImage( vgImage );
iVgRenderer->vgSeti( VG_BLEND_MODE, KBlendMode );
iVgRenderer->vgDestroyImage( vgImage );
}
// ==========================================================================
// Clear the whole graphics context with the background color
// ==========================================================================
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::Clear(TUint32 aRGBA8888Color)
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::Clear(TUint32 aARGB )
{
TUint32 rgba = ( aARGB << 8 ) | ( aARGB >> 24 );
TInt32 r, g, b, a;
r = (TInt)((rgba & 0xFF000000) >> 24);
g = (TInt)((rgba & 0x00FF0000) >> 16);
b = (TInt)((rgba & 0x0000FF00) >> 8);
a = (TInt)( rgba & 0x000000FF);
r += r >> 7; g += g >> 7; b += b >> 7; a += a >> 7;
const TFloatFixPt KInverse255 = TFloatFixPt ( 1.0f/256.0f );
const VGfloat clearColor[4] = { (VGfloat)(KInverse255 * TFloatFixPt (r)),
(VGfloat)(KInverse255 * TFloatFixPt (g)),
(VGfloat)(KInverse255 * TFloatFixPt (b)),
(VGfloat)(KInverse255 * TFloatFixPt (a)) };
iVgRenderer->vgSeti( VG_SCISSORING, VG_FALSE );
iVgRenderer->vgSetfv( VG_CLEAR_COLOR, 4, clearColor );
iVgRenderer->vgClear( 0, 0, iColorBufferSize.iWidth, iColorBufferSize.iHeight );
iVgRenderer->vgSeti( VG_SCISSORING, VG_TRUE );
}
// ==========================================================================
// This method copies the internal RGBA8888 framebuffer to CfbsBitmap that
// is specified in constructor. The CfbsBitmap could be 4k color (RGB0444),
// 64k color (RGB565), or 16M color (RGB888).
// ==========================================================================
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::UpdateFramebufferL()
// --------------------------------------------------------------------------
void CGfx2dGcOpenVG::UpdateFramebufferL( CFbsBitmap* aBitmap, CFbsBitmap* aMask)
{
if ( !aBitmap || aBitmap->SizeInPixels() != iColorBufferSize )
{
return;
}
const TDisplayMode KBitmapDisplayMode = aBitmap->DisplayMode();
// This check just before VGISymbianCopyToBitmap avoid putting lot
// many similar error checks in the code. If there is any problem
// during OpenVG call we simply leave without drawing any thing.
VGErrorCode vgret = (VGErrorCode)iVgRenderer->vgGetError();
if(vgret != VG_NO_ERROR )
{
User::LeaveIfError(OpenVGErrorToSymbianError(vgret));
}
// EGray2 is not support in VGISymbianCopyToBitmap API
if ( KBitmapDisplayMode == EGray2 )
{
const TInt KStride = CFbsBitmap::ScanLineLength( iColorBufferSize.iWidth, KBitmapDisplayMode );
aBitmap->LockHeap();
// Get data address of last line and move upwards (negative stride)
// OpenVG uses Cartesian coordinate system and Symbian uses Screen coordinate system.
TUint* data = (TUint*)((TUint)aBitmap->DataAddress() + ( KStride * ( iColorBufferSize.iHeight - 1 ) ) );
iVgRenderer->vgReadPixels( data, -KStride, VG_BW_1, 0, 0,
iColorBufferSize.iWidth, iColorBufferSize.iHeight );
aBitmap->UnlockHeap();
if ( aMask )
{
GenerateMask( aMask );
}
}
// All other color modes
else
{
// No Mask -- to be generated in GenerateMask
TInt error=KErrNone;
//In cases, where the mask/aMaskBitmap != NULL, the hint should be defined as VGI_SKIP_TRANSPARENT_PIXELS.
//In all other cases, i.e., when mask/aMaskBitmap == NULL, the definition should be VGI_COPY_TRANSPARENT_PIXELS
error = iVgSurface->CopyBitmap(ENone,ENone, aBitmap, aMask, iColorBufferSize);
if ( error != KErrNone )
{
#ifdef _DEBUG
RDebug::Printf("VGISymbianCopyToBitmap failed: error code: %d", error );
RDebug::Printf(" - Color mode: %d", aBitmap->DisplayMode() );
RDebug::Printf(" - Bitmap size: %dx%d", iColorBufferSize.iWidth, iColorBufferSize.iHeight );
#endif
User::LeaveIfError(error);
}
// VGISymbianCopyToBitmap only generates Gray256 mask
if ( aMask && aMask->DisplayMode() == EGray2 )
{
GenerateMask( aMask );
}
}
}
//NGA
// ---------------------------------------------------------------------------------------------------------------------------------------
//void UpdateFramebufferL( CFbsBitmap* aBitmap, CFbsBitmap* aMask,TSize BitmapSize,TDisplayMode aBitmapDspMode,TDisplayMode aMaskDspMode )
// ---------------------------------------------------------------------------------------------------------------------------------------
void CGfx2dGcOpenVG::UpdateFramebufferL( CFbsBitmap* aBitmap, CFbsBitmap* aMask,TSize /*BitmapSize*/,TDisplayMode aBitmapDspMode,TDisplayMode aMaskDspMode )
{
if ( !aBitmap)
{
return;
}
const TDisplayMode KBitmapDisplayMode = aBitmap->DisplayMode();
// This check just before VGISymbianCopyToBitmap avoid putting lot
// many similar error checks in the code. If there is any problem
// during OpenVG call we simply leave without drawing any thing.
VGErrorCode vgret = (VGErrorCode)iVgRenderer->vgGetError();
if(vgret != VG_NO_ERROR )
{
User::LeaveIfError(OpenVGErrorToSymbianError(vgret));
}
// EGray2 is not support in VGISymbianCopyToBitmap API
if ( KBitmapDisplayMode == EGray2 )
{
const TInt KStride = CFbsBitmap::ScanLineLength( iColorBufferSize.iWidth, KBitmapDisplayMode );
aBitmap->LockHeap();
// Get data address of last line and move upwards (negative stride)
// OpenVG uses Cartesian coordinate system and Symbian uses Screen coordinate system.
TUint* data = (TUint*)((TUint)aBitmap->DataAddress() + ( KStride * ( iColorBufferSize.iHeight - 1 ) ) );
iVgRenderer->vgReadPixels( data, -KStride, VG_BW_1, 0, 0,
iColorBufferSize.iWidth, iColorBufferSize.iHeight );
aBitmap->UnlockHeap();
if ( aMask )
{
GenerateMask( aMask );
}
}
// All other color modes
else
{
// No Mask -- to be generated in GenerateMask
TInt error=KErrNone;
//In cases, where the mask/aMaskBitmap != NULL, the hint should be defined as VGI_SKIP_TRANSPARENT_PIXELS.
//In all other cases, i.e., when mask/aMaskBitmap == NULL, the definition should be VGI_COPY_TRANSPARENT_PIXELS
error = iVgSurface->CopyBitmap(aBitmapDspMode, aMaskDspMode, aBitmap, aMask, iColorBufferSize);
if ( error != KErrNone )
{
#ifdef _DEBUG
RDebug::Printf("VGISymbianCopyToBitmap failed: error code: %d", error );
RDebug::Printf(" - Color mode: %d", aBitmap->DisplayMode() );
RDebug::Printf(" - Bitmap size: %dx%d", iColorBufferSize.iWidth, iColorBufferSize.iHeight );
#endif
User::LeaveIfError(error);
}
// VGISymbianCopyToBitmap only generates Gray256 mask
if ( aMask && aMask->DisplayMode() == EGray2 )
{
GenerateMask( aMask );
}
}
}
// ====================================================================================
// Blend bitmap with background according to group opacity
// This function gets called with the opacity framebuffer and the group opacity value
// The opacity buffer is initialized with the 0xAA55AA55 value. The pixels not matching
// the initialiazation value are the pixels that have to be blended with the background.
// ====================================================================================
// --------------------------------------------------------------------------
// void CGfx2dGcVGR::BlendWithBackground(TUint32* aFrameBuffer, TReal32 aOpacity)
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::BlendWithBackground(TUint32* /* aColorBuffer */, TReal32 /* aOpacity */)
{
/*
if ( !iColorBuffer || !aColorBuffer )
{
return;
}
TReal32 inverseAlpha = 1.0f - aOpacity;
const TInt KMax = iColorBufferSize.iWidth * iColorBufferSize.iHeight;
TUint32* dst = iColorBuffer;
TUint32* src = aColorBuffer;
for ( TInt i = KMax - 1; i >= 0; i-- )
{
TUint32 srcColor = src[i];
TUint32 dstColor = dst[i];
if ( srcColor != dstColor )
{
dst[i] = ((((TUint)((srcColor >> 24 ) * aOpacity) +
(TUint)((dstColor >> 24 ) * inverseAlpha))) << 24) | // red
((((TUint)((srcColor >> 16 & 0xff) * aOpacity) +
(TUint)((dstColor >> 16 & 0xff) * inverseAlpha))) << 16) | // green
((((TUint)((srcColor >> 8 & 0xff) * aOpacity) +
(TUint)((dstColor >> 8 & 0xff) * inverseAlpha))) << 8 ) | // blue
(srcColor & 0x000000FF); // keep orignal alpha
}
}
*/
}
// ==========================================================================
// Generate 8 bit gray or 1bit B/W mask from internal ARGB8888 frame buffer.
// ==========================================================================
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::GenerateMask(CFbsBitmap* aMask)
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::GenerateMask(CFbsBitmap* aMask)
{
if ( !aMask || aMask->SizeInPixels() != iColorBufferSize )
{
return;
}
const TDisplayMode KMaskDisplayMode = aMask->DisplayMode();
if ( KMaskDisplayMode != EGray256 && KMaskDisplayMode != EGray2 )
{
return;
}
const TInt KOriginalFilterMasks = iVgRenderer->vgGeti( VG_FILTER_CHANNEL_MASK );//
const TInt KStride = CFbsBitmap::ScanLineLength( iColorBufferSize.iWidth, KMaskDisplayMode );
// Change to get alpha values from OpenVG
iVgRenderer->vgSeti( VG_FILTER_CHANNEL_MASK, VG_ALPHA );
VGImageFormat format = ( KMaskDisplayMode == EGray256 ) ? VG_A_8 : VG_BW_1;
aMask->LockHeap();
// Get data address of last line and move upwards (negative stride)
// OpenVG uses Cartesian coordinate system and Symbian uses Screen coordinate system.
TUint* data = (TUint*)((TUint)aMask->DataAddress() + ( KStride * ( iColorBufferSize.iHeight - 1 ) ) );
iVgRenderer->vgReadPixels( data, -KStride, format, 0, 0,
iColorBufferSize.iWidth, iColorBufferSize.iHeight );
aMask->UnlockHeap();
// Set back the original filter-masks
iVgRenderer->vgSeti( VG_FILTER_CHANNEL_MASK, KOriginalFilterMasks );
}
// ==========================================================================
// This function calls the low level function to set fill opacity value
// ==========================================================================
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetFillOpacity(TFloatFixPt aFillOpacity)
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetFillOpacity(TFloatFixPt aFillOpacity)
{
iFillOpacity = aFillOpacity;
}
// ==========================================================================
// This function calls the low level function to set stroke opacity value
// ==========================================================================
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetStrokeOpacity(TFloatFixPt aStrokeOpacity)
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetStrokeOpacity(TFloatFixPt aStrokeOpacity)
{
iStrokeOpacity = aStrokeOpacity;
}
// ==========================================================================
// This function is called to set the dithering flag
// ==========================================================================
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::SetDoDithering( TBool aDoDithering )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::SetDoDithering( TBool /*aDoDithering*/ )
{
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::ApplyTransform
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::ApplyTransform( TGfxAffineTransform& aAffineTransform )
{
iVgRenderer->vgSeti( VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE );
TUint transformType = aAffineTransform.iTransType;
// Only translation is applied
if ( transformType == KTransformTranslate )
{
iVgRenderer->vgLoadIdentity();
iVgRenderer->vgScale( 1.0f, -1.0f );
iVgRenderer->vgTranslate( (VGfloat)aAffineTransform.iM02,
(VGfloat)(TFloatFixPt (-iColorBufferSize.iHeight) + aAffineTransform.iM12 ) );
}
// General case: Rotate and/or scaling, translation
else
{
TGfxAffineTransform flipTransform = TGfxAffineTransform::GetScaleInstance( 1.0f, -1.0f );
flipTransform.Translate( TFloatFixPt ( 0 ), TFloatFixPt ( -iColorBufferSize.iHeight ) );
flipTransform.Concatenate( aAffineTransform );
VGfloat matrix[] = { (VGfloat)flipTransform.iM00, (VGfloat)flipTransform.iM10, 0,
(VGfloat)flipTransform.iM01, (VGfloat)flipTransform.iM11, 0,
(VGfloat)flipTransform.iM02, (VGfloat)flipTransform.iM12, 1 };
iVgRenderer->vgLoadMatrix( matrix );
}
}
void CGfx2dGcOpenVG::ApplyTransformMediaElement( const TGfxAffineTransform& aAffineTransform,TSize& /*aSize*/ )
{
iVgRenderer->vgSeti( VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE );
// TUint transformType = aAffineTransform.iTransType;
// Only translation is applied
/* if ( transformType == KTransformTranslate )
{
vgLoadIdentity();
vgScale( 1.0f, -1.0f );
vgTranslate( (VGfloat)aAffineTransform.iM02,
(VGfloat)(TFloatFixPt (-iColorBufferSize.iHeight) + aAffineTransform.iM12 ) );
}
// General case: Rotate and/or scaling, translation
else
{
TGfxAffineTransform flipTransform = TGfxAffineTransform::GetScaleInstance( 1.0f, -1.0f );
flipTransform.Translate( TFloatFixPt ( 0 ), TFloatFixPt ( -iColorBufferSize.iHeight ) );
flipTransform.Concatenate( aAffineTransform );
VGfloat matrix[] = { (VGfloat)flipTransform.iM00, (VGfloat)flipTransform.iM10, 0,
(VGfloat)flipTransform.iM01, (VGfloat)flipTransform.iM11, 0,
(VGfloat)flipTransform.iM02, (VGfloat)flipTransform.iM12, 1 };
vgLoadMatrix( matrix );
}*/
TGfxAffineTransform flipTransform = TGfxAffineTransform::GetScaleInstance( 1.0f, -1.0f );
flipTransform.Translate( TFloatFixPt ( 0 ), TFloatFixPt ( -iColorBufferSize.iHeight ) );
//flipTransform.Concatenate( aAffineTransform );
TGfxAffineTransform flipTransformTemp = aAffineTransform;
flipTransformTemp.Concatenate( flipTransform );
flipTransform.Concatenate( flipTransformTemp );
VGfloat matrix[] = { (VGfloat)flipTransform.iM00, (VGfloat)flipTransform.iM10, 0,
(VGfloat)flipTransform.iM01, (VGfloat)flipTransform.iM11, 0,
(VGfloat)flipTransform.iM02, (VGfloat)flipTransform.iM12, 1 };
iVgRenderer->vgLoadMatrix( matrix );
}
VGImage CGfx2dGcOpenVG::CreateVGImage( void* aBuffer, TSize aSize, TDisplayMode aDisplayMode, TBool aPreMultiplied )
{
VGImage vgImage = VGImage( -1 );
if ( aBuffer )
{
VGint stride = CFbsBitmap::ScanLineLength( aSize.iWidth, aDisplayMode );
if ( aDisplayMode == EColor64K )
{
vgImage = iVgRenderer->vgCreateImage( VG_sRGB_565, aSize.iWidth, aSize.iHeight, VG_IMAGE_QUALITY_FASTER );
iVgRenderer->vgImageSubData( vgImage, aBuffer, stride, VG_sRGB_565,
0, 0, aSize.iWidth, aSize.iHeight );
}
else if ( aDisplayMode == EColor16MU )
{
VGImageFormat format = aPreMultiplied ? VG_sRGBA_8888_PRE :VG_sRGBA_8888;
vgImage = iVgRenderer->vgCreateImage( format, aSize.iWidth, aSize.iHeight, VG_IMAGE_QUALITY_FASTER );
iVgRenderer->vgImageSubData( vgImage, aBuffer, stride, format,
0, 0, aSize.iWidth, aSize.iHeight );
}
else
{
#ifdef _DEBUG
RDebug::Printf("SVGT CreateVGImage:: Color Mode not supported: %d ", aDisplayMode );
#endif
}
}
return vgImage;
}
void CGfx2dGcOpenVG::BindToImageL()
{
TUint32* buffer = NULL;
buffer = new (ELeave) TUint32[ iColorBufferSize.iWidth * iColorBufferSize.iHeight ] ;
iVgSurface->PrepareToBindClientBuffer();
//VGImage vgImage = CreateVGImage( buffer, iColorBufferSize, EColor16MU, ETrue );
VGImage vgImage = iVgRenderer->vgCreateImage( VG_sRGBA_8888_PRE,iColorBufferSize.iWidth, iColorBufferSize.iHeight, VG_IMAGE_QUALITY_FASTER );
//Clear VGImage
VGfloat color[4] = { 1.0f, 1.0f, 1.0f, 0.0f };
iVgRenderer->vgSetfv(VG_CLEAR_COLOR, 4, color);
iVgRenderer->vgClearImage(vgImage,0,0,iColorBufferSize.iWidth,iColorBufferSize.iHeight);
//Clear VGImage
TInt error = iVgSurface->BindClientBuffer( vgImage );
if ( error != KErrNone )
{
#ifdef _DEBUG
RDebug::Printf("SVGT CGfx2dGcOpenVG::BindToImageL--VGISymbianBindToImageL failed: %d", error);
#endif
iVgRenderer->vgDestroyImage(vgImage) ;
// Delete color-buffer to match count with vgImage
delete[] buffer;
if( error == KErrNoMemory )
{
// Need to reset values at our side as OpenVG calls VGISymbianTerminate.
ResetContextHandle();
}
User::Leave(error);
}
iGroupOpacityBuffers.Append( buffer );
iGroupOpacityImages.Append( vgImage );
iVgRenderer->vgLoadIdentity();
}
void CGfx2dGcOpenVG::BindToMediaImageL(TInt aWidth, TInt aHeight)
{
TUint32* buffer = NULL;
buffer = new (ELeave) TUint32[ iColorBufferSize.iWidth * iColorBufferSize.iHeight ];
iVgSurface->PrepareToBindClientBuffer();
VGImage vgImage = CreateVGImage( buffer, iColorBufferSize, EColor16MU, ETrue );
VGfloat color[4] = { 1.0f, 1.0f, 1.0f, 0.0f };
iVgRenderer->vgSetfv(VG_CLEAR_COLOR, 4, color);
iVgRenderer->vgClearImage(vgImage,0,0,iColorBufferSize.iWidth,iColorBufferSize.iHeight);
//vgClearImage(vgImage,0,0,aWidth,aHeight);
TInt error = iVgSurface->BindClientBuffer( vgImage );
if ( error != KErrNone )
{
#ifdef _DEBUG
RDebug::Printf("SVGT CGfx2dGcOpenVG::BindToImage--VGISymbianBindToImage failed: %d", error);
#endif
iVgRenderer->vgDestroyImage(vgImage) ;
// Delete color-buffer to match count with vgImage
delete[] buffer;
if( error == KErrNoMemory )
{
// Need to reset values at our side as OpenVG calls VGISymbianTerminate.
ResetContextHandle();
}
User::Leave(error);
}
iGroupOpacityBuffers.Append( buffer );
iGroupOpacityImages.Append( vgImage );
iVgRenderer->vgLoadIdentity();
TGfxRectangle2D aClip(0,0,aWidth,aHeight);
iClipMain = iClip;
SetClip(aClip);
}
void CGfx2dGcOpenVG::UnbindFromImageL( TReal32 aOpacity )
{
if ( iGroupOpacityImages.Count() == 0 )
{
return;
}
TInt error = iVgSurface->UnBindClientBuffer();
if ( error != KErrNone )
{
#ifdef _DEBUG
RDebug::Printf("SVGT CGfx2dGcOpenVG::UnbindFromImage--VGISymbianUnBindImage failed: %d", error);
#endif
if( error == KErrNoMemory )
{
// Need to reset values at our side as OpenVG calls VGITerminate.
ResetContextHandle();
}
User::LeaveIfError(error);
}
// Need to bind to previous level image
// Else VGISymbianUnBindImage binds to non-image
if ( iGroupOpacityImages.Count() > 1 )
{
iVgSurface->PrepareToBindClientBuffer();
TInt error = iVgSurface->BindClientBuffer( iGroupOpacityImages[iGroupOpacityImages.Count()-2] );
if ( error != KErrNone )
{
#ifdef _DEBUG
RDebug::Printf("SVGT CGfx2dGcOpenVG::UnbindFromImage--VGISymbianBindToImage failed: %d", error);
#endif
iVgSurface->UnBindClientBuffer();
// Remove and Destroy all the previous images and buffer
TInt iIndex = iGroupOpacityImages.Count()-1;
for( ;iIndex >= 0 ; iIndex-- )
{
iVgRenderer->vgDestroyImage( iGroupOpacityImages[ iIndex ] );
iGroupOpacityImages.Remove( iIndex );
}
iIndex = iGroupOpacityBuffers.Count()-1;
for( ;iIndex >= 0 ; iIndex-- )
{
delete [] iGroupOpacityBuffers[ iIndex ];
iGroupOpacityBuffers.Remove( iIndex );
}
if( error == KErrNoMemory )
{
// Need to reset values at our side as OpenVG calls VGISymbianTerminate.
ResetContextHandle();
}
User::LeaveIfError(error);
}
}
// Check if default fill paint needs to be created
if ( iFillPaint == VG_INVALID_HANDLE )
{
iFillPaint = iVgRenderer->vgCreatePaint();
}
// Check if default stroke paint needs to be created
if ( iStrokePaint == VG_INVALID_HANDLE )
{
iStrokePaint = iVgRenderer->vgCreatePaint();
}
VGfloat opaquePaint[] = { 1.0f, 1.0f, 1.0f, aOpacity };
// Create paint object
VGPaint paint = iVgRenderer->vgCreatePaint();
if ( paint != VG_INVALID_HANDLE )
{
// Set solid paint of opacity
iVgRenderer->vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
iVgRenderer->vgSetParameterfv( paint, VG_PAINT_COLOR, 4, opaquePaint);
iVgRenderer->vgSetPaint( paint, VG_FILL_PATH | VG_STROKE_PATH );
// Set image mode to multiply
iVgRenderer->vgSeti( VG_IMAGE_MODE, VG_DRAW_IMAGE_MULTIPLY );
// Draw opacity image
iVgRenderer->vgSeti( VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE );
iVgRenderer->vgLoadIdentity();
iVgRenderer->vgDrawImage( iGroupOpacityImages[iGroupOpacityImages.Count()-1] );
// Reset the image draw mode
iVgRenderer->vgSeti( VG_IMAGE_MODE, VG_DRAW_IMAGE_NORMAL );
// Restore the fill and paint
if ( iFillPaint != VG_INVALID_HANDLE )
{
iVgRenderer->vgSetPaint( iFillPaint, VG_FILL_PATH );
}
if ( iStrokePaint != VG_INVALID_HANDLE )
{
iVgRenderer->vgSetPaint( iStrokePaint, VG_STROKE_PATH );
}
iVgRenderer->vgDestroyPaint( paint );
}
else
{
VGErrorCode error = (VGErrorCode)iVgRenderer->vgGetError();
if (error == VG_OUT_OF_MEMORY_ERROR)
{
RDebug::Printf("SVGT CGfx2dGcOpenVG::UnbindFromImage vgCreatePaint OOM");
// Remove and Destroy all the previous images and buffer
TInt iIndex = iGroupOpacityImages.Count()-1;
for( ;iIndex >= 0 ; iIndex-- )
{
iVgRenderer->vgDestroyImage( iGroupOpacityImages[ iIndex ] );
iGroupOpacityImages.Remove( iIndex );
}
iIndex = iGroupOpacityBuffers.Count()-1;
for( ;iIndex >= 0 ; iIndex-- )
{
delete [] iGroupOpacityBuffers[ iIndex ];
iGroupOpacityBuffers.Remove( iIndex );
}
ResetContextHandle();
User::Leave(KErrNoMemory);
}
#ifdef _DEBUG
RDebug::Printf("SVGT CGfx2dGcOpenVG::UnbindFromImage vgCreatePaint failed");
#endif
}
// Remove/Delete OpenVG Image object
TInt imageIndex = iGroupOpacityImages.Count() - 1;
if ( imageIndex >= 0 )
{
iVgRenderer->vgDestroyImage( iGroupOpacityImages[ imageIndex ] );
iGroupOpacityImages.Remove( imageIndex );
}
// Remove/Delete color-buffer
TInt bufferIndex = iGroupOpacityBuffers.Count() - 1;
if ( bufferIndex >= 0 )
{
delete [] iGroupOpacityBuffers[ bufferIndex ];
iGroupOpacityBuffers.Remove( bufferIndex );
}
}
// --------------------------------------------------------------------------
// void CGfx2dGcOpenVG::UnbindFromMediaImageL(
// const TGfxAffineTransform& aAffineTransform,
// TReal32 aOpacity,
// TInt aWidth,
// TInt aHeight )
// ---------------------------------------------------------------------------
void CGfx2dGcOpenVG::UnbindFromMediaImageL(
const TGfxAffineTransform& aAffineTransform,
TReal32 aOpacity,
TInt aWidth,
TInt aHeight, TInt aDraw )
{
if ( iGroupOpacityImages.Count() == 0 )
{
return;
}
TInt error = iVgSurface->UnBindClientBuffer();
if ( error != KErrNone )
{
#ifdef _DEBUG
RDebug::Printf( "SVGT CGfx2dGcOpenVG::UnbindFromMediaImage--VGISymbianUnBindImage failed: %d", error);
#endif
if( error == KErrNoMemory )
{
// Need to reset values at our side as OpenVG calls
// VGITerminate.
ResetContextHandle();
}
User::LeaveIfError(error);
}
// Restore the clipping window back to main window
SetClip(iClipMain);
// Need to bind to previous level image
// Else VGISymbianUnBindImage binds to non-image
if ( iGroupOpacityImages.Count() > 1 )
{
iVgSurface->PrepareToBindClientBuffer();
TInt error = iVgSurface->BindClientBuffer( iGroupOpacityImages[iGroupOpacityImages.Count()-2] );
if ( error != KErrNone )
{
#ifdef _DEBUG
RDebug::Printf("SVGT CGfx2dGcOpenVG::UnbindFromMediaImage--VGISymbianBindToImage failed: %d", error);
#endif
iVgSurface->UnBindClientBuffer();
// Remove and Destroy all the previous images and buffer
TInt iIndex = iGroupOpacityImages.Count()-1;
for( ;iIndex >= 0 ; iIndex-- )
{
iVgRenderer->vgDestroyImage( iGroupOpacityImages[ iIndex ] );
iGroupOpacityImages.Remove( iIndex );
}
iIndex = iGroupOpacityBuffers.Count()-1;
for( ;iIndex >= 0 ; iIndex-- )
{
delete [] iGroupOpacityBuffers[ iIndex ];
iGroupOpacityBuffers.Remove( iIndex );
}
// Destroy the Previous two Opacity buffer
if( error == KErrNoMemory )
{
// Need to reset values at our side as OpenVG calls VGISymbianTerminate.
ResetContextHandle();
}
User::LeaveIfError(error);
}
}
// Create opaque paint
VGfloat opaquePaint[] = { 1.0f, 1.0f, 1.0f, aOpacity };
// Check if default fill paint needs to be created
if ( iFillPaint == VG_INVALID_HANDLE )
{
iFillPaint = iVgRenderer->vgCreatePaint();
}
// Check if default stroke paint needs to be created
if ( iStrokePaint == VG_INVALID_HANDLE )
{
iStrokePaint = iVgRenderer->vgCreatePaint();
}
// Create paint object
VGPaint paint = iVgRenderer->vgCreatePaint();
if ( paint != VG_INVALID_HANDLE )
{
// Set solid paint of opacity
iVgRenderer->vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
iVgRenderer->vgSetParameterfv( paint, VG_PAINT_COLOR, 4, opaquePaint);
iVgRenderer->vgSetPaint( paint, VG_FILL_PATH | VG_STROKE_PATH );
// Set image mode to normal
iVgRenderer->vgSeti( VG_IMAGE_MODE, VG_DRAW_IMAGE_NORMAL );
// Draw the animation element with transforms applied on the
// main colour buffer
TSize size(aWidth,aHeight);
ApplyTransformMediaElement(aAffineTransform,size);
// Check so that animation element is drawn only when animation has started
if ( aDraw == KMediaAnimationVisible )
{
iVgRenderer->vgDrawImage( iGroupOpacityImages[iGroupOpacityImages.Count()-1] );
}
// Restore the fill and paint
if ( iFillPaint != VG_INVALID_HANDLE )
{
iVgRenderer->vgSetPaint( iFillPaint, VG_FILL_PATH );
}
if ( iStrokePaint != VG_INVALID_HANDLE )
{
iVgRenderer->vgSetPaint( iStrokePaint, VG_STROKE_PATH );
}
iVgRenderer->vgDestroyPaint( paint );
}
else
{
VGErrorCode error = (VGErrorCode)iVgRenderer->vgGetError();
if (error == VG_OUT_OF_MEMORY_ERROR)
{
RDebug::Printf("SVGT CGfx2dGcOpenVG::UnbindFromMediaImage vgCreatePaint OOM");
// Remove and Destroy all the previous images and buffer
TInt iIndex = iGroupOpacityImages.Count()-1;
for( ;iIndex >= 0 ; iIndex-- )
{
iVgRenderer->vgDestroyImage( iGroupOpacityImages[ iIndex ] );
iGroupOpacityImages.Remove( iIndex );
}
iIndex = iGroupOpacityBuffers.Count()-1;
for( ;iIndex >= 0 ; iIndex-- )
{
delete [] iGroupOpacityBuffers[ iIndex ];
iGroupOpacityBuffers.Remove( iIndex );
}
ResetContextHandle();
User::Leave(KErrNoMemory);
}
#ifdef _DEBUG
RDebug::Printf("SVGT CGfx2dGcOpenVG::UnbindFromMediaImage vgCreatePaint failed");
#endif
}
// Remove/Delete OpenVG Image object
TInt imageIndex = iGroupOpacityImages.Count() - 1;
if ( imageIndex >= 0 )
{
iVgRenderer->vgDestroyImage( iGroupOpacityImages[ imageIndex ] );
iGroupOpacityImages.Remove( imageIndex );
}
// Remove/Delete color-buffer
TInt bufferIndex = iGroupOpacityBuffers.Count() - 1;
if ( bufferIndex >= 0 )
{
delete [] iGroupOpacityBuffers[ bufferIndex ];
iGroupOpacityBuffers.Remove( bufferIndex );
}
}
// These are for work-around for OpenVG to simulate multiple contexts
void CGfx2dGcOpenVG::SetupContextL()
{
// Ensure OpenVG is initialized: could have been terminated by another Svg engine
// Returns immediately if already initialized
TInt err = iVgSurface->InitializeSurface( iColorBufferSize, VGI_COLORSPACE_SRGB );
if (!((err == KErrNone) || (err == KErrAlreadyExists)))
{
#ifdef _DEBUG
RDebug::Printf("SVG can't initialize OpenVG Context %d", err);
#endif
iGraphicsContextCreated = EFalse;
User::Leave(err);
}
iGraphicsContextCreated = ETrue;
// Ensure context size is correct: could have been change by another Svg engine
// Returns immediately if size is the same
err = iVgSurface->ResizeSurface( iColorBufferSize );
if( err != KErrNone )
{
if(err == KErrNoMemory )
{
#ifdef _DEBUG
RDebug::Printf("OpenVG Context destroyed %d", err);
#endif //_DEBUG
// This indicates that OpenVG has destroyed the current context handle
// and also the Path, StrokePaint and FillPaint handles are no more valid.
// Thus reinitialize them to 0, so that they can be recreated.
ResetContextHandle();
}
#ifdef _DEBUG
RDebug::Printf("SVG can't RESIZE OpenVG Context %d", err);
#endif //_DEBUG
User::Leave(err);
}
}
void CGfx2dGcOpenVG::Flush()
{
if (iCurrentRendererType == ESVGRendererTLV)
{
iPath = VG_INVALID_HANDLE;
iFillPaint = VG_INVALID_HANDLE;
iStrokePaint = VG_INVALID_HANDLE;
}
iVgRenderer->vgFlush();
}
/**
* Sets the Paint,Stroke and Path handle back to VG_INVALID_HANDLE
*
* @since
* @return void
*/
void CGfx2dGcOpenVG::ResetContextHandle()
{
iPath = VG_INVALID_HANDLE;
iFillPaint = VG_INVALID_HANDLE;
iStrokePaint = VG_INVALID_HANDLE;
iGraphicsContextCreated = EFalse;
}
void CGfx2dGcOpenVG::GetMatrix(TReal32 * m)
{
//Below is the replacement for vgGetMatrix
TGfxAffineTransform flipTransform;
if ( iTransform.iTransType == KTransformTranslate )
{
flipTransform = TGfxAffineTransform::GetScaleInstance( 1.0f, -1.0f );//get and identity matrix and scale the x,y axis to (1,-1)
flipTransform.Translate((VGfloat)iTransform.iM02, (VGfloat)(TFloatFixPt (-iColorBufferSize.iHeight) + iTransform.iM12 ) );
m[0] = (VGfloat)flipTransform.iM00;
m[1] = (VGfloat)flipTransform.iM10;
m[2] = 0;
m[3] = (VGfloat)flipTransform.iM01;
m[4] = (VGfloat)flipTransform.iM11;
m[5] = 0;
m[6] = (VGfloat)flipTransform.iM02;
m[7] = (VGfloat)flipTransform.iM12;
m[8] = 1;
}
// General case: Rotate and/or scaling, translation
else
{
flipTransform = TGfxAffineTransform::GetScaleInstance( 1.0f, -1.0f );
flipTransform.Translate( TFloatFixPt ( 0 ), TFloatFixPt ( -iColorBufferSize.iHeight ) );
flipTransform.Concatenate( iTransform );
m[0] = (VGfloat)flipTransform.iM00;
m[1] = (VGfloat)flipTransform.iM10;
m[2] = 0;
m[3] = (VGfloat)flipTransform.iM01;
m[4] = (VGfloat)flipTransform.iM11;
m[5] = 0;
m[6] = (VGfloat)flipTransform.iM02;
m[7] = (VGfloat)flipTransform.iM12;
m[8] = 1;
}
}
void CGfx2dGcOpenVG::SetBitmapHeader(const TDesC* aHeaderData)
{
iVgSurface->SetConfiguration(CVGSurface::BTIMAP_HEADER, aHeaderData);
}
const TPtrC8 CGfx2dGcOpenVG::TLVEncodedData() const
{
return(iVgRenderer->TLVEncodedData());
}