1 /*

     2 * Copyright (c) 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 the License "Symbian Foundation License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  AppUi class implementation.

    15 *

    16 */

    17 

    18 

    19 #include <avkon.hrh>

    20 #include <e32math.h>

    21 #include <eikmenup.h>

    22 #include <aknlistquerydialog.h>

    23 #include <hapticstest.rsg>

    24 #include <utf.h>

    25 

    26 #include "hapticstest.pan"

    27 #include "hapticstestappui.h"

    28 #include "hapticstestappview.h"

    29 #include "hapticstesteffectdatahandler.h"

    30 #include "hapticstest.hrh"

    31 

    32 _LIT( KSessionPathMem, "C:\\Data\\Others\\" );

    33 _LIT( KSessionPathCrd, "E:\\Others\\" );

    34 _LIT( KIVTFileType, "*.ivt" );

    35 

    36 const TInt KSampleCount = 8;

    37 

    38 static const TUint8 KStreamArray[KSampleCount][10] =

    39     {

    40     0x00, 0x00, 0x20, 0x13, 0x00, 0x00, 0x7f, 0x01, 0x5d, 0x41,

    41     0x29, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0xc1, 0x4d, 0x42,           

    42     0x51, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0x01, 0x5d, 0xc1,

    43     0x65, 0x00, 0x20, 0x07, 0x00, 0x00, 0x7f, 0x01, 0x5d, 0xd1,

    44     0x7a, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0xc1, 0x4d, 0x42,

    45     0x8e, 0x00, 0x20, 0x16, 0x00, 0x00, 0x7f, 0x01, 0x5d, 0x01,

    46     0xa2, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0xc1, 0x4d, 0x42,

    47     0x06, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0xc1, 0x4d, 0x42    

    48     };

    49 

    50 

    51 

    52 

    53 // ---------------------------------------------------------

    54 // ConstructL is called by the application framework

    55 // ---------------------------------------------------------

    56 //

    57 void CHapticsTestAppUi::ConstructL()

    58     {

    59     BaseConstructL();

    60 

    61     // create appview

    62     iAppView = CHapticsTestAppView::NewL( ClientRect() );    

    63     AddToStackL( iAppView );

    64 

    65     // create effect data handler

    66     iEffectData = CHapticsTestEffectDataHandler::NewL();

    67 

    68     // create async play sender

    69     iAsyncPlaySender = new ( ELeave ) CHapticsTestAsyncPlaySender( this );

    70     

    71     FindIVTFiles();

    72 

    73     iAppView->InsertOutput( _L("Haptics usage from options menu.") );

    74     }

    75 

    76 // ---------------------------------------------------------

    77 // Constructor.

    78 // ---------------------------------------------------------

    79 //

    80 CHapticsTestAppUi::CHapticsTestAppUi()

    81     : iSynchronous( ETrue ), iUseHandle( EFalse ), iUsesMemCard( EFalse )

    82     {

    83     // no implementation required

    84     }

    85 

    86 // ---------------------------------------------------------

    87 // Destructor.

    88 // ---------------------------------------------------------

    89 //

    90 CHapticsTestAppUi::~CHapticsTestAppUi()

    91     {

    92     if (iAppView)

    93         {

    94         RemoveFromStack( iAppView );

    95         delete iAppView;

    96         iAppView = NULL;

    97         }

    98 

    99     if( iHaptics )

   100         {

   101         delete iHaptics;

   102         iHaptics = NULL;

   103         }

   104     

   105     if ( iTempHaptics )

   106         {

   107         delete iTempHaptics;

   108         iTempHaptics = NULL;

   109         }

   110     

   111     delete iEffectData;

   112 

   113     iIVTFileArray.Close();

   114 

   115     while ( iLoadedIVTFileArray.Count() )

   116         {

   117         delete iLoadedIVTFileArray[0].iDataBuffer;

   118         iLoadedIVTFileArray.Remove( 0 );

   119         }

   120     

   121     iLoadedIVTFileArray.Close();

   122 

   123     if ( iAsyncPlaySender )

   124         {

   125         iAsyncPlaySender->Cancel();

   126         delete iAsyncPlaySender;

   127         iAsyncPlaySender = NULL;

   128         }

   129     }

   130 

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

   132 // handle any menu commands

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

   134 //

   135 void CHapticsTestAppUi::HandleCommandL( TInt aCommand )

   136     {

   137     switch( aCommand )

   138         {

   139         case EEikCmdExit:

   140         case EAknSoftkeyExit:

   141             Exit();

   142             break;

   143 

   144         case EHapticsTestOpenHaptics:

   145             {

   146             OpenHapticsL();

   147             }

   148             break;

   149 

   150         case EHapticsTestAutoInit:

   151             {

   152             // automatically create haptics instance, fetch supported

   153             // actuators, and open Any-actuator

   154             OpenHapticsL();

   155             FetchSupportedActuators();

   156             OpenActuator( EHWRMLogicalActuatorAny );

   157             }

   158             break;

   159 

   160         case EHapticsTestSupportedActuators:

   161             {

   162             FetchSupportedActuators();

   163             }

   164             break;

   165 

   166         case EHapticsTestOpenActuator:

   167         case EHapticsTestOpenActuatorAny:

   168             {

   169             OpenActuator( EHWRMLogicalActuatorAny );

   170             }

   171             break;

   172         case EHapticsTestOpenActuatorDevice:

   173             {

   174             OpenActuator( EHWRMLogicalActuatorDevice );

   175             }

   176             break;

   177         case EHapticsTestOpenActuatorPrimaryDisplay:

   178             {

   179             OpenActuator( EHWRMLogicalActuatorPrimaryDisplay );

   180             }

   181             break;

   182         case EHapticsTestOpenActuatorSecondaryDisplay:

   183             {

   184             OpenActuator( EHWRMLogicalActuatorSecondaryDisplay );

   185             }

   186             break;

   187         case EHapticsTestOpenActuatorGame:

   188             {

   189             OpenActuator( EHWRMLogicalActuatorGame );

   190             }

   191             break;

   192         case EHapticsTestOpenActuatorGameLeft:

   193             {

   194             OpenActuator( EHWRMLogicalActuatorGameLeft );

   195             }

   196             break;

   197         case EHapticsTestOpenActuatorGameRight:

   198             {

   199             OpenActuator( EHWRMLogicalActuatorGameRight );

   200             }

   201             break;

   202         case EHapticsTestOpenActuatorExternalVibra:

   203             {

   204             OpenActuator( EHWRMLogicalActuatorExternalVibra );

   205             }

   206             break;

   207         

   208         case EHapticsTestLoadIVTFile:

   209         case EHapticsTestLoadIVTFileNoneFound:

   210             {

   211             // nothing to do

   212             }

   213             break;

   214         case EHapticsTestLoadIVTFileSelected:

   215             {

   216             // open selected file

   217             TInt index = iMenuPane->SelectedItem();

   218             LoadIVTDataL( iIVTFileArray[index] );

   219             }

   220             break;

   221         

   222         case EHapticsTestPlayEffect:

   223         case EHapticsTestPlayEffectNoneFound:

   224             {

   225             // nothing to do

   226             }

   227             break;

   228         case EHapticsTestPlayEffectSelected:

   229             {

   230             // play selected effect

   231             TInt index = CountFileHandleAndEffectIndex( iMenuPane->SelectedItem() );

   232             PlayEffect( index );

   233             PrintEffectInfo( index );

   234             }

   235             break;

   236         case EHapticsTestPlayEffectRepeat:

   237         case EHapticsTestPlayEffectRepeatNoneFound:

   238             {

   239             // nothing to do

   240             }

   241             break;        

   242         case EHapticsTestPlayEffectRepeatSelected:

   243             {

   244             // play selected effect repeatedly

   245             TInt index = CountFileHandleAndEffectIndex( iMenuPane->SelectedItem() );

   246             RepeatEffect( index, GetNumberOfRepeats() );

   247             PrintEffectInfo( index );

   248             }

   249             break;

   250     

   251         case EHapticsTestPlayEffectManual:

   252             {

   253             // nothing to do

   254             }

   255             break;

   256         case EHapticsTestPlayEffectManualMagSweep:

   257             {

   258             PlayMagSweepL();

   259             }

   260             break;

   261         case EHapticsTestPlayEffectManualMagSweepInf:

   262             {

   263             PlayMagSweepL( ETrue );

   264             }

   265             break;

   266         case EHapticsTestPlayEffectManualMagSweepInfMod:

   267             {

   268             PlayMagSweepL( ETrue, ETrue );

   269             }

   270             break;

   271         case EHapticsTestPlayEffectManualPeriodic:

   272             {

   273             PlayPeriodicL();

   274             }

   275             break;

   276         case EHapticsTestPlayEffectManualPeriodicInf:

   277             {

   278             PlayPeriodicL( ETrue );

   279             }

   280             break;

   281         case EHapticsTestPlayEffectManualPeriodicInfMod:

   282             {

   283             PlayPeriodicL( ETrue, ETrue );

   284             }

   285             break;

   286         case EHapticsTestPlayEffectManualRepeat:

   287             {

   288             PlayRepeatL( GetNumberOfRepeats() );

   289             }

   290             break;

   291 

   292         case EHapticsTestChangeState:

   293         case EHapticsTestChangeStateNoneFound:

   294             {

   295             // nothing to do

   296             }

   297             break;

   298 

   299         case EHapticsTestChangeStatePause:

   300             {

   301             // get itemindex and pause effect

   302             TInt itemIndex = iMenuPane->SelectedItem();

   303             PauseEffect( itemIndex );

   304             }

   305             break;

   306 

   307         case EHapticsTestChangeStateResume:

   308             {

   309             // get itemindex and resume effect

   310             TInt itemIndex = iMenuPane->SelectedItem();

   311             ResumeEffect( itemIndex );

   312             }

   313             break;

   314 

   315         case EHapticsTestChangeStateStop:

   316             {

   317             // get itemindex and stop effect

   318             TInt itemIndex = iMenuPane->SelectedItem();

   319             StopEffect( itemIndex );

   320             }

   321             break;

   322 

   323         case EHapticsTestChangeStateStopAll:

   324             {

   325             TInt err = iHaptics->StopAllPlayingEffects();

   326             if ( err )

   327                 {

   328                 TBuf<8> errBuf;

   329                 errBuf.AppendNum( err );

   330                 iAppView->InsertOutput( _L("Stopping all effects failed, err = "), EFalse );

   331                 iAppView->InsertOutput( errBuf );

   332                 }

   333             else

   334                 {

   335                 iAppView->InsertOutput( _L("Stopping all effects succeeded.") );

   336                 

   337                 // reset the auto-modification

   338                 iEffectData->ResetModifiableEffectTimer();

   339                 }

   340             }

   341             break;

   342 

   343         case EHapticsTestModifyEffect:

   344             {

   345             // nothing to do

   346             }

   347             break;

   348         case EHapticsTestModifyEffectDuration1:

   349             {

   350             iEffectData->SetDuration( KEffectDuration1 );

   351             ModifyEffect();

   352             }

   353             break;

   354         case EHapticsTestModifyEffectDuration5:

   355             {

   356             iEffectData->SetDuration( KEffectDuration5 );

   357             ModifyEffect();

   358             }

   359             break;

   360         case EHapticsTestModifyEffectDuration10:

   361             {

   362             iEffectData->SetDuration( KEffectDuration10 );

   363             ModifyEffect();

   364             }

   365             break;

   366         case EHapticsTestModifyEffectDuration30:

   367             {

   368             iEffectData->SetDuration( KEffectDuration30 );

   369             ModifyEffect();

   370             }

   371             break;

   372         case EHapticsTestModifyEffectDuration60:

   373             {

   374             iEffectData->SetDuration( KEffectDuration60 );

   375             ModifyEffect();

   376             }

   377             break;

   378         case EHapticsTestModifyEffectMagnitudeMin:

   379             {

   380             iEffectData->SetMagnitude( KHWRMHapticsMinMagnitude );

   381             ModifyEffect();

   382             }

   383             break;

   384         case EHapticsTestModifyEffectMagnitude25:

   385             {

   386             iEffectData->SetMagnitude( KEffectMagnitude25 );

   387             ModifyEffect();

   388             }

   389             break;

   390         case EHapticsTestModifyEffectMagnitude50:

   391             {

   392             iEffectData->SetMagnitude( KEffectMagnitude50 );

   393             ModifyEffect();

   394             }

   395             break;

   396         case EHapticsTestModifyEffectMagnitude75:

   397             {

   398             iEffectData->SetMagnitude( KEffectMagnitude75 );

   399             ModifyEffect();

   400             }

   401             break;

   402         case EHapticsTestModifyEffectMagnitudeMax:

   403             {

   404             iEffectData->SetMagnitude( KHWRMHapticsMaxMagnitude );

   405             ModifyEffect();

   406             }

   407             break;

   408         case EHapticsTestModifyEffectStyleSmooth:

   409             {

   410             iEffectData->SetStyle( CHWRMHaptics::EHWRMHapticsStyleSmooth );

   411             ModifyEffect();

   412             }

   413             break;

   414         case EHapticsTestModifyEffectStyleStrong:

   415             {

   416             iEffectData->SetStyle( CHWRMHaptics::EHWRMHapticsStyleStrong );

   417             ModifyEffect();

   418             }

   419             break;

   420         case EHapticsTestModifyEffectStyleSharp:

   421             {

   422             iEffectData->SetStyle( CHWRMHaptics::EHWRMHapticsStyleSharp );

   423             ModifyEffect();

   424             }

   425             break;

   426         case EHapticsTestModifyEffectAttackMin:

   427             {

   428             iEffectData->SetAttackLevel( KHWRMHapticsMinMagnitude );

   429             ModifyEffect();

   430             }

   431             break;

   432         case EHapticsTestModifyEffectAttack25:

   433             {

   434             iEffectData->SetAttackLevel( KEffectMagnitude25 );

   435             ModifyEffect();

   436             }

   437             break;

   438         case EHapticsTestModifyEffectAttack50:

   439             {

   440             iEffectData->SetAttackLevel( KEffectMagnitude50 );

   441             ModifyEffect();

   442             }

   443             break;

   444         case EHapticsTestModifyEffectAttack75:

   445             {

   446             iEffectData->SetAttackLevel( KEffectMagnitude75 );

   447             ModifyEffect();

   448             }

   449             break;

   450         case EHapticsTestModifyEffectAttackMax:

   451             {

   452             iEffectData->SetAttackLevel( KHWRMHapticsMaxMagnitude );

   453             ModifyEffect();

   454             }

   455             break;

   456         case EHapticsTestModifyEffectFadeMin:

   457             {

   458             iEffectData->SetFadeLevel( KHWRMHapticsMinMagnitude );

   459             ModifyEffect();

   460             }

   461             break;

   462         case EHapticsTestModifyEffectFade25:

   463             {

   464             iEffectData->SetFadeLevel( KEffectMagnitude25 );

   465             ModifyEffect();

   466             }

   467             break;

   468         case EHapticsTestModifyEffectFade50:

   469             {

   470             iEffectData->SetFadeLevel( KEffectMagnitude50 );

   471             ModifyEffect();

   472             }

   473             break;

   474         case EHapticsTestModifyEffectFade75:

   475             {

   476             iEffectData->SetFadeLevel( KEffectMagnitude75 );

   477             ModifyEffect();

   478             }

   479             break;

   480         case EHapticsTestModifyEffectFadeMax:

   481             {

   482             iEffectData->SetFadeLevel( KHWRMHapticsMaxMagnitude );

   483             ModifyEffect();

   484             }

   485             break;

   486         case EHapticsTestModifyEffectAttackTime02:

   487             {

   488             iEffectData->SetAttackTime( KEffectAttackTime02 );

   489             ModifyEffect();

   490             }

   491             break;

   492         case EHapticsTestModifyEffectAttackTime1:

   493             {

   494             iEffectData->SetAttackTime( KEffectAttackTime1 );

   495             ModifyEffect();

   496             }

   497             break;

   498         case EHapticsTestModifyEffectAttackTime5:

   499             {

   500             iEffectData->SetAttackTime( KEffectAttackTime5 );

   501             ModifyEffect();

   502             }

   503             break;

   504         case EHapticsTestModifyEffectAttackTime10:

   505             {

   506             iEffectData->SetAttackTime( KEffectAttackTime10 );

   507             ModifyEffect();

   508             }

   509             break;

   510         case EHapticsTestModifyEffectAttackTime30:

   511             {

   512             iEffectData->SetAttackTime( KEffectAttackTime30 );

   513             ModifyEffect();

   514             }

   515             break;

   516         case EHapticsTestModifyEffectAttackTime60:

   517             {

   518             iEffectData->SetAttackTime( KEffectAttackTime60 );

   519             ModifyEffect();

   520             }

   521             break;

   522         case EHapticsTestModifyEffectFadeTime02:

   523             {

   524             iEffectData->SetFadeTime( KEffectFadeTime02 );

   525             ModifyEffect();

   526             }

   527             break;

   528         case EHapticsTestModifyEffectFadeTime1:

   529             {

   530             iEffectData->SetFadeTime( KEffectFadeTime1 );

   531             ModifyEffect();

   532             }

   533             break;

   534         case EHapticsTestModifyEffectFadeTime5:

   535             {

   536             iEffectData->SetFadeTime( KEffectFadeTime5 );

   537             ModifyEffect();

   538             }

   539             break;

   540         case EHapticsTestModifyEffectFadeTime10:

   541             {

   542             iEffectData->SetFadeTime( KEffectFadeTime10 );

   543             ModifyEffect();

   544             }

   545             break;

   546         case EHapticsTestModifyEffectFadeTime30:

   547             {

   548             iEffectData->SetFadeTime( KEffectFadeTime30 );

   549             ModifyEffect();

   550             }

   551             break;

   552         case EHapticsTestModifyEffectFadeTime60:

   553             {

   554             iEffectData->SetFadeTime( KEffectFadeTime60 );

   555             ModifyEffect();

   556             }

   557             break;

   558         case EHapticsTestModifyEffectPeriod50:

   559             {

   560             iEffectData->SetPeriod( KEffectPeriod50 );

   561             ModifyEffect();

   562             }

   563             break;

   564         case EHapticsTestModifyEffectPeriod100:

   565             {

   566             iEffectData->SetPeriod( KEffectPeriod100 );

   567             ModifyEffect();

   568             }

   569             break;

   570         case EHapticsTestModifyEffectPeriod300:

   571             {

   572             iEffectData->SetPeriod( KEffectPeriod300 );

   573             ModifyEffect();

   574             }

   575             break;

   576         case EHapticsTestModifyEffectPeriod600:

   577             {

   578             iEffectData->SetPeriod( KEffectPeriod600 );

   579             ModifyEffect();

   580             }

   581             break;

   582         case EHapticsTestModifyEffectPeriod1000:

   583             {

   584             iEffectData->SetPeriod( KEffectPeriod1000 );

   585             ModifyEffect();

   586             }

   587             break;

   588         case EHapticsTestModifyEffectPeriod3000:

   589             {

   590             iEffectData->SetPeriod( KEffectPeriod3000 );

   591             ModifyEffect();

   592             }

   593             break;

   594         

   595         case EHapticsTestCloseHaptics:

   596             {

   597             CloseHaptics();

   598             }

   599             break;

   600 

   601         case EHapticsTestSynchronousCalls:

   602             {

   603             iSynchronous = ETrue;

   604             iAppView->InsertOutput( _L("Using synchronous methods.") );

   605             }

   606             break;

   607 

   608         case EHapticsTestAsynchronousCalls:

   609             {

   610             iSynchronous = EFalse;

   611             iAppView->InsertOutput( _L("Using asynchronous methods.") );

   612             }

   613             break;

   614 

   615         case EHapticsTestUsingFileHandle:

   616             {

   617             iUseHandle = ETrue;

   618             iAppView->InsertOutput( _L("Using file handle in play methods.") );

   619             }

   620             break;

   621 

   622         case EHapticsTestNotUsingFileHandle:

   623             {

   624             iUseHandle = EFalse;

   625             iAppView->InsertOutput( _L("Using data buffer in play methods.") );

   626             }

   627             break;

   628 

   629         case EHapticsTestShowEffectInfo:

   630             {

   631             iShowEffectInfo = ETrue;

   632             iAppView->InsertOutput( _L("Shows information of played effect.") );

   633             }

   634             break;

   635 

   636         case EHapticsTestHideEffectInfo:

   637             {

   638             iShowEffectInfo = EFalse;

   639             iAppView->InsertOutput( _L("Stops showing information of played effect.") );

   640             }

   641             break;

   642 

   643         case EHapticsTestDeleteIVTData:

   644         case EHapticsTestDeleteIVTDataNoneFound:

   645             {

   646             // nothing to do    

   647             }

   648             break;

   649 

   650         case EHapticsTestDeleteIVTDataSelected:

   651             {

   652             // delete selected loaded IVT file

   653             TInt index = iMenuPane->SelectedItem();

   654             DeleteLoadedIVTData( index );

   655             }

   656             break;

   657             

   658         case EHapticsTestDeleteAllIVTData:

   659             {

   660             // delete all loaded IVT files

   661             DeleteAllLoadedIVTData();    

   662             }

   663             break;

   664 

   665         case EHapticsTestReserve:

   666             {

   667             // nothing to do

   668             }

   669         case EHapticsTestReserveNotTrusted:

   670             {

   671             ReserveHaptics( iHaptics, EFalse );

   672             }

   673             break;

   674         case EHapticsTestReserveTrusted:

   675             {

   676             ReserveHaptics( iHaptics, ETrue );

   677             }

   678             break;

   679         case EHapticsTestReserveNotTrustedTemp:

   680             {

   681             // create the temp haptics client, if it does not exist

   682             if ( !iTempHaptics )

   683                 {

   684                 iTempHaptics = CHWRMHaptics::NewL( NULL, NULL );

   685                 }

   686 

   687             ReserveHaptics( iTempHaptics, EFalse );

   688             }

   689             break;

   690         case EHapticsTestRelease:

   691             {

   692             iHaptics->ReleaseHaptics();

   693             iAppView->InsertOutput( _L("Reservation released.") );

   694             }

   695             break;

   696         case EHapticsTestReleaseTemp:

   697             {

   698             if ( iTempHaptics )

   699                 {

   700                 iTempHaptics->ReleaseHaptics();

   701                 iAppView->InsertOutput( _L("Temp client's reservation released.") );

   702                 

   703                 delete iTempHaptics;

   704                 iTempHaptics = NULL;

   705                 }

   706             else

   707                 {

   708                 iAppView->InsertOutput( _L("Temp client not created/reserved.") );

   709                 }

   710             }

   711             break;

   712 

   713         case EHapticsTestConstGetters:

   714             {

   715             ConstGetters();

   716             }

   717             break;

   718 

   719         case EHapticsTestGetStatus:

   720             {

   721             // fetch haptics status, and print it

   722             MHWRMHapticsObserver::THWRMHapticsStatus status = 

   723                 iHaptics->HapticsStatus();

   724             

   725             if ( iTempHaptics )

   726                 {

   727                 iAppView->InsertOutput( _L("[Haptics client] - "), EFalse );

   728                 PrintStatusInfo( status );

   729                 

   730                 status = iTempHaptics->HapticsStatus();

   731                 iAppView->InsertOutput( _L("[Temporary client] - "), EFalse );

   732                 PrintStatusInfo( status );

   733                 }

   734             else

   735                 {

   736                 PrintStatusInfo( status );

   737                 }

   738             

   739             }

   740             break;

   741 

   742         case EHapticsTestSetPropertyPriorityMin:

   743             {

   744             SetPropertyPriorityMin();    

   745             }

   746             break;

   747 

   748         case EHapticsTestSetPropertyPriorityDefault:

   749             {

   750             SetPropertyPriorityDefault();    

   751             }

   752             break;

   753 

   754         case EHapticsTestSetPropertyPriorityMax:

   755             {

   756             SetPropertyPriorityMax();

   757             }

   758             break;

   759 

   760         case EHapticsTestSetPropertyDisableEffectsTrue:

   761             {

   762             SetPropertyDisableEffectsTrue();    

   763             }

   764             break;

   765 

   766         case EHapticsTestSetPropertyDisableEffectsFalse:

   767             {

   768             SetPropertyDisableEffectsFalse();    

   769             }

   770             break;

   771 

   772         case EHapticsTestSetPropertyStrengthMute:

   773             {

   774             SetPropertyStrengthMin();    

   775             }

   776             break;

   777 

   778         case EHapticsTestSetPropertyStrengthHalf:

   779             {

   780             SetPropertyStrengthMiddle();    

   781             }

   782             break;

   783 

   784         case EHapticsTestSetPropertyStrengthFull:

   785             {

   786             SetPropertyStrengthMax();    

   787             }

   788             break;

   789 

   790         case EHapticsTestGetPropertyPriority:

   791             {

   792             GetPropertyPriority();    

   793             }

   794             break;

   795 

   796         case EHapticsTestGetPropertyDisableEffects:

   797             {

   798             GetPropertyDisableEffects();    

   799             }

   800             break;

   801 

   802         case EHapticsTestGetPropertyStrength:

   803             {

   804             GetPropertyStrength();    

   805             }

   806             break;

   807 

   808 

   809         case EHapticsTestGetCapabilityDeviceCategory:

   810             {

   811             GetCapabilityDeviceCategory();    

   812             }

   813             break;

   814 

   815         case EHapticsTestGetCapabilityMaxNestedRepeats:

   816             {

   817             GetCapabilityMaxNestedRepeats();    

   818             }

   819             break;

   820 

   821 

   822         case EHapticsTestGetCapabilityNumActuators:

   823             {

   824             GetCapabilityNumActuators();    

   825             }

   826             break;

   827 

   828 

   829         case EHapticsTestGetCapabilityActuatorType:

   830             {

   831             GetCapabilityActuatorType();    

   832             }

   833             break;

   834 

   835 

   836         case EHapticsTestGetCapabilityNumEffectSlots:

   837             {

   838             GetCapabilityNumEffectSlots();    

   839             }

   840             break;

   841 

   842         case EHapticsTestGetCapabilityNumEffectStyles:

   843             {

   844             GetCapabilityNumEffectStyles();    

   845             }

   846             break;

   847 

   848         case EHapticsTestGetCapabilityMinPeriod:

   849             {

   850             GetCapabilityMinPeriod();    

   851             }

   852             break;

   853 

   854         case EHapticsTestGetCapabilityMaxPeriod:

   855             {

   856             GetCapabilityMaxPeriod();    

   857             }

   858             break;

   859 

   860         case EHapticsTestGetCapabilityMaxEffectDuration:

   861             {

   862             GetCapabilityMaxEffectDuration();    

   863             }

   864             break;

   865 

   866         case EHapticsTestGetCapabilitySupportedEffects:

   867             {

   868             GetCapabilitySupportedEffects();    

   869             }

   870             break;

   871 

   872         case EHapticsTestGetCapabilityDeviceName:

   873             {

   874             GetCapabilityDeviceName();    

   875             }

   876             break;

   877 

   878         case EHapticsTestGetCapabilityMaxEnvelopeTime:

   879             {

   880             GetCapabilityMaxEnvelopeTime();    

   881             }

   882             break;

   883 

   884         case EHapticsTestGetCapabilityAPIVersionNumber:

   885             {

   886             GetCapabilityAPIVersionNumber();    

   887             }

   888             break;

   889 

   890         case EHapticsTestGetCapabilityMaxIVTSize:

   891             {

   892             GetCapabilityMaxIVTSize();    

   893             }

   894             break;

   895 

   896         case EHapticsTestClearOutput:

   897             {

   898             iAppView->ClearOutput();

   899             }

   900             break;

   901 

   902         case EHapticsTestStreaming:

   903             {

   904             StartStreaming();

   905             }

   906             break;

   907 

   908         case EHapticsTestPlayStreamSample:

   909         case EHapticsTestNextStreamSample:

   910             {

   911             PlayStreamingSample( iCurrentSample );

   912             iCurrentSample >= KSampleCount ? iCurrentSample = 0 : iCurrentSample++;

   913             }

   914             break;

   915 

   916         case EHapticsTestPlayAllSamples:

   917             {

   918             for ( TInt n = 0; n < 8; n++ )

   919                 {

   920                 PlayStreamingSample( n );                

   921                 User::After( 300000 );

   922                 }

   923             }

   924             break;

   925 

   926         case EHapticsTestStopStreaming:

   927             {

   928             StopStreaming();

   929             }

   930             break;

   931 

   932         case EHapticsTestPanic:

   933         default:

   934             Panic( EHapticsTestBasicUi );

   935             break;

   936         }

   937     }

   938 

   939 // ---------------------------------------------------------

   940 // Manages the options menu contents based on user actions and data.

   941 // ---------------------------------------------------------

   942 //

   943 void CHapticsTestAppUi::DynInitMenuPaneL( TInt aResourceId, 

   944                                           CEikMenuPane* aMenuPane )

   945     {

   946     CAknAppUi::DynInitMenuPaneL( aResourceId, aMenuPane );

   947 

   948     // store menupane to be used in HandleCommandL()

   949     iMenuPane = aMenuPane;

   950 

   951     if ( aResourceId == R_HAPTICSTEST_MENU )

   952         {

   953         if ( !iHaptics )

   954             {

   955             // haptics client not created, hide commands using it

   956             aMenuPane->SetItemDimmed( EHapticsTestReserve, ETrue );

   957             aMenuPane->SetItemDimmed( EHapticsTestConstGetters, ETrue );

   958             aMenuPane->SetItemDimmed( EHapticsTestGetStatus, ETrue );

   959             }

   960         if ( !iActuatorOpened )

   961             {

   962             // Actuator has not been opened yet, hide ivt-file loading

   963             // submenu and general play-submenu

   964             aMenuPane->SetItemDimmed( EHapticsTestGeneralPlayEffect, ETrue );

   965             aMenuPane->SetItemDimmed( EHapticsTestLoadIVTFile, ETrue );

   966             aMenuPane->SetItemDimmed( EHapticsTestPropertiesSubmenu, ETrue );

   967             aMenuPane->SetItemDimmed( EHapticsTestCapabilitiesSubmenu, ETrue );

   968             aMenuPane->SetItemDimmed( EHapticsTestStreaming, ETrue );

   969             }

   970         if ( 0 == iLoadedIVTFileArray.Count() )

   971             {

   972             // also hide the deleteIVT data related menu items

   973             aMenuPane->SetItemDimmed( EHapticsTestDeleteIVTData, ETrue );

   974             aMenuPane->SetItemDimmed( EHapticsTestDeleteAllIVTData, ETrue );

   975             }

   976         if ( !iEffectData->Count() )

   977             {

   978             // hide the pause/resume/stop submenu

   979             aMenuPane->SetItemDimmed( EHapticsTestChangeState, ETrue );

   980             }

   981         if ( !iEffectData->ModifiableEffectExists() )

   982             {

   983             aMenuPane->SetItemDimmed( EHapticsTestModifyEffect, ETrue );

   984             }

   985         if ( iStreaming )

   986             {

   987             aMenuPane->SetItemDimmed( EHapticsTestStreaming, ETrue );

   988             aMenuPane->SetItemDimmed( EHapticsTestReserve, ETrue );

   989             aMenuPane->SetItemDimmed( EHapticsTestLoadIVTFile, ETrue );

   990             aMenuPane->SetItemDimmed( EHapticsTestGeneralPlayEffect, ETrue );

   991             aMenuPane->SetItemDimmed( EHapticsTestChangeState, ETrue );

   992             aMenuPane->SetItemDimmed( EHapticsTestModifyEffect, ETrue );

   993             aMenuPane->SetItemDimmed( EHapticsTestDeleteIVTData, ETrue );

   994             aMenuPane->SetItemDimmed( EHapticsTestPropertiesSubmenu, ETrue );

   995             aMenuPane->SetItemDimmed( EHapticsTestCapabilitiesSubmenu, ETrue );

   996             aMenuPane->SetItemDimmed( EHapticsTestDeleteAllIVTData, ETrue );

   997             aMenuPane->SetItemDimmed( EHapticsTestGetStatus, ETrue );

   998             aMenuPane->SetItemDimmed( EHapticsTestConstGetters, ETrue );

   999             aMenuPane->SetItemDimmed( EHapticsTestClearOutput, ETrue );

  1000             aMenuPane->SetItemDimmed( EHapticsTestPanic, ETrue );

  1001             aMenuPane->SetItemDimmed( EHapticsTestInit, ETrue );

  1002             aMenuPane->SetItemDimmed( EHapticsToggle, ETrue );

  1003             aMenuPane->SetItemDimmed( EAknSoftkeyExit, ETrue );

  1004             aMenuPane->SetItemDimmed( EHapticsTestPlayStreamSample, iCurrentSample );

  1005             aMenuPane->SetItemDimmed( EHapticsTestNextStreamSample, !iCurrentSample );

  1006             }

  1007         else

  1008             {

  1009             aMenuPane->SetItemDimmed( EHapticsTestPlayAllSamples, ETrue );

  1010             aMenuPane->SetItemDimmed( EHapticsTestPlayStreamSample, ETrue );

  1011             aMenuPane->SetItemDimmed( EHapticsTestNextStreamSample, ETrue );

  1012             aMenuPane->SetItemDimmed( EHapticsTestStopStreaming, ETrue );

  1013             }

  1014         }

  1015     else if ( aResourceId == R_HAPTICSTEST_INIT_SUBMENU )

  1016         {

  1017         if ( !iHaptics )

  1018             {

  1019             // haptics client not created, hide commands using it

  1020             aMenuPane->SetItemDimmed( EHapticsTestSupportedActuators, ETrue );

  1021             aMenuPane->SetItemDimmed( EHapticsTestOpenActuator, ETrue );

  1022             }

  1023         if ( !iSupportedActuators )

  1024             {

  1025             // either there are no supported actuators, or they have not

  1026             // been fethed yet --> hide actuator opening submenu

  1027             aMenuPane->SetItemDimmed( EHapticsTestOpenActuator, ETrue );

  1028             }

  1029         }

  1030     else if ( aResourceId == R_HAPTICSTEST_GENERALPLAY_SUBMENU )

  1031         {

  1032         if ( !iActuatorOpened )

  1033             {

  1034             // Actuator has not been opened yet, hide the manual effect

  1035             // play submenu

  1036             aMenuPane->SetItemDimmed( EHapticsTestPlayEffectManual, ETrue );

  1037             }

  1038         if ( 0 == iLoadedIVTFileArray.Count() )

  1039             {

  1040             // IVT-data has not been loaded, hide the effect submenu

  1041             aMenuPane->SetItemDimmed( EHapticsTestPlayEffect, ETrue );

  1042             aMenuPane->SetItemDimmed( EHapticsTestPlayEffectRepeat, ETrue );

  1043             }

  1044         }

  1045     else if ( aResourceId == R_HAPTICSTEST_TOGGLE_SUBMENU )

  1046         {

  1047         if ( iSynchronous )

  1048             {

  1049             // synchronous calls in ON, hide synchronous call selection

  1050             aMenuPane->SetItemDimmed( EHapticsTestSynchronousCalls, ETrue );

  1051             }

  1052         else

  1053             {

  1054             // asynchronous calls in ON, hide asynchronous call selection

  1055             aMenuPane->SetItemDimmed( EHapticsTestAsynchronousCalls, ETrue );

  1056             }

  1057         if ( iUseHandle )

  1058             {

  1059             aMenuPane->SetItemDimmed( EHapticsTestUsingFileHandle, ETrue );

  1060             if ( iShowEffectInfo )

  1061                 {

  1062                 aMenuPane->SetItemDimmed( EHapticsTestShowEffectInfo, ETrue );

  1063                 }

  1064             else

  1065                 {

  1066                 aMenuPane->SetItemDimmed( EHapticsTestHideEffectInfo, ETrue );

  1067                 }

  1068             }

  1069         else

  1070             {

  1071             aMenuPane->SetItemDimmed( EHapticsTestNotUsingFileHandle, ETrue );

  1072             aMenuPane->SetItemDimmed( EHapticsTestShowEffectInfo, ETrue );

  1073             aMenuPane->SetItemDimmed( EHapticsTestHideEffectInfo, ETrue );

  1074             }    

  1075         }

  1076     else if ( aResourceId == R_HAPTICSTEST_ACTUATORS_SUBMENU )

  1077         {

  1078         if ( !(EHWRMLogicalActuatorAny & iSupportedActuators) )

  1079             {

  1080             aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorAny, ETrue );

  1081             }

  1082         if ( !(EHWRMLogicalActuatorDevice & iSupportedActuators) )

  1083             {

  1084             aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorDevice, ETrue );

  1085             }

  1086         if ( !(EHWRMLogicalActuatorPrimaryDisplay & iSupportedActuators) )

  1087             {

  1088             aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorPrimaryDisplay, ETrue );

  1089             }

  1090         if ( !(EHWRMLogicalActuatorSecondaryDisplay & iSupportedActuators) )

  1091             {

  1092             aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorSecondaryDisplay, ETrue );

  1093             }

  1094         if ( !(EHWRMLogicalActuatorGame & iSupportedActuators) )

  1095             {

  1096             aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorGame, ETrue );

  1097             }

  1098         if ( !(EHWRMLogicalActuatorGameLeft & iSupportedActuators) )

  1099             {

  1100             aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorGameLeft, ETrue );

  1101             }

  1102         if ( !(EHWRMLogicalActuatorGameRight & iSupportedActuators) )

  1103             {

  1104             aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorGameRight, ETrue );

  1105             }

  1106         if ( !(EHWRMLogicalActuatorExternalVibra & iSupportedActuators) )

  1107             {

  1108             aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorExternalVibra, ETrue );

  1109             }

  1110         }

  1111     else if ( aResourceId == R_HAPTICSTEST_IVTFILES_SUBMENU )

  1112         {

  1113         if ( iIVTFileArray.Count() )

  1114             {

  1115             // ivt-files present, hide the "no files" -item

  1116             aMenuPane->SetItemDimmed( EHapticsTestLoadIVTFileNoneFound, ETrue );

  1117             

  1118             // make file names visible in the submenu

  1119             CEikMenuPaneItem::SData data;

  1120             for ( TInt i = 0; i < iIVTFileArray.Count(); ++i )

  1121                 {

  1122                 data.iText.Copy( iIVTFileArray[i] );

  1123                 data.iCommandId = EHapticsTestLoadIVTFileSelected;

  1124                 data.iCascadeId = 0;

  1125                 data.iFlags = 0;

  1126                 data.iExtraText = KNullDesC;

  1127                 

  1128                 aMenuPane->AddMenuItemL( data );

  1129                 }

  1130             }

  1131         }

  1132     else if ( aResourceId == R_HAPTICSTEST_PLAYEFFECT_SUBMENU )

  1133         {

  1134         CreatePlayEffectSubmenuL( aMenuPane, 

  1135                                   EHapticsTestPlayEffectSelected,