/*

* 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:  vkb main window area implementation

*

*/

// system includes

#include <peninputcmdparam.h>            // use global signal

#include <peninputvkbcn.rsg>

#include <peninputlayoutmultilineicf.h>

#include <peninputeventbutton.h>

#include <peninputdragbutton.h>

#include <peninputrepeatbutton.h>

#include <AknLayoutDef.h>

#include <peninputcommonchoicelist.h>

#include <peninputlayout.h>

#include <AknIconUtils.h>

#include <AknLayoutDef.h>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <barsread.h>

#include <AknsUtils.h>

#include <AknFepGlobalEnums.h>

#include <peninputlayoutinputmodechoice.h>

#include <peninputcmd.h>            // use global signal

#include <aknfeppeninputenums.h>    //command from fep or IME to plugin

#include <aknlayoutscalable_apps.cdl.h>

#include <peninputlayoutbubblectrl.h>

#include <peninputscrollablelist.h>

#include <s32mem.h>

#include <peninputvkbctrllayout.h>

#include <peninputvkbctrlext.h>

// user includes

#include "peninputvkb.hrh"

#include "peninputvkbwindow.h"

#include "peninputvkbevent.h"

#include "peninputvkbclientarea.h"

#include "peninputvkbdataprovider.h"

#include "peninputvkbcnlafdatamgr.h"

#include "peninputvkblayout.h"

// constant definition

const TInt KInvalidImg = -1 ;

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

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

// CAknFepVkbWindow::NewL

// (other items were commented in a header).

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

//

CAknFepVkbWindow* CAknFepVkbWindow::NewL(CFepUiLayout* aUiLayout, 

                                         TInt aControlId,

                                         MAknFepVkbDataProvider* aDataProvider,

                                         CAknFepVkbUiStateMgr* aUiStateMgr)

    {

    CAknFepVkbWindow* self = 

        CAknFepVkbWindow::NewLC(aUiLayout, aControlId, aDataProvider, aUiStateMgr);

    CleanupStack::Pop(self);

    return self;

    }

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

// CAknFepVkbWindow::NewLC

// (other items were commented in a header).

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

//

CAknFepVkbWindow* CAknFepVkbWindow::NewLC(CFepUiLayout* aUiLayout, 

                                          TInt aControlId,

                                          MAknFepVkbDataProvider* aDataProvider,

                                          CAknFepVkbUiStateMgr* aUiStateMgr)

    {

    CAknFepVkbWindow* self = 

        new (ELeave) CAknFepVkbWindow(aUiLayout, aControlId, aDataProvider, aUiStateMgr);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CAknFepVkbWindow::~CAknFepVkbWindow

// (other items were commented in a header).

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

//

CAknFepVkbWindow::~CAknFepVkbWindow()

    {

    delete iIdle;

    delete iLafMgr;

    iLafMgr = NULL;

    }

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

// CAknFepVkbWindow::CAknFepVkbWindow

// (other items were commented in a header).

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

//

CAknFepVkbWindow::CAknFepVkbWindow(CFepUiLayout* aUiLayout, 

                                   TInt aControlId, 

                                   MAknFepVkbDataProvider* aDataProvider,

                                   CAknFepVkbUiStateMgr* aUiStateMgr )

    :CAknFepCtrlBaseWindowExt(aUiLayout, aControlId), 

    iLafMgr(NULL),

    iDataProvider(aDataProvider), 

    iUiStateMgr(aUiStateMgr),

    iFirstTimeConstruct(ETrue), 

    iPopupInited(EFalse),

    iPopupSet(EFalse)    

    {

    }

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

// CAknFepVkbWindow::ConstructL

// (other items were commented in a header).

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

//

void CAknFepVkbWindow::ConstructL()

    {

    iLafMgr = CPeninputCnGenericVkbLafMgr::NewL();

    iLafMgr->SetInputModeL((TPluginInputMode)(UiLayout()->PenInputType()));

    BaseConstructL();

    // Add input context field into the headpane

//    AddContextFieldL();

    // Read bitmaps of close and move button

    TInt resID = GetWindowResId();

    SetResourceId( resID );

    // Create client area

    iClientArea = CAknFepVkbClientArea::NewL(UiLayout(), 

                                             EAknFepVkbCtrlIdClientArea,

                                             iDataProvider,

                                             iLafMgr);    

    // Then add it into the clientpane

    AddControlL(iClientArea);       

    iClientArea->SetTopParent(this);

    //Add popup window

    AddPopupWindowL();

    ConstructFromResourceL();

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

    CreateCandidateListOnFSQL();      

    }

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

// CAknFepVkbWindow::ConstructFromResourceL

// (other items were commented in a header).

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

//

void CAknFepVkbWindow::ConstructFromResourceL()

    {

    CAknFepCtrlBaseWindowExt::ConstructFromResourceL();

    iInputContextField = 

        static_cast<CFepLayoutMultiLineIcf*>

        (Control(EPeninputWindowCtrlIdMultiLineICF));

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

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

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

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

    //Change the ID when ID into release  

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

									  NULL,

									  KAknsIIDQsnFrInputPreviewSideL,

									  KAknsIIDQsnFrInputPreviewMiddle,

									  KAknsIIDQsnFrInputPreviewSideR);  

    if(UiLayout()->PenInputType() == EPluginInputModeFSQ)

        {

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

        }  

    }    

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

// CAknFepVkbWindow::ChangeImLayout

// (other items were commented in a header).

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

//

void CAknFepVkbWindow::ChangeImLayout(TInt aRange, TBool aChangeVkb)

    {

    TInt imLayout = iDataProvider->RequestData(EAknFepDataTypeIMLayout);

    if ( iArrowLeftButton )

        {

        iArrowLeftButton->Hide( EAknFepVkbImCnZhuyin == imLayout );    

        }

    if ( iArrowRightButton )

        {

        iArrowRightButton->Hide( EAknFepVkbImCnZhuyin == imLayout );    

        }

    iClientArea->ChangeImLayout(aRange, aChangeVkb);

    SizeChangedForTitle();

    Draw();

    }

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

// CAknFepVkbWindow::ChangeVkbLayout

// (other items were commented in a header).

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

//

void CAknFepVkbWindow::ChangeVkbLayout(TInt aVkbLayoutId)

    {

    iClientArea->ChangeVkbLayout(aVkbLayoutId);

    }

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

// CAknFepVkbWindow::LoopVkbLayout

// (other items were commented in a header).

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

//

void CAknFepVkbWindow::LoopVkbLayout(TVkbShiftType aType, TBool aNotify )

    {

    iClientArea->LoopVkbLayout(aType, aNotify);

    }

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

// CAknFepVkbWindow::Draw

// (other items were commented in a header).

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

//

void CAknFepVkbWindow::Draw()

	{

	if ( Hiden() )

		{

		return;

		}

    CAknFepCtrlBaseWindowExt::Draw();

    UpdateArea(Rect(), EFalse);

	}

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

// CAknFepVkbWindow::SetRect

// (other items were commented in a header).

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

//

void CAknFepVkbWindow::SetRect(const TRect& aRect)

    {

	TRect rect = aRect;

    if(UiLayout()->PenInputType() == EPluginInputModeFSQ)

        {

        rect.Move( TPoint(- rect.iTl ));

        CFepUiBaseCtrl::SetRect( rect );

        UiLayout()->SetRect(rect);

        }

    else

    	{

        TSize shadowTl = *((TSize*)iDataProvider->RequestData(EAknFepDataTypeShadowTlSize));

        TSize shadowBr = *((TSize*)iDataProvider->RequestData(EAknFepDataTypeShadowBrSize));

	    TRect shadowRect = TRect( TPoint(), 

	                              TSize( aRect.Width() + shadowTl.iWidth + shadowBr.iWidth,

	                                     aRect.Height() + shadowTl.iHeight + shadowBr.iHeight)

	                            );

	    rect.Move( TPoint(shadowTl.iWidth, shadowTl.iHeight) - rect.iTl );

	CFepUiBaseCtrl::SetRect( rect );

	    RootControl()->SetRect( rect );

    UiLayout()->SetShadowRect(shadowRect);

	    }

     /*   

    CFepUiBaseCtrl::SetRect(aRect);

    ResetShadowSizeIfNeeded();*/

    }

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

// CAknFepVkbWindow::SetPopupProperty

// (other items were commented in a header).

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

//

void CAknFepVkbWindow::SetPopupProperty()

	{

	TRect mainPaneRect = *((TRect*)iDataProvider->RequestData(EAknFepDataTypeMainPaneRect));

    TAknWindowLineLayout choiceWnd = 

                                AknLayoutScalable_Avkon::popup_choice_list_window(1).LayoutLine();

    TAknLayoutRect choiceRect;

    choiceRect.LayoutRect(mainPaneRect, choiceWnd);

    TRect itemRect = TRect(0,

                           0,

                           choiceRect.Rect().Width(),

                           AknLayoutScalable_Avkon::list_single_choice_list_pane(0).LayoutLine().iH);

    TAknTextLineLayout choiceTextLayout = 

                         AknLayoutScalable_Avkon::list_single_choice_list_pane_t1(1).LayoutLine();

    const CFont* font = AknLayoutUtils::FontFromId(choiceTextLayout.iFont, NULL);

    iPopupWnd->SetFont(font);

    iPopupWnd->SetItemRect(itemRect, 

                           itemRect);

    TInt leftMargin = choiceTextLayout.il;

    iPopupWnd->SetMarginAndBaseline(leftMargin,font->HeightInPixels());

    iPopupWnd->SetFontColor(AKN_LAF_COLOR_STATIC(choiceTextLayout.iC));

    if (iPopupWndBgImg)

    	{

    	AknIconUtils::SetSize(iPopupWndBgImg, TSize(itemRect.Width(),itemRect.Height()*3), 

                            EAspectRatioNotPreserved);

    	}

    if (iPopupWndFocusImg)

    	{

    	AknIconUtils::SetSize(iPopupWndFocusImg, TSize(itemRect.Width(),itemRect.Height()*3), 

                            EAspectRatioNotPreserved);

    	}

    iPopupSet = ETrue;	

    iPopupItemSize = itemRect.Size();

	}

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

// CAknFepVkbWindow::SizeChanged

// (other items were commented in a header).

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

//

void CAknFepVkbWindow::SizeChanged(TBool /*aLandscapeStyle*/)

    {

    SizeChangedForTitle();

    iClientArea->SizeChanged();

    Draw();

        }

void CAknFepVkbWindow::SizeChangedForTitle()

    	{

	TRect innerRect;

    if (iLafMgr && !iLafMgr->IsValid())

        {

        return;

        }

    if (iDataProvider->SizeChanging() || (!iDataProvider->UnitShadowSizeSet()))

    	{

    	iDataProvider->ReadUnitShadowSize();

    	}

	TSize shadowTl = *((TSize*)iDataProvider->RequestData(EAknFepDataTypeShadowTlSize));

    TInt x = shadowTl.iWidth;

    TInt y = shadowTl.iHeight;

    if ( UiLayout()->PenInputType() == EPluginInputModeFSQ )

        {

        x = 0;

        y = 0;

        }

    TInt btnWidth = iDataProvider->RequestData(EAknFepDataTypeUnitWidth);

    TInt btnHeight = iDataProvider->RequestData(EAknFepDataTypeUnitHeight);    

    // Close btn

    TRect closeBtnRect;

    closeBtnRect.iTl = TPoint(x, y);

    closeBtnRect.SetSize(TSize(btnWidth, btnHeight));

    AknPenImageUtils::CalculateGraphicRect( closeBtnRect, innerRect );

    static_cast<CAknFepCtrlCommonButton*>

        ( Control( EPeninutWindowCtrlIdCloseBtn ) )->SizeChanged( closeBtnRect, innerRect, ETrue );

    // ICF

    TInt columNum = iDataProvider->RequestData(EAknFepDataTypeIcfColumnNums); 

    TInt titlebarHeight = iDataProvider->RequestData(EAknFepDataTypeTitleBarHeight); 

    TRect icfRect;

    icfRect.iTl = TPoint(closeBtnRect.iBr.iX, closeBtnRect.iTl.iY);

    icfRect.SetSize(TSize(btnWidth * columNum + iClientArea->iCellAidGap, titlebarHeight));   

    // Set ICF Margin 

   	TPeninputCnICFConfig icfCfg;

   	iLafMgr->GetICFConfig( icfCfg );

    const CFont* icfFont = iLafMgr->ICFTextFont();

	iInputContextField->SetTextMargin( icfCfg.iLeftMargin,

									   icfCfg.iRightMargin,

									   icfCfg.iTopMargin,

									   0 );

    iInputContextField->SetLineSpace( icfCfg.iLineSpaceMargin );

    TRAP_IGNORE(iInputContextField->SizeChangedL( icfRect, 

	                                  icfCfg.iTextLineHeight,

	                                  icfFont->FontMaxHeight(),

	                                  icfFont ));    

    // Option Button

    TRect optionBtnRect;

    optionBtnRect.iTl = TPoint(closeBtnRect.iTl.iX, closeBtnRect.iBr.iY);

    optionBtnRect.SetSize(TSize(btnWidth, btnHeight));

    AknPenImageUtils::CalculateGraphicRect( optionBtnRect, innerRect );

    static_cast<CAknFepCtrlEventButton*>

        (Control(EPeninutWindowCtrlIdOptionBtn))->SizeChanged(optionBtnRect, innerRect, ETrue);

    TPoint backSpaceRefPoint;

    // Move Button

    TInt imLayout = iDataProvider->RequestData(EAknFepDataTypeIMLayout);

    if (UiLayout()->PenInputType() == EPluginInputModeVkb)

        {

        TRect moveBtnRect;

        if(EAknFepVkbImCnZhuyin == imLayout)

            {

            moveBtnRect.iTl = TPoint(icfRect.iBr.iX + btnWidth, icfRect.iTl.iY);

            moveBtnRect.SetSize(TSize(btnWidth, btnHeight));

            }

        else

            {

            moveBtnRect.iTl = TPoint(icfRect.iBr.iX, icfRect.iTl.iY);

            moveBtnRect.SetSize(TSize(btnWidth * 2, btnHeight));            

            }

        AknPenImageUtils::CalculateGraphicRect( moveBtnRect, innerRect );

        static_cast<CAknFepCtrlDragButton*>

            ( Control( EPeninutWindowCtrlIdMoveBtn ) )->SizeChanged(moveBtnRect, innerRect, ETrue);

        backSpaceRefPoint = TPoint(moveBtnRect.iTl.iX, moveBtnRect.iBr.iY);

        }

    else if (UiLayout()->PenInputType() == EPluginInputModeFSQ)

        {

        if ( EAknFepVkbImCnZhuyin == imLayout )

            {

            /*TRect emptyRect= TRect();

            AknPenImageUtils::CalculateGraphicRect( emptyRect, innerRect );

            static_cast<CAknFepCtrlRepeatButton*>

                ( Control( EPeninupWindowCtrlIdArrowLeftBtn ) )->SizeChanged(emptyRect, innerRect, ETrue);

            static_cast<CAknFepCtrlRepeatButton*>

                ( Control( EPeninupWindowCtrlIdArrowRightBtn ) )->SizeChanged(emptyRect, innerRect, ETrue);*/

           /* TRect arrowRect;

            TRect innerRect;

            arrowRect.iTl = TPoint(closeBtnRect.iBr.iX, closeBtnRect.iBr.iY);

            arrowRect.SetSize(TSize(btnWidth + btnWidth*2, btnHeight));

            AknPenImageUtils::CalculateGraphicRect( arrowRect, innerRect );

            static_cast<CAknFepCtrlRepeatButton*>

                ( Control( EPeninupWindowCtrlIdArrowUpBtn ) )->SizeChanged(arrowRect, innerRect, ETrue);

            arrowRect.iTl = TPoint(arrowRect.iBr.iX, arrowRect.iTl.iY);

            arrowRect.SetSize(TSize(btnWidth + btnWidth*2, btnHeight));

            AknPenImageUtils::CalculateGraphicRect( arrowRect, innerRect );

            static_cast<CAknFepCtrlRepeatButton*>

                ( Control( EPeninupWindowCtrlIdArrowDownBtn ) )->SizeChanged(arrowRect, innerRect, ETrue);

            arrowRect.iTl = TPoint(arrowRect.iBr.iX, arrowRect.iTl.iY);

            arrowRect.SetSize(TSize(btnWidth + btnWidth*2, btnHeight));

            AknPenImageUtils::CalculateGraphicRect( arrowRect, innerRect );

            static_cast<CAknFepCtrlRepeatButton*>

                ( Control( EPeninupWindowCtrlIdArrowLeftBtn ) )->SizeChanged(arrowRect, innerRect, ETrue);

            arrowRect.iTl = TPoint(arrowRect.iBr.iX, arrowRect.iTl.iY);

            arrowRect.SetSize(TSize(btnWidth + btnWidth*2, btnHeight));

            AknPenImageUtils::CalculateGraphicRect( arrowRect, innerRect );

            static_cast<CAknFepCtrlRepeatButton*>

                ( Control( EPeninupWindowCtrlIdArrowRightBtn ) )->SizeChanged(arrowRect, innerRect, ETrue);*/

            }

        else

            {

            TRect leftBtnRect;

            leftBtnRect.iTl = TPoint(icfRect.iBr.iX, icfRect.iTl.iY);

            leftBtnRect.SetSize(TSize(btnWidth, btnHeight));        

			AknPenImageUtils::CalculateGraphicRect( leftBtnRect, innerRect );

            iArrowLeftButton->SizeChanged(leftBtnRect, innerRect, ETrue);

            TRect rightBtnRect;

            rightBtnRect.iTl = TPoint(leftBtnRect.iBr.iX, leftBtnRect.iTl.iY);

            rightBtnRect.SetSize(TSize(btnWidth, btnHeight));        

			AknPenImageUtils::CalculateGraphicRect( rightBtnRect, innerRect );

            iArrowRightButton->SizeChanged(rightBtnRect, innerRect, ETrue);

            backSpaceRefPoint = TPoint(leftBtnRect.iTl.iX, leftBtnRect.iBr.iY);

            }

        }

    // BackSpace button

    TRect backSpaceBtnRect;

    if(EAknFepVkbImCnZhuyin == imLayout)

        {

        if(UiLayout()->PenInputType() == EPluginInputModeFSQ)

            {

            backSpaceBtnRect.iTl = TPoint(icfRect.iBr.iX, icfRect.iTl.iY);

            backSpaceBtnRect.SetSize(TSize(btnWidth * 2, btnHeight));

            }

        else

            {

            backSpaceBtnRect.iTl = TPoint(icfRect.iBr.iX, icfRect.iTl.iY);

            backSpaceBtnRect.SetSize(TSize(btnWidth, btnHeight));

            }

        }

    else

        {

        backSpaceBtnRect.iTl = backSpaceRefPoint;

        backSpaceBtnRect.SetSize(TSize(btnWidth * 2, btnHeight));

        }