diff -r 000000000000 -r eb1f2e154e89 textinput/peninputgenericitut/src/peninputgenericitutdatamgr.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textinput/peninputgenericitut/src/peninputgenericitutdatamgr.cpp Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,1464 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "peninputgenericitutdatamgr.h" +#include "peninputgenericitutlayoutcontext.h" +#include "peninputgenericitutconverter.h" +#include "peninputgenericitutcustomization.h" +#include "peninputgenericitutwindowmanager.h" + +#define LAF_MODIFY 1 +_LIT(KItutCommonResFile, "z:\\resource\\plugins\\peninputgeneralitutnew.rsc"); +_LIT(KConfigResourceFile, + "z:\\resource\\plugins\\peninputitutconfig_"); +_LIT(KResourceFileExtName, ".rsc"); + +_LIT(KAvkonResourceFile, "z:\\resource\\avkon.rsc"); + +const TInt KOnePageCandidateCount = 40; +const TInt KMaxPredictCandCnt = 250; +const TInt KInvalidResId = -1; +const TInt KInvalidImMode = -1; +const TInt KInvalidIndex = -1; +const TUint16 KPlusChar = '+'; + +// For virtual ITUT candidate list in landscape mode. No reason +const TInt KCandsAdjustment = 7; + + +CGenericItutDataMgr* CGenericItutDataMgr::NewL(MItutLayoutContext* aLayoutContext, + CPtiEngine* aPtiEngine) + { + CGenericItutDataMgr* self = new (ELeave) CGenericItutDataMgr(aLayoutContext, aPtiEngine); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self);//self + return self; + } + +void CGenericItutDataMgr::ClearChnCandidates(TInt aCmd) + { + switch (aCmd) + { + case EItutCandidates: + { + iCandidates.ResetAndDestroy(); + iCandidates.Close(); + } + break; + case EItutPuncCandidates: + { + iPuncCandidates.ResetAndDestroy(); + iPuncCandidates.Close(); + } + break; + default: + break; + } + } + +CGenericItutDataMgr::~CGenericItutDataMgr() + { + iSubscriberList.Close(); + + iMenuItemList.ResetAndDestroy(); + + CCoeEnv::Static()->DeleteResourceFile(iAvkonResId); + + CCoeEnv::Static()->DeleteResourceFile(iCommonResId); + + if (iConfigResId) + { + CCoeEnv::Static()->DeleteResourceFile(iConfigResId); + } + + ClearChnCandidates(EItutCandidates); + ClearChnCandidates(EItutPuncCandidates); + + iKeypadCellRects.Close(); + iKeypadCellRectsCn.Close(); + iKeypadCellRectsQuery.Close(); + delete iNumericKeymapData; + } + +void CGenericItutDataMgr::ConstructL() + { + + // initialize layout info of controls and layout + ReadLafInfo(); + + TFileName resourceCommonName(KItutCommonResFile); + CCoeEnv* coeEnv = CCoeEnv::Static(); + BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceCommonName); + iCommonResId = coeEnv->AddResourceFileL(resourceCommonName); + + TFileName resourceAvkonName(KAvkonResourceFile); + BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceAvkonName); + iAvkonResId = coeEnv->AddResourceFileL(resourceAvkonName); + + TResourceReader reader; + CCoeEnv::Static()->CreateResourceReaderLC(reader, R_AVKON_TOUCH_INDICATOR_EDIT_MODE_MENU); + + const TInt count=reader.ReadInt16(); + for ( TInt ii=0; iiiCommand = reader.ReadInt32(); + reader.ReadInt32(); + reader.ReadInt32(); + item->iText = reader.ReadTPtrC(); + reader.ReadTPtrC(); + reader.ReadTPtrC(); + reader.ReadInt16(); + reader.ReadInt16(); + CleanupStack::Pop(); // pop first, since additem pushes again + iMenuItemList.Append( item ); + reader.ReadInt32(); // extension link + } + CleanupStack::PopAndDestroy(); //reader + } + +CGenericItutDataMgr::TMenuItem* CGenericItutDataMgr::GetMenuItem(TInt aCommand) + { + for (TInt i=0;iiCommand == aCommand ) + return iMenuItemList[i]; + } + return NULL; + } + +void CGenericItutDataMgr::AddSubscriber(MItutPropertySubscriber* aSubscriber) + { + if (aSubscriber) + { + const TInt index = iSubscriberList.Find(aSubscriber); + + if (index == KErrNotFound) + { + iSubscriberList.Append(aSubscriber); + } + } + } + +void CGenericItutDataMgr::ReadLafInfo() + { + // Screen + TRect rect, rectcn; + AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen, rect); + iScreenSize = rect.Size(); + + iLandScape = iScreenSize.iWidth < iScreenSize.iHeight ? EFalse : ETrue; + + AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EApplicationWindow, rect); + + // finger Layout + TAknWindowLineLayout vitulayout; + TAknLayoutRect viturect; + + if (iLandScape) + { + vitulayout = AknLayoutScalable_Apps::popup_vitu2_window(1).LayoutLine(); + } + else + { + vitulayout = AknLayoutScalable_Apps::popup_vitu2_window(0).LayoutLine(); + } + + viturect.LayoutRect(rect, vitulayout); + + iLayoutRect = viturect.Rect(); + iLayoutOffset = iLayoutRect.iTl; + + // ICF & Keypad + TAknWindowLineLayout icflayoutlatin, icflayoutcn,itukeypad, itucell,icflayoutbgcn; + TAknTextLineLayout icflefttext; + TAknTextLineLayout icflefttext1, icflefttext2, icflefttext3; + TAknLayoutRect icfrectlatin, icfrectcn, itukeypadrect, itucellrect,icfrectcnbg; + + if (iLandScape) + { + icflayoutlatin = AknLayoutScalable_Apps::field_vitu2_entry_pane(1).LayoutLine(); + icflayoutcn = AknLayoutScalable_Apps::field_vitu2_entry_pane(3).LayoutLine(); + } + else + { + icflayoutlatin = AknLayoutScalable_Apps::field_vitu2_entry_pane(0).LayoutLine(); + icflayoutcn = AknLayoutScalable_Apps::field_vitu2_entry_pane(2).LayoutLine(); + } + + icfrectlatin.LayoutRect(viturect.Rect(), icflayoutlatin); + icflayoutbgcn = AknLayoutScalable_Apps::bg_popup_call_pane_cp08(0).LayoutLine(); + icfrectcn.LayoutRect(viturect.Rect(), icflayoutcn); + icfrectcnbg.LayoutRect(icfrectcn.Rect(),icflayoutbgcn); + + TAknLayoutScalableParameterLimits entryPaneVariety = + AknLayoutScalable_Apps::field_vitu2_entry_pane_t1_ParamLimits(2); + // Calc the max row number + TInt maxRow = entryPaneVariety.LastRow(); + + // latin ICF layout + icflefttext = AknLayoutScalable_Apps::field_vitu2_entry_pane_t1(2, 0, 0).LayoutLine(); + icflefttext1 = AknLayoutScalable_Apps::field_vitu2_entry_pane_t1(2, 0, 1).LayoutLine(); + icflefttext2 = AknLayoutScalable_Apps::field_vitu2_entry_pane_t1(2, 0, 2).LayoutLine(); + icflefttext3 = AknLayoutScalable_Apps::field_vitu2_entry_pane_t1(2, 0, maxRow).LayoutLine(); + + iIcfTextAlignment = icflefttext.iJ; + iIcfTextLeftMargin = icflefttext.il; + iIcfTextRightMargin = icflefttext.ir; + + TAknLayoutText ctxt, ctxt1, ctxt2, ctxt3; + ctxt.LayoutText( icfrectlatin.Rect(), icflefttext ); + ctxt1.LayoutText( icfrectlatin.Rect(), icflefttext1 ); + ctxt2.LayoutText( icfrectlatin.Rect(), icflefttext2 ); + ctxt3.LayoutText( icfrectlatin.Rect(), icflefttext3 ); + + + iIcfTextTopMargin = ctxt.TextRect().iTl.iY - icfrectlatin.Rect().iTl.iY; + iIcfTextLineSpaceMargin = ctxt1.TextRect().iTl.iY - ctxt.TextRect().iBr.iY; + iIcfTextBottomMargin = icfrectlatin.Rect().iBr.iY - ctxt3.TextRect().iBr.iY + - iIcfTextLineSpaceMargin; + iIcfTextHeight = ctxt.TextRect().Height(); + + iIcfFont = const_cast(AknLayoutUtils::FontFromId(icflefttext.iFont, NULL)); + + // chinese ICF layout + entryPaneVariety = AknLayoutScalable_Apps::field_vitu2_entry_pane_t1_ParamLimits(0); + // Calc the max row number + maxRow = entryPaneVariety.LastRow(); + icflefttext = AknLayoutScalable_Apps::field_vitu2_entry_pane_t1(0, 0, 0).LayoutLine(); + icflefttext1 = AknLayoutScalable_Apps::field_vitu2_entry_pane_t1(0, 0, 1).LayoutLine(); + icflefttext3 = AknLayoutScalable_Apps::field_vitu2_entry_pane_t1(0, 0, maxRow).LayoutLine(); + iIcfTextLeftMarginCn = icflefttext.il; + iIcfTextRightMarginCn = icflefttext.ir; + + ctxt.LayoutText( icfrectcn.Rect(), icflefttext ); + ctxt1.LayoutText( icfrectcn.Rect(), icflefttext1 ); + ctxt3.LayoutText( icfrectcn.Rect(), icflefttext3 ); + + TInt topOffset = icfrectcnbg.Rect().iTl.iY - icfrectcn.Rect().iTl.iY; + iIcfTextTopMarginCn = ctxt.TextRect().iTl.iY - icfrectcn.Rect().iTl.iY - topOffset; + iIcfTextLineSpaceMarginCn = ctxt1.TextRect().iTl.iY - ctxt.TextRect().iBr.iY; + iIcfTextBottomMarginCn = icfrectcn.Rect().iBr.iY - ctxt3.TextRect().iBr.iY + - iIcfTextLineSpaceMarginCn; + iIcfTextHeightCn = ctxt.TextRect().Height(); + + iIcfFontCn = const_cast(AknLayoutUtils::FontFromId(icflefttext.iFont, NULL)); + + rect = icfrectlatin.Rect(); + rect.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + iIcfWesRect = rect; + + rect = icfrectcnbg.Rect(); + rect.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + iIcfChnRect = rect; + //iIcfChnRect.iTl.iY += 10; +#ifdef LAF_MODIFY + //if(IsChinese()) + { + iIcfChnRect.Move(0,-iIcfChnRect.iTl.iY + 14); + } +#endif + + // Keypad + TInt keypadvariety = iLandScape ? 1 : 0; + itukeypad = AknLayoutScalable_Apps::grid_vitu2_itu_pane(keypadvariety).LayoutLine(); + itukeypadrect.LayoutRect(viturect.Rect(), itukeypad); + iKeypadRect = itukeypadrect.Rect(); + iKeypadRect.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + + TInt cnParam = iLandScape ? 3 : 2; + itukeypad = AknLayoutScalable_Apps::grid_vitu2_itu_pane(cnParam).LayoutLine(); + itukeypadrect.LayoutRect(viturect.Rect(), itukeypad); + iKeypadRectCn = itukeypadrect.Rect(); + iKeypadRectCn.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + + TInt queryParam = iLandScape ? 5 : 4; + itukeypad = AknLayoutScalable_Apps::grid_vitu2_itu_pane(queryParam).LayoutLine(); + itukeypadrect.LayoutRect(viturect.Rect(), itukeypad); + iKeypadRectQuery = itukeypadrect.Rect(); + iKeypadRectQuery.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + + iKeypadCellRects.Reset(); + iKeypadCellRectsCn.Reset(); + iKeypadCellRectsQuery.Reset(); + + // keypad is 4 rows, 3 cols + for (TInt i = 0; i < 4; i++) + { + for (TInt j = 0; j < 3; j++) + { + itucell = AknLayoutScalable_Apps::cell_vitu2_itu_pane(keypadvariety, + j, + i).LayoutLine(); + itucellrect.LayoutRect(iKeypadRect, itucell); + TRect cellrect = itucellrect.Rect(); + cellrect.Move(-iKeypadRect.iTl.iX, -iKeypadRect.iTl.iY); + iKeypadCellRects.Append(cellrect); + + // read shift icon rect + if( i == 3 && j == 2 ) + { + TAknWindowLineLayout shiftIcon = AknLayoutScalable_Apps:: + cell_vitu2_itu_pane_g1( keypadvariety ).LayoutLine(); + TAknLayoutRect shiftIconRect; + shiftIconRect.LayoutRect( cellrect, shiftIcon ); + iShiftIconRect = shiftIconRect.Rect(); + } + itucellrect.LayoutRect(iKeypadRectCn, itucell); + cellrect = itucellrect.Rect(); + cellrect.Move(-iKeypadRectCn.iTl.iX, -iKeypadRectCn.iTl.iY); + iKeypadCellRectsCn.Append(cellrect); + + itucellrect.LayoutRect(iKeypadRectQuery, itucell); + cellrect = itucellrect.Rect(); + cellrect.Move(-iKeypadRectQuery.iTl.iX, -iKeypadRectQuery.iTl.iY); + iKeypadCellRectsQuery.Append(cellrect); + } + } + + iVkNumText = iLandScape ? AknLayoutScalable_Apps::cell_vitu2_itu_pane_t1(4).LayoutLine() : + AknLayoutScalable_Apps::cell_vitu2_itu_pane_t1(0).LayoutLine(); + // Key text row 1 + iVkAlphaText1 = iLandScape ? AknLayoutScalable_Apps::cell_vitu2_itu_pane_t2(2).LayoutLine() : + AknLayoutScalable_Apps::cell_vitu2_itu_pane_t2(0).LayoutLine(); + iVkAlphaText3 = iLandScape ? AknLayoutScalable_Apps::cell_vitu2_itu_pane_t2(3).LayoutLine() : + AknLayoutScalable_Apps::cell_vitu2_itu_pane_t2(1).LayoutLine(); + iVkAlphaText3.iJ = 3; + + iVkAlphaText1ForThai = iLandScape ? AknLayoutScalable_Apps::cell_vitu2_itu_pane_t3(6).LayoutLine() : + AknLayoutScalable_Apps::cell_vitu2_itu_pane_t2(7).LayoutLine(); + iVkAlphaText3ForThai = iLandScape ? AknLayoutScalable_Apps::cell_vitu2_itu_pane_t2(10).LayoutLine() : + AknLayoutScalable_Apps::cell_vitu2_itu_pane_t2(8).LayoutLine(); + iVkAlphaText3ForThai.iJ = 3; + + // Key text row 2 + iVkAlphaText2 = iLandScape ? AknLayoutScalable_Apps::cell_vitu2_itu_pane_t3(1).LayoutLine() : + AknLayoutScalable_Apps::cell_vitu2_itu_pane_t3(0).LayoutLine(); + iVkAlphaText2.iJ = 3; + + iVkAlphaText2ForThai = iLandScape ? AknLayoutScalable_Apps::cell_vitu2_itu_pane_t3(6).LayoutLine() : + AknLayoutScalable_Apps::cell_vitu2_itu_pane_t3(5).LayoutLine(); + iVkAlphaText2ForThai.iJ = 3; + + // backspace and switch button + TAknWindowLineLayout funcbtn, funcclr, funcswitch, funcinner, funcinnercn, funcleft, funcright; + TAknWindowLineLayout funcswitchcn, funcleftcn, funcrightcn, funcclrcn; + TAknWindowLineLayout funcind, funcindcn, funcindinner, funcbtncn, funccell; + TAknLayoutRect funcbtnrect, funcclrrect, funcswitchrect, funcbtncnrect; + TAknLayoutRect funcindrect, funcindrectinner, funcindcnrect, funccellrect; + TAknLayoutRect funcinnerrect, funcinnerrectcn, funcleftrect, funcrightrect; + TAknLayoutRect funcclrcnrect, funcleftcnrect, funcrightcnrect, funcswitchcnrect; + + + if (iLandScape) + { + funcbtn = AknLayoutScalable_Apps::grid_vitu2_function_pane(1).LayoutLine(); + funcbtncn = AknLayoutScalable_Apps::grid_vitu2_function_pane(3).LayoutLine(); + } + else + { + funcbtn = AknLayoutScalable_Apps::grid_vitu2_function_pane(0).LayoutLine(); + funcbtncn = AknLayoutScalable_Apps::grid_vitu2_function_pane(2).LayoutLine(); + } + + funcclr = AknLayoutScalable_Apps::cell_vitu2_function_pane(0, 3, 0).LayoutLine(); + funcswitch = AknLayoutScalable_Apps::cell_vitu2_function_pane(0, 0, 0).LayoutLine(); + + funcinner = AknLayoutScalable_Apps::cell_vitu2_function_pane_g1(0).LayoutLine(); + + funcbtnrect.LayoutRect(viturect.Rect(), funcbtn); + funcbtncnrect.LayoutRect(viturect.Rect(), funcbtncn); + rect = funcbtnrect.Rect(); + rect.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + funcclrrect.LayoutRect(rect, funcclr); + funcswitchrect.LayoutRect(rect, funcswitch); + + // left and right button + funcleft = AknLayoutScalable_Apps::cell_vitu2_function_pane(0, 1, 0).LayoutLine(); + funcright = AknLayoutScalable_Apps::cell_vitu2_function_pane(0, 2, 0).LayoutLine(); + funcleftrect.LayoutRect(rect, funcleft); + funcrightrect.LayoutRect(rect, funcright); + iArrowLeftRect = funcleftrect.Rect(); + iArrowRightRect = funcrightrect.Rect(); + funcinnerrect.LayoutRect(iArrowLeftRect, funcinner); + iArrowLeftInnerRect = funcinnerrect.Rect(); + funcinnerrect.LayoutRect(iArrowRightRect, funcinner); + iArrowRightInnerRect = funcinnerrect.Rect(); + + // funcinnerrect + iBackspaceRect = funcclrrect.Rect(); + funcinnerrect.LayoutRect(iBackspaceRect, funcinner); + iBackspaceInnerRect = funcinnerrect.Rect(); + iSwitchRect = funcswitchrect.Rect(); + funcinnerrect.LayoutRect( iSwitchRect, funcinner ); + iSwitchInnerRect = funcinnerrect.Rect(); + + // Cursor button in Chinese input mode + rect = funcbtncnrect.Rect(); + rect.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + funcinnercn = AknLayoutScalable_Apps::cell_vitu2_function_pane_g1(1).LayoutLine(); + // 1. left arrow + funccell = AknLayoutScalable_Apps::cell_vitu2_function_pane( 1, 1, 0 ).LayoutLine(); + funccellrect.LayoutRect( rect, funccell ); + iArrowLeftCnRect = funccellrect.Rect(); + funcinnerrectcn.LayoutRect( funccellrect.Rect(), funcinnercn ); + iArrowLeftInnerCnRect = funcinnerrectcn.Rect(); + + // 2, up arrow + funccell = AknLayoutScalable_Apps::cell_vitu2_function_pane( 1, 0, 0 ).LayoutLine(); + funccellrect.LayoutRect( rect, funccell ); + iArrowUpRect = funccellrect.Rect(); + funcinnerrectcn.LayoutRect( funccellrect.Rect(), funcinnercn ); + iArrowUpInnerRect = funcinnerrectcn.Rect(); + + // 3. right arrow + funccell = AknLayoutScalable_Apps::cell_vitu2_function_pane( 1, 2, 0 ).LayoutLine(); + funccellrect.LayoutRect( rect, funccell ); + iArrowRightCnRect = funccellrect.Rect(); + funcinnerrectcn.LayoutRect( funccellrect.Rect(), funcinnercn ); + iArrowRightInnerCnRect = funcinnerrectcn.Rect(); + + // 4. down arrow + funccell = AknLayoutScalable_Apps::cell_vitu2_function_pane( 1, 0, 1 ).LayoutLine(); + funccellrect.LayoutRect( rect, funccell ); + iArrowDownRect = funccellrect.Rect(); + funcinnerrectcn.LayoutRect( funccellrect.Rect(), funcinnercn ); + iArrowDownInnerRect = funcinnerrectcn.Rect(); +#ifdef LAF_MODIFY + //indicator bar rect + funccell = AknLayoutScalable_Apps::cell_vitu2_function_pane( 1, 1, 1 ).LayoutLine(); + funccellrect.LayoutRect( rect, funccell ); + iImIndiOuterRectCn = funccellrect.Rect(); + funccell = AknLayoutScalable_Apps::cell_vitu2_function_pane( 1, 2, 1 ).LayoutLine(); + funccellrect.LayoutRect(rect,funccell); + iImIndiOuterRectCn.iBr = funccellrect.Rect().iBr; + + iImIndicatorChnRect = iImIndiOuterRectCn; + iImIndicatorChnRect.Shrink( 24, 12 ); + +#endif + + // candidate list + TAknWindowLineLayout candlist, candlistpane, charpane, listctrl; + TAknLayoutRect candlistrect, candlistpanerect, charpanerect1, charpanerect2; + TAknLayoutRect charpanerect3, listctrlrect; + + if (iLandScape) + { + candlist = AknLayoutScalable_Apps::popup_vitu2_dropdown_list_window(1). + LayoutLine(); + } + else + { + candlist = AknLayoutScalable_Apps::popup_vitu2_dropdown_list_window(0). + LayoutLine(); + } + candlistrect.LayoutRect( viturect.Rect(), candlist ); + rect = candlistrect.Rect(); + rect.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + candlistpane = AknLayoutScalable_Apps::grid_vitu2_dropdown_list_pane(). + LayoutLine(); + candlistpanerect.LayoutRect( rect, candlistpane ); + + charpane = AknLayoutScalable_Apps::cell_vitu2_dropdown_list_char_pane( 0 , 0 , 0 ). + LayoutLine(); + charpanerect1.LayoutRect( candlistpanerect.Rect(), charpane ); + charpane = AknLayoutScalable_Apps::cell_vitu2_dropdown_list_char_pane( 0 , 1 , 0 ). + LayoutLine(); + charpanerect2.LayoutRect( candlistpanerect.Rect(), charpane ); + charpane = AknLayoutScalable_Apps::cell_vitu2_dropdown_list_char_pane( 0 , 0 , 1 ). + LayoutLine(); + charpanerect3.LayoutRect( candlistpanerect.Rect(), charpane ); + listctrl = AknLayoutScalable_Apps::cell_vitu2_dropdown_list_ctrl_pane( 0, 0, 0 ). + LayoutLine(); + listctrlrect.LayoutRect( candlistpanerect.Rect(), listctrl ); + + iCandsHorizontalMargin = charpanerect2.Rect().iTl.iX - charpanerect1.Rect().iBr.iX; + iCandsVerticalMargin = charpanerect3.Rect().iTl.iY - charpanerect1.Rect().iBr.iY; + iCandsNaviWidth = listctrlrect.Rect().Width(); + + iCandsUnitWidth = charpanerect1.Rect().Width(); + iCandsUnitHeight = charpanerect1.Rect().Height() ; + + iCandsSpinBtnHeight = listctrlrect.Rect().Height(); + iCandsSpellLTPos = charpanerect1.Rect().iTl; + iCandsLTPos = charpanerect3.Rect().iTl; + iCandsPuncLTPos = iCandsSpellLTPos; + + TAknTextLineLayout candstxtlayout = + AknLayoutScalable_Apps::cell_vitu2_dropdown_list_char_pane_t1().LayoutLine(); + TAknLayoutText candstxt; + candstxt.LayoutText( charpanerect1.Rect(), candstxtlayout ); + iCandsFont = const_cast( AknLayoutUtils::FontFromId( candstxtlayout.iFont, NULL ) ); + iCandsTextMargin = candstxt.TextRect().iTl.iX - charpanerect1.Rect().iTl.iX; + iCandsTextColor = candstxt.Color(); + + //extra adjustment + // No reason to add the iCandsTextMargin and KCandsAdjustment + iCandsUnitWidth += KCandsAdjustment; + iCandsNaviWidth += iCandsTextMargin; + + TPtrC ptr(reinterpret_cast(&iLandScape), sizeof(iLandScape)/sizeof(TText)); + NotifySubscriber(MItutPropertySubscriber::EItutPropertyLandscape, ptr); + + TSize spellSize( iCandsUnitWidth * 6 + iCandsHorizontalMargin * 7, iCandsUnitHeight ); + iSpellRect = TRect( iCandsSpellLTPos, spellSize ); + iSpellFont = const_cast( AknLayoutUtils::FontFromId( candstxtlayout.iFont, NULL ) ); + iSpellTextColor = candstxt.Color(); + + + + // Navi buttons + TAknWindowLineLayout toppane, toppanecn, btnup, btndown, btnopt, btncls, btnback; + TAknLayoutRect toppanerect, toppanerectcn, btnuprect, btndownrect, + btnoptrect, btnoptrectcn, btnclsrect, btnclsrectcn, btnbackrectcn; + TAknWindowLineLayout upinner, downinner, optinner, clsinner; + TAknLayoutRect upinrect, downinrect, optinrect, optinrectcn, clsinrect, clsinrectcn; + if (iLandScape) + { + toppane = AknLayoutScalable_Apps::grid_vitu2_function_top_pane(1).LayoutLine(); + toppanecn = AknLayoutScalable_Apps::grid_vitu2_function_top_pane(3).LayoutLine(); + } + else + { + toppane = AknLayoutScalable_Apps::grid_vitu2_function_top_pane(0).LayoutLine(); + toppanecn = AknLayoutScalable_Apps::grid_vitu2_function_top_pane(2).LayoutLine(); + } + toppanerect.LayoutRect( viturect.Rect(), toppane ); + toppanerectcn.LayoutRect(viturect.Rect(), toppanecn); + rect = toppanerect.Rect(); + rectcn = toppanerectcn.Rect(); + rect.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + rectcn.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + + // Chinese input mode + funcswitchcn = AknLayoutScalable_Apps::cell_vitu2_function_top_pane( 0, 2, 0 ).LayoutLine(); + funcswitchcnrect.LayoutRect( rectcn, funcswitchcn ); + iSwitchCnRect = funcswitchcnrect.Rect(); + funcinnercn = AknLayoutScalable_Apps::cell_vitu2_function_top_pane_g1(0).LayoutLine(); + funcinnerrectcn.LayoutRect( funcswitchcnrect.Rect(), funcinnercn ); + iSwitchInnerCnRect = funcinnerrectcn.Rect(); + + btnopt= AknLayoutScalable_Apps::cell_vitu2_function_top_pane( 0, 1, 0 ).LayoutLine(); + btnoptrect.LayoutRect( rect, btnopt ); + btnoptrectcn.LayoutRect(rectcn, btnopt); + optinner = AknLayoutScalable_Apps::cell_vitu2_function_top_pane_g1(1).LayoutLine(); + optinrect.LayoutRect( btnoptrect.Rect(), optinner ); + optinner = AknLayoutScalable_Apps::cell_vitu2_function_top_pane_g1(0).LayoutLine(); + optinrectcn.LayoutRect(btnoptrectcn.Rect(), optinner); + iOptionInnerRect = optinrect.Rect(); +#ifdef LAF_MODIFY + iOptionInnerRectCn = optinrectcn.Rect(); +#endif + btncls= AknLayoutScalable_Apps::cell_vitu2_function_top_pane( 0, 0, 0 ).LayoutLine(); + btnclsrect.LayoutRect( rect, btncls ); + btnclsrectcn.LayoutRect(rectcn, btncls); + clsinner = AknLayoutScalable_Apps::cell_vitu2_function_top_pane_g1(1).LayoutLine(); + clsinrect.LayoutRect( btnclsrect.Rect(), clsinner ); + clsinner = AknLayoutScalable_Apps::cell_vitu2_function_top_pane_g1(0).LayoutLine(); + clsinrectcn.LayoutRect(btnclsrectcn.Rect(), clsinner); + iCloseInnerRect = clsinrect.Rect(); +#ifdef LAF_MODIFY + iCloseInnerRectCn = clsinrectcn.Rect(); +#endif + btnback= AknLayoutScalable_Apps::cell_vitu2_function_top_pane( 0, 3, 0 ).LayoutLine(); + btnbackrectcn.LayoutRect(rectcn, btnback); + iBackspaceCnRect = btnbackrectcn.Rect(); + funcinner = AknLayoutScalable_Apps::cell_vitu2_function_top_pane_g1(0).LayoutLine(); + funcinnerrect.LayoutRect( btnbackrectcn.Rect(), funcinner ); + iBackspaceInnerCnRect = funcinnerrect.Rect(); + + + iOptionsRect = btnoptrect.Rect(); + iOptionsRectCn = btnoptrectcn.Rect(); + iCloseRect = btnclsrect.Rect(); + iCloseRectCn = btnclsrectcn.Rect(); + + // input mode indicator, should use laf data in the future +#ifndef LAF_MODIFY + funcindcn = AknLayoutScalable_Apps::field_vitu2_entry_pane_g1().LayoutLine(); + funcindcnrect.LayoutRect( icfrectcn.Rect(), funcindcn ); +#endif + funcind = AknLayoutScalable_Apps::cell_vitu2_function_top_wide_pane(1).LayoutLine(); + funcindrect.LayoutRect(rect, funcind); + + funcindinner = AknLayoutScalable_Apps::cell_vitu2_function_top_wide_pane_g1(2).LayoutLine(); + funcindrectinner.LayoutRect(funcindrect.Rect(), funcindinner); + //iBackspaceCnRect = funcindcnrect.Rect(); + + iImIndicatorWesRect = funcindrectinner.Rect(); + iImIndiOuterRect = funcindrect.Rect(); +#ifndef LAF_MODIFY + funcindinner = AknLayoutScalable_Apps::cell_vitu2_function_top_wide_pane_g1(1).LayoutLine(); + funcindrectinner.LayoutRect(funcindrect.Rect(), funcindinner); + iImIndicatorChnRect = funcindrectinner.Rect(); +#endif + // match selection list + TAknWindowLineLayout matchlist, listpane, itempane1, itempane2, scrollpane; + TAknLayoutRect matchlistrect, listpanerect, itempanerect1, itempanerect2, scrollpanerect; + TAknWindowLineLayout arrowup, arrowdown, arrowupinner, arrowdowninner; + TAknLayoutRect arrowuprect, arrowdownrect, arrowupinnerRect, arrowdowninnerRect; + + if( iLandScape ) + { + matchlist = AknLayoutScalable_Apps::popup_vitu2_match_list_window(3).LayoutLine(); + listpane = AknLayoutScalable_Apps::list_vitu2_match_list_pane(1).LayoutLine(); + scrollpane = AknLayoutScalable_Apps::vitu2_page_scroll_pane(1).LayoutLine(); + } + else + { + matchlist = AknLayoutScalable_Apps::popup_vitu2_match_list_window(2).LayoutLine(); + listpane = AknLayoutScalable_Apps::list_vitu2_match_list_pane(0).LayoutLine(); + scrollpane = AknLayoutScalable_Apps::vitu2_page_scroll_pane(0).LayoutLine(); + } + + matchlistrect.LayoutRect( viturect.Rect(), matchlist ); + rect = matchlistrect.Rect(); + rect.Move(-iLayoutOffset.iX, -iLayoutOffset.iY); + + listpanerect.LayoutRect( rect, listpane ); + scrollpanerect.LayoutRect( rect, scrollpane ); + itempane1 = AknLayoutScalable_Apps::list_vitu2_match_list_item_pane( 0, 0, 0 ).LayoutLine(); + itempanerect1.LayoutRect( listpanerect.Rect(), itempane1 ); + itempane2 = AknLayoutScalable_Apps::list_vitu2_match_list_item_pane( 0, 0, 1 ).LayoutLine(); + itempanerect2.LayoutRect( listpanerect.Rect(), itempane2 ); + + arrowupinner= AknLayoutScalable_Apps::vitu2_page_scroll_pane_g1().LayoutLine(); + arrowdowninner = AknLayoutScalable_Apps::vitu2_page_scroll_pane_g2().LayoutLine(); + arrowup = AknLayoutScalable_Apps::bg_button_pane_cp023().LayoutLine(); + arrowdown= AknLayoutScalable_Apps::bg_button_pane_cp024().LayoutLine(); + arrowuprect.LayoutRect( scrollpanerect.Rect(), arrowup ); + arrowdownrect.LayoutRect( scrollpanerect.Rect(), arrowdown ); + arrowupinnerRect.LayoutRect( scrollpanerect.Rect(), arrowupinner ); + arrowdowninnerRect.LayoutRect( scrollpanerect.Rect(), arrowdowninner ); + + //iSelectionTl = rect.iTl; + iSelectionHorMargin = listpanerect.Rect().iTl.iX; + iSelectionVerMargin = listpanerect.Rect().iTl.iY; + iSelectionTl = TPoint(iIcfWesRect.iTl.iX + 10, iIcfWesRect.iTl.iY + 10); + iSelectionItemSize = itempanerect1.Rect().Size(); + iSelectionItemMargin = itempanerect1.Rect().iBr.iY - itempanerect2.Rect().iTl.iY; + iSelectionNaviSize = arrowuprect.Rect().Size(); + iSelectionNaviInnerSize = arrowupinnerRect.Rect().Size(); + iSelectionTextLine = AknLayoutScalable_Apps::list_vitu2_match_list_item_pane_t1().LayoutLine(); + iSelectionPageTextLine = AknLayoutScalable_Apps::vitu2_page_scroll_pane_t1().LayoutLine(); + + // read spell popup window laf + TAknWindowLineLayout queryPane, btnOK, btnCancle, ICFArea, btnClr, btnClrInner; + TAknWindowLineLayout editIndicator; + TAknLayoutRect queryPaneRect, btnOKRect, btnCancleRect, ICFAreaRect, btnClrRect; + TAknLayoutRect btnClrInnerRect, editIndicatorRect; + TAknTextLineLayout btnOKText, btnCancleText; + if( iLandScape ) + { + queryPane = AknLayoutScalable_Apps::popup_vitu2_query_window(1).LayoutLine(); + } + else + { + queryPane = AknLayoutScalable_Apps::popup_vitu2_query_window(0).LayoutLine(); + } + queryPaneRect.LayoutRect( viturect.Rect(), queryPane ); + btnOK = AknLayoutScalable_Apps::bg_button_pane_cp016().LayoutLine(); + btnOKRect.LayoutRect( queryPaneRect.Rect(), btnOK ); + btnCancle = AknLayoutScalable_Apps::bg_button_pane_cp017().LayoutLine(); + btnCancleRect.LayoutRect( queryPaneRect.Rect(), btnCancle ); + btnOKText = AknLayoutScalable_Apps::popup_vitu2_query_window_t4(0).LayoutLine(); + btnCancleText = AknLayoutScalable_Apps::popup_vitu2_query_window_t5(0).LayoutLine(); + + editIndicator = AknLayoutScalable_Apps::popup_vitu2_query_window_g1().LayoutLine(); + editIndicatorRect.LayoutRect( queryPaneRect.Rect(), editIndicator ); + + ICFArea = AknLayoutScalable_Apps::input_focus_pane_cp08().LayoutLine(); + ICFAreaRect.LayoutRect( queryPaneRect.Rect(), ICFArea ); + + btnClr = AknLayoutScalable_Apps::bg_button_pane_cp015().LayoutLine(); + btnClrRect.LayoutRect( queryPaneRect.Rect(), btnClr ); + btnClrInner = AknLayoutScalable_Apps::popup_vitu2_query_window_g2().LayoutLine(); + btnClrInnerRect.LayoutRect( queryPaneRect.Rect(), btnClrInner ); + + iSpellQueryPaneRect = queryPaneRect.Rect(); + iSpellEditIndicator = editIndicatorRect.Rect(); + iOkRect = btnOKRect.Rect(); + iCancelRect = btnCancleRect.Rect(); + iSpellICFRect = ICFAreaRect.Rect(); + iSpellClrRect = btnClrRect.Rect(); + iSpellClrInnerRect = btnClrInnerRect.Rect(); + + iBtnTextFormat = iVkAlphaText1;//btnOKText; + iBtnTextFormat1 = iVkAlphaText1;//btnCancleText; +#ifdef LAF_MODIFY +// manully ajust. + iBtnTextFormat.iFont = btnOKText.iFont; + iBtnTextFormat.il = iBtnTextFormat.il - 30 > 0? iBtnTextFormat.il - 30 : 0; + iBtnTextFormat.iB = 10; + iBtnTextFormat1.iFont = btnCancleText.iFont; + iBtnTextFormat1.il = iBtnTextFormat1.il - 30 > 0? iBtnTextFormat1.il - 30 : 0; + iBtnTextFormat1.iB = 10; + +// TInt offsetY = 50; +// iSpellICFRect.Move(0,-offsetY); +// iSpellClrRect.Move(0,-offsetY); +// iSpellClrInnerRect.Move( 0, -offsetY ); +#endif //LAF_MODIFY + + // just test if there is size change of added ctrls + iSendRect = iArrowLeftRect; + iDisconnRect = iArrowRightRect; + // end test + + // preview popup window + TAknWindowLineLayout previewWnd, previewBackground, previewWndInner; + TAknLayoutRect previewWndRect, previewBackgroundRect, previewWndInnerRect; + TAknLayoutText previewWndText; + previewWnd = AknLayoutScalable_Avkon::popup_fshwr2_char_preview_window(0).LayoutLine(); + + previewWndRect.LayoutRect( iLayoutRect, previewWnd ); + previewBackground = AknLayoutScalable_Avkon::bg_popup_fep_char_preview_window_cp01().LayoutLine(); + previewBackgroundRect.LayoutRect( previewWndRect.Rect(), previewBackground ); + iPreviewWndRect = previewBackgroundRect.Rect(); + + previewWndInner = AknLayoutScalable_Avkon::bg_popup_fep_char_preview_window_g9().LayoutLine(); + previewWndInnerRect.LayoutRect( previewBackgroundRect.Rect(), previewWndInner ); + + iPreviewWndInnerRect = previewWndInnerRect.Rect(); + iPreviewWndText = + AknLayoutScalable_Avkon::popup_fshwr2_char_preview_window_t1(0).LayoutLine(); + previewWndText.LayoutText(previewWndRect.Rect(), iPreviewWndText); + iBubbleFont = const_cast(previewWndText.Font()); + } + +void CGenericItutDataMgr::SetTextAlignment() + { + CFepLayoutMultiLineIcf* icffield = static_cast(iLayoutContext->Control(ECtrlIdICF)); + + if (icffield && InputLanguage() != ELangNone) + { + TRAP_IGNORE(icffield->SetTextAlignmentL(iIcfTextAlignment, InputLanguage())); + } + } + +void CGenericItutDataMgr::SetIcfTextAlignment(TInt aAlignment) + { + iIcfTextAlignment = aAlignment; + } + +void CGenericItutDataMgr::SetLanguageL(TInt aLanguage) + { + ASSERT( IsValidLanguage( aLanguage ) ); + + if (iLanguage != aLanguage) + { + if( IsValidLanguage( iLanguage ) ) + iIsLangDirectionSwitch = IsRtoLLanguage( aLanguage ) ^ IsRtoLLanguage( iLanguage ); + else + //Check mirroring is needed when first setting language + iIsLangDirectionSwitch = IsRtoLLanguage( aLanguage ); + + iLanguage = aLanguage; + iInputMode = KInvalidImMode; + + //SetTextAlignment(); + + TInt scriptIdx = GetConfigResFileName(aLanguage); + + if (scriptIdx != iCurrentScriptIdx) + { + iCurrentScriptIdx = scriptIdx; + + CCoeEnv* coeEnv = CCoeEnv::Static(); + + if (iConfigResId) + { + coeEnv->DeleteResourceFile(iConfigResId); + } + + TFileName resourceConfigName(iResourceFilename); + BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceConfigName); + iConfigResId = coeEnv->AddResourceFileL(resourceConfigName); + + if (IsChinese()) + { + iLayoutContext->UiManager()->CreateChineseSpecificCtrlsIfNeededL(); + } + + NotifyChangeControlLayout(MItutPropertySubscriber::EItutPropertyKeypadResourceId, + KeypadResourceId()); + } + } + } + +void CGenericItutDataMgr::SetCase(TInt aCase) + { + if (iCase != aCase || iInputMode == ELatin) + { + iCase = aCase; + NotifyChangeControlLayout(MItutPropertySubscriber::EItutPropertyKeypadResourceId, + KeypadResourceId()); + } + } + +void CGenericItutDataMgr::SetInputModeL(TInt aMode) + { + TInt engineMode = KInvalidImMode; + + switch (aMode) + { + case EPinyin: + { + engineMode = EPtiEnginePinyinByPhrase; + } + break; + case EStroke: + { + engineMode = EPtiEngineStrokeByPhrase; + } + break; + case EZhuyin: + { + engineMode = EPtiEngineZhuyinByPhrase; + } + break; + case ELatin: + case EHindi: + case ENumber: + case EHangul: + case ENativeNumber: + { + iInputMode = aMode; + NotifyChangeControlLayout(MItutPropertySubscriber::EItutPropertyKeypadResourceId, + KeypadResourceId()); + } + break; + case EZhuyinFind: + { + iInputMode = EZhuyin; + + return; + } + case EStrokeFind: + { + iInputMode = EStroke; + + return; + } + default: + return; + } + + if (IsChinese()) + { + TInt err = iPtiEngine->ActivateLanguageL(iLanguage, TPtiEngineInputMode(engineMode)); + if (err == KErrNone) + { + iPtiEngine->SetCandidatePageLength(KOnePageCandidateCount); + iInputMode = aMode; + } + } + } + +TAny* CGenericItutDataMgr::RequestData(TInt aDataType) + { + switch ( aDataType ) + { + case EScreenSize: + return &iScreenSize; + case ELayoutOffset: + return &iLayoutOffset; + case ELayoutRect: + return &iLayoutRect; + case EIcfRect: + return IsChinese() ? &iIcfChnRect : & iIcfWesRect; + case EIcfFont: + return IsChinese() ? reinterpret_cast(iIcfFontCn) : + reinterpret_cast(iIcfFont); + case EBackspaceRect: + case EItutPosClear: + return IsChinese() ? &iBackspaceCnRect : &iBackspaceRect; + case ESwitchRect: + case EItutPosSwitchLayout: + return IsChinese() ? &iSwitchCnRect : &iSwitchRect; + case EImIndicatorRect: + if (iSpellMode) + { + return &iSpellEditIndicator; + } + + if (IsChinese()) + { + return &iImIndicatorChnRect; + } + CalWesternIndicator(); + return &iCalindwesternRect; + case EImIndicatorOuterRect: + if(IsChinese()) + { + return &iImIndiOuterRectCn; + } + else + { + return &iImIndiOuterRect; + } + case EKeypadRect: + return IsChinese() ? &iKeypadRectCn : &iKeypadRect; + case EKeypadCellRects: + return IsChinese() ? &iKeypadCellRectsCn : &iKeypadCellRects; + case EKeypadLeftTextLine: + return &iVkNumText; + case EKeypadRightTextLine1: + return IsThai() ? &iVkAlphaText1ForThai : &iVkAlphaText1; + case EKeypadRightTextLine2: + return IsThai() ? &iVkAlphaText2ForThai : &iVkAlphaText2; + case EKeypadRightTextLine3: + return IsThai() ? &iVkAlphaText3ForThai : &iVkAlphaText3; + case EDropdownlistUnitWidth: + return &iCandsUnitWidth; + case EDropdownlistUnitHeight: + return &iCandsUnitHeight; + case EDropdownlistHorizontalMargin: + return &iCandsHorizontalMargin; + case EDropdownlistVerticalMargin: + return &iCandsVerticalMargin; + case EDropdownListNaviWidth: + return &iCandsNaviWidth; + case EDropdownListSpinBtnHeight: + return &iCandsSpinBtnHeight; + case EDropdownListSpellLTPos: + return &iCandsSpellLTPos; + case EDropdownListCandsLTPos: + return &iCandsLTPos; + case EDropdownListPuncLTPos: + return &iCandsPuncLTPos; + case EDropdownListFont: + return reinterpret_cast(iCandsFont); + case EDropdownListTextMargin: + return &iCandsTextMargin; + case EDropdownListTextColor: + return &iCandsTextColor; + case ESpellRect: + return &iSpellRect; + case ESpellFont: + return reinterpret_cast(iSpellFont); + case ESpellTextColor: + return &iSpellTextColor; + case ELanguage: + return &iLanguage; + case EInputMode: + return &iInputMode; + case ECase: + return &iCase; + case EChnCandidates: + return &iCandidates; + case EChnPuncCandidates: + return &iPuncCandidates; + case EArrowLeftRect: + case EItutPosArrowLeft: + return IsChinese() ? &iArrowLeftCnRect : &iArrowLeftRect; + case EArrowRightRect: + case EItutPosArrowRight: + return IsChinese() ? &iArrowRightCnRect : &iArrowRightRect; + case EArrowUpRect: + case EItutPosArrowUp: + return &iArrowUpRect; + case EArrowDownRect: + case EItutPosArrowDown: + return &iArrowDownRect; + case EItutPosSend: + return &iSendRect; + case EItutPosDisconn: + return &iDisconnRect; + case EMatchSelectionTlPos: + return &iSelectionTl; + case EMatchSelectionItemSize: + return &iSelectionItemSize; + case EMatchSelectionItemMargin: + return &iSelectionItemMargin; + case EMatchSelectionTextLine: + return &iSelectionTextLine; + case EOptionsRect: +#ifdef LAF_MODIFY + return IsChinese() ? &iOptionsRectCn : &iOptionsRect; +#else + return &iOptionsRect; +#endif + case ECloseRect: +#ifdef LAF_MODIFY + return IsChinese() ? &iCloseRectCn : &iCloseRect; +#else + return &iCloseRect; +#endif + case ESwitchInnerRect: + return IsChinese() ? &iSwitchInnerCnRect : &iSwitchInnerRect; + case ELeftInnerRect: + return IsChinese() ? &iArrowLeftInnerCnRect : &iArrowLeftInnerRect; + case ERightInnerRect: + return IsChinese() ? &iArrowRightInnerCnRect : &iArrowRightInnerRect; + case EBackspaceInnerRect: + return IsChinese() ? &iBackspaceInnerCnRect : &iBackspaceInnerRect; + case EUpInnerRect: + return &iArrowUpInnerRect; + case EDownInnerRect: + return &iArrowDownInnerRect; + case ECloseInnerRect: +#ifdef LAF_MODIFY + return IsChinese() ? &iCloseInnerRectCn : &iCloseInnerRect; +#else + return &iCloseInnerRect; +#endif + case EOptionInnerRect: +#ifdef LAF_MODIFY + return IsChinese() ? &iOptionInnerRectCn : &iOptionInnerRect; +#else + return &iOptionInnerRect; +#endif + case EItutPosOk: + return &iOkRect; + case EItutPosCancel: + return &iCancelRect; + case EBtnTextLine: + return &iBtnTextFormat; + case ESpellTextCancle: + return &iBtnTextFormat1; + case ESpellICFRect: + return &iSpellICFRect; + case ESpellClrRect: + return &iSpellClrRect; + case ESpellClrInnerRect: + return &iSpellClrInnerRect; + case ESpellEditIndicatorRect: + return &iSpellEditIndicator; + case ESpellQueryPaneRect: + return &iSpellQueryPaneRect; + case ELatinOnly: + return &iLatinOnly; + case EPreviewBubbleRect: + return &iPreviewWndRect; + case EPreviewBubbleInnerRect: + return &iPreviewWndInnerRect; + case EPreviewBubbleTextlayout: + return &iPreviewWndText; + case EPreviewBubbleFont: + return reinterpret_cast(iBubbleFont); + default: + break; + } + + return NULL; + } + +CGenericItutDataMgr::CGenericItutDataMgr(MItutLayoutContext* aLayoutContext, + CPtiEngine* aPtiEngine) + : + iPtiEngine( aPtiEngine ), + iLanguage(ELangNone), + iInputMode(KInvalidImMode), + iCase(EAknEditorUpperCase), + iConfigResId(0), + iLayoutContext(aLayoutContext), + iCurrentScriptIdx(KInvalidIndex), + iLandScape(EFalse), + iSpellMode(EFalse) + { + } + +void CGenericItutDataMgr::NotifySubscriber(MItutPropertySubscriber::TItutProperty aPropertyName, + const TDesC& aValue) + { + for (TInt i = 0; i < iSubscriberList.Count(); i++) + { + TRAP_IGNORE(iSubscriberList[i]->SetPropertyL(aPropertyName, aValue)); + } + } + +void CGenericItutDataMgr::NotifyChangeControlLayout( + MItutPropertySubscriber::TItutProperty aPropertyName, TInt aCtrlResId) + { + TInt ctrlResId = KInvalidResId; + + switch (aPropertyName) + { + case MItutPropertySubscriber::EItutPropertyKeypadResourceId: + { + ctrlResId = iLayoutContext->Control(ECtrlIdStdItut)->ResourceId(); + } + break; + case MItutPropertySubscriber::EItutPropertyCandidateListResourceId: + { + ctrlResId = iLayoutContext->Control(ECtrlIdStdCandsList)->ResourceId(); + } + break; + default: + break; + } + + // since keypad resource divided by script, so maybe ctrlResId unchanged, + // but it is actually changed in different script + if ((ctrlResId != aCtrlResId) || + (aPropertyName == MItutPropertySubscriber::EItutPropertyKeypadResourceId)) + { + TPtrC ptr(reinterpret_cast(&aCtrlResId), sizeof(aCtrlResId)/sizeof(TText)); + + NotifySubscriber(aPropertyName, ptr); + } + } + +TInt CGenericItutDataMgr::GetNextPageCandidateL(RPointerArray& aList) + { + if (iPtiEngine && (iPtiEngine->NextCandidatePage())) + { + TItutDataConverter::ConvertChnPhraseCandidateL(iPtiEngine->CandidatePage(), aList); + + return KErrNone; + } + + return KErrNotSupported; + } + +TBool CGenericItutDataMgr::NextPageCandidateExist() + { + if (iPtiEngine) + { + return iPtiEngine->MoreCandidatePages(); + } + + return EFalse; + } + +TInt CGenericItutDataMgr::KeypadResourceId() + { + if (iInputMode == ENumber ) + { + if( IsExistPlusChar() ) + return R_FINGER_INPUT_KEYPAD_NUMBER_WITH_PLUS; + else + return R_FINGER_INPUT_KEYPAD_NUMBER; + } + if( iInputMode == ENativeNumber ) + { + if( IsExistPlusChar() ) + return R_FINGER_INPUT_KEYPAD_NATIVE_NUMBER_WITH_PLUS; + else + return R_FINGER_INPUT_KEYPAD_NATIVE_NUMBER; + } + + if ( iLatinOnly ) + { + if ( iCase == EAknEditorTextCase || iCase == EAknEditorUpperCase ) + { + return R_FINGER_INPUT_KEYPAD_LATINONLY_UPPERCASE; + } + return R_FINGER_INPUT_KEYPAD_LATINONLY_LOWERCASE; + } + + if (!iLangCaseSensitive ) + { + return R_FINGER_INPUT_KEYPAD_ABC; + } + if ( IsChinese() ) + { + return ChineseKeypadResourceId(); + } + if ( IsHindi() ) + { + return HindiKeypadResourceId(); + } + + if ( IsKorean() ) + { + return KoreanKeypadResourceId(); + } + if (iCase == EAknEditorTextCase || iCase == EAknEditorUpperCase) + { + return R_FINGER_INPUT_KEYPAD_ABC_UPPERCASE; + } + else + { + return R_FINGER_INPUT_KEYPAD_ABC_LOWERCASE; + } + } + +TInt CGenericItutDataMgr::ChineseKeypadResourceId() + { + + if (iInputMode == EZhuyin) + { + return R_FINGER_INPUT_KEYPAD_ZHUYIN_STANDBY_PREDICT; + } + if (iInputMode == EPinyin) + { + return R_FINGER_INPUT_KEYPAD_PINYIN_STANDBY_PREDICT; + } + if (iInputMode == EStroke) + { + TInt resID; + if (InputLanguage() == ELangPrcChinese) + { + resID = R_FINGER_INPUT_KEYPAD_STROKE_STANDBY_PREDICT_PRC; + } + else + { + resID = R_FINGER_INPUT_KEYPAD_STROKE_STANDBY_PREDICT_TRA; + } + return resID; + } + + if (iCase == EAknEditorTextCase || iCase == EAknEditorUpperCase) + { + return R_FINGER_INPUT_KEYPAD_ABC_UPPERCASE_CHN; + } + else + { + return R_FINGER_INPUT_KEYPAD_ABC_LOWERCASE_CHN; + } + } + +TInt CGenericItutDataMgr::HindiKeypadResourceId() + { + if ( iInputMode == EHindi ) + { + return R_FINGER_INPUT_KEYPAD_ABC; + } + + if (iCase == EAknEditorTextCase || iCase == EAknEditorUpperCase) + { + return R_FINGER_INPUT_KEYPAD_LATINONLY_UPPERCASE; + } + else + { + return R_FINGER_INPUT_KEYPAD_LATINONLY_LOWERCASE; + } + } + +TInt CGenericItutDataMgr::KoreanKeypadResourceId() + { + if ( iInputMode == EHangul ) + { + return R_FINGER_INPUT_KEYPAD_KOREAN; + } + + if (iCase == EAknEditorTextCase || iCase == EAknEditorUpperCase) + { + return R_FINGER_INPUT_KEYPAD_LATINONLY_UPPERCASE; + } + else + { + return R_FINGER_INPUT_KEYPAD_LATINONLY_LOWERCASE; + } + } + + +TInt CGenericItutDataMgr::GetConfigResFileName(TInt aLang) + { + iResourceFilename.Zero(); + iResourceFilename = KConfigResourceFile(); + + for (TInt i = 0; i < sizeof(TScriptMapping) / sizeof(TScriptMapping[0]); i++) + { + TScriptInfo script = TScriptMapping[i]; + + if (FindLang(&(LangsArr[script.iStartIdx]), script.iEndIdx - script.iStartIdx, aLang) != + KErrNotFound) + { + iResourceFilename.Append(ResFileExtByScriptIdx(script.iScriptExt)); + iResourceFilename.Append(KResourceFileExtName); + iLangCaseSensitive = script.iCaseSensitive; + return i; + } + } + + // default resource file is latin + iResourceFilename.Append(ResFileExtByScriptIdx(TScriptMapping[0].iScriptExt)); + iResourceFilename.Append(KResourceFileExtName); + iLangCaseSensitive = TScriptMapping[0].iCaseSensitive; + return 0; + } + +TInt CGenericItutDataMgr::FindLang(const TInt* aArray, + TInt aEndIdx, + TInt aLang) + { + for (TInt i = 0; i <= aEndIdx; i++) + { + if (aLang == *aArray) + { + return i; + } + + aArray++; + } + + return KErrNotFound; + } + +TBool CGenericItutDataMgr::IsChinese() + { + return (iLanguage == ELangPrcChinese || iLanguage == ELangHongKongChinese + || iLanguage == ELangTaiwanChinese); + } + +// tp teleca addon +TBool CGenericItutDataMgr::IsKorean() + { + return ( iLanguage == ELangKorean ); + } + +TBool CGenericItutDataMgr::IsHindi() + { + return ( iLanguage == ELangHindi ); + } + +TBool CGenericItutDataMgr::IsThai() + { + return ( iLanguage == ELangThai ); + } + +TBool CGenericItutDataMgr::IsRtoLLanguage() + { + return ( iLanguage == ELangArabic || + iLanguage == ELangHebrew || + iLanguage == ELangFarsi || + iLanguage == ELangUrdu ); + } + +TBool CGenericItutDataMgr::IsRtoLLanguage( TInt aLanguage ) + { + return ( aLanguage == ELangArabic || + aLanguage == ELangHebrew || + aLanguage == ELangFarsi || + aLanguage == ELangUrdu ); + } + +TBool CGenericItutDataMgr::IsLangDirectionSwitch() const + { + return iIsLangDirectionSwitch; + } + +const TDesC& CGenericItutDataMgr::ResFileExtByScriptIdx(const TScriptExtIndex aIndex) + { + switch (aIndex) + { + case ELatinExt: + return KLatinExt; + case ECyrillicExt: + return KCyrillicExt; + case EGreekExt: + return KGreekExt; + case EHebrewExt: + return KHebrewExt; + case EArabicExt: + return KArabicExt; + case EFarsiExt: + return KFarsiExt; + case EUrduExt: + return KUrduExt; + case EThaiExt: + return KThaiExt; + case EChnExt: + return KChnExt; + case EDevanagiriExt: + return KDevanagiriExt; + case EHangulExt: + return KHangulExt; + default: + break; + } + + return KNullDesC; + } + +void CGenericItutDataMgr::SetUpdate(TBool aNeedUpdate) + { + iNeedUpdate = aNeedUpdate; + } + +TBool CGenericItutDataMgr::IsUpdate() const + { + return iNeedUpdate; + } + +void CGenericItutDataMgr::CalWesternIndicator() + { + TSize indSize(iImIndicatorWesRect.Width() * 5 / 6, iImIndicatorWesRect.Height() * 5 / 6); + + TInt offsetX = ( iImIndicatorWesRect.Width() - indSize.iWidth ) / 2; + TInt offsetY = ( iImIndicatorWesRect.Height() - indSize.iHeight ) / 2; + + TInt x = iImIndicatorWesRect.iTl.iX + offsetX; + TInt y = iImIndicatorWesRect.iTl.iY + offsetY; + + iCalindwesternRect.SetRect(TPoint(x,y) , indSize); + } + +void CGenericItutDataMgr::SetNumericKeymap( const TInt aKeymap ) + { + iNumericKeymap = aKeymap; + } + +void CGenericItutDataMgr::SetNumericKeymapData( TInt* aKeymapData ) + { + delete iNumericKeymapData; + TInt* len = (TInt*)((TUint8*)aKeymapData - 4); + TPtrC16 keymapRes((const TUint16*)aKeymapData, *len/2); + iNumericKeymapData = keymapRes.Alloc(); + } + +TBool CGenericItutDataMgr::IsExistPlusChar() + { + if( !IsNumericOnly() ) + { + return EFalse; + } + if ( iNumericKeymap == EKeymapFromResource ) + { + HBufC* keyRes = iNumericKeymapData; + if( keyRes != NULL && keyRes->Locate( TChar( KPlusChar ) ) != KErrNotFound ) + { + return ETrue; + } + } + else if ( iNumericKeymap == EAknEditorStandardNumberModeKeymap + || iNumericKeymap == EAknEditorConverterNumberModeKeymap + || iNumericKeymap == EAknEditorCalculatorNumberModeKeymap + || iNumericKeymap == EAknEditorToFieldNumberModeKeymap + || iNumericKeymap == EAknEditorFixedDiallingNumberModeKeymap + || iNumericKeymap == EAknEditorSATNumberModeKeymap ) + { + return ETrue; + } + return EFalse; + } + +// End Of File