/*

* 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 <peninputvkbwindow.rsg>

#include <peninputvkbwindowconfiginfo_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 "peninputgenericvkb.hrh"

#include "peninputgenericvkbwindow.h"

#include "peninputgenericvkbenum.h"

#include "peninputrangebarinfo.h"

#include "peninputgenericvkblafdatamgr.h"

#include "peninputgenericvkblangmeritpair.h"

#include "peninputgenericvkblayout.h"

// Constants

const TInt KPeninputVkbWndInvalidIndex = -1;

const TInt KInvalidImg = -1 ;

const TInt KKeyCodeSize = 1;

_LIT( KVkbWindowResourceFile, 

      "z:\\resource\\plugins\\peninputvkbwindow.RSC" );

_LIT( KConfigurationResourceFile, 

      "z:\\resource\\plugins\\peninputvkbwindowconfiginfo_" );

_LIT( KResourceFileExtName, ".RSC" );

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

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::CPeninputGenericVkbWindow

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

CPeninputGenericVkbWindow::CPeninputGenericVkbWindow( 

    CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext, 

    MPeninputUiStateMgr* aUiStateMgr )

    : CPeninputLayoutWindowExt( aUiLayout, aLayoutContext ),

      iUiStateMgr(aUiStateMgr),

      iPopupInited(EFalse),

      iPopupSet(EFalse),

      iLafMgr(NULL),

      iFirstConstruct(ETrue)

    {

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::NewL

// (other items were commented in a header)

// --------------------------------------------------------------------------

// 

CPeninputGenericVkbWindow* CPeninputGenericVkbWindow::NewL( 

    CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext, 

    MPeninputUiStateMgr* aUiStateMgr )

    {

    CPeninputGenericVkbWindow* self = 

        new ( ELeave ) CPeninputGenericVkbWindow( aUiLayout, aLayoutContext, aUiStateMgr );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::~CPeninputGenericVkbWindow

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

CPeninputGenericVkbWindow::~CPeninputGenericVkbWindow()

    {

    delete iIdle;

    iUnits.Close();

    delete iLafMgr;

    iLafMgr = NULL;

    delete iBmpRotator;

    }

void CPeninputGenericVkbWindow::ConstructL()

    {

    iBmpRotator = CPeninputSyncBitmapRotator::NewL();

    iLafMgr = CPeninputGenericVkbLafMgr::NewL();

    iLafMgr->SetInputModeL(TPluginInputMode (iLayoutContext->LayoutType()));

    CPeninputLayoutWindowExt::ConstructL();

    // For addition of ITI features, add a candidate list in vkb window   

    CreateCandidateListL();    

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::HandleControlEvent

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

void CPeninputGenericVkbWindow::HandleControlEvent( TInt aEventType,

                                                    CFepUiBaseCtrl* aCtrl, 

                                                    const TDesC& aEventData )

    {

    // Call this function in base class

    CPeninputLayoutWindowExt::HandleControlEvent( aEventType, aCtrl, 

                                                  aEventData );

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

    switch ( aEventType )

        {

        case EPeninputLayoutVkbEventResetShift: 

            {

            HandleShiftAndCapslockBtnClicked();

            }

            break;  

        case EPenInputLayoutEventClosePopup:

        	{

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

                {

                iPopupWnd->CloseWindow();

                ResetAccentButton();

                iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );

                }

        	}

            break;

        case EEventChoiceSelected:

            {

            CFepLayoutChoiceList::SEvent* event = 

                ( CFepLayoutChoiceList::SEvent* ) aEventData.Ptr();

            if ( event->iIndex != KPeninputVkbWndInvalidIndex )

                {

                if (aCtrl->ControlId() == EPeninutWindowCtrlIdAccentPopupWindow)

                    {

                    TInt currentRange = CPeninputDataConverter::AnyToInt(

                                      iLayoutContext->RequestData(EPeninputDataTypeCurrentRange));

                    TInt currentAccent = CPeninputDataConverter::AnyToInt(

                                      iLayoutContext->RequestData(EPeninputDataTypeCurrentAccent));

                    if ((currentRange == ERangeAccent) && (currentAccent == event->iIndex))

                        {

						iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );

                        return;

                        }

                    iLayoutContext->SetData( EPeninputDataTypeCurrentAccent, &(event->iIndex));

                    // Active range, update rangebar and vkb layout

                    //ChangeRange( ERangeAccent, EPeninputVkbLayoutAccented1 + 2 * event->iIndex);

                    (currentRange == ERangeAccent) ? ChangeRange(ERangeAccent, 

                                       EPeninputVkbLayoutAccented1 + 2 * event->iIndex, EFalse) :

                                                     ChangeRange(ERangeAccent, 

                                       EPeninputVkbLayoutAccented1 + 2 * event->iIndex, ETrue);

                    }

                else if (aCtrl->ControlId() == EPeninutWindowCtrlIdSwitcherPopupWindow)

                    {

                    if (iLayoutContext->LayoutType() != event->iCommand)

                        {

                        TBool switchByMode = ETrue;

                        TInt  mode = event->iCommand;

                        TBuf<8> buf;

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

                                                            sizeof(TBool)/sizeof(TText));

                        buf.Append(reinterpret_cast<TText*>(&mode), sizeof(TInt)/sizeof(TText));

                        UiLayout()->SignalOwner(ESignalLayoutUIChanged,buf);

                        }

                    }

                else if ( aCtrl->ControlId() == EPentinputHwrCandidateList )

                    {

                    TRAP_IGNORE( HandleCandidateListSelectedL( aCtrl, aEventData ) );

                    }

                }

            else

                {

                ResetAccentButton();   

                }

            iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );

            }

            break;

        case EPeninputLayoutEventToHwr:

            {

            TRAP_IGNORE( UpdateICFTextL() );

            TRAP_IGNORE(PopupSwitchWindowL());

            }

            break; 

        case EEventVirtualKeyLatched:

            {

            HandleVirtualKeyLatchedEvent(aEventType, aCtrl, aEventData);

            }

            break;

        case EEventVirtualKeyUnLatched:

            {

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

            TBool deadKeyChange = EFalse;

            iLayoutContext->SetData(EAkninputDataTypeLatchedSet, &deadKeyChange);

            iNewDeadKeyBuf = KNullDesC;

            }

            break;

        case EPeninputLayoutEventBack:

            {

            TInt latchedFlag = CPeninputDataConverter::AnyToInt

                               (iLayoutContext->RequestData(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 = CPeninputDataConverter::AnyToInt

                               (iLayoutContext->RequestData(EAkninputDataTypeLatchedSet));

            if(latchedFlag)

                {

                HBufC* newCharBuf = HBufC::New( aEventData.Length() + iNewDeadKeyBuf.Length() );

                if( newCharBuf )

                    {

                    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

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

                iNewDeadKeyBuf = KNullDesC;

                delete newCharBuf;

                }

            }

            break;

/*        case EPeninputLayoutEventLeftArrow:

            SimulateRawEvent(EStdKeyLeftArrow,TRawEvent::EKeyDown);

            SimulateRawEvent(EStdKeyLeftArrow,TRawEvent::EKeyUp);

            break;

        case EPeninputLayoutEventRightArrow:

            SimulateRawEvent(EStdKeyRightArrow,TRawEvent::EKeyDown);

            SimulateRawEvent(EStdKeyRightArrow,TRawEvent::EKeyUp);

            break;*/

        default:

            break;

        }

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::SimulateRawEvent

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

void CPeninputGenericVkbWindow::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);

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::GetWindowConfigResId

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

TInt CPeninputGenericVkbWindow::GetWindowConfigResId()

    {

    return R_PENINPUT_LAYOUT_CONFIG_INFO;

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::GetWindowResId

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

TInt CPeninputGenericVkbWindow::GetWindowResId()

    {

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

        {

        return R_PENINPUT_LAYOUT_FSQ_WINDOW_INFO;

        }

    return R_PENINPUT_LAYOUT_VKB_WINDOW_INFO;        

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::GetNumKeymappingResId

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

TInt CPeninputGenericVkbWindow::GetNumKeymappingResId()

    {

    return R_PENINPUT_LAYOUT_KEY_MAPPING_STRING_LIST;

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::GetWindowConfigResFileName

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

const TDesC& CPeninputGenericVkbWindow::GetWindowConfigResFileName( 

    TInt aLangID )

    {

    if ( aLangID <= 0 ) 

        {

        return KNullDesC;

        }

     if ( aLangID == ELangFrench )

        {

        TBuf<KMaxFileLength>  canadianfrenchresfilename; 

        canadianfrenchresfilename= KConfigurationResourceFile();

        canadianfrenchresfilename.AppendNum( ELangCanadianFrench );

        canadianfrenchresfilename.Append( KResourceFileExtName );

        RFile file;

        TInt rs = file.Open( CCoeEnv::Static()->FsSession(),canadianfrenchresfilename, EFileRead );

        if ( rs == KErrNone )

            {

            file.Close();

            aLangID = ELangCanadianFrench;   

            }

        }

    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;

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::GetWindowResFileName

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

const TDesC& CPeninputGenericVkbWindow::GetWindowResFileName()

    {

    return KVkbWindowResourceFile();

    }

// --------------------------------------------------------------------------

// CPeninputGenericVkbWindow::CreateAllControls

// (other items were commented in a header)

// --------------------------------------------------------------------------

//

void CPeninputGenericVkbWindow::CreateAllControlsL()

    {

    CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>

                                                   (Control(EPeninputWindowCtrlIdMultiLineICF));

    iBubbleSize = AknLayoutScalable_Apps::popup_char_count_window().LayoutLine();

    iBubbleTextLayout = AknLayoutScalable_Apps::popup_char_count_window_t1(0).LayoutLine();

    icf->MsgBubbleCtrl()->SetTextFormat(iBubbleTextLayout);

    icf->MsgBubbleCtrl()->SetTextColorIndex( EAknsCIQsnTextColorsCG67 );

    //Change the ID when ID into release

    icf->MsgBubbleCtrl()->SetBitmapParam(NULL,

    									  NULL,

    									  KAknsIIDQsnFrInputPreviewSideL,

    									  KAknsIIDQsnFrInputPreviewMiddle,

    									  KAknsIIDQsnFrInputPreviewSideR);  

    icf->InfoBubbleCtrl()->SetTextFormat(iBubbleTextLayout);

    icf->InfoBubbleCtrl()->SetTextColorIndex( EAknsCIQsnTextColorsCG67 );

    icf->InfoBubbleCtrl()->SetBitmapParam(NULL,

    									  NULL,

    									  KAknsIIDQsnFrInputPreviewSideL,

    									  KAknsIIDQsnFrInputPreviewMiddle,

    									  KAknsIIDQsnFrInputPreviewSideR);

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

        {

        icf->SetMsgBubbleCtrlSize(TSize(iBubbleSize.iW,iBubbleSize.iH));

        icf->SetInfoBubbleCtrlSize(TSize(iBubbleSize.iW,iBubbleSize.iH));

        }

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

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

        {

        iVkbCtrl->SetIrregularKeyBoard(ETrue);

        iVkbLayout->SetIrregularResourceId(R_AKN_FEP_VKB_IRREGULAR_BITMAP);

        iVkbLayout->ConstructFromIrregularResourceL();

        }

    else

        {

        iVkbCtrl->SetIrregularKeyBoard(EFalse);

        iVkbLayout->SetNonIrregularResourceId(R_AKN_FEP_VKB_NONIRREGULAR_BITMAP);

        iVkbLayout->ConstructFromNonIrregularResourceL();        

        }

    // Add bubble support

    iVkbCtrl->ShowBubble(ETrue);    

    iVkbCtrl->SetGowithPointerDown(ETrue);

    iVkbCtrl->SetBubbleBitmapParam(NULL,NULL,KAknsIIDQsnFrInputCharPreview);  //Change the ID when ID into release

    //set key to be 9 piece graphics

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

        {

        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

	    TResourceReader reader;

	    CCoeEnv::Static()->CreateResourceReaderLC( reader,

	    	 			   R_PENINPUT_LAYOUT_VKB_SHIFT_CAPSLOCK );  

	    button->SetResourceId( R_PENINPUT_LAYOUT_VKB_SHIFT_CAPSLOCK );      

	    button->ConstructFromResourceL();  

	    // Pop and destroy reader

	    CleanupStack::PopAndDestroy( 1 );

	    // Add into the control pool                                                   

	    AddControlL( button );

	    button->AddEventObserver( UiLayout() );

	    }

    CleanupStack::Pop( button );  

    // Space button          

    CAknFepCtrlEventButton* spaceButton = static_cast<CAknFepCtrlEventButton*>

                                                   (Control(EPeninutWindowCtrlIdSpaceBtn));

    // Create 3-pieces color icon for space button

	CPenInput3PiecesColorIcons* 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

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

	    {

	    spaceButton->SetImageFrameId( KAknsIIDQsnFrKeypadButtonFrNormal, 

	                                  KAknsIIDQsnFrKeypadButtonFrPressed,

	                                  KAknsIIDQsnFrKeypadButtonFrInactive );

	    }