1 /*

     2 * Copyright (c) 2009 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:  Implementation for finger hwr UiLayout

    15 *

    16 */

    17 

    18 

    19 //SYSTEM INCLUDES

    20 #include <bautils.h>

    21 #include <coemain.h>

    22 

    23 //FEP Includes

    24 #include <aknfepglobalenums.h>

    25 #include <aknfeppeninputenums.h>

    26 #include <peninputlayoutchoicelist.h>

    27 #include <SettingsInternalCRKeys.h>

    28 #include <centralrepository.h>

    29 #include <peninputlayoutvkb.h>

    30 #include <AknFepGlobalEnums.h>

    31 #include <peninputcmdparam.h>

    32 #include <peninputdropdownlist.h>

    33 #include <peninputlayoutmultilineicf.h>

    34 

    35 //USER INCLUDES

    36 #include "peninputfingerhwrdatastore.h"

    37 #include "peninputfingerhwrstatemanager.h"

    38 #include "peninputfingerhwrevent.h"

    39 #include "peninputfingerhwrlayout.h"

    40 #include "peninputfingerhwrcontrolid.h"

    41 

    42 #include "peninputfingerhwrwnd.h"

    43 #include "peninputfingerhwrcn.rsg"

    44 

    45 //CONST DEFINATION

    46 _LIT( KFSHWRRssFile, "\\resource\\peninputfingerhwrcn.rsc" );

    47 

    48 const TUint8 KTempBufSize = 8;

    49 const TUint8 KIntLen = sizeof(TInt)/2;

    50 const TUint8 KIntSize = sizeof(TInt);

    51 

    52 const TInt16 KEmotionKeyMark = 0xFFFE;

    53 

    54 // ============================ MEMBER FUNCTIONS =============================

    55 

    56 // ---------------------------------------------------------------------------

    57 // Symbian Constructor

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

    59 //

    60 CPeninputFingerHwrLayout* CPeninputFingerHwrLayout::NewL( 

    61     MLayoutOwner* aLayoutOwner, const TAny* aInitData )

    62     {

    63     CPeninputFingerHwrLayout* self = new( ELeave ) CPeninputFingerHwrLayout( 

    64             aLayoutOwner );

    65     

    66     CleanupStack::PushL( self );

    67     self->ConstructL( aInitData );

    68     CleanupStack::Pop( self ); //self

    69     return self;

    70     }

    71 

    72 // ---------------------------------------------------------------------------

    73 // handle the command from Fep.

    74 // ---------------------------------------------------------------------------

    75 //

    76 TInt CPeninputFingerHwrLayout::HandleCommand( const TInt aCmd, TUint8* aData )

    77     {

    78     TInt ret = KErrUnknown;

    79     TRAPD(err, ret = HandleCommandL( aCmd, aData ) );

    80     if ( err )

    81         {

    82         return KErrUnknown;

    83         }

    84     else

    85         {

    86         return ret;

    87         }

    88     }

    89 

    90 // ---------------------------------------------------------------------------

    91 // handle the command from Fep.

    92 // ---------------------------------------------------------------------------

    93 //

    94 TInt CPeninputFingerHwrLayout::HandleCommandL( const TInt aCmd, TUint8* aData )

    95     {

    96     if ( CFepUiLayout::HandleCommand( aCmd, aData ) == KErrNone )

    97         {

    98         return KErrNone;

    99         }

   100 

   101     TInt ret = KErrUnknown;

   102     switch ( aCmd )

   103         {

   104         case ECmdPenInputEditorNumericKeyMap:

   105             {

   106             iDataStore->SetNumberMode( *(TAknEditorNumericKeymap*)aData );

   107             OnNumMappingChangedL();

   108             ret = KErrNone;

   109             }

   110             break;

   111         case ECmdPenInputEditorCustomNumericKeyMap:

   112             {

   113             TInt len = *( TInt* )( aData - KIntSize );

   114             TPtrC16 keymapRes( (TUint16*)aData, len / 2 );

   115             iDataStore->SetCustomNumberModeL( keymapRes );

   116             OnNumMappingChangedL();

   117             ret = KErrNone;

   118             }

   119             break;

   120         case ECmdPenInputPermittedRange:

   121             {

   122             TInt ranges = *(TInt*)aData;

   123             iDataStore->SetPermittedRanges( ranges );

   124             iHwrWnd->SetPermittedRanges( ranges );

   125             ret = KErrNone;

   126             }

   127             break;

   128         case ECmdPenInputLanguage:

   129             {

   130             TInt language = *( TInt* )aData;

   131             iDataStore->SetLanguageL( language );

   132             iHwrWnd->SetInputLanguage( language );

   133 

   134             ret = KErrNone;

   135             }

   136             break;

   137         case ECmdPenInputRange:

   138             {

   139             TInt range = *( TInt* )aData;

   140             iDataStore->SetPrimaryRange( range );

   141             range = iDataStore->CurrentRange();

   142             iHwrWnd->TryToChangeCharRange( range );

   143 

   144             TBuf<KIntLen> buf;

   145             buf.Append( reinterpret_cast<TText*>( aData ), KIntLen );

   146 

   147             SignalOwner( ESignalRange, buf );

   148 

   149             ret = KErrNone;

   150             }

   151             break;

   152         case ECmdPenInputPermittedCase:

   153             {

   154             TInt cs = *( TInt* )aData;

   155             iDataStore->SetPermittedCases( cs );

   156             ret = KErrNone;

   157             }

   158             break;

   159         case ECmdPenInputCase:

   160             {

   161             TInt cs = *( TInt* )aData;

   162             iDataStore->SetCase( cs );

   163             ret = KErrNone;

   164             }

   165             break;

   166         case ECmdPenInputWindowOpen:

   167             {

   168             LayoutOwner()->Hide( EFalse );

   169             RootControl()->UpdateValidRegion( NULL, EFalse );

   170 

   171             TRect hwrRect = iHwrWnd->WritingBoxRect();

   172             TSize hwrSize = hwrRect.Size();

   173             iDataStore->SetInputAreaSize(hwrSize);

   174             iDataStore->SetScreenSize(hwrSize);

   175             ChangeCurStateManagerToStandby();

   176             

   177             if( !iIsOpenFingerHWR )

   178                 {

   179                 iDataStore->GetKeyboardType();

   180                 iDataStore->SetKeyboardToQwerty();

   181                 }

   182                 

   183             iIsOpenFingerHWR = ETrue;

   184             ret = KErrNone;

   185             }

   186             break;

   187         case ECmdPenInputWindowClose:

   188             {

   189             iIsOpenFingerHWR = EFalse;

   190             

   191             iDataStore->ResetKeyboardType();

   192             LayoutOwner()->Hide( ETrue );

   193             ret = KErrNone;

   194             }

   195             break;

   196         case ECmdPenInputSetTextAlignment:

   197             {

   198             iHwrWnd->SetTextAlignmentL( *aData, ELangPrcChinese );

   199             ret = KErrNone;            

   200             }

   201             break;

   202         case ECmdPenInputSetPromptText:

   203             {

   204             iHwrWnd->SetPromptTextL( aData );

   205             ret = KErrNone;

   206             }

   207             break;

   208         case ECmdPenInputDimArrowKeys:

   209             {

   210             TBool IsDimArrowKeys = *aData;

   211             iHwrWnd->DimArrowKeys( IsDimArrowKeys );

   212             ret = KErrNone;

   213             }

   214             break;

   215         case ECmdPenInputCharacterPreview:

   216             {

   217             iHwrWnd->ShowBubble(*aData);    

   218             }

   219             break;

   220         case ECmdPenInputEnableSettingBtn:    

   221             {

   222             TBool isEnableSetting = *aData;

   223             iHwrWnd->SetEnableSettingBtn(isEnableSetting);

   224             }

   225             break;  

   226         default:

   227             break;

   228         }

   229 

   230     return ret;

   231     }

   232 

   233 // ---------------------------------------------------------------------------

   234 // handle size changing event.

   235 // ---------------------------------------------------------------------------

   236 //

   237 TInt CPeninputFingerHwrLayout::SizeChanged( const TAny* /*pData*/ )

   238     {

   239     //Handle size change event

   240     SetRect( TRect( TPoint( 0, 0 ), ScreenSize() ) );

   241     

   242     TRAP_IGNORE( iHwrWnd->SizeChangedL( EFalse ) );

   243 

   244     return KErrNone;

   245     }

   246 

   247 // ---------------------------------------------------------------------------

   248 // Handle editor text coming.

   249 // ---------------------------------------------------------------------------

   250 //

   251 TInt CPeninputFingerHwrLayout::OnAppEditorTextComing( 

   252     const TFepInputContextFieldData& aData )

   253     {

   254     if ( iHwrWnd )

   255         {

   256         TRAPD( err, iHwrWnd->SetEditorTextL( aData ) );

   257         return err;

   258         }

   259 

   260     return KErrNone;

   261     }

   262 

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

   264 // Handle application info change.

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

   266 //

   267 void CPeninputFingerHwrLayout::HandleAppInfoChange( const TDesC& aInfo,

   268     TPeninputAppInfo aType )

   269     {

   270     if ( aType == EAppIndicatorMsg )

   271         {

   272         TRAP_IGNORE( iHwrWnd->SetBubbleTextL( aInfo ) );

   273         }

   274     }

   275 

   276 // ---------------------------------------------------------------------------

   277 // Called by owner when the system resource changed event.

   278 // ---------------------------------------------------------------------------

   279 //

   280 TInt CPeninputFingerHwrLayout::OnResourceChange( TInt aType )

   281     {

   282     CFepUiLayout::OnResourceChange( aType );

   283     if ( aType == KAknsMessageSkinChange )

   284         {

   285         //Do other things when skin change

   286         TInt newValue = GetPenTrailColor();

   287 	    SetBoxPenColor(newValue);        

   288         }

   289     return KErrNone;

   290     }

   291 

   292 // ---------------------------------------------------------------------------

   293 // get the peninput ui type.

   294 // ---------------------------------------------------------------------------

   295 //

   296 TInt CPeninputFingerHwrLayout::PenInputType()

   297     {

   298     return EPluginInputModeFingerHwr;

   299     }

   300 

   301 // ---------------------------------------------------------------------------

   302 // Called by owner when the layout is going to be hidden.

   303 // ---------------------------------------------------------------------------

   304 //

   305 void CPeninputFingerHwrLayout::OnDeActivate()

   306     {

   307     iIsOpenFingerHWR = EFalse;

   308     iDataStore->ResetKeyboardType();

   309     

   310     //cancel writing

   311     iHwrWnd->CancelWriting();

   312     

   313     // Bring the expandable dropdown list back to right level

   314     iHwrWnd->PredictiveList()->BringToBack();

   315     

   316     //cancel range selector

   317     if ( iHwrWnd->RangeDropListVisible() )

   318         {

   319         iHwrWnd->CancelRangeDropList();

   320         }

   321     

   322     if(iHwrWnd->CurrentCharRange() != EFingerHwrSymbolRange)

   323         {

   324         iHwrWnd->UpdateLayout( ETrue );

   325         }

   326     

   327     CFepUiLayout::OnDeActivate();

   328     }

   329 

   330 // ---------------------------------------------------------------------------

   331 // handle control event.

   332 // ---------------------------------------------------------------------------

   333 //

   334 void CPeninputFingerHwrLayout::HandleControlEvent( TInt aEventType,

   335     CFepUiBaseCtrl* aCtrl, const TDesC& aEventData )

   336     {

   337     TRAP_IGNORE( HandleControlEventL( aEventType, aCtrl, aEventData ) );

   338     }

   339 

   340 // ---------------------------------------------------------------------------

   341 // handle control event.

   342 // ---------------------------------------------------------------------------

   343 //

   344 void CPeninputFingerHwrLayout::HandleControlEventL( TInt aEventType,

   345     CFepUiBaseCtrl* aCtrl, const TDesC& aEventData )

   346     {

   347     switch ( aEventType )

   348         {

   349         case EEventButtonDown:

   350             {

   351             OnCtrlButtonDownL( aEventType, aCtrl, aEventData );

   352             }

   353             break;

   354         case EEventButtonUp:

   355             {

   356             OnCtrlButtonUpL( aEventType, aCtrl, aEventData );

   357             }

   358             break;

   359         case EEventChoiceSelected:

   360             {

   361             OnImeSelected( aEventType, aCtrl, aEventData );

   362             }

   363             break;

   364 

   365         case EEventHwrCharacterTimerOut:

   366             {

   367             OnHwrCharacterFinishedL();

   368             }

   369             break;

   370         case EEventHwrStrokeStarted:

   371             {

   372             OnHwrStrokeStartedL();

   373             }

   374             break;

   375         case EEventHwrStrokeFinished:

   376             {

   377             OnHwrStrokeFinishedL();

   378             }

   379             break;

   380         case EHwrEventKeyBack:

   381             {

   382             OnBackspaceClickedL();

   383             }

   384             break;

   385         case EHwrEventNavKeyClicked:

   386             {

   387             OnRepButtonClickedL( aCtrl, aEventData );

   388             }

   389             break;

   390         case EEventVirtualKeyDown:

   391             {

   392             OnVirtualKeyDownL( aCtrl, aEventData );

   393             }

   394             break;

   395         case EEventVirtualKeyUp:

   396             {

   397             OnVirtualKeyUpL( aCtrl, aEventData );

   398             }

   399             break;

   400         case EHwrEventCandidateSelected:

   401             {

   402             OnCandidateSelectedL( aCtrl, aEventData );

   403             }

   404             break;

   405         case EHwrEventPredictiveSelected:

   406             {

   407             OnPredictSelectedL( aCtrl, aEventData );

   408             }

   409             break;

   410         case EHwrEventGetNextCandidatePage:

   411             {

   412             OnCandidateWndEventL();

   413             }

   414             break;

   415         case EEventIcfPointerUpEvent:

   416             {

   417             OnIcfClicked();

   418             }

   419             break;

   420         default:

   421             break;

   422         }

   423     }

   424 

   425 // ---------------------------------------------------------------------------

   426 // Get the data stroe object.

   427 // ---------------------------------------------------------------------------

   428 //

   429 CPeninputFingerHwrDataStore& CPeninputFingerHwrLayout::DataStore()

   430     {

   431     return *iDataStore;

   432     }

   433 

   434 // ---------------------------------------------------------------------------

   435 // Delete the previous charcode and submit the new one

   436 // ---------------------------------------------------------------------------

   437 //

   438 void CPeninputFingerHwrLayout::Replace( const TDesC& aOldCharCode,

   439     const TDesC& aNewCharCode, const TBool aIsPart )

   440     {

   441     // user tries to correct the previous selection

   442     // Delete the previous character and append the new one

   443     HBufC* newCharBuf = HBufC::New( aNewCharCode.Length() + KIntLen );

   444     if ( newCharBuf )

   445         {

   446         TInt len = aOldCharCode.Length();

   447         if(len == 0 )

   448             {

   449             delete newCharBuf;

   450             return;

   451             }

   452             

   453         newCharBuf->Des().Append( ( TUint16* )&len, KIntLen );

   454         newCharBuf->Des().Append( aNewCharCode );

   455         if ( aIsPart )

   456             {

   457             SignalOwner( ESignalReplacePartText, *newCharBuf );

   458             }

   459         else

   460             {

   461             SignalOwner( ESignalReplaceText, *newCharBuf );

   462             }

   463         delete newCharBuf;

   464         }

   465     }

   466 

   467 // ---------------------------------------------------------------------------

   468 // Submit string to layout owner.

   469 // ---------------------------------------------------------------------------

   470 //

   471 void CPeninputFingerHwrLayout::SubmitStringToFep( const TDesC& aCharCode )

   472     {

   473     SignalOwner( ESignalKeyEvent, aCharCode );

   474     }

   475 

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

   477 // Submit char to layout owner.

   478 // ---------------------------------------------------------------------------

   479 //

   480 void CPeninputFingerHwrLayout::SubmitCharToFep( const TInt aCharCode )

   481     {

   482     TBuf<1> buf;

   483     buf.Append( aCharCode );

   484     SignalOwner( ESignalKeyEvent, buf );

   485     }

   486 

   487 #ifdef RD_INTELLIGENT_TEXT_INPUT

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

   489 // Submit start position to layout owner.

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

   491 //

   492 void CPeninputFingerHwrLayout::SubmitStartPosToFep( TBool aSetPosFlag )

   493     {

   494     TBuf<4> buf;

   495     TInt length = sizeof(TBool)/sizeof(TText);

   496     buf.Append( reinterpret_cast<TText*>( &aSetPosFlag ), length );

   497     SignalOwner( ESignalCharacterStart, buf );

   498     }

   499 #endif 

   500 

   501 // ---------------------------------------------------------------------------

   502 // repository callback for settings.

   503 // ---------------------------------------------------------------------------

   504 //

   505 TInt CPeninputFingerHwrLayout::HandleGSRepositoryCallBack( TAny* aPtr )

   506     {

   507     CPeninputFingerHwrLayout *self = static_cast<CPeninputFingerHwrLayout*>( aPtr );

   508 

   509     CAknFepRepositoryWatcher* watcher = self->iGSRepositoryWatcher;

   510     if ( watcher )

   511         {

   512         TInt newValue = self->GetNewValue( watcher, watcher->ChangedKey() );

   513 

   514         switch ( watcher->ChangedKey() )

   515             {

   516             case KSettingsWritingSpeed:

   517                 {

   518                 self->SetWritingSpeed( newValue );

   519                 }

   520                 break;

   521             case KSettingsPenWidth:

   522                 {

   523                 self->SetBoxPenSize( TSize( newValue, newValue ) );

   524                 }

   525                 break;

   526             case KSettingsPenColor:

   527                 {

   528                 self->SetBoxPenColor( newValue );

   529                 }

   530                 break;

   531             default:

   532                 break;

   533             }

   534         }

   535     return KErrNone;

   536     }

   537 

   538 // ---------------------------------------------------------------------------

   539 // load default settings.

   540 // ---------------------------------------------------------------------------

   541 //

   542 void CPeninputFingerHwrLayout::LoadAndPublishDefaultL()

   543     {

   544     if(!iRepositorySetting)

   545         {

   546         return;

   547         }

   548 

   549     TInt newValue;

   550 

   551     iRepositorySetting->Get( KSettingsWritingSpeed, newValue );

   552     SetWritingSpeed( newValue );

   553 

   554     iRepositorySetting->Get( KSettingsPenWidth, newValue );

   555     SetBoxPenSize( TSize( newValue, newValue ) );

   556 

   557     newValue = GetPenTrailColor();

   558     SetBoxPenColor( newValue );

   559 

   560     iRepositorySetting->Get( KSettingsPenInputLang, newValue );

   561     iDataStore->SetLanguageL( newValue );

   562 

   563     }

   564 

   565 // ---------------------------------------------------------------------------

   566 // 

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

   568 //

   569 void CPeninputFingerHwrLayout::SyncHwrStrokeEndMark( const TPoint&  aEndMark )

   570     {

   571     iHwrWnd->SetStrokeEndMark( aEndMark );

   572     }

   573 

   574 #ifndef RD_INTELLIGENT_TEXT_INPUT

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

   576 // hide or show fixed english symbol list.

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

   578 //

   579 void CPeninputFingerHwrLayout::HideTwoRowEngSymbolList( const TBool aIsHide )

   580     {

   581     iHwrWnd->HideTwoRowEngSymbolList( aIsHide );

   582     }

   583 #endif // RD_INTELLIGENT_TEXT_INPUT   

   584 

   585 // private

   586 

   587 // ---------------------------------------------------------------------------

   588 // c++ constructor

   589 // ---------------------------------------------------------------------------

   590 //

   591 CPeninputFingerHwrLayout::CPeninputFingerHwrLayout( MLayoutOwner* aLayoutOwner ) 

   592     : CFepUiLayout( aLayoutOwner ), iLastOverlapIdx(KInvalidIndex)

   593     {

   594     }

   595 

   596 // ---------------------------------------------------------------------------

   597 // c++ destructor

   598 // ---------------------------------------------------------------------------

   599 //

   600 CPeninputFingerHwrLayout::~CPeninputFingerHwrLayout()

   601     {

   602     CCoeEnv::Static()->DeleteResourceFile( iResId );

   603 

   604     delete iDataStore;

   605     iStateMgrArray.ResetAndDestroy();

   606     iStateMgrArray.Close();

   607 

   608     delete iGSRepositoryWatcher;

   609     delete iRepositorySetting;

   610     }

   611 

   612 // ---------------------------------------------------------------------------

   613 // Symbian second-phase constructor

   614 // ---------------------------------------------------------------------------

   615 //   

   616 void CPeninputFingerHwrLayout::ConstructL( const TAny* aInitData )

   617     {

   618     BaseConstructL();

   619     //load resource

   620     TFileName resFileName( KFSHWRRssFile );

   621     CCoeEnv* coeEnv = CCoeEnv::Static();

   622     BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resFileName );

   623     iResId = coeEnv->AddResourceFileL( resFileName );

   624 

   625     //initialze the data store

   626     TPeninputLayoutData* layoutData = ( TPeninputLayoutData* )aInitData;

   627 

   628     iDataStore = CPeninputFingerHwrDataStore::NewL( (*layoutData).iPtiEngine, this );

   629 

   630     //create the repository for gereral settings

   631     iRepositorySetting = CRepository::NewL( KCRUidPersonalizationSettings );

   632 

   633     //create the repository watcher for general settings

   634     iGSRepositoryWatcher = CAknFepRepositoryWatcher::NewL( 

   635             KCRUidPersonalizationSettings, 

   636             TCallBack( HandleGSRepositoryCallBack, this ), 

   637             iRepositorySetting );

   638 

   639     //create state manager   

   640     CreateStateManagerL();

   641 

   642     CreateHwrWindowL();

   643 

   644     LoadAndPublishDefaultL();

   645     //set screen layout extent

   646     SetRect( TRect( TPoint( 0, 0 ), ScreenSize() ) );

   647     }

   648 

   649 // ---------------------------------------------------------------------------

   650 // Create the hwr box window.

   651 // ---------------------------------------------------------------------------

   652 // 

   653 void CPeninputFingerHwrLayout::CreateHwrWindowL()

   654     {

   655     iHwrWnd = CPeninputFingerHwrWnd::NewL( this, EHwrCtrlIdHwrWindow, EFalse );

   656 

   657     iHwrWnd->SetResourceId( R_FINGERHWR_WINDOW );

   658     iHwrWnd->ConstructFromResourceL();

   659     

   660     iHwrWnd->SetStrokeEndMark( iDataStore->StrokeEndMark() );

   661 

   662     AddControlL( iHwrWnd, EFalse );

   663     }

   664 

   665 // ---------------------------------------------------------------------------

   666 // Create the state manager.

   667 // ---------------------------------------------------------------------------

   668 // 

   669 void CPeninputFingerHwrLayout::CreateStateManagerL()

   670     {

   671     iStateMgrArray.AppendL( CPeninputFingerHwrStateManagerCn::NewL( this ) );

   672     iStateMgrArray.AppendL( CPeninputFingerHwrStateManagerEn::NewL( this ) );

   673     iStateMgrArray.AppendL( CPeninputFingerHwrStateManagerNum::NewL( this ) );

   674     }

   675 

   676 // ---------------------------------------------------------------------------

   677 // handler of button down event.

   678 // ---------------------------------------------------------------------------

   679 // 

   680 void CPeninputFingerHwrLayout::OnCtrlButtonDownL( TInt /*aEventType*/,

   681     CFepUiBaseCtrl* /*aCtrl*/, const TDesC& /*aEventData*/ )

   682     {

   683 

   684     }

   685 

   686 // ---------------------------------------------------------------------------

   687 // handler of button up event.

   688 // ---------------------------------------------------------------------------

   689 // 

   690 void CPeninputFingerHwrLayout::OnCtrlButtonUpL( TInt /*aEventType*/,

   691     CFepUiBaseCtrl* aCtrl, const TDesC& /*aEventData*/ )

   692     {

   693     if ( !aCtrl )

   694         {

   695         return;

   696         }

   697 

   698     switch ( aCtrl->ControlId() )

   699         {

   700         case EHwrCtrlIdClose:

   701             {

   702             // Go to standby when button up before character timeout    

   703             if ( iDataStore->StartCharacter())

   704                 {

   705                 iDataStore->SetStartCharacter(EFalse);

   706                 iHwrWnd->CancelWriting();

   707                 ChangeCurStateManagerToStandby();

   708                 iHwrWnd->UpdateLayout( ETrue );

   709                 }

   710         

   711             SignalOwner( ESignalLayoutClosed );

   712             }

   713             break;

   714         case EHwrCtrlIdLanguageOption:

   715             {

   716             SignalOwner( ESignalLaunchOptionMenu );

   717             }

   718             break;

   719         case EHwrCtrlIdVkbSwitcher:

   720             {

   721             iHwrWnd->PopupImeSwitcher();

   722             }

   723             break;

   724         case EHwrCtrlIdChineseMiButton:

   725         case EHwrCtrlIdEnglishMiButton:

   726         case EHwrCtrlIdNumberMiButton:

   727             {

   728             // Go to standby when button up before character timeout    

   729             if ( iDataStore->StartCharacter())

   730                 {

   731                 iDataStore->SetStartCharacter(EFalse);

   732                 iHwrWnd->CancelWriting();

   733                 ChangeCurStateManagerToStandby();

   734                 iHwrWnd->UpdateLayout( ETrue );

   735                 }

   736         

   737             iHwrWnd->ShowRangeDropList( EPopDirAuto );            

   738             }

   739             break;

   740         case EHwrCtrlIdChineseButton:

   741             {

   742             if ( iDataStore->CurrentRange() != EFingerHwrNativeRange )

   743                 {

   744                 iDataStore->SetPrimaryRange( ERangeNative );

   745                 iDataStore->SaveRange( ERangeNative );

   746 

   747                 ChangeCurStateManagerToStandby();

   748                 NotifyPrimaryRangeChanged( ERangeNative );

   749                 }

   750 

   751             iHwrWnd->TryToChangeCharRange( EFingerHwrNativeRange );            

   752             }

   753             break;

   754         case EHwrCtrlIdEnglishButton:

   755             {

   756             if ( iDataStore->CurrentRange() != EFingerHwrEnglishRange )

   757                 {

   758                 iDataStore->SetPrimaryRange( ERangeEnglish );

   759                 iDataStore->SaveRange( ERangeEnglish );

   760 

   761                 ChangeCurStateManagerToStandby();

   762                 NotifyPrimaryRangeChanged( ERangeEnglish );

   763                 }

   764 

   765             iHwrWnd->TryToChangeCharRange( EFingerHwrEnglishRange );

   766             }

   767             break;

   768         case EHwrCtrlIdSymbolButton:

   769             {

   770             // Go to standby when button up before character timeout    

   771             if ( iDataStore->StartCharacter())

   772                 {

   773                 iDataStore->SetStartCharacter(EFalse);

   774                 iHwrWnd->CancelWriting();

   775                 ChangeCurStateManagerToStandby();

   776                 iHwrWnd->UpdateLayout( ETrue );

   777                 }

   778         

   779             if ( iHwrWnd->CurrentCharRange() == EFingerHwrSymbolRange )

   780                 {

   781                 RestoreRange();

   782                 }

   783             else

   784                 {

   785                 ChangeCurStateManagerToStandby();

   786                 iHwrWnd->TryToChangeCharRange( EFingerHwrSymbolRange );

   787                 }

   788             }

   789             break;

   790         case EHwrCtrlIdNumberButton:

   791             {

   792             if ( iDataStore->CurrentRange() != EFingerHwrNumberRange )

   793                 {

   794                 iDataStore->SetPrimaryRange( ERangeNumber );

   795                 iDataStore->SaveRange( ERangeNumber );

   796 

   797                 ChangeCurStateManagerToStandby();

   798                 NotifyPrimaryRangeChanged( ERangeNumber );

   799                 }

   800             iHwrWnd->TryToChangeCharRange( EFingerHwrNumberRange );

   801             }

   802             break;

   803         case EHwrCtrlIdSctPage0Btn:

   804             {

   805             iHwrWnd->ShowSctPage( 1, EPagePosPageNo );

   806             }

   807             break;

   808         case EHwrCtrlIdSctPage1Btn:

   809             {

   810             iHwrWnd->ShowSctPage( 2, EPagePosPageNo );

   811             }

   812             break;

   813         case EHwrCtrlIdSctPage2Btn:

   814             {

   815             iHwrWnd->ShowSctPage( 0, EPagePosPageNo );

   816             }

   817             break;

   818         default:

   819             break;

   820         }

   821 

   822     }

   823 

   824 // ---------------------------------------------------------------------------

   825 // handler of rep-button clicked event.

   826 // ---------------------------------------------------------------------------

   827 // 

   828 void CPeninputFingerHwrLayout::OnRepButtonClickedL( CFepUiBaseCtrl* aCtrl,

   829     const TDesC& aData )

   830     {

   831     if ( !aCtrl )

   832         {

   833         return;

   834         }

   835 

   836     switch ( aCtrl->ControlId() )

   837         {

   838         case EHwrCtrlIdArrowRight:

   839         case EHwrCtrlIdArrowLeft:

   840             {

   841             SignalOwner( ESignalKeyEvent, aData );

   842             }

   843             break;

   844         case EHwrCtrlIdArrowDown:

   845             {

   846             iHwrWnd->Icf()->HandleArrowBtnEventL( CFepLayoutMultiLineIcf::EArrowDown );

   847             }

   848             break;

   849         case EHwrCtrlIdArrowUp:

   850             {

   851             iHwrWnd->Icf()->HandleArrowBtnEventL( CFepLayoutMultiLineIcf::EArrowUp );

   852             }

   853             break;

   854         default:

   855             break;

   856         }

   857     }

   858 

   859 // ---------------------------------------------------------------------------

   860 // handler of BACKSPACE button clicked event.

   861 // ---------------------------------------------------------------------------

   862 // 

   863 void CPeninputFingerHwrLayout::OnBackspaceClickedL()

   864     {

   865     if ( iDataStore->StartCharacter() ) // before character timer out

   866         {

   867         // goto standby and clear screen

   868         iDataStore->SetStartCharacter(EFalse);

   869         iHwrWnd->CancelWriting();

   870         }

   871     else

   872         {

   873         SubmitCharToFep( EKeyBackspace );

   874         }

   875         

   876         CurStateManager()->HandleEventL( EHwrEventKeyBack, KNullDesC );

   877         iLastOverlapIdx = iDataStore->RemoveDuplicateCand(iDataStore->Candidate(),

   878                                           const_cast<RPointerArray<HBufC>&>(iDataStore->Predictive()),

   879                                           0,

   880                                           0);

   881         

   882     

   883     // not update layou when SCT button is latched

   884     if ( ( iDataStore->CurrentRange() == EFingerHwrNativeRange || 

   885            iDataStore->CurrentRange() == EFingerHwrEnglishRange ) && 

   886            iHwrWnd->CurrentCharRange() != EFingerHwrSymbolRange )

   887         {

   888         iHwrWnd->UpdateLayout( CurStateManager()->IsStandbyState() );

   889         }

   890     }

   891 

   892 // ---------------------------------------------------------------------------

   893 // handler of virtual key down event.

   894 // ---------------------------------------------------------------------------

   895 //

   896 void CPeninputFingerHwrLayout::OnVirtualKeyDownL( CFepUiBaseCtrl* /*aCtrl*/,

   897     const TDesC& /*aData*/ )

   898     {

   899 

   900     }

   901 

   902 // ---------------------------------------------------------------------------

   903 // handler of virtual key up event.

   904 // ---------------------------------------------------------------------------

   905 //  

   906 void CPeninputFingerHwrLayout::OnVirtualKeyUpL( CFepUiBaseCtrl* /*aCtrl*/,

   907     const TDesC& aData )

   908     {

   909     const TVirtualKeyEventData* vkdata = NULL;

   910     const TKeyEvent *keydata = NULL;

   911     vkdata = reinterpret_cast<const TVirtualKeyEventData*>( aData.Ptr() );

   912     keydata = reinterpret_cast<const TKeyEvent*>( aData.Ptr() );

   913 

   914     if ( vkdata->iKeyEvent.iScanCode == KEmotionKeyMark )

   915         {

   916         TBuf<KTempBufSize> buf;

   917         buf.Append( vkdata->iKeyData );

   918         SubmitStringToFep( buf );

   919         }

   920     else

   921         {

   922         TBuf<1> bufBck;

   923         bufBck.Append( keydata->iScanCode );

   924         SignalOwner( ESignalKeyEvent, bufBck );

   925         }

   926     //restore range before sct popup

   927     RestoreRange();

   928     }

   929 

   930 // ---------------------------------------------------------------------------

   931 // handler of candidate list event.

   932 // ---------------------------------------------------------------------------

   933 // 

   934 void CPeninputFingerHwrLayout::OnCandidateSelectedL( CFepUiBaseCtrl* aCtrl,

   935     const TDesC& aData )

   936     {

   937     if ( !aCtrl )

   938         {

   939         return;

   940         }

   941     

   942     CurStateManager()->HandleEventL( EHwrEventCandidateSelected, aData );

   943     

   944     iLastOverlapIdx = iDataStore->RemoveDuplicateCand(iDataStore->Candidate(),

   945                                           const_cast<RPointerArray<HBufC>&>(iDataStore->Predictive()),

   946                                           0,

   947                                           0);

   948     

   949 

   950     iHwrWnd->UpdateLayout( EFalse );

   951     }

   952 

   953 // ---------------------------------------------------------------------------

   954 // handler of predictive list event.

   955 // ---------------------------------------------------------------------------

   956 // 

   957 void CPeninputFingerHwrLayout::OnPredictSelectedL( CFepUiBaseCtrl* aCtrl,

   958     const TDesC& aData )

   959     {

   960     if ( !aCtrl )

   961         {

   962         return;

   963         }

   964 

   965     CurStateManager()->HandleEventL( EHwrEventPredictiveSelected, aData );

   966     iLastOverlapIdx = iDataStore->RemoveDuplicateCand(iDataStore->Candidate(),

   967                       const_cast<RPointerArray<HBufC>&>(iDataStore->Predictive()),

   968                       0,

   969                       0);

   970 

   971     iHwrWnd->UpdateLayout( EFalse );

   972     }

   973 

   974 // ---------------------------------------------------------------------------

   975 // clicked event handler of icf.

   976 // ---------------------------------------------------------------------------

   977 // 

   978 void CPeninputFingerHwrLayout::OnIcfClicked()

   979     {

   980     if ( iHwrWnd->CurrentCharRange() == EFingerHwrSymbolRange )

   981         {

   982         // cancel sct and restore last range.

   983         RestoreRange();

   984         }

   985     else

   986         {

   987         // Go to standby

   988         ChangeCurStateManagerToStandby();

   989         iHwrWnd->UpdateLayout( ETrue );

   990         }

   991     }

   992 

   993 // ---------------------------------------------------------------------------

   994 // handler of ime selector event.

   995 // ---------------------------------------------------------------------------

   996 // 

   997 void CPeninputFingerHwrLayout::OnImeSelected( TInt /*aEventType*/,

   998     CFepUiBaseCtrl* aCtrl, const TDesC& aEventData )

   999     {

  1000     if ( !aCtrl )

  1001         {

  1002         return;

  1003         }

  1004 

  1005     CFepLayoutChoiceList::SEvent* event= NULL;

  1006     event = (CFepLayoutChoiceList::SEvent*)aEventData.Ptr();

  1007     if ( !event || event->iIndex == -1 )

  1008         {

  1009         return;

  1010         }

  1011 

  1012     TBool switchByMode = ETrue;

  1013     TInt mode = event->iCommand;

  1014 

  1015     TBuf<KTempBufSize> buf;

  1016     TInt length = sizeof(TBool)/sizeof(TText);

  1017     buf.Append( reinterpret_cast<TText*>( &switchByMode ), length );

  1018     

  1019     length = sizeof(TInt)/sizeof(TText);

  1020     buf.Append( reinterpret_cast<TText*>( &mode ), length );

  1021     SignalOwner( ESignalLayoutUIChanged, buf );

  1022     }

  1023 

  1024 // ---------------------------------------------------------------------------

  1025 // handler of StrokeStarted event.

  1026 // ---------------------------------------------------------------------------

  1027 //                                              

  1028 void CPeninputFingerHwrLayout::OnHwrStrokeStartedL()

  1029     {

  1030     if(!iDataStore->StartCharacter())

  1031         {

  1032 #ifdef RD_INTELLIGENT_TEXT_INPUT

  1033         // set first stroke flag for Auto Complete

  1034         iDataStore->SetFirstStroke(ETrue);

  1035         

  1036         // The default candidate cell is not highlight

  1037         iDataStore->SetHighlight(EFalse);

  1038               

  1039         iHwrWnd->UpdateLayout(EFalse);

  1040         

  1041         // Show two empty dropdown list       

  1042         iHwrWnd->CandidateList()->ResetAndClear();

  1043         iHwrWnd->PredictiveList()->ResetAndClear();

  1044         

  1045 #else

  1046         if(iDataStore->PrimaryRange() == ERangeEnglish)

  1047             {

  1048             iDataStore->SetFixEnglishSymbolL();

  1049             }

  1050         // Hide the fix English Symbol list         

  1051         iHwrWnd->HideTwoRowEngSymbolList(ETrue);

  1052         

  1053         // The default candidate cell is not highlight

  1054         iDataStore->SetHighlight(EFalse);      

  1055         iHwrWnd->UpdateLayout(EFalse);

  1056         

  1057         // Show empty upper row in Native range

  1058         // Show fix English Symbol in English range

  1059         if(iDataStore->PrimaryRange() != ERangeEnglish)

  1060             {

  1061             iHwrWnd->CandidateList()->ResetAndClear();

  1062             }

  1063             

  1064         // Show empty lower row

  1065         iHwrWnd->PredictiveList()->ResetAndClear();

  1066         

  1067 #endif

  1068         }

  1069         

  1070     // remember the start writing position.

  1071     iDataStore->SetStartCharacter(ETrue);

  1072     iHwrWnd->CancelAllPopList();

  1073     CurStateManager()->HandleEventL( EEventHwrStrokeStarted, KNullDesC );

  1074     }

  1075 

  1076 // ---------------------------------------------------------------------------

  1077 // handler of StrokeFinished event.

  1078 // ---------------------------------------------------------------------------

  1079 // 

  1080 void CPeninputFingerHwrLayout::OnHwrStrokeFinishedL()

  1081     {

  1082     RArray<TPoint> points = iHwrWnd->StrokeList();

  1083     TPtrC ptr;

  1084     ptr.Set(reinterpret_cast<TText*>(&points), sizeof(&points));

  1085     CurStateManager()->HandleEventL( EEventHwrStrokeFinished, ptr );

  1086     

  1087 #ifdef RD_INTELLIGENT_TEXT_INPUT     

  1088     iDataStore->SetFirstStroke(EFalse);

  1089 #endif    

  1090 

  1091     iHwrWnd->UpdateLayout(EFalse);

  1092     }

  1093 

  1094 // ---------------------------------------------------------------------------

  1095 // handler of CharacterFinished event.

  1096 // ---------------------------------------------------------------------------

  1097 // 

  1098 void CPeninputFingerHwrLayout::OnHwrCharacterFinishedL()

  1099     {

  1100     iDataStore->SetStartCharacter( EFalse );

  1101 

  1102     RArray<TPoint> points = iHwrWnd->StrokeList();

  1103     TPtrC ptr;

  1104     ptr.Set( reinterpret_cast<TText*>( &points ), sizeof(&points) );

  1105     CurStateManager()->HandleEventL( EEventHwrCharacterTimerOut, ptr );

  1106 

  1107     // When recognize Enter or Backspace, it will go to standby

  1108     iHwrWnd->UpdateLayout( CurStateManager()->IsStandbyState(), EFalse, EFalse );

  1109     }

  1110 

  1111 // ---------------------------------------------------------------------------

  1112 // handler of NumMapping changed event.

  1113 // ---------------------------------------------------------------------------

  1114 //

  1115 void CPeninputFingerHwrLayout::OnNumMappingChangedL()

  1116     {

  1117     HBufC* mapping = iDataStore->KeyMappingStringL();

  1118 

  1119     iHwrWnd->SetNumericMapping( *mapping );

  1120 

  1121     delete mapping;

  1122     }

  1123 

  1124 // ---------------------------------------------------------------------------

  1125 // Handler of the candidate list event.

  1126 // ---------------------------------------------------------------------------

  1127 //   

  1128 void CPeninputFingerHwrLayout::OnCandidateWndEventL()

  1129     {

  1130     TInt candscnt = iDataStore->PredictiveCount(); 

  1131  

  1132     iDataStore->GetNextPredictivePageL();

  1133 

  1134     iLastOverlapIdx = iDataStore->RemoveDuplicateCand(iDataStore->Candidate(),