/*
* 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: Implementation of vkb window class
*
*/
// System includes
#include <peninputvkbwindow.rsg>
#include <peninputvkbwindowconfiginfo_01.rsg>
#include <aknfeppeninputenums.h>
#include <peninputinputcontextfield.h>
#include <peninputpluginutils.h>
#include <peninputcommonlayoutext.h>
#include <peninputvkbctrllayout.h>
#include <peninputvkbctrlext.h>
#include <peninputeventbutton.h>
#include <peninputdragbutton.h>
#include <peninputrepeatbutton.h>
#include <peninputmultimodebutton.h>
#include <peninputrangebar.h>
#include <peninputdataconverter.h>
#include <peninputdataprovider.h>
#include <peninputclientlayoutinfo.h>
#include <peninputlayoutchoicelist.h>
#include <peninputlongpressbutton.h>
#include <bautils.h>
#include <aknlayoutscalable_apps.cdl.h>
#include <peninputlayoutbubblectrl.h>
#include <peninputscrollablelist.h>
#include <e32keys.h>
#include <AknIconUtils.h>
#include <AknLayoutDef.h>
#include <AknUtils.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <AknsUtils.h>
#include <AknFepGlobalEnums.h>
#include <peninputlayoutinputmodechoice.h>
#include <peninputlayoutmultilineicf.h>
#include <s32mem.h>
// User includes
#include "peninputgenericvkb.hrh"
#include "peninputgenericvkbwindow.h"
#include "peninputgenericvkbenum.h"
#include "peninputrangebarinfo.h"
#include "peninputgenericvkblafdatamgr.h"
#include "peninputgenericvkblangmeritpair.h"
#include "peninputgenericvkblayout.h"
// Constants
const TInt KPeninputVkbWndInvalidIndex = -1;
const TInt KInvalidImg = -1 ;
const TInt KKeyCodeSize = 1;
const TInt KTooltipLeftMargin = 10;
const TInt KTooltipTopMargin = 0;
const TInt KTooltipRightMargin = 10;
const TInt KTooltipBottomMargin = 0;
_LIT( KVkbWindowResourceFile,
"z:\\resource\\plugins\\peninputvkbwindow.RSC" );
_LIT( KConfigurationResourceFile,
"z:\\resource\\plugins\\peninputvkbwindowconfiginfo_" );
_LIT( KResourceFileExtName, ".RSC" );
_LIT(KEmptyString, "");
// ======== MEMBER FUNCTIONS ========
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::CPeninputGenericVkbWindow
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
CPeninputGenericVkbWindow::CPeninputGenericVkbWindow(
CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext,
MPeninputUiStateMgr* aUiStateMgr )
: CPeninputLayoutWindowExt( aUiLayout, aLayoutContext ),
iUiStateMgr(aUiStateMgr),
iPopupInited(EFalse),
iPopupSet(EFalse),
iLafMgr(NULL),
iFirstConstruct(ETrue),
iIndiWithText( EFalse ),
iUSRscFileExist( EFalse )
{
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::NewL
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
CPeninputGenericVkbWindow* CPeninputGenericVkbWindow::NewL(
CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext,
MPeninputUiStateMgr* aUiStateMgr )
{
CPeninputGenericVkbWindow* self =
new ( ELeave ) CPeninputGenericVkbWindow( aUiLayout, aLayoutContext, aUiStateMgr );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::~CPeninputGenericVkbWindow
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
CPeninputGenericVkbWindow::~CPeninputGenericVkbWindow()
{
delete iIdle;
iUnits.Close();
delete iLafMgr;
iLafMgr = NULL;
delete iBmpRotator;
iAccentCmdList.Close();
}
void CPeninputGenericVkbWindow::ConstructL()
{
iHandleRangeShortPress = ETrue;
iBmpRotator = CPeninputSyncBitmapRotator::NewL();
iLafMgr = CPeninputGenericVkbLafMgr::NewL();
iLafMgr->SetInputModeL(TPluginInputMode (iLayoutContext->LayoutType()));
CPeninputLayoutWindowExt::ConstructL();
// Save whether American rsc file exist or not
TBuf<KMaxFileLength> usUSRscFileName;
usUSRscFileName= KConfigurationResourceFile();
usUSRscFileName.AppendNum( ELangAmerican );
usUSRscFileName.Append( KResourceFileExtName );
RFs fileSession;
User::LeaveIfError( fileSession.Connect() );
CleanupClosePushL( fileSession );
if ( BaflUtils::FileExists( fileSession , usUSRscFileName ))
{
iUSRscFileExist = ETrue;
}
CleanupStack::PopAndDestroy( 1 );
// For addition of ITI features, add a candidate list in vkb window
CreateCandidateListL();
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::HandleControlEvent
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::HandleControlEvent( TInt aEventType,
CFepUiBaseCtrl* aCtrl,
const TDesC& aEventData )
{
// Call this function in base class
CPeninputLayoutWindowExt::HandleControlEvent( aEventType, aCtrl,
aEventData );
TInt* data = ( TInt* ) aEventData.Ptr();
switch ( aEventType )
{
case EPeninputLayoutEventMultiRange:
{
if ( aCtrl->ControlId() == EPeninutWindowCtrlIdMultiRangeBtn )
{
if ( iHandleRangeShortPress )
{
HandleRangeButtonShortPress();
}
}
iHandleRangeShortPress = ETrue;
}
break;
case EPeninputLayoutEventMultiRangeLongPress:
{
if ( aCtrl->ControlId() == EPeninutWindowCtrlIdMultiRangeBtn )
{
// Before pop up list, cancel down event, and set range button un-highlight.
TRAP_IGNORE( aCtrl->CancelPointerDownL());
static_cast<CAknFepCtrlCommonButton*>(aCtrl)->SetHighlight( EFalse );
PopupChoiceList();
}
}
break;
case EPeninputLayoutVkbEventResetShift:
{
HandleShiftAndCapslockBtnClicked();
}
break;
case EPenInputLayoutEventClosePopup:
{
if ( iPopupWnd && !iPopupWnd->Hiden() )
{
iPopupWnd->CloseWindow();
if ( iLayoutContext->LayoutType() != EPluginInputModeFSQ )
{
ResetAccentButton();
}
iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );
}
}
break;
case EEventChoiceSelected:
{
CFepUiBaseCtrl* btn = Control( EPeninutWindowCtrlIdMultiRangeBtn );
if ( btn )
{
iHandleRangeShortPress = EFalse;
TRAP_IGNORE( btn->HandlePointerUpEventL( btn->Rect().iBr ) );
iHandleRangeShortPress = ETrue;
}
CFepLayoutChoiceList::SEvent* event =
( CFepLayoutChoiceList::SEvent* ) aEventData.Ptr();
if ( event->iIndex != KPeninputVkbWndInvalidIndex )
{
if (aCtrl->ControlId() == EPeninutWindowCtrlIdAccentPopupWindow)
{
if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
TRAP_IGNORE( HandleRangeListSelectedL( aCtrl, aEventData ));
}
else
{
TInt currentRange = CPeninputDataConverter::AnyToInt(
iLayoutContext->RequestData(EPeninputDataTypeCurrentRange));
TInt currentAccent = CPeninputDataConverter::AnyToInt(
iLayoutContext->RequestData(EPeninputDataTypeCurrentAccent));
if ((currentRange == ERangeAccent) && (currentAccent == event->iIndex))
{
iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );
return;
}
iLayoutContext->SetData( EPeninputDataTypeCurrentAccent, &(event->iIndex));
// Active range, update rangebar and vkb layout
//ChangeRange( ERangeAccent, EPeninputVkbLayoutAccented1 + 2 * event->iIndex);
(currentRange == ERangeAccent) ? ChangeRange(ERangeAccent,
EPeninputVkbLayoutAccented1 + 2 * event->iIndex, EFalse) :
ChangeRange(ERangeAccent,
EPeninputVkbLayoutAccented1 + 2 * event->iIndex, ETrue);
}
}
else if (aCtrl->ControlId() == EPeninutWindowCtrlIdSwitcherPopupWindow)
{
if (iLayoutContext->LayoutType() != event->iCommand)
{
TBool switchByMode = ETrue;
TInt mode = event->iCommand;
TBuf<8> buf;
buf.Append(reinterpret_cast<TText*>(&switchByMode),
sizeof(TBool)/sizeof(TText));
buf.Append(reinterpret_cast<TText*>(&mode), sizeof(TInt)/sizeof(TText));
UiLayout()->SignalOwner(ESignalLayoutUIChanged,buf);
}
}
else if ( aCtrl->ControlId() == EPentinputHwrCandidateList )
{
TRAP_IGNORE( HandleCandidateListSelectedL( aCtrl, aEventData ) );
}
}
else
{
if ( iLayoutContext->LayoutType() != EPluginInputModeFSQ )
{
ResetAccentButton();
}
}
iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );
}
break;
case EPeninputLayoutEventToHwr:
{
TRAP_IGNORE( UpdateICFTextL() );
TRAP_IGNORE(PopupSwitchWindowL());
}
break;
case EEventVirtualKeyLatched:
{
HandleVirtualKeyLatchedEvent(aEventType, aCtrl, aEventData);
}
break;
case EEventVirtualKeyUnLatched:
{
HBufC* newCharBuf = HBufC::New( 2*iNewDeadKeyBuf.Length() );
if( newCharBuf )
{
CPeninputGenericVkbLayout* layout
= static_cast<CPeninputGenericVkbLayout*>( UiLayout() );
if( layout->IsEnableITIOnFSQ() )
{
// If ITI is open, double same keys should be send for one dead key,
// core will handle them as one key.
newCharBuf->Des().Append( iNewDeadKeyBuf );
}
newCharBuf->Des().Append( iNewDeadKeyBuf );
}
// Submit DeadKey
UiLayout()->SignalOwner(ESignalKeyEvent, *newCharBuf);
delete newCharBuf;
TBool deadKeyChange = EFalse;
iLayoutContext->SetData(EAkninputDataTypeLatchedSet, &deadKeyChange);
iNewDeadKeyBuf = KNullDesC;
}
break;
case EPeninputLayoutEventBack:
{
TInt latchedFlag = CPeninputDataConverter::AnyToInt
(iLayoutContext->RequestData(EAkninputDataTypeLatchedSet));
// If one DeadKey is latched, only unlatch the DeadKey and reset the iNewDeadKeyBuf
// Don't delete the visible charater in ICF
if(latchedFlag)
{
UnLatchDeadKey(iNewDeadKeyBuf);
TBool deadKeyChange = EFalse;
iLayoutContext->SetData(EAkninputDataTypeLatchedSet, &deadKeyChange);
iNewDeadKeyBuf = KNullDesC;
}
}
break;
case EPeninputLayoutEventEnter:
case EPeninputLayoutEventSpace:
{
TInt latchedFlag = CPeninputDataConverter::AnyToInt
(iLayoutContext->RequestData(EAkninputDataTypeLatchedSet));
if(latchedFlag)
{
HBufC* newCharBuf = HBufC::New( aEventData.Length() + 2*iNewDeadKeyBuf.Length() );
if( newCharBuf )
{
CPeninputGenericVkbLayout* layout
= static_cast<CPeninputGenericVkbLayout*>( UiLayout() );
if( layout->IsEnableITIOnFSQ() )
{
// If ITI is open, double same keys should be send for one dead key,
// core will handle them as one key.
newCharBuf->Des().Append( iNewDeadKeyBuf );
}
newCharBuf->Des().Append( iNewDeadKeyBuf );
newCharBuf->Des().Append( aEventData );
}
UnLatchDeadKey(iNewDeadKeyBuf);
TBool deadKeyChange = EFalse;
iLayoutContext->SetData(EAkninputDataTypeLatchedSet, &deadKeyChange);
// Submit DeadKey + Space or Enter at the same time
if( newCharBuf != NULL )
{
UiLayout()->SignalOwner(ESignalKeyEvent,*newCharBuf);
}
iNewDeadKeyBuf = KNullDesC;
delete newCharBuf;
}
}
break;
/* case EPeninputLayoutEventLeftArrow:
SimulateRawEvent(EStdKeyLeftArrow,TRawEvent::EKeyDown);
SimulateRawEvent(EStdKeyLeftArrow,TRawEvent::EKeyUp);
break;
case EPeninputLayoutEventRightArrow:
SimulateRawEvent(EStdKeyRightArrow,TRawEvent::EKeyDown);
SimulateRawEvent(EStdKeyRightArrow,TRawEvent::EKeyUp);
break;*/
default:
break;
}
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::SimulateRawEvent
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::SimulateRawEvent(TInt aScanCode, TRawEvent::TType aType)
{
TRawEvent event;
event.Set(aType,aScanCode);
TPtrC eventPtr(reinterpret_cast<const TUint16*>(&event),sizeof(event)/sizeof(TUint16));
UiLayout()->SignalOwner(ESignalSimulateEvent,eventPtr);
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::GetWindowConfigResId
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
TInt CPeninputGenericVkbWindow::GetWindowConfigResId()
{
return R_PENINPUT_LAYOUT_CONFIG_INFO;
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::GetWindowResId
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
TInt CPeninputGenericVkbWindow::GetWindowResId()
{
if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
return R_PENINPUT_LAYOUT_FSQ_WINDOW_INFO;
}
return R_PENINPUT_LAYOUT_VKB_WINDOW_INFO;
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::GetNumKeymappingResId
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
TInt CPeninputGenericVkbWindow::GetNumKeymappingResId()
{
return R_PENINPUT_LAYOUT_KEY_MAPPING_STRING_LIST;
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::GetWindowConfigResFileName
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
const TDesC& CPeninputGenericVkbWindow::GetWindowConfigResFileName(
TInt aLangID )
{
if ( aLangID <= 0 )
{
return KNullDesC;
}
if ( aLangID == ELangFrench )
{
TBuf<KMaxFileLength> canadianfrenchresfilename;
canadianfrenchresfilename= KConfigurationResourceFile();
canadianfrenchresfilename.AppendNum( ELangCanadianFrench );
canadianfrenchresfilename.Append( KResourceFileExtName );
RFile file;
TInt rs = file.Open( CCoeEnv::Static()->FsSession(),canadianfrenchresfilename, EFileRead );
if ( rs == KErrNone )
{
file.Close();
aLangID = ELangCanadianFrench;
}
}
// If US Rsc file exist, use it instead of English rsc file
if(( aLangID == ELangEnglish ) && ( iUSRscFileExist ))
{
aLangID = ELangAmerican;
}
iResourceFilename.Zero();
// Generate resource file name according to language id
iResourceFilename = KConfigurationResourceFile();
if ( aLangID < 10 )
{
iResourceFilename.AppendNum( 0 );
iResourceFilename.AppendNum( aLangID );
}
else
{
iResourceFilename.AppendNum( aLangID );
}
iResourceFilename.Append( KResourceFileExtName );
return iResourceFilename;
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::GetWindowResFileName
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
const TDesC& CPeninputGenericVkbWindow::GetWindowResFileName()
{
return KVkbWindowResourceFile();
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::CreateAllControls
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::CreateAllControlsL()
{
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
iBubbleSize = AknLayoutScalable_Apps::popup_char_count_window().LayoutLine();
iBubbleTextLayout = AknLayoutScalable_Apps::popup_char_count_window_t1(0).LayoutLine();
icf->MsgBubbleCtrl()->SetTextFormat(iBubbleTextLayout);
icf->MsgBubbleCtrl()->SetTextColorIndex( EAknsCIQsnTextColorsCG67 );
//Change the ID when ID into release
icf->MsgBubbleCtrl()->SetBitmapParam(NULL,
NULL,
KAknsIIDQsnFrInputPreviewSideL,
KAknsIIDQsnFrInputPreviewMiddle,
KAknsIIDQsnFrInputPreviewSideR);
icf->MsgBubbleCtrl()->SetTextL( KEmptyString );
icf->InfoBubbleCtrl()->SetTextFormat(iBubbleTextLayout);
icf->InfoBubbleCtrl()->SetTextColorIndex( EAknsCIQsnTextColorsCG67 );
icf->InfoBubbleCtrl()->SetBitmapParam(NULL,
NULL,
KAknsIIDQsnFrInputPreviewSideL,
KAknsIIDQsnFrInputPreviewMiddle,
KAknsIIDQsnFrInputPreviewSideR);
if (iLayoutContext->LayoutType() == EPluginInputModeFSQ)
{
icf->SetMsgBubbleCtrlSize(TSize(iBubbleSize.iW,iBubbleSize.iH));
icf->SetInfoBubbleCtrlSize(TSize(iBubbleSize.iW,iBubbleSize.iH));
}
if ( !( iLayoutContext->LayoutType() == EPluginInputModeFSQ ))
{
// Range bar
AddRangeBarL();
}
// Vkb control
iVkbCtrl = CPeninputVkbCtrlExt::NewL( TRect(), UiLayout(),
EPeninutWindowCtrlIdVkbCtrl, NULL );
iVkbCtrl->SetResourceId( R_PENINPUT_LAYOUT_VKB_KEYBOARD );
iVkbCtrl->ConstructFromResourceL();
iVkbCtrl->SetKeyTextColorGroup( EAknsCIQsnTextColorsCG68 );
iVkbLayout->SetVkbKeyboard( iVkbCtrl );
if (iLayoutContext->LayoutType() != EPluginInputModeFSQ)
{
iVkbCtrl->SetIrregularKeyBoard(ETrue);
iVkbLayout->SetIrregularResourceId(R_AKN_FEP_VKB_IRREGULAR_BITMAP);
iVkbLayout->ConstructFromIrregularResourceL();
}
else
{
iVkbCtrl->SetIrregularKeyBoard(EFalse);
iVkbLayout->SetNonIrregularResourceId(R_AKN_FEP_VKB_NONIRREGULAR_BITMAP);
iVkbLayout->ConstructFromNonIrregularResourceL();
}
// Add bubble support
iVkbCtrl->ShowBubble(ETrue);
iVkbCtrl->SetGowithPointerDown(ETrue);
iVkbCtrl->SetBubbleBitmapParam(NULL,NULL,KAknsIIDQsnFrInputCharPreview); //Change the ID when ID into release
//set key to be 9 piece graphics
if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
iVkbCtrl->SetKeySkinId( EKeyBmpNormal, KAknsIIDQsnFrKeypadButtonFrNormal );
iVkbCtrl->SetKeySkinId( EKeyBmpHighlight, KAknsIIDQsnFrKeypadButtonFrPressed );
iVkbCtrl->SetKeySkinId( EKeyBmpDim, KAknsIIDQsnFrKeypadButtonFrInactive );
}
AddControlL( iVkbCtrl );
iVkbCtrl->AddEventObserver( UiLayout() );
AddButtonL( EPeninutWindowCtrlIdEnterBtn,
EPeninputLayoutEventEnter,
R_PENINPUT_LAYOUT_VKB_ENTER,
EKeyEnter );
// Shift and capslock merged button
CAknFepCtrlMultiModeButton* button =
CAknFepCtrlMultiModeButton::NewLC( UiLayout(),
EPeninutWindowCtrlIdShiftBtn );
if ( button )
{
// Read resource
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader,
R_PENINPUT_LAYOUT_VKB_SHIFT_CAPSLOCK );
button->SetResourceId( R_PENINPUT_LAYOUT_VKB_SHIFT_CAPSLOCK );
button->ConstructFromResourceL();
// Pop and destroy reader
CleanupStack::PopAndDestroy( 1 );
// Add into the control pool
AddControlL( button );
button->AddEventObserver( UiLayout() );
}
CleanupStack::Pop( button );
// Space button
CAknFepCtrlEventButton* spaceButton = static_cast<CAknFepCtrlEventButton*>
(Control(EPeninutWindowCtrlIdSpaceBtn));
// 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 ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
spaceButton->SetImageFrameId( KAknsIIDQsnFrKeypadButtonFrNormal,
KAknsIIDQsnFrKeypadButtonFrPressed,
KAknsIIDQsnFrKeypadButtonFrInactive );
}
if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
// Switch to hwr button
AddButtonL( EPeninutWindowCtrlIdMultiRangeBtn,
EPeninputLayoutEventMultiRange,
R_PENINPUT_LAYOUT_FSQ_MULTIRANGE );
}
else
{
// Switch to hwr button
AddButtonL( EPeninutWindowCtrlIdSwitchToHwrBtn,
EPeninputLayoutEventToHwr,
R_PENINPUT_LAYOUT_VKB_HWR );
}
// Add popup window
AddPopupWindowL();
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::ChangeUnitSize
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
const TRect CPeninputGenericVkbWindow::ChangeUnitSize()
{
return TRect();
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::ChangeClientSize
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::ChangeClientSize()
{
if ( !iPopupWnd->Hiden() )
{
iPopupWnd->CloseWindow();
if ( iLayoutContext->LayoutType() != EPluginInputModeFSQ )
{
ResetAccentButton();
}
iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );
}
PopupWindowSizeChange();
TInt clientLayoutId = CPeninputDataConverter::AnyToInt
( iLayoutContext->RequestData( EPeninputDataTypeClientLayout ) );
CPeninputClientLayoutInfo* clientLayout =
ConfigInfo()->FindClientLayoutInfo( clientLayoutId );
if ( clientLayout )
{
ReorganizeControls( clientLayout->LayoutID(), EFalse );
}
UpdateArea( iVkbCtrl->Rect(), EFalse );
}
void CPeninputGenericVkbWindow::SetVkbLayoutSize()
{
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);
TInt vkbLayoutid = CPeninputDataConverter::AnyToInt
( iLayoutContext->RequestData( EPeninputDataTypeVkbLayout ) );
CPeninputVkbLayoutInfo* vkbLayout =
ConfigInfo()->FindVkbLayoutInfo( 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));
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());
}
}
if ( iVkbCtrl->IsIrregularKeyBoard() )
{
TSize curSize = vkbLayout->KeyInfoList()[0]->Key()->Rect().Size();
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 curSize = vkbLayout->KeyInfoList()[0]->Key()->Rect().Size();
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 );
}
}
}
}
}
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::ReorganizeControls
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::ReorganizeControls( TInt aClientLayoutId,
TBool aNeedReset )
{
CPeninputClientLayoutInfo* clientLayout =
ConfigInfo()->FindClientLayoutInfo( aClientLayoutId );
RPointerArray<CPeninputControlInfo>& controlList =
clientLayout->ControlInfoList();
const TInt keyColumns = clientLayout->Columns();
const TInt keyRows = clientLayout->Rows();
if( iLastUsedTotalColumns == keyColumns &&
iLastUsedTotalRows == keyRows )
{
return;
}
iLafMgr->SetLayoutType(iLafMgr->LayoutTypeFromRowsColumns(keyRows,keyColumns));
iLastUsedTotalColumns = keyColumns;
iLastUsedTotalRows = keyRows;
TRect winRect( Rect().iTl, iLafMgr->EntirePaneRect().Size());
SetWindowRect(winRect);
//ReorgnizeTitleBar();
ReorgnizeICFAndButtons();
const TInt count = controlList.Count();
TInt controlID = 0;
CFepUiBaseCtrl* ctrl = NULL;
TRect rect;
TRect inRect;
TRect exRect;
TPoint winPoint = Rect().iTl;
TPoint LafPoint = iLafMgr->EntirePaneRect().iTl;
TInt x = winPoint.iX - LafPoint.iX;
TInt y = winPoint.iY - LafPoint.iY;
if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
x = 0;
y = 0;
}
for ( TInt i = 0; i < count; i++ )
{
controlID = controlList[i]->ControlID();
ctrl = Control( controlID );
if ( ctrl )
{
AddNotOwnedControl( ctrl );
if ( ( ctrl->ControlType() | ECtrlButton ) == ECtrlButton )
{
iLafMgr->GetButtonRect(TPeninputCommonCtrlID(ctrl->ControlId()),exRect ,inRect);
exRect.Move(x, y);
inRect.Move(x, y);
if( controlID == EPeninutWindowCtrlIdShiftBtn)
{
( static_cast<CAknFepCtrlMultiModeButton*> (ctrl) )->
SizeChanged( exRect, inRect, ETrue );
}
else
{
if (TPeninputCommonCtrlID(ctrl->ControlId()) == EPeninutWindowCtrlIdSpaceBtn)
{
// config 3 pieces icon info
TRect iconsFrameRect, middleIconRect;
iLafMgr->GetSpaceButtonExLayoutInfo( iconsFrameRect, middleIconRect );
iconsFrameRect.Move( x, y );
middleIconRect.Move( x, y );
inRect = iconsFrameRect;
( static_cast<CAknFepCtrlCommonButton*> (ctrl) )->SetDraw3PieceFrameInfo(
TDraw3PiecesFrame(KAknsIIDQgnIndiInputSpaceL,
KAknsIIDQgnIndiInputSpaceMiddle,
KAknsIIDQgnIndiInputSpaceR,
middleIconRect));
}
( static_cast<CAknFepCtrlCommonButton*> (ctrl) )->SizeChanged( exRect,
inRect,
ETrue );
}
}
else if ( ctrl->ControlId() == EPeninutWindowCtrlIdVkbCtrl )
{
iVkbCtrl->SetFont( iLafMgr->KeyTextFont() );
iVkbCtrl->SetTextLineLayout( iLafMgr->KeyTextLayout() );
iVkbCtrl->SetTextFormat( iLafMgr->PreviewWndText() ); //Read laf
if (aNeedReset)
{
iVkbCtrl->Reset();
}
rect = iLafMgr->KeypadRect();
rect.Move(x, y);
( static_cast<CPeninputVkbCtrlExt*> (ctrl) )->SizeChanged(rect);
}
else if ( ctrl->ControlId() == EPeninutWindowCtrlIdRangeBar )
{
TRAP_IGNORE(SetRangeBarSizeL(x, y));
}
}
}
// Addition for ITI features, read LAF data for candidate list
const TPeninputCandidateListLayoutData& candidateListLAF =
iLafMgr->CandidateListLayoutData();
iCandidateList->SizeChanged( candidateListLAF.iSelectionItemSize,
candidateListLAF.iSelectionHorMargin,
candidateListLAF.iSelectionVerMargin,
candidateListLAF.iSelectionNaviSize,
candidateListLAF.iSelectionNaviInnerSize );
iCandidateList->SetPageInfoTextLineLayout
( candidateListLAF.iSelectionPageTextLine );
const CFont* itemFont = candidateListLAF.iFont;
TRgb textColor = CandidateListTextColor();
if ( itemFont )
{
// Set font defined in LAF
iCandidateList->SetTextProperty( itemFont, textColor );
}
else
{
// If font in LAF is NULL, set ICF text font to candidate list
iCandidateList->SetTextProperty( iLafMgr->ICFTextFont(), textColor );
}
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
if ( icf )
{
// read LAF data for tooltip box
const TPeninputTooltipBoxLayoutData& tooltipBoxLAF
= iLafMgr->TooltipBoxLayoutData();
icf->TooltipBubbleCtrl()->SetTextFormat( tooltipBoxLAF.iTooltipTextLayout );
icf->TooltipBubbleCtrl()->SetTextColorIndex( EAknsCIQsnTextColorsCG55 );
icf->TooltipBubbleCtrl()->SetBitmapParam(NULL,
NULL,
KAknsIIDQsnFrInputPreviewSideL,
KAknsIIDQsnFrInputPreviewMiddle,
KAknsIIDQsnFrInputPreviewSideR);
icf->TooltipBubbleCtrl()->SetFrameDiff( KTooltipLeftMargin,
KTooltipTopMargin,
KTooltipRightMargin,
KTooltipBottomMargin );
// read color from skin for autocompletion part
icf->SetAutoCompleteTextColor( AutoCompletionPartColor() );
}
}
void CPeninputGenericVkbWindow::SetRangeBarSizeL(TInt x, TInt y)
{
TRect exRect;
exRect = iLafMgr->RangbarRect();
exRect.Move(x, y);
// Get range bar display cell rects
TRect rect, innerRect;
RArray<TRect> displayCellRects, dispalyCellInnerRects;
CleanupClosePushL( displayCellRects );
CleanupClosePushL( dispalyCellInnerRects );
for( TInt i = 0; i < iLafMgr->RangbarCellCount(); i++ )
{
iLafMgr->RangbarCellAt( i, rect, innerRect );
rect.Move(x, y);
displayCellRects.AppendL( rect );
innerRect.Move(x, y);
dispalyCellInnerRects.AppendL( innerRect );
}
iRangeBar->SetDispalyCellRectsL( displayCellRects, dispalyCellInnerRects );
CleanupStack::PopAndDestroy(2);
iRangeBar->SizeChanged( exRect );
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::SetControlsFont
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::SetControlsFont()
{
/*
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>(Control(EPeninputWindowCtrlIdMultiLineICF));
const CFont* icfFont = iLafMgr->ICFTextFont();
// set icf margin
TPeninputICFConfig icfConfig;
iLafMgr->GetICFConfig( icfConfig );
icf->SetTextMargin( icfConfig.iLeftMargin,
icfConfig.iRightMargin,
icfConfig.iTopMargin,
0 );
TRAP_IGNORE(icf->SizeChangedL(
icf->Rect(),
icfConfig.iTextLineHeight,
icfFont->FontMaxHeight(),
icfFont));
*/
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::AddPopupWindowL
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::AddPopupWindowL()
{
iPopupWnd = CPeninputCommonChoiceList::NewL( UiLayout(),
EPeninutWindowCtrlIdAccentPopupWindow,
KAknsIIDQsnFrList,
KAknsIIDQsnFrPopupSub );
iPopupWnd->AddEventObserver( UiLayout() );
AddControlL( iPopupWnd );
iIdle = CIdle::NewL(CActive::EPriorityIdle );
iIdle ->Start(TCallBack(BackgroundTaskL,this));
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::PopupChoiceList
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::PopupChoiceList()
{
if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
TRAP_IGNORE( PopupRangeListL());
}
else
{
CFepUiBaseCtrl* accentBtn = Control( EPeninutWindowCtrlIdAccentedBtn );
if ( accentBtn )
{
if(!iPopupInited)
TRAP_IGNORE(DoIdleConstructL());
iPopupWnd->Display( accentBtn->Rect() );
iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStatePopup );
}
}
}
// ---------------------------------------------------------------------------
// Show range list
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::PopupRangeListL()
{
if ( !iPopupInited )
{
TRAP_IGNORE( DoIdleConstructL() );
}
iPopupWnd->ClearItemsL();
RArray<CFepLayoutChoiceList::SItem> items;
PrepareRangeListItems( items );
TInt count = items.Count();
for ( TInt i = 0; i < count; i++ )
{
iPopupWnd->AddItemL( items[i] );
}
items.Close();
if ( iPopupWnd->ItemsCount() < 1 )
{
return;
}
if ( iPopupWnd->ItemsCount() < 2 )
{
const CFepLayoutChoiceList::SItem* item = iPopupWnd->ItemByIndex( 0 );
CFepLayoutChoiceList::SEvent event;
event.iIndex = 0;
event.iCommand = item->iCommand;
TPtrC ptr;
ptr.Set(reinterpret_cast<TText*>(&event), sizeof(event));
HandleRangeListSelectedL( iPopupWnd, ptr );
return;
}
CFepUiBaseCtrl* btn = Control( EPeninutWindowCtrlIdMultiRangeBtn );
iPopupWnd->SetListColumnNumWithLafL( iPopupWnd->ItemsCount() );
iPopupWnd->SetCurrentFocusedIndex( - 1 ); //no active item
iPopupWnd->Display( btn->Rect() );
iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStatePopup );
}
// ---------------------------------------------------------------------------
// Handle range list event
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::HandleRangeListSelectedL( CFepUiBaseCtrl* /*aCtrl*/,
const TDesC& aData )
{
CFepLayoutChoiceList::SEvent* event =
(CFepLayoutChoiceList::SEvent*)aData.Ptr();
TInt index = -1;
TInt range = ERangeInvalid;
if ( event->iCommand == EPeninputVkbLayoutNativeChar )
{
range = ERangeNative;
}
else if ( event->iCommand == EPeninputVkbLayoutNativeNumber )
{
range = ERangeNativeNumber;
}
else if ( event->iCommand == EPeninputVkbLayoutLatinChar )
{
range = ERangeEnglish;
}
else if ( event->iCommand == EPeninputVkbLayoutLatinNumber )
{
range = ERangeNumber;
}
else if ( event->iCommand == EPeninputVkbLayoutSymbol )
{
range = ERangeSymbol;
}
else if ( event->iCommand == EPeninputVkbLayoutAccented1 )
{
index = 0;
range = ERangeAccent;
}
else if ( event->iCommand == EPeninputVkbLayoutAccented2 )
{
index = 1;
range = ERangeAccent;
}
else if ( event->iCommand == EPeninputVkbLayoutAccented3 )
{
index = 2;
range = ERangeAccent;
}
TInt currentRange = IntContext( EPeninputDataTypeCurrentRange );
TInt currentAccent = IntContext( EPeninputDataTypeCurrentAccent );
if ( currentRange == range )
{
if ( range != ERangeAccent || currentAccent == index )
{
iUiStateMgr->SetCurrentUiState( EPeninputVkbUiStateStandby );
return;
}
}
iLayoutContext->SetData( EPeninputDataTypeCurrentAccent, &index );
if ( range != ERangeAccent )
{
ChangeRange( range );
}
else
{
ChangeRange( ERangeAccent,
EPeninputVkbLayoutAccented1 + 2 * index, ETrue );
}
UpdateRangeCtrlsL();
}
// ---------------------------------------------------------------------------
// Update state of range button
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::UpdateRangeCtrlsL()
{
CAknFepCtrlCommonButton* rangeBtn =
static_cast<CAknFepCtrlCommonButton*>(
Control(EPeninutWindowCtrlIdMultiRangeBtn));
if ( !rangeBtn )
{
return;
}
RArray<CFepLayoutChoiceList::SItem> items;
PrepareRangeListItems( items );
TInt count = items.Count();
items.Close();
TInt languageId = IntContext( EPeninputDataTypeInputLanguage );
TInt range = IntContext( EPeninputDataTypeCurrentRange );
TInt resId = -1;
TInt aplhaRangeResId = -1;
TInt numberRangeResId = -1;
GetRangeIconResource( languageId, aplhaRangeResId, numberRangeResId );
if ( range == ERangeEnglish || range == ERangeNative )
{
resId = aplhaRangeResId;
}
else
{
resId = numberRangeResId;
}
if( rangeBtn->ResourceId() != resId )
{
rangeBtn->SetResourceId( resId );
rangeBtn->ConstructFromResourceL();
}
rangeBtn->SetDimmed( count < 1 );
}
// ---------------------------------------------------------------------------
// Get resource ids of range button icon
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::GetRangeIconResource( TInt aLangId,
TInt& aAlphaRange,
TInt& aOtherRange )
{
switch ( aLangId )
{
case ELangRussian: //Cyrillic
case ELangBulgarian:
case ELangUkrainian:
{
aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_CYRILLIC_ALPHA;
aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_CYRILLIC_NUMERIC;
}
break;
case ELangGreek: //Greek
case ELangCyprusGreek:
{
aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_GREEK_ALPHA;
aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_GREEK_NUMERIC;
}
break;
case ELangHebrew: //Hebrew
{
aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_HEBREW_ALPHA;
aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_HEBREW_NUMERIC;
}
break;
case ELangArabic: //Arabic
case ELangFarsi: //Farsi
case ELangUrdu: //Urdu
{
aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_ARABIC_ALPHA;
aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_ARABIC_NUMERIC;
}
break;
case ELangThai: //Thai
{
aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_THAI_ALPHA;
aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_THAI_NUMERIC;
}
break;
default: //others
{
aAlphaRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_LATIN_ALPHA;
aOtherRange = R_PENINPUT_LAYOUT_VKB_RANGECTRL_LATIN_NUMERIC;
}
}
}
// ---------------------------------------------------------------------------
// Prepare range list items
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::PrepareRangeListItems(
RArray<CFepLayoutChoiceList::SItem>& aRangeItems )
{
aRangeItems.Reset();
TInt currentRange = IntContext( EPeninputDataTypeCurrentRange );
TInt permittedRange = IntContext( EPeninputDataTypePermittedRange );
TInt currentAccent = IntContext( EPeninputDataTypeCurrentAccent );
TInt currentLanguage = IntContext( EPeninputDataTypeInputLanguage );
CPeninputRangeBarInfo* rbinfo= ConfigInfo()->RangeBarInfo();
CPeninputRangeInfo* rgninfo = NULL;
//add accent items
if ( permittedRange & ERangeAccent )
{
rgninfo = rbinfo->FindRange( ERangeAccent );
if ( rgninfo )
{
for ( TInt i = 0; i < iAccentCmdList.Count(); i++ )
{
if( currentRange != ERangeAccent || currentAccent != i )
{
aRangeItems.Append( iAccentCmdList[i] );
}
}
}
}
//add range items
CFepLayoutChoiceList::SItem item;
if ( permittedRange & ERangeNative )
{
rgninfo = rbinfo->FindRange( ERangeNative );
if ( rgninfo && currentRange != ERangeNative )
{
item.iCommand = EPeninputVkbLayoutNativeChar;
item.iText.Copy( iRangeLabels.iLabelNativeChar );
aRangeItems.Append( item );
}
}
if (( permittedRange & ERangeNativeNumber ) && ( currentRange != ERangeNumber )
&& (( ELangArabic == currentLanguage ) || ( ELangFarsi == currentLanguage )
|| ( ELangUrdu == currentLanguage )))
{
rgninfo = rbinfo->FindRange( ERangeNativeNumber );
if ( rgninfo && currentRange != ERangeNativeNumber )
{
item.iCommand = EPeninputVkbLayoutNativeNumber;
item.iText.Copy( iRangeLabels.iLabelNativeNumber );
aRangeItems.Append( item );
}
}
else if(( permittedRange & ERangeNumber ) && ( currentRange != ERangeNumber )
&& !(( ELangThai == currentLanguage ) && ( currentRange == ERangeNativeNumber )))
{
rgninfo = rbinfo->FindRange( ERangeNumber );
if ( rgninfo && currentRange != ERangeNumber )
{
item.iCommand = EPeninputVkbLayoutLatinNumber;
item.iText.Copy( iRangeLabels.iLabelLatinNumber );
aRangeItems.Append( item );
}
}
else
{
// Do nothing
}
if ( permittedRange & ERangeEnglish )
{
rgninfo = rbinfo->FindRange( ERangeEnglish );
if ( rgninfo && currentRange != ERangeEnglish )
{
item.iCommand = EPeninputVkbLayoutLatinChar;
item.iText.Copy( iRangeLabels.iLabelLatinChar );
aRangeItems.Append( item );
}
}
}
// ---------------------------------------------------------------------------
// Load range labels for range list
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::ConstructRangeLabelListL( TInt /*aLangId*/ )
{
iRangeLabels.iLabelNativeChar.Zero();
iRangeLabels.iLabelNativeNumber.Zero();
iRangeLabels.iLabelLatinChar.Zero();
iRangeLabels.iLabelLatinNumber.Zero();
iRangeLabels.iLabelSymbol.Zero();
iRangeLabels.iLabelAccent.Zero();
TInt resid = R_PENINPUT_LAYOUT_VKB_RANGES;
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, resid );
TPtrC ptr1 = reader.ReadTPtrC();
TPtrC ptr2 = reader.ReadTPtrC();
TPtrC ptr3 = reader.ReadTPtrC();
TPtrC ptr4 = reader.ReadTPtrC();
TPtrC ptr5 = reader.ReadTPtrC();
TPtrC ptr6 = reader.ReadTPtrC();
iRangeLabels.iLabelNativeChar.Copy( ptr1 );
iRangeLabels.iLabelNativeNumber.Copy( ptr2 );
iRangeLabels.iLabelLatinChar.Copy( ptr3 );
iRangeLabels.iLabelLatinNumber.Copy( ptr4 );
iRangeLabels.iLabelSymbol.Copy( ptr5 );
iRangeLabels.iLabelAccent.Copy( ptr6 );
CleanupStack::PopAndDestroy( 1 ); //reader
}
// ---------------------------------------------------------------------------
// Utils to get context value
// ---------------------------------------------------------------------------
//
TInt CPeninputGenericVkbWindow::IntContext( TPeninputDataType aDataIndex )
{
return CPeninputDataConverter::AnyToInt(
iLayoutContext->RequestData( aDataIndex ));
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::ResetAccentButton
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::ResetAccentButton()
{
TInt curRange = CPeninputDataConverter::AnyToInt
( iLayoutContext->RequestData( EPeninputDataTypeCurrentRange ) );
if ( iRangeBar )
{
iRangeBar->ActiveRange( curRange );
}
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::PopupWindowSizeChange
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::PopupWindowSizeChange()
{
if (CPeninputDataConverter::AnyToInt(
iLayoutContext->RequestData(EAkninputDataTypeSizeChanging)) || (!iPopupSet))
{
// if size changing, or popup window's property has not been set yet
TAknWindowLineLayout appWnd = AknLayoutScalable_Avkon::application_window(0).LayoutLine();
iAppWndRect = appWnd.Rect();
TAknWindowLineLayout mainPane = AknLayoutScalable_Avkon::main_pane(4).LayoutLine();
TAknLayoutRect mainPaneRect;
mainPaneRect.LayoutRect(iAppWndRect, mainPane);
TAknWindowLineLayout choiceWnd =
AknLayoutScalable_Avkon::popup_choice_list_window(1).LayoutLine();
TAknLayoutRect choiceRect;
choiceRect.LayoutRect(mainPaneRect.Rect(), choiceWnd);
iPopupItemRect = TRect(0, 0, choiceRect.Rect().Width(),
AknLayoutScalable_Avkon::list_single_choice_list_pane(0).LayoutLine().iH);
iChoiceTextLayout =
AknLayoutScalable_Avkon::list_single_choice_list_pane_t1(1).LayoutLine();
}
const CFont* font = AknLayoutUtils::FontFromId(iChoiceTextLayout.iFont, NULL);
iPopupWnd->SetFont(font);
iPopupWnd->SetItemRect(iPopupItemRect, iPopupItemRect);
TInt leftMargin = iChoiceTextLayout.il;
iPopupWnd->SetMarginAndBaseline(leftMargin, font->HeightInPixels());
iPopupWnd->SetFontColor(AKN_LAF_COLOR_STATIC(iChoiceTextLayout.iC));
AknIconUtils::SetSize(iPopupWndBgImg, TSize(iPopupItemRect.Width(),
iPopupItemRect.Height()*3), EAspectRatioNotPreserved);
AknIconUtils::SetSize(iPopupWndFocusImg, TSize(iPopupItemRect.Width(),
iPopupItemRect.Height()* 3), EAspectRatioNotPreserved);
iPopupSet = ETrue;
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::GetPopupWndInfoFromRes
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::GetPopupWndInfoFromResL( TResourceReader aRes,
const TRect& aRect )
{
TPtrC bmpFileName = aRes.ReadTPtrC();
TInt32 imgMajorSkinId = aRes.ReadInt32();
TAknsItemID id;
MAknsSkinInstance* skininstance = UiLayout()->SkinInstance();
TInt popWinBmpId = aRes.ReadInt16();
TInt popWinBmpMaskId = aRes.ReadInt16();
TInt popWinBmpSkinId = aRes.ReadInt16();
id.Set( TInt( imgMajorSkinId ), popWinBmpSkinId );
if ( popWinBmpId != KInvalidImg )
{
AknsUtils::CreateIconL( skininstance,
id,
iPopupWndBgImg,
bmpFileName,
popWinBmpId );
AknIconUtils::SetSize( iPopupWndBgImg, TSize( aRect.Width(),
aRect.Height() * 3 ), EAspectRatioNotPreserved );
iPopupWnd->SetBackgroundBitmapL( iPopupWndBgImg );
}
TInt focusBmpId = aRes.ReadInt16();
TInt focusBmpMaskId = aRes.ReadInt16();
TInt focusBmpSkinId = aRes.ReadInt16();
id.Set( TInt( imgMajorSkinId ), focusBmpSkinId );
if ( focusBmpId != KInvalidImg )
{
AknsUtils::CreateIconL( skininstance,
id,
iPopupWndFocusImg,
bmpFileName,
focusBmpId );
AknIconUtils::SetSize( iPopupWndFocusImg, TSize( aRect.Width(),
aRect.Height() * 3 ), EAspectRatioNotPreserved );
iPopupWnd->SetFocusBmp( iPopupWndFocusImg );
}
}
// --------------------------------------------------------------------------
// CAknFepVkbClientArea::AddRangeBarL
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::AddRangeBarL()
{
// Range bar
iRangeBar = CAknFepCtrlRangeBar::NewL( UiLayout(),
EPeninutWindowCtrlIdRangeBar,
CAknFepCtrlRangeBar::EBtnGroupHorizontal );
// Set event id
iRangeBar->SetEventIdForRange( EPeninputLayoutEventRange );
iRangeBar->SetEventIdForCase( EPeninputLayoutEventRangeLoop );
AddControlL( iRangeBar );
iRangeBar->AddEventObserver(UiLayout());
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::AddButtonL
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
CAknFepCtrlEventButton* CPeninputGenericVkbWindow::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 );
}
else
{
if ( aControlId == EPeninutWindowCtrlIdMultiRangeBtn )
{
button = CAknFepCtrlLongPressButton::NewL( UiLayout(), aControlId,
aEventId, aUnicode,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive );
}
else
{
button = CAknFepCtrlEventButton::NewL( UiLayout(), aControlId,
aEventId, aUnicode,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive );
}
}
CleanupStack::PushL( button );
if ( button )
{
// Read resource
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, aResId );
button->SetResourceId( aResId );
button->ConstructFromResourceL();
// Pop and destroy reader
CleanupStack::PopAndDestroy( 1 );
// Add into the control pool
AddControlL( button );
button->AddEventObserver(UiLayout());
}
CleanupStack::Pop( button );
return button;
}
// --------------------------------------------------------------------------
// CPeninputGenericVkbWindow::DoCaseChange
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::DoCaseChange( TInt aNewCase )
{
TInt curCase = CPeninputDataConverter::AnyToInt
( iLayoutContext->RequestData( EPeninputDataTypeCase ) );
if ( aNewCase == curCase )
{
return;
}
TInt curRange = CPeninputDataConverter::AnyToInt
( iLayoutContext->RequestData( EPeninputDataTypeCurrentRange ) );
if ((( curRange == ERangeAccent ) || ( ( curRange == ERangeEnglish )
|| ( ( curRange == ERangeNative ) && ( ConfigInfo()->CaseSensitive()) ) ) ) )
{
// Set shift and caplock button
TInt shfit;
TInt capslock;
CPeninputDataConverter::ShiftCapslockByCase( aNewCase,
shfit, capslock );
iLayoutContext->SetData( EPeninputDataTypeShiftDown, &shfit );
//ChangeButtonStatus( shfit, EPeninutWindowCtrlIdShiftBtn );
iLayoutContext->SetData( EPeninputDataTypeCapslockDown, &capslock );
//ChangeButtonStatus( capslock, EPeninutWindowCtrlIdCapslockBtn );
iLayoutContext->SetData( EPeninputDataTypeCase, &aNewCase );
ChangeMergedButtonStatus( shfit, capslock );
TInt vkblayout = ConfigInfo()->ShiftCapsSingleVkbLayoutByCase
( curRange, aNewCase );
if ( curRange == ERangeAccent )
{
TInt curAccentIndex = CPeninputDataConverter::AnyToInt
( iLayoutContext->RequestData( EPeninputDataTypeCurrentAccent ) );
vkblayout = vkblayout + curAccentIndex * 2;
}
ChangeVkbLayout( vkblayout );
}
}
// ---------------------------------------------------------------------------
// CPeninputGenericVkbWindow::BackgroundConstructL
// Do background construct.
// ---------------------------------------------------------------------------
//
TInt CPeninputGenericVkbWindow::BackgroundTaskL(TAny* aPtr)
{
CPeninputGenericVkbWindow* self = static_cast<CPeninputGenericVkbWindow*>(aPtr);
self->DoIdleConstructL();
return EFalse; // only run once
}
void CPeninputGenericVkbWindow::DoIdleConstructL()
{
if(iPopupInited)
return;
// Read resource
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader,
R_PENINPUT_LAYOUT_VKB_POPUP_WINDOW );
GetPopupWndInfoFromResL(reader, iPopupItemRect);
// Pop and destroy reader
CleanupStack::PopAndDestroy( 1 );
}
// -----------------------------------------------------------------------------
// CPeninputGenericVkbWindow::ConstructFromResourceL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::ConstructFromResourceL()
{
CPeninputLayoutWindowExt::ConstructFromResourceL();
if( iVkbLayout && !iFirstConstruct )
{
if( iVkbCtrl->IsIrregularKeyBoard() )
iVkbLayout->ConstructFromIrregularResourceL();
else
iVkbLayout->ConstructFromNonIrregularResourceL();
//SetVkbLayoutSize();
if( IsRtoLLanguage( iLanguage ) )
{
//Mirror backspace graphic
HandleButtonResOnLangDirChange( EPeninutWindowCtrlIdBackspaceBtn );
}
}
iFirstConstruct = EFalse;
}
// -----------------------------------------------------------------------------
// CPeninputGenericVkbWindow::SetSwitchlistLanguage
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::SetSwitchlistLanguage(TInt aLang)
{
ASSERT( IsValidLanguage( aLang ) );
//Check language input direction change
TBool isLangDirectionChange = EFalse;
if( IsValidLanguage( iLanguage ) )
isLangDirectionChange = IsRtoLLanguage( aLang ) ^ IsRtoLLanguage( iLanguage );
else
isLangDirectionChange = IsRtoLLanguage( aLang );
if( aLang ==ELangHebrew ||
aLang == ELangGreek ||
aLang == ELangHindi ||
aLang == ELangMarathi )
{
iLafMgr->SetLafOption( (TPeninputVkbLafOption)
( iLafMgr->OptionType() &(~EOption3CellRange) ) );
}
else
{
iLafMgr->SetLafOption( (TPeninputVkbLafOption)
( iLafMgr->OptionType() | EOption3CellRange) );
}
if( isLangDirectionChange )
{
//Mirror backspace graphic
HandleButtonResOnLangDirChange( EPeninutWindowCtrlIdBackspaceBtn );
}
iLanguage = aLang;
}
// -----------------------------------------------------------------------------
// CPeninputGenericVkbWindow::SetSwitchlistSecretFlag
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::SetSwitchlistSecretFlag(TBool aSecret)
{
CPeninputLayoutInputmodelChoice* choiceList =
static_cast<CPeninputLayoutInputmodelChoice*>(
Control(EPeninutWindowCtrlIdSwitcherPopupWindow ));
if ( choiceList )
{
choiceList->SetSecretEditor( aSecret );
}
//disable or enable arrow keys of FSQ in secret editor.
}
// ---------------------------------------------------------------------------
// CPeninputGenericVkbWindow::DimArrowKeys
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::DimArrowKeys( TBool aDimArrow )
{
if(iLayoutContext->LayoutType() == EPluginInputModeFSQ
&& iArrowLeftButton && iArrowRightButton)
{
iArrowLeftButton->SetDimmed( aDimArrow );
iArrowRightButton->SetDimmed( aDimArrow );
}
}
void CPeninputGenericVkbWindow::DimEnterKey( TBool aDimmed )
{
CAknFepCtrlEventButton* enterBtn = static_cast<CAknFepCtrlEventButton*>
( Control(EPeninutWindowCtrlIdEnterBtn) );
if(iLayoutContext->LayoutType() == EPluginInputModeFSQ
&& enterBtn )
{
enterBtn->SetDimmed( aDimmed );
}
}
// ---------------------------------------------------------------------------
// CAknFepVkbWindow::PopupAccentWindow
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::PopupSwitchWindowL()
{
CFepUiBaseCtrl* accentBtn = Control(EPeninutWindowCtrlIdSwitchToHwrBtn);
if ( accentBtn )
{
if (!iPopupInited)
{
DoIdleConstructL();
}
TRect rect = accentBtn->Rect();
static_cast<CPeninputLayoutInputmodelChoice*>
(Control(EPeninutWindowCtrlIdSwitcherPopupWindow))->PopUpSwitchListL( accentBtn->Rect() );
}
}
// ---------------------------------------------------------------------------
// CPeninputGenericVkbWindow::SetDeadKey
// (Set DeadKey)
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::SetDeadKey()
{
// Get VKB list
RPointerArray<CPeninputVkbLayoutInfo> vkbListInfo;
vkbListInfo = iVkbLayout->VkbLayoutInfoList();
TInt vkbListNum = vkbListInfo.Count();
CPeninputVkbKeyInfo* pVKBKeyInfo;
CVirtualKey* pKey;
TInt count = sizeof(KSupportLanguages)/sizeof(TLangMeritPair);
for(TInt i = 0; i < vkbListNum; i++)
{
for(TInt j = 0; j < count; j++)
{
if(vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeChar ||
vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeCharShift)
{
pVKBKeyInfo = vkbListInfo[i]->FindKey( KSupportLanguages[j].iDeadKey );
if(pVKBKeyInfo)
{
// Set the DeadKey as a latch button
pKey = pVKBKeyInfo->Key();
pKey->SetLatchKey(ETrue);
}
}
}
}
}
// ---------------------------------------------------------------------------
// CPeninputGenericVkbWindow::UnLatchDeadKey
// (Unlatch the DeadKey)
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::UnLatchDeadKey( const TDesC& abuf )
{
RPointerArray<CPeninputVkbLayoutInfo> vkbListInfo;
vkbListInfo = iVkbLayout->VkbLayoutInfoList();
TInt vkbListNum = vkbListInfo.Count();
CPeninputVkbKeyInfo* pVKBKeyInfo;
CVirtualKey* pKey;
TInt count = sizeof(KSupportLanguages)/sizeof(TLangMeritPair);
for(TInt i = 0; i < vkbListNum; i++)
{
for(TInt j = 0; j < count; j++)
{
// Only NativeChar and NativeCharShift layout contain DeadKey
if(vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeChar ||
vkbListInfo[i]->LayoutID() == EPeninputVkbLayoutNativeCharShift)
{
// Find the DeadKey in NativeChar or NativeCharShift layout
pVKBKeyInfo = vkbListInfo[i]->FindKey( KSupportLanguages[j].iDeadKey );
if(pVKBKeyInfo)
{
pKey = pVKBKeyInfo->Key();
if(pKey->Latched())
{
if(abuf == KNullDesC)
{
// When focus change, the latched key will be released
TBool deadKeyChange = EFalse;
iLayoutContext->SetData(EAkninputDataTypeLatchedSet, &deadKeyChange);
pKey->SetLatched(EFalse);
TRect rect = pKey->Rect();
rect.Move( iVkbCtrl->Rect().iTl );
UpdateArea( rect, EFalse );
return;
}
if(abuf[0] == KSupportLanguages[j].iDeadKey)
{
// When another DeadKey is clicked, the old one will be released
pKey->SetLatched(EFalse);
TRect rect = pKey->Rect();
rect.Move( iVkbCtrl->Rect().iTl );
UpdateArea( rect, EFalse );
return;
}
}
}
}
}
}
}
// ---------------------------------------------------------------------------
// CPeninputGenericVkbWindow::HandleAccentCharEvent
// (Unlatch the DeadKey)
// ---------------------------------------------------------------------------
//
TBool CPeninputGenericVkbWindow::HandleAccentCharEvent( TInt /*aEventType*/,
const TDesC& aEventData,
const TDesC& aDeadKey,
HBufC* anewCharBuf )
{
// Get the unicode of virtual key char
TBuf<16> buf;
TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();
buf.Append(event->iCode);
TBool rs = EFalse;
// Caculate the accent char number
TInt count = sizeof(KSupportLanguages)/sizeof(TLangMeritPair);
TInt i = 0;
if(aDeadKey.Compare( KNullDesC ) != 0) // One DeadKey is latched
{
for(i = 0; i < count; i++)
{
if((aDeadKey[0] == KSupportLanguages[i].iDeadKey) &&
(buf[0] == KSupportLanguages[i].iChar))
{
if(anewCharBuf)
{
anewCharBuf->Des().Append(KSupportLanguages[i].iAccentedChar);
rs = ETrue;
}
break;
}
}
}
return rs;
}
// ---------------------------------------------------------------------------
// CPeninputGenericVkbWindow::HandleVirtualKeyLatchedEvent
// (Handle virtual key latched event).
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::HandleVirtualKeyLatchedEvent(TInt /*aEventType*/,
CFepUiBaseCtrl* /*aCtrl*/,
const TDesC& aEventData )
{
TBuf<16> deadKey(KNullDesC);
TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();
deadKey.Append(event->iCode);
TInt latchedFlag = CPeninputDataConverter::AnyToInt(
iLayoutContext->RequestData(EAkninputDataTypeLatchedSet));
if(latchedFlag)
{
// Update the new and old DeadKey buffer
iOldDeadKeyBuf = iNewDeadKeyBuf;
iNewDeadKeyBuf = deadKey;
HBufC* newCharBuf = HBufC::New( 2*iOldDeadKeyBuf.Length() );
if( newCharBuf )
{
CPeninputGenericVkbLayout* layout
= static_cast<CPeninputGenericVkbLayout*>( UiLayout() );
if( layout->IsEnableITIOnFSQ() )
{
// If ITI is open, double same keys should be send for one dead key,
// core will handle them as one key.
newCharBuf->Des().Append( iOldDeadKeyBuf );
}
newCharBuf->Des().Append( iOldDeadKeyBuf );
}
// Submit old DeadKey
UiLayout()->SignalOwner(ESignalKeyEvent, *newCharBuf);
delete newCharBuf;
// Unlatch the previous DeadKey
UnLatchDeadKey(iOldDeadKeyBuf);
}
else
{
iNewDeadKeyBuf = deadKey;
// Set DeadKey state to latched
TBool deadKeyChange = ETrue;
iLayoutContext->SetData(EAkninputDataTypeLatchedSet, &deadKeyChange);
}
}
// ---------------------------------------------------------------------------
// CPeninputCommonLayout::HandleVirtualKeyUpEvent
// (Handle virtual key up event).
// ---------------------------------------------------------------------------
//
TBool CPeninputGenericVkbWindow::HandleVirtualKeyUpEvent(TInt aEventType,
CFepUiBaseCtrl* /*aCtrl*/,
const TDesC& aEventData )
{
// Get DeadKey state
TInt latchedFlag = CPeninputDataConverter::AnyToInt(
iLayoutContext->RequestData(EAkninputDataTypeLatchedSet));
if(latchedFlag)
{
TBool ret = EFalse;
TRAP_IGNORE(ret = HandleDeadKeyL(aEventType,aEventData))
if(ret)
{
return ETrue;
}
else
{
// When the DeadKey can not combine with current character,
// Sumit current DeadKey
UiLayout()->SignalOwner( ESignalKeyEvent, iNewDeadKeyBuf );
}
}
iNewDeadKeyBuf = KNullDesC;
return EFalse;
}
TBool CPeninputGenericVkbWindow::HandleDeadKeyL(TInt aEventType,
const TDesC& aEventData )
{
// Set DeadKey to unlatched state
TBool deadKeyChange = EFalse;
iLayoutContext->SetData(EAkninputDataTypeLatchedSet, &deadKeyChange);
UnLatchDeadKey(iNewDeadKeyBuf);
CPeninputGenericVkbLayout* layout
= static_cast<CPeninputGenericVkbLayout*>( UiLayout() );
if ( layout->IsEnableITIOnFSQ() )
{
TBuf<KKeyCodeSize> buf;
TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();
buf.Append(event->iCode);
HBufC* newCharBuf = HBufC::New( iNewDeadKeyBuf.Length() + buf.Length() );
if( newCharBuf )
{
newCharBuf->Des().Append( iNewDeadKeyBuf );
newCharBuf->Des().Append( buf );
}
// Submit DeadKey + Key at the same time
UiLayout()->SignalOwner(ESignalKeyEvent,*newCharBuf);
delete newCharBuf;
return ETrue;
}
// Get the accent char
HBufC* newCharBuf = HBufC::NewL(1);
if(HandleAccentCharEvent(aEventType,
aEventData,
iNewDeadKeyBuf,
newCharBuf))
{
// Send ths accent key to FEP
UiLayout()->SignalOwner( ESignalKeyEvent, *newCharBuf);
iNewDeadKeyBuf = KNullDesC;
delete newCharBuf;
return ETrue;
}
delete newCharBuf;
return EFalse;
}
void CPeninputGenericVkbWindow::SetLafLayOut(TInt aRows, TInt aColumns)
{
iLafMgr->SetLayoutType(iLafMgr->LayoutTypeFromRowsColumns(aRows,aColumns));
}
void CPeninputGenericVkbWindow::AddCustomControlGroupL(CFepUiBaseCtrl* aCtrl)
{
AddControlL(aCtrl);
}
TBool CPeninputGenericVkbWindow::CreateCustomControlL( TInt16 aControlId, TInt32 aImageId )
{
TBool create = ETrue;
switch ( aControlId )
{
case EPeninutWindowCtrlIdMoveBtn:
{
if ( !iMoveButton )
{
iMoveButton = CAknFepCtrlDragButton::NewL(UiLayout(), EPeninutWindowCtrlIdMoveBtn);
AddControlL(iMoveButton);
iMoveButton->AddPositionObserver(this);
iMoveButton->AddEventObserver( UiLayout() );
iMoveButton->SetResourceId( aImageId );
iMoveButton->SetImageFrameId(KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive);
UiLayout()->EnableLayoutMoving( static_cast<CDragBar*>( iMoveButton ) );
}
iMoveButton->ConstructFromResourceL();
}
break;
case EPeninupWindowCtrlIdArrowLeftBtn:
{
if ( iLayoutContext->LayoutType() != EPluginInputModeFSQ )
{
break;
}
if (!iArrowLeftButton)
{
iArrowLeftButton = CAknFepCtrlRepeatButton::NewL(
UiLayout(), aControlId, EPeninputLayoutEventLeftArrow, EKeyLeftArrow,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive );
AddControlL(iArrowLeftButton);
iArrowLeftButton->AddEventObserver(UiLayout());
iArrowLeftButton->SetResourceId( aImageId );
}
iArrowLeftButton->ConstructFromResourceL();
}
break;
case EPeninupWindowCtrlIdArrowRightBtn:
{
if ( iLayoutContext->LayoutType() != EPluginInputModeFSQ )
{
break;
}
if (!iArrowRightButton)
{
iArrowRightButton = CAknFepCtrlRepeatButton::NewL(
UiLayout(), aControlId, EPeninputLayoutEventRightArrow, EKeyRightArrow,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive );
AddControlL(iArrowRightButton);
iArrowRightButton->AddEventObserver(UiLayout());
iArrowRightButton->SetResourceId( aImageId );
}
iArrowRightButton->ConstructFromResourceL();
}
break;
default:
{
create = EFalse;
}
}
return create;
}
void CPeninputGenericVkbWindow::SetPromptTextL(TUint8* aData)
{
RDesReadStream readStream;
TPtr8 countPtr(aData, 2*sizeof(TInt), 2*sizeof(TInt));
readStream.Open(countPtr);
CleanupClosePushL(readStream);
const TInt dataCount = readStream.ReadInt32L();
const TInt textCount = readStream.ReadInt32L();
CleanupStack::PopAndDestroy(&readStream);
TPtr8 ptr( aData+2*sizeof(TInt), dataCount+textCount, dataCount+textCount );
readStream.Open(ptr);
CleanupClosePushL(readStream);
HBufC8* dataBuf = HBufC8::NewLC(dataCount);
TPtr8 dataBufPtr = dataBuf->Des();
readStream.ReadL(dataBufPtr, dataCount);
TFepPromptText* pIcfData =
reinterpret_cast<TFepPromptText*>(const_cast<TUint8*>(dataBufPtr.Ptr()));
HBufC* textBuf;
if (textCount > 0)
{
textBuf = HBufC::NewLC(textCount/2);
TPtr textBufPtr = textBuf->Des();
readStream.ReadL(textBufPtr, textCount/2);
static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF))->SetPromptTextL
(textBuf->Des(), pIcfData->iCleanContent);
CleanupStack::PopAndDestroy(textBuf);
}
else
{
static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF))->SetPromptTextL(KNullDesC, pIcfData->iCleanContent);
}
CleanupStack::PopAndDestroy(dataBuf);
CleanupStack::PopAndDestroy(&readStream);
}
void CPeninputGenericVkbWindow::UpdateLafData()
{
TRAP_IGNORE( iLafMgr->UpdateLafDataL() );
}
void CPeninputGenericVkbWindow::ReorgnizeICFAndButtons()
{
TRect rect;
TPoint winPoint = Rect().iTl;
TPoint LafPoint = iLafMgr->EntirePaneRect().iTl;
TInt x = winPoint.iX - LafPoint.iX;
TInt y = winPoint.iY - LafPoint.iY;
if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
x = 0;
y = 0;
}
TRect inRect;
TRect exRect;
rect = iLafMgr->ICFRect();
rect.Move(x, y);
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
const CFont* icfFont = iLafMgr->ICFTextFont();
// set icf margin
TPeninputICFConfig icfConfig;
iLafMgr->GetICFConfig( icfConfig );
icf->SetTextMargin( icfConfig.iLeftMargin,
icfConfig.iRightMargin,
icfConfig.iTopMargin,
0 );
icf->SetLineSpace( icfConfig.iLineSpaceMargin );
TRAP_IGNORE(icf->SizeChangedL(
rect,
icfConfig.iTextLineHeight,
icfFont->FontMaxHeight(),
icfFont));
if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
iLafMgr->GetButtonRect(
EPeninutWindowCtrlIdMultiRangeBtn, exRect, inRect );
exRect.Move(x, y);
inRect.Move(x, y);
static_cast<CAknFepCtrlEventButton*>
( Control( EPeninutWindowCtrlIdMultiRangeBtn ))->SizeChanged(
exRect, inRect, ETrue );
TRAP_IGNORE( icf->MsgBubbleCtrl()->SetTextL( KEmptyString ));
iIndiWithText = EFalse;
IndiBubbleWithoutText();
}
iLafMgr->GetButtonRect(EPeninutWindowCtrlIdOptionBtn,exRect ,inRect);
exRect.Move(x, y);
inRect.Move(x, y);
static_cast<CAknFepCtrlEventButton*>
( Control( EPeninutWindowCtrlIdOptionBtn ) )->SizeChanged( exRect, inRect, ETrue );
iLafMgr->GetButtonRect(EPeninutWindowCtrlIdCloseBtn,exRect ,inRect);
exRect.Move(x, y);
inRect.Move(x, y);
static_cast<CAknFepCtrlCommonButton*>
( Control( EPeninutWindowCtrlIdCloseBtn ) )->SizeChanged( exRect, inRect, ETrue );
iLafMgr->GetButtonRect(EPeninutWindowCtrlIdBackspaceBtn,exRect ,inRect);
exRect.Move(x, y);
inRect.Move(x, y);
// Check size change of bk button, need for mirroring when arabic
CAknFepCtrlCommonButton* bkBtn = static_cast<CAknFepCtrlCommonButton*>
( Control( EPeninutWindowCtrlIdBackspaceBtn ) );
TBool bBKSizeChanged = EFalse;
if( exRect.Size() != bkBtn->Rect().Size() &&
inRect.Size() != bkBtn->ForgroundBmpRect().Size() )
{
bBKSizeChanged = ETrue;
}
bkBtn->SizeChanged( exRect, inRect, ETrue );
iLafMgr->GetButtonRect(EPeninutWindowCtrlIdSpaceBtn,exRect ,inRect);
inRect = exRect;
inRect.Shrink(10, 0);
exRect.Move(x, y);
inRect.Move(x, y);
static_cast<CAknFepCtrlCommonButton*>
( Control( EPeninutWindowCtrlIdSpaceBtn ) )->SizeChanged( exRect, inRect, ETrue );
TRect spaceIconRect = inRect;
spaceIconRect.Shrink(10, 0);
static_cast<CAknFepCtrlCommonButton*>
( Control( EPeninutWindowCtrlIdSpaceBtn ) )->SetDraw3PieceFrameInfo(
TDraw3PiecesFrame(KAknsIIDQgnIndiInputSpaceL,
KAknsIIDQgnIndiInputSpaceMiddle,
KAknsIIDQgnIndiInputSpaceR,
spaceIconRect));
if ( iLayoutContext->LayoutType() == EPluginInputModeFSQ )
{
iLafMgr->GetButtonRect(EPeninupWindowCtrlIdArrowLeftBtn,exRect ,inRect);
exRect.Move(x, y);
inRect.Move(x, y);
iArrowLeftButton->SizeChanged( exRect, inRect, ETrue );
iLafMgr->GetButtonRect(EPeninupWindowCtrlIdArrowRightBtn,exRect ,inRect);
exRect.Move(x, y);
inRect.Move(x, y);
iArrowRightButton->SizeChanged( exRect, inRect, ETrue );
}
else
{
iLafMgr->GetButtonRect(EPeninutWindowCtrlIdMoveBtn,exRect ,inRect);
exRect.Move(x, y);
inRect.Move(x, y);
static_cast<CAknFepCtrlDragButton*>
( Control( EPeninutWindowCtrlIdMoveBtn ) )->SizeChanged( exRect, inRect, ETrue );
}
//If backspace size changed when language is RtoL mirror should be used
if( bBKSizeChanged && IsRtoLLanguage( iLanguage ) )
{
//Mirror backspace graphic
HandleButtonResOnLangDirChange( EPeninutWindowCtrlIdBackspaceBtn );
}
}
void CPeninputGenericVkbWindow::ShowBubble(TInt aShow)
{
if (aShow > 0)
{
iVkbCtrl->ShowBubble(ETrue);
}
else
{
iVkbCtrl->ShowBubble(EFalse);
}
}
void CPeninputGenericVkbWindow::ConstructAccentListL(TInt aLang)
{
iPopupWnd->ClearItemsL();
if (aLang == ELangVietnamese)
{
_LIT( KVietAccentList1, "\x00E0 - \x013A" );
_LIT( KVietAccentList2, "\x013C - \x017E" );
CFepLayoutChoiceList::SItem item;
item.iCommand = EPeninputVkbLayoutAccented1;
item.iText.Copy( KVietAccentList1 );
iPopupWnd->AddItemL( item );
item.iCommand = EPeninputVkbLayoutAccented2;
item.iText.Copy( KVietAccentList2 );
iPopupWnd->AddItemL( item );
}
// 10X3
else if (aLang == ELangEnglish
|| aLang == ELangAmerican
|| aLang == ELangDutch
|| aLang == ELangTagalog
|| aLang == ELangIndonesian
|| aLang == ELangMalay)
{
_LIT( KVietAccentList1, "\x00E0 - \x0121" );
_LIT( KVietAccentList2, "\x0123 - \x014F" );
_LIT( KVietAccentList3, "\x0151 - \x017E" );
CFepLayoutChoiceList::SItem item;
item.iCommand = EPeninputVkbLayoutAccented1;
item.iText.Copy( KVietAccentList1 );
iPopupWnd->AddItemL( item );
item.iCommand = EPeninputVkbLayoutAccented2;
item.iText.Copy( KVietAccentList2 );
iPopupWnd->AddItemL( item );
item.iCommand = EPeninputVkbLayoutAccented3;
item.iText.Copy( KVietAccentList3 );
iPopupWnd->AddItemL( item );
}
//10X4
else
{
// Add item
TResourceReader reader;
CFepLayoutChoiceList::SItem item;
item.iCommand = EPeninputVkbLayoutAccented1;
CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT1 );
TPtrC p1 = reader.ReadTPtrC();
item.iText.Copy( p1 );
iPopupWnd->AddItemL( item );
CleanupStack::PopAndDestroy( 1 );
item.iCommand = EPeninputVkbLayoutAccented2;
CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT2 );
TPtrC p2 = reader.ReadTPtrC();
item.iText.Copy( p2 );
iPopupWnd->AddItemL( item );
CleanupStack::PopAndDestroy( 1 );
item.iCommand = EPeninputVkbLayoutAccented3;
CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT3 );
TPtrC p3 = reader.ReadTPtrC();
item.iText.Copy( p3 );
iPopupWnd->AddItemL( item );
CleanupStack::PopAndDestroy( 1 );
}
iPopupWnd->SetListColumnNumWithLafL( iPopupWnd->ItemsCount() );
iPopupInited = ETrue;
iPopupSet = ETrue;
}
// ---------------------------------------------------------------------------
// Load accent labels for range list
// ---------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::ConstructFSQAccentListL( TInt aLangId )
{
iAccentCmdList.Reset();
TBool is10x3 = ( aLangId == ELangEnglish ) || ( aLangId == ELangAmerican )
|| ( aLangId == ELangDutch) || (aLangId == ELangTagalog )
|| ( aLangId == ELangIndonesian) || (aLangId == ELangMalay );
if ( aLangId == ELangVietnamese )
{
_LIT( KVietAccentList1, "\x00E0 - \x013A" );
_LIT( KVietAccentList2, "\x013C - \x017E" );
CFepLayoutChoiceList::SItem item;
item.iCommand = EPeninputVkbLayoutAccented1;
item.iText.Copy( KVietAccentList1 );
iAccentCmdList.Append( item );
item.iCommand = EPeninputVkbLayoutAccented2;
item.iText.Copy( KVietAccentList2 );
iAccentCmdList.Append( item );
}
else if( aLangId == ELangRussian || aLangId == ELangUkrainian || aLangId == ELangBulgarian )
{
_LIT( KCyrillicAccent, "\x00E0 - \x017E" );
CFepLayoutChoiceList::SItem item;
item.iCommand = EPeninputVkbLayoutAccented1;
item.iText.Copy( KCyrillicAccent );
iAccentCmdList.Append( item );
}
// 10X3
else if ( is10x3 )
{
_LIT( KVietAccentList1, "\x00E0 - \x0121" );
_LIT( KVietAccentList2, "\x0123 - \x014F" );
_LIT( KVietAccentList3, "\x0151 - \x017E" );
CFepLayoutChoiceList::SItem item;
item.iCommand = EPeninputVkbLayoutAccented1;
item.iText.Copy( KVietAccentList1 );
iAccentCmdList.Append( item );
item.iCommand = EPeninputVkbLayoutAccented2;
item.iText.Copy( KVietAccentList2 );
iAccentCmdList.Append( item );
item.iCommand = EPeninputVkbLayoutAccented3;
item.iText.Copy( KVietAccentList3 );
iAccentCmdList.Append( item );
}
//10X4
else
{
// Add item
TResourceReader reader;
CFepLayoutChoiceList::SItem item;
item.iCommand = EPeninputVkbLayoutAccented1;
CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT1 );
TPtrC p1 = reader.ReadTPtrC();
item.iText.Copy( p1 );
iAccentCmdList.Append( item );
CleanupStack::PopAndDestroy( 1 ); //reader
item.iCommand = EPeninputVkbLayoutAccented2;
CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT2 );
TPtrC p2 = reader.ReadTPtrC();
item.iText.Copy( p2 );
iAccentCmdList.Append( item );
CleanupStack::PopAndDestroy( 1 ); //reader
item.iCommand = EPeninputVkbLayoutAccented3;
CCoeEnv::Static()->CreateResourceReaderLC( reader, R_PENINPUT_VKB_ACCENT3 );
TPtrC p3 = reader.ReadTPtrC();
item.iText.Copy( p3 );
iAccentCmdList.Append( item );
CleanupStack::PopAndDestroy( 1 );//reader
}
iPopupInited = ETrue;
iPopupSet = ETrue;
}
void CPeninputGenericVkbWindow::UpdateICFTextL()
{
CFepLayoutMultiLineIcf* icf =
static_cast<CFepLayoutMultiLineIcf*>(Control(EPeninputWindowCtrlIdMultiLineICF));
if( icf )
{
icf->UpdateSecretTextL();
}
}
void CPeninputGenericVkbWindow::HandleButtonResOnLangDirChange( TInt aControlId )
{
TRAP_IGNORE(HandleButtonResOnLangDirChangeL(aControlId));
}
void CPeninputGenericVkbWindow::HandleButtonResOnLangDirChangeL( TInt aControlId )
{
CAknFepCtrlCommonButton* ctrl = static_cast<CAknFepCtrlCommonButton*>(
Control(aControlId) );
if( ctrl && iBmpRotator)
{
TSyncRotationAngle rotChoice = CBitmapRotator::EMirrorVerticalAxis;
User::LeaveIfError( iBmpRotator->Rotate( *ctrl->ForgroundBmp() ,
rotChoice ) );
User::LeaveIfError( iBmpRotator->Rotate( *ctrl->ForgroundBmpMask() ,
rotChoice ) );
}
}
// --------------------------------------------------------------------------
// Show tooltip of ICF
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::ShowTooltipL( const TDesC& aText, TInt aLangCode )
{
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
CPeninputGenericVkbLayout* layout
= static_cast<CPeninputGenericVkbLayout*>( UiLayout() );
if ( !icf || !( layout->IsEnableITIOnFSQ() ) )
{
return;
}
// Calculate tooltip width
const TPeninputTooltipBoxLayoutData& tooltipBoxLAF
= iLafMgr->TooltipBoxLayoutData();
TRect tooltipRect = tooltipBoxLAF.iRect;
// Calculate inner rect
TRect innerRect = tooltipRect;
innerRect.iTl += TPoint( KTooltipLeftMargin, KTooltipTopMargin );
innerRect.iBr -= TPoint( KTooltipRightMargin, KTooltipBottomMargin );
const CFont* font = tooltipBoxLAF.iFont;
// Set inner width in terms of text width
innerRect.SetWidth( font->TextWidthInPixels( aText ) );
tooltipRect.iTl
= innerRect.iTl - TPoint( KTooltipLeftMargin, KTooltipTopMargin );
tooltipRect.iBr
= innerRect.iBr + TPoint( KTooltipRightMargin, KTooltipBottomMargin );
// Set tooltip rect in terms of inner rect
icf->ShowTooltipL( aText, tooltipRect, aLangCode );
}
// --------------------------------------------------------------------------
// Hide tooltip of ICF
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::HideTooltip()
{
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
if ( !icf )
{
return;
}
icf->HideTooltip();
}
// --------------------------------------------------------------------------
// Hide candidate list
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::HideCandidateList()
{
if ( !iCandidateList )
{
return;
}
iCandidateList->Hide( ETrue );
}
// --------------------------------------------------------------------------
// Show candidate list
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::ShowCandidateListL( TInt aAlign, const CDesCArray* aItemArray,
TInt aActiveIndex )
{
if ( !iCandidateList )
{
return;
}
iCandidateList->ClearItemsL();
iCandidateList->SetTextAlignment((CGraphicsContext::TTextAlign) aAlign);
if ( aItemArray )
{
CFepLayoutChoiceList::SItem item;
item.iCommand = 0;
for (TInt i = 0; i < aItemArray->Count(); ++i)
{
if ((*aItemArray)[i].Length() <= item.iText.MaxLength())
{
item.iText.Copy((*aItemArray)[i]);
}
else
{
// Given longer than maxlength, display the part of less than max
item.iText.Copy((*aItemArray)[i].Left(item.iText.MaxLength()));
}
iCandidateList->AddItemL( item );
}
}
iCandidateList->SetCurrentFocusedIndex( aActiveIndex );
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
TPoint posBelow( 0, 0 );
TPoint posRight( 0, 0 );
posBelow = posRight = icf->Rect().iTl;
icf->InlineTextPos( posBelow, posRight );
TPoint tlPos = posRight;
iCandidateList->Display( TRect( tlPos, tlPos ),
CFepLayoutPopupWnd::EDispBottomRight );
}
// --------------------------------------------------------------------------
// Handle candidate list selected events.
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::HandleCandidateListSelectedL
( CFepUiBaseCtrl* aCtrl, const TDesC& aEventData )
{
if ( aCtrl != iCandidateList )
{
return;
}
CFepLayoutChoiceList::SEvent* event =
(CFepLayoutChoiceList::SEvent*)aEventData.Ptr();
if ( event->iIndex != KErrNotFound )
{
TPtrC ptr;
ptr.Set( reinterpret_cast<TUint16*>(&( event->iIndex ) ),
sizeof( TInt ) );
UiLayout()->SignalOwner( ESignalSelectCandidate, ptr );
}
}
// --------------------------------------------------------------------------
// Create a candidate list control.
// --------------------------------------------------------------------------
//
void CPeninputGenericVkbWindow::CreateCandidateListL()
{
iCandidateList = CFepLayoutScrollableList::NewL(
UiLayout(),
EPentinputHwrCandidateList,
TSize( 0, 0 ),
0,
0,
TSize( 0, 0 ),
TSize( 0, 0 ) );
iCandidateList->SetImgFrId(KAknsIIDQsnFrPopupSub,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive,
KAknsIIDQsnFrList,
KAknsIIDQsnFrPopupSub);
iCandidateList->SetResourceId(R_PENINPUT_FSQ_CANDIDATE_LIST);
iCandidateList->ConstructFromResourceL();
iCandidateList->SetPageInfoResID( R_PENINPUT_FSQ_CANDIDATE_LIST_PAGE_NUM );
iCandidateList->AddEventObserver( UiLayout() );
AddControlL(iCandidateList);
}
// --------------------------------------------------------------------------
// Retrieve text color from skin for candidiate list.
// --------------------------------------------------------------------------
//
TRgb CPeninputGenericVkbWindow::CandidateListTextColor()
{
MAknsSkinInstance* skininstance = UiLayout()->SkinInstance();
TRgb matchlistcolor = KRgbBlack;
AknsUtils::GetCachedColor( skininstance,
matchlistcolor,
KAknsIIDQsnTextColors,
EAknsCIQsnTextColorsCG43 );
return matchlistcolor;
}
// --------------------------------------------------------------------------
// Retrieve text color from skin for autocompletion part.
// --------------------------------------------------------------------------
//
TRgb CPeninputGenericVkbWindow::AutoCompletionPartColor()
{
MAknsSkinInstance* skininstance = UiLayout()->SkinInstance();
TRgb matchlistcolor = KRgbBlack;
AknsUtils::GetCachedColor( skininstance,
matchlistcolor,
KAknsIIDQsnTextColors,
EAknsCIQsnTextColorsCG64 );
return matchlistcolor;
}
void CPeninputGenericVkbWindow::SetIndiBubbleImageL( const TInt aImgID1,
const TInt aMaskID1,
const TInt aImgID2,
const TInt aMaskID2 )
{
MAknsSkinInstance* skininstance = UiLayout()->SkinInstance();
CFbsBitmap* bmp1 = NULL;
CFbsBitmap* mask1 = NULL;
TInt colorIndex = EAknsCIQsnIconColorsCG30;
AknsUtils::CreateColorIconL(skininstance,
KAknsIIDQsnIconColors,
KAknsIIDQsnIconColors,
colorIndex,
bmp1,
mask1,
AknIconUtils::AvkonIconFileName(),
aImgID1,
aMaskID1,
KRgbGray);
CleanupStack::PushL( bmp1 );
CleanupStack::PushL( mask1 );
AknIconUtils::GetContentDimensions(bmp1, iIndicatorSize);
CFbsBitmap* bmp2 = NULL;
CFbsBitmap* mask2 = NULL;
AknsUtils::CreateColorIconL(skininstance,
KAknsIIDQsnIconColors,
KAknsIIDQsnIconColors,
colorIndex,
bmp2,
mask2,
AknIconUtils::AvkonIconFileName(),
aImgID2,
aMaskID2,
KRgbGray);
CleanupStack::PushL( bmp2 );
CleanupStack::PushL( mask2 );
AknIconUtils::GetContentDimensions(bmp2, iIndicatorTextSize);
TRect boundRect;
if ( iIndiWithText )
{
boundRect = iLafMgr->IndiIconRectWithText();
}
else
{
boundRect = iLafMgr->IndiIconRectWithoutText();
}
TRect imgrect, textrect;
CalIndicatorRect(boundRect, imgrect, textrect, EIndiAlignCenter);
AknIconUtils::SetSize(bmp1, imgrect.Size(), EAspectRatioNotPreserved);
AknIconUtils::SetSize(mask1, imgrect.Size(), EAspectRatioNotPreserved);
AknIconUtils::SetSize(bmp2, textrect.Size(), EAspectRatioNotPreserved);
AknIconUtils::SetSize(mask2, textrect.Size(), EAspectRatioNotPreserved);
CFbsBitmap* bmp3 = AknPenImageUtils::CombineTwoImagesL(bmp1, bmp2, bmp1->DisplayMode());
CFbsBitmap* mask3 = AknPenImageUtils::CombineTwoImagesL(mask1, mask2, EGray256);
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
icf->MsgBubbleCtrl()->SetBitmapParam( bmp3, mask3,
KAknsIIDQsnFrInputPreviewSideL,
KAknsIIDQsnFrInputPreviewMiddle,
KAknsIIDQsnFrInputPreviewSideR );
CleanupStack::PopAndDestroy( mask2 );
CleanupStack::PopAndDestroy( bmp2 );
CleanupStack::PopAndDestroy( mask1 );
CleanupStack::PopAndDestroy( bmp1 );
}
void CPeninputGenericVkbWindow::CalIndicatorRect(const TRect& aBoundRect,
TRect& aRealRect1,
TRect& aRealRect2,
TIndicatorAlign aAlign)
{
TInt imgAspectText = iIndicatorTextSize.iWidth / iIndicatorTextSize.iHeight;
TInt imgAspectIndi = iIndicatorSize.iWidth / iIndicatorSize.iHeight;
TSize imgSizeText( aBoundRect.Size().iHeight * imgAspectText,
aBoundRect.Size().iHeight );
TSize imgSizeIndi( aBoundRect.Size().iHeight * imgAspectIndi,
aBoundRect.Size().iHeight );
// check if the length of img > bound rect width
TInt nTotalWidth = imgSizeText.iWidth + imgSizeIndi.iWidth;
if( nTotalWidth > aBoundRect.Size().iWidth )
{
TReal nAspect = (TReal)imgSizeText.iWidth / nTotalWidth;
imgSizeText.iWidth = aBoundRect.Size().iWidth * nAspect;
imgSizeIndi.iWidth = aBoundRect.Size().iWidth - imgSizeText.iWidth;
imgSizeText.iHeight = imgSizeText.iWidth / imgAspectText;
// make sure the height of two rect is equal
imgSizeIndi.iHeight = imgSizeText.iHeight;
}
if( aAlign == EIndiAlignRight )
{
aRealRect2 = TRect(TPoint( aBoundRect.iBr.iX - imgSizeText.iWidth, aBoundRect.iTl.iY),
imgSizeText);
aRealRect1 = TRect(TPoint(aRealRect2.iTl.iX - imgSizeIndi.iWidth, aRealRect2.iTl.iY),
imgSizeIndi);
}
else if( aAlign == EIndiAlignCenter )
{
TInt offsetX = ( aBoundRect.Size().iWidth - imgSizeText.iWidth - imgSizeIndi.iWidth ) / 2;
TInt offsetY = ( aBoundRect.Size().iHeight - imgSizeText.iHeight ) / 2;
aRealRect2 = TRect( TPoint( aBoundRect.iBr.iX - imgSizeText.iWidth - offsetX,
aBoundRect.iTl.iY + offsetY),
imgSizeText );
aRealRect1 = TRect( TPoint(aRealRect2.iTl.iX - imgSizeIndi.iWidth, aRealRect2.iTl.iY),
imgSizeIndi );
}
else if( aAlign == EIndiAlignLeft )
{
aRealRect1 = TRect( aBoundRect.iTl, imgSizeIndi );
aRealRect2 = TRect( TPoint( aRealRect1.iBr.iX, aRealRect1.iTl.iY ), imgSizeText );
}
}
void CPeninputGenericVkbWindow::IndiBubbleWithText()
{
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
if ( icf )
{
TAknTextLineLayout textLine = iLafMgr->IndiText();
TRect bubbleRect = iLafMgr->IndiPaneRectWithText();
TRect iconRect = iLafMgr->IndiIconRectWithText();
TSize offset;
offset.iHeight = iconRect.iTl.iY - bubbleRect.iTl.iY;
offset.iWidth = iconRect.iTl.iX - bubbleRect.iTl.iX;
TSize size( iconRect.Width(), iconRect.Height());
icf->MsgBubbleCtrl()->SetRect( bubbleRect );
icf->MsgBubbleCtrl()->SetIconOffsetAndSize( offset, size );
icf->MsgBubbleCtrl()->SetTextFormat( textLine );
icf->MsgBubbleCtrl()->SetTextColorIndex( EAknsCIQsnTextColorsCG67 );
}
}
void CPeninputGenericVkbWindow::IndiBubbleWithoutText()
{
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
if ( icf )
{
TRect bubbleRect = iLafMgr->IndiPaneRectWithoutText();
TRect iconRect = iLafMgr->IndiIconRectWithoutText();
TSize offset;
offset.iHeight = iconRect.iTl.iY - bubbleRect.iTl.iY;
offset.iWidth = iconRect.iTl.iX - bubbleRect.iTl.iX;
TSize size( iconRect.Width(), iconRect.Height());
icf->MsgBubbleCtrl()->SetRect( bubbleRect );
icf->MsgBubbleCtrl()->SetIconOffsetAndSize( offset, size );
}
}
void CPeninputGenericVkbWindow::SetIndiWithTextFlag( TBool aFlag )
{
iIndiWithText = aFlag;
}
void CPeninputGenericVkbWindow::UpdateIndiBubbleL( TUint8* aData )
{
CFepLayoutMultiLineIcf* icf = static_cast<CFepLayoutMultiLineIcf*>
(Control(EPeninputWindowCtrlIdMultiLineICF));
RDesReadStream readStream;
TFepIndicatorInfo indicatorData;
TPtr8 countPtr( aData, 4*sizeof(TInt), 4*sizeof(TInt) );
readStream.Open(countPtr);
CleanupClosePushL(readStream);
indicatorData.iIndicatorImgID = readStream.ReadInt32L();
indicatorData.iIndicatorMaskID = readStream.ReadInt32L();
indicatorData.iIndicatorTextImgID = readStream.ReadInt32L();
indicatorData.iIndicatorTextMaskID = readStream.ReadInt32L();
CleanupStack::PopAndDestroy(&readStream);
if ( indicatorData.iIndicatorImgID != 0 &&
indicatorData.iIndicatorMaskID != 0 &&
indicatorData.iIndicatorTextImgID != 0 &&
indicatorData.iIndicatorTextMaskID != 0 )
{
SetIndicatorData( indicatorData );
if ( icf )
{
SetIndiBubbleImageL( indicatorData.iIndicatorImgID,
indicatorData.iIndicatorMaskID,
indicatorData.iIndicatorTextImgID,
indicatorData.iIndicatorTextMaskID );
TBuf<100> text;
icf->MsgBubbleCtrl()->GetText( text );
icf->ShowBubble( text, icf->MsgBubbleCtrl()->Rect());
}
}
}
void CPeninputGenericVkbWindow::HandleRangeButtonShortPress()
{
const TInt range = CPeninputDataConverter::AnyToInt(
iLayoutContext->RequestData(EPeninputDataTypeCurrentRange));
const TInt langId = IntContext( EPeninputDataTypeInputLanguage );
switch ( langId )
{
case ELangRussian:
case ELangBulgarian:
case ELangUkrainian:
{
range == ERangeNative ? ChangeRange( ERangeNumber ) : ChangeRange( ERangeNative );
}
break;
case ELangArabic:
case ELangFarsi:
case ELangUrdu:
{
range == ERangeNative ? ChangeRange( ERangeNativeNumber ) : ChangeRange( ERangeNative );
}
break;
case ELangThai:
{
range == ERangeNative ? ChangeRange( ERangeNumber ) : ChangeRange( ERangeNative );
}
break;
case ELangGreek:
case ELangHebrew:
{
range == ERangeNative ? ChangeRange( ERangeNumber ) : ChangeRange( ERangeNative );
}
break;
default: // Latin, vietnamese, and other possible languages
{
if ( ConfigInfo()->RangeBarInfo()->FindRange( ERangeNative ) )
{
if ( range == ERangeNative )
{
if ( ConfigInfo()->RangeBarInfo()->FindRange( ERangeNativeNumber ) )
{
ChangeRange( ERangeNativeNumber );
}
else if ( ConfigInfo()->RangeBarInfo()->FindRange( ERangeNumber ) )
{
ChangeRange( ERangeNumber );
}
}
else
{
ChangeRange( ERangeNative );
}
}
else if ( ConfigInfo()->RangeBarInfo()->FindRange( ERangeEnglish ) )
{
range == ERangeEnglish ? ChangeRange( ERangeNumber ) : ChangeRange( ERangeEnglish );
}
}
break;
}
TRAP_IGNORE( UpdateRangeCtrlsL() );
}
// End Of File