1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  test AknToolbar.h

    15 *

    16 */

    17 

    18 

    19 // [INCLUDE FILES]

    20 #include <e32svr.h>

    21 #include <stifparser.h>

    22 #include <stiftestinterface.h>

    23 #include <akntoolbar.h>

    24 #include <akndef.h>

    25 #include <aknbutton.h>

    26 #include <akntoolbarextension.h>

    27 

    28 #include <testsdktoolbar.rsg>

    29 #include "testsdktoolbar.h"

    30 #include "testsdktoolbarcontrol.h"

    31 #include "testsdktoolbar.hrh"

    32 

    33 

    34 // CONSTANTS

    35 const TInt KEventPointX = 5;

    36 const TInt KEventPointY = 5;

    37 const TInt KToolbarWidth = 20;

    38 const TInt KToolbarHeight = 10;

    39 

    40 _LIT( KButtonText, "Button" );

    41 _LIT( KButtonHelpText, "Help");

    42 

    43 // ============================= MEMBER FUNCTIONS ==============================

    44 

    45 // -----------------------------------------------------------------------------

    46 // CTestSDKToolbar::TestToolbarNewL

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

    48 //

    49 TInt CTestSDKToolbar::TestToolbarNewL( CStifItemParser& /*aItem*/ )

    50     {

    51 

    52     // Print to UI

    53     _LIT( KTestSDKToolbar, "testsdktoolbar" );

    54     _LIT( KTestToolbarNewL, "in NewL" );

    55     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarNewL );

    56     // Print to log file

    57     iLog->Log( KTestToolbarNewL );

    58 

    59     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

    60     CleanupStack::PushL( toolbar );

    61     STIF_ASSERT_NOT_NULL( toolbar );

    62 

    63     CleanupStack::PopAndDestroy( toolbar );

    64     return KErrNone;

    65 

    66     }

    67 

    68 // -----------------------------------------------------------------------------

    69 // CTestSDKToolbar::TestToolbarNewLCL

    70 // -----------------------------------------------------------------------------

    71 //

    72 TInt CTestSDKToolbar::TestToolbarNewLCL( CStifItemParser& /*aItem*/ )

    73     {

    74 

    75     // Print to UI

    76     _LIT( KTestSDKToolbar, "testsdktoolbar" );

    77     _LIT( KTestToolbarNewLC, "in NewLC" );

    78     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarNewLC );

    79     // Print to log file

    80     iLog->Log( KTestToolbarNewLC );

    81 

    82     CAknToolbar* toolbar = CAknToolbar::NewLC( R_TOOLBAR );

    83     

    84     STIF_ASSERT_NOT_NULL( toolbar );

    85 

    86     CleanupStack::PopAndDestroy( toolbar );

    87     return KErrNone;

    88 

    89     }

    90 

    91 // -----------------------------------------------------------------------------

    92 // CTestSDKToolbar::TestToolbarCountComponentControlsL

    93 // -----------------------------------------------------------------------------

    94 //

    95 TInt CTestSDKToolbar::TestToolbarCountComponentControlsL( CStifItemParser& /*aItem*/ )

    96     {

    97 

    98     // Print to UI

    99     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   100     _LIT( KTestToolbarCountComponentControls, "in CountComponentControls" );

   101     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarCountComponentControls );

   102     // Print to log file

   103     iLog->Log( KTestToolbarCountComponentControls );

   104 

   105     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   106     CleanupStack::PushL( toolbar );

   107 

   108     TInt num = toolbar->CountComponentControls();

   109     STIF_ASSERT_EQUALS( 0, num );

   110     

   111     CleanupStack::PopAndDestroy( toolbar );

   112     return KErrNone;

   113 

   114     }

   115 

   116 // -----------------------------------------------------------------------------

   117 // CTestSDKToolbar::TestToolbarComponentControlL

   118 // -----------------------------------------------------------------------------

   119 //

   120 TInt CTestSDKToolbar::TestToolbarComponentControlL( CStifItemParser& /*aItem*/ )

   121     {

   122 

   123     // Print to UI

   124     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   125     _LIT( KTestToolbarComponentControl, "in ComponentControl" );

   126     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarComponentControl );

   127     // Print to log file

   128     iLog->Log( KTestToolbarComponentControl );

   129 

   130     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   131     CleanupStack::PushL( toolbar );

   132 

   133     TInt index = 0;

   134     CCoeControl* control = toolbar->ComponentControl( index );

   135     STIF_ASSERT_NULL( control );

   136     

   137     CleanupStack::PopAndDestroy( toolbar );

   138     return KErrNone;

   139 

   140     }

   141 

   142 // -----------------------------------------------------------------------------

   143 // CTestSDKToolbar::TestToolbarHandlePointerEventL

   144 // -----------------------------------------------------------------------------

   145 //

   146 TInt CTestSDKToolbar::TestToolbarHandlePointerEventL( CStifItemParser& /*aItem*/ )

   147     {

   148 

   149     // Print to UI

   150     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   151     _LIT( KTestToolbarHandlePointerEventL, "in HandlePointerEventL" );

   152     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarHandlePointerEventL );

   153     // Print to log file

   154     iLog->Log( KTestToolbarHandlePointerEventL );

   155 

   156     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   157     CleanupStack::PushL( toolbar );

   158 

   159     TPointerEvent event;

   160     event.iType = TPointerEvent::EButton1Down;

   161     event.iModifiers = 0;

   162     TPoint eventPos( KEventPointX, KEventPointY );

   163     event.iPosition = eventPos;

   164     event.iParentPosition = eventPos;

   165     

   166     toolbar->HandlePointerEventL( event );

   167     CleanupStack::PopAndDestroy( toolbar );

   168     

   169     return KErrNone;

   170 

   171     }

   172 

   173 // -----------------------------------------------------------------------------

   174 // CTestSDKToolbar::TestToolbarHandleResourceChangeL

   175 // -----------------------------------------------------------------------------

   176 //

   177 TInt CTestSDKToolbar::TestToolbarHandleResourceChangeL( CStifItemParser& /*aItem*/ )

   178     {

   179 

   180     // Print to UI

   181     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   182     _LIT( KTestToolbarHandleResourceChange, "in HandleResourceChange" );

   183     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarHandleResourceChange );

   184     // Print to log file

   185     iLog->Log( KTestToolbarHandleResourceChange );

   186 

   187     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   188     CleanupStack::PushL( toolbar );

   189 

   190     TInt type = KEikDynamicLayoutVariantSwitch;

   191     toolbar->HandleResourceChange( type );

   192     

   193     CleanupStack::PopAndDestroy( toolbar );

   194     return KErrNone;

   195 

   196     }

   197 

   198 // -----------------------------------------------------------------------------

   199 // CTestSDKToolbar::TestToolbarHandleControlEventL

   200 // -----------------------------------------------------------------------------

   201 //

   202 TInt CTestSDKToolbar::TestToolbarHandleControlEventL( CStifItemParser& /*aItem*/ )

   203     {

   204 

   205     // Print to UI

   206     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   207     _LIT( KTestToolbarHandleControlEventL, "in HandleControlEventL" );

   208     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarHandleControlEventL );

   209     // Print to log file

   210     iLog->Log( KTestToolbarHandleControlEventL );

   211 

   212     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   213     CleanupStack::PushL( toolbar );

   214 

   215     CTestToolbarControl* control = CTestToolbarControl::NewL();

   216     CleanupStack::PushL( control );

   217     MCoeControlObserver::TCoeEvent eventType = MCoeControlObserver::EEventStateChanged;

   218     toolbar->HandleControlEventL( control, eventType );

   219     

   220     CleanupStack::PopAndDestroy( control );

   221     CleanupStack::PopAndDestroy( toolbar );

   222     return KErrNone;

   223 

   224     }

   225 

   226 // -----------------------------------------------------------------------------

   227 // CTestSDKToolbar::TestToolbarPositionChangedL

   228 // -----------------------------------------------------------------------------

   229 //

   230 TInt CTestSDKToolbar::TestToolbarPositionChangedL( CStifItemParser& /*aItem*/ )

   231     {

   232 

   233     // Print to UI

   234     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   235     _LIT( KTestToolbarPositionChanged, "in PositionChanged" );

   236     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarPositionChanged );

   237     // Print to log file

   238     iLog->Log( KTestToolbarPositionChanged );

   239 

   240     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   241     CleanupStack::PushL( toolbar );

   242 

   243     toolbar->PositionChanged();

   244     

   245     CleanupStack::PopAndDestroy( toolbar );

   246     return KErrNone;

   247 

   248     }

   249 

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

   251 // CTestSDKToolbar::TestToolbarProcessCommandL

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

   253 //

   254 TInt CTestSDKToolbar::TestToolbarProcessCommandL( CStifItemParser& /*aItem*/ )

   255     {

   256 

   257     // Print to UI

   258     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   259     _LIT( KTestToolbarProcessCommandL, "in ProcessCommandL" );

   260     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarProcessCommandL );

   261     // Print to log file

   262     iLog->Log( KTestToolbarProcessCommandL );

   263 

   264     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   265     CleanupStack::PushL( toolbar );

   266 

   267     CAknButton *button = CAknButton::NewLC( NULL, NULL, NULL,

   268                              NULL, KButtonText, KButtonHelpText, 

   269                              KAknButtonNoFrame, 0 );

   270     toolbar->AddItemL( 

   271             button, EAknCtButton, ETestToolBarCbaCmdBtn, 1 );

   272     CleanupStack::Pop( button );

   273     

   274     toolbar->SetFocusing( ETrue );

   275     toolbar->SetFocusedItemL( ETestToolBarCbaCmdBtn );

   276     

   277     TInt commandId = EAknSoftkeySelect;

   278     toolbar->ProcessCommandL( commandId );

   279     

   280     CleanupStack::PopAndDestroy( toolbar );

   281     return KErrNone;

   282 

   283     }

   284 

   285 // -----------------------------------------------------------------------------

   286 // CTestSDKToolbar::TestToolbarSetDimmedL

   287 // -----------------------------------------------------------------------------

   288 //

   289 TInt CTestSDKToolbar::TestToolbarSetDimmedL( CStifItemParser& /*aItem*/ )

   290     {

   291 

   292     // Print to UI

   293     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   294     _LIT( KTestToolbarSetDimmed, "in SetDimmed" );

   295     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetDimmed );

   296     // Print to log file

   297     iLog->Log( KTestToolbarSetDimmed );

   298 

   299     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   300     CleanupStack::PushL( toolbar );

   301 

   302     toolbar->SetDimmed( ETrue );

   303     

   304     CleanupStack::PopAndDestroy( toolbar );

   305     return KErrNone;

   306 

   307     }

   308 

   309 // -----------------------------------------------------------------------------

   310 // CTestSDKToolbar::TestToolbarOfferKeyEventL

   311 // -----------------------------------------------------------------------------

   312 //

   313 TInt CTestSDKToolbar::TestToolbarOfferKeyEventL( CStifItemParser& /*aItem*/ )

   314     {

   315 

   316     // Print to UI

   317     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   318     _LIT( KTestToolbarOfferKeyEventL, "in OfferKeyEventL" );

   319     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarOfferKeyEventL );

   320     // Print to log file

   321     iLog->Log( KTestToolbarOfferKeyEventL );

   322 

   323     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   324     CleanupStack::PushL( toolbar );

   325 

   326     TKeyEvent keyEvent;

   327     keyEvent.iScanCode = EStdKeyEnter;

   328     TKeyResponse keyResponse = toolbar->OfferKeyEventL( keyEvent, EEventKey );

   329     STIF_ASSERT_TRUE( ( keyResponse == EKeyWasNotConsumed )

   330             || ( keyResponse == EKeyWasConsumed ) );

   331 

   332     CleanupStack::PopAndDestroy( toolbar );

   333     return KErrNone;

   334 

   335     }

   336 

   337 // -----------------------------------------------------------------------------

   338 // CTestSDKToolbar::TestToolbarInputCapabilitiesL

   339 // -----------------------------------------------------------------------------

   340 //

   341 TInt CTestSDKToolbar::TestToolbarInputCapabilitiesL( CStifItemParser& /*aItem*/ )

   342     {

   343 

   344     // Print to UI

   345     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   346     _LIT( KTestToolbarInputCapabilities, "in InputCapabilities" );

   347     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarInputCapabilities );

   348     // Print to log file

   349     iLog->Log( KTestToolbarInputCapabilities );

   350 

   351     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   352     CleanupStack::PushL( toolbar );

   353 

   354     TCoeInputCapabilities inputCapabilities = toolbar->InputCapabilities();

   355     STIF_ASSERT_TRUE( inputCapabilities == TCoeInputCapabilities::EAllText );

   356 

   357     CleanupStack::PopAndDestroy( toolbar );

   358     return KErrNone;

   359 

   360     }

   361 

   362 // -----------------------------------------------------------------------------

   363 // CTestSDKToolbar::TestToolbarDrawL

   364 // -----------------------------------------------------------------------------

   365 //

   366 TInt CTestSDKToolbar::TestToolbarDrawL( CStifItemParser& /*aItem*/ )

   367     {

   368 

   369     // Print to UI

   370     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   371     _LIT( KTestToolbarDraw, "in Draw" );

   372     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarDraw );

   373     // Print to log file

   374     iLog->Log( KTestToolbarDraw );

   375 

   376     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   377     CleanupStack::PushL( toolbar );

   378 

   379     CTestToolbarControl* control = CTestToolbarControl::NewL();

   380     CleanupStack::PushL( control );

   381     TRect rect( 0, 0, KToolbarWidth, KToolbarHeight );

   382     control->DoActivateGc();

   383     CWindowGc& gc = control->SystemGc();

   384     toolbar->Draw( gc, *control, rect );

   385 

   386     control->DoDeactivateGc();

   387     CleanupStack::PopAndDestroy( control );

   388     CleanupStack::PopAndDestroy( toolbar );

   389     return KErrNone;

   390 

   391     }

   392 

   393 // -----------------------------------------------------------------------------

   394 // CTestSDKToolbar::TestToolbarControlOrNullL

   395 // -----------------------------------------------------------------------------

   396 //

   397 TInt CTestSDKToolbar::TestToolbarControlOrNullL( CStifItemParser& /*aItem*/ )

   398     {

   399 

   400     // Print to UI

   401     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   402     _LIT( KTestToolbarControlOrNull, "in ControlOrNull" );

   403     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarControlOrNull );

   404     // Print to log file

   405     iLog->Log( KTestToolbarControlOrNull );

   406 

   407     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   408     CleanupStack::PushL( toolbar );

   409 

   410     CCoeControl* control = toolbar->ControlOrNull( EtCmdToolbarTextEditor );

   411     STIF_ASSERT_NULL( control );

   412 

   413     CleanupStack::PopAndDestroy( toolbar );

   414     return KErrNone;

   415 

   416     }

   417 

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

   419 // CTestSDKToolbar::TestToolbarSetToolbarVisibilityL

   420 // -----------------------------------------------------------------------------

   421 //

   422 TInt CTestSDKToolbar::TestToolbarSetToolbarVisibilityL( CStifItemParser& aItem )

   423     {

   424 

   425     // Print to UI

   426     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   427     _LIT( KTestToolbarSetToolbarVisibility, "in SetToolbarVisibility" );

   428     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetToolbarVisibility );

   429     // Print to log file

   430     iLog->Log( KTestToolbarSetToolbarVisibility );

   431 

   432     TInt num = 0;

   433     TInt err = aItem.GetNextInt( num );

   434     if ( err != KErrNone )

   435         {

   436         return err;

   437         }

   438 

   439     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   440     CleanupStack::PushL( toolbar );

   441 

   442     switch( num )

   443         {

   444         case 1:

   445             toolbar->SetToolbarVisibility( ETrue );

   446             break;

   447             

   448         case 2:

   449             toolbar->SetToolbarVisibility( ETrue, ETrue );

   450             break;

   451             

   452         default:

   453             CleanupStack::PopAndDestroy( toolbar );

   454             return KErrNotSupported;

   455         }

   456 

   457     CleanupStack::PopAndDestroy( toolbar );

   458     return KErrNone;

   459 

   460     }

   461 

   462 // -----------------------------------------------------------------------------

   463 // CTestSDKToolbar::TestToolbarSetItemDimmedL

   464 // -----------------------------------------------------------------------------

   465 //

   466 TInt CTestSDKToolbar::TestToolbarSetItemDimmedL( CStifItemParser& /*aItem*/ )

   467     {

   468 

   469     // Print to UI

   470     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   471     _LIT( KTestToolbarSetItemDimmed, "in SetItemDimmed" );

   472     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetItemDimmed );

   473     // Print to log file

   474     iLog->Log( KTestToolbarSetItemDimmed );

   475 

   476     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   477     CleanupStack::PushL( toolbar );

   478 

   479     toolbar->SetItemDimmed( EtCmdToolbarTextEditor, ETrue, ETrue );

   480 

   481     CleanupStack::PopAndDestroy( toolbar );

   482     return KErrNone;

   483 

   484     }

   485 

   486 // -----------------------------------------------------------------------------

   487 // CTestSDKToolbar::TestToolbarHideItemL

   488 // -----------------------------------------------------------------------------

   489 //

   490 TInt CTestSDKToolbar::TestToolbarHideItemL( CStifItemParser& /*aItem*/ )

   491     {

   492 

   493     // Print to UI

   494     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   495     _LIT( KTestToolbarHideItem, "in HideItem" );

   496     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarHideItem );

   497     // Print to log file

   498     iLog->Log( KTestToolbarHideItem );

   499 

   500     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   501     CleanupStack::PushL( toolbar );

   502 

   503     toolbar->HideItem( EtCmdToolbarTextEditor, ETrue, ETrue );

   504 

   505     CleanupStack::PopAndDestroy( toolbar );

   506     return KErrNone;

   507 

   508     }

   509 

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

   511 // CTestSDKToolbar::TestToolbarSetToolbarObserverL

   512 // -----------------------------------------------------------------------------

   513 //

   514 TInt CTestSDKToolbar::TestToolbarSetToolbarObserverL( CStifItemParser& /*aItem*/ )

   515     {

   516 

   517     // Print to UI

   518     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   519     _LIT( KTestToolbarSetToolbarObserver, "in SetToolbarObserver" );

   520     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetToolbarObserver );

   521     // Print to log file

   522     iLog->Log( KTestToolbarSetToolbarObserver );

   523 

   524     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   525     CleanupStack::PushL( toolbar );

   526     CTestToolbarControl* control = new ( ELeave ) CTestToolbarControl;

   527     CleanupStack::PushL( control );

   528 

   529     toolbar->SetToolbarObserver( control );

   530 

   531     CleanupStack::PopAndDestroy( control );

   532     CleanupStack::PopAndDestroy( toolbar );

   533     return KErrNone;

   534 

   535     }

   536 

   537 // -----------------------------------------------------------------------------

   538 // CTestSDKToolbar::TestToolbarToolbarObserverL

   539 // -----------------------------------------------------------------------------

   540 //

   541 TInt CTestSDKToolbar::TestToolbarToolbarObserverL( CStifItemParser& /*aItem*/ )

   542     {

   543 

   544     // Print to UI

   545     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   546     _LIT( KTestToolbarToolbarObserver, "in ToolbarObserver" );

   547     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarToolbarObserver );

   548     // Print to log file

   549     iLog->Log( KTestToolbarToolbarObserver );

   550 

   551     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   552     CleanupStack::PushL( toolbar );

   553     CTestToolbarControl* control = new ( ELeave ) CTestToolbarControl;

   554     CleanupStack::PushL( control );

   555 

   556     toolbar->SetToolbarObserver( control );

   557     

   558     MAknToolbarObserver* observer = toolbar->ToolbarObserver();

   559     STIF_ASSERT_NOT_NULL( observer );

   560 

   561     CleanupStack::PopAndDestroy( control );

   562     CleanupStack::PopAndDestroy( toolbar );

   563     return KErrNone;

   564 

   565     }

   566 

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

   568 // CTestSDKToolbar::TestToolbarAddItemL

   569 // -----------------------------------------------------------------------------

   570 //

   571 TInt CTestSDKToolbar::TestToolbarAddItemL( CStifItemParser& aItem )

   572     {

   573 

   574     // Print to UI

   575     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   576     _LIT( KTestToolbarAddItemL, "in AddItemL" );

   577     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarAddItemL );

   578     // Print to log file

   579     iLog->Log( KTestToolbarAddItemL );

   580 

   581     TInt num = 0;

   582     TInt err = aItem.GetNextInt( num );

   583     if ( err != KErrNone )

   584         {

   585         return err;

   586         }

   587 

   588     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   589     CleanupStack::PushL( toolbar );

   590 

   591     CAknButton *button = CAknButton::NewLC( NULL, NULL, NULL,

   592                              NULL, KButtonText, KButtonHelpText, 

   593                              KAknButtonNoFrame, 0 );

   594 

   595     switch( num )

   596         {

   597         case 1:

   598             toolbar->AddItemL( 

   599                     button, EAknCtButton, ETestToolBarCbaCmdBtn, 1 );

   600             break;

   601 

   602         case 2:

   603             {

   604             TInt index = 0;

   605             toolbar->AddItemL( 

   606                     button, EAknCtButton, ETestToolBarCbaCmdBtn, 1, index );

   607             }

   608             break;

   609 

   610         default:

   611             CleanupStack::Pop( button );

   612             CleanupStack::PopAndDestroy( toolbar );

   613             return KErrNotSupported;

   614         }

   615 

   616     CleanupStack::Pop( button );

   617     CleanupStack::PopAndDestroy( toolbar );

   618     return KErrNone;

   619 

   620     }

   621 

   622 // -----------------------------------------------------------------------------

   623 // CTestSDKToolbar::TestToolbarRemoveItemL

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

   625 //

   626 TInt CTestSDKToolbar::TestToolbarRemoveItemL( CStifItemParser& /*aItem*/ )

   627     {

   628 

   629     // Print to UI

   630     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   631     _LIT( KTestToolbarRemoveItem, "in RemoveItem" );

   632     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarRemoveItem );

   633     // Print to log file

   634     iLog->Log( KTestToolbarRemoveItem );

   635 

   636     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   637     CleanupStack::PushL( toolbar );

   638 

   639     toolbar->RemoveItem( EtCmdToolbarTextEditor );

   640 

   641     CleanupStack::PopAndDestroy( toolbar );

   642     return KErrNone;

   643 

   644     }

   645 

   646 // -----------------------------------------------------------------------------

   647 // CTestSDKToolbar::TestToolbarIsSupportedItemTypeL

   648 // -----------------------------------------------------------------------------

   649 //

   650 TInt CTestSDKToolbar::TestToolbarIsSupportedItemTypeL( CStifItemParser& /*aItem*/ )

   651     {

   652 

   653     // Print to UI

   654     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   655     _LIT( KTestToolbarIsSupportedItemType, "in IsSupportedItemType" );

   656     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarIsSupportedItemType );

   657     // Print to log file

   658     iLog->Log( KTestToolbarIsSupportedItemType );

   659 

   660     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   661     CleanupStack::PushL( toolbar );

   662 

   663     TInt type = EAknCtButton;

   664     TBool isSupported = toolbar->IsSupportedItemType( type );

   665     STIF_ASSERT_TRUE( isSupported );

   666 

   667     CleanupStack::PopAndDestroy( toolbar );

   668     return KErrNone;

   669 

   670     }

   671 

   672 // -----------------------------------------------------------------------------

   673 // CTestSDKToolbar::TestToolbarSetInitialFocusedItemL

   674 // -----------------------------------------------------------------------------

   675 //

   676 TInt CTestSDKToolbar::TestToolbarSetInitialFocusedItemL( CStifItemParser& /*aItem*/ )

   677     {

   678 

   679     // Print to UI

   680     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   681     _LIT( KTestToolbarSetInitialFocusedItem, "in SetInitialFocusedItem" );

   682     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetInitialFocusedItem );

   683     // Print to log file

   684     iLog->Log( KTestToolbarSetInitialFocusedItem );

   685 

   686     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   687     CleanupStack::PushL( toolbar );

   688 

   689     toolbar->SetInitialFocusedItem( EtCmdToolbarTextEditor );

   690 

   691     CleanupStack::PopAndDestroy( toolbar );

   692     return KErrNone;

   693 

   694     }

   695 

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

   697 // CTestSDKToolbar::TestToolbarSetEmphasisL

   698 // -----------------------------------------------------------------------------

   699 //

   700 TInt CTestSDKToolbar::TestToolbarSetEmphasisL( CStifItemParser& /*aItem*/ )

   701     {

   702 

   703     // Print to UI

   704     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   705     _LIT( KTestToolbarSetEmphasis, "in SetEmphasis" );

   706     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetEmphasis );

   707     // Print to log file

   708     iLog->Log( KTestToolbarSetEmphasis );

   709 

   710     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   711     CleanupStack::PushL( toolbar );

   712 

   713     toolbar->SetEmphasis( ETrue );

   714 

   715     CleanupStack::PopAndDestroy( toolbar );

   716     return KErrNone;

   717 

   718     }

   719 

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

   721 // CTestSDKToolbar::TestToolbarIsShownL

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

   723 //

   724 TInt CTestSDKToolbar::TestToolbarIsShownL( CStifItemParser& /*aItem*/ )

   725     {

   726 

   727     // Print to UI

   728     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   729     _LIT( KTestToolbarIsShown, "in IsShown" );

   730     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarIsShown );

   731     // Print to log file

   732     iLog->Log( KTestToolbarIsShown );

   733 

   734     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   735     CleanupStack::PushL( toolbar );

   736 

   737     toolbar->SetToolbarVisibility( EFalse );

   738     TBool isShown = toolbar->IsShown();

   739     STIF_ASSERT_FALSE( isShown );

   740 

   741     CleanupStack::PopAndDestroy( toolbar );

   742     return KErrNone;

   743 

   744     }

   745 

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

   747 // CTestSDKToolbar::TestToolbarSetWithSlidingL

   748 // -----------------------------------------------------------------------------

   749 //

   750 TInt CTestSDKToolbar::TestToolbarSetWithSlidingL( CStifItemParser& /*aItem*/ )

   751     {

   752 

   753     // Print to UI

   754     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   755     _LIT( KTestToolbarSetWithSliding, "in SetWithSliding" );

   756     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetWithSliding );

   757     // Print to log file

   758     iLog->Log( KTestToolbarSetWithSliding );

   759 

   760     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   761     CleanupStack::PushL( toolbar );

   762 

   763     toolbar->SetWithSliding( ETrue );

   764 

   765     CleanupStack::PopAndDestroy( toolbar );

   766     return KErrNone;

   767 

   768     }

   769 

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

   771 // CTestSDKToolbar::TestToolbarSetCloseOnCommandL

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

   773 //

   774 TInt CTestSDKToolbar::TestToolbarSetCloseOnCommandL( CStifItemParser& /*aItem*/ )

   775     {

   776 

   777     // Print to UI

   778     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   779     _LIT( KTestToolbarSetCloseOnCommand, "in SetCloseOnCommand" );

   780     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetCloseOnCommand );

   781     // Print to log file

   782     iLog->Log( KTestToolbarSetCloseOnCommand );

   783 

   784     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   785     CleanupStack::PushL( toolbar );

   786 

   787     toolbar->SetCloseOnCommand( EtCmdToolbarTextEditor,ETrue );

   788 

   789     CleanupStack::PopAndDestroy( toolbar );

   790     return KErrNone;

   791 

   792     }

   793 

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

   795 // CTestSDKToolbar::TestToolbarSetCloseOnAllCommandsL

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

   797 //

   798 TInt CTestSDKToolbar::TestToolbarSetCloseOnAllCommandsL( CStifItemParser& /*aItem*/ )

   799     {

   800 

   801     // Print to UI

   802     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   803     _LIT( KTestToolbarSetCloseOnAllCommands, "in SetCloseOnAllCommands" );

   804     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetCloseOnAllCommands );

   805     // Print to log file

   806     iLog->Log( KTestToolbarSetCloseOnAllCommands );

   807 

   808     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   809     CleanupStack::PushL( toolbar );

   810 

   811     toolbar->SetCloseOnAllCommands( ETrue );

   812 

   813     CleanupStack::PopAndDestroy( toolbar );

   814     return KErrNone;

   815 

   816     }

   817 

   818 // -----------------------------------------------------------------------------

   819 // CTestSDKToolbar::TestToolbarSetOrientationL

   820 // -----------------------------------------------------------------------------

   821 //

   822 TInt CTestSDKToolbar::TestToolbarSetOrientationL( CStifItemParser& /*aItem*/ )

   823     {

   824 

   825     // Print to UI

   826     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   827     _LIT( KTestToolbarSetOrientation, "in SetOrientation" );

   828     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetOrientation );

   829     // Print to log file

   830     iLog->Log( KTestToolbarSetOrientation );

   831 

   832     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   833     CleanupStack::PushL( toolbar );

   834 

   835     TAknOrientation orientation = EAknOrientationVertical;

   836     toolbar->SetOrientation( orientation );

   837 

   838     CleanupStack::PopAndDestroy( toolbar );

   839     return KErrNone;

   840 

   841     }

   842 

   843 // -----------------------------------------------------------------------------

   844 // CTestSDKToolbar::TestToolbarUpdateBackgroundL

   845 // -----------------------------------------------------------------------------

   846 //

   847 TInt CTestSDKToolbar::TestToolbarUpdateBackgroundL( CStifItemParser& /*aItem*/ )

   848     {

   849 

   850     // Print to UI

   851     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   852     _LIT( KTestToolbarUpdateBackground, "in UpdateBackground" );

   853     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarUpdateBackground );

   854     // Print to log file

   855     iLog->Log( KTestToolbarUpdateBackground );

   856 

   857     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   858     CleanupStack::PushL( toolbar );

   859 

   860     toolbar->UpdateBackground();

   861 

   862     CleanupStack::PopAndDestroy( toolbar );

   863     return KErrNone;

   864 

   865     }

   866 

   867 // -----------------------------------------------------------------------------

   868 // CTestSDKToolbar::TestToolbarDisableToolbarL

   869 // -----------------------------------------------------------------------------

   870 //

   871 TInt CTestSDKToolbar::TestToolbarDisableToolbarL( CStifItemParser& /*aItem*/ )

   872     {

   873 

   874     // Print to UI

   875     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   876     _LIT( KTestToolbarDisableToolbarL, "in DisableToolbarL" );

   877     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarDisableToolbarL );

   878     // Print to log file

   879     iLog->Log( KTestToolbarDisableToolbarL );

   880 

   881     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   882     CleanupStack::PushL( toolbar );

   883 

   884     toolbar->DisableToolbarL( ETrue );

   885 

   886     CleanupStack::PopAndDestroy( toolbar );

   887     return KErrNone;

   888 

   889     }

   890 

   891 // -----------------------------------------------------------------------------

   892 // CTestSDKToolbar::TestToolbarIsToolbarDisabledL

   893 // -----------------------------------------------------------------------------

   894 //

   895 TInt CTestSDKToolbar::TestToolbarIsToolbarDisabledL( CStifItemParser& /*aItem*/ )

   896     {

   897 

   898     // Print to UI

   899     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   900     _LIT( KTestToolbarIsToolbarDisabled, "in IsToolbarDisabled" );

   901     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarIsToolbarDisabled );

   902     // Print to log file

   903     iLog->Log( KTestToolbarIsToolbarDisabled );

   904 

   905     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   906     CleanupStack::PushL( toolbar );

   907 

   908     toolbar->DisableToolbarL( ETrue );

   909     TBool disabled = toolbar->IsToolbarDisabled();

   910     STIF_ASSERT_TRUE( disabled );

   911 

   912     CleanupStack::PopAndDestroy( toolbar );

   913     return KErrNone;

   914 

   915     }

   916 

   917 // -----------------------------------------------------------------------------

   918 // CTestSDKToolbar::TestToolbarSetFocusedItemL

   919 // -----------------------------------------------------------------------------

   920 //

   921 TInt CTestSDKToolbar::TestToolbarSetFocusedItemL( CStifItemParser& /*aItem*/ )

   922     {

   923 

   924     // Print to UI

   925     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   926     _LIT( KTestToolbarSetFocusedItemL, "in SetFocusedItemL" );

   927     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetFocusedItemL );

   928     // Print to log file

   929     iLog->Log( KTestToolbarSetFocusedItemL );

   930 

   931     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   932     CleanupStack::PushL( toolbar );

   933 

   934     CAknButton *button = CAknButton::NewLC( NULL, NULL, NULL,

   935                              NULL, KButtonText, KButtonHelpText, 

   936                              KAknButtonNoFrame, 0 );

   937     toolbar->AddItemL( 

   938             button, EAknCtButton, ETestToolBarCbaCmdBtn, 1 );

   939     CleanupStack::Pop( button );

   940     

   941     toolbar->SetFocusing( ETrue );

   942     toolbar->SetFocusedItemL( ETestToolBarCbaCmdBtn );

   943 

   944     CleanupStack::PopAndDestroy( toolbar );

   945     return KErrNone;

   946 

   947     }

   948 

   949 // -----------------------------------------------------------------------------

   950 // CTestSDKToolbar::TestToolbarFocusedItemL

   951 // -----------------------------------------------------------------------------

   952 //

   953 TInt CTestSDKToolbar::TestToolbarFocusedItemL( CStifItemParser& /*aItem*/ )

   954     {

   955 

   956     // Print to UI

   957     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   958     _LIT( KTestToolbarFocusedItem, "in FocusedItem" );

   959     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarFocusedItem );

   960     // Print to log file

   961     iLog->Log( KTestToolbarFocusedItem );

   962 

   963     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

   964     CleanupStack::PushL( toolbar );

   965 

   966     CAknButton *button = CAknButton::NewLC( NULL, NULL, NULL,

   967                              NULL, KButtonText, KButtonHelpText, 

   968                              KAknButtonNoFrame, 0 );

   969     toolbar->AddItemL( 

   970             button, EAknCtButton, ETestToolBarCbaCmdBtn, 1 );

   971     CleanupStack::Pop( button );

   972 

   973     toolbar->SetFocusing( ETrue );

   974     TInt commandId = ETestToolBarCbaCmdBtn;

   975     toolbar->SetFocusedItemL( commandId );

   976     

   977     TInt focusedItem = toolbar->FocusedItem();

   978     STIF_ASSERT_EQUALS( commandId, focusedItem );

   979 

   980     CleanupStack::PopAndDestroy( toolbar );

   981     return KErrNone;

   982 

   983     }

   984 

   985 // -----------------------------------------------------------------------------

   986 // CTestSDKToolbar::TestToolbarEventModifiersL

   987 // -----------------------------------------------------------------------------

   988 //

   989 TInt CTestSDKToolbar::TestToolbarEventModifiersL( CStifItemParser& /*aItem*/ )

   990     {

   991 

   992     // Print to UI

   993     _LIT( KTestSDKToolbar, "testsdktoolbar" );

   994     _LIT( KTestToolbarEventModifiers, "in EventModifiers" );

   995     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarEventModifiers );

   996     // Print to log file

   997     iLog->Log( KTestToolbarEventModifiers );

   998 

   999     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

  1000     CleanupStack::PushL( toolbar );

  1001 

  1002     CTestToolbarControl* control = CTestToolbarControl::NewL();

  1003     CleanupStack::PushL( control );

  1004     MCoeControlObserver::TCoeEvent eventType = MCoeControlObserver::EEventStateChanged;

  1005     toolbar->HandleControlEventL( control, eventType );

  1006     CleanupStack::PopAndDestroy( control );

  1007 

  1008     TInt modifiers = toolbar->EventModifiers(); 

  1009     STIF_ASSERT_TRUE( modifiers == 0 );

  1010 

  1011     CleanupStack::PopAndDestroy( toolbar );

  1012     return KErrNone;

  1013 

  1014     }

  1015 

  1016 // -----------------------------------------------------------------------------

  1017 // CTestSDKToolbar::TestToolbarToolbarFlagsL

  1018 // -----------------------------------------------------------------------------

  1019 //

  1020 TInt CTestSDKToolbar::TestToolbarToolbarFlagsL( CStifItemParser& /*aItem*/ )

  1021     {

  1022 

  1023     // Print to UI

  1024     _LIT( KTestSDKToolbar, "testsdktoolbar" );

  1025     _LIT( KTestToolbarToolbarFlags, "in ToolbarFlags" );

  1026     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarToolbarFlags );

  1027     // Print to log file

  1028     iLog->Log( KTestToolbarToolbarFlags );

  1029 

  1030     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

  1031     CleanupStack::PushL( toolbar );

  1032 

  1033     TInt flags = toolbar->ToolbarFlags();

  1034     STIF_ASSERT_TRUE( flags >= 0 );

  1035 

  1036     CleanupStack::PopAndDestroy( toolbar );

  1037     return KErrNone;

  1038 

  1039     }

  1040 

  1041 // -----------------------------------------------------------------------------

  1042 // CTestSDKToolbar::TestToolbarSetSoftkeyResourceIdL

  1043 // -----------------------------------------------------------------------------

  1044 //

  1045 TInt CTestSDKToolbar::TestToolbarSetSoftkeyResourceIdL( CStifItemParser& /*aItem*/ )

  1046     {

  1047 

  1048     // Print to UI

  1049     _LIT( KTestSDKToolbar, "testsdktoolbar" );

  1050     _LIT( KTestToolbarSetSoftkeyResourceIdL, "in SetSoftkeyResourceIdL" );

  1051     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarSetSoftkeyResourceIdL );

  1052     // Print to log file

  1053     iLog->Log( KTestToolbarSetSoftkeyResourceIdL );

  1054 

  1055     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

  1056     CleanupStack::PushL( toolbar );

  1057 

  1058     toolbar->SetSoftkeyResourceIdL( R_AVKON_SOFTKEYS_CLOSE );

  1059 

  1060     CleanupStack::PopAndDestroy( toolbar );

  1061     return KErrNone;

  1062 

  1063     }

  1064 

  1065 // -----------------------------------------------------------------------------

  1066 // CTestSDKToolbar::TestToolbarToolbarExtensionL

  1067 // -----------------------------------------------------------------------------

  1068 //

  1069 TInt CTestSDKToolbar::TestToolbarToolbarExtensionL( CStifItemParser& /*aItem*/ )

  1070     {

  1071 

  1072     // Print to UI

  1073     _LIT( KTestSDKToolbar, "testsdktoolbar" );

  1074     _LIT( KTestToolbarToolbarExtension, "in ToolbarExtension" );

  1075     TestModuleIf().Printf( 0, KTestSDKToolbar, KTestToolbarToolbarExtension );

  1076     // Print to log file

  1077     iLog->Log( KTestToolbarToolbarExtension );

  1078 

  1079     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

  1080     CleanupStack::PushL( toolbar );

  1081 

  1082     CAknToolbarExtension* toolbarExt = toolbar->ToolbarExtension();

  1083     STIF_ASSERT_NULL( toolbarExt );

  1084 

  1085     CleanupStack::PopAndDestroy( toolbar );

  1086     return KErrNone;

  1087 

  1088     }

  1089 

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

  1091 // CTestSDKToolbar::TestToolbarHideItemsAndDrawOnlyBackgroundL

  1092 // -----------------------------------------------------------------------------

  1093 //

  1094 TInt CTestSDKToolbar::TestToolbarHideItemsAndDrawOnlyBackgroundL( CStifItemParser& aItem )

  1095     {

  1096 

  1097     // Print to UI

  1098     _LIT( KTestSDKToolbar, "testsdktoolbar" );

  1099     _LIT( KTestToolbarHideItemsAndDrawOnlyBackground, "in HideItemsAndDrawOnlyBackground" );

  1100     TestModuleIf().Printf( 0, KTestSDKToolbar,

  1101             KTestToolbarHideItemsAndDrawOnlyBackground );

  1102     // Print to log file

  1103     iLog->Log( KTestToolbarHideItemsAndDrawOnlyBackground );

  1104 

  1105     TInt num = 0;

  1106     TInt err = aItem.GetNextInt( num );

  1107     if ( err != KErrNone )

  1108         {

  1109         return err;

  1110         }

  1111 

  1112     CAknToolbar* toolbar = CAknToolbar::NewL( R_TOOLBAR );

  1113     CleanupStack::PushL( toolbar );

  1114 

  1115     CAknButton *button = CAknButton::NewLC( NULL, NULL, NULL,

  1116                              NULL, KButtonText, KButtonHelpText, 

  1117                              KAknButtonNoFrame, 0 );

  1118     toolbar->AddItemL( 

  1119             button, EAknCtButton, ETestToolBarCbaCmdBtn, 1 );

  1120     CleanupStack::Pop( button );

  1121 

  1122     

  1123     

  1124     switch( num )

  1125         {

  1126         case 1:

  1127             toolbar->HideItemsAndDrawOnlyBackground( ETrue );

  1128             break;

  1129 

  1130         case 2:

  1131             toolbar->HideItemsAndDrawOnlyBackground( ETrue, ECoeWinPriorityHigh );

  1132             break;

  1133 

  1134         default:

  1135             CleanupStack::PopAndDestroy( toolbar );