classicui_pub/scroller_api/tsrc/src/testsdkscrollerblockseiksbfrm.cpp
changeset 0 2f259fa3e83a
equal deleted inserted replaced
-1:000000000000 0:2f259fa3e83a
       
     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 eiksbfrm.h
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 // [INCLUDE FILES]
       
    20 #include <eiksbfrm.h>
       
    21 #include <coemain.h>
       
    22 #include <coeaui.h>
       
    23 
       
    24 #include "testsdkscroller.h"
       
    25 #include "testsdkscrollercontrol.h"
       
    26 
       
    27 // CONSTANTS
       
    28 const TInt KWidth = 100;
       
    29 const TInt KHeight = 100;
       
    30 
       
    31 // ============================ MEMBER FUNCTIONS ===============================
       
    32 
       
    33 // -----------------------------------------------------------------------------
       
    34 // CTestSDKScroller::TestSDKSbFrmLaDefConsL
       
    35 // -----------------------------------------------------------------------------
       
    36 //
       
    37 TInt CTestSDKScroller::TestSDKSbFrmLaDefConsL( CStifItemParser& /*aItem*/ )
       
    38     {
       
    39 
       
    40     // Print to UI
       
    41     _LIT( KTestSDKScroller, "testsdkscroller" );
       
    42     _LIT( KTestSDKSbFrmLaDefCons, "in SbFrmLaNewL" );
       
    43     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmLaDefCons );
       
    44     // Print to log file
       
    45     iLog->Log( KTestSDKSbFrmLaDefCons );
       
    46 
       
    47     TEikScrollBarFrameLayout* sbFrameLa = new ( ELeave ) TEikScrollBarFrameLayout;
       
    48     CleanupStack::PushL( sbFrameLa );
       
    49     STIF_ASSERT_NOT_NULL( sbFrameLa );
       
    50 
       
    51     CleanupStack::PopAndDestroy( sbFrameLa );
       
    52      return KErrNone;
       
    53 
       
    54     }
       
    55 
       
    56 // -----------------------------------------------------------------------------
       
    57 // CTestSDKScroller::TestSDKSbFrmLaSetInclusiveMarginL
       
    58 // -----------------------------------------------------------------------------
       
    59 //
       
    60 TInt CTestSDKScroller::TestSDKSbFrmLaSetInclusiveMarginL( CStifItemParser& /*aItem*/ )
       
    61     {
       
    62 
       
    63     // Print to UI
       
    64     _LIT( KTestSDKScroller, "testsdkscroller" );
       
    65     _LIT( KTestSDKSbFrmLaSetInclusiveMargin, "in SbFrmLaSetInclusiveMargin" );
       
    66     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmLaSetInclusiveMargin );
       
    67     // Print to log file
       
    68     iLog->Log( KTestSDKSbFrmLaSetInclusiveMargin );
       
    69 
       
    70     TEikScrollBarFrameLayout* sbFrameLa = new ( ELeave ) TEikScrollBarFrameLayout;
       
    71     CleanupStack::PushL( sbFrameLa );
       
    72 
       
    73     TInt margin = 0;
       
    74     sbFrameLa->SetInclusiveMargin( margin );
       
    75 
       
    76     CleanupStack::PopAndDestroy( sbFrameLa );
       
    77      return KErrNone;
       
    78 
       
    79     }
       
    80 
       
    81 // -----------------------------------------------------------------------------
       
    82 // CTestSDKScroller::TestSDKSbFrmLaSetClientMarginL
       
    83 // -----------------------------------------------------------------------------
       
    84 //
       
    85 TInt CTestSDKScroller::TestSDKSbFrmLaSetClientMarginL( CStifItemParser& /*aItem*/ )
       
    86     {
       
    87 
       
    88     // Print to UI
       
    89     _LIT( KTestSDKScroller, "testsdkscroller" );
       
    90     _LIT( KTestSDKSbFrmLaSetInclusiveMargin, "in SbFrmLaSetInclusiveMargin" );
       
    91     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmLaSetInclusiveMargin );
       
    92     // Print to log file
       
    93     iLog->Log( KTestSDKSbFrmLaSetInclusiveMargin );
       
    94 
       
    95     TEikScrollBarFrameLayout* sbFrameLa = new ( ELeave ) TEikScrollBarFrameLayout;
       
    96     CleanupStack::PushL( sbFrameLa );
       
    97 
       
    98     TInt margin = 0;
       
    99     sbFrameLa->SetClientMargin( margin );
       
   100 
       
   101     CleanupStack::PopAndDestroy( sbFrameLa );
       
   102     return KErrNone;
       
   103 
       
   104     }
       
   105 
       
   106 // -----------------------------------------------------------------------------
       
   107 // CTestSDKScroller::TestSDKSbFrmDefConsWithPaL
       
   108 // -----------------------------------------------------------------------------
       
   109 //
       
   110 TInt CTestSDKScroller::TestSDKSbFrmDefConsWithPaL( CStifItemParser& /*aItem*/ )
       
   111     {
       
   112 
       
   113     // Print to UI
       
   114     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   115     _LIT( KTestSDKSbFrmDefConsWithPa, "in SbFrmDefConsWithPa" );
       
   116     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmDefConsWithPa );
       
   117     // Print to log file
       
   118     iLog->Log( KTestSDKSbFrmDefConsWithPa );
       
   119 
       
   120     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   121     CleanupStack::PushL( control );
       
   122 
       
   123     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   124     CleanupStack::PushL( sbFrame );
       
   125     STIF_ASSERT_NOT_NULL( sbFrame );
       
   126 
       
   127     CleanupStack::PopAndDestroy( sbFrame );
       
   128     CleanupStack::PopAndDestroy( control );
       
   129     return KErrNone;
       
   130 
       
   131     }
       
   132 
       
   133 // -----------------------------------------------------------------------------
       
   134 // CTestSDKScroller::TestSDKSbFrmDrawSbsNowL
       
   135 // -----------------------------------------------------------------------------
       
   136 //
       
   137 TInt CTestSDKScroller::TestSDKSbFrmDrawSbsNowL( CStifItemParser& /*aItem*/ )
       
   138     {
       
   139 
       
   140     // Print to UI
       
   141     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   142     _LIT( KTestSDKSbFrmDrawSbsNow, "in SbFrmDrawSbsNow" );
       
   143     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmDrawSbsNow );
       
   144     // Print to log file
       
   145     iLog->Log( KTestSDKSbFrmDrawSbsNow );
       
   146 
       
   147     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   148     CleanupStack::PushL( control );
       
   149     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   150     CleanupStack::PushL( sbFrame );
       
   151     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   152 
       
   153     sbFrame->DrawScrollBarsNow();
       
   154 
       
   155     CleanupStack::PopAndDestroy( sbFrame );
       
   156     CleanupStack::PopAndDestroy( control );
       
   157     return KErrNone;
       
   158 
       
   159     }
       
   160 
       
   161 // -----------------------------------------------------------------------------
       
   162 // CTestSDKScroller::TestSDKSbFrmSetSbVisibilityL
       
   163 // -----------------------------------------------------------------------------
       
   164 //
       
   165 TInt CTestSDKScroller::TestSDKSbFrmSetSbVisibilityL( CStifItemParser& /*aItem*/ )
       
   166     {
       
   167 
       
   168     // Print to UI
       
   169     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   170     _LIT( KTestSDKSbFrmSetSbVisibilityL, "in SbFrmSbVisibilityL" );
       
   171     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetSbVisibilityL );
       
   172     // Print to log file
       
   173     iLog->Log( KTestSDKSbFrmSetSbVisibilityL );
       
   174 
       
   175     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   176     CleanupStack::PushL( control );
       
   177     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   178     CleanupStack::PushL( sbFrame );
       
   179     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   180 
       
   181     CEikScrollBarFrame::TScrollBarVisibility hVisibility =
       
   182             CEikScrollBarFrame::EOff;
       
   183     CEikScrollBarFrame::TScrollBarVisibility vVisibility =
       
   184             CEikScrollBarFrame::EOff;
       
   185     sbFrame->SetScrollBarVisibilityL( hVisibility, vVisibility );
       
   186 
       
   187     CleanupStack::PopAndDestroy( sbFrame );
       
   188     CleanupStack::PopAndDestroy( control );
       
   189     return KErrNone;
       
   190 
       
   191     }
       
   192 
       
   193 // -----------------------------------------------------------------------------
       
   194 // CTestSDKScroller::TestSDKSbFrmVSbVisibilityL
       
   195 // -----------------------------------------------------------------------------
       
   196 //
       
   197 TInt CTestSDKScroller::TestSDKSbFrmVSbVisibilityL( CStifItemParser& /*aItem*/ )
       
   198     {
       
   199 
       
   200     // Print to UI
       
   201     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   202     _LIT( KTestSDKSbFrmVSbVisibilityL, "in SbFrmVSbVisibilityL" );
       
   203     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmVSbVisibilityL );
       
   204     // Print to log file
       
   205     iLog->Log( KTestSDKSbFrmVSbVisibilityL );
       
   206 
       
   207     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame;
       
   208     CleanupStack::PushL( sbFrame );
       
   209     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   210 
       
   211     CEikScrollBarFrame::TScrollBarVisibility hVisibility =
       
   212             CEikScrollBarFrame::EOn;
       
   213     CEikScrollBarFrame::TScrollBarVisibility vVisibility =
       
   214             CEikScrollBarFrame::EOn;
       
   215     sbFrame->SetScrollBarVisibilityL( hVisibility, vVisibility );
       
   216 
       
   217     CEikScrollBarFrame::TScrollBarVisibility vSbVisibility =
       
   218         sbFrame->VScrollBarVisibility();
       
   219     STIF_ASSERT_EQUALS( vVisibility, vSbVisibility );
       
   220 
       
   221     CleanupStack::PopAndDestroy( sbFrame );
       
   222     return KErrNone;
       
   223 
       
   224     }
       
   225 
       
   226 // -----------------------------------------------------------------------------
       
   227 // CTestSDKScroller::TestSDKSbFrmSetSbfrmObserverL
       
   228 // -----------------------------------------------------------------------------
       
   229 //
       
   230 TInt CTestSDKScroller::TestSDKSbFrmSetSbfrmObserverL( CStifItemParser& /*aItem*/ )
       
   231     {
       
   232 
       
   233     // Print to UI
       
   234     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   235     _LIT( KTestSDKSbFrmSetSbfrmObserverL, "in SbFrmDefConsWithPa" );
       
   236     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetSbfrmObserverL );
       
   237     // Print to log file
       
   238     iLog->Log( KTestSDKSbFrmSetSbfrmObserverL );
       
   239 
       
   240     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   241     CleanupStack::PushL( control );
       
   242     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   243     CleanupStack::PushL( sbFrame );
       
   244 
       
   245     sbFrame->SetScrollBarFrameObserver( control );
       
   246 
       
   247     CleanupStack::PopAndDestroy( sbFrame );
       
   248     CleanupStack::PopAndDestroy( control );
       
   249     return KErrNone;
       
   250 
       
   251     }
       
   252 
       
   253 // -----------------------------------------------------------------------------
       
   254 // CTestSDKScroller::TestSDKSbFrmTileL
       
   255 // -----------------------------------------------------------------------------
       
   256 //
       
   257 TInt CTestSDKScroller::TestSDKSbFrmTileL( CStifItemParser& /*aItem*/ )
       
   258     {
       
   259 
       
   260     // Print to UI
       
   261     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   262     _LIT( KTestSDKSbFrmTile, "in SbFrmTile" );
       
   263     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTile );
       
   264     // Print to log file
       
   265     iLog->Log( KTestSDKSbFrmTile );
       
   266 
       
   267     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   268     CleanupStack::PushL( control );
       
   269     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   270     CleanupStack::PushL( sbFrame );
       
   271     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   272 
       
   273     TEikScrollBarModel* vModel = new ( ELeave ) TEikScrollBarModel;
       
   274     CleanupStack::PushL( vModel );
       
   275     TBool model = sbFrame->Tile( vModel );
       
   276     STIF_ASSERT_FALSE( model );
       
   277 
       
   278     CleanupStack::PopAndDestroy( vModel );
       
   279     CleanupStack::PopAndDestroy( sbFrame );
       
   280     CleanupStack::PopAndDestroy( control );
       
   281     return KErrNone;
       
   282 
       
   283     }
       
   284 
       
   285 // -----------------------------------------------------------------------------
       
   286 // CTestSDKScroller::TestSDKSbFrmTileWithSbfrmLaL
       
   287 // -----------------------------------------------------------------------------
       
   288 //
       
   289 TInt CTestSDKScroller::TestSDKSbFrmTileWithSbfrmLaL( CStifItemParser& /*aItem*/ )
       
   290     {
       
   291 
       
   292     // Print to UI
       
   293     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   294     _LIT( KTestSDKSbFrmTileWithSbfrmLa, "in SbFrmTileWithSbfrmLa" );
       
   295     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTileWithSbfrmLa );
       
   296     // Print to log file
       
   297     iLog->Log( KTestSDKSbFrmTileWithSbfrmLa );
       
   298 
       
   299     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   300     CleanupStack::PushL( control );
       
   301     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   302     CleanupStack::PushL( sbFrame );
       
   303     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   304 
       
   305     TEikScrollBarModel* vModel = new ( ELeave ) TEikScrollBarModel;
       
   306     CleanupStack::PushL( vModel );
       
   307     TEikScrollBarModel* hModel = new ( ELeave ) TEikScrollBarModel;
       
   308     CleanupStack::PushL( hModel );
       
   309     TEikScrollBarFrameLayout* sbFrameLa = new ( ELeave ) TEikScrollBarFrameLayout;
       
   310     CleanupStack::PushL( sbFrameLa );
       
   311     TSize size( KWidth, KHeight );
       
   312     TRect clientRect( size );
       
   313     TRect inclusiveRect( size );
       
   314     
       
   315     TBool model = sbFrame->TileL( hModel, vModel, clientRect,
       
   316             inclusiveRect, *sbFrameLa );
       
   317     STIF_ASSERT_FALSE( model );
       
   318 
       
   319     CleanupStack::PopAndDestroy( sbFrameLa );
       
   320     CleanupStack::PopAndDestroy( hModel );
       
   321     CleanupStack::PopAndDestroy( vModel );
       
   322     CleanupStack::PopAndDestroy( sbFrame );
       
   323     CleanupStack::PopAndDestroy( control );
       
   324     return KErrNone;
       
   325 
       
   326     }
       
   327 
       
   328 // -----------------------------------------------------------------------------
       
   329 // CTestSDKScroller::TestSDKSbFrmMoveThumbsByL
       
   330 // -----------------------------------------------------------------------------
       
   331 //
       
   332 TInt CTestSDKScroller::TestSDKSbFrmMoveThumbsByL( CStifItemParser& /*aItem*/ )
       
   333     {
       
   334 
       
   335     // Print to UI
       
   336     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   337     _LIT( KTestSDKSbFrmMoveThumbsBy, "in SbFrmMoveThumbsBy" );
       
   338     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmMoveThumbsBy );
       
   339     // Print to log file
       
   340     iLog->Log( KTestSDKSbFrmMoveThumbsBy );
       
   341 
       
   342     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   343     CleanupStack::PushL( control );
       
   344     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   345     CleanupStack::PushL( sbFrame );
       
   346     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   347 
       
   348     TInt deltaX = 1;
       
   349     TInt deltaY = 1;
       
   350     sbFrame->MoveThumbsBy( deltaX, deltaY );
       
   351 
       
   352     CleanupStack::PopAndDestroy( sbFrame );
       
   353     CleanupStack::PopAndDestroy( control );
       
   354     return KErrNone;
       
   355 
       
   356     }
       
   357 
       
   358 // -----------------------------------------------------------------------------
       
   359 // CTestSDKScroller::TestSDKSbFrmMoveHThumbToL
       
   360 // -----------------------------------------------------------------------------
       
   361 //
       
   362 TInt CTestSDKScroller::TestSDKSbFrmMoveHThumbToL( CStifItemParser& /*aItem*/ )
       
   363     {
       
   364 
       
   365     // Print to UI
       
   366     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   367     _LIT( KTestSDKSbFrmMoveHThumbTo, "in SbFrmMoveHThumbTo" );
       
   368     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmMoveHThumbTo );
       
   369     // Print to log file
       
   370     iLog->Log( KTestSDKSbFrmMoveHThumbTo );
       
   371 
       
   372     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   373     CleanupStack::PushL( control );
       
   374     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   375     CleanupStack::PushL( sbFrame );
       
   376     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   377 
       
   378     TInt hThumbPos = 0;
       
   379     sbFrame->MoveHorizThumbTo( hThumbPos );
       
   380 
       
   381     CleanupStack::PopAndDestroy( sbFrame );
       
   382     CleanupStack::PopAndDestroy( control );
       
   383     return KErrNone;
       
   384 
       
   385     }
       
   386 
       
   387 // -----------------------------------------------------------------------------
       
   388 // CTestSDKScroller::TestSDKSbFrmMoveVThumbToL
       
   389 // -----------------------------------------------------------------------------
       
   390 //
       
   391 TInt CTestSDKScroller::TestSDKSbFrmMoveVThumbToL( CStifItemParser& /*aItem*/ )
       
   392     {
       
   393 
       
   394     // Print to UI
       
   395     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   396     _LIT( KTestSDKSbFrmMoveVThumbTo, "in SbFrmMoveVThumbTo" );
       
   397     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmMoveVThumbTo );
       
   398     // Print to log file
       
   399     iLog->Log( KTestSDKSbFrmMoveVThumbTo );
       
   400 
       
   401     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   402     CleanupStack::PushL( control );
       
   403     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   404     CleanupStack::PushL( sbFrame );
       
   405     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   406 
       
   407     TInt vThumbPos = 0;
       
   408     sbFrame->MoveVertThumbTo( vThumbPos );
       
   409 
       
   410     CleanupStack::PopAndDestroy( sbFrame );
       
   411     CleanupStack::PopAndDestroy( control );
       
   412     return KErrNone;
       
   413 
       
   414     }
       
   415 
       
   416 // -----------------------------------------------------------------------------
       
   417 // CTestSDKScroller::TestSDKSbFrmSetVFocusPosToThumbPosL
       
   418 // -----------------------------------------------------------------------------
       
   419 //
       
   420 TInt CTestSDKScroller::TestSDKSbFrmSetVFocusPosToThumbPosL( CStifItemParser& /*aItem*/ )
       
   421     {
       
   422 
       
   423     // Print to UI
       
   424     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   425     _LIT( KTestSDKSbFrmSetVFocusPosToThumbPos, "in SbFrmSetVFocusPosToThumbPos" );
       
   426     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetVFocusPosToThumbPos );
       
   427     // Print to log file
       
   428     iLog->Log( KTestSDKSbFrmSetVFocusPosToThumbPos );
       
   429 
       
   430     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   431     CleanupStack::PushL( control );
       
   432     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   433     CleanupStack::PushL( sbFrame );
       
   434     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   435 
       
   436     TInt focusPos = 0;
       
   437     sbFrame->SetVFocusPosToThumbPos( focusPos );
       
   438 
       
   439     CleanupStack::PopAndDestroy( sbFrame );
       
   440     CleanupStack::PopAndDestroy( control );
       
   441     return KErrNone;
       
   442 
       
   443     }
       
   444 
       
   445 // -----------------------------------------------------------------------------
       
   446 // CTestSDKScroller::TestSDKSbFrmSbBreadthL
       
   447 // -----------------------------------------------------------------------------
       
   448 //
       
   449 TInt CTestSDKScroller::TestSDKSbFrmSbBreadthL( CStifItemParser& /*aItem*/ )
       
   450     {
       
   451 
       
   452     // Print to UI
       
   453     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   454     _LIT( KTestSDKSbFrmSbBreadth, "in SbFrmSbBreadth" );
       
   455     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSbBreadth );
       
   456     // Print to log file
       
   457     iLog->Log( KTestSDKSbFrmSbBreadth );
       
   458 
       
   459     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   460     CleanupStack::PushL( control );
       
   461     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   462     CleanupStack::PushL( sbFrame );
       
   463     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   464 
       
   465     CEikScrollBar::TOrientation orientation = CEikScrollBar::EHorizontal;
       
   466     TInt hOrientation = sbFrame->ScrollBarBreadth( orientation );
       
   467     STIF_ASSERT_EQUALS( 0, hOrientation );
       
   468 
       
   469     CleanupStack::PopAndDestroy( sbFrame );
       
   470     CleanupStack::PopAndDestroy( control );
       
   471     return KErrNone;
       
   472 
       
   473     }
       
   474 
       
   475 // -----------------------------------------------------------------------------
       
   476 // CTestSDKScroller::TestSDKSbFrmSetAdjustsHModelL
       
   477 // -----------------------------------------------------------------------------
       
   478 //
       
   479 TInt CTestSDKScroller::TestSDKSbFrmSetAdjustsHModelL( CStifItemParser& /*aItem*/ )
       
   480     {
       
   481 
       
   482     // Print to UI
       
   483     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   484     _LIT( KTestSDKSbFrmSetAdjustsHModel, "in SbFrmSetAdjustsHModel" );
       
   485     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetAdjustsHModel );
       
   486     // Print to log file
       
   487     iLog->Log( KTestSDKSbFrmSetAdjustsHModel );
       
   488 
       
   489     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   490     CleanupStack::PushL( control );
       
   491     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   492     CleanupStack::PushL( sbFrame );
       
   493     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   494 
       
   495     sbFrame->SetAdjustsHorizontalModel( ETrue );
       
   496 
       
   497     CleanupStack::PopAndDestroy( sbFrame );
       
   498     CleanupStack::PopAndDestroy( control );
       
   499     return KErrNone;
       
   500 
       
   501     }
       
   502 
       
   503 // -----------------------------------------------------------------------------
       
   504 // CTestSDKScroller::TestSDKSbFrmSetAdjustsVModelL
       
   505 // -----------------------------------------------------------------------------
       
   506 //
       
   507 TInt CTestSDKScroller::TestSDKSbFrmSetAdjustsVModelL( CStifItemParser& /*aItem*/ )
       
   508     {
       
   509 
       
   510     // Print to UI
       
   511     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   512     _LIT( KTestSDKSbFrmSetAdjustsVModel, "in SbFrmSetAdjustsVModel" );
       
   513     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetAdjustsVModel );
       
   514     // Print to log file
       
   515     iLog->Log( KTestSDKSbFrmSetAdjustsVModel );
       
   516 
       
   517     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   518     CleanupStack::PushL( control );
       
   519     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   520     CleanupStack::PushL( sbFrame );
       
   521     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   522 
       
   523     sbFrame->SetAdjustsVerticalModel( ETrue );
       
   524 
       
   525     CleanupStack::PopAndDestroy( sbFrame );
       
   526     CleanupStack::PopAndDestroy( control );
       
   527     return KErrNone;
       
   528 
       
   529     }
       
   530 
       
   531 // -----------------------------------------------------------------------------
       
   532 // CTestSDKScroller::TestSDKSbFrmSetSbfrmFlagsL
       
   533 // -----------------------------------------------------------------------------
       
   534 //
       
   535 TInt CTestSDKScroller::TestSDKSbFrmSetSbfrmFlagsL( CStifItemParser& /*aItem*/ )
       
   536     {
       
   537 
       
   538     // Print to UI
       
   539     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   540     _LIT( KTestSDKSbFrmSetSbfrmFlags, "in SbFrmSetSbfrmFlags" );
       
   541     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetSbfrmFlags );
       
   542     // Print to log file
       
   543     iLog->Log( KTestSDKSbFrmSetSbfrmFlags );
       
   544 
       
   545     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   546     CleanupStack::PushL( control );
       
   547     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   548     CleanupStack::PushL( sbFrame );
       
   549     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   550 
       
   551     TInt mask = 0;
       
   552     sbFrame->SetScrollBarFrameFlags( mask );
       
   553 
       
   554     CleanupStack::PopAndDestroy( sbFrame );
       
   555     CleanupStack::PopAndDestroy( control );
       
   556     return KErrNone;
       
   557 
       
   558     }
       
   559 
       
   560 // -----------------------------------------------------------------------------
       
   561 // CTestSDKScroller::TestSDKSbFrmSbExistsL
       
   562 // -----------------------------------------------------------------------------
       
   563 //
       
   564 TInt CTestSDKScroller::TestSDKSbFrmSbExistsL( CStifItemParser& /*aItem*/ )
       
   565     {
       
   566 
       
   567     // Print to UI
       
   568     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   569     _LIT( KTestSDKSbFrmSbExists, "in SbFrmSbExists" );
       
   570     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSbExists );
       
   571     // Print to log file
       
   572     iLog->Log( KTestSDKSbFrmSbExists );
       
   573 
       
   574     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   575     CleanupStack::PushL( control );
       
   576     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   577     CleanupStack::PushL( sbFrame );
       
   578     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   579 
       
   580     CEikScrollBar::TOrientation orientation = CEikScrollBar::EHorizontal;
       
   581     TBool exist = sbFrame->ScrollBarExists( orientation );
       
   582     STIF_ASSERT_FALSE( exist );
       
   583 
       
   584     CleanupStack::PopAndDestroy( sbFrame );
       
   585     CleanupStack::PopAndDestroy( control );
       
   586     return KErrNone;
       
   587 
       
   588     }
       
   589 
       
   590 // -----------------------------------------------------------------------------
       
   591 // CTestSDKScroller::TestSDKSbFrmCountComCtrlsL
       
   592 // -----------------------------------------------------------------------------
       
   593 //
       
   594 TInt CTestSDKScroller::TestSDKSbFrmCountComCtrlsL( CStifItemParser& /*aItem*/ )
       
   595     {
       
   596 
       
   597     // Print to UI
       
   598     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   599     _LIT( KTestSDKSbFrmCountComCtrls, "in SbFrmCountComCtrls" );
       
   600     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmCountComCtrls );
       
   601     // Print to log file
       
   602     iLog->Log( KTestSDKSbFrmCountComCtrls );
       
   603 
       
   604     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   605     CleanupStack::PushL( control );
       
   606     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   607     CleanupStack::PushL( sbFrame );
       
   608     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   609 
       
   610     TInt count = sbFrame->CountComponentControls();
       
   611     STIF_ASSERT_EQUALS( 2, count );
       
   612 
       
   613     CleanupStack::PopAndDestroy( sbFrame );
       
   614     CleanupStack::PopAndDestroy( control );
       
   615     return KErrNone;
       
   616 
       
   617     }
       
   618 
       
   619 // -----------------------------------------------------------------------------
       
   620 // CTestSDKScroller::TestSDKSbFrmComponentControlL
       
   621 // -----------------------------------------------------------------------------
       
   622 //
       
   623 TInt CTestSDKScroller::TestSDKSbFrmComponentControlL( CStifItemParser& /*aItem*/ )
       
   624     {
       
   625 
       
   626     // Print to UI
       
   627     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   628     _LIT( KTestSDKSbFrmComponentControl, "in SbFrmComponentControl" );
       
   629     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmComponentControl );
       
   630     // Print to log file
       
   631     iLog->Log( KTestSDKSbFrmComponentControl );
       
   632 
       
   633     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   634     CleanupStack::PushL( control );
       
   635     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   636     CleanupStack::PushL( sbFrame );
       
   637     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   638 
       
   639     TInt index = 0;
       
   640     CCoeControl* sbFrameControl = sbFrame->ComponentControl( index );
       
   641     STIF_ASSERT_NOT_NULL( sbFrameControl );
       
   642 
       
   643     CleanupStack::PopAndDestroy( sbFrame );
       
   644     CleanupStack::PopAndDestroy( control );
       
   645     return KErrNone;
       
   646 
       
   647     }
       
   648 
       
   649 // -----------------------------------------------------------------------------
       
   650 // CTestSDKScroller::TestSDKSbFrmGetSbHandleL
       
   651 // -----------------------------------------------------------------------------
       
   652 //
       
   653 TInt CTestSDKScroller::TestSDKSbFrmGetSbHandleL( CStifItemParser& /*aItem*/ )
       
   654     {
       
   655 
       
   656     // Print to UI
       
   657     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   658     _LIT( KTestSDKSbFrmGetSbHandle, "in SbFrmGetSbHandle" );
       
   659     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmGetSbHandle );
       
   660     // Print to log file
       
   661     iLog->Log( KTestSDKSbFrmGetSbHandle );
       
   662 
       
   663     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   664     CleanupStack::PushL( control );
       
   665     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   666     CleanupStack::PushL( sbFrame );
       
   667     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   668 
       
   669     CEikScrollBar::TOrientation orientation = CEikScrollBar::EHorizontal;
       
   670     CEikScrollBar* sbHandle = sbFrame->GetScrollBarHandle( orientation );
       
   671     STIF_ASSERT_NULL( sbHandle );
       
   672 
       
   673     CleanupStack::PopAndDestroy( sbFrame );
       
   674     CleanupStack::PopAndDestroy( control );
       
   675     return KErrNone;
       
   676 
       
   677     }
       
   678 
       
   679 // -----------------------------------------------------------------------------
       
   680 // CTestSDKScroller::TestSDKSbFrmVScrollBarL
       
   681 // -----------------------------------------------------------------------------
       
   682 //
       
   683 TInt CTestSDKScroller::TestSDKSbFrmVScrollBarL( CStifItemParser& /*aItem*/ )
       
   684     {
       
   685 
       
   686     // Print to UI
       
   687     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   688     _LIT( KTestSDKSbFrmVScrollBar, "in SbFrmVScrollBar" );
       
   689     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmVScrollBar );
       
   690     // Print to log file
       
   691     iLog->Log( KTestSDKSbFrmVScrollBar );
       
   692 
       
   693     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   694     CleanupStack::PushL( control );
       
   695     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   696     CleanupStack::PushL( sbFrame );
       
   697     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   698 
       
   699     CEikScrollBar* vScrollBar = sbFrame->VerticalScrollBar();
       
   700     STIF_ASSERT_NOT_NULL( vScrollBar );
       
   701 
       
   702     CleanupStack::PopAndDestroy( sbFrame );
       
   703     CleanupStack::PopAndDestroy( control );
       
   704     return KErrNone;
       
   705 
       
   706     }
       
   707 
       
   708 // -----------------------------------------------------------------------------
       
   709 // CTestSDKScroller::TestSDKSbFrmSetTypeOfHSbL
       
   710 // -----------------------------------------------------------------------------
       
   711 //
       
   712 TInt CTestSDKScroller::TestSDKSbFrmSetTypeOfHSbL( CStifItemParser& /*aItem*/ )
       
   713     {
       
   714 
       
   715     // Print to UI
       
   716     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   717     _LIT( KTestSDKSbFrmSetTypeOfHSb, "in SbFrmSetTypeOfHSb" );
       
   718     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetTypeOfHSb );
       
   719     // Print to log file
       
   720     iLog->Log( KTestSDKSbFrmSetTypeOfHSb );
       
   721 
       
   722     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   723     CleanupStack::PushL( control );
       
   724     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   725     CleanupStack::PushL( sbFrame );
       
   726     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   727 
       
   728     CEikScrollBarFrame::TScrollBarType sbType = CEikScrollBarFrame::EArrowHead;
       
   729     sbFrame->SetTypeOfHScrollBar( sbType );
       
   730 
       
   731     CleanupStack::PopAndDestroy( sbFrame );
       
   732     CleanupStack::PopAndDestroy( control );
       
   733     return KErrNone;
       
   734 
       
   735     }
       
   736 
       
   737 // -----------------------------------------------------------------------------
       
   738 // CTestSDKScroller::TestSDKSbFrmSetTypeOfVSbL
       
   739 // -----------------------------------------------------------------------------
       
   740 //
       
   741 TInt CTestSDKScroller::TestSDKSbFrmSetTypeOfVSbL( CStifItemParser& /*aItem*/ )
       
   742     {
       
   743 
       
   744     // Print to UI
       
   745     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   746     _LIT( KTestSDKSbFrmSetTypeOfVSb, "in SbFrmSetTypeOfVSb" );
       
   747     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetTypeOfVSb );
       
   748     // Print to log file
       
   749     iLog->Log( KTestSDKSbFrmSetTypeOfVSb );
       
   750 
       
   751     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   752     CleanupStack::PushL( control );
       
   753     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   754     CleanupStack::PushL( sbFrame );
       
   755     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   756 
       
   757     CEikScrollBarFrame::TScrollBarType sbType = CEikScrollBarFrame::EArrowHead;
       
   758     sbFrame->SetTypeOfVScrollBar( sbType );
       
   759 
       
   760     CleanupStack::PopAndDestroy( sbFrame );
       
   761     CleanupStack::PopAndDestroy( control );
       
   762     return KErrNone;
       
   763 
       
   764     }
       
   765 
       
   766 // -----------------------------------------------------------------------------
       
   767 // CTestSDKScroller::TestSDKSbFrmTypeOfHSbL
       
   768 // -----------------------------------------------------------------------------
       
   769 //
       
   770 TInt CTestSDKScroller::TestSDKSbFrmTypeOfHSbL( CStifItemParser& /*aItem*/ )
       
   771     {
       
   772 
       
   773     // Print to UI
       
   774     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   775     _LIT( KTestSDKSbFrmTypeOfHSb, "in SbFrmTypeOfHSb" );
       
   776     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTypeOfHSb );
       
   777     // Print to log file
       
   778     iLog->Log( KTestSDKSbFrmTypeOfHSb );
       
   779 
       
   780     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   781     CleanupStack::PushL( control );
       
   782     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   783     CleanupStack::PushL( sbFrame );
       
   784     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   785 
       
   786     CEikScrollBarFrame::TScrollBarType sbType = CEikScrollBarFrame::EDoubleSpan;
       
   787     CEikScrollBarFrame::TScrollBarType type = sbFrame->TypeOfHScrollBar();
       
   788     STIF_ASSERT_EQUALS( sbType, type );
       
   789 
       
   790     CleanupStack::PopAndDestroy( sbFrame );
       
   791     CleanupStack::PopAndDestroy( control );
       
   792     return KErrNone;
       
   793 
       
   794     }
       
   795 
       
   796 // -----------------------------------------------------------------------------
       
   797 // CTestSDKScroller::TestSDKSbFrmTypeOfVSbL
       
   798 // -----------------------------------------------------------------------------
       
   799 //
       
   800 TInt CTestSDKScroller::TestSDKSbFrmTypeOfVSbL( CStifItemParser& /*aItem*/ )
       
   801     {
       
   802 
       
   803     // Print to UI
       
   804     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   805     _LIT( KTestSDKSbFrmTypeOfVSb, "in SbFrmTypeOfVSb" );
       
   806     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTypeOfVSb );
       
   807     // Print to log file
       
   808     iLog->Log( KTestSDKSbFrmTypeOfVSb );
       
   809 
       
   810     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   811     CleanupStack::PushL( control );
       
   812     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   813     CleanupStack::PushL( sbFrame );
       
   814     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   815 
       
   816     CEikScrollBarFrame::TScrollBarType sbType = CEikScrollBarFrame::EDoubleSpan;
       
   817     CEikScrollBarFrame::TScrollBarType type = sbFrame->TypeOfVScrollBar();
       
   818     STIF_ASSERT_EQUALS( sbType, type );
       
   819 
       
   820     CleanupStack::PopAndDestroy( sbFrame );
       
   821     CleanupStack::PopAndDestroy( control );
       
   822     return KErrNone;
       
   823 
       
   824     }
       
   825 
       
   826 // -----------------------------------------------------------------------------
       
   827 // CTestSDKScroller::TestSDKSbFrmIsArrowHeadSbL
       
   828 // -----------------------------------------------------------------------------
       
   829 //
       
   830 TInt CTestSDKScroller::TestSDKSbFrmIsArrowHeadSbL( CStifItemParser& /*aItem*/ )
       
   831     {
       
   832 
       
   833     // Print to UI
       
   834     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   835     _LIT( KTestSDKSbFrmIsArrowHeadSb, "in SbFrmIsArrowHeadSb" );
       
   836     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmIsArrowHeadSb );
       
   837     // Print to log file
       
   838     iLog->Log( KTestSDKSbFrmIsArrowHeadSb );
       
   839 
       
   840     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   841     CleanupStack::PushL( control );
       
   842     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   843     CleanupStack::PushL( sbFrame );
       
   844 
       
   845     TInt flags = 0;
       
   846     TBool isArrowHead = sbFrame->IsArrowHeadScrollBar( flags );
       
   847     STIF_ASSERT_TRUE( isArrowHead );
       
   848 
       
   849     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   850     isArrowHead = sbFrame->IsArrowHeadScrollBar( flags );
       
   851     STIF_ASSERT_FALSE( isArrowHead );
       
   852 
       
   853     CleanupStack::PopAndDestroy( sbFrame );
       
   854     CleanupStack::PopAndDestroy( control );
       
   855     return KErrNone;
       
   856 
       
   857     }
       
   858 
       
   859 // -----------------------------------------------------------------------------
       
   860 // CTestSDKScroller::TestSDKSbFrmCreDoubleSpanSbsL
       
   861 // -----------------------------------------------------------------------------
       
   862 //
       
   863 TInt CTestSDKScroller::TestSDKSbFrmCreDoubleSpanSbsL( CStifItemParser& /*aItem*/ )
       
   864     {
       
   865 
       
   866     // Print to UI
       
   867     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   868     _LIT( KTestSDKSbFrmCreDoubleSpanSbsL, "in SbFrmIsArrowHeadSb" );
       
   869     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmCreDoubleSpanSbsL );
       
   870     // Print to log file
       
   871     iLog->Log( KTestSDKSbFrmCreDoubleSpanSbsL );
       
   872 
       
   873     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   874     CleanupStack::PushL( control );
       
   875     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   876     CleanupStack::PushL( sbFrame );
       
   877 
       
   878     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   879 
       
   880     CleanupStack::PopAndDestroy( sbFrame );
       
   881     CleanupStack::PopAndDestroy( control );
       
   882     return KErrNone;
       
   883 
       
   884     }
       
   885 
       
   886 // -----------------------------------------------------------------------------
       
   887 // CTestSDKScroller::TestSDKSbFrmCreDoubleSpanSbsWithSbPaL
       
   888 // -----------------------------------------------------------------------------
       
   889 //
       
   890 TInt CTestSDKScroller::TestSDKSbFrmCreDoubleSpanSbsWithSbPaL( CStifItemParser& /*aItem*/ )
       
   891     {
       
   892 
       
   893     // Print to UI
       
   894     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   895     _LIT( KTestSDKSbFrmCreDoubleSpanSbsWithSbPaL, "in SbFrmIsArrowHeadSb" );
       
   896     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmCreDoubleSpanSbsWithSbPaL );
       
   897     // Print to log file
       
   898     iLog->Log( KTestSDKSbFrmCreDoubleSpanSbsWithSbPaL );
       
   899 
       
   900     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   901     CleanupStack::PushL( control );
       
   902     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   903     CleanupStack::PushL( sbFrame );
       
   904 
       
   905     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse, ETrue, ETrue );
       
   906 
       
   907     CleanupStack::PopAndDestroy( sbFrame );
       
   908     CleanupStack::PopAndDestroy( control );
       
   909     return KErrNone;
       
   910 
       
   911     }
       
   912 
       
   913 // -----------------------------------------------------------------------------
       
   914 // CTestSDKScroller::TestSDKSbFrmTileWithRectL
       
   915 // -----------------------------------------------------------------------------
       
   916 //
       
   917 TInt CTestSDKScroller::TestSDKSbFrmTileWithRectL( CStifItemParser& /*aItem*/ )
       
   918     {
       
   919 
       
   920     // Print to UI
       
   921     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   922     _LIT( KTestSDKSbFrmTileWithRect, "in SbFrmTileWithRect" );
       
   923     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTileWithRect );
       
   924     // Print to log file
       
   925     iLog->Log( KTestSDKSbFrmTileWithRect );
       
   926 
       
   927     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   928     CleanupStack::PushL( control );
       
   929     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   930     CleanupStack::PushL( sbFrame );
       
   931     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   932 
       
   933     TEikScrollBarModel* hModel = new ( ELeave ) TEikScrollBarModel;
       
   934     CleanupStack::PushL( hModel );
       
   935     TEikScrollBarModel* vModel = new ( ELeave ) TEikScrollBarModel;
       
   936     CleanupStack::PushL( vModel );
       
   937     sbFrame->Tile( hModel, vModel );
       
   938 
       
   939     CleanupStack::PopAndDestroy( vModel );
       
   940     CleanupStack::PopAndDestroy( hModel );
       
   941     CleanupStack::PopAndDestroy( sbFrame );
       
   942     CleanupStack::PopAndDestroy( control );
       
   943     return KErrNone;
       
   944 
       
   945     }
       
   946 
       
   947 // -----------------------------------------------------------------------------
       
   948 // CTestSDKScroller::TestSDKSbFrmTileWithSbModelL
       
   949 // -----------------------------------------------------------------------------
       
   950 //
       
   951 TInt CTestSDKScroller::TestSDKSbFrmTileWithSbModelL( CStifItemParser& /*aItem*/ )
       
   952     {
       
   953 
       
   954     // Print to UI
       
   955     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   956     _LIT( KTestSDKSbFrmTileWithSbModel, "in SbFrmTileWithSbModel" );
       
   957     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTileWithSbModel );
       
   958     // Print to log file
       
   959     iLog->Log( KTestSDKSbFrmTileWithSbModel );
       
   960 
       
   961     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   962     CleanupStack::PushL( control );
       
   963     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   964     CleanupStack::PushL( sbFrame );
       
   965     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   966 
       
   967     TEikScrollBarModel* vModel = new ( ELeave ) TEikScrollBarModel;
       
   968     CleanupStack::PushL( vModel );
       
   969     TSize size( KWidth, KHeight );
       
   970     TRect vScrollBar( size );
       
   971     sbFrame->Tile( vModel, vScrollBar );
       
   972 
       
   973     CleanupStack::PopAndDestroy( vModel );
       
   974     CleanupStack::PopAndDestroy( sbFrame );
       
   975     CleanupStack::PopAndDestroy( control );
       
   976     return KErrNone;
       
   977 
       
   978     }
       
   979 
       
   980 // -----------------------------------------------------------------------------
       
   981 // CTestSDKScroller::TestSDKSbFrmSbVisibilityL
       
   982 // -----------------------------------------------------------------------------
       
   983 //
       
   984 TInt CTestSDKScroller::TestSDKSbFrmSbVisibilityL( CStifItemParser& /*aItem*/ )
       
   985     {
       
   986 
       
   987     // Print to UI
       
   988     _LIT( KTestSDKScroller, "testsdkscroller" );
       
   989     _LIT( KTestSDKSbFrmSbVisibility, "in SbFrmSbVisibility" );
       
   990     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSbVisibility );
       
   991     // Print to log file
       
   992     iLog->Log( KTestSDKSbFrmSbVisibility );
       
   993 
       
   994     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
   995     CleanupStack::PushL( control );
       
   996     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
   997     CleanupStack::PushL( sbFrame );
       
   998     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
   999 
       
  1000     CEikScrollBar::TOrientation orientation = CEikScrollBar::EHorizontal;
       
  1001     CEikScrollBarFrame::TScrollBarVisibility sbVisibility = sbFrame->ScrollBarVisibility( orientation );
       
  1002     STIF_ASSERT_EQUALS( CEikScrollBarFrame::EOff, sbVisibility );
       
  1003 
       
  1004     CleanupStack::PopAndDestroy( sbFrame );
       
  1005     CleanupStack::PopAndDestroy( control );
       
  1006     return KErrNone;
       
  1007 
       
  1008     }
       
  1009 
       
  1010 // -----------------------------------------------------------------------------
       
  1011 // CTestSDKScroller::TestSDKSbFrmDrawBgL
       
  1012 // -----------------------------------------------------------------------------
       
  1013 //
       
  1014 TInt CTestSDKScroller::TestSDKSbFrmDrawBgL( CStifItemParser& /*aItem*/ )
       
  1015     {
       
  1016 
       
  1017     // Print to UI
       
  1018     _LIT( KTestSDKScroller, "testsdkscroller" );
       
  1019     _LIT( KTestSDKSbFrmDrawBg, "in SbFrmDrawBg" );
       
  1020     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmDrawBg );
       
  1021     // Print to log file
       
  1022     iLog->Log( KTestSDKSbFrmDrawBg );
       
  1023 
       
  1024     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
  1025     CleanupStack::PushL( control );
       
  1026     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
  1027     CleanupStack::PushL( sbFrame );
       
  1028     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
  1029 
       
  1030     TInt err = sbFrame->DrawBackground( ETrue, ETrue );
       
  1031 
       
  1032     CleanupStack::PopAndDestroy( sbFrame );
       
  1033     CleanupStack::PopAndDestroy( control );
       
  1034     return err;
       
  1035 
       
  1036     }
       
  1037 
       
  1038 // -----------------------------------------------------------------------------
       
  1039 // CTestSDKScroller::TestSDKSbFrmDrawBgStateL
       
  1040 // -----------------------------------------------------------------------------
       
  1041 //
       
  1042 TInt CTestSDKScroller::TestSDKSbFrmDrawBgStateL( CStifItemParser& /*aItem*/ )
       
  1043     {
       
  1044 
       
  1045     // Print to UI
       
  1046     _LIT( KTestSDKScroller, "testsdkscroller" );
       
  1047     _LIT( KTestSDKSbFrmDrawBgState, "in SbFrmDrawBgState" );
       
  1048     TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmDrawBgState );
       
  1049     // Print to log file
       
  1050     iLog->Log( KTestSDKSbFrmDrawBgState );
       
  1051 
       
  1052     CTestScrollerControl* control = CTestScrollerControl::NewL();
       
  1053     CleanupStack::PushL( control );
       
  1054     CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control );
       
  1055     CleanupStack::PushL( sbFrame );
       
  1056     sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
       
  1057 
       
  1058     TBool drawHorizontal = ETrue;
       
  1059     TBool drawVertical = ETrue;
       
  1060     TInt err = sbFrame->DrawBackgroundState( drawHorizontal, drawVertical );
       
  1061 
       
  1062     CleanupStack::PopAndDestroy( sbFrame );
       
  1063     CleanupStack::PopAndDestroy( control );
       
  1064     return err;
       
  1065 
       
  1066     }
       
  1067 
       
  1068