textinput/peninputfingerhwrar/src/peninputfingerhwrarlayout.cpp
branchRCL_3
changeset 7 a47de9135b21
parent 3 f5a1e66df979
child 8 6ceef9a83b1a
equal deleted inserted replaced
3:f5a1e66df979 7:a47de9135b21
    18 //SYSTEM INCLUDES
    18 //SYSTEM INCLUDES
    19 #include <bautils.h>
    19 #include <bautils.h>
    20 #include <coemain.h>
    20 #include <coemain.h>
    21 
    21 
    22 //FEP Includes
    22 //FEP Includes
    23 #include <AknFepGlobalEnums.h>
    23 #include <aknfepglobalenums.h>
    24 #include <aknfeppeninputenums.h>
    24 #include <aknfeppeninputenums.h>
    25 #include <peninputlayoutchoicelist.h>
    25 #include <peninputlayoutchoicelist.h>
    26 #include <settingsinternalcrkeys.h>
    26 #include <settingsinternalcrkeys.h>
    27 #include <centralrepository.h>
    27 #include <centralrepository.h>
    28 #include <peninputlayoutvkb.h>
    28 #include <peninputlayoutvkb.h>
    29 #include <AknFepGlobalEnums.h>
       
    30 #include <peninputcmdparam.h>
    29 #include <peninputcmdparam.h>
    31 #include <peninputdropdownlist.h>
    30 #include <peninputdropdownlist.h>
    32 #include <peninputlayoutmultilineicf.h>
    31 #include <peninputlayoutmultilineicf.h>
    33 
    32 
    34 //USER INCLUDES
    33 //USER INCLUDES
   152             break;
   151             break;
   153         case ECmdPenInputPermittedRange:
   152         case ECmdPenInputPermittedRange:
   154             {
   153             {
   155             TInt ranges = *(TInt*)aData;
   154             TInt ranges = *(TInt*)aData;
   156             iDataStore->SetPermittedRanges( ranges );
   155             iDataStore->SetPermittedRanges( ranges );
   157             iHwrWnd->SetPermittedRanges( ranges );
       
   158             ret = KErrNone;
   156             ret = KErrNone;
   159             }
   157             }
   160             break;
   158             break;
   161         case ECmdPenInputLanguage:
   159         case ECmdPenInputLanguage:
   162             {
   160             {
   186 
   184 
   187             TRect hwrRect = iHwrWnd->WritingBoxRect();
   185             TRect hwrRect = iHwrWnd->WritingBoxRect();
   188             TSize hwrSize = hwrRect.Size();
   186             TSize hwrSize = hwrRect.Size();
   189             iDataStore->SetInputAreaSize(hwrSize);
   187             iDataStore->SetInputAreaSize(hwrSize);
   190             iDataStore->SetScreenSize(hwrSize);
   188             iDataStore->SetScreenSize(hwrSize);
   191             ChangeCurStateManagerToStandby();
   189             ChangeCurStateToStandby();
   192             
   190             
   193             iDataStore->GetKeyboardType();
   191             iDataStore->GetKeyboardType();
   194             iDataStore->SetKeyboardToQwerty();
   192             iDataStore->SetKeyboardToQwerty();
   195             ret = KErrNone;
   193             ret = KErrNone;
   196             }
   194             }
   297 				}
   295 				}
   298 			else if(iDataStore->IsArabicNumber(charBeforeCursor)) // arabic-indic numbers
   296 			else if(iDataStore->IsArabicNumber(charBeforeCursor)) // arabic-indic numbers
   299 				{
   297 				{
   300 				candtype = ECandArabicIndicNumFirst;
   298 				candtype = ECandArabicIndicNumFirst;
   301 				}
   299 				}
   302 			else if(iDataStore->IsArabicChar(charBeforeCursor))
   300 				
   303 			    {
       
   304 			    candtype = ECandArabicCharFirst;
       
   305 			    }
       
   306 			iDataStore->SetFirstCandidateType(candtype);	
   301 			iDataStore->SetFirstCandidateType(candtype);	
   307 			}
   302 			}
   308         
   303         
   309         return err;
   304         return err;
   310         }
   305         }
   354 // Called by owner when the layout is going to be hidden.
   349 // Called by owner when the layout is going to be hidden.
   355 // ---------------------------------------------------------------------------
   350 // ---------------------------------------------------------------------------
   356 //
   351 //
   357 void CPeninputFingerHwrArLayout::OnDeActivate()
   352 void CPeninputFingerHwrArLayout::OnDeActivate()
   358     {
   353     {
   359     //cancel writing
   354     // cancel writing
   360     iHwrWnd->CancelWriting();
   355     iHwrWnd->CancelWriting();
   361     
   356     
   362     if(!iHwrWnd->IsSymbolTableShowingUp())
   357 	// close the symbol table if it's showing up
   363         {
   358     iHwrWnd->CloseSymbolTable();
   364         iHwrWnd->UpdateLayout( ETrue );
   359     
   365         }
   360 	// close the candidate list if it's showing up
       
   361     iHwrWnd->CloseCandidateList();
   366     
   362     
   367     CFepUiLayout::OnDeActivate();
   363     CFepUiLayout::OnDeActivate();
   368     }
   364     }
   369 
   365 
   370 // ---------------------------------------------------------------------------
   366 // ---------------------------------------------------------------------------
   443             }
   439             }
   444             break;
   440             break;
   445             
   441             
   446         case EHwrEventOutsideEvent:
   442         case EHwrEventOutsideEvent:
   447             {
   443             {
   448             ChangeCurStateManagerToStandby();
   444             ChangeCurStateToStandby();
   449             iHwrWnd->CloseSymbolTable();
   445             iHwrWnd->CloseSymbolTable();
   450             }
   446             }
   451             break;
   447             break;
   452             
   448             
   453         default:
   449         default:
   547                 self->SetBoxPenColor( newValue );
   543                 self->SetBoxPenColor( newValue );
   548                 }
   544                 }
   549                 break;
   545                 break;
   550             case KSettingsPenInputGuideLine:
   546             case KSettingsPenInputGuideLine:
   551                 {
   547                 {
   552                 
   548                 self->SetGuideLineOn(newValue);
   553                 }
   549                 }
   554                 break;
   550                 break;
   555             default:
   551             default:
   556                 break;
   552                 break;
   557             }
   553             }
   614 CPeninputFingerHwrArLayout::~CPeninputFingerHwrArLayout()
   610 CPeninputFingerHwrArLayout::~CPeninputFingerHwrArLayout()
   615     {
   611     {
   616     CCoeEnv::Static()->DeleteResourceFile( iResId );
   612     CCoeEnv::Static()->DeleteResourceFile( iResId );
   617 
   613 
   618     delete iDataStore;
   614     delete iDataStore;
   619     iStateMgrArray.ResetAndDestroy();
   615 	delete iStateMgr;
   620     iStateMgrArray.Close();
       
   621 
       
   622     delete iGSRepositoryWatcher;
   616     delete iGSRepositoryWatcher;
   623     delete iRepositorySetting;
   617     delete iRepositorySetting;
   624     }
   618     }
   625 
   619 
   626 // ---------------------------------------------------------------------------
   620 // ---------------------------------------------------------------------------
   643 // Create the state manager.
   637 // Create the state manager.
   644 // ---------------------------------------------------------------------------
   638 // ---------------------------------------------------------------------------
   645 // 
   639 // 
   646 void CPeninputFingerHwrArLayout::CreateStateManagerL()
   640 void CPeninputFingerHwrArLayout::CreateStateManagerL()
   647     {
   641     {
   648     iStateMgrArray.AppendL( CPeninputFingerHwrArStateManager::NewL( this ) );
   642     iStateMgr = CPeninputFingerHwrArStateManager::NewL( this );
   649     }
   643     }
   650 
   644 
   651 // ---------------------------------------------------------------------------
   645 // ---------------------------------------------------------------------------
   652 // handler of button down event.
   646 // handler of button down event.
   653 // ---------------------------------------------------------------------------
   647 // ---------------------------------------------------------------------------
   677             // Go to standby when button up before character timeout    
   671             // Go to standby when button up before character timeout    
   678             if ( iDataStore->StartCharacter())
   672             if ( iDataStore->StartCharacter())
   679                 {
   673                 {
   680                 iDataStore->SetStartCharacter(EFalse);
   674                 iDataStore->SetStartCharacter(EFalse);
   681                 iHwrWnd->CancelWriting();
   675                 iHwrWnd->CancelWriting();
   682                 ChangeCurStateManagerToStandby();
   676                 ChangeCurStateToStandby();
   683                 iHwrWnd->UpdateLayout( ETrue );
   677                 iHwrWnd->CloseCandidateList();
   684                 }
   678                 }
   685         
   679         
   686             SignalOwner( ESignalLayoutClosed );
   680             SignalOwner( ESignalLayoutClosed );
   687             }
   681             }
   688             break;
   682             break;
   696             // Go to standby when button up before character timeout    
   690             // Go to standby when button up before character timeout    
   697             if ( iDataStore->StartCharacter())
   691             if ( iDataStore->StartCharacter())
   698                 {
   692                 {
   699                 iDataStore->SetStartCharacter(EFalse);
   693                 iDataStore->SetStartCharacter(EFalse);
   700                 iHwrWnd->CancelWriting();
   694                 iHwrWnd->CancelWriting();
   701                 ChangeCurStateManagerToStandby();
   695                 ChangeCurStateToStandby();
   702                 iHwrWnd->UpdateLayout( ETrue );
   696                 iHwrWnd->CloseCandidateList();
   703                 }
   697                 }
   704             
   698             
   705             if(iHwrWnd->IsSymbolTableShowingUp())
   699             if(iHwrWnd->IsSymbolTableShowingUp())
   706             	{
   700             	{
   707                 iHwrWnd->CloseSymbolTable();
   701                 iHwrWnd->CloseSymbolTable();
   708                 }
   702                 }
   709             else
   703             else
   710                 {
   704                 {
   711                 ChangeCurStateManagerToStandby();
   705                 ChangeCurStateToStandby();
   712                 iHwrWnd->OpenSymbolTable();
   706                 iHwrWnd->OpenSymbolTable();
   713                 }
   707                 }
   714             }
   708             }
   715             break;
   709             break;
   716         case EHwrCtrlId3Page1Btn:
   710         case EHwrCtrlId3Page1Btn:
   717             {
   711             {
   718             iHwrWnd->ShowSctPage( 1, EPagePosPageNo );
   712             iHwrWnd->ShowSymbolPage( 1, EPagePosPageNo );
   719             }
   713             }
   720             break;
   714             break;
   721         case EHwrCtrlId3Page2Btn:
   715         case EHwrCtrlId3Page2Btn:
   722             {
   716             {
   723             iHwrWnd->ShowSctPage( 2, EPagePosPageNo );
   717             iHwrWnd->ShowSymbolPage( 2, EPagePosPageNo );
   724             }
   718             }
   725             break;
   719             break;
   726         case EHwrCtrlId3Page3Btn:
   720         case EHwrCtrlId3Page3Btn:
   727             {
   721             {
   728             iHwrWnd->ShowSctPage( 0, EPagePosPageNo );
   722             iHwrWnd->ShowSymbolPage( 0, EPagePosPageNo );
   729             }
   723             }
   730             break;
   724             break;
   731         case EHwrCtrlId2Page1Btn:
   725         case EHwrCtrlId2Page1Btn:
   732             {
   726             {
   733             iHwrWnd->ShowSctPage( 1, EPagePosPageNo );
   727             iHwrWnd->ShowSymbolPage( 1, EPagePosPageNo );
   734             }
   728             }
   735             break;    
   729             break;    
   736         case EHwrCtrlId2Page2Btn:
   730         case EHwrCtrlId2Page2Btn:
   737             {
   731             {
   738             iHwrWnd->ShowSctPage( 0, EPagePosPageNo );
   732             iHwrWnd->ShowSymbolPage( 0, EPagePosPageNo );
   739             }
   733             }
   740             break;    
   734             break;    
   741 		case EHwrCtrlIdBtnEnter:
   735 		case EHwrCtrlIdBtnEnter:
   742             {
   736             {
   743 			TBuf<1> bufEnter;
   737 			TBuf<1> bufEnter;
   806 	iHwrWnd->CancelWriting();
   800 	iHwrWnd->CancelWriting();
   807     if (iHwrWnd->IsCandidateShowup())
   801     if (iHwrWnd->IsCandidateShowup())
   808         {
   802         {
   809         // goto standby and clear screen
   803         // goto standby and clear screen
   810         iDataStore->SetStartCharacter(EFalse);
   804         iDataStore->SetStartCharacter(EFalse);
   811 		ChangeCurStateManagerToStandby();
   805 		ChangeCurStateToStandby();
   812 	    iHwrWnd->UpdateLayout( ETrue );
   806 	    iHwrWnd->CloseCandidateList();
   813         }
   807         }
   814     else
   808     else
   815         {
   809         {
   816 		
       
   817         SubmitCharToFep( EKeyBackspace );
   810         SubmitCharToFep( EKeyBackspace );
   818         CurStateManager()->HandleEventL( EHwrEventKeyBack, KNullDesC );
   811         iStateMgr->HandleEventL( EHwrEventKeyBack, KNullDesC );
   819 		if(iDataStore->StartCharacter())
   812 		if(iDataStore->StartCharacter())
   820 		    {
   813 		    {
   821 			ChangeCurStateManagerToStandby();
   814 			ChangeCurStateToStandby();
   822 		    iHwrWnd->UpdateLayout( ETrue );
   815 		    iHwrWnd->CloseCandidateList();;
   823 			}
   816 			}
   824         }
   817         }
   825     }
   818     }
   826 
   819 
   827 // ---------------------------------------------------------------------------
   820 // ---------------------------------------------------------------------------
   873     if ( !aCtrl )
   866     if ( !aCtrl )
   874         {
   867         {
   875         return;
   868         return;
   876         }
   869         }
   877     
   870     
   878     CurStateManager()->HandleEventL( EHwrEventCandidateSelected, aData );
   871     iStateMgr->HandleEventL( EHwrEventCandidateSelected, aData );
   879     
   872     
   880     
   873     ChangeCurStateToStandby();
   881     ChangeCurStateManagerToStandby();
   874 
   882 
   875     iHwrWnd->CloseCandidateList();;
   883     iHwrWnd->UpdateLayout( ETrue );
       
   884     }
   876     }
   885 
   877 
   886 
   878 
   887 // ---------------------------------------------------------------------------
   879 // ---------------------------------------------------------------------------
   888 // clicked event handler of icf.
   880 // clicked event handler of icf.
   889 // ---------------------------------------------------------------------------
   881 // ---------------------------------------------------------------------------
   890 // 
   882 // 
   891 void CPeninputFingerHwrArLayout::OnIcfClicked()
   883 void CPeninputFingerHwrArLayout::OnIcfClicked()
   892     {
   884     {
   893     // Go to standby
   885     // Go to standby
   894 	ChangeCurStateManagerToStandby();
   886 	ChangeCurStateToStandby();
   895 	iHwrWnd->UpdateLayout( ETrue );
   887 	if(iHwrWnd->IsCandidateShowup())
       
   888 	    {
       
   889 		iHwrWnd->CloseCandidateList();
       
   890 		}
   896 	}
   891 	}
   897 
   892 
   898 // ---------------------------------------------------------------------------
   893 // ---------------------------------------------------------------------------
   899 // handler of StrokeStarted event.
   894 // handler of StrokeStarted event.
   900 // ---------------------------------------------------------------------------
   895 // ---------------------------------------------------------------------------
   901 //                                              
   896 //                                              
   902 void CPeninputFingerHwrArLayout::OnHwrStrokeStartedL()
   897 void CPeninputFingerHwrArLayout::OnHwrStrokeStartedL()
   903     {
   898     {
   904 	iHwrWnd->HideIndicator();
   899 	iHwrWnd->HideIndicator();
       
   900 	
   905 	// The default candidate cell is not highlight
   901 	// The default candidate cell is not highlight
   906 	iDataStore->SetHighlight(EFalse);      
   902 	iDataStore->SetHighlight(EFalse); 
   907 	iHwrWnd->UpdateLayout(ETrue);
   903     
       
   904     // close the candidate list if it's currently showing up	
       
   905 	if(iHwrWnd->IsCandidateShowup())
       
   906 	    {
       
   907 		iHwrWnd->CloseCandidateList();
       
   908 		}
   908     
   909     
   909 	// remember the start writing position.
   910 	// remember the start writing position.
   910     iDataStore->SetStartCharacter(ETrue);
   911     iDataStore->SetStartCharacter(ETrue);
   911     CurStateManager()->HandleEventL( EEventHwrStrokeStarted, KNullDesC );
   912     iStateMgr->HandleEventL( EEventHwrStrokeStarted, KNullDesC );
   912     }
   913     }
   913 
   914 
   914 // ---------------------------------------------------------------------------
   915 // ---------------------------------------------------------------------------
   915 // handler of StrokeFinished event.
   916 // handler of StrokeFinished event.
   916 // ---------------------------------------------------------------------------
   917 // ---------------------------------------------------------------------------
   918 void CPeninputFingerHwrArLayout::OnHwrStrokeFinishedL()
   919 void CPeninputFingerHwrArLayout::OnHwrStrokeFinishedL()
   919     {
   920     {
   920     RArray<TPoint> points = iHwrWnd->StrokeList();
   921     RArray<TPoint> points = iHwrWnd->StrokeList();
   921     TPtrC ptr;
   922     TPtrC ptr;
   922     ptr.Set(reinterpret_cast<TText*>(&points), sizeof(&points));
   923     ptr.Set(reinterpret_cast<TText*>(&points), sizeof(&points));
   923     CurStateManager()->HandleEventL( EEventHwrStrokeFinished, ptr );
   924     iStateMgr->HandleEventL( EEventHwrStrokeFinished, ptr );
   924     }
   925     }
   925 
   926 
   926 // ---------------------------------------------------------------------------
   927 // ---------------------------------------------------------------------------
   927 // handler of CharacterFinished event.
   928 // handler of CharacterFinished event.
   928 // ---------------------------------------------------------------------------
   929 // ---------------------------------------------------------------------------
   932     iDataStore->SetStartCharacter( EFalse );
   933     iDataStore->SetStartCharacter( EFalse );
   933 
   934 
   934     RArray<TPoint> points = iHwrWnd->StrokeList();
   935     RArray<TPoint> points = iHwrWnd->StrokeList();
   935     TPtrC ptr;
   936     TPtrC ptr;
   936     ptr.Set( reinterpret_cast<TText*>( &points ), sizeof(&points) );
   937     ptr.Set( reinterpret_cast<TText*>( &points ), sizeof(&points) );
   937     CurStateManager()->HandleEventL( EEventHwrCharacterTimerOut, ptr );
   938     iStateMgr->HandleEventL( EEventHwrCharacterTimerOut, ptr );
   938 
   939   
   939     // When recognize Enter or Backspace, it will go to standby
   940 	iHwrWnd->OpenCandidateList();
   940     iHwrWnd->UpdateLayout( CurStateManager()->IsStandbyState(), ETrue);
   941 	}
   941     }
       
   942 
   942 
   943 // ---------------------------------------------------------------------------
   943 // ---------------------------------------------------------------------------
   944 // get value from repository.
   944 // get value from repository.
   945 // ---------------------------------------------------------------------------
   945 // ---------------------------------------------------------------------------
   946 // 
   946 // 
  1037 
  1037 
  1038 // ---------------------------------------------------------------------------
  1038 // ---------------------------------------------------------------------------
  1039 // set hwr writing pen color.
  1039 // set hwr writing pen color.
  1040 // ---------------------------------------------------------------------------
  1040 // ---------------------------------------------------------------------------
  1041 //  
  1041 //  
  1042 void CPeninputFingerHwrArLayout::SetGuideLineOn(const TBool aGuideLineOn)
  1042 void CPeninputFingerHwrArLayout::SetGuideLineOn(TBool aGuideLineOn)
  1043     {
  1043     {
  1044     iHwrWnd->SetGuideLineOn( aGuideLineOn );
  1044     iHwrWnd->SetGuideLineOn( aGuideLineOn );
  1045     }
  1045     }
  1046 
  1046 
  1047 // ---------------------------------------------------------------------------
  1047 // ---------------------------------------------------------------------------
  1048 // get current state manager.
       
  1049 // ---------------------------------------------------------------------------
       
  1050 // 
       
  1051 CPeninputFingerHwrArStateManagerBase* CPeninputFingerHwrArLayout::CurStateManager()
       
  1052     {
       
  1053     return iStateMgrArray[0];
       
  1054     }
       
  1055 
       
  1056 
       
  1057 // ---------------------------------------------------------------------------
       
  1058 // change current state manager to standby state.
  1048 // change current state manager to standby state.
  1059 // ---------------------------------------------------------------------------
  1049 // ---------------------------------------------------------------------------
  1060 // 
  1050 // 
  1061 void CPeninputFingerHwrArLayout::ChangeCurStateManagerToStandby()
  1051 void CPeninputFingerHwrArLayout::ChangeCurStateToStandby()
  1062     {
  1052     {
  1063     CPeninputFingerHwrArStateManagerBase* stateMgr = CurStateManager();
  1053     iStateMgr->SetState( CPeninputFingerHwrArStateManagerBase::EStateStandBy );
  1064     if ( stateMgr )
       
  1065         {
       
  1066         stateMgr->SetState( CPeninputFingerHwrArStateManagerBase::EStateStandBy );
       
  1067         }
       
  1068     }
  1054     }
  1069 
  1055 
  1070 //End of file
  1056 //End of file