1 /*

     2 * Copyright (c) 2006-2008 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Implements CHuiVg10Gc, an OpenVG 1.0 version of the HUITK

    15 *                graphics context.

    16 *

    17 */

    18 

    19 

    20 

    21 #include "HuiVg10Gc.h"  // Class definition

    22 #include "HuiVg10RenderPlugin.h"

    23 #include "HuiVg10Texture.h"

    24 #include "HuiVg10RenderSurface.h"

    25 #include "uiacceltk/HuiSegmentedTexture.h"

    26 #include "uiacceltk/HuiFont.h"

    27 #include "uiacceltk/HuiImage.h"

    28 #include "uiacceltk/HuiTextMesh.h"

    29 #include "uiacceltk/HuiCurvePath.h"

    30 #include "uiacceltk/HuiTransformation.h"

    31 #include "uiacceltk/HuiUtil.h"

    32 #include "uiacceltk/HuiPanic.h"

    33 #include "uiacceltk/huifixmath.h"

    34 #include "HuiRenderSurface.h"

    35 #include "../../CommonInc/uiacceltkdomaincrkeys.h"

    36 

    37 #include <e32math.h>

    38 #include <VG/vgu.h>

    39 #ifdef __NVG

    40 #pragma message( "NVG Defined!" )

    41     #include <nvg.h>

    42     #include <AknIconHeader.h>

    43     #include <AknIconUtils.h>

    44     #include "NVGIcon.h"

    45 #endif

    46 

    47 const TInt KHuiMaxVgScissorRects = 32;

    48 

    49 /** Only render colorful rectangles instead of real graphics 

    50  *  content. Useful for debugging broken OpenVG drivers.

    51  */

    52 //#define RENDER_DEBUG_RECTANGLES

    53 

    54 CHuiVg10Gc* CHuiVg10Gc::NewL()

    55     {

    56     CHuiVg10Gc* self = CHuiVg10Gc::NewLC();

    57     CleanupStack::Pop(self);

    58     return self;

    59     }

    60 

    61 

    62 CHuiVg10Gc* CHuiVg10Gc::NewLC()

    63     {

    64     CHuiVg10Gc* self = new (ELeave) CHuiVg10Gc();

    65     CleanupStack::PushL(self);

    66     self->ConstructL();

    67     return self;

    68     }

    69 

    70 

    71 CHuiVg10Gc::CHuiVg10Gc()

    72         : CHuiGc()

    73     {

    74     }

    75 

    76 

    77 void CHuiVg10Gc::ConstructL()

    78     {

    79     // iMatrix stack must be allocated here because InitState() is not allowed to leave

    80     

    81     iMatrixStack = CHuiMatrixStack::NewL();

    82 #ifdef __NVG

    83     CHuiVg10RenderPlugin& renderer = (CHuiVg10RenderPlugin&) CHuiStatic::Renderer();

    84     iNvgEngine = &renderer.NvgEngine();

    85 #endif    

    86     }

    87 

    88 

    89 CHuiVg10Gc::~CHuiVg10Gc()

    90     {

    91 #ifdef __NVG

    92     // Don't delete the iNvgEngine, it's owned by the plugin!

    93     iNvgEngine = NULL;

    94 #endif    

    95     delete iMatrixStack;

    96     

    97     vgDestroyPath(iPath);

    98     vgDestroyPath(iImagePath);

    99     vgDestroyPath(iRectPath);

   100     vgDestroyPath(iRoundRectPath);

   101     vgDestroyPath(iLinePath);

   102     vgDestroyPath(iBorderPath);

   103     vgDestroyPath(iArcPath);

   104     vgDestroyPaint(iPaint);

   105     vgDestroyPaint(iGradientPaint);

   106     vgDestroyPath(iEllipsePath);

   107     }

   108     

   109 

   110 void CHuiVg10Gc::Push(THuiGcMatrix aMatrix)

   111     {

   112     if (aMatrix == EHuiGcMatrixModel)

   113         {

   114         // Replicate the current OpenVG matrix to the matrix stack

   115         UpdateClientMatrix();

   116         iMatrixStack->Push();

   117         

   118         // Save the matrix flags

   119         iMatrixFlagsStack.Append(iMatrixFlags);

   120         }

   121     }

   122 

   123 

   124 void CHuiVg10Gc::Pop(THuiGcMatrix aMatrix)

   125     {

   126     if (aMatrix == EHuiGcMatrixModel)

   127         {

   128         // Replicate the current matrix to OpenVG

   129         iMatrixStack->Pop();

   130         CHuiMatrixStack::TMatrix& matrix = iMatrixStack->Current();

   131         vgLoadMatrix((VGfloat*)matrix.iMatrix);

   132         

   133         // Restore the matrix flags

   134         iMatrixFlags = iMatrixFlagsStack[iMatrixFlagsStack.Count() - 1];

   135         iMatrixFlagsStack.Remove(iMatrixFlagsStack.Count() - 1);

   136         HUI_VG_INVARIANT();

   137         }

   138     }

   139 

   140 

   141 void CHuiVg10Gc::LoadIdentity(THuiGcMatrix aMatrix)

   142     {

   143     if (aMatrix == EHuiGcMatrixModel)

   144         {

   145         vgLoadIdentity();

   146         

   147         TRect displayArea = DisplayArea();            

   148         TInt h = displayArea.Height();

   149         TInt w = displayArea.Width();

   150 

   151         // DisplayArea is rotated if orientation is rotated, so we must "counter rotate"

   152         // to avoid rotating too much.

   153         if(Orientation() == EOrientationCCW90 || Orientation() == EOrientationCW90)

   154             {

   155             TInt tmp = w;

   156             w = h;

   157             h = tmp;

   158             }

   159         

   160         // Flip the Y axis to match Hitchcock's coordinate system

   161         vgTranslate(0, h); 

   162         vgScale(1.0f, -1.0f);

   163         

   164         if(Orientation() == EOrientationCCW90)

   165             {

   166             // Rotate around origo and move back to displayarea

   167             vgRotate(90);

   168             vgTranslate(0, -w);

   169             }

   170         else if(Orientation() == EOrientationCW90)

   171             {            

   172             // Rotate around origo and move back to displayarea

   173             vgRotate(-90);

   174             vgTranslate(-h, 0);

   175             }

   176         else if (Orientation() == EOrientation180)

   177             {

   178             // Rotate around origo and move back to displayarea

   179             vgRotate(-180);

   180             vgTranslate(-w, -h);            

   181             }                   

   182         else

   183             {

   184             // Nothing to do ?

   185             }

   186         

   187         // Reset the flags for this matrix

   188         iMatrixFlags = 0;

   189         

   190         HUI_VG_INVARIANT();

   191         }

   192     }

   193 

   194 

   195 void CHuiVg10Gc::Multiply(THuiGcMatrix aStack, TReal32 aMatrix[16])

   196     {

   197     if (aStack == EHuiGcMatrixModel)

   198         {

   199         const VGfloat m[9] = 

   200             {

   201             aMatrix[0], aMatrix[1], aMatrix[2],

   202             aMatrix[4], aMatrix[5], aMatrix[6],

   203             aMatrix[8], aMatrix[9], aMatrix[10],

   204             };

   205         vgMultMatrix(m);

   206         HUI_VG_INVARIANT();

   207         }

   208     }

   209 

   210 

   211 void CHuiVg10Gc::Translate(THuiGcMatrix aMatrix,

   212                            TReal32 aX, TReal32 aY, TReal32 /*aZ*/) __SOFTFP

   213     {

   214     if (aMatrix == EHuiGcMatrixModel)

   215         {

   216         vgTranslate(aX, aY);

   217         HUI_VG_INVARIANT();

   218         }

   219     }

   220 

   221 

   222 void CHuiVg10Gc::Scale(THuiGcMatrix aMatrix,

   223                          TReal32 aX, TReal32 aY, TReal32 /*aZ*/) __SOFTFP

   224     {

   225     if (aMatrix == EHuiGcMatrixModel)

   226         {

   227         vgScale(aX, aY);

   228         HUI_VG_INVARIANT();

   229         }

   230     }

   231 

   232 void CHuiVg10Gc::Shear(THuiGcMatrix aMatrix,

   233                        TReal32 aX, TReal32 aY, TReal32 /*aZ*/) __SOFTFP

   234     {

   235     if (aMatrix == EHuiGcMatrixModel)

   236         {

   237         vgShear(aX, aY);

   238         HUI_VG_INVARIANT();

   239         }

   240     }

   241 

   242 void CHuiVg10Gc::Rotate(THuiGcMatrix aMatrix, TReal32 aAngle,

   243                         TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP

   244     {

   245     if (aMatrix != EHuiGcMatrixModel)

   246         {

   247         return;

   248         }

   249 

   250     // Only rotation around the unit Z axis is supported

   251 	if (aX != 0.0f || aY != 0.0f || Abs(aZ) != 1.0f)

   252 	    {

   253 	    return;

   254 	    }

   255 		

   256     if (aZ < 0)

   257         {

   258         aAngle = -aAngle;

   259         }

   260     

   261     iMatrixFlags |= EMatrixFlagsRotation;

   262     vgRotate(aAngle);

   263     HUI_VG_INVARIANT();

   264     }

   265 

   266 

   267 // Replicate the current OpenVG matrix to the matrix stack

   268 void CHuiVg10Gc::UpdateMatrix(VGMatrixMode aMatrix)

   269     {

   270     VGfloat m[9];

   271     ASSERT(vgGeti(VG_MATRIX_MODE) == VG_MATRIX_IMAGE_USER_TO_SURFACE);

   272     vgGetMatrix(m);

   273     vgSeti(VG_MATRIX_MODE, aMatrix);

   274     vgLoadMatrix(m);

   275     vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);

   276         

   277     HUI_VG_INVARIANT();

   278     }

   279 

   280 void CHuiVg10Gc::UpdateClientMatrix()

   281     {

   282     // Replicate the current OpenVG matrix to the matrix stack

   283     vgGetMatrix((VGfloat*)iMatrixStack->Current().iMatrix);

   284     

   285     // The matrix is *probably* not an identity transform

   286     iMatrixStack->Current().iIsIdentity = EFalse;

   287     HUI_VG_INVARIANT();

   288     }

   289 

   290 void CHuiVg10Gc::CreateVgObjectsL()

   291     {

   292     // Make sure we have enough resources to work with

   293     ASSERT(vgGeti(VG_MAX_SCISSOR_RECTS) >= 1);

   294     

   295     // Create the default VG objects

   296     iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

   297                          5, 8, VG_PATH_CAPABILITY_APPEND_TO);

   298     iImagePath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

   299                               5, 8, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

   300     iArcPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

   301                             2, 7, VG_PATH_CAPABILITY_APPEND_TO);

   302     iPaint = vgCreatePaint();

   303     iGradientPaint = vgCreatePaint();

   304     iBlendMode = VG_BLEND_SRC_OVER;

   305 

   306     // Initialize a rectangle path with dummy coordinates

   307     iRectPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

   308                              5, 8, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

   309 

   310     iRoundRectPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

   311                                  5, 8, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

   312 

   313     iEllipsePath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

   314                                  5, 8, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

   315     

   316     const VGubyte rectSegments[] =

   317         {

   318         VG_MOVE_TO_ABS,

   319         VG_LINE_TO_REL,

   320         VG_LINE_TO_REL,

   321         VG_LINE_TO_REL,

   322         VG_CLOSE_PATH

   323         };

   324     const VGfloat rectCoords[] = 

   325         {

   326          0.0f, 0.0f,             // (x, y)

   327          1.0f, 0.0f,             // (width, 0)

   328          0.0f, 1.0f,             // (0, height)

   329         -1.0f, 0.0f,             // (-width, 0)

   330         };

   331     vgAppendPathData(iRectPath, 5, rectSegments, rectCoords);

   332     vgRemovePathCapabilities(iRectPath, VG_PATH_CAPABILITY_APPEND_TO);

   333     vgAppendPathData(iImagePath, 5, rectSegments, rectCoords);

   334     vgRemovePathCapabilities(iImagePath, VG_PATH_CAPABILITY_APPEND_TO);

   335 

   336     // Initialize a line path with dummy coordinates

   337     iLinePath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

   338                              2, 4, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

   339     const VGubyte lineSegments[] =

   340         {

   341         VG_MOVE_TO_ABS,

   342         VG_LINE_TO_ABS,

   343         };

   344     const VGfloat lineCoords[] = 

   345         {

   346         0.0f, 0.0f,             // (x, y)

   347         1.0f, 1.0f,             // (x, y)

   348         };

   349     vgAppendPathData(iLinePath, 2, lineSegments, lineCoords);

   350     vgRemovePathCapabilities(iLinePath, VG_PATH_CAPABILITY_APPEND_TO);

   351     

   352     // Initialize a path for drawing borders

   353     iBorderPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

   354                                11, 10 * 2, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

   355 

   356     const VGubyte borderSegments[12] =

   357         {

   358         VG_MOVE_TO_ABS,

   359         VG_LINE_TO_REL,

   360         VG_LINE_TO_REL,

   361         VG_LINE_TO_REL,

   362         VG_LINE_TO_REL,

   363         VG_LINE_TO_REL,

   364         VG_LINE_TO_REL,

   365         VG_LINE_TO_REL,

   366         VG_LINE_TO_REL,

   367         VG_LINE_TO_REL,

   368         VG_LINE_TO_REL,

   369         VG_CLOSE_PATH,

   370         };

   371 

   372     const VGfloat borderCoords[10 * 2] = 

   373         {

   374         0.0f, 0.0f, 0.0f, 0.0f, 0.0f,

   375         0.0f, 0.0f, 0.0f, 0.0f, 0.0f,

   376         0.0f, 0.0f, 0.0f, 0.0f, 0.0f,

   377         0.0f, 0.0f, 0.0f, 0.0f, 0.0f,

   378         };

   379 

   380     vgAppendPathData(iBorderPath, 12, borderSegments, borderCoords);

   381     vgRemovePathCapabilities(iBorderPath, VG_PATH_CAPABILITY_APPEND_TO);

   382         

   383     // Get hardware configuration

   384     TInt hwConf = 0; // the defaulf value for everything is 0 to allow new flags to be defined

   385     HuiUtil::GetValueFromCentralRepository( KUIAccelTKHWConfigurationFlags, hwConf );

   386     if ( hwConf & KHuiAntialiasing )

   387         {

   388         SetQuality( EHuiQualityAccurate );

   389         }

   390     else

   391         {

   392         SetQuality( EHuiQualityFast );

   393         }

   394 

   395     

   396     iVgObjectsCreated = ETrue;

   397     }

   398  

   399 void CHuiVg10Gc::InitState()

   400     {

   401     // Clean matrix stack in case there is anything left

   402     // We can't construct a new stack here because we are not allowed to leave.

   403     // We keep the original stack and just delete the contents leaving one 

   404     // identity matrix that is always added when a new matrix stack is created

   405     TInt i = 0;

   406     // One identity matrix will remain.

   407     // When a new matrix stack is created, one identity matrix is added

   408     // It can never be removed, the code would panic.

   409     for ( i = 0; i < iMatrixStack->Count() - 2; i++ )

   410         {

   411         iMatrixStack->Pop(); 

   412         }

   413     // remove flags from stack, too.

   414     iMatrixFlagsStack.Reset();

   415 

   416     iScissorRect = TRect(0, 0, 0, 0);

   417     iMatrixFlags = 0;

   418     

   419     if (!iVgObjectsCreated)

   420         {

   421         TRAP_IGNORE(CreateVgObjectsL());    

   422         }

   423 

   424     // Default paint

   425     vgSetParameteri(iPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);

   426     vgSetPaint(iPaint, VG_FILL_PATH | VG_STROKE_PATH);

   427         

   428     // Gradient paint

   429     vgSetParameteri(iGradientPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);

   430         

   431     HUI_VG_INVARIANT();

   432     

   433     // Reset default state

   434     

   435     Enable(EFeatureBlending);

   436     Disable(EFeatureDepthTest);

   437 	iStateScissorTest = ETrue;    

   438     Disable(EFeatureClipping);

   439 

   440     // Use the image matrix as the primary matrix

   441     vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);

   442 

   443     RestoreState();

   444     HUI_VG_INVARIANT();

   445     }

   446 

   447 void CHuiVg10Gc::SetQuality(THuiQuality aQuality)

   448     {

   449     CHuiGc::SetQuality(aQuality);

   450     switch (Quality())

   451         {

   452         case EHuiQualityAccurate:

   453             vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);

   454             vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_BETTER);

   455             break;

   456         case EHuiQualityFast:

   457             vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);

   458             vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_FASTER);

   459             break;

   460         default:

   461             break;

   462         }

   463     HUI_VG_INVARIANT();

   464     }

   465 

   466 void CHuiVg10Gc::SetFillRule( THuiFillMode aFillMode )

   467     {   

   468     switch (aFillMode)

   469        {

   470        case EHuiFillNonZero:

   471            vgSeti(VG_FILL_RULE, VG_NON_ZERO);

   472            break;

   473        case EHuiFillEvenOdd:

   474            vgSeti(VG_FILL_RULE, VG_EVEN_ODD);

   475            break;

   476        default:

   477            break;

   478        }

   479     HUI_VG_INVARIANT();   

   480     }

   481 

   482 void CHuiVg10Gc::RestoreState() const

   483     {

   484     // Restore paint

   485     vgSetPaint(iPaint, VG_FILL_PATH | VG_STROKE_PATH);        

   486 

   487     // Restore scissor test state

   488     if(iStateScissorTest)

   489         {

   490         vgSeti(VG_SCISSORING, VG_TRUE);

   491         }

   492     else

   493         {

   494         vgSeti(VG_SCISSORING, VG_FALSE);

   495         }

   496     

   497     // Restore scissor rects

   498     // This fixes CHuiFxEffect cached draw

   499     TInt count = iClipRegion.Count();

   500     VGint coords[KHuiMaxVgScissorRects * 4];

   501 

   502     if(count > KHuiMaxVgScissorRects)

   503         {

   504         count = KHuiMaxVgScissorRects; //only 32 scissor rects supported    

   505         }

   506         

   507     TInt numberOfCoords = count*4;

   508     for ( TInt i = 0, j=0 ; i < numberOfCoords ; j++)

   509         { 

   510         coords[i++] = iClipRegion[j].iTl.iX;

   511         coords[i++] = iClipRegion[j].iTl.iY;

   512         coords[i++] = iClipRegion[j].Width();

   513         coords[i++] = iClipRegion[j].Height();      

   514         }

   515     

   516     vgSetiv(VG_SCISSOR_RECTS, numberOfCoords, coords);          

   517 

   518     HUI_VG_INVARIANT();

   519     }

   520 

   521 void CHuiVg10Gc::RestoreFlaggedState() const

   522     {

   523     // Get the changed stateflags from the renderplugin

   524     CHuiVg10RenderPlugin& renderer = (CHuiVg10RenderPlugin&) CHuiStatic::Renderer();

   525     TInt flags = renderer.GetRestoreStateFlags();

   526     

   527     // First a quick check, if nothing needs to be done

   528     if(!flags)

   529         {

   530         return;

   531         }

   532       

   533     // Check each flag and act accrodingly!

   534     if(flags & EHuiVg10GcStateFlagDirtyPaint)

   535         {

   536         // Restore paint

   537         vgSetPaint(iPaint, VG_FILL_PATH | VG_STROKE_PATH);

   538         }

   539 

   540     if(flags & EHuiVg10GcStateFlagDirtyScissor)

   541         {

   542         // Restore scissor test state

   543         if(iStateScissorTest)

   544             {

   545             vgSeti(VG_SCISSORING, VG_TRUE);

   546             }

   547         else

   548             {

   549             vgSeti(VG_SCISSORING, VG_FALSE);

   550             }

   551         }

   552     

   553     if(flags & EHuiVg10GcStateFlagDirtyScissorRects)

   554         {

   555         // Restore scissor rects

   556         TInt count = iClipRegion.Count();

   557         VGint coords[KHuiMaxVgScissorRects * 4];

   558 

   559         if(count > KHuiMaxVgScissorRects)

   560             {

   561             count = KHuiMaxVgScissorRects; //only 32 scissor rects supported    

   562             }

   563             

   564         TInt numberOfCoords = count*4;

   565         for ( TInt i = 0, j=0 ; i < numberOfCoords ; j++)

   566             { 

   567             coords[i++] = iClipRegion[j].iTl.iX;

   568             coords[i++] = iClipRegion[j].iTl.iY;

   569             coords[i++] = iClipRegion[j].Width();

   570             coords[i++] = iClipRegion[j].Height();      

   571             }

   572         

   573         vgSetiv(VG_SCISSOR_RECTS, numberOfCoords, coords);

   574         }

   575 

   576     // Clear the flags!

   577     renderer.ClearRestoreStateFlags();

   578     

   579     HUI_VG_INVARIANT();

   580     }

   581 

   582 void CHuiVg10Gc::UpdateProjection()

   583     {

   584     // Nothing to do

   585     }

   586 

   587 

   588 TInt CHuiVg10Gc::TextureUnits() const

   589     {

   590     return 1;

   591     }

   592 

   593 

   594 void CHuiVg10Gc::SetTextureUnits(TInt /*aTextureUnitCount*/)

   595     {

   596     // Nothing to do

   597     }

   598 

   599 

   600 void CHuiVg10Gc::Enable(TFeature aFeature, TBool aDoEnable)

   601     {

   602     HUI_VG_INVARIANT();

   603 

   604     switch(aFeature)

   605         {

   606         case EFeatureDepthTest:

   607             // Not supported

   608             break;

   609 

   610         case EFeatureDepthWrite:

   611             // Not supported

   612             break;

   613 

   614         case EFeatureTexturing:

   615             // Always enabled

   616             break;

   617 

   618         case EFeatureBlending:

   619             if(aDoEnable)

   620                 {

   621                 vgSeti(VG_BLEND_MODE, iBlendMode);

   622                 }

   623             else

   624                 {

   625                 vgSeti(VG_BLEND_MODE, VG_BLEND_SRC);

   626                 }

   627             break;

   628 

   629         case EFeatureClipping:

   630             if(aDoEnable)

   631                 {

   632                 // enable clipping

   633                 //if(!iStateScissorTest)

   634                 	{

   635                 	iStateScissorTest = ETrue;

   636                     vgSeti(VG_SCISSORING, VG_TRUE);

   637                 	}

   638                 }

   639             else

   640                 {

   641                 // disable clipping

   642                 //if(iStateScissorTest)

   643                 	{

   644                 	iStateScissorTest = EFalse;

   645                     vgSeti(VG_SCISSORING, VG_FALSE);

   646                 	}

   647                 

   648                 }

   649             break;

   650 

   651         case EFeatureAntialias:

   652             if(aDoEnable)

   653                 {

   654                 vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);

   655                 }

   656             else

   657                 {

   658                 vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);

   659                 }

   660             break;

   661 

   662         case EFeatureFog:

   663             // Not supported

   664             break;

   665 

   666         default:

   667             break;

   668         }

   669 

   670     HUI_VG_INVARIANT();

   671     }

   672 

   673 

   674 void CHuiVg10Gc::SetBlendMode(TBlendMode aBlendMode)

   675     {

   676     switch(aBlendMode)

   677         {

   678         case EBlendAdd:

   679             iBlendMode = VG_BLEND_ADDITIVE;

   680             break;

   681 

   682         default:

   683             iBlendMode = VG_BLEND_SRC_OVER;

   684             break;

   685         }

   686         vgSeti(VG_BLEND_MODE, iBlendMode);

   687     }

   688 

   689 

   690 void CHuiVg10Gc::SetTextureMode(TTextureMode aTextureMode, TReal32 /*aParam*/) __SOFTFP

   691     {

   692     switch(aTextureMode)

   693         {

   694         case ETextureModeNormal:

   695             break;

   696 

   697         default:

   698             break;

   699         }

   700 

   701     HUI_VG_INVARIANT();

   702     }

   703 

   704 

   705 void CHuiVg10Gc::SetDimmingFog(const TRgb& /*aColor*/, TReal32 /*aAmount*/) __SOFTFP

   706     {

   707     // Fog not supported

   708     }

   709 

   710 

   711 void CHuiVg10Gc::Clear()

   712     {

   713     HUI_VG_INVARIANT();

   714     TInt x = ProjectionViewport().iTl.iX;

   715     TInt y = ProjectionViewport().iTl.iY;

   716     TInt w = ProjectionViewport().Width();

   717     TInt h = ProjectionViewport().Height();

   718     VGfloat scale = 1.0f / 255.0f;

   719     VGfloat color[] = 

   720         {

   721         PenColor().Red()   * scale,

   722         PenColor().Green() * scale,

   723         PenColor().Blue()  * scale,

   724         PenAlpha() * scale

   725         };

   726     vgSetfv(VG_CLEAR_COLOR, 4, color);

   727     vgClear(x, y, w, h);

   728     HUI_VG_INVARIANT();

   729     }

   730 

   731 	

   732 void CHuiVg10Gc::ClearDepth()

   733     {

   734     Clear();

   735     }

   736 

   737 

   738 void CHuiVg10Gc::ClearColorAndDepth()

   739     {

   740     Clear();

   741     }

   742 

   743 // Do renderer specific initializations of the frame

   744 void CHuiVg10Gc::InitNewFrame()

   745 	{

   746 	LoadIdentity(EHuiGcMatrixModel);

   747 	}

   748 

   749 void CHuiVg10Gc::Clip(const TRect& aClipRect)

   750     {

   751     THuiRealRect transformed = aClipRect;

   752     

   753     HUI_DEBUGF4(_L("CHuiVg10Gc::Clip() - aClipRect     (%5i, %5i, %5i, %5i)"),

   754                 aClipRect.iTl.iX, aClipRect.iTl.iY,

   755                 aClipRect.iBr.iX, aClipRect.iBr.iY);

   756     

   757     // Transform the rectangle using our stacks

   758     UpdateClientMatrix();

   759     iMatrixStack->Current().Multiply(transformed.iTl);

   760     iMatrixStack->Current().Multiply(transformed.iBr);

   761     

   762     // Normalize the rectangle

   763     if (transformed.iTl.iX > transformed.iBr.iX)

   764     	{

   765     	TReal32 tmp = transformed.iTl.iX;

   766     	transformed.iTl.iX = transformed.iBr.iX;

   767     	transformed.iBr.iX = tmp;

   768     	}

   769     if (transformed.iTl.iY > transformed.iBr.iY)

   770     	{

   771     	TReal32 tmp = transformed.iTl.iY;

   772     	transformed.iTl.iY = transformed.iBr.iY;

   773     	transformed.iBr.iY = tmp;

   774     	}

   775 

   776     HUI_DEBUGF4(_L("CHuiVg10Gc::Clip() - Transformed = (%5.0f, %5.0f, %5.0f, %5.0f)"),

   777                 transformed.iTl.iX, transformed.iTl.iY,

   778                 transformed.iBr.iX, transformed.iBr.iY);

   779 

   780     CHuiGc::Clip(transformed.Round());

   781     HUI_VG_INVARIANT();

   782     }

   783 

   784 

   785 void CHuiVg10Gc::SetClip(const TRect& aClipRect)

   786     {

   787     iScissorRect = aClipRect;

   788     iScissorRect.Normalize();

   789     

   790     CHuiGc::SetClip(iScissorRect);

   791 

   792     VGint coords[4] = 

   793         {

   794         iScissorRect.iTl.iX,  iScissorRect.iTl.iY,

   795         iScissorRect.Width(), iScissorRect.Height()

   796         };

   797    

   798     Enable(EFeatureClipping);    

   799     vgSetiv(VG_SCISSOR_RECTS, 4, coords);

   800     HUI_VG_INVARIANT();

   801     }

   802 

   803 void CHuiVg10Gc::Clip(const TRegion& aRegion)

   804     {

   805     UpdateClientMatrix();

   806 

   807     iTempRegion.Clear();

   808     

   809     for (TInt i=0; i<aRegion.Count(); i++)

   810         {

   811         THuiRealRect transformed = aRegion[i];

   812         iMatrixStack->Current().Multiply(transformed.iTl);

   813         iMatrixStack->Current().Multiply(transformed.iBr);

   814         

   815         // Normalize the rectangle

   816         if (transformed.iTl.iX > transformed.iBr.iX)

   817         	{

   818         	TReal32 tmp = transformed.iTl.iX;

   819         	transformed.iTl.iX = transformed.iBr.iX;

   820         	transformed.iBr.iX = tmp;

   821         	}

   822         if (transformed.iTl.iY > transformed.iBr.iY)

   823         	{

   824         	TReal32 tmp = transformed.iTl.iY;

   825         	transformed.iTl.iY = transformed.iBr.iY;

   826         	transformed.iBr.iY = tmp;

   827         	}            

   828         

   829         iTempRegion.AddRect(transformed.Round());

   830         }

   831 	    

   832 	CHuiGc::Clip(iTempRegion);	    

   833     

   834     HUI_VG_INVARIANT();

   835     }

   836     

   837 void CHuiVg10Gc::SetClipRegion(const TRegion& aRegion)

   838     {

   839     TInt count = aRegion.Count();

   840     VGint coords[KHuiMaxVgScissorRects * 4];

   841 

   842     if(count > KHuiMaxVgScissorRects)

   843         {

   844         count = KHuiMaxVgScissorRects; //only 32 scissor rects supported    

   845         }

   846         

   847     TInt numberOfCoords = count*4;

   848     for ( TInt i = 0, j=0 ; i < numberOfCoords ; j++)

   849         { 

   850         coords[i++] = aRegion[j].iTl.iX;

   851         coords[i++] = aRegion[j].iTl.iY;

   852         coords[i++] = aRegion[j].Width();

   853         coords[i++] = aRegion[j].Height();      

   854         }

   855     

   856     CHuiGc::SetClipRegion(aRegion);     

   857     

   858     Enable(EFeatureClipping);    

   859     vgSetiv(VG_SCISSOR_RECTS, numberOfCoords, coords);          

   860     

   861     HUI_VG_INVARIANT();

   862     }

   863 

   864 void CHuiVg10Gc::CancelClipping()

   865     {

   866     Disable(EFeatureClipping);    

   867     }

   868 

   869 void CHuiVg10Gc::DrawText(const CHuiTextMesh& aTextMesh,

   870                           const THuiRealRect& aBounds,

   871                           TReal32 aShadow) __SOFTFP

   872     {

   873     CHuiGc::DrawText(aTextMesh, aBounds, aShadow);

   874     }

   875 

   876 

   877 /**

   878  *  Given a THuiImage, return the corresponding VGImage or 

   879  *  VG_INVALID_HANDLE if there is none.

   880  */

   881 static VGImage GetVGImageFromTexture(const MHuiSegmentedTexture& aTexture)

   882     {

   883     if (aTexture.SegmentCount() == 1)

   884         {

   885         return (VGImage)aTexture.SegmentName(0);

   886         }

   887     return VG_INVALID_HANDLE;

   888     }

   889 

   890 

   891 /**

   892  *  Construct a source rectangle based on the texture coordinates

   893  *  specified for an image.

   894  */

   895 static THuiRealRect GetSourceRectangleFromImage(const THuiImage& aImage)

   896     {

   897     TReal32 texCoords[8];

   898     aImage.GetTexCoords(texCoords);

   899     THuiRealRect sourceRect;

   900     

   901     sourceRect.iTl.iX = texCoords[0];

   902     sourceRect.iTl.iY = texCoords[1];

   903     sourceRect.iBr.iX = texCoords[4];

   904     sourceRect.iBr.iY = texCoords[5];

   905     

   906     return sourceRect;

   907     }

   908 

   909 void CHuiVg10Gc::DoDrawImage(const THuiImage& aImage,

   910                              const THuiRealPoint& aTopLeft,

   911                              const THuiRealSize& aSize)

   912     {

   913     if(!aImage.HasTexture())

   914         {

   915         return;

   916         }

   917     

   918     // Fetch the texture coordinates from the image

   919     THuiRealRect destRect(aTopLeft, aSize);

   920     THuiRealRect sourceRect(GetSourceRectangleFromImage(aImage));

   921     DrawTexture(aImage.Texture(), sourceRect, destRect);

   922     }

   923 

   924 

   925 void CHuiVg10Gc::DoDrawImages(const THuiImage& aImage,

   926                                 const THuiImage& aImage2,

   927                                 const THuiRealPoint& aTopLeft,

   928                                 const THuiRealSize& aSize)

   929     {

   930     DoDrawImage(aImage,  aTopLeft, aSize);

   931     DoDrawImage(aImage2, aTopLeft, aSize);

   932     }

   933 

   934 

   935 void CHuiVg10Gc::UpdateColor(TReal32 /*aAlphaFactor*/) __SOFTFP

   936     {

   937     VGuint color = (PenColor().Internal() << 8) | PenAlpha();

   938     

   939 #if defined(RENDER_DEBUG_RECTANGLES)

   940     color = Math::Random() | 0xff;

   941 #endif

   942     

   943     // Update the color of the current paint

   944     vgSetColor(iPaint, color);

   945     

   946     // Detect white fully opaque color

   947     if (color == 0xffffffff)

   948         {

   949         vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_NORMAL);

   950         }

   951     else

   952         {

   953         vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_MULTIPLY);

   954         }

   955     HUI_VG_INVARIANT();

   956     }

   957 

   958 void CHuiVg10Gc::DrawCroppedTexture(const MHuiSegmentedTexture& aTexture, const THuiRealRect& aSourceRect,

   959                                     const THuiRealRect& aDestRect)

   960     {

   961     // Render state which affects what we do here (roughly decreasing order of probability):

   962     // - Source cropping

   963     // - Color modulation

   964     // - Alpha modulation

   965     // - Affine matrix transform (i.e. other than scale or translation)

   966     //

   967     // Difficult combinations:

   968     // - Source cropping with color or alpha modulation

   969     //   - Option 1: Create a child image from the cropped region

   970     //     - Can't do this because the cropping region is in floating point coords.

   971     //     - Performance overhead possibly non-negligible.

   972     //   - Option 2: Use scissoring to do the cropping

   973     //     - Does not work for rotate/skew transform.

   974     //   - Option 3: Use a mask to do the cropping

   975     //     - Auxiliary mask bitmap needed, possible performance hit.

   976     //   - Option 4: Use a pattern paint

   977     //     - Color/alpha modulation requires an offscreen image.

   978     // - Resolution: Go with option 2 and option 1 if rotation/skewing is in effect.

   979     TSize imageSize = aTexture.Size();

   980     VGfloat srcW   = aSourceRect.Width()  * imageSize.iWidth;

   981     VGfloat srcH   = aSourceRect.Height() * imageSize.iHeight;

   982     VGfloat srcX   = aSourceRect.iTl.iX   * imageSize.iWidth;

   983     VGfloat srcY   = aSourceRect.iTl.iY   * imageSize.iHeight;

   984 

   985     // Make sure the source rectangle is not degenerate

   986     srcW = Max(1.0f, srcW);

   987     srcH = Max(1.0f, srcH);

   988     

   989     VGfloat scaleX = aDestRect.Width()  / srcW;

   990     VGfloat scaleY = aDestRect.Height() / srcH;

   991     VGImage image = VG_INVALID_HANDLE;

   992     

   993 	// Check if OpenVg state has changed

   994     RestoreFlaggedState();

   995     

   996 #ifdef __NVG

   997     const CHuiVg10Texture& texture = static_cast<const CHuiVg10Texture&>( aTexture );

   998     TBool isExtended = texture.IsExtended();

   999 #endif

  1000     

  1001     // Getting the vgImage out of the texture

  1002     image = GetVGImageFromTexture( aTexture );

  1003     

  1004     if (iMatrixFlags & EMatrixFlagsRotation)

  1005         {

  1006         VGImage tmpImage = vgChildImage(image, (VGint)srcX, imageSize.iHeight - (VGint)srcY - (VGint)srcH, (VGint)srcW, (VGint)srcH);

  1007         

  1008         if (tmpImage == VG_INVALID_HANDLE)

  1009             {

  1010             HUI_DEBUG(_L("CHuiVg10Gc::DrawCroppedTexture() - Unable to create temporary child image."));

  1011             // We cannot leave because we are called by a non-leaving exported function

  1012             // If we cannot draw, we just return without doing anything.

  1013             return;

  1014             }

  1015         HUI_VG_INVARIANT();

  1016         

  1017         // Render the child image

  1018         Push(EHuiGcMatrixModel);

  1019 #if !defined(RENDER_DEBUG_RECTANGLES)

  1020         vgTranslate(aDestRect.iTl.iX, aDestRect.iTl.iY);

  1021         vgScale(scaleX, scaleY);

  1022         vgDrawImage(tmpImage);

  1023 #else

  1024         TRect d(aDestRect.iTl.iX, aDestRect.iTl.iY, aDestRect.iBr.iX, aDestRect.iBr.iY);

  1025         DrawRect(d);

  1026 #endif

  1027         Pop(EHuiGcMatrixModel);

  1028         

  1029         vgDestroyImage(tmpImage);

  1030         HUI_VG_INVARIANT();

  1031         return;

  1032         }

  1033     

  1034     // Set a scissor rectangle that corresponds with the target rectangle

  1035     TBool clippingWasEnabled = iStateScissorTest;

  1036     

  1037     if (!clippingWasEnabled)

  1038         {

  1039         Enable(EFeatureClipping);    

  1040         }

  1041     

  1042     PushClip();

  1043     Clip(aDestRect);    

  1044     

  1045     // Render the image

  1046     Push(EHuiGcMatrixModel);

  1047 #if !defined(RENDER_DEBUG_RECTANGLES)

  1048     vgTranslate(aDestRect.iTl.iX, aDestRect.iTl.iY);

  1049     vgScale(scaleX, scaleY);

  1050     vgTranslate(-srcX, -srcY);

  1051 

  1052 #ifdef __NVG

  1053     if ( isExtended && texture.IsNvgContent())

  1054         {

  1055         // Determine the size to which we want to draw the NVG icon paths

  1056         TSize contentSize( HUI_ROUND_FLOAT_TO_INT(aDestRect.Width()),

  1057                 HUI_ROUND_FLOAT_TO_INT(aDestRect.Height()) );

  1058         UpdateMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);

  1059         // Draw the NVG data (be it either the object cached commands or the "normal" nvg data)

  1060         DrawNVG(texture.GetExtendedTextureData(), texture.GetIconCommandsData(), contentSize, EFalse);

  1061         }

  1062     else

  1063         {

  1064         if (image != VG_INVALID_HANDLE)

  1065             {

  1066             //HUI_DEBUG1(_L("HuiVg10Gc::DrawCroppedTexture - drawing with vgDrawImage(%d) instead of DrawNVG"), image);

  1067             vgDrawImage(image);

  1068             }

  1069         else

  1070             {

  1071             HUI_DEBUG1(_L("HuiVg10Gc::DrawCroppedTexture - INVALID HANDLE, vgDrawImage() not called!"), image);

  1072             }

  1073         }

  1074 #else

  1075     vgDrawImage(image);

  1076 #endif // __NVG

  1077 

  1078 #else // RENDER_DEBUG_RECTANGLES

  1079     TRect d(aDestRect.iTl.iX, aDestRect.iTl.iY, aDestRect.iBr.iX, aDestRect.iBr.iY);

  1080     DrawRect(d);

  1081 #endif

  1082     HUI_VG_INVARIANT();

  1083     Pop(EHuiGcMatrixModel);

  1084     

  1085     // Restore state

  1086     PopClip();

  1087 

  1088     if (!clippingWasEnabled)

  1089         {

  1090         Disable(EFeatureClipping);    

  1091         }

  1092     

  1093     HUI_VG_INVARIANT();

  1094     

  1095 #if 0

  1096     // Crop implementation using a paint pattern

  1097     // TODO: Handle color modulation + cropping

  1098     VGfloat srcW   = aSourceRect.Width()  * aImage.Texture().Size().iWidth;

  1099     VGfloat srcH   = aSourceRect.Height() * aImage.Texture().Size().iHeight;

  1100     VGfloat srcX   = aSourceRect.iTl.iX   * aImage.Texture().Size().iWidth;

  1101     VGfloat srcY   = aSourceRect.iTl.iY   * aImage.Texture().Size().iHeight;

  1102     VGfloat scaleX = aDestRect.Width()  / srcW;

  1103     VGfloat scaleY = aDestRect.Height() / srcH;

  1104     VGImage image  = GetVGImageFromTexture(aTexture);

  1105 

  1106     vgPaintPattern(iPaint, image);

  1107     

  1108     // Transform the paint pattern to fill the destination rectangle as required

  1109     vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);

  1110     vgLoadIdentity();

  1111     vgTranslate(aDestRect.iTl.iX, aDestRect.iTl.iY);

  1112     vgScale(scaleX, scaleY);

  1113     vgTranslate(-srcX, -srcY);

  1114     vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);

  1115     

  1116     // Update the path transformation matrix

  1117     UpdateMatrix(VG_MATRIX_PATH_USER_TO_SURFACE);

  1118 

  1119     // Draw a rectangle which is filled with the image as a pattern

  1120     const VGfloat coords[] = 

  1121         {

  1122         aDestRect.iTl.iX, aDestRect.iTl.iY,

  1123         aDestRect.Width(), 0,

  1124         0, aDestRect.Height(),

  1125         -aDestRect.Width(), 0,

  1126         };

  1127     vgModifyPathCoords(iImagePath, 0, 5, coords);

  1128     vgDrawPath(iImagePath, VG_FILL_PATH);

  1129     

  1130     // Restore the state

  1131     vgPaintPattern(iPaint, VG_INVALID_HANDLE);

  1132     UpdateColor();

  1133     vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);

  1134     vgLoadIdentity();