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 akntabgrp.h

    15 *

    16 */

    17 

    18 

    19 

    20 // [INCLUDE FILES]

    21 #include <e32svr.h>

    22 #include <stifparser.h>

    23 #include <stiftestinterface.h>

    24 

    25 #include <coecntrl.h>

    26 #include <barsread.h>

    27 #include <fbs.h>

    28 #include <aknconsts.h>

    29 #include <coedef.h>

    30 #include <coecobs.h>

    31 #include <aknnavide.h> 

    32 #include <akniconutils.h> 

    33 

    34 #include <testsdktabgrp.rsg>

    35 #include "testsdktabgrp.h"

    36 #include "testsdktabgrp.hrh"

    37 #include "testsdktabgrpcontrol.h"

    38 

    39 // CONSTANTS

    40 const TInt KNum = 1;

    41 const TInt KPointX = 10;

    42 const TInt KPointY = 30;

    43 const TInt KWidth = 100;

    44 const TInt KHeight = 100;

    45 

    46 // ============================ MEMBER FUNCTIONS ===============================

    47 

    48 // -----------------------------------------------------------------------------

    49 // CTestSDKTabGroup::Delete

    50 // Delete here all resources allocated and opened from test methods. 

    51 // Called from destructor. 

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

    53 //

    54 void CTestSDKTabGroup::Delete() 

    55     {

    56 

    57     }

    58 

    59 // -----------------------------------------------------------------------------

    60 // CTestSDKTabGroup::RunMethodL

    61 // Run specified method. Contains also table of test mothods and their names.

    62 // -----------------------------------------------------------------------------

    63 //

    64 TInt CTestSDKTabGroup::RunMethodL( CStifItemParser& aItem ) 

    65     {

    66 

    67     static TStifFunctionInfo const KFunctions[] =

    68         {  

    69         // First string is the function name used in TestScripter script file.

    70         // Second is the actual implementation member function. 

    71         ENTRY( "TestNewL", CTestSDKTabGroup::TestTabGroupNewL ),

    72         ENTRY( "TestNewLC", CTestSDKTabGroup::TestTabGroupNewLCL ),

    73         ENTRY( "TestAddTabL", CTestSDKTabGroup::TestTabGroupAddTabL ),

    74         ENTRY( "TestReplaceTabL", CTestSDKTabGroup::TestTabGroupReplaceTabL ),

    75         ENTRY( "TestReplaceTabTextL",

    76                 CTestSDKTabGroup::TestTabGroupReplaceTabTextL ),

    77         ENTRY( "TestDeleteTabL", CTestSDKTabGroup::TestTabGroupDeleteTabL ),

    78         ENTRY( "TestSetActiveTabById",

    79                 CTestSDKTabGroup::TestTabGroupSetActiveTabByIdL ),

    80         ENTRY( "TestSetActiveTabByIndex",

    81                 CTestSDKTabGroup::TestTabGroupSetActiveTabByIndexL ),

    82         ENTRY( "TestActiveTabId", CTestSDKTabGroup::TestTabGroupActiveTabIdL ),

    83         ENTRY( "TestActiveTabIndex",

    84                 CTestSDKTabGroup::TestTabGroupActiveTabIndexL ),

    85         ENTRY( "TestSetTabFixedWidthL",

    86                 CTestSDKTabGroup::TestTabGroupSetTabFixedWidthL ),

    87         ENTRY( "TestDimTab", CTestSDKTabGroup::TestTabGroupDimTabL ),

    88         ENTRY( "TestIsTabDimmed", CTestSDKTabGroup::TestTabGroupIsTabDimmedL ),

    89         ENTRY( "TestTabIndexFromId",

    90                 CTestSDKTabGroup::TestTabGroupTabIndexFromIdL ),

    91         ENTRY( "TestTabIdFromIndex",

    92                 CTestSDKTabGroup::TestTabGroupTabIdFromIndexL ),

    93         ENTRY( "TestTabCount", CTestSDKTabGroup::TestTabGroupTabCountL ),

    94         ENTRY( "TestSetObserver", CTestSDKTabGroup::TestTabGroupSetObserverL ),

    95         ENTRY( "TestMinimumSize", CTestSDKTabGroup::TestTabGroupMinimumSizeL ),

    96         ENTRY( "TestOfferKeyEventL",

    97                 CTestSDKTabGroup::TestTabGroupOfferKeyEventL ),

    98         ENTRY( "TestGetColorUseListL",

    99                 CTestSDKTabGroup::TestTabGroupGetColorUseListL ),

   100         ENTRY( "TestHandleResourceChange",

   101                 CTestSDKTabGroup::TestTabGroupHandleResourceChangeL ),

   102         ENTRY( "TestHandlePointerEventL",

   103                 CTestSDKTabGroup::TestTabGroupHandlePointerEventL ),

   104         ENTRY( "TestHandleControlEventL",

   105                 CTestSDKTabGroup::TestTabGroupHandleControlEventL ),

   106         ENTRY( "TestPrepareContext",

   107                 CTestSDKTabGroup::TestTabGroupPrepareContextL ),

   108         ENTRY( "TestHandleNaviDecoratorEventL",

   109                 CTestSDKTabGroup::TestTabGroupHandleNaviDecoratorEventL ),

   110         ENTRY( "TestSizeChanged",

   111                 CTestSDKTabGroup::TestTabGroupSizeChangedL ),

   112         ENTRY( "TestCountComponentControls",

   113                 CTestSDKTabGroup::TestTabGroupCountComponentControlsL ),

   114         ENTRY( "TestComponentControl",

   115                 CTestSDKTabGroup::TestTabGroupComponentControlL ),

   116         ENTRY( "TestFocusChanged",

   117                 CTestSDKTabGroup::TestTabGroupFocusChangedL ),

   118         ENTRY( "TestSetTabMultiColorMode",

   119                 CTestSDKTabGroup::TestTabGroupSetTabMultiColorModeL ),

   120 

   121         // [test cases entries]

   122 

   123         };

   124 

   125     const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

   126 

   127     return RunInternalL( KFunctions, count, aItem );

   128 

   129     }

   130 

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

   132 // CTestSDKTabGroup::TestTabGroupNewL

   133 // -----------------------------------------------------------------------------

   134 //

   135 TInt CTestSDKTabGroup::TestTabGroupNewL( CStifItemParser& /*aItem*/ )

   136     {

   137 

   138     // Print to UI

   139     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   140     _LIT( KNewL, "In NewL" );

   141     TestModuleIf().Printf( 0, KTestSDKTabGroup, KNewL );

   142     // Print to log file

   143     iLog->Log( KNewL );

   144 

   145     CTestTabsControl* testControl = CTestTabsControl::NewL();

   146     CleanupStack::PushL( testControl );

   147     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   148     CleanupStack::PushL( tabGroup );

   149     STIF_ASSERT_NOT_NULL( tabGroup );

   150 

   151     CleanupStack::PopAndDestroy( tabGroup );

   152     CleanupStack::PopAndDestroy( testControl );

   153 

   154     return KErrNone;

   155 

   156     }

   157 

   158 // -----------------------------------------------------------------------------

   159 // CTestSDKTabGroup::TestTabGroupNewLCL

   160 // -----------------------------------------------------------------------------

   161 //

   162 TInt CTestSDKTabGroup::TestTabGroupNewLCL( CStifItemParser& /*aItem*/ )

   163     {

   164 

   165     // Print to UI

   166     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   167     _LIT( KNewLC, "In NewLC" );

   168     TestModuleIf().Printf( 0, KTestSDKTabGroup, KNewLC );

   169     // Print to log file

   170     iLog->Log( KNewLC );

   171 

   172     CTestTabsControl* testControl = CTestTabsControl::NewL();

   173     CleanupStack::PushL( testControl );

   174     CAknTabGroup* tabGroup = CAknTabGroup::NewLC( *testControl );

   175     STIF_ASSERT_NOT_NULL( tabGroup );

   176 

   177     CleanupStack::PopAndDestroy( tabGroup );

   178     CleanupStack::PopAndDestroy( testControl );

   179     return KErrNone;

   180 

   181     }

   182 

   183 // -----------------------------------------------------------------------------

   184 // CTestSDKTabGroup::TestTabGroupAddTabL

   185 // -----------------------------------------------------------------------------

   186 //

   187 TInt CTestSDKTabGroup::TestTabGroupAddTabL( CStifItemParser& aItem )

   188     {

   189 

   190     // Print to UI

   191     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   192     _LIT( KAddTabL, "In AddTabL" );

   193     TestModuleIf().Printf( 0, KTestSDKTabGroup, KAddTabL );

   194     // Print to log file

   195     iLog->Log( KAddTabL );

   196 

   197     TInt num = 0;

   198     TInt err = aItem.GetNextInt( num );

   199     if ( err != KErrNone )

   200         {

   201         return err;

   202         }

   203 

   204     CTestTabsControl* testControl = CTestTabsControl::NewL();

   205     CleanupStack::PushL( testControl );

   206     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   207     CleanupStack::PushL( tabGroup );

   208 

   209     _LIT( KText, "AddNewTab" );

   210     _LIT( KBitmapFile, "z:\\resource\\apps\\avkon2.mbm" );

   211     CFbsBitmap* bitmap = NULL;

   212     CFbsBitmap* mask = NULL;

   213     AknIconUtils::CreateIconL( bitmap, mask, KBitmapFile,

   214             EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask );

   215     CleanupStack::PushL( bitmap );

   216     CleanupStack::PushL( mask );

   217 

   218     switch( num )

   219         {

   220         case 1:

   221             {

   222             TResourceReader reader;

   223             iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   224             

   225             TInt id = ETab;

   226             TInt tabId = tabGroup->AddTabL( reader );

   227             STIF_ASSERT_EQUALS( id, tabId );

   228             

   229             CleanupStack::PopAndDestroy();

   230             break;

   231             }

   232         case 2:

   233             {

   234             tabGroup->AddTabL( ETab, KText );

   235             break;

   236             }

   237         case 3:

   238             {

   239             tabGroup->AddTabL( ETab, KText, bitmap, mask );

   240             break;

   241             }

   242         case 4:

   243             {

   244             tabGroup->AddTabL( ETab, bitmap, mask );

   245             break;

   246             }

   247         default:

   248             CleanupStack::Pop( mask );

   249             CleanupStack::Pop( bitmap );

   250             CleanupStack::PopAndDestroy( tabGroup );

   251             CleanupStack::PopAndDestroy( testControl );

   252             return KErrNotSupported;

   253         }

   254 

   255     CleanupStack::Pop( mask );

   256     CleanupStack::Pop( bitmap );

   257     CleanupStack::PopAndDestroy( tabGroup );

   258     CleanupStack::PopAndDestroy( testControl );

   259     return KErrNone;

   260 

   261     }

   262 

   263 // -----------------------------------------------------------------------------

   264 // CTestSDKTabGroup::TestTabGroupReplaceTabL

   265 // -----------------------------------------------------------------------------

   266 //

   267 TInt CTestSDKTabGroup::TestTabGroupReplaceTabL( CStifItemParser& aItem )

   268     {

   269 

   270     // Print to UI

   271     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   272     _LIT( KReplaceTabL, "In ReplaceTabL" );

   273     TestModuleIf().Printf( 0, KTestSDKTabGroup, KReplaceTabL );

   274     // Print to log file

   275     iLog->Log( KReplaceTabL );

   276 

   277     TInt num = 0;

   278     TInt err = aItem.GetNextInt( num );

   279     if ( err != KErrNone )

   280         {

   281         return err;

   282         }

   283 

   284     CTestTabsControl* testControl = CTestTabsControl::NewL();

   285     CleanupStack::PushL( testControl );

   286     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   287     CleanupStack::PushL( tabGroup );

   288 

   289     _LIT( KReplaceText, "ReplaceTab" );

   290     _LIT( KBitmapFile, "z:\\resource\\apps\\avkon2.mbm" );

   291     CFbsBitmap* bitmap = NULL;

   292     CFbsBitmap* mask = NULL;

   293     AknIconUtils::CreateIconL( bitmap, mask, KBitmapFile,

   294             EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask );

   295     CleanupStack::PushL( bitmap );

   296     CleanupStack::PushL( mask );

   297 

   298     TResourceReader reader;

   299     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   300     TInt tabId = tabGroup->AddTabL( reader );

   301     CleanupStack::PopAndDestroy();

   302 

   303     switch( num )

   304         {

   305         case 1:

   306             {

   307             iEikonEnvPointer->CreateResourceReaderLC( reader, R_REPLACETAB );

   308             tabGroup->ReplaceTabL( reader );

   309             

   310             CleanupStack::PopAndDestroy();

   311             break;

   312             }

   313         case 2:

   314             {

   315             tabGroup->ReplaceTabL( ETab, KReplaceText );

   316             break;

   317             }

   318         case 3:

   319             {

   320             tabGroup->ReplaceTabL( ETab, KReplaceText, bitmap, mask );

   321             break;

   322             }

   323         case 4:

   324             {

   325             tabGroup->ReplaceTabL( ETab, bitmap, mask );

   326             break;

   327             }

   328         default:

   329             CleanupStack::Pop( mask );

   330             CleanupStack::Pop( bitmap );

   331             CleanupStack::PopAndDestroy( tabGroup );

   332             CleanupStack::PopAndDestroy( testControl );

   333             return KErrNotSupported;

   334         }

   335 

   336     CleanupStack::Pop( mask );

   337     CleanupStack::Pop( bitmap );

   338     CleanupStack::PopAndDestroy( tabGroup );

   339     CleanupStack::PopAndDestroy( testControl );

   340     return KErrNone;

   341 

   342     }

   343 

   344 // -----------------------------------------------------------------------------

   345 // CTestSDKTabGroup::TestTabGroupReplaceTabTextL

   346 // -----------------------------------------------------------------------------

   347 //

   348 TInt CTestSDKTabGroup::TestTabGroupReplaceTabTextL( CStifItemParser& /*aItem*/ )

   349     {

   350 

   351     // Print to UI

   352     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   353     _LIT( KReplaceTabTextL, "In ReplaceTabTextL" );

   354     TestModuleIf().Printf( 0, KTestSDKTabGroup, KReplaceTabTextL );

   355     // Print to log file

   356     iLog->Log( KReplaceTabTextL );

   357 

   358     CTestTabsControl* testControl = CTestTabsControl::NewL();

   359     CleanupStack::PushL( testControl );

   360     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   361     CleanupStack::PushL( tabGroup );

   362 

   363     TResourceReader reader;

   364     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   365     TInt tabId = tabGroup->AddTabL( reader );

   366     CleanupStack::PopAndDestroy();

   367 

   368     _LIT( KReplaceText, "ReplaceTab" );

   369     tabGroup->ReplaceTabTextL( tabId, KReplaceText );

   370 

   371     CleanupStack::PopAndDestroy( tabGroup );

   372     CleanupStack::PopAndDestroy( testControl );

   373     return KErrNone;

   374 

   375     }

   376 

   377 // -----------------------------------------------------------------------------

   378 // CTestSDKTabGroup::TestTabGroupDeleteTabL

   379 // -----------------------------------------------------------------------------

   380 //

   381 TInt CTestSDKTabGroup::TestTabGroupDeleteTabL( CStifItemParser& /*aItem*/ )

   382     {

   383 

   384     // Print to UI

   385     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   386     _LIT( KDeleteTabL, "In DeleteTabL" );

   387     TestModuleIf().Printf( 0, KTestSDKTabGroup, KDeleteTabL );

   388     // Print to log file

   389     iLog->Log( KDeleteTabL );

   390 

   391     CTestTabsControl* testControl = CTestTabsControl::NewL();

   392     CleanupStack::PushL( testControl );

   393     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   394     CleanupStack::PushL( tabGroup );

   395 

   396     TResourceReader reader;

   397     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   398     TInt tabId = tabGroup->AddTabL( reader );

   399     CleanupStack::PopAndDestroy();

   400 

   401     tabGroup->DeleteTabL( tabId );

   402 

   403     CleanupStack::PopAndDestroy( tabGroup );

   404     CleanupStack::PopAndDestroy( testControl );

   405     return KErrNone;

   406 

   407     }

   408 

   409 // -----------------------------------------------------------------------------

   410 // CTestSDKTabGroup::TestTabGroupSetActiveTabByIdL

   411 // -----------------------------------------------------------------------------

   412 //

   413 TInt CTestSDKTabGroup::TestTabGroupSetActiveTabByIdL( CStifItemParser& /*aItem*/ )

   414     {

   415 

   416     // Print to UI

   417     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   418     _LIT( KSetActiveTabById, "In SetActiveTabById" );

   419     TestModuleIf().Printf( 0, KTestSDKTabGroup, KSetActiveTabById );

   420     // Print to log file

   421     iLog->Log( KSetActiveTabById );

   422 

   423     CTestTabsControl* testControl = CTestTabsControl::NewL();

   424     CleanupStack::PushL( testControl );

   425     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   426     CleanupStack::PushL( tabGroup );

   427 

   428     TResourceReader reader;

   429     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   430     TInt tabId = tabGroup->AddTabL( reader );

   431     CleanupStack::PopAndDestroy();

   432 

   433     tabGroup->SetActiveTabById( tabId );

   434 

   435     CleanupStack::PopAndDestroy( tabGroup );

   436     CleanupStack::PopAndDestroy( testControl );

   437     return KErrNone;

   438 

   439     }

   440 

   441 // -----------------------------------------------------------------------------

   442 // CTestSDKTabGroup::TestTabGroupSetActiveTabByIndexL

   443 // -----------------------------------------------------------------------------

   444 //

   445 TInt CTestSDKTabGroup::TestTabGroupSetActiveTabByIndexL( CStifItemParser& /*aItem*/ )

   446     {

   447 

   448     // Print to UI

   449     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   450     _LIT( KSetActiveTabByIndex, "In SetActiveTabByIndex" );

   451     TestModuleIf().Printf( 0, KTestSDKTabGroup, KSetActiveTabByIndex );

   452     // Print to log file

   453     iLog->Log( KSetActiveTabByIndex );

   454 

   455     CTestTabsControl* testControl = CTestTabsControl::NewL();

   456     CleanupStack::PushL( testControl );

   457     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   458     CleanupStack::PushL( tabGroup );

   459 

   460     TResourceReader reader;

   461     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   462     TInt tabId = tabGroup->AddTabL( reader );

   463     CleanupStack::PopAndDestroy();

   464 

   465     TInt tabIndex = 0;

   466     tabGroup->SetActiveTabByIndex( tabIndex );

   467 

   468     CleanupStack::PopAndDestroy( tabGroup );

   469     CleanupStack::PopAndDestroy( testControl );

   470     return KErrNone;

   471 

   472     }

   473 

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

   475 // CTestSDKTabGroup::TestTabGroupActiveTabIdL

   476 // -----------------------------------------------------------------------------

   477 //

   478 TInt CTestSDKTabGroup::TestTabGroupActiveTabIdL( CStifItemParser& /*aItem*/ )

   479     {

   480 

   481     // Print to UI

   482     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   483     _LIT( KActiveTabId, "In ActiveTabId" );

   484     TestModuleIf().Printf( 0, KTestSDKTabGroup, KActiveTabId );

   485     // Print to log file

   486     iLog->Log( KActiveTabId );

   487 

   488     CTestTabsControl* testControl = CTestTabsControl::NewL();

   489     CleanupStack::PushL( testControl );

   490     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   491     CleanupStack::PushL( tabGroup );

   492 

   493     TResourceReader reader;

   494     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   495     TInt tabId = tabGroup->AddTabL( reader );

   496     CleanupStack::PopAndDestroy();

   497 

   498     tabGroup->SetActiveTabById( tabId );

   499     TInt tabActiveId = tabGroup->ActiveTabId();

   500     STIF_ASSERT_EQUALS( tabId, tabActiveId );

   501 

   502     CleanupStack::PopAndDestroy( tabGroup );

   503     CleanupStack::PopAndDestroy( testControl );

   504     return KErrNone;

   505 

   506     }

   507 

   508 // -----------------------------------------------------------------------------

   509 // CTestSDKTabGroup::TestTabGroupActiveTabIndexL

   510 // -----------------------------------------------------------------------------

   511 //

   512 TInt CTestSDKTabGroup::TestTabGroupActiveTabIndexL( CStifItemParser& /*aItem*/ )

   513     {

   514 

   515     // Print to UI

   516     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   517     _LIT( KActiveTabIndex, "In ActiveTabIndex" );

   518     TestModuleIf().Printf( 0, KTestSDKTabGroup, KActiveTabIndex );

   519     // Print to log file

   520     iLog->Log( KActiveTabIndex );

   521 

   522     CTestTabsControl* testControl = CTestTabsControl::NewL();

   523     CleanupStack::PushL( testControl );

   524     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   525     CleanupStack::PushL( tabGroup );

   526 

   527     TResourceReader reader;

   528     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   529     TInt tabId = tabGroup->AddTabL( reader );

   530     CleanupStack::PopAndDestroy();

   531 

   532     TInt tabIndex = 0;

   533     tabGroup->SetActiveTabByIndex( tabIndex );

   534     TInt tabActiveIndex = tabGroup->ActiveTabIndex();

   535     STIF_ASSERT_EQUALS( tabIndex, tabActiveIndex );

   536 

   537     CleanupStack::PopAndDestroy( tabGroup );

   538     CleanupStack::PopAndDestroy( testControl );

   539     return KErrNone;

   540 

   541     }

   542 

   543 // -----------------------------------------------------------------------------

   544 // CTestSDKTabGroup::TestTabGroupSetTabFixedWidthL

   545 // -----------------------------------------------------------------------------

   546 //

   547 TInt CTestSDKTabGroup::TestTabGroupSetTabFixedWidthL( CStifItemParser& /*aItem*/ )

   548     {

   549 

   550     // Print to UI

   551     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   552     _LIT( KSetTabFixedWidthL, "In SetTabFixedWidthL" );

   553     TestModuleIf().Printf( 0, KTestSDKTabGroup, KSetTabFixedWidthL );

   554     // Print to log file

   555     iLog->Log( KSetTabFixedWidthL );

   556 

   557     CTestTabsControl* testControl = CTestTabsControl::NewL();

   558     CleanupStack::PushL( testControl );

   559     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   560     CleanupStack::PushL( tabGroup );

   561 

   562     TResourceReader reader;

   563     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   564     TInt tabId = tabGroup->AddTabL( reader );

   565     CleanupStack::PopAndDestroy();

   566 

   567     tabGroup->SetTabFixedWidthL( KTabWidthWithOneTab );

   568 

   569     CleanupStack::PopAndDestroy( tabGroup );

   570     CleanupStack::PopAndDestroy( testControl );

   571     return KErrNone;

   572 

   573     }

   574 

   575 // -----------------------------------------------------------------------------

   576 // CTestSDKTabGroup::TestTabGroupDimTabL

   577 // -----------------------------------------------------------------------------

   578 //

   579 TInt CTestSDKTabGroup::TestTabGroupDimTabL( CStifItemParser& /*aItem*/ )

   580     {

   581 

   582     // Print to UI

   583     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   584     _LIT( KDimTab, "In DimTab" );

   585     TestModuleIf().Printf( 0, KTestSDKTabGroup, KDimTab );

   586     // Print to log file

   587     iLog->Log( KDimTab );

   588 

   589     CTestTabsControl* testControl = CTestTabsControl::NewL();

   590     CleanupStack::PushL( testControl );

   591     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   592     CleanupStack::PushL( tabGroup );

   593 

   594     TResourceReader reader;

   595     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   596     TInt tabId = tabGroup->AddTabL( reader );

   597     CleanupStack::PopAndDestroy();

   598 

   599     tabGroup->DimTab( tabId, ETrue );

   600 

   601     CleanupStack::PopAndDestroy( tabGroup );

   602     CleanupStack::PopAndDestroy( testControl );

   603     return KErrNone;

   604 

   605     }

   606 

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

   608 // CTestSDKTabGroup::TestTabGroupIsTabDimmedL

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

   610 //

   611 TInt CTestSDKTabGroup::TestTabGroupIsTabDimmedL( CStifItemParser& /*aItem*/ )

   612     {

   613 

   614     // Print to UI

   615     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   616     _LIT( KIsTabDimmed, "In IsTabDimmed" );

   617     TestModuleIf().Printf( 0, KTestSDKTabGroup, KIsTabDimmed );

   618     // Print to log file

   619     iLog->Log( KIsTabDimmed );

   620 

   621     CTestTabsControl* testControl = CTestTabsControl::NewL();

   622     CleanupStack::PushL( testControl );

   623     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   624     CleanupStack::PushL( tabGroup );

   625 

   626     TResourceReader reader;

   627     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   628     TInt tabId = tabGroup->AddTabL( reader );

   629     CleanupStack::PopAndDestroy();

   630 

   631     tabGroup->DimTab( tabId, ETrue );

   632     TBool isDimmed = tabGroup->IsTabDimmed( tabId );

   633     STIF_ASSERT_TRUE( isDimmed );

   634 

   635     CleanupStack::PopAndDestroy( tabGroup );

   636     CleanupStack::PopAndDestroy( testControl );

   637     return KErrNone;

   638 

   639     }

   640 

   641 // -----------------------------------------------------------------------------

   642 // CTestSDKTabGroup::TestTabGroupTabIndexFromIdL

   643 // -----------------------------------------------------------------------------

   644 //

   645 TInt CTestSDKTabGroup::TestTabGroupTabIndexFromIdL( CStifItemParser& /*aItem*/ )

   646     {

   647 

   648     // Print to UI

   649     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   650     _LIT( KTabIndexFromId, "In TabIndexFromId" );

   651     TestModuleIf().Printf( 0, KTestSDKTabGroup, KTabIndexFromId );

   652     // Print to log file

   653     iLog->Log( KTabIndexFromId );

   654 

   655     CTestTabsControl* testControl = CTestTabsControl::NewL();

   656     CleanupStack::PushL( testControl );

   657     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   658     CleanupStack::PushL( tabGroup );

   659 

   660     TResourceReader reader;

   661     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   662     TInt tabId = tabGroup->AddTabL( reader );

   663     CleanupStack::PopAndDestroy();

   664 

   665     TInt tabIndex = tabGroup->TabIndexFromId( tabId );

   666     TInt tabExpectedIndex = 0;

   667     STIF_ASSERT_EQUALS( tabExpectedIndex, tabIndex );

   668 

   669     CleanupStack::PopAndDestroy( tabGroup );

   670     CleanupStack::PopAndDestroy( testControl );

   671     return KErrNone;

   672 

   673     }

   674 

   675 // -----------------------------------------------------------------------------

   676 // CTestSDKTabGroup::TestTabGroupTabIdFromIndexL

   677 // -----------------------------------------------------------------------------

   678 //

   679 TInt CTestSDKTabGroup::TestTabGroupTabIdFromIndexL( CStifItemParser& /*aItem*/ )

   680     {

   681 

   682     // Print to UI

   683     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   684     _LIT( KTabIdFromIndex, "In TabIdFromIndex" );

   685     TestModuleIf().Printf( 0, KTestSDKTabGroup, KTabIdFromIndex );

   686     // Print to log file

   687     iLog->Log( KTabIdFromIndex );

   688 

   689     CTestTabsControl* testControl = CTestTabsControl::NewL();

   690     CleanupStack::PushL( testControl );

   691     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   692     CleanupStack::PushL( tabGroup );

   693 

   694     TResourceReader reader;

   695     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   696     TInt tabId = tabGroup->AddTabL( reader );

   697     CleanupStack::PopAndDestroy();

   698 

   699     TInt tabIndex = 0;

   700     TInt tabActualId = tabGroup->TabIdFromIndex( tabIndex );

   701     STIF_ASSERT_EQUALS( tabId, tabActualId );

   702 

   703     CleanupStack::PopAndDestroy( tabGroup );

   704     CleanupStack::PopAndDestroy( testControl );

   705     return KErrNone;

   706 

   707     }

   708 

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

   710 // CTestSDKTabGroup::TestTabGroupTabCountL

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

   712 //

   713 TInt CTestSDKTabGroup::TestTabGroupTabCountL( CStifItemParser& /*aItem*/ )

   714     {

   715 

   716     // Print to UI

   717     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   718     _LIT( KTabCount, "In TabCount" );

   719     TestModuleIf().Printf( 0, KTestSDKTabGroup, KTabCount );

   720     // Print to log file

   721     iLog->Log( KTabCount );

   722 

   723     CTestTabsControl* testControl = CTestTabsControl::NewL();

   724     CleanupStack::PushL( testControl );

   725     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   726     CleanupStack::PushL( tabGroup );

   727 

   728     TResourceReader reader;

   729     iEikonEnvPointer->CreateResourceReaderLC( reader, R_ADDTAB );

   730     TInt tabId = tabGroup->AddTabL( reader );

   731     CleanupStack::PopAndDestroy();

   732 

   733     TInt tabCounts = tabGroup->TabCount();

   734     TInt tabExpectedCounts = 1;

   735     STIF_ASSERT_EQUALS( tabExpectedCounts, tabCounts );

   736 

   737     CleanupStack::PopAndDestroy( tabGroup );

   738     CleanupStack::PopAndDestroy( testControl );

   739     return KErrNone;

   740 

   741     }

   742 

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

   744 // CTestSDKTabGroup::TestTabGroupSetObserverL

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

   746 //

   747 TInt CTestSDKTabGroup::TestTabGroupSetObserverL( CStifItemParser& /*aItem*/ )

   748     {

   749 

   750     // Print to UI

   751     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   752     _LIT( KSetObserver, "In SetObserver" );

   753     TestModuleIf().Printf( 0, KTestSDKTabGroup, KSetObserver );

   754     // Print to log file

   755     iLog->Log( KSetObserver );

   756 

   757     CTestTabsControl* testControl = CTestTabsControl::NewL();

   758     CleanupStack::PushL( testControl );

   759     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   760     CleanupStack::PushL( tabGroup );

   761 

   762     tabGroup->SetObserver( testControl );

   763 

   764     CleanupStack::PopAndDestroy( tabGroup );

   765     CleanupStack::PopAndDestroy( testControl );

   766     return KErrNone;

   767 

   768     }

   769 

   770 // -----------------------------------------------------------------------------

   771 // CTestSDKTabGroup::TestTabGroupMinimumSizeL

   772 // -----------------------------------------------------------------------------

   773 //

   774 TInt CTestSDKTabGroup::TestTabGroupMinimumSizeL( CStifItemParser& /*aItem*/ )

   775     {

   776 

   777     // Print to UI

   778     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   779     _LIT( KMinimumSize, "In MinimumSize" );

   780     TestModuleIf().Printf( 0, KTestSDKTabGroup, KMinimumSize );

   781     // Print to log file

   782     iLog->Log( KMinimumSize );

   783 

   784     CTestTabsControl* testControl = CTestTabsControl::NewL();

   785     CleanupStack::PushL( testControl );

   786     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   787     CleanupStack::PushL( tabGroup );

   788 

   789     TSize minSize = tabGroup->MinimumSize();

   790     TInt zero = 0;

   791     STIF_ASSERT_TRUE( ( minSize.iHeight > zero ) && ( minSize.iWidth > zero ) );

   792 

   793     CleanupStack::PopAndDestroy( tabGroup );

   794     CleanupStack::PopAndDestroy( testControl );

   795     return KErrNone;

   796 

   797     }

   798 

   799 // -----------------------------------------------------------------------------

   800 // CTestSDKTabGroup::TestTabGroupOfferKeyEventL

   801 // -----------------------------------------------------------------------------

   802 //

   803 TInt CTestSDKTabGroup::TestTabGroupOfferKeyEventL( CStifItemParser& /*aItem*/ )

   804     {

   805 

   806     // Print to UI

   807     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   808     _LIT( KOfferKeyEventL, "In OfferKeyEventL" );

   809     TestModuleIf().Printf( 0, KTestSDKTabGroup, KOfferKeyEventL );

   810     // Print to log file

   811     iLog->Log( KOfferKeyEventL );

   812 

   813     CTestTabsControl* testControl = CTestTabsControl::NewL();

   814     CleanupStack::PushL( testControl );

   815     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   816     CleanupStack::PushL( tabGroup );

   817 

   818     TKeyEvent keyEvent;

   819     keyEvent.iScanCode = EStdKeyEnter;

   820     TKeyResponse keyResponse = tabGroup->OfferKeyEventL( keyEvent, EEventKey );

   821     STIF_ASSERT_TRUE( keyResponse == EKeyWasNotConsumed );

   822 

   823     CleanupStack::PopAndDestroy( tabGroup );

   824     CleanupStack::PopAndDestroy( testControl );

   825     return KErrNone;

   826 

   827     }

   828 

   829 // -----------------------------------------------------------------------------

   830 // CTestSDKTabGroup::TestTabGroupGetColorUseListL

   831 // -----------------------------------------------------------------------------

   832 //

   833 TInt CTestSDKTabGroup::TestTabGroupGetColorUseListL( CStifItemParser& /*aItem*/ )

   834     {

   835 

   836     // Print to UI

   837     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   838     _LIT( KGetColorUseListL, "In GetColorUseListL" );

   839     TestModuleIf().Printf( 0, KTestSDKTabGroup, KGetColorUseListL );

   840     // Print to log file

   841     iLog->Log( KGetColorUseListL );

   842 

   843     CTestTabsControl* testControl = CTestTabsControl::NewL();

   844     CleanupStack::PushL( testControl );

   845     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   846     CleanupStack::PushL( tabGroup );

   847 

   848     CArrayFix<TCoeColorUse>* colorUseList = new (ELeave) CArrayFixFlat<TCoeColorUse> ( KNum );

   849     CleanupStack::PushL( colorUseList );

   850     tabGroup->GetColorUseListL( *colorUseList );

   851     STIF_ASSERT_NOT_NULL( colorUseList );

   852 

   853     CleanupStack::PopAndDestroy( colorUseList );

   854     CleanupStack::PopAndDestroy( tabGroup );

   855     CleanupStack::PopAndDestroy( testControl );

   856     return KErrNone;

   857 

   858     }

   859 

   860 // -----------------------------------------------------------------------------

   861 // CTestSDKTabGroup::TestTabGroupHandleResourceChangeL

   862 // -----------------------------------------------------------------------------

   863 //

   864 TInt CTestSDKTabGroup::TestTabGroupHandleResourceChangeL( CStifItemParser& /*aItem*/ )

   865     {

   866 

   867     // Print to UI

   868     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   869     _LIT( KHandleResourceChange, "In HandleResourceChange" );

   870     TestModuleIf().Printf( 0, KTestSDKTabGroup, KHandleResourceChange );

   871     // Print to log file

   872     iLog->Log( KHandleResourceChange );

   873 

   874     CTestTabsControl* testControl = CTestTabsControl::NewL();

   875     CleanupStack::PushL( testControl );

   876     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   877     CleanupStack::PushL( tabGroup );

   878 

   879     tabGroup->HandleResourceChange( KAknsMessageSkinChange );

   880 

   881     CleanupStack::PopAndDestroy( tabGroup );

   882     CleanupStack::PopAndDestroy( testControl );

   883     return KErrNone;

   884 

   885     }

   886 

   887 // -----------------------------------------------------------------------------

   888 // CTestSDKTabGroup::TestTabGroupHandlePointerEventL

   889 // -----------------------------------------------------------------------------

   890 //

   891 TInt CTestSDKTabGroup::TestTabGroupHandlePointerEventL( CStifItemParser& /*aItem*/ )

   892     {

   893 

   894     // Print to UI

   895     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   896     _LIT( KHandlePointerEventL, "In HandlePointerEventL" );

   897     TestModuleIf().Printf( 0, KTestSDKTabGroup, KHandlePointerEventL );

   898     // Print to log file

   899     iLog->Log( KHandlePointerEventL );

   900 

   901     CTestTabsControl* testControl = CTestTabsControl::NewL();

   902     CleanupStack::PushL( testControl );

   903     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   904     CleanupStack::PushL( tabGroup );

   905 

   906     TPointerEvent event;

   907     event.iType = TPointerEvent::EButton1Down;

   908     event.iModifiers = 0;

   909     TPoint eventPos( KPointX, KPointY );

   910     event.iPosition = eventPos;

   911     event.iParentPosition = eventPos;

   912 

   913     tabGroup->HandlePointerEventL( event );

   914 

   915     CleanupStack::PopAndDestroy( tabGroup );

   916     CleanupStack::PopAndDestroy( testControl );

   917     return KErrNone;

   918 

   919     }

   920 

   921 // -----------------------------------------------------------------------------

   922 // CTestSDKTabGroup::TestTabGroupHandleControlEventL

   923 // -----------------------------------------------------------------------------

   924 //

   925 TInt CTestSDKTabGroup::TestTabGroupHandleControlEventL( CStifItemParser& /*aItem*/ )

   926     {

   927 

   928     // Print to UI

   929     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   930     _LIT( KHandleControlEventL, "In HandleControlEventL" );

   931     TestModuleIf().Printf( 0, KTestSDKTabGroup, KHandleControlEventL );

   932     // Print to log file

   933     iLog->Log( KHandleControlEventL );

   934 

   935     CTestTabsControl* testControl = CTestTabsControl::NewL();

   936     CleanupStack::PushL( testControl );

   937     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   938     CleanupStack::PushL( tabGroup );

   939 

   940     MCoeControlObserver::TCoeEvent eventType = MCoeControlObserver::EEventStateChanged;

   941     

   942     tabGroup->HandleControlEventL( testControl, eventType );

   943 

   944     CleanupStack::PopAndDestroy( tabGroup );

   945     CleanupStack::PopAndDestroy( testControl );

   946     return KErrNone;

   947 

   948     }

   949 

   950 // -----------------------------------------------------------------------------

   951 // CTestSDKTabGroup::TestTabGroupPrepareContextL

   952 // -----------------------------------------------------------------------------

   953 //

   954 TInt CTestSDKTabGroup::TestTabGroupPrepareContextL( CStifItemParser& /*aItem*/ )

   955     {

   956 

   957     // Print to UI

   958     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   959     _LIT( KPrepareContext, "In PrepareContext" );

   960     TestModuleIf().Printf( 0, KTestSDKTabGroup, KPrepareContext );

   961     // Print to log file

   962     iLog->Log( KPrepareContext );

   963 

   964     CTestTabsControl* testControl = CTestTabsControl::NewL();

   965     CleanupStack::PushL( testControl );

   966     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   967     CleanupStack::PushL( tabGroup );

   968 

   969     CWindowGc& gc = CCoeEnv::Static()->SystemGc();

   970     tabGroup->PrepareContext( gc );

   971 

   972     CleanupStack::PopAndDestroy( tabGroup );

   973     CleanupStack::PopAndDestroy( testControl );

   974     return KErrNone;

   975 

   976     }

   977 

   978 // -----------------------------------------------------------------------------

   979 // CTestSDKTabGroup::TestTabGroupHandleNaviDecoratorEventL

   980 // -----------------------------------------------------------------------------

   981 //

   982 TInt CTestSDKTabGroup::TestTabGroupHandleNaviDecoratorEventL( CStifItemParser& /*aItem*/ )

   983     {

   984 

   985     // Print to UI

   986     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

   987     _LIT( KHandleNaviDecoratorEventL, "In HandleNaviDecoratorEventL" );

   988     TestModuleIf().Printf( 0, KTestSDKTabGroup, KHandleNaviDecoratorEventL );

   989     // Print to log file

   990     iLog->Log( KHandleNaviDecoratorEventL );

   991 

   992     CTestTabsControl* testControl = CTestTabsControl::NewL();

   993     CleanupStack::PushL( testControl );

   994     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

   995     CleanupStack::PushL( tabGroup );

   996 

   997     TInt layoutType = CAknNavigationDecorator::ENaviControlLayoutNormal;

   998     tabGroup->HandleNaviDecoratorEventL( layoutType );

   999 

  1000     CleanupStack::PopAndDestroy( tabGroup );

  1001     CleanupStack::PopAndDestroy( testControl );

  1002     return KErrNone;

  1003 

  1004     }

  1005 

  1006 // -----------------------------------------------------------------------------

  1007 // CTestSDKTabGroup::TestTabGroupSizeChangedL

  1008 // -----------------------------------------------------------------------------

  1009 //

  1010 TInt CTestSDKTabGroup::TestTabGroupSizeChangedL( CStifItemParser& /*aItem*/ )

  1011     {

  1012 

  1013     // Print to UI

  1014     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

  1015     _LIT( KSizeChanged, "In SizeChanged" );

  1016     TestModuleIf().Printf( 0, KTestSDKTabGroup, KSizeChanged );

  1017     // Print to log file

  1018     iLog->Log( KSizeChanged );

  1019 

  1020     CTestTabsControl* testControl = CTestTabsControl::NewL();

  1021     CleanupStack::PushL( testControl );

  1022     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

  1023     CleanupStack::PushL( tabGroup );

  1024 

  1025     TSize size( KWidth, KHeight );

  1026     tabGroup->SetSize( size );

  1027 

  1028     CleanupStack::PopAndDestroy( tabGroup );

  1029     CleanupStack::PopAndDestroy( testControl );

  1030     return KErrNone;

  1031 

  1032     }

  1033 

  1034 // -----------------------------------------------------------------------------

  1035 // CTestSDKTabGroup::TestTabGroupCountComponentControlsL

  1036 // -----------------------------------------------------------------------------

  1037 //

  1038 TInt CTestSDKTabGroup::TestTabGroupCountComponentControlsL( CStifItemParser& /*aItem*/ )

  1039     {

  1040 

  1041     // Print to UI

  1042     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

  1043     _LIT( KCountComponentControls, "In CountComponentControls" );

  1044     TestModuleIf().Printf( 0, KTestSDKTabGroup, KCountComponentControls );

  1045     // Print to log file

  1046     iLog->Log( KCountComponentControls );

  1047 

  1048     CTestTabsControl* testControl = CTestTabsControl::NewL();

  1049     CleanupStack::PushL( testControl );

  1050     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

  1051     CleanupStack::PushL( tabGroup );

  1052 

  1053     tabGroup->DrawNow();

  1054 

  1055     CleanupStack::PopAndDestroy( tabGroup );

  1056     CleanupStack::PopAndDestroy( testControl );

  1057     return KErrNone;

  1058 

  1059     }

  1060 

  1061 // -----------------------------------------------------------------------------

  1062 // CTestSDKTabGroup::TestTabGroupComponentControlL

  1063 // -----------------------------------------------------------------------------

  1064 //

  1065 TInt CTestSDKTabGroup::TestTabGroupComponentControlL( CStifItemParser& /*aItem*/ )

  1066     {

  1067 

  1068     // Print to UI

  1069     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

  1070     _LIT( KComponentControl, "In ComponentControl" );

  1071     TestModuleIf().Printf( 0, KTestSDKTabGroup, KComponentControl );

  1072     // Print to log file

  1073     iLog->Log( KComponentControl );

  1074 

  1075     CTestTabsControl* testControl = CTestTabsControl::NewL();

  1076     CleanupStack::PushL( testControl );

  1077     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

  1078     CleanupStack::PushL( tabGroup );

  1079 

  1080     tabGroup->DrawNow();

  1081 

  1082     CleanupStack::PopAndDestroy( tabGroup );

  1083     CleanupStack::PopAndDestroy( testControl );

  1084     return KErrNone;

  1085 

  1086     }

  1087 

  1088 // -----------------------------------------------------------------------------

  1089 // CTestSDKTabGroup::TestTabGroupFocusChangedL

  1090 // -----------------------------------------------------------------------------

  1091 //

  1092 TInt CTestSDKTabGroup::TestTabGroupFocusChangedL( CStifItemParser& /*aItem*/ )

  1093     {

  1094 

  1095     // Print to UI

  1096     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

  1097     _LIT( KFocusChanged, "In FocusChanged" );

  1098     TestModuleIf().Printf( 0, KTestSDKTabGroup, KFocusChanged );

  1099     // Print to log file

  1100     iLog->Log( KFocusChanged );

  1101 

  1102     CTestTabsControl* testControl = CTestTabsControl::NewL();

  1103     CleanupStack::PushL( testControl );

  1104     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

  1105     CleanupStack::PushL( tabGroup );

  1106 

  1107     tabGroup->SetFocus( EFalse, EDrawNow );

  1108     tabGroup->SetFocus( ETrue, EDrawNow );

  1109 

  1110     CleanupStack::PopAndDestroy( tabGroup );

  1111     CleanupStack::PopAndDestroy( testControl );

  1112     return KErrNone;

  1113 

  1114     }

  1115 

  1116 // -----------------------------------------------------------------------------

  1117 // CTestSDKTabGroup::TestTabGroupSetTabMultiColorModeL

  1118 // -----------------------------------------------------------------------------

  1119 //

  1120 TInt CTestSDKTabGroup::TestTabGroupSetTabMultiColorModeL( CStifItemParser& /*aItem*/ )

  1121     {

  1122 

  1123     // Print to UI

  1124     _LIT( KTestSDKTabGroup, "testsdktabgrp" );

  1125     _LIT( KSetTabMultiColorMode, "In SetTabMultiColorMode" );

  1126     TestModuleIf().Printf( 0, KTestSDKTabGroup, KSetTabMultiColorMode );

  1127     // Print to log file

  1128     iLog->Log( KSetTabMultiColorMode );

  1129 

  1130     CTestTabsControl* testControl = CTestTabsControl::NewL();

  1131     CleanupStack::PushL( testControl );

  1132     CAknTabGroup* tabGroup = CAknTabGroup::NewL( *testControl );

  1133     CleanupStack::PushL( tabGroup );

  1134 

  1135     TResourceReader reader;