/*

* 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:  drop-down list control

*

*/

#include <peninputsplititutnew.rsg>

#include <peninputsplititutconfig_chinese.rsg>

#include <skinlayout.cdl.h>

#include <AknsDrawUtils.h>

#include <AknsUtils.h>

#include <AknUtils.h> 

#include <peninputrawkeybutton.h>

#include <peninputrepeatbutton.h>

#include <peninputcommonbutton.h>

#include <AknFepGlobalEnums.h>

#include <aknfeppeninputenums.h>

#include <peninputdropdownlist.h>

#include <s32mem.h>

#include <peninputlabel.h>

#include <peninputlayoutbubblectrl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include "peninputsplititutwindow.h"

#include "peninputsplititutdatamgr.h"

#include "peninputsplititutuimgrbase.h"

#include "peninputsplititutuistatebase.h"

#include "peninputsplititutchnuimgr.h"

#include "peninputsplititutwesternuimgr.h"

#include "peninputsplititutconverter.h"

#include "peninputcommonbgctrl.h"

_LIT(KBmpFileName, "z:\\resource\\apps\\peninputsplititut.mbm");

_LIT(KEmptyString, "");

const TInt KImageMajorSkinId = EAknsMajorGeneric;

const TUint KDefaultSpellTextColor = 0;

const TInt KSpaceUnicode = 32;

const TInt KButtonOneUnicode = 49;

const TInt KInvalidBmp = -1;

const TUint KDefaultIcfTextColor = 0x000000;

const TUint KDefaultIcfFrameColor = 0x000000;

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

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

// CSplitItutWindow::NewL

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

//

CSplitItutWindow* CSplitItutWindow::NewL(CSplitItutWindowManager* aWindowMgr,

                                             CSplitItutUiLayout* aLayoutOwner,

                                             CSplitItutDataMgr* aDataMgr)

    {

    CSplitItutWindow* window = new (ELeave) CSplitItutWindow(aWindowMgr,aLayoutOwner,aDataMgr);

    CleanupStack::PushL(window);

    window->ConstructL();

    CleanupStack::Pop(window);

    return window;

    }

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

// CSplitItutWindow::CSplitItutWindow

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

//

CSplitItutWindow::CSplitItutWindow(CSplitItutWindowManager* aWindowMgr, 

                                       CSplitItutUiLayout* aLayoutOwner,

                                       CSplitItutDataMgr* aDataMgr)

    : iDataMgr(aDataMgr),

      iLayoutOwner(aLayoutOwner),

      iWindowMgr(aWindowMgr)

    {

    }

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

// CSplitItutWindow::~CSplitItutWindow

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

//

CSplitItutWindow::~CSplitItutWindow()

    {

    delete iBmpRotator;

    }

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

// CSplitItutWindow::SetPropertyL

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

//

void CSplitItutWindow::SetPropertyL(MItutPropertySubscriber::TItutProperty aPropertyName, 

                                        const TDesC& aPropertyValue)

    {

    switch (aPropertyName)

        {

        case MItutPropertySubscriber::EItutPropertyKeypadResourceId:

        case MItutPropertySubscriber::EItutPropertyCandidateListResourceId:

            {

            TInt resId = TItutDataConverter::AnyToInt(const_cast<TUint16*>(aPropertyValue.Ptr()));

            if (resId == KInvalidResId)

                {

                return;

                }

            if (aPropertyName == MItutPropertySubscriber::EItutPropertyKeypadResourceId)

                {

                ConstructItutKeypadFromResourceL(resId);

                }

            else if (iCandsList)

                {

                iCandsList->ResetAndClear(CFepCtrlDropdownList::EListExpandable);

                iCandsList->SetResourceId(resId);

                iCandsList->ConstructFromResourceL();                  

                }

            }

            break;

        case MItutPropertySubscriber::EItutPropertyLandscape:

            {

            TBool landscape = *((TInt*)(aPropertyValue.Ptr()));

            if (iDataMgr->IsChinese())

                {

                if (landscape)

                    {

                    // expand upward

                    iSpellCandsList->SetCandExpandType(CFepCtrlDropdownList::ECandExpandUpward);

                    iCandsList->SetCandExpandType(CFepCtrlDropdownList::ECandExpandUpward);

                    }

                else

                    {

                    // portrait, expand downward

                    iSpellCandsList->SetCandExpandType();

                    iCandsList->SetCandExpandType();

                    }

                }

            }

            break;

        default:

            break;    

        }

    }

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

// CSplitItutWindow::CreateItutKeypadL

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

//

void CSplitItutWindow::CreateItutKeypadL()

    {

    TRect keypadRect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(EKeypadRect));

    TFontSpec spec;

    iStandardItutKp = CVirtualKeyboard::NewL(keypadRect,

                                             iLayoutOwner,

                                             ECtrlIdStdItut,

                                             spec);

    AddControlL(iStandardItutKp);

    iStandardItutKp->SetResourceId(KInvalidResId);

	// read keypad image info

	ConstructKeyImageFromResourceL( R_ITUT_KEYPAD_BITMAP );

    iStandardItutKp->SetKeyTextColorGroup( EAknsCIQsnTextColorsCG65 );

    iStandardItutKp->SetDrawOpaqueBackground(EFalse);

    // read key shift icon res

    CPenInputColorIcon* shiftIcon = CPenInputColorIcon::NewL( R_ITUT_KEYPAD_SHIFT_ICON );

    shiftIcon->ResizeL( iDataMgr->iShiftIconRect.Size() );

    iStandardItutKp->SetShiftIcon( shiftIcon );

    //set key to be 9 piece graphics

    iStandardItutKp->SetKeySkinId( EKeyBmpNormal, KAknsIIDQsnFrKeypadButtonFrNormal );

    iStandardItutKp->SetKeySkinId( EKeyBmpHighlight, KAknsIIDQsnFrKeypadButtonFrPressed );

    iStandardItutKp->SetKeySkinId( EKeyBmpDim, KAknsIIDQsnFrKeypadButtonFrInactive );

    }

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

// CSplitItutWindow::CreateLayoutIconL

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

//

void CSplitItutWindow::CreateLayoutIconL(TInt aMajorSkinId,

                                             TInt aMinorSkinId,

                                             const TDesC& aBmpFileName,

                                             TInt aBmpId,

                                             TInt aMaskBmpId,

                                             CFbsBitmap*& aBmp,

                                             CFbsBitmap*& aMaskBmp,

                                             TSize aSize)

    {

    TAknsItemID id;

    MAknsSkinInstance* skininstance = AknsUtils::SkinInstance();

    id.Set(TInt(aMajorSkinId), aMinorSkinId);

    if (aBmpId != KInvalidBmp)

        {

        if (aMaskBmpId != KInvalidBmp)

            {

            AknsUtils::CreateIconL(skininstance,

                                   id,

                                   aBmp,

                                   aMaskBmp,

                                   aBmpFileName,

                                   aBmpId,

                                   aMaskBmpId);

            AknIconUtils::SetSize(aMaskBmp, aSize, EAspectRatioNotPreserved);

            }

        else

            {

            AknsUtils::CreateIconL(skininstance,

                                   id,

                                   aBmp,

                                   aBmpFileName,

                                   aBmpId);

            }

        AknIconUtils::SetSize(aBmp, aSize, EAspectRatioNotPreserved);

        }

    }

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

// CSplitItutWindow::ConstructItutKeypadFromResourceL

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

//

void CSplitItutWindow::ConstructItutKeypadFromResourceL(TInt aResId)

    {

    iStandardItutKp->SetResourceId(aResId);

    iStandardItutKp->SetTextLineLayout(

        TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadLeftTextLine)),

        EPosLeft);

    iStandardItutKp->SetTextLineLayout(

        TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadRightTextLine1)),

        EPosRight1);

    iStandardItutKp->SetTextLineLayout(

        TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadRightTextLine2)),

        EPosRight2);

    iStandardItutKp->SetTextLineLayout(

        TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadRightTextLine3)),

        EPosRight3);

    TResourceReader reader;

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

    // construct keys

    TInt countkeys = reader.ReadInt16();

    RPointerArray<CVirtualKey>& keys = 

        const_cast<RPointerArray<CVirtualKey>&>(iStandardItutKp->KeyArray());

    if (keys.Count() == 0)

        {

        for (TInt i = 0; i < countkeys; i++)

            {

            RArray<TRect>& cellrects = 

                       TItutDataConverter::AnyToRectArray(iDataMgr->RequestData(EKeypadCellRects));

            CVirtualKey* vk = CreateKeyL(reader,

                                         cellrects[i]);

            CleanupStack::PushL(vk);

            iStandardItutKp->AddRawKeyL(vk);

            CleanupStack::Pop(vk);

            }

        }

    else

        {

        countkeys = keys.Count();

        for (TInt i = 0; i < countkeys; i++)

            {

            ChangeVirtualKeyInfoL(reader, keys[i]);

            }

        }

    CleanupStack::PopAndDestroy(1); // reader

	iStandardItutKp->Draw();

    iStandardItutKp->UpdateArea( iStandardItutKp->Rect() );

    }

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

// CSplitItutWindow::ChangeVirtualKeyInfoL

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

//

void CSplitItutWindow::ChangeVirtualKeyInfoL( TResourceReader& aReader, 

                                              CVirtualKey* aKey)

    {

    TBuf<5> mapData;

    //Init Data

    for (TInt i = 0; i < 5; i++)

        {

        mapData.Append(0);

        }

    RPointerArray<HBufC> unicodesArr;

    for (TInt i = 0; i <= EPosLast; i++)

        {

        HBufC* unicode = aReader.ReadHBufCL();

        if (i == 0 && unicode != NULL)

            {

            mapData = unicode->Des();

            }

        unicodesArr.AppendL(unicode);

        }

    TInt keyscancode = aReader.ReadInt16();

    if (keyscancode != aKey->ScanCode())

        {

        return;

        }

    TInt curMode = TItutDataConverter::AnyToInt(

            iLayoutOwner->DataMgr()->RequestData(EInputMode));

    TBool isChinese = iLayoutOwner->DataMgr()->IsChinese();

    TBool isThai = iLayoutOwner->DataMgr()->IsThai();

    TInt latinOnly = TItutDataConverter::AnyToInt(

            iLayoutOwner->DataMgr()->RequestData(ELatinOnly));     

    //No symbol in Number range. Symbols under chinese are read from res 

    if ( curMode != ENumber && curMode != ENativeNumber 

         && iSymbolData.iSymbol1 != 0 && keyscancode == KButtonOneUnicode 

         && ( !isChinese || latinOnly )

         && ( !isThai ) )

        {

        //So we should delete it

        for (TInt i = 0; i <= EPosLast; i++)

            {

            delete unicodesArr[i];

            }

        SetUnicodesForHardKey1(aKey, mapData);

        }

    else

        {

        aKey->SetUnicodesL(unicodesArr);

        }

    unicodesArr.Close();

    }

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

// CSplitItutWindow::CreateKeyL

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

//

CVirtualKey* CSplitItutWindow::CreateKeyL(TResourceReader& aReader,

                                              TRect aKeyRect)

    {

    RPointerArray<HBufC> unicodesArr;

    for (TInt i = 0; i <= EPosLast; i++)

        {

        HBufC* unicode = aReader.ReadHBufCL();

        unicodesArr.AppendL(unicode);

        }

    TInt keyscancode = aReader.ReadInt16();

    CVirtualKey* vk = CVirtualKey::NewL(unicodesArr,

                                        keyscancode, 

                                        aKeyRect);

    unicodesArr.Close();

    CleanupStack::PushL(vk);

    TRect innerrect = aKeyRect;

    innerrect.Shrink(TSize(7, 7));

    vk->SetInnerRect(innerrect);

    CleanupStack::Pop(vk);

    return vk;

    }

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

// CSplitItutWindow::CreateBackGroundControlL

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

//

void CSplitItutWindow::CreateBackGroundControlL()

	{

    iBackgroundCtrl = CAknFepCtrlCommonBgCtrl::NewL(

                                          iLayoutOwner,

                                          ECtrlIdBackground,

                                          KAknsIIDQsnFrPopup,

                                          KAknsIIDQsnFrPopupCenter);

	iBackgroundCtrl->SetRect(TItutDataConverter::AnyToRect(

					iLayoutOwner->DataMgr()->RequestData(EBackgroundRect)));

	AddControlL(iBackgroundCtrl);

	}

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

// CSplitItutWindow::CreateRawKeyButtonL

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

//

CAknFepCtrlCommonButton* CSplitItutWindow::CreateRawKeyButtonL(const TInt aControlId,

                                                        const TInt aCommand)

    {

    CAknFepCtrlCommonButton* temp = NULL;

    if (aCommand == KUnavailableID)

        {

        temp =  CAknFepCtrlRawKeyButton::NewL(iLayoutOwner,

                                             aControlId,

                                             KAknsIIDQsnFrFunctionButtonNormal,

											 KAknsIIDQsnFrFunctionButtonPressed,

											 KAknsIIDQsnFrFunctionButtonInactive,  

                                             EEventRawKeyDownEvent,

                                             EEventRawKeyUpEvent); 

        }

    else

        {

        temp =  CAknFepCtrlRawKeyButton::NewL(iLayoutOwner,

                                             aControlId,

                                             KAknsIIDQsnFrFunctionButtonNormal,

											 KAknsIIDQsnFrFunctionButtonPressed,

											 KAknsIIDQsnFrFunctionButtonInactive,  

                                             EEventRawKeyDownEvent,

                                             EEventRawKeyUpEvent,

                                             aCommand); 

        }

    return temp;       

    }

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

// CSplitItutWindow::CreateCommonButtonL

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

//

CAknFepCtrlCommonButton* CSplitItutWindow::CreateCommonButtonL(const TInt aControlId)

    {

    return CAknFepCtrlCommonButton::NewL(iLayoutOwner, 

    									 aControlId,

    									 KAknsIIDQsnFrFunctionButtonNormal,

										 KAknsIIDQsnFrFunctionButtonPressed,

										 KAknsIIDQsnFrFunctionButtonInactive );

    }    

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

// CSplitItutWindow::CreateRepeatButtonL

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

//

CAknFepCtrlCommonButton* CSplitItutWindow::CreateRepeatButtonL(const TInt /*aControlId*/,

                                                               const TInt /*aCommand*/)

    {

    return NULL;

    }     

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

// CSplitItutWindow::CreateButtonL

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

//

CFepUiBaseCtrl* CSplitItutWindow::CreateButtonL(TButtonType aType,

                                                  const TInt aControlId,

                                                  const TInt aRectId,

                                                  const TInt aInnerRectId,

                                                  const TInt aResourceId,

                                                  const TInt aCommand)

    {

    CAknFepCtrlCommonButton* temp = NULL;

    switch(aType)

        {

        case ERawKeyButton:

            {

            temp = CreateRawKeyButtonL(aControlId, aCommand);    

            }

        break;

        case ECommonButton:

            {

            temp = CreateCommonButtonL(aControlId);    

            }

        break;

        default:

            {

            User::Leave(KErrArgument);    

            }                

        }

    TRect btnrect;

    TRect btnInnerRect;

    if (aRectId != KUnavailableID &&

        aInnerRectId != KUnavailableID)

        {

        btnrect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(aRectId));

        btnInnerRect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(aInnerRectId));

        temp->SetRect(btnrect);

        temp->SetForgroundBmpRect(btnInnerRect);

        }

    if (aResourceId != KUnavailableID)

        {

        temp->SetResourceId(aResourceId);

        temp->ConstructFromResourceL();            

        }

    if (aRectId != KUnavailableID &&

        aInnerRectId != KUnavailableID)