1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Drawing utility class.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "AknsCppPreface.h"

    21 

    22 #include <coecntrl.h>

    23 #include <w32std.h>

    24 #include <AknStatuspaneUtils.h>

    25 #include "layoutmetadata.cdl.h"

    26 #include "AknsDrawUtils.h"

    27 

    28 #include "AknsItemData.h"

    29 #include <AknsSkinInstance.h>

    30 #include <AknsControlContext.h>

    31 #include "AknsBackgroundLayout.h"

    32 #include <AknsImageAttributeData.h>

    33 #include "AknsAppSkinInstance.h"

    34 #include "AknsTemporaryBitmap.h"

    35 #include "AknsScalabilityUtils.h"

    36 #include <AknsLayeredBackgroundControlContext.h>

    37 #include "AknsMaskedLayerBackgroundControlContext.h"

    38 #include "AknsRlMasterLayout.h"

    39 #include "AknsRlUtils.h"

    40 

    41 

    42 #include "AknSkinsVariant.hrh"

    43 

    44 #include "AknsDebug.h"

    45 

    46 #ifdef RD_SLIDING_ANIMATION_EFFECTS

    47 _LIT(KAknsDrawUtilsSLDisabled,"ds");

    48 _LIT(KAknsDrawUtilsSLFromCBA ,"cba");

    49 _LIT(KAknsDrawUtilsSLFromL,   "l");

    50 _LIT(KAknsDrawUtilsSLFromTL,  "tl");

    51 _LIT(KAknsDrawUtilsSLFromT,   "t");

    52 _LIT(KAknsDrawUtilsSLFromTR,  "tr");

    53 _LIT(KAknsDrawUtilsSLFromR,   "r");

    54 _LIT(KAknsDrawUtilsSLFromBR,  "br");

    55 _LIT(KAknsDrawUtilsSLFromB,   "b");

    56 _LIT(KAknsDrawUtilsSLFromBl,  "bl");

    57 _LIT(KAknsDrawUtilsSLRnd,     "rnd");

    58 #endif

    59 AKNS_UNDEFINED_METHOD(AknsDrawUtils::AknsDrawUtils)

    60 

    61 // ============================= LOCAL FUNCTIONS ===============================

    62 

    63 // -----------------------------------------------------------------------------

    64 // IsSinglePart

    65 //

    66 // Checks whether the given item is a single-part image (bitmap or masked bitmap)

    67 //

    68 // Returns: ETrue or EFalse

    69 // -----------------------------------------------------------------------------

    70 //

    71 static TBool IsSinglePart(

    72     MAknsSkinInstance* aInstance, const TAknsItemID& aIID )

    73     {

    74     CAknsItemData* fdata = aInstance->GetCachedItemData(

    75         aIID, EAknsITBitmap );

    76     if( fdata )

    77         {

    78         if( fdata->Type()==EAknsITBitmap

    79             || fdata->Type()==EAknsITMaskedBitmap )

    80             {

    81             return ETrue;

    82             }

    83         }

    84     return EFalse;

    85     }

    86 

    87 // -----------------------------------------------------------------------------

    88 // RetrieveKnownBackgroundImage

    89 //

    90 // Retrieves background image item data that has a known item ID (if any)

    91 //

    92 // Returns: Pointer to cached background image, or NULL

    93 //          if none found.

    94 // -----------------------------------------------------------------------------

    95 //

    96 static CAknsImageItemData* RetrieveKnownBackgroundImage(

    97     MAknsSkinInstance* aInstance,

    98     const TAknsItemID& aIID, const TAknsBackground* aLayout = NULL )

    99     {

   100     if( !aInstance || aIID == KAknsIIDDefault || aIID == KAknsIIDNone )

   101         {

   102         return NULL;

   103         }

   104 

   105     TAknsItemID id = aIID;

   106 

   107     // special handling for main panes

   108     if (aIID == KAknsIIDQsnBgAreaMain ||

   109         aIID == KAknsIIDQsnBgAreaMainListGene ||

   110         aIID == KAknsIIDQsnBgAreaMainListSet ||

   111         aIID == KAknsIIDQsnBgAreaMainMessage)

   112         {

   113         if (AknStatuspaneUtils::FlatLayoutActive())

   114             {

   115             id = KAknsIIDQsnBgAreaMainFlat;

   116             }

   117         else if (AknStatuspaneUtils::SmallLayoutActive())

   118             {

   119             id = KAknsIIDQsnBgAreaMainSmall;

   120             }

   121         }

   122 

   123     // Special handling for popup centerpieces

   124     if( AknsRlUtils::IsPopupCenter( id )

   125         && IsSinglePart( aInstance, KAknsIIDQsnFrPopup ) )

   126         {

   127         // Frame exists and is not image table, return surrounding frame

   128         return static_cast<CAknsImageItemData*>(

   129             aInstance->GetCachedItemData( KAknsIIDQsnFrPopup, EAknsITImage ) );

   130         }

   131 

   132     CAknsItemData* idata = aInstance->GetCachedItemData( id ); //lint !e613 Always non-null

   133 

   134     if( idata && AknsUtils::IsDerivedType( EAknsITImage, idata->Type()) )

   135         {

   136         return static_cast<CAknsImageItemData*>(idata);

   137         }

   138     // Render only if...

   139     TBool doScalableRendering( EFalse );

   140 

   141     CAknsAppSkinInstance* appSkinInstance =

   142         static_cast<CAknsAppSkinInstance*>(aInstance);

   143     if( idata )

   144         {

   145         if( AknsUtils::IsDerivedType( EAknsITEffectQueue, idata->Type() ) )

   146             {

   147             // ... 1) data exists and is an effect queue or...

   148             doScalableRendering = ETrue;

   149             }

   150         else if( AknsUtils::IsDerivedType( EAknsITAnimation, idata->Type() ) )

   151             {

   152             CAknsAnimationItemData* adata =

   153                 static_cast<CAknsAnimationItemData*>( idata );

   154             if( adata->Morphing() )

   155                 {

   156                 // ... 2) data exists and is a morphing animation element...

   157                 doScalableRendering = ETrue;

   158                 }

   159             }

   160         }

   161     else 

   162         {

   163             if( (appSkinInstance->MasterLayout()->GetParent(id) != KAknsIIDDefault) )

   164             {

   165             // ...or data does not exist and there is a (definite, but possibly

   166             // non-existing) parent.

   167             doScalableRendering = ETrue;

   168             }

   169         }

   170 

   171     if( doScalableRendering )

   172         {

   173         return AknsScalabilityUtils::ConvertToBitmap(appSkinInstance, id, aLayout);

   174         }

   175 

   176     return NULL;

   177     }

   178 

   179 // -----------------------------------------------------------------------------

   180 // RetrieveBackgroundImage

   181 //

   182 // Retrieves background image item data (if any)

   183 //

   184 // Returns: Pointer to cached background image, or NULL

   185 //          if none found.

   186 // -----------------------------------------------------------------------------

   187 //

   188 static CAknsImageItemData* RetrieveBackgroundImage(

   189     MAknsSkinInstance* aInstance,

   190     const TAknsBackground* aLayout, TAknsItemID& aIID )

   191     {

   192     aIID = aLayout ? aLayout->iImageID : KAknsIIDNone;

   193     return RetrieveKnownBackgroundImage( aInstance, aIID, aLayout );

   194     }

   195 

   196 // -----------------------------------------------------------------------------

   197 // RetrieveBackgroundLayout

   198 //

   199 // Retrieves pointer (not owned) to background layout.

   200 //

   201 // Returns: Pointer to background layout, or NULL

   202 //          if none found.

   203 // -----------------------------------------------------------------------------

   204 //

   205 static TAknsBackground* RetrieveBackgroundLayout(

   206     MAknsControlContext* aContext )

   207     {

   208     if( aContext )

   209         {

   210         return static_cast<TAknsBackground*>(

   211             aContext->SupplySkinObject( EAknsCCOBackground ) );

   212         }

   213 

   214     return NULL;

   215     }

   216 

   217 // -----------------------------------------------------------------------------

   218 // GetParentAbsoluteDelta

   219 //

   220 // Calculates position delta based on parent absolute layout.

   221 // -----------------------------------------------------------------------------

   222 //

   223 static TPoint GetParentAbsoluteDelta(

   224     const TAknsBackground* aLayout,

   225     const CCoeControl* aControl )

   226     {

   227     TPoint p(0,0);

   228 

   229     if( aLayout && aLayout->iParentAbsolute && aControl )

   230         {

   231         TPoint cachedPos;

   232         if( AknsUtils::GetControlPosition( aControl, cachedPos ) == KErrNone )

   233             {

   234             p = cachedPos;

   235             }

   236         else

   237             {

   238             __ASSERT_DEBUG( aControl->DrawableWindow(),

   239                 AKNS_DEBUG_PANIC(EAknsDPanicNoWindow) );

   240 

   241             // For release build, play it safe

   242             if( !aControl->DrawableWindow() )

   243                 {

   244                 return p;

   245                 }

   246 

   247             p = aControl->PositionRelativeToScreen();

   248             }

   249 

   250         if( !aControl->OwnsWindow() )

   251             {

   252             p -= aControl->Position();

   253             }

   254 

   255         p -= aLayout->iParentPos;

   256         }

   257 

   258     return p;

   259     }

   260 

   261 // -----------------------------------------------------------------------------

   262 // DrawPartialCachedImage

   263 //

   264 // Draws the specified part of an image with layout.

   265 //

   266 // -----------------------------------------------------------------------------

   267 //

   268 static TBool DrawPartialCachedImage(

   269     MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgLayoutRect,

   270     const TRect& aTrgDrawRect, CAknsImageItemData* aImgData,

   271     const TAknsItemID& aIID, const TAknsImageAttributeData* aAttr,

   272     const TInt aDrawParam )

   273     {

   274     TRect trgLayoutRect( aTrgLayoutRect );

   275 

   276     // Adjust "faked" centerpiece region

   277     if( AknsRlUtils::IsPopupCenter(aIID)

   278         && IsSinglePart( aSkin, KAknsIIDQsnFrPopup ) )

   279         {

   280         TSize tl, br;

   281         AknsRlUtils::GetPopupFrameDimensions( tl, br );

   282 

   283         trgLayoutRect.iTl -= tl;

   284         trgLayoutRect.iBr += br;

   285         }

   286 

   287     return AknsScalabilityUtils::DrawPartialCachedImage( aSkin, aGc, trgLayoutRect,

   288         aTrgDrawRect, aImgData, aIID, aAttr, aDrawParam );

   289     }

   290 

   291 static TBool IsBackgroundItem( const TAknsItemID& aIID,CAknsAppSkinInstance* aSkin )

   292     {

   293     TBool isbg = EFalse;

   294      

   295     if( aIID.iMajor == EAknsMajorSkin)

   296         {

   297         switch (aIID.iMinor)

   298             {

   299             case EAknsMinorQsnBgScreen:

   300             case EAknsMinorQsnBgScreenIdle:

   301             case EAknsMinorQsnBgScreenMp:

   302             case EAknsMinorQsnBgAreaMain:

   303             case EAknsMinorQsnBgAreaMainAppsGrid:

   304             case EAknsMinorQsnBgAreaMainListGene:

   305             case EAknsMinorQsnBgAreaMainListSet:

   306             case EAknsMinorQsnBgAreaMainMessage:

   307             case EAknsMinorQsnBgAreaMainHigh:

   308             case EAknsMinorQsnBgAreaMainCalc:

   309             case EAknsMinorQsnBgAreaMainPinb:

   310             case EAknsMinorQsnBgAreaMainQdial:

   311             case EAknsMinorQsnBgAreaMainMp:

   312             case EAknsMinorQsnBgAreaMainFlat:

   313             case EAknsMinorQsnBgAreaMainSmall:

   314             case EAknsMinorQsnBgAreaMainIdle:

   315             case EAknsMinorQsnBgAreaMainIdleDimmed:

   316             case EAknsMinorQsnBgAreaStatus:

   317             case EAknsMinorQsnBgAreaStatusIdle:

   318             case EAknsMinorQsnBgAreaStaconRt:

   319             case EAknsMinorQsnBgAreaStaconLt:

   320             case EAknsMinorQsnBgAreaStaconRb:

   321             case EAknsMinorQsnBgAreaStaconLb:

   322             case EAknsMinorQsnBgAreaStaconRtIdle:

   323             case EAknsMinorQsnBgAreaStaconLtIdle:

   324             case EAknsMinorQsnBgAreaStaconRbIdle:

   325             case EAknsMinorQsnBgAreaStaconLbIdle:

   326             case EAknsMinorQsnBgAreaControl:

   327             case EAknsMinorQsnBgAreaControlPopup:

   328             case EAknsMinorQsnBgAreaControlMp:

   329             case EAknsMinorQsnBgAreaControlIdle:

   330             case EAknsMinorQsnBgColumn0:

   331             case EAknsMinorQsnBgColumnA:

   332             case EAknsMinorQsnBgColumnAB:

   333             case EAknsMinorQsnBgColumnC0:

   334             case EAknsMinorQsnBgColumnCA:

   335             case EAknsMinorQsnBgColumnCAB:

   336             case EAknsMinorQsnBgSliceList0:

   337             case EAknsMinorQsnBgSliceListA:

   338             case EAknsMinorQsnBgSliceListAB:

   339                 isbg = ETrue;

   340                 break;

   341             case EAknsMinorWallpaper:

   342                 {

   343                 if ( aSkin && !aSkin->WallpaperDefined() )

   344                     {

   345                     isbg = ETrue;

   346                     }

   347                 }

   348                 break;

   349             default:

   350                 break;

   351             }

   352         }

   353      else if (aIID.iMajor == EAknsMajorAvkon)

   354         {

   355         switch (aIID.iMinor)

   356             {

   357             case EAknsMinorQsnBgNavipaneSolid:

   358             case EAknsMinorQsnBgNavipaneWipe:

   359             case EAknsMinorQsnBgNavipaneSolidIdle:

   360             case EAknsMinorQsnBgNavipaneWipeIdle:

   361                 isbg = ETrue;

   362             default:

   363                 break;

   364             }

   365         }

   366     return isbg;

   367     }

   368 

   369 

   370 // -----------------------------------------------------------------------------

   371 // Blit

   372 //

   373 // Blits given image to gc.

   374 //

   375 // -----------------------------------------------------------------------------

   376 //

   377 inline static TBool Blit(

   378     MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgRect,

   379     CAknsImageItemData* aImgData, const TAknsItemID& aIID,

   380     const TAknsBackground* aLayout, const TPoint& aPADelta,

   381     const TInt aDrawParam )

   382     {

   383     CAknsAppSkinInstance* appInstance = 

   384         static_cast<CAknsAppSkinInstance*>(aSkin);

   385         

   386     if ( IsBackgroundItem( aIID,appInstance ) && 

   387             appInstance && appInstance->AnimBackgroundState() )

   388         {

   389         if( (aDrawParam&KAknsDrawParamPrepareOnly) )

   390             {

   391             return ETrue;

   392             }        

   393         

   394         TRgb color = KRgbWhite;

   395         color.SetAlpha(0x00);

   396         aGc.SetPenColor(color);

   397         aGc.SetBrushColor(color);

   398         aGc.SetPenStyle(CGraphicsContext::ESolidPen);

   399         aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

   400         aGc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

   401         TRect layoutRect( aTrgRect );

   402         if( aLayout )

   403             {

   404             layoutRect = aLayout->iRect;

   405             }

   406         layoutRect.Move( -aPADelta );

   407 

   408         TRect drawRect = aTrgRect;

   409         drawRect.Intersection( layoutRect );

   410 

   411         aGc.Clear(drawRect);

   412         return ETrue;

   413         }

   414 

   415     TRect layoutRect( aTrgRect );

   416 

   417     const TAknsImageAttributeData* attr = NULL;

   418 

   419     if( aLayout )

   420         {

   421         layoutRect = aLayout->iRect;

   422 

   423         if( aLayout->iAttr.iAttributes != EAknsImageAttributeNone )

   424             {

   425             attr = &(aLayout->iAttr);

   426             }

   427         }

   428 

   429     layoutRect.Move( -aPADelta );

   430 

   431     TRect drawRect(aTrgRect);

   432     drawRect.Intersection( layoutRect );

   433 

   434     return DrawPartialCachedImage( aSkin, aGc, layoutRect, drawRect,

   435         aImgData, aIID, attr, aDrawParam );

   436     }

   437 

   438 // -----------------------------------------------------------------------------

   439 // BlitAndClear

   440 //

   441 // Blits given image to gc and draws the area that is not

   442 // covered by the bitmap.

   443 //

   444 // -----------------------------------------------------------------------------

   445 //

   446 inline static TBool BlitAndClear(

   447     MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgRect,

   448     CAknsImageItemData* aImgData, const TAknsItemID& aIID,

   449     const TAknsBackground* aLayout, const TPoint& aPADelta,

   450     const TInt aDrawParam )

   451     {

   452     CAknsAppSkinInstance* appInstance = 

   453             static_cast<CAknsAppSkinInstance*>(aSkin);

   454             

   455     if ( IsBackgroundItem( aIID,appInstance ) && 

   456             appInstance && appInstance->AnimBackgroundState() )

   457         {

   458         return Blit( aSkin, aGc, aTrgRect, aImgData, aIID, aLayout, aPADelta, aDrawParam );

   459         }

   460     

   461     if( !(aDrawParam & KAknsDrawParamPrepareOnly) )

   462         {

   463         TAknsItemType type = aImgData->Type();

   464         // don't clear if the item is not a masked one

   465         if( AknsUtils::IsDerivedType( EAknsITMaskedBitmap, type )  

   466                 && !(aDrawParam & KAknsDrawParamNoClearUnderImage) )

   467             {

   468             TRect layoutRect( aTrgRect );

   469             if( aLayout )

   470                 {

   471                 layoutRect = aLayout->iRect;

   472                 }

   473             layoutRect.Move( -aPADelta );

   474 

   475             TRect drawRect(aTrgRect);

   476             drawRect.Intersection( layoutRect );

   477 

   478             aGc.DrawRect( drawRect );

   479             }

   480         }

   481     return Blit( aSkin, aGc, aTrgRect, aImgData, aIID, aLayout, aPADelta, aDrawParam );

   482     }

   483 

   484 // -----------------------------------------------------------------------------

   485 // CheckAndDrawCachedImage

   486 //

   487 // -----------------------------------------------------------------------------

   488 //

   489 static TBool CheckAndDrawCachedImage( MAknsSkinInstance* aSkin,

   490     CBitmapContext& aGc, const TRect& aRect, const TAknsItemID& aIID,

   491     const TInt aDrawParam )

   492     {

   493     // Basic consistency checks

   494     if( !aSkin )

   495         {

   496         return EFalse;

   497         }

   498 

   499     CAknsItemData* data = aSkin->GetCachedItemData( aIID );

   500     if( !data )

   501         {

   502         return EFalse;

   503         }

   504 

   505     if( !AknsUtils::IsDerivedType( EAknsITImage, data->Type() ) )

   506         {

   507         return EFalse;

   508         }

   509 

   510     return DrawPartialCachedImage( aSkin, aGc, aRect, aRect,

   511         static_cast<CAknsImageItemData*>(data), aIID,

   512         NULL, aDrawParam );

   513     }

   514 

   515 // -----------------------------------------------------------------------------

   516 // GetParentContext

   517 //

   518 // -----------------------------------------------------------------------------

   519 //

   520 static MAknsControlContext* GetParentContext( MAknsControlContext* aContext )

   521     {

   522     if( aContext )

   523         {

   524         return static_cast<MAknsControlContext*>(

   525             aContext->SupplySkinObject( EAknsCCOParentContext ) );

   526         }

   527     return NULL;

   528     }

   529 

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

   531 // CheckAndDrawFrame

   532 //

   533 // -----------------------------------------------------------------------------

   534 //

   535 static TBool CheckAndDrawFrame( MAknsSkinInstance* aInstance,

   536     CBitmapContext& aGc, const TRect& aOuterRect, const TRect& aInnerRect,

   537     const TAknsItemID& aFrameID, const TAknsItemID& aCenterID,

   538     const TInt aDrawParam )

   539     {

   540     if( !aInstance )

   541         {

   542         return EFalse;

   543         }

   544     

   545     if( !(aDrawParam & KAknsDrawParamPrepareOnly) )

   546         {

   547         // Prepare before drawing

   548         CheckAndDrawFrame( aInstance, aGc, aOuterRect, aInnerRect,

   549             aFrameID, aCenterID, aDrawParam|KAknsDrawParamPrepareOnly );

   550         }

   551 

   552     CAknsImageItemData* rawData = static_cast<CAknsImageItemData*>(

   553         aInstance->GetCachedItemData( aFrameID, EAknsITImage ) );

   554     if( !rawData )

   555         {

   556         return EFalse;

   557         }

   558 

   559     if (!(aDrawParam & KAknsDrawParamPrepareOnly))

   560         {

   561         aGc.SetPenStyle(CGraphicsContext::ENullPen);

   562         aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

   563         }

   564 

   565     TBool retVal = EFalse;

   566 

   567     if( AknsUtils::IsDerivedType( EAknsITImageTable, rawData->Type() ) )

   568         {

   569         CAknsImageTableItemData* data =

   570             static_cast<CAknsImageTableItemData*>(rawData);

   571         if( data->NumberOfImages() != EAknsFrameElementsN )

   572             {

   573             return EFalse;

   574             }

   575 

   576         // Corners

   577         retVal |= CheckAndDrawCachedImage( aInstance, aGc,

   578             TRect( aOuterRect.iTl, aInnerRect.iTl ),

   579             data->ImageIID( EAknsFrameIndexTl ), aDrawParam );

   580         retVal |= CheckAndDrawCachedImage( aInstance, aGc,

   581             TRect( aInnerRect.iBr.iX, aOuterRect.iTl.iY,

   582             aOuterRect.iBr.iX, aInnerRect.iTl.iY ),

   583             data->ImageIID( EAknsFrameIndexTr ), aDrawParam );

   584         retVal |= CheckAndDrawCachedImage( aInstance, aGc,

   585             TRect( aOuterRect.iTl.iX, aInnerRect.iBr.iY,

   586             aInnerRect.iTl.iX, aOuterRect.iBr.iY ),

   587             data->ImageIID( EAknsFrameIndexBl ), aDrawParam );

   588         retVal |= CheckAndDrawCachedImage( aInstance, aGc,

   589             TRect( aInnerRect.iBr, aOuterRect.iBr ),

   590             data->ImageIID( EAknsFrameIndexBr ), aDrawParam );

   591 

   592         // Sides

   593         TRect sideRect( aInnerRect.iTl.iX, aOuterRect.iTl.iY,

   594             aInnerRect.iBr.iX, aInnerRect.iTl.iY );

   595         retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,

   596             data->ImageIID( EAknsFrameIndexT ), aDrawParam );

   597         sideRect.SetRect( aInnerRect.iTl.iX, aInnerRect.iBr.iY,

   598             aInnerRect.iBr.iX, aOuterRect.iBr.iY );

   599         retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,

   600             data->ImageIID( EAknsFrameIndexB ), aDrawParam );

   601         sideRect.SetRect( aOuterRect.iTl.iX, aInnerRect.iTl.iY,

   602             aInnerRect.iTl.iX, aInnerRect.iBr.iY );

   603         retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,

   604             data->ImageIID( EAknsFrameIndexL ), aDrawParam );

   605         sideRect.SetRect( aInnerRect.iBr.iX, aInnerRect.iTl.iY,

   606             aOuterRect.iBr.iX, aInnerRect.iBr.iY );

   607         retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,

   608             data->ImageIID( EAknsFrameIndexR ), aDrawParam );

   609 

   610         // Center

   611         //lint --e{961} Valid logic

   612         if( aCenterID == KAknsIIDDefault )

   613             {

   614             retVal |= CheckAndDrawCachedImage( aInstance, aGc, aInnerRect,

   615                 data->ImageIID( EAknsFrameIndexCenter ), aDrawParam );

   616             }

   617         else if( aCenterID != KAknsIIDNone )

   618             {

   619             retVal |= CheckAndDrawCachedImage( aInstance, aGc, aInnerRect,

   620                 aCenterID, aDrawParam );

   621             }

   622         }

   623     else if( AknsUtils::IsDerivedType( EAknsITBitmap, rawData->Type() ) )

   624         {

   625         // Center only

   626         retVal |= CheckAndDrawCachedImage( aInstance, aGc, aOuterRect,

   627             aFrameID, aDrawParam );

   628         }

   629 

   630     if (!(aDrawParam & KAknsDrawParamPrepareOnly))

   631         {

   632         aGc.SetPenStyle(CGraphicsContext::ESolidPen); //lint !e961 Intentional

   633         aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

   634         }

   635     return retVal;

   636     }

   637 

   638 

   639 // ============================ MEMBER FUNCTIONS ===============================

   640 

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

   642 // AknsDrawUtils::ControlContext()

   643 // (commented in the header).

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

   645 //

   646 AKNS_EXPORTED_METHOD(AknsDrawUtils::ControlContext)

   647 EXPORT_C MAknsControlContext* AknsDrawUtils::ControlContext(

   648     const MObjectProvider* aMop )

   649     {

   650     MAknsControlContext* cc = NULL;

   651     if( aMop )

   652         {

   653         const_cast<MObjectProvider*>(aMop)->MopGetObject( cc );

   654         }

   655 

   656     return cc;

   657     }

   658 

   659 // -----------------------------------------------------------------------------

   660 // AknsDrawUtils::ControlContextOfParent()

   661 // (commented in the header).

   662 // -----------------------------------------------------------------------------

   663 //

   664 AKNS_EXPORTED_METHOD(AknsDrawUtils::ControlContextOfParent)

   665 EXPORT_C MAknsControlContext* AknsDrawUtils::ControlContextOfParent(

   666     const CCoeControl* aControl )

   667     {

   668     MObjectProvider* parentMop = NULL;

   669     if( aControl )

   670         {

   671         // Bypass private qualifier of iMopParent member of CCoeControl

   672         const TUint8* mopParentPointerLocation =

   673             reinterpret_cast<const TUint8*>(aControl);

   674         mopParentPointerLocation += sizeof( CCoeControl );

   675         mopParentPointerLocation -= sizeof( MObjectProvider* );

   676         TInt mopParentPointer =

   677             *reinterpret_cast<const TInt*>( mopParentPointerLocation ); //lint !e826 Intentionally ugly

   678         // Check alignment

   679         __ASSERT_DEBUG( !(mopParentPointer&3),

   680             AKNS_DEBUG_PANIC(EAknsDPanicBadAlignment));

   681         parentMop = reinterpret_cast<MObjectProvider*>(

   682             mopParentPointer );

   683         }

   684 

   685     return ControlContext( parentMop );

   686     }

   687 

   688 // -----------------------------------------------------------------------------

   689 // AknsDrawUtils::Background()

   690 // (commented in the header).

   691 // -----------------------------------------------------------------------------

   692 //

   693 AKNS_EXPORTED_METHOD(AknsDrawUtils::Background)

   694 EXPORT_C TBool AknsDrawUtils::Background( MAknsSkinInstance* aInstance,

   695     MAknsControlContext* aContext, CWindowGc& aGc, const TRect& aRect )

   696     {

   697     return Background( aInstance, aContext, NULL, aGc, aRect );

   698     }

   699 

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

   701 // AknsDrawUtils::Background()

   702 // (commented in the header).

   703 // -----------------------------------------------------------------------------

   704 //

   705 EXPORT_C TBool AknsDrawUtils::Background( MAknsSkinInstance* aInstance,

   706     MAknsControlContext* aContext, const CCoeControl* aControl,

   707     CWindowGc& aGc, const TRect& aRect )

   708     {

   709     return Background( aInstance, aContext, aControl, aGc, aRect,

   710         KAknsDrawParamDefault );

   711     }

   712 

   713 // -----------------------------------------------------------------------------

   714 // AknsDrawUtils::Background()

   715 // (commented in the header).

   716 // -----------------------------------------------------------------------------

   717 //

   718 EXPORT_C TBool AknsDrawUtils::Background( MAknsSkinInstance* aInstance,

   719     MAknsControlContext* aContext, const CCoeControl* aControl,

   720     CWindowGc& aGc, const TRect& aRect, const TInt aDrawParam )

   721     {

   722     return DrawBackground( aInstance, aContext, aControl,

   723         aGc, aRect.iTl, aRect, aDrawParam );

   724     }

   725 

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

   727 // AknsDrawUtils::DrawBackground()

   728 // (commented in the header).

   729 // -----------------------------------------------------------------------------

   730 EXPORT_C TBool AknsDrawUtils::DrawBackground( MAknsSkinInstance* aInstance,

   731     MAknsControlContext* aContext, const CCoeControl* aControl,

   732     CBitmapContext& aGc, const TPoint& aDstPos,

   733     const TRect& aControlRect, const TInt aDrawParam )

   734     {

   735     TInt drawParam = aDrawParam;

   736     TInt originalParam = aDrawParam;

   737     TBool retVal = EFalse;

   738     TBool blitFailed = EFalse;

   739     TBool blit = EFalse;

   740     TBool blitAttempted = EFalse;

   741 

   742     if ( !&aGc )

   743         {

   744         return retVal;

   745         }

   746 

   747     MAknsControlContext* parentContext = GetParentContext( aContext );

   748     if( parentContext )

   749         {

   750         retVal = DrawBackground( aInstance, parentContext, aControl, aGc,

   751             aDstPos, aControlRect, aDrawParam );

   752         drawParam |= KAknsDrawParamNoClearUnderImage;

   753         }

   754     else if( drawParam & KAknsDrawParamBottomLevelRGBOnly )

   755         {

   756         drawParam |= KAknsDrawParamRGBOnly;

   757         }

   758 

   759     originalParam = drawParam;

   760 

   761     if( aContext )

   762         {

   763         aContext->UpdateContext();

   764         }

   765 

   766     TAknsBackground* bgLayout = RetrieveBackgroundLayout( aContext );

   767 

   768     TAknsItemID imgIID( KAknsIIDNone );

   769     CAknsImageItemData* imgData = RetrieveBackgroundImage(

   770         aInstance, bgLayout, imgIID );

   771 

   772     // chained background

   773     if (imgData && imgData->ParentIID() != KAknsIIDNone)

   774         {

   775         TAknsItemID parentiid = imgData->ParentIID();

   776         TRect parentDrawRect = imgData->DrawRect();

   777 

   778         imgData = RetrieveKnownBackgroundImage(

   779             aInstance, parentiid );

   780         if (imgData)

   781             {

   782             imgData->SetDrawRect(parentDrawRect);

   783             drawParam |= KAknsDrawParamChained ;

   784             }

   785         }

   786 

   787     TPoint paDelta = GetParentAbsoluteDelta( bgLayout, aControl );

   788 

   789     TRect drawRect = aControlRect;

   790     drawRect.Move( aDstPos-aControlRect.iTl );

   791     paDelta += aControlRect.iTl-aDstPos;

   792 

   793     if (!(aDrawParam & KAknsDrawParamPrepareOnly))

   794         {

   795         aGc.SetPenStyle(CGraphicsContext::ENullPen);

   796         aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

   797         }

   798 

   799     if ( !(aDrawParam & KAknsDrawParamIgnoreLayerMask))

   800         {

   801         if( imgData )

   802             {

   803             blitAttempted = ETrue;

   804             if( (drawParam&KAknsDrawParamNoClearUnderImage)==0 )

   805                 {

   806                 blit = BlitAndClear( aInstance, aGc, drawRect,

   807                     imgData, imgIID, bgLayout, paDelta, drawParam );

   808                 }

   809             else

   810                 {

   811                 blit = Blit( aInstance, aGc, drawRect,

   812                     imgData, imgIID, bgLayout, paDelta, drawParam );

   813                 }

   814             if ( !blit )

   815                 {

   816                 blitFailed = ETrue;

   817                 }

   818             }

   819         else

   820             {

   821             if( !(drawParam&KAknsDrawParamNoClearUnderImage) &&

   822                 !(drawParam&KAknsDrawParamPrepareOnly) )

   823                 {

   824                 // Clear only if permitted

   825                 aGc.DrawRect( drawRect );

   826                 }

   827             }

   828         }

   829 

   830     if( bgLayout )

   831         {

   832         if (!(aDrawParam & KAknsDrawParamIgnoreLayerMask) && aContext->IsCompatibleWithType(EAknsControlContextTypeMasked))

   833             {

   834             CAknsMaskedLayerBackgroundControlContext* layeredCxt = static_cast<CAknsMaskedLayerBackgroundControlContext*>(aContext);

   835             if (layeredCxt->iOffScreenBmp)

   836                 {

   837                 CAknsMaskedBitmapItemData* maskedImgData = NULL;

   838                 TRAPD( err, maskedImgData = CAknsMaskedBitmapItemData::NewL() );

   839                 if ( err != KErrNone )

   840                     {

   841                     return EFalse;

   842                     }

   843                 maskedImgData->SetBitmap(layeredCxt->iOffScreenBmp);

   844                 maskedImgData->SetMask(layeredCxt->iLayerMask);

   845 

   846                 TAknsBackground* childLayout = bgLayout->iNext;

   847 

   848                 blitAttempted = ETrue;

   849                 blit = Blit( aInstance, aGc, drawRect, maskedImgData,

   850                     KAknsIIDNone, childLayout, paDelta, drawParam );

   851                 if ( !blit )

   852                     {

   853                     blitFailed = ETrue;

   854                     }

   855 

   856                 maskedImgData->SetBitmap(NULL);

   857                 maskedImgData->SetMask(NULL);

   858                 delete maskedImgData;

   859                 if (!(aDrawParam & KAknsDrawParamPrepareOnly))

   860                     {

   861                     aGc.SetPenStyle(CGraphicsContext::ESolidPen);

   862                     aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

   863                     }

   864                 retVal = !blitFailed;

   865                 return retVal;

   866                 }

   867             }

   868 

   869         if (!aContext->IsCompatibleWithType(EAknsControlContextTypeFrame))

   870             {

   871             // special handling for frames

   872             drawParam|=KAknsDrawParamNoClearUnderImage;

   873             originalParam|=KAknsDrawParamNoClearUnderImage;

   874             }

   875         TAknsBackground* nextLayout = bgLayout->iNext;

   876         while( nextLayout &&

   877             ((drawParam & KAknsDrawParamLimitToFirstLevel) == 0) )

   878             {

   879             imgData = RetrieveKnownBackgroundImage( aInstance,

   880                 nextLayout->iImageID );

   881             if (imgData && imgData->ParentIID() != KAknsIIDNone)

   882                 {

   883                 TAknsItemID parentiid = imgData->ParentIID();

   884                 TRect parentDrawRect = imgData->DrawRect();

   885 

   886                 imgData = RetrieveKnownBackgroundImage(

   887                     aInstance, parentiid );

   888                 if (imgData)

   889                     {

   890                     imgData->SetDrawRect(parentDrawRect);

   891                     drawParam |= KAknsDrawParamChained ;

   892                     }

   893                 }

   894             else

   895                 {

   896                 drawParam=originalParam;

   897                 }

   898             if( imgData )

   899                 {

   900                 blitAttempted = ETrue;

   901                 blit = BlitAndClear( aInstance, aGc, drawRect, imgData,

   902                     nextLayout->iImageID, nextLayout, paDelta, drawParam );

   903                 if ( !blit )

   904                     {

   905                     blitFailed = ETrue;

   906                     }

   907                 }

   908             nextLayout = nextLayout->iNext;

   909             }

   910         }

   911 

   912     if (!(aDrawParam & KAknsDrawParamPrepareOnly))

   913         {

   914         aGc.SetPenStyle(CGraphicsContext::ESolidPen);

   915         aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

   916         }

   917 

   918     // If Blit failed, or was not even attempted => return EFalse

   919     if ( blitFailed )

   920         {

   921         retVal = EFalse;

   922         }

   923     else if ( !retVal )

   924         {

   925         retVal = blitAttempted;

   926         }

   927 

   928     return retVal;

   929     }

   930 

   931 // -----------------------------------------------------------------------------

   932 // AknsDrawUtils::BackgroundBetweenRects()

   933 // (commented in the header).

   934 // -----------------------------------------------------------------------------

   935 //

   936 AKNS_EXPORTED_METHOD(AknsDrawUtils::BackgroundBetweenRects)

   937 EXPORT_C TBool AknsDrawUtils::BackgroundBetweenRects(

   938     MAknsSkinInstance* aInstance,

   939     MAknsControlContext* aContext, CWindowGc& aGc,

   940     const TRect& aOuterRect,const TRect& aInnerRect )

   941     {

   942     return BackgroundBetweenRects( aInstance, aContext, NULL, aGc, aOuterRect,

   943         aInnerRect );

   944     }

   945 

   946 // -----------------------------------------------------------------------------

   947 // AknsDrawUtils::BackgroundBetweenRects()

   948 // (commented in the header).

   949 // -----------------------------------------------------------------------------

   950 //

   951 EXPORT_C TBool AknsDrawUtils::BackgroundBetweenRects(

   952     MAknsSkinInstance* aInstance, MAknsControlContext* aContext,

   953     const CCoeControl* aControl, CWindowGc& aGc,

   954     const TRect& aOuterRect,const TRect& aInnerRect )

   955     {

   956     return BackgroundBetweenRects( aInstance, aContext, aControl, aGc,

   957         aOuterRect, aInnerRect, KAknsDrawParamDefault );

   958     }

   959 

   960 // -----------------------------------------------------------------------------

   961 // AknsDrawUtils::BackgroundBetweenRects()

   962 // (commented in the header).

   963 // -----------------------------------------------------------------------------

   964 //

   965 EXPORT_C TBool AknsDrawUtils::BackgroundBetweenRects(

   966     MAknsSkinInstance* aInstance, MAknsControlContext* aContext,

   967     const CCoeControl* aControl, CWindowGc& aGc,

   968     const TRect& aOuterRect,const TRect& aInnerRect, const TInt aDrawParam )

   969     {

   970     TInt drawParam = aDrawParam;

   971     TInt originalParam = aDrawParam;

   972     TBool retVal = EFalse;

   973     TBool blitFailed = EFalse;

   974     TBool blitAttempted = EFalse;

   975 

   976     if ( !&aGc )

   977         {

   978         return retVal;

   979         }

   980 

   981     MAknsControlContext* parentContext = GetParentContext( aContext );

   982     if( parentContext )

   983         {

   984         retVal = BackgroundBetweenRects( aInstance, parentContext, aControl, aGc,

   985             aOuterRect, aInnerRect, aDrawParam );

   986         drawParam |= KAknsDrawParamNoClearUnderImage;

   987         }

   988     else if( drawParam & KAknsDrawParamBottomLevelRGBOnly )

   989         {

   990         drawParam |= KAknsDrawParamRGBOnly;

   991         }

   992 

   993     originalParam = drawParam;

   994 

   995     if( aContext )

   996         {

   997         aContext->UpdateContext();

   998         }

   999 

  1000     TAknsBackground* bgLayout = RetrieveBackgroundLayout( aContext );

  1001 

  1002     TAknsItemID imgIID( KAknsIIDNone );

  1003     CAknsImageItemData* imgData = RetrieveBackgroundImage(

  1004         aInstance, bgLayout, imgIID );

  1005 

  1006     // chained background

  1007     if (imgData && imgData->ParentIID() != KAknsIIDNone)

  1008         {

  1009         TAknsItemID parentiid = imgData->ParentIID();

  1010         TRect parentDrawRect = imgData->DrawRect();

  1011 

  1012         imgData = RetrieveKnownBackgroundImage(

  1013             aInstance, parentiid );

  1014         if (imgData)

  1015             {

  1016             imgData->SetDrawRect(parentDrawRect);

  1017             drawParam |= KAknsDrawParamChained ;

  1018             }

  1019         }

  1020 

  1021     TPoint paDelta = GetParentAbsoluteDelta( bgLayout, aControl );

  1022 

  1023     if (!(aDrawParam & KAknsDrawParamPrepareOnly))

  1024         {

  1025         aGc.SetPenStyle(CGraphicsContext::ENullPen);

  1026         aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

  1027         }

  1028 

  1029     TBool blit = EFalse;

  1030     //Rect for frame border

  1031     TRect rlist[4];

  1032     rlist[0] = aOuterRect;

  1033     rlist[0].iBr.iY=aInnerRect.iTl.iY;

  1034     rlist[1] = rlist[0];

  1035     rlist[1].iBr.iY=aOuterRect.iBr.iY;

  1036     rlist[1].iTl.iY=aInnerRect.iBr.iY;

  1037     rlist[2] = aInnerRect;

  1038     rlist[2].iTl.iX=aOuterRect.iTl.iX;

  1039     rlist[2].iBr.iX=aInnerRect.iTl.iX;

  1040     rlist[3] = rlist[2];

  1041     rlist[3].iTl.iX=aInnerRect.iBr.iX;

  1042     rlist[3].iBr.iX=aOuterRect.iBr.iX;

  1043     if( imgData )

  1044         {        

  1045         blitAttempted = ETrue;

  1046         for ( TInt i=0; i <4 ; i++ )

  1047             {

  1048             if( (drawParam & KAknsDrawParamNoClearUnderImage) == 0 )

  1049                 {            

  1050                 blit = BlitAndClear( aInstance, aGc, rlist[i],

  1051                         imgData, imgIID, bgLayout, paDelta, drawParam );

  1052                 }

  1053             else

  1054                 {

  1055                 blit = Blit( aInstance, aGc, rlist[i],

  1056                         imgData, imgIID, bgLayout, paDelta, drawParam );

  1057                 }

  1058             if ( !blit )

  1059                 {

  1060                 blitFailed = ETrue;

  1061                 }

  1062             }

  1063         }

  1064     else

  1065         {

  1066         if( !(drawParam & KAknsDrawParamNoClearUnderImage) &&

  1067             !(drawParam & KAknsDrawParamPrepareOnly) )

  1068             {

  1069             // Clear only if permitted

  1070             for (TInt i=0; i<4; i++)

  1071                 {

  1072                 aGc.DrawRect(rlist[i]);

  1073                 }

  1074             }

  1075         }

  1076 

  1077     if( bgLayout )

  1078         {

  1079         TAknsBackground* nextLayout = bgLayout->iNext;

  1080         while( nextLayout && (drawParam!=KAknsDrawParamLimitToFirstLevel) )

  1081             {

  1082             imgData = RetrieveKnownBackgroundImage( aInstance,

  1083                 nextLayout->iImageID );

  1084             if (imgData && imgData->ParentIID() != KAknsIIDNone)

  1085                 {

  1086                 TAknsItemID parentiid = imgData->ParentIID();

  1087                 TRect parentDrawRect = imgData->DrawRect();

  1088 

  1089                 imgData = RetrieveKnownBackgroundImage(

  1090                 aInstance, parentiid );

  1091                 if (imgData)

  1092                     {

  1093                     imgData->SetDrawRect(parentDrawRect);

  1094                     drawParam |= KAknsDrawParamChained;

  1095                     }

  1096                 }

  1097             else

  1098                 {

  1099                 drawParam=originalParam;

  1100                 }

  1101 

  1102             if( imgData )

  1103                 {                

  1104                 blitAttempted = ETrue;

  1105                 for ( TInt i=0; i < 4; i++ )

  1106                     {

  1107                     blit = Blit( aInstance, aGc, rlist[i], imgData,

  1108                             nextLayout->iImageID, nextLayout, paDelta, drawParam );

  1109                     if ( !blit )

  1110                         {

  1111                         blitFailed = ETrue;

  1112                         }

  1113                     }

  1114                 }

  1115 

  1116             nextLayout = nextLayout->iNext;

  1117             }

  1118         }

  1119 

  1120     if (!(aDrawParam & KAknsDrawParamPrepareOnly))

  1121         {

  1122         aGc.SetPenStyle(CGraphicsContext::ESolidPen);

  1123         aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

  1124         }

  1125 

  1126     if ( blitFailed )

  1127         {

  1128         retVal = EFalse;

  1129         }

  1130     else if ( !retVal )

  1131         {

  1132         retVal = blitAttempted;

  1133         }

  1134