textinput/peninputgenericitut/src/peninputgenericitutwindow.cpp
changeset 0 eb1f2e154e89
child 5 a47de9135b21
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/textinput/peninputgenericitut/src/peninputgenericitutwindow.cpp	Tue Feb 02 01:02:04 2010 +0200
@@ -0,0 +1,1796 @@
+/*
+* 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 <aknlayoutscalable_apps.cdl.h>
+#include <peninputgeneralitutnew.rsg>
+#include <peninputitutconfig_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 "peninputrepeatbuttonex.h"
+#include <AknFepGlobalEnums.h>
+#include <aknfeppeninputenums.h>
+#include <peninputdropdownlist.h>
+#include <peninputlayoutchoicelist.h>
+#include <peninputscrollablelist.h>
+#include <s32mem.h>
+#include <peninputlabel.h>
+#include <peninputlayoutinputmodechoice.h>
+#include <peninputlayoutbubblectrl.h>
+
+#include "peninputgenericitutwindow.h"
+#include "peninputgenericitutdatamgr.h"
+#include "peninputgenericitutuimgrbase.h"
+#include "peninputgenericitutuistatebase.h"
+#include "peninputitutchnuimgr.h"
+#include "peninputitutwesternuimgr.h"
+#include "peninputgenericitutconverter.h"
+#include "peninputcommonbgctrl.h"
+
+_LIT(KBmpFileName, "z:\\resource\\apps\\peninputgenericitut.mbm");
+
+const TInt KImageMajorSkinId = EAknsMajorGeneric;
+const TUint KDefaultSpellTextColor = 0;
+const TUint KDefaultIcfTextColor = 0x000000;
+const TUint KDefaultIcfFrameColor = 0x000000;
+
+const TInt KSpaceUnicode = 32;
+const TInt KButtonOneUnicode = 49;
+
+CGenericItutWindow* CGenericItutWindow::NewL(CGenericItutWindowManager* aWindowMgr,
+                                             CGenericItutUiLayout* aLayoutOwner,
+                                             CGenericItutDataMgr* aDataMgr)
+    {
+    CGenericItutWindow* window = new (ELeave) CGenericItutWindow(aWindowMgr,aLayoutOwner,aDataMgr);
+
+    CleanupStack::PushL(window);
+    window->ConstructL();
+    CleanupStack::Pop(window);
+
+    return window;
+    }
+
+CGenericItutWindow::CGenericItutWindow(CGenericItutWindowManager* aWindowMgr, 
+                                       CGenericItutUiLayout* aLayoutOwner,
+                                       CGenericItutDataMgr* aDataMgr)
+    : iDataMgr(aDataMgr),
+      iLayoutOwner(aLayoutOwner),
+      iWindowMgr(aWindowMgr)
+    {
+    }
+
+CGenericItutWindow::~CGenericItutWindow()
+    {
+    delete iBmpRotator;
+    }
+
+void CGenericItutWindow::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;    
+        }
+    }
+
+void CGenericItutWindow::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 );
+    }
+
+void CGenericItutWindow::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);
+        }
+    }
+
+void CGenericItutWindow::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() );
+
+	//iLayoutOwner->RootControl()->Draw();
+    }
+
+void CGenericItutWindow::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 ) && (curMode != EHangul) )
+        {
+        //This array is alloced when
+        //HBufC* unicode = aReader.ReadHBufCL();
+        //unicodesArr.AppendL(unicode);
+        //So we should delete it
+        for (TInt i = 0; i <= EPosLast; i++)
+            {
+            delete unicodesArr[i];
+            }
+        SetUnicodesForHardKey1(aKey, mapData);
+        }
+    else
+        {
+        aKey->SetUnicodesL(unicodesArr);
+        }
+
+    unicodesArr.Close();
+    }
+
+CVirtualKey* CGenericItutWindow::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;
+    }
+
+void CGenericItutWindow::CreateBackGroundControlL()
+	{
+    iBackgroundCtrl = CAknFepCtrlCommonBgCtrl::NewL(
+                                          iLayoutOwner,
+                                          ECtrlIdBackground,
+                                          KAknsIIDQsnFrPopup,
+                                          KAknsIIDQsnFrPopupCenter);
+
+
+	iBackgroundCtrl->SetRect(TItutDataConverter::AnyToRect(
+					iLayoutOwner->DataMgr()->RequestData(ELayoutRect)));
+					    
+	TCommonBgCtrlSubItem bgSubItem;								
+	TRect spellPaneRect;
+	
+	spellPaneRect = TItutDataConverter::AnyToRect(
+						iDataMgr->RequestData(ESpellQueryPaneRect) );								
+
+	bgSubItem.iRect = spellPaneRect;
+	bgSubItem.iFrameID = KAknsIIDQsnFrPopupSub;
+	bgSubItem.iCenterID = KAknsIIDDefault;
+	bgSubItem.iIsShow = EFalse;
+	
+	iBackgroundCtrl->AddSubBgItemL( bgSubItem );
+								
+	AddControlL(iBackgroundCtrl);
+	}
+
+
+CAknFepCtrlCommonButton* CGenericItutWindow::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;       
+    }
+    
+CAknFepCtrlCommonButton* CGenericItutWindow::CreateCommonButtonL(const TInt aControlId)
+    {
+    return CAknFepCtrlCommonButton::NewL(iLayoutOwner, 
+    									 aControlId,
+    									 KAknsIIDQsnFrFunctionButtonNormal,
+										 KAknsIIDQsnFrFunctionButtonPressed,
+										 KAknsIIDQsnFrFunctionButtonInactive );
+     
+    }    
+    
+CAknFepCtrlCommonButton* CGenericItutWindow::CreateRepeatButtonL(const TInt aControlId,
+                                                                   const TInt aCommand)
+    {
+    return CAknFepCtrlRepeatButtonEx::NewL(iLayoutOwner,
+                                           aControlId,
+                                           KAknsIIDQsnFrFunctionButtonNormal,
+										   KAknsIIDQsnFrFunctionButtonPressed,
+										   KAknsIIDQsnFrFunctionButtonInactive,
+                                           aCommand);
+     
+    }     
+
+    
+CFepUiBaseCtrl* CGenericItutWindow::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;
+        case ERepeatButtonEx:
+            {
+            temp = CreateRepeatButtonL(aControlId, aCommand);    
+            }
+        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)
+        {
+        temp->SizeChanged(temp->Rect(), btnInnerRect, ETrue);
+        }        
+
+    AddControlL(temp);
+    
+    return temp;
+    }
+
+
+void CGenericItutWindow::CreateAllButtonL()
+    {
+    CFepUiBaseCtrl* temp = NULL;
+    //create backgrand 
+    CreateBackGroundControlL();
+    
+    //create backspace
+    CreateButtonL(ERawKeyButton, ECtrlIdBackspace, EBackspaceRect, 
+                  EBackspaceInnerRect,R_FINGER_RAWKEY_BACKSPACE);
+
+    //create switch
+    CreateButtonL(ECommonButton, ECtrlIdSwitch, ESwitchRect, 
+                  ESwitchInnerRect, R_FINGER_LAYOUT_SWITCH);
+                      
+
+    //create indicator
+//    temp = CreateButtonL(ERawKeyButton, ECtrlIdIndicator, KUnavailableID, 
+//                  KUnavailableID,KUnavailableID, 127);
+    //If open indicator menu, please use the following 2 lines
+    temp = CreateButtonL(ECommonButton, ECtrlIdIndicator, KUnavailableID, 
+                  KUnavailableID,KUnavailableID);
+                  
+    if (temp)
+        {
+        temp->Hide(ETrue);   
+        }
+    
+    temp = NULL;
+
+
+    // create navi 
+    CreateButtonL(ERawKeyButton, ECtrlIdArrowLeft, EArrowLeftRect, 
+                  ELeftInnerRect,R_FINGER_RAWKEY_LEFTARROW);    
+    
+    CreateButtonL(ERawKeyButton, ECtrlIdArrowRight, EArrowRightRect, 
+                  ERightInnerRect,R_FINGER_RAWKEY_RIGHTARROW); 
+
+    CreateButtonL(ERepeatButtonEx, ECtrlIdArrowUp, EArrowUpRect, 
+                  EUpInnerRect,R_PENINPUT_FINGER_CURSOR_UP); 
+
+    CreateButtonL(ERepeatButtonEx, ECtrlIdArrowDown, EArrowDownRect, 
+                  EDownInnerRect,R_PENINPUT_FINGER_CURSOR_DOWN);
+
+    //create option 
+    CreateButtonL(ECommonButton, ECtrlIdOptions, EOptionsRect, 
+                  EOptionInnerRect, R_PENINPUT_FINGER_OPTIONS);    
+    
+    //Crease close
+    CreateButtonL(ECommonButton, ECtrlIdClose, ECloseRect, 
+                  ECloseInnerRect, R_PENINPUT_FINGER_CLOSE);  
+                  
+                  
+    CAknFepCtrlLabel* spellIndicator = CAknFepCtrlLabel::NewL(iLayoutOwner, ECtrlIdSpellIndicator);
+    AddControlL(spellIndicator);
+    spellIndicator->Hide(ETrue);                    
+
+    }
+
+void CGenericItutWindow::CreateDropdownListL()
+    {
+	TRect outrect,innerrect;
+	outrect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(EPreviewBubbleRect));  
+	innerrect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(EPreviewBubbleInnerRect));
+    TAknTextLineLayout bubbleTextLayout = 
+        TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EPreviewBubbleTextlayout));
+    CFont* bubbleFont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EPreviewBubbleFont));
+    
+    TDropdownListDrawInfo candiDrawInfo(KAknsIIDQsnFrFunctionButtonInactive, 
+    									KAknsIIDQsnFrFunctionButtonNormal,
+    								    KAknsIIDQsnFrFunctionButtonPressed,
+    						            KAknsIIDQsnFrItutButtonCandiSideL,
+    						            KAknsIIDQsnFrItutButtonCandiMiddle,
+    						            KAknsIIDQsnFrItutButtonCandiSideR,
+    						            KAknsIIDQsnFrItutButtonCandiPressedSideL,
+    						            KAknsIIDQsnFrItutButtonCandiPressedMiddle,
+    						            KAknsIIDQsnFrItutButtonCandiPressedSideR,
+    						            TRgb(194, 221, 242),
+    						            ETrue);
+    						            
+    TDropdownListDrawInfo compositionDrawInfo(KAknsIIDQsnFrFunctionButtonInactive, 
+    									KAknsIIDQsnFrFunctionButtonNormal,
+    								    KAknsIIDQsnFrFunctionButtonPressed,
+    						            KAknsIIDQsnFrItutButtonComposeSideL,
+    						            KAknsIIDQsnFrItutButtonComposeMiddle,
+    						            KAknsIIDQsnFrItutButtonComposeSideR,
+    						            KAknsIIDQsnFrItutButtonComposePressedSideL,
+    						            KAknsIIDQsnFrItutButtonComposePressedSideR,
+    						            KAknsIIDQsnFrItutButtonComposePressedMiddle,
+    						            TRgb(194, 221, 242),
+    						            ETrue);    						            
+    TInt unitWidth =  TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistUnitWidth));
+    TInt unitHeight = TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistUnitHeight));
+    TInt horizontalMargin =  
+        TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistHorizontalMargin));
+    TInt verticalMargin =  
+        TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistVerticalMargin));
+
+    CFont* listfont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EDropdownListFont));
+    TInt textmargin = TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownListTextMargin));
+    TRgb textcolor = TItutDataConverter::AnyToRgb(iDataMgr->RequestData(EDropdownListTextColor));
+
+    TPoint spellListLTPos = 
+        TItutDataConverter::AnyToPoint(iDataMgr->RequestData(EDropdownListSpellLTPos));
+    // create spelling drop list
+    iSpellCandsList = CFepCtrlDropdownList::NewL(iLayoutOwner,
+                                                 ECtrlIdSpellCandsList,
+                                                 R_AKN_FEP_PINYIN_SPELLING_DROP_DOWN_LIST,
+                                                 spellListLTPos,
+                                                 TSize(unitWidth, unitHeight),
+                                                 5,
+                                                 3);
+
+    if (iDataMgr->IsLandScape())
+        {
+        iSpellCandsList->SetCandExpandType(CFepCtrlDropdownList::ECandExpandUpward);
+        }
+
+    iSpellCandsList->SetCellMargin(horizontalMargin, verticalMargin);
+    iSpellCandsList->SetFont(listfont);
+    AddControlL(iSpellCandsList);
+    iSpellCandsList->SetEventIdForCandidateSelected(EItutCmdCandidateSelected);
+    iSpellCandsList->SetCandTruncateType(CFepCtrlDropdownList::ECandTruncateFromBeginning);
+    iSpellCandsList->SetFuzzyBoundry(10);
+    iSpellCandsList->Hide(ETrue);
+	iSpellCandsList->SetDropdownListImgID(compositionDrawInfo);
+
+    TPoint candListLTPos = 
+        TItutDataConverter::AnyToPoint(iDataMgr->RequestData(EDropdownListCandsLTPos));
+    // create candidate drop list
+    iCandsList = CFepCtrlDropdownList::NewL(iLayoutOwner,
+                                            ECtrlIdStdCandsList,
+                                            R_AKN_FEP_NORMAL_CAND_DROP_DOWN_LIST,
+                                            candListLTPos,
+                                            TSize(unitWidth, unitHeight),
+                                            5,
+                                            3);
+
+    if (iDataMgr->IsLandScape())
+        {
+        iCandsList->SetCandExpandType(CFepCtrlDropdownList::ECandExpandUpward);
+        }
+
+    iCandsList->SetCellMargin(horizontalMargin, verticalMargin);
+    iCandsList->SetFont(listfont);
+    AddControlL(iCandsList);
+    iCandsList->SetEventIdForCandidateSelected(EItutCmdCandidateSelected);
+    iCandsList->SetEventIdForNextPageCandidate(EItutCmdGetNextCandidatePage);
+    iCandsList->SetEventIdForCandidateExisted(EItutCmdCandidateExisted);
+    iCandsList->SetCandTruncateType(CFepCtrlDropdownList::ECandTruncateAsEllipsis);        
+    iCandsList->SetFuzzyBoundry(10);
+    iCandsList->Hide(ETrue);
+	iCandsList->SetDropdownListImgID(candiDrawInfo);
+
+    TPoint puncListLTPos = 
+        TItutDataConverter::AnyToPoint(iDataMgr->RequestData(EDropdownListPuncLTPos));
+    // create punctuation drop list
+    iPuncCandsList = CFepCtrlDropdownList::NewL(iLayoutOwner,
+                                                ECtrlIdPuncCandsList,
+                                                R_AKN_FEP_PUNC_DROP_DOWN_LIST,
+                                                puncListLTPos,
+                                                TSize(unitWidth, unitHeight),
+                                                5,
+                                                1);
+    iPuncCandsList->SetCellMargin(horizontalMargin, verticalMargin);
+    iPuncCandsList->SetFont(listfont);
+    AddControlL(iPuncCandsList);
+    iPuncCandsList->SetEventIdForCandidateSelected(EItutCmdCandidateSelected);
+	iPuncCandsList->SetDropdownListImgID(candiDrawInfo);
+    iPuncCandsList->Hide(ETrue);
+    }
+
+void CGenericItutWindow::ConstructIcfFromResourceL()
+    {
+    if (!iICF->ResourceId())
+        {
+        return;
+        }
+
+    TResourceReader icfreader;
+    CCoeEnv::Static()->CreateResourceReaderLC(icfreader, iICF->ResourceId());
+    TInt32 colorMajorSkinId = icfreader.ReadInt32();
+    TInt skinitemid = icfreader.ReadInt16();
+    TInt coloridx = icfreader.ReadInt16();
+
+    TAknsItemID colorid;
+    colorid.Set(TInt(colorMajorSkinId), skinitemid);
+
+    TRgb icftextcolor;
+    MAknsSkinInstance* skininstance = AknsUtils::SkinInstance();
+    TInt error = AknsUtils::GetCachedColor(skininstance, 
+                                           icftextcolor, 
+                                           colorid, 
+                                           coloridx);
+
+    if (error != KErrNone)
+        {
+        icftextcolor = TRgb(KDefaultIcfTextColor);
+        }
+
+    iICF->SetTextColorL(icftextcolor);    
+    
+    // Set highlight color
+    TRgb icfhightlightcolor;
+    error = AknsUtils::GetCachedColor( skininstance, 
+                                       icfhightlightcolor, 
+                                       KAknsIIDQsnHighlightColors,
+                                       EAknsCIQsnHighlightColorsCG2 ); 
+    if ( error == KErrNone ) 
+        {
+        iICF->SetTextSelColorL( icfhightlightcolor );
+        }
+
+    skinitemid = icfreader.ReadInt16();
+    coloridx = icfreader.ReadInt16();
+    
+    colorid.Set(TInt(colorMajorSkinId), skinitemid);
+    
+    TRgb icfframecolor;
+    error = AknsUtils::GetCachedColor(skininstance, 
+                                      icfframecolor, 
+                                      colorid, 
+                                      coloridx);
+
+    if (error != KErrNone)
+        {
+    	icfframecolor = TRgb(KDefaultIcfFrameColor);
+        }
+
+    iICF->SetBorderColor(icfframecolor);
+    CleanupStack::PopAndDestroy( 1 ); // icfreader
+    }
+
+void CGenericItutWindow::CreateICFL()
+    {
+    CFont* icffont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EIcfFont));
+    TRect rect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(EIcfRect));
+    iICF = CFepLayoutMultiLineIcf::NewL(rect, 
+                                        iLayoutOwner, 
+                                        ECtrlIdICF, 
+                                        icffont->HeightInPixels(),
+                                        icffont->FontMaxHeight(),
+                                        icffont);
+
+    iICF->SetFocus(ETrue);
+
+    iICF->SetResourceId(R_FINGER_ICF);
+    ConstructIcfFromResourceL();
+    iICF->SetBgImgSkinId(KAknsIIDQsnFrCall2Rect);
+    //iDataMgr->SetTextAlignment();
+    
+    AddControlL(iICF);
+    }
+
+void CGenericItutWindow::AddEditorMenuL()
+    {
+    iEditorMenu = CPeninputCommonChoiceList::NewL( iLayoutOwner, 
+                                        			ECtrlIdEditorMenu,
+                                        			KAknsIIDQsnFrList,
+                                        			KAknsIIDQsnFrPopupSub );
+    
+    AddControlL( iEditorMenu );
+    }
+
+void CGenericItutWindow::ShowEditorMenuL(TInt* aData)
+    {
+    TInt count = *aData;
+    iEditorMenu->ClearItemsL();
+    for (TInt i=1;i<=count;i++ )
+        {
+        TInt menucommand = *(aData+i);
+        CGenericItutDataMgr::TMenuItem* menuitem = iDataMgr->GetMenuItem(menucommand);
+        if ( menuitem )
+            {
+            CFepLayoutChoiceList::SItem item;
+            item.iCommand = menucommand;
+            item.iText = menuitem->iText;
+            iEditorMenu->AddItemL(item);                        
+            }
+        }
+           
+    if ( count > 0 )
+        {
+        iEditorMenu->SetListColumnNumWithLafL(count); 
+        iEditorMenu->Display(Control(ECtrlIdIndicator)->Rect());
+        }                
+    }
+
+void CGenericItutWindow::ConstructL()
+    {
+    iBmpRotator = CPeninputSyncBitmapRotator::NewL();
+    CreateAllButtonL();
+    CreateItutKeypadL();
+    CreateICFL();
+    CreateMatchSelectionCtrlL();
+    
+    AddEditorMenuL();
+    
+    iInputModeSwitch = CPeninputLayoutInputmodelChoice::NewL(
+                                     iLayoutOwner,
+                                     ECtrlIdInputSwitch,
+                                     EPluginInputModeItut );
+    iInputModeSwitch->SetListSkinID( KAknsIIDQsnFrList, KAknsIIDQsnFrPopupSub );
+    AddControlL( iInputModeSwitch );
+    
+   
+    iBubbleSize = AknLayoutScalable_Apps::popup_char_count_window().LayoutLine();
+    iBubbleTextLayout = AknLayoutScalable_Apps::popup_char_count_window_t1(0).LayoutLine();
+    
+    iICF->MsgBubbleCtrl()->SetTextFormat(iBubbleTextLayout);
+    iICF->MsgBubbleCtrl()->SetTextColorIndex( EAknsCIQsnTextColorsCG67 );
+    //Change the ID when ID into release
+    iICF->MsgBubbleCtrl()->SetBitmapParam(NULL,
+    									  NULL,
+    									  KAknsIIDQsnFrInputPreviewSideL,
+    									  KAknsIIDQsnFrInputPreviewMiddle,
+    									  KAknsIIDQsnFrInputPreviewSideR);  
+    iICF->SetMsgBubbleCtrlSize(TSize(iBubbleSize.iW,iBubbleSize.iH));
+    /* Teleca change start, 18.05.2009 ssal */ 
+    iICF->InfoBubbleCtrl()->SetTextFormat(iBubbleTextLayout); 
+    iICF->InfoBubbleCtrl()->SetTextColorIndex( EAknsCIQsnTextColorsCG67 );
+    iICF->InfoBubbleCtrl()->SetBitmapParam(NULL,
+    									  NULL,
+    									  KAknsIIDQsnFrInputPreviewSideL,
+    									  KAknsIIDQsnFrInputPreviewMiddle,
+    									  KAknsIIDQsnFrInputPreviewSideR);  
+    iICF->SetInfoBubbleCtrlSize(TSize(iBubbleSize.iW,iBubbleSize.iH));
+    }
+
+void CGenericItutWindow::AddControlL(CFepUiBaseCtrl* aControl)
+    {
+    iLayoutOwner->AddControlL(aControl);   
+    }
+
+void CGenericItutWindow::CreateChineseSpecificCtrlsIfNeededL()
+    {
+    if (iChnCtrlInited)
+        {
+        return;
+        }
+
+    CreateDropdownListL();
+    // create spell control for stroke/zhuyin
+    TRect rect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(ESpellRect));
+    iSpell = CFepInputContextField::NewL(rect, iLayoutOwner, ECtrlIdSpellICF);
+
+    iSpell->SetResourceId(R_FINGER_SPELL);
+    ConstructSpellCtrlFromResourceL();
+
+    iSpell->SetFont(TItutDataConverter::AnyToFont(iDataMgr->RequestData(ESpellFont)));
+    AddControlL(iSpell); 
+
+    iSpell->Hide(ETrue);
+    
+  
+    iChnCtrlInited = ETrue;
+    }
+
+void CGenericItutWindow::ConstructSpellCtrlFromResourceL()
+    {
+    if (!iSpell || !iSpell->ResourceId())
+        {
+        return;
+        }
+
+    TResourceReader spellreader;
+    CCoeEnv::Static()->CreateResourceReaderLC(spellreader, iSpell->ResourceId());
+
+    TInt bgimgResId = spellreader.ReadInt32();
+    TResourceReader bgreader;
+    CCoeEnv::Static()->CreateResourceReaderLC(bgreader, bgimgResId);
+
+    TInt bmpid = bgreader.ReadInt16();
+    TInt maskbmpid = bgreader.ReadInt16();
+    TInt bmpskinid = bgreader.ReadInt16();
+
+    CFbsBitmap* bmp = NULL;
+    CFbsBitmap* maskbmp = NULL;
+    
+    CreateLayoutIconL(KImageMajorSkinId,
+                      bmpskinid,
+                      KBmpFileName,
+                      bmpid,
+                      maskbmpid,
+                      bmp,
+                      maskbmp,
+                      iSpell->Rect().Size());
+
+    CleanupStack::PushL( bmp );       
+    CleanupStack::PushL( maskbmp );       
+
+    if (bmp)
+        {
+        iSpell->SetBackgroundBitmapL(bmp);
+        }
+  
+    CleanupStack::PopAndDestroy( maskbmp );       
+    CleanupStack::Pop( bmp );
+
+    CleanupStack::PopAndDestroy( 1 ); // bgreader
+
+    TInt colorMajorSkinId = spellreader.ReadInt32();
+    TInt skinitemid= spellreader.ReadInt16();
+    TInt coloridx = spellreader.ReadInt16();
+
+    TAknsItemID colorid;
+    colorid.Set(TInt(colorMajorSkinId), skinitemid);
+
+    TRgb spelltextcolor;
+    MAknsSkinInstance* skininstance = AknsUtils::SkinInstance();
+    TInt error = AknsUtils::GetCachedColor(skininstance, 
+                                           spelltextcolor, 
+                                           colorid, 
+                                           coloridx);
+
+    if (error != KErrNone)
+        {
+        spelltextcolor = TRgb(KDefaultSpellTextColor);
+        }
+
+    iSpell->SetTextColor(spelltextcolor);
+
+    CleanupStack::PopAndDestroy( 1 ); // spellreader
+    }
+
+
+TRgb CGenericItutWindow::GetMatchListTextColor()
+    {
+    MAknsSkinInstance* skininstance = AknsUtils::SkinInstance();
+    TRgb matchlistcolor;
+    TInt error = AknsUtils::GetCachedColor(skininstance, 
+                                           matchlistcolor, 
+                                           KAknsIIDQsnTextColors,
+                                           EAknsCIQsnTextColorsCG43);
+
+    if (error != KErrNone)
+        {
+        matchlistcolor = TRgb(KDefaultIcfTextColor);
+        }
+    
+    return matchlistcolor;
+    }
+
+void CGenericItutWindow::CreateMatchSelectionCtrlL()
+    {
+    // size and pos info of new match selection list should get from laf: later
+    iMatchSelection = CFepLayoutScrollableList::NewL(iLayoutOwner, 
+                                                     ECtrlIdMatchSelection,
+                                                     iDataMgr->iSelectionItemSize,
+                                                     iDataMgr->iSelectionHorMargin,
+                                                     iDataMgr->iSelectionVerMargin,
+                                                     iDataMgr->iSelectionNaviSize,
+                                                     iDataMgr->iSelectionNaviInnerSize);
+     
+    iMatchSelection->SetImgFrId(KAknsIIDQsnFrPopupSub, 
+                                KAknsIIDQsnFrFunctionButtonNormal,
+								KAknsIIDQsnFrFunctionButtonPressed,
+								KAknsIIDQsnFrFunctionButtonInactive,
+                                KAknsIIDQsnFrList,
+                                KAknsIIDQsnFrPopupSub);
+    CFont* itemfont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EIcfFont));
+    TRgb textcolor = GetMatchListTextColor();
+
+    iMatchSelection->SetTextProperty(itemfont, textcolor);
+    iMatchSelection->SetResourceId(R_FINGER_SELECTION_LIST);
+    iMatchSelection->ConstructFromResourceL();
+    iMatchSelection->SetTextLineLayout( iDataMgr->iSelectionTextLine );
+    iMatchSelection->SetPageInfoTextLineLayout( iDataMgr->iSelectionPageTextLine );
+    iMatchSelection->SetPageInfoResID( R_PENINPUT_SELECTION_LIST_PAGE_NUM );
+    AddControlL(iMatchSelection);
+    }
+
+TInt CGenericItutWindow::OnAppEditorTextComing(const TFepInputContextFieldData& aData)
+    {
+    TRAPD(err, iICF->SetTextL(aData));
+
+    // make sure if selection list on top of multiline icf,
+    // it will not be hidden by icf
+    if (!iMatchSelection->Hiden())
+        {
+        iMatchSelection->Draw();
+        }
+
+    return err;
+    }
+
+
+    
+void CGenericItutWindow::SetIndicatorImageL(CFepUiBaseCtrl* aIndicator,
+                                              const TInt aImgID1,
+                                              const TInt aMaskID1,
+                                              const TInt aImgID2,
+                                              const TInt aMaskID2)
+    {
+    MAknsSkinInstance* skininstance = AknsUtils::SkinInstance();
+
+    CFbsBitmap* bmp1 = NULL;
+    CFbsBitmap* mask1 = NULL;
+    
+    TInt colorIndex;
+    if (iLayoutOwner->UiMgr()->CurrentState()->StateType() ==
+            CGenericItutUiMgrBase::EStateSpelling)
+		{
+		colorIndex = EAknsCIQsnIconColorsCG10;
+		}
+    else
+		{
+		colorIndex = EAknsCIQsnIconColorsCG30;
+		}
+    AknsUtils::CreateColorIconL(skininstance,
+                                KAknsIIDQsnIconColors,
+                                KAknsIIDQsnIconColors,
+                                colorIndex,
+                                bmp1,
+                                mask1,
+                                AknIconUtils::AvkonIconFileName(),
+                                aImgID1,
+                                aMaskID1,
+                                KRgbGray);
+    CleanupStack::PushL( bmp1 );
+    CleanupStack::PushL( mask1 );
+                                
+    AknIconUtils::GetContentDimensions(bmp1, iIndicatorSize);
+
+    CFbsBitmap* bmp2 = NULL;
+    CFbsBitmap* mask2 = NULL;
+    AknsUtils::CreateColorIconL(skininstance,
+                                KAknsIIDQsnIconColors,
+                                KAknsIIDQsnIconColors,
+                                colorIndex,
+                                bmp2,
+                                mask2,
+                                AknIconUtils::AvkonIconFileName(),
+                                aImgID2,
+                                aMaskID2,
+                                KRgbGray);
+ 
+    CleanupStack::PushL( bmp2 );
+    CleanupStack::PushL( mask2 );
+    
+    AknIconUtils::GetContentDimensions(bmp2, iIndicatorTextSize);
+
+    TRect boundRect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(EImIndicatorRect));
+    TRect imgrect, textrect;
+
+    if (aIndicator->ControlId() == ECtrlIdIndicator)
+        {
+        CalIndicatorRect(boundRect, imgrect, textrect, EIndiAlignCenter);
+        AknIconUtils::SetSize(bmp1, imgrect.Size(), EAspectRatioNotPreserved);
+        AknIconUtils::SetSize(mask1, imgrect.Size(), EAspectRatioNotPreserved);
+        AknIconUtils::SetSize(bmp2, textrect.Size(), EAspectRatioNotPreserved);
+        AknIconUtils::SetSize(mask2, textrect.Size(), EAspectRatioNotPreserved);
+
+        CFbsBitmap* bmp3 = AknPenImageUtils::CombineTwoImagesL(bmp1, bmp2, EColor256);
+        CFbsBitmap* mask3 = AknPenImageUtils::CombineTwoImagesL(mask1, mask2, EGray256);
+        
+        TInt bigger = imgrect.Height() > textrect.Height() ? imgrect.Height() : textrect.Height();
+        TRect indirect(imgrect.iTl, TSize(imgrect.Width() + textrect.Width(), bigger));
+        // button like indicator
+        CAknFepCtrlCommonButton* indibtn = static_cast<CAknFepCtrlCommonButton*>(aIndicator);
+        TRect outerrect = 
+                       TItutDataConverter::AnyToRect(iDataMgr->RequestData(EImIndicatorOuterRect));
+        /*if (IsChineseMode())
+            {
+            indirect.Move( TPoint(0 , 0));
+            }
+        else
+            {
+            indirect.Move(TPoint( -20 ,0));//
+            }
+        */
+        indibtn->SetForgroundBmpRect(indirect);
+        indibtn->SetForegroundBmpL(bmp3, mask3);
+        indibtn->SetRect(outerrect);
+        //indibtn->Hide(EFalse);
+        }
+    else
+        {
+        CalIndicatorRect(boundRect, imgrect, textrect, EIndiAlignRight);
+        AknIconUtils::SetSize(bmp1, imgrect.Size(), EAspectRatioNotPreserved);
+        AknIconUtils::SetSize(mask1, imgrect.Size(), EAspectRatioNotPreserved);
+        AknIconUtils::SetSize(bmp2, textrect.Size(), EAspectRatioNotPreserved);
+        AknIconUtils::SetSize(mask2, textrect.Size(), EAspectRatioNotPreserved);
+
+        CFbsBitmap* bmp3 = AknPenImageUtils::CombineTwoImagesL(bmp1, bmp2, EColor256);
+        CFbsBitmap* mask3 = AknPenImageUtils::CombineTwoImagesL(mask1, mask2, EGray256);
+        
+        TInt bigger = imgrect.Height() > textrect.Height() ? imgrect.Height() : textrect.Height();
+        TRect indirect(imgrect.iTl, TSize(imgrect.Width() + textrect.Width(), bigger));
+ 		
+        // label like indicator
+        CAknFepCtrlLabel* indilabel = static_cast<CAknFepCtrlLabel*>(aIndicator);
+        indilabel->SetBitmapL(bmp3);
+        indilabel->SetMaskBitmapL(mask3);
+        indilabel->SetRect(indirect);
+        //indilabel->Hide(EFalse);
+        }
+
+    CleanupStack::PopAndDestroy( mask2 );
+    CleanupStack::PopAndDestroy( bmp2 );
+    CleanupStack::PopAndDestroy( mask1 );
+    CleanupStack::PopAndDestroy( bmp1 );    
+    }
+
+
+void CGenericItutWindow::UpdateIndicatorL(TUint8* aData)
+    {
+    if ( iLayoutOwner->UiMgr()->CurrentState()->StateType() == 
+            CGenericItutUiMgrBase::EStateComposition ||
+         iLayoutOwner->UiMgr()->CurrentState()->StateType() == 
+            CGenericItutUiMgrBase::EStatePredict )
+        {
+        return;
+        }
+        
+	RDesReadStream readStream;
+
+    TFepIndicatorInfo indicatorData;
+
+    TPtr8 countPtr( aData, 4*sizeof(TInt), 4*sizeof(TInt) );            
+	readStream.Open(countPtr);
+	CleanupClosePushL(readStream);
+
+    indicatorData.iIndicatorImgID = readStream.ReadInt32L();
+    indicatorData.iIndicatorMaskID = readStream.ReadInt32L();
+    indicatorData.iIndicatorTextImgID = readStream.ReadInt32L();
+    indicatorData.iIndicatorTextMaskID = readStream.ReadInt32L();
+
+    CleanupStack::PopAndDestroy(&readStream);
+
+    if (indicatorData.iIndicatorImgID != 0 && 
+        indicatorData.iIndicatorMaskID != 0 && 
+        indicatorData.iIndicatorTextImgID != 0 &&
+        indicatorData.iIndicatorTextMaskID != 0)
+        {
+        iDataMgr->SetIndicatorData(indicatorData);
+        iImDimensionSet = ETrue;
+        
+        
+        CFepUiBaseCtrl* temp = NULL;
+        
+        
+        if (iLayoutOwner->UiMgr()->CurrentState()->StateType() ==
+            CGenericItutUiMgrBase::EStateSpelling)
+            {
+            temp = Control(ECtrlIdSpellIndicator);
+            Control(ECtrlIdIndicator)->Hide(ETrue);  
+	        SetIndicatorImageL(temp, 
+	                           indicatorData.iIndicatorImgID,
+	                           indicatorData.iIndicatorMaskID,
+	                           indicatorData.iIndicatorTextImgID,
+	                           indicatorData.iIndicatorTextMaskID);
+	        if( temp->Hiden() )               
+	            {
+	            temp->Hide( EFalse );    
+	            }
+	        else
+	            {
+	           	iLayoutOwner->RootControl()->ReDrawRect(temp->Rect()); 
+	            iLayoutOwner->RootControl()->UpdateArea( temp->Rect() );
+	            }
+            }
+        else
+            {
+            temp = Control(ECtrlIdIndicator); 
+            Control(ECtrlIdSpellIndicator)->Hide(ETrue);  
+	    SetIndicatorImageL(temp, 
+	                           indicatorData.iIndicatorImgID,
+	                           indicatorData.iIndicatorMaskID,
+	                           indicatorData.iIndicatorTextImgID,
+	                           indicatorData.iIndicatorTextMaskID);
+	    if( temp->Hiden() )               
+	        {
+	        temp->Hide( EFalse );    
+	        }
+	    else
+	        {
+                temp->ClearRect( temp->Rect() );
+	        temp->Draw();
+	        temp->UpdateArea( temp->Rect() );
+            iLayoutOwner->RootControl()->ReDrawRect( temp->Rect() );
+	        }                   
+            }
+        }
+    }
+
+void CGenericItutWindow::CalIndicatorRect(const TRect& aBoundRect,
+                                          TRect& aRealRect1,
+                                          TRect& aRealRect2,
+                                          TIndicatorAlign aAlign) 
+	{
+	if (!iImDimensionSet)
+		{
+		return;
+		}
+	
+	TInt imgAspectText = iIndicatorTextSize.iWidth / iIndicatorTextSize.iHeight;
+	TInt imgAspectIndi = iIndicatorSize.iWidth / iIndicatorSize.iHeight;
+    TSize imgSizeText( aBoundRect.Size().iHeight * imgAspectText, 
+    			  	   aBoundRect.Size().iHeight );
+	TSize imgSizeIndi( aBoundRect.Size().iHeight * imgAspectIndi, 
+    			   			   aBoundRect.Size().iHeight );
+	// check if the length of img > bound rect width
+	TInt nTotalWidth = imgSizeText.iWidth + imgSizeIndi.iWidth;
+	if( nTotalWidth > aBoundRect.Size().iWidth )
+		{
+		TReal nAspect = (TReal)imgSizeText.iWidth / nTotalWidth;
+		imgSizeText.iWidth = aBoundRect.Size().iWidth * nAspect;
+		imgSizeIndi.iWidth = aBoundRect.Size().iWidth - imgSizeText.iWidth;
+		imgSizeText.iHeight = imgSizeText.iWidth / imgAspectText;
+		// make sure the height of two rect is equal
+		imgSizeIndi.iHeight = imgSizeText.iHeight;
+		
+		/*	TInt n = (nTotalWidth - aBoundRect.Size().iWidth) / 2;
+		imgSizeText.iWidth -= n;
+		imgSizeIndi.iWidth -= n;
+		imgSizeText.iHeight -= n / imgAspectText;
+		imgSizeIndi.iHeight -= n / imgAspectIndi;
+		*/
+		}
+	if( aAlign == EIndiAlignRight )
+		{
+    	aRealRect2 = TRect(TPoint( aBoundRect.iBr.iX - imgSizeText.iWidth, aBoundRect.iTl.iY),
+    			   	   imgSizeText);
+		aRealRect1 = TRect(TPoint(aRealRect2.iTl.iX - imgSizeIndi.iWidth, aRealRect2.iTl.iY),
+				       imgSizeIndi);
+		}
+	else if( aAlign == EIndiAlignCenter )
+		{
+		TInt offsetX = ( aBoundRect.Size().iWidth - imgSizeText.iWidth - imgSizeIndi.iWidth ) / 2;
+		TInt offsetY = ( aBoundRect.Size().iHeight - imgSizeText.iHeight ) / 2;
+    	aRealRect2 = TRect( TPoint( aBoundRect.iBr.iX - imgSizeText.iWidth - offsetX, 
+    							   aBoundRect.iTl.iY + offsetY),
+    			   	   	    imgSizeText );
+		aRealRect1 = TRect( TPoint(aRealRect2.iTl.iX - imgSizeIndi.iWidth, aRealRect2.iTl.iY),
+				       imgSizeIndi );
+		}
+	else if( aAlign == EIndiAlignLeft )
+		{
+		aRealRect1 = TRect( aBoundRect.iTl, imgSizeIndi );
+		aRealRect2 = TRect( TPoint( aRealRect1.iBr.iX, aRealRect1.iTl.iY ), imgSizeText );
+		}
+	}
+
+void CGenericItutWindow::SetPromptTextL(TUint8* aData)
+    {
+    RDesReadStream readStream;
+
+    TPtr8 countPtr(aData, 2*sizeof(TInt), 2*sizeof(TInt));
+	  readStream.Open(countPtr);
+	  CleanupClosePushL(readStream);
+    const TInt dataCount = readStream.ReadInt32L();
+	  const TInt textCount = readStream.ReadInt32L();
+    CleanupStack::PopAndDestroy(&readStream);
+    
+    TPtr8 ptr( aData+2*sizeof(TInt), dataCount+textCount, dataCount+textCount );            
+	  readStream.Open(ptr);
+	  CleanupClosePushL(readStream);
+	
+	  HBufC8* dataBuf = HBufC8::NewLC(dataCount);
+	  TPtr8 dataBufPtr = dataBuf->Des();
+	  readStream.ReadL(dataBufPtr, dataCount);
+
+    TFepPromptText* pIcfData = 
+        reinterpret_cast<TFepPromptText*>(const_cast<TUint8*>(dataBufPtr.Ptr()));
+
+    HBufC* textBuf;
+    if (textCount > 0)
+        {
+        textBuf = HBufC::NewLC(textCount/2);
+    	TPtr textBufPtr = textBuf->Des();
+    	readStream.ReadL(textBufPtr, textCount/2);
+         
+        const HBufC* icfPromptText = iICF->PromptText();
+        
+        if (!icfPromptText || icfPromptText->Compare(textBuf->Des()) != 0 )
+        	{
+        	iICF->SetPromptTextL( textBuf->Des(), pIcfData->iCleanContent );	
+        	}
+        
+        CleanupStack::PopAndDestroy(textBuf);
+        }
+    else
+        {
+        iICF->SetPromptTextL(KNullDesC, pIcfData->iCleanContent);
+        }
+
+    CleanupStack::PopAndDestroy(dataBuf);
+	  CleanupStack::PopAndDestroy(&readStream);
+    }
+
+TInt CGenericItutWindow::PenInputType()
+    {
+    return EPluginInputModeItut;
+    }
+
+void CGenericItutWindow::SetCtrlRect(CFepUiBaseCtrl* aCtrl, TInt aRectIdx)
+    {
+    aCtrl->SetRect(TItutDataConverter::AnyToRect(iDataMgr->RequestData(aRectIdx)));
+    }
+
+TInt CGenericItutWindow::SizeChanged(TBool aIcfOverlap)
+    {
+    // resize all controls
+    SetCtrlRect(iStandardItutKp, EKeypadRect);
+
+    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);
+    
+    RPointerArray<CVirtualKey>& keys = 
+        const_cast<RPointerArray<CVirtualKey>&>(iStandardItutKp->KeyArray());
+    RArray<TRect>& cellRects = 
+        TItutDataConverter::AnyToRectArray(iDataMgr->RequestData(EKeypadCellRects));
+
+    for (TInt i = 0 ; i < keys.Count(); i++)
+        {
+        keys[i]->SetRect(cellRects[i]);
+        TRect innerrect = cellRects[i];
+        innerrect.Shrink(TSize(4, 4));
+        keys[i]->SetInnerRect(innerrect);
+        }
+	// set key background image size
+	TSize curSize = cellRects[0].Size();
+	if( iStandardItutKp->NonIrregularKeyBitmap(EKeyBmpNormal) )
+		{
+		TSize size = iStandardItutKp->NonIrregularKeyBitmap(EKeyBmpNormal)->SizeInPixels();
+		if( curSize != size )	
+			{
+	        for ( TInt i = 0; i <= EKeyBmpLastType; i++ )
+	            {
+	            if( iStandardItutKp->NonIrregularKeyBitmap((TVirtualKeyBmpType)i) )
+	            	{
+	                AknIconUtils::SetSize( 
+                                   iStandardItutKp->NonIrregularKeyBitmap((TVirtualKeyBmpType)i), 
+                                   curSize, EAspectRatioNotPreserved );                    		
+	            	}
+	            }	
+			}
+		}
+   iMatchSelection->SetPageInfoTextLineLayout( iDataMgr->iSelectionPageTextLine );
+   iMatchSelection->SizeChanged( 
+        iDataMgr->iSelectionItemSize,
+        iDataMgr->iSelectionHorMargin,
+        iDataMgr->iSelectionVerMargin,
+        iDataMgr->iSelectionNaviSize,
+        iDataMgr->iSelectionNaviInnerSize);
+
+    // should set textline when it is defined in laf
+    CFont* itemfont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EIcfFont));
+    TRgb textcolor = GetMatchListTextColor();
+    iMatchSelection->SetTextProperty(
+        TItutDataConverter::AnyToFont(iDataMgr->RequestData(EIcfFont)), GetMatchListTextColor());
+
+	iBackgroundCtrl->SizeChanged( 
+                         TItutDataConverter::AnyToRect(iDataMgr->RequestData( ELayoutRect ) ) );
+	iBackgroundCtrl->GetSubBgItem(0).iRect = TItutDataConverter::AnyToRect(
+											   iDataMgr->RequestData(ESpellQueryPaneRect) );								
+	
+    TRAP_IGNORE(ApplyVariantLafDataL(ETrue); 
+                iLayoutOwner->HandleCommand(EItutExtCmdSizeChanged, NULL));
+    
+    
+    if (iChnCtrlInited)
+        {
+        SetCtrlRect(iSpell, ESpellRect);
+        iSpell->SetFont(TItutDataConverter::AnyToFont(iDataMgr->RequestData(ESpellFont)));
+
+        ResizeCandidateList(iSpellCandsList, EDropdownListSpellLTPos, ETrue);
+        ResizeCandidateList(iCandsList, EDropdownListCandsLTPos, ETrue);
+        ResizeCandidateList(iPuncCandsList, EDropdownListPuncLTPos, EFalse);
+        }
+        
+    if (aIcfOverlap && !iMatchSelection->Hiden())
+        {
+        iICF->SetOverLapState(ETrue, iMatchSelection->Rect());
+        }
+
+    return KErrNone;    
+    }
+
+TBool CGenericItutWindow::ControlSizeChanged(const TInt aControlId, 
+                                            const TInt aRect, 
+                                            const TInt aInnerRect, 
+                                            TBool aIsReloadImages)
+    {
+    CAknFepCtrlCommonButton* temp = CommonButtonControl(aControlId);
+    if( !temp )
+    	return EFalse;
+    
+
+    TRect rect;
+    TRect innerRect;
+    
+    rect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(aRect));
+	innerRect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(aInnerRect));
+    
+    TBool bSizedChanged = (rect.Size() != temp->Rect().Size()) && 
+    	    (innerRect.Size() != temp->ForgroundBmpRect().Size());
+    temp->SizeChanged(rect, innerRect, aIsReloadImages);   
+      
+    return bSizedChanged;
+    }
+
+void CGenericItutWindow::ApplyVariantLafDataL(TBool aResolutionChange)
+    {
+    if (aResolutionChange)
+        {
+        CAknFepCtrlCommonButton* indibutton = CommonButtonControl(ECtrlIdIndicator);
+
+        SetIndicatorImageL(indibutton, 
+                           iDataMgr->IndicatorData().iIndicatorImgID,
+                           iDataMgr->IndicatorData().iIndicatorMaskID,
+                           iDataMgr->IndicatorData().iIndicatorTextImgID,
+                           iDataMgr->IndicatorData().iIndicatorTextMaskID);              
+        }
+
+    CFont* icffont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EIcfFont));
+    iICF->Hide(ETrue);
+    
+    if( iDataMgr->IsChinese() )
+    	{
+    	iICF->SetTextMargin ( iDataMgr->iIcfTextLeftMarginCn,
+    					  iDataMgr->iIcfTextRightMarginCn,
+    					  iDataMgr->iIcfTextTopMarginCn,
+    					  iDataMgr->iIcfTextBottomMarginCn );
+    					  
+	    iICF->SetLineSpace( iDataMgr->iIcfTextLineSpaceMarginCn );    					  
+	 
+	    iICF->SizeChangedL(TItutDataConverter::AnyToRect(iDataMgr->RequestData(EIcfRect)), 
+	                      //icffont->HeightInPixels(),
+	                      iDataMgr->iIcfTextHeightCn,
+	                      icffont->FontMaxHeight(),
+	                      icffont);	    		
+    	}
+    else
+    	{
+	    iICF->SetTextMargin ( iDataMgr->iIcfTextLeftMargin,
+	    					  iDataMgr->iIcfTextRightMargin,
+	    					  iDataMgr->iIcfTextTopMargin,
+	    					  iDataMgr->iIcfTextBottomMargin );
+	    					  
+	    iICF->SetLineSpace( iDataMgr->iIcfTextLineSpaceMargin );    					  
+	 
+	    iICF->SizeChangedL(TItutDataConverter::AnyToRect(iDataMgr->RequestData(EIcfRect)), 
+	                      //icffont->HeightInPixels(),
+	                      iDataMgr->iIcfTextHeight,
+	                      icffont->FontMaxHeight(),
+	                      icffont);
+    	}
+
+    iICF->Hide(EFalse);    
+    
+    if( iDataMgr->IsChinese() )
+        {
+        ControlSizeChanged(ECtrlIdArrowUp, EArrowUpRect, EUpInnerRect, ETrue);
+        ControlSizeChanged(ECtrlIdArrowDown, EArrowDownRect, EDownInnerRect, ETrue);
+        }
+    
+    TBool bSizeChanged = EFalse;       
+    ControlSizeChanged(ECtrlIdArrowLeft, EArrowLeftRect, ELeftInnerRect, ETrue);
+    ControlSizeChanged(ECtrlIdArrowRight, EArrowRightRect, ERightInnerRect, ETrue);
+    ControlSizeChanged(ECtrlIdSwitch, ESwitchRect, ESwitchInnerRect, ETrue);
+    bSizeChanged = ControlSizeChanged(ECtrlIdBackspace, EBackspaceRect, EBackspaceInnerRect, ETrue);
+    ControlSizeChanged(ECtrlIdOptions, EOptionsRect, EOptionInnerRect, ETrue);
+    ControlSizeChanged(ECtrlIdClose, ECloseRect, ECloseInnerRect, ETrue);
+   						  	
+    // resize all controls
+    SetCtrlRect(iStandardItutKp, EKeypadRect); 
+    
+    // Handle control res when language direction changing here.
+    if( iDataMgr->IsLangDirectionSwitch() || 
+    	( bSizeChanged && iDataMgr->IsRtoLLanguage() ) )
+    	{
+    	HandleButtonResOnLangDirChange( ECtrlIdBackspace );
+    	iDataMgr->SetLangDirectionSwitch( EFalse );	
+    	}   
+    }
+
+void CGenericItutWindow::ResizeCandidateList(CFepCtrlDropdownList* aList, 
+                                             TInt aLTPosIdx, TBool aExpandable)
+    {
+    if (!aList)
+        {
+        return;   
+        }
+    
+    TInt unitWidth = TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistUnitWidth));
+    TInt unitHeight = TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistUnitHeight));
+    TInt horizontalMargin = 
+        TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistHorizontalMargin));
+    TInt verticalMargin = 
+        TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistVerticalMargin));
+    //TInt naviWidth = TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownListNaviWidth));
+    TInt naviWidth = TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistUnitWidth));
+    CFont* listfont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EDropdownListFont));
+    TPoint listLTPos = TItutDataConverter::AnyToPoint(iDataMgr->RequestData(aLTPosIdx));
+    
+    aList->SizeChanged(unitWidth, 
+                       unitHeight,
+                       naviWidth,
+                       listLTPos);
+
+    aList->SetCellMargin(horizontalMargin, verticalMargin);
+    
+    if (aExpandable)
+        {
+        TInt naviSpinBtnHeight = 
+            TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownListSpinBtnHeight));
+        
+        aList->SetSpinBtnHeight(naviSpinBtnHeight);
+        }
+    }
+
+void CGenericItutWindow::OnSkinChange()
+    {
+    CFont* itemfont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EIcfFont));
+    TRgb textcolor = GetMatchListTextColor();
+    iMatchSelection->SetTextProperty(itemfont, textcolor); 
+    
+    // when skin change all control with skin image should be reload.
+    TRAP_IGNORE(ConstructKeyImageFromResourceL( R_ITUT_KEYPAD_BITMAP ));    
+    
+    // reconstruct shift icon when skin changed
+    TRAP_IGNORE(iStandardItutKp->ShiftIcon()->ReConstructL());
+    TRAP_IGNORE(iStandardItutKp->ShiftIcon()->ResizeL(iDataMgr->iShiftIconRect.Size()));
+    
+    //Skin change will case the reconstuction of the button graphic.
+    //When language is RToL, it should be mirrored again.
+    if( iDataMgr->IsRtoLLanguage() )
+    	{
+    	HandleButtonResOnLangDirChange( ECtrlIdBackspace );	
+    	}
+    }
+
+
+void CGenericItutWindow::CalculateFrameRects(const TRect aRect,
+											 TRect& aOuterRect, 
+											 TRect& aInnerRect )
+    {
+    TRect windowRect = aRect;
+    
+    TAknLayoutRect topLeft;
+    topLeft.LayoutRect(windowRect, SkinLayout::Submenu_skin_placing_Line_2());
+
+    TAknLayoutRect bottomRight;
+    bottomRight.LayoutRect(windowRect, SkinLayout::Submenu_skin_placing_Line_5());
+
+    aOuterRect = TRect(topLeft.Rect().iTl, bottomRight.Rect().iBr);
+    aInnerRect = TRect(topLeft.Rect().iBr, bottomRight.Rect().iTl);
+    }
+    
+void CGenericItutWindow::EnterMatchSelectionState(TBool aOn)
+    {
+    TBuf<4> buf;
+    buf.Append(reinterpret_cast<TText*>(&aOn), sizeof(TBool)/sizeof(TText));
+    iLayoutOwner->SignalOwner(ESignalEnterMatchSelection, buf);
+    }
+
+void CGenericItutWindow::ResetIndicatorL(CFepUiBaseCtrl* aIndicator)
+	{
+    SetIndicatorImageL(aIndicator, 
+                       iDataMgr->IndicatorData().iIndicatorImgID,
+                       iDataMgr->IndicatorData().iIndicatorMaskID,
+                       iDataMgr->IndicatorData().iIndicatorTextImgID,
+                       iDataMgr->IndicatorData().iIndicatorTextMaskID);
+	}
+
+CAknFepCtrlCommonButton* CGenericItutWindow::CommonButtonControl(const TInt aControlId)
+    {
+    CFepUiBaseCtrl* ctrl = NULL;
+    ctrl = Control(aControlId);
+    
+    if (!ctrl)
+        {
+        return NULL;   
+        }
+        
+    if (!ctrl->IsKindOfControl(ECtrlButton))
+    
+        {
+        return NULL;   
+        }
+        
+    return static_cast<CAknFepCtrlCommonButton*>(ctrl);
+    }
+
+void CGenericItutWindow::DisplayInputmodeSwitchL()
+    {
+    TRect rect = Control(ECtrlIdSwitch)->Rect();   
+              
+    TRAP_IGNORE( iInputModeSwitch->PopUpSwitchListL(rect) );        
+    }
+
+CFepUiBaseCtrl* CGenericItutWindow::Control(const TInt aCtrlId)
+    {
+    CFepUiBaseCtrl* ctrl = NULL;
+    RPointerArray<CFepUiBaseCtrl> todo;
+    TInt current = 0;
+    TBool found = EFalse;
+    
+    todo.Append(iLayoutOwner->RootControl());
+    CControlGroup* temp;
+    
+    while (current < todo.Count() && !found)
+        {
+        ctrl = todo[current];
+        
+        if(ctrl->ControlId() == aCtrlId) //Find control
+            {
+            found = ETrue;     
+            }
+        else
+            {
+            if(ctrl->IsKindOfControl(ECtrlControlGroup))
+                {
+                temp = static_cast<CControlGroup*>(ctrl);
+                for (int i = 0; i < temp->NumOfControls(); i++)
+                    {
+                    todo.Append(temp->At(i));
+                    }
+                }
+                
+            current++;
+            }
+        }
+        
+    todo.Close();
+    
+    return found ? ctrl : NULL;
+    }      
+
+TBool CGenericItutWindow::IsChineseMode()
+    {
+    TInt immode = iDataMgr->InputMode();
+    TBool chineseMode = EFalse;
+    
+    if (immode == EPinyin || immode == EStroke || immode == EZhuyin)
+        {
+        chineseMode = ETrue;
+        }
+    
+    return chineseMode;    
+    }
+
+void CGenericItutWindow::ConstructKeyImageFromResourceL( TInt aKeyImageResID )
+	{
+    TResourceReader reader;    
+    CCoeEnv::Static()->CreateResourceReaderLC( reader, aKeyImageResID );      
+    
+    TPtrC bmpFileName = reader.ReadTPtrC();
+    TInt32 imgMajorSkinId = reader.ReadInt32();
+    TAknsItemID id;
+    
+    RArray<TRect>& cellRects = 
+                     TItutDataConverter::AnyToRectArray(iDataMgr->RequestData(EKeypadCellRects));
+    TSize keySize = cellRects[0].Size();
+    for (TInt index = 0; index <= EKeyBmpLastType ; index += 2)
+        { 
+        // Get the image ids and mask ids from resource
+        TInt bmpId = reader.ReadInt16(); 
+        TInt bmpMskId = reader.ReadInt16();
+        
+        // read skin item id
+        const TInt skinitemid = reader.ReadInt16();
+        id.Set(TInt(imgMajorSkinId), skinitemid);
+        
+        if (bmpId != KInvalidBmp)
+            {
+        	CFbsBitmap* bmp = NULL;
+        	CFbsBitmap* maskbmp = NULL;
+
+        	if (bmpMskId != KInvalidBmp)
+        		{
+        		AknsUtils::CreateIconL(AknsUtils::SkinInstance(),
+        		                       id,
+        		                       bmp,
+        		                       maskbmp,
+        		                       bmpFileName,
+        		                       bmpId,
+        		                       bmpMskId);
+        		
+       		    // set maskbmp and size
+       		    AknIconUtils::SetSize( maskbmp, keySize, EAspectRatioNotPreserved );
+                iStandardItutKp->SetNonIrregularKeyBitmapL(
+                TVirtualKeyBmpType(EKeyBmpNormal + index + 1), maskbmp );
+                }
+            else
+                {
+        	    AknsUtils::CreateIconL(AknsUtils::SkinInstance(),
+        	                           id,
+        	                           bmp,
+        	                           bmpFileName,
+        	                           bmpId);
+                }
+            // set bmp and size
+            AknIconUtils::SetSize( bmp, keySize, EAspectRatioNotPreserved );
+           	iStandardItutKp->SetNonIrregularKeyBitmapL( 
+                                                 TVirtualKeyBmpType(EKeyBmpNormal + index), bmp );
+            }       
+        }
+    // Pop and destroy reader
+    CleanupStack::PopAndDestroy( 1 );		
+	}
+	
+void CGenericItutWindow::HandleButtonResOnLangDirChange( TInt aControlId )
+	{
+    TRAP_IGNORE(HandleButtonResOnLangDirChangeL(aControlId));
+    }
+void CGenericItutWindow::HandleButtonResOnLangDirChangeL( TInt aControlId )
+	{
+	CAknFepCtrlCommonButton* ctrl = CommonButtonControl(aControlId);
+	if( ctrl && iBmpRotator)
+		{
+		TSyncRotationAngle rotChoice = CBitmapRotator::EMirrorVerticalAxis; 
+		User::LeaveIfError( iBmpRotator->Rotate( *ctrl->ForgroundBmp() ,
+								  				 rotChoice ) );
+		User::LeaveIfError( iBmpRotator->Rotate( *ctrl->ForgroundBmpMask() ,
+								  				 rotChoice ) );   								  
+		}		
+	}
+
+void CGenericItutWindow::SetHardKeyOneSymbol(TUint8* aData)
+    {
+    TRAP_IGNORE(SetHardKeyOneSymbolL(aData));
+    }
+void CGenericItutWindow::SetHardKeyOneSymbolL(TUint8* aData)
+    {
+    //Read stream
+    RDesReadStream readStream;
+
+    TPtr8 countPtr( aData, 3*sizeof(TInt), 3*sizeof(TInt) );            
+    readStream.Open(countPtr);
+    CleanupClosePushL(readStream);
+
+    iSymbolData.iSymbol1 = readStream.ReadInt32L();
+    iSymbolData.iSymbol2 = readStream.ReadInt32L();
+    iSymbolData.iSymbol3 = readStream.ReadInt32L();
+    
+    CleanupStack::PopAndDestroy(&readStream);  
+    }
+
+void CGenericItutWindow::SetUnicodesForHardKey1(CVirtualKey* aKey, const TDesC& aMapData)
+    {
+    TRAP_IGNORE(SetUnicodesForHardKey1L(aKey, aMapData));
+    }
+void CGenericItutWindow::SetUnicodesForHardKey1L(CVirtualKey* aKey, const TDesC& aMapData)
+    {
+    RPointerArray<HBufC> unicodesArr1;
+    RArray<TInt> unicodesInt;
+    
+    unicodesInt.Append(iSymbolData.iSymbol1);
+    unicodesInt.Append(iSymbolData.iSymbol2);
+    unicodesInt.Append(iSymbolData.iSymbol3);
+    
+    TInt curMode = TItutDataConverter::AnyToInt(
+            iLayoutOwner->DataMgr()->RequestData(EInputMode));
+    
+    TInt curLang = TItutDataConverter::AnyToInt(
+            iLayoutOwner->DataMgr()->RequestData(ELanguage));    
+    
+    TInt latinOnly = TItutDataConverter::AnyToInt(
+            iLayoutOwner->DataMgr()->RequestData(ELatinOnly));        
+    
+    HBufC* symbols = HBufC::NewL( 20 );
+    for (TInt i = 0; i <= 2; i++)
+        {
+        symbols->Des().Append( unicodesInt[i] );
+        if (EHindi == curMode ||
+                (ELatin == curMode && curLang == ELangThai && !latinOnly))
+            {
+            continue;
+            }
+        else
+            {
+            symbols->Des().Append( KSpaceUnicode );
+            }
+        }
+    
+    HBufC* number = HBufC::NewL( 1 );
+    number->Des().Append( aMapData );
+    unicodesArr1.AppendL(number);
+    unicodesArr1.AppendL(symbols);
+    
+    aKey->SetUnicodesL(unicodesArr1);
+
+    unicodesArr1.Close();
+    unicodesInt.Close();
+
+    }
+// End Of File