--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/textinput/peninputhwrfscn/src/peninputhwrengine.cpp Tue Feb 02 01:02:04 2010 +0200
@@ -0,0 +1,909 @@
+/*
+* 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 HWR engine
+*
+*/
+
+
+//FEP INCLUDES
+#include <AknFepGlobalEnums.h>
+#include <aknfeppeninputenums.h>
+#include <PtiHwrRecognizer.h>
+
+//USER INCLUDES
+#include "peninputhwrengine.h"
+#include "peninputhwrfscndatastore.h"
+
+// CONSTANT DEFINITION HEADER
+#include "peninputhwrfscnstoreconstants.h"
+
+// ---------------------------------------------------------------------------
+// SplitString()
+// ---------------------------------------------------------------------------
+//
+static TInt SplitString( const TPtrC &aPtr,
+ TUint16 aSeperator,
+ RPointerArray<HBufC>& aStringArray )
+ {
+ // phrase input mode
+ TInt start = 0;
+ TInt length = 0;
+
+ for ( TInt i = 0; i < aPtr.Length(); i++ )
+ {
+ if ( aPtr[i] == aSeperator )
+ {
+ TPtrC segment( aPtr.Ptr() + start, length );
+ TRAP_IGNORE( aStringArray.AppendL( segment.AllocL() ) );
+ start += ( length + 1 );
+ length = 0;
+ }
+ else
+ {
+ length++;
+ }
+ }
+
+ if ( length )
+ {
+ TPtrC segm( aPtr.Ptr() + start, length );
+ TRAP_IGNORE( aStringArray.AppendL( segm.AllocL() ) );
+ }
+
+ return aStringArray.Count();
+ }
+
+// ---------------------------------------------------------------------------
+// Symbian constructor
+// ---------------------------------------------------------------------------
+//
+CAknFepHwrEngine* CAknFepHwrEngine::NewL( CPtiEngine* aPtiEngine,
+ CPeninputHwrfscnDataStore* aOwner )
+ {
+ CAknFepHwrEngine* self = new ( ELeave ) CAknFepHwrEngine();
+
+ CleanupStack::PushL( self );
+ self->ConstructL( aPtiEngine, aOwner );
+ CleanupStack::Pop( self );//self
+
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// C++ constructor
+// ---------------------------------------------------------------------------
+//
+CAknFepHwrEngine::CAknFepHwrEngine()
+ {
+ iNeedSetNumberMode = EFalse;
+ iNeedSetCase = EFalse;
+ iNeedSetRange = EFalse;
+ iRecognizer = NULL;
+ iOwnPtiEngine = EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// destructor
+// ---------------------------------------------------------------------------
+//
+CAknFepHwrEngine::~CAknFepHwrEngine()
+ {
+ if( iOwnPtiEngine )
+ {
+ delete iPtiEngine;
+ }
+ delete iCustomKeymap;
+
+ delete iIdle;
+
+ iNeedPermittedRanges.Close();
+ }
+
+// ---------------------------------------------------------------------------
+// Second phase constructor
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::ConstructL( CPtiEngine* aPtiEngine,
+ CPeninputHwrfscnDataStore* aOwner )
+ {
+ if( !aPtiEngine )
+ {
+ iPtiEngine = CPtiEngine::NewL( ETrue );
+ iOwnPtiEngine = ETrue;
+ }
+ else
+ {
+ iPtiEngine = aPtiEngine;
+ }
+
+ iIdle = CIdle::NewL( CActive::EPriorityIdle );
+ iOwner = aOwner;
+ }
+
+// ---------------------------------------------------------------------------
+// Convert stroke end mark
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::ConvertStrokeEndMark( RArray<TPoint>& aTraceData,
+ TPoint aPnt1, TPoint aPnt2 )
+ {
+ TInt count = aTraceData.Count();
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ if ( aTraceData[i] == aPnt1 )
+ {
+ aTraceData.Remove( i );
+ aTraceData.Insert( aPnt2, i );
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Do recoginize by engine
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::DoRecognizeL( const RArray<TPoint>& aTraceData,
+ RPointerArray<HBufC>& aCandidates )
+ {
+ if ( !iRecognizer )
+ {
+ DoIdleConstructL();
+ }
+
+ TPoint ctrlStrokeEndMark = iOwner->StrokeEndMarkFromControl();
+
+ if ( ctrlStrokeEndMark != iRecognizer->StrokeEndMark() )
+ {
+ ConvertStrokeEndMark( CONST_CAST( RArray<TPoint>&, aTraceData ),
+ iOwner->StrokeEndMarkFromControl(),
+ iRecognizer->StrokeEndMark() );
+ iOwner->SetStrokeEndMark(); // make control's stroke end mark info same to engine
+ }
+
+ aCandidates.ResetAndDestroy();
+
+ //Do recognition for number only
+ if ( iOwner->IsNumberOnly() )
+ {
+ DoRecognizeOfNumberOnly( aTraceData,aCandidates );
+ return;
+ }
+
+ TInt primaryCount = iRecognizer->Recognize( aTraceData, aCandidates );
+
+ // filter recognized candidate, set start position for all ranges
+ TPtrC ptr( KSeparator );
+
+ // remove uncessary aux candidate, including range separator
+ for ( TInt i=0; i<aCandidates.Count(); i++ )
+ {
+ if ( aCandidates[i]->Compare( KGestureBackspace ) == 0 )
+ {
+ // convert backspace returned by engine, to make sure it display correctly.
+ *aCandidates[i] = KDisplayBackspace;
+ break;
+ }
+ }
+
+ //reorder the secondary range
+ ReorderSecondaryRange( aCandidates );
+
+ // remove uncessary primary candidate
+ TInt totallyCount = aCandidates.Count();
+ TInt removePos = iTotalCandidateNum;
+
+ for ( TInt i = removePos; i < totallyCount; i++ )
+ {
+ delete aCandidates[removePos];
+ aCandidates.Remove( removePos );
+ }
+
+ // not allowing '-' to be the first char in chinese range
+ // not allowing '/' to be the first char in English and Number range
+ TPtrC dashPtr( KDash );
+ TPtrC solidusPtr( KSolidus );
+ if ( ( iPremaryRange == ERangeNative ) &&
+ ( aCandidates[0]->Compare( dashPtr ) == 0 ) )
+ {
+ *aCandidates[0] = *aCandidates[1];
+ *aCandidates[1] = dashPtr;
+ }
+ else if ( ( ( iPremaryRange == ERangeEnglish ) ||
+ ( iPremaryRange == ERangeNumber ) )
+ && ( aCandidates[0]->Compare( solidusPtr ) == 0 ) )
+ {
+ *aCandidates[0] = *aCandidates[1];
+ *aCandidates[1] = solidusPtr;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Do recognition when the range is only number
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::DoRecognizeOfNumberOnly( const RArray<TPoint>& aTraceData,
+ RPointerArray<HBufC>& aCandidates )
+ {
+ if ( iNumberMode == EAknEditorPlainNumberModeKeymap )
+ {
+ TBuf<KPlainNumSize> buf;
+ buf.Append( KNumberString() );
+ buf.Append( KGestureBackspace );
+ iRecognizer->RecognizeWithCharSet( aTraceData, aCandidates, buf );
+ }
+ else
+ {
+ iRecognizer->Recognize( aTraceData, aCandidates );
+ }
+
+ //find special char and do special handling
+ TInt count = aCandidates.Count();
+ for ( TInt i = count - 1; i >= 0; i-- )
+ {
+ //the space and enter are not allowed to be appeared in candidates
+ if( ( *aCandidates[i] )[0] == KGestureSpace()[0] ||
+ ( *aCandidates[i] )[0] == KGestureEnter()[0] )
+ {
+ delete aCandidates[i];
+ aCandidates.Remove( i );
+ }
+ else if( aCandidates[i]->Compare( KGestureBackspace ) == 0 )
+ {
+ *aCandidates[i] = KDisplayBackspace;
+ }
+ }
+
+ if ( iCustomKeymap )
+ {
+ count = aCandidates.Count();
+ for( TInt i = count - 1; i >= 0; i-- )
+ {
+ if( iCustomKeymap->Find( *aCandidates[i] ) == KErrNotFound )
+ {
+ delete aCandidates[i];
+ aCandidates.Remove( i );
+ }
+ }
+ }
+
+ // remove uncessary primary candidate
+ count = aCandidates.Count() - iTotalCandidateNum;
+ for ( TInt i = 0; i < count; i++ )
+ {
+ delete aCandidates[iTotalCandidateNum];
+ aCandidates.Remove( iTotalCandidateNum );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Reorder secondary range in candidate list
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::ReorderSecondaryRange( RPointerArray<HBufC>& aCandidates )
+ {
+ if( iRangeCount <= 1 )
+ {
+ return;
+ }
+
+ RPointerArray<HBufC> secondary;
+ TInt auxCandidateNum = GetAuxCandidateNum();
+
+ HBufC* secCandidate = NULL;
+ TInt candiateCount = aCandidates.Count();
+
+ TInt primaryCountFromEng = 0;
+
+ // Get all secondary candidates
+ for( TInt i = 0; i < candiateCount; i++ )// "i" is the index of separater
+ {
+ if( aCandidates[i]->CompareC( KSeparator ) == 0 )
+ {
+ if(primaryCountFromEng == 0)
+ {
+ // Save the primary candidates count from ptiengine
+ primaryCountFromEng = i;
+ }
+ TInt auxCountFromEng = 0;
+ while(i < candiateCount - 1 && aCandidates[++i]->CompareC( KSeparator ) != 0)
+ {
+ // calculate the secondary range candidate count
+ auxCountFromEng++;
+
+ // Copy all the secondary candidate to an array
+ secCandidate = aCandidates[i]->Alloc();
+ secondary.Append( secCandidate );
+ }
+
+ for(TInt j = 0; j < auxCandidateNum - auxCountFromEng ; j++ )
+ {
+ // supply empty secondary candidate when engine not return
+ // enough cell
+ secondary.Append( KNullDesC().Alloc() );
+ }
+ i--; // go back to the separator index
+ }
+ }
+
+
+ // caculate the primary candidate count
+ TInt primaryCount = 0;
+ TInt rowCount = 0;
+
+ if( iPremaryRange == ERangeNumber )
+ {
+ primaryCount = KCandidateCountNumMode - iRangeCount + 1;
+ rowCount = 1;
+ }
+ else
+ {
+ primaryCount = KCandidateCountPerRow - iRangeCount + 1;
+ rowCount = KCandidateRowCount;
+ }
+
+ // supply empty primary candidate when engine not return
+ // enough cell
+ if(primaryCountFromEng < primaryCount * rowCount)
+ {
+ for(TInt y = 0; y < primaryCount * rowCount - primaryCountFromEng; y++)
+ {
+ aCandidates.Insert( KNullDesC().Alloc(), primaryCountFromEng );
+ }
+ }
+
+ // insert secondary candidates into the end of each row
+ for( ; rowCount > 0; rowCount-- )
+ {
+ for( TInt m = 0; m < iRangeCount - 1; m++ )
+ {
+ TInt secondaryIndex = rowCount - 1 + m * auxCandidateNum;
+ TInt insertPos = primaryCount * rowCount + m;
+ aCandidates.Insert( secondary[secondaryIndex], insertPos );
+ }
+ }
+ secondary.Reset();
+ secondary.Close();
+ }
+
+
+// ---------------------------------------------------------------------------
+// Do predictive using trigger string
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::DoPredictiveL( const TDesC& aTriggerStr,
+ RPointerArray<HBufC>& aPredictives,
+ TBool aNextPage )
+ {
+ // predictive only valid for Chinese
+ if ( ( iLanguage != ELangPrcChinese ) &&
+ ( iLanguage != ELangTaiwanChinese ) &&
+ ( iLanguage != ELangHongKongChinese ) )
+ {
+ return;
+ }
+
+ // activate correct pti language according to given language
+ if ( !aNextPage )
+ {
+ iPtiEngine->SetCandidatePageLength( KPredictiveCountPerPage );
+
+ aPredictives.ResetAndDestroy();
+ if( !iPtiEngine->SetPredictiveChineseChar( aTriggerStr ) )
+ {
+ return;
+ }
+ }
+ else
+ {
+ if ( !iPtiEngine->NextCandidatePage() )
+ {
+ return;
+ }
+ }
+
+ TPtrC ptr = iPtiEngine->CandidatePage();
+
+ if ( ( iPtiEngine->InputMode() == EPtiEnginePinyinVkb ) ||
+ ( iPtiEngine->InputMode() == EPtiEngineStrokeByPhrase ) ||
+ ( iPtiEngine->InputMode() == EPtiEngineZhuyinVkb ) )
+ {
+ SplitString( ptr, KSegment, aPredictives );
+ }
+ else
+ {
+ TInt predictiveCandidateNum = ptr.Length();
+
+ for ( TInt i=0; i<predictiveCandidateNum; i++ )
+ {
+ aPredictives.Append( ptr.Mid( i,1 ).AllocL() );
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// Do homophonic using trigger string
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::DoHomophonicL( const TDesC& aTriggerStr,
+ RPointerArray<HBufC>& aHomophonic )
+ {
+ // homophonic only valid for PRC Chinese and Taiwan Chinese
+ if ( ( iLanguage == ELangPrcChinese ) ||
+ ( iLanguage == ELangTaiwanChinese ) )
+ {
+ iPtiEngine->SetCandidatePageLength( KMaxHomophonicCandidateCount );
+ aHomophonic.ResetAndDestroy();
+
+ // get the spelling of the character
+ TBuf<KMaxSpellingsLettersNum> spelling;
+ TPtiSpelling spellingType = EPtiPinyin;
+
+ if ( iPtiEngine->InputMode() == EPtiEnginePinyinVkb )
+ {
+ spellingType = EPtiPinyin;
+ }
+ else if ( iPtiEngine->InputMode() == EPtiEngineZhuyinVkb )
+ {
+ spellingType = EPtiZhuyin;
+ }
+
+ TInt result = iPtiEngine->GetSpelling( aTriggerStr[0],
+ spelling, spellingType );
+ if( KErrNone != result )
+ {
+ return;
+ }
+
+ // get homophonic or polyphonic candidates by spelling
+ GetHomophonicAndPolyphonic( spelling, aHomophonic );
+
+ // delete the repeated characters
+ TInt count = aHomophonic.Count();
+ for ( TInt i = count - 1; i >= 0; i-- )
+ {
+ if ( aTriggerStr == *( aHomophonic[i] ) )
+ {
+ delete aHomophonic[i];
+ aHomophonic.Remove( i );
+ }
+ }
+ // remove the seleted character to the first cell
+ aHomophonic.Insert( aTriggerStr.AllocL(), 0 );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Get homophonic or polyphonic candidates
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::GetHomophonicAndPolyphonic( TDes& aSpelling,
+ RPointerArray<HBufC>& aHomophonic )
+ {
+ TInt index = KErrNotFound;
+ TBuf<KMaxOneSpellingLettersNum> tmpSpelling;
+
+ while( aSpelling != KNullDesC16 )
+ {
+ tmpSpelling.Zero();
+ // find the separator
+ index = aSpelling.Find( KPolyphonicSeparator );
+ if( index != KErrNotFound )
+ {
+ // get one spelling in the polyphonic string
+ tmpSpelling = aSpelling.Left( index );
+
+ // remove the left spelling and a separator
+ aSpelling = aSpelling.Right( aSpelling.Length() - index - 1 );
+ }
+ else // only one spelling
+ {
+ tmpSpelling = aSpelling;
+ aSpelling = KNullDesC16;
+ }
+
+ // get candidate for each spelling
+ RPointerArray<HBufC> candidates;
+ HBufC* formatString = iPtiEngine->GetCandidatesByInputString(
+ tmpSpelling,
+ candidates,
+ EFalse );
+
+ for( TInt i = 0; i < candidates.Count(); i++ )
+ {
+ aHomophonic.Append( candidates[i] );
+ }
+ delete formatString;
+ candidates.Reset();
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// Set primary and auxiliary ranges for hwr engine
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::SetRanges( const RArray<TInt>& aPermittedRanges )
+ {
+ ASSERT( aPermittedRanges.Count() > 0 );
+
+ if ( !iRecognizer )
+ {
+ iNeedPermittedRanges.Reset();
+
+ for ( TInt i = 0; i < aPermittedRanges.Count(); i++ )
+ {
+ iNeedPermittedRanges.Append( aPermittedRanges[i] );
+ }
+
+ iNeedSetRange = ETrue;
+ return;
+ }
+ else
+ {
+ iPremaryRange = aPermittedRanges[0];
+ iRangeCount = aPermittedRanges.Count();
+
+ if( iPremaryRange == ERangeNumber )
+ {
+ SetCandidatesMaxCount( KCandidateCountNumMode );
+ SetAuxCandidateNum( KAuxCandidateCountNumMode );
+ }
+ else
+ {
+ SetCandidatesMaxCount( KCandidateCount );
+ SetAuxCandidateNum( KAuxCandidateCount );
+ }
+
+ TRecognitionRange range;
+
+ SetRecognitionRange( aPermittedRanges[0], range );
+ iRecognizer->SetRange( range );
+
+ // set auxiliary ranges for hwr engine
+ for ( TInt i=1; i<aPermittedRanges.Count(); i++ )
+ {
+ SetRecognitionRange( aPermittedRanges[i], range );
+
+ iRecognizer->AddAuxiliaryRange( range );
+ }
+
+ SetCase( iCase );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------------------------
+// Set case
+// ---------------------------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::SetCase( TInt aCase )
+ {
+ iCase = aCase;
+
+ if ( !iRecognizer )
+ {
+ iNeedSetCase = ETrue;
+ }
+ else
+ {
+ // set letter to lower first when LowerCase
+ // set letter to upper first when UpperCase and TextCase
+ if ( aCase == ECaseLower )
+ {
+ iRecognizer->SetFirstLetterOrder( ELowerFirst );
+ }
+ else
+ {
+ iRecognizer->SetFirstLetterOrder( EUpperFirst );
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------------------------
+// Set number mode for hwr engine
+// ---------------------------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::SetNumberMode( const TAknEditorNumericKeymap& aNumberMode )
+ {
+ iNumberMode = aNumberMode;
+
+ if ( !iRecognizer )
+ {
+ iNeedSetNumberMode = ETrue;
+ }
+ else
+ {
+ iRecognizer->SetNumberMode( aNumberMode );
+ if( aNumberMode != EKeymapFromResource )
+ {
+ ResetCustomKeyMap();
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------------------------
+// Get stroke end mark from hwr engine
+// ---------------------------------------------------------------------------------------------
+//
+TPoint CAknFepHwrEngine::StrokeEndMark() const
+ {
+ if ( iRecognizer )
+ {
+ return iRecognizer->StrokeEndMark();
+ }
+ else
+ {
+ return TPoint( KDefaultStrokeEndMarkX, KDefaultStrokeEndMarkY );
+ }
+ }
+
+// ---------------------------------------------------------------------------------------------
+// Set primary candidate num for hwr engine
+// ---------------------------------------------------------------------------------------------
+//
+TInt CAknFepHwrEngine::SetPrimaryCandidateNum( TInt aNum )
+ {
+ if ( iRecognizer )
+ {
+ return iRecognizer->SetCandidateNum( aNum );
+ }
+ else
+ {
+ return KErrGeneral;
+ }
+ }
+
+// ---------------------------------------------------------------------------------------------
+// Set aux candidate num that should be shown
+// ---------------------------------------------------------------------------------------------
+//
+TInt CAknFepHwrEngine::SetAuxCandidateNum( TInt aNum )
+ {
+ if ( iRecognizer )
+ {
+ return iRecognizer->SetAuxCandidateNum( aNum );
+ }
+ else
+ {
+ return KErrGeneral;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------------------------
+// Get aux candidate num that should be shown
+// ---------------------------------------------------------------------------------------------
+//
+TInt CAknFepHwrEngine::GetAuxCandidateNum()
+ {
+ if ( iRecognizer )
+ {
+ return iRecognizer->GetAuxCandidateNum();
+ }
+ else
+ {
+ return KErrGeneral;
+ }
+ }
+
+// ---------------------------------------------------------------------------------------------
+// Set total candidate num that should be shown
+// ---------------------------------------------------------------------------------------------
+//
+TInt CAknFepHwrEngine::SetCandidatesMaxCount( TInt aCount )
+ {
+ if ( aCount > 0 )
+ {
+ iTotalCandidateNum = aCount;
+ return KErrNone;
+ }
+ else
+ {
+ return KErrGeneral;
+ }
+ }
+
+// ---------------------------------------------------------------------------------------------
+// Set language
+// ---------------------------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::SetLanguageL( TInt aLanguage )
+ {
+ if ( ( iLanguage == aLanguage ) ||
+ ( aLanguage != ELangPrcChinese &&
+ aLanguage != ELangHongKongChinese &&
+ aLanguage != ELangTaiwanChinese ) )
+ {
+ return;
+ }
+
+ iLanguage = aLanguage;
+ switch ( iLanguage )
+ {
+ case ELangPrcChinese:
+ {
+ if ( iPtiEngine->ActivateLanguageL( iLanguage, EPtiEnginePinyinVkb ) != KErrNone )
+ {
+ iPtiEngine->ActivateLanguageL( iLanguage, EPtiEnginePinyin );
+ }
+ }
+ break;
+ case ELangHongKongChinese:
+ if ( iPtiEngine->ActivateLanguageL( iLanguage, EPtiEngineStrokeByPhrase ) != KErrNone )
+ {
+ iPtiEngine->ActivateLanguageL( ELangHongKongChinese, EPtiEngineStroke );
+ }
+ break;
+ case ELangTaiwanChinese:
+ if ( iPtiEngine->ActivateLanguageL( iLanguage, EPtiEngineZhuyinVkb ) != KErrNone )
+ {
+ iPtiEngine->ActivateLanguageL( ELangTaiwanChinese, EPtiEngineZhuyin );
+ }
+ break;
+ default:
+ return;
+ }
+
+ iRecognizer = NULL;
+
+ if( !iIdle->IsActive() )
+ {
+ iIdle->Start( TCallBack( BackgroundTaskL, this ) );
+ }
+ }
+
+// ---------------------------------------------------------------------------------------------
+// CAknFepHwrEngine::DoIdleConstructL
+// Do background construct.
+// ---------------------------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::DoIdleConstructL()
+ {
+ if ( iRecognizer )
+ {
+ return;
+ }
+
+ iRecognizer = iPtiEngine->GetHwrRecognizerL( TLanguage( iLanguage ) );
+
+ iOwner->SetStrokeEndMark();
+ SetPrimaryCandidateNum( KPremaryCandidateCount );
+ SetAuxCandidateNum( KAuxCandidateCount );
+
+ if ( iNeedSetRange )
+ {
+ SetRanges( iNeedPermittedRanges );
+ iNeedPermittedRanges.Reset();
+ iNeedSetRange = EFalse;
+ }
+
+ if ( iNeedSetCase )
+ {
+ SetCase( iCase );
+ iNeedSetCase = EFalse;
+ }
+
+ if ( iNeedSetNumberMode )
+ {
+ SetNumberMode( TAknEditorNumericKeymap( iNumberMode ) );
+ iNeedSetNumberMode = EFalse;
+ }
+ }
+
+// ---------------------------------------------------------------------------------------------
+// CAknFepHwrEngine::BackgroundConstructL
+// Do background construct.
+// ---------------------------------------------------------------------------------------------
+//
+TBool CAknFepHwrEngine::BackgroundTaskL( TAny* aPtr )
+ {
+ CAknFepHwrEngine* self = static_cast<CAknFepHwrEngine*>( aPtr );
+ self->DoIdleConstructL();
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// Set recognition range for hwr engine
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::SetRecognitionRange( const TInt aRange,
+ TRecognitionRange& aRecognitionRange )
+ {
+ aRecognitionRange.iLanguage = TLanguage( iLanguage );
+
+ switch ( aRange )
+ {
+ case ERangeNative:
+ {
+ if ( iLanguage == ELangPrcChinese )
+ {
+ aRecognitionRange.iSubRange = EPtiRangePRCChinese;
+ }
+ else if ( iLanguage == ELangHongKongChinese )
+ {
+ aRecognitionRange.iSubRange = EPtiRangeHKChinese;
+ }
+ else
+ {
+ aRecognitionRange.iSubRange = EPtiRangeTWChinese;
+ }
+ break;
+ }
+ case ERangeEnglish:
+ aRecognitionRange.iLanguage = ELangEnglish;
+ aRecognitionRange.iSubRange = EPtiRangeLatin;
+
+ break;
+ case ERangeNumber:
+ aRecognitionRange.iSubRange = EPtiRangeNumber;
+
+ break;
+ case ERangeSymbol:
+ // The symbol mode is associated with iLanguage instead of iPremaryRange
+ aRecognitionRange.iLanguage = TLanguage( iLanguage );
+ aRecognitionRange.iSubRange = EPtiRangeSymbol;
+
+ break;
+ default:
+ break;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Set recognition range for hwr engine
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::SetCustomKeymapL( const TDesC& aKeyMap )
+ {
+ ResetCustomKeyMap();
+
+ iCustomKeymap = HBufC::NewL( aKeyMap.Length() + KNumberString().Length() );
+ iCustomKeymap->Des().Copy( KNumberString() );
+ iCustomKeymap->Des().Append( aKeyMap );
+ }
+
+// ---------------------------------------------------------------------------
+// Set recognition range for hwr engine
+// ---------------------------------------------------------------------------
+//
+void CAknFepHwrEngine::ResetCustomKeyMap()
+ {
+ delete iCustomKeymap;
+ iCustomKeymap = NULL;
+ }
+TInt CAknFepHwrEngine::SetInputAreaSize(TSize& aSize)
+ {
+ if(iRecognizer)
+ {
+ return iRecognizer->SetInputAreaSize(aSize);
+ }
+ else
+ {
+ return KErrNotFound;
+ }
+ }
+TInt CAknFepHwrEngine::SetScreenSize(TSize& aSize)
+ {
+ if(iRecognizer)
+ {
+ return iRecognizer->SetScreenSize(aSize);
+ }
+ else
+ {
+ return KErrNotFound;
+ }
+ }
+//End Of File