/*
* 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 for chinese peninput finger hwr
*
*/
//SYSTEM INCLUDE
#include <centralrepository.h>
#include <settingsinternalcrkeys.h>
//FEP INCLUDE
#include <aknfeppeninputenums.h>
#include <AknFepGlobalEnums.h>
#include <AknFepInternalCRKeys.h>
//USER INCLUDE
#include "peninputfingerhwrlayout.h"
#include "peninputfingerhwrdatastore.h"
#include "peninputfingerhwrtriggerstr.h"
#include "peninputfingerhwrengine.h"
#include "peninputpluginutils.h"
#include "peninputfingerhwrstoreconstants.h"
#include <peninputfingerhwrcn.rsg>
//CONSTANT DEFINATION HEADER
// ----------------------------------------------------------------------------
// Symbian constructor
// ----------------------------------------------------------------------------
//
CPeninputFingerHwrDataStore* CPeninputFingerHwrDataStore::NewL(
CPtiEngine* aPtiEngine, CPeninputFingerHwrLayout* aLayout )
{
CPeninputFingerHwrDataStore* self = new ( ELeave )
CPeninputFingerHwrDataStore(aLayout);
CleanupStack::PushL( self );
self->ConstructL( aPtiEngine );
CleanupStack::Pop( self );//self
return self;
}
// ----------------------------------------------------------------------------
// destructor
// ----------------------------------------------------------------------------
//
CPeninputFingerHwrDataStore::~CPeninputFingerHwrDataStore()
{
iCandidates.ResetAndDestroy();
iCandidates.Close();
iPredictives.ResetAndDestroy();
iPredictives.Close();
iRangeStartPos.Close();
iPermittedRanges.Close();
iKeyMappingIdList.Close();
iKeyMappingStringList.ResetAndDestroy();
iKeyMappingStringList.Close();
delete iRepositoryFep;
delete iTriggerStr;
delete iHwrEngine;
delete iUserDefinedResource;
if ( iDefaultNumberMapping )
{
delete iDefaultNumberMapping;
}
iDefaultNumberMapping = NULL;
}
// ----------------------------------------------------------------------------
// Is valid candidate
// ----------------------------------------------------------------------------
//
TBool CPeninputFingerHwrDataStore::IsValidCandidate( TInt aCandidateIndex ) const
{
return ( *iCandidates[aCandidateIndex] ).Length() > 0;
}
// ----------------------------------------------------------------------------
// Is English letter
// ----------------------------------------------------------------------------
//
TBool CPeninputFingerHwrDataStore::IsEnglishLetter( const TDesC& aLetter)
{
TUint unicode = *((TUint16*) aLetter.Ptr());
const TUint ACode = 0x0041; // Letter "A"
const TUint ZCode = 0x005A; // Letter "Z"
const TUint aCode = 0x0061; // Letter "a"
const TUint zCode = 0x007A; // Letter "z"
if( ((ACode <= unicode) && (unicode <= ZCode))||
((aCode <= unicode) && (unicode <= zCode)) )
{
return ETrue;
}
else
{
return EFalse;
}
}
// ----------------------------------------------------------------------------
// Do recoginize by engine for Chinese
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::DoChineseRecognizeL( const RArray<TPoint>& aTraceData )
{
iHwrEngine->DoRecognizeL( aTraceData, iCandidates );
// To set candidate and do predictive
SetCandidatesL();
}
// ----------------------------------------------------------------------------
// Do recoginize by engine for English
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::DoEngRecognizeL( const RArray<TPoint>& aTraceData )
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
iHwrEngine->DoRecognizeL( aTraceData, iCandidates );
// To set candiate and do auto complete
SetAutoCompleteCandidatesL();
#else
iHwrEngine->DoRecognizeL( aTraceData, iPredictives );
#endif // RD_INTELLIGENT_TEXT_INPUT
}
// ----------------------------------------------------------------------------
// Do predictive using trigger string
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::DoPredictiveL()
{
// clear the predictives
iPredictives.ResetAndDestroy();
TInt primaryRange = iPermittedRanges[0];
TPtrC string = TriggerStr()->GetString();
if( primaryRange == ERangeNative )
{
iHwrEngine->DoPredictiveL( string, iPredictives );
}
#ifdef RD_INTELLIGENT_TEXT_INPUT
if( primaryRange == ERangeEnglish )
{ // only for auto complete
if(!IsEnglishLetter(string.Right(1)))
{
// clear the predictives when input non-letter.
iPredictives.ResetAndDestroy();
}
else
{
iHwrEngine->DoEngPredictiveL( string, iPredictives );
// Remove all the accent symbol from auto complete candidate
RemoveAccent();
}
}
#endif // No predictive candidate when auto complete is off
}
// ----------------------------------------------------------------------------
// Set fixed Chinese symbols
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetChineseSymbolL()
{
iCandidates.ResetAndDestroy();
TInt symCount = sizeof( ChineseSymbolCode )/sizeof( TUint16 );
for( TInt i = 0; i < symCount; i++ )
{
TBuf<1> charBuf;
charBuf.Append( ChineseSymbolCode[i] );
iCandidates.AppendL( charBuf.AllocL() );
}
}
// ----------------------------------------------------------------------------
// Set fixed Chinese predictives
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetFixChinesePredictiveL()
{
iPredictives.ResetAndDestroy();
TInt symCount = sizeof( ChinesePredictCode )/sizeof( TUint16 );
for( TInt i = 0; i < symCount; i++ )
{
TBuf<1> charBuf;
charBuf.Append( ChinesePredictCode[i] );
iPredictives.AppendL( charBuf.AllocL() );
}
}
// ----------------------------------------------------------------------------
// Set fixed English symbols
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetFixEnglishSymbolL(TRowCount aRowCount)
{
TInt symCount = 0;
switch(aRowCount)
{
case ERowOne: // only set one row dropdownlist
{
iCandidates.ResetAndDestroy();
symCount = sizeof( EnglishSymbolCodeOneRow )/sizeof( TUint16 );
for( TInt i = 0; i < symCount; i++ )
{
TBuf<1> charBuf;
charBuf.Append( EnglishSymbolCodeOneRow[i] );
iCandidates.AppendL( charBuf.AllocL() );
}
}
break;
case ERowTwo: // Set two rows dropdownlist
{
iCandidates.ResetAndDestroy();
iPredictives.ResetAndDestroy();
symCount = sizeof( EnglishSymbolCodeTwoRow )/sizeof( TUint16 );
for( TInt i = 0; i < symCount; i++ )
{
TBuf<1> charBuf1; // the first row
TBuf<2> charBuf2; // the second row
charBuf1.Append( EnglishSymbolCodeOneRow[i] );
iCandidates.AppendL( charBuf1.AllocL() );
if(i > 2) // for smile symbol
{
charBuf2.Append(ColonSymbol);
}
charBuf2.Append( EnglishSymbolCodeTwoRow[i] );
iPredictives.AppendL( charBuf2.AllocL() );
}
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// Get the predictive count
// ----------------------------------------------------------------------------
//
TInt CPeninputFingerHwrDataStore::PredictiveCount() const
{
return iPredictives.Count();
}
// ----------------------------------------------------------------------------
// Get the trigger string
// ----------------------------------------------------------------------------
//
CAknFepHwrTriggerStr* CPeninputFingerHwrDataStore::TriggerStr() const
{
return iTriggerStr;
}
// ----------------------------------------------------------------------------
// Set permitted ranges
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetPermittedRanges( TInt aPermittedRanges )
{
if(aPermittedRanges == 0)
return;
iPermittedRanges.Reset();
//order can not be changed
if ( aPermittedRanges & ERangeNative )
{
iPermittedRanges.Append( ERangeNative );
}
if ( aPermittedRanges & ERangeEnglish )
{
iPermittedRanges.Append( ERangeEnglish );
}
if ( aPermittedRanges & ERangeNumber )
{
iPermittedRanges.Append( ERangeNumber );
}
if ( aPermittedRanges & ERangeSymbol )
{
iPermittedRanges.Append( ERangeSymbol );
}
iIntRange = aPermittedRanges;
// set primary and auxiliary ranges for hwr engine
iHwrEngine->SetRanges( iPermittedRanges );
}
// ----------------------------------------------------------------------------
// Set permitted cases
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetPermittedCases( TInt aPermittedCases )
{
iPermittedCases = aPermittedCases;
}
// ----------------------------------------------------------------------------
// Set Primary range
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetPrimaryRange( TInt aPrimaryRange )
{
const TInt oldIndex = iPermittedRanges.Find( aPrimaryRange );
// store the current range
switch(aPrimaryRange)
{
case ERangeNative:
{
iCurrentRange = EFingerHwrNativeRange;
}
break;
case ERangeEnglish:
{
iCurrentRange = EFingerHwrEnglishRange;
}
break;
case ERangeNumber:
{
iCurrentRange = EFingerHwrNumberRange;
}
break;
default:
break;
}
if ( oldIndex > 0 )
{
iPermittedRanges.Sort();
const TInt index = iPermittedRanges.Find( aPrimaryRange );
iPermittedRanges.Remove( index );
iPermittedRanges.Insert( aPrimaryRange, 0 );
// set primary range for hwr engine
iHwrEngine->SetRanges( iPermittedRanges );
}
}
// ----------------------------------------------------------------------------
// get Primary range
// ----------------------------------------------------------------------------
//
TInt CPeninputFingerHwrDataStore::PrimaryRange()
{
if( iPermittedRanges.Count() > 0 )
{
return iPermittedRanges[0];
}
return -1;
}
// ----------------------------------------------------------------------------
// get current range
// ----------------------------------------------------------------------------
//
TFingerHwrRange CPeninputFingerHwrDataStore::CurrentRange()
{
return iCurrentRange;
}
// ----------------------------------------------------------------------------
// Set case
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetCase( TInt aCase )
{
iCase = aCase;
iHwrEngine->SetCase( iCase );
}
// ----------------------------------------------------------------------------
// Set language
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetLanguageL( TInt aLanguage )
{
if( iLanguage == aLanguage )
{
return;
}
if ( !LanguageIsChinese( aLanguage ) && ( aLanguage != ELangEnglish ) )
{
return;
}
if ( aLanguage == ELangEnglish )
{
TLanguage displayLang = User::Language();
// set real language to a Chinese
if ( !LanguageIsChinese( iLanguage ) )
{
// original language is not Chinese
if ( LanguageIsChinese( displayLang ) )
{
iLanguage = displayLang;
}
else
{
iLanguage = ELangPrcChinese;
}
SetEngineLanguageL( iLanguage );
}
}
else
{
// aLanguage is Chinese
if ( iLanguage != aLanguage )
{
iLanguage = aLanguage;
SetEngineLanguageL( iLanguage );
}
}
}
// ----------------------------------------------------------------------------
// Set the candidate list
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetCandidatesL()
{
if( !IsDirectlySentCandidate( *iCandidates[0] ) )
{
iTriggerStr->Set( *iCandidates[0] );
DoPredictiveL();
}
else
{
iTriggerStr->DeleteAll();
SetFixChinesePredictiveL();
}
}
// ----------------------------------------------------------------------------
// Set the candidate list
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetAutoCompleteCandidatesL()
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
//those special chars: backspace and enter char need sent to
//app directly, not need to display candidate window
if ( iCandidates.Count()<1 || !iCandidates[0] )
{
return;
}
if ( !IsDirectlySentCandidate( *iCandidates[0] ) )
{
TPtrC string = iTriggerStr->GetString();
if(FirstStroke())
{
if(string.Length() == 0 ||
(string.Length() != 0 && !IsEnglishLetter(string.Right(1))))
{
// reset trigger string when got a punctuation
iLayout->SubmitStartPosToFep(ETrue);
iTriggerStr->Set( *iCandidates[0] );
}
else
{
// just add the new stroke to trigger string,
// when write a new char
iTriggerStr->Append( *iCandidates[0] );
}
}
else
{
// replace previous stroke
iTriggerStr->DeleteLast();
iTriggerStr->Append( *iCandidates[0] );
}
DoPredictiveL();
}
#endif
}
// ----------------------------------------------------------------------------
// Get first stroke flag
// ----------------------------------------------------------------------------
//
TBool CPeninputFingerHwrDataStore::FirstStroke()
{
return iIsFirstStroke;
}
// ----------------------------------------------------------------------------
// Set first stroke flag
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetFirstStroke(const TBool aIsFirstStroke)
{
iIsFirstStroke = aIsFirstStroke;
}
// ----------------------------------------------------------------------------
// Get the candidate
// ----------------------------------------------------------------------------
//
const RPointerArray<HBufC>& CPeninputFingerHwrDataStore::Candidate() const
{
return iCandidates;
}
// ----------------------------------------------------------------------------
// Get the predictive
// ----------------------------------------------------------------------------
//
const RPointerArray<HBufC>& CPeninputFingerHwrDataStore::Predictive()
{
return iPredictives;
}
// ----------------------------------------------------------------------------
// Set number mode for hwr engine
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetNumberMode(
const TAknEditorNumericKeymap aNumberMode )
{
iCurrentNumberMode = aNumberMode;
iHwrEngine->SetNumberMode( aNumberMode );
iHwrEngine->SetRanges( iPermittedRanges );
}
// ----------------------------------------------------------------------------
// Set number mode for hwr engine
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetCustomNumberModeL( const TDesC& aCustomMode )
{
iHwrEngine->SetCustomKeymapL( aCustomMode );
delete iUserDefinedResource;
iUserDefinedResource = NULL;
iUserDefinedResource = HBufC::NewL( aCustomMode.Length() );
iUserDefinedResource->Des().Append( aCustomMode );
}
// ----------------------------------------------------------------------------
// save range to repository if english or chinese
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SaveRange( TInt aRange )
{
if ( iRepositoryFep && ( aRange == ERangeNative || aRange == ERangeEnglish ) )
{
iRepositoryFep->Set( KAknFepLastUsedRange, aRange );
}
}
// ------------------------------------------------------------------
// Get next predictive candidate page
// -------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::GetNextPredictivePageL()
{
iHwrEngine->DoPredictiveL( KNullDesC, iPredictives, ETrue );
TInt predictCount = PredictiveCount();
if ( predictCount <= 0 )
{
SetFixChinesePredictiveL();
}
}
// ------------------------------------------------------------------
// sync stroke end mark of writingbox with hwr engine.
// -------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetStrokeEndMark()
{
iLayout->SyncHwrStrokeEndMark( iHwrEngine->StrokeEndMark() );
}
// ----------------------------------------------------------------------------
// get stroke end mark from hwr engine
// ----------------------------------------------------------------------------
//
TPoint CPeninputFingerHwrDataStore::StrokeEndMark()
{
return iHwrEngine->StrokeEndMark();
}
// ----------------------------------------------------------------------------
// stroke end mark from control
// ----------------------------------------------------------------------------
//
TPoint CPeninputFingerHwrDataStore::StrokeEndMarkFromControl()
{
return TPoint( KDefaultStrokeEndMarkX, KDefaultStrokeEndMarkY );
}
// --------------------------------------------------------------------
// Get number keymapping string
// --------------------------------------------------------------------
//
HBufC* CPeninputFingerHwrDataStore::KeyMappingStringL() const
{
TLocale locale;
TBuf<KMaxNumericString> rs = KNumberString(); // copy "0123456789"
const TInt index = iKeyMappingIdList.Find( iCurrentNumberMode );
if ( !( iPermittedRanges.Count() == 1 && iPermittedRanges[0] == ERangeNumber ) )
{
rs.Append( *iDefaultNumberMapping ); //normal editor
}
else if ( iCurrentNumberMode == EKeymapFromResource )
{
rs.Append( *iUserDefinedResource );
}
else if ( index != KErrNotFound )
{
HBufC* buf = iKeyMappingStringList[index];
rs.Append( *buf );
if ( ( iCurrentNumberMode == EAknEditorCalculatorNumberModeKeymap ) ||
( iCurrentNumberMode == EAknEditorConverterNumberModeKeymap ) )
{
rs.Append( locale.DecimalSeparator() );
}
}
return rs.AllocL();
}
// ------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::IsSpecialDisplayChars
// ------------------------------------------------------------------------
//
TBool CPeninputFingerHwrDataStore::IsSpecialDisplayChars( const TDesC& aChar ) const
{
if( aChar.Compare( KGestureEnter ) == 0
|| aChar.Compare( KDisplayBackspace ) == 0
|| aChar.Compare( KGestureSpace )== 0 )
{
return ETrue;
}
return EFalse;
}
// -----------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::IsDirectlySentCandidate
// -----------------------------------------------------------------------------
//
TBool CPeninputFingerHwrDataStore::IsDirectlySentCandidate( const TDesC& aChar ) const
{
if( aChar.Compare( KGestureEnter ) == 0 ||
aChar.Compare( KDisplayBackspace ) == 0)
{
return ETrue;
}
return EFalse;
}
// ------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::ConvertDisplayChars
// ------------------------------------------------------------------------
//
HBufC* CPeninputFingerHwrDataStore::ConvertDisplayChars( const TDesC& aChar ) const
{
HBufC* convertedCan = NULL;
TBuf<KSpecialConvertedCharCount> str;
if( aChar.Compare( KGestureEnter ) == 0 )
{
str.Append( EKeyEnter );
}
else if( aChar.Compare( KDisplayBackspace ) == 0 )
{
str.Append( EKeyBackspace );
}
else if( aChar.Compare( KGestureSpace )== 0 )
{
str.Append( EKeySpace );
}
if( str.Length() > 0 )
{
convertedCan = str.Alloc();
}
return convertedCan;
}
// -----------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::StartCharacter
// -----------------------------------------------------------------------------
//
TBool CPeninputFingerHwrDataStore::StartCharacter()
{
return iStartCharacter;
}
// -----------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::SetStartCharacter
// -----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetStartCharacter(const TBool aStartCharacter)
{
iStartCharacter = aStartCharacter;
}
// -----------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::SetInputAreaSize
// -----------------------------------------------------------------------------
//
TInt CPeninputFingerHwrDataStore::SetInputAreaSize(TSize& aSize)
{
return iHwrEngine->SetInputAreaSize(aSize);
}
// -----------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::SetScreenSize
// -----------------------------------------------------------------------------
//
TInt CPeninputFingerHwrDataStore::SetScreenSize(TSize& aSize)
{
return iHwrEngine->SetScreenSize(aSize);
}
// -----------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::ClearPredictive
// -----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::ClearPredictive()
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
iPredictives.ResetAndDestroy();
#endif
}
// -----------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::SetHighlight
// -----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetHighlight(const TBool aIsHighlight)
{
iIsHighlightCell = aIsHighlight;
}
// -----------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::Highlight
// -----------------------------------------------------------------------------
//
TBool CPeninputFingerHwrDataStore::Highlight()
{
return iIsHighlightCell;
}
// -----------------------------------------------------------------------------
// CPeninputFingerHwrDataStore::RemoveDuplicateCand
// -----------------------------------------------------------------------------
//
TInt CPeninputFingerHwrDataStore::RemoveDuplicateCand(const RPointerArray<HBufC>& aSrc,
RPointerArray<HBufC>& aTgt,
TInt aSrcStartIdx,
TInt aTgtStartIdx)
{
TInt lastOverlapIdx = KInvalidIndex;
// on the assumption that if candidate overlap,
// it is overlap only once
TInt srccandcnt = aSrc.Count();
for (TInt i = aSrcStartIdx; i < srccandcnt; i++)
{
for (TInt j = aTgtStartIdx; j < aTgt.Count(); j++)
{
if (aTgt[j]->Compare(*(aSrc[i])) == 0)
{
lastOverlapIdx = i;
delete aTgt[j];
aTgt.Remove(j);
j--;
break;
}
}
}
return lastOverlapIdx;
}
// ----------------------------------------------------------------------------
// C++ constructor
// ----------------------------------------------------------------------------
//
CPeninputFingerHwrDataStore::CPeninputFingerHwrDataStore(CPeninputFingerHwrLayout* aLayout)
:iLayout( aLayout )
{
iLanguage = ELangNone;
iCurrentNumberMode = EAknEditorStandardNumberModeKeymap;
iIsHighlightCell = ETrue;
}
// ----------------------------------------------------------------------------
// Second phase constructor
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::ConstructL( CPtiEngine* aPtiEngine )
{
//create the repository for fep settings
iRepositoryFep = CRepository::NewL( KCRUidAknFep );
//create the trigger string
iTriggerStr = new ( ELeave ) CAknFepHwrTriggerStr();
//create the hwr engine
iHwrEngine = CAknFepHwrEngine::NewL( aPtiEngine, this );
//initialize the key mapping list
InitKeyMappingListL();
}
// ----------------------------------------------------------------------------
// Initialize the key mapping list
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::InitKeyMappingListL()
{
CCoeEnv* env = CCoeEnv::Static();
//read default key mapping string from resource
if ( iDefaultNumberMapping )
{
delete iDefaultNumberMapping;
iDefaultNumberMapping = NULL;
}
iDefaultNumberMapping = env->AllocReadResourceL( R_AKN_FEP_HWR_KEY_MAPPING_DEFAULT );
//read the key maping string from resource
TResourceReader reader;
env->CreateResourceReaderLC( reader, R_AKN_FEP_HWR_KEY_MAPPING_STRING_LIST );
const TInt count = reader.ReadInt16();
for ( TInt i = 0; i < count; i++ )
{
iKeyMappingIdList.Append( reader.ReadInt16() );
TPtrC ptr = reader.ReadTPtrC();
iKeyMappingStringList.Append( ptr.Alloc() );
}
iCurrentNumberMode = EAknEditorStandardNumberModeKeymap;
CleanupStack::PopAndDestroy(); //reader
}
// ----------------------------------------------------------------------------
// Judge if a language is Chinese
// ----------------------------------------------------------------------------
//
TBool CPeninputFingerHwrDataStore::LanguageIsChinese( TInt aLanguage )
{
if ( ( aLanguage == ELangPrcChinese ) ||
( aLanguage == ELangHongKongChinese ) ||
( aLanguage == ELangTaiwanChinese ) )
{
return ETrue;
}
return EFalse;
}
// ----------------------------------------------------------------------------
// Set real engine language
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetEngineLanguageL( TInt aLanguage )
{
SetLanguageShowText( aLanguage );
iHwrEngine->SetLanguageL( aLanguage );
iHwrEngine->SetPrimaryCandidateNum( KCandidateCount );
}
// ----------------------------------------------------------------------------
// Set language show text
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetLanguageShowText( TInt aLanguage )
{
AknPenInputUtils::GetISOLanguageCode( TLanguage( aLanguage ),
iLanguageShowText );
}
// ----------------------------------------------------------------------------
// Remove accent characters
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::RemoveAccent()
{
#ifdef RD_INTELLIGENT_TEXT_INPUT
if(TriggerStr()->GetString().Length() != 1)
{
return;
}
TInt count = PredictiveCount();
for(TInt i = count; i > 0; i--)
{
if(!IsEnglishLetter(iPredictives[i - 1]->Des()))
{
delete iPredictives[i-1];
iPredictives.Remove(i-1);
count--;
}
}
#endif
}
// ----------------------------------------------------------------------------
// Reset key board type
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::ResetKeyboardType()
{
iHwrEngine->ResetKeyboardType();
}
// ----------------------------------------------------------------------------
// Set key board type to Qwerty
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::SetKeyboardToQwerty()
{
iHwrEngine->SetKeyboardToQwerty();
}
// ----------------------------------------------------------------------------
// Get key board type
// ----------------------------------------------------------------------------
//
void CPeninputFingerHwrDataStore::GetKeyboardType()
{
iHwrEngine->GetKeyboardType();
}
// End Of File