1 /*

     2 * Copyright (c) 2002 - 2007 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:  Test AknsUtils.h

    15 *

    16 */

    17 

    18 

    19 #include <aknsutils.h>

    20 #include <eikdialg.h>

    21 #include <avkon.mbg>

    22 #include <aknsitemid.h>

    23 #include <aknsitemdef.h>

    24 

    25 #include "testsdkskins.h"

    26 #include "testsdkskinscontrol.h"

    27 

    28 const TInt KLength = 10;

    29 _LIT( KMapfile, "z:\\resource\\apps\\avkon2.mbm" );

    30 

    31 // ============================ MEMBER FUNCTIONS ===============================

    32 // -----------------------------------------------------------------------------

    33 // CTestSDKSkins::TestUInitSkinSupportL

    34 // -----------------------------------------------------------------------------

    35 TInt CTestSDKSkins::TestUInitSkinSupportL( CStifItemParser& /*aItem*/ )

    36     {

    37     AknsUtils::InitSkinSupportL();

    38     

    39     return KErrNone;

    40     

    41     }

    42 

    43 // -----------------------------------------------------------------------------

    44 // CTestSDKSkins::TestUCreateDataContextForContainerL

    45 // -----------------------------------------------------------------------------

    46 TInt CTestSDKSkins::TestUCreateDataContextForContainerL( CStifItemParser& /*aItem*/ )

    47     {

    48     MAknsDataContext* context = AknsUtils::CreateDataContextForContainerL();

    49     STIF_ASSERT_NOT_NULL( context );

    50     

    51     delete context;

    52     context = NULL;

    53     

    54     return KErrNone;

    55     

    56     }

    57 

    58 // -----------------------------------------------------------------------------

    59 // CTestSDKSkins::TestUCreateBitmapItemDefL

    60 // -----------------------------------------------------------------------------

    61 TInt CTestSDKSkins::TestUCreateBitmapItemDefL( CStifItemParser& /*aItem*/ )

    62     {

    63     TAknsItemID itemID;

    64     CAknsItemDef* def = AknsUtils::CreateBitmapItemDefL( itemID, KMapfile, 0 );

    65     CleanupStack::PushL( def );

    66     STIF_ASSERT_NOT_NULL( def );

    67     

    68     CleanupStack::PopAndDestroy( def );

    69     

    70     return KErrNone;

    71     

    72     }

    73 

    74 // -----------------------------------------------------------------------------

    75 // CTestSDKSkins::TestUCreateMaskedBitmapItemDefL

    76 // -----------------------------------------------------------------------------

    77 TInt CTestSDKSkins::TestUCreateMaskedBitmapItemDefL( CStifItemParser& /*aItem*/ )

    78     {

    79     TAknsItemID itemID;

    80     CAknsItemDef* def = AknsUtils::CreateMaskedBitmapItemDefL( itemID, KMapfile, 1, 2 );

    81     CleanupStack::PushL( def );

    82     STIF_ASSERT_NOT_NULL( def );

    83     

    84     CleanupStack::PopAndDestroy( def );

    85     

    86     return KErrNone;

    87     

    88     }

    89 

    90 // -----------------------------------------------------------------------------

    91 // CTestSDKSkins::TestUSkinInstanceL

    92 // -----------------------------------------------------------------------------

    93 TInt CTestSDKSkins::TestUSkinInstanceL( CStifItemParser& /*aItem*/ )

    94     {

    95     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

    96     CleanupStack::PushL( instance );

    97     STIF_ASSERT_NOT_NULL( instance );

    98     

    99     CleanupStack::Pop( instance );

   100     

   101     return KErrNone;

   102     

   103     }

   104 

   105 // -----------------------------------------------------------------------------

   106 // CTestSDKSkins::TestUDataContextL

   107 // -----------------------------------------------------------------------------

   108 TInt CTestSDKSkins::TestUDataContextL( CStifItemParser& /*aItem*/ )

   109     {

   110     CEikDialog* dialog = new (ELeave) CEikDialog;

   111     CleanupStack::PushL( dialog );

   112     STIF_ASSERT_NOT_NULL( dialog );

   113     

   114     MAknsDataContext* context = AknsUtils::DataContext( dialog );

   115     STIF_ASSERT_NOT_NULL( context );

   116     

   117     CleanupStack::PopAndDestroy( dialog );

   118     

   119     return KErrNone;

   120     

   121     }

   122 

   123 // -----------------------------------------------------------------------------

   124 // CTestSDKSkins::TestUCreateIconML

   125 // -----------------------------------------------------------------------------

   126 TInt CTestSDKSkins::TestUCreateIconML( CStifItemParser& /*aItem*/ )

   127     {

   128     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   129     CleanupStack::PushL( instance );

   130     TAknsItemID itemID;

   131     CFbsBitmap* bitMap = NULL;

   132     CFbsBitmap* bitMapMask = NULL;

   133     

   134     AknsUtils::CreateIconL( instance, itemID, bitMap, bitMapMask, KMapfile, 

   135                             EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask );

   136     CleanupStack::PushL( bitMap );

   137     CleanupStack::PushL( bitMapMask );

   138     

   139     STIF_ASSERT_NOT_NULL( bitMap );

   140     STIF_ASSERT_NOT_NULL( bitMapMask );

   141     

   142     CleanupStack::Pop( bitMapMask );

   143     CleanupStack::Pop( bitMap );

   144     CleanupStack::Pop( instance );

   145     

   146     return KErrNone;

   147     

   148     }

   149 

   150 // -----------------------------------------------------------------------------

   151 // CTestSDKSkins::TestUCreateIconMLC

   152 // -----------------------------------------------------------------------------

   153 TInt CTestSDKSkins::TestUCreateIconMLC( CStifItemParser& /*aItem*/ )

   154     {

   155     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   156     CleanupStack::PushL( instance );

   157     TAknsItemID itemID;

   158     CFbsBitmap* bitMap = NULL;

   159     CFbsBitmap* bitMapMask = NULL;

   160     

   161     AknsUtils::CreateIconLC( instance, itemID, bitMap, bitMapMask, KMapfile, 

   162                             EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask );

   163     

   164     STIF_ASSERT_NOT_NULL( bitMap );

   165     STIF_ASSERT_NOT_NULL( bitMapMask );

   166     

   167     CleanupStack::Pop( bitMapMask );

   168     CleanupStack::Pop( bitMap );

   169     CleanupStack::Pop( instance );

   170     

   171     return KErrNone;

   172     

   173     }

   174 

   175 // -----------------------------------------------------------------------------

   176 // CTestSDKSkins::TestUCreateIconL

   177 // -----------------------------------------------------------------------------

   178 TInt CTestSDKSkins::TestUCreateIconL( CStifItemParser& /*aItem*/ )

   179     {

   180     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   181     CleanupStack::PushL( instance );

   182     TAknsItemID itemID;

   183     CFbsBitmap* bitMap = NULL;

   184     

   185     AknsUtils::CreateIconL( instance, itemID, bitMap, KMapfile, EMbmAvkonQgn_indi_mic );

   186     CleanupStack::PushL( bitMap );

   187     

   188     STIF_ASSERT_NOT_NULL( bitMap );

   189 

   190     CleanupStack::Pop( bitMap );

   191     CleanupStack::Pop( instance );

   192     

   193     return KErrNone;

   194     

   195     }

   196 

   197 // -----------------------------------------------------------------------------

   198 // CTestSDKSkins::TestUCreateIconLC

   199 // -----------------------------------------------------------------------------

   200 TInt CTestSDKSkins::TestUCreateIconLC( CStifItemParser& /*aItem*/ )

   201     {

   202     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   203     CleanupStack::PushL( instance );

   204     TAknsItemID itemID;

   205     CFbsBitmap* bitMap = NULL;

   206     

   207     AknsUtils::CreateIconLC( instance, itemID, bitMap, KMapfile, EMbmAvkonQgn_indi_mic );

   208     

   209     STIF_ASSERT_NOT_NULL( bitMap );

   210 

   211     CleanupStack::Pop( bitMap );

   212     CleanupStack::Pop( instance );

   213     

   214     return KErrNone;

   215     

   216     }

   217 

   218 // -----------------------------------------------------------------------------

   219 // CTestSDKSkins::TestUCreateMaskedBitmapL

   220 // -----------------------------------------------------------------------------

   221 TInt CTestSDKSkins::TestUCreateMaskedBitmapL( CStifItemParser& /*aItem*/ )

   222     {

   223     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   224     CleanupStack::PushL( instance );

   225     TAknsItemID itemID;

   226     

   227     CApaMaskedBitmap* bitMap = AknsUtils::CreateMaskedBitmapL( instance, itemID, KMapfile, 1, 2 );

   228     CleanupStack::PushL( bitMap );

   229     STIF_ASSERT_NOT_NULL( bitMap );

   230 

   231     CleanupStack::PopAndDestroy( bitMap );

   232     CleanupStack::Pop( instance );

   233     

   234     return KErrNone;

   235     

   236     }

   237 

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

   239 // CTestSDKSkins::TestUCreateGulIconL

   240 // -----------------------------------------------------------------------------

   241 TInt CTestSDKSkins::TestUCreateGulIconL( CStifItemParser& /*aItem*/ )

   242     {

   243     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   244     CleanupStack::PushL( instance );

   245     TAknsItemID itemID;

   246     

   247     CGulIcon* guiIcon = AknsUtils::CreateGulIconL( instance, itemID, KMapfile, 1, 2 );

   248     CleanupStack::PushL( guiIcon );

   249     STIF_ASSERT_NOT_NULL( guiIcon );

   250 

   251     CleanupStack::PopAndDestroy( guiIcon );

   252     CleanupStack::Pop( instance );

   253     

   254     return KErrNone;

   255     

   256     }

   257 

   258 // -----------------------------------------------------------------------------

   259 // CTestSDKSkins::TestUCreateAppIconLC

   260 // -----------------------------------------------------------------------------

   261 TInt CTestSDKSkins::TestUCreateAppIconLC( CStifItemParser& /*aItem*/ )

   262     {

   263     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   264     CleanupStack::PushL( instance );

   265     

   266     CFbsBitmap* bitMap = NULL;

   267     CFbsBitmap* bitMapMask = NULL;

   268     

   269     TUid uid = TUid::Uid( 0x2001CB80 );

   270     AknsUtils::CreateAppIconLC( instance, uid, EAknsAppIconTypeContext, bitMap, bitMapMask );

   271     

   272     STIF_ASSERT_NOT_NULL( bitMap );

   273     STIF_ASSERT_NOT_NULL( bitMapMask );

   274 

   275     CleanupStack::PopAndDestroy( bitMap );

   276     CleanupStack::PopAndDestroy( bitMapMask );

   277     CleanupStack::Pop( instance );

   278     

   279     return KErrNone;

   280     

   281     }

   282 

   283 // -----------------------------------------------------------------------------

   284 // CTestSDKSkins::TestUOpenAppIconFileL

   285 // -----------------------------------------------------------------------------

   286 TInt CTestSDKSkins::TestUOpenAppIconFileL( CStifItemParser& /*aItem*/ )

   287     {

   288     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   289     CleanupStack::PushL( instance );

   290     

   291     _LIT( KAppIconFile, "C:\\appicon.txt" );

   292     RFs rfs;

   293     CleanupClosePushL( rfs );

   294     User::LeaveIfError( rfs.Connect() );

   295     RFile file;

   296     CleanupClosePushL( file );

   297     file.Replace( rfs, KAppIconFile, EFileWrite );

   298     

   299     CFbsBitmap* bitMap = NULL;

   300     CFbsBitmap* bitMapMask = NULL;

   301     

   302     TUid uid = TUid::Uid( 0x2001CB80 );

   303     AknsUtils::CreateAppIconLC( instance, uid, EAknsAppIconTypeContext, bitMap, bitMapMask );

   304     

   305     CleanupStack::PopAndDestroy( bitMap );

   306     CleanupStack::PopAndDestroy( bitMapMask );

   307 

   308     AknsUtils* util = NULL;

   309     

   310     TInt flag = util->OpenAppIconFile( instance, uid, EAknsAppIconType3D, file );

   311     STIF_ASSERT_TRUE( KErrNotSupported == flag );

   312     

   313     CleanupStack::PopAndDestroy( &file );

   314     CleanupStack::PopAndDestroy( &rfs );

   315     CleanupStack::Pop( instance );

   316     

   317     return KErrNone;

   318     

   319     }

   320 

   321 // -----------------------------------------------------------------------------

   322 // CTestSDKSkins::TestUCreateColorIconL

   323 // -----------------------------------------------------------------------------

   324 TInt CTestSDKSkins::TestUCreateColorIconL( CStifItemParser& /*aItem*/ )

   325     {

   326     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   327     CleanupStack::PushL( instance );

   328     TAknsItemID itemID;

   329     TAknsItemID colorID;

   330     

   331     CFbsBitmap* bitMap = NULL;

   332     CFbsBitmap* bitMapMask = NULL;

   333     

   334     TRgb rgb = 0x00020408;

   335     

   336     AknsUtils::CreateColorIconL( instance, itemID, colorID, 0, bitMap, bitMapMask, KMapfile, 1, 2, rgb );

   337     CleanupStack::PushL( bitMap );

   338     CleanupStack::PushL( bitMapMask );

   339     

   340     STIF_ASSERT_NOT_NULL( bitMap );

   341     STIF_ASSERT_NOT_NULL( bitMapMask );

   342 

   343     CleanupStack::PopAndDestroy( bitMapMask );

   344     CleanupStack::PopAndDestroy( bitMap );

   345     CleanupStack::Pop( instance );

   346     

   347     return KErrNone;

   348     

   349     }

   350 

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

   352 // CTestSDKSkins::TestUCreateColorIconLC

   353 // -----------------------------------------------------------------------------

   354 TInt CTestSDKSkins::TestUCreateColorIconLC( CStifItemParser& /*aItem*/ )

   355     {

   356     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   357     CleanupStack::PushL( instance );

   358     TAknsItemID itemID;

   359     TAknsItemID colorID;

   360     

   361     CFbsBitmap* bitMap = NULL;

   362     CFbsBitmap* bitMapMask = NULL;

   363     

   364     TRgb rgb = 0x00020408;

   365     

   366     AknsUtils::CreateColorIconLC( instance, itemID, colorID, 0, bitMap, 

   367                                   bitMapMask, KMapfile, 1, 2, rgb );

   368     

   369     STIF_ASSERT_NOT_NULL( bitMap );

   370     STIF_ASSERT_NOT_NULL( bitMapMask );

   371 

   372     CleanupStack::PopAndDestroy( bitMapMask );

   373     CleanupStack::PopAndDestroy( bitMap );

   374     CleanupStack::Pop( instance );

   375     

   376     return KErrNone;

   377     

   378     }

   379 

   380 // -----------------------------------------------------------------------------

   381 // CTestSDKSkins::TestUCreateColorIconML

   382 // -----------------------------------------------------------------------------

   383 TInt CTestSDKSkins::TestUCreateColorIconML( CStifItemParser& /*aItem*/ )

   384     {

   385     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   386     CleanupStack::PushL( instance );

   387     TAknsItemID itemID;

   388     TAknsItemID colorID;

   389     

   390     CFbsBitmap* bitMap = NULL;

   391     CFbsBitmap* bitMapMask = NULL;

   392     

   393     TRgb rgb = 0x00020408;

   394     

   395     TSize size( KLength, KLength );

   396     

   397     AknsUtils::CreateColorIconL( instance, itemID, colorID, 0, bitMap, bitMapMask, 

   398                                  KMapfile, 1, 2, rgb, size, EAspectRatioPreserved );

   399     CleanupStack::PushL( bitMap );

   400     CleanupStack::PushL( bitMapMask );

   401     

   402     STIF_ASSERT_NOT_NULL( bitMap );

   403     STIF_ASSERT_NOT_NULL( bitMapMask );

   404 

   405     CleanupStack::PopAndDestroy( bitMapMask );

   406     CleanupStack::PopAndDestroy( bitMap );

   407     CleanupStack::Pop( instance );

   408     

   409     return KErrNone;

   410     

   411     }

   412 

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

   414 // CTestSDKSkins::TestUCreateColorIconMLC

   415 // -----------------------------------------------------------------------------

   416 TInt CTestSDKSkins::TestUCreateColorIconMLC( CStifItemParser& /*aItem*/ )

   417     {

   418     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   419     CleanupStack::PushL( instance );

   420     TAknsItemID itemID;

   421     TAknsItemID colorID;

   422     

   423     CFbsBitmap* bitMap = NULL;

   424     CFbsBitmap* bitMapMask = NULL;

   425     

   426     TRgb rgb = 0x00020408;

   427     

   428     TSize size( KLength, KLength );

   429     

   430     AknsUtils::CreateColorIconLC( instance, itemID, colorID, 0, bitMap, bitMapMask, 

   431                                   KMapfile, 1, 2, rgb, size, EAspectRatioPreserved );

   432     

   433     STIF_ASSERT_NOT_NULL( bitMap );

   434     STIF_ASSERT_NOT_NULL( bitMapMask );

   435 

   436     CleanupStack::PopAndDestroy( bitMapMask );

   437     CleanupStack::PopAndDestroy( bitMap );

   438     CleanupStack::Pop( instance );

   439     

   440     return KErrNone;

   441     

   442     }

   443 

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

   445 // CTestSDKSkins::TestUGetAppIconL

   446 // -----------------------------------------------------------------------------

   447 TInt CTestSDKSkins::TestUGetAppIconL( CStifItemParser& /*aItem*/ )

   448     {

   449     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   450     CleanupStack::PushL( instance );

   451     

   452     CApaMaskedBitmap* bitMapMask = CApaMaskedBitmap::NewLC();

   453     STIF_ASSERT_NOT_NULL( bitMapMask );

   454     

   455     TUid uid = TUid::Uid( 0x2001CB80 );

   456     TSize size( KLength, KLength );

   457     

   458     TInt flag = AknsUtils::GetAppIcon( instance, uid, size, *bitMapMask );

   459     

   460     CleanupStack::PopAndDestroy( bitMapMask );

   461     CleanupStack::Pop( instance );

   462     

   463     return KErrNone;

   464     

   465     }

   466 

   467 // -----------------------------------------------------------------------------

   468 // CTestSDKSkins::TestUCreateBitmapL

   469 // -----------------------------------------------------------------------------

   470 TInt CTestSDKSkins::TestUCreateBitmapL( CStifItemParser& /*aItem*/ )

   471     {

   472     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   473     CleanupStack::PushL( instance );

   474     

   475     CFbsBitmap* bitMap = AknsUtils::CreateBitmapL( instance, KAknsIIDQsnCpScrollBgTop );

   476     CleanupStack::PushL( bitMap );

   477     

   478     STIF_ASSERT_NOT_NULL( bitMap );

   479     

   480     CleanupStack::PopAndDestroy( bitMap );

   481     CleanupStack::Pop( instance );

   482     

   483     return KErrNone;

   484     

   485     }

   486 

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

   488 // CTestSDKSkins::TestUCreateMaskedBitmapIL

   489 // -----------------------------------------------------------------------------

   490 TInt CTestSDKSkins::TestUCreateMaskedBitmapIL( CStifItemParser& /*aItem*/ )

   491     {

   492     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   493     CleanupStack::PushL( instance );

   494     

   495     TRAP_IGNORE( AknsUtils::CreateMaskedBitmapL( instance, KAknsIIDQsnCpScrollBgTop ) );

   496     

   497     CleanupStack::Pop( instance );

   498     

   499     return KErrNone;

   500     

   501     }

   502 

   503 // -----------------------------------------------------------------------------

   504 // CTestSDKSkins::TestUCreateGulIconIL

   505 // -----------------------------------------------------------------------------

   506 TInt CTestSDKSkins::TestUCreateGulIconIL( CStifItemParser& /*aItem*/ )

   507     {

   508     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   509     CleanupStack::PushL( instance );

   510     

   511     CGulIcon* icon = AknsUtils::CreateGulIconL( instance, KAknsIIDQsnCpScrollBgTop, EFalse );

   512     CleanupStack::PushL( icon );

   513     STIF_ASSERT_NOT_NULL( icon );

   514 

   515     CleanupStack::PopAndDestroy( icon );

   516     CleanupStack::Pop( instance );

   517     

   518     return KErrNone;

   519     

   520     }

   521 

   522 // -----------------------------------------------------------------------------

   523 // CTestSDKSkins::TestUGetCachedBitmapL

   524 // -----------------------------------------------------------------------------

   525 TInt CTestSDKSkins::TestUGetCachedBitmapL( CStifItemParser& /*aItem*/ )

   526     {

   527     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   528     CleanupStack::PushL( instance );

   529     

   530     CFbsBitmap* bitMap = AknsUtils::GetCachedBitmap( instance, KAknsIIDQsnCpScrollBgTop );

   531 

   532     STIF_ASSERT_NOT_NULL( bitMap );

   533 

   534     CleanupStack::Pop( instance );

   535     

   536     return KErrNone;

   537     

   538     }

   539 

   540 // -----------------------------------------------------------------------------

   541 // CTestSDKSkins::TestUGetCachedMaskedBitmapL

   542 // -----------------------------------------------------------------------------

   543 TInt CTestSDKSkins::TestUGetCachedMaskedBitmapL( CStifItemParser& /*aItem*/ )

   544     {

   545     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   546     CleanupStack::PushL( instance );

   547     

   548     CFbsBitmap* bitMap = NULL;

   549     CFbsBitmap* bitMapMask = NULL;

   550     

   551     AknsUtils::GetCachedMaskedBitmap( instance, KAknsIIDQsnCpScrollBgTop, bitMap, bitMapMask );

   552     CleanupStack::PushL( bitMap );

   553     CleanupStack::PushL( bitMapMask );

   554     

   555     STIF_ASSERT_NOT_NULL( bitMap );

   556     STIF_ASSERT_NOT_NULL( bitMapMask );

   557 

   558     CleanupStack::Pop( bitMapMask );

   559     CleanupStack::Pop( bitMap );

   560     CleanupStack::Pop( instance );

   561     

   562     return KErrNone;

   563     

   564     }

   565 

   566 // -----------------------------------------------------------------------------

   567 // CTestSDKSkins::TestUGetCachedColorL

   568 // -----------------------------------------------------------------------------

   569 TInt CTestSDKSkins::TestUGetCachedColorL( CStifItemParser& /*aItem*/ )

   570     {

   571     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   572     CleanupStack::PushL( instance );

   573 

   574     TRgb rgb;

   575     

   576     TInt flag = AknsUtils::GetCachedColor( instance, rgb, KAknsIIDQsnComponentColors, 1 );

   577     STIF_ASSERT_TRUE( KErrNone == flag );

   578 

   579     CleanupStack::Pop( instance );

   580     

   581     return KErrNone;

   582     

   583     }

   584 

   585 // -----------------------------------------------------------------------------

   586 // CTestSDKSkins::TestUBooleanPropertyL

   587 // -----------------------------------------------------------------------------

   588 TInt CTestSDKSkins::TestUBooleanPropertyL( CStifItemParser& /*aItem*/ )

   589     {

   590     MAknsSkinInstance* instance = AknsUtils::SkinInstance();

   591     CleanupStack::PushL( instance );

   592 

   593     TRAPD( err, AknsUtils::BooleanPropertyL( instance, KAknsIIDPropertyMessageHeaderLines ) );

   594     STIF_ASSERT_TRUE( err == KErrNotFound );

   595 

   596     CleanupStack::Pop( instance );

   597     

   598     return KErrNone;

   599     

   600     }

   601 

   602 // -----------------------------------------------------------------------------

   603 // CTestSDKSkins::TestUSetAvkonSkinEnabledL

   604 // -----------------------------------------------------------------------------

   605 TInt CTestSDKSkins::TestUSetAvkonSkinEnabledL( CStifItemParser& /*aItem*/ )

   606     {

   607     AknsUtils::SetAvkonSkinEnabledL( ETrue );

   608     TBool skin = AknsUtils::AvkonSkinEnabled();

   609     STIF_ASSERT_TRUE( skin );

   610     

   611     return KErrNone;

   612     

   613     }

   614 

   615 // -----------------------------------------------------------------------------

   616 // CTestSDKSkins::TestUAvkonSkinEnabledL

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

   618 TInt CTestSDKSkins::TestUAvkonSkinEnabledL( CStifItemParser& aItem )

   619     {

   620     return TestUSetAvkonSkinEnabledL( aItem );

   621     

   622     }

   623 

   624 // -----------------------------------------------------------------------------

   625 // CTestSDKSkins::TestUSetAvkonHighlightAnimationEnabledL

   626 // -----------------------------------------------------------------------------

   627 TInt CTestSDKSkins::TestUSetAvkonHighlightAnimationEnabledL( CStifItemParser& /*aItem*/ )

   628     {

   629     AknsUtils::SetAvkonHighlightAnimationEnabledL( ETrue );

   630     TBool skin = AknsUtils::AvkonHighlightAnimationEnabled();

   631     STIF_ASSERT_TRUE( skin );

   632     

   633     return KErrNone;

   634     

   635     }

   636 

   637 // -----------------------------------------------------------------------------

   638 // CTestSDKSkins::TestUAvkonHighlightAnimationEnabledL

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

   640 TInt CTestSDKSkins::TestUAvkonHighlightAnimationEnabledL( CStifItemParser& aItem )

   641     {

   642     return TestUSetAvkonHighlightAnimationEnabledL( aItem );

   643     

   644     }

   645 

   646 // -----------------------------------------------------------------------------

   647 // CTestSDKSkins::TestURegisterControlPositionL

   648 // -----------------------------------------------------------------------------

   649 TInt CTestSDKSkins::TestURegisterControlPositionL( CStifItemParser& /*aItem*/ )

   650     {

   651     CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL();

   652     CleanupStack::PushL( control );

   653     STIF_ASSERT_NOT_NULL( control );

   654     

   655     AknsUtils::RegisterControlPosition( control );

   656     AknsUtils::DeregisterControlPosition( control );

   657     

   658     CleanupStack::PopAndDestroy( control );

   659     

   660     return KErrNone;

   661     

   662     }

   663 

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

   665 // CTestSDKSkins::TestURegisterControlPositionPL

   666 // -----------------------------------------------------------------------------

   667 TInt CTestSDKSkins::TestURegisterControlPositionPL( CStifItemParser& /*aItem*/ )

   668     {

   669     CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL();

   670     CleanupStack::PushL( control );

   671     STIF_ASSERT_NOT_NULL( control );

   672     

   673     TPoint point( KLength, KLength );

   674     TPoint pointGet;

   675     

   676     AknsUtils::RegisterControlPosition( control, point );

   677     TInt flag = AknsUtils::GetControlPosition( control, pointGet );

   678     STIF_ASSERT_TRUE( flag == KErrNone );

   679     STIF_ASSERT_TRUE( point == pointGet );

   680     AknsUtils::DeregisterControlPosition( control );

   681     

   682     CleanupStack::PopAndDestroy( control );

   683     

   684     return KErrNone;

   685     

   686     }

   687 

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

   689 // CTestSDKSkins::TestUDeregisterControlPositionL

   690 // -----------------------------------------------------------------------------

   691 TInt CTestSDKSkins::TestUDeregisterControlPositionL( CStifItemParser& aItem )

   692     {

   693     return TestURegisterControlPositionL( aItem );

   694     

   695     }

   696 

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

   698 // CTestSDKSkins::TestUGetControlPositionL

   699 // -----------------------------------------------------------------------------

   700 TInt CTestSDKSkins::TestUGetControlPositionL( CStifItemParser& aItem )

   701     {

   702     return TestURegisterControlPositionPL( aItem );

   703     

   704     }

   705 

   706