1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  slider_api

    15 *

    16 */

    17 

    18 

    19 

    20 // [INCLUDE FILES]

    21 #include <e32svr.h>

    22 #include <stifparser.h>

    23 #include <stiftestinterface.h>

    24 #include <aknslider.h>

    25 #include <coemain.h> 

    26 #include <fbs.h> 

    27 #include <avkon.hrh>

    28 #include <coecntrl.h>

    29 

    30 #include <barsread.h>

    31 #include <testsdkslider.rsg>

    32 

    33 

    34 #include "testsdkslider.h"

    35 #include "testsdkslidercontainer.h"

    36 #include "testsdksliderview.h"

    37 #include "testsdksliderprotectedclass.h"

    38 // [const data]

    39 

    40 const TInt kMinimumValue = 0;

    41 const TInt kMaxmumValue = 100;

    42 const TInt kStep = 2;

    43 

    44 // ============================ MEMBER FUNCTIONS ===============================

    45 

    46 // -----------------------------------------------------------------------------

    47 // CTestSDKSlider::Delete

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

    49 // Called from destructor. 

    50 // -----------------------------------------------------------------------------

    51 //

    52 void CTestSDKSlider::Delete() 

    53     {

    54 

    55 

    56     }

    57 

    58 // -----------------------------------------------------------------------------

    59 // CTestSDKSlider::RunMethodL

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

    61 // -----------------------------------------------------------------------------

    62 //

    63 TInt CTestSDKSlider::RunMethodL( CStifItemParser& aItem ) 

    64     {

    65 

    66     static TStifFunctionInfo const KFunctions[] =

    67         {  

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

    69         // Second is the actual implementation member function. 

    70         ENTRY( "TestSliderConstructorL", CTestSDKSlider::TestSliderConstructorL ),

    71         ENTRY( "TestSliderDelete", CTestSDKSlider::TestSliderDelete ),

    72         ENTRY( "TestSliderSetValueL", CTestSDKSlider::TestSliderSetValueL ),

    73         ENTRY( "TestSliderValue", CTestSDKSlider::TestSliderValue ),

    74         ENTRY( "TestSliderSetRange", CTestSDKSlider::TestSliderSetRange ),

    75         ENTRY( "TestSliderGetRange", CTestSDKSlider::TestSliderGetRange ),

    76         ENTRY( "TestSliderSetStepSize", CTestSDKSlider::TestSliderSetStepSize ),

    77         ENTRY( "TestSliderSetMinimumTextL", CTestSDKSlider::TestSliderSetMinimumTextL ),

    78         ENTRY( "TestSliderSetMaximumTextL", CTestSDKSlider::TestSliderSetMaximumTextL ),

    79         ENTRY( "TestSliderSetDecimalPlaces", CTestSDKSlider::TestSliderSetDecimalPlaces ),

    80         ENTRY( "TestSliderDecimalPlaces", CTestSDKSlider::TestSliderDecimalPlaces ),

    81         ENTRY( "TestSliderSetGraphicsL", CTestSDKSlider::TestSliderSetGraphicsL ),

    82         ENTRY( "TestSliderUseDefaultGraphics", CTestSDKSlider::TestSliderUseDefaultGraphics ),

    83         ENTRY( "TestSliderUsesDefaultGraphicsReturnTBool", CTestSDKSlider::TestSliderUsesDefaultGraphicsReturnTBool ),

    84         ENTRY( "TestSliderSetPositionIndicators", CTestSDKSlider::TestSliderSetPositionIndicators ),

    85         ENTRY( "TestSliderPositionIndicators", CTestSDKSlider::TestSliderPositionIndicators ),

    86         ENTRY( "TestSliderOrientation", CTestSDKSlider::TestSliderOrientation ),

    87         ENTRY( "TestSliderSetTicksEnabled", CTestSDKSlider::TestSliderSetTicksEnabled ),

    88         ENTRY( "TestSliderTicksEnabled", CTestSDKSlider::TestSliderTicksEnabled ),

    89         ENTRY( "TestSliderSetTickInterval", CTestSDKSlider::TestSliderSetTickInterval ),

    90         ENTRY( "TestSliderTickInterval", CTestSDKSlider::TestSliderTickInterval ),

    91         ENTRY( "TestSliderCreateBitmapL", CTestSDKSlider::TestSliderCreateBitmapL ),

    92         ENTRY( "TestSliderCreateBitmapWithValuL", CTestSDKSlider::TestSliderCreateBitmapWithValuL ),

    93         ENTRY( "TestSliderCreateSetStyleListBoxIconL", CTestSDKSlider::TestSliderCreateSetStyleListBoxIconL ),

    94         ENTRY( "TestSliderCreateSetStyleListBoxIconWithValuL", CTestSDKSlider::TestSliderCreateSetStyleListBoxIconWithValuL ),

    95         ENTRY( "TestSliderEnableDragL", CTestSDKSlider::TestSliderEnableDragL ),

    96         ENTRY( "TestSliderConstructFromResourceL", CTestSDKSlider::TestSliderConstructFromResourceL ),

    97         ENTRY( "TestSliderConstructFromResourceWithControlL", CTestSDKSlider::TestSliderConstructFromResourceWithControlL ),

    98         ENTRY( "TestSliderHandleResourceChange", CTestSDKSlider::TestSliderHandleResourceChange ),

    99         ENTRY( "TestSliderNumberOfLines", CTestSDKSlider::TestSliderNumberOfLines ),

   100         ENTRY( "TestSliderCreateValueTextInHBufCL", CTestSDKSlider::TestSliderCreateValueTextInHBufCL ),

   101         ENTRY( "TestSliderCountComponentControlsL", CTestSDKSlider::TestSliderCountComponentControlsL ),

   102         ENTRY( "TestSliderComponentControlL", CTestSDKSlider::TestSliderComponentControlL ),

   103         ENTRY( "TestSliderHandlePointerEventL", CTestSDKSlider::TestSliderHandlePointerEventL ),

   104         ENTRY( "TestSliderSetValueTextL", CTestSDKSlider::TestSliderSetValueTextL ),

   105         ENTRY( "TestSliderFocusChanged", CTestSDKSlider::TestSliderFocusChanged ),

   106 

   107 

   108 

   109 

   110         // [test cases entries]

   111 

   112         };

   113 

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

   115 

   116     return RunInternalL( KFunctions, count, aItem );

   117 

   118     }

   119 

   120 

   121 // -----------------------------------------------------------------------------

   122 // CTestSDKSlider::TestSliderConstructorL

   123 // -----------------------------------------------------------------------------

   124 //

   125 TInt CTestSDKSlider::TestSliderConstructorL( CStifItemParser& /*aItem*/ )

   126     {

   127 

   128     // Print to UI

   129     _LIT( Ktestsdkslider, "testsdkslider" );

   130     _LIT( KTestSliderConstructorL, "In TestSliderConstructorL" );

   131     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderConstructorL );

   132     // Print to log file

   133     iLog->Log( KTestSliderConstructorL );

   134 

   135     iSlider = new (ELeave) CAknSlider;

   136     STIF_ASSERT_NOT_NULL( iSlider );

   137     

   138     return KErrNone;

   139     }

   140 

   141 // -----------------------------------------------------------------------------

   142 // CTestSDKSlider::TestSliderDelete

   143 // -----------------------------------------------------------------------------

   144 //

   145 TInt CTestSDKSlider::TestSliderDelete( CStifItemParser& /*aItem*/ )

   146     {

   147 

   148     // Print to UI

   149     _LIT( Ktestsdkslider, "testsdkslider" );

   150     _LIT( KTestSliderDelete, "In TestSliderDelete" );

   151     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderDelete );

   152     // Print to log file

   153     iLog->Log( KTestSliderDelete );

   154 

   155     delete iSlider;

   156     iSlider = NULL;

   157     

   158     return KErrNone;

   159     }

   160 

   161 // -----------------------------------------------------------------------------

   162 // CTestSDKSlider::TestSliderSetValueL

   163 // -----------------------------------------------------------------------------

   164 //

   165 TInt CTestSDKSlider::TestSliderSetValueL( CStifItemParser& /*aItem*/ )

   166     {

   167 

   168     // Print to UI

   169     _LIT( Ktestsdkslider, "testsdkslider" );

   170     _LIT( KTestSliderSetValueL, "In TestSliderSetValueL" );

   171     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetValueL );

   172     // Print to log file

   173     iLog->Log( KTestSliderSetValueL );

   174    

   175     TBool err = KErrNone;

   176     

   177     TInt value = iSlider->Value();

   178     TRAP ( err, iSlider->SetValueL( value ) );

   179     

   180     

   181     return err;  

   182     }

   183 

   184 

   185 

   186 // -----------------------------------------------------------------------------

   187 // CTestSDKSlider::TestSliderValue

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

   189 //

   190 TInt CTestSDKSlider::TestSliderValue( CStifItemParser& /*aItem*/ )

   191     {

   192 

   193     // Print to UI

   194     _LIT( Ktestsdkslider, "testsdkslider" );

   195     _LIT( KTestSliderValue, "In TestSliderValue" );

   196     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderValue );

   197     // Print to log file

   198     iLog->Log( KTestSliderValue );

   199 

   200     TInt value = iSlider->Value();

   201 

   202     return KErrNone;

   203     }

   204 

   205 // -----------------------------------------------------------------------------

   206 // CTestSDKSlider::TestSliderSetRange

   207 // -----------------------------------------------------------------------------

   208 //

   209 TInt CTestSDKSlider::TestSliderSetRange( CStifItemParser& /*aItem*/ )

   210     {

   211 

   212     // Print to UI

   213     _LIT( Ktestsdkslider, "testsdkslider" );

   214     _LIT( KTestSliderSetRange, "In TestSliderSetRange" );

   215     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetRange );

   216     // Print to log file

   217     iLog->Log( KTestSliderSetRange );

   218 

   219     iSlider->SetRange( kMinimumValue,kMaxmumValue );

   220     return KErrNone;

   221     }

   222 

   223 // -----------------------------------------------------------------------------

   224 // CTestSDKSlider::TestSliderGetRange

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

   226 //

   227 TInt CTestSDKSlider::TestSliderGetRange( CStifItemParser& /*aItem*/ )

   228     {

   229 

   230     // Print to UI

   231     _LIT( Ktestsdkslider, "testsdkslider" );

   232     _LIT( KTestSliderGetRange, "In TestSliderGetRange" );

   233     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderGetRange );

   234     // Print to log file

   235     iLog->Log( KTestSliderGetRange );

   236     TInt minimumValue = 0;

   237     TInt maxmumValue = 100;

   238     

   239     iSlider->GetRange( minimumValue, maxmumValue );

   240     return KErrNone;

   241     }

   242 // -----------------------------------------------------------------------------

   243 // CTestSDKSlider::TestSliderGetRange

   244 // -----------------------------------------------------------------------------

   245 //

   246 TInt CTestSDKSlider::TestSliderSetStepSize( CStifItemParser& /*aItem*/ )

   247     {

   248 

   249     // Print to UI

   250     _LIT( Ktestsdkslider, "testsdkslider" );

   251     _LIT( KTestSliderSetStepSize, "In TestSliderSetStepSize" );

   252     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetStepSize );

   253     // Print to log file

   254     iLog->Log( KTestSliderSetStepSize );

   255     

   256     iSlider->SetStepSize( kStep );

   257     return KErrNone;

   258     }

   259 

   260 // -----------------------------------------------------------------------------

   261 // CTestSDKSlider::TestSliderSetMinimumTextL

   262 // -----------------------------------------------------------------------------

   263 //

   264 TInt CTestSDKSlider::TestSliderSetMinimumTextL( CStifItemParser& /*aItem*/ )

   265     {

   266 

   267     // Print to UI

   268     _LIT( Ktestsdkslider, "testsdkslider" );

   269     _LIT( KTestSliderSetMinimumTextL, "In TestSliderSetMinimumTextL" );

   270     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetMinimumTextL );

   271     // Print to log file

   272     iLog->Log( KTestSliderSetMinimumTextL );

   273     

   274     TBool err = KErrNone;

   275     TBufC<128> buf( _L("MiniTEST") );

   276     TRAP ( err, iSlider->SetMinimumTextL( buf ) );

   277     return err;

   278     }

   279 

   280 // -----------------------------------------------------------------------------

   281 // CTestSDKSlider::TestSliderSetMaximumTextL

   282 // -----------------------------------------------------------------------------

   283 //

   284 TInt CTestSDKSlider::TestSliderSetMaximumTextL( CStifItemParser& /*aItem*/ )

   285     {

   286 

   287     // Print to UI

   288     _LIT( Ktestsdkslider, "testsdkslider" );

   289     _LIT( KTestSliderSetMaximumTextL, "In TestSliderSetMaximumTextL" );

   290     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetMaximumTextL );

   291     // Print to log file

   292     iLog->Log( KTestSliderSetMaximumTextL );

   293     

   294     TBool err = KErrNone;

   295     TBufC<128> buf( _L("MaxTEST") );

   296     TRAP ( err, iSlider->SetMaximumTextL( buf ) );

   297     return err;

   298     }

   299 

   300 // -----------------------------------------------------------------------------

   301 // CTestSDKSlider::TestSliderSetDecimalPlaces

   302 // -----------------------------------------------------------------------------

   303 //

   304 TInt CTestSDKSlider::TestSliderSetDecimalPlaces( CStifItemParser& /*aItem*/ )

   305     {

   306 

   307     // Print to UI

   308     _LIT( Ktestsdkslider, "testsdkslider" );

   309     _LIT( KTestSliderSetDecimalPlaces, "In TestSliderSetDecimalPlaces" );

   310     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetDecimalPlaces );

   311     // Print to log file

   312     iLog->Log( KTestSliderSetDecimalPlaces );

   313 

   314     iSlider->SetDecimalPlaces( kMinimumValue );

   315     return KErrNone;

   316     }

   317 

   318 // -----------------------------------------------------------------------------

   319 // CTestSDKSlider::TestSliderDecimalPlaces

   320 // -----------------------------------------------------------------------------

   321 //

   322 TInt CTestSDKSlider::TestSliderDecimalPlaces( CStifItemParser& /*aItem*/ )

   323     {

   324 

   325     // Print to UI

   326     _LIT( Ktestsdkslider, "testsdkslider" );

   327     _LIT( KTestSliderDecimalPlaces, "In TestSliderDecimalPlaces" );

   328     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderDecimalPlaces );

   329     // Print to log file

   330     iLog->Log( KTestSliderDecimalPlaces );

   331 

   332     TInt decimal = iSlider->DecimalPlaces();

   333     return KErrNone;

   334     }

   335 

   336 // -----------------------------------------------------------------------------

   337 // CTestSDKSlider::TestSliderSetGraphicsL

   338 // -----------------------------------------------------------------------------

   339 //

   340 TInt CTestSDKSlider::TestSliderSetGraphicsL( CStifItemParser& /*aItem*/ )

   341     {

   342 

   343     // Print to UI

   344     _LIT( Ktestsdkslider, "testsdkslider" );

   345     _LIT( KTestSliderSetGraphicsL, "In TestSliderSetGraphicsL" );

   346     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetGraphicsL );

   347     // Print to log file

   348     iLog->Log( KTestSliderSetGraphicsL );

   349 

   350     TInt value = iSlider->Value();

   351     CFbsBitmap* bitmap = iSlider->CreateBitmapL( value, R_TESTSLIDER_SLIDER );

   352     

   353     iSlider->SetGraphics( kMinimumValue, bitmap, kMinimumValue );

   354     

   355     return KErrNone;

   356     }

   357 

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

   359 // CTestSDKSlider::TestSliderUseDefaultGraphics

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

   361 //

   362 TInt CTestSDKSlider::TestSliderUseDefaultGraphics( CStifItemParser& /*aItem*/ )

   363     {

   364 

   365     // Print to UI

   366     _LIT( Ktestsdkslider, "testsdkslider" );

   367     _LIT( KTestSliderUseDefaultGraphics, "In TestSliderUseDefaultGraphics" );

   368     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderUseDefaultGraphics );

   369     // Print to log file

   370     iLog->Log( KTestSliderUseDefaultGraphics );

   371     iSlider->UseDefaultGraphics( kMinimumValue );

   372     return KErrNone;

   373     }

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

   375 // CTestSDKSlider::TestSliderUsesDefaultGraphicsReturnTBool

   376 // -----------------------------------------------------------------------------

   377 //

   378 TInt CTestSDKSlider::TestSliderUsesDefaultGraphicsReturnTBool( CStifItemParser& /*aItem*/ )

   379     {

   380 

   381     // Print to UI

   382     _LIT( Ktestsdkslider, "testsdkslider" );

   383     _LIT( KTestSliderUsesDefaultGraphicsReturnTBool, "In TestSliderUsesDefaultGraphicsReturnTBool" );

   384     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderUsesDefaultGraphicsReturnTBool );

   385     // Print to log file

   386     iLog->Log( KTestSliderUsesDefaultGraphicsReturnTBool );

   387     TBool defaltGraphics;

   388     defaltGraphics = iSlider->UsesDefaultGraphics( kMinimumValue );

   389     STIF_ASSERT_FALSE( defaltGraphics );

   390     return KErrNone;

   391     }

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

   393 // CTestSDKSlider::TestSliderSetPositionIndicators

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

   395 //

   396 TInt CTestSDKSlider::TestSliderSetPositionIndicators( CStifItemParser& /*aItem*/ )

   397     {

   398 

   399     // Print to UI

   400     _LIT( Ktestsdkslider, "testsdkslider" );

   401     _LIT( KTestSliderSetPositionIndicators, "In TestSliderSetPositionIndicators" );

   402     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetPositionIndicators );

   403     // Print to log file

   404     iLog->Log( KTestSliderSetPositionIndicators );

   405     

   406     iSlider->SetPositionIndicators( kMinimumValue );

   407 

   408     return KErrNone;

   409     }

   410 // -----------------------------------------------------------------------------

   411 // CTestSDKSlider::TestSliderPositionIndicators

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

   413 //

   414 TInt CTestSDKSlider::TestSliderPositionIndicators( CStifItemParser& /*aItem*/ )

   415     {

   416 

   417     // Print to UI

   418     _LIT( Ktestsdkslider, "testsdkslider" );

   419     _LIT( KTestSliderPositionIndicators, "In TestSliderPositionIndicators" );

   420     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderPositionIndicators );

   421     // Print to log file

   422     iLog->Log( KTestSliderPositionIndicators );

   423     

   424     TUint32 positionIndicators = iSlider->PositionIndicators();

   425     TUint32 minimumValue =0;

   426     STIF_ASSERT_NOT_EQUALS( minimumValue, positionIndicators );

   427     

   428     return KErrNone;

   429     }

   430 

   431 // -----------------------------------------------------------------------------

   432 // CTestSDKSlider::TestSliderOrientation

   433 // -----------------------------------------------------------------------------

   434 //

   435 TInt CTestSDKSlider::TestSliderOrientation( CStifItemParser& /*aItem*/ )

   436     {

   437 

   438     // Print to UI

   439     _LIT( Ktestsdkslider, "testsdkslider" );

   440     _LIT( KTestSliderOrientation, "In TestSliderOrientation" );

   441     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderOrientation );

   442     // Print to log file

   443     iLog->Log( KTestSliderOrientation );

   444 

   445     TAknOrientation Orientation = iSlider->Orientation();

   446 

   447     return KErrNone;

   448     }

   449 

   450 // -----------------------------------------------------------------------------

   451 // CTestSDKSlider::TestSliderSetTicksEnabled

   452 // -----------------------------------------------------------------------------

   453 //

   454 TInt CTestSDKSlider::TestSliderSetTicksEnabled( CStifItemParser& /*aItem*/ )

   455     {

   456 

   457     // Print to UI

   458     _LIT( Ktestsdkslider, "testsdkslider" );

   459     _LIT( KTestSliderSetTicksEnabled, "In TestSliderSetTicksEnabled" );

   460     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetTicksEnabled );

   461     // Print to log file

   462     iLog->Log( KTestSliderSetTicksEnabled );

   463 

   464     iSlider->SetTicksEnabled( ETrue );

   465 

   466     return KErrNone;

   467     }

   468 // -----------------------------------------------------------------------------

   469 // CTestSDKSlider::TestSliderTicksEnabled

   470 // -----------------------------------------------------------------------------

   471 //

   472 TInt CTestSDKSlider::TestSliderTicksEnabled( CStifItemParser& /*aItem*/ )

   473     {

   474 

   475     // Print to UI

   476     _LIT( Ktestsdkslider, "testsdkslider" );

   477     _LIT( KTestSliderTicksEnabled, "In TestSliderTicksEnabled" );

   478     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderTicksEnabled );

   479     // Print to log file

   480     iLog->Log( KTestSliderTicksEnabled );

   481 

   482     TBool ticksEnabled = iSlider->TicksEnabled();

   483     STIF_ASSERT_FALSE( ticksEnabled );

   484 

   485     return KErrNone;

   486     }

   487 

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

   489 // CTestSDKSlider::TestSliderSetTickInterval

   490 // -----------------------------------------------------------------------------

   491 //

   492 TInt CTestSDKSlider::TestSliderSetTickInterval( CStifItemParser& /*aItem*/ )

   493     {

   494 

   495     // Print to UI

   496     _LIT( Ktestsdkslider, "testsdkslider" );

   497     _LIT( KTestSliderSetTickInterval, "In TestSliderSetTickInterval" );

   498     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetTickInterval );

   499     // Print to log file

   500     iLog->Log( KTestSliderSetTickInterval );

   501    

   502     iSlider->SetTickInterval( kMinimumValue );

   503    

   504 

   505     return KErrNone;

   506     }

   507 

   508 

   509 // -----------------------------------------------------------------------------

   510 // CTestSDKSlider::TestSliderTickInterval

   511 // -----------------------------------------------------------------------------

   512 //

   513 TInt CTestSDKSlider::TestSliderTickInterval( CStifItemParser& /*aItem*/ )

   514     {

   515 

   516     // Print to UI

   517     _LIT( Ktestsdkslider, "testsdkslider" );

   518     _LIT( KTestSliderTickInterval, "In TestSliderTickInterval" );

   519     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderTickInterval );

   520     // Print to log file

   521     iLog->Log( KTestSliderTickInterval );

   522    

   523     TUint tickInterval = iSlider->TickInterval();

   524     TUint minimumValue = 0;

   525     STIF_ASSERT_EQUALS( minimumValue, tickInterval );

   526 

   527     return KErrNone;

   528     }

   529 

   530 // -----------------------------------------------------------------------------

   531 // CTestSDKSlider::TestSliderCreateBitmapL

   532 // -----------------------------------------------------------------------------

   533 //

   534 TInt CTestSDKSlider::TestSliderCreateBitmapL( CStifItemParser& /*aItem*/ )

   535     {

   536 

   537     // Print to UI

   538     _LIT( Ktestsdkslider, "testsdkslider" );

   539     _LIT( KTestSliderCreateBitmapL, "In TestSliderCreateBitmapL" );

   540     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderCreateBitmapL );

   541     // Print to log file

   542     iLog->Log( KTestSliderCreateBitmapL );

   543 

   544     TInt value = iSlider->Value();

   545     CFbsBitmap* bitmap = CAknSlider::CreateBitmapL( value, R_TESTSLIDER_SLIDER);

   546     STIF_ASSERT_NOT_NULL( bitmap );

   547 

   548     return KErrNone;

   549     }

   550 // -----------------------------------------------------------------------------

   551 // CTestSDKSlider::TestSliderCreateBitmapWithValuL

   552 // -----------------------------------------------------------------------------

   553 //

   554 TInt CTestSDKSlider::TestSliderCreateBitmapWithValuL( CStifItemParser& /*aItem*/ )

   555     {

   556 

   557     // Print to UI

   558     _LIT( Ktestsdkslider, "testsdkslider" );

   559     _LIT( KTestSliderCreateBitmapWithValuL, "In TestSliderCreateBitmapWithValuL" );

   560     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderCreateBitmapWithValuL );

   561     // Print to log file

   562     iLog->Log( KTestSliderCreateBitmapWithValuL );

   563 

   564     TInt value = iSlider->Value();

   565     TInt minimumValue = 0;

   566     TInt maxmumValue = 100;

   567 

   568     CFbsBitmap* bitmap = CAknSlider::CreateBitmapL( value, minimumValue, maxmumValue);

   569     STIF_ASSERT_NOT_NULL( bitmap );

   570 

   571     return KErrNone;

   572     }

   573 // -----------------------------------------------------------------------------

   574 // CTestSDKSlider::TestSliderCreateSetStyleListBoxIconL

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

   576 //

   577 TInt CTestSDKSlider::TestSliderCreateSetStyleListBoxIconL( CStifItemParser& /*aItem*/ )

   578     {

   579 

   580     // Print to UI

   581     _LIT( Ktestsdkslider, "testsdkslider" );

   582     _LIT( KTestSliderCreateSetStyleListBoxIconL, "In TestSliderCreateSetStyleListBoxIconL" );

   583     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderCreateSetStyleListBoxIconL );

   584     // Print to log file

   585     iLog->Log( KTestSliderCreateSetStyleListBoxIconL );

   586 

   587     TInt value = iSlider->Value();

   588 

   589 

   590     CGulIcon* gulIcon = CAknSlider::CreateSetStyleListBoxIconL( value, R_TESTSLIDER_SLIDER );

   591     STIF_ASSERT_NOT_NULL( gulIcon );

   592 

   593     return KErrNone;

   594     }

   595 // -----------------------------------------------------------------------------

   596 // CTestSDKSlider::TestSliderCreateSetStyleListBoxIconWithValuL

   597 // -----------------------------------------------------------------------------

   598 //

   599 TInt CTestSDKSlider::TestSliderCreateSetStyleListBoxIconWithValuL( CStifItemParser& /*aItem*/ )

   600     {

   601 

   602     // Print to UI

   603     _LIT( Ktestsdkslider, "testsdkslider" );

   604     _LIT( KTestSliderCreateSetStyleListBoxIconWithValuL, "In TestSliderCreateSetStyleListBoxIconWithValuL" );

   605     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderCreateSetStyleListBoxIconWithValuL );

   606     // Print to log file

   607     iLog->Log( KTestSliderCreateSetStyleListBoxIconWithValuL );

   608 

   609     TInt value = iSlider->Value();

   610     TInt minimumValue = 0;

   611     TInt maxmumValue = 100;

   612 

   613     CGulIcon* gulIcon = CAknSlider::CreateSetStyleListBoxIconL( value, minimumValue, maxmumValue );

   614     STIF_ASSERT_NOT_NULL( gulIcon );

   615 

   616     return KErrNone;

   617     }

   618 // -----------------------------------------------------------------------------

   619 // CTestSDKSlider::TestSliderEnableDragL

   620 // -----------------------------------------------------------------------------

   621 //

   622 TInt CTestSDKSlider::TestSliderEnableDragL( CStifItemParser& /*aItem*/ )

   623     {

   624 

   625     // Print to UI

   626     _LIT( Ktestsdkslider, "testsdkslider" );

   627     _LIT( KTestSliderEnableDragL, "In TestSliderEnableDragL" );

   628     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderEnableDragL );

   629     // Print to log file

   630     iLog->Log( KTestSliderEnableDragL );

   631     

   632     iSliderView = CSliderView::NewL();

   633     iSliderContainer = new( ELeave ) CSliderContainer();

   634     iSliderContainer->SetMopParent( iSliderView );

   635     iSliderContainer->ConstructL( iSliderView->ClientRect() );

   636     CCoeEnv::Static()->AppUi()->AddToStackL( iSliderContainer );

   637     iSliderContainer->MakeVisible( ETrue );

   638     iSlider->SetContainerWindowL( *iSliderContainer ); 

   639 

   640     iSlider->EnableDrag();

   641 

   642     

   643     return KErrNone;

   644     }

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

   646 // CTestSDKSlider::TestSliderConstructFromResourceL

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

   648 //

   649 TInt CTestSDKSlider::TestSliderConstructFromResourceL( CStifItemParser& /*aItem*/ )

   650     {

   651 

   652     // Print to UI

   653     _LIT( Ktestsdkslider, "testsdkslider" );

   654     _LIT( KTestSliderConstructFromResourceL, "In TestSliderConstructFromResourceL" );

   655     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderConstructFromResourceL );

   656     // Print to log file

   657     iLog->Log( KTestSliderConstructFromResourceL );

   658    

   659     TBool err = KErrNone;

   660     TResourceReader reader;

   661     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TESTSLIDER_SLIDER );

   662 

   663     TRAP ( err, iSlider->ConstructFromResourceL( reader ));

   664     CleanupStack::PopAndDestroy();

   665     return err;

   666     }

   667 

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

   669 // CTestSDKSlider::TestSliderConstructFromResourceWithControlL

   670 // -----------------------------------------------------------------------------

   671 //

   672 TInt CTestSDKSlider::TestSliderConstructFromResourceWithControlL( CStifItemParser& /*aItem*/ )

   673     {

   674 

   675     // Print to UI

   676     _LIT( Ktestsdkslider, "testsdkslider" );

   677     _LIT( KTestSliderConstructFromResourceWithControlL, "In TestSliderConstructFromResourceWithControlL" );

   678     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderConstructFromResourceWithControlL );

   679     // Print to log file

   680     iLog->Log( KTestSliderConstructFromResourceWithControlL );

   681    

   682     TBool err = KErrNone;

   683     TResourceReader reader;

   684 

   685     TInt value = iSlider->Value();

   686     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TESTSLIDER_SLIDER );

   687     CCoeControl* parent = new ( ELeave ) CCoeControl();

   688     CleanupStack::PushL( parent );

   689     TRAP ( err, iSlider->ConstructFromResourceL( parent, value, reader ));

   690    

   691     CleanupStack::PopAndDestroy( 2 );

   692     

   693     return err;

   694     }

   695 

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

   697 // CTestSDKSlider::TestSliderHandleResourceChange

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

   699 //

   700 TInt CTestSDKSlider::TestSliderHandleResourceChange( CStifItemParser& /*aItem*/ )

   701     {

   702 

   703     // Print to UI

   704     _LIT( Ktestsdkslider, "testsdkslider" );

   705     _LIT( KTestSliderHandleResourceChange, "In TestSliderHandleResourceChange" );

   706     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderHandleResourceChange );

   707     // Print to log file

   708     iLog->Log( KTestSliderHandleResourceChange );

   709 

   710     iSlider->HandleResourceChange( kMinimumValue );

   711 

   712     return KErrNone;

   713     }

   714 // -----------------------------------------------------------------------------

   715 // CTestSDKSlider::TestSliderNumberOfLines

   716 // -----------------------------------------------------------------------------

   717 //

   718 TInt CTestSDKSlider::TestSliderNumberOfLines( CStifItemParser& /*aItem*/ )

   719     {

   720 

   721     // Print to UI

   722     _LIT( Ktestsdkslider, "testsdkslider" );

   723     _LIT( KTestSliderNumberOfLines, "In TestSliderNumberOfLines" );

   724     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderNumberOfLines );

   725     // Print to log file

   726     iLog->Log( KTestSliderNumberOfLines );

   727 

   728     TInt expect = 0;

   729     TInt numberOfLines = iSlider->NumberOfLines();

   730     STIF_ASSERT_NOT_EQUALS( expect, numberOfLines);

   731 

   732     return KErrNone;

   733     }

   734 // -----------------------------------------------------------------------------

   735 // CTestSDKSlider::TestSliderCreateValueTextInHBufCL

   736 // -----------------------------------------------------------------------------

   737 //

   738 TInt CTestSDKSlider::TestSliderCreateValueTextInHBufCL( CStifItemParser& /*aItem*/ )

   739     {

   740 

   741     // Print to UI

   742     _LIT( Ktestsdkslider, "testsdkslider" );

   743     _LIT( KTestSliderCreateValueTextInHBufCL, "In TestSliderCreateValueTextInHBufCL" );

   744     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderCreateValueTextInHBufCL );

   745     // Print to log file

   746     iLog->Log( KTestSliderCreateValueTextInHBufCL );

   747 

   748     TInt value = iSlider->Value();

   749     HBufC* buf = CAknSlider::CreateValueTextInHBufCL( value, R_TESTSLIDER_SLIDER);

   750     STIF_ASSERT_NOT_NULL( buf );

   751 

   752     return KErrNone;

   753     }

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

   755 // CTestSDKSlider::TestSliderCountComponentControlsL

   756 // -----------------------------------------------------------------------------

   757 //

   758 TInt CTestSDKSlider::TestSliderCountComponentControlsL( CStifItemParser& /*aItem*/ )

   759     {

   760 

   761     // Print to UI

   762     _LIT( Ktestsdkslider, "testsdkslider" );

   763     _LIT( KTestSliderCountComponentControlsL, "In TestSliderCountComponentControlsL" );

   764     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderCountComponentControlsL );

   765     // Print to log file

   766     iLog->Log( KTestSliderCountComponentControlsL );

   767     CTestAknSlider* slider = new (ELeave) CTestAknSlider;

   768     TResourceReader reader;

   769 

   770     TInt value = 0;

   771     CCoeEnv::Static()->CreateResourceReaderLC(reader, R_TESTSLIDER_SLIDER);

   772     CCoeControl* parent = new ( ELeave ) CCoeControl();

   773     CleanupStack::PushL(parent);

   774     slider->ConstructFromResourceL( parent, value, reader );

   775     TInt componentControls = slider->CountComponentControls();

   776     CleanupStack::PopAndDestroy( 2 );

   777     return KErrNone;

   778     }

   779 // -----------------------------------------------------------------------------

   780 // CTestSDKSlider::TestSliderComponentControlL

   781 // -----------------------------------------------------------------------------

   782 //

   783 TInt CTestSDKSlider::TestSliderComponentControlL( CStifItemParser& /*aItem*/ )

   784     {

   785 

   786     // Print to UI

   787     _LIT( Ktestsdkslider, "testsdkslider" );

   788     _LIT( KTestSliderComponentControlL, "In TestSliderComponentControlL" );

   789     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderComponentControlL );

   790     // Print to log file

   791     iLog->Log( KTestSliderComponentControlL );

   792     CTestAknSlider* slider = new (ELeave) CTestAknSlider;

   793     TResourceReader reader;

   794 

   795     TInt value = 0;

   796     CCoeEnv::Static()->CreateResourceReaderLC(reader, R_TESTSLIDER_SLIDER);

   797     CCoeControl* parent = new ( ELeave ) CCoeControl();

   798     CleanupStack::PushL(parent);

   799     slider->ConstructFromResourceL( parent, value, reader );

   800     TInt cindex = 0;

   801     CCoeControl* control = slider->ComponentControl( cindex );

   802     CleanupStack::PopAndDestroy( 2 );

   803     STIF_ASSERT_NOT_NULL( control );

   804     return KErrNone;

   805     }

   806 // -----------------------------------------------------------------------------

   807 // CTestSDKSlider::TestSliderHandlePointerEventL

   808 // -----------------------------------------------------------------------------

   809 //

   810 TInt CTestSDKSlider::TestSliderHandlePointerEventL( CStifItemParser& /*aItem*/ )

   811     {

   812 

   813     // Print to UI

   814     _LIT( Ktestsdkslider, "testsdkslider" );

   815     _LIT( KTestSliderHandlePointerEventL, "In TestSliderHandlePointerEventL" );

   816     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderHandlePointerEventL );

   817     // Print to log file

   818     iLog->Log( KTestSliderHandlePointerEventL );

   819 

   820     TPointerEvent event;

   821 

   822     event.iType = TPointerEvent::EButton1Down;

   823 

   824     event.iModifiers = 0;

   825 

   826     TPoint eventPos( 10, 30);

   827 

   828     event.iPosition = eventPos;

   829 

   830     event.iParentPosition = eventPos;

   831 

   832     TBool err = KErrNone;

   833 

   834     TRAP( err, iSlider->HandlePointerEventL( event ) );

   835 

   836 

   837     return err;

   838     }

   839 // -----------------------------------------------------------------------------

   840 // CTestSDKSlider::TestSliderSetValueTextL

   841 // -----------------------------------------------------------------------------

   842 //

   843 TInt CTestSDKSlider::TestSliderSetValueTextL( CStifItemParser& /*aItem*/ )

   844     {

   845 

   846     // Print to UI

   847     _LIT( Ktestsdkslider, "testsdkslider" );

   848     _LIT( KTestSliderSetValueTextL, "In TestSliderSetValueTextL" );

   849     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderSetValueTextL );

   850     // Print to log file

   851     iLog->Log( KTestSliderSetValueTextL );

   852 

   853     CTestAknSlider* slider = new (ELeave) CTestAknSlider;

   854     TResourceReader reader;

   855 

   856     TInt value = 0;

   857     CCoeEnv::Static()->CreateResourceReaderLC(reader, R_TESTSLIDER_SLIDER);

   858     CCoeControl* parent = new ( ELeave ) CCoeControl();

   859     CleanupStack::PushL(parent);

   860     slider->ConstructFromResourceL( parent, value, reader );

   861     TBool err = KErrNone;

   862     TRAP( err, slider->SetValueTextL() );

   863     CleanupStack::PopAndDestroy( 2 );

   864  

   865     return err;

   866     

   867 

   868     }

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

   870 // CTestSDKSlider::TestSliderFocusChanged

   871 // -----------------------------------------------------------------------------

   872 //

   873 TInt CTestSDKSlider::TestSliderFocusChanged( CStifItemParser& /*aItem*/ )

   874     {

   875 

   876     // Print to UI

   877     _LIT( Ktestsdkslider, "testsdkslider" );

   878     _LIT( KTestSliderFocusChanged, "In TestSliderFocusChanged" );

   879     TestModuleIf().Printf( 0, Ktestsdkslider, KTestSliderFocusChanged );

   880     // Print to log file

   881     iLog->Log( KTestSliderFocusChanged );

   882 

   883     iSlider->FocusChanged( ENoDrawNow );

   884 

   885     return KErrNone;

   886     

   887 

   888     }

   889 //  [End of File]