1 /*

     2 * Copyright (c) 2002-2004 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:  Xuikon control adapter source file

    15 *

    16 */

    17 

    18 

    19 // System includes

    20 #include <utf.h>

    21 #include <SVGEngineInterfaceImpl.h>

    22 #include <s32file.h>

    23 #include <mifconvdefs.h>

    24 //skinning support

    25 #include <AknsFrameBackgroundControlContext.h>

    26 #include <AknsDrawUtils.h>

    27 #include <aknconsts.h>

    28 #include <AknUtils.h>

    29 #include <AknsListBoxBackgroundControlContext.h>

    30 #include <gulicon.h>

    31 #include <aknpointereventsuppressor.h>

    32 #ifdef RD_TACTILE_FEEDBACK

    33 #include <touchfeedback.h>

    34 #endif // RD_TACTILE_FEEDBACK

    35 

    36 // User includes

    37 #include "xnappuiadapter.h"

    38 #include "xnviewadapter.h"

    39 #include "xnviewmanager.h"

    40 #include "xncontroladapterimpl.h"

    41 #include "xncontroladapter.h"

    42 #include "xnmenuadapter.h"

    43 #include "xnviewcontroladapter.h"

    44 #include "xncomponentnodeimpl.h"

    45 #include "xntype.h"

    46 #include "xnnodepluginif.h"

    47 #include "xnuiengine.h"

    48 #include "xnviewnodeimpl.h"

    49 #include "c_xnutils.h"

    50 #include "xndomdocument.h"

    51 #include "xndomattribute.h"

    52 #include "xndomnode.h"

    53 #include "xnproperty.h"

    54 #include "xndomlist.h"

    55 #include "xnodt.h"

    56 #include "xnresource.h"

    57 #include "xnplugindata.h"

    58 #include "xnnode.h"

    59 #include "xnpanic.h"

    60 #include "xnviewdata.h"

    61 #include "xnscrollablecontroladapter.h"

    62 #include "xnfocuscontrol.h"

    63 #include "xneditmode.h"

    64 

    65 _LIT8(KScrollableBoxNodeName, "scrollablebox");

    66 _LIT8( KView, "view" );

    67 

    68 // Constants

    69 const TInt KSkinGfxInnerRectShrink = 5;

    70 const TInt KFocusGrowValue = 3;

    71 

    72 const TInt KLongTapStartShortDelay( 150000 ); // 0.15s for Sk

    73 const TInt KLongTapStartLongDelay( 500000 ); // 0.5s

    74 const TInt KLongTapTimeShortDelay( 600000 ); // 0.6s for SK

    75 const TInt KLongTapTimeLongDelay( 1500000 ); // 1.5s

    76 

    77 const TInt KDragThreshold = 100; // pixels

    78 const TInt KMaxTapMove = 100; //100x100 pixels

    79 

    80 const TReal KEps( 3e-16 ); // proximite EPS value for double FP numbers

    81 

    82 // LOCAL FUNCTION PROTOTYPES

    83 static TRgb ConvertHslToRgb( TInt aHue, TInt aSaturation, TInt aLightness );

    84 static void ConvertRgbToHsl( TRgb aRGB, TUint& aHue, TUint& aSaturation,

    85     TUint& aLightness );

    86 static void LoadFbsBitmapL(

    87     CXnResource& aResource, CFbsBitmap*& aTarget, RFs& aFsSession );

    88 static void LoadMbmBitmapL( CXnResource& aResource,

    89     TInt aBitmapIndex, CFbsBitmap*& aTarget, RFs& aFsSession );

    90 static void LoadSVGBitmapL( CXnResource& aResource,

    91     CFbsBitmap*& aBitmap, CFbsBitmap*& aBitmapMask,

    92     TRect aRect, RFs& aFsSession );

    93 static TBool GetBitmapL( CXnUiEngine& aEngine, CXnNode& aNode,

    94     const TDesC& aResourceFileName, TInt& aBitmapIndex,

    95     CFbsBitmap*& aTarget, CFbsBitmap*& aBitmapMask,

    96     CXnControlAdapterImpl::TIconProvider*& aIconProvider,

    97     TRect aRect, RFs& aFsSession );

    98 

    99 static void LimitRectToPaddingRect( CXnNode& aNode, TRect& aRect );

   100 static void DrawSpaceBackgroundY( CWindowGc& aGc, TInt aYRepeatCount,

   101     CXnNode& aNode, TRect& aRect, CFbsBitmap* aBitmap, TRect aBitmapRect,

   102     TRect aImageRect, TInt& aYOffset );

   103 static void DrawRepeatBackgroundY( CWindowGc& aGc, TInt aYRepeatCount,

   104     CXnNode& aNode, TRect& aRect, CFbsBitmap* aBitmap, TRect aBitmapRect,

   105     TRect aImageRect, TInt& aYOffset );

   106 static void StripQuotes( HBufC*& aString );

   107 static void DrawBackgroundColorL(

   108     const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

   109 static void GetBackroundRepeatValuesL( CXnNode& aNode, TBool& aRepeatX,

   110     TBool& aRepeatY, TBool& aSpaceX, TBool& aSpaceY );

   111 static void DrawRepeatedBackgroundImage( CWindowGc& aGc, CXnNode& aNode,

   112     TRect& aRect, TRect aImageRect, TRect aBitmapRect,

   113     CFbsBitmap* aBitmap, TBool aRepeatX, TBool aRepeatY, TBool aSpaceX,

   114     TBool aSpaceY, TInt aXRepeatCount, TInt aYRepeatCount );

   115 static TBool GetBackgroundPositionFromPropertyL(

   116     CXnNode& aNode, TBool aScaleImage, TRect& aRect,

   117     TRect aImageRect, CFbsBitmap* aBitmap, TBool& aHeightSet );

   118 static TBool GetBackgroundSizeFromPropertyL( TRect& aRect, CXnNode& aNode,

   119     CFbsBitmap* aBitmap, TBool& aScaleImage );

   120 static TRgb LighterColor( const TRgb& aRgb );

   121 static TRgb DarkerColor( const TRgb& aRgb );

   122 static void DrawSolidTopBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc );

   123 static void SplitTopBorderPolygonL( CArrayFix< TPoint >* aArray,

   124     CArrayFix< TPoint >*& aUpperPart, CArrayFix< TPoint >*& aLowerPart );

   125 static void DrawRidgeTopBorderL(

   126     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   127 static void DrawGrooveTopBorderL(

   128     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   129 static void DrawInsetTopBorder(

   130     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   131 static void DrawOutsetTopBorder(

   132     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   133 static TBool GetBorderColorL(

   134     const TDesC8& aPropertyName, CXnNode& aNode, CWindowGc& aGc, TRgb& aRgb );

   135 static void DrawTopBorderL(

   136     const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

   137 static void DrawBottomBorderL(

   138     const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

   139 static void DrawSolidBottomBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc );

   140 static void SplitBottomBorderPolygonL( CArrayFix< TPoint >* aArray,

   141     CArrayFix< TPoint >*& aUpperPart, CArrayFix< TPoint >*& aLowerPart );

   142 static void DrawRidgeBottomBorderL(

   143     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   144 static void DrawGrooveBottomBorderL(

   145     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   146 static void DrawInsetBottomBorder(

   147     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   148 static void DrawOutsetBottomBorder(

   149     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   150 static void DrawSolidLeftBorder(

   151     CArrayFix< TPoint >* aArray, CWindowGc& aGc );

   152 static void SplitLeftBorderPolygonL( CArrayFix< TPoint >* aArray,

   153     CArrayFix< TPoint >*& aLeftPart, CArrayFix< TPoint >*& aRightPart );

   154 static void DrawRidgeLeftBorderL(

   155     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   156 static void DrawGrooveLeftBorderL(

   157     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   158 static void DrawInsetLeftBorder(

   159     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   160 static void DrawOutsetLeftBorder(

   161     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   162 static void DrawLeftBorderL(

   163     const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

   164 static void DrawRightBorderL(

   165     const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

   166 static void DrawSolidRightBorder(

   167     CArrayFix< TPoint >* aArray, CWindowGc& aGc );

   168 static void SplitRightBorderPolygonL( CArrayFix< TPoint >* aArray,

   169     CArrayFix< TPoint >*& aLeftPart, CArrayFix< TPoint >*& aRightPart );

   170 static void DrawRidgeRightBorderL(

   171     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   172 static void DrawGrooveRightBorderL(

   173     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   174 static void DrawInsetRightBorder(

   175     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   176 static void DrawOutsetRightBorder(

   177     CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

   178 static void DrawBorderImagesL(

   179     const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc,

   180     CFbsBitmap* aBitmap, TInt aBorderBitmapDividerTop,

   181     TInt aBorderBitmapDividerRight,

   182     TInt aBorderBitmapDividerBottom, TInt aBorderBitmapDividerLeft );

   183 static TBool IsPropertyNone( CXnProperty& aProperty );

   184 static void DrawBordersL( const TRect& aRect, CXnNode& aNode, CWindowGc& aGc );

   185 static void SwapChildArrays( RPointerArray< CXnControlAdapter >& originalArray,

   186     RPointerArray< CXnControlAdapter >& sortedArray );

   187 static CXnProperty* GetZIndexL( CXnControlAdapter* aAdapter );

   188 static void InsertChildToSortedArrayL(

   189     RPointerArray< CXnControlAdapter >& aTargetArray,

   190     CXnControlAdapter* aChild );

   191 static void InitializeBackgroundBitmapL( CXnUiEngine& aEngine, CXnNode& aNode,

   192     TInt& aBitmapIndex, CFbsBitmap*& aBitmap, CFbsBitmap*& aMask,

   193     CXnControlAdapterImpl::TIconProvider*& aIconProvider, RFs& aFsSession );

   194 static HBufC* GetBackgroundImagePathLC( CXnNode& aNode );

   195 static CFbsBitmap* InitializeBorderBitmapL(

   196     CXnUiEngine& aEngine, CXnNode& aNode,

   197     TInt& aBitmapIndex, TInt& aBorderBitmapDividerTop,

   198     TInt& aBorderBitmapDividerRight, TInt& aBorderBitmapDividerBottom,

   199     TInt& aBorderBitmapDividerLeft,

   200     CXnControlAdapterImpl::TIconProvider*& aIconProvider, RFs& aFsSession );

   201 static void DrawDottedBorder(

   202     TRect aBorderRect, CWindowGc& aGc, TRgb& aRgb, TBool aHorizontal );

   203 static HBufC* GetBackgroundImageMaskPathLC( CXnNode& aNode );

   204 static CFbsBitmap* CreateBitmapFromColorL( TSize aSize, TRgb aColor );

   205 static TBool CreateGestureHelperL( CXnNode& aNode );

   206 static TInt AccessResourceFileL(

   207     CXnResource& aResource, RFile& aFile, RFs& aFsSession );

   208 static void DrawFocusAppearance( CXnNode& aNode, CWindowGc& aGc );

   209 static CXnDomNode* HasHoldTrigger( CXnDomNode* aNode );

   210 static void CancelFocusRefusalL( CXnUiEngine& aUiEngine );

   211     

   212 // ============================= LOCAL FUNCTIONS ===============================

   213 // -----------------------------------------------------------------------------

   214 // -----------------------------------------------------------------------------

   215 // 

   216 static CXnScrollableControlAdapter* IsChildOfScrollableControl( CXnNode& aNode )

   217     {

   218     CXnNode* parent = aNode.Parent();

   219     while( parent )

   220         {

   221         if( parent->Type()->Type() == KScrollableBoxNodeName )

   222             {

   223             CXnScrollableControlAdapter* ret = static_cast<CXnScrollableControlAdapter*>(parent->Control());

   224             return ret;

   225             }

   226         parent = parent->Parent();

   227         }

   228     return NULL;

   229     }

   230 

   231 // -----------------------------------------------------------------------------

   232 // SetControlContext

   233 // 

   234 // -----------------------------------------------------------------------------

   235 // 

   236 static void SetControlContext(CXnControlAdapter& aChild, CXnNode& aNode)

   237     {

   238     CXnScrollableControlAdapter* scrollableControl = IsChildOfScrollableControl( aNode );

   239     if(scrollableControl)

   240         {

   241         aNode.SetScrollableControl(scrollableControl);

   242         aChild.CopyControlContextFrom(scrollableControl);

   243         }        

   244     }

   245 

   246 // -----------------------------------------------------------------------------

   247 // AccessResourceFileL

   248 // Opens a resource file for accessing. The caller must close the file.

   249 // -----------------------------------------------------------------------------

   250 //

   251 static TInt AccessResourceFileL(

   252     CXnResource& aResource,

   253     RFile& aFile,

   254     RFs& aFsSession )

   255     {

   256     TInt err = KErrNone;

   257 

   258     // parse file name and extension

   259     const TDesC& fileName = aResource.FileName();

   260     TParsePtrC fileParser( fileName );

   261     TPtrC filepath = fileParser.DriveAndPath();

   262 

   263     // open resource file

   264     aFsSession.SetSessionPath( filepath );

   265     aFsSession.ShareProtected();

   266     err = aFile.Open( aFsSession, fileName, EFileShareReadersOnly );

   267     if ( err != KErrNone )

   268         {

   269         aFile.Close();

   270         }

   271 

   272     return err;

   273     }

   274 

   275 // -----------------------------------------------------------------------------

   276 // LoadFbsBitmapL

   277 // Loads a bitmap file from the theme server and creates a CFbsBitmap

   278 // -----------------------------------------------------------------------------

   279 //

   280 static void LoadFbsBitmapL(

   281     CXnResource& aResource,

   282     CFbsBitmap*& aTarget,

   283     RFs& aFsSession )

   284     {

   285      RFile file;

   286 

   287      TInt ret = AccessResourceFileL( aResource, file, aFsSession );

   288      if ( ret == KErrNone )

   289         {

   290         CleanupClosePushL( file );

   291         aTarget = new ( ELeave ) CFbsBitmap;

   292         if ( !aTarget )

   293             {

   294             CleanupStack::PopAndDestroy();

   295             return;

   296             }

   297         RFileReadStream readStream( file );

   298         CleanupClosePushL( readStream );

   299         aTarget->InternalizeL( readStream );

   300         CleanupStack::PopAndDestroy( &readStream );

   301         CleanupStack::PopAndDestroy( &file );

   302         }

   303     }

   304 

   305 // -----------------------------------------------------------------------------

   306 // LoadMifBitmapL

   307 // Loads a bitmap file from the theme server and creates a CFbsBitmap

   308 // -----------------------------------------------------------------------------

   309 //

   310 static void LoadMifBitmapL(

   311     CXnResource& aResource,

   312     TInt aBitmapIndex,

   313     CFbsBitmap*& aBitmap,

   314     CFbsBitmap*& aMask,

   315     CXnControlAdapterImpl::TIconProvider*& aIconProvider,

   316     RFs& aFsSession,

   317     const TRect& aRect )

   318     {

   319     RFile file;

   320 

   321     TInt ret = AccessResourceFileL( aResource, file, aFsSession );

   322     if ( ret == KErrNone )

   323         {

   324         aIconProvider = new ( ELeave ) CXnControlAdapterImpl::TIconProvider( file );

   325         }

   326 

   327     if ( ret == KErrNone )

   328         {

   329         // Mask is next after bitmap

   330         AknIconUtils::CreateIconL( aBitmap, aMask, *aIconProvider,

   331             aBitmapIndex + KMifIdFirst, aBitmapIndex + KMifIdFirst + 1 );

   332         AknIconUtils::SetSize( aBitmap, aRect.Size(), EAspectRatioNotPreserved );

   333         }

   334     }

   335 

   336 // -----------------------------------------------------------------------------

   337 // LoadMbmBitmapL

   338 // Loads a bitmap file from the theme server and creates a CFbsBitmap

   339 // -----------------------------------------------------------------------------

   340 //

   341 static void LoadMbmBitmapL(

   342     CXnResource& aResource,

   343     TInt aBitmapIndex,

   344     CFbsBitmap*& aTarget,

   345     RFs& aFsSession )

   346     {

   347     RFile file;

   348 

   349     TInt ret = AccessResourceFileL( aResource, file, aFsSession );

   350     if ( ret == KErrNone )

   351         {

   352         CleanupClosePushL( file );

   353         aTarget = new ( ELeave ) CFbsBitmap;

   354         aTarget->Load( file, aBitmapIndex );

   355         CleanupStack::PopAndDestroy();

   356         }

   357     }

   358 

   359 // -----------------------------------------------------------------------------

   360 // LoadSVGBitmapL

   361 // Loads an SVG file from the theme server and creates a CFbsBitmap.

   362 // -----------------------------------------------------------------------------

   363 //

   364 static void LoadSVGBitmapL(

   365     CXnResource& aResource,

   366     CFbsBitmap*& aBitmap,

   367     CFbsBitmap*& aBitmapMask,

   368     TRect aRect,

   369     RFs& aFsSession )

   370     {

   371     RFile file;

   372 

   373     TInt ret = AccessResourceFileL( aResource, file, aFsSession );

   374     if ( ret == KErrNone )

   375         {

   376         CleanupClosePushL( file );

   377 

   378         CFbsBitmap* frameBuffer = new ( ELeave ) CFbsBitmap;

   379         CleanupStack::PushL( frameBuffer );

   380 

   381         TSize contentSize( aRect.Size() );

   382 

   383         frameBuffer->Create( contentSize, EColor16M );

   384 

   385         TFontSpec fontSpec;

   386         CSvgEngineInterfaceImpl* svgEngine =

   387             CSvgEngineInterfaceImpl::NewL( frameBuffer, NULL, fontSpec );

   388 

   389         CleanupStack::PushL( svgEngine );

   390 

   391         svgEngine->Load( file );

   392 

   393         TInt domHandle;

   394         svgEngine->PrepareDom( file, domHandle );

   395 

   396         CFbsBitmap* target = new ( ELeave ) CFbsBitmap;

   397         target->Create( contentSize, EColor16M );

   398         svgEngine->RenderDom( domHandle, target );

   399 

   400         aBitmap = target;

   401 

   402         CFbsBitmap* mask = new ( ELeave ) CFbsBitmap;

   403         mask->Create( contentSize, EGray256 );

   404         svgEngine->GenerateMask( mask );

   405 

   406         aBitmapMask = mask;

   407 

   408         CleanupStack::PopAndDestroy( 3, &file ); // frameBuffer, svgEngine, file

   409         }

   410     }

   411 

   412 

   413 // -----------------------------------------------------------------------------

   414 // ResolveMifIDL

   415 // Resolves a mif id from a given string.

   416 // -----------------------------------------------------------------------------

   417 //

   418 static TBool ResolveMifIDL(

   419     const TDesC& aMifId,

   420     TInt& aMifID )

   421     {

   422     HBufC* str = aMifId.AllocL();

   423     TPtr ptrMif = str->Des();

   424     ptrMif.TrimAll();

   425     TInt pos( ptrMif.FindF( KMif ) );

   426     if ( KErrNotFound != pos )

   427         {

   428         pos += KMif().Length();

   429         TPtr ptr = ptrMif.MidTPtr( pos, ( ptrMif.Length() - pos ) );

   430         ptr.TrimAll();

   431         TInt offset( ptr.Locate( KRightParenthesis ) );

   432         if ( KErrNotFound != offset )

   433             {

   434             TLex lex( ptr.Left( offset ) );

   435             lex.SkipSpace();

   436             lex.Val( aMifID );

   437             delete str;

   438             return ETrue;

   439             }

   440         }

   441     delete str;

   442     return EFalse;

   443     }

   444 

   445 // -----------------------------------------------------------------------------

   446 // LoadSkinBitmapL

   447 // Loads a skin bitmap and creates a CFbsBitmap from it.

   448 // -----------------------------------------------------------------------------

   449 //

   450 static TBool LoadSkinBitmapL(

   451     const TDesC& aSkinId,

   452     CFbsBitmap*& aBitmap,

   453     CFbsBitmap*& aBitmapMask,

   454     TRect aRect )

   455     {

   456     TAknsItemID itemID;

   457 

   458     MAknsSkinInstance* skin( AknsUtils::SkinInstance() );

   459 

   460     TInt mifId( 0 );

   461 

   462     TInt mifFound( ResolveMifIDL( aSkinId, mifId ) );

   463 

   464     TInt colorIndex( KErrNotFound );

   465 

   466     if ( skin && CXnUtils::ResolveSkinItemIDL( aSkinId, itemID, colorIndex ) )

   467         {

   468         if ( itemID.iMajor == EAknsMajorAppIcon ) // Check if appl. icon request

   469             {

   470             TUid applUid;

   471             applUid = TUid::Uid( itemID.iMinor );

   472 

   473             AknsUtils::CreateAppIconLC(

   474                 skin, applUid, EAknsAppIconTypeList, aBitmap, aBitmapMask );

   475             AknIconUtils::SetSize(

   476                 aBitmap, aRect.Size(), EAspectRatioNotPreserved );

   477             CleanupStack::Pop( 2 ); //aBitmap, aBitmapMask

   478 

   479             return ETrue;

   480             }

   481         else

   482             {

   483             TInt error( KErrNone );

   484 

   485             // if we have a color index, then we create a colored icon

   486             if ( colorIndex != KErrNotFound )

   487                 {

   488                 TRgb defaultColor( 0, 0, 0 );

   489 

   490                 TRAP( error, AknsUtils::CreateColorIconL(

   491                     skin, itemID, KAknsIIDQsnTextColors,

   492                     colorIndex, aBitmap, aBitmapMask,

   493                     KNullDesC, mifId, mifId + 1, defaultColor ) );

   494                 }

   495             else

   496                 {

   497                 TRAP( error, AknsUtils::CreateIconL(

   498                     skin, itemID, aBitmap, aBitmapMask, KNullDesC,

   499                     mifId, mifId + 1 ) );

   500                 }

   501 

   502             if ( error != KErrNone )

   503                 {

   504                 error = KErrNone;

   505                 TRAP( error, AknsUtils::CreateIconL(

   506                     skin, itemID, aBitmap, KNullDesC, mifId ) );

   507                 }

   508 

   509             if ( error == KErrNone )

   510                 {

   511                 AknIconUtils::SetSize(

   512                     aBitmap, aRect.Size(), EAspectRatioNotPreserved );

   513 

   514                 return ETrue;

   515                 }

   516             }

   517         }

   518 

   519     if ( mifFound )

   520         {

   521         AknIconUtils::CreateIconL(

   522             aBitmap, aBitmapMask, KAvkonBitmapFile, mifId, mifId + 1 );

   523         AknIconUtils::SetSize(

   524             aBitmap, aRect.Size(), EAspectRatioNotPreserved );

   525 

   526         return ETrue;

   527         }

   528 

   529     return EFalse;

   530     }

   531 

   532 // -----------------------------------------------------------------------------

   533 // GetBitmap

   534 // Fetches a bitmap

   535 // -----------------------------------------------------------------------------

   536 //

   537 static TBool GetBitmapL(

   538     CXnUiEngine& aEngine,

   539     CXnNode& /*aNode*/,

   540     const TDesC& aResourceFileName,

   541     TInt& aBitmapIndex,

   542     CFbsBitmap*& aBitmap,

   543     CFbsBitmap*& aBitmapMask,

   544     CXnControlAdapterImpl::TIconProvider*& aIconProvider,

   545     TRect aRect,

   546     RFs& aFsSession )

   547     {

   548     if ( LoadSkinBitmapL( aResourceFileName, aBitmap, aBitmapMask, aRect ) )

   549         {

   550         return ETrue;

   551         }

   552 

   553     CXnResource* resource( CXnUtils::FindResource(

   554         aEngine.Resources(), aResourceFileName, aBitmapIndex ) );

   555 

   556     if ( resource )

   557         {

   558         if ( resource->ResourceType() == EResourceSVG )

   559             {

   560             LoadSVGBitmapL( *resource, aBitmap, aBitmapMask, aRect, aFsSession );

   561 

   562             return ETrue;

   563             }

   564         else if ( resource->ResourceType() == EResourceMIF )

   565             {

   566             LoadMifBitmapL( *resource, aBitmapIndex, aBitmap,

   567                 aBitmapMask, aIconProvider, aFsSession, aRect );

   568 

   569             return ETrue;

   570             }

   571         else if ( resource->ResourceType() == EResourceMBM )

   572             {

   573             LoadMbmBitmapL( *resource, aBitmapIndex, aBitmap, aFsSession );

   574 

   575             return ETrue;

   576             }

   577         else if ( resource->ResourceType() == EResourceFBS )

   578             {

   579             LoadFbsBitmapL( *resource, aBitmap, aFsSession );

   580 

   581             return ETrue;

   582             }

   583         }

   584 

   585     return EFalse;

   586     }

   587 

   588 // -----------------------------------------------------------------------------

   589 // DrawBackgroundColorL

   590 // Draws background color to the padding rect

   591 // -----------------------------------------------------------------------------

   592 //

   593 static void DrawBackgroundColorL(

   594     const TRect& /*aRect*/,

   595     CXnNode& aNode,

   596     CWindowGc& aGc )

   597     {

   598     CXnProperty* colorProperty( aNode.BackgroundColorL() );

   599 

   600     if ( colorProperty )

   601         {

   602         TRect paddingRect = aNode.PaddingRect();

   603 

   604         CXnDomPropertyValue* value =

   605             static_cast< CXnDomPropertyValue* >(

   606                 colorProperty->Property()->PropertyValueList().Item( 0 ) );

   607 

   608         if ( value->PrimitiveValueType() == CXnDomPropertyValue::ERgbColor )

   609             {

   610             TRgb rgb( value->RgbColorValueL() );

   611 

   612             aGc.SetPenColor( rgb );

   613 

   614             aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );

   615             aGc.SetBrushColor( rgb );

   616 

   617             aGc.DrawRect( paddingRect );

   618             }

   619         }

   620     }

   621 

   622 // -----------------------------------------------------------------------------

   623 // StripQuotes

   624 // Strips enclosing quotes from a string

   625 // -----------------------------------------------------------------------------

   626 //

   627 static void StripQuotes( HBufC*& aString )

   628     {

   629     TInt pos1 = aString->Locate( '\"' );

   630     TInt pos2 = aString->Locate( '\'' );

   631     // check, if the first character is " or '

   632     if ( pos1 == 0 || pos2 == 0 )

   633         {

   634         TInt len = aString->Length() - 2;

   635         TPtr ptr = aString->Des();

   636         TPtrC16 newString( aString->Mid( 1, len ).Ptr(), len );

   637         ptr = newString;

   638         }

   639     }

   640 

   641 // -----------------------------------------------------------------------------

   642 // DrawRepeatBackgroundY

   643 // Draws repeated background in the vertical direction

   644 // -----------------------------------------------------------------------------

   645 //

   646 static void DrawRepeatBackgroundY(

   647     CWindowGc& aGc, TInt aYRepeatCount, CXnNode& aNode, TRect& aRect,

   648     CFbsBitmap* aBitmap, TRect aBitmapRect,

   649     TRect aImageRect, TInt& aYOffset )

   650     {

   651     for (TInt i = 0; i <= aYRepeatCount && aRect.iTl.iY < aNode.PaddingRect().iBr.iY;)

   652         {

   653         TRect newRect;

   654         newRect = TRect(

   655             aRect.iTl,

   656             TPoint(

   657                 aRect.iTl.iX + aImageRect.Width(),

   658                 aRect.iTl.iY + aImageRect.Height() ) );

   659         aGc.DrawBitmap( newRect, aBitmap, aBitmapRect );

   660         aRect.Move( 0, newRect.Height() );

   661         aYOffset += newRect.Height();

   662         if ( ++i == aYRepeatCount || aYRepeatCount == 0 )

   663             {

   664             break;

   665             }

   666         }

   667     }

   668 

   669 // -----------------------------------------------------------------------------

   670 // DrawSpaceBackgroundY

   671 // Draws spaced background in the vertical direction

   672 // -----------------------------------------------------------------------------

   673 //

   674 static void DrawSpaceBackgroundY(

   675     CWindowGc& aGc, TInt aYRepeatCount, CXnNode& aNode, TRect& aRect,

   676     CFbsBitmap* aBitmap, TRect aBitmapRect,

   677     TRect aImageRect, TInt& aYOffset )

   678     {

   679     for (TInt j = 0; j <= aYRepeatCount && aRect.iTl.iY < aNode.PaddingRect().iBr.iY;)

   680         {

   681         TRect newRect = aRect;

   682         newRect = TRect(

   683             aRect.iTl,

   684             TPoint(

   685                 aRect.iTl.iX + aImageRect.Width(),

   686                 aRect.iTl.iY + aImageRect.Height() ) );

   687         aGc.DrawBitmap( newRect, aBitmap, aBitmapRect );

   688         aRect.Move( 0, newRect.Height() );

   689         aYOffset += newRect.Height();

   690         if ( ++j == aYRepeatCount || aYRepeatCount == 0 )

   691             {

   692             break;

   693             }

   694         }

   695     }

   696 

   697 // -----------------------------------------------------------------------------

   698 // LimitRectToPaddingRect

   699 // Limits a rect so that it does not exceed padding rect

   700 // -----------------------------------------------------------------------------

   701 //

   702 static void LimitRectToPaddingRect( CXnNode& aNode, TRect& aRect )

   703     {

   704     TRect tmpRect = aNode.PaddingRect();

   705     if ( aRect.iTl.iX < tmpRect.iTl.iX )

   706         {

   707         aRect.SetRect( tmpRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY );

   708         }

   709     if ( aRect.iTl.iY < tmpRect.iTl.iY )

   710         {

   711         aRect.SetRect( aRect.iTl.iX, tmpRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY );

   712         }

   713     if ( aRect.iBr.iX > tmpRect.iBr.iX )

   714         {

   715         aRect.SetRect( aRect.iTl.iX, aRect.iTl.iY, tmpRect.iBr.iX, aRect.iBr.iY );

   716         }

   717     if ( aRect.iBr.iY > tmpRect.iBr.iY )

   718         {

   719         aRect.SetRect( aRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, tmpRect.iBr.iY );

   720         }

   721     }

   722 

   723 // -----------------------------------------------------------------------------

   724 // GetBackroundRepeatValuesL

   725 // Gets background repeat information from node properties

   726 // -----------------------------------------------------------------------------

   727 //

   728 static void GetBackroundRepeatValuesL(

   729     CXnNode& aNode,

   730     TBool& aRepeatX,

   731     TBool& aRepeatY,

   732     TBool& aSpaceX,

   733     TBool& aSpaceY )

   734     {

   735     CXnProperty* backgroundRepeatProperty = aNode.GetPropertyL(

   736         XnPropertyNames::appearance::common::KBackGroundRepeat );

   737     if ( backgroundRepeatProperty )

   738         {

   739         CXnDomList& propertyValueList =

   740             backgroundRepeatProperty->Property()->PropertyValueList();

   741         TInt valueCount = propertyValueList.Length();

   742         for ( TInt i = 0; i < valueCount; ++i )

   743             {

   744             CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >(

   745                 propertyValueList.Item( i ) );

   746             if ( value->PrimitiveValueType() == CXnDomPropertyValue::EString ||

   747                  value->PrimitiveValueType() == CXnDomPropertyValue::EIdent )

   748                 {

   749                 switch ( i )

   750                     {

   751                     case 0:

   752                         {

   753                         if ( value->StringValueL() ==

   754                              XnPropertyNames::appearance::common::backgroundrepeat::KRepeat )

   755                             {

   756                             aRepeatX = ETrue;

   757                             aRepeatY = ETrue;

   758                             }

   759                         else if ( value->StringValueL() ==

   760                                   XnPropertyNames::appearance::common::backgroundrepeat::KSpace )

   761                             {

   762                             aSpaceX = ETrue;

   763                             aSpaceY = ETrue;

   764                             }

   765                         else if ( value->StringValueL() ==

   766                                   XnPropertyNames::appearance::common::backgroundrepeat::KRepeatX )

   767                             {

   768                             aRepeatX = ETrue;

   769                             aRepeatY = EFalse;

   770                             }

   771                         else if ( value->StringValueL() ==

   772                                   XnPropertyNames::appearance::common::backgroundrepeat::KRepeatY )

   773                             {

   774                             aRepeatX = EFalse;

   775                             aRepeatY = ETrue;

   776                             }

   777                         break;

   778                         }

   779                     case 1:

   780                         {

   781                         if ( value->StringValueL() ==

   782                              XnPropertyNames::appearance::common::backgroundrepeat::KRepeat )

   783                             {

   784                             aRepeatY = ETrue;

   785                             aSpaceY = EFalse;

   786                             }

   787                         else if ( value->StringValueL() ==

   788                                   XnPropertyNames::appearance::common::backgroundrepeat::KSpace )

   789                             {

   790                             aRepeatY = EFalse;

   791                             aSpaceY = ETrue;

   792                             }

   793                         else if ( value->StringValueL() ==

   794                                   XnPropertyNames::appearance::common::backgroundrepeat::KNoRepeat )

   795                             {

   796                             aRepeatY = EFalse;

   797                             aSpaceY = EFalse;

   798                             }

   799                         break;

   800                         }

   801                     }

   802                 }

   803             }

   804         }

   805     }

   806 

   807 // -----------------------------------------------------------------------------

   808 // DrawRepeatedBackgroundImage

   809 // Draws a repeated background image

   810 // -----------------------------------------------------------------------------

   811 //

   812 static void DrawRepeatedBackgroundImage(

   813     CWindowGc& aGc,

   814     CXnNode& aNode,

   815     TRect& aRect,

   816     TRect aImageRect,

   817     TRect aBitmapRect,

   818     CFbsBitmap* aBitmap,

   819     TBool aRepeatX,

   820     TBool aRepeatY,

   821     TBool aSpaceX,

   822     TBool aSpaceY,

   823     TInt aXRepeatCount,

   824     TInt aYRepeatCount )

   825     {

   826     TRect paddingRect = aNode.PaddingRect();

   827     if ( aRepeatX && !aRepeatY && !aSpaceX && !aSpaceY )

   828         {

   829         aRect.SetRect( TPoint( paddingRect.iTl.iX, aRect.iTl.iY ), aRect.Size() );

   830         for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; )

   831             {

   832             TRect newRect = TRect(

   833                 aRect.iTl,

   834                 TPoint(

   835                     aRect.iTl.iX + aImageRect.Width(),

   836                     aRect.iTl.iY + aImageRect.Height() ) );

   837             aGc.DrawBitmap( newRect, aBitmap, aBitmapRect );

   838             aRect.Move( newRect.Width(), 0 );

   839             if ( ++i == aXRepeatCount || aXRepeatCount == 0 )

   840                 {

   841                 break;

   842                 }

   843             }

   844         }

   845     else if ( !aRepeatX && !aRepeatY && aSpaceX && !aSpaceY )

   846         {

   847         aRect.SetRect( TPoint( paddingRect.iTl.iX, aRect.iTl.iY ), aRect.Size() );

   848         if ( aImageRect.Width() < paddingRect.Width() && aXRepeatCount > 0 )

   849             {

   850             aRect.Move(

   851                 ( paddingRect.Width() - aImageRect.Width() * aXRepeatCount ) / 2,

   852                 0 );

   853             }

   854         for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; )

   855             {

   856             TRect newRect = TRect(

   857                 aRect.iTl,

   858                 TPoint(

   859                     aRect.iTl.iX + aImageRect.Width(),

   860                     aRect.iTl.iY + aImageRect.Height() ) );

   861             aGc.DrawBitmap( newRect, aBitmap, aBitmapRect );

   862             aRect.Move( newRect.Width(), 0 );

   863             if ( ++i == aXRepeatCount || aXRepeatCount == 0 )

   864                 {

   865                 break;

   866                 }

   867             }

   868         }

   869     else if ( !aRepeatX && aRepeatY && !aSpaceX && !aSpaceY )

   870         {

   871         aRect.SetRect( TPoint( aRect.iTl.iX, paddingRect.iTl.iY ), aRect.Size() );

   872         TInt yOffset = 0;

   873         DrawRepeatBackgroundY(

   874             aGc, aYRepeatCount, aNode, aRect,

   875             aBitmap, aBitmapRect,

   876             aImageRect, yOffset );

   877         }

   878     else if ( !aRepeatX && !aRepeatY && !aSpaceX && aSpaceY )

   879         {

   880         aRect.SetRect( TPoint( aRect.iTl.iX, paddingRect.iTl.iY ), aRect.Size() );

   881         if ( aImageRect.Height() < paddingRect.Height() && aYRepeatCount > 0 )

   882             {

   883             aRect.Move(

   884                 0,

   885                 ( paddingRect.Height() - aImageRect.Height() * aYRepeatCount ) / 2 );

   886             }

   887         TInt yOffset = 0;

   888         DrawSpaceBackgroundY(

   889             aGc, aYRepeatCount, aNode, aRect,

   890             aBitmap, aBitmapRect,

   891             aImageRect, yOffset );

   892         }

   893     else if ( aRepeatX && aRepeatY && !aSpaceX && !aSpaceY )

   894         {

   895         aRect.SetRect( paddingRect.iTl, aRect.Size() );

   896         TInt yOffset = 0;

   897         for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; )

   898             {

   899             aRect.Move( 0, -yOffset );

   900             yOffset = 0;

   901             TRect newRect = TRect(

   902                 aRect.iTl,

   903                 TPoint(

   904                     aRect.iTl.iX + aImageRect.Width(),

   905                     aRect.iTl.iY + aImageRect.Height() ) );

   906             aRect = newRect;

   907             DrawRepeatBackgroundY(

   908                 aGc, aYRepeatCount, aNode, aRect,

   909                 aBitmap, aBitmapRect,

   910                 aImageRect, yOffset );

   911             aRect.Move( newRect.Width(), 0 );

   912             if ( ++i == aXRepeatCount || aXRepeatCount == 0 )

   913                 {

   914                 break;

   915                 }

   916             }

   917         }

   918     else if ( !aRepeatX && !aRepeatY && aSpaceX && aSpaceY )

   919         {

   920         aRect.SetRect( paddingRect.iTl, aRect.Size() );

   921         if ( aImageRect.Width() < paddingRect.Width() && aXRepeatCount > 0 )

   922             {

   923             aRect.Move(

   924                 ( paddingRect.Width() - aImageRect.Width() * aXRepeatCount ) / 2,

   925                 0 );

   926             }

   927         if ( aImageRect.Height() < paddingRect.Height() && aYRepeatCount > 0 )

   928             {

   929             aRect.Move(

   930                 0,

   931                 ( paddingRect.Height() - aImageRect.Height() * aYRepeatCount ) / 2 );

   932             }

   933         TInt yOffset = 0;

   934         for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; )

   935             {

   936             aRect.Move( 0, -yOffset );

   937             yOffset = 0;

   938             TRect newRect = TRect(

   939                 aRect.iTl,

   940                 TPoint(

   941                     aRect.iTl.iX + aImageRect.Width(),

   942                     aRect.iTl.iY + aImageRect.Height() ) );

   943             aRect = newRect;

   944             DrawSpaceBackgroundY(

   945                 aGc, aYRepeatCount, aNode, aRect,

   946                 aBitmap, aBitmapRect,

   947                 aImageRect, yOffset );

   948             aRect.Move( newRect.Width(), 0 );

   949             if ( ++i == aXRepeatCount || aXRepeatCount == 0 )

   950                 {

   951                 break;

   952                 }

   953             }

   954         }

   955     else if ( aRepeatX && !aRepeatY && !aSpaceX && aSpaceY )

   956         {

   957         aRect.SetRect( paddingRect.iTl, aRect.Size() );

   958         if ( aImageRect.Height() < paddingRect.Height() && aYRepeatCount > 0 )

   959             {

   960             aRect.Move(

   961                 0,

   962                 ( paddingRect.Height() - aImageRect.Height() * aYRepeatCount ) / 2 );

   963             }

   964         TInt yOffset = 0;

   965         for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; )

   966             {

   967             aRect.Move( 0, -yOffset );

   968             yOffset = 0;

   969             TRect newRect = TRect(

   970                 aRect.iTl,

   971                 TPoint(

   972                     aRect.iTl.iX + aImageRect.Width(),

   973                     aRect.iTl.iY + aImageRect.Height() ) );

   974             aRect = newRect;

   975             DrawSpaceBackgroundY(

   976                 aGc, aYRepeatCount, aNode, aRect,

   977                 aBitmap, aBitmapRect,

   978                 aImageRect, yOffset );

   979             aRect.Move( newRect.Width(), 0 );

   980             if ( ++i == aXRepeatCount || aXRepeatCount == 0 )

   981                 {

   982                 break;

   983                 }

   984             }

   985         }

   986     else if ( !aRepeatX && aRepeatY && aSpaceX && !aSpaceY )

   987         {

   988         aRect.SetRect( paddingRect.iTl, aRect.Size() );

   989         TInt yOffset = 0;

   990         if ( aImageRect.Width() < paddingRect.Width() && aXRepeatCount > 0 )

   991             {

   992             aRect.Move(

   993                 ( paddingRect.Width() - aImageRect.Width() * aXRepeatCount ) / 2,

   994                 -yOffset );

   995             }

   996         for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; )

   997             {

   998             aRect.Move( 0, -yOffset );

   999             yOffset = 0;

  1000             TRect newRect = TRect(

  1001                 aRect.iTl,

  1002                 TPoint(

  1003                     aRect.iTl.iX + aImageRect.Width(),

  1004                     aRect.iTl.iY + aImageRect.Height() ) );

  1005             aRect = newRect;

  1006             DrawRepeatBackgroundY(

  1007                 aGc, aYRepeatCount, aNode, aRect,

  1008                 aBitmap, aBitmapRect,

  1009                 aImageRect, yOffset );

  1010             aRect.Move( newRect.Width(), 0 );

  1011             if ( ++i == aXRepeatCount || aXRepeatCount == 0 )

  1012                 {

  1013                 break;

  1014                 }

  1015             }

  1016        }

  1017     }

  1018 

  1019 // -----------------------------------------------------------------------------

  1020 // GetBackgroundPositionFromPropertyL

  1021 // Gets background position information from node properties

  1022 // -----------------------------------------------------------------------------

  1023 //

  1024 static TBool GetBackgroundPositionFromPropertyL(

  1025     CXnNode& aNode,

  1026     TBool aScaleImage,

  1027     TRect& aRect,

  1028     TRect aImageRect,

  1029     CFbsBitmap* aBitmap,

  1030     TBool& aHeightSet )

  1031     {

  1032     CXnProperty* backgroundPositionProperty = aNode.GetPropertyL(

  1033         XnPropertyNames::appearance::common::KBackGroundPosition );

  1034     TBool centerHorizontal = ETrue;

  1035     if ( backgroundPositionProperty )

  1036         {

  1037         CXnDomList& propertyValueList =

  1038             backgroundPositionProperty->Property()->PropertyValueList();

  1039         TSize size;

  1040         for ( TInt i = propertyValueList.Length() - 1; i >= 0; --i )

  1041             {

  1042             CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >(

  1043                 propertyValueList.Item( i ) );

  1044             if ( value->PrimitiveValueType() == CXnDomPropertyValue::EString ||

  1045                  value->PrimitiveValueType() == CXnDomPropertyValue::EIdent )

  1046                 {

  1047                 if ( aScaleImage )

  1048                     {

  1049                     size = aImageRect.Size();

  1050                     }

  1051                 else

  1052                     {

  1053                     size = aBitmap->SizeInPixels();

  1054                     }

  1055                 switch ( i )

  1056                     {

  1057                     case 0:

  1058                         {

  1059                         // StringValueL will not leave, we check the type first

  1060                         if ( value->StringValueL() ==

  1061                              XnPropertyNames::appearance::common::backgroundposition::KRight )

  1062                             {

  1063                             centerHorizontal = EFalse;

  1064                             aRect.Move( aRect.Width(), 0 );

  1065                             aRect.Move( -size.iWidth, 0 );

  1066                             }

  1067                         else if ( value->StringValueL() ==

  1068                                   XnPropertyNames::appearance::common::backgroundposition::KLeft )

  1069                             {

  1070                             centerHorizontal = EFalse;

  1071                             }

  1072                         else if ( value->StringValueL() ==

  1073                                   XnPropertyNames::appearance::common::backgroundposition::KBottom )

  1074                             {

  1075                             aHeightSet = ETrue;

  1076                             aRect.Move( 0, aRect.Height() );

  1077                             aRect.Move( 0, -size.iHeight );

  1078                             }

  1079                         else if ( value->StringValueL() ==

  1080                                   XnPropertyNames::appearance::common::backgroundposition::KTop )

  1081                             {

  1082                             aHeightSet = ETrue;

  1083                             }

  1084                         break;

  1085                         }

  1086                     case 1:

  1087                         {

  1088                         // StringValueL will not leave, we check the type first

  1089                         if ( value->StringValueL() ==

  1090                              XnPropertyNames::appearance::common::backgroundposition::KRight )

  1091                             {

  1092                             aRect.Move( aRect.Width(), 0 );

  1093                             aRect.Move( -size.iWidth, 0 );

  1094                             centerHorizontal = EFalse;

  1095                             }

  1096                         else if ( value->StringValueL() ==

  1097                                   XnPropertyNames::appearance::common::backgroundposition::KLeft )

  1098                             {

  1099                             centerHorizontal = EFalse;

  1100                             }

  1101                         else if ( value->StringValueL() ==

  1102                                   XnPropertyNames::appearance::common::backgroundposition::KBottom )

  1103                             {

  1104                             aHeightSet = ETrue;

  1105                             aRect.Move( 0, aRect.Height() );

  1106                             aRect.Move( 0, -size.iHeight );

  1107                             }

  1108                         else if ( value->StringValueL() ==

  1109                                   XnPropertyNames::appearance::common::backgroundposition::KTop )

  1110                             {

  1111                             aHeightSet = ETrue;

  1112                             }

  1113                         break;

  1114                         }

  1115                     }

  1116                 }

  1117            else if ( value->PrimitiveValueType() == CXnDomPropertyValue::EPercentage )

  1118                 {

  1119                 // FloatValueL will not leave, we check the type first

  1120                 TReal percentage = value->FloatValueL();

  1121                 if ( percentage > 100 )

  1122                     {

  1123                     percentage = 100;

  1124                     }

  1125                 TSize size = aImageRect.Size();

  1126                 switch ( i )

  1127                     {

  1128                     case 0:

  1129                         {

  1130                         TInt rectOffset = ( percentage / 100.0 ) * aRect.Width();

  1131                         TInt bitmapOffset = ( percentage / 100.0 ) * size.iWidth;

  1132                         aRect.Move( rectOffset, 0 );

  1133                         aRect.Move( -bitmapOffset, 0 );

  1134                         centerHorizontal = EFalse;