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:  For test alf core toolkit api modules

    15 *

    16 */

    17 

    18 

    19 

    20 // [INCLUDE FILES]

    21 #include <e32svr.h>

    22 #include <stifparser.h>

    23 #include <stiftestinterface.h>

    24 #include <uiacceltk/huienv.h>

    25 #include <uiacceltk/huicontrol.h>

    26 #include <uiacceltk/huicontrolgroup.h>

    27 #include "uiacceltk/huivisual.h"

    28 #include <uiacceltk/huianchorlayout.h>

    29 #include <uiacceltk/huievent.h>

    30 #include <uiacceltk/huicommand.h>

    31 #include <uiacceltk/huiimagevisual.h>

    32 #include <uiacceltk/huitextvisual.h>

    33 #include <uiacceltk/huitimedvalue.h>

    34 #include <uiacceltk/huitransformation.h>

    35 #include <eikenv.h>

    36 #include <e32err.h>

    37 

    38 #include "testuiaifcoretoolkit.h"

    39 #include "testuiaifblockshuiactioncommandchild.h"

    40 #include "testuiaifblockshuigroupcommandchild.h"

    41 #include "testuiaifblockshuicontrolcommandchild.h"

    42 #include "testuiaifblockshuivisualcommandchild.h"

    43 #include "testuiaifblockshuiimagecommandchild.h"

    44 #include "testuiaifblockshuitextcommandchild.h"

    45 #include "testuiaifblockshuivaluecommandchild.h"

    46 #include "testuiaifblockshuipointcommandchild.h"

    47 #include "testuiaifblockshuitranscommandchild.h"

    48 #include "testuiaifblockshuimarkercommandchild.h"

    49 #include "testuiaifblockshuicustomeventcommandchild.h"

    50 //

    51 

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

    53 // CTestUiAifCoreToolkit::TestCHuiCommandDestructL

    54 // -----------------------------------------------------------------------------

    55 //

    56 TInt CTestUiAifCoreToolkit::TestCHuiCommandDestructL( CStifItemParser& /*aItem*/ )

    57     {

    58 

    59     // Print to UI

    60     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

    61     _LIT( KTestCHuiCommandDestructL, "In TestCHuiCommandDestructL" );

    62     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiCommandDestructL );

    63     // Print to log file

    64     iLog->Log( KTestCHuiCommandDestructL );

    65 

    66     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

    67     STIF_ASSERT_NOT_NULL( actionCommand );

    68     CleanupStack::PushL( actionCommand );

    69     CleanupStack::Pop( 1 );

    70     if( actionCommand )

    71         {

    72         delete actionCommand;

    73         actionCommand = NULL;

    74         }

    75     

    76     return KErrNone;

    77     

    78     }

    79 // -----------------------------------------------------------------------------

    80 // CTestUiAifCoreToolkit::TestCHuiCommandObjectCommandL

    81 // -----------------------------------------------------------------------------

    82 //

    83 TInt CTestUiAifCoreToolkit::TestCHuiCommandObjectCommandL( CStifItemParser& /*aItem*/ )

    84     {

    85 

    86     // Print to UI

    87     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

    88     _LIT( KTestCHuiCommandObjectCommandL, "In TestCHuiCommandObjectCommandL" );

    89     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiCommandObjectCommandL );

    90     // Print to log file

    91     iLog->Log( KTestCHuiCommandObjectCommandL );

    92 

    93     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

    94     STIF_ASSERT_NOT_NULL( actionCommand );

    95     CleanupStack::PushL( actionCommand );

    96     actionCommand->ObjectCommand();

    97     CleanupStack::Pop( 1 );

    98     if( actionCommand )

    99         {

   100         delete actionCommand;

   101         actionCommand = NULL;

   102         }

   103     

   104     return KErrNone;

   105     

   106     }

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

   108 // CTestUiAifCoreToolkit::TestCHuiCommandSetSenderL

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

   110 //

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

   112     {

   113 

   114     // Print to UI

   115     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   116     _LIT( KTestCHuiCommandSetSenderL, "In TestCHuiCommandSetSenderL" );

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

   118     // Print to log file

   119     iLog->Log( KTestCHuiCommandSetSenderL );

   120 

   121     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   122     STIF_ASSERT_NOT_NULL( actionCommand );

   123     CleanupStack::PushL( actionCommand );

   124     actionCommand->SetSender( EHuiCommandObjectTypeNone, iHuiControl );

   125     CleanupStack::Pop( 1 );

   126     if( actionCommand )

   127         {

   128         delete actionCommand;

   129         actionCommand = NULL;

   130         }

   131     

   132     return KErrNone;

   133     

   134     }

   135 // -----------------------------------------------------------------------------

   136 // CTestUiAifCoreToolkit::TestCHuiCommandTypeL

   137 // -----------------------------------------------------------------------------

   138 //

   139 TInt CTestUiAifCoreToolkit::TestCHuiCommandTypeL( CStifItemParser& /*aItem*/ )

   140     {

   141 

   142     // Print to UI

   143     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   144     _LIT( KTestCHuiCommandTypeL, "In TestCHuiCommandTypeL" );

   145     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiCommandTypeL );

   146     // Print to log file

   147     iLog->Log( KTestCHuiCommandTypeL );

   148 

   149     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   150     STIF_ASSERT_NOT_NULL( actionCommand );

   151     CleanupStack::PushL( actionCommand );

   152     actionCommand->SetSender( EHuiCommandObjectTypeNone, iHuiControl );

   153     actionCommand->Type();

   154     CleanupStack::Pop( 1 );

   155     if( actionCommand )

   156         {

   157         delete actionCommand;

   158         actionCommand = NULL;

   159         }

   160     

   161     return KErrNone;

   162     

   163     }

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

   165 // CTestUiAifCoreToolkit::TestCHuiSenderTypeL

   166 // -----------------------------------------------------------------------------

   167 //

   168 TInt CTestUiAifCoreToolkit::TestCHuiSenderTypeL( CStifItemParser& /*aItem*/ )

   169     {

   170 

   171     // Print to UI

   172     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   173     _LIT( KTestCHuiSenderTypeL, "In TestCHuiSenderTypeL" );

   174     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiSenderTypeL );

   175     // Print to log file

   176     iLog->Log( KTestCHuiSenderTypeL );

   177 

   178     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   179     STIF_ASSERT_NOT_NULL( actionCommand );

   180     CleanupStack::PushL( actionCommand );

   181     actionCommand->SetSender( EHuiCommandObjectTypeNone, iHuiControl );

   182     actionCommand->Type();

   183     actionCommand->SenderType();

   184     CleanupStack::Pop( 1 );

   185     if( actionCommand )

   186         {

   187         delete actionCommand;

   188         actionCommand = NULL;

   189         }

   190     

   191     return KErrNone;

   192     

   193     }

   194 // -----------------------------------------------------------------------------

   195 // CTestUiAifCoreToolkit::TestCHuiSenderL

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

   197 //

   198 TInt CTestUiAifCoreToolkit::TestCHuiSenderL( CStifItemParser& /*aItem*/ )

   199     {

   200 

   201     // Print to UI

   202     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   203     _LIT( KTestCHuiSenderL, "In TestCHuiSenderL" );

   204     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiSenderL );

   205     // Print to log file

   206     iLog->Log( KTestCHuiSenderL );

   207 

   208     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   209     STIF_ASSERT_NOT_NULL( actionCommand );

   210     CleanupStack::PushL( actionCommand );

   211     actionCommand->SetSender( EHuiCommandObjectTypeNone, iHuiControl );

   212     actionCommand->Type();

   213     actionCommand->SenderType();

   214     actionCommand->Sender();

   215     CleanupStack::Pop( 1 );

   216     if( actionCommand )

   217         {

   218         delete actionCommand;

   219         actionCommand = NULL;

   220         }

   221     

   222     return KErrNone;

   223     

   224     }

   225 // -----------------------------------------------------------------------------

   226 // CTestUiAifCoreToolkit::TestCHuiSenderVisualL

   227 // -----------------------------------------------------------------------------

   228 //

   229 TInt CTestUiAifCoreToolkit::TestCHuiSenderVisualL( CStifItemParser& /*aItem*/ )

   230     {

   231 

   232     // Print to UI

   233     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   234     _LIT( KTestCHuiSenderVisualL, "In TestCHuiSenderVisualL" );

   235     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiSenderVisualL );

   236     // Print to log file

   237     iLog->Log( KTestCHuiSenderVisualL );

   238 

   239     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   240     STIF_ASSERT_NOT_NULL( actionCommand );

   241     CleanupStack::PushL( actionCommand );

   242     actionCommand->SetSender( EHuiCommandObjectTypeNone, iHuiControl );

   243     actionCommand->Type();

   244     actionCommand->SenderType();

   245     actionCommand->Sender();

   246     actionCommand->SenderVisual();

   247     CleanupStack::Pop( 1 );

   248     if( actionCommand )

   249         {

   250         delete actionCommand;

   251         actionCommand = NULL;

   252         }

   253     

   254     return KErrNone;

   255     

   256     }

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

   258 // CTestUiAifCoreToolkit::TestCHuiSenderControlL

   259 // -----------------------------------------------------------------------------

   260 //

   261 TInt CTestUiAifCoreToolkit::TestCHuiSenderControlL( CStifItemParser& /*aItem*/ )

   262     {

   263 

   264     // Print to UI

   265     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   266     _LIT( KTestCHuiSenderControlL, "In TestCHuiSenderControlL" );

   267     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiSenderControlL );

   268     // Print to log file

   269     iLog->Log( KTestCHuiSenderControlL );

   270 

   271     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   272     STIF_ASSERT_NOT_NULL( actionCommand );

   273     CleanupStack::PushL( actionCommand );

   274     actionCommand->SetSender( EHuiCommandObjectTypeNone, iHuiControl );

   275     actionCommand->Type();

   276     actionCommand->SenderType();

   277     actionCommand->Sender();

   278     actionCommand->SenderVisual();

   279     actionCommand->SenderControl();

   280     CleanupStack::Pop( 1 );

   281     if( actionCommand )

   282         {

   283         delete actionCommand;

   284         actionCommand = NULL;

   285         }

   286     

   287     return KErrNone;

   288     

   289     }

   290 // -----------------------------------------------------------------------------

   291 // CTestUiAifCoreToolkit::TestCHuiSenderControlGroupL

   292 // -----------------------------------------------------------------------------

   293 //

   294 TInt CTestUiAifCoreToolkit::TestCHuiSenderControlGroupL( CStifItemParser& /*aItem*/ )

   295     {

   296 

   297     // Print to UI

   298     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   299     _LIT( KTestCHuiSenderControlGroupL, "In TestCHuiSenderControlGroupL" );

   300     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiSenderControlGroupL );

   301     // Print to log file

   302     iLog->Log( KTestCHuiSenderControlGroupL );

   303 

   304     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   305     STIF_ASSERT_NOT_NULL( actionCommand );

   306     CleanupStack::PushL( actionCommand );

   307     actionCommand->SetSender( EHuiCommandObjectTypeNone, iHuiControl );

   308     actionCommand->Type();

   309     actionCommand->SenderType();

   310     actionCommand->Sender();

   311     actionCommand->SenderVisual();

   312     actionCommand->SenderControl();

   313     actionCommand->SenderControlGroup();

   314     CleanupStack::Pop( 1 );

   315     if( actionCommand )

   316         {

   317         delete actionCommand;

   318         actionCommand = NULL;

   319         }

   320     

   321     return KErrNone;

   322     

   323     }

   324 // -----------------------------------------------------------------------------

   325 // CTestUiAifCoreToolkit::TestCHuiCommandConstructL

   326 // -----------------------------------------------------------------------------

   327 //

   328 TInt CTestUiAifCoreToolkit::TestCHuiCommandConstructL( CStifItemParser& /*aItem*/ )

   329     {

   330 

   331     // Print to UI

   332     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   333     _LIT( KTestCHuiCommandConstructL, "In TestCHuiCommandConstructL" );

   334     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiCommandConstructL );

   335     // Print to log file

   336     iLog->Log( KTestCHuiCommandConstructL );

   337 

   338     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   339     STIF_ASSERT_NOT_NULL( actionCommand );

   340     CleanupStack::PushL( actionCommand );

   341     actionCommand->SetSender( EHuiCommandObjectTypeNone, iHuiControl );

   342     actionCommand->Type();

   343     actionCommand->SenderType();

   344     actionCommand->Sender();

   345     actionCommand->SenderVisual();

   346     actionCommand->SenderControl();

   347     actionCommand->SenderControlGroup();

   348     CleanupStack::Pop( 1 );

   349     if( actionCommand )

   350         {

   351         delete actionCommand;

   352         actionCommand = NULL;

   353         }

   354     

   355     return KErrNone;

   356     

   357     }

   358 // -----------------------------------------------------------------------------

   359 // CTestUiAifCoreToolkit::TestCHuiCommandExtensionL

   360 // -----------------------------------------------------------------------------

   361 //

   362 TInt CTestUiAifCoreToolkit::TestCHuiCommandExtensionL( CStifItemParser& /*aItem*/ )

   363     {

   364 

   365     // Print to UI

   366     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   367     _LIT( KTestCHuiCommandExtensionL, "In TestCHuiCommandExtensionL" );

   368     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiCommandExtensionL );

   369     // Print to log file

   370     iLog->Log( KTestCHuiCommandExtensionL );

   371 

   372     TTestUiAifBlocksHuiActionCommandChild* actionCommandChild =

   373         new ( ELeave ) TTestUiAifBlocksHuiActionCommandChild( 1 );

   374     STIF_ASSERT_NOT_NULL( actionCommandChild );

   375     CleanupStack::PushL( actionCommandChild );

   376     const TUid aExtensionUid = TUid::Null();

   377     TAny** aExtensionParams = NULL;

   378     actionCommandChild->SetCommandExtension( aExtensionUid, aExtensionParams );

   379     CleanupStack::Pop( 1 );

   380     if( actionCommandChild )

   381         {

   382         delete actionCommandChild;

   383         actionCommandChild = NULL;

   384         }

   385     

   386     return KErrNone;

   387     

   388     }

   389 // -----------------------------------------------------------------------------

   390 // CTestUiAifCoreToolkit::TestCHuiCommandTActionCommandL

   391 // -----------------------------------------------------------------------------

   392 //

   393 TInt CTestUiAifCoreToolkit::TestCHuiCommandTActionCommandL( CStifItemParser& /*aItem*/ )

   394     {

   395 

   396     // Print to UI

   397     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   398     _LIT( KTestCHuiCommandTActionCommandL, "In TestCHuiCommandTActionCommandL" );

   399     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiCommandTActionCommandL );

   400     // Print to log file

   401     iLog->Log( KTestCHuiCommandTActionCommandL );

   402 

   403     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   404     STIF_ASSERT_NOT_NULL( actionCommand );

   405     CleanupStack::PushL( actionCommand );

   406     CleanupStack::Pop( 1 );

   407     if( actionCommand )

   408         {

   409         delete actionCommand;

   410         actionCommand = NULL;

   411         }

   412     

   413     return KErrNone;

   414     

   415     }

   416 // -----------------------------------------------------------------------------

   417 // CTestUiAifCoreToolkit::TestCHuiCommandExecuteL

   418 // -----------------------------------------------------------------------------

   419 //

   420 TInt CTestUiAifCoreToolkit::TestCHuiCommandExecuteL( CStifItemParser& /*aItem*/ )

   421     {

   422 

   423     // Print to UI

   424     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   425     _LIT( KTestCHuiCommandExecuteL, "In TestCHuiCommandExecuteL" );

   426     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiCommandExecuteL );

   427     // Print to log file

   428     iLog->Log( KTestCHuiCommandExecuteL );

   429 

   430     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   431     STIF_ASSERT_NOT_NULL( actionCommand );

   432     CleanupStack::PushL( actionCommand );

   433     actionCommand->ExecuteL( *iHuiEnv );

   434     CleanupStack::Pop( 1 );

   435     if( actionCommand )

   436         {

   437         delete actionCommand;

   438         actionCommand = NULL;

   439         }

   440     

   441     return KErrNone;

   442     

   443     }

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

   445 // CTestUiAifCoreToolkit::TestCHuiCommandSizeL

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

   447 //

   448 TInt CTestUiAifCoreToolkit::TestCHuiCommandSizeL( CStifItemParser& /*aItem*/ )

   449     {

   450 

   451     // Print to UI

   452     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   453     _LIT( KTestCHuiCommandSizeL, "In TestCHuiCommandSizeL" );

   454     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiCommandSizeL );

   455     // Print to log file

   456     iLog->Log( KTestCHuiCommandSizeL );

   457 

   458     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   459     STIF_ASSERT_NOT_NULL( actionCommand );

   460     CleanupStack::PushL( actionCommand );

   461     actionCommand->ExecuteL( *iHuiEnv );

   462     actionCommand->Size();

   463     CleanupStack::Pop( 1 );

   464     if( actionCommand )

   465         {

   466         delete actionCommand;

   467         actionCommand = NULL;

   468         }

   469     

   470     return KErrNone;

   471     

   472     }

   473 // -----------------------------------------------------------------------------

   474 // CTestUiAifCoreToolkit::TestCHuiCommandIdL

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

   476 //

   477 TInt CTestUiAifCoreToolkit::TestCHuiCommandIdL( CStifItemParser& /*aItem*/ )

   478     {

   479 

   480     // Print to UI

   481     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   482     _LIT( KTestCHuiCommandIdL, "In TestCHuiCommandIdL" );

   483     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiCommandIdL );

   484     // Print to log file

   485     iLog->Log( KTestCHuiCommandIdL );

   486 

   487     THuiActionCommand* actionCommand = new ( ELeave )THuiActionCommand( 1 );

   488     STIF_ASSERT_NOT_NULL( actionCommand );

   489     CleanupStack::PushL( actionCommand );

   490     actionCommand->ExecuteL( *iHuiEnv );

   491     actionCommand->Size();

   492     actionCommand->Id();

   493     CleanupStack::Pop( 1 );

   494     if( actionCommand )

   495         {

   496         delete actionCommand;

   497         actionCommand = NULL;

   498         }

   499     

   500     return KErrNone;

   501     

   502     }

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

   504 // CTestUiAifCoreToolkit::TestCHuiActionCommandExtensionL

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

   506 //

   507 TInt CTestUiAifCoreToolkit::TestCHuiActionCommandExtensionL( CStifItemParser& /*aItem*/ )

   508     {

   509 

   510     // Print to UI

   511     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   512     _LIT( KTestCHuiActionCommandExtensionL, "In TestCHuiActionCommandExtensionL" );

   513     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiActionCommandExtensionL );

   514     // Print to log file

   515     iLog->Log( KTestCHuiActionCommandExtensionL );

   516 

   517     TTestUiAifBlocksHuiActionCommandChild* actionCommandChild =

   518         new ( ELeave ) TTestUiAifBlocksHuiActionCommandChild( 1 );

   519     STIF_ASSERT_NOT_NULL( actionCommandChild );

   520     CleanupStack::PushL( actionCommandChild );

   521     const TUid aExtensionUid = TUid::Null();

   522     TAny** aExtensionParams = NULL;

   523     actionCommandChild->SetCommandExtension( aExtensionUid, aExtensionParams );

   524     CleanupStack::Pop( 1 );

   525     if( actionCommandChild )

   526         {

   527         delete actionCommandChild;

   528         actionCommandChild = NULL;

   529         }

   530     

   531     return KErrNone;

   532     

   533     }

   534 // -----------------------------------------------------------------------------

   535 // CTestUiAifCoreToolkit::TestCHuiObjectCommandL

   536 // -----------------------------------------------------------------------------

   537 //

   538 TInt CTestUiAifCoreToolkit::TestCHuiObjectCommandL( CStifItemParser& /*aItem*/ )

   539     {

   540 

   541     // Print to UI

   542     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   543     _LIT( KTestCHuiObjectCommandL, "In TestCHuiObjectCommandL" );

   544     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiObjectCommandL );

   545     // Print to log file

   546     iLog->Log( KTestCHuiObjectCommandL );

   547 

   548     THuiOp aOperation = EHuiOpHide;

   549     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   550         *iHuiControlGroup, aOperation, iHuiDisplay );

   551     STIF_ASSERT_NOT_NULL( groupCommand );

   552     CleanupStack::PushL( groupCommand );

   553     groupCommand->ObjectCommand();

   554     CleanupStack::Pop( 1 );

   555     

   556     return KErrNone;

   557     

   558     }

   559 // -----------------------------------------------------------------------------

   560 // CTestUiAifCoreToolkit::TestCHuiObjectCommandExecuteL

   561 // -----------------------------------------------------------------------------

   562 //

   563 TInt CTestUiAifCoreToolkit::TestCHuiObjectCommandExecuteL( CStifItemParser& /*aItem*/ )

   564     {

   565 

   566     // Print to UI

   567     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   568     _LIT( KTestCHuiObjectCommandExecuteL, "In TestCHuiObjectCommandExecuteL" );

   569     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiObjectCommandExecuteL );

   570     // Print to log file

   571     iLog->Log( KTestCHuiObjectCommandExecuteL );

   572 

   573     THuiOp aOperation = EHuiOpHide;

   574     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   575         *iHuiControlGroup, aOperation, iHuiDisplay );

   576     STIF_ASSERT_NOT_NULL( groupCommand );

   577     CleanupStack::PushL( groupCommand );

   578     groupCommand->ObjectCommand();

   579     groupCommand->ExecuteL( *iHuiEnv );

   580     CleanupStack::Pop( 1 );

   581     

   582     return KErrNone;

   583     

   584     }

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

   586 // CTestUiAifCoreToolkit::TestCHuiObjectCommandSizeL

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

   588 //

   589 TInt CTestUiAifCoreToolkit::TestCHuiObjectCommandSizeL( CStifItemParser& /*aItem*/ )

   590     {

   591 

   592     // Print to UI

   593     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   594     _LIT( KTestCHuiObjectCommandSizeL, "In TestCHuiObjectCommandSizeL" );

   595     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiObjectCommandSizeL );

   596     // Print to log file

   597     iLog->Log( KTestCHuiObjectCommandSizeL );

   598 

   599     THuiOp aOperation = EHuiOpHide;

   600     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   601         *iHuiControlGroup, aOperation, iHuiDisplay );

   602     STIF_ASSERT_NOT_NULL( groupCommand );

   603     CleanupStack::PushL( groupCommand );

   604     groupCommand->ObjectCommand();

   605     groupCommand->ExecuteL( *iHuiEnv );

   606     groupCommand->Size();

   607     CleanupStack::Pop( 1 );

   608     

   609     return KErrNone;

   610     

   611     }

   612 // -----------------------------------------------------------------------------

   613 // CTestUiAifCoreToolkit::TestCHuiObjectCommandObjectL

   614 // -----------------------------------------------------------------------------

   615 //

   616 TInt CTestUiAifCoreToolkit::TestCHuiObjectCommandObjectL( CStifItemParser& /*aItem*/ )

   617     {

   618 

   619     // Print to UI

   620     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   621     _LIT( KTestCHuiObjectCommandObjectL, "In TestCHuiObjectCommandObjectL" );

   622     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiObjectCommandObjectL );

   623     // Print to log file

   624     iLog->Log( KTestCHuiObjectCommandObjectL );

   625 

   626     THuiOp aOperation = EHuiOpHide;

   627     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   628         *iHuiControlGroup, aOperation, iHuiDisplay );

   629     STIF_ASSERT_NOT_NULL( groupCommand );

   630     CleanupStack::PushL( groupCommand );

   631     groupCommand->ObjectCommand();

   632     groupCommand->ExecuteL( *iHuiEnv );

   633     groupCommand->Size();

   634     groupCommand->Object();

   635     CleanupStack::Pop( 1 );

   636     

   637     return KErrNone;

   638     

   639     }

   640 // -----------------------------------------------------------------------------

   641 // CTestUiAifCoreToolkit::TestCHuiObjectCommandOperationL

   642 // -----------------------------------------------------------------------------

   643 //

   644 TInt CTestUiAifCoreToolkit::TestCHuiObjectCommandOperationL( CStifItemParser& /*aItem*/ )

   645     {

   646 

   647     // Print to UI

   648     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   649     _LIT( KTestCHuiObjectCommandOperationL, "In TestCHuiObjectCommandOperationL" );

   650     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiObjectCommandOperationL );

   651     // Print to log file

   652     iLog->Log( KTestCHuiObjectCommandOperationL );

   653 

   654     THuiOp aOperation = EHuiOpHide;

   655     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   656         *iHuiControlGroup, aOperation, iHuiDisplay );

   657     STIF_ASSERT_NOT_NULL( groupCommand );

   658     CleanupStack::PushL( groupCommand );

   659     groupCommand->ObjectCommand();

   660     groupCommand->ExecuteL( *iHuiEnv );

   661     groupCommand->Size();

   662     groupCommand->Object();

   663     groupCommand->Operation();

   664     CleanupStack::Pop( 1 );

   665     

   666     return KErrNone;

   667     

   668     }

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

   670 // CTestUiAifCoreToolkit::TestCHuiObjectCommandConstructL

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

   672 //

   673 TInt CTestUiAifCoreToolkit::TestCHuiObjectCommandConstructL( CStifItemParser& /*aItem*/ )

   674     {

   675 

   676     // Print to UI

   677     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   678     _LIT( KTestCHuiObjectCommandConstructL, "In TestCHuiObjectCommandConstructL" );

   679     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiObjectCommandConstructL );

   680     // Print to log file

   681     iLog->Log( KTestCHuiObjectCommandConstructL );

   682 

   683     THuiOp aOperation = EHuiOpHide;

   684     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   685         *iHuiControlGroup, aOperation, iHuiDisplay );

   686     STIF_ASSERT_NOT_NULL( groupCommand );

   687     CleanupStack::PushL( groupCommand );

   688     CleanupStack::Pop( 1 );

   689     

   690     return KErrNone;

   691     

   692     }

   693 // -----------------------------------------------------------------------------

   694 // CTestUiAifCoreToolkit::TestCHuiObjectCommandExtensionL

   695 // -----------------------------------------------------------------------------

   696 //

   697 TInt CTestUiAifCoreToolkit::TestCHuiObjectCommandExtensionL( CStifItemParser& /*aItem*/ )

   698     {

   699 

   700     // Print to UI

   701     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   702     _LIT( KTestCHuiObjectCommandExtensionL, "In TestCHuiObjectCommandExtensionL" );

   703     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestCHuiObjectCommandExtensionL );

   704     // Print to log file

   705     iLog->Log( KTestCHuiObjectCommandExtensionL );

   706 

   707     THuiOp aOperation = EHuiOpHide;

   708     TTestUiAifBlocksHuiGroupCommandChild* groupCommandChild = new ( ELeave )

   709         TTestUiAifBlocksHuiGroupCommandChild( *iHuiControlGroup, aOperation, iHuiDisplay );

   710     STIF_ASSERT_NOT_NULL( groupCommandChild );

   711     CleanupStack::PushL( groupCommandChild );

   712     const TUid aExtensionUid = TUid::Null();

   713     TAny** aExtensionParams = NULL;

   714     groupCommandChild->SetCommandExtension( aExtensionUid, aExtensionParams );

   715     CleanupStack::Pop( 1 );

   716     

   717     return KErrNone;

   718     

   719     }

   720 // -----------------------------------------------------------------------------

   721 // CTestUiAifCoreToolkit::TestTHuiGroupCommandL

   722 // -----------------------------------------------------------------------------

   723 //

   724 TInt CTestUiAifCoreToolkit::TestTHuiGroupCommandL( CStifItemParser& /*aItem*/ )

   725     {

   726 

   727     // Print to UI

   728     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   729     _LIT( KTestTHuiGroupCommandL, "In TestTHuiGroupCommandL" );

   730     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiGroupCommandL );

   731     // Print to log file

   732     iLog->Log( KTestTHuiGroupCommandL );

   733 

   734     THuiOp aOperation = EHuiOpHide;

   735     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   736         *iHuiControlGroup, aOperation, iHuiDisplay );

   737     STIF_ASSERT_NOT_NULL( groupCommand );

   738     CleanupStack::PushL( groupCommand );

   739     CleanupStack::Pop( 1 );

   740     

   741     return KErrNone;

   742     

   743     }

   744 // -----------------------------------------------------------------------------

   745 // CTestUiAifCoreToolkit::TestTHuiGroupCommandExecuteL

   746 // -----------------------------------------------------------------------------

   747 //

   748 TInt CTestUiAifCoreToolkit::TestTHuiGroupCommandExecuteL( CStifItemParser& /*aItem*/ )

   749     {

   750 

   751     // Print to UI

   752     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   753     _LIT( KTestTHuiGroupCommandExecuteL, "In TestTHuiGroupCommandExecuteL" );

   754     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiGroupCommandExecuteL );

   755     // Print to log file

   756     iLog->Log( KTestTHuiGroupCommandExecuteL );

   757 

   758     THuiOp aOperation = EHuiOpHide;

   759     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   760         *iHuiControlGroup, aOperation, iHuiDisplay );

   761     STIF_ASSERT_NOT_NULL( groupCommand );

   762     CleanupStack::PushL( groupCommand );

   763     groupCommand->ExecuteL( *iHuiEnv );

   764     CleanupStack::Pop( 1 );

   765     

   766     return KErrNone;

   767     

   768     }

   769 // -----------------------------------------------------------------------------

   770 // CTestUiAifCoreToolkit::TestTHuiGroupCommandSizeL

   771 // -----------------------------------------------------------------------------

   772 //

   773 TInt CTestUiAifCoreToolkit::TestTHuiGroupCommandSizeL( CStifItemParser& /*aItem*/ )

   774     {

   775 

   776     // Print to UI

   777     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   778     _LIT( KTestTHuiGroupCommandSizeL, "In TestTHuiGroupCommandSizeL" );

   779     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiGroupCommandSizeL );

   780     // Print to log file

   781     iLog->Log( KTestTHuiGroupCommandSizeL );

   782 

   783     THuiOp aOperation = EHuiOpHide;

   784     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   785         *iHuiControlGroup, aOperation, iHuiDisplay );

   786     STIF_ASSERT_NOT_NULL( groupCommand );

   787     CleanupStack::PushL( groupCommand );

   788     groupCommand->ExecuteL( *iHuiEnv );

   789     groupCommand->Size();

   790     CleanupStack::Pop( 1 );

   791     

   792     return KErrNone;

   793     

   794     }

   795 // -----------------------------------------------------------------------------

   796 // CTestUiAifCoreToolkit::TestTHuiGroupCommandControlGroupL

   797 // -----------------------------------------------------------------------------

   798 //

   799 TInt CTestUiAifCoreToolkit::TestTHuiGroupCommandControlGroupL( CStifItemParser& /*aItem*/ )

   800     {

   801 

   802     // Print to UI

   803     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   804     _LIT( KTestTHuiGroupCommandControlGroupL, "In TestTHuiGroupCommandControlGroupL" );

   805     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiGroupCommandControlGroupL );

   806     // Print to log file

   807     iLog->Log( KTestTHuiGroupCommandControlGroupL );

   808 

   809     THuiOp aOperation = EHuiOpHide;

   810     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   811         *iHuiControlGroup, aOperation, iHuiDisplay );

   812     STIF_ASSERT_NOT_NULL( groupCommand );

   813     CleanupStack::PushL( groupCommand );

   814     groupCommand->ExecuteL( *iHuiEnv );

   815     groupCommand->Size();

   816     groupCommand->ControlGroup();

   817     CleanupStack::Pop( 1 );

   818     

   819     return KErrNone;

   820     

   821     }

   822 // -----------------------------------------------------------------------------

   823 // CTestUiAifCoreToolkit::TestTHuiGroupCommandDisplayL

   824 // -----------------------------------------------------------------------------

   825 //

   826 TInt CTestUiAifCoreToolkit::TestTHuiGroupCommandDisplayL( CStifItemParser& /*aItem*/ )

   827     {

   828 

   829     // Print to UI

   830     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   831     _LIT( KTestTHuiGroupCommandDisplayL, "In TestTHuiGroupCommandDisplayL" );

   832     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiGroupCommandDisplayL );

   833     // Print to log file

   834     iLog->Log( KTestTHuiGroupCommandDisplayL );

   835 

   836     THuiOp aOperation = EHuiOpHide;

   837     THuiGroupCommand* groupCommand = new ( ELeave ) THuiGroupCommand( 

   838         *iHuiControlGroup, aOperation, iHuiDisplay );

   839     STIF_ASSERT_NOT_NULL( groupCommand );

   840     CleanupStack::PushL( groupCommand );

   841     groupCommand->ExecuteL( *iHuiEnv );

   842     groupCommand->Size();

   843     groupCommand->ControlGroup();

   844     groupCommand->Display();

   845     CleanupStack::Pop( 1 );

   846     

   847     return KErrNone;

   848     

   849     }

   850 // -----------------------------------------------------------------------------

   851 // CTestUiAifCoreToolkit::TestTHuiGroupCommandExtensionL

   852 // -----------------------------------------------------------------------------

   853 //

   854 TInt CTestUiAifCoreToolkit::TestTHuiGroupCommandExtensionL( CStifItemParser& /*aItem*/ )

   855     {

   856 

   857     // Print to UI

   858     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   859     _LIT( KTestTHuiGroupCommandExtensionL, "In TestTHuiGroupCommandExtensionL" );

   860     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiGroupCommandExtensionL );

   861     // Print to log file

   862     iLog->Log( KTestTHuiGroupCommandExtensionL );

   863 

   864     THuiOp aOperation = EHuiOpHide;

   865     TTestUiAifBlocksHuiGroupCommandChild* groupCommandChild = new ( ELeave )

   866         TTestUiAifBlocksHuiGroupCommandChild( *iHuiControlGroup, aOperation, iHuiDisplay );

   867     STIF_ASSERT_NOT_NULL( groupCommandChild );

   868     CleanupStack::PushL( groupCommandChild );

   869     const TUid aExtensionUid = TUid::Null();

   870     TAny** aExtensionParams = NULL;

   871     groupCommandChild->SetCommandExtension( aExtensionUid, aExtensionParams );

   872     CleanupStack::Pop( 1 );

   873     

   874     return KErrNone;

   875     

   876     }

   877 // -----------------------------------------------------------------------------

   878 // CTestUiAifCoreToolkit::TestTHuiControlCommandL

   879 // -----------------------------------------------------------------------------

   880 //

   881 TInt CTestUiAifCoreToolkit::TestTHuiControlCommandL( CStifItemParser& /*aItem*/ )

   882     {

   883 

   884     // Print to UI

   885     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   886     _LIT( KTestTHuiiHuiControlCommandL, "In TestTHuiiHuiControlCommandL" );

   887     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiiHuiControlCommandL );

   888     // Print to log file

   889     iLog->Log( KTestTHuiiHuiControlCommandL );

   890 

   891     THuiOp aOperation = EHuiOpHide;

   892     THuiControlCommand* iHuiControlCommand = new ( ELeave ) THuiControlCommand( 

   893         *iHuiControl, aOperation );

   894     STIF_ASSERT_NOT_NULL( iHuiControlCommand );

   895     

   896     return KErrNone;

   897     

   898     }

   899 // -----------------------------------------------------------------------------

   900 // CTestUiAifCoreToolkit::TestTHuiControlCommandExecuteL

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

   902 //

   903 TInt CTestUiAifCoreToolkit::TestTHuiControlCommandExecuteL( CStifItemParser& /*aItem*/ )

   904     {

   905 

   906     // Print to UI

   907     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   908     _LIT( KTestTHuiiHuiControlCommandExecuteL, "In TestTHuiiHuiControlCommandExecuteL" );

   909     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiiHuiControlCommandExecuteL );

   910     // Print to log file

   911     iLog->Log( KTestTHuiiHuiControlCommandExecuteL );

   912 

   913     THuiOp aOperation = EHuiOpHide;

   914     THuiControlCommand* iHuiControlCommand = new ( ELeave ) THuiControlCommand( 

   915         *iHuiControl, aOperation );

   916     STIF_ASSERT_NOT_NULL( iHuiControlCommand );

   917     iHuiControlCommand->ExecuteL( *iHuiEnv );

   918     

   919     return KErrNone;

   920     

   921     }

   922 // -----------------------------------------------------------------------------

   923 // CTestUiAifCoreToolkit::TestTHuiControlCommandSizeL

   924 // -----------------------------------------------------------------------------

   925 //

   926 TInt CTestUiAifCoreToolkit::TestTHuiControlCommandSizeL( CStifItemParser& /*aItem*/ )

   927     {

   928 

   929     // Print to UI

   930     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   931     _LIT( KTestTHuiControlCommandSizeL, "In TestTHuiControlCommandSizeL" );

   932     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiControlCommandSizeL );

   933     // Print to log file

   934     iLog->Log( KTestTHuiControlCommandSizeL );

   935 

   936     THuiOp aOperation = EHuiOpHide;

   937     THuiControlCommand* iHuiControlCommand = new ( ELeave ) THuiControlCommand( 

   938         *iHuiControl, aOperation );

   939     STIF_ASSERT_NOT_NULL( iHuiControlCommand );

   940     iHuiControlCommand->ExecuteL( *iHuiEnv );

   941     iHuiControlCommand->Size();

   942     

   943     return KErrNone;

   944     

   945     }

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

   947 // CTestUiAifCoreToolkit::TestTHuiiHuiControlCommandControlL

   948 // -----------------------------------------------------------------------------

   949 //

   950 TInt CTestUiAifCoreToolkit::TestTHuiControlCommandControlL( CStifItemParser& /*aItem*/ )

   951     {

   952 

   953     // Print to UI

   954     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   955     _LIT( KTestTHuiControlCommandControlL, "In TestTHuiControlCommandControlL" );

   956     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiControlCommandControlL );

   957     // Print to log file

   958     iLog->Log( KTestTHuiControlCommandControlL );

   959 

   960     THuiOp aOperation = EHuiOpHide;

   961     THuiControlCommand* iHuiControlCommand = new ( ELeave ) THuiControlCommand( 

   962         *iHuiControl, aOperation );

   963     STIF_ASSERT_NOT_NULL( iHuiControlCommand );

   964     iHuiControlCommand->ExecuteL( *iHuiEnv );

   965     iHuiControlCommand->Size();

   966     iHuiControlCommand->Control();

   967     

   968     return KErrNone;

   969     

   970     }

   971 // -----------------------------------------------------------------------------

   972 // CTestUiAifCoreToolkit::TestTHuiControlCommandExtensionL

   973 // -----------------------------------------------------------------------------

   974 //

   975 TInt CTestUiAifCoreToolkit::TestTHuiControlCommandExtensionL( CStifItemParser& /*aItem*/ )

   976     {

   977 

   978     // Print to UI

   979     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

   980     _LIT( KTestTHuiControlCommandExtensionL, "In TestTHuiControlCommandExtensionL" );

   981     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiControlCommandExtensionL );

   982     // Print to log file

   983     iLog->Log( KTestTHuiControlCommandExtensionL );

   984 

   985     THuiOp aOperation = EHuiOpHide;

   986     TTestUiAifBlocksHuiControlCommandChild* iHuiControlCommandChild = 

   987         new ( ELeave ) TTestUiAifBlocksHuiControlCommandChild( *iHuiControl, aOperation );

   988     STIF_ASSERT_NOT_NULL( iHuiControlCommandChild );

   989     const TUid aExtensionUid = TUid::Null();

   990     TAny** aExtensionParams = NULL;

   991     iHuiControlCommandChild->SetCommandExtension( aExtensionUid, aExtensionParams );

   992     

   993     return KErrNone;

   994     

   995     }

   996 // -----------------------------------------------------------------------------

   997 // CTestUiAifCoreToolkit::TestTHuiVisualCommandL

   998 // -----------------------------------------------------------------------------

   999 //

  1000 TInt CTestUiAifCoreToolkit::TestTHuiVisualCommandL( CStifItemParser& /*aItem*/ )

  1001     {

  1002 

  1003     // Print to UI

  1004     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1005     _LIT( KTestTHuiVisualCommandL, "In TestTHuiVisualCommandL" );

  1006     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiVisualCommandL );

  1007     // Print to log file

  1008     iLog->Log( KTestTHuiVisualCommandL );

  1009 

  1010     CHuiVisual* visual = new ( ELeave )CHuiVisual( *iHuiControl );

  1011     STIF_ASSERT_NOT_NULL( visual );

  1012     CleanupStack::PushL( visual );

  1013     THuiOp aOperation = EHuiOpRemoveAndDestroyAll;

  1014     THuiVisualCommand* visualCommand = new ( ELeave ) THuiVisualCommand( 

  1015         *visual, aOperation );

  1016     STIF_ASSERT_NOT_NULL( visualCommand );

  1017     CleanupStack::PushL( visualCommand );

  1018     CleanupStack::Pop( 2 );

  1019     

  1020     return KErrNone;

  1021     

  1022     }

  1023 // -----------------------------------------------------------------------------

  1024 // CTestUiAifCoreToolkit::TestTHuiVisualCommandExecuteL

  1025 // -----------------------------------------------------------------------------

  1026 //

  1027 TInt CTestUiAifCoreToolkit::TestTHuiVisualCommandExecuteL( CStifItemParser& /*aItem*/ )

  1028     {

  1029 

  1030     // Print to UI

  1031     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1032     _LIT( KTestTHuiVisualCommandExecuteL, "In TestTHuiVisualCommandExecuteL" );

  1033     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiVisualCommandExecuteL );

  1034     // Print to log file

  1035     iLog->Log( KTestTHuiVisualCommandExecuteL );

  1036 

  1037     CHuiVisual* visual = new ( ELeave )CHuiVisual( *iHuiControl );

  1038     STIF_ASSERT_NOT_NULL( visual );

  1039     CleanupStack::PushL( visual );

  1040     THuiOp aOperation = EHuiOpRemoveAndDestroyAll;

  1041     THuiVisualCommand* visualCommand = new ( ELeave ) THuiVisualCommand( 

  1042         *visual, aOperation );

  1043     STIF_ASSERT_NOT_NULL( visualCommand );

  1044     CleanupStack::PushL( visualCommand );

  1045     visualCommand->ExecuteL( *iHuiEnv );

  1046     CleanupStack::Pop( 2 );

  1047     

  1048     return KErrNone;

  1049     

  1050     }

  1051 // -----------------------------------------------------------------------------

  1052 // CTestUiAifCoreToolkit::TestTHuiVisualCommandSizeL

  1053 // -----------------------------------------------------------------------------

  1054 //

  1055 TInt CTestUiAifCoreToolkit::TestTHuiVisualCommandSizeL( CStifItemParser& /*aItem*/ )

  1056     {

  1057 

  1058     // Print to UI

  1059     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1060     _LIT( KTestTHuiVisualCommandSizeL, "In TestTHuiVisualCommandSizeL" );

  1061     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiVisualCommandSizeL );

  1062     // Print to log file

  1063     iLog->Log( KTestTHuiVisualCommandSizeL );

  1064 

  1065     CHuiVisual* visual = new ( ELeave )CHuiVisual( *iHuiControl );

  1066     STIF_ASSERT_NOT_NULL( visual );

  1067     CleanupStack::PushL( visual );

  1068     THuiOp aOperation = EHuiOpRemoveAndDestroyAll;

  1069     THuiVisualCommand* visualCommand = new ( ELeave ) THuiVisualCommand( 

  1070         *visual, aOperation );

  1071     STIF_ASSERT_NOT_NULL( visualCommand );

  1072     CleanupStack::PushL( visualCommand );

  1073     visualCommand->ExecuteL( *iHuiEnv );

  1074     visualCommand->Size();

  1075     CleanupStack::Pop( 2 );

  1076     

  1077     return KErrNone;

  1078     

  1079     }

  1080 // -----------------------------------------------------------------------------

  1081 // CTestUiAifCoreToolkit::TestTHuiVisualCommandVisualL

  1082 // -----------------------------------------------------------------------------

  1083 //

  1084 TInt CTestUiAifCoreToolkit::TestTHuiVisualCommandVisualL( CStifItemParser& /*aItem*/ )

  1085     {

  1086 

  1087     // Print to UI

  1088     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1089     _LIT( KTestTHuiVisualCommandVisualL, "In TestTHuiVisualCommandVisualL" );

  1090     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiVisualCommandVisualL );

  1091     // Print to log file

  1092     iLog->Log( KTestTHuiVisualCommandVisualL );

  1093 

  1094     CHuiVisual* visual = new ( ELeave )CHuiVisual( *iHuiControl );

  1095     STIF_ASSERT_NOT_NULL( visual );

  1096     CleanupStack::PushL( visual );

  1097     THuiOp aOperation = EHuiOpRemoveAndDestroyAll;

  1098     THuiVisualCommand* visualCommand = new ( ELeave ) THuiVisualCommand( 

  1099         *visual, aOperation );

  1100     STIF_ASSERT_NOT_NULL( visualCommand );

  1101     CleanupStack::PushL( visualCommand );

  1102     visualCommand->ExecuteL( *iHuiEnv );

  1103     visualCommand->Size();

  1104     visualCommand->Visual();

  1105     CleanupStack::Pop( 2 );

  1106     

  1107     return KErrNone;

  1108     

  1109     }

  1110 // -----------------------------------------------------------------------------

  1111 // CTestUiAifCoreToolkit::TestTHuiVisualCommandFlagsToSetL

  1112 // -----------------------------------------------------------------------------

  1113 //

  1114 TInt CTestUiAifCoreToolkit::TestTHuiVisualCommandFlagsToSetL( CStifItemParser& /*aItem*/ )

  1115     {

  1116 

  1117     // Print to UI

  1118     _LIT( Ktestuiaifcoretoolkit, "testuiaifcoretoolkit" );

  1119     _LIT( KTestTHuiVisualCommandFlagsToSetL, "In TestTHuiVisualCommandFlagsToSetL" );

  1120     TestModuleIf().Printf( 0, Ktestuiaifcoretoolkit, KTestTHuiVisualCommandFlagsToSetL );

  1121     // Print to log file

  1122     iLog->Log( KTestTHuiVisualCommandFlagsToSetL );

  1123 

  1124     CHuiVisual* visual = new ( ELeave )CHuiVisual( *iHuiControl );

  1125     STIF_ASSERT_NOT_NULL( visual );

  1126     CleanupStack::PushL( visual );

  1127     THuiOp aOperation = EHuiOpRemoveAndDestroyAll;

  1128     THuiVisualCommand* visualCommand = new ( ELeave ) THuiVisualCommand( 

  1129         *visual, aOperation );

  1130     STIF_ASSERT_NOT_NULL( visualCommand );

  1131     CleanupStack::PushL( visualCommand );

  1132     visualCommand->ExecuteL( *iHuiEnv );

  1133     visualCommand->Size();

  1134     visualCommand->Visual();