svgtopt/nvgdecoder/src/NVGCSIcon.cpp
changeset 0 d46562c3d99d
equal deleted inserted replaced
-1:000000000000 0:d46562c3d99d
       
     1 /*
       
     2 * Copyright (c) 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:  NVG Decoder source file
       
    15 *
       
    16 */
       
    17 
       
    18 #include "NVGCSIcon.h"
       
    19 #include "NVGIconData.h"
       
    20 #include "nvgfittoviewbox.h"
       
    21 #include "nvg.h"
       
    22 #include "NVGUtil.h"
       
    23 #include "OpenVGHandleStore.h"
       
    24 
       
    25 #include <string.h>
       
    26 #include <e32math.h>
       
    27 
       
    28 
       
    29 CNVGCSIcon::CNVGCSIcon()
       
    30     :   iNVGIconData(0),
       
    31         iPath(VG_INVALID_HANDLE),
       
    32         iFillPaint(VG_INVALID_HANDLE),
       
    33         iStrokePaint(VG_INVALID_HANDLE),
       
    34         iLastFillPaintType(0),
       
    35         iLastStrokePaintType(0),
       
    36         iLastFillPaintColor(0),
       
    37         iLastStrkePaintColor(0),
       
    38         iResetFillPaint(0),
       
    39         iResetStrokePaint(0)
       
    40     {
       
    41     }
       
    42 
       
    43 CNVGCSIcon::~CNVGCSIcon()
       
    44     {
       
    45     vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);
       
    46     vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH);
       
    47 
       
    48     delete iNVGIconData;
       
    49     delete iOpenVGHandles;
       
    50     }
       
    51 
       
    52 CNVGCSIcon * CNVGCSIcon::NewL(const TDesC8& aBuf)
       
    53     {
       
    54     CNVGCSIcon* self    = CNVGCSIcon::NewLC(aBuf);
       
    55     
       
    56     CleanupStack::Pop(self);
       
    57     return self;
       
    58     }
       
    59     
       
    60 CNVGCSIcon * CNVGCSIcon::NewLC(const TDesC8& aBuf)
       
    61     {
       
    62     CNVGCSIcon* self    = new (ELeave) CNVGCSIcon;
       
    63     CleanupStack::PushL(self);
       
    64 
       
    65     self->ConstructL(aBuf);
       
    66     
       
    67     return self;
       
    68     }
       
    69 
       
    70 void CNVGCSIcon::ConstructL(const TDesC8& aBuf)
       
    71     {
       
    72     iNVGIconData = CNVGIconData::NewL(aBuf.Length());
       
    73     iOpenVGHandles = COpenVGHandleStore::NewL();
       
    74     
       
    75     if (iPath == VG_INVALID_HANDLE)
       
    76         {
       
    77         iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
       
    78                         VG_PATH_DATATYPE_S_32, 1.0f/65536.0f, 0.0f, 0, 0,
       
    79                         VG_PATH_CAPABILITY_APPEND_TO);
       
    80         iOpenVGHandles->AddPathDHL(iPath);
       
    81         }
       
    82     
       
    83     if (iFillPaint == VG_INVALID_HANDLE)
       
    84         {
       
    85         iFillPaint = vgCreatePaint();
       
    86         iOpenVGHandles->AddPaintDHL(iFillPaint);
       
    87         }
       
    88     vgSetPaint(iFillPaint, VG_FILL_PATH);
       
    89     
       
    90     if (iStrokePaint == VG_INVALID_HANDLE)
       
    91         {
       
    92         iStrokePaint = vgCreatePaint();
       
    93         iOpenVGHandles->AddPaintDHL(iStrokePaint);
       
    94         }
       
    95     vgSetPaint(iStrokePaint, VG_STROKE_PATH);
       
    96     }
       
    97 
       
    98 TInt CNVGCSIcon::SetViewBox(TReal32 x, TReal32 y, TReal32 w, TReal32 h) __SOFTFP
       
    99     {
       
   100     iViewBoxX = x;
       
   101     iViewBoxY = y;
       
   102     iViewBoxW = w;
       
   103     iViewBoxH = h;
       
   104     
       
   105     return KErrNone;
       
   106     }
       
   107 
       
   108 TInt CNVGCSIcon::SetPreserveAspectRatio(TInt aPreserveAspectSetting, 
       
   109         TInt aSmilFitSetting)
       
   110     {
       
   111     iPreserveAspectSetting = aPreserveAspectSetting;
       
   112     iSmilFitSetting = aSmilFitSetting;
       
   113 
       
   114     return KErrNone;
       
   115     }
       
   116 
       
   117 TInt CNVGCSIcon::Rotate(TReal32 aAngle, TReal32 aX, TReal32 aY) __SOFTFP
       
   118     {
       
   119     iRotationAngle  = aAngle;
       
   120     iRotationX      = aX;
       
   121     iRotationY      = aY;
       
   122     
       
   123     return KErrNone;
       
   124     }
       
   125     
       
   126 void CNVGCSIcon::AddPathDataL(VGint numSegments, const VGubyte * pathSegments, const void * pathData)
       
   127     {
       
   128     iNVGIconData->EncodeInt32L(EPathData);
       
   129     iNVGIconData->EncodeInt32L(numSegments);
       
   130     iNVGIconData->EncodeDataL(pathSegments, numSegments);
       
   131 
       
   132     TInt coordinateCount = 0;
       
   133     for (TInt i = 0; i < numSegments; ++i)
       
   134         {
       
   135         switch (pathSegments[i])
       
   136             {
       
   137             case VG_HLINE_TO:
       
   138             case VG_VLINE_TO:
       
   139                 coordinateCount += 1;
       
   140                 break;
       
   141             case VG_MOVE_TO:
       
   142             case VG_LINE_TO:
       
   143             case VG_SQUAD_TO:
       
   144                 coordinateCount += 2;
       
   145                 break;                
       
   146             case VG_QUAD_TO:
       
   147             case VG_SCUBIC_TO:
       
   148                 coordinateCount += 4;
       
   149                 break;
       
   150             case VG_SCCWARC_TO:
       
   151             case VG_SCWARC_TO:
       
   152             case VG_LCCWARC_TO:
       
   153             case VG_LCWARC_TO:
       
   154                 coordinateCount += 5;
       
   155                 break;
       
   156             case VG_CUBIC_TO:
       
   157                 coordinateCount += 6;
       
   158                 break;
       
   159             default:
       
   160                 break;
       
   161             }
       
   162         }
       
   163     iNVGIconData->EncodeInt16L(coordinateCount);
       
   164     iNVGIconData->EncodeDataL(pathData, coordinateCount * 4);
       
   165     }
       
   166 
       
   167 void CNVGCSIcon::AddDrawPathCommandL(VGPath aPath, VGbitfield aPaintMode)
       
   168     {
       
   169     iOpenVGHandles->AddPathDHL(aPath);
       
   170     iNVGIconData->EncodeInt32L(EPath);
       
   171     iNVGIconData->EncodeInt32L(aPath);    
       
   172     iNVGIconData->EncodeInt32L(aPaintMode);    
       
   173     }
       
   174 
       
   175 void CNVGCSIcon::AddLinearGradientCommandL(VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix, VGPaint aPaint)
       
   176     {
       
   177     iOpenVGHandles->AddPaintDHL(aPaint);
       
   178     iNVGIconData->EncodeInt32L(EPaint);
       
   179     AddLinearGradientCommandDataL(aPaint, aCount, aGradientData, aGradientMatrix);
       
   180     }
       
   181 
       
   182 void CNVGCSIcon::AddRadialGradientCommandL(VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix, VGPaint aPaint)
       
   183     {
       
   184     iOpenVGHandles->AddPaintDHL(aPaint);
       
   185     iNVGIconData->EncodeInt32L(EPaint);
       
   186     AddRadialGradientCommandDataL(aPaint, aCount, aGradientData, aGradientMatrix);
       
   187     }
       
   188 
       
   189 void CNVGCSIcon::AddSetColorCommandL(VGuint aRgba)
       
   190     {
       
   191     iNVGIconData->EncodeInt32L(EPaint);
       
   192     iNVGIconData->EncodeInt32L(VG_PAINT_TYPE_COLOR);
       
   193     iNVGIconData->EncodeInt32L(aRgba);
       
   194     }
       
   195 
       
   196 void CNVGCSIcon::AddColorRampCommandL(VGPaint aPaint)
       
   197     {
       
   198     iNVGIconData->EncodeInt32L(EColorRamp);
       
   199     iNVGIconData->EncodeInt32L(aPaint);
       
   200     }
       
   201 
       
   202 void CNVGCSIcon::AddSetTransformCommandL(const VGfloat* aTransformMatrix, TInt aFlag)
       
   203     {
       
   204     iNVGIconData->EncodeInt32L(ETransform);
       
   205     iNVGIconData->EncodeDataL(aTransformMatrix, 9 * sizeof(VGfloat));
       
   206     iNVGIconData->EncodeInt32L(aFlag);
       
   207     }
       
   208 
       
   209 void CNVGCSIcon::AddSetStrokeWidthCommandL(VGfloat aStrokeWidth)
       
   210     {
       
   211     iNVGIconData->EncodeInt32L(EStrokeWidth);
       
   212     iNVGIconData->EncodeReal32L(aStrokeWidth);
       
   213     }
       
   214 
       
   215 void CNVGCSIcon::AddSetStrokeMiterLimitCommandL(VGfloat aMiterLimit)
       
   216     {
       
   217     iNVGIconData->EncodeInt32L(EStrokeMiterLimit);
       
   218     iNVGIconData->EncodeReal32L(aMiterLimit);
       
   219     }
       
   220 
       
   221 void CNVGCSIcon::AddStrokeLineJoinCapCommandL(VGint aCapStyle, VGint aJoinStyle)
       
   222     {
       
   223     iNVGIconData->EncodeInt32L(EStrokeLineJoinCap);
       
   224     iNVGIconData->EncodeInt32L(aCapStyle);
       
   225     iNVGIconData->EncodeInt32L(aJoinStyle);
       
   226     }
       
   227 
       
   228 void CNVGCSIcon::AddStrokeLinearGradientCommandL(VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix, VGPaint aPaint)
       
   229     {
       
   230     iOpenVGHandles->AddPaintDHL(aPaint);
       
   231     iNVGIconData->EncodeInt32L(EStrokePaint);
       
   232     AddLinearGradientCommandDataL(aPaint, aCount, aGradientData, aGradientMatrix);
       
   233     }
       
   234 
       
   235 void CNVGCSIcon::AddStrokeRadialGradientCommandL(VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix, VGPaint aPaint)
       
   236     {
       
   237     iOpenVGHandles->AddPaintDHL(aPaint);
       
   238     iNVGIconData->EncodeInt32L(EStrokePaint);
       
   239     AddRadialGradientCommandDataL(aPaint, aCount, aGradientData, aGradientMatrix);
       
   240     }
       
   241 
       
   242 void CNVGCSIcon::AddStrokeSetColorCommandL(VGuint aRgba)
       
   243     {
       
   244     iNVGIconData->EncodeInt32L(EStrokePaint);
       
   245     AddSetColorCommandDataL(aRgba);
       
   246     }
       
   247 
       
   248 void CNVGCSIcon::AddStrokeColorRampCommandL(VGPaint aPaint)
       
   249     {
       
   250     iNVGIconData->EncodeInt32L(EStrokeColorRamp);
       
   251     iNVGIconData->EncodeInt32L(aPaint);
       
   252     }
       
   253 
       
   254 void CNVGCSIcon::AddLinearGradientCommandDataL(VGPaint aPaint, VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix)
       
   255     {
       
   256     iNVGIconData->EncodeInt32L(VG_PAINT_TYPE_LINEAR_GRADIENT);
       
   257     iNVGIconData->EncodeInt32L(aPaint);
       
   258     iNVGIconData->EncodeInt32L(aCount);
       
   259     iNVGIconData->EncodeDataL(aGradientData, aCount * sizeof(VGfloat));
       
   260     iNVGIconData->EncodeDataL(aGradientMatrix, 9 * sizeof(VGfloat));    
       
   261     }
       
   262 
       
   263 void CNVGCSIcon::AddRadialGradientCommandDataL(VGPaint aPaint, VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix)
       
   264     {
       
   265     iNVGIconData->EncodeInt32L(VG_PAINT_TYPE_RADIAL_GRADIENT);
       
   266     iNVGIconData->EncodeInt32L(aPaint);
       
   267     iNVGIconData->EncodeInt32L(aCount);
       
   268     iNVGIconData->EncodeDataL(aGradientData, aCount * sizeof(VGfloat));
       
   269     iNVGIconData->EncodeDataL(aGradientMatrix, 9 * sizeof(VGfloat));
       
   270     }
       
   271 
       
   272 void CNVGCSIcon::AddSetColorCommandDataL(VGuint aRgba)
       
   273     {
       
   274     iNVGIconData->EncodeInt32L(VG_PAINT_TYPE_COLOR);
       
   275     iNVGIconData->EncodeInt32L(aRgba);
       
   276     }
       
   277 
       
   278 TInt CNVGCSIcon::Draw(const TSize aSize, CNvgEngine * aNVGEngine)
       
   279     {
       
   280     NVG_DEBUGP2("DRAWING NVGCSIcon %s, ", __FUNCTION__);
       
   281 
       
   282     TInt error = KErrNone;
       
   283     
       
   284     iNVGEngine = aNVGEngine;
       
   285     
       
   286     // Get Matrix modes and all caller matrices (must be restored afterwards)
       
   287     UpdateClientMatrices();
       
   288     
       
   289     TRAP(error, DoDrawL(aSize));
       
   290     
       
   291     // restore everything as we may have changed matrix mode            
       
   292     RestoreClientMatrices();
       
   293     
       
   294     return error;
       
   295     }
       
   296 
       
   297 TInt CNVGCSIcon::DoDrawL(const TSize aSize)
       
   298     {
       
   299     TInt ret = KErrNone;
       
   300     
       
   301     vgSetPaint(iFillPaint,   VG_FILL_PATH);
       
   302     vgSetPaint(iStrokePaint, VG_STROKE_PATH);
       
   303     iLastFillPaintColor     = 0;
       
   304     iLastStrkePaintColor    = 0;
       
   305     iLastFillPaintType      = 0;
       
   306     iLastStrokePaintType    = 0;
       
   307 
       
   308     VGfloat lCurrentPathMatrix[9];
       
   309     vgGetMatrix(lCurrentPathMatrix);
       
   310     
       
   311     vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);  
       
   312     vgLoadMatrix(lCurrentPathMatrix);
       
   313     SetRotation();
       
   314 #ifdef __MIRROR_    
       
   315     vgScale(1.0f, -1.0f);
       
   316     vgTranslate(0, (VGfloat)(-aSize.iHeight) );
       
   317 #endif
       
   318     
       
   319     SetViewBoxToViewTransformationL(aSize);
       
   320    
       
   321     
       
   322     vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
       
   323     
       
   324     VGfloat currentMatrix[9];
       
   325     
       
   326     vgGetMatrix(currentMatrix);
       
   327     
       
   328     iNVGIconData->BeginRead();
       
   329 
       
   330     while (!iNVGIconData->EOF())
       
   331         {
       
   332         switch (iNVGIconData->ReadInt32L())
       
   333             {
       
   334             case EPath:
       
   335                 {
       
   336                 VGPath path = (VGPath)iNVGIconData->ReadInt32L();
       
   337                 VGPaintMode paintMode = (VGPaintMode)iNVGIconData->ReadInt32L();
       
   338 
       
   339                 if (path == VG_INVALID_HANDLE)
       
   340                     {
       
   341                     vgDrawPath(iPath, paintMode);
       
   342                     }
       
   343                 else
       
   344                     {
       
   345                     vgDrawPath(path, paintMode);
       
   346                     }
       
   347                 
       
   348                 break;
       
   349                 }
       
   350             case EPathData:
       
   351                 {                
       
   352                 if (iPath != VG_INVALID_HANDLE)
       
   353                     {
       
   354                     VGint numSegments;
       
   355                     VGubyte * pathSegments = 0;
       
   356                     VGubyte * pathData = 0;
       
   357                     
       
   358                     numSegments  = iNVGIconData->ReadInt32L();
       
   359                     pathSegments = new (ELeave) VGubyte[numSegments];
       
   360                     CleanupStack::PushL(TCleanupItem(CleanupArray, pathSegments));
       
   361                     if (pathSegments)
       
   362                         {
       
   363                         iNVGIconData->ReadL(pathSegments, numSegments);
       
   364                         VGint coordinateCount = iNVGIconData->ReadInt32L();
       
   365                         pathData = new (ELeave) VGubyte[coordinateCount * 4];
       
   366                         if (pathData)
       
   367                             {
       
   368                             CleanupStack::PushL(TCleanupItem(CleanupArray, pathData));
       
   369                             iNVGIconData->ReadL(pathData, coordinateCount * 4);
       
   370                             vgClearPath(iPath, VG_PATH_CAPABILITY_APPEND_TO);
       
   371                             vgAppendPathData(iPath, numSegments, pathSegments, pathData);
       
   372                             CleanupStack::PopAndDestroy();
       
   373                             }                        
       
   374                         }
       
   375                     CleanupStack::PopAndDestroy();
       
   376                     }
       
   377                 break;
       
   378                 }
       
   379             case EPaint:
       
   380                 {
       
   381                 DrawPaintL(iFillPaint, VG_MATRIX_FILL_PAINT_TO_USER, iLastFillPaintType, iLastFillPaintColor, VG_FILL_PATH);
       
   382                 break;
       
   383                 }
       
   384             case EColorRamp:
       
   385                 {
       
   386                 iNVGIconData->ReadInt32L();
       
   387                 break;
       
   388                 }
       
   389             case ETransform:
       
   390                 {
       
   391                 TInt flag;
       
   392                 VGfloat transformMatrix[9];
       
   393                 
       
   394                 TPtr8 tmPtr((TUint8 *)transformMatrix, 9 * sizeof(VGfloat));
       
   395                 
       
   396                 iNVGIconData->ReadL(tmPtr, 9 * sizeof(VGfloat));
       
   397                 flag = iNVGIconData->ReadInt32L();
       
   398                 
       
   399                 vgLoadMatrix(currentMatrix);
       
   400                 if (flag)
       
   401                     {
       
   402                     vgMultMatrix(transformMatrix);
       
   403                     }
       
   404                 }
       
   405                 break;
       
   406             case EStrokeWidth:
       
   407                 {
       
   408                 VGfloat strokeWidth = iNVGIconData->ReadReal32L();
       
   409                 vgSetf(VG_STROKE_LINE_WIDTH, strokeWidth);
       
   410                 break;
       
   411                 }
       
   412             case EStrokeMiterLimit:
       
   413                 {
       
   414                 VGfloat miterLimit = iNVGIconData->ReadReal32L();
       
   415                 vgSetf(VG_STROKE_MITER_LIMIT, miterLimit);
       
   416                 break;
       
   417                 }
       
   418             case EStrokeLineJoinCap:
       
   419                 {
       
   420                 VGint lineJoin = iNVGIconData->ReadInt32L();
       
   421                 VGint cap = iNVGIconData->ReadInt32L();
       
   422                 
       
   423                 vgSeti(VG_STROKE_JOIN_STYLE, (VGJoinStyle)lineJoin);
       
   424                 vgSeti(VG_STROKE_CAP_STYLE, (VGCapStyle)cap);
       
   425                 break;
       
   426                 }
       
   427             case EStrokePaint:
       
   428                 {
       
   429                 DrawPaintL(iStrokePaint, VG_MATRIX_STROKE_PAINT_TO_USER, iLastStrokePaintType, iLastStrkePaintColor, VG_STROKE_PATH);
       
   430                 break;
       
   431                 }
       
   432             case EStrokeColorRamp:
       
   433                 {
       
   434                 iNVGIconData->ReadInt32L();
       
   435                 break;
       
   436                 }
       
   437             default:
       
   438                 {
       
   439                 User::Leave(KErrCorrupt);
       
   440                 break;
       
   441                 }
       
   442             }
       
   443         }
       
   444     
       
   445     iNVGIconData->EndRead();
       
   446     
       
   447     return ret;
       
   448     }
       
   449 
       
   450 void CNVGCSIcon::DrawColorRampL(VGPaint aPaint)
       
   451     {
       
   452     TInt stopCount = iNVGIconData->ReadInt32L();
       
   453     VGfloat * colorRamps = new (ELeave) VGfloat[stopCount];
       
   454     CleanupStack::PushL(TCleanupItem(CleanupArray, colorRamps));
       
   455 
       
   456     iNVGIconData->ReadL((TUint8 *)colorRamps, stopCount * sizeof(VGfloat));
       
   457     vgSetParameteri(aPaint, VG_PAINT_COLOR_RAMP_SPREAD_MODE, VG_COLOR_RAMP_SPREAD_PAD);
       
   458     vgSetParameterfv(aPaint, VG_PAINT_COLOR_RAMP_STOPS, stopCount, colorRamps);                    
       
   459     
       
   460     CleanupStack::PopAndDestroy();
       
   461     }
       
   462 
       
   463 void CNVGCSIcon::DrawPaintL(VGPaint aPaint, VGMatrixMode aMatrixMode, TUint & aLastPaintType, TUint & aLastPaintColor, VGPaintMode aPaintMode)
       
   464     {
       
   465     VGPaintType paintType = (VGPaintType)iNVGIconData->ReadInt32L();
       
   466     
       
   467     if (paintType == VG_PAINT_TYPE_LINEAR_GRADIENT ||
       
   468         paintType == VG_PAINT_TYPE_RADIAL_GRADIENT)
       
   469         {
       
   470         VGPaintParamType paintPType = VG_PAINT_LINEAR_GRADIENT;
       
   471         if (paintType == VG_PAINT_TYPE_RADIAL_GRADIENT)
       
   472             {
       
   473             paintPType = VG_PAINT_RADIAL_GRADIENT;
       
   474             }
       
   475         
       
   476         VGPaint paintHandle = iNVGIconData->ReadInt32L();
       
   477         TInt count = iNVGIconData->ReadInt32L();
       
   478         VGfloat gradientData[5];
       
   479         VGfloat gradientMatrix[9];
       
   480         
       
   481         iNVGIconData->ReadL((TUint8 *)gradientData, count * sizeof(VGfloat));
       
   482         iNVGIconData->ReadL((TUint8 *)gradientMatrix, 9 * sizeof(VGfloat));
       
   483         
       
   484         if (paintHandle)
       
   485             {
       
   486             vgSetPaint(paintHandle,   aPaintMode);
       
   487             vgSeti(VG_MATRIX_MODE, aMatrixMode);
       
   488             vgLoadMatrix(gradientMatrix);
       
   489             if (aPaintMode == VG_FILL_PATH)
       
   490                 {
       
   491                 iResetFillPaint = 1;
       
   492                 }
       
   493             else
       
   494                 {
       
   495                 iResetStrokePaint = 1;
       
   496                 }
       
   497             }
       
   498         else
       
   499             {
       
   500         if (aLastPaintType != paintType)
       
   501             {
       
   502             vgSetParameteri(aPaint, VG_PAINT_TYPE, paintType);
       
   503             }
       
   504         vgSetParameterfv(aPaint, paintPType, count, gradientData);
       
   505         
       
   506         vgSeti(VG_MATRIX_MODE, aMatrixMode);
       
   507         vgLoadMatrix(gradientMatrix);
       
   508             }
       
   509         vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
       
   510         }
       
   511     else if (paintType == VG_PAINT_TYPE_COLOR)
       
   512         {
       
   513         if (aPaintMode == VG_FILL_PATH && iResetFillPaint)
       
   514             {
       
   515             iResetFillPaint = 0;
       
   516             vgSetPaint(aPaint, aPaintMode);
       
   517             }
       
   518         else if (aPaintMode == VG_STROKE_PATH && iResetStrokePaint)
       
   519             {
       
   520             iResetStrokePaint = 0;
       
   521             vgSetPaint(aPaint, aPaintMode);
       
   522             }
       
   523         TUint color = static_cast<TUint>(iNVGIconData->ReadInt32L());
       
   524         if (aLastPaintType != paintType)
       
   525             {
       
   526             vgSetParameteri(aPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
       
   527             vgSetColor(aPaint, color);
       
   528             }
       
   529         else
       
   530             {
       
   531             if (aLastPaintColor != color)
       
   532                 {
       
   533                 vgSetColor(aPaint, color);
       
   534                 }
       
   535             }
       
   536         aLastPaintColor = color;
       
   537         }
       
   538     else
       
   539         {
       
   540         User::Leave(KErrCorrupt);
       
   541         }
       
   542     aLastPaintType = paintType;
       
   543     }
       
   544 
       
   545 void CNVGCSIcon::SetViewBoxToViewTransformationL(const TSize aSize)
       
   546     {
       
   547     CNvgFitToViewBoxImpl * fitToViewBoxImpl = CNvgFitToViewBoxImpl::NewLC();
       
   548 
       
   549     fitToViewBoxImpl->SetAlign((TNvgAlignStatusType)iPreserveAspectSetting);
       
   550     fitToViewBoxImpl->SetScaling((TNvgMeetOrSliceType)iSmilFitSetting);
       
   551     
       
   552     fitToViewBoxImpl->SetViewBox(iViewBoxX, iViewBoxY, iViewBoxW, iViewBoxH);
       
   553 
       
   554     fitToViewBoxImpl->SetWindowViewportTrans(TRect(0, 0, aSize.iWidth, aSize.iHeight), TSize(0, 0));
       
   555     
       
   556     CleanupStack::PopAndDestroy(fitToViewBoxImpl);
       
   557     }
       
   558 
       
   559 void CNVGCSIcon::SetRotation()
       
   560     {
       
   561     if (iRotationAngle)
       
   562         {
       
   563        	vgTranslate(iRotationX, iRotationY);  
       
   564            
       
   565         vgRotate(iRotationAngle);
       
   566            
       
   567         vgTranslate(-iRotationX, -iRotationY);
       
   568         }
       
   569     }
       
   570 
       
   571 void CNVGCSIcon::UpdateClientMatrices()
       
   572     {
       
   573     iMatrixMode = vgGeti(VG_MATRIX_MODE);
       
   574     vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
       
   575     vgGetMatrix(iPathMatrix);
       
   576     vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
       
   577     vgGetMatrix(iImageMatrix);
       
   578     vgSeti(VG_MATRIX_MODE, iMatrixMode);
       
   579     }
       
   580 
       
   581 void CNVGCSIcon::RestoreClientMatrices()
       
   582     {
       
   583     vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
       
   584     vgLoadMatrix(iPathMatrix);
       
   585     vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
       
   586     vgLoadMatrix(iImageMatrix);
       
   587     vgSeti(VG_MATRIX_MODE, iMatrixMode);
       
   588     }