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 <avkon.mbg>

    23 #include <stifparser.h>

    24 #include <stiftestinterface.h>

    25 #include <uiacceltk/huienv.h>

    26 #include <uiacceltk/huistatic.h>

    27 #include <uiacceltk/huievent.h>

    28 #include <uiacceltk/huieventhandler.h>

    29 #include "testuiaifcoretoolkit.h"

    30 

    31 

    32 //this class test for MHuiEventHandler class

    33 

    34 class CHuiEventHandlerImp : public  CBase, MHuiEventHandler

    35     {

    36 public:

    37     //default construct

    38     CHuiEventHandlerImp()

    39         {

    40         }

    41     //inherite from MHuiEventHandler

    42     TBool OfferEventL(const THuiEvent& /*aEvent*/)

    43         {

    44         return ETrue;

    45         }

    46     };

    47 // -----------------------------------------------------------------------------

    48 // CTestUiAifCoreToolkit::TestTTHuiCEnvHuiEnvLC

    49 // -----------------------------------------------------------------------------

    50 //

    51 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvHuiEnvLC( CStifItemParser& /*aItem*/ )

    52     {

    53 

    54     // Print to UI

    55     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

    56     _LIT( KTestTTHuiCEnvHuiEnvLC, "In TestTTHuiCEnvHuiEnvLC" );

    57     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvHuiEnvLC );

    58     // Print to log file 

    59     iLog->Log( KTestTTHuiCEnvHuiEnvLC );

    60     

    61     //NewLC function has been call by the NewL function.

    62     

    63     return KErrNone;

    64     

    65     }

    66 

    67 // -----------------------------------------------------------------------------

    68 // CTestUiAifCoreToolkit::TestTTHuiCEnvRenderer

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

    70 //

    71 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvRenderer( CStifItemParser& /*aItem*/ )

    72     {

    73 

    74     // Print to UI

    75     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

    76     _LIT( KTestTTHuiCEnvRenderer, "In TestTTHuiCEnvRenderer" );

    77     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvRenderer );

    78     // Print to log file 

    79     iLog->Log( KTestTTHuiCEnvRenderer );

    80     

    81     iHuiEnv->Renderer();

    82     

    83     return KErrNone;

    84     

    85     }

    86 

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

    88 // CTestUiAifCoreToolkit::TestTTHuiCEnvNewDisplayL

    89 // -----------------------------------------------------------------------------

    90 //

    91 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvNewDisplayL( CStifItemParser& /*aItem*/ )

    92     {

    93 

    94     // Print to UI

    95     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

    96     _LIT( KTestTTHuiCEnvNewDisplayL, "In TestTTHuiCEnvNewDisplayL" );

    97     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvNewDisplayL );

    98     // Print to log file 

    99     iLog->Log( KTestTTHuiCEnvNewDisplayL );

   100     

   101     iHuiEnv->NewDisplayL( iDisplayRect, NULL, 0, NULL, CHuiDisplay::EDisplayNormal);

   102     

   103     return KErrNone;

   104     

   105     }

   106 

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

   108 // CTestUiAifCoreToolkit::TestTTHuiCEnvNewDisplayLL

   109 // -----------------------------------------------------------------------------

   110 //

   111 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvNewDisplayLL( CStifItemParser& /*aItem*/ )

   112     {

   113 

   114     // Print to UI

   115     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   116     _LIT( KTestTTHuiCEnvNewDisplayLL, "In TestTTHuiCEnvNewDisplayLL" );

   117     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvNewDisplayLL );

   118     // Print to log file 

   119     iLog->Log( KTestTTHuiCEnvNewDisplayLL );

   120     

   121     TUid bufferUid = {KTestScreenBufferUidValue};

   122     CHuiDisplay* huiDisplay = &iHuiEnv->NewDisplayL(iDisplayRect, NULL, 0, NULL, 

   123         CHuiDisplay::EDisplayNormal,bufferUid );

   124     return KErrNone;

   125     

   126     }

   127 

   128 // -----------------------------------------------------------------------------

   129 // CTestUiAifCoreToolkit::TestTTHuiCEnvDisplayCount

   130 // -----------------------------------------------------------------------------

   131 //

   132 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvDisplayCount( CStifItemParser& /*aItem*/ )

   133     {

   134 

   135     // Print to UI

   136     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   137     _LIT( KTestTTHuiCEnvDisplayCount, "In TestTTHuiCEnvDisplayCount" );

   138     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvDisplayCount );

   139     // Print to log file 

   140     iLog->Log( KTestTTHuiCEnvDisplayCount );

   141     

   142     iHuiEnv->DisplayCount();

   143     

   144     return KErrNone;

   145     

   146     }

   147 

   148 // -----------------------------------------------------------------------------

   149 // CTestUiAifCoreToolkit::TestTTHuiCEnvSetRefreshMode

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

   151 //

   152 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvSetRefreshMode( CStifItemParser& /*aItem*/ )

   153     {

   154 

   155     // Print to UI

   156     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   157     _LIT( KTestTTHuiCEnvSetRefreshMode, "In TestTTHuiCEnvSetRefreshMode" );

   158     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvSetRefreshMode );

   159     // Print to log file 

   160     iLog->Log( KTestTTHuiCEnvSetRefreshMode );

   161     

   162     iHuiEnv->SetRefreshMode( EHuiRefreshModeManual );

   163     

   164     return KErrNone;

   165     

   166     }

   167 

   168 // -----------------------------------------------------------------------------

   169 // CTestUiAifCoreToolkit::TestTTHuiCEnvRefreshMode

   170 // -----------------------------------------------------------------------------

   171 //

   172 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvRefreshMode( CStifItemParser& /*aItem*/ )

   173     {

   174 

   175     // Print to UI

   176     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   177     _LIT( KTestTTHuiCEnvRefreshMode, "In TestTTHuiCEnvRefreshMode" );

   178     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvRefreshMode );

   179     // Print to log file 

   180     iLog->Log( KTestTTHuiCEnvRefreshMode );

   181     

   182     iHuiEnv->RefreshMode();

   183     

   184     return KErrNone;

   185     

   186     }

   187 

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

   189 // CTestUiAifCoreToolkit::TestTTHuiCEnvSetMaxFrameRate

   190 // -----------------------------------------------------------------------------

   191 //

   192 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvSetMaxFrameRate( CStifItemParser& /*aItem*/ )

   193     {

   194 

   195     // Print to UI

   196     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   197     _LIT( KTestTTHuiCEnvSetMaxFrameRate, "In TestTTHuiCEnvSetMaxFrameRate" );

   198     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvSetMaxFrameRate );

   199     // Print to log file 

   200     iLog->Log( KTestTTHuiCEnvSetMaxFrameRate );

   201     

   202     TReal32 real = 20;

   203     iHuiEnv->SetMaxFrameRate( real );

   204     

   205     return KErrNone;

   206     

   207     }

   208 

   209 // -----------------------------------------------------------------------------

   210 // CTestUiAifCoreToolkit::TestTTHuiCEnvContinueRefresh

   211 // -----------------------------------------------------------------------------

   212 //

   213 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvContinueRefresh( CStifItemParser& /*aItem*/ )

   214     {

   215 

   216     // Print to UI

   217     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   218     _LIT( KTestTTHuiCEnvContinueRefresh, "In TestTTHuiCEnvContinueRefresh" );

   219     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvContinueRefresh);

   220     // Print to log file 

   221     iLog->Log( KTestTTHuiCEnvContinueRefresh );

   222     

   223     iHuiEnv->ContinueRefresh();

   224     

   225     return KErrNone;

   226     

   227     }

   228 

   229 // -----------------------------------------------------------------------------

   230 // CTestUiAifCoreToolkit::TestTTHuiCEnvPauseRefresh

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

   232 //

   233 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvPauseRefresh( CStifItemParser& /*aItem*/ )

   234     {

   235 

   236     // Print to UI

   237     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   238     _LIT( KTestTTHuiCEnvPauseRefresh, "In TestTTHuiCEnvPauseRefresh" );

   239     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvPauseRefresh);

   240     // Print to log file 

   241     iLog->Log( KTestTTHuiCEnvPauseRefresh );

   242     

   243     iHuiEnv->PauseRefresh();

   244     

   245     return KErrNone;

   246     

   247     }

   248 

   249 // -----------------------------------------------------------------------------

   250 // CTestUiAifCoreToolkit::TestTTHuiCEnvNewControlGroupL

   251 // -----------------------------------------------------------------------------

   252 //

   253 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvNewControlGroupL( CStifItemParser& /*aItem*/ )

   254     {

   255 

   256     // Print to UI

   257     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   258     _LIT( KTestTTHuiCEnvNewControlGroupL, "In TestTTHuiCEnvNewControlGroupL" );

   259     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvNewControlGroupL);

   260     // Print to log file 

   261     iLog->Log( KTestTTHuiCEnvNewControlGroupL );

   262     

   263     TInt temp = 0;

   264     iHuiEnv->NewControlGroupL( temp );

   265     

   266     return KErrNone;

   267     

   268     }

   269 

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

   271 // CTestUiAifCoreToolkit::TestTTHuiCEnvDeleteControlGroup

   272 // -----------------------------------------------------------------------------

   273 //

   274 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvDeleteControlGroup( CStifItemParser& /*aItem*/ )

   275     {

   276 

   277     // Print to UI

   278     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   279     _LIT( KTestTTHuiCEnvDeleteControlGroup, "In TestTTHuiCEnvDeleteControlGroup" );

   280     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvDeleteControlGroup);

   281     // Print to log file 

   282     iLog->Log( KTestTTHuiCEnvDeleteControlGroup );

   283     

   284     TInt temp = 0;

   285     iHuiEnv->DeleteControlGroup( temp );

   286     

   287     return KErrNone;

   288     

   289     }

   290 

   291 // -----------------------------------------------------------------------------

   292 // CTestUiAifCoreToolkit::TestTTHuiCEnvLoadControlGroupL

   293 // -----------------------------------------------------------------------------

   294 //

   295 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvLoadControlGroupL( CStifItemParser& /*aItem*/ )

   296     {

   297 

   298     // Print to UI

   299     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   300     _LIT( KTestTTHuiCEnvLoadControlGroupL, "In TestTTHuiCEnvLoadControlGroupL" );

   301     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvLoadControlGroupL);

   302     // Print to log file 

   303     iLog->Log( KTestTTHuiCEnvLoadControlGroupL );

   304     

   305     TInt groupid = 0;

   306     iHuiEnv->LoadControlGroupL( groupid );

   307     

   308     return KErrNone;

   309     

   310     }

   311 

   312 // -----------------------------------------------------------------------------

   313 // CTestUiAifCoreToolkit::TestTTHuiCEnvControlGroup

   314 // -----------------------------------------------------------------------------

   315 //

   316 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvControlGroup( CStifItemParser& /*aItem*/ )

   317     {

   318 

   319     // Print to UI

   320     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   321     _LIT( KTestTTHuiCEnvControlGroup, "In TestTTHuiCEnvControlGroup" );

   322     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvControlGroup);

   323     // Print to log file 

   324     iLog->Log( KTestTTHuiCEnvControlGroup );

   325 

   326     iHuiEnv->ControlGroup( KHuiCtrlGroupId );

   327     return KErrNone;

   328     

   329     }

   330 

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

   332 // CTestUiAifCoreToolkit::TestTTHuiCEnvLoadBitmapsL

   333 // -----------------------------------------------------------------------------

   334 //

   335 TInt CTestUiAifCoreToolkit::TestTTHuiCEnvLoadBitmapsL( CStifItemParser& /*aItem*/ )

   336     {

   337 

   338     // Print to UI

   339     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   340     _LIT( KTestTTHuiCEnvLoadBitmapsL, "In TestTTHuiCEnvLoadBitmapsL" );

   341     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCEnvLoadBitmapsL);

   342     // Print to log file 

   343     iLog->Log( KTestTTHuiCEnvLoadBitmapsL );

   344     

   345     TInt bitmapid = 0;

   346     iHuiEnv->LoadBitmapsL( bitmapid );

   347     

   348     return KErrNone;

   349     

   350     }

   351 

   352 // -----------------------------------------------------------------------------

   353 // CTestUiAifCoreToolkit::TestTTHuiCVisualFactory

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

   355 //

   356 TInt CTestUiAifCoreToolkit::TestTTHuiCVisualFactory( CStifItemParser& /*aItem*/ )

   357     {

   358 

   359     // Print to UI

   360     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   361     _LIT( KTestTTHuiCVisualFactory, "In TestTTHuiCVisualFactory" );

   362     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCVisualFactory);

   363     // Print to log file 

   364     iLog->Log( KTestTTHuiCVisualFactory );

   365     

   366     iHuiEnv->VisualFactory();

   367     

   368     return KErrNone;

   369     

   370     }

   371 

   372 // -----------------------------------------------------------------------------

   373 // CTestUiAifCoreToolkit::TestTTHuiCTextureManager

   374 // -----------------------------------------------------------------------------

   375 //

   376 TInt CTestUiAifCoreToolkit::TestTTHuiCTextureManager( CStifItemParser& /*aItem*/ )

   377     {

   378 

   379     // Print to UI

   380     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   381     _LIT( KTestTTHuiCTextureManager, "In TestTTHuiCTextureManager" );

   382     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCTextureManager);

   383     // Print to log file 

   384     iLog->Log( KTestTTHuiCTextureManager );

   385     

   386     iHuiEnv->TextureManager();

   387     

   388     return KErrNone;

   389     

   390     }

   391 

   392 // -----------------------------------------------------------------------------

   393 // CTestUiAifCoreToolkit::TestTTHuiCFontManager

   394 // -----------------------------------------------------------------------------

   395 //

   396 TInt CTestUiAifCoreToolkit::TestTTHuiCFontManager( CStifItemParser& /*aItem*/ )

   397     {

   398 

   399     // Print to UI

   400     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   401     _LIT( KTestTTHuiCFontManager, "In TestTTHuiCFontManager" );

   402     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCFontManager);

   403     // Print to log file 

   404     iLog->Log( KTestTTHuiCFontManager );

   405     

   406     iHuiEnv->FontManager();

   407     

   408     return KErrNone;

   409     

   410     }

   411 

   412 // -----------------------------------------------------------------------------

   413 // CTestUiAifCoreToolkit::TestTTHuiCTextStyleManager

   414 // -----------------------------------------------------------------------------

   415 //

   416 TInt CTestUiAifCoreToolkit::TestTTHuiCTextStyleManager( CStifItemParser& /*aItem*/ )

   417     {

   418 

   419     // Print to UI

   420     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   421     _LIT( KTestTTHuiCTextStyleManager, "In TestTTHuiCTextStyleManager" );

   422     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCTextStyleManager);

   423     // Print to log file 

   424     iLog->Log( KTestTTHuiCTextStyleManager );

   425     

   426     iHuiEnv->TextStyleManager();

   427     

   428     return KErrNone;

   429     

   430     }

   431 

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

   433 // CTestUiAifCoreToolkit::TestTTHuiCFindControl

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

   435 //

   436 TInt CTestUiAifCoreToolkit::TestTTHuiCFindControl( CStifItemParser& /*aItem*/ )

   437     {

   438 

   439     // Print to UI

   440     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   441     _LIT( KTestTTHuiCFindControl, "In TestTTHuiCFindControl" );

   442     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCFindControl);

   443     // Print to log file 

   444     iLog->Log( KTestTTHuiCFindControl );

   445     

   446     TInt temp = 0;

   447     iHuiEnv->FindControl( temp );

   448     

   449     return KErrNone;

   450     

   451     }

   452 

   453 // -----------------------------------------------------------------------------

   454 // CTestUiAifCoreToolkit::TestTTHuiCSendL

   455 // -----------------------------------------------------------------------------

   456 //

   457 TInt CTestUiAifCoreToolkit::TestTTHuiCSendL( CStifItemParser& /*aItem*/ )

   458     {

   459 

   460     // Print to UI

   461     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   462     _LIT( KTestTTHuiCSendL, "In TestTTHuiCSendL" );

   463     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCSendL);

   464     // Print to log file 

   465     iLog->Log( KTestTTHuiCSendL );

   466     

   467     THuiCommand* aCommand = new ( ELeave )THuiActionCommand( 1 );

   468     CleanupStack::PushL( aCommand );

   469     iHuiEnv->Send( *aCommand );

   470     CleanupStack::PopAndDestroy( aCommand );

   471     return KErrNone;

   472     

   473     }

   474 

   475 // -----------------------------------------------------------------------------

   476 // CTestUiAifCoreToolkit::TestTTHuiCSendLL

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

   478 //

   479 TInt CTestUiAifCoreToolkit::TestTTHuiCSendLL( CStifItemParser& /*aItem*/ )

   480     {

   481 

   482     // Print to UI

   483     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   484     _LIT( KTestTTHuiCSendLL, "In TestTTHuiCSendLL" );

   485     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCSendLL);

   486     // Print to log file 

   487     iLog->Log( KTestTTHuiCSendLL );

   488     

   489     THuiCommand* aCommand = new ( ELeave )THuiActionCommand( 1 );

   490     CleanupStack::PushL( aCommand );

   491     

   492     iHuiEnv->SendL( *aCommand );

   493     

   494     CleanupStack::PopAndDestroy( aCommand );

   495     return KErrNone;

   496     

   497     }

   498 

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

   500 // CTestUiAifCoreToolkit::TestTTHuiCCancelCommandsL

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

   502 //

   503 TInt CTestUiAifCoreToolkit::TestTTHuiCCancelCommandsL( CStifItemParser& /*aItem*/ )

   504     {

   505 

   506     // Print to UI

   507     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   508     _LIT( KTestTTHuiCCancelCommandsL, "In TestTTHuiCCancelCommandsL" );

   509     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTTHuiCCancelCommandsL);

   510     // Print to log file 

   511     iLog->Log( KTestTTHuiCCancelCommandsL );

   512     

   513     THuiCommand* aCommand = new ( ELeave )THuiActionCommand( 1 );

   514     CleanupStack::PushL( aCommand );

   515     iHuiEnv->CancelCommands( &aCommand );

   516     CleanupStack::PopAndDestroy( aCommand );

   517     

   518     return KErrNone;

   519     

   520     }

   521 

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

   523 // CTestUiAifCoreToolkit::TestTTHuiCCancelCommandsL

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

   525 //

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

   527     {

   528 

   529     // Print to UI

   530     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   531     _LIT( KTestTTHuiCCancelCommandsEventHandlerL, 

   532             "In TestTTHuiCCancelCommandsEventHandlerL" );

   533     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,

   534             KTestTTHuiCCancelCommandsEventHandlerL);

   535     // Print to log file 

   536     iLog->Log( KTestTTHuiCCancelCommandsEventHandlerL );

   537     

   538     CHuiEventHandlerImp* eventHandler = new ( ELeave ) CHuiEventHandlerImp();

   539     CleanupStack::PushL( eventHandler );

   540     iHuiEnv->CancelCommands( &eventHandler );

   541     CleanupStack::PopAndDestroy( eventHandler );

   542     

   543     return KErrNone;

   544     

   545     }

   546 

   547 // -----------------------------------------------------------------------------

   548 // CTestUiAifCoreToolkit::TestTTHuiCCancelCommandsTHuiOpL

   549 // -----------------------------------------------------------------------------

   550 //

   551 TInt CTestUiAifCoreToolkit::TestTTHuiCCancelCommandsTHuiOpL( CStifItemParser& /*aItem*/ )

   552     {

   553 

   554     // Print to UI

   555     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   556     _LIT( KTestTTHuiCCancelCommandsTHuiOpL, 

   557             "In TestTTHuiCCancelCommandsTHuiOpL" );

   558     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,

   559             KTestTTHuiCCancelCommandsTHuiOpL);

   560     // Print to log file 

   561     iLog->Log( KTestTTHuiCCancelCommandsTHuiOpL );

   562     

   563     THuiCommand* aCommand = new ( ELeave )THuiActionCommand( EHuiOpNone );

   564     CleanupStack::PushL( aCommand );

   565     iHuiEnv->CancelCommands( &aCommand, EHuiOpNone);

   566     CleanupStack::PopAndDestroy( aCommand );

   567     

   568     return KErrNone;

   569     

   570     }

   571 

   572 // -----------------------------------------------------------------------------

   573 // CTestUiAifCoreToolkit::TestTTHuiCCancelCommandsTIntL

   574 // -----------------------------------------------------------------------------

   575 //

   576 TInt CTestUiAifCoreToolkit::TestTTHuiCCancelCommandsTIntL( CStifItemParser& /*aItem*/ )

   577     {

   578 

   579     // Print to UI

   580     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   581     _LIT( KTestTTHuiCCancelCommandsTIntL, 

   582             "In TestTTHuiCCancelCommandsTIntL" );

   583     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,

   584             KTestTTHuiCCancelCommandsTIntL);

   585     // Print to log file 

   586     iLog->Log( KTestTTHuiCCancelCommandsTIntL );

   587     

   588     TInt temp = 1;

   589     THuiCommand* aCommand = new ( ELeave )THuiActionCommand( temp );

   590     CleanupStack::PushL( aCommand );

   591     iHuiEnv->CancelCommands( &aCommand, EHuiCommandTypeNone, temp );

   592     CleanupStack::PopAndDestroy( aCommand );

   593     

   594     return KErrNone;

   595     

   596     }

   597 

   598 // -----------------------------------------------------------------------------

   599 // CTestUiAifCoreToolkit::TestTTHuiCTimeUntilCommandL

   600 // -----------------------------------------------------------------------------

   601 //

   602 TInt CTestUiAifCoreToolkit::TestTTHuiCTimeUntilCommandL( CStifItemParser& /*aItem*/ )

   603     {

   604 

   605     // Print to UI

   606     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   607     _LIT( KTestTTHuiCTimeUntilCommandL, 

   608             "In TestTTHuiCTimeUntilCommandL" );

   609     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,

   610             KTestTTHuiCTimeUntilCommandL);

   611     // Print to log file 

   612     iLog->Log( KTestTTHuiCTimeUntilCommandL );

   613     

   614     TInt temp = 1;

   615     THuiCommand* aCommand = new ( ELeave )THuiActionCommand( temp );

   616     CleanupStack::PushL( aCommand );

   617     iHuiEnv->TimeUntilCommand( aCommand, EHuiCommandTypeNone);

   618     CleanupStack::PopAndDestroy( aCommand );

   619     

   620     return KErrNone;

   621     

   622     }

   623 

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

   625 // CTestUiAifCoreToolkit::TestTTHuiCSkin

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

   627 //

   628 TInt CTestUiAifCoreToolkit::TestTTHuiCSkin( CStifItemParser& /*aItem*/ )

   629     {

   630 

   631     // Print to UI

   632     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   633     _LIT( KTestTTHuiCSkin, 

   634             "In TestTTHuiCSkin" );

   635     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTTHuiCSkin);

   636     // Print to log file 

   637     iLog->Log( KTestTTHuiCSkin );

   638     

   639     iHuiEnv->Skin();

   640     

   641     return KErrNone;

   642     

   643     }

   644 

   645 // -----------------------------------------------------------------------------

   646 // CTestUiAifCoreToolkit::TestTStartRefresh

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

   648 //

   649 TInt CTestUiAifCoreToolkit::TestTStartRefresh( CStifItemParser& /*aItem*/ )

   650     {

   651 

   652     // Print to UI

   653     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   654     _LIT( KTestTStartRefresh, "In TestTStartRefresh" );

   655     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTStartRefresh);

   656     // Print to log file 

   657     iLog->Log( KTestTStartRefresh );

   658     

   659     TInt refTime = 10;

   660     iHuiEnv->StartRefresh( refTime );

   661     

   662     return KErrNone;

   663     

   664     }

   665 

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

   667 // CTestUiAifCoreToolkit::TestTHandleKeyEventLL

   668 // -----------------------------------------------------------------------------

   669 //

   670 TInt CTestUiAifCoreToolkit::TestTHandleKeyEventLL( CStifItemParser& /*aItem*/ )

   671     {

   672 

   673     // Print to UI

   674     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   675     _LIT( KTestTHandleKeyEventLL, "In TestTHandleKeyEventLL" );

   676     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTHandleKeyEventLL);

   677     // Print to log file 

   678     iLog->Log( KTestTHandleKeyEventLL );

   679     

   680     TKeyEvent keyEvent;

   681     

   682     iHuiEnv->HandleKeyEventL( keyEvent, EEventKey );

   683     

   684     return KErrNone;

   685     

   686     }

   687 

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

   689 // CTestUiAifCoreToolkit::TestTSetIdleThreshold

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

   691 //

   692 TInt CTestUiAifCoreToolkit::TestTSetIdleThreshold( CStifItemParser& /*aItem*/ )

   693     {

   694 

   695     // Print to UI

   696     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   697     _LIT( KTestTSetIdleThreshold, "In TestTSetIdleThreshold" );

   698     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTSetIdleThreshold);

   699     // Print to log file 

   700     iLog->Log( KTestTSetIdleThreshold );

   701     

   702     TInt refTime = 10;

   703     iHuiEnv->SetIdleThreshold( refTime );

   704     

   705     return KErrNone;

   706     

   707     }

   708 

   709 // -----------------------------------------------------------------------------

   710 // CTestUiAifCoreToolkit::TestTBroadcastEventLL

   711 // -----------------------------------------------------------------------------

   712 //

   713 TInt CTestUiAifCoreToolkit::TestTBroadcastEventLL( CStifItemParser& /*aItem*/ )

   714     {

   715 

   716     // Print to UI

   717     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   718     _LIT( KTestTBroadcastEventLL, "In TestTBroadcastEventLL" );

   719     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTBroadcastEventLL);

   720     // Print to log file 

   721     iLog->Log( KTestTBroadcastEventLL );

   722     

   723     TInt temp = 0;

   724     THuiEvent huiEvent( temp );

   725     iHuiEnv->BroadcastEventL( huiEvent );

   726     

   727     return KErrNone;

   728     

   729     }

   730 

   731 // -----------------------------------------------------------------------------

   732 // CTestUiAifCoreToolkit::TestTPrimaryDisplayL

   733 // -----------------------------------------------------------------------------

   734 //

   735 TInt CTestUiAifCoreToolkit::TestTPrimaryDisplayL( CStifItemParser& /*aItem*/ )

   736     {

   737 

   738     // Print to UI

   739     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   740     _LIT( KTestTPrimaryDisplayL, "In TestTPrimaryDisplayL" );

   741     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTPrimaryDisplayL);

   742     // Print to log file 

   743     iLog->Log( KTestTPrimaryDisplayL );

   744     

   745     iHuiEnv->NewDisplayL( iDisplayRect );

   746     iHuiEnv->PrimaryDisplay();

   747     

   748     return KErrNone;

   749     

   750     }

   751 

   752 // -----------------------------------------------------------------------------

   753 // CTestUiAifCoreToolkit::TestTCHuiEnvDisplayL

   754 // -----------------------------------------------------------------------------

   755 //

   756 TInt CTestUiAifCoreToolkit::TestTCHuiEnvDisplayL( CStifItemParser& /*aItem*/ )

   757     {

   758 

   759     // Print to UI

   760     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   761     _LIT( KTestTCHuiEnvDisplayL, "In TestTCHuiEnvDisplayL" );

   762     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTCHuiEnvDisplayL);

   763     // Print to log file 

   764     iLog->Log( KTestTCHuiEnvDisplayL );

   765     

   766     TInt index = 0;

   767     iHuiEnv->NewDisplayL( iDisplayRect );

   768     iHuiEnv->CHuiEnv::Display( index );

   769     

   770     return KErrNone;

   771     

   772     }

   773 

   774 // -----------------------------------------------------------------------------

   775 // CTestUiAifCoreToolkit::TestTCNotifySkinChangedLL

   776 // -----------------------------------------------------------------------------

   777 //

   778 TInt CTestUiAifCoreToolkit::TestTCNotifySkinChangedLL( CStifItemParser& /*aItem*/ )

   779     {

   780 

   781     // Print to UI

   782     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   783     _LIT( KTestTCNotifySkinChangedLL, "In TestTCNotifySkinChangedLL" );

   784     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTCNotifySkinChangedLL);

   785     // Print to log file 

   786     iLog->Log( KTestTCNotifySkinChangedLL );

   787     

   788     iHuiEnv->NotifySkinChangedL();

   789     

   790     return KErrNone;

   791     

   792     }

   793 

   794 // -----------------------------------------------------------------------------

   795 // CTestUiAifCoreToolkit::TestTCRefreshCallBack

   796 // -----------------------------------------------------------------------------

   797 //

   798 TInt CTestUiAifCoreToolkit::TestTCRefreshCallBack( CStifItemParser& /*aItem*/ )

   799     {

   800 

   801     // Print to UI

   802     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   803     _LIT( KTestTCRefreshCallBack, "In TestTCRefreshCallBack" );

   804     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTCRefreshCallBack);

   805     // Print to log file 

   806     iLog->Log( KTestTCRefreshCallBack );

   807     

   808     CHuiEnv::RefreshCallBack( iHuiEnv );

   809     

   810     return KErrNone;

   811     

   812     }

   813 

   814 // -----------------------------------------------------------------------------

   815 // CTestUiAifCoreToolkit::TestTCRelease

   816 // -----------------------------------------------------------------------------

   817 //

   818 TInt CTestUiAifCoreToolkit::TestTCRelease( CStifItemParser& /*aItem*/ )

   819     {

   820 

   821     // Print to UI

   822     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   823     _LIT( KTestTCRelease, "In TestTCRelease" );

   824     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTCRelease);

   825     // Print to log file 

   826     iLog->Log( KTestTCRelease );

   827     

   828     iHuiEnv->Release();

   829     

   830     return KErrNone;

   831     

   832     }

   833 

   834 // -----------------------------------------------------------------------------

   835 // CTestUiAifCoreToolkit::TestTCRestoreLL

   836 // -----------------------------------------------------------------------------

   837 //

   838 TInt CTestUiAifCoreToolkit::TestTCRestoreL( CStifItemParser& /*aItem*/ )

   839     {

   840 

   841     // Print to UI

   842     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   843     _LIT( KTestTCRestoreL, "In TestTCRestoreLL" );

   844     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTCRestoreL);

   845     // Print to log file 

   846     iLog->Log( KTestTCRestoreL );

   847     

   848     iHuiEnv->RestoreL();

   849     

   850     return KErrNone;

   851     

   852     }

   853 

   854 // -----------------------------------------------------------------------------

   855 // CTestUiAifCoreToolkit::TestTCSetMaxCpuTime

   856 // -----------------------------------------------------------------------------

   857 //

   858 TInt CTestUiAifCoreToolkit::TestTCSetMaxCpuTime( CStifItemParser& /*aItem*/ )

   859     {

   860 

   861     // Print to UI

   862     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   863     _LIT( KTestTCSetMaxCpuTime, "In TestTCSetMaxCpuTime" );

   864     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTCSetMaxCpuTime);

   865     // Print to log file 

   866     iLog->Log( KTestTCSetMaxCpuTime );

   867     TUint time = 20;

   868     iHuiEnv->SetMaxCpuTime( time );

   869     

   870     return KErrNone;

   871     

   872     }

   873 

   874 // -----------------------------------------------------------------------------

   875 // CTestUiAifCoreToolkit::TestTCStatic

   876 // -----------------------------------------------------------------------------

   877 //

   878 TInt CTestUiAifCoreToolkit::TestTCStatic( CStifItemParser& /*aItem*/ )

   879     {

   880 

   881     // Print to UI

   882     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   883     _LIT( KTestTCStatic, "In TestTCStatic" );

   884     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTCStatic);

   885     // Print to log file 

   886     iLog->Log( KTestTCStatic );

   887    

   888     CHuiEnv::Static();

   889     

   890     return KErrNone;

   891     

   892     }

   893 

   894 // -----------------------------------------------------------------------------

   895 // CTestUiAifCoreToolkit::TestTCThemeManager

   896 // -----------------------------------------------------------------------------

   897 //

   898 TInt CTestUiAifCoreToolkit::TestTCThemeManager( CStifItemParser& /*aItem*/ )

   899     {

   900 

   901     // Print to UI

   902     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   903     _LIT( KTestTCThemeManager, "In TestTCThemeManager" );

   904     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTCThemeManager);

   905     // Print to log file 

   906     iLog->Log( KTestTCThemeManager );

   907    

   908     iHuiEnv->ThemeManager();

   909     

   910     return KErrNone;

   911     

   912     }

   913 

   914 // -----------------------------------------------------------------------------

   915 // CTestUiAifCoreToolkit::TestTCSetFPSCounterThreshold

   916 // -----------------------------------------------------------------------------

   917 //

   918 TInt CTestUiAifCoreToolkit::TestTCSetFPSCounterThreshold( CStifItemParser& /*aItem*/ )

   919     {

   920 

   921     // Print to UI

   922     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   923     _LIT( KTestTCSetFPSCounterThreshold, "In TestTCSetFPSCounterThreshold" );

   924     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,KTestTCSetFPSCounterThreshold);

   925     // Print to log file 

   926     iLog->Log( KTestTCSetFPSCounterThreshold );

   927    

   928     TUint time = 10;

   929     iHuiEnv->SetFPSCounterThreshold( time );

   930     

   931     return KErrNone;

   932     

   933     }

   934 

   935 // -----------------------------------------------------------------------------

   936 // CTestUiAifCoreToolkit::TestTCChangeRefreshLoopPriority

   937 // -----------------------------------------------------------------------------

   938 //

   939 TInt CTestUiAifCoreToolkit::TestTCChangeRefreshLoopPriority( CStifItemParser& /*aItem*/ )

   940     {

   941 

   942     // Print to UI

   943     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   944     _LIT( KTestTCChangeRefreshLoopPriority, "In TestTCSetFPSCounterThreshold" );

   945     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit,

   946             KTestTCChangeRefreshLoopPriority);

   947     // Print to log file 

   948     iLog->Log( KTestTCChangeRefreshLoopPriority );

   949    

   950     iHuiEnv->ChangeRefreshLoopPriority( CActive::EPriorityStandard );

   951     

   952     return KErrNone;

   953     

   954     }

   955 

   956 //  [End of File]