/*
* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0""
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: vkb client area implementation
*
*/
// system includes
#include <peninputvkbctrlext.h>
#include <peninputvkbctrllayout.h>
#include <peninputlayout.h>
#include <peninputlayoutrootctrl.h>
#include <peninputeventbutton.h>
#include <peninputdropdownlist.h>
#include <peninputmultimodebutton.h>
#include <aknfeppeninputenums.h> //command from fep or IME to plugin
#include <peninputrangebar.h>
#include <peninputvkbcn.rsg>
#include <peninputrepeatbutton.h>
#include <AknLayoutDef.h>
#include <AknUtils.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <AknsUtils.h>
#include <peninputlayoutmultilineicf.h>
#include <peninputdragbutton.h>
#include <peninputpluginutils.h>
// user includes
#include "peninputvkbevent.h"
#include "peninputvkbdataprovider.h"
#include "peninputvkbclientarea.h"
#include "peninputvkbctrlpool.h"
#include "peninputvkblayoutpool.h"
#include "peninputvkbcompositionfield.h"
#include "peninputvkbImlayout.h"
#include "peninputvkbnumerickeymappingmgr.h"
#include "peninputvkbwindow.h"
#include "peninputvkbdatamgr.h"
#include "peninputvkbuistate.h"
// constant definition
const TInt KDropdownRowsForStroke = 3;
const TInt KDropdownRowsForOthers = 4;
const TUint16 KStrokeSeparator = 0x2022;
const TUint16 KPinyinSeparator = 0x0027;
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::CAknFepVkbClientArea
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CAknFepVkbClientArea::CAknFepVkbClientArea(CFepUiLayout* aUiLayout,
TInt aControlId,
MAknFepVkbDataProvider* aDataProvider,
CPeninputCnGenericVkbLafMgr* aLafMgr)
:CControlGroup(aUiLayout, aControlId, EFalse),
iDataProvider(aDataProvider),
iTextPropertySet(EFalse),
iDropdownPropertySet(EFalse),
iLafMgr(aLafMgr)
{
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::NewL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CAknFepVkbClientArea* CAknFepVkbClientArea::NewL(CFepUiLayout* aUiLayout,
TInt aControlId,
MAknFepVkbDataProvider* aDataProvider,
CPeninputCnGenericVkbLafMgr* aLafMgr)
{
CAknFepVkbClientArea* self = CAknFepVkbClientArea::NewLC(aUiLayout, aControlId,
aDataProvider, aLafMgr);
CleanupStack::Pop(self);
return self;
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::NewLC
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CAknFepVkbClientArea* CAknFepVkbClientArea::NewLC(CFepUiLayout* aUiLayout,
TInt aControlId,
MAknFepVkbDataProvider* aDataProvider,
CPeninputCnGenericVkbLafMgr* aLafMgr)
{
CAknFepVkbClientArea* self = new (ELeave) CAknFepVkbClientArea(aUiLayout, aControlId,
aDataProvider, aLafMgr);
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::SetTextProperty
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::SetTextProperty()
{
TAknTextLineLayout compositionText;
compositionText = AknLayoutScalable_Avkon::cell_vkb_candidate_pane_t1().LayoutLine();
iCompositionField->SetNormalColor(AKN_LAF_COLOR_STATIC(compositionText.iC));
iCompositionField->SetWarningColor(KRgbRed);
iCompositionField->SetFont(AknLayoutUtils::FontFromId(compositionText.iFont, NULL));
iTextPropertySet = ETrue;
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::ConstructL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::ConstructL()
{
BaseConstructL();
iCtrlPool = CAknFepVkbCtrlPool::NewL();
iVkbLayout = CAknFepCtrlVkbLayout::NewL();
iLayoutPool = CAknFepLayoutPool::NewL( *iVkbLayout );
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC(reader, R_AKN_FEP_VKB_KEY_MAPPING_STRING_LIST);
iKeyMappingMgr = CAknFepVkbNumericKepMappingMgr::NewL(reader);
CleanupStack::PopAndDestroy(); // reader
// 1.Create all control in the client, including all kinds of control in different layout
// Composition field
iCompositionField = CAknFepVkbCompositionField::NewL(KMaxLengthCompFieldElemCount,TRect(),
UiLayout(),
EAknFepVkbCtrlIdCompositionField,
iDataProvider );
iCompositionField->SetResourceId(R_AKN_FEP_VKB_COMPOSITION_FIELD);
iCompositionField->ConstructFromResourceL();
iCtrlPool->AddControl(iCompositionField);
AddButtonL(EAknFepVkbCtrlIdArrowUpBtn,
EVkbEventUpArrow,
R_AKN_FEP_VKB_ARROW_UP_BUTTON,
EKeyUpArrow,
ETrue);
AddButtonL(EAknFepVkbCtrlIdArrowDownBtn,
EVkbEventDownArrow,
R_AKN_FEP_VKB_ARROW_DOWN_BUTTON,
EKeyDownArrow,
ETrue
);
AddButtonL(EAknFepVkbCtrlIdArrowLeftBtn,
EVkbEventLeftArrow,
R_AKN_FEP_VKB_ARROW_LEFT_BUTTON,
EKeyLeftArrow,
ETrue
);
AddButtonL(EAknFepVkbCtrlIdArrowRightBtn,
EVkbEventRightArrow,
R_AKN_FEP_VKB_ARROW_RIGHT_BUTTON,
EKeyRightArrow,
ETrue
);
// Vkb control
iVkbCtrl = CPeninputVkbCtrlExt::NewL(TRect(),
UiLayout(),
EAknFepVkbCtrlIdVkbCtrl,
NULL);
iVkbCtrl->SetResourceId( R_PENINPUT_LAYOUT_VKB_KEYBOARD );
iVkbCtrl->ConstructFromResourceL();
iVkbCtrl->SetKeyTextColorGroup( EAknsCIQsnTextColorsCG68 );
iVkbLayout->SetVkbKeyboard( iVkbCtrl );
if (UiLayout()->PenInputType() == EPluginInputModeVkb)
{
iVkbCtrl->SetIrregularKeyBoard(ETrue);
iVkbLayout->SetIrregularResourceId(R_AKN_FEP_VKBCN_IRREGULAR_BITMAP);
iVkbLayout->ConstructFromIrregularResourceL();
}
else if (UiLayout()->PenInputType() == EPluginInputModeFSQ)
{
iVkbCtrl->SetIrregularKeyBoard(EFalse);
iVkbLayout->SetNonIrregularResourceId(R_AKN_FEP_VKBCN_NONIRREGULAR_BITMAP);
iVkbLayout->ConstructFromNonIrregularResourceL();
//set key to be 9 piece graphics
iVkbCtrl->SetKeySkinId( EKeyBmpNormal, KAknsIIDQsnFrKeypadButtonFrNormal );
iVkbCtrl->SetKeySkinId( EKeyBmpHighlight, KAknsIIDQsnFrKeypadButtonFrPressed );
iVkbCtrl->SetKeySkinId( EKeyBmpDim, KAknsIIDQsnFrKeypadButtonFrInactive );
}
iCtrlPool->AddControl(iVkbCtrl);
// Add bubble support
iVkbCtrl->ShowBubble(ETrue);
iVkbCtrl->SetGowithPointerDown(ETrue);
iVkbCtrl->SetBubbleBitmapParam(NULL,NULL,KAknsIIDQsnFrInputCharPreview); //Change the ID when ID into release
AddButtonL(EAknFepVkbCtrlIdTouchInputOption,
EVkbEventTouchInputOption,
R_AKN_FEP_VKB_TOUCH_INPUT_OPTION);
// Enter button
AddButtonL(EAknFepVkbCtrlIdEnterBtn,EVkbEventKeyEnter,R_AKN_FEP_VKB_ENTER, EKeyEnter);
// Drop down list
AddDropdownListL();
// Range bar
AddRangeBarL();
// Shift and capslock merged button
CAknFepCtrlMultiModeButton* button =
CAknFepCtrlMultiModeButton::NewLC( UiLayout(), EAknFepVkbCtrlIdShiftBtn );
if ( button )
{
// Read resource
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader,
R_AKN_FEP_VKB_SHIFT_CAPSLOCK );
button->SetResourceId( R_AKN_FEP_VKB_SHIFT_CAPSLOCK );
button->ConstructFromResourceL();
// Pop and destroy reader
CleanupStack::PopAndDestroy( 1 );
// Add into the control pool
iCtrlPool->AddControl( button );
}
CleanupStack::Pop( button );
// Space button
CAknFepCtrlEventButton* spaceButton = AddButtonL(
EAknFepVkbCtrlIdSpaceBtn,
EVkbEventKeySpace,
R_AKN_FEP_VKB_SPACE1,
EKeySpace);
// Create 3-pieces color icon for space button
CPenInput3PiecesColorIcons* colorIcons =
CPenInput3PiecesColorIcons::NewL( R_AKN_FEP_VKB_SPACE_ICON1,
R_AKN_FEP_VKB_SPACE_ICON2,
R_AKN_FEP_VKB_SPACE_ICON3 );
spaceButton->Set3PiecesColorIcons( colorIcons );
//set background of space button to be 9 piece graphics
if ( UiLayout()->PenInputType() == EPluginInputModeFSQ )
{
spaceButton->SetImageFrameId( KAknsIIDQsnFrKeypadButtonFrNormal,
KAknsIIDQsnFrKeypadButtonFrPressed,
KAknsIIDQsnFrKeypadButtonFrInactive );
}
// switch to hwr button
AddButtonL(EAknFepVkbCtrlIdSwitchToHwrBtn,EVkbEventHwr,R_AKN_FEP_VKB_HWR);
SetTextProperty();
if( iCtrlPool != NULL )
{
for( TInt i=0; i < iCtrlPool->ControlCount(); i++ )
{
iCtrlPool->ControlByIndex(i)->AddEventObserver( UiLayout() );
}
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::~CAknFepVkbClientArea
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CAknFepVkbClientArea::~CAknFepVkbClientArea()
{
delete iVkbLayout;
delete iCtrlPool;
delete iLayoutPool;
delete iKeyMappingMgr;
iRemainedPoolControlIDs.Close();
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::SizeChanged
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::SizeChanged()
{
TAknTextLineLayout keypadText, compositionText, dropDownText;
TInt btnWidth = iDataProvider->RequestData(EAknFepDataTypeUnitWidth);
TInt btnHeight = iDataProvider->RequestData(EAknFepDataTypeUnitHeight);
if (iDataProvider->SizeChanging() || (!iTextPropertySet))
{
SetTextProperty();
}
// modify drop down list font
if (iDataProvider->SizeChanging() || (!iDropdownPropertySet))
{
TAknTextLineLayout listText =
AknLayoutScalable_Avkon::cell_vkb_candidate_pane_t1().LayoutLine();
iDropdownList->SetFont(AknLayoutUtils::FontFromId(listText.iFont, NULL));
//iDropdownList->SetTextColor(AKN_LAF_COLOR_STATIC(listText.iC), ETrue);
iDropdownList->SizeChanged(btnWidth, btnHeight, btnWidth);
}
if ( iCurrentImLayout )
{
//3.Change the postion and size of controls in current layout
ReorganizeControls(iCurrentImLayout, EFalse);
}
//calculate current vkblayout according current imlayout
if ( iCurrentVkbLayout )
{
//dimmed some keys if needed
TRAP_IGNORE(DimKeys());
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::ChangeImLayout
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::ChangeImLayout(TInt aImLayout, TBool aChangeVkb)
{
iDataProvider->SetData(EAknFepDataTypeIMLayout, aImLayout);
static_cast<CAknFepVkbDataMgr*>(iDataProvider)->ResetUnitSize();
TInt currentRange = iDataProvider->RequestData(EAknFepDataTypeCurrentRange);
CAknFepVkbImLayout* newImLayout = iLayoutPool->GetImLayout(aImLayout);
if ( iCurrentImLayout != newImLayout)
{
iCurrentImLayout = newImLayout;
if ( currentRange == ERangeNative)
{
iDropdownList->SetRowNum(aImLayout == EAknFepVkbImCnStroke ?
KDropdownRowsForStroke : KDropdownRowsForOthers );
}
ReorganizeControls(iCurrentImLayout, ETrue);
}
if ( iRangeBar )
{
iRangeBar->SetRange(currentRange);
}
//calculate current vkblayout according current imlayout
if (aChangeVkb)
{
if ( ( currentRange == ERangeEnglish ) || ( currentRange == ERangeAccent ) )
{
// Change shift and capslock button status according to the current case
TInt curCase = iDataProvider->RequestData( EAknFepDataTypeCase );
TInt shfit;
TInt capslock;
switch ( curCase )
{
case ECaseUpper:
shfit = 0;
capslock = 1;
break;
case ECaseText:
shfit = 1;
capslock = 0;
break;
case ECaseInverseText:
shfit = 1;
capslock = 1;
break;
case ECaseLower:
case ECaseInvalide:
default:
shfit = 0;
capslock = 0;
break;
}
iDataProvider->SetData( EAknFepDataTypeShfitDown, shfit );
//ChangeButtonStatus( shfit, EAknFepVkbCtrlIdShiftBtn );
iDataProvider->SetData( EAknFepDataTypeCapslockDown, capslock );
//ChangeButtonStatus( capslock, EAknFepVkbCtrlIdCapslockBtn );
ChangeMergedButtonStatus(shfit, capslock);
if ( ( shfit && capslock ) || ( !shfit && !capslock ) )
{
ChangeVkbLayout();
}
else
{
TAknFepVkbLayout vkbLayout = ShiftCapsSingleVkbLayoutId( currentRange );
ChangeVkbLayout( vkbLayout );
}
}
else
{
iDataProvider->SetData( EAknFepDataTypeShfitDown, 0 );
//ChangeButtonStatus( 0, EAknFepVkbCtrlIdShiftBtn );
iDataProvider->SetData( EAknFepDataTypeCapslockDown, 0 );
//ChangeButtonStatus( 0, EAknFepVkbCtrlIdCapslockBtn );
ChangeMergedButtonStatus(0, 0);
ChangeVkbLayout();
}
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::ShiftCapsSingleVkbLayoutId
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TAknFepVkbLayout CAknFepVkbClientArea::ShiftCapsSingleVkbLayoutId( TInt aRange )
{
TInt defaultIMLayout = iDataProvider->RequestData(EAknFepDataTypeDefaultIMLayout);
TInt curLanguage = iDataProvider->RequestData(EAknFepDataTypeInputLanguage);
TAknFepVkbLayout vkbLayout = EAknFepVkbVkbLatinShift;
TInt imLayout = iDataProvider->RequestData(EAknFepDataTypeIMLayout);
switch (aRange)
{
case ERangeEnglish:
if (curLanguage == ELangTaiwanChinese && defaultIMLayout != EAknFepVkbImCnStroke)
{
vkbLayout = EAknFepVkbVkbLatinForZhuyinShift;
}
else
{
vkbLayout = EAknFepVkbVkbLatinShift;
}
break;
case ERangeNumber:
if (curLanguage == ELangTaiwanChinese && defaultIMLayout != EAknFepVkbImCnStroke)
{
vkbLayout = EAknFepVkbVkbNumberForZhuyinShift;
}
else
{
vkbLayout = EAknFepVkbVkbNumberShift;
}
break;
case ERangeSymbol:
vkbLayout = EAknFepVkbVkbSymbolShift;
break;
case ERangeAccent:
{
TInt accent = iDataProvider->RequestData(EAknFepDataTypeCurrentAccent);
switch (accent)
{
case EAknFepVkbVkbAccented1:
vkbLayout = EAknFepVkbVkbAccentedShfit1;
break;
case EAknFepVkbVkbAccented2:
vkbLayout = EAknFepVkbVkbAccentedShfit2;
break;
case EAknFepVkbVkbAccented3:
vkbLayout = EAknFepVkbVkbAccentedShfit3;
break;
default:
vkbLayout = EAknFepVkbVkbAccentedShfit1;
break;
}
}
break;
default:
break;
}
return vkbLayout;
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::ChangeVkbLayout
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::ChangeVkbLayout(TInt aVkbLayoutId)
{
TAknFepVkbLayout vkbLayoutId;
TInt range = iDataProvider->RequestData(EAknFepDataTypeCurrentRange);
if ( aVkbLayoutId >= 0 )
{
CPeninputVkbLayoutInfo* tempLayout = iLayoutPool->GetVkbLayout(aVkbLayoutId);
if ( iCurrentVkbLayout == tempLayout)
{
return;
}
else
{
iCurrentVkbLayout = tempLayout;
}
vkbLayoutId = static_cast<TAknFepVkbLayout>(aVkbLayoutId);
}
else
{
vkbLayoutId = GetDefaultVkbLayout(range);
iCurrentVkbLayout = iLayoutPool->GetVkbLayout(vkbLayoutId);
}
iVkbLayout->ChangeVkbLayout( vkbLayoutId );
iVkbLayoutId = aVkbLayoutId;
SetVkbLayoutSize(vkbLayoutId);
iVkbCtrl->SetRect( TRect( iVkbBoardLeftTop, iLafMgr->KeypadRect().Size() ) );
//dimmed some keys if needed
TRAP_IGNORE(DimKeys());
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::SetVkbLayoutSize
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::SetVkbLayoutSize(TInt aVkbLayoutId)
{
TInt currentRange = iDataProvider->RequestData(EAknFepDataTypeCurrentRange);
TAknFepVkbLayout vkbLayoutid;
if(aVkbLayoutId < 0)
{
vkbLayoutid = GetDefaultVkbLayout(currentRange);
}
else
{
vkbLayoutid = static_cast<TAknFepVkbLayout>(aVkbLayoutId);
}
CPeninputVkbLayoutInfo* vkbLayout = iLayoutPool->GetVkbLayout( vkbLayoutid );
// Calculate current vkblayout according current layout
if ( vkbLayout )
{
const TInt columns = vkbLayout->Columns();
const TInt rows = vkbLayout->Rows();
TRect keyRect;
TRect charRect;
iLafMgr->SetLayoutType(iLafMgr->LayoutTypeFromRowsColumns(rows,columns));
// Set priview popup size
TRect outrect,innerrect;
iLafMgr->GetPreviewWndRect(outrect,innerrect);
iVkbCtrl->SetTextFormat(iLafMgr->PreviewWndText()); //Read laf
iVkbCtrl->SetBubbleSize(TSize(outrect.Width(),outrect.Height())); // Read laf
iVkbCtrl->SetFrameDiff(innerrect.iTl.iX - outrect.iTl.iX,
innerrect.iTl.iY - outrect.iTl.iY,
outrect.iBr.iX - innerrect.iBr.iX,
outrect.iBr.iY - innerrect.iBr.iY);
if(iDropdownList)
{
iDropdownList->SetBubbleBitmapParam(NULL,NULL,KAknsIIDQsnFrInputCharPreview);
iDropdownList->SetTextFormat(iLafMgr->PreviewWndText()); //Read laf
iDropdownList->SetBubbleTextFont(iLafMgr->PreviewFont());
iDropdownList->SetBubbleSize(TSize(outrect.Width(),outrect.Height())); // Read laf
iDropdownList->SetFrameDiff(innerrect.iTl.iX - outrect.iTl.iX,
innerrect.iTl.iY - outrect.iTl.iY,
outrect.iBr.iX - innerrect.iBr.iX,
outrect.iBr.iY - innerrect.iBr.iY);
}
for (TInt exter = 0; exter < rows; exter ++)
{
for (TInt inter = 0; inter < columns; inter ++ )
{
iLafMgr->GetKeyRect(inter,exter, keyRect, charRect);
vkbLayout->SetKeyInfo(exter,inter,keyRect,charRect,iLafMgr->KeyTextFont());
}
}
TSize curSize = vkbLayout->KeyInfoList()[0]->Key()->Rect().Size();
if ( iVkbCtrl->IsIrregularKeyBoard() )
{
TSize size =
iVkbCtrl->IrregularKeyBitmap(EKeyLeftDown,EKeyStateNormal)->SizeInPixels();
if ( curSize != size )
{
for ( TInt i = 0; i <= EKeyRightUp; i++ )
{
for ( TInt j = 0; j <= EKeyStateDimmedMask; j++ )
{
AknIconUtils::SetSize( iVkbCtrl->IrregularKeyBitmap(
(TVirtualKeyIrregularKeyType)i,(TVirtualKeyIrregularKeyState)j),
curSize, EAspectRatioNotPreserved );
AknIconUtils::SetSize( iVkbCtrl->IrregularKeyBitmap(
(TVirtualKeyIrregularKeyType)i,(TVirtualKeyIrregularKeyState)j),
curSize, EAspectRatioNotPreserved );
}
}
}
}
else
{
TSize size = iVkbCtrl->NonIrregularKeyBitmap(EKeyBmpNormal)->SizeInPixels();
if( curSize != size )
{
for ( TInt i = 0; i <= EKeyBmpLastType; i++ )
{
if( iVkbCtrl->NonIrregularKeyBitmap((TVirtualKeyBmpType)i) )
{
AknIconUtils::SetSize(
iVkbCtrl->NonIrregularKeyBitmap((TVirtualKeyBmpType)i), curSize,
EAspectRatioNotPreserved );
}
}
}
}
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::LoopVkbLayout
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::LoopVkbLayout(TVkbShiftType aType, TBool aNotify)
{
TInt currentRange = iDataProvider->RequestData(EAknFepDataTypeCurrentRange);
if (currentRange!=ERangeNative)
{
TBool shiftDown = iDataProvider->RequestData(EAknFepDataTypeShfitDown);
TBool capslockDown = iDataProvider->RequestData(EAknFepDataTypeCapslockDown);
if ( aType == EVkbShift)
{
if ((currentRange == ERangeEnglish) || (currentRange == ERangeAccent))
{
capslockDown = !capslockDown;
iDataProvider->SetData( EAknFepDataTypeCapslockDown, capslockDown );
ChangeMergedButtonStatus( shiftDown, capslockDown );
}
}
else if ( aType == EVkbCapslock )
{
if(static_cast<CAknFepVkbDataMgr*>(iDataProvider)->IsShiftPermitted())
{
if ((currentRange == ERangeEnglish) || (currentRange == ERangeAccent))
{
shiftDown = !shiftDown;
ChangeMergedButtonStatus( shiftDown, capslockDown );
iDataProvider->SetData( EAknFepDataTypeShfitDown, shiftDown );
}
}
else
{
if(static_cast<CAknFepVkbDataMgr*>(iDataProvider)->IsCapsLockPermitted())
{
capslockDown = !capslockDown;
iDataProvider->SetData( EAknFepDataTypeCapslockDown, capslockDown );
ChangeMergedButtonStatus( shiftDown, capslockDown );
}
}
}
else if( aType == EVkbBoth )
{
if ( shiftDown )
{
shiftDown = 0;
}
else
{
shiftDown = 1;
}
iDataProvider->SetData( EAknFepDataTypeShfitDown, shiftDown );
if ((currentRange == ERangeEnglish) || (currentRange == ERangeAccent))
{
capslockDown = !capslockDown;
iDataProvider->SetData( EAknFepDataTypeCapslockDown, capslockDown );
ChangeMergedButtonStatus( shiftDown, capslockDown );
}
}
else
{
ChangeMergedButtonStatus( shiftDown, capslockDown );
}
// Update indicator
TInt caseid = CaseByShiftCapslockStatus();
if ( aNotify && (currentRange == ERangeEnglish || currentRange == ERangeAccent))
{
TBuf<4> buf;
TInt fepcase = FepCaseByCaseId( caseid );
iDataProvider->SetData( EAknFepDataTypeCase, fepcase );
buf.Append(reinterpret_cast<TText*>(&fepcase), 4);
UiLayout()->LayoutOwner()->SignalOwner( ESignalCaseMode, buf );
}
if ( ( shiftDown && capslockDown ) || ( !shiftDown && !capslockDown ) )
{
ChangeVkbLayout();
}
else
{
TAknFepVkbLayout vkbLayout = ShiftCapsSingleVkbLayoutId( currentRange );
ChangeVkbLayout( vkbLayout );
}
}
Draw();
UpdateArea(Rect(), EFalse);
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::FepCaseByCaseId
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CAknFepVkbClientArea::FepCaseByCaseId( TInt aCaseId )
{
switch ( aCaseId )
{
case 0:
return ECaseLower;
case 1:
return ECaseText;
case 2:
return ECaseUpper;
case 3:
return ECaseInverseText;
default:
return ECaseLower;
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::CaseByShiftCapslockStatus
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CAknFepVkbClientArea::CaseByShiftCapslockStatus()
{
TBool shiftDown = iDataProvider->RequestData(EAknFepDataTypeShfitDown);
TBool capslockDown = iDataProvider->RequestData(EAknFepDataTypeCapslockDown);
return ( (TInt)capslockDown * 2 + (TInt)shiftDown );
}
void CAknFepVkbClientArea::ReorganizeZhuYinControls( TBool aShowArrowKey )
{
if ( UiLayout()->PenInputType() != EPluginInputModeFSQ )
{
return;
}
CAknFepCtrlRepeatButton* arrowUpBtn = static_cast<CAknFepCtrlRepeatButton*>
( ControlById( EAknFepVkbCtrlIdArrowUpBtn ) );
CAknFepCtrlRepeatButton* arrowDownBtn = static_cast<CAknFepCtrlRepeatButton*>
( ControlById( EAknFepVkbCtrlIdArrowDownBtn ) );
CAknFepCtrlRepeatButton* arrowLeftBtn = static_cast<CAknFepCtrlRepeatButton*>
( ControlById( EAknFepVkbCtrlIdArrowLeftBtn ) );
CAknFepCtrlRepeatButton* arrowRightBtn = static_cast<CAknFepCtrlRepeatButton*>
( ControlById( EAknFepVkbCtrlIdArrowRightBtn ) );
CAknFepVkbCompositionField* compositionField = static_cast<CAknFepVkbCompositionField*>
(ControlById( EAknFepVkbCtrlIdCompositionField));
CFepCtrlDropdownList* dropdownList = static_cast<CFepCtrlDropdownList*>
(ControlById( EAknFepVkbCtrlIdCandidateList));
if ( iDataProvider->RequestData(EAknFepDataTypeIMLayout) == EAknFepVkbImCnZhuyin )
{
if ( aShowArrowKey )
{
compositionField->Hide(ETrue);
dropdownList->Hide(ETrue);
arrowUpBtn->Hide(EFalse);
arrowDownBtn->Hide(EFalse);
arrowLeftBtn->Hide(EFalse);
arrowRightBtn->Hide(EFalse);
}
else
{
arrowUpBtn->Hide(ETrue);
arrowDownBtn->Hide(ETrue);
arrowLeftBtn->Hide(ETrue);
arrowRightBtn->Hide(ETrue);
compositionField->Hide(EFalse);
dropdownList->Hide(EFalse);
}
}
else if( iDataProvider->RequestData(EAknFepDataTypeIMLayout) == EAknFepVkbImCnPinyin ||
iDataProvider->RequestData(EAknFepDataTypeIMLayout) == EAknFepVkbImCnStroke ||
iDataProvider->RequestData(EAknFepDataTypeIMLayout) == EAknFepVkbImCnCangjie )
{
compositionField->Hide(EFalse);
dropdownList->Hide(EFalse);
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::ReorganizeControls
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::ReorganizeControls(CAknFepVkbImLayout* aImLayout,
TBool aImLayoutChanged)
{
// First remove all controls in the group, but don't delete them
Reset(aImLayoutChanged);
// Then add controls according to the configuration of clientlayout
RPointerArray<CAknFepControlInfo>& controlList = aImLayout->ControlInfoList();
TInt count = controlList.Count();
TInt controlID = 0;
CFepUiBaseCtrl* ctrl = NULL;
TInt range = iDataProvider->RequestData(EAknFepDataTypeCurrentRange);
TInt curLanguage = iDataProvider->RequestData(EAknFepDataTypeInputLanguage);
TInt vkbLayoutId = GetDefaultVkbLayout(range);
CPeninputVkbLayoutInfo* vkbLayout = iLayoutPool->GetVkbLayout(vkbLayoutId);
TInt vkbRows = vkbLayout->Rows();
TInt vkbColumns = vkbLayout->Columns();
iLafMgr->SetLayoutType(iLafMgr->LayoutTypeFromRowsColumns(vkbRows,vkbColumns));
TPeninputCnCellType cellType = GetCellType(vkbColumns);
iCellAidGap = iLafMgr->CellAidGap(cellType);
TRect rect;
TInt btnWidth = iDataProvider->RequestData(EAknFepDataTypeUnitWidth);
TInt btnHeight = iDataProvider->RequestData(EAknFepDataTypeUnitHeight);
TInt layoutType = iDataProvider->RequestData(EAknFepDataTypeIMLayout);
TInt candidateHeight = 0;
if ( layoutType == EAknFepVkbImCnZhuyin )
{
candidateHeight = btnHeight;
}
else if (UiLayout()->PenInputType() != EPluginInputModeFSQ)
{
candidateHeight = iLafMgr->KeypadRect().Height() / vkbRows + 1;
}
else if (UiLayout()->PenInputType() == EPluginInputModeFSQ)
{
candidateHeight = iLafMgr->KeypadRect().Height() / vkbRows;
}
TSize size;
TInt width = UiLayout()->PenInputType() == EPluginInputModeFSQ ?
iLafMgr->EntirePaneRect().Width() : iLafMgr->KeypadRect().Width();
if (range == ERangeNative)
{
size = TSize( width,
iLafMgr->KeypadRect().Height()
+ ( aImLayout->Rows() - vkbRows - 1)*btnHeight
+ candidateHeight);
}
else
{
size = TSize( width,
iLafMgr->KeypadRect().Height()
+ ( aImLayout->Rows() - vkbRows)*btnHeight);
}
if (UiLayout()->PenInputType() == EPluginInputModeFSQ )
{
TRect screenrect;
AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen, screenrect);
size = screenrect.Size();
}
rect.SetSize( size );
//Set owner rect
SetWholeWindowRect(rect);
TInt needJustify = iDataProvider->RequestData(EAknFepDataTypeNeedBRJustify);
if (needJustify)
{
BottomRightJustify();
iDataProvider->SetData(EAknFepDataTypeNeedBRJustify, EFalse);
}
TPoint point = Rect().iTl;
TInt i = 0;
// Copy ctrl ID from ctrl pool
iRemainedPoolControlIDs.Reset();
for( i = 0; i < iCtrlPool->ControlCount(); i++ )
{
TInt id = iCtrlPool->ControlByIndex(i)->ControlId();
iRemainedPoolControlIDs.Append(id);
}
for (i=0;i<count;i++)
{
controlID = controlList[i]->ControlID();
ctrl = iCtrlPool->Control(controlID);
if ( ctrl )
{
TRAP_IGNORE(AddControlL(ctrl));
// Remove control IDs added to the control group in the array
TInt n = iRemainedPoolControlIDs.Find( controlID );
if( n != KErrNotFound)
iRemainedPoolControlIDs.Remove(n);
}
}
if ( iCtrlList.Count() != count )
{
return;
}
TRect optionRect;
TRect compositionRect;
TRect innerRect;
if (range == ERangeNative)
{
if ( layoutType == EAknFepVkbImCnZhuyin )
{
// Option Btn
optionRect.iTl = Rect().iTl;
optionRect.SetSize(TSize(btnWidth, btnHeight));
AknPenImageUtils::CalculateGraphicRect( optionRect, innerRect );
static_cast<CAknFepCtrlEventButton*>
(ControlById(EAknFepVkbCtrlIdTouchInputOption))->SizeChanged(optionRect,
innerRect,
ETrue);
TRect arrowRect;
TRect innerRect;
if ( UiLayout()->PenInputType() == EPluginInputModeFSQ )
{
arrowRect.iTl = TPoint( optionRect.iBr.iX, optionRect.iTl.iY );
arrowRect.SetSize(TSize(btnWidth + btnWidth, btnHeight));
AknPenImageUtils::CalculateGraphicRect( arrowRect, innerRect );
static_cast<CAknFepCtrlRepeatButton*>
( ControlById( EAknFepVkbCtrlIdArrowUpBtn ) )->SizeChanged(arrowRect,
innerRect,
ETrue);
arrowRect.iTl = TPoint(arrowRect.iBr.iX, arrowRect.iTl.iY);
arrowRect.SetSize(TSize(btnWidth + btnWidth, btnHeight));
AknPenImageUtils::CalculateGraphicRect( arrowRect, innerRect );
static_cast<CAknFepCtrlRepeatButton*>
( ControlById( EAknFepVkbCtrlIdArrowDownBtn ) )->SizeChanged(arrowRect,
innerRect,
ETrue);
arrowRect.iTl = TPoint(arrowRect.iBr.iX, arrowRect.iTl.iY);
arrowRect.SetSize(TSize(btnWidth + btnWidth, btnHeight));
AknPenImageUtils::CalculateGraphicRect( arrowRect, innerRect );
static_cast<CAknFepCtrlRepeatButton*>
( ControlById( EAknFepVkbCtrlIdArrowLeftBtn ) )->SizeChanged(arrowRect,
innerRect,
ETrue);
arrowRect.iTl = TPoint(arrowRect.iBr.iX, arrowRect.iTl.iY);
arrowRect.SetSize(TSize(btnWidth + btnWidth, btnHeight));
AknPenImageUtils::CalculateGraphicRect( arrowRect, innerRect );
static_cast<CAknFepCtrlRepeatButton*>
( ControlById( EAknFepVkbCtrlIdArrowRightBtn ) )->SizeChanged(arrowRect,
innerRect,
ETrue);
}
compositionRect.iTl = TPoint(optionRect.iBr.iX, optionRect.iTl.iY);
compositionRect.SetSize(TSize(btnWidth * 3 + iCellAidGap, candidateHeight));
}
else
{
compositionRect.iTl = Rect().iTl;
compositionRect.SetSize(TSize(btnWidth * 3 + iCellAidGap, candidateHeight));
}
iCompositionField->SetReady(ETrue);
iCompositionField->Hide(EFalse);
iCompositionField->SizeChanged(compositionRect);
TRect candidateRect;
candidateRect.iTl = TPoint(compositionRect.iBr.iX, compositionRect.iTl.iY);
candidateRect.SetSize(TSize(btnWidth * 6, candidateHeight));
static_cast<CFepCtrlDropdownList*>(ControlById( EAknFepVkbCtrlIdCandidateList))->
SizeChanged(btnWidth, candidateHeight, btnWidth, candidateRect.iTl);
if( iDropdownList && iDropdownList->Hiden() )
iDropdownList->Hide(EFalse);
ReorganizeZhuYinControls( ETrue );
}
else
{
// Hide composition field when is not native range, since
// Hide process also can deregister its tactile feedback
// area, or else click button '3' when it is dimmed will
// cause tactile feedback, because '3' is just at the same
// place in number range as the composition filed in the
// native range.
if (iCompositionField)
iCompositionField->Hide(ETrue);
if( iDropdownList && !iDropdownList->Hiden() )
iDropdownList->Hide(ETrue);
}
iVkbBoardLeftTop = Rect().iTl;
if (range == ERangeNative)
{
if( layoutType == EAknFepVkbImCnZhuyin )
{
iVkbBoardLeftTop = TPoint(optionRect.iTl.iX, optionRect.iBr.iY);
}
else
{
iVkbBoardLeftTop = TPoint(compositionRect.iTl.iX, compositionRect.iBr.iY);
}
}
//TPoint vkbLeftTop = iVkbBoardLeftTop;
iVkbBoardLeftTop.iX += UiLayout()->PenInputType() == EPluginInputModeFSQ ?
iLafMgr->KeypadRect().iTl.iX : 0;
// After update LAF data for grid gap feature, the keyboard height is cut.
// This modification affact FSQ window size.
TInt yAxisOffset = UiLayout()->PenInputType() == EPluginInputModeFSQ ?
3 : 0;
iVkbBoardLeftTop.iY += yAxisOffset;
TRect vkbRect = TRect( iVkbBoardLeftTop, iLafMgr->KeypadRect().Size() );
CPeninputVkbCtrlExt* vkbCtrl =
static_cast<CPeninputVkbCtrlExt*>(ControlById( EAknFepVkbCtrlIdVkbCtrl));
vkbCtrl->SetRect( vkbRect );
vkbCtrl->SetFont( iLafMgr->KeyTextFont() );
vkbCtrl->SetTextLineLayout( iLafMgr->KeyTextLayout() );
vkbCtrl->SetTextFormat( iLafMgr->KeyTextLayout() ); //Read laf
TInt tempHeightForFSQ = btnHeight;
if (UiLayout()->PenInputType() == EPluginInputModeFSQ )
{
tempHeightForFSQ = btnHeight + 3;
}
TPoint rangeBarRefPoint = TPoint(vkbRect.iTl.iX, vkbRect.iBr.iY);
rangeBarRefPoint.iY += yAxisOffset;
if (range != ERangeNative)
{
TRect shiftRect;
shiftRect.iTl = TPoint(Rect().iTl.iX, vkbRect.iBr.iY);
shiftRect.iTl.iY += yAxisOffset;
shiftRect.SetSize(TSize(btnWidth, tempHeightForFSQ));
AknPenImageUtils::CalculateGraphicRect( shiftRect, innerRect );
ControlById( EAknFepVkbCtrlIdShiftBtn)->SetReady(ETrue);
static_cast<CAknFepCtrlMultiModeButton*>(ControlById( EAknFepVkbCtrlIdShiftBtn))->
SizeChanged(shiftRect, innerRect, ETrue);
rangeBarRefPoint = TPoint(shiftRect.iBr.iX, shiftRect.iTl.iY);
}
TRect rangeBarRect;
//rangeBarRect.iTl = TPoint(shiftRect.iBr.iX, shiftRect.iTl.iY);
rangeBarRect.iTl = rangeBarRefPoint;
rangeBarRect.SetSize(TSize(btnWidth, tempHeightForFSQ));
static_cast<CAknFepCtrlRangeBar*>
(ControlById( EAknFepVkbCtrlIdRangeBar))->SizeChanged(rangeBarRect);
rangeBarRect =
static_cast<CAknFepCtrlRangeBar*>(ControlById( EAknFepVkbCtrlIdRangeBar))->Rect();
TRect spaceBtnRect;
TInt spaceWidthCount = 4;
/* if( range == ERangeNumber && UiLayout()->PenInputType() == EPluginInputModeFSQ )
{
spaceWidthCount = 5;
}*/
if (range == ERangeNative || curLanguage == ELangTaiwanChinese)
{
spaceWidthCount = (vkbLayoutId == EAknFepVkbVkbCnZhuyinInitial) ? 6 : 5;
}
TInt defaultIMLayout = iDataProvider->RequestData(EAknFepDataTypeDefaultIMLayout);
if (curLanguage == ELangTaiwanChinese &&
defaultIMLayout == EAknFepVkbImCnStroke && range != ERangeNative)
{
spaceWidthCount = 4;
}
spaceBtnRect.iTl = TPoint(rangeBarRect.iBr.iX, rangeBarRect.iTl.iY);
spaceBtnRect.SetSize(TSize(btnWidth * spaceWidthCount + iCellAidGap, tempHeightForFSQ));
//AknPenImageUtils::CalculateGraphicRect( spaceBtnRect, innerRect );
innerRect = spaceBtnRect;
TSize iconOffset = iLafMgr->GetSpaceIconOffset();
innerRect.Shrink( iconOffset );
static_cast<CAknFepCtrlEventButton*>
(ControlById(EAknFepVkbCtrlIdSpaceBtn))->SizeChanged(spaceBtnRect, innerRect, ETrue);
TRect spaceIconRect = innerRect;
spaceIconRect.Shrink( iLafMgr->GetSpaceSideIconWidth(), 0);
static_cast<CAknFepCtrlEventButton*>
(ControlById(EAknFepVkbCtrlIdSpaceBtn))->SetDraw3PieceFrameInfo(
TDraw3PiecesFrame(KAknsIIDQgnIndiInputSpaceL,
KAknsIIDQgnIndiInputSpaceMiddle,
KAknsIIDQgnIndiInputSpaceR,
spaceIconRect));
TRect returnBtnRect;
returnBtnRect.iTl = TPoint(spaceBtnRect.iBr.iX, spaceBtnRect.iTl.iY);
returnBtnRect.SetSize(TSize(btnWidth, tempHeightForFSQ));
AknPenImageUtils::CalculateGraphicRect( returnBtnRect, innerRect );
static_cast<CAknFepCtrlEventButton*>
(ControlById(EAknFepVkbCtrlIdEnterBtn))->SizeChanged(returnBtnRect, innerRect, ETrue);
TRect inputModeSwitchBtnRect;
inputModeSwitchBtnRect.iTl = TPoint(returnBtnRect.iBr.iX, returnBtnRect.iTl.iY);
inputModeSwitchBtnRect.SetSize(TSize(btnWidth, tempHeightForFSQ));
AknPenImageUtils::CalculateGraphicRect( inputModeSwitchBtnRect, innerRect );
static_cast<CAknFepCtrlEventButton*>
(ControlById(EAknFepVkbCtrlIdSwitchToHwrBtn))->SizeChanged(inputModeSwitchBtnRect,
innerRect,
ETrue);
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::Reset
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::Reset(TBool aImLayoutChanged)
{
iActiveCtrl = NULL;
iCtrlList.Reset();
if (aImLayoutChanged)
{
iVkbCtrl->Reset();
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::HandleControlEvent
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::HandleControlEvent(TInt aEventType,
CFepUiBaseCtrl* aCtrl,
const TDesC& aEventData)
{
TInt* data = (TInt*) aEventData.Ptr();
TInt layoutType = iDataProvider->RequestData(EAknFepDataTypeIMLayout);
switch (aEventType)
{
case EVkbEventResetShift:
LoopVkbLayout(EVkbCapslock, ETrue);
break;
case EVkbEventSetPermittedRange:
iRangeBar->SetPermittedRanges(*data);
break;
case EVkbEventPositionChanged:
{
TInt style = *( ( TUint16* ) aEventData.Ptr() );
CalculatePosition( style );
}
break;
//Events need to send to composition field
case EVkbEventWindowClose:
case EVkbEventCandidateSelected:
case EVkbEventCompFieldAnalysisResponse:
case EPeninputLayoutEventBack:
case EVkbEventKeySpace:
case EVkbEventKeyEnter:
case EEventVirtualKeyUp:
case EVkbEventLeftArrow:
case EVkbEventRightArrow:
{
TInt imLayout = iDataProvider->RequestData(EAknFepDataTypeIMLayout);
if ((imLayout == EAknFepVkbImCnStroke) && (aEventType == EVkbEventKeySpace))
{
TBuf<1> buf;
buf.Append(KStrokeSeparator);
iCompositionField->HandleControlEvent(aEventType,aCtrl,buf);
}
else if(((imLayout == EAknFepVkbImCnPinyin))
&& (aEventType == EVkbEventKeySpace))
{
TBuf<1> buf;
buf.Append(KPinyinSeparator);
iCompositionField->HandleControlEvent(aEventType,aCtrl,buf);
}
else
{
iCompositionField->HandleControlEvent(aEventType,aCtrl,aEventData);
}
}
break;
case EVkbEventCompFieldDataFlush:
UiLayout()->SignalOwner(ESignalKeyEvent,aEventData);
ClearCandidatesInList();
ReorganizeZhuYinControls( ETrue );
break;
case EVkbEventClearContent:
{
TBool isChineseInputting = EFalse;
TInt imLayout = iDataProvider->RequestData(EAknFepDataTypeIMLayout);
if(imLayout == EAknFepVkbImCnPinyin ||
imLayout == EAknFepVkbImCnZhuyin ||
imLayout == EAknFepVkbImCnStroke ||
imLayout == EAknFepVkbImCnCangjie)
{
isChineseInputting = ETrue;
}
if (isChineseInputting)
{
//Clear context in composition field
iCompositionField->HandleControlEvent(aEventType,aCtrl,aEventData);
}
//Clear all candidates in the list if needed
if ( layoutType!= EAknFepVkbImLatin )
{
if (isChineseInputting)
{
ClearCandidatesInList();
}
ReorganizeZhuYinControls( ETrue );
}
}
break;
case EVkbEventCompFieldNoChars:
//Clear all candidates in the list
ClearCandidatesInList();
ReorganizeZhuYinControls( ETrue );
break;
case EEventControlFocusGained:
if ( *data == ECompotisionFieldGetFocus )
{
iCompositionField->HandleControlEvent(aEventType,aCtrl,aEventData);
}
break;
case EEventControlFocusLost:
if ( ( aCtrl ) && ( aCtrl->ControlId() == EPeninputWindowCtrlIdMultiLineICF) )
{
iCompositionField->HandleControlEvent(aEventType,aCtrl,aEventData);
}
break;
//Events sent to composition field are over
case EVkbEventResetShiftCapslock:
// ChangeButtonStatus(EFalse, EAknFepVkbCtrlIdShiftBtn);
// ChangeButtonStatus(EFalse, EAknFepVkbCtrlIdCapslockBtn);
ChangeMergedButtonStatus(0, 0);
break;
case EVkbEventCandidatesChanged:
{
RPointerArray<HBufC>* list = (RPointerArray<HBufC>*)aCtrl;
if (list && iCompositionField->IsValidSpell() )
{
ReorganizeZhuYinControls( EFalse );
if(UiLayout()->PenInputType() == EPluginInputModeFSQ)
{
TRAP_IGNORE(iDropdownList->SetCandidatesL(*list,
CFepCtrlDropdownList::EListExpandableWithBubble));
}
else
{
TRAP_IGNORE(iDropdownList->SetCandidatesL(*list,
CFepCtrlDropdownList::EListExpandable));
}
}
else
{
ClearCandidatesInList();
// Not display arrow keys when composition field get focus
if(!(iCompositionField->IsFocused()))
{
ReorganizeZhuYinControls( ETrue );
}
}
}
break;
case EVkbEventGetNextPageCandidate:
{
RPointerArray<HBufC>* list = (RPointerArray<HBufC>*)aCtrl;
if (list)
{
TRAP_IGNORE(iDropdownList->AddCandidatesL(*list,
CFepCtrlDropdownList::EListExpandable));
}
}
break;
case EVkbEventComposition2Standby:
//Change vkb layout to standy ui state
if ( layoutType == EAknFepVkbImCnPinyin)
{
ChangeVkbLayout(EAknFepVkbVkbCnPinyinInitial);
}
else if ( layoutType == EAknFepVkbImCnZhuyin)
{
ChangeVkbLayout(EAknFepVkbVkbCnZhuyinInitial);
}
else if ( layoutType == EAknFepVkbImCnStroke || EAknFepVkbImCnCangjie)
{
iVkbCtrl->CancelDims();
}
break;
case EVkbEventStandby2Composition:
TRAP_IGNORE( HandleStandby2CompositionEventL() );
break;
default:
break;
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::CompositionFieldStringLength
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CAknFepVkbClientArea::CompositionFieldStringLength()
{
if ( iCurrentImLayout->FindControlInfo(EAknFepVkbCtrlIdCompositionField) )
{
if ( iCompositionField )
{
return iCompositionField->Length();
}
}
return 0;
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::GetDefaultVkbLayout
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TAknFepVkbLayout CAknFepVkbClientArea::GetDefaultVkbLayout(const TInt aRange)
{
TInt defaultIMLayout = iDataProvider->RequestData(EAknFepDataTypeDefaultIMLayout);
TInt curLanguage = iDataProvider->RequestData(EAknFepDataTypeInputLanguage);
TInt imLayout = iDataProvider->RequestData(EAknFepDataTypeIMLayout);
switch (aRange)
{
case ERangeNative:
{
switch (imLayout)
{
case EAknFepVkbImCnPinyin:
return EAknFepVkbVkbCnPinyinInitial;
case EAknFepVkbImCnZhuyin:
return EAknFepVkbVkbCnZhuyinInitial;
case EAknFepVkbImCnStroke:
return EAknFepVkbVkbCnStroke;
case EAknFepVkbImCnCangjie:
return EAknFepVkbVkbCnCangjie;
}
}
if (curLanguage == ELangTaiwanChinese && defaultIMLayout != EAknFepVkbImCnStroke)
{
return EAknFepVkbVkbLatinForZhuyin;
}
else
{
return EAknFepVkbVkbLatin;
}
case ERangeEnglish:
if (curLanguage == ELangTaiwanChinese && defaultIMLayout != EAknFepVkbImCnStroke)
{
return EAknFepVkbVkbLatinForZhuyin;
}
else
{
return EAknFepVkbVkbLatin;
}
case ERangeNumber:
if (curLanguage == ELangTaiwanChinese && defaultIMLayout != EAknFepVkbImCnStroke)
{
return EAknFepVkbVkbNumberForZhuyin;
}
else
{
return EAknFepVkbVkbNumber;
}
case ERangeSymbol:
return EAknFepVkbVkbSymbol;
case ERangeAccent:
{
TInt accent = iDataProvider->RequestData(EAknFepDataTypeCurrentAccent);
switch (accent)
{
case EAknFepVkbVkbAccented1:
return EAknFepVkbVkbAccented1;
case EAknFepVkbVkbAccented2:
return EAknFepVkbVkbAccented2;
case EAknFepVkbVkbAccented3:
return EAknFepVkbVkbAccented3;
default:
return EAknFepVkbVkbAccented1;
}
}
default:
if (curLanguage == ELangTaiwanChinese && defaultIMLayout != EAknFepVkbImCnStroke)
{
return EAknFepVkbVkbLatinForZhuyin;
}
else
{
return EAknFepVkbVkbLatin;
}
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::SetWholeWindowRect
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::SetWholeWindowRect(const TRect& aRect)
{
TRect rect = aRect;
TInt btnHeight = iDataProvider->RequestData(EAknFepDataTypeUnitHeight);
//rect.iTl.iY = rect.iTl.iY - iDataProvider->RequestData(EAknFepDataTypeUnitHeight) * 2;
TInt imLayout = iDataProvider->RequestData(EAknFepDataTypeIMLayout);
TInt titlebarHeight = iDataProvider->RequestData(EAknFepDataTypeTitleBarHeight);
rect.iTl.iY = aRect.iTl.iY - titlebarHeight;
iTopParent->SetRect(rect);
TPoint tl = TPoint( iTopParent->Rect().iTl.iX,
iTopParent->Rect().iTl.iY + titlebarHeight );
//rect.SetSize(TSize((10 * iUnitWidth), iDataProvider->RequestData(EAknFepDataTypeUnitHeight) * 2 + 6 * iUnitHeight));
SetRect( TRect( tl, iTopParent->Rect().iBr ) );
}
// ---------------------------------------------------------------------------
// CAknFepVkbWindow::CalculatePosition
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::CalculatePosition( TInt aJustifyMode )
{
switch ( aJustifyMode )
{
case EVkbPositionChangeBrJustify:
BottomRightJustify();
break;
case EVkbPositionChangeDataQuery:
//BottomRightJustify();
DataQueryJustify();
break;
/*case EVkbPositionChangeNone:
break;*/
default:
TopLeftJustify();
break;;
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::TopLeftJustify
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::TopLeftJustify()
{
// Read position from datamgr
TRect newRect = TRect(UiLayout()->Position(),UiLayout()->Rect().Size());
TPoint tl = UiLayout()->Position();
if (tl.iX < 0)
{
tl.iX = 0;
}
if (tl.iY < 0)
{
tl.iY = 0;
}
newRect.iTl = tl;
newRect.SetSize(iTopParent->Rect().Size());
if (newRect != UiLayout()->Rect())
{
//Write the new position into CenRep
TInt x = 0;
TInt y = 0;
x = 0x0000FFFF & newRect.iBr.iX;
y = 0xFFFF0000 & ( newRect.iBr.iY << 16 );
iDataProvider->SetData(EAknFepDataTypeWindowPosition,x | y);
}
//Set the layout position
UiLayout()->SetRect(newRect);
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::BottomRightJustify
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::BottomRightJustify()
{
if(UiLayout()->PenInputType() == EPluginInputModeFSQ)
{
return;
}
// Read position from datamgr
TRect newRect = TRect(UiLayout()->Position(),UiLayout()->Rect().Size());
TPoint oldbr,br;
TPoint tl;
TSize screenSize;
TInt screenSizeData = iDataProvider->RequestData(EAknFepDataTypeScreenSize);
screenSize.iWidth = screenSizeData & 0x0000FFFF;
screenSize.iHeight = ( screenSizeData & 0xFFFF0000 ) >> 16;
TRect screenRect = TRect(TPoint(0,0),screenSize);
TInt windowPosition = iDataProvider->RequestData(EAknFepDataTypeWindowPosition);
oldbr.iX = windowPosition & 0x0000FFFF;
oldbr.iY = ( windowPosition & 0xFFFF0000 ) >> 16;
br = oldbr;
if ( !screenRect.Contains(br) )
{
if (screenSize.iWidth < br.iX)
{
br.iX = screenSize.iWidth;
}
if (screenSize.iHeight < br.iY)
{
br.iY = screenSize.iHeight;
}
}
// Check the top left point is in screen
tl.iX = br.iX - UiLayout()->Rect().Width();
if (tl.iX < 0)
{
tl.iX = 0;
}
tl.iY = br.iY - UiLayout()->Rect().Height();
if (tl.iY < 0)
{
tl.iY = 0;
}
if (UiLayout()->PenInputType() == EPluginInputModeFSQ)
{
tl.iX = 0;
tl.iY = 0;
}
newRect.iTl = tl;
newRect.SetSize(UiLayout()->Rect().Size());
if (oldbr != newRect.iBr)
{
//Write the new position into CenRep
TInt x = 0;
TInt y = 0;
x = 0x0000FFFF & newRect.iBr.iX;
y = 0xFFFF0000 & ( newRect.iBr.iY << 16 );
iDataProvider->SetData(EAknFepDataTypeWindowPosition,x | y);
//Set the layout position
UiLayout()->SetRect(TRect(tl,newRect.Size()));
}
//Set the layout position
UiLayout()->SetRect(newRect);
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::DataQueryJustify
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::DataQueryJustify()
{
TRect* dataQueryRect = (TRect*) (iDataProvider->RequestData(EAknFepDataTypeDataQueryRect));
TRect rect = TRect(UiLayout()->Position(),UiLayout()->Rect().Size());
CCoeEnv* coeEnv = CCoeEnv::Static();
TPixelsTwipsAndRotation ptSize;
coeEnv->ScreenDevice()->GetDefaultScreenSizeAndRotation(ptSize);
// Landscape mode: move window to the br of the screen
if (ptSize.iPixelSize.iWidth > ptSize.iPixelSize.iHeight)
{
rect.SetRect(ptSize.iPixelSize.iWidth - rect.Width(),
ptSize.iPixelSize.iHeight/2 - rect.Height()/2,
ptSize.iPixelSize.iWidth,
ptSize.iPixelSize.iHeight/2 + rect.Height()/2);
}
// Portrait mode: dodge the dataquery
else if ( rect.Intersects(*dataQueryRect) )
{
TInt Y = dataQueryRect->iTl.iY;
TInt height = rect.iBr.iY - rect.iTl.iY;
rect.iTl.iY = Y - height;
rect.iBr.iY = Y;
if( rect.iTl.iY <0 )
{
rect.iTl.iY = 0;
rect.iBr.iY = height;
}
}
//Write the new position into CenRep
TInt x = 0;
TInt y = 0;
x = 0x0000FFFF & rect.iBr.iX;
y = 0xFFFF0000 & ( rect.iBr.iY << 16 );
iDataProvider->SetData(EAknFepDataTypeWindowPosition,x | y);
//Set the layout position
UiLayout()->SetRect(rect);
/*
TInt fontHeight = aData & 0x0000FFFF;
TInt bottomY = ( aData & 0xFFFF0000 ) >> 16;
if ( ( (bottomY - fontHeight) >= UiLayout()->Rect().iBr.iY )
|| ( (bottomY + fontHeight) <= UiLayout()->Rect().iTl.iY ) )
{
return;
}
else
{
tl = UiLayout()->Rect().iTl;
br = UiLayout()->Rect().iBr;
TInt middleY = UiLayout()->Rect().iTl.iY + UiLayout()->Rect().Height() / 2;
if ( middleY <= bottomY )
{
br.iY = bottomY - fontHeight;
tl.iY = br.iY - UiLayout()->Rect().Height();
if (tl.iY < 0) // Then skip to the bottom of the current editor
{
tl.iY = bottomY + fontHeight;
br.iY = tl.iY + UiLayout()->Rect().Height();
}
}
else
{
tl.iY = bottomY + fontHeight;
br.iY = tl.iY + UiLayout()->Rect().Height();
if (br.iY > screenSize.iHeight)
{
br.iY = bottomY - fontHeight;
tl.iY = br.iY - UiLayout()->Rect().Height();
}
}
TInt x = 0;
TInt y = 0;
x = 0x0000FFFF & br.iX;
y = 0xFFFF0000 & ( br.iY << 16 );
iDataProvider->SetData(EAknFepDataTypeWindowPosition,x | y);
}
*/
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::SetTopParent
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::SetTopParent(CFepUiBaseCtrl* aParent)
{
iTopParent = aParent;
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::AddDropdownListL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::AddDropdownListL()
{
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC(reader,R_AKN_FEP_VKB_DROP_DOWN_LIST);
if (!iDataProvider->UnitShadowSizeSet())
{
iDataProvider->ReadUnitShadowSize();
}
TInt btnWidth = iDataProvider->RequestData(EAknFepDataTypeUnitWidth);
TInt btnHeight = iDataProvider->RequestData(EAknFepDataTypeUnitHeight);
TAknTextLineLayout listText =
AknLayoutScalable_Avkon::cell_vkb_candidate_pane_t1().LayoutLine();
TDropdownListDrawInfo candiDrawInfo(KAknsIIDQsnFrFunctionButtonInactive,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrItutButtonCandiSideL,
KAknsIIDQsnFrItutButtonCandiMiddle,
KAknsIIDQsnFrItutButtonCandiSideR,
KAknsIIDQsnFrItutButtonCandiPressedSideL,
KAknsIIDQsnFrItutButtonCandiPressedMiddle,
KAknsIIDQsnFrItutButtonCandiPressedSideR,
TRgb(194, 221, 242),
ETrue);
iDropdownList = CFepCtrlDropdownList::NewL(TPoint(0,btnWidth),
UiLayout(),
EAknFepVkbCtrlIdCandidateList,
reader,
0,
0,
btnWidth,
6,
4,
AknLayoutUtils::FontFromId(listText.iFont, NULL),
NULL,
CGraphicsContext::ECenter,
3,
KRgbBlack, // border color
TRgb(0xeeeeee), // content bg color
KRgbWhite, // navi bg color
AKN_LAF_COLOR_STATIC(listText.iC),
KRgbRed);
iDropdownPropertySet = ETrue;
iDropdownList->SetResourceId(R_AKN_FEP_VKB_DROP_DOWN_LIST);
iDropdownList->SetEventIdForCandidateSelected(EVkbEventCandidateSelected);
iDropdownList->SetEventIdForNextPageCandidate(EVkbEventGetNextPageCandidate);
iDropdownList->SetEventIdForPreviousPageCandidate(EVkbEventGetPreviousPageCandidate);
iDropdownList->SetEventIdForCandidateExisted(EVkbEventQueryCandidateExisted);
iDropdownList->SetDropdownListImgID(candiDrawInfo);
//iDropdownList->AddEventObserver(UiLayout());
CleanupStack::PopAndDestroy(); // reader
if ( iCtrlPool )
{
iCtrlPool->AddControl(iDropdownList);
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::AddButtonL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CAknFepCtrlEventButton* CAknFepVkbClientArea::AddButtonL(const TInt aControlId,
const TInt aEventId,
const TInt aResId,
const TInt aUnicode,
const TBool aIsRepeat)
{
CAknFepCtrlEventButton* button = NULL;
if ( aIsRepeat )
{
button = CAknFepCtrlRepeatButton::NewL( UiLayout(),
aControlId,
aEventId,
aUnicode,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive);
}
else
{
button = CAknFepCtrlEventButton::NewL(UiLayout(),
aControlId,
aEventId,
aUnicode,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive);
}
if ( button )
{
// Read resource
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC(reader, aResId);
button->SetResourceId( aResId );
button->ConstructFromResourceL();
CleanupStack::PopAndDestroy(); // reader
// Add into the control pool
if ( iCtrlPool )
{
iCtrlPool->AddControl(button);
}
}
return button;
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::AddRangeBarL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::AddRangeBarL()
{
// Range bar
iRangeBar = CAknFepCtrlRangeBar::NewL(UiLayout(),
EAknFepVkbCtrlIdRangeBar,
CAknFepCtrlRangeBar::EBtnGroupHorizontal);
iRangeBar->SetActionStyle( CAknFepCtrlRangeBar::ERangeBarActionStyleHighLight );
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC(reader, R_AKN_FEP_VKB_RANGE_LIST);
iRangeBar->ConstructFromResourceL(reader);
CleanupStack::PopAndDestroy(); // reader
//Set event id
iRangeBar->SetEventIdForRange(EVkbEventSetRange);
iCtrlPool->AddControl(iRangeBar);
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::ChangeMergedButtonStatus
// (other items were commented in a header)
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::ChangeMergedButtonStatus(
const TInt aIsShiftCase,
const TInt aIsCapslockCase )
{
CAknFepCtrlMultiModeButton* button =
static_cast<CAknFepCtrlMultiModeButton*>
(ControlById( EAknFepVkbCtrlIdShiftBtn ) );
if( !button )
{
return;
}
switch ( aIsCapslockCase * 2 + aIsShiftCase )
{
case 1: // text case
{
TRAP_IGNORE( button->SetCurrentModeL( EBtnBmpActive, 1 ) );
button->SetHighlight( ETrue );
}
break;
case 2: // upper case
{
TRAP_IGNORE( button->SetCurrentModeL( EBtnBmpActive, 2 ) );
button->SetHighlight( ETrue );
}
break;
default:
{
TRAP_IGNORE( button->SetCurrentModeL( EBtnBmpActive, 0 ) );
button->SetHighlight( EFalse );
}
break;
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::CompositionField
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CFepLayoutEditAreaBase* CAknFepVkbClientArea::CompositionField()
{
if ( iCurrentImLayout && iCurrentImLayout->FindControlInfo(EAknFepVkbCtrlIdCompositionField) )
{
return iCompositionField;
}
return NULL;
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::AddControlL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::AddControlL(CFepUiBaseCtrl* aControl)
{
//do nothing if we already has the control.
if(KErrNotFound != iCtrlList.Find(aControl))
return;
if(aControl)
{
aControl->SetReady( Ready() );
iCtrlList.AppendL(aControl);
RRegion region(8);
region.Copy(Region());
region.AddRect(aControl->Rect());
SetRegion(region);
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::DimKeys
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::DimKeys()
{
TRAP_IGNORE(DimKeysL());
}
void CAknFepVkbClientArea::DimKeysL()
{
iVkbCtrl->CancelDims();
TInt currentRange = iDataProvider->RequestData(EAknFepDataTypeCurrentRange);
TInt permitRange = iDataProvider->RequestData(EAknFepDataTypePermittedRange);
if ( (currentRange == ERangeNumber )
&& ( permitRange == ERangeNumber ) )
{
TInt keyMapping = iDataProvider->RequestData(EAknFepDataTypeNumericKeymap);
HBufC* rs = NULL;
if ( keyMapping == EKeymapFromResource )
{
HBufC* customRes =
(HBufC*) iDataProvider->RequestData(EAknFepDataTypeUseDefinedResource);
_LIT(KTenNumbers,"0123456789");
rs = HBufC::NewL(KTenNumbers().Length() + customRes->Length());
rs->Des().Copy(*customRes);
rs->Des().Append(KTenNumbers);
iVkbCtrl->DimKeys(rs);
}
else
{
rs = iKeyMappingMgr->KeyMappingStringL(keyMapping);
iVkbCtrl->DimKeys(rs);
}
delete rs;
}
iVkbCtrl->Draw();
UpdateArea(iVkbCtrl->Rect(), EFalse);
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::ClearCandidatesInList
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::ClearCandidatesInList()
{
RPointerArray<HBufC> candidates;
if(UiLayout()->PenInputType() == EPluginInputModeFSQ)
{
TRAP_IGNORE(iDropdownList->SetCandidatesL(candidates,
CFepCtrlDropdownList::EListNoExpandableWithBubble));
}
else
{
TRAP_IGNORE(iDropdownList->SetCandidatesL(candidates,
CFepCtrlDropdownList::EListNoExpandable));
}
iDataProvider->SetData(EAknFepDataTypeCandidateCount,0);
candidates.Close();
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::NeedCreateWord
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TBool CAknFepVkbClientArea::NeedCreateWord()
{
return iCompositionField->NeedCreateWord();
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::SetNextCandidateExistFlag
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::SetNextCandidateExistFlag(TBool aFlag)
{
iDropdownList->SetFlagCandidateExist(aFlag);
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::ConstructFromResourceL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::ConstructFromResourceL()
{
CControlGroup::ConstructFromResourceL();
// Construct for rest controls not in the control group
for(TInt i = 0; i < iRemainedPoolControlIDs.Count(); i++ )
{
iCtrlPool->Control( iRemainedPoolControlIDs[i] )->ConstructFromResourceL();
}
if( iVkbLayout )
{
if( iVkbCtrl->IsIrregularKeyBoard() )
iVkbLayout->ConstructFromIrregularResourceL();
else
iVkbLayout->ConstructFromNonIrregularResourceL();
SetVkbLayoutSize( iVkbLayoutId );
}
// iVkbLayout->ConstructFromResourceL();
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::SetEnableSwitchToHwr
// (other items were commented in a header)
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::SetEnableSwitchToHwr(TBool aEnable)
{
CAknFepCtrlEventButton* switchToHwrBtn = static_cast<CAknFepCtrlEventButton*>
( iCtrlPool->Control( EAknFepVkbCtrlIdSwitchToHwrBtn ) );
if ( aEnable )
{
switchToHwrBtn->SetDimmed(EFalse);
}
else
{
switchToHwrBtn->SetDimmed(ETrue);
switchToHwrBtn->SetActive(EFalse);
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::ActiveCurrentRange
// (other items were commented in a header)
// ---------------------------------------------------------------------------
//
void CAknFepVkbClientArea::ActiveCurrentRange()
{
TInt curRange = iDataProvider->RequestData(EAknFepDataTypeCurrentRange);
if ( iRangeBar )
{
iRangeBar->SetRange(curRange);
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbClientArea::GetCreatedWordSpell
// (other items were commented in a header)
// ---------------------------------------------------------------------------
//
TPtrC CAknFepVkbClientArea::GetCreatedWordSpell()
{
return iCompositionField->GetCreatedWordSpell();
}
TPeninputCnCellType CAknFepVkbClientArea::GetCellType(TInt aColumns)
{
/* TInt curRange = iDataProvider->RequestData(EAknFepDataTypeCurrentRange);
TBool zhuyinIm = iDataProvider->RequestData(EAknFepDataTypeIMLayout) == EAknFepVkbImCnZhuyin;
TPeninputCnCellType cellType;
if( UiLayout()->PenInputType() == EPluginInputModeFSQ )
{
cellType = ( aColumns == 10 )? EVkbCangjieAndPinying_FSQ : EVkbZhuyin_FSQ;
}
else if( UiLayout()->PenInputType() == EPluginInputModeVkb )
{
if (curRange == ERangeEnglish)
{
cellType = EVkbLatin;
}
if (curRange == ERangeNumber)
{
cellType = EVkbNumber;
}
if (curRange == ERangeAccent)
{
cellType = EVkbAccent;
}
else
{
cellType = ( zhuyinIm )? EVkbZhuyin : EVkbCangjieAndPinying;
}
}*/
TInt curLanguage = iDataProvider->RequestData(EAknFepDataTypeInputLanguage);
TPeninputCnCellType cellType = EVkbCangjieAndPinying;
if( UiLayout()->PenInputType() == EPluginInputModeFSQ )
{
if (aColumns == 10)
{
cellType = EVkbCangjieAndPinying_FSQ;
}
else if(aColumns == 11)
{
cellType = EVkbZhuyin_FSQ;
}
}
else
{
if (aColumns == 10)
{
cellType = EVkbCangjieAndPinying;
}
else if(aColumns == 11)
{
cellType = EVkbZhuyin;
}
}
return cellType;
}
void CAknFepVkbClientArea::ShowBubble(TBool aShow)
{
if (iVkbCtrl)
{
iVkbCtrl->ShowBubble(aShow);
}
if(iDropdownList)
{
iDropdownList->ShowBubble(aShow);
}
}
void CAknFepVkbClientArea::DimArrowKeys( TBool aDimArrow )
{
static_cast<CAknFepCtrlRepeatButton*>
( iCtrlPool->Control( EAknFepVkbCtrlIdArrowUpBtn ) )->SetDimmed(aDimArrow);
static_cast<CAknFepCtrlRepeatButton*>
( iCtrlPool->Control( EAknFepVkbCtrlIdArrowDownBtn ) )->SetDimmed(aDimArrow);
static_cast<CAknFepCtrlRepeatButton*>
( iCtrlPool->Control( EAknFepVkbCtrlIdArrowLeftBtn ) )->SetDimmed(aDimArrow);
static_cast<CAknFepCtrlRepeatButton*>
( iCtrlPool->Control( EAknFepVkbCtrlIdArrowRightBtn ) )->SetDimmed(aDimArrow);
}
void CAknFepVkbClientArea::HandleStandby2CompositionEventL()
{
TInt layoutType = iDataProvider->RequestData(EAknFepDataTypeIMLayout);
//Change vkb layout to composition ui state
ReorganizeZhuYinControls( EFalse );
if ( layoutType == EAknFepVkbImCnPinyin)
{
ChangeVkbLayout(EAknFepVkbVkbCnPinyinComposition);
}
else if ( layoutType == EAknFepVkbImCnZhuyin)
{
ChangeVkbLayout(EAknFepVkbVkbCnZhuyinComposition);
}
else if ( layoutType == EAknFepVkbImCnStroke || EAknFepVkbImCnCangjie)
{
HBufC* symbolNumSet = HBufC::NewLC( KLengthSymbolNeedToFilter );
for (TInt index = 0; index < KLengthSymbolNeedToFilter; index ++)
{
symbolNumSet->Des().Append( KSymbolsNeedToFilter[index] );
}
iVkbCtrl->DimKeySet( symbolNumSet, ETrue );
CleanupStack::PopAndDestroy( symbolNumSet );
}
}
// End Of File