/*
* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0""
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Implementation of vkb window class
*
*/

// System includes
#include <peninputssqwin.rsg>
#include <peninputssqwinconfiginfo_01.rsg>
#include <aknfeppeninputenums.h>
#include <peninputinputcontextfield.h>
#include <peninputpluginutils.h>
#include <peninputcommonlayoutext.h>
#include <peninputvkbctrllayout.h>
#include <peninputvkbctrlext.h>
#include <peninputeventbutton.h>
#include <peninputdragbutton.h>
#include <peninputrepeatbutton.h>
#include <peninputmultimodebutton.h>
#include <peninputrangebar.h>
#include <peninputdataconverter.h>
#include <peninputdataprovider.h>
#include <peninputclientlayoutinfo.h>
#include <peninputlayoutchoicelist.h>
#include <aknlayoutscalable_apps.cdl.h>
#include <peninputlayoutbubblectrl.h>
#include <peninputscrollablelist.h>
#include <e32keys.h>
#include <AknIconUtils.h>
#include <AknLayoutDef.h>
#include <AknUtils.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <AknsUtils.h>
#include <AknFepGlobalEnums.h>
#include <peninputlayoutinputmodechoice.h>
#include <peninputlayoutmultilineicf.h>
#include <s32mem.h>

// User includes
#include "peninputsplitqwerty.hrh"
#include "peninputsplitqwertywindow.h"
#include "peninputsplitqwertyenum.h"
#include "peninputrangebarinfo.h"
#include "peninputsplitqwertylafdatamgr.h"
#include "peninputsplitqwertylangmeritpair.h"
#include "peninputsplitqwertylayout.h"

#include <peninputaknvkbpreviewbubblerenderer.h>
#include <peninputlongpressbutton.h>

// Constants
const TInt KPeninputVkbWndInvalidIndex = -1;
const TInt KInvalidImg = -1 ;
const TInt KKeyCodeSize = 1;
const TInt KKeyDouble = 2;

_LIT( KVkbWindowResourceFile, "z:\\resource\\plugins\\peninputssqwin.rsc" );
_LIT( KConfigurationResourceFile, "z:\\resource\\plugins\\peninputssqwinconfiginfo_" );
_LIT( KResourceFileExtName, ".rsc" );

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

// ---------------------------------------------------------------------------
// Symbian constructor
// ---------------------------------------------------------------------------
// 
CPeninputSplitQwertyWindow* CPeninputSplitQwertyWindow::NewL(
                                        CFepUiLayout* aUiLayout, 
                                        MPeninputLayoutContext* aLayoutContext, 
                                        MPeninputUiStateMgr* aUiStateMgr )
    {
    CPeninputSplitQwertyWindow* 
        self = new ( ELeave ) CPeninputSplitQwertyWindow( aUiLayout,
                                                          aLayoutContext, 
                                                          aUiStateMgr );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

// ---------------------------------------------------------------------------
// C++ destructor
// ---------------------------------------------------------------------------
//
CPeninputSplitQwertyWindow::~CPeninputSplitQwertyWindow()
    {
    delete iIdle;
    iUnits.Close();
    
    delete iLafMgr;
    iLafMgr = NULL;
    delete iBmpRotator;
    
    iAccentCmdList.Close();
    }

// ---------------------------------------------------------------------------
// Get id of window config resource
// ---------------------------------------------------------------------------
//
TInt CPeninputSplitQwertyWindow::GetWindowConfigResId()
    {
    return R_PENINPUT_LAYOUT_CONFIG_INFO;
    }

// ---------------------------------------------------------------------------
// Get id of window resource
// ---------------------------------------------------------------------------
//
TInt CPeninputSplitQwertyWindow::GetWindowResId()
    {
    return R_PENINPUT_LAYOUT_FSQ_WINDOW_INFO;
    }

// ---------------------------------------------------------------------------
// Get resource id of numeric keymapping
// ---------------------------------------------------------------------------
//
TInt CPeninputSplitQwertyWindow::GetNumKeymappingResId()
    {
    return R_PENINPUT_LAYOUT_KEY_MAPPING_STRING_LIST;
    }

// ---------------------------------------------------------------------------
// Get file name of window config resource
// ---------------------------------------------------------------------------
//
const TDesC& CPeninputSplitQwertyWindow::GetWindowConfigResFileName( TInt aLangID )
    {
    if ( aLangID <= 0 ) 
        {
        return KNullDesC;
        }
        
    iResourceFilename.Zero();
    // Generate resource file name according to language id
    iResourceFilename = KConfigurationResourceFile();
    
    if ( aLangID < 10 )
        {
        iResourceFilename.AppendNum( 0 );
        iResourceFilename.AppendNum( aLangID );
        }
    else
        {
        iResourceFilename.AppendNum( aLangID );
        }
    iResourceFilename.Append( KResourceFileExtName );
    
    return iResourceFilename;
    }

// ---------------------------------------------------------------------------
// Get file name of window resource
// ---------------------------------------------------------------------------
//
const TDesC& CPeninputSplitQwertyWindow::GetWindowResFileName()
    {
    return KVkbWindowResourceFile();
    }

// ---------------------------------------------------------------------------
// Change unit size
// ---------------------------------------------------------------------------
//
const TRect CPeninputSplitQwertyWindow::ChangeUnitSize()
    {
    return TRect();
    }

// ---------------------------------------------------------------------------
// Change size of client area
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::ChangeClientSize()
    {
    if ( !iPopupWnd->Hiden() )
        {
        iPopupWnd->CloseWindow();
        iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );
        }
        
    HandlePopupSizeChange();
            
    TInt clientLayoutId = IntContext( EPeninputDataTypeClientLayout );
    CPeninputClientLayoutInfo* 
        clientLayout = ConfigInfo()->FindClientLayoutInfo( clientLayoutId );
        
    if ( clientLayout )
        {
        ReorganizeControls( clientLayout->LayoutID(), EFalse );
        } 

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

// ---------------------------------------------------------------------------
// Construct all controls specified in resource
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::CreateAllControlsL()
    {
    // Range bar
    AddRangeBarL();

    // Vkb control
    iVkbCtrl = CPeninputVkbCtrlExt::NewL( TRect(), 
                                          UiLayout(), 
                                          EPeninutWindowCtrlIdVkbCtrl, 
                                          NULL  );
    
    iVkbCtrl->SetResourceId( R_PENINPUT_LAYOUT_VKB_KEYBOARD );
    iVkbCtrl->ConstructFromResourceL();
    iVkbCtrl->SetKeyTextColorGroup( EAknsCIQsnTextColorsCG68 );
    iVkbLayout->SetVkbKeyboard( iVkbCtrl );
    
    iVkbCtrl->SetIrregularKeyBoard( EFalse );
    iVkbLayout->SetNonIrregularResourceId( R_AKN_FEP_VKB_NONIRREGULAR_BITMAP );
    iVkbLayout->ConstructFromNonIrregularResourceL();        

    //todo split-view FSQ, bubble support
    CPeninputAknVkbPreviewBubbleRenderer* renderer = CPeninputAknVkbPreviewBubbleRenderer::NewL();
    iVkbCtrl->SetPreviewBubbleRenderer( renderer );
    iVkbCtrl->ShowBubble( ETrue );    
    iVkbCtrl->SetGowithPointerDown( ETrue );
    iVkbCtrl->SetBubbleBitmapParam( NULL, NULL, KAknsIIDQsnFrInputCharPreview ); 
    iVkbCtrl->SetBubbleSize( TSize(80,80) ); //todo preview-bubble
       
    //set key to be 9 piece graphics
    iVkbCtrl->SetKeySkinId( EKeyBmpNormal, KAknsIIDQsnFrKeypadButtonFrNormal );
    iVkbCtrl->SetKeySkinId( EKeyBmpHighlight, KAknsIIDQsnFrKeypadButtonFrPressed );
    iVkbCtrl->SetKeySkinId( EKeyBmpDim, KAknsIIDQsnFrKeypadButtonFrInactive );
    
    AddControlL( iVkbCtrl );
    iVkbCtrl->AddEventObserver( UiLayout() );
    
    AddButtonL( EPeninutWindowCtrlIdEnterBtn, 
                EPeninputLayoutEventEnter, 
                R_PENINPUT_LAYOUT_VKB_ENTER, 
                EKeyEnter );
       
    // Shift and capslock merged button

    CAknFepCtrlMultiModeButton* button = CAknFepCtrlMultiModeButton::NewLC( 
                                                UiLayout(), 
                                                EPeninutWindowCtrlIdShiftBtn );
    if ( button )
        {
        // Read resource
        TInt resid = R_PENINPUT_LAYOUT_VKB_SHIFT_CAPSLOCK;
        TResourceReader reader;
        CCoeEnv::Static()->CreateResourceReaderLC( reader, resid );
        button->SetResourceId( resid );      
        button->ConstructFromResourceL();  
        
        CleanupStack::PopAndDestroy( 1 ); //reader
        
        AddControlL( button );
        button->AddEventObserver( UiLayout() );
        }
    CleanupStack::Pop( button );  

    
    // Space button          
    CAknFepCtrlEventButton* spaceButton = EventButtonCtrl( 
                                                EPeninutWindowCtrlIdSpaceBtn ); 

    // Create 3-pieces color icon for space button
    CPenInput3PiecesColorIcons* colorIcons = NULL;
    colorIcons = CPenInput3PiecesColorIcons::NewL( R_AKN_FEP_VKB_SPACE_ICON1,
                                                   R_AKN_FEP_VKB_SPACE_ICON2,
                                                   R_AKN_FEP_VKB_SPACE_ICON3 );
    
    spaceButton->Set3PiecesColorIcons( colorIcons );
    
    //set background of space button to be 9 piece graphics
    spaceButton->SetImageFrameId( KAknsIIDQsnFrKeypadButtonFrNormal, 
                                  KAknsIIDQsnFrKeypadButtonFrPressed,
                                  KAknsIIDQsnFrKeypadButtonFrInactive );

    // Add popup window
    AddPopupWindowL();
  
    }

// ---------------------------------------------------------------------------
// Set control fonts. Fonts info comes from resource
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::SetControlsFont()
    {
    }

// ---------------------------------------------------------------------------
// Pop up choice list
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::PopupChoiceList()
    {
    TRAP_IGNORE( PopupRangeListL() );
    }

// ---------------------------------------------------------------------------
// Re-organize all controls in the assigned client area layout
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::ReorganizeControls( TInt aClientLayoutId,
                                                     TBool aNeedReset )
    {
    CPeninputClientLayoutInfo* clientLayout = 
        ConfigInfo()->FindClientLayoutInfo( aClientLayoutId ); 
    RPointerArray<CPeninputControlInfo>& controlList = 
        clientLayout->ControlInfoList();
  
    const TInt keyColumns = clientLayout->Columns();
    const TInt keyRows = clientLayout->Rows();
    
    if ( iLastUsedTotalColumns == keyColumns && iLastUsedTotalRows == keyRows )
        {
        return;
        }    

    iLafMgr->SetLayoutType(
                iLafMgr->LayoutTypeFromRowsColumns( keyRows, keyColumns )
                );
    
    iLastUsedTotalColumns = keyColumns;
    iLastUsedTotalRows = keyRows;
    
    TRect winRect( Rect().iTl, iLafMgr->EntirePaneRect().Size() );        
    SetWindowRect( winRect );    
    UiLayout()->LayoutOwner()->SetPosition( iLafMgr->EntirePaneRect().iTl );
    
    ReorgnizeTitleBar();
    
    const TInt count = controlList.Count();
    TInt controlID = 0;
    CFepUiBaseCtrl* ctrl = NULL;
    TRect rect;
    TRect inRect;
    TRect exRect;

    TPoint winPoint = Rect().iTl;
    TPoint LafPoint = iLafMgr->EntirePaneRect().iTl;
    
    for ( TInt i = 0; i < count; i++ )
        {
        controlID = controlList[i]->ControlID();
        ctrl = Control( controlID );

        if ( !ctrl )
            {
            continue;
            }
        
        AddNotOwnedControl( ctrl );
        
        if ( ( ctrl->ControlType() | ECtrlButton ) == ECtrlButton )
            {
            
            iLafMgr->GetButtonRect( 
                            TPeninputCommonCtrlID(ctrl->ControlId() ), 
                            exRect, inRect );
            
            if( controlID ==  EPeninutWindowCtrlIdShiftBtn)
                {
                CAknFepCtrlMultiModeButton* btn = NULL;
                btn = static_cast<CAknFepCtrlMultiModeButton*>(ctrl);
                btn->SizeChanged( exRect, inRect, ETrue );
                }
            else
                {
                CAknFepCtrlCommonButton* btn = NULL;
                btn = static_cast<CAknFepCtrlCommonButton*>(ctrl);
                
                if ( ctrl->ControlId() == EPeninutWindowCtrlIdSpaceBtn )
                    {
                    // config 3 pieces icon info       
                    TRect frameRect, middleRect;
                    iLafMgr->GetSpaceButtonExLayoutInfo( frameRect, middleRect );
                    inRect = frameRect;
                    
                    TDraw3PiecesFrame pic3frame( 
                            KAknsIIDQgnIndiInputSpaceL,
                            KAknsIIDQgnIndiInputSpaceMiddle,
                            KAknsIIDQgnIndiInputSpaceR,
                            middleRect);
                    
                    btn->SetDraw3PieceFrameInfo( pic3frame );
                    }
                
                btn->SizeChanged( exRect, inRect, ETrue );
                }
            }
        
        else if ( ctrl->ControlId() == EPeninutWindowCtrlIdVkbCtrl )
            {
            iVkbCtrl->SetFont( iLafMgr->KeyTextFont() );
            iVkbCtrl->SetTextLineLayout( iLafMgr->KeyTextLayout() );
            iVkbCtrl->SetTextFormat( iLafMgr->PreviewWndText() );  //Read laf 
            if ( aNeedReset )
                {
                iVkbCtrl->Reset();
                }

            rect = iLafMgr->KeypadRect();
            CPeninputVkbCtrlExt* ctrlext = static_cast<CPeninputVkbCtrlExt*>(ctrl);
            ctrlext->SizeChanged(rect);
            }  
        }  
    }

// ---------------------------------------------------------------------------
// Do when case changed
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::DoCaseChange( TInt aNewCase )
    {
    TInt curCase = IntContext( EPeninputDataTypeCase );
    
    if ( aNewCase == curCase )
        {
        return;
        }
        
    TInt curRange = IntContext( EPeninputDataTypeCurrentRange ); 
                               
    if ( ( curRange == ERangeEnglish ) 
         || ( curRange == ERangeAccent ) 
         || ( curRange == ERangeNative && ConfigInfo()->CaseSensitive() ) 
       )
        {
        // Set shift and caplock button
        TInt shfit;  
        TInt capslock;  
        
        CPeninputDataConverter::ShiftCapslockByCase( aNewCase, shfit, capslock );

        iLayoutContext->SetData( EPeninputDataTypeShiftDown, &shfit ); 
        iLayoutContext->SetData( EPeninputDataTypeCapslockDown, &capslock );        
        iLayoutContext->SetData( EPeninputDataTypeCase, &aNewCase ); 
        ChangeMergedButtonStatus( shfit, capslock );
        
        TInt vkblayout = ConfigInfo()->ShiftCapsSingleVkbLayoutByCase( curRange, 
                                                                       aNewCase );

        if ( curRange == ERangeAccent ) 
           {
           TInt curAccentIndex = IntContext( EPeninputDataTypeCurrentAccent );
           vkblayout = vkblayout + curAccentIndex * 2;
           }
        
        ChangeVkbLayout( vkblayout );
        }
    }

// ---------------------------------------------------------------------------
// Handle control event
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::HandleControlEvent( TInt aEventType,
                                                    CFepUiBaseCtrl* aCtrl, 
                                                    const TDesC& aEventData )
    {
    // Call this function in base class
    CPeninputLayoutWindowExt::HandleControlEvent( aEventType, aCtrl, 
                                                  aEventData );
    
    TInt* data = (TInt*) aEventData.Ptr(); 
    TInt ctrlId = aCtrl ? aCtrl->ControlId() : -1;
    
    switch ( aEventType )
        {
        case EPeninputLayoutEventMultiRangeLongPress:
            {
            if ( ctrlId == EPeninutWindowCtrlIdRangeBtn )
                {
                // Before pop up list, cancel down event, and set range button un-highlight.
                TRAP_IGNORE( aCtrl->CancelPointerDownL());
                static_cast<CAknFepCtrlCommonButton*>(aCtrl)->SetHighlight( EFalse );
                PopupChoiceList();                
                }
            }
            break;
        case EPeninputLayoutEventMultiRange:
            {
            if ( ctrlId == EPeninutWindowCtrlIdRangeBtn )
                {
                if ( iHandleRangeShortPress )
                    {
                    HandleRangeButtonShortPress();
                    }
                }
            
            iHandleRangeShortPress = ETrue;
            }
            break;
        case EPeninputLayoutVkbEventResetShift: 
            {
            HandleShiftAndCapslockBtnClicked();
            }
            break;  
        case EPenInputLayoutEventClosePopup:
            {
            if ( iPopupWnd && !iPopupWnd->Hiden() )
                {
                iPopupWnd->CloseWindow();
                iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );
                }
            }
            break;
        case EEventChoiceSelected:
            {
            CFepUiBaseCtrl* btn = Control( EPeninutWindowCtrlIdRangeBtn );
            
            if ( btn )
                {
                iHandleRangeShortPress = EFalse;
                TRAP_IGNORE( btn->HandlePointerUpEventL( btn->Rect().iBr ) );
                iHandleRangeShortPress = ETrue;
                }
            CFepLayoutChoiceList::SEvent* event = NULL;
            event = (CFepLayoutChoiceList::SEvent*) aEventData.Ptr();

            if ( event->iIndex != KPeninputVkbWndInvalidIndex )
                {
                if ( ctrlId == EPeninutWindowCtrlIdAccentPopupWindow )
                    {
                    TRAP_IGNORE( HandleRangeListSelectedL( aCtrl, aEventData ) );
                    }
                }
            iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );
            }
            break;
        case EEventVirtualKeyLatched:
            {
            HandleVirtualKeyLatchedEvent( aEventType, aCtrl, aEventData );
            }
            break;
        case EEventVirtualKeyUnLatched:
            {
            // Sumbit Deadkey
            TRAP_IGNORE( SubmitDeadKeyL( iNewDeadKeyBuf ) );
             
            TBool deadKeyChange = EFalse;
            iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );
            iNewDeadKeyBuf = KNullDesC;
            }
            break;
        case EPeninputLayoutEventBack:
            {
            TInt latchedFlag = IntContext( EAkninputDataTypeLatchedSet );
            // If one DeadKey is latched, 
            // only unlatch the DeadKey and reset the iNewDeadKeyBuf
            // Don't delete the visible charater in ICF
            if ( latchedFlag )
                {
                UnLatchDeadKey(iNewDeadKeyBuf);

                TBool deadKeyChange = EFalse;
                iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );
                iNewDeadKeyBuf = KNullDesC;
                }
            }
            break;
        case EPeninputLayoutEventEnter:
        case EPeninputLayoutEventSpace:
            {
            TInt latchedFlag = IntContext( EAkninputDataTypeLatchedSet );
            if ( latchedFlag )
                {
                HBufC* newCharBuf = HBufC::New( KKeyDouble * iNewDeadKeyBuf.Length() 
                                                + aEventData.Length() );
                if( newCharBuf )
                    {
                    CPeninputSplitQwertyLayout* layout 
                         = static_cast<CPeninputSplitQwertyLayout*>( UiLayout() );
                    if( layout->IsEnableITI() )
                        {
                        // If ITI is open, double same keys should be send for one dead key,
                        // core will handle them as one key.                    
                        newCharBuf->Des().Append( iNewDeadKeyBuf );
                        }
                    newCharBuf->Des().Append( iNewDeadKeyBuf );
                    newCharBuf->Des().Append( aEventData );
                    }
                
                UnLatchDeadKey( iNewDeadKeyBuf );

                TBool deadKeyChange = EFalse;
                iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );
                
                // Submit DeadKey + Space or Enter at the same time
                
                if( newCharBuf != NULL )
                    {
                    UiLayout()->SignalOwner( ESignalKeyEvent, *newCharBuf );
                    }
                iNewDeadKeyBuf = KNullDesC;
                delete newCharBuf;
                newCharBuf = NULL;
                }
            }
            break;
        default:
            break;
        }
    }

// ---------------------------------------------------------------------------
// load settings from resource
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::ConstructFromResourceL()
    {                 
    CPeninputLayoutWindowExt::ConstructFromResourceL();
    if ( iVkbLayout && !iFirstConstruct )
        {
        if ( iVkbCtrl->IsIrregularKeyBoard() )
            {
            iVkbLayout->ConstructFromIrregularResourceL();
            }
        else
            {
            iVkbLayout->ConstructFromNonIrregularResourceL();
            }
        
        SetVkbLayoutSize();
        
        if ( IsRtoLLanguage( iLanguage ) )
            {
            //Mirror backspace graphic
            HandleButtonResOnLangDirChange( EPeninutWindowCtrlIdBackspaceBtn );
            }
        }
        
    iFirstConstruct = EFalse;
    iHandleRangeShortPress = ETrue;
    }

// ---------------------------------------------------------------------------
// Callback function to do background construction
// ---------------------------------------------------------------------------
//
TInt CPeninputSplitQwertyWindow::BackgroundTaskL( TAny* aPtr )
    {
    CPeninputSplitQwertyWindow* self = static_cast<CPeninputSplitQwertyWindow*>(aPtr);
    self->DoIdleConstructL();
    return EFalse; // only run once
    }

// ---------------------------------------------------------------------------
// Set current language
// ---------------------------------------------------------------------------
//
void  CPeninputSplitQwertyWindow::SetSwitchlistLanguage(TInt aLang)
    {
    ASSERT( IsValidLanguage( aLang ) );
    
    //Check language input direction change
    TBool isLangDirectionChange = EFalse;
    if ( IsValidLanguage( iLanguage ) )
        {
        isLangDirectionChange =  IsRtoLLanguage( aLang ) ^ IsRtoLLanguage( iLanguage );
        }
    else
        {
        isLangDirectionChange = IsRtoLLanguage( aLang );
        }
    
    TPeninputVkbLafOption option = iLafMgr->OptionType();
    if ( aLang ==ELangHebrew || aLang == ELangGreek || aLang == ELangHindi 
                                                    || aLang == ELangMarathi ) 
        {
        option = (TPeninputVkbLafOption)( option & ( ~EOption3CellRange ) );
        iLafMgr->SetLafOption( option );    
        }
    else
        {
        option = (TPeninputVkbLafOption)( option | EOption3CellRange );
        iLafMgr->SetLafOption( option );    
        }
            
    if( isLangDirectionChange )
        {
        //Mirror backspace graphic
        HandleButtonResOnLangDirChange( EPeninutWindowCtrlIdBackspaceBtn );
        }
            
    iLanguage = aLang;    
    }

// ---------------------------------------------------------------------------
// Set current editor is secret
// ---------------------------------------------------------------------------
//    
void  CPeninputSplitQwertyWindow::SetSwitchlistSecretFlag( TBool aSecret )
    {
    CFepUiBaseCtrl* ctrl = Control( EPeninutWindowCtrlIdSwitcherPopupWindow );
    CPeninputLayoutInputmodelChoice* choice =
                        static_cast<CPeninputLayoutInputmodelChoice*>( ctrl );
    if ( choice )
        {
        choice->SetSecretEditor( aSecret );    
        }
    //disable or enable arrow keys of FSQ in secret editor.
    }

// ---------------------------------------------------------------------------
// Dim the arrow keys on qwerty when the editor is findpane or secret editor
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::DimArrowKeys( TBool aDimArrow )
    {
    if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ 
         && iArrowLeftButton && iArrowRightButton )
        {
        iArrowLeftButton->SetDimmed( aDimArrow );
        iArrowRightButton->SetDimmed( aDimArrow );
        }
    }

// ---------------------------------------------------------------------------
// Handle accented char event
// ---------------------------------------------------------------------------
//     
TBool CPeninputSplitQwertyWindow::HandleAccentCharEvent( TInt /*aEventType*/, 
                                                    const TDesC& aEventData, 
                                                    const TDesC& aDeadKey, 
                                                    HBufC* anewCharBuf )
    {
    // Get the unicode of virtual key char
    TBuf<16> buf;
    TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();
    buf.Append( event->iCode );
    TBool rs = EFalse;
    
    // Caculate the accent char number
    TInt count = sizeof(KSupportLanguages)/sizeof(TLangMeritPair);

    if ( aDeadKey.Compare( KNullDesC ) != 0 ) // One DeadKey is latched
        {
        for ( TInt i = 0; i < count; i++ )
            {
            if ( ( aDeadKey[0] == KSupportLanguages[i].iDeadKey ) && 
                 ( buf[0] == KSupportLanguages[i].iChar) )
                {
                if ( anewCharBuf )
                    {
                    anewCharBuf->Des().Append( KSupportLanguages[i].iAccentedChar );
                    rs = ETrue;
                    }
                break;
                }
            }
        }
    return rs;
    }

// ---------------------------------------------------------------------------
// Handle virtual key latched event
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::HandleVirtualKeyLatchedEvent(TInt /*aEventType*/, 
                                                         CFepUiBaseCtrl* /*aCtrl*/, 
                                                         const TDesC& aEventData )
    {
    TBuf<16> deadKey(KNullDesC);
    TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();
    deadKey.Append(event->iCode);
        
    TInt latchedFlag = IntContext( EAkninputDataTypeLatchedSet );
    if ( latchedFlag )
        {
        // Update the new and old DeadKey buffer
        iOldDeadKeyBuf = iNewDeadKeyBuf;
        iNewDeadKeyBuf = deadKey;

        // Submit old Deadkey
        TRAP_IGNORE( SubmitDeadKeyL( iOldDeadKeyBuf ) );
     
        // Unlatch the previous DeadKey
        UnLatchDeadKey( iOldDeadKeyBuf );
        }
    else
        {
        iNewDeadKeyBuf = deadKey;
        
        // Set DeadKey state to latched
        TBool deadKeyChange = ETrue;
        iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );
        }
   
    // Send the char to FEP
    // Not submit the DeadKey when latch it.
//    UiLayout()->SignalOwner( ESignalKeyEvent, iNewDeadKeyBuf );
    }

// ---------------------------------------------------------------------------
// Submit dead key
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::SubmitDeadKeyL( const TDesC& abuf )
    {
    HBufC* newCharBuf = HBufC::NewL( KKeyDouble * abuf.Length() );
    if( newCharBuf )
        {
        CPeninputSplitQwertyLayout* layout 
                = static_cast<CPeninputSplitQwertyLayout*>( UiLayout() );
        if( layout->IsEnableITI() )
            {
            // If ITI is open, double same keys should be send for one dead key,
            // core will handle them as one key.
            newCharBuf->Des().Append( abuf );
            }
        newCharBuf->Des().Append( abuf );
        
        // Submit DeadKey
        UiLayout()->SignalOwner( ESignalKeyEvent, *newCharBuf );
        delete newCharBuf;
        newCharBuf = NULL;
        }
    }
// ---------------------------------------------------------------------------
// Handle virtual key up event
// ---------------------------------------------------------------------------
//
TBool CPeninputSplitQwertyWindow::HandleVirtualKeyUpEvent(TInt aEventType, 
                                                    CFepUiBaseCtrl* /*aCtrl*/, 
                                                    const TDesC& aEventData )
    {
    // Get DeadKey state
    TInt latchedFlag = IntContext( EAkninputDataTypeLatchedSet );
    if ( latchedFlag )
        {
        TBool ret = EFalse;
        
        TRAP_IGNORE( ret = HandleDeadKeyL( aEventType, aEventData ) );
        
        if ( ret )
            {
            return ETrue;    
            }
        else
            {
            // When the DeadKey can not combine with current character,
            // Sumit current DeadKey
            UiLayout()->SignalOwner( ESignalKeyEvent, iNewDeadKeyBuf );
            }
        }
        
    iNewDeadKeyBuf = KNullDesC;
    return EFalse;
    } 

// ---------------------------------------------------------------------------
// Set dead key
// ---------------------------------------------------------------------------
//     
void CPeninputSplitQwertyWindow::SetDeadKey()
    {
    // Get VKB list
    RPointerArray<CPeninputVkbLayoutInfo> vkbListInfo;
    vkbListInfo = iVkbLayout->VkbLayoutInfoList();
    TInt vkbListNum = vkbListInfo.Count();
    
    CPeninputVkbKeyInfo* keyinfo;
    TInt count = sizeof(KSupportLanguages)/sizeof(TLangMeritPair);
    for ( TInt i = 0; i < vkbListNum; i++ )
        {
        for ( TInt j = 0; j < count; j++ )
            {
            if ( vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeChar ||
                 vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeCharShift )
                {
                keyinfo = vkbListInfo[i]->FindKey( KSupportLanguages[j].iDeadKey );
                if ( keyinfo )
                    {
                    // Set the DeadKey as a latch button
                    CVirtualKey* key = keyinfo->Key();
                    key->SetLatchKey( ETrue );
                    }
                }
            }
        }
    }
    
    
// ---------------------------------------------------------------------------
// Unlatch a DeadKey by the key buffer
// ---------------------------------------------------------------------------
//     
void CPeninputSplitQwertyWindow::UnLatchDeadKey( const TDesC& abuf )
    {
    RPointerArray<CPeninputVkbLayoutInfo> vkbListInfo;
    vkbListInfo = iVkbLayout->VkbLayoutInfoList();
    TInt vkbListNum = vkbListInfo.Count();
    
    CPeninputVkbKeyInfo* keyinfo;
    TInt count = sizeof(KSupportLanguages)/sizeof(TLangMeritPair);
    for ( TInt i = 0; i < vkbListNum; i++ )
        {
        for ( TInt j = 0; j < count; j++ )
            {
            // Only NativeChar and NativeCharShift layout contain DeadKey
            if(vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeChar ||
               vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeCharShift)
                {
                // Find the DeadKey in NativeChar or NativeCharShift layout
                keyinfo = vkbListInfo[i]->FindKey( KSupportLanguages[j].iDeadKey );
                if ( keyinfo )
                    {
                    CVirtualKey* key = keyinfo->Key();
                    if ( key->Latched() )
                        {
                        if ( abuf == KNullDesC )
                            {
                            // When focus change, the latched key will be released
                            TBool deadKeyChange = EFalse;
                            iLayoutContext->SetData( EAkninputDataTypeLatchedSet, 
                                                     &deadKeyChange );
                            key->SetLatched( EFalse );
                            TRect rect = key->Rect();
                            rect.Move( iVkbCtrl->Rect().iTl );
                            UpdateArea( rect, EFalse ); 
                            return;
                            }
                        if ( abuf[0] == KSupportLanguages[j].iDeadKey )
                            {
                            // When another DeadKey is clicked, the old one will be released
                            key->SetLatched( EFalse );
                            TRect rect = key->Rect();
                            rect.Move( iVkbCtrl->Rect().iTl );
                            UpdateArea( rect, EFalse ); 
                            return;
                            }
                        }
                    }
                }
            }
        }
    }

// ---------------------------------------------------------------------------
// Update laf data
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::UpdateLafData()
    {
    TRAP_IGNORE( iLafMgr->UpdateLafDataL() );
    }

// ---------------------------------------------------------------------------
// Load accent labels for range list
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::ConstructAccentListL( TInt aLangId )
    {  
    iAccentCmdList.Reset();
    
    TBool is10x3 = ( aLangId == ELangEnglish ) || ( aLangId == ELangAmerican )
                   || ( aLangId == ELangDutch)  || (aLangId == ELangTagalog ) 
                   || ( aLangId == ELangIndonesian) || (aLangId == ELangMalay );
    
    if ( aLangId == ELangVietnamese )
        {
        _LIT( KVietAccentList1, "\x00E0 - \x013A" );
        _LIT( KVietAccentList2, "\x013C - \x017E" );
        
        CFepLayoutChoiceList::SItem item;

        item.iCommand = EPeninputVkbLayoutAccented1;
        item.iText.Copy( KVietAccentList1 );      
        iAccentCmdList.Append( item );
        
        item.iCommand = EPeninputVkbLayoutAccented2;
        item.iText.Copy( KVietAccentList2 );
        iAccentCmdList.Append( item );
        }
    else if( aLangId == ELangRussian || aLangId == ELangUkrainian || aLangId == ELangBulgarian )
    	{
	    _LIT( KCyrillicAccent, "\x00E0 - \x017E" );
	    
        CFepLayoutChoiceList::SItem item;

        item.iCommand = EPeninputVkbLayoutAccented1;
        item.iText.Copy( KCyrillicAccent );      
        iAccentCmdList.Append( item );
    	}    
    // 10X3
    else if ( is10x3 )
        {
        _LIT( KVietAccentList1, "\x00E0 - \x0121" );
        _LIT( KVietAccentList2, "\x0123 - \x014F" );
        _LIT( KVietAccentList3, "\x0151 - \x017E" );
        
        CFepLayoutChoiceList::SItem item;

        item.iCommand = EPeninputVkbLayoutAccented1;
        item.iText.Copy( KVietAccentList1 );
        iAccentCmdList.Append( item );
        
        item.iCommand = EPeninputVkbLayoutAccented2;
        item.iText.Copy( KVietAccentList2 );
        iAccentCmdList.Append( item );

        
        item.iCommand = EPeninputVkbLayoutAccented3;
        item.iText.Copy( KVietAccentList3 );
        iAccentCmdList.Append( item );
        }
    //10X4
    else
        {
        // Add item
        TResourceReader reader;
        CFepLayoutChoiceList::SItem item;

        item.iCommand = EPeninputVkbLayoutAccented1;
        CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT1 );
        TPtrC p1 = reader.ReadTPtrC();
        item.iText.Copy( p1 );
        iAccentCmdList.Append( item );
        CleanupStack::PopAndDestroy( 1 ); //reader
        
        item.iCommand = EPeninputVkbLayoutAccented2;
        CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT2 );
        TPtrC p2 = reader.ReadTPtrC();
        item.iText.Copy( p2 );
        iAccentCmdList.Append( item );
        CleanupStack::PopAndDestroy( 1 ); //reader
        
        item.iCommand = EPeninputVkbLayoutAccented3;
        CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT3 );
        TPtrC p3 = reader.ReadTPtrC();
        item.iText.Copy( p3 );
        iAccentCmdList.Append( item );
        CleanupStack::PopAndDestroy( 1 );//reader          
        }

    iPopupInited = ETrue;
    iPopupSet = ETrue;
    }

// ---------------------------------------------------------------------------
// Load range labels for range list
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::ConstructRangeLabelListL( TInt /*aLangId*/ )
    {
    iRangeLabels.iLabelNativeChar.Zero();
    iRangeLabels.iLabelNativeNumber.Zero();
    iRangeLabels.iLabelLatinChar.Zero();
    iRangeLabels.iLabelLatinNumber.Zero();
    iRangeLabels.iLabelSymbol.Zero();
    iRangeLabels.iLabelAccent.Zero();
    
    TInt resid = R_PENINPUT_LAYOUT_VKB_RANGES;
    
    TResourceReader reader;   
    CCoeEnv::Static()->CreateResourceReaderLC( reader, resid );
    TPtrC ptr1 = reader.ReadTPtrC();
    TPtrC ptr2 = reader.ReadTPtrC();
    TPtrC ptr3 = reader.ReadTPtrC();
    TPtrC ptr4 = reader.ReadTPtrC();
    TPtrC ptr5 = reader.ReadTPtrC();
    TPtrC ptr6 = reader.ReadTPtrC();
    
    iRangeLabels.iLabelNativeChar.Copy( ptr1 );
    iRangeLabels.iLabelNativeNumber.Copy( ptr2 );
    iRangeLabels.iLabelLatinChar.Copy( ptr3 );
    iRangeLabels.iLabelLatinNumber.Copy( ptr4 );
    iRangeLabels.iLabelSymbol.Copy( ptr5 );
    iRangeLabels.iLabelAccent.Copy( ptr6 );
    
    CleanupStack::PopAndDestroy( 1 ); //reader        
    }

// ---------------------------------------------------------------------------
// Show or hide preview bubble
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::ShowBubble( TInt aShow )
    {
    iVkbCtrl->ShowBubble( aShow > 0 ? ETrue : EFalse ); 
    }

// ---------------------------------------------------------------------------
// Update state of range button
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::UpdateRangeCtrlsL()
    {
    RArray<CFepLayoutChoiceList::SItem> items;
    PrepareRangeListItems( items );
    TInt count = items.Count();
    items.Close();
    
    TInt languageId = IntContext( EPeninputDataTypeInputLanguage );
    TInt range = IntContext( EPeninputDataTypeCurrentRange );

    TInt resId = -1;
    TInt aplhaRangeResId = -1;
    TInt numberRangeResId = -1;
    GetRangeIconResource( languageId, aplhaRangeResId, numberRangeResId );
    
    if ( range == ERangeEnglish || range == ERangeNative ) 
        {
        resId = aplhaRangeResId;
        }
    else
        {
        resId = numberRangeResId; 
        }
        
    iRangeButton->SetResourceId( resId );
    iRangeButton->ConstructFromResourceL();
    iRangeButton->SetDimmed( count < 1 );    
    }

// ---------------------------------------------------------------------------
// Update layout position and size
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::UpdateLayoutPosAndSize()
    {
    if ( iLafMgr )
        {
        TRect rect = iLafMgr->ClientRect();
        TPoint pos = iLafMgr->EntirePaneRect().iTl;
        
        UiLayout()->SetRect( rect );
        UiLayout()->LayoutOwner()->SetPosition( pos );
        }
    }

// ---------------------------------------------------------------------------
// Set laf layout type
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::SetLafLayOut( TInt aRows, TInt aColumns )
    {
    iLafMgr->SetLayoutType( 
                iLafMgr->LayoutTypeFromRowsColumns( aRows, aColumns )
                );
    }

// ---------------------------------------------------------------------------
// Create custom control
// ---------------------------------------------------------------------------
//
TBool CPeninputSplitQwertyWindow::CreateCustomControlL( TInt16 aControlId, 
                                                        TInt32 aImageId )
    {
    TBool create = ETrue;
    switch ( aControlId )
        {
        case EPeninupWindowCtrlIdArrowLeftBtn:
            {
            if ( iLayoutContext->LayoutType() != EPluginInputModeFSQ )
                {
                break;
                }

            if ( !iArrowLeftButton )
                {
                iArrowLeftButton = CAknFepCtrlRepeatButton::NewL( 
                                          UiLayout(), 
                                          aControlId, 
                                          EPeninputLayoutEventLeftArrow, 
                                          EKeyLeftArrow, 
                                          KAknsIIDQsnFrFunctionButtonNormal,
                                          KAknsIIDQsnFrFunctionButtonPressed,
                                          KAknsIIDQsnFrFunctionButtonInactive );

                AddControlL( iArrowLeftButton );
                iArrowLeftButton->AddEventObserver( UiLayout() );
                iArrowLeftButton->SetResourceId( aImageId );
                }

            iArrowLeftButton->ConstructFromResourceL();
            }
            break;
        case EPeninupWindowCtrlIdArrowRightBtn:
            {
            if ( iLayoutContext->LayoutType() != EPluginInputModeFSQ )
                {
                break;
                }

            if ( !iArrowRightButton )
                {
                iArrowRightButton = CAknFepCtrlRepeatButton::NewL( 
                                          UiLayout(), 
                                          aControlId, 
                                          EPeninputLayoutEventRightArrow, 
                                          EKeyRightArrow, 
                                          KAknsIIDQsnFrFunctionButtonNormal,
                                          KAknsIIDQsnFrFunctionButtonPressed,
                                          KAknsIIDQsnFrFunctionButtonInactive );

                AddControlL( iArrowRightButton );
                iArrowRightButton->AddEventObserver( UiLayout() );
                iArrowRightButton->SetResourceId( aImageId );
                }
            iArrowRightButton->ConstructFromResourceL();
            }
            break;
        default:
            {
            create = EFalse;
            }
        }
        return create;
    }

// ---------------------------------------------------------------------------
// Add custom control to this group
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::AddCustomControlGroupL( CFepUiBaseCtrl* aCtrl )
    {
    AddControlL( aCtrl );
    }    

// ---------------------------------------------------------------------------
// Set layout size
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::SetVkbLayoutSize()
    {
    TRect outrect,innerrect;   
    iLafMgr->GetPreviewWndRect( outrect, innerrect );
    
    iVkbCtrl->SetTextFormat( iLafMgr->PreviewWndText() );  //Read laf 
    
    TSize bubbleSize( outrect.Width(), outrect.Height() );
    iVkbCtrl->SetBubbleSize( bubbleSize );  // Read laf
    
    iVkbCtrl->SetFrameDiff( innerrect.iTl.iX - outrect.iTl.iX,
                            innerrect.iTl.iY - outrect.iTl.iY,
                            outrect.iBr.iX - innerrect.iBr.iX,
                            outrect.iBr.iY - innerrect.iBr.iY );
    
    TInt vkbLayoutid = IntContext( EPeninputDataTypeVkbLayout );
    CPeninputVkbLayoutInfo* vkbLayout = ConfigInfo()->FindVkbLayoutInfo( 
                                                                 vkbLayoutid );

    // Calculate current vkblayout according current layout
    if ( vkbLayout )
        {
        const TInt columns = vkbLayout->Columns();
        const TInt rows = vkbLayout->Rows();
        TRect keyRect;
        TRect charRect;
        
        //iLafMgr->SetLayoutType(iLafMgr->LayoutTypeFromRowsColumns(rows,columns));
 
        for ( TInt exter = 0; exter < rows; exter++ )
            {
            for ( TInt inter = 0; inter < columns; inter++ )
                {
                iLafMgr->GetKeyRect( inter, exter, keyRect, charRect );
                vkbLayout->SetKeyInfo( exter, inter, keyRect, charRect,
                                       iLafMgr->KeyTextFont() );
                }
            }
     
        if ( iVkbCtrl->IsIrregularKeyBoard() )
            {
            CFbsBitmap* bitmap = iVkbCtrl->IrregularKeyBitmap( EKeyLeftDown,
                                                              EKeyStateNormal );
            
            TSize curSize = vkbLayout->KeyInfoList()[0]->Key()->Rect().Size();
            TSize size = bitmap->SizeInPixels();
            if ( curSize != size )
                {
                for ( TInt i = 0; i <= EKeyRightUp; i++ )
                    {
                    for ( TInt j = 0; j <= EKeyStateDimmedMask; j++ )
                        {
                        bitmap = iVkbCtrl->IrregularKeyBitmap(
                                              (TVirtualKeyIrregularKeyType)i,
                                              (TVirtualKeyIrregularKeyState)j );
                        
                        AknIconUtils::SetSize( bitmap, curSize, 
                                               EAspectRatioNotPreserved ); 

                        }
                    }
                }
            }
        else
            {
            CFbsBitmap* bitmap = iVkbCtrl->NonIrregularKeyBitmap( EKeyBmpNormal );
            TSize curSize = vkbLayout->KeyInfoList()[0]->Key()->Rect().Size();
            TSize size = bitmap->SizeInPixels();
            if( curSize != size )    
                {
                for ( TInt i = 0; i <= EKeyBmpLastType; i++ )
                    {
                    bitmap = iVkbCtrl->NonIrregularKeyBitmap( (TVirtualKeyBmpType)i );
                    if( bitmap )
                        {
                        AknIconUtils::SetSize( bitmap, curSize, 
                                               EAspectRatioNotPreserved );
                        }
                    }
                }
            }
        }
    }

// ---------------------------------------------------------------------------
// C++ constructor
// ---------------------------------------------------------------------------
//
CPeninputSplitQwertyWindow::CPeninputSplitQwertyWindow( 
                                        CFepUiLayout* aUiLayout, 
                                        MPeninputLayoutContext* aLayoutContext, 
                                        MPeninputUiStateMgr* aUiStateMgr )
    : CPeninputLayoutWindowExt( aUiLayout, aLayoutContext )
    , iUiStateMgr( aUiStateMgr )
    , iPopupInited( EFalse )
    , iPopupSet( EFalse )
    , iFirstConstruct( ETrue )
    {
    }

// ---------------------------------------------------------------------------
// Symbian constructor
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::ConstructL()
    {
    iBmpRotator = CPeninputSyncBitmapRotator::NewL();
    iLafMgr = CPeninputSplitQwertyLafMgr::NewL();
    iLafMgr->SetInputModeL( TPluginInputMode( iLayoutContext->LayoutType() ) );
    CPeninputLayoutWindowExt::ConstructL();   
    }

// ---------------------------------------------------------------------------
// Add range bar into client area
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::AddRangeBarL()
    {
    CAknFepCtrlLongPressButton* button = CAknFepCtrlLongPressButton::NewL( 
            UiLayout(), 
            EPeninutWindowCtrlIdRangeBtn, 
            0xffff, 0,
            KAknsIIDQsnFrFunctionButtonNormal,
            KAknsIIDQsnFrFunctionButtonPressed,
            KAknsIIDQsnFrFunctionButtonInactive );                

    CleanupStack::PushL( button ); 
    button->SetResourceId( R_PENINPUT_LAYOUT_VKB_RANGE_DEFAULT );
    button->ConstructFromResourceL();
    AddControlL( button );
    CleanupStack::Pop( button );
    
    button->AddEventObserver( UiLayout() );  
    iRangeButton = button;  
    }

// ---------------------------------------------------------------------------
// Add button to client area
// ---------------------------------------------------------------------------
//
CAknFepCtrlEventButton* CPeninputSplitQwertyWindow::AddButtonL( 
                                                    const TInt aControlId, 
                                                    const TInt aEventId, 
                                                    const TInt aResId, 
                                                    const TInt aUnicode, 
                                                    const TBool aIsRepeat )
    {
    CAknFepCtrlEventButton* button = NULL;
    
    if ( aIsRepeat )
        {
        button = CAknFepCtrlRepeatButton::NewL( UiLayout(), 
                                                aControlId, 
                                                aEventId, 
                                                aUnicode );
        }
    else
        {
        button = CAknFepCtrlEventButton::NewL( UiLayout(), 
                                               aControlId, 
                                               aEventId, 
                                               aUnicode );
        }
        
    CleanupStack::PushL( button );  
    if ( button )
        {
        // Read resource
        TResourceReader reader;
        
        CCoeEnv::Static()->CreateResourceReaderLC( reader, aResId );  
        button->SetResourceId( aResId );      
        button->ConstructFromResourceL();  
        // Pop and destroy reader
        CleanupStack::PopAndDestroy( 1 );
        
        // Add into the control pool
        AddControlL( button );
        button->AddEventObserver(UiLayout());
        
        }
    CleanupStack::Pop( button );  
          
    return button;
    }

// ---------------------------------------------------------------------------
// Add popup window to display accented char list
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::AddPopupWindowL()
    {
    iPopupWnd = CPeninputCommonChoiceList::NewL( 
                                        UiLayout(), 
                                        EPeninutWindowCtrlIdAccentPopupWindow,
                                        KAknsIIDQsnFrList,
                                        KAknsIIDQsnFrPopupSub );

    iPopupWnd->AddEventObserver( UiLayout() );
    
    AddControlL( iPopupWnd );
    iIdle = CIdle::NewL( CActive::EPriorityIdle );
    iIdle ->Start( TCallBack( BackgroundTaskL, this ) );
    }

// ---------------------------------------------------------------------------
// Reorgnize position and size of function buttons
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::ReorgnizeTitleBar()
    {
    TRect inner, bound;
    
    CAknFepCtrlEventButton* evtButton = NULL;
    CAknFepCtrlCommonButton* cmmButton = NULL;
    TBool bBKSizeChanged = EFalse;
       
    evtButton = EventButtonCtrl( EPeninutWindowCtrlIdOptionBtn );
    if ( evtButton )
        {
        iLafMgr->GetButtonRect(EPeninutWindowCtrlIdOptionBtn, bound, inner );
        evtButton->SizeChanged( bound, inner, ETrue );
        }

    cmmButton = CommonButtonCtrl( EPeninutWindowCtrlIdCloseBtn );
    if ( cmmButton )
        {
        iLafMgr->GetButtonRect(EPeninutWindowCtrlIdCloseBtn, bound ,inner );
        cmmButton->SizeChanged( bound, inner, ETrue );
        }
    
    cmmButton = CommonButtonCtrl( EPeninutWindowCtrlIdBackspaceBtn );
    if ( cmmButton )
        {
        iLafMgr->GetButtonRect( EPeninutWindowCtrlIdBackspaceBtn, bound, inner );

        if( bound.Size() != cmmButton->Rect().Size() &&
            inner.Size() != cmmButton->ForgroundBmpRect().Size() )
            {
            bBKSizeChanged = ETrue;
            }    
        cmmButton->SizeChanged( bound, inner, ETrue );
        }

    cmmButton = CommonButtonCtrl( EPeninutWindowCtrlIdSpaceBtn );
    if ( cmmButton )
        {
        iLafMgr->GetButtonRect(EPeninutWindowCtrlIdSpaceBtn, bound, inner );
        inner = bound;
        inner.Shrink( 10, 0 );
        
        cmmButton->SizeChanged( bound, inner, ETrue );
            
        TRect spaceIconRect = inner;
        spaceIconRect.Shrink( 10, 0 );
        TDraw3PiecesFrame draw3pic( KAknsIIDQgnIndiInputSpaceL,
                                    KAknsIIDQgnIndiInputSpaceMiddle,
                                    KAknsIIDQgnIndiInputSpaceR,
                                    spaceIconRect);
        cmmButton->SetDraw3PieceFrameInfo( draw3pic );
        }
    
    if ( iRangeButton )
        {
        iLafMgr->GetButtonRect( EPeninutWindowCtrlIdRangeBtn, bound, inner );
        iRangeButton->SetRect( bound );
        iRangeButton->SizeChanged( bound, inner, ETrue );
        }  
    
    if ( iArrowLeftButton )
        {
        iLafMgr->GetButtonRect( EPeninupWindowCtrlIdArrowLeftBtn, bound, inner );
        iArrowLeftButton->SizeChanged( bound, inner, ETrue );
        }
    if ( iArrowRightButton )
        {
        iLafMgr->GetButtonRect( EPeninupWindowCtrlIdArrowRightBtn, bound, inner );
        iArrowRightButton->SizeChanged( bound, inner, ETrue );
        }  

    //If backspace size changed when language is RtoL mirror should be used    
    if ( bBKSizeChanged && IsRtoLLanguage( iLanguage ) )
        {
        //Mirror backspace graphic
        HandleButtonResOnLangDirChange( EPeninutWindowCtrlIdBackspaceBtn );
        }   
    }


// ---------------------------------------------------------------------------
// Show range list
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::PopupRangeListL()
    {
    if ( !iPopupInited )
        {
        TRAP_IGNORE( DoIdleConstructL() );
        }
    

    iPopupWnd->ClearItemsL();
    RArray<CFepLayoutChoiceList::SItem> items;
    PrepareRangeListItems( items );
    TInt count = items.Count();
    for ( TInt i = 0; i < count; i++ )
        {
        iPopupWnd->AddItemL( items[i] );
        }
    items.Close();

    if ( iPopupWnd->ItemsCount() < 1 ) 
        {
        return;
        }
    
    if ( iPopupWnd->ItemsCount() < 2 )
        {
        const CFepLayoutChoiceList::SItem* item = iPopupWnd->ItemByIndex( 0 );
        CFepLayoutChoiceList::SEvent event;
        event.iIndex = 0;
        event.iCommand = item->iCommand;
        TPtrC ptr;
        ptr.Set(reinterpret_cast<TText*>(&event), sizeof(event));
        HandleRangeListSelectedL( iPopupWnd, ptr );
        return;
        }
    
    CFepUiBaseCtrl* btn = Control( EPeninutWindowCtrlIdRangeBtn );    
    iPopupWnd->SetListColumnNumWithLafL( iPopupWnd->ItemsCount() );    
    iPopupWnd->SetCurrentFocusedIndex( - 1 ); //no active item
    iPopupWnd->Display( btn->Rect() );
    iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStatePopup );    
    }

// ---------------------------------------------------------------------------
// get resource info of accented chars popup window
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::GetPopupWndInfoFromResL( TResourceReader aRes,
                                                          const TRect& aRect )
    {
    TPtrC bmpFileName = aRes.ReadTPtrC();        
    TInt32 imgMajorSkinId = aRes.ReadInt32();

    TAknsItemID id;
    
    MAknsSkinInstance* skininstance = UiLayout()->SkinInstance();

    TInt popWinBmpId = aRes.ReadInt16();
    TInt popWinBmpMaskId = aRes.ReadInt16();
    TInt popWinBmpSkinId = aRes.ReadInt16();
    
    id.Set( TInt( imgMajorSkinId ), popWinBmpSkinId );
    
    if ( popWinBmpId != KInvalidImg )
        {
        AknsUtils::CreateIconL( skininstance,
                                id,
                                iPopupWndBgImg,
                                bmpFileName,
                                popWinBmpId );
            
        AknIconUtils::SetSize( iPopupWndBgImg, TSize( aRect.Width(), 
            aRect.Height() * 3 ), EAspectRatioNotPreserved );
        iPopupWnd->SetBackgroundBitmapL( iPopupWndBgImg );
        }
        
    TInt focusBmpId = aRes.ReadInt16();
    TInt focusBmpMaskId = aRes.ReadInt16();
    TInt focusBmpSkinId = aRes.ReadInt16();

    id.Set( TInt( imgMajorSkinId ), focusBmpSkinId );
    
    if ( focusBmpId != KInvalidImg )
        {
        AknsUtils::CreateIconL( skininstance,
                                id,
                                iPopupWndFocusImg,
                                bmpFileName,
                                focusBmpId );

        AknIconUtils::SetSize( iPopupWndFocusImg, 
                               TSize( aRect.Width(),aRect.Height() * 3 ), 
                               EAspectRatioNotPreserved );
        
        iPopupWnd->SetFocusBmp( iPopupWndFocusImg );
        }
    }

// ---------------------------------------------------------------------------
// Background constructor
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::DoIdleConstructL()
    {   
    if( iPopupInited )
    {
    return;
    }

    // Read resource
    TResourceReader reader;
    CCoeEnv::Static()->CreateResourceReaderLC( reader, 
                                         R_PENINPUT_LAYOUT_VKB_POPUP_WINDOW ); 
        
    GetPopupWndInfoFromResL( reader, iPopupItemRect );
       
    // Pop and destroy reader
    CleanupStack::PopAndDestroy( 1 );

    }

// ---------------------------------------------------------------------------
// Simulate raw event
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::SimulateRawEvent( TInt aScanCode, 
                                                   TRawEvent::TType aType )
    {
    TRawEvent event; 
    event.Set( aType, aScanCode );
    
    TPtrC eventPtr( reinterpret_cast<const TUint16*>(&event),
                    sizeof(event)/sizeof(TUint16) );

    UiLayout()->SignalOwner(ESignalSimulateEvent,eventPtr);
    }


// ---------------------------------------------------------------------------
// Handle size changed for range list
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::HandlePopupSizeChange()
    {
    if ( IntContext( EAkninputDataTypeSizeChanging ) || (!iPopupSet) )
        {
        // if size changing, or popup window's property has not been set yet
        TAknWindowLineLayout appWnd = AknLayoutScalable_Avkon::application_window(0).LayoutLine();
        iAppWndRect = appWnd.Rect();
        
        TAknWindowLineLayout mainPane = AknLayoutScalable_Avkon::main_pane(4).LayoutLine();
        TAknLayoutRect mainPaneRect;
        mainPaneRect.LayoutRect( iAppWndRect, mainPane );
        
        TAknWindowLineLayout choiceWnd = AknLayoutScalable_Avkon::popup_choice_list_window(1).LayoutLine();
        TAknLayoutRect choiceRect;
        choiceRect.LayoutRect( mainPaneRect.Rect(), choiceWnd );
        
        iPopupItemRect = TRect( 0, 0, choiceRect.Rect().Width(), 
                         AknLayoutScalable_Avkon::list_single_choice_list_pane(0).LayoutLine().iH );
        
        iChoiceTextLayout = 
                         AknLayoutScalable_Avkon::list_single_choice_list_pane_t1(1).LayoutLine();
        }
        
    const CFont* font = AknLayoutUtils::FontFromId( iChoiceTextLayout.iFont, NULL );
    iPopupWnd->SetFont( font );
    iPopupWnd->SetItemRect( iPopupItemRect, iPopupItemRect );

    TInt leftMargin = iChoiceTextLayout.il;
    
    iPopupWnd->SetMarginAndBaseline( leftMargin, font->HeightInPixels() );
    
    iPopupWnd->SetFontColor( AKN_LAF_COLOR_STATIC( iChoiceTextLayout.iC ) );

    TSize imgSize ( iPopupItemRect.Width(), iPopupItemRect.Height() * 3 );
    AknIconUtils::SetSize( iPopupWndBgImg, imgSize, EAspectRatioNotPreserved );
    AknIconUtils::SetSize(iPopupWndFocusImg, imgSize, EAspectRatioNotPreserved );
    
    iPopupSet = ETrue;
    }


// ---------------------------------------------------------------------------
// Handle dead key event
// ---------------------------------------------------------------------------
//
 TBool CPeninputSplitQwertyWindow::HandleDeadKeyL( TInt aEventType, 
                                                   const TDesC& aEventData )
    {
    // Set DeadKey to unlatched state
    TBool deadKeyChange = EFalse;
    iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );
    UnLatchDeadKey( iNewDeadKeyBuf );

    // Handle dead key when ITI is enable
    CPeninputSplitQwertyLayout* layout 
                      = static_cast<CPeninputSplitQwertyLayout*>( UiLayout() );
    if ( layout->IsEnableITI() )
         {
         TBuf<KKeyCodeSize> buf;
         TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();
         buf.Append( event->iCode );

         HBufC* newCharBuf = HBufC::NewL( iNewDeadKeyBuf.Length() + buf.Length() );
         if( newCharBuf )
             {
             newCharBuf->Des().Append( iNewDeadKeyBuf );
             newCharBuf->Des().Append( buf );

             // Submit DeadKey + Key at the same time
             UiLayout()->SignalOwner(ESignalKeyEvent,*newCharBuf);

             delete newCharBuf;
             newCharBuf = NULL;
             }
         
         return ETrue;
         }
     
    // Get the accent char
    HBufC* newCharBuf = HBufC::NewL( KKeyCodeSize );
    
    TBool handled = HandleAccentCharEvent( aEventType, 
                                           aEventData, 
                                           iNewDeadKeyBuf, 
                                           newCharBuf );
    
    if( handled )
        {
        // Send ths accent key to FEP
        UiLayout()->SignalOwner( ESignalKeyEvent, *newCharBuf );
        iNewDeadKeyBuf = KNullDesC;
        delete newCharBuf;
        newCharBuf = NULL;
        return ETrue;
        }
    
    delete newCharBuf;
    newCharBuf = NULL;
    
    return EFalse;
    }

 // --------------------------------------------------------------------------
 // Handle resource of button(base on language direction)
 // --------------------------------------------------------------------------
 //
void CPeninputSplitQwertyWindow::HandleButtonResOnLangDirChange( TInt aControlId )
    {
    TRAP_IGNORE( HandleButtonResOnLangDirChangeL( aControlId ) );
    }

// ---------------------------------------------------------------------------
// Handle resource of button(base on language direction)
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::HandleButtonResOnLangDirChangeL( TInt aControlId )
    {
    CAknFepCtrlCommonButton* ctrl = CommonButtonCtrl( aControlId ); 
    if ( ctrl && iBmpRotator )
        {
        TSyncRotationAngle rotChoice = CBitmapRotator::EMirrorVerticalAxis; 
        
        User::LeaveIfError( 
                iBmpRotator->Rotate( *ctrl->ForgroundBmp() ,rotChoice ) 
                );
        
        User::LeaveIfError( 
                iBmpRotator->Rotate( *ctrl->ForgroundBmpMask(), rotChoice ) 
                );
        }        
    }    

// ---------------------------------------------------------------------------
// Utils to get context value 
// ---------------------------------------------------------------------------
//
TInt CPeninputSplitQwertyWindow::IntContext( TPeninputDataType aDataIndex )
    {
    return CPeninputDataConverter::AnyToInt( 
                                       iLayoutContext->RequestData( aDataIndex ) 
                                   );
    }

// ---------------------------------------------------------------------------
// Handle range list event
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::HandleRangeListSelectedL( CFepUiBaseCtrl* /*aCtrl*/, 
                                                           const TDesC& aData )
    {
    CFepLayoutChoiceList::SEvent* event = (CFepLayoutChoiceList::SEvent*)aData.Ptr();
    
    TInt index = -1;
    TInt range = ERangeInvalid;

    if ( event->iCommand == EPeninputVkbLayoutNativeChar )
        {
        range = ERangeNative;
        }

    else if ( event->iCommand == EPeninputVkbLayoutNativeNumber )
        {
        range = ERangeNativeNumber;
        }
    
    else if ( event->iCommand == EPeninputVkbLayoutLatinChar )
        {
        range = ERangeEnglish;
        }
    
    else if ( event->iCommand == EPeninputVkbLayoutLatinNumber )
        {
        range = ERangeNumber;
        }
    
    else if ( event->iCommand == EPeninputVkbLayoutSymbol )
        {
        range = ERangeSymbol;
        }

    else if ( event->iCommand == EPeninputVkbLayoutAccented1 )
        {
        index = 0;
        range = ERangeAccent;
        }
    
    else if ( event->iCommand == EPeninputVkbLayoutAccented2 )
        {
        index = 1;
        range = ERangeAccent;
        }
    
    else if ( event->iCommand == EPeninputVkbLayoutAccented3 )
        {
        index = 2;
        range = ERangeAccent;
        }
        
    TInt currentRange = IntContext( EPeninputDataTypeCurrentRange );
    TInt currentAccent = IntContext( EPeninputDataTypeCurrentAccent );

    if ( currentRange == range )
        {
        if ( range != ERangeAccent || currentAccent == index )
            {
            iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );
            return;
            }
        }

    iLayoutContext->SetData( EPeninputDataTypeCurrentAccent, &index );

    if ( range != ERangeAccent )
        {
        ChangeRange( range );
        }
    else
        {
        ChangeRange( ERangeAccent, EPeninputVkbLayoutAccented1 + 2 * index, ETrue );
        }
    UpdateRangeCtrlsL();
    }

// ---------------------------------------------------------------------------
// Get resource ids of range button icon
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::GetRangeIconResource( TInt aLangId, 
                                                       TInt& aAlphaRange, 
                                                       TInt& aOtherRange  )
    {   
    switch ( aLangId )
        {
        case ELangRussian:    //Cyrillic
        case ELangBulgarian:
        case ELangUkrainian:
            {
            aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_CYRILLIC_ALPHA;
            aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_CYRILLIC_NUMERIC;
            }
            break;
        case ELangGreek:       //Greek
        case ELangCyprusGreek:
            {
            aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_GREEK_ALPHA;
            aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_GREEK_NUMERIC;
            }
            break;        
        case ELangHebrew:     //Hebrew
            {
            aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_HEBREW_ALPHA;
            aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_HEBREW_NUMERIC;
            }
            break;  
        case ELangArabic:     //Arabic
        case ELangFarsi:      //Farsi
        case ELangUrdu:       //Urdu
            {
            aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_ARABIC_ALPHA;
            aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_ARABIC_NUMERIC;
            }
            break;
        case ELangThai:       //Thai
            {
            aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_THAI_ALPHA;
            aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_THAI_NUMERIC;
            }
            break;
        default:              //others       
            {
            aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_LATIN_ALPHA;
            aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_LATIN_NUMERIC;
            }
        }
    }

// ---------------------------------------------------------------------------
// Prepare range list items
// ---------------------------------------------------------------------------
//
void CPeninputSplitQwertyWindow::PrepareRangeListItems( 
                             RArray<CFepLayoutChoiceList::SItem>& aRangeItems )
    {
    aRangeItems.Reset();
    TInt currentRange = IntContext( EPeninputDataTypeCurrentRange );
    TInt permittedRange = IntContext( EPeninputDataTypePermittedRange );
    TInt currentAccent = IntContext( EPeninputDataTypeCurrentAccent );
    TInt currentLanguage = IntContext( EPeninputDataTypeInputLanguage );
    
    CPeninputRangeBarInfo* rbinfo= ConfigInfo()->RangeBarInfo();
    CPeninputRangeInfo* rgninfo = NULL;
   
    //add accent items
    if ( permittedRange & ERangeAccent )
        {
        rgninfo = rbinfo->FindRange( ERangeAccent );
        if ( rgninfo )
            {
            for ( TInt i = 0; i < iAccentCmdList.Count(); i++ )
                {
                if( currentRange != ERangeAccent || currentAccent != i )
                    {
                    aRangeItems.Append( iAccentCmdList[i] );
                    }
                }
            }
        }
    
    //add range items
    
    CFepLayoutChoiceList::SItem item;
    
    if ( permittedRange & ERangeNative )
        {
        rgninfo = rbinfo->FindRange( ERangeNative );
        if ( rgninfo && currentRange != ERangeNative )
            {
            item.iCommand = EPeninputVkbLayoutNativeChar;
            item.iText.Copy( iRangeLabels.iLabelNativeChar );
            aRangeItems.Append( item );
            }
        }
    
    if (( permittedRange & ERangeNativeNumber ) && ( currentRange != ERangeNumber ) 
    && (( ELangArabic == currentLanguage ) || ( ELangFarsi == currentLanguage ) 
    || ( ELangUrdu == currentLanguage )))
        {
        rgninfo = rbinfo->FindRange( ERangeNativeNumber );
        if ( rgninfo && currentRange != ERangeNativeNumber )
            {
            item.iCommand = EPeninputVkbLayoutNativeNumber;
            item.iText.Copy( iRangeLabels.iLabelNativeNumber );
            aRangeItems.Append( item );
            }
        }
    else if(( permittedRange & ERangeNumber ) && ( currentRange != ERangeNumber ) 
    		&& !(( ELangThai == currentLanguage ) && ( currentRange == ERangeNativeNumber )))
       {
       rgninfo = rbinfo->FindRange( ERangeNumber );
       if ( rgninfo && currentRange != ERangeNumber )
           {
           item.iCommand = EPeninputVkbLayoutLatinNumber;
           item.iText.Copy( iRangeLabels.iLabelLatinNumber );
    	   aRangeItems.Append( item );
    	   }
        }
    else
      	{        
            // Do nothing
       }    
   
    if ( permittedRange & ERangeEnglish )
        {
        rgninfo = rbinfo->FindRange( ERangeEnglish );
        if ( rgninfo && currentRange != ERangeEnglish )
            {
            item.iCommand = EPeninputVkbLayoutLatinChar;
            item.iText.Copy( iRangeLabels.iLabelLatinChar );
            aRangeItems.Append( item );
            }
        }
    }

void CPeninputSplitQwertyWindow::HandleRangeButtonShortPress()
    {
    const TInt range = CPeninputDataConverter::AnyToInt(
         iLayoutContext->RequestData(EPeninputDataTypeCurrentRange));
     
    const TInt langId = CPeninputDataConverter::AnyToInt(
         iLayoutContext->RequestData(EPeninputDataTypeInputLanguage));    

    switch ( langId )
        {
        case ELangRussian:
        case ELangBulgarian:
        case ELangUkrainian:
            {
            range == ERangeNative ? ChangeRange( ERangeNumber ) : ChangeRange( ERangeNative );
            }
            break;

        case ELangArabic:
        case ELangFarsi:
        case ELangUrdu:
            {
            range == ERangeNative ? ChangeRange( ERangeNativeNumber ) : ChangeRange( ERangeNative );
            }
            break;
            
        case ELangThai:
            {
            range == ERangeNative ? ChangeRange( ERangeNumber ) : ChangeRange( ERangeNative ); 
            }
            break;

        case ELangGreek:
        case ELangHebrew:
            {
            range == ERangeNative ? ChangeRange( ERangeNumber ) : ChangeRange( ERangeNative ); 
            }
            break;
        default: // Latin, vietnamese, and other possible languages
            {
            if ( ConfigInfo()->RangeBarInfo()->FindRange( ERangeNative ) )
                {
                if ( range == ERangeNative )
                    {
                    if ( ConfigInfo()->RangeBarInfo()->FindRange( ERangeNativeNumber ) )
                        {
                        ChangeRange( ERangeNativeNumber );
                        }
                    else if ( ConfigInfo()->RangeBarInfo()->FindRange( ERangeNumber ) )
                        {
                        ChangeRange( ERangeNumber );
                        }
                    }
                else
                    {
                    ChangeRange( ERangeNative );
                    }
                }
            else if ( ConfigInfo()->RangeBarInfo()->FindRange( ERangeEnglish ) )
                {
                range == ERangeEnglish ? ChangeRange( ERangeNumber ) : ChangeRange( ERangeEnglish );
                }
            }
            break;
        }
    
    TRAP_IGNORE( UpdateRangeCtrlsL() );
    }

// End Of File
