1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  test aknpictographinterface.h

    15                       akniconsrvclient.h

    16                       akniconutils.h

    17                       akninternaliconutils.h

    18 *

    19 */

    20 

    21 

    22 

    23 #include <stifparser.h>

    24 #include <akniconutils.h>

    25 #include <avkon.mbg>

    26 #include <aknsutils.h>

    27 

    28 #include "testsdkpictograph.h"

    29 #include "akniconutilsext.h"

    30 

    31 // CONSTANTS

    32 const TInt KIconWidth = 32;

    33 const TInt KIconHeight = 32;

    34 const TInt KAngle = 30;

    35 

    36 // ============================ MEMBER FUNCTIONS ===============================

    37 

    38 // -----------------------------------------------------------------------------

    39 // CTestSDKPicToGraph::TestDimenDefCons

    40 // -----------------------------------------------------------------------------

    41 //

    42 TInt CTestSDKPicToGraph::TestDimenDefCons( CStifItemParser& /*aItem*/ )

    43     {

    44 

    45     // Print to UI

    46     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

    47     _LIT( KTestDimenDefCons, "In IconUtils DimenDefCons" );

    48     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestDimenDefCons );

    49     // Print to log file

    50     iLog->Log( KTestDimenDefCons );

    51 

    52     TAknContentDimensions dimen;

    53 

    54     return KErrNone;

    55 

    56     }

    57 

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

    59 // CTestSDKPicToGraph::TestDimenConstruct

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

    61 //

    62 TInt CTestSDKPicToGraph::TestDimenConstruct( CStifItemParser& /*aItem*/ )

    63     {

    64 

    65     // Print to UI

    66     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

    67     _LIT( KTestDimenConstruct, "In IconUtils DimenConstruct" );

    68     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestDimenConstruct );

    69     // Print to log file

    70     iLog->Log( KTestDimenConstruct );

    71 

    72     TAknContentDimensions dimen( KIconWidth, KIconHeight );

    73 

    74     return KErrNone;

    75 

    76     }

    77 

    78 // -----------------------------------------------------------------------------

    79 // CTestSDKPicToGraph::TestDimenSetDimen

    80 // -----------------------------------------------------------------------------

    81 //

    82 TInt CTestSDKPicToGraph::TestDimenSetDimen( CStifItemParser& aItem )

    83     {

    84 

    85     // Print to UI

    86     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

    87     _LIT( KTestDimenSetDimen, "In IconUtils DimenSetDimen" );

    88     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestDimenSetDimen );

    89     // Print to log file

    90     iLog->Log( KTestDimenSetDimen );

    91 

    92     TInt num = 0;

    93     TInt err = aItem.GetNextInt( num );

    94     if ( err != KErrNone )

    95         {

    96         return err;

    97         }

    98 

    99     TAknContentDimensions dimen;

   100     switch( num )

   101     {

   102     case 1:

   103         dimen.SetDimensions( KIconWidth, KIconHeight );

   104         break;

   105     case 2:

   106         TSize iconSize( KIconWidth, KIconHeight );

   107         dimen.SetDimensions( iconSize );

   108         break;

   109     }

   110 

   111     return KErrNone;

   112 

   113     }

   114 

   115 // -----------------------------------------------------------------------------

   116 // CTestSDKPicToGraph::TestIconNewL

   117 // -----------------------------------------------------------------------------

   118 //

   119 TInt CTestSDKPicToGraph::TestIconNewL( CStifItemParser& /*aItem*/ )

   120     {

   121 

   122     // Print to UI

   123     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   124     _LIT( KTestIconNewL, "In IconUtils IconNewL" );

   125     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestIconNewL );

   126     // Print to log file

   127     iLog->Log( KTestIconNewL );

   128 

   129     CAknIcon* icon = CAknIcon::NewL();

   130     CleanupStack::PushL( icon );

   131     STIF_ASSERT_NOT_NULL( icon );

   132 

   133     CleanupStack::PopAndDestroy( icon );

   134     return KErrNone;

   135 

   136     }

   137 

   138 // -----------------------------------------------------------------------------

   139 // CTestSDKPicToGraph::TestIconBitmapL

   140 // -----------------------------------------------------------------------------

   141 //

   142 TInt CTestSDKPicToGraph::TestIconBitmapL( CStifItemParser& /*aItem*/ )

   143     {

   144 

   145     // Print to UI

   146     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   147     _LIT( KTestIconBitmap, "In IconUtils IconBitmap" );

   148     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestIconBitmap );

   149     // Print to log file

   150     iLog->Log( KTestIconBitmap );

   151 

   152     CAknIcon* icon = CAknIcon::NewL();

   153     CleanupStack::PushL( icon );

   154     CFbsBitmap* bitmap = icon->Bitmap();

   155     STIF_ASSERT_NULL( bitmap );

   156 

   157     CleanupStack::PopAndDestroy( icon );

   158     return KErrNone;

   159 

   160     }

   161 

   162 // -----------------------------------------------------------------------------

   163 // CTestSDKPicToGraph::TestIconMaskL

   164 // -----------------------------------------------------------------------------

   165 //

   166 TInt CTestSDKPicToGraph::TestIconMaskL( CStifItemParser& /*aItem*/ )

   167     {

   168 

   169     // Print to UI

   170     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   171     _LIT( KTestIconMask, "In IconUtils IconMask" );

   172     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestIconMask );

   173     // Print to log file

   174     iLog->Log( KTestIconMask );

   175 

   176     CAknIcon* icon = CAknIcon::NewL();

   177     CleanupStack::PushL( icon );

   178     CFbsBitmap* mask = icon->Mask();

   179     STIF_ASSERT_NULL( mask );

   180 

   181     CleanupStack::PopAndDestroy( icon );

   182     return KErrNone;

   183 

   184     }

   185 

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

   187 // CTestSDKPicToGraph::TestIconSetBitmapL

   188 // -----------------------------------------------------------------------------

   189 //

   190 TInt CTestSDKPicToGraph::TestIconSetBitmapL( CStifItemParser& /*aItem*/ )

   191     {

   192 

   193     // Print to UI

   194     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   195     _LIT( KTestIconSetBitmap, "In IconUtils IconSetBitmap" );

   196     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestIconSetBitmap );

   197     // Print to log file

   198     iLog->Log( KTestIconSetBitmap );

   199 

   200     CAknIcon* icon = CAknIcon::NewL();

   201     CleanupStack::PushL( icon );

   202 

   203     CFbsBitmap* bitmap = NULL;

   204     CFbsBitmap* mask = NULL;

   205     AknIconUtils::CreateIconL( bitmap, mask, AknIconUtils::AvkonIconFileName(),

   206             EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask );

   207     CleanupStack::PushL( bitmap );

   208     CleanupStack::PushL( mask );

   209     icon->SetBitmap( bitmap );

   210 

   211     CleanupStack::PopAndDestroy( mask );

   212     CleanupStack::Pop( bitmap );

   213     CleanupStack::PopAndDestroy( icon );

   214     return KErrNone;

   215 

   216     }

   217 

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

   219 // CTestSDKPicToGraph::TestIconSetMaskL

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

   221 //

   222 TInt CTestSDKPicToGraph::TestIconSetMaskL( CStifItemParser& /*aItem*/ )

   223     {

   224 

   225     // Print to UI

   226     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   227     _LIT( KTestIconSetMask, "In IconUtils IconSetMask" );

   228     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestIconSetMask );

   229     // Print to log file

   230     iLog->Log( KTestIconSetMask );

   231 

   232     CAknIcon* icon = CAknIcon::NewL();

   233     CleanupStack::PushL( icon );

   234 

   235     CFbsBitmap* bitmap = NULL;

   236     CFbsBitmap* mask = NULL;

   237     AknIconUtils::CreateIconL( bitmap, mask, AknIconUtils::AvkonIconFileName(),

   238             EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask );

   239     CleanupStack::PushL( bitmap );

   240     CleanupStack::PushL( mask );

   241     icon->SetMask( mask );

   242 

   243     CleanupStack::Pop( mask );

   244     CleanupStack::PopAndDestroy( bitmap );

   245     CleanupStack::PopAndDestroy( icon );

   246     return KErrNone;

   247 

   248     }

   249 

   250 // -----------------------------------------------------------------------------

   251 // CTestSDKPicToGraph::TestUtilCreateIconWithMaskL

   252 // -----------------------------------------------------------------------------

   253 //

   254 TInt CTestSDKPicToGraph::TestUtilCreateIconWithMaskL( CStifItemParser& /*aItem*/ )

   255     {

   256 

   257     // Print to UI

   258     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   259     _LIT( KTestUtilCreateIconL, "In IconUtils IconUtilCreateIconL" );

   260     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilCreateIconL );

   261     // Print to log file

   262     iLog->Log( KTestUtilCreateIconL );

   263 

   264     CFbsBitmap* bitmap = NULL;

   265     CFbsBitmap* mask = NULL;

   266     AknIconUtils::CreateIconL( bitmap, mask, AknIconUtils::AvkonIconFileName(),

   267             EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask );

   268     delete mask;

   269     delete bitmap;

   270 

   271     return KErrNone;

   272 

   273     }

   274 

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

   276 // CTestSDKPicToGraph::TestUtilCreateIconWithBmpIdL

   277 // -----------------------------------------------------------------------------

   278 //

   279 TInt CTestSDKPicToGraph::TestUtilCreateIconWithBmpIdL( CStifItemParser& /*aItem*/ )

   280     {

   281 

   282     // Print to UI

   283     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   284     _LIT( KTestUtilCreateIconL, "In IconUtils IconUtilCreateIconL" );

   285     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilCreateIconL );

   286     // Print to log file

   287     iLog->Log( KTestUtilCreateIconL );

   288 

   289     CFbsBitmap* fbsBitmap =  AknIconUtils::CreateIconL(

   290             AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   291     CleanupStack::PushL( fbsBitmap );

   292     STIF_ASSERT_NOT_NULL( fbsBitmap );

   293     CleanupStack::PopAndDestroy( fbsBitmap );

   294 

   295     return KErrNone;

   296 

   297     }

   298 

   299 // -----------------------------------------------------------------------------

   300 // CTestSDKPicToGraph::TestUtilCreateIconWithProMaskL

   301 // -----------------------------------------------------------------------------

   302 //

   303 TInt CTestSDKPicToGraph::TestUtilCreateIconWithProMaskL( CStifItemParser& /*aItem*/ )

   304     {

   305 

   306     // Print to UI

   307     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   308     _LIT( KTestUtilCreateIconL, "In IconUtils IconUtilCreateIconL" );

   309     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilCreateIconL );

   310     // Print to log file

   311     iLog->Log( KTestUtilCreateIconL );

   312 

   313 

   314     CFbsBitmap* bitmap = NULL;

   315     CFbsBitmap* mask = NULL;

   316     CTestIconProvider* provider = new ( ELeave ) CTestIconProvider;

   317     CleanupStack::PushL( provider );

   318 

   319     AknIconUtils::CreateIconL( bitmap, mask, *provider,

   320             EMbmAvkonQgn_graf_tab_21, EMbmAvkonQgn_graf_tab_21_mask );

   321 

   322     delete mask;

   323     delete bitmap;

   324     CleanupStack::PopAndDestroy( provider );

   325     return KErrNone;

   326 

   327     }

   328 

   329 // -----------------------------------------------------------------------------

   330 // CTestSDKPicToGraph::TestUtilCreateIconWithProviderL

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

   332 //

   333 TInt CTestSDKPicToGraph::TestUtilCreateIconWithProviderL( CStifItemParser& /*aItem*/ )

   334     {

   335 

   336     // Print to UI

   337     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   338     _LIT( KTestUtilCreateIconL, "In IconUtils IconUtilCreateIconL" );

   339     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilCreateIconL );

   340     // Print to log file

   341     iLog->Log( KTestUtilCreateIconL );

   342 

   343     CTestIconProvider* provider = new ( ELeave ) CTestIconProvider;

   344     CleanupStack::PushL( provider );

   345 

   346     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL( *provider,

   347             EMbmAvkonQgn_graf_tab_21 );

   348     CleanupStack::PushL( fbsBitmap );

   349     STIF_ASSERT_NOT_NULL( fbsBitmap );

   350     CleanupStack::PopAndDestroy( fbsBitmap );

   351 

   352     CleanupStack::PopAndDestroy( provider );

   353     return KErrNone;

   354 

   355     }

   356 

   357 // -----------------------------------------------------------------------------

   358 // CTestSDKPicToGraph::TestUtilCreateIconWithSoIconL

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

   360 //

   361 TInt CTestSDKPicToGraph::TestUtilCreateIconWithSoIconL( CStifItemParser& /*aItem*/ )

   362     {

   363 

   364     // Print to UI

   365     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   366     _LIT( KTestUtilCreateIconL, "In IconUtils IconUtilCreateIconL" );

   367     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilCreateIconL );

   368     // Print to log file

   369     iLog->Log( KTestUtilCreateIconL );

   370 

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

   372     TAknsItemID itemID;

   373     CFbsBitmap* bitmap = NULL;

   374     CFbsBitmap* mask = NULL;

   375     AknsUtils::CreateIconL( instance, itemID, bitmap, mask, 

   376             AknIconUtils::AvkonIconFileName(), 1, 2 );

   377     CleanupStack::PushL( bitmap );

   378     CleanupStack::PushL( mask );

   379 

   380     CAknIcon* sourceIcon = CAknIcon::NewL();

   381     CleanupStack::PushL( sourceIcon );

   382     sourceIcon->SetBitmap( bitmap );

   383     sourceIcon->SetMask( mask );

   384 

   385     CAknIcon* icon = AknIconUtils::CreateIconL( sourceIcon );

   386     CleanupStack::PushL( icon );

   387     STIF_ASSERT_NOT_NULL( icon );

   388 

   389     CleanupStack::Pop( icon );

   390     CleanupStack::PopAndDestroy( sourceIcon );

   391     CleanupStack::Pop( mask );

   392     CleanupStack::Pop( bitmap );

   393     return KErrNone;

   394 

   395     }

   396 

   397 // -----------------------------------------------------------------------------

   398 // CTestSDKPicToGraph::TestUtilCreateIconWithSoBmpL

   399 // -----------------------------------------------------------------------------

   400 //

   401 TInt CTestSDKPicToGraph::TestUtilCreateIconWithSoBmpL( CStifItemParser& /*aItem*/ )

   402     {

   403 

   404     // Print to UI

   405     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   406     _LIT( KTestUtilCreateIconL, "In IconUtils IconUtilCreateIconL" );

   407     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilCreateIconL );

   408     // Print to log file

   409     iLog->Log( KTestUtilCreateIconL );

   410 

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

   412     TAknsItemID itemID;

   413     CFbsBitmap* bitmap = NULL;

   414     CFbsBitmap* mask = NULL;

   415     AknsUtils::CreateIconL( instance, itemID, bitmap, mask, 

   416             AknIconUtils::AvkonIconFileName(), 1, 2 );

   417     CleanupStack::PushL( bitmap );

   418     CleanupStack::PushL( mask );

   419 

   420     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL ( bitmap );

   421     CleanupStack::PushL( fbsBitmap );

   422     STIF_ASSERT_NOT_NULL( fbsBitmap );

   423 

   424     CleanupStack::PopAndDestroy( fbsBitmap );

   425     CleanupStack::PopAndDestroy( mask );

   426     CleanupStack::Pop( bitmap );

   427 

   428     return KErrNone;

   429 

   430     }

   431 

   432 // -----------------------------------------------------------------------------

   433 // CTestSDKPicToGraph::TestUtilCreateIconLCL

   434 // -----------------------------------------------------------------------------

   435 //

   436 TInt CTestSDKPicToGraph::TestUtilCreateIconLCL( CStifItemParser& aItem )

   437     {

   438 

   439     // Print to UI

   440     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   441     _LIT( KTestUtilCreateIconLC, "In IconUtils IconUtilCreateIconLC" );

   442     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilCreateIconLC );

   443     // Print to log file

   444     iLog->Log( KTestUtilCreateIconLC );

   445 

   446     TInt num = 0;

   447     TInt err = aItem.GetNextInt( num );

   448     if ( err != KErrNone )

   449         {

   450         return err;

   451         }

   452 

   453     CFbsBitmap* bitmap = NULL;

   454     CFbsBitmap* mask = NULL;

   455     CTestIconProvider* provider = new ( ELeave ) CTestIconProvider;

   456     CleanupStack::PushL( provider );

   457 

   458     switch( num )

   459         {

   460         case 1:

   461             AknIconUtils::CreateIconLC( bitmap, mask, AknIconUtils::AvkonIconFileName(),

   462                     EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask );

   463             break;

   464         case 2:

   465             AknIconUtils::CreateIconLC( bitmap, mask, *provider,

   466                     EMbmAvkonQgn_graf_tab_21, EMbmAvkonQgn_graf_tab_21_mask );

   467             break;

   468         }

   469 

   470     CleanupStack::PopAndDestroy( mask );

   471     CleanupStack::PopAndDestroy( bitmap );

   472     CleanupStack::PopAndDestroy( provider );

   473     return KErrNone;

   474 

   475     }

   476 

   477 // -----------------------------------------------------------------------------

   478 // CTestSDKPicToGraph::TestUtilPreserveIconDataL

   479 // -----------------------------------------------------------------------------

   480 //

   481 TInt CTestSDKPicToGraph::TestUtilPreserveIconDataL( CStifItemParser& /*aItem*/ )

   482     {

   483 

   484     // Print to UI

   485     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   486     _LIT( KTestUtilPreserveIconData, "In IconUtils IconUtilPreserveIconData" );

   487     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilPreserveIconData );

   488     // Print to log file

   489     iLog->Log( KTestUtilPreserveIconData );

   490 

   491     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   492         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   493     CleanupStack::PushL( fbsBitmap );

   494     AknIconUtils::PreserveIconData( fbsBitmap );

   495 

   496     CleanupStack::PopAndDestroy( fbsBitmap );

   497     return KErrNone;

   498 

   499     }

   500 

   501 // -----------------------------------------------------------------------------

   502 // CTestSDKPicToGraph::TestUtilDestroyIconDataL

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

   504 //

   505 TInt CTestSDKPicToGraph::TestUtilDestroyIconDataL( CStifItemParser& /*aItem*/ )

   506     {

   507 

   508     // Print to UI

   509     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   510     _LIT( KTestUtilDestroyIconData, "In IconUtils IconUtilDestroyIconData" );

   511     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilDestroyIconData );

   512     // Print to log file

   513     iLog->Log( KTestUtilDestroyIconData );

   514 

   515     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   516         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   517     CleanupStack::PushL( fbsBitmap );

   518     AknIconUtils::DestroyIconData( fbsBitmap );

   519 

   520     CleanupStack::PopAndDestroy( fbsBitmap );

   521     return KErrNone;

   522 

   523     }

   524 

   525 // -----------------------------------------------------------------------------

   526 // CTestSDKPicToGraph::TestUtilSetSizeL

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

   528 //

   529 TInt CTestSDKPicToGraph::TestUtilSetSizeL( CStifItemParser& /*aItem*/ )

   530     {

   531 

   532     // Print to UI

   533     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   534     _LIT( KTestUtilSetSize, "In IconUtils IconUtilSetSize" );

   535     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilSetSize );

   536     // Print to log file

   537     iLog->Log( KTestUtilSetSize );

   538 

   539     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   540         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   541     CleanupStack::PushL( fbsBitmap );

   542     TSize size( KIconWidth, KIconHeight );

   543     TInt err = AknIconUtils::SetSize( fbsBitmap, size );

   544 

   545     CleanupStack::PopAndDestroy( fbsBitmap );

   546     return err;

   547 

   548     }

   549 

   550 // -----------------------------------------------------------------------------

   551 // CTestSDKPicToGraph::TestUtilSetSizeAndRotationL

   552 // -----------------------------------------------------------------------------

   553 //

   554 TInt CTestSDKPicToGraph::TestUtilSetSizeAndRotationL( CStifItemParser& /*aItem*/ )

   555     {

   556 

   557     // Print to UI

   558     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   559     _LIT( KTestUtilSetSizeAndRotation, "In IconUtils IconUtilSetSizeAndRotation" );

   560     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilSetSizeAndRotation );

   561     // Print to log file

   562     iLog->Log( KTestUtilSetSizeAndRotation );

   563 

   564     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   565         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   566     CleanupStack::PushL( fbsBitmap );

   567     TSize size( KIconWidth, KIconHeight );

   568     TInt err = AknIconUtils::SetSizeAndRotation( fbsBitmap, size,

   569             EAspectRatioPreserved, KAngle );

   570 

   571     CleanupStack::PopAndDestroy( fbsBitmap );

   572     return err;

   573 

   574     }

   575 

   576 // -----------------------------------------------------------------------------

   577 // CTestSDKPicToGraph::TestUtilSetObserverL

   578 // -----------------------------------------------------------------------------

   579 //

   580 TInt CTestSDKPicToGraph::TestUtilSetObserverL( CStifItemParser& /*aItem*/ )

   581     {

   582 

   583     // Print to UI

   584     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   585     _LIT( KTestUtilSetObserver, "In IconUtils IconUtilSetObserver" );

   586     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilSetObserver );

   587     // Print to log file

   588     iLog->Log( KTestUtilSetObserver );

   589 

   590     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   591         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   592     CleanupStack::PushL( fbsBitmap );

   593     CTestIconObserver* observer = new ( ELeave ) CTestIconObserver;

   594     CleanupStack::PushL( observer );

   595     AknIconUtils::SetObserver( fbsBitmap, observer );

   596 

   597     CleanupStack::PopAndDestroy( observer );

   598     CleanupStack::PopAndDestroy( fbsBitmap );

   599     return KErrNone;

   600 

   601     }

   602 

   603 // -----------------------------------------------------------------------------

   604 // CTestSDKPicToGraph::TestUtilAvkonIconFileName

   605 // -----------------------------------------------------------------------------

   606 //

   607 TInt CTestSDKPicToGraph::TestUtilAvkonIconFileName( CStifItemParser& /*aItem*/ )

   608     {

   609 

   610     // Print to UI

   611     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   612     _LIT( KTestUtilAvkonIconFileName, "In IconUtils IconUtilAvkonIconFileName" );

   613     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilAvkonIconFileName );

   614     // Print to log file

   615     iLog->Log( KTestUtilAvkonIconFileName );

   616 

   617     TDesC fileName = AknIconUtils::AvkonIconFileName();

   618     STIF_ASSERT_NOT_EQUALS( 0, fileName.Length() );

   619 

   620     return KErrNone;

   621 

   622     }

   623 

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

   625 // CTestSDKPicToGraph::TestUtilValidateLogicalAppIconId

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

   627 //

   628 TInt CTestSDKPicToGraph::TestUtilValidateLogicalAppIconId( CStifItemParser& /*aItem*/ )

   629     {

   630 

   631     // Print to UI

   632     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   633     _LIT( KTestUtilValidateLogicalAppIconId, "In IconUtils IconUtilValidateLogicalAppIconId" );

   634     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilValidateLogicalAppIconId );

   635     // Print to log file

   636     iLog->Log( KTestUtilValidateLogicalAppIconId );

   637 

   638     TDesC fileName = AknIconUtils::AvkonIconFileName();

   639     TInt bitmapId = EMbmAvkonQgn_graf_tab_21;

   640     TInt maskId = EMbmAvkonQgn_graf_tab_21_mask;

   641     AknIconUtils::ValidateLogicalAppIconId( fileName, bitmapId, maskId );

   642 

   643     return KErrNone;

   644 

   645     }

   646 

   647 // -----------------------------------------------------------------------------

   648 // CTestSDKPicToGraph::TestUtilIsMifFile

   649 // -----------------------------------------------------------------------------

   650 //

   651 TInt CTestSDKPicToGraph::TestUtilIsMifFile( CStifItemParser& /*aItem*/ )

   652     {

   653 

   654     // Print to UI

   655     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   656     _LIT( KTestUtilIsMifFile, "In IconUtils IconUtilIsMifFile" );

   657     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilIsMifFile );

   658     // Print to log file

   659     iLog->Log( KTestUtilIsMifFile );

   660 

   661     TDesC fileName = AknIconUtils::AvkonIconFileName();

   662     TBool mifFile = AknIconUtils::IsMifFile( fileName );

   663     STIF_ASSERT_FALSE( mifFile );

   664 

   665     return KErrNone;

   666 

   667     }

   668 

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

   670 // CTestSDKPicToGraph::TestUtilIsMifIconL

   671 // -----------------------------------------------------------------------------

   672 //

   673 TInt CTestSDKPicToGraph::TestUtilIsMifIconL( CStifItemParser& /*aItem*/ )

   674     {

   675 

   676     // Print to UI

   677     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   678     _LIT( KTestUtilIsMifIcon, "In IconUtils IconUtilIsMifIcon" );

   679     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilIsMifIcon );

   680     // Print to log file

   681     iLog->Log( KTestUtilIsMifIcon );

   682 

   683     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   684         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   685     CleanupStack::PushL( fbsBitmap );

   686     TBool mifIcon = AknIconUtils::IsMifIcon( fbsBitmap );

   687     STIF_ASSERT_FALSE( mifIcon );

   688 

   689     CleanupStack::PopAndDestroy( fbsBitmap );

   690     return KErrNone;

   691 

   692     }

   693 

   694 // -----------------------------------------------------------------------------

   695 // CTestSDKPicToGraph::TestUtilGetContentDimensionsL

   696 // -----------------------------------------------------------------------------

   697 //

   698 TInt CTestSDKPicToGraph::TestUtilGetContentDimensionsL( CStifItemParser& aItem )

   699     {

   700 

   701     // Print to UI

   702     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   703     _LIT( KTestUtilGetContentDimensions, "In IconUtils IconUtilGetContentDimensions" );

   704     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilGetContentDimensions );

   705     // Print to log file

   706     iLog->Log( KTestUtilGetContentDimensions );

   707 

   708     TInt num = 0;

   709     TInt err = aItem.GetNextInt( num );

   710     if ( err != KErrNone )

   711         {

   712         return err;

   713         }

   714 

   715     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   716         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   717     CleanupStack::PushL( fbsBitmap );

   718     TSize size( KIconWidth, KIconHeight );

   719     TAknContentDimensions dimen( KIconWidth, KIconHeight );

   720 

   721     switch( num )

   722         {

   723         case 1:

   724             err = AknIconUtils::GetContentDimensions( fbsBitmap, size );

   725             break;

   726         case 2:

   727             err = AknIconUtils::GetContentDimensions( fbsBitmap, dimen );

   728             break;

   729         default:

   730             CleanupStack::PopAndDestroy( fbsBitmap );

   731             return KErrNotSupported;

   732         }

   733 

   734     CleanupStack::PopAndDestroy( fbsBitmap );

   735     return err;

   736 

   737     }

   738 

   739 // -----------------------------------------------------------------------------

   740 // CTestSDKPicToGraph::TestUtilSetIconColorL

   741 // -----------------------------------------------------------------------------

   742 //

   743 TInt CTestSDKPicToGraph::TestUtilSetIconColorL( CStifItemParser& /*aItem*/ )

   744     {

   745 

   746     // Print to UI

   747     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   748     _LIT( KTestUtilSetIconColor, "In IconUtils IconUtilSetIconColor" );

   749     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilSetIconColor );

   750     // Print to log file

   751     iLog->Log( KTestUtilSetIconColor );

   752 

   753     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   754         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   755     CleanupStack::PushL( fbsBitmap );

   756     AknIconUtils::SetIconColor( fbsBitmap, KRgbYellow );

   757 

   758     CleanupStack::PopAndDestroy( fbsBitmap );

   759     return KErrNone;

   760 

   761     }

   762 

   763 // -----------------------------------------------------------------------------

   764 // CTestSDKPicToGraph::TestUtilExcludeFromCacheL

   765 // -----------------------------------------------------------------------------

   766 //

   767 TInt CTestSDKPicToGraph::TestUtilExcludeFromCacheL( CStifItemParser& /*aItem*/ )

   768     {

   769 

   770     // Print to UI

   771     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   772     _LIT( KTestUtilExcludeFromCache, "In IconUtils IconUtilExcludeFromCache" );

   773     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilExcludeFromCache );

   774     // Print to log file

   775     iLog->Log( KTestUtilExcludeFromCache );

   776 

   777     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   778         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   779     CleanupStack::PushL( fbsBitmap );

   780     AknIconUtils::ExcludeFromCache( fbsBitmap );

   781 

   782     CleanupStack::PopAndDestroy( fbsBitmap );

   783     return KErrNone;

   784 

   785     }

   786 

   787 // -----------------------------------------------------------------------------

   788 // CTestSDKPicToGraph::TestUtilDisableCompressionL

   789 // -----------------------------------------------------------------------------

   790 //

   791 TInt CTestSDKPicToGraph::TestUtilDisableCompressionL( CStifItemParser& /*aItem*/ )

   792     {

   793 

   794     // Print to UI

   795     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   796     _LIT( KTestUtilDisableCompression, "In IconUtils IconUtilDisableCompression" );

   797     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilDisableCompression );

   798     // Print to log file

   799     iLog->Log( KTestUtilDisableCompression );

   800 

   801     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   802         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   803     CleanupStack::PushL( fbsBitmap );

   804     AknIconUtils::DisableCompression( fbsBitmap );

   805 

   806     CleanupStack::PopAndDestroy( fbsBitmap );

   807     return KErrNone;

   808 

   809     }

   810 

   811 // -----------------------------------------------------------------------------

   812 // CTestSDKPicToGraph::TestUtilScaleBitmapL

   813 // -----------------------------------------------------------------------------

   814 //

   815 TInt CTestSDKPicToGraph::TestUtilScaleBitmapL( CStifItemParser& /*aItem*/ )

   816     {

   817 

   818     // Print to UI

   819     _LIT( KTestSDKPicToGraph, "testsdkpictograph" );

   820     _LIT( KTestUtilScaleBitmapL, "In IconUtils IconUtilScaleBitmapL" );

   821     TestModuleIf().Printf( 0, KTestSDKPicToGraph, KTestUtilScaleBitmapL );

   822     // Print to log file

   823     iLog->Log( KTestUtilScaleBitmapL );

   824 

   825     CFbsBitmap* fbsBitmap = AknIconUtils::CreateIconL(

   826         AknIconUtils::AvkonIconFileName(), EMbmAvkonQgn_graf_tab_21 );

   827     CleanupStack::PushL( fbsBitmap );

   828     TRect rect( 0, 0, KIconWidth, KIconHeight );

   829     AknIconUtils::ScaleBitmapL( rect, fbsBitmap, fbsBitmap );

   830 

   831     CleanupStack::PopAndDestroy( fbsBitmap );

   832     return KErrNone;

   833 

   834     }

   835