/*
* Copyright (c) 2009 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 main window of finger hwr.
*
*/
// INCLUDE
#include <peninputfingerhwrcn.rsg>
#include <aknlayoutscalable_apps.cdl.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <peninputlayoutmultilineicf.h>
#include <peninputdropdownlist.h>
#include <peninputrepeatbutton.h>
#include <AknLayoutDef.h>
#include <AknUtils.h>
#include <AknsUtils.h>
#include <AknIconUtils.h>
#include <coemain.h>
#include <s32mem.h>
#include <peninputlayoutchoicelist.h>
#include <aknfeppeninputenums.h>
#include <AknFepGlobalEnums.h>
#include <peninputlayoutinputmodechoice.h>
#include <peninputrepeatbutton.h>
#include <peninputlayout.h>
#include <peninputlayoutbubblectrl.h>
#include <peninputlayoutvkb.h>
#include <peninputmultiimagebutton.h>
#include "peninputfingerhwrwnd.h"
#include "peninputfingerhwrlafmanager.h"
#include "peninputfingerhwrevent.h"
#include "peninputfingerhwrcontrolid.h"
#include "peninputfingerhwrstoreconstants.h"
#include "peninputfingerhwrlayout.h"
#include "peninputfingerhwrdatastore.h"
#include "peninputlayouthwrwnd.h"
#include "peninputmultipagevkb.h"
#include "peninputfingerhwrrangeselector.h"
#include "hbufcarray.h"
const TUint32 KDefaultTextColor = 0x000000;
const TUint KDefaultFrameColor = 0x000000;
const TUint32 KDefaultWriteBoxBgColor = 0xdddddd;
const TUint32 KDefaultWriteBoxFrameColor = 0x000000;
// ---------------------------------------------------------------------------
// Symbian Constructor
// ---------------------------------------------------------------------------
//
CPeninputFingerHwrWnd* CPeninputFingerHwrWnd::NewL( CFepUiLayout* aFepUiLayout,
TInt aControlId, TBool aLandscapeStyle )
{
CPeninputFingerHwrWnd* self = NewLC( aFepUiLayout, aControlId, aLandscapeStyle );
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// Symbian Constructor
// ---------------------------------------------------------------------------
//
CPeninputFingerHwrWnd* CPeninputFingerHwrWnd::NewLC( CFepUiLayout* aFepUiLayout,
TInt aControlId, TBool aLandscapeStyle )
{
CPeninputFingerHwrWnd* self = new ( ELeave ) CPeninputFingerHwrWnd( aFepUiLayout, aControlId );
CleanupStack::PushL( self );
self->ConstructL( aLandscapeStyle );
return self;
}
// ---------------------------------------------------------------------------
// c++ destructor
// ---------------------------------------------------------------------------
//
CPeninputFingerHwrWnd::~CPeninputFingerHwrWnd()
{
//delete by it's owner
iContextField = NULL;
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1 = NULL;
iFixEngSymbolList2 = NULL;
#endif
iCandidateList = NULL;
iPredictList = NULL;
iWritingBox = NULL;
iCloseBtn = NULL;
iOptionBtn = NULL;
iImeSwitchBtn = NULL;
iBackspaceBtn = NULL;
iArrowLeftBtn = NULL;
iArrowRightBtn = NULL;
iArrowUpBtn = NULL;
iArrowDownBtn = NULL;
iRangeSpecialBtn = NULL;
iRangeSelector = NULL;
iSctPage0Btn = NULL;
iSctPage1Btn = NULL;
iSctPage2Btn = NULL;
iVirtualNumpad = NULL;
iVirtualSctpad = NULL;
iVirtualSctpadFix = NULL;
iRangeSelector = NULL;
iInputModeSwitch = NULL;
delete iLafManager;
iLafManager = NULL;
}
// ---------------------------------------------------------------------------
// Construct control from resource.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::ConstructFromResourceL()
{
if ( iResourceId == KInvalidResId )
{
User::Leave( KErrArgument );
}
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, iResourceId );
TInt supportskin = reader.ReadInt16();
if ( iFirstTimeConstruct && ( supportskin != KNotSupportSkin ) )
{
UiLayout()->AddControlL( this );
}
// read shadow resources
TInt32 shadow = reader.ReadInt32();
ReadShadowInfoL( shadow );
// read icf resource
TInt32 icf = reader.ReadInt32();
ReadICFInfoL( icf );
if ( iFirstTimeConstruct )
{
const TInt32 boxwndResId = reader.ReadInt32();
const TInt32 bgImageResId = reader.ReadInt32();
ReadWritingBoxInfoL( boxwndResId );
ReadBackgroundInfoL( bgImageResId );
}
else
{
CControlGroup::ConstructFromResourceL();
const TInt32 boxwndResId = reader.ReadInt32();
const TInt32 bgImageResId = reader.ReadInt32();
ReadWritingBoxInfoL( boxwndResId );
ReadBackgroundInfoL( bgImageResId );
}
CleanupStack::PopAndDestroy(); // reader
// read keypad image info
if ( iVirtualNumpad )
{
TSize keysize = iLafManager->VirtualNumpadCellSize().Size();
LoadVkbKeyImageL( iVirtualNumpad, R_FINGER_HWR_NUMPAD_IMAGE, keysize );
RArray<TRect> rects;
CleanupClosePushL( rects );
iLafManager->GetVirtualKeyRects( rects );
LoadVirtualNumpadKeysL( R_FINGER_HWR_NUMPAD, rects );
CleanupStack::PopAndDestroy(); //rects
}
if ( iVirtualSctpad )
{
TSize keysize = iLafManager->VirtualSctpadCellSize().Size();
LoadVkbKeyImageL( iVirtualSctpad, R_FINGER_HWR_SCTPAD_IMAGE, keysize );
RArray<TRect> rects;
CleanupClosePushL( rects );
iLafManager->GetVirtualKeyRects( rects );
LoadVirtualSctpadKeysL( R_FINGER_HWR_SCTPAD, rects );
CleanupStack::PopAndDestroy(); //rects
}
if ( iVirtualSctpadFix )
{
TSize keysize = iLafManager->FixVirtualSctpadCellSize().Size();
LoadVkbKeyImageL( iVirtualSctpadFix, R_FINGER_HWR_SCTPAD_IMAGE, keysize );
RArray<TRect> rects;
CleanupClosePushL( rects );
iLafManager->GetFixVirtualKeyRects( rects );
LoadFixVirtualSctpadKeysL( R_FINGER_HWR_SCTPAD_FIX, rects );
CleanupStack::PopAndDestroy(); //rects
}
if (!iFirstTimeConstruct)
{
Draw();
}
iFirstTimeConstruct = EFalse;
}
// ---------------------------------------------------------------------------
// Draw window.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::Draw()
{
DrawOpaqueMaskBackground( Rect() );
if( BackgroundBmp() && BackgroundBmp()->SizeInPixels() != Rect().Size() )
{
AknIconUtils::SetSize(BackgroundBmp(), Rect().Size(), EAspectRatioNotPreserved);
}
DrawBackground();
CControlGroup::Draw();
UpdateArea( Rect(), EFalse );
}
// ---------------------------------------------------------------------------
// Resize.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SizeChangedL( TBool /*aLandscapeStyle*/ )
{
iLafManager->ReadLafInfo();
ResetLayoutL();
if ( iLafManager->IsLandscape() )
{
iPredictList->SetCandExpandType( CFepCtrlDropdownList::ECandExpandUpward );
}
else
{
iPredictList->SetCandExpandType( CFepCtrlDropdownList::ECandExpandDownward );
}
iCandidateList->SizeChanged( iLafManager->CandidateUnitWidth(),
iLafManager->CandidateUnitHeight(),
iLafManager->CandidateUnitWidth(),
iLafManager->CandidateLTPos(),
KCandidateCountPerRow,
1 );
iPredictList->SizeChanged( iLafManager->CandidateUnitWidth(),
iLafManager->CandidateUnitHeight(),
iLafManager->CandidateUnitWidth(),
iLafManager->PredictiveLTPos(),
KPredictiveCountPerRow,
KPredictiveRowCount );
if ( iFixEngSymbolList1 )
{
iFixEngSymbolList1->SizeChanged( iLafManager->CandidateUnitWidth(),
iLafManager->CandidateUnitHeight(),
iLafManager->CandidateUnitWidth(),
iLafManager->CandidateLTPos(),
KCandidateCountPerRow,
1 );
}
if ( iFixEngSymbolList2 )
{
iFixEngSymbolList2->SizeChanged( iLafManager->CandidateUnitWidth(),
iLafManager->CandidateUnitHeight(),
iLafManager->CandidateUnitWidth(),
iLafManager->PredictiveLTPos(),
KPredictiveCountPerRow,
1 );
}
iContextField->SetTextMargin ( iLafManager->IcfLeftMargin(),
iLafManager->IcfRightMargin(),
iLafManager->IcfTopMargin(),
iLafManager->IcfBottomMargin() );
iContextField->SetLineSpace( iLafManager->IcfLineSpaceMargin() );
iContextField->SizeChangedL( iLafManager->IcfRect(),
iLafManager->IcfTextHeight(),
iLafManager->IcfFont()->FontMaxHeight(),
iLafManager->IcfFont() );
}
// ---------------------------------------------------------------------------
// accept editor's text alignment.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetTextAlignmentL( TInt aAlignment, TInt aLangId )
{
if ( iContextField )
{
iContextField->SetTextAlignmentL( aAlignment, aLangId );
}
}
// ---------------------------------------------------------------------------
// accept editor's text
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetEditorTextL( const TFepInputContextFieldData& aData )
{
if ( iContextField )
{
iContextField->SetTextL( aData );
}
}
// ---------------------------------------------------------------------------
// accept editor's promopt txt.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetPromptTextL( TUint8* aPromoptData )
{
RDesReadStream readStream;
TPtr8 countPtr( aPromoptData, 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( aPromoptData+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 );
iContextField->SetPromptTextL( textBuf->Des(), ETrue );
CleanupStack::PopAndDestroy( textBuf );
}
else
{
iContextField->SetPromptTextL( KNullDesC, ETrue );
}
CleanupStack::PopAndDestroy( dataBuf );
CleanupStack::PopAndDestroy( &readStream );
}
// ---------------------------------------------------------------------------
// Dim option button
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetEnableSettingBtn(const TBool aEnable)
{
if ( aEnable )
{
iOptionBtn->SetDimmed(EFalse);
}
else
{
iOptionBtn->SetDimmed(ETrue);
iOptionBtn->SetActive(EFalse);
}
}
// ---------------------------------------------------------------------------
// accept editor's bubble text.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetBubbleTextL( const TDesC& aInfo )
{
if ( aInfo.Length() > 0 )
{
iContextField->ShowBubble( aInfo, iContextField->MsgBubbleCtrl()->Rect() );
}
else
{
iContextField->HideBubble();
}
}
// ---------------------------------------------------------------------------
// accept editor's char ranges restriction.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetPermittedRanges( const TInt aPermittedRanges )
{
if(aPermittedRanges == 0)
return;
iPermittedRanges = aPermittedRanges;
iRangeSelector->SetPermittedRanges( aPermittedRanges );
}
// ---------------------------------------------------------------------------
// accept editor's number mapping restriction.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetNumericMapping( const TDesC& aNumMapping )
{
//format of aNumMapping is "0123456789******"
//char offset in aNumMapping
//cell 0 using aNumMapping[KNumOffsets[0]]
//cell 1 using aNumMapping[KNumOffsets[1]]
const TInt KNumOffsets[] =
{
1, 2, 3, 15,
4, 5, 6, 14,
7, 8, 9, 13,
10, 0, 11, 12
};
TInt maxMappingItemCount = sizeof(KNumOffsets)/sizeof(TInt);
TInt mappingItemCount = aNumMapping.Length();
//numberpad
TInt keyCount = iVirtualNumpad->KeyArray().Count();
for ( TInt i = 0; i < keyCount; i++ )
{
CVirtualKey* vk = iVirtualNumpad->KeyArray()[i];
TInt offset = ( i < maxMappingItemCount ) ? KNumOffsets[i] : -1;
if ( offset > -1 && offset < mappingItemCount )
{
TUint16 unicode = aNumMapping[offset];
vk->SetKeyData( aNumMapping.Mid( offset,1 ) );
vk->SetKeyScancode( unicode );
vk->SetDimmed( EFalse );
}
else
{
vk->SetKeyData( KNullDesC );
vk->SetKeyScancode( 0xFFFF );
vk->SetDimmed( EFalse );
}
}
//sctpad
keyCount = iVirtualSctpad->KeyArray().Count();
if ( iPermittedRanges == ERangeNumber )
{
for ( TInt i = 0; i < keyCount; i++ )
{
CVirtualKey* vk = iVirtualSctpad->KeyArray()[i];
TInt pos = aNumMapping.Find( vk->KeyUnicodes() );
vk->SetDimmed( pos == KErrNotFound );
}
}
else
{
for ( TInt i = 0; i < keyCount; i++ )
{
CVirtualKey* vk = iVirtualSctpad->KeyArray()[i];
vk->SetDimmed( EFalse );
}
}
//sync feedback
UpdateAllVirtualKeysFeedback( CurrentCharRange() );
}
// ---------------------------------------------------------------------------
// accept editor's input language.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetInputLanguage( const TInt aLanguageId )
{
if ( iContextField )
{
iContextField->SetLanguageId( aLanguageId );
}
// special punctuations
const TInt KSpecialPuncPos[] = { 14, 15 };
const TInt KSpecialChsPunc[] = { 0x300A, 0x300B };
const TInt KSpecialChtPunc[] = { 0x300C, 0x300D };
TBool isCht = ( ELangHongKongChinese == aLanguageId ) ||
( ELangTaiwanChinese == aLanguageId );
TInt specialPuncCount = sizeof(KSpecialPuncPos)/sizeof(TInt);
for ( TInt i = 0; i < specialPuncCount; i++ )
{
TInt keypos = KSpecialPuncPos[i];
TInt charcode = isCht ? KSpecialChtPunc[i] : KSpecialChsPunc[i];
CVirtualKey* vk = iVirtualSctpad->KeyArray()[keypos];
if ( vk )
{
TBuf<1> buf;
buf.Append( charcode );
vk->SetKeyData( buf );
vk->SetKeyScancode( charcode );
}
}
}
// ---------------------------------------------------------------------------
// get strokes from hwr writing box.
// ---------------------------------------------------------------------------
//
const RArray<TPoint>& CPeninputFingerHwrWnd::StrokeList()
{
return iWritingBox->StrokeList();
}
// ---------------------------------------------------------------------------
// set end mark of hwr
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetStrokeEndMark( const TPoint& aEndMark )
{
iWritingBox->SetStrokeEndMark( aEndMark );
}
// ---------------------------------------------------------------------------
// set pen color of hwr writing.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetBoxPenColor( const TInt aPenColor )
{
iWritingBox->SetPenColor( aPenColor );
}
// ---------------------------------------------------------------------------
// set pen size of hwr writing.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetBoxPenSize( const TSize aPenSize )
{
iWritingBox->SetPenSize( aPenSize );
}
// ---------------------------------------------------------------------------
// set writing speed hwr writing.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetBoxWritingSpeed( const TTimeIntervalMicroSeconds32& aCharDelay )
{
iWritingBox->SetCharacterDelay( aCharDelay );
iWritingBox->SetStrokeDelay( 90000 );
}
// ---------------------------------------------------------------------------
// retrieve rect of hwr writingbox.
// ---------------------------------------------------------------------------
//
TRect CPeninputFingerHwrWnd::WritingBoxRect()
{
return iWritingBox->Rect();
}
// ---------------------------------------------------------------------------
// Cancel wrting
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CancelWriting()
{
iWritingBox->CancelCharWriting();
}
// ---------------------------------------------------------------------------
// Popup ime switch list.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::PopupImeSwitcher()
{
TRAP_IGNORE( iInputModeSwitch->PopUpSwitchListL( iImeSwitchBtn->Rect() ) );
}
// ---------------------------------------------------------------------------
// show range selection list.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::ShowRangeDropList( TInt aDirect )
{
iRangeSelector->SetCurRange( iCurCharRangeNoSct, iCurCharRange == iCurCharRangeNoSct );
iRangeSelector->Popup( aDirect );
}
// ---------------------------------------------------------------------------
// cancel range selection.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CancelRangeDropList()
{
iRangeSelector->CancelPopup();
UpdateArea( Rect(), EFalse );
}
// ---------------------------------------------------------------------------
// test whether the range selection list is visible.
// ---------------------------------------------------------------------------
//
TBool CPeninputFingerHwrWnd::RangeDropListVisible()
{
return iRangeSelector ? iRangeSelector->IsPopup() : EFalse;
}
// ---------------------------------------------------------------------------
// Change SCT page.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::ShowSctPage( TInt aPageNo, TInt aPos )
{
switch ( aPos )
{
case EPagePosPageNo:
{
iVirtualSctpad->NavToPage( aPageNo );
}
break;
default:
break;
}
UpdateSctPageButtonsUi();
UpdateAllVirtualKeysFeedback( EFingerHwrSymbolRange );
}
// ---------------------------------------------------------------------------
// sync sct paging buttons.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::UpdateSctPageButtonsUi()
{
TInt curpage = iVirtualSctpad->CurPageIndex();
TInt pagecount = iVirtualSctpad->PageCount();
iSctPage0Btn->Hide( curpage != 0 );
iSctPage1Btn->Hide( curpage != 1 );
iSctPage2Btn->Hide( curpage != 2 );
}
// ---------------------------------------------------------------------------
// retrieve the ICF control.
// ---------------------------------------------------------------------------
//
CFepLayoutMultiLineIcf* CPeninputFingerHwrWnd::Icf()
{
return iContextField;
}
// ---------------------------------------------------------------------------
// retrieve the predictive List control.
// ---------------------------------------------------------------------------
//
CFepCtrlDropdownList* CPeninputFingerHwrWnd::PredictiveList()
{
return iPredictList;
}
// ---------------------------------------------------------------------------
// retrieve the candicate list control.
// ---------------------------------------------------------------------------
//
CFepCtrlDropdownList* CPeninputFingerHwrWnd::CandidateList()
{
return iCandidateList;
}
// ---------------------------------------------------------------------------
// cancel all popped list.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CancelAllPopList()
{
if ( iRangeSelector->IsPopup() )
{
iRangeSelector->CancelPopup();
}
}
// ---------------------------------------------------------------------------
// Update layout
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::UpdateLayout( const TBool aIsStandby, const TBool aReloadCandicate, const TBool aReloadPredictive )
{
TRAP_IGNORE( UpdateLayoutL( aIsStandby, aReloadCandicate, aReloadPredictive ) );
}
// ---------------------------------------------------------------------------
// Update layout
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::UpdateLayoutL( const TBool aIsStandby,
const TBool aReloadCandicate, const TBool aReloadPredictive )
{
// Set the candidates when dropdown list is shown
if ( !aIsStandby )
{
typedef CFepCtrlDropdownList::TListType TDropListType;
CPeninputFingerHwrLayout* hwrLayout = NULL;
hwrLayout = static_cast<CPeninputFingerHwrLayout*>( UiLayout() );
CPeninputFingerHwrDataStore& datastore = hwrLayout->DataStore();
const RPointerArray<HBufC>& candidates = datastore.Candidate();
const RPointerArray<HBufC>& predictives = datastore.Predictive();
TDropListType expandable = CFepCtrlDropdownList::EListExpandableWithBubble;
TDropListType unexpandable = CFepCtrlDropdownList::EListNoExpandableWithBubble;
if ( datastore.PrimaryRange() == ERangeNative )
{
iCandidateList->Hide( EFalse );
iPredictList->Hide( EFalse );
if ( aReloadCandicate )
{
iCandidateList->SetCandidatesL( candidates, unexpandable );
}
SetCandHighlightCell();
// Re draw preview bubble after drawing highlight cell
iCandidateList->ReDrawBubble();
iPredictList->ReDrawBubble();
if ( aReloadPredictive )
{
iPredictList->SetCandidatesL( predictives, expandable );
}
}
else if ( datastore.PrimaryRange() == ERangeEnglish )
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
iCandidateList->Hide(EFalse);
iPredictList->Hide(EFalse);
if ( aReloadCandicate )
{
iCandidateList->SetCandidatesL( candidates, unexpandable );
}
if ( aReloadPredictive )
{
TBool canExpand = datastore.PredictiveCount() > KCandidateCount;
TDropListType type = canExpand ? expandable : unexpandable;
iPredictList->SetCandidatesL( predictives, type );
}
SetCandHighlightCell();
// Re draw preview bubble after drawing highlight cell
iCandidateList->ReDrawBubble();
iPredictList->ReDrawBubble();
#else
if(!iCandidateList->Hiden() && !iPredictList->Hiden())
{
if ( aReloadPredictive )
{
iCandidateList->SetCandidatesL( candidates, unexpandable );
iPredictList->SetCandidatesL( predictives, unexpandable );
}
iPredictList->SetHighlightCell( 0 );
// Re draw preview bubble after drawing highlight cell
iCandidateList->ReDrawBubble();
iPredictList->ReDrawBubble();
}
if(!iFixEngSymbolList1->Hiden() && !iFixEngSymbolList2->Hiden())
{
iFixEngSymbolList1->SetCandidatesL( candidates, unexpandable );
iFixEngSymbolList2->SetCandidatesL( predictives,unexpandable );
}
#endif
}
}
else
{
// hide all the dropdown list in standby state
iCandidateList->Hide( ETrue );
iPredictList->Hide( ETrue );
iCandidateList->ClearBubble();
iPredictList->ClearBubble();
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1->Hide( ETrue );
iFixEngSymbolList2->Hide( ETrue );
#endif
}
iArrowLeftBtn->Hide( !aIsStandby );
iArrowRightBtn->Hide( !aIsStandby );
iArrowUpBtn->Hide( !aIsStandby );
iArrowDownBtn->Hide( !aIsStandby );
iOptionBtn->Hide( !aIsStandby );
iImeSwitchBtn->Hide( !aIsStandby );
}
// ---------------------------------------------------------------------------
// Set highlight candidate cell when expand another list.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::SetCandHighlightCell()
{
// if expand predictive list upward before charactor time out,
// the candidate list will cover on expand predictive list.
// To avoid this problem, add this function.
CPeninputFingerHwrLayout* hwrLayout = NULL;
hwrLayout = static_cast<CPeninputFingerHwrLayout*>( UiLayout() );
CPeninputFingerHwrDataStore& datastore = hwrLayout->DataStore();
CFepUiBaseCtrl* capCtrl = RootControl()->CtrlCapPointer();
if(!(capCtrl && capCtrl->ControlId() == EHwrCtrlIdPredictiveList &&
iPredictList->CandExpandType() == CFepCtrlDropdownList::ECandExpandUpward))
{
// Set and draw highlight cell
iCandidateList->SetHighlightCell( 0, datastore.Highlight() );
}
else
{
// Just set the highlight cell without draw
iCandidateList->SetHighlightCell( 0, datastore.Highlight(), EFalse );
}
}
#ifndef RD_INTELLIGENT_TEXT_INPUT
// ---------------------------------------------------------------------------
// hide or show two eng-symbol candidate lists.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::HideTwoRowEngSymbolList( const TBool aIsHide )
{
iCandidateList->Hide( !aIsHide );
iPredictList->Hide( !aIsHide );
iFixEngSymbolList1->Hide( aIsHide );
iFixEngSymbolList2->Hide( aIsHide );
}
#endif
// ---------------------------------------------------------------------------
// dim arrow buttons.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::DimArrowKeys( TBool aDimArrow )
{
iArrowLeftBtn->SetDimmed( aDimArrow );
iArrowRightBtn->SetDimmed( aDimArrow );
iArrowUpBtn->SetDimmed( aDimArrow );
iArrowDownBtn->SetDimmed( aDimArrow );
}
// ---------------------------------------------------------------------------
// change layout to specified char range.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::TryToChangeCharRange( TInt aCharRange )
{
//CancelPopup must be called before LayoutStandby????
//if not, pointer is captured, unregister feedback area will failed.
if ( iRangeSelector->IsPopup() )
{
iRangeSelector->CancelPopup();
}
if ( iCurCharRange != aCharRange )
{
switch ( aCharRange )
{
case EFingerHwrNativeRange:
{
iCurCharRange = EFingerHwrNativeRange;
iCurCharRangeNoSct = EFingerHwrNativeRange;
LayoutStandbyChinese();
}
break;
case EFingerHwrEnglishRange:
{
iCurCharRange = EFingerHwrEnglishRange;
iCurCharRangeNoSct = EFingerHwrEnglishRange;
LayoutStandbyEnglish();
}
break;
case EFingerHwrNumberRange:
{
iCurCharRange = EFingerHwrNumberRange;
iCurCharRangeNoSct = EFingerHwrNumberRange;
LayoutStandbyNumeric();
}
break;
case EFingerHwrSymbolRange:
{
iCurCharRange = EFingerHwrSymbolRange;
LayoutStandbySymbol();
}
break;
default:
break;
}
TRAP_IGNORE(ReloadWritingGuideLinesL());
}
iRangeSelector->SetCurRange( iCurCharRangeNoSct, iCurCharRange == iCurCharRangeNoSct );
}
// ---------------------------------------------------------------------------
// retrieve char range of layout, including sct.
// ---------------------------------------------------------------------------
//
TInt CPeninputFingerHwrWnd::CurrentCharRange()
{
return iCurCharRange;
}
// ---------------------------------------------------------------------------
// restore the char range saved before sct.
// ---------------------------------------------------------------------------
//
TInt CPeninputFingerHwrWnd::RestoreNonSctLayout()
{
TInt rangeFlag = ERangeInvalid;
switch ( iCurCharRangeNoSct )
{
case EFingerHwrNativeRange:
{
rangeFlag = ERangeNative;
}
break;
case EFingerHwrEnglishRange:
{
rangeFlag = ERangeEnglish;
}
break;
case EFingerHwrNumberRange:
{
rangeFlag = ERangeNumber;
}
break;
default:
{
rangeFlag = ERangeInvalid;
}
break;
}
TryToChangeCharRange( iCurCharRangeNoSct );
return rangeFlag;
}
// ---------------------------------------------------------------------------
// c++ constructor
// ---------------------------------------------------------------------------
//
CPeninputFingerHwrWnd::CPeninputFingerHwrWnd(
CFepUiLayout* aFepUiLayout, TInt aControlId )
: CControlGroup( aFepUiLayout,aControlId ), iFirstTimeConstruct( ETrue )
{
iInEditWordQueryDlg = EFalse;
}
// ---------------------------------------------------------------------------
// Symbian second-phase constructor
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::ConstructL( TBool /*aLandscapeStyle*/ )
{
BaseConstructL();
iLafManager = CPeninputFingerHwrLAFManager::NewL();
iLafManager->ReadLafInfo();
//crate writing
CreateWritingBoxL();
//create icf
CreateContextFieldL();
//create candidate lists
CreateCandidateListL();
//create predictive lists
CreatePredictListL();
//create virtual num pad
CreateVirtualNumpadL();
//create virtual sct pad
CreateVirtualSctpadL();
//create space and backspace virtual pad
CreateFixVirtualSctpadL();
//create control buttons
CreateButtonsL();
//create range selecor
iRangeSelector = CPeninputFingerHwrRangeSelector::NewL(
UiLayout(), EHwrCtrlIdRangeSelector );
AddControlL( iRangeSelector );
//create ime selector
iInputModeSwitch = CPeninputLayoutInputmodelChoice::NewL(
UiLayout(), EHwrCtrlIdInputModeSwitcher,
EPluginInputModeFingerHwr );
iInputModeSwitch->SetListSkinID( KAknsIIDQsnFrList, KAknsIIDQsnFrPopupSub );
UiLayout()->AddControlL( iInputModeSwitch );
iInputModeSwitch->AddEventObserver( UiLayout() );
iCurCharRangeNoSct = EFingerHwrNativeRange;
iCurCharRange = EFingerHwrNativeRange;
ResetLayoutL();
LayoutStandbyChinese();
}
// ---------------------------------------------------------------------------
// create icf.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CreateContextFieldL()
{
const CFont* icffont =iLafManager->IcfFont();
iContextField = CFepLayoutMultiLineIcf::NewL(
iLafManager->IcfRect(),
UiLayout(),
EHwrCtrlIdInputContextField,
icffont->HeightInPixels(),
icffont->FontMaxHeight(),
icffont );
iContextField->SetTextMargin ( iLafManager->IcfLeftMargin(),
iLafManager->IcfRightMargin(),
iLafManager->IcfTopMargin(),
iLafManager->IcfBottomMargin() );
iContextField->SetLineSpace( iLafManager->IcfLineSpaceMargin() );
iContextField->SizeChangedL( iLafManager->IcfRect(),
iLafManager->IcfTextHeight(),
iLafManager->IcfFont()->FontMaxHeight(),
iLafManager->IcfFont() );
TAknWindowLineLayout bubbleLineLayout = AknLayoutScalable_Apps::popup_char_count_window().LayoutLine();
TAknTextLineLayout bubbleTextLayout = AknLayoutScalable_Apps::popup_char_count_window_t1( 0 ).LayoutLine();
iContextField->MsgBubbleCtrl()->SetTextFormat( bubbleTextLayout );
iContextField->MsgBubbleCtrl()->SetTextColorIndex( EAknsCIQsnTextColorsCG67 );
//Change the ID when ID into release
iContextField->MsgBubbleCtrl()->SetBitmapParam( NULL,
NULL,
KAknsIIDQsnFrInputPreviewSideL,
KAknsIIDQsnFrInputPreviewMiddle,
KAknsIIDQsnFrInputPreviewSideR );
iContextField->SetMsgBubbleCtrlSize( TSize( bubbleLineLayout.iW,bubbleLineLayout.iH ) );
//transfer to headerPane
AddControlL( iContextField );
//add layout as event observer
iContextField->AddEventObserver( UiLayout() );
iContextField->SetFocus();
}
// ---------------------------------------------------------------------------
// create candidate lists.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CreateCandidateListL()
{
TDropdownListDrawInfo candiDrawInfo(
KAknsIIDQsnFrFunctionButtonInactive,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrItutButtonCandiSideL,
KAknsIIDQsnFrItutButtonCandiMiddle,
KAknsIIDQsnFrItutButtonCandiSideR,
KAknsIIDQsnFrItutButtonCandiPressedSideL,
KAknsIIDQsnFrItutButtonCandiPressedMiddle,
KAknsIIDQsnFrItutButtonCandiPressedSideR,
TRgb( 194, 221, 242 ),
ETrue );
TInt unitWidth = iLafManager->CandidateUnitWidth();
TInt unitHeight = iLafManager->CandidateUnitHeight();
TPoint ltPosition = iLafManager->CandidateLTPos();
iCandidateList = CFepCtrlDropdownList::NewL( UiLayout(),
EHwrCtrlIdCandidateList,
R_FSHWR_CANDIDATE_DROP_DOWN_LIST, ltPosition,
TSize(unitWidth, unitHeight), KCandidateCountPerRow, 1 );
AddControlL( iCandidateList );
const CFont *font = iLafManager->CandidateFont();
TInt horizontalMargin = iLafManager->CandidateHorizontalMargin();
TInt verticalMargin = iLafManager->CandidateVerticalMargin();
iCandidateList->SetCellMargin( horizontalMargin, verticalMargin );
iCandidateList->SetFont( font );
// set the needed events
iCandidateList->SetEventIdForCandidateSelected( EHwrEventCandidateSelected );
iCandidateList->AddEventObserver( UiLayout() );
// hide the candidate list
iCandidateList->Hide( ETrue );
iCandidateList->SetDropdownListImgID( candiDrawInfo );
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1 = CFepCtrlDropdownList::NewL( UiLayout(),
EHwrCtrlIdFixEngSymbolList,
R_FSHWR_CANDIDATE_DROP_DOWN_LIST,
ltPosition,
TSize( unitWidth, unitHeight ),
KCandidateCountPerRow,
1 );
AddControlL( iFixEngSymbolList1 );
iFixEngSymbolList1->SetCellMargin( horizontalMargin, verticalMargin );
iFixEngSymbolList1->SetFont( font );
iFixEngSymbolList1->SetEventIdForCandidateSelected( EHwrEventCandidateSelected );
iFixEngSymbolList1->AddEventObserver( UiLayout() );
// hide the candidate list
iFixEngSymbolList1->Hide( ETrue );
iFixEngSymbolList1->SetDropdownListImgID( candiDrawInfo );
#endif
}
// ---------------------------------------------------------------------------
// create predictive lists.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CreatePredictListL()
{
TDropdownListDrawInfo predicDrawInfo(
KAknsIIDQsnFrFunctionButtonInactive,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrItutButtonComposeSideL,
KAknsIIDQsnFrItutButtonComposeMiddle,
KAknsIIDQsnFrItutButtonComposeSideR,
KAknsIIDQsnFrItutButtonComposePressedSideL,
KAknsIIDQsnFrItutButtonComposePressedSideR,
KAknsIIDQsnFrItutButtonComposePressedMiddle,
TRgb( 194, 221, 242 ),
ETrue );
TInt unitWidth = iLafManager->CandidateUnitWidth();
TInt unitHeight = iLafManager->CandidateUnitHeight();
TPoint ltPosition = iLafManager->PredictiveLTPos();
iPredictList = CFepCtrlDropdownList::NewL( UiLayout(),
EHwrCtrlIdPredictiveList,
R_FSHWR_PREDICT_DROP_DOWN_LIST,
ltPosition,
TSize( unitWidth, unitHeight ),
KPredictiveCountPerRow,
KPredictiveRowCount );
if ( iLafManager->IsLandscape() )
{
iPredictList->SetCandExpandType( CFepCtrlDropdownList::ECandExpandUpward );
}
AddControlL( iPredictList );
const CFont *font = iLafManager->CandidateFont();
TInt horizontalMargin = iLafManager->CandidateHorizontalMargin();
TInt verticalMargin = iLafManager->CandidateVerticalMargin();
iPredictList->SetCellMargin( horizontalMargin, verticalMargin );
iPredictList->SetFont( font );
// set the needed events
iPredictList->SetEventIdForCandidateSelected( EHwrEventPredictiveSelected );
iPredictList->SetEventIdForNextPageCandidate( EHwrEventGetNextCandidatePage );
iPredictList->AddEventObserver( UiLayout() );
// hide the predictive list
iPredictList->Hide( ETrue );
iPredictList->SetDropdownListImgID( predicDrawInfo );
iPredictList->SizeChanged( iLafManager->CandidateUnitWidth(),
iLafManager->CandidateUnitHeight(),
iLafManager->CandidateUnitWidth(),
iLafManager->PredictiveLTPos(),
KPredictiveCountPerRow,
KPredictiveRowCount );
#ifndef RD_INTELLIGENT_TEXT_INPUT
TDropdownListDrawInfo candiDrawInfo(
KAknsIIDQsnFrFunctionButtonInactive,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrItutButtonCandiSideL,
KAknsIIDQsnFrItutButtonCandiMiddle,
KAknsIIDQsnFrItutButtonCandiSideR,
KAknsIIDQsnFrItutButtonCandiPressedSideL,
KAknsIIDQsnFrItutButtonCandiPressedMiddle,
KAknsIIDQsnFrItutButtonCandiPressedSideR,
TRgb( 194, 221, 242 ),
ETrue );
iFixEngSymbolList2 = CFepCtrlDropdownList::NewL( UiLayout(),
EHwrCtrlIdFixEngSymbolList,
R_FSHWR_CANDIDATE_DROP_DOWN_LIST,
ltPosition,
TSize( unitWidth, unitHeight ),
KCandidateCountPerRow,
1 );
AddControlL( iFixEngSymbolList2 );
iFixEngSymbolList2->SetCellMargin( horizontalMargin, verticalMargin );
iFixEngSymbolList2->SetFont( font );
iFixEngSymbolList2->SetEventIdForCandidateSelected( EHwrEventCandidateSelected );
iFixEngSymbolList2->AddEventObserver( UiLayout() );
// hide the candidate list
iFixEngSymbolList2->Hide( ETrue );
iFixEngSymbolList2->SetDropdownListImgID( candiDrawInfo );
#endif
}
// ---------------------------------------------------------------------------
// create writing box.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CreateWritingBoxL()
{
iWritingBox = CTransparentHwrWnd::NewL( TRect( 0,0,0,0 ), UiLayout(),
EHwrCtrlIdWritingBox, EFalse );
AddControlL( iWritingBox );
//set it to window
iWritingBox->SetStrokeEndMark( TPoint( -1,0 ) );
iWritingBox->AddEventObserver( UiLayout() );
iWritingBox->EnableTraceOutsideWindow( EFalse );
iWritingBox->SetWndTransparencyFactor( 0 );
iWritingBox->InstallPenTraceDecoratorL( KNullDesC );
}
// ---------------------------------------------------------------------------
// create all function buttons.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CreateButtonsL()
{
iCloseBtn = CreateEventBtnL( EHwrCtrlIdClose, R_AKN_FEP_HWR_CLOSE );
iOptionBtn = CreateEventBtnL( EHwrCtrlIdLanguageOption, R_AKN_FEP_HWR_OPTION );
iImeSwitchBtn = CreateEventBtnL( EHwrCtrlIdVkbSwitcher, R_AKN_FEP_HWR_VKB );
iBackspaceBtn = CreateRepBtnL( EHwrCtrlIdBackspace, R_AKN_FEP_HWR_BACK_SPACE,
EHwrEventKeyBack, EKeyBackspace );
iArrowLeftBtn = CreateRepBtnL( EHwrCtrlIdArrowLeft, R_AKN_FEP_HWR_ARROWLEFT,
EHwrEventNavKeyClicked, EKeyLeftArrow );
iArrowRightBtn = CreateRepBtnL( EHwrCtrlIdArrowRight, R_AKN_FEP_HWR_ARROWRIGHT,
EHwrEventNavKeyClicked, EKeyRightArrow );
iArrowUpBtn = CreateRepBtnL( EHwrCtrlIdArrowUp, R_AKN_FEP_HWR_ARROWUP,
EHwrEventNavKeyClicked, EKeyUpArrow );
iArrowDownBtn = CreateRepBtnL( EHwrCtrlIdArrowDown, R_AKN_FEP_HWR_ARROWDOWN,
EHwrEventNavKeyClicked, EKeyDownArrow );
iRangeSpecialBtn = CreateEventBtnL( EHwrCtrlIdSymbolButton, R_AKN_FEP_HWR_RANGE_SPECIAL );
iSctPage0Btn = CreateEventBtnL( EHwrCtrlIdSctPage0Btn, R_AKN_FEP_HWR_SCT_PAGE_1 );
iSctPage1Btn = CreateEventBtnL( EHwrCtrlIdSctPage1Btn, R_AKN_FEP_HWR_SCT_PAGE_2 );
iSctPage2Btn = CreateEventBtnL( EHwrCtrlIdSctPage2Btn, R_AKN_FEP_HWR_SCT_PAGE_3 );
}
// ---------------------------------------------------------------------------
// create virtual number pad.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CreateVirtualNumpadL()
{
TFontSpec spec;
iVirtualNumpad = CVirtualKeyboard::NewL(
TRect( 0,0,0,0 ),
UiLayout(),
EHwrCtrlIdNumpad,
spec );
AddControlL( iVirtualNumpad );
iVirtualNumpad->AddEventObserver( UiLayout() );
iVirtualNumpad->SetResourceId( KInvalidResId );
// read keypad image info
TSize keysize = iLafManager->VirtualNumpadCellSize().Size();
LoadVkbKeyImageL( iVirtualNumpad, R_FINGER_HWR_NUMPAD_IMAGE, keysize );
RArray<TRect> rects;
CleanupClosePushL( rects );
iLafManager->GetVirtualKeyRects( rects );
LoadVirtualNumpadKeysL( R_FINGER_HWR_NUMPAD, rects );
CleanupStack::PopAndDestroy(); //rects
iVirtualNumpad->SetKeyTextColorGroup( EAknsCIQsnTextColorsCG65 );
iVirtualNumpad->SetDrawOpaqueBackground( EFalse );
//set key to be 9 piece graphics
iVirtualNumpad->SetKeySkinId( EKeyBmpNormal, KAknsIIDQsnFrKeypadButtonFrNormal );
iVirtualNumpad->SetKeySkinId( EKeyBmpHighlight, KAknsIIDQsnFrKeypadButtonFrPressed );
iVirtualNumpad->SetKeySkinId( EKeyBmpDim, KAknsIIDQsnFrKeypadButtonFrInactive );
}
// ---------------------------------------------------------------------------
// create virtual sct pad.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CreateVirtualSctpadL()
{
TFontSpec spec;
iVirtualSctpad = CMultiPageVirtualKeyboard::NewL(
iLafManager->CtrlRect(EHwrCtrlIdSctpad),
UiLayout(),
EHwrCtrlIdSctpad,
spec );
AddControlL( iVirtualSctpad );
iVirtualSctpad->AddEventObserver( UiLayout() );
iVirtualSctpad->SetResourceId( KInvalidResId );
// read keypad image info
TSize keysize = iLafManager->VirtualSctpadCellSize().Size();
LoadVkbKeyImageL( iVirtualSctpad, R_FINGER_HWR_SCTPAD_IMAGE, keysize );
RArray<TRect> rects;
CleanupClosePushL( rects );
iLafManager->GetVirtualKeyRects( rects );
LoadVirtualSctpadKeysL( R_FINGER_HWR_SCTPAD, rects );
CleanupStack::PopAndDestroy();//rects
TInt rows = iLafManager->VirtualSctpadRowCount();
TInt cols = iLafManager->VirtualSctpadColCount();
iVirtualSctpad->UpdatePaging( rows, cols );
iVirtualSctpad->SetKeyTextColorGroup( EAknsCIQsnTextColorsCG65 );
iVirtualSctpad->SetDrawOpaqueBackground( EFalse );
//set key to be 9 piece graphics
iVirtualSctpad->SetKeySkinId( EKeyBmpNormal, KAknsIIDQsnFrKeypadButtonFrNormal );
iVirtualSctpad->SetKeySkinId( EKeyBmpHighlight, KAknsIIDQsnFrKeypadButtonFrPressed );
iVirtualSctpad->SetKeySkinId( EKeyBmpDim, KAknsIIDQsnFrKeypadButtonFrInactive );
}
// ---------------------------------------------------------------------------
// create virtual sct pad.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::CreateFixVirtualSctpadL()
{
TFontSpec spec;
iVirtualSctpadFix = CVirtualKeyboard::NewL(
iLafManager->CtrlRect(EHwrCtrlIdSctpadFix),
UiLayout(),
EHwrCtrlIdSctpadFix,
spec );
AddControlL( iVirtualSctpadFix );
iVirtualSctpadFix->AddEventObserver( UiLayout() );
iVirtualSctpadFix->SetResourceId( KInvalidResId );
// read keypad image info
TSize keysize = iLafManager->FixVirtualSctpadCellSize().Size();
LoadVkbKeyImageL( iVirtualSctpadFix, R_FINGER_HWR_SCTPAD_IMAGE, keysize );
RArray<TRect> rects;
CleanupClosePushL( rects );
iLafManager->GetFixVirtualKeyRects( rects );
LoadFixVirtualSctpadKeysL( R_FINGER_HWR_SCTPAD_FIX, rects );
CleanupStack::PopAndDestroy();//rects
iVirtualSctpadFix->SetKeyTextColorGroup( EAknsCIQsnTextColorsCG65 );
iVirtualSctpadFix->SetDrawOpaqueBackground( EFalse );
//set key to be 9 piece graphics
iVirtualSctpadFix->SetKeySkinId( EKeyBmpNormal, KAknsIIDQsnFrKeypadButtonFrNormal );
iVirtualSctpadFix->SetKeySkinId( EKeyBmpHighlight, KAknsIIDQsnFrKeypadButtonFrPressed );
iVirtualSctpadFix->SetKeySkinId( EKeyBmpDim, KAknsIIDQsnFrKeypadButtonFrInactive );
}
// ---------------------------------------------------------------------------
// EventButton creation helper.
// ---------------------------------------------------------------------------
//
CAknFepCtrlEventButton* CPeninputFingerHwrWnd::CreateEventBtnL( TInt aCtrlId,
TInt32 aResId, TInt aEvent/*= 0xFFFF*/,TInt aUnicode/*=0*/ )
{
CAknFepCtrlEventButton* button = CAknFepCtrlEventButton::NewL(
UiLayout(), aCtrlId, aEvent, aUnicode,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive );
button->SetResourceId( aResId );
button->ConstructFromResourceL();
button->AddEventObserver( UiLayout() );
AddControlL( button );
return button;
}
// ---------------------------------------------------------------------------
// RepeatButton creation helper.
// ---------------------------------------------------------------------------
//
CAknFepCtrlRepeatButton* CPeninputFingerHwrWnd::CreateRepBtnL( const TInt aCtrlId,
TInt32 aResId, const TInt aEvent, const TInt aUnicode )
{
CAknFepCtrlRepeatButton* button = CAknFepCtrlRepeatButton::NewL(
UiLayout(), aCtrlId, aEvent, aUnicode,
KAknsIIDQsnFrFunctionButtonNormal,
KAknsIIDQsnFrFunctionButtonPressed,
KAknsIIDQsnFrFunctionButtonInactive );
button->SetResourceId( aResId );
button->ConstructFromResourceL( );
button->AddEventObserver( UiLayout() );
AddControlL( button );
return button;
}
// ---------------------------------------------------------------------------
// load virtual number pad images.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::LoadVkbKeyImageL( CVirtualKeyboard* aVkb,
TInt aResId, const TSize& aKeySize )
{
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, aResId );
TPtrC bmpFileName = reader.ReadTPtrC();
TInt32 imgMajorSkinId = reader.ReadInt32();
TAknsItemID id;
TSize keySize = aKeySize;
for ( TInt index = 0; index <= EKeyBmpLastType ; index += 2 )
{
// Get the image ids and mask ids from resource
TInt bmpId = reader.ReadInt16();
TInt bmpMskId = reader.ReadInt16();
// read skin item id
const TInt skinitemid = reader.ReadInt16();
id.Set( TInt( imgMajorSkinId ), skinitemid );
if ( bmpId != KInvalidImg )
{
CFbsBitmap* bmp = NULL;
CFbsBitmap* maskbmp = NULL;
if ( bmpMskId != KInvalidImg )
{
AknsUtils::CreateIconL( UiLayout()->SkinInstance(),
id, bmp, maskbmp, bmpFileName, bmpId, bmpMskId );
// set maskbmp and size
AknIconUtils::SetSize( maskbmp, keySize, EAspectRatioNotPreserved );
aVkb->SetNonIrregularKeyBitmapL(
TVirtualKeyBmpType( EKeyBmpNormal + index + 1 ), maskbmp );
}
else
{
AknsUtils::CreateIconL( UiLayout()->SkinInstance(), id,
bmp, bmpFileName, bmpId );
}
// set bmp and size
AknIconUtils::SetSize( bmp, keySize, EAspectRatioNotPreserved );
aVkb->SetNonIrregularKeyBitmapL(
TVirtualKeyBmpType( EKeyBmpNormal + index ), bmp );
}
}
// Pop and destroy reader
CleanupStack::PopAndDestroy( 1 );
}
// ---------------------------------------------------------------------------
// create virtual key.
// ---------------------------------------------------------------------------
//
CVirtualKey* CPeninputFingerHwrWnd::CreateVkbKeyL( TResourceReader& aReader,
const TRect aKeyRect )
{
CHBufCArray* keytexts = CHBufCArray::NewL();
CleanupStack::PushL( keytexts );
for ( TInt i = 0; i <= EPosLast; i++ )
{
HBufC* unicode = aReader.ReadHBufCL();
keytexts->Array().AppendL( unicode );
}
TInt keyscancode = aReader.ReadInt16();
HBufC* text = keytexts->Array()[0];
CVirtualKey* vk = NULL;
if ( text )
{
vk = CVirtualKey::NewL( *text, keyscancode, aKeyRect, aKeyRect, 0 );
}
else
{
vk = CVirtualKey::NewL( KNullDesC, keyscancode, aKeyRect, aKeyRect, 0 );
}
CleanupStack::PopAndDestroy( keytexts ); //keytexts
TRect innerrect = aKeyRect;
innerrect.Shrink( TSize(10, 10) );
vk->SetInnerRect( innerrect );
return vk;
}
// ---------------------------------------------------------------------------
// update virtual key info.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::UpdateVkbKeyL( CVirtualKey* aVirtualKey,
TResourceReader& aReader, const TRect aKeyRect )
{
CHBufCArray* keytexts = CHBufCArray::NewL();
CleanupStack::PushL( keytexts );
for ( TInt i = 0; i <= EPosLast; i++ )
{
HBufC* unicode = aReader.ReadHBufCL();
keytexts->Array().AppendL( unicode );
}
TInt keyscancode = aReader.ReadInt16();
HBufC* text = keytexts->Array()[0];
if ( text )
{
aVirtualKey->SetKeyData( *text );
}
else
{
aVirtualKey->SetKeyData( KNullDesC );
}
aVirtualKey->SetKeyScancode( keyscancode );
CleanupStack::PopAndDestroy( keytexts ); //keytexts
TRect innerrect = aKeyRect;
innerrect.Shrink( TSize(10,10) );
aVirtualKey->SetInnerRect( innerrect );
}
// ---------------------------------------------------------------------------
// load virtual number keys.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::LoadVirtualNumpadKeysL(
const TInt aResId, const RArray<TRect>& aCellRects )
{
iVirtualNumpad->SetResourceId( aResId );
TAknTextLineLayout txtlayout = iLafManager->NumpadKeyTxtLayout();
iVirtualNumpad->SetTextLineLayout( txtlayout );
TInt fontid = txtlayout.FontId();
const CFont* font = AknLayoutUtils::FontFromId( fontid );
iVirtualNumpad->SetFont( font );
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, aResId );
// construct keys
TInt resKeyCount = reader.ReadInt16();
TInt existsKeyCount = iVirtualNumpad->KeyArray().Count();
TInt rectCount = aCellRects.Count();
for ( TInt i = 0; i < resKeyCount; i++ )
{
if ( i < existsKeyCount )
{
CVirtualKey* vk = iVirtualNumpad->KeyArray()[i];
UpdateVkbKeyL( vk, reader, aCellRects[i%rectCount] );
}
else
{
CVirtualKey* vk = CreateVkbKeyL( reader, aCellRects[i%rectCount] );
CleanupStack::PushL( vk );
iVirtualNumpad->AddKeyL( vk );
CleanupStack::Pop( vk );
}
}
CleanupStack::PopAndDestroy( 1 ); // reader
iVirtualNumpad->Draw();
iVirtualNumpad->UpdateArea( iVirtualNumpad->Rect() );
}
// ---------------------------------------------------------------------------
// load virtual sct keys.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::LoadVirtualSctpadKeysL( const TInt aResId,
const RArray<TRect>& aCellRects )
{
iVirtualSctpad->SetResourceId( aResId );
TAknTextLineLayout txtlayout = iLafManager->SctpadKeyTxtLayout();
iVirtualSctpad->SetTextLineLayout( txtlayout );
TInt fontid = txtlayout.FontId();
const CFont* font = AknLayoutUtils::FontFromId( fontid );
iVirtualSctpad->SetFont( font );
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, aResId );
// construct keys
TInt resKeyCount = reader.ReadInt16();
TInt existsKeyCount = iVirtualSctpad->KeyArray().Count();
TInt rectCount = aCellRects.Count();
for ( TInt i = 0; i < resKeyCount; i++ )
{
if ( i < existsKeyCount )
{
CVirtualKey* vk = iVirtualSctpad->KeyArray()[i];
UpdateVkbKeyL( vk, reader, aCellRects[i%rectCount] );
}
else
{
CVirtualKey* vk = CreateVkbKeyL( reader, aCellRects[i%rectCount] );
CleanupStack::PushL( vk );
iVirtualSctpad->AddKeyL( vk );
CleanupStack::Pop( vk );
}
}
CleanupStack::PopAndDestroy( 1 ); // reader
iVirtualSctpad->Draw();
iVirtualSctpad->UpdateArea( iVirtualSctpad->Rect() );
}
// ---------------------------------------------------------------------------
// load virtual sct keys.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::LoadFixVirtualSctpadKeysL( const TInt aResId,
const RArray<TRect>& aCellRects )
{
iVirtualSctpadFix->SetResourceId( aResId );
TAknTextLineLayout txtlayout = iLafManager->FixSctpadKeyTxtLayout();
iVirtualSctpadFix->SetTextLineLayout( txtlayout );
TInt fontid = txtlayout.FontId();
const CFont* font = AknLayoutUtils::FontFromId( fontid );
iVirtualSctpadFix->SetFont( font );
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, aResId );
// construct keys
TInt resKeyCount = reader.ReadInt16();
TInt existsKeyCount = iVirtualSctpadFix->KeyArray().Count();
TInt rectCount = aCellRects.Count();
for ( TInt i = 0; i < resKeyCount; i++ )
{
if ( i < existsKeyCount )
{
CVirtualKey* vk = iVirtualSctpadFix->KeyArray()[i];
UpdateVkbKeyL( vk, reader, aCellRects[i] );
}
else
{
CVirtualKey* vk = CreateVkbKeyL( reader, aCellRects[i] );
CleanupStack::PushL( vk );
iVirtualSctpadFix->AddKeyL( vk );
CleanupStack::Pop( vk );
}
}
CleanupStack::PopAndDestroy( 1 ); // reader
iVirtualSctpadFix->Draw();
iVirtualSctpadFix->UpdateArea( iVirtualSctpadFix->Rect() );
}
// ---------------------------------------------------------------------------
// relayout full ui, reset all controls position.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::ResetLayoutL()
{
TRect rcScreen = iLafManager->LayoutRect();
SetRect( rcScreen );
TRect rect;
//Move ICF
rect = iLafManager->CtrlRect( iContextField->ControlId() );
iContextField->SetRect( rect );
//Move Writing box
rect = iLafManager->CtrlRect( iWritingBox->ControlId() );
iWritingBox->SetRect( rect );
//Move Virtual Numpad
if ( iVirtualNumpad )
{
rect = iLafManager->CtrlRect( iVirtualNumpad->ControlId() );
iVirtualNumpad->SetRect( rect );
TAknTextLineLayout txtlayout = iLafManager->NumpadKeyTxtLayout();
iVirtualNumpad->SetTextLineLayout( txtlayout );
const RPointerArray<CVirtualKey>& keys = iVirtualNumpad->KeyArray();
RArray<TRect> rects;
iLafManager->GetVirtualKeyRects( rects );
const TInt count = keys.Count();
for ( TInt i = 0; i < count; i++ )
{
CVirtualKey* vk = keys[i];
vk->SetRect( rects[i] );
}
rects.Reset();
rects.Close();
}
//move virtual Sctpad
if ( iVirtualSctpad )
{
rect = iLafManager->CtrlRect( iVirtualSctpad->ControlId() );
iVirtualSctpad->SetRect( rect );
TAknTextLineLayout txtlayout = iLafManager->SctpadKeyTxtLayout();
iVirtualSctpad->SetTextLineLayout( txtlayout );
const RPointerArray<CVirtualKey>& keys = iVirtualSctpad->KeyArray();
RArray<TRect> rects;
iLafManager->GetVirtualKeyRects( rects );
TInt n = rects.Count(); //num of cells in one page
for ( TInt i = 0; i < keys.Count(); i++ )
{
CVirtualKey* vk = keys[i];
vk->SetRect( rects[i%n] );
}
rects.Reset();
rects.Close();
}
//move virtual Sctpad
if ( iVirtualSctpadFix )
{
rect = iLafManager->CtrlRect( iVirtualSctpadFix->ControlId() );
iVirtualSctpadFix->SetRect( rect );
TAknTextLineLayout txtlayout = iLafManager->FixSctpadKeyTxtLayout();
iVirtualSctpadFix->SetTextLineLayout( txtlayout );
const RPointerArray<CVirtualKey>& keys = iVirtualSctpadFix->KeyArray();
RArray<TRect> rects;
iLafManager->GetFixVirtualKeyRects( rects );
TInt n = rects.Count(); //
for ( TInt i = 0; i < keys.Count(); i++ )
{
CVirtualKey* vk = keys[i];
vk->SetRect( rects[i] );
}
rects.Reset();
rects.Close();
}
//Move buttons
TSize siBtnPadding = iLafManager->ButtonInnerPadding();
TInt pdx = siBtnPadding.iWidth;
TInt pdy = siBtnPadding.iHeight;
rect = iLafManager->CtrlRect( iCloseBtn->ControlId() );
MoveIconButton( iCloseBtn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iRangeSpecialBtn->ControlId() );
MoveIconButton( iRangeSpecialBtn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iBackspaceBtn->ControlId() );
MoveIconButton( iBackspaceBtn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iArrowUpBtn->ControlId() );
MoveIconButton( iArrowUpBtn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iArrowLeftBtn->ControlId() );
MoveIconButton( iArrowLeftBtn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iArrowRightBtn->ControlId() );
MoveIconButton( iArrowRightBtn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iArrowDownBtn->ControlId() );
MoveIconButton( iArrowDownBtn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iOptionBtn->ControlId() );
MoveIconButton( iOptionBtn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iImeSwitchBtn->ControlId() );
MoveIconButton( iImeSwitchBtn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iSctPage0Btn->ControlId() );
MoveSwitchPageButton( iSctPage0Btn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iSctPage1Btn->ControlId() );
MoveSwitchPageButton( iSctPage1Btn, rect, pdx, pdy, ETrue );
rect = iLafManager->CtrlRect( iSctPage2Btn->ControlId() );
MoveSwitchPageButton( iSctPage2Btn, rect, pdx, pdy, ETrue );
//save range buttons position
iRectOfRangeBtn = iLafManager->CtrlRect( iRangeSelector->ControlId() );
//move range selector
iRangeSelector->SetRect( iRectOfRangeBtn );
iRangeSelector->SetBaseRect( iRectOfRangeBtn );
}
// ---------------------------------------------------------------------------
// layout for chinese range standby.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::LayoutStandbyChinese()
{
iCandidateList->Hide( ETrue );
iPredictList->Hide( ETrue );
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1->Hide( ETrue );
iFixEngSymbolList2->Hide( ETrue );
#endif
iWritingBox->Hide( EFalse );
iVirtualNumpad->Hide( ETrue );
iVirtualSctpad->Hide( ETrue );
iVirtualSctpadFix->Hide( ETrue );
iArrowLeftBtn->Hide( EFalse );
iArrowRightBtn->Hide( EFalse );
iArrowUpBtn->Hide( EFalse );
iArrowDownBtn->Hide( EFalse );
iOptionBtn->Hide( EFalse );
iImeSwitchBtn->Hide( EFalse );
iSctPage0Btn->Hide( ETrue );
iSctPage1Btn->Hide( ETrue );
iSctPage2Btn->Hide( ETrue );
iRangeSpecialBtn->SetHighlight( EFalse );
UpdateAllVirtualKeysFeedback( EFingerHwrNativeRange );
}
// ---------------------------------------------------------------------------
// layout for english range standby.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::LayoutStandbyEnglish()
{
iCandidateList->Hide( ETrue );
iPredictList->Hide( ETrue );
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1->Hide( ETrue );
iFixEngSymbolList2->Hide( ETrue );
#endif
iWritingBox->Hide( EFalse );
iVirtualNumpad->Hide( ETrue );
iVirtualSctpad->Hide( ETrue );
iVirtualSctpadFix->Hide( ETrue );
iArrowLeftBtn->Hide( EFalse );
iArrowRightBtn->Hide( EFalse );
iArrowUpBtn->Hide( EFalse );
iArrowDownBtn->Hide( EFalse );
iOptionBtn->Hide( EFalse );
iImeSwitchBtn->Hide( EFalse );
iSctPage0Btn->Hide( ETrue );
iSctPage1Btn->Hide( ETrue );
iSctPage2Btn->Hide( ETrue );
iRangeSpecialBtn->SetHighlight( EFalse );
UpdateAllVirtualKeysFeedback( EFingerHwrEnglishRange );
}
// ---------------------------------------------------------------------------
// layout for number range standby.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::LayoutStandbyNumeric()
{
iCandidateList->Hide( ETrue );
iPredictList->Hide( ETrue );
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1->Hide( ETrue );
iFixEngSymbolList2->Hide( ETrue );
#endif
iWritingBox->Hide( ETrue );
iVirtualNumpad->Hide( EFalse );
iVirtualSctpad->Hide( ETrue );
iVirtualSctpadFix->Hide( ETrue );
iArrowLeftBtn->Hide( EFalse );
iArrowRightBtn->Hide( EFalse );
iArrowUpBtn->Hide( EFalse );
iArrowDownBtn->Hide( EFalse );
iOptionBtn->Hide( EFalse );
iImeSwitchBtn->Hide( EFalse );
iSctPage0Btn->Hide( ETrue );
iSctPage1Btn->Hide( ETrue );
iSctPage2Btn->Hide( ETrue );
iRangeSpecialBtn->SetHighlight( EFalse );
UpdateAllVirtualKeysFeedback( EFingerHwrNumberRange );
}
// ---------------------------------------------------------------------------
// layout for symbol range standby.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::LayoutStandbySymbol()
{
iCandidateList->Hide( ETrue );
iPredictList->Hide( ETrue );
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1->Hide( ETrue );
iFixEngSymbolList2->Hide( ETrue );
#endif
iWritingBox->Hide( ETrue );
iVirtualNumpad->Hide( ETrue );
iArrowLeftBtn->Hide( ETrue );
iArrowRightBtn->Hide( ETrue );
iArrowUpBtn->Hide( ETrue );
iArrowDownBtn->Hide( ETrue );
iVirtualSctpad->Hide( EFalse );
iVirtualSctpadFix->Hide( EFalse );
iOptionBtn->Hide( EFalse );
iImeSwitchBtn->Hide( EFalse );
iRangeSpecialBtn->SetHighlight( ETrue );
TInt pageno = ( iCurCharRangeNoSct == EFingerHwrNativeRange ) ? 0 : 1;
ShowSctPage( pageno, EPagePosPageNo );
UpdateAllVirtualKeysFeedback( EFingerHwrSymbolRange );
UiLayout()->RootControl()->ReDrawRect( iVirtualSctpadFix->Rect() );
UpdateArea( iVirtualSctpadFix->Rect() );
}
// ---------------------------------------------------------------------------
// EventButton layout helper. Move button to specified rect.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::MoveIconButton( CAknFepCtrlEventButton* aButton,
const TRect& aRect, TInt aXPadding, TInt aYPadding, TBool aReloadImages )
{
if ( !aButton )
{
return;
}
aButton->SetRect( aRect );
TRect rcInner = aRect;
if ( rcInner.Width()> rcInner.Height() )
{
TInt dx = ( rcInner.Width() - rcInner.Height() ) / 2;
rcInner.Move( dx, 0 );
rcInner.SetWidth( rcInner.Height() );
}
else
{
TInt dy = ( rcInner.Height() - rcInner.Width() ) / 2;
rcInner.Move( 0, dy );
rcInner.SetHeight( rcInner.Width() );
}
rcInner.Shrink( aXPadding, aYPadding );
aButton->SizeChanged( aRect, rcInner, aReloadImages );
}
// ---------------------------------------------------------------------------
// EventButton layout helper.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::MoveSwitchPageButton( CAknFepCtrlEventButton* aButton,
const TRect& aRect, TInt aXPadding, TInt aYPadding, TBool aReloadImages )
{
if ( !aButton )
{
return;
}
aButton->SetRect( aRect );
TRect rcInner = aRect;
rcInner.Shrink( aXPadding + 5, aYPadding );
aButton->SizeChanged( aRect, rcInner, aReloadImages );
}
// ---------------------------------------------------------------------------
// Read control's shadow info.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::ReadShadowInfoL( const TInt aResId )
{
TResourceReader resReader;
CCoeEnv::Static()->CreateResourceReaderLC( resReader, aResId );
TPtrC bmpFileName = resReader.ReadTPtrC();
TInt32 imgMajorSkinId = resReader.ReadInt32();
TAknsItemID id;
TInt skinitemid;
MAknsSkinInstance* skininstance = UiLayout()->SkinInstance();
for ( TInt i = 0; i < KShadowBmpBr + 1; i++ )
{
const TInt16 bmpId = resReader.ReadInt16();
const TInt16 bmpMskId = resReader.ReadInt16();
skinitemid = resReader.ReadInt16();
id.Set( TInt( imgMajorSkinId ), skinitemid );
if ( bmpId != KInvalidImg )
{
CFbsBitmap* shadowImg = NULL;
CFbsBitmap* shadowMaskImg = NULL;
if ( bmpMskId != KInvalidImg )
{
AknsUtils::CreateIconL( skininstance,
id,
shadowImg,
shadowMaskImg,
bmpFileName,
bmpId,
bmpMskId );
}
else
{
AknsUtils::CreateIconL( skininstance,
id,
shadowImg,
bmpFileName,
bmpId );
}
SetShadowBmp( shadowImg, shadowMaskImg, TShadowBitmapIndex( i ) );
}
}
CleanupStack::PopAndDestroy( 1 ); // reader
}
// ---------------------------------------------------------------------------
// Read control's background info.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::ReadBackgroundInfoL( const TInt aResId )
{
if ( aResId == 0 )
return;
if ( BackgroundBmp() )
{
CFbsBitmap* bkBmp = BackgroundBmp();
delete bkBmp;
SetBackgroundBmp( NULL );
}
if ( BkMaskBmp() )
{
CFbsBitmap* bkMaskBmp = BkMaskBmp();
delete bkMaskBmp;
SetBackgroundMaskBmp( NULL );
}
TResourceReader resReader;
CCoeEnv::Static()->CreateResourceReaderLC( resReader, aResId );
TPtrC bmpFileName = resReader.ReadTPtrC();
TInt32 imgMajorSkinId = resReader.ReadInt32();
TAknsItemID id;
TInt skinitemid;
MAknsSkinInstance* skininstance = UiLayout()->SkinInstance();
const TInt16 bmpId = resReader.ReadInt16();
const TInt16 bmpMskId = resReader.ReadInt16();
skinitemid = resReader.ReadInt16();
id.Set( TInt( imgMajorSkinId ), skinitemid );
if ( bmpId != KInvalidImg )
{
CFbsBitmap* backgroundImg = NULL;
CFbsBitmap* backgroundMaskImg = NULL;
if ( bmpMskId != KInvalidImg )
{
AknsUtils::CreateIconL( skininstance, id, backgroundImg,
backgroundMaskImg, bmpFileName, bmpId, bmpMskId );
}
else
{
AknsUtils::CreateIconL( skininstance, id, backgroundImg,
bmpFileName, bmpId );
}
SetBackgroundBmp( backgroundImg );
SetBackgroundMaskBmp( backgroundMaskImg );
}
CleanupStack::PopAndDestroy( 1 ); //reader
}
// ---------------------------------------------------------------------------
// read icf appearance info.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::ReadICFInfoL( const TInt aResId )
{
if ( aResId == 0 )
{
return;
}
TResourceReader icfreader;
CCoeEnv::Static()->CreateResourceReaderLC( icfreader, aResId );
TInt32 colorMajorSkinId = icfreader.ReadInt32();
TInt skinitemid = icfreader.ReadInt16();
TInt coloridx = icfreader.ReadInt16();
TAknsItemID colorid;
colorid.Set( TInt( colorMajorSkinId ), skinitemid );
TRgb icftextcolor;
MAknsSkinInstance* skininstance = UiLayout()->SkinInstance();
TInt error = AknsUtils::GetCachedColor( skininstance, icftextcolor,
colorid, coloridx );
if ( error != KErrNone )
{
icftextcolor = TRgb( KDefaultTextColor );
}
iContextField->SetTextColorL( icftextcolor );
// Set highlight color
TRgb icfhightlightcolor;
error = AknsUtils::GetCachedColor( skininstance,
icfhightlightcolor,
KAknsIIDQsnHighlightColors,
EAknsCIQsnHighlightColorsCG2 );
if ( error == KErrNone )
{
iContextField->SetTextSelColorL( icfhightlightcolor );
}
skinitemid = icfreader.ReadInt16();
coloridx = icfreader.ReadInt16();
colorid.Set( TInt( colorMajorSkinId ), skinitemid );
TRgb icfframecolor;
error = AknsUtils::GetCachedColor( skininstance, icfframecolor,
colorid, coloridx );
if ( error != KErrNone )
{
icfframecolor = TRgb( KDefaultFrameColor );
}
iContextField->SetBorderColor( icfframecolor );
iContextField->SetBgImgSkinId( KAknsIIDQgnGrafFepInputBg );
CleanupStack::PopAndDestroy( 1 ); // icfreader
}
// ---------------------------------------------------------------------------
// read writingbox appearance info.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::ReadWritingBoxInfoL( const TInt aResId )
{
if ( aResId == 0 )
{
return;
}
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, aResId );
// get write box bg color
TInt32 colorMajorSkinId = reader.ReadInt32();
TInt skinitemid = reader.ReadInt16();
TInt coloridx = reader.ReadInt16();
TAknsItemID colorid;
colorid.Set( TInt( colorMajorSkinId ), skinitemid );
TRgb boxcolor;
MAknsSkinInstance* skininstance = UiLayout()->SkinInstance();
TInt error = AknsUtils::GetCachedColor( skininstance,
boxcolor,
colorid,
coloridx );
if ( error != KErrNone )
{
boxcolor = TRgb( KDefaultWriteBoxBgColor );
}
iWritingBoxBkColor = boxcolor;
iWritingBox->SetBkColor( boxcolor );
skinitemid = reader.ReadInt16();
coloridx = reader.ReadInt16();
colorid.Set( TInt( colorMajorSkinId ), skinitemid );
TRgb boxframecolor;
error = AknsUtils::GetCachedColor( skininstance,
boxframecolor,
colorid,
coloridx );
if ( error != KErrNone )
{
boxframecolor = TRgb( KDefaultWriteBoxFrameColor );
}
iWritingBoxFrameColor = boxframecolor;
iWritingBox->SetFrameCol( boxframecolor );
CleanupStack::PopAndDestroy(); // reader
ReloadWritingGuideLinesL();
}
// ---------------------------------------------------------------------------
// update feedback state of all virtual keys.
// ---------------------------------------------------------------------------
//
void CPeninputFingerHwrWnd::UpdateAllVirtualKeysFeedback( TInt aType )
{
if ( !UiLayout()->SupportTactileFeedback() )
{
// return ;
// CFepUiLayout::OnActivate() is incorrect
// SupportTactileFeedback return is false when touch is about to active
}
TBool isNumpad = ( aType == EFingerHwrNumberRange ) ? ETrue : EFalse;
TBool isSctpad = ( aType == EFingerHwrSymbolRange ) ? ETrue : EFalse;
//update numpad keys
TInt keyCount = iVirtualNumpad->KeyArray().Count();
for ( TInt i = 0; i < keyCount; i++ )
{
CVirtualKey* vk = iVirtualNumpad->KeyArray()[i];
TBool enable = !vk->Dimmed() && isNumpad;
iVirtualNumpad->EnableKeyFeedback( vk, enable );
}
//update sctpad keys
keyCount = iVirtualSctpad->KeyArray().Count();
TInt pageSize = iVirtualSctpad->PageSize();
TInt curPage = iVirtualSctpad->CurPageIndex();
for ( TInt i = 0; i < keyCount; i++ )
{
CVirtualKey* vk = iVirtualSctpad->KeyArray()[i];
TInt page = i / pageSize;
TBool enable = !vk->Dimmed() && isSctpad && ( page == curPage );
iVirtualSctpad->EnableKeyFeedback( vk, enable );
}
}
void CPeninputFingerHwrWnd::ReloadWritingGuideLinesL()
{
TInt resid = -1;
if( iCurCharRange == EFingerHwrNativeRange )
{
resid = R_FINGER_HWR_GUIDELINE_CHS;
}
else if( iCurCharRange == EFingerHwrEnglishRange )
{
resid = R_FINGER_HWR_GUIDELINE_ENG;
}
else
{
return;
}
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, resid );
TPtrC fileName = reader.ReadTPtrC();
TInt32 majorSkinId = reader.ReadInt32();
TInt16 indexOfColor = reader.ReadInt16();
TInt16 imageid = reader.ReadInt16();
TInt16 maskid = reader.ReadInt16();
TInt16 skinid = reader.ReadInt16();
TAknsItemID id;
id.Set( TInt( majorSkinId ), skinid );
CFbsBitmap* bmpImage = NULL;
CFbsBitmap* bmpMask = NULL;
//AknsUtils::CreateIconL(UiLayout()->SkinInstance(), id, bmpImage, bmpMask, bmpFileName, imageid,maskid);
TRgb colorBkgnd = iWritingBoxBkColor;
TRgb colorGuideLine = AKN_LAF_COLOR( 0 );
if ( ETrue )
{
TRgb color1 = colorBkgnd;
TRgb color2 = colorGuideLine;
TInt k = 64;
TInt brightness = Max( color1.Red(), color1.Green() );
brightness = Max( brightness, color1.Blue() );
color2 = ( brightness > 128 ) ? TRgb(0,0,0) : TRgb(255,255,255);
TInt r = ( color1.Red() * ( 256 - k ) + color2.Red() * k ) / 256;
TInt g = ( color1.Green()* ( 256 - k ) + color2.Green() * k ) / 256;
TInt b = ( color1.Blue() * ( 256 - k ) + color2.Blue() * k ) / 256;
colorGuideLine = TRgb(r,g,b);
}
AknsUtils::CreateColorIconL( UiLayout()->SkinInstance(),
id, KAknsIIDQsnIconColors, -1,
bmpImage, bmpMask, fileName, imageid, maskid,
colorGuideLine );
CleanupStack::PushL( bmpImage ); //1
CleanupStack::PushL( bmpMask ); //2
TSize imgsize = iLafManager->CtrlRect(EHwrCtrlIdWritingBox).Size();
AknIconUtils::SetSize( bmpImage, imgsize, EAspectRatioNotPreserved );
AknIconUtils::SetSize( bmpMask, imgsize, EAspectRatioNotPreserved );
//prepare to merge
CFbsBitmap* bmpMerged = new(ELeave) CFbsBitmap();
CleanupStack::PushL( bmpMerged ); //3
bmpMerged->Create( imgsize, BitmapDevice()->DisplayMode() );
CFbsBitmapDevice* dev=CFbsBitmapDevice::NewL( bmpMerged );
CleanupStack::PushL( dev ); //4
CFbsBitGc* gc = CFbsBitGc::NewL();
CleanupStack::PushL( gc ); //5
//merge image and mask to dest
TRect rcImage( TPoint(0,0), imgsize );
gc->Activate( dev );
gc->SetPenStyle( CGraphicsContext::ENullPen );
gc->SetBrushColor( colorBkgnd );
gc->SetBrushStyle( CGraphicsContext::ESolidBrush );
gc->DrawRect( rcImage );
gc->SetBrushStyle( CGraphicsContext::ENullBrush );
gc->BitBltMasked( TPoint(0,0), bmpImage, rcImage, bmpMask, EFalse );
CleanupStack::PopAndDestroy( 2 ); //gc, dev
iWritingBox->SetBackgroundBitmapL( bmpMerged );
iWritingBox->SetBackgroundMaskBitmapL( bmpMask );
CleanupStack::Pop( 2 ); //bmpMerged, bmpMask
CleanupStack::PopAndDestroy( 1 ); //bmpImage
CleanupStack::PopAndDestroy(); //reader
iWritingBox->ReDrawRect( iWritingBox->Rect() );
iWritingBox->UpdateArea( iWritingBox->Rect() );
}
void CPeninputFingerHwrWnd::ShowBubble(TInt aShow)
{
if (aShow > 0)
{
TRect outrect,innerrect;
iCandidateList->ShowBubble(ETrue);
iPredictList->ShowBubble(ETrue);
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1->ShowBubble(ETrue);
iFixEngSymbolList2->ShowBubble(ETrue);
#endif
// Set priview popup size
iCandidateList->SetBubbleBitmapParam(NULL,NULL,KAknsIIDQsnFrInputCharPreview);
outrect = iLafManager->PreviewBubbleRect();
innerrect = iLafManager->PreviewBubbleInnerRect();
iCandidateList->SetTextFormat(iLafManager->PreviewBubbleTextLayout());
iCandidateList->SetBubbleTextFont(iLafManager->PreviewBubbleFont());
iCandidateList->SetBubbleSize(TSize(outrect.Width(),outrect.Height())); // Read laf
iCandidateList->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);
iPredictList->SetBubbleBitmapParam(NULL,NULL,KAknsIIDQsnFrInputCharPreview);
iPredictList->SetTextFormat(iLafManager->PreviewBubbleTextLayout());
iPredictList->SetBubbleTextFont(iLafManager->PreviewBubbleFont());
iPredictList->SetBubbleSize(TSize(outrect.Width(),outrect.Height())); // Read laf
iPredictList->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);
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1->SetBubbleBitmapParam(NULL,NULL,KAknsIIDQsnFrInputCharPreview);
iFixEngSymbolList1->SetTextFormat(iLafManager->PreviewBubbleTextLayout());
iFixEngSymbolList1->SetBubbleTextFont(iLafManager->PreviewBubbleFont());
iFixEngSymbolList1->SetBubbleSize(TSize(outrect.Width(),outrect.Height())); // Read laf
iFixEngSymbolList1->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);
iFixEngSymbolList2->SetBubbleBitmapParam(NULL,NULL,KAknsIIDQsnFrInputCharPreview);
iFixEngSymbolList2->SetTextFormat(iLafManager->PreviewBubbleTextLayout());
iFixEngSymbolList2->SetBubbleTextFont(iLafManager->PreviewBubbleFont());
iFixEngSymbolList2->SetBubbleSize(TSize(outrect.Width(),outrect.Height())); // Read laf
iFixEngSymbolList2->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);
#endif
}
else
{
iCandidateList->ShowBubble(EFalse);
iPredictList->ShowBubble(EFalse);
#ifndef RD_INTELLIGENT_TEXT_INPUT
iFixEngSymbolList1->ShowBubble(EFalse);
iFixEngSymbolList2->ShowBubble(EFalse);
#endif
}
}
// End Of File