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 api of alf_core_toolkit

    15 *

    16 */

    17 

    18 

    19 // [INCLUDE FILES]

    20 #include <e32svr.h>

    21 #include <gdi.h>

    22 #include <stifparser.h>

    23 #include <stiftestinterface.h>

    24 #include <uiacceltk/huienv.h>

    25 #include <uiacceltk/huistatic.h>

    26 #include <uiacceltk/huitexture.h>

    27 

    28 #include "testuiaifcoretoolkit.h"

    29 

    30 // -----------------------------------------------------------------------------

    31 // CTestUiAifCoreToolkit::TestTHuiTextNewL

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

    33 //

    34 TInt CTestUiAifCoreToolkit::TestTHuiTextNewL( CStifItemParser& /*aItem*/ )

    35     {

    36 

    37     // Print to UI

    38     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

    39     _LIT( KTestTHuiTextNewL, "In TestTHuiTextNewL" );

    40     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextNewL );

    41     // Print to log file 

    42     iLog->Log( KTestTHuiTextNewL );

    43     

    44     CHuiTexture* texTure = CHuiTexture::NewL();

    45     delete texTure;

    46     

    47     return KErrNone;

    48     }

    49 

    50 // -----------------------------------------------------------------------------

    51 // CTestUiAifCoreToolkit::TestTHuiTextNewLC

    52 // -----------------------------------------------------------------------------

    53 //

    54 TInt CTestUiAifCoreToolkit::TestTHuiTextNewLC( CStifItemParser& /*aItem*/ )

    55     {

    56 

    57     // Print to UI

    58     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

    59     _LIT( KTestTHuiTextNewLC, "In TestTHuiTextNewLC" );

    60     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextNewLC );

    61     // Print to log file 

    62     iLog->Log( KTestTHuiTextNewLC );

    63     

    64     CHuiTexture* textTure = CHuiTexture::NewLC();

    65     

    66     // Verify that all the member variables are correctly initialized.

    67     STIF_ASSERT_TRUE( textTure->ImageFileName().Size() == 0 );

    68     STIF_ASSERT_TRUE( !textTure->HasContent() );

    69     STIF_ASSERT_TRUE( !textTure->IsShadowEnabled() );

    70     STIF_ASSERT_TRUE( textTure->ShadowStyle() == EHuiTextureShadowStyleIcon );

    71     STIF_ASSERT_TRUE( !textTure->HasAlpha() );

    72     STIF_ASSERT_TRUE( textTure->Size().iWidth == 0 );

    73     STIF_ASSERT_TRUE( textTure->Size().iHeight == 0 );

    74     STIF_ASSERT_TRUE( textTure->Size().iWidth == 0 );

    75     STIF_ASSERT_TRUE( textTure->SegmentCount() == 0);

    76     STIF_ASSERT_TRUE( !textTure->TextureChanged() );

    77     STIF_ASSERT_TRUE( !textTure->IsSkinContent() );

    78     

    79     CleanupStack::PopAndDestroy( textTure );

    80     

    81     return KErrNone;

    82     }

    83 

    84 // -----------------------------------------------------------------------------

    85 // CTestUiAifCoreToolkit::TestTHuiTextImageFileNameL

    86 // -----------------------------------------------------------------------------

    87 //

    88 TInt CTestUiAifCoreToolkit::TestTHuiTextImageFileNameL( CStifItemParser& /*aItem*/ )

    89     {

    90 

    91     // Print to UI

    92     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

    93     _LIT( KTestTHuiTextImageFileNameL, "In TestTHuiTextImageFileNameL" );

    94     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextImageFileNameL );

    95     // Print to log file 

    96     iLog->Log( KTestTHuiTextImageFileNameL );

    97     

    98     CHuiTexture* texTure = CHuiTexture::NewL();

    99     CleanupStack::PushL( texTure );

   100     

   101     CleanupStack::PopAndDestroy( texTure );

   102     

   103     return KErrNone;

   104     }

   105 

   106 // -----------------------------------------------------------------------------

   107 // CTestUiAifCoreToolkit::TestTHuiTextHasContentL

   108 // -----------------------------------------------------------------------------

   109 //

   110 TInt CTestUiAifCoreToolkit::TestTHuiTextHasContentL( CStifItemParser& /*aItem*/ )

   111     {

   112 

   113     // Print to UI

   114     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   115     _LIT( KTestTHuiTextHasContentL, "In TestTHuiTextHasContentL" );

   116     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextHasContentL );

   117     // Print to log file 

   118     iLog->Log( KTestTHuiTextHasContentL );

   119     

   120     CHuiTexture* texTure = CHuiTexture::NewL();

   121     CleanupStack::PushL( texTure );

   122     

   123     STIF_ASSERT_TRUE( texTure->HasContent() == EFalse);

   124     

   125     CleanupStack::PopAndDestroy( texTure );

   126     return KErrNone;

   127     }

   128 

   129 // -----------------------------------------------------------------------------

   130 // CTestUiAifCoreToolkit::TestTHuiTextHasAlphaL

   131 // -----------------------------------------------------------------------------

   132 //

   133 TInt CTestUiAifCoreToolkit::TestTHuiTextHasAlphaL( CStifItemParser& /*aItem*/ )

   134     {

   135 

   136     // Print to UI

   137     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   138     _LIT( KTestTHuiTextHasAlphaL, "In TestTHuiTextHasAlphaL" );

   139     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextHasAlphaL );

   140     // Print to log file 

   141     iLog->Log( KTestTHuiTextHasAlphaL );

   142     

   143     CHuiTexture* texTure = CHuiTexture::NewL();

   144     CleanupStack::PushL( texTure );

   145     

   146     STIF_ASSERT_TRUE( texTure->HasAlpha() == EFalse);

   147     

   148     CleanupStack::PopAndDestroy( texTure );

   149     

   150     return KErrNone;

   151     }

   152 

   153 // -----------------------------------------------------------------------------

   154 // CTestUiAifCoreToolkit::TestTHuiTextMaxTextureSizeL

   155 // -----------------------------------------------------------------------------

   156 //

   157 TInt CTestUiAifCoreToolkit::TestTHuiTextMaxTextureSizeL( CStifItemParser& /*aItem*/ )

   158     {

   159 

   160     // Print to UI

   161     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   162     _LIT( KTestTHuiTextMaxTextureSizeL, "In TestTHuiTextMaxTextureSizeL" );

   163     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextMaxTextureSizeL );

   164     // Print to log file 

   165     iLog->Log( KTestTHuiTextMaxTextureSizeL );

   166     

   167     CHuiTexture* texTure = CHuiTexture::NewL();

   168     CleanupStack::PushL( texTure );

   169     

   170     texTure->MaxTextureSize();

   171     

   172     CleanupStack::PopAndDestroy( texTure );

   173     

   174     return KErrNone;

   175     }

   176 

   177 

   178 // -----------------------------------------------------------------------------

   179 // CTestUiAifCoreToolkit::TestTHuiTextClearLL

   180 // -----------------------------------------------------------------------------

   181 //

   182 TInt CTestUiAifCoreToolkit::TestTHuiTextClearLL( CStifItemParser& /*aItem*/ )

   183     {

   184 

   185     // Print to UI

   186     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   187     _LIT( KTestTHuiTextMaxTextureSizeL, "In TestTHuiTextMaxTextureSizeL" );

   188     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextMaxTextureSizeL );

   189     // Print to log file 

   190     iLog->Log( KTestTHuiTextMaxTextureSizeL );

   191     

   192     CHuiTexture* texTure = CHuiTexture::NewL();

   193     CleanupStack::PushL( texTure );

   194     

   195     TSize size(128, 128);

   196     TRgb rgb = KRgbRed;    

   197     texTure->ClearL(size, rgb);

   198 

   199     CleanupStack::PopAndDestroy( texTure );

   200     

   201     return KErrNone;

   202     }

   203 

   204 // -----------------------------------------------------------------------------

   205 // CTestUiAifCoreToolkit::TestTHuiClearWithAlphaLL

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

   207 //

   208 TInt CTestUiAifCoreToolkit::TestTHuiClearWithAlphaLL( CStifItemParser& /*aItem*/ )

   209     {

   210 

   211     // Print to UI

   212     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   213     _LIT( KTestTHuiTextMaxTextureSizeL, "In TestTHuiTextMaxTextureSizeL" );

   214     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextMaxTextureSizeL );

   215     // Print to log file 

   216     iLog->Log( KTestTHuiTextMaxTextureSizeL );

   217     

   218     CHuiTexture* texTure = CHuiTexture::NewL();

   219     CleanupStack::PushL( texTure );

   220     

   221     TSize size(128, 128);

   222     TRgb rgb = KRgbRed;

   223     TUint temp = 255;

   224     texTure->ClearWithAlphaL( size, rgb, temp);

   225     

   226     CleanupStack::PopAndDestroy( texTure );

   227     

   228     return KErrNone;

   229     }

   230 

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

   232 // CTestUiAifCoreToolkit::TestTHuiSegmentedTextureL

   233 // -----------------------------------------------------------------------------

   234 //

   235 TInt CTestUiAifCoreToolkit::TestTHuiSegmentedTextureL( CStifItemParser& /*aItem*/ )

   236     {

   237 

   238     // Print to UI

   239     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   240     _LIT( KTestTHuiSegmentedTextureL, "In TestTHuiSegmentedTextureL" );

   241     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSegmentedTextureL );

   242     // Print to log file 

   243     iLog->Log( KTestTHuiSegmentedTextureL );

   244     

   245     CHuiTexture* texTure = CHuiTexture::NewL();

   246     CleanupStack::PushL( texTure );

   247     

   248     texTure->SegmentedTexture();

   249     

   250     CleanupStack::PopAndDestroy( texTure );

   251     

   252     return KErrNone;

   253     }

   254 

   255 // -----------------------------------------------------------------------------

   256 // CTestUiAifCoreToolkit::TestTHuiSegmentedTextureConstL

   257 // -----------------------------------------------------------------------------

   258 //

   259 TInt CTestUiAifCoreToolkit::TestTHuiSegmentedTextureConstL( CStifItemParser& /*aItem*/ )

   260     {

   261 

   262     // Print to UI

   263     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   264     _LIT( KTestTHuiSegmentedTextureConstL, "In TestTHuiSegmentedTextureConstL" );

   265     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSegmentedTextureConstL);

   266     // Print to log file 

   267     iLog->Log( KTestTHuiSegmentedTextureConstL );

   268     

   269     CHuiTexture* texTure = CHuiTexture::NewL();

   270     CleanupStack::PushL( texTure );

   271     

   272     ( ( const CHuiTexture* )texTure )->SegmentedTexture();

   273     

   274     CleanupStack::PopAndDestroy( texTure );

   275     

   276     return KErrNone;

   277     }

   278 

   279 // -----------------------------------------------------------------------------

   280 // CTestUiAifCoreToolkit::TestTHuiShadowedTextureL

   281 // -----------------------------------------------------------------------------

   282 //

   283 TInt CTestUiAifCoreToolkit::TestTHuiShadowedTextureL( CStifItemParser& /*aItem*/ )

   284     {

   285 

   286     // Print to UI

   287     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   288     _LIT( KTestTHuiShadowedTextureL, "In TestTHuiShadowedTextureL" );

   289     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiShadowedTextureL );

   290     // Print to log file 

   291     iLog->Log( KTestTHuiShadowedTextureL );

   292     

   293     CHuiTexture* texTure = CHuiTexture::NewL();

   294     CleanupStack::PushL( texTure );

   295     

   296     texTure->ShadowedTexture();

   297     

   298     CleanupStack::PopAndDestroy( texTure );

   299     

   300     return KErrNone;

   301     }

   302 

   303 // -----------------------------------------------------------------------------

   304 // CTestUiAifCoreToolkit::TestTHuiShadowedTextureConstL

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

   306 //

   307 TInt CTestUiAifCoreToolkit::TestTHuiShadowedTextureConstL( CStifItemParser& /*aItem*/ )

   308     {

   309 

   310     // Print to UI

   311     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   312     _LIT( KTestTHuiShadowedTextureConstL, "In TestTHuiShadowedTextureConstL" );

   313     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, 

   314             KTestTHuiShadowedTextureConstL );

   315     // Print to log file 

   316     iLog->Log( KTestTHuiShadowedTextureConstL );

   317     

   318     CHuiTexture* texTure = CHuiTexture::NewL();

   319     CleanupStack::PushL( texTure );

   320     

   321     ( ( const CHuiTexture* )texTure )->ShadowedTexture();

   322     

   323     CleanupStack::PopAndDestroy( texTure );

   324     

   325     return KErrNone;

   326     

   327     }

   328 

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

   330 // CTestUiAifCoreToolkit::TestTHuiEnableShadowL

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

   332 //

   333 TInt CTestUiAifCoreToolkit::TestTHuiEnableShadowL( CStifItemParser& /*aItem*/ )

   334     {

   335 

   336     // Print to UI

   337     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   338     _LIT( KTestTHuiEnableShadowL, "In TestTHuiEnableShadowL" );

   339     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiEnableShadowL );

   340     // Print to log file 

   341     iLog->Log( KTestTHuiEnableShadowL );

   342     

   343     CHuiTexture* texTure = CHuiTexture::NewL();

   344     CleanupStack::PushL( texTure );

   345     

   346     texTure->EnableShadow();

   347     texTure->SetSkinContent( ETrue );

   348     

   349     // Set shadow enabled

   350     texTure->EnableShadow();

   351     STIF_ASSERT_TRUE(texTure->IsShadowEnabled());

   352     STIF_ASSERT_TRUE(texTure->IsSkinContent());

   353     

   354     // Set skin content

   355     texTure->EnableShadow(EFalse);

   356     texTure->SetSkinContent(ETrue);

   357     STIF_ASSERT_TRUE( ! texTure->IsShadowEnabled() );

   358     STIF_ASSERT_TRUE( texTure->IsSkinContent() );

   359     

   360     // Set skin content and shadow enabled

   361     texTure->EnableShadow();

   362     STIF_ASSERT_TRUE(texTure->IsShadowEnabled() );

   363     STIF_ASSERT_TRUE(texTure->IsSkinContent() );

   364     

   365     CleanupStack::PopAndDestroy( texTure );

   366     

   367     return KErrNone;

   368     

   369     }

   370 

   371 // -----------------------------------------------------------------------------

   372 // CTestUiAifCoreToolkit::TestTHuiIsShadowEnabledL

   373 // -----------------------------------------------------------------------------

   374 //

   375 TInt CTestUiAifCoreToolkit::TestTHuiIsShadowEnabledL( CStifItemParser& /*aItem*/ )

   376     {

   377 

   378     // Print to UI

   379     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   380     _LIT( KTestTHuiIsShadowEnabledL, "In TestTHuiIsShadowEnabledL" );

   381     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiIsShadowEnabledL );

   382     // Print to log file 

   383     iLog->Log( KTestTHuiIsShadowEnabledL );

   384     

   385     CHuiTexture* texTure = CHuiTexture::NewL();

   386     CleanupStack::PushL( texTure );

   387     

   388     STIF_ASSERT_TRUE( texTure->IsShadowEnabled() == EFalse );

   389     

   390     CleanupStack::PopAndDestroy( texTure );

   391     

   392     return KErrNone;

   393     

   394     }

   395 

   396 // -----------------------------------------------------------------------------

   397 // CTestUiAifCoreToolkit::TestTHuiSetShadowStyleL

   398 // -----------------------------------------------------------------------------

   399 //

   400 TInt CTestUiAifCoreToolkit::TestTHuiSetShadowStyleL( CStifItemParser& /*aItem*/ )

   401     {

   402 

   403     // Print to UI

   404     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   405     _LIT( KTestTHuiSetShadowStyleL, "In TestTHuiSetShadowStyleL" );

   406     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSetShadowStyleL );

   407     // Print to log file 

   408     iLog->Log( KTestTHuiSetShadowStyleL );

   409     

   410     CHuiTexture* texTure = CHuiTexture::NewL();

   411     CleanupStack::PushL( texTure );

   412     

   413     texTure->SetShadowStyle( EHuiTextureShadowStyleIcon );

   414     

   415     CleanupStack::PopAndDestroy( texTure );

   416     

   417     return KErrNone;

   418     

   419     }

   420 

   421 // -----------------------------------------------------------------------------

   422 // CTestUiAifCoreToolkit::TestTHuiShadowStyleL

   423 // -----------------------------------------------------------------------------

   424 //

   425 TInt CTestUiAifCoreToolkit::TestTHuiShadowStyleL( CStifItemParser& /*aItem*/ )

   426     {

   427 

   428     // Print to UI

   429     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   430     _LIT( KTestTHuiShadowStyleL, "In TestTHuiShadowStyleL" );

   431     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiShadowStyleL );

   432     // Print to log file 

   433     iLog->Log( KTestTHuiShadowStyleL );

   434     

   435     CHuiTexture* texTure = CHuiTexture::NewL();

   436     CleanupStack::PushL( texTure );

   437     

   438     STIF_ASSERT_EQUALS( texTure->ShadowStyle(), EHuiTextureShadowStyleIcon);

   439     

   440     CleanupStack::PopAndDestroy( texTure );

   441     

   442     return KErrNone;

   443     

   444     }

   445 

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

   447 // CTestUiAifCoreToolkit::TestTHuiSetSizeL

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

   449 //

   450 TInt CTestUiAifCoreToolkit::TestTHuiSetSizeL( CStifItemParser& /*aItem*/ )

   451     {

   452 

   453     // Print to UI

   454     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   455     _LIT( KTestTHuiSetSizeL, "In TestTHuiSetSizeL" );

   456     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSetSizeL );

   457     // Print to log file 

   458     iLog->Log( KTestTHuiSetSizeL );

   459     

   460     CHuiTexture* texTure = CHuiTexture::NewL();

   461     CleanupStack::PushL( texTure );

   462     

   463     TSize size(10,29);

   464     texTure->SetSize( size );

   465     

   466     CleanupStack::PopAndDestroy( texTure );

   467     

   468     return KErrNone;

   469     

   470     }

   471 

   472 // -----------------------------------------------------------------------------

   473 // CTestUiAifCoreToolkit::TestTHuiSizeL

   474 // -----------------------------------------------------------------------------

   475 //

   476 TInt CTestUiAifCoreToolkit::TestTHuiSizeL( CStifItemParser& /*aItem*/ )

   477     {

   478 

   479     // Print to UI

   480     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   481     _LIT( KTestTHuiSizeL, "In TestTHuiSizeL" );

   482     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSizeL );

   483     // Print to log file 

   484     iLog->Log( KTestTHuiSizeL );

   485     

   486     CHuiTexture* texTure = CHuiTexture::NewL();

   487     CleanupStack::PushL( texTure );

   488     

   489     texTure->Size();

   490     

   491     CleanupStack::PopAndDestroy( texTure );

   492     

   493     return KErrNone;

   494     

   495     }

   496 

   497 // -----------------------------------------------------------------------------

   498 // CTestUiAifCoreToolkit::TestTHuiSegmentCountL

   499 // -----------------------------------------------------------------------------

   500 //

   501 TInt CTestUiAifCoreToolkit::TestTHuiSegmentCountL( CStifItemParser& /*aItem*/ )

   502     {

   503 

   504     // Print to UI

   505     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   506     _LIT( KTestTHuiSegmentCountL, "In TestTHuiSegmentCountL" );

   507     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSegmentCountL );

   508     // Print to log file 

   509     iLog->Log( KTestTHuiSegmentCountL );

   510     

   511     CHuiTexture* texTure = CHuiTexture::NewL();

   512     CleanupStack::PushL( texTure );

   513     

   514     STIF_ASSERT_EQUALS(texTure->SegmentCount(), 0);

   515     

   516     CleanupStack::PopAndDestroy( texTure );

   517     

   518     return KErrNone;

   519     

   520     }

   521 

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

   523 // CTestUiAifCoreToolkit::TestTHuiSegmentNameL

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

   525 //

   526 TInt CTestUiAifCoreToolkit::TestTHuiSegmentNameL( CStifItemParser& /*aItem*/ )

   527     {

   528 

   529     // Print to UI

   530     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   531     _LIT( KTestTHuiSegmentNameL, "In TestTHuiSegmentNameL" );

   532     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSegmentNameL );

   533     // Print to log file 

   534     iLog->Log( KTestTHuiSegmentNameL );

   535     

   536     CHuiTexture* texTure = CHuiTexture::NewL();

   537     CleanupStack::PushL( texTure );

   538     

   539     TUint8* image = 0;

   540     THuiTextureFormat aFormat = EHuiTextureFormatRgb888;

   541     TInt imageSize = (aFormat == EHuiTextureFormatRgb888 ? 3 : 4) * 100 * 200;

   542     image = new (ELeave) TUint8[imageSize];

   543     CleanupStack::PushL(image);

   544     for(TInt t=0; t<imageSize; t++)

   545         {

   546         image[t] = ((t % 3) + 1) * 2; // 2,4,6

   547         }

   548     // try to upload!

   549     texTure->UploadL(aFormat,

   550                      TSize(100, 200),

   551                      image,

   552                      EHuiTextureUploadFlagRetainResolution);

   553     

   554     TInt temp = 0;

   555     texTure->SegmentName( temp );

   556     

   557     CleanupStack::PopAndDestroy(image);

   558     CleanupStack::PopAndDestroy( texTure );

   559     

   560     

   561     return KErrNone;

   562     

   563     }

   564 

   565 // -----------------------------------------------------------------------------

   566 // CTestUiAifCoreToolkit::TestTHuiSegmentSizeL

   567 // -----------------------------------------------------------------------------

   568 //

   569 TInt CTestUiAifCoreToolkit::TestTHuiSegmentSizeL( CStifItemParser& /*aItem*/ )

   570     {

   571 

   572     // Print to UI

   573     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   574     _LIT( KTestTHuiSegmentSizeL, "In TestTHuiSegmentSizeL" );

   575     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSegmentSizeL );

   576     // Print to log file 

   577     iLog->Log( KTestTHuiSegmentSizeL );

   578     

   579     CHuiTexture* texTure = CHuiTexture::NewL();

   580     CleanupStack::PushL( texTure );

   581     

   582     TUint8* image = 0;

   583     THuiTextureFormat aFormat = EHuiTextureFormatRgb888;

   584     TInt imageSize = (aFormat == EHuiTextureFormatRgb888 ? 3 : 4) * 100 * 200;

   585     image = new (ELeave) TUint8[imageSize];

   586     CleanupStack::PushL(image);

   587     for(TInt t=0; t<imageSize; t++)

   588         {

   589         image[t] = ((t % 3) + 1) * 2; // 2,4,6

   590         }

   591     // try to upload!

   592     texTure->UploadL(aFormat,

   593                      TSize(100, 200),

   594                      image,

   595                      EHuiTextureUploadFlagRetainResolution);

   596     

   597     TInt temp = 0;

   598     texTure->SegmentSize( temp );

   599     

   600     CleanupStack::PopAndDestroy(image);

   601     CleanupStack::PopAndDestroy( texTure );

   602     

   603     return KErrNone;

   604     

   605     }

   606 

   607 // -----------------------------------------------------------------------------

   608 // CTestUiAifCoreToolkit::TestTHuiSegmentTextureSizeL

   609 // -----------------------------------------------------------------------------

   610 //

   611 TInt CTestUiAifCoreToolkit::TestTHuiSegmentTextureSizeL( CStifItemParser& /*aItem*/ )

   612     {

   613 

   614     // Print to UI

   615     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   616     _LIT( KTestTHuiSegmentTextureSizeL, "In TestTHuiSegmentTextureSizeL" );

   617     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,

   618             KTestTHuiSegmentTextureSizeL );

   619     // Print to log file 

   620     iLog->Log( KTestTHuiSegmentTextureSizeL );

   621     

   622     CHuiTexture* texTure = CHuiTexture::NewL();

   623     CleanupStack::PushL( texTure );

   624     

   625     TUint8* image = 0;

   626     THuiTextureFormat aFormat = EHuiTextureFormatRgb888;

   627     TInt imageSize = (aFormat == EHuiTextureFormatRgb888 ? 3 : 4) * 100 * 200;

   628     image = new (ELeave) TUint8[imageSize];

   629     CleanupStack::PushL(image);

   630     for(TInt t=0; t<imageSize; t++)

   631         {

   632         image[t] = ((t % 3) + 1) * 2; // 2,4,6

   633         }

   634     // try to upload!

   635     texTure->UploadL(aFormat,

   636                      TSize(100, 200),

   637                      image,

   638                      EHuiTextureUploadFlagRetainResolution);

   639     

   640     TInt temp = 0;

   641     texTure->SegmentTextureSize( temp );

   642     

   643     CleanupStack::PopAndDestroy(image);

   644     CleanupStack::PopAndDestroy( texTure );

   645     

   646     return KErrNone;

   647     

   648     }

   649 

   650 // -----------------------------------------------------------------------------

   651 // CTestUiAifCoreToolkit::TestTHuiSegmentOffsetL

   652 // -----------------------------------------------------------------------------

   653 //

   654 TInt CTestUiAifCoreToolkit::TestTHuiSegmentOffsetL( CStifItemParser& /*aItem*/ )

   655     {

   656 

   657     // Print to UI

   658     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   659     _LIT( KTestTHuiSegmentOffsetL, "In TestTHuiSegmentOffsetL" );

   660     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSegmentOffsetL );

   661     // Print to log file 

   662     iLog->Log( KTestTHuiSegmentOffsetL );

   663     

   664     CHuiTexture* texTure = CHuiTexture::NewL();

   665     CleanupStack::PushL( texTure );

   666     

   667     TUint8* image = 0;

   668     THuiTextureFormat aFormat = EHuiTextureFormatRgb888;

   669     TInt imageSize = (aFormat == EHuiTextureFormatRgb888 ? 3 : 4) * 100 * 200;

   670     image = new (ELeave) TUint8[imageSize];

   671     CleanupStack::PushL(image);

   672     for(TInt t=0; t<imageSize; t++)

   673         {

   674         image[t] = ((t % 3) + 1) * 2; // 2,4,6

   675         }

   676     // try to upload!

   677     texTure->UploadL(aFormat,

   678                      TSize(100, 200),

   679                      image,

   680                      EHuiTextureUploadFlagRetainResolution);

   681     

   682     TInt temp = 0;

   683     texTure->SegmentOffset( temp );

   684     

   685     CleanupStack::PopAndDestroy(image);

   686     CleanupStack::PopAndDestroy( texTure );

   687     

   688     return KErrNone;

   689     

   690     }

   691 

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

   693 // CTestUiAifCoreToolkit::TestTHuiTextureChangedL

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

   695 //

   696 TInt CTestUiAifCoreToolkit::TestTHuiTextureChangedL( CStifItemParser& /*aItem*/ )

   697     {

   698 

   699     // Print to UI

   700     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   701     _LIT( KTestTHuiTextureChangedL, "In TestTHuiTextureChangedL" );

   702     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextureChangedL );

   703     // Print to log file 

   704     iLog->Log( KTestTHuiTextureChangedL );

   705     

   706     CHuiTexture* texTure = CHuiTexture::NewL();

   707     CleanupStack::PushL( texTure );

   708     

   709     STIF_ASSERT_TRUE( texTure->TextureChanged() == EFalse);

   710     

   711     CleanupStack::PopAndDestroy( texTure );

   712     

   713     return KErrNone;

   714     

   715     }

   716 

   717 // -----------------------------------------------------------------------------

   718 // CTestUiAifCoreToolkit::TestTHuiTextureClearChangedL

   719 // -----------------------------------------------------------------------------

   720 //

   721 TInt CTestUiAifCoreToolkit::TestTHuiTextureClearChangedL( CStifItemParser& /*aItem*/ )

   722     {

   723 

   724     // Print to UI

   725     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   726     _LIT( KTestTHuiTextureClearChangedL, "In TestTHuiTextureClearChangedL" );

   727     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTextureClearChangedL );

   728     // Print to log file 

   729     iLog->Log( KTestTHuiTextureClearChangedL );

   730     

   731     CHuiTexture* texTure = CHuiTexture::NewL();

   732     CleanupStack::PushL( texTure );

   733     

   734     texTure->TextureClearChanged();

   735     

   736     CleanupStack::PopAndDestroy( texTure );

   737     

   738     return KErrNone;

   739     

   740     }

   741 

   742 

   743 // -----------------------------------------------------------------------------

   744 // CTestUiAifCoreToolkit::TestTHuiSetTextureChangedL

   745 // -----------------------------------------------------------------------------

   746 //

   747 TInt CTestUiAifCoreToolkit::TestTHuiSetSegmentOffsetL( CStifItemParser& /*aItem*/ )

   748     {

   749 

   750     // Print to UI

   751     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   752     _LIT( KTestTHuiSetSegmentOffsetL, "In TestTHuiSetSegmentOffsetL" );

   753     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSetSegmentOffsetL );

   754     // Print to log file 

   755     iLog->Log( KTestTHuiSetSegmentOffsetL );

   756     

   757     CHuiTexture* texTure = CHuiTexture::NewL();

   758     CleanupStack::PushL( texTure );

   759     

   760     TUint8* image = 0;

   761     THuiTextureFormat aFormat = EHuiTextureFormatRgb888;

   762     TInt imageSize = (aFormat == EHuiTextureFormatRgb888 ? 3 : 4) * 100 * 200;

   763     image = new (ELeave) TUint8[imageSize];

   764     CleanupStack::PushL(image);

   765     for(TInt t=0; t<imageSize; t++)

   766         {

   767         image[t] = ((t % 3) + 1) * 2; // 2,4,6

   768         }

   769     // try to upload!

   770     texTure->UploadL(aFormat,

   771                      TSize(100, 200),

   772                      image,

   773                      EHuiTextureUploadFlagRetainResolution);

   774     

   775     TInt temp = 0;

   776     TPoint size( 10,20 );

   777     texTure->SetSegmentOffset( temp, size );

   778     

   779     CleanupStack::PopAndDestroy(image);

   780     CleanupStack::PopAndDestroy( texTure );

   781     

   782     return KErrNone;

   783     

   784     }

   785 

   786 // -----------------------------------------------------------------------------

   787 // CTestUiAifCoreToolkit::TestTHuiSetSegmentCountL

   788 // -----------------------------------------------------------------------------

   789 //

   790 TInt CTestUiAifCoreToolkit::TestTHuiSetSegmentCountL( CStifItemParser& /*aItem*/ )

   791     {

   792 

   793     // Print to UI

   794     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   795     _LIT( KTestTHuiSetSegmentCountL, "In TestTHuiSetSegmentCountL" );

   796     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, 

   797             KTestTHuiSetSegmentCountL );

   798     // Print to log file 

   799     iLog->Log( KTestTHuiSetSegmentCountL );

   800     

   801     CHuiTexture* texTure = CHuiTexture::NewL();

   802     CleanupStack::PushL( texTure );

   803     

   804     TInt temp = texTure->SegmentCount() ;

   805     texTure->SetSegmentCountL( temp );

   806     

   807     CleanupStack::PopAndDestroy( texTure );

   808     

   809     return KErrNone;

   810     

   811     }

   812 

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

   814 // CTestUiAifCoreToolkit::TestTHuiSetSegmentNameL

   815 // -----------------------------------------------------------------------------

   816 //

   817 TInt CTestUiAifCoreToolkit::TestTHuiSetSegmentNameL( CStifItemParser& /*aItem*/ )

   818     {

   819 

   820     // Print to UI

   821     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   822     _LIT( KTestTHuiSetSegmentCountL, "In TestTHuiSetSegmentCountL" );

   823     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, 

   824             KTestTHuiSetSegmentCountL );

   825     // Print to log file 

   826     iLog->Log( KTestTHuiSetSegmentCountL );

   827     

   828     CHuiTexture* texTure = CHuiTexture::NewL();

   829     CleanupStack::PushL( texTure );

   830     

   831     TUint8* image = 0;

   832     THuiTextureFormat aFormat = EHuiTextureFormatRgb888;

   833     TInt imageSize = (aFormat == EHuiTextureFormatRgb888 ? 3 : 4) * 100 * 200;

   834     image = new (ELeave) TUint8[imageSize];

   835     CleanupStack::PushL(image);

   836     for(TInt t=0; t<imageSize; t++)

   837         {

   838         image[t] = ((t % 3) + 1) * 2; // 2,4,6

   839         }

   840     // try to upload!

   841     texTure->UploadL(aFormat,

   842                      TSize(100, 200),

   843                      image,

   844                      EHuiTextureUploadFlagRetainResolution);

   845     

   846     TInt temp = 0;

   847     TUint name = 3;

   848     texTure->SetSegmentName( temp, name);

   849     

   850     CleanupStack::PopAndDestroy( image );

   851     CleanupStack::PopAndDestroy( texTure );

   852     

   853     return KErrNone;

   854     

   855     }

   856 

   857 // -----------------------------------------------------------------------------

   858 // CTestUiAifCoreToolkit::TestTHuiSetSegmentSizeL

   859 // -----------------------------------------------------------------------------

   860 //

   861 TInt CTestUiAifCoreToolkit::TestTHuiSetSegmentSizeL( CStifItemParser& /*aItem*/ )

   862     {

   863 

   864     // Print to UI

   865     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   866     _LIT( KTestTHuiSetSegmentSizeL, "In TestTHuiSetSegmentSizeL" );

   867     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, 

   868             KTestTHuiSetSegmentSizeL );

   869     // Print to log file 

   870     iLog->Log( KTestTHuiSetSegmentSizeL );

   871     

   872     CHuiTexture* texTure = CHuiTexture::NewL();

   873     CleanupStack::PushL( texTure );

   874     

   875     TUint8* image = 0;

   876     THuiTextureFormat aFormat = EHuiTextureFormatRgb888;

   877     TInt imageSize = (aFormat == EHuiTextureFormatRgb888 ? 3 : 4) * 100 * 200;

   878     image = new (ELeave) TUint8[imageSize];

   879     CleanupStack::PushL(image);

   880     for(TInt t=0; t<imageSize; t++)

   881         {

   882         image[t] = ((t % 3) + 1) * 2; // 2,4,6

   883         }

   884     // try to upload!

   885     texTure->UploadL(aFormat,

   886                      TSize(100, 200),

   887                      image,

   888                      EHuiTextureUploadFlagRetainResolution);

   889     

   890     TInt temp = 0 ;

   891     TSize size( 10,20 );

   892     texTure->SetSegmentSize( temp, size );

   893     

   894     CleanupStack::PopAndDestroy( image );

   895     CleanupStack::PopAndDestroy( texTure );

   896     

   897     return KErrNone;

   898     

   899     }

   900 

   901 // -----------------------------------------------------------------------------

   902 // CTestUiAifCoreToolkit::TestTHuiSetSegmentTextureSizeL

   903 // -----------------------------------------------------------------------------

   904 //

   905 TInt CTestUiAifCoreToolkit::TestTHuiSetSegmentTextureSizeL( CStifItemParser& /*aItem*/ )

   906     {

   907 

   908     // Print to UI

   909     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   910     _LIT( KTestTHuiSetSegmentSizeL, "In TestTHuiSetSegmentSizeL" );

   911     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, 

   912             KTestTHuiSetSegmentSizeL );

   913     // Print to log file 

   914     iLog->Log( KTestTHuiSetSegmentSizeL );

   915     

   916     CHuiTexture* texTure = CHuiTexture::NewL();

   917     CleanupStack::PushL( texTure );

   918     

   919     TUint8* image = 0;

   920     THuiTextureFormat aFormat = EHuiTextureFormatRgb888;

   921     TInt imageSize = (aFormat == EHuiTextureFormatRgb888 ? 3 : 4) * 100 * 200;

   922     image = new (ELeave) TUint8[imageSize];

   923     CleanupStack::PushL(image);

   924     for(TInt t=0; t<imageSize; t++)

   925         {

   926         image[t] = ((t % 3) + 1) * 2; // 2,4,6

   927         }

   928     // try to upload!

   929     texTure->UploadL(aFormat,

   930                      TSize(100, 200),

   931                      image,

   932                      EHuiTextureUploadFlagRetainResolution);

   933     

   934     TInt temp = 0 ;

   935     TSize size( 10,20 );

   936     texTure->SetSegmentTextureSize( temp, size );

   937     

   938     CleanupStack::PopAndDestroy( image );

   939     CleanupStack::PopAndDestroy( texTure );

   940     

   941     return KErrNone;

   942     

   943     }

   944 

   945 // -----------------------------------------------------------------------------

   946 // CTestUiAifCoreToolkit::TestTHuiSetSkinContentL

   947 // -----------------------------------------------------------------------------

   948 //

   949 TInt CTestUiAifCoreToolkit::TestTHuiSetSkinContentL( CStifItemParser& /*aItem*/ )

   950     {

   951 

   952     // Print to UI

   953     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   954     _LIT( KTestTHuiSetSkinContentL, "In TestTHuiSetSkinContentL" );

   955     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSetSkinContentL );

   956     // Print to log file 

   957     iLog->Log( KTestTHuiSetSkinContentL );

   958     

   959     CHuiTexture* texTure = CHuiTexture::NewL();

   960     CleanupStack::PushL( texTure );

   961 

   962     texTure->SetSkinContent( ETrue );

   963     

   964     CleanupStack::PopAndDestroy( texTure );

   965     

   966     return KErrNone;

   967     

   968     }

   969 

   970 // -----------------------------------------------------------------------------

   971 // CTestUiAifCoreToolkit::TestTHuiIsSkinContentL

   972 // -----------------------------------------------------------------------------

   973 //

   974 TInt CTestUiAifCoreToolkit::TestTHuiIsSkinContentL( CStifItemParser& /*aItem*/ )

   975     {

   976 

   977     // Print to UI

   978     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   979     _LIT( KTestTHuiIsSkinContentL, "In TestTHuiIsSkinContentL" );

   980     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiIsSkinContentL );

   981     // Print to log file 

   982     iLog->Log( KTestTHuiIsSkinContentL );

   983     

   984     CHuiTexture* texTure = CHuiTexture::NewL();

   985     CleanupStack::PushL( texTure );

   986     

   987     STIF_ASSERT_TRUE( !texTure->IsSkinContent());

   988     

   989     CleanupStack::PopAndDestroy( texTure );

   990     

   991     return KErrNone;

   992     

   993     }

   994 

   995 // -----------------------------------------------------------------------------

   996 // CTestUiAifCoreToolkit::TestTHuiTypeL

   997 // -----------------------------------------------------------------------------

   998 //

   999 TInt CTestUiAifCoreToolkit::TestTHuiTypeL( CStifItemParser& /*aItem*/ )

  1000     {

  1001 

  1002     // Print to UI

  1003     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1004     _LIT( KTestTHuiTypeL, "In TestTHuiTypeL" );

  1005     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiTypeL );

  1006     // Print to log file 

  1007     iLog->Log( KTestTHuiTypeL );

  1008     

  1009     CHuiTexture* texTure = CHuiTexture::NewL();

  1010     CleanupStack::PushL( texTure );

  1011 

  1012     texTure->Type();

  1013     

  1014     CleanupStack::PopAndDestroy( texTure );

  1015     

  1016     return KErrNone;

  1017     

  1018     }

  1019 

  1020 // -----------------------------------------------------------------------------

  1021 // CTestUiAifCoreToolkit::TestTHuiSessionIdL

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

  1023 //

  1024 TInt CTestUiAifCoreToolkit::TestTHuiSessionIdL( CStifItemParser& /*aItem*/ )

  1025     {

  1026 

  1027     // Print to UI

  1028     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1029     _LIT( KTestTHuiSessionIdL, "In TestTHuiSessionIdL" );

  1030     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSessionIdL );

  1031     // Print to log file 

  1032     iLog->Log( KTestTHuiSessionIdL );

  1033     

  1034     CHuiTexture* texTure = CHuiTexture::NewL();

  1035     CleanupStack::PushL( texTure );

  1036 

  1037     texTure->SessionId();

  1038     

  1039     CleanupStack::PopAndDestroy( texTure );

  1040     

  1041     return KErrNone;

  1042     

  1043     }

  1044 

  1045 // -----------------------------------------------------------------------------

  1046 // CTestUiAifCoreToolkit::TestTHuiSetSessionIdL

  1047 // -----------------------------------------------------------------------------

  1048 //

  1049 TInt CTestUiAifCoreToolkit::TestTHuiSetSessionIdL( CStifItemParser& /*aItem*/ )

  1050     {

  1051 

  1052     // Print to UI

  1053     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1054     _LIT( KTestTHuiSetSessionIdL, "In TestTHuiSetSessionIdL" );

  1055     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSetSessionIdL );

  1056     // Print to log file 

  1057     iLog->Log( KTestTHuiSetSessionIdL );

  1058     

  1059     CHuiTexture* texTure = CHuiTexture::NewL();

  1060     CleanupStack::PushL( texTure );

  1061     TInt temp = 2 ;

  1062     texTure->SetSessionId( temp );

  1063     

  1064     CleanupStack::PopAndDestroy( texTure );

  1065     

  1066     return KErrNone;

  1067     

  1068     }

  1069 

  1070 // -----------------------------------------------------------------------------

  1071 // CTestUiAifCoreToolkit::TestTHuiSetPriorityL

  1072 // -----------------------------------------------------------------------------

  1073 //

  1074 TInt CTestUiAifCoreToolkit::TestTHuiSetPriorityL( CStifItemParser& /*aItem*/ )

  1075     {

  1076 

  1077     // Print to UI

  1078     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1079     _LIT( KTestTHuiSetPriorityL, "In TestTHuiSetPriorityL" );

  1080     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiSetPriorityL );

  1081     // Print to log file 

  1082     iLog->Log( KTestTHuiSetPriorityL );

  1083     

  1084     CHuiTexture* texTure = CHuiTexture::NewL();

  1085     CleanupStack::PushL( texTure );

  1086     TInt temp = 2 ;

  1087     texTure->SetPriority( temp );

  1088     

  1089     CleanupStack::PopAndDestroy( texTure );

  1090     

  1091     return KErrNone;

  1092     

  1093     }

  1094 

  1095 // -----------------------------------------------------------------------------

  1096 // CTestUiAifCoreToolkit::TestTHuiPriorityL

  1097 // -----------------------------------------------------------------------------

  1098 //

  1099 TInt CTestUiAifCoreToolkit::TestTHuiPriorityL( CStifItemParser& /*aItem*/ )

  1100     {

  1101 

  1102     // Print to UI

  1103     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1104     _LIT( KTestTHuiPriorityL, "In TestTHuiPriorityL" );

  1105     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiPriorityL );

  1106     // Print to log file 

  1107     iLog->Log( KTestTHuiPriorityL );

  1108     

  1109     CHuiTexture* texTure = CHuiTexture::NewL();

  1110     CleanupStack::PushL( texTure );

  1111     

  1112     texTure->Priority();

  1113     

  1114     CleanupStack::PopAndDestroy( texTure );

  1115     

  1116     return KErrNone;

  1117     

  1118     }

  1119 

  1120 // -----------------------------------------------------------------------------

  1121 // CTestUiAifCoreToolkit::TestTHuiEnableAutoSizeCalculationL

  1122 // -----------------------------------------------------------------------------

  1123 //

  1124 TInt CTestUiAifCoreToolkit::TestTHuiEnableAutoSizeCalculationL( CStifItemParser& /*aItem*/ )

  1125     {

  1126 

  1127     // Print to UI

  1128     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1129     _LIT( KTestTHuiEnableAutoSizeCalculationL, 

  1130             "In TestTHuiEnableAutoSizeCalculationL" );

  1131     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,

  1132             KTestTHuiEnableAutoSizeCalculationL );

  1133     // Print to log file 

  1134     iLog->Log( KTestTHuiEnableAutoSizeCalculationL );