/*

* 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 <AknsUtils.h>

#include <AknFepGlobalEnums.h>

#include <peninputlayoutinputmodechoice.h>

#include <peninputlayoutmultilineicf.h>

// User includes

#include "peninputsplitqwerty.hrh"

#include "peninputsplitqwertywindow.h"

#include "peninputsplitqwertyenum.h"

#include "peninputrangebarinfo.h"

#include "peninputsplitqwertylafdatamgr.h"

#include "peninputsplitqwertylangmeritpair.h"

#include "peninputsplitqwertylayout.h"

// Constants

const TInt KPeninputVkbWndInvalidIndex = -1;

const TInt KInvalidImg = -1 ;

_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

    /*

    iVkbCtrl->ShowBubble(ETrue);    

    iVkbCtrl->SetGowithPointerDown(ETrue);

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

    */

    //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 );  

    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 EEventButtonUp:

            {

            if ( ctrlId == EPeninutWindowCtrlIdRangeBtn )

                {

                PopupChoiceList();

                }

            }

            break;

        case EPeninputLayoutVkbEventResetShift: 

            {

            HandleShiftAndCapslockBtnClicked();

            }

            break;  

        case EPenInputLayoutEventClosePopup:

            {

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

                {

                iPopupWnd->CloseWindow();

                iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );

                }

            }

            break;

        case EEventChoiceSelected:

            {

            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:

            {

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

            TBool deadKeyChange = EFalse;

            iLayoutContext->SetData( EAkninputDataTypeLatchedSet, &deadKeyChange );

            iNewDeadKeyBuf = KNullDesC;

            }