1 /*

     2 * Copyright (c) 2002-2005 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 of vkb window class

    15 *

    16 */

    17 

    18 // System includes

    19 #include <peninputssqwin.rsg>

    20 #include <peninputssqwinconfiginfo_01.rsg>

    21 #include <aknfeppeninputenums.h>

    22 #include <peninputinputcontextfield.h>

    23 #include <peninputpluginutils.h>

    24 #include <peninputcommonlayoutext.h>

    25 #include <peninputvkbctrllayout.h>

    26 #include <peninputvkbctrlext.h>

    27 #include <peninputeventbutton.h>

    28 #include <peninputdragbutton.h>

    29 #include <peninputrepeatbutton.h>

    30 #include <peninputmultimodebutton.h>

    31 #include <peninputrangebar.h>

    32 #include <peninputdataconverter.h>

    33 #include <peninputdataprovider.h>

    34 #include <peninputclientlayoutinfo.h>

    35 #include <peninputlayoutchoicelist.h>

    36 #include <aknlayoutscalable_apps.cdl.h>

    37 #include <peninputlayoutbubblectrl.h>

    38 #include <peninputscrollablelist.h>

    39 #include <e32keys.h>

    40 #include <AknIconUtils.h>

    41 #include <AknLayoutDef.h>

    42 #include <AknUtils.h>

    43 #include <AknLayoutScalable_Avkon.cdl.h>

    44 #include <AknsUtils.h>

    45 #include <AknFepGlobalEnums.h>

    46 #include <peninputlayoutinputmodechoice.h>

    47 #include <peninputlayoutmultilineicf.h>

    48 #include <S32MEM.h>

    49 

    50 // User includes

    51 #include "peninputsplitqwerty.hrh"

    52 #include "peninputsplitqwertywindow.h"

    53 #include "peninputsplitqwertyenum.h"

    54 #include "peninputrangebarinfo.h"

    55 #include "peninputsplitqwertylafdatamgr.h"

    56 #include "peninputsplitqwertylangmeritpair.h"

    57 #include "peninputsplitqwertylayout.h"

    58 

    59 // Constants

    60 const TInt KPeninputVkbWndInvalidIndex = -1;

    61 const TInt KInvalidImg = -1 ;

    62 

    63 _LIT( KVkbWindowResourceFile, "z:\\resource\\plugins\\peninputssqwin.rsc" );

    64 _LIT( KConfigurationResourceFile, "z:\\resource\\plugins\\peninputssqwinconfiginfo_" );

    65 _LIT( KResourceFileExtName, ".rsc" );

    66 

    67 // ======== MEMBER FUNCTIONS ========

    68 

    69 // ---------------------------------------------------------------------------

    70 // Symbian constructor

    71 // ---------------------------------------------------------------------------

    72 // 

    73 CPeninputSplitQwertyWindow* CPeninputSplitQwertyWindow::NewL(

    74                                         CFepUiLayout* aUiLayout, 

    75                                         MPeninputLayoutContext* aLayoutContext, 

    76                                         MPeninputUiStateMgr* aUiStateMgr )

    77     {

    78     CPeninputSplitQwertyWindow* 

    79         self = new ( ELeave ) CPeninputSplitQwertyWindow( aUiLayout,

    80                                                           aLayoutContext, 

    81                                                           aUiStateMgr );

    82     CleanupStack::PushL( self );

    83     self->ConstructL();

    84     CleanupStack::Pop( self );

    85 

    86     return self;

    87     }

    88 

    89 // ---------------------------------------------------------------------------

    90 // C++ destructor

    91 // ---------------------------------------------------------------------------

    92 //

    93 CPeninputSplitQwertyWindow::~CPeninputSplitQwertyWindow()

    94     {

    95     delete iIdle;

    96     iUnits.Close();

    97     

    98     delete iLafMgr;

    99     iLafMgr = NULL;

   100     delete iBmpRotator;

   101     

   102     iAccentCmdList.Close();

   103     }

   104 

   105 // ---------------------------------------------------------------------------

   106 // Get id of window config resource

   107 // ---------------------------------------------------------------------------

   108 //

   109 TInt CPeninputSplitQwertyWindow::GetWindowConfigResId()

   110     {

   111     return R_PENINPUT_LAYOUT_CONFIG_INFO;

   112     }

   113 

   114 // ---------------------------------------------------------------------------

   115 // Get id of window resource

   116 // ---------------------------------------------------------------------------

   117 //

   118 TInt CPeninputSplitQwertyWindow::GetWindowResId()

   119     {

   120     return R_PENINPUT_LAYOUT_FSQ_WINDOW_INFO;

   121     }

   122 

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

   124 // Get resource id of numeric keymapping

   125 // ---------------------------------------------------------------------------

   126 //

   127 TInt CPeninputSplitQwertyWindow::GetNumKeymappingResId()

   128     {

   129     return R_PENINPUT_LAYOUT_KEY_MAPPING_STRING_LIST;

   130     }

   131 

   132 // ---------------------------------------------------------------------------

   133 // Get file name of window config resource

   134 // ---------------------------------------------------------------------------

   135 //

   136 const TDesC& CPeninputSplitQwertyWindow::GetWindowConfigResFileName( TInt aLangID )

   137     {

   138     if ( aLangID <= 0 ) 

   139         {

   140         return KNullDesC;

   141         }

   142         

   143     iResourceFilename.Zero();

   144     // Generate resource file name according to language id

   145     iResourceFilename = KConfigurationResourceFile();

   146     

   147     if ( aLangID < 10 )

   148         {

   149         iResourceFilename.AppendNum( 0 );

   150         iResourceFilename.AppendNum( aLangID );

   151         }

   152     else

   153         {

   154         iResourceFilename.AppendNum( aLangID );

   155         }

   156     iResourceFilename.Append( KResourceFileExtName );

   157     

   158     return iResourceFilename;

   159     }

   160 

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

   162 // Get file name of window resource

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

   164 //

   165 const TDesC& CPeninputSplitQwertyWindow::GetWindowResFileName()

   166     {

   167     return KVkbWindowResourceFile();

   168     }

   169 

   170 // ---------------------------------------------------------------------------

   171 // Change unit size

   172 // ---------------------------------------------------------------------------

   173 //

   174 const TRect CPeninputSplitQwertyWindow::ChangeUnitSize()

   175     {

   176     return TRect();

   177     }

   178 

   179 // ---------------------------------------------------------------------------

   180 // Change size of client area

   181 // ---------------------------------------------------------------------------

   182 //

   183 void CPeninputSplitQwertyWindow::ChangeClientSize()

   184     {

   185     if ( !iPopupWnd->Hiden() )

   186         {

   187         iPopupWnd->CloseWindow();

   188         iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );

   189         }

   190         

   191     HandlePopupSizeChange();

   192             

   193     TInt clientLayoutId = IntContext( EPeninputDataTypeClientLayout );

   194     CPeninputClientLayoutInfo* 

   195         clientLayout = ConfigInfo()->FindClientLayoutInfo( clientLayoutId );

   196         

   197     if ( clientLayout )

   198         {

   199         ReorganizeControls( clientLayout->LayoutID(), EFalse );

   200         } 

   201 

   202     UpdateArea( iVkbCtrl->Rect(), EFalse );

   203     }

   204 

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

   206 // Construct all controls specified in resource

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

   208 //

   209 void CPeninputSplitQwertyWindow::CreateAllControlsL()

   210     {

   211     // Range bar

   212     AddRangeBarL();

   213 

   214     // Vkb control

   215     iVkbCtrl = CPeninputVkbCtrlExt::NewL( TRect(), 

   216                                           UiLayout(), 

   217                                           EPeninutWindowCtrlIdVkbCtrl, 

   218                                           NULL  );

   219     

   220     iVkbCtrl->SetResourceId( R_PENINPUT_LAYOUT_VKB_KEYBOARD );

   221     iVkbCtrl->ConstructFromResourceL();

   222     iVkbCtrl->SetKeyTextColorGroup( EAknsCIQsnTextColorsCG68 );

   223     iVkbLayout->SetVkbKeyboard( iVkbCtrl );

   224     

   225     iVkbCtrl->SetIrregularKeyBoard( EFalse );

   226     iVkbLayout->SetNonIrregularResourceId( R_AKN_FEP_VKB_NONIRREGULAR_BITMAP );

   227     iVkbLayout->ConstructFromNonIrregularResourceL();        

   228 

   229     //todo split-view FSQ, bubble support

   230     /*

   231     iVkbCtrl->ShowBubble(ETrue);    

   232     iVkbCtrl->SetGowithPointerDown(ETrue);

   233     iVkbCtrl->SetBubbleBitmapParam(NULL,NULL,KAknsIIDQsnFrInputCharPreview); 

   234     */

   235        

   236     //set key to be 9 piece graphics

   237     iVkbCtrl->SetKeySkinId( EKeyBmpNormal, KAknsIIDQsnFrKeypadButtonFrNormal );

   238     iVkbCtrl->SetKeySkinId( EKeyBmpHighlight, KAknsIIDQsnFrKeypadButtonFrPressed );

   239     iVkbCtrl->SetKeySkinId( EKeyBmpDim, KAknsIIDQsnFrKeypadButtonFrInactive );

   240     

   241     AddControlL( iVkbCtrl );

   242     iVkbCtrl->AddEventObserver( UiLayout() );

   243     

   244     AddButtonL( EPeninutWindowCtrlIdEnterBtn, 

   245                 EPeninputLayoutEventEnter, 

   246                 R_PENINPUT_LAYOUT_VKB_ENTER, 

   247                 EKeyEnter );

   248        

   249     // Shift and capslock merged button

   250 

   251     CAknFepCtrlMultiModeButton* button = CAknFepCtrlMultiModeButton::NewLC( 

   252                                                 UiLayout(), 

   253                                                 EPeninutWindowCtrlIdShiftBtn );

   254     if ( button )

   255         {

   256         // Read resource

   257         TInt resid = R_PENINPUT_LAYOUT_VKB_SHIFT_CAPSLOCK;

   258         TResourceReader reader;

   259         CCoeEnv::Static()->CreateResourceReaderLC( reader, resid );

   260         button->SetResourceId( resid );      

   261         button->ConstructFromResourceL();  

   262         

   263         CleanupStack::PopAndDestroy( 1 ); //reader

   264         

   265         AddControlL( button );

   266         button->AddEventObserver( UiLayout() );

   267         }

   268     CleanupStack::Pop( button );  

   269 

   270     

   271     // Space button          

   272     CAknFepCtrlEventButton* spaceButton = EventButtonCtrl( 

   273                                                 EPeninutWindowCtrlIdSpaceBtn ); 

   274 

   275     // Create 3-pieces color icon for space button

   276     CPenInput3PiecesColorIcons* colorIcons = NULL;

   277     colorIcons = CPenInput3PiecesColorIcons::NewL( R_AKN_FEP_VKB_SPACE_ICON1,

   278                                                    R_AKN_FEP_VKB_SPACE_ICON2,

   279                                                    R_AKN_FEP_VKB_SPACE_ICON3 );

   280     

   281     spaceButton->Set3PiecesColorIcons( colorIcons );

   282     

   283     //set background of space button to be 9 piece graphics

   284     spaceButton->SetImageFrameId( KAknsIIDQsnFrKeypadButtonFrNormal, 

   285                                   KAknsIIDQsnFrKeypadButtonFrPressed,

   286                                   KAknsIIDQsnFrKeypadButtonFrInactive );

   287 

   288     // Add popup window

   289     AddPopupWindowL();

   290   

   291     }

   292 

   293 // ---------------------------------------------------------------------------

   294 // Set control fonts. Fonts info comes from resource

   295 // ---------------------------------------------------------------------------

   296 //

   297 void CPeninputSplitQwertyWindow::SetControlsFont()

   298     {

   299     }

   300 

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

   302 // Pop up choice list

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

   304 //

   305 void CPeninputSplitQwertyWindow::PopupChoiceList()

   306     {

   307     TRAP_IGNORE( PopupRangeListL() );

   308     }

   309 

   310 // ---------------------------------------------------------------------------

   311 // Re-organize all controls in the assigned client area layout

   312 // ---------------------------------------------------------------------------

   313 //

   314 void CPeninputSplitQwertyWindow::ReorganizeControls( TInt aClientLayoutId,

   315                                                      TBool aNeedReset )

   316     {

   317     CPeninputClientLayoutInfo* clientLayout = 

   318         ConfigInfo()->FindClientLayoutInfo( aClientLayoutId ); 

   319     RPointerArray<CPeninputControlInfo>& controlList = 

   320         clientLayout->ControlInfoList();

   321   

   322     const TInt keyColumns = clientLayout->Columns();

   323     const TInt keyRows = clientLayout->Rows();

   324     

   325     if ( iLastUsedTotalColumns == keyColumns && iLastUsedTotalRows == keyRows )

   326         {

   327         return;

   328         }    

   329 

   330     iLafMgr->SetLayoutType(

   331                 iLafMgr->LayoutTypeFromRowsColumns( keyRows, keyColumns )

   332                 );

   333     

   334     iLastUsedTotalColumns = keyColumns;

   335     iLastUsedTotalRows = keyRows;

   336     

   337     TRect winRect( Rect().iTl, iLafMgr->EntirePaneRect().Size() );

   338         

   339     SetWindowRect( winRect );  

   340     ReorgnizeTitleBar();

   341     

   342     const TInt count = controlList.Count();

   343     TInt controlID = 0;

   344     CFepUiBaseCtrl* ctrl = NULL;

   345     TRect rect;

   346     TRect inRect;

   347     TRect exRect;

   348 

   349     TPoint winPoint = Rect().iTl;

   350     TPoint LafPoint = iLafMgr->EntirePaneRect().iTl;

   351     

   352     for ( TInt i = 0; i < count; i++ )

   353         {

   354         controlID = controlList[i]->ControlID();

   355         ctrl = Control( controlID );

   356 

   357         if ( !ctrl )

   358             {

   359             continue;

   360             }

   361         

   362         AddNotOwnedControl( ctrl );

   363         

   364         if ( ( ctrl->ControlType() | ECtrlButton ) == ECtrlButton )

   365             {

   366             

   367             iLafMgr->GetButtonRect( 

   368                             TPeninputCommonCtrlID(ctrl->ControlId() ), 

   369                             exRect, inRect );

   370             

   371             if( controlID ==  EPeninutWindowCtrlIdShiftBtn)

   372                 {

   373                 CAknFepCtrlMultiModeButton* btn = NULL;

   374                 btn = static_cast<CAknFepCtrlMultiModeButton*>(ctrl);

   375                 btn->SizeChanged( exRect, inRect, ETrue );

   376                 }

   377             else

   378                 {

   379                 CAknFepCtrlCommonButton* btn = NULL;

   380                 btn = static_cast<CAknFepCtrlCommonButton*>(ctrl);

   381                 

   382                 if ( ctrl->ControlId() == EPeninutWindowCtrlIdSpaceBtn )

   383                     {

   384                     // config 3 pieces icon info       

   385                     TRect frameRect, middleRect;

   386                     iLafMgr->GetSpaceButtonExLayoutInfo( frameRect, middleRect );

   387                     inRect = frameRect;

   388                     

   389                     TDraw3PiecesFrame pic3frame( 

   390                             KAknsIIDQgnIndiInputSpaceL,

   391                             KAknsIIDQgnIndiInputSpaceMiddle,

   392                             KAknsIIDQgnIndiInputSpaceR,

   393                             middleRect);

   394                     

   395                     btn->SetDraw3PieceFrameInfo( pic3frame );

   396                     }

   397                 

   398                 btn->SizeChanged( exRect, inRect, ETrue );

   399                 }

   400             }

   401         

   402         else if ( ctrl->ControlId() == EPeninutWindowCtrlIdVkbCtrl )

   403             {

   404             iVkbCtrl->SetFont( iLafMgr->KeyTextFont() );

   405             iVkbCtrl->SetTextLineLayout( iLafMgr->KeyTextLayout() );

   406             iVkbCtrl->SetTextFormat( iLafMgr->PreviewWndText() );  //Read laf 

   407             if ( aNeedReset )

   408                 {

   409                 iVkbCtrl->Reset();

   410                 }

   411 

   412             rect = iLafMgr->KeypadRect();

   413             CPeninputVkbCtrlExt* ctrlext = static_cast<CPeninputVkbCtrlExt*>(ctrl);

   414             ctrlext->SizeChanged(rect);

   415             }  

   416         }  

   417     }

   418 

   419 // ---------------------------------------------------------------------------

   420 // Do when case changed

   421 // ---------------------------------------------------------------------------

   422 //

   423 void CPeninputSplitQwertyWindow::DoCaseChange( TInt aNewCase )

   424     {

   425     TInt curCase = IntContext( EPeninputDataTypeCase );

   426     

   427     if ( aNewCase == curCase )

   428         {

   429         return;

   430         }

   431         

   432     TInt curRange = IntContext( EPeninputDataTypeCurrentRange ); 

   433                                

   434     if ( ( curRange == ERangeEnglish ) 

   435          || ( curRange == ERangeAccent ) 

   436          || ( curRange == ERangeNative && ConfigInfo()->CaseSensitive() ) 

   437        )

   438         {

   439         // Set shift and caplock button

   440         TInt shfit;  

   441         TInt capslock;  

   442         

   443         CPeninputDataConverter::ShiftCapslockByCase( aNewCase, shfit, capslock );

   444 

   445         iLayoutContext->SetData( EPeninputDataTypeShiftDown, &shfit ); 

   446         iLayoutContext->SetData( EPeninputDataTypeCapslockDown, &capslock );        

   447         iLayoutContext->SetData( EPeninputDataTypeCase, &aNewCase ); 

   448         ChangeMergedButtonStatus( shfit, capslock );

   449         

   450         TInt vkblayout = ConfigInfo()->ShiftCapsSingleVkbLayoutByCase( curRange, 

   451                                                                        aNewCase );

   452 

   453         if ( curRange == ERangeAccent ) 

   454            {

   455            TInt curAccentIndex = IntContext( EPeninputDataTypeCurrentAccent );

   456            vkblayout = vkblayout + curAccentIndex * 2;

   457            }

   458         

   459         ChangeVkbLayout( vkblayout );

   460         }

   461     }

   462 

   463 // ---------------------------------------------------------------------------

   464 // Handle control event

   465 // ---------------------------------------------------------------------------

   466 //

   467 void CPeninputSplitQwertyWindow::HandleControlEvent( TInt aEventType,

   468                                                     CFepUiBaseCtrl* aCtrl, 

   469                                                     const TDesC& aEventData )

   470     {

   471     // Call this function in base class

   472     CPeninputLayoutWindowExt::HandleControlEvent( aEventType, aCtrl, 

   473                                                   aEventData );

   474     

   475     TInt* data = (TInt*) aEventData.Ptr(); 

   476     TInt ctrlId = aCtrl ? aCtrl->ControlId() : -1;

   477     

   478     switch ( aEventType )

   479         {

   480         case EEventButtonUp:

   481             {

   482             if ( ctrlId == EPeninutWindowCtrlIdRangeBtn )

   483                 {

   484                 PopupChoiceList();

   485                 }

   486             }

   487             break;

   488         case EPeninputLayoutVkbEventResetShift: 

   489             {

   490             HandleShiftAndCapslockBtnClicked();

   491             }

   492             break;  

   493         case EPenInputLayoutEventClosePopup:

   494             {

   495             if ( iPopupWnd && !iPopupWnd->Hiden() )

   496                 {

   497                 iPopupWnd->CloseWindow();

   498                 iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );

   499                 }

   500             }

   501             break;

   502         case EEventChoiceSelected:

   503             {

   504             CFepLayoutChoiceList::SEvent* event = NULL;

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

   506 

   507             if ( event->iIndex != KPeninputVkbWndInvalidIndex )

   508                 {

   509                 if ( ctrlId == EPeninutWindowCtrlIdAccentPopupWindow )

   510                     {

   511                     TRAP_IGNORE( HandleRangeListSelectedL( aCtrl, aEventData ) );

   512                     }

   513                 }

   514             iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );

   515             }

   516             break;

   517         case EEventVirtualKeyLatched:

   518             {

   519             HandleVirtualKeyLatchedEvent( aEventType, aCtrl, aEventData );

   520             }

   521             break;

   522         case EEventVirtualKeyUnLatched:

   523             {

   524             UiLayout()->SignalOwner( ESignalKeyEvent, iNewDeadKeyBuf );

   525             TBool deadKeyChange = EFalse;

   526             iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );

   527             iNewDeadKeyBuf = KNullDesC;

   528             }

   529             break;

   530         case EPeninputLayoutEventBack:

   531             {

   532             TInt latchedFlag = IntContext( EAkninputDataTypeLatchedSet );

   533             // If one DeadKey is latched, 

   534             // only unlatch the DeadKey and reset the iNewDeadKeyBuf

   535             // Don't delete the visible charater in ICF

   536             if ( latchedFlag )

   537                 {

   538                 UnLatchDeadKey(iNewDeadKeyBuf);

   539 

   540                 TBool deadKeyChange = EFalse;

   541                 iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );

   542                 iNewDeadKeyBuf = KNullDesC;

   543                 }

   544             }

   545             break;

   546         case EPeninputLayoutEventEnter:

   547         case EPeninputLayoutEventSpace:

   548             {

   549             TInt latchedFlag = IntContext( EAkninputDataTypeLatchedSet );

   550             if ( latchedFlag )

   551                 {

   552                 TInt length = aEventData.Length() + iNewDeadKeyBuf.Length();

   553                 HBufC* newCharBuf = HBufC::New( length );

   554                 if ( newCharBuf )

   555                     {

   556                     newCharBuf->Des().Append( iNewDeadKeyBuf );

   557                     newCharBuf->Des().Append( aEventData );

   558                     }                

   559                 

   560                 UnLatchDeadKey( iNewDeadKeyBuf );

   561 

   562                 TBool deadKeyChange = EFalse;

   563                 iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );

   564                 

   565                 // Submit DeadKey + Space or Enter at the same time

   566                 UiLayout()->SignalOwner( ESignalKeyEvent, *newCharBuf );

   567                 iNewDeadKeyBuf = KNullDesC;

   568                 delete newCharBuf;

   569                 }

   570             }

   571             break;

   572         default:

   573             break;

   574         }

   575     }

   576 

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

   578 // load settings from resource

   579 // ---------------------------------------------------------------------------

   580 //

   581 void CPeninputSplitQwertyWindow::ConstructFromResourceL()

   582     {                 

   583     CPeninputLayoutWindowExt::ConstructFromResourceL();

   584     if ( iVkbLayout && !iFirstConstruct )

   585         {

   586         if ( iVkbCtrl->IsIrregularKeyBoard() )

   587             {

   588             iVkbLayout->ConstructFromIrregularResourceL();

   589             }

   590         else

   591             {

   592             iVkbLayout->ConstructFromNonIrregularResourceL();

   593             }

   594         

   595         SetVkbLayoutSize();

   596         

   597         if ( IsRtoLLanguage( iLanguage ) )

   598             {

   599             //Mirror backspace graphic

   600             HandleButtonResOnLangDirChange( EPeninutWindowCtrlIdBackspaceBtn );

   601             }

   602         }

   603         

   604     iFirstConstruct = EFalse;

   605     }

   606 

   607 // ---------------------------------------------------------------------------

   608 // Callback function to do background construction

   609 // ---------------------------------------------------------------------------

   610 //

   611 TInt CPeninputSplitQwertyWindow::BackgroundTaskL( TAny* aPtr )

   612     {

   613     CPeninputSplitQwertyWindow* self = static_cast<CPeninputSplitQwertyWindow*>(aPtr);

   614     self->DoIdleConstructL();

   615     return EFalse; // only run once

   616     }

   617 

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

   619 // Set current language

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

   621 //

   622 void  CPeninputSplitQwertyWindow::SetSwitchlistLanguage(TInt aLang)

   623     {

   624     ASSERT( IsValidLanguage( aLang ) );

   625     

   626     //Check language input direction change

   627     TBool isLangDirectionChange = EFalse;

   628     if ( IsValidLanguage( iLanguage ) )

   629         {

   630         isLangDirectionChange =  IsRtoLLanguage( aLang ) ^ IsRtoLLanguage( iLanguage );

   631         }

   632     else

   633         {

   634         isLangDirectionChange = IsRtoLLanguage( aLang );

   635         }

   636     

   637     TPeninputVkbLafOption option = iLafMgr->OptionType();

   638     if ( aLang ==ELangHebrew || aLang == ELangGreek || aLang == ELangHindi 

   639                                                     || aLang == ELangMarathi ) 

   640         {

   641         option = (TPeninputVkbLafOption)( option & ( ~EOption3CellRange ) );

   642         iLafMgr->SetLafOption( option );    

   643         }

   644     else

   645         {

   646         option = (TPeninputVkbLafOption)( option | EOption3CellRange );

   647         iLafMgr->SetLafOption( option );    

   648         }

   649             

   650     if( isLangDirectionChange )

   651         {

   652         //Mirror backspace graphic

   653         HandleButtonResOnLangDirChange( EPeninutWindowCtrlIdBackspaceBtn );

   654         }

   655             

   656     iLanguage = aLang;    

   657     }

   658 

   659 // ---------------------------------------------------------------------------

   660 // Set current editor is secret

   661 // ---------------------------------------------------------------------------

   662 //    

   663 void  CPeninputSplitQwertyWindow::SetSwitchlistSecretFlag( TBool aSecret )

   664     {

   665     CFepUiBaseCtrl* ctrl = Control( EPeninutWindowCtrlIdSwitcherPopupWindow );

   666     CPeninputLayoutInputmodelChoice* choice =

   667                         static_cast<CPeninputLayoutInputmodelChoice*>( ctrl );

   668     if ( choice )

   669         {

   670         choice->SetSecretEditor( aSecret );    

   671         }

   672     //disable or enable arrow keys of FSQ in secret editor.

   673     }

   674 

   675 // ---------------------------------------------------------------------------

   676 // Dim the arrow keys on qwerty when the editor is findpane or secret editor

   677 // ---------------------------------------------------------------------------

   678 //

   679 void CPeninputSplitQwertyWindow::DimArrowKeys( TBool aDimArrow )

   680     {

   681     if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ 

   682          && iArrowLeftButton && iArrowRightButton )

   683         {

   684         iArrowLeftButton->SetDimmed( aDimArrow );

   685         iArrowRightButton->SetDimmed( aDimArrow );

   686         }

   687     }

   688 

   689 // ---------------------------------------------------------------------------

   690 // Handle accented char event

   691 // ---------------------------------------------------------------------------

   692 //     

   693 TBool CPeninputSplitQwertyWindow::HandleAccentCharEvent( TInt /*aEventType*/, 

   694                                                     const TDesC& aEventData, 

   695                                                     const TDesC& aDeadKey, 

   696                                                     HBufC* anewCharBuf )

   697     {

   698     // Get the unicode of virtual key char

   699     TBuf<16> buf;

   700     TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();

   701     buf.Append( event->iCode );

   702     TBool rs = EFalse;

   703     

   704     // Caculate the accent char number

   705     TInt count = sizeof(KSupportLanguages)/sizeof(TLangMeritPair);

   706 

   707     if ( aDeadKey.Compare( KNullDesC ) != 0 ) // One DeadKey is latched

   708         {

   709         for ( TInt i = 0; i < count; i++ )

   710             {

   711             if ( ( aDeadKey[0] == KSupportLanguages[i].iDeadKey ) && 

   712                  ( buf[0] == KSupportLanguages[i].iChar) )

   713                 {

   714                 if ( anewCharBuf )

   715                     {

   716                     anewCharBuf->Des().Append( KSupportLanguages[i].iAccentedChar );

   717                     rs = ETrue;

   718                     }

   719                 break;

   720                 }

   721             }

   722         }

   723     return rs;

   724     }

   725 

   726 // ---------------------------------------------------------------------------

   727 // Handle virtual key latched event

   728 // ---------------------------------------------------------------------------

   729 //

   730 void CPeninputSplitQwertyWindow::HandleVirtualKeyLatchedEvent(TInt /*aEventType*/, 

   731                                                          CFepUiBaseCtrl* /*aCtrl*/, 

   732                                                          const TDesC& aEventData )

   733     {

   734     TBuf<16> deadKey(KNullDesC);

   735     TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();

   736     deadKey.Append(event->iCode);

   737         

   738     TInt latchedFlag = IntContext( EAkninputDataTypeLatchedSet );

   739     if ( latchedFlag )

   740         {

   741         // Update the new and old DeadKey buffer

   742         iOldDeadKeyBuf = iNewDeadKeyBuf;

   743         iNewDeadKeyBuf = deadKey;

   744 

   745         // When type another DeadKey, submit the previous one.

   746         UiLayout()->SignalOwner( ESignalKeyEvent, iOldDeadKeyBuf );

   747         // Unlatch the previous DeadKey

   748         UnLatchDeadKey(iOldDeadKeyBuf);

   749         }

   750     else

   751         {

   752         iNewDeadKeyBuf = deadKey;

   753         

   754         // Set DeadKey state to latched

   755         TBool deadKeyChange = ETrue;

   756         iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );

   757         }

   758    

   759     // Send the char to FEP

   760     // Not submit the DeadKey when latch it.

   761 //    UiLayout()->SignalOwner( ESignalKeyEvent, iNewDeadKeyBuf );

   762     }

   763 

   764 // ---------------------------------------------------------------------------

   765 // Handle virtual key up event

   766 // ---------------------------------------------------------------------------

   767 //

   768 TBool CPeninputSplitQwertyWindow::HandleVirtualKeyUpEvent(TInt aEventType, 

   769                                                     CFepUiBaseCtrl* /*aCtrl*/, 

   770                                                     const TDesC& aEventData )

   771     {

   772     // Get DeadKey state

   773     TInt latchedFlag = IntContext( EAkninputDataTypeLatchedSet );

   774     if ( latchedFlag )

   775         {

   776         TBool ret = EFalse;

   777         

   778         TRAP_IGNORE( ret = HandleDeadKeyL( aEventType, aEventData ) );

   779         

   780         if ( ret )

   781             {

   782             return ETrue;    

   783             }

   784         else

   785             {

   786             // When the DeadKey can not combine with current character,

   787             // Sumit current DeadKey

   788             UiLayout()->SignalOwner( ESignalKeyEvent, iNewDeadKeyBuf );

   789             }

   790         }

   791         

   792     iNewDeadKeyBuf = KNullDesC;

   793     return EFalse;

   794     } 

   795 

   796 // ---------------------------------------------------------------------------

   797 // Set dead key

   798 // ---------------------------------------------------------------------------

   799 //     

   800 void CPeninputSplitQwertyWindow::SetDeadKey()

   801     {

   802     // Get VKB list

   803     RPointerArray<CPeninputVkbLayoutInfo> vkbListInfo;

   804     vkbListInfo = iVkbLayout->VkbLayoutInfoList();

   805     TInt vkbListNum = vkbListInfo.Count();

   806     

   807     CPeninputVkbKeyInfo* keyinfo;

   808     TInt count = sizeof(KSupportLanguages)/sizeof(TLangMeritPair);

   809     for ( TInt i = 0; i < vkbListNum; i++ )

   810         {

   811         for ( TInt j = 0; j < count; j++ )

   812             {

   813             if ( vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeChar ||

   814                  vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeCharShift )

   815                 {

   816                 keyinfo = vkbListInfo[i]->FindKey( KSupportLanguages[j].iDeadKey );

   817                 if ( keyinfo )

   818                     {

   819                     // Set the DeadKey as a latch button

   820                     CVirtualKey* key = keyinfo->Key();

   821                     key->SetLatchKey( ETrue );

   822                     }

   823                 }

   824             }

   825         }

   826     }

   827     

   828     

   829 // ---------------------------------------------------------------------------

   830 // Unlatch a DeadKey by the key buffer

   831 // ---------------------------------------------------------------------------

   832 //     

   833 void CPeninputSplitQwertyWindow::UnLatchDeadKey( const TDesC& abuf )

   834     {

   835     RPointerArray<CPeninputVkbLayoutInfo> vkbListInfo;

   836     vkbListInfo = iVkbLayout->VkbLayoutInfoList();

   837     TInt vkbListNum = vkbListInfo.Count();

   838     

   839     CPeninputVkbKeyInfo* keyinfo;

   840     TInt count = sizeof(KSupportLanguages)/sizeof(TLangMeritPair);

   841     for ( TInt i = 0; i < vkbListNum; i++ )

   842         {

   843         for ( TInt j = 0; j < count; j++ )

   844             {

   845             // Only NativeChar and NativeCharShift layout contain DeadKey

   846             if(vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeChar ||

   847                vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeCharShift)

   848                 {

   849                 // Find the DeadKey in NativeChar or NativeCharShift layout

   850                 keyinfo = vkbListInfo[i]->FindKey( KSupportLanguages[j].iDeadKey );

   851                 if ( keyinfo )

   852                     {

   853                     CVirtualKey* key = keyinfo->Key();

   854                     if ( key->Latched() )

   855                         {

   856                         if ( abuf == KNullDesC )

   857                             {

   858                             // When focus change, the latched key will be released

   859                             TBool deadKeyChange = EFalse;

   860                             iLayoutContext->SetData( EAkninputDataTypeLatchedSet, 

   861                                                      &deadKeyChange );

   862                             key->SetLatched( EFalse );

   863                             TRect rect = key->Rect();

   864                             rect.Move( iVkbCtrl->Rect().iTl );

   865                             UpdateArea( rect, EFalse ); 

   866                             return;

   867                             }

   868                         if ( abuf[0] == KSupportLanguages[j].iDeadKey )

   869                             {

   870                             // When another DeadKey is clicked, the old one will be released

   871                             key->SetLatched( EFalse );

   872                             TRect rect = key->Rect();

   873                             rect.Move( iVkbCtrl->Rect().iTl );

   874                             UpdateArea( rect, EFalse ); 

   875                             return;

   876                             }

   877                         }

   878                     }

   879                 }

   880             }

   881         }

   882     }

   883 

   884 // ---------------------------------------------------------------------------

   885 // Update laf data

   886 // ---------------------------------------------------------------------------

   887 //

   888 void CPeninputSplitQwertyWindow::UpdateLafData()

   889     {

   890     TRAP_IGNORE( iLafMgr->UpdateLafDataL() );

   891     }

   892 

   893 // ---------------------------------------------------------------------------

   894 // Load accent labels for range list

   895 // ---------------------------------------------------------------------------

   896 //

   897 void CPeninputSplitQwertyWindow::ConstructAccentListL( TInt aLangId )

   898     {  

   899     iAccentCmdList.Reset();

   900     

   901     TBool is10x3 = ( aLangId == ELangEnglish ) || ( aLangId == ELangAmerican )

   902                    || ( aLangId == ELangDutch)  || (aLangId == ELangTagalog ) 

   903                    || ( aLangId == ELangIndonesian) || (aLangId == ELangMalay );

   904     

   905     if ( aLangId == ELangVietnamese )

   906         {

   907         _LIT( KVietAccentList1, "\x00E0 - \x013A" );

   908         _LIT( KVietAccentList2, "\x013C - \x017E" );

   909         

   910         CFepLayoutChoiceList::SItem item;

   911 

   912         item.iCommand = EPeninputVkbLayoutAccented1;

   913         item.iText.Copy( KVietAccentList1 );      

   914         iAccentCmdList.Append( item );

   915         

   916         item.iCommand = EPeninputVkbLayoutAccented2;

   917         item.iText.Copy( KVietAccentList2 );

   918         iAccentCmdList.Append( item );

   919         }

   920     

   921     // 10X3

   922     else if ( is10x3 )

   923         {

   924         _LIT( KVietAccentList1, "\x00E0 - \x0121" );

   925         _LIT( KVietAccentList2, "\x0123 - \x014F" );

   926         _LIT( KVietAccentList3, "\x0151 - \x017E" );

   927         

   928         CFepLayoutChoiceList::SItem item;

   929 

   930         item.iCommand = EPeninputVkbLayoutAccented1;

   931         item.iText.Copy( KVietAccentList1 );

   932         iAccentCmdList.Append( item );

   933         

   934         item.iCommand = EPeninputVkbLayoutAccented2;

   935         item.iText.Copy( KVietAccentList2 );

   936         iAccentCmdList.Append( item );

   937 

   938         

   939         item.iCommand = EPeninputVkbLayoutAccented3;

   940         item.iText.Copy( KVietAccentList3 );

   941         iAccentCmdList.Append( item );

   942         }

   943     //10X4

   944     else

   945         {

   946         // Add item

   947         TResourceReader reader;

   948         CFepLayoutChoiceList::SItem item;

   949 

   950         item.iCommand = EPeninputVkbLayoutAccented1;

   951         CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT1 );

   952         TPtrC p1 = reader.ReadTPtrC();

   953         item.iText.Copy( p1 );

   954         iAccentCmdList.Append( item );

   955         CleanupStack::PopAndDestroy( 1 ); //reader

   956         

   957         item.iCommand = EPeninputVkbLayoutAccented2;

   958         CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT2 );

   959         TPtrC p2 = reader.ReadTPtrC();

   960         item.iText.Copy( p2 );

   961         iAccentCmdList.Append( item );

   962         CleanupStack::PopAndDestroy( 1 ); //reader

   963         

   964         item.iCommand = EPeninputVkbLayoutAccented3;

   965         CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT3 );

   966         TPtrC p3 = reader.ReadTPtrC();

   967         item.iText.Copy( p3 );

   968         iAccentCmdList.Append( item );

   969         CleanupStack::PopAndDestroy( 1 );//reader          

   970         }

   971 

   972     iPopupInited = ETrue;

   973     iPopupSet = ETrue;

   974     }

   975 

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

   977 // Load range labels for range list

   978 // ---------------------------------------------------------------------------

   979 //

   980 void CPeninputSplitQwertyWindow::ConstructRangeLabelListL( TInt aLangId )

   981     {

   982     iRangeLabels.iLabelNativeChar.Zero();

   983     iRangeLabels.iLabelNativeNumber.Zero();

   984     iRangeLabels.iLabelLatinChar.Zero();

   985     iRangeLabels.iLabelLatinNumber.Zero();

   986     iRangeLabels.iLabelSymbol.Zero();

   987     iRangeLabels.iLabelAccent.Zero();

   988     

   989     TInt resid = -1;

   990     switch ( aLangId )

   991         {

   992         case 16: //Cyrillic

   993         case 42:

   994         case 93:

   995             {

   996             resid = R_PENINPUT_LAYOUT_VKB_RANGES_CYRILLIC;

   997             }

   998             break;

   999         

  1000         case 54: //Greek

  1001         case 55:

  1002             {

  1003             resid = R_PENINPUT_LAYOUT_VKB_RANGES_GREEK;

  1004             }

  1005             break;        

  1006         case 57: //Hebrew

  1007             {

  1008             resid = R_PENINPUT_LAYOUT_VKB_RANGES_HEBREW;

  1009             }

  1010             break;  

  1011         case 37: //Arabic

  1012             {

  1013             resid = R_PENINPUT_LAYOUT_VKB_RANGES_ARABIC;

  1014             }

  1015             break;

  1016         case 50://Farsi

  1017             {

  1018             resid = R_PENINPUT_LAYOUT_VKB_RANGES_FARSI;

  1019             }

  1020             break;

  1021         case 94: //Urdu

  1022             {

  1023             resid = R_PENINPUT_LAYOUT_VKB_RANGES_URDU;

  1024             }

  1025             break;

  1026         case 33: //Thai

  1027             {

  1028             resid = R_PENINPUT_LAYOUT_VKB_RANGES_THAI;

  1029             }

  1030             break;

  1031         case 29: //chinese

  1032         case 30:

  1033         case 31:

  1034             break;

  1035         case 58: //Devanagiri

  1036         case 72:

  1037             {

  1038             resid = R_PENINPUT_LAYOUT_VKB_RANGES_DEVANAGIRI;

  1039             }

  1040             break;

  1041         default: //Latin        

  1042             {

  1043             //1,   2,   3,   4,   5,   6,   7,   8,   9,   10, 

  1044             //11,  12,  13,  14,  15,  17,  18,  20,  21,  22,  

  1045             //23,  24,  25,  26,  27,  28,  39,  44,  45,  46,  

  1046             //47,  48,  49,  51,  59,  67,  68,  70,  76,  78,  

  1047             //79,  82,  83,  85,  91,  96,  102, 103, 401, 402

  1048             resid = R_PENINPUT_LAYOUT_VKB_RANGES_LATIN;

  1049             }

  1050         }

  1051     

  1052     TResourceReader reader;   

  1053     CCoeEnv::Static()->CreateResourceReaderLC( reader, resid );

  1054     TPtrC ptr1 = reader.ReadTPtrC();

  1055     TPtrC ptr2 = reader.ReadTPtrC();

  1056     TPtrC ptr3 = reader.ReadTPtrC();

  1057     TPtrC ptr4 = reader.ReadTPtrC();

  1058     TPtrC ptr5 = reader.ReadTPtrC();

  1059     TPtrC ptr6 = reader.ReadTPtrC();

  1060     

  1061     iRangeLabels.iLabelNativeChar.Copy( ptr1 );

  1062     iRangeLabels.iLabelNativeNumber.Copy( ptr2 );

  1063     iRangeLabels.iLabelLatinChar.Copy( ptr3 );

  1064     iRangeLabels.iLabelLatinNumber.Copy( ptr4 );

  1065     iRangeLabels.iLabelSymbol.Copy( ptr5 );

  1066     iRangeLabels.iLabelAccent.Copy( ptr6 );

  1067     

  1068     CleanupStack::PopAndDestroy( 1 ); //reader        

  1069     }

  1070 

  1071 // ---------------------------------------------------------------------------

  1072 // Show or hide preview bubble

  1073 // ---------------------------------------------------------------------------

  1074 //

  1075 void CPeninputSplitQwertyWindow::ShowBubble( TInt aShow )

  1076     {

  1077     iVkbCtrl->ShowBubble( EFalse ); 

  1078     }

  1079 

  1080 // ---------------------------------------------------------------------------

  1081 // Update state of range button

  1082 // ---------------------------------------------------------------------------

  1083 //

  1084 void CPeninputSplitQwertyWindow::UpdateRangeCtrlsL()

  1085     {

  1086     TInt currentRange = IntContext( EPeninputDataTypeCurrentRange );

  1087     

  1088     TInt resid = ConfigInfo()->RangebarResId();

  1089     

  1090     TResourceReader reader;

  1091     

  1092     CCoeEnv::Static()->CreateResourceReaderLC( reader, resid ); 

  1093     

  1094     TInt count = reader.ReadInt16();

  1095     for ( TInt i = 0; i < count; i++ )

  1096         {

  1097         const TInt16 rangeId = reader.ReadInt16();

  1098         const TInt16 rangeType = reader.ReadInt16();

  1099         const TInt16 ctrlId = reader.ReadInt16();

  1100         const TInt16 ctrlType = reader.ReadInt16(); 

  1101         const TInt32 ctrlResId = reader.ReadInt32();

  1102         const TInt actionStyle = reader.ReadInt16();

  1103         TBool hide = reader.ReadInt16();

  1104         TInt posidx = reader.ReadInt16();        

  1105         

  1106         if ( currentRange == rangeId )

  1107             {

  1108             iRangeButton->SetResourceId( ctrlResId );

  1109             iRangeButton->ConstructFromResourceL();

  1110             break;

  1111             }

  1112         }

  1113     

  1114     // Pop and destroy reader

  1115     CleanupStack::PopAndDestroy( 1 );

  1116     

  1117     }

  1118 

  1119 // ---------------------------------------------------------------------------

  1120 // Update layout position and size

  1121 // ---------------------------------------------------------------------------

  1122 //

  1123 void CPeninputSplitQwertyWindow::UpdateLayoutPosAndSize()

  1124     {

  1125     if ( iLafMgr )

  1126         {

  1127         TRect rect = iLafMgr->ClientRect();

  1128         TPoint pos = iLafMgr->EntirePaneRect().iTl;

  1129         

  1130         UiLayout()->SetRect( rect );

  1131         UiLayout()->LayoutOwner()->SetPosition( pos );

  1132         }

  1133     }

  1134