/*

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

const TInt KTooltipLeftMargin = 10;

const TInt KTooltipTopMargin = 0;

const TInt KTooltipRightMargin = 10;

const TInt KTooltipBottomMargin = 0;

_LIT( KVkbWindowResourceFile, 

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

_LIT( KConfigurationResourceFile, 

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

_LIT( KResourceFileExtName, ".RSC" );

_LIT(KEmptyString, "");

// ======== 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),

      iIndiWithText( EFalse )

    {

    }

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

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

    iAccentCmdList.Close();

    }

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

            {

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

                {

                PopupChoiceList();

                }

            }

            break;

        case EPeninputLayoutVkbEventResetShift: 

            {

            HandleShiftAndCapslockBtnClicked();

            }

            break;  

        case EPenInputLayoutEventClosePopup:

        	{

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

                {

                iPopupWnd->CloseWindow();

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

                    {

                    ResetAccentButton();

                    }

                iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );

                }

        	}

            break;

        case EEventChoiceSelected:

            {

            CFepLayoutChoiceList::SEvent* event = 

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

            if ( event->iIndex != KPeninputVkbWndInvalidIndex )

                {

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

                    {

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

                        {

                        TRAP_IGNORE( HandleRangeListSelectedL( aCtrl, aEventData ));

                        }

                    else

                        {

                        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

                {

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

                    {

                    ResetAccentButton();

                    }

                }

            iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );

            }

            break;

        case EPeninputLayoutEventToHwr:

            {

            TRAP_IGNORE( UpdateICFTextL() );

            TRAP_IGNORE(PopupSwitchWindowL());

            }

            break; 

        case EEventVirtualKeyLatched:

            {

            HandleVirtualKeyLatchedEvent(aEventType, aCtrl, aEventData);

            }

            break;

        case EEventVirtualKeyUnLatched:

            {

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

            if( newCharBuf )

                {

                CPeninputGenericVkbLayout* layout 

                        = static_cast<CPeninputGenericVkbLayout*>( UiLayout() );

                if( layout->IsEnableITIOnFSQ() )

                    {

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

                }

            // Submit DeadKey

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

            delete newCharBuf;

            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() + 2*iNewDeadKeyBuf.Length() );

                if( newCharBuf )

                    {

                    CPeninputGenericVkbLayout* layout 

                             = static_cast<CPeninputGenericVkbLayout*>( UiLayout() );

                    if( layout->IsEnableITIOnFSQ() )

                        {

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

                }

            }

            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->MsgBubbleCtrl()->SetTextL( KEmptyString );

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

        }

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

        {

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

        {