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 #ifdef RD_TACTILE_FEEDBACK

    32 #include <touchfeedback.h>

    33 #endif // RD_TACTILE_FEEDBACK

    34 

    35 // User includes

    36 #include "xnappuiadapter.h"

    37 #include "xnviewadapter.h"

    38 #include "xnviewmanager.h"

    39 #include "xncontroladapterimpl.h"

    40 #include "xncontroladapter.h"

    41 #include "xnmenuadapter.h"

    42 #include "xncomponentnodeimpl.h"

    43 #include "xntype.h"

    44 #include "xnnodepluginif.h"

    45 #include "xnuiengine.h"

    46 #include "xnviewnodeimpl.h"

    47 #include "c_xnutils.h"

    48 #include "xndomdocument.h"

    49 #include "xndomattribute.h"

    50 #include "xndomnode.h"

    51 #include "xnproperty.h"

    52 #include "xndomlist.h"

    53 #include "xnodt.h"

    54 #include "xnresource.h"

    55 #include "xnhittest.h"

    56 #include "xnplugindata.h"

    57 #include "xnnode.h"

    58 #include "xnpanic.h"

    59 #include "xnviewdata.h"

    60 #include "xnscrollablecontroladapter.h"

    61 #include "xnfocuscontrol.h"

    62 #include "xneditmode.h"

    63 

    64 _LIT8(KScrollableBoxNodeName, "scrollablebox");

    65         

    66 using namespace XnGestureHelper;

    67 #include "xngesture.h"

    68 

    69 // Constants

    70 const TInt KSkinGfxInnerRectShrink = 5;

    71 const TInt KFocusGrowValue = 3;

    72 

    73 

    74 // LOCAL FUNCTION PROTOTYPES

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

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

    77     TUint& aLightness );

    78 static void LoadFbsBitmapL(

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

    80 static void LoadMbmBitmapL( CXnResource& aResource,

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

    82 static void LoadSVGBitmapL( CXnResource& aResource,

    83     CFbsBitmap*& aBitmap, CFbsBitmap*& aBitmapMask,

    84     TRect aRect, RFs& aFsSession );

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

    86     const TDesC& aResourceFileName, TInt& aBitmapIndex,

    87     CFbsBitmap*& aTarget, CFbsBitmap*& aBitmapMask,

    88     CXnControlAdapterImpl::TIconProvider*& aIconProvider,

    89     TRect aRect, RFs& aFsSession );

    90 

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

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

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

    94     TRect aImageRect, TInt& aYOffset );

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

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

    97     TRect aImageRect, TInt& aYOffset );

    98 static void StripQuotes( HBufC*& aString );

    99 static void DrawBackgroundColorL(

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

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

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

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

   104     TRect& aRect, TRect aImageRect, TRect aBitmapRect,

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

   106     TBool aSpaceY, TInt aXRepeatCount, TInt aYRepeatCount );

   107 static TBool GetBackgroundPositionFromPropertyL(

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

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

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

   111     CFbsBitmap* aBitmap, TBool& aScaleImage );

   112 static TRgb LighterColor( const TRgb& aRgb );

   113 static TRgb DarkerColor( const TRgb& aRgb );

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

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

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

   117 static void DrawRidgeTopBorderL(

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

   119 static void DrawGrooveTopBorderL(

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

   121 static void DrawInsetTopBorder(

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

   123 static void DrawOutsetTopBorder(

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

   125 static TBool GetBorderColorL(

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

   127 static void DrawTopBorderL(

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

   129 static void DrawBottomBorderL(

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

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

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

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

   134 static void DrawRidgeBottomBorderL(

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

   136 static void DrawGrooveBottomBorderL(

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

   138 static void DrawInsetBottomBorder(

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

   140 static void DrawOutsetBottomBorder(

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

   142 static void DrawSolidLeftBorder(

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

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

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

   146 static void DrawRidgeLeftBorderL(

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

   148 static void DrawGrooveLeftBorderL(

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

   150 static void DrawInsetLeftBorder(

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

   152 static void DrawOutsetLeftBorder(

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

   154 static void DrawLeftBorderL(

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

   156 static void DrawRightBorderL(

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

   158 static void DrawSolidRightBorder(

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

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

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

   162 static void DrawRidgeRightBorderL(

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

   164 static void DrawGrooveRightBorderL(

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

   166 static void DrawInsetRightBorder(

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

   168 static void DrawOutsetRightBorder(

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

   170 static void DrawBorderImagesL(

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

   172     CFbsBitmap* aBitmap, TInt aBorderBitmapDividerTop,

   173     TInt aBorderBitmapDividerRight,

   174     TInt aBorderBitmapDividerBottom, TInt aBorderBitmapDividerLeft );

   175 static TBool IsPropertyNone( CXnProperty& aProperty );

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

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

   178     RPointerArray< CXnControlAdapter >& sortedArray );

   179 static CXnProperty* GetZIndexL( CXnControlAdapter* aAdapter );

   180 static void InsertChildToSortedArrayL(

   181     RPointerArray< CXnControlAdapter >& aTargetArray,

   182     CXnControlAdapter* aChild );

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

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

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

   186 static HBufC* GetBackgroundImagePathLC( CXnNode& aNode );

   187 static CFbsBitmap* InitializeBorderBitmapL(

   188     CXnUiEngine& aEngine, CXnNode& aNode,

   189     TInt& aBitmapIndex, TInt& aBorderBitmapDividerTop,

   190     TInt& aBorderBitmapDividerRight, TInt& aBorderBitmapDividerBottom,

   191     TInt& aBorderBitmapDividerLeft,

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

   193 static void DrawDottedBorder(

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

   195 static HBufC* GetBackgroundImageMaskPathLC( CXnNode& aNode );

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

   197 static TBool CreateGestureHelperL( CXnNode& aNode );

   198 static TInt AccessResourceFileL(

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

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

   201 static CXnDomNode* HasHoldTrigger( CXnDomNode* aNode );

   202 static void CancelFocusRefusalL( CXnUiEngine& aUiEngine );

   203     

   204 // ============================= LOCAL FUNCTIONS ===============================

   205 // -----------------------------------------------------------------------------

   206 // -----------------------------------------------------------------------------

   207 // 

   208 static CXnScrollableControlAdapter* IsChildOfScrollableControl( CXnNode& aNode )

   209     {

   210     CXnNode* parent = aNode.Parent();

   211     while( parent )

   212         {

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

   214             {

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

   216             return ret;

   217             }

   218         parent = parent->Parent();

   219         }

   220     return NULL;

   221     }

   222 

   223 // -----------------------------------------------------------------------------

   224 // SetControlContext

   225 // 

   226 // -----------------------------------------------------------------------------

   227 // 

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

   229     {

   230     CXnScrollableControlAdapter* scrollableControl = IsChildOfScrollableControl( aNode );

   231     if(scrollableControl)

   232         {

   233         aNode.SetScrollableControl(scrollableControl);

   234         aChild.CopyControlContextFrom(scrollableControl);

   235         }        

   236     }

   237 

   238 // -----------------------------------------------------------------------------

   239 // AccessResourceFileL

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

   241 // -----------------------------------------------------------------------------

   242 //

   243 static TInt AccessResourceFileL(

   244     CXnResource& aResource,

   245     RFile& aFile,

   246     RFs& aFsSession )

   247     {

   248     TInt err = KErrNone;

   249 

   250     // parse file name and extension

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

   252     TParsePtrC fileParser( fileName );

   253     TPtrC filepath = fileParser.DriveAndPath();

   254 

   255     // open resource file

   256     aFsSession.SetSessionPath( filepath );

   257     aFsSession.ShareProtected();

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

   259     if ( err != KErrNone )

   260         {

   261         aFile.Close();

   262         }

   263 

   264     return err;

   265     }

   266 

   267 // -----------------------------------------------------------------------------

   268 // LoadFbsBitmapL

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

   270 // -----------------------------------------------------------------------------

   271 //

   272 static void LoadFbsBitmapL(

   273     CXnResource& aResource,

   274     CFbsBitmap*& aTarget,

   275     RFs& aFsSession )

   276     {

   277      RFile file;

   278 

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

   280      if ( ret == KErrNone )

   281         {

   282         CleanupClosePushL( file );

   283         aTarget = new ( ELeave ) CFbsBitmap;

   284         if ( !aTarget )

   285             {

   286             CleanupStack::PopAndDestroy();

   287             return;

   288             }

   289         RFileReadStream readStream( file );

   290         CleanupClosePushL( readStream );

   291         aTarget->InternalizeL( readStream );

   292         CleanupStack::PopAndDestroy( &readStream );

   293         CleanupStack::PopAndDestroy( &file );

   294         }

   295     }

   296 

   297 // -----------------------------------------------------------------------------

   298 // LoadMifBitmapL

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

   300 // -----------------------------------------------------------------------------

   301 //

   302 static void LoadMifBitmapL(

   303     CXnResource& aResource,

   304     TInt aBitmapIndex,

   305     CFbsBitmap*& aBitmap,

   306     CFbsBitmap*& aMask,

   307     CXnControlAdapterImpl::TIconProvider*& aIconProvider,

   308     RFs& aFsSession,

   309     const TRect& aRect )

   310     {

   311     RFile file;

   312 

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

   314     if ( ret == KErrNone )

   315         {

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

   317         }

   318 

   319     if ( ret == KErrNone )

   320         {

   321         // Mask is next after bitmap

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

   323             aBitmapIndex + KMifIdFirst, aBitmapIndex + KMifIdFirst + 1 );

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

   325         }

   326     }

   327 

   328 // -----------------------------------------------------------------------------

   329 // LoadMbmBitmapL

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

   331 // -----------------------------------------------------------------------------

   332 //

   333 static void LoadMbmBitmapL(

   334     CXnResource& aResource,

   335     TInt aBitmapIndex,

   336     CFbsBitmap*& aTarget,

   337     RFs& aFsSession )

   338     {

   339     RFile file;

   340 

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

   342     if ( ret == KErrNone )

   343         {

   344         CleanupClosePushL( file );

   345         aTarget = new ( ELeave ) CFbsBitmap;

   346         aTarget->Load( file, aBitmapIndex );

   347         CleanupStack::PopAndDestroy();

   348         }

   349     }

   350 

   351 // -----------------------------------------------------------------------------

   352 // LoadSVGBitmapL

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

   354 // -----------------------------------------------------------------------------

   355 //

   356 static void LoadSVGBitmapL(

   357     CXnResource& aResource,

   358     CFbsBitmap*& aBitmap,

   359     CFbsBitmap*& aBitmapMask,

   360     TRect /*aRect*/,

   361     RFs& aFsSession )

   362     {

   363     RFile file;

   364 

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

   366     if ( ret == KErrNone )

   367         {

   368         CleanupClosePushL( file );

   369 

   370         CFbsBitmap* frameBuffer = new ( ELeave ) CFbsBitmap;

   371         CleanupStack::PushL( frameBuffer );

   372 

   373         frameBuffer->Create( TSize( 0, 0 ), EColor16M );

   374 

   375         TFontSpec fontSpec;

   376         CSvgEngineInterfaceImpl* svgEngine =

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

   378 

   379         CleanupStack::PushL( svgEngine );

   380 

   381         svgEngine->Load( file );

   382 

   383         TSize contentSize = svgEngine->ContentDimensions();

   384 

   385         TInt domHandle;

   386         svgEngine->PrepareDom( file, domHandle );

   387 

   388         svgEngine->SetSvgDimensionToFrameBuffer(

   389             contentSize.iWidth, contentSize.iHeight );

   390 

   391         CFbsBitmap* target = new ( ELeave ) CFbsBitmap;

   392         target->Create( contentSize, EColor16M );

   393         svgEngine->RenderDom( domHandle, target );

   394 

   395         aBitmap = target;

   396 

   397         CFbsBitmap* mask = new ( ELeave ) CFbsBitmap;

   398         mask->Create( contentSize, EGray256 );

   399         svgEngine->GenerateMask( mask );

   400 

   401         aBitmapMask = mask;

   402 

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

   404         }

   405     }

   406 

   407 

   408 // -----------------------------------------------------------------------------

   409 // ResolveMifIDL

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

   411 // -----------------------------------------------------------------------------

   412 //

   413 static TBool ResolveMifIDL(

   414     const TDesC& aMifId,

   415     TInt& aMifID )

   416     {

   417     HBufC* str = aMifId.AllocL();

   418     TPtr ptrMif = str->Des();

   419     ptrMif.TrimAll();

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

   421     if ( KErrNotFound != pos )

   422         {

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

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

   425         ptr.TrimAll();

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

   427         if ( KErrNotFound != offset )

   428             {

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

   430             lex.SkipSpace();

   431             lex.Val( aMifID );

   432             delete str;

   433             return ETrue;

   434             }

   435         }

   436     delete str;

   437     return EFalse;

   438     }

   439 

   440 // -----------------------------------------------------------------------------

   441 // LoadSkinBitmapL

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

   443 // -----------------------------------------------------------------------------

   444 //

   445 static TBool LoadSkinBitmapL(

   446     const TDesC& aSkinId,

   447     CFbsBitmap*& aBitmap,

   448     CFbsBitmap*& aBitmapMask,

   449     TRect aRect )

   450     {

   451     TAknsItemID itemID;

   452 

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

   454 

   455     TInt mifId( 0 );

   456 

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

   458 

   459     TInt colorIndex( KErrNotFound );

   460 

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

   462         {

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

   464             {

   465             TUid applUid;

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

   467 

   468             AknsUtils::CreateAppIconLC(

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

   470             AknIconUtils::SetSize(

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

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

   473 

   474             return ETrue;

   475             }

   476         else

   477             {

   478             TInt error( KErrNone );

   479 

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

   481             if ( colorIndex != KErrNotFound )

   482                 {

   483                 TRgb defaultColor( 0, 0, 0 );

   484 

   485                 TRAP( error, AknsUtils::CreateColorIconL(

   486                     skin, itemID, KAknsIIDQsnTextColors,

   487                     colorIndex, aBitmap, aBitmapMask,

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

   489                 }

   490             else

   491                 {

   492                 TRAP( error, AknsUtils::CreateIconL(

   493                     skin, itemID, aBitmap, aBitmapMask, KNullDesC,

   494                     mifId, mifId + 1 ) );

   495                 }

   496 

   497             if ( error != KErrNone )

   498                 {

   499                 error = KErrNone;

   500                 TRAP( error, AknsUtils::CreateIconL(

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

   502                 }

   503 

   504             if ( error == KErrNone )

   505                 {

   506                 AknIconUtils::SetSize(

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

   508 

   509                 return ETrue;

   510                 }

   511             }

   512         }

   513 

   514     if ( mifFound )

   515         {

   516         AknIconUtils::CreateIconL(

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

   518         AknIconUtils::SetSize(

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

   520 

   521         return ETrue;

   522         }

   523 

   524     return EFalse;

   525     }

   526 

   527 // -----------------------------------------------------------------------------

   528 // GetBitmap

   529 // Fetches a bitmap

   530 // -----------------------------------------------------------------------------

   531 //

   532 static TBool GetBitmapL(

   533     CXnUiEngine& aEngine,

   534     CXnNode& /*aNode*/,

   535     const TDesC& aResourceFileName,

   536     TInt& aBitmapIndex,

   537     CFbsBitmap*& aBitmap,

   538     CFbsBitmap*& aBitmapMask,

   539     CXnControlAdapterImpl::TIconProvider*& aIconProvider,

   540     TRect aRect,

   541     RFs& aFsSession )

   542     {

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

   544         {

   545         return ETrue;

   546         }

   547 

   548     CXnResource* resource( CXnUtils::FindResource(

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

   550 

   551     if ( resource )

   552         {

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

   554             {

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

   556 

   557             return ETrue;

   558             }

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

   560             {

   561             LoadMifBitmapL( *resource, aBitmapIndex, aBitmap,

   562                 aBitmapMask, aIconProvider, aFsSession, aRect );

   563 

   564             return ETrue;

   565             }

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

   567             {

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

   569 

   570             return ETrue;

   571             }

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

   573             {

   574             LoadFbsBitmapL( *resource, aBitmap, aFsSession );

   575 

   576             return ETrue;

   577             }

   578         }

   579 

   580     return EFalse;

   581     }

   582 

   583 // -----------------------------------------------------------------------------

   584 // DrawBackgroundColorL

   585 // Draws background color to the padding rect

   586 // -----------------------------------------------------------------------------

   587 //

   588 static void DrawBackgroundColorL(

   589     const TRect& /*aRect*/,

   590     CXnNode& aNode,

   591     CWindowGc& aGc )

   592     {

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

   594 

   595     if ( colorProperty )

   596         {

   597         TRect paddingRect = aNode.PaddingRect();

   598 

   599         CXnDomPropertyValue* value =

   600             static_cast< CXnDomPropertyValue* >(

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

   602 

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

   604             {

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

   606 

   607             aGc.SetPenColor( rgb );

   608 

   609             aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );

   610             aGc.SetBrushColor( rgb );

   611 

   612             aGc.DrawRect( paddingRect );

   613             }

   614         }

   615     }

   616 

   617 // -----------------------------------------------------------------------------

   618 // StripQuotes

   619 // Strips enclosing quotes from a string

   620 // -----------------------------------------------------------------------------

   621 //

   622 static void StripQuotes( HBufC*& aString )

   623     {

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

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

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

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

   628         {

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

   630         TPtr ptr = aString->Des();

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

   632         ptr = newString;

   633         }

   634     }

   635 

   636 // -----------------------------------------------------------------------------

   637 // DrawRepeatBackgroundY

   638 // Draws repeated background in the vertical direction

   639 // -----------------------------------------------------------------------------

   640 //

   641 static void DrawRepeatBackgroundY(

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

   643     CFbsBitmap* aBitmap, TRect aBitmapRect,

   644     TRect aImageRect, TInt& aYOffset )

   645     {

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

   647         {

   648         TRect newRect;

   649         newRect = TRect(

   650             aRect.iTl,

   651             TPoint(

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

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

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

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

   656         aYOffset += newRect.Height();

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

   658             {

   659             break;

   660             }

   661         }

   662     }

   663 

   664 // -----------------------------------------------------------------------------

   665 // DrawSpaceBackgroundY

   666 // Draws spaced background in the vertical direction

   667 // -----------------------------------------------------------------------------

   668 //

   669 static void DrawSpaceBackgroundY(

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

   671     CFbsBitmap* aBitmap, TRect aBitmapRect,

   672     TRect aImageRect, TInt& aYOffset )

   673     {

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

   675         {

   676         TRect newRect = aRect;

   677         newRect = TRect(

   678             aRect.iTl,

   679             TPoint(

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

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

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

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

   684         aYOffset += newRect.Height();

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

   686             {

   687             break;

   688             }

   689         }

   690     }

   691 

   692 // -----------------------------------------------------------------------------

   693 // LimitRectToPaddingRect

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

   695 // -----------------------------------------------------------------------------

   696 //

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

   698     {

   699     TRect tmpRect = aNode.PaddingRect();

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

   701         {

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

   703         }

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

   705         {

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

   707         }

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

   709         {

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

   711         }

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

   713         {

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

   715         }

   716     }

   717 

   718 // -----------------------------------------------------------------------------

   719 // GetBackroundRepeatValuesL

   720 // Gets background repeat information from node properties

   721 // -----------------------------------------------------------------------------

   722 //

   723 static void GetBackroundRepeatValuesL(

   724     CXnNode& aNode,

   725     TBool& aRepeatX,

   726     TBool& aRepeatY,

   727     TBool& aSpaceX,

   728     TBool& aSpaceY )

   729     {

   730     CXnProperty* backgroundRepeatProperty = aNode.GetPropertyL(

   731         XnPropertyNames::appearance::common::KBackGroundRepeat );

   732     if ( backgroundRepeatProperty )

   733         {

   734         CXnDomList& propertyValueList =

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

   736         TInt valueCount = propertyValueList.Length();

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

   738             {

   739             CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >(

   740                 propertyValueList.Item( i ) );

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

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

   743                 {

   744                 switch ( i )

   745                     {

   746                     case 0:

   747                         {

   748                         if ( value->StringValueL() ==

   749                              XnPropertyNames::appearance::common::backgroundrepeat::KRepeat )

   750                             {

   751                             aRepeatX = ETrue;

   752                             aRepeatY = ETrue;

   753                             }

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

   755                                   XnPropertyNames::appearance::common::backgroundrepeat::KSpace )

   756                             {

   757                             aSpaceX = ETrue;

   758                             aSpaceY = ETrue;

   759                             }

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

   761                                   XnPropertyNames::appearance::common::backgroundrepeat::KRepeatX )

   762                             {

   763                             aRepeatX = ETrue;

   764                             aRepeatY = EFalse;

   765                             }

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

   767                                   XnPropertyNames::appearance::common::backgroundrepeat::KRepeatY )

   768                             {

   769                             aRepeatX = EFalse;

   770                             aRepeatY = ETrue;

   771                             }

   772                         break;

   773                         }

   774                     case 1:

   775                         {

   776                         if ( value->StringValueL() ==

   777                              XnPropertyNames::appearance::common::backgroundrepeat::KRepeat )

   778                             {

   779                             aRepeatY = ETrue;

   780                             aSpaceY = EFalse;

   781                             }

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

   783                                   XnPropertyNames::appearance::common::backgroundrepeat::KSpace )

   784                             {

   785                             aRepeatY = EFalse;

   786                             aSpaceY = ETrue;

   787                             }

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

   789                                   XnPropertyNames::appearance::common::backgroundrepeat::KNoRepeat )

   790                             {

   791                             aRepeatY = EFalse;

   792                             aSpaceY = EFalse;

   793                             }

   794                         break;

   795                         }

   796                     }

   797                 }

   798             }

   799         }

   800     }

   801 

   802 // -----------------------------------------------------------------------------

   803 // DrawRepeatedBackgroundImage

   804 // Draws a repeated background image

   805 // -----------------------------------------------------------------------------

   806 //

   807 static void DrawRepeatedBackgroundImage(

   808     CWindowGc& aGc,

   809     CXnNode& aNode,

   810     TRect& aRect,

   811     TRect aImageRect,

   812     TRect aBitmapRect,

   813     CFbsBitmap* aBitmap,

   814     TBool aRepeatX,

   815     TBool aRepeatY,

   816     TBool aSpaceX,

   817     TBool aSpaceY,

   818     TInt aXRepeatCount,

   819     TInt aYRepeatCount )

   820     {

   821     TRect paddingRect = aNode.PaddingRect();

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

   823         {

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

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

   826             {

   827             TRect newRect = TRect(

   828                 aRect.iTl,

   829                 TPoint(

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

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

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

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

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

   835                 {

   836                 break;

   837                 }

   838             }

   839         }

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

   841         {

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

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

   844             {

   845             aRect.Move(

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

   847                 0 );

   848             }

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

   850             {

   851             TRect newRect = TRect(

   852                 aRect.iTl,

   853                 TPoint(

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

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

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

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

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

   859                 {

   860                 break;

   861                 }

   862             }

   863         }

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

   865         {

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

   867         TInt yOffset = 0;

   868         DrawRepeatBackgroundY(

   869             aGc, aYRepeatCount, aNode, aRect,

   870             aBitmap, aBitmapRect,

   871             aImageRect, yOffset );

   872         }

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

   874         {

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

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

   877             {

   878             aRect.Move(

   879                 0,

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

   881             }

   882         TInt yOffset = 0;

   883         DrawSpaceBackgroundY(

   884             aGc, aYRepeatCount, aNode, aRect,

   885             aBitmap, aBitmapRect,

   886             aImageRect, yOffset );

   887         }

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

   889         {

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

   891         TInt yOffset = 0;

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

   893             {

   894             aRect.Move( 0, -yOffset );

   895             yOffset = 0;

   896             TRect newRect = TRect(

   897                 aRect.iTl,

   898                 TPoint(

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

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

   901             aRect = newRect;

   902             DrawRepeatBackgroundY(

   903                 aGc, aYRepeatCount, aNode, aRect,

   904                 aBitmap, aBitmapRect,

   905                 aImageRect, yOffset );

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

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

   908                 {

   909                 break;

   910                 }

   911             }

   912         }

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

   914         {

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

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

   917             {

   918             aRect.Move(

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

   920                 0 );

   921             }

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

   923             {

   924             aRect.Move(

   925                 0,

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

   927             }

   928         TInt yOffset = 0;

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

   930             {

   931             aRect.Move( 0, -yOffset );

   932             yOffset = 0;

   933             TRect newRect = TRect(

   934                 aRect.iTl,

   935                 TPoint(

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

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

   938             aRect = newRect;

   939             DrawSpaceBackgroundY(

   940                 aGc, aYRepeatCount, aNode, aRect,

   941                 aBitmap, aBitmapRect,

   942                 aImageRect, yOffset );

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

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

   945                 {

   946                 break;

   947                 }

   948             }

   949         }

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

   951         {

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

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

   954             {

   955             aRect.Move(

   956                 0,

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

   958             }

   959         TInt yOffset = 0;

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

   961             {

   962             aRect.Move( 0, -yOffset );

   963             yOffset = 0;

   964             TRect newRect = TRect(

   965                 aRect.iTl,

   966                 TPoint(

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

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

   969             aRect = newRect;

   970             DrawSpaceBackgroundY(

   971                 aGc, aYRepeatCount, aNode, aRect,

   972                 aBitmap, aBitmapRect,

   973                 aImageRect, yOffset );

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

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

   976                 {

   977                 break;

   978                 }

   979             }

   980         }

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

   982         {

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

   984         TInt yOffset = 0;

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

   986             {

   987             aRect.Move(

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

   989                 -yOffset );

   990             }

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

   992             {

   993             aRect.Move( 0, -yOffset );

   994             yOffset = 0;

   995             TRect newRect = TRect(

   996                 aRect.iTl,

   997                 TPoint(

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

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

  1000             aRect = newRect;

  1001             DrawRepeatBackgroundY(

  1002                 aGc, aYRepeatCount, aNode, aRect,

  1003                 aBitmap, aBitmapRect,

  1004                 aImageRect, yOffset );

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

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

  1007                 {

  1008                 break;

  1009                 }

  1010             }

  1011        }

  1012     }

  1013 

  1014 // -----------------------------------------------------------------------------

  1015 // GetBackgroundPositionFromPropertyL

  1016 // Gets background position information from node properties

  1017 // -----------------------------------------------------------------------------

  1018 //

  1019 static TBool GetBackgroundPositionFromPropertyL(

  1020     CXnNode& aNode,

  1021     TBool aScaleImage,

  1022     TRect& aRect,

  1023     TRect aImageRect,

  1024     CFbsBitmap* aBitmap,

  1025     TBool& aHeightSet )

  1026     {

  1027     CXnProperty* backgroundPositionProperty = aNode.GetPropertyL(

  1028         XnPropertyNames::appearance::common::KBackGroundPosition );

  1029     TBool centerHorizontal = ETrue;

  1030     if ( backgroundPositionProperty )

  1031         {

  1032         CXnDomList& propertyValueList =

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

  1034         TSize size;

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

  1036             {

  1037             CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >(

  1038                 propertyValueList.Item( i ) );

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

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

  1041                 {

  1042                 if ( aScaleImage )

  1043                     {

  1044                     size = aImageRect.Size();

  1045                     }

  1046                 else

  1047                     {

  1048                     size = aBitmap->SizeInPixels();

  1049                     }

  1050                 switch ( i )

  1051                     {

  1052                     case 0:

  1053                         {

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

  1055                         if ( value->StringValueL() ==

  1056                              XnPropertyNames::appearance::common::backgroundposition::KRight )

  1057                             {

  1058                             centerHorizontal = EFalse;

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

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

  1061                             }

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

  1063                                   XnPropertyNames::appearance::common::backgroundposition::KLeft )

  1064                             {

  1065                             centerHorizontal = EFalse;

  1066                             }

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

  1068                                   XnPropertyNames::appearance::common::backgroundposition::KBottom )

  1069                             {

  1070                             aHeightSet = ETrue;

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

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

  1073                             }

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

  1075                                   XnPropertyNames::appearance::common::backgroundposition::KTop )

  1076                             {

  1077                             aHeightSet = ETrue;

  1078                             }

  1079                         break;

  1080                         }

  1081                     case 1:

  1082                         {

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

  1084                         if ( value->StringValueL() ==

  1085                              XnPropertyNames::appearance::common::backgroundposition::KRight )

  1086                             {

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

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

  1089                             centerHorizontal = EFalse;

  1090                             }

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

  1092                                   XnPropertyNames::appearance::common::backgroundposition::KLeft )

  1093                             {

  1094                             centerHorizontal = EFalse;

  1095                             }

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

  1097                                   XnPropertyNames::appearance::common::backgroundposition::KBottom )

  1098                             {

  1099                             aHeightSet = ETrue;

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

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

  1102                             }

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

  1104                                   XnPropertyNames::appearance::common::backgroundposition::KTop )

  1105                             {

  1106                             aHeightSet = ETrue;

  1107                             }

  1108                         break;

  1109                         }

  1110                     }

  1111                 }

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

  1113                 {

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

  1115                 TReal percentage = value->FloatValueL();

  1116                 if ( percentage > 100 )

  1117                     {

  1118                     percentage = 100;

  1119                     }

  1120                 TSize size = aImageRect.Size();

  1121                 switch ( i )

  1122                     {

  1123                     case 0:

  1124                         {

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

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

  1127                         aRect.Move( rectOffset, 0 );

  1128                         aRect.Move( -bitmapOffset, 0 );

  1129                         centerHorizontal = EFalse;

  1130                         break;

  1131                         }

  1132                     case 1:

  1133                         {

  1134                         aHeightSet = ETrue;