--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/fep/aknfep/src/AknFepUiIndicInputManager.cpp Tue Feb 02 01:02:04 2010 +0200
@@ -0,0 +1,1130 @@
+/*
+* Copyright (c) 2002-2004 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:
+* Provides the TAknFepUIIndicInputManager methods.
+*
+*/
+
+
+
+
+
+
+
+
+
+
+
+#include "AknFepUiIndicInputManager.h"
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::ValidateInput
+
+// This function validates the input text given by PtiEngine. This function
+// returns the resopnse code depending on the previous character, current input
+// character and the next character. Depending on the response code apropriate
+// action is taken for inputting the current inputed character. This function
+// incorporates the logic for Devanagari alphabate input.
+// -----------------------------------------------------------------------------
+
+
+TIndicInputResponse TAknFepUiIndicInputManager::ValidateInput( TInt aKey,
+ TUint aPrevChar,
+ TUint aCurrChar,
+ TUint /*aNextChar*/,
+ TBool& aIsHalantOrMatraAllowed,
+ TBool aIsStarKeyPressed,
+ TBool aIsKeyTimerExpired,
+ TPtiTextCase& aNewCase,
+ TKeyPressLength /*aLength*/,
+ TLanguage aLanguage,
+ TBool aIsRakarPresent /* = EFalse*/,
+ TBool aIsZWSPresent /* = EFalse */
+#ifdef RD_MARATHI
+ , TBool aIsChandraAPresent /* = EFalse */
+#endif // RD_MARATHI
+ )
+
+ {
+ TIndicInputResponse keyResponse = EIndicInputResponseNone;
+
+ TPtiTextCase setcase = EPtiCaseLower;
+
+ TAknFepUiIndicInputManager::SetHalantOrMatraAllowed( aPrevChar,
+ aIsHalantOrMatraAllowed,
+ aIsKeyTimerExpired,
+ aLanguage );
+
+ switch( aKey )
+ {
+ case EPtiKey1:
+ {
+ if( IsCharNukta( aCurrChar, aLanguage ) &&
+ ( IsCharNuktaConsonant( aPrevChar, aLanguage ) ||
+ !IsCharBaseConsonant( aPrevChar, aLanguage ) ) )
+ {
+ keyResponse = EIndicInputResponseInvalid;
+ }
+#ifdef RD_MARATHI
+ else if( IsCharEyeLashRa( aCurrChar, aLanguage ) )
+ {
+ keyResponse = EIndicInputResponseInsertEyeLashRa;
+ }
+#endif // RD_MARATHI
+
+ else if ( IsCharEmpty( aPrevChar, aLanguage ) )
+ {
+ // The special characters present in key-1 have to be
+ // allowed. So the response is not set to digit directly
+ // But at the same time, skip the fallback modifiers.
+ if( IsCharModifier( aCurrChar, aLanguage ) )
+ {
+ keyResponse = EIndicInputResponseInvalid;
+ }
+ }
+ else if( IsCharRakar( aCurrChar, aLanguage ) )
+ {
+ if( aIsHalantOrMatraAllowed )
+ {
+ keyResponse = EIndicInputResponseInsertRakar;
+ }
+ else
+ {
+ keyResponse = EIndicInputResponseInvalid;
+ }
+ }
+ else if( IsCharRepha( aCurrChar, aLanguage ) )
+ {
+ if( IsRephaAllowed( aPrevChar, aLanguage ) ||
+ ( aIsRakarPresent && !aIsKeyTimerExpired ) )
+ {
+ keyResponse = EIndicInputResponseInsertRepha;
+ }
+ else
+ {
+ keyResponse = EIndicInputResponseInvalid;
+ }
+ }
+ else if ( IsCharOther( aPrevChar, aLanguage )
+ || IsCharVirama( aPrevChar, aLanguage ) )
+ {
+ // Since the response cannot be set to digit
+ // directly here, validate the modifiers first.
+ if( IsCharModifier( aCurrChar, aLanguage ) )
+ {
+ if( !IsModifierAllowed( aPrevChar, aLanguage ) )
+ {
+ keyResponse = EIndicInputResponseInvalid;
+ }
+ }
+ }
+ else if ( IsCharModifier( aPrevChar, aLanguage ) )
+ {
+ // Unlike in earlier code, the response cannot be set to
+ // Digit directly here. The special characters present in
+ // key-1 have to be allowed. As a result, the fallback
+ // modifiers need to be skipped.
+ if( IsCharModifier( aCurrChar, aLanguage ) )
+ {
+ if( !IsModifierAllowed( aPrevChar, aLanguage ) )
+ {
+ keyResponse = EIndicInputResponseInvalid;
+ }
+ }
+ else
+ {
+ if ( ! aIsHalantOrMatraAllowed )
+ {
+ setcase = EPtiCaseUpper;
+ }
+ else if ( IsCharVirama( aCurrChar, aLanguage ) )
+ {
+ keyResponse = EIndicInputResponseInsertZWS;
+ }
+ }
+ }
+#ifdef RD_MARATHI
+ else if( IsCharVirama( aCurrChar, aLanguage ) &&
+ aIsHalantOrMatraAllowed )
+ {
+ keyResponse = EIndicInputResponseInsertZWS;
+ }
+#endif // RD_MARATHI
+
+ // In cases where the response cannot be set to digit directly,
+ // each character in key-1 has to be validated. Example in an
+ // Here we validate the Virama, Rakara and Repha
+ if( IsCharVirama( aCurrChar, aLanguage ) )
+ {
+ if( keyResponse != EIndicInputResponseInsertZWS )
+ {
+ keyResponse = EIndicInputResponseInvalid;
+ }
+ }
+ else if( IsCharRakar( aCurrChar, aLanguage ) )
+ {
+ if( keyResponse != EIndicInputResponseInsertRakar )
+ {
+ keyResponse = EIndicInputResponseInvalid;
+ }
+ }
+ else if( IsCharRepha( aCurrChar, aLanguage ) )
+ {
+ // In case of empty editor, all the modifiers, virama
+ // and rakar will be skipped. Even the Repha is to be skipped
+ if( keyResponse != EIndicInputResponseInsertRepha )
+ {
+ keyResponse = EIndicInputResponseInvalid;
+ }
+ }
+ }
+ break;
+
+ case EPtiKey2:
+ case EPtiKey3:
+ {
+ if ( IsCharEmpty( aPrevChar, aLanguage )
+ || IsCharAnVowel( aPrevChar, aLanguage )
+ || IsCharModifier( aPrevChar, aLanguage )
+#ifdef RD_MARATHI
+ || ( aIsChandraAPresent && !aIsKeyTimerExpired )
+#endif // RD_MARATHI
+ )
+ {
+ setcase = EPtiCaseUpper;
+ }
+ else if( IsCharVirama( aPrevChar, aLanguage ) )
+ {
+ setcase = EPtiCaseUpper;
+
+ // Response code changed to EIndicInputResponseNone to avoid
+ // insertion of ZWS character for Vowels.
+ keyResponse = EIndicInputResponseNone;
+ }
+ else if ( IsCharOther( aPrevChar, aLanguage ) )
+ {
+ if ( aIsKeyTimerExpired || IsCharSpace( aPrevChar ) || ( ! aIsHalantOrMatraAllowed ) )
+ {
+ setcase = EPtiCaseUpper;
+ }
+ }
+ else if ( IsCharMatra( aPrevChar, aLanguage ) )
+ {
+ if ( aIsKeyTimerExpired )
+ {
+ setcase = EPtiCaseUpper;
+ }
+ }
+ else if ( IsCharBaseConsonant( aPrevChar, aLanguage )
+ || IsCharNukta( aPrevChar, aLanguage ) )
+ {
+ if ( aIsStarKeyPressed )
+ {
+ setcase = EPtiCaseUpper;
+ }
+ }
+#ifdef RD_MARATHI
+ if( IsCharChandraA( aCurrChar ) )
+ {
+ keyResponse = EIndicInputResponseInsertChandraA;
+ }
+#endif // RD_MARATHI
+ }
+ break;
+
+ case EPtiKey4:
+ case EPtiKey5:
+ case EPtiKey6:
+ case EPtiKey7:
+ case EPtiKey8:
+ case EPtiKey9:
+ {
+ if ( aIsStarKeyPressed )
+ {
+ if( IsCharBaseConsonant( aCurrChar, aLanguage )
+ && ( IsCharBaseConsonant( aPrevChar, aLanguage ) ||
+ IsCharNukta( aPrevChar, aLanguage ) ) )
+ {
+ keyResponse = EIndicInputResponseInsertZWSandLigature;
+ }
+ else if( IsCharBaseConsonant( aCurrChar, aLanguage )
+ && IsCharVirama( aPrevChar, aLanguage ) )
+ {
+ keyResponse = EIndicInputResponseZWSandCharacter;
+ }
+ }
+ else if( IsCharVirama( aPrevChar, aLanguage ) )
+ {
+ keyResponse = EIndicInputResponseZWSandCharacter;
+ }
+ }
+ break;
+
+ case EPtiKey0:
+ {
+ // Special ligatures added in key-0.
+ if( IsCharLigature( aCurrChar, aLanguage ) )
+ {
+ if ( aIsStarKeyPressed &&
+ IsCharBaseConsonant( aPrevChar, aLanguage ) )
+ {
+ keyResponse = EIndicInputResponseInsertViramaZWSandDirectLigature;
+ }
+ else if( IsCharVirama( aPrevChar, aLanguage ) &&
+ IsCharAtStartOfLigature( aCurrChar, aLanguage ) &&
+ !aIsZWSPresent )
+ {
+ keyResponse = EIndicInputResponseZWSandDirectLigature;
+ }
+ else
+ {
+ keyResponse = EIndicInputResponseInsertDirectLigature;
+ }
+ }
+ }
+ break;
+
+ default:
+ {
+ keyResponse = EIndicInputResponseIgnore;
+ }
+ break;
+
+ }
+ aNewCase = setcase;
+ return keyResponse;
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::IsCharOther
+
+// This function checks for wheather the character is other character. The other
+// character includes numbers, character of other languages and spaces.
+// -----------------------------------------------------------------------------
+
+TBool TAknFepUiIndicInputManager::IsCharOther( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+
+ case KLangHindiPhonetic:
+#endif
+ {
+ if ( !( IsCharBaseConsonant( aChar, aLanguage )
+ || IsCharNukta( aChar, aLanguage )
+ || IsCharMatra( aChar, aLanguage )
+ || IsCharAnVowel( aChar, aLanguage )
+ || IsCharModifier( aChar, aLanguage )
+ || IsCharVirama( aChar, aLanguage )
+ || IsCharRakar( aChar, aLanguage )
+ || IsCharRepha( aChar, aLanguage )
+ || IsCharLigature( aChar, aLanguage )
+#ifdef RD_MARATHI
+ || IsCharEyeLashRa( aChar, aLanguage )
+ || IsCharChandraA( aChar )
+#endif
+ ) )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+ return( result );
+ }
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::IsCharEmpty
+
+// This function checks wheather the character is null
+// -----------------------------------------------------------------------------
+
+TBool TAknFepUiIndicInputManager::IsCharEmpty( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+ case KLangHindiPhonetic:
+#endif
+ {
+ if ( aChar == 0 )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+ return( result );
+ }
+
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::IsCharBaseConsonant
+
+// This function checks wheather the character is base consonant
+// -----------------------------------------------------------------------------
+
+TBool TAknFepUiIndicInputManager::IsCharBaseConsonant( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+ case KLangHindiPhonetic:
+#endif
+ {
+ if ( ( aChar >= 0x0915 && aChar <= 0x0939 )
+ ||( aChar >= 0x0958 && aChar <= 0x095F ) )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+ return( result );
+ }
+
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::IsCharNukta
+
+// This function checks wheather the character is Nukta.
+// -----------------------------------------------------------------------------
+
+ TBool TAknFepUiIndicInputManager::IsCharNukta( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+ case KLangHindiPhonetic:
+#endif
+ {
+ if ( aChar == 0x093C )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+
+ return( result );
+ }
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::IsCharMatra
+
+// This function checks wheather the character is Nukta.
+// -----------------------------------------------------------------------------
+
+TBool TAknFepUiIndicInputManager::IsCharMatra( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+ case KLangHindiPhonetic:
+#endif
+ {
+ if ( ( aChar >= 0x093E && aChar <= 0x094C )
+ ||( aChar == 0x0962 || aChar == 0x0963 ) )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+ return( result );
+ }
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::IsCharAnVowel
+
+// This function checks for wheather the character is Nukta.
+// -----------------------------------------------------------------------------
+
+ TBool TAknFepUiIndicInputManager::IsCharAnVowel( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+ case KLangHindiPhonetic:
+#endif
+ {
+ if ( ( aChar>=0x0904 && aChar<=0x0914 )
+ ||( aChar==0x0960 || aChar==0x0961 ) )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+ return( result );
+ }
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::IsCharModifier
+
+// This function checks wheather the character is Modifier.
+// -----------------------------------------------------------------------------
+
+ TBool TAknFepUiIndicInputManager::IsCharModifier( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+ case KLangHindiPhonetic:
+#endif
+ {
+ if ( aChar>= 0x0901 && aChar <= 0x0903 )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+
+ return( result );
+ }
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::IsCharVirama
+
+// This function checks wheather the character is Halant.
+// -----------------------------------------------------------------------------
+
+
+ TBool TAknFepUiIndicInputManager::IsCharVirama( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+
+ case KLangHindiPhonetic:
+#endif
+ {
+ if ( aChar == 0x094D )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+
+ return( result );
+ }
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::IsCharSpace
+
+// This function checks wheather the character is Space.
+// -----------------------------------------------------------------------------
+
+TBool TAknFepUiIndicInputManager::IsCharSpace( TUint aChar )
+ {
+ TBool result = EFalse;
+
+ if ( aChar == ( 0x0020 ) )
+ {
+ result = ETrue;
+ }
+ return( result );
+ }
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::SetHalantAllowed
+
+// This function checks wheather the Halant can be inputted at the current curssor
+// posiotion.
+// -----------------------------------------------------------------------------
+
+void TAknFepUiIndicInputManager::SetHalantOrMatraAllowed( TUint aPrevChar,
+ TBool& aViramaAllowed,
+ TBool aIsKeyTimerExpired,
+ TLanguage aLanguage )
+ {
+ if ( IsCharAnVowel( aPrevChar, aLanguage ) )
+ {
+ aViramaAllowed = EFalse;
+ }
+ else if ( IsCharBaseConsonant( aPrevChar, aLanguage ) ||
+ IsCharNukta( aPrevChar, aLanguage ) )
+ {
+ aViramaAllowed = ETrue;
+ }
+ if ( ( IsCharMatra( aPrevChar, aLanguage ) ||
+ IsCharOther( aPrevChar, aLanguage ) ||
+ IsCharVirama( aPrevChar, aLanguage ) ||
+ IsCharModifier( aPrevChar, aLanguage ) ) && aIsKeyTimerExpired )
+ {
+ // The new conditions are required as we are not making the response
+ // to digit as before. We iterate through all the characters in key-1
+ // and skip the ones which are not required.
+ aViramaAllowed = EFalse;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// TAknFepUiIndicInputManager::Virama
+
+// This function returns back the unicode value for Halant.
+// -----------------------------------------------------------------------------
+
+TUint TAknFepUiIndicInputManager::Virama( TLanguage aLanguage )
+ {
+ TUint ret = 0;
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+ case KLangHindiPhonetic:
+#endif
+ {
+ ret = 0x094D;
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+
+ return( ret );
+ }
+
+TBool TAknFepUiIndicInputManager :: IsIndicLangauge(TLanguage aInputLanguage)
+ {
+ TBool ret = EFalse;
+ switch(aInputLanguage)
+ {
+ case ELangHindi:
+ case ELangMarathi:
+ ret = ETrue;
+ break;
+
+ default: /*Other Language*/
+ break;
+ }
+ return ret;
+ }
+
+TBool TAknFepUiIndicInputManager :: IsIndicDigitsSupported(TLanguage aInputLanguage)
+ {
+ TBool ret = EFalse;
+ switch(aInputLanguage)
+ {
+#ifdef RD_HINDI_PHONETIC_INPUT
+
+ case KLangHindiPhonetic:
+ ret = ETrue;
+ break;
+#endif
+ default:
+ TLanguage uiLanguage = User::Language();
+ switch(uiLanguage)
+ {
+ case ELangHindi:
+ case ELangMarathi:
+ ret = ETrue;
+ }
+ }
+ return ret;
+ }
+
+TBool TAknFepUiIndicInputManager::IsRephaAllowed( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+ {
+ if ( IsCharBaseConsonant( aChar, aLanguage ) ||
+ IsCharMatra( aChar, aLanguage ) )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+ return( result );
+ }
+
+TBool TAknFepUiIndicInputManager::IsCharRepha( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+ {
+ if ( aChar == 0x0971 )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+
+ return( result );
+ }
+
+TUint TAknFepUiIndicInputManager::RaCharacter( TLanguage aLanguage )
+ {
+ TUint ret = 0;
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+ {
+ ret = 0x0930;
+ }
+ break;
+
+ // Other Language
+ default:
+ break;
+ }
+
+ return( ret );
+ }
+
+void TAknFepUiIndicInputManager::GetRepha( TDes& aRepha, TLanguage aLanguage )
+ {
+ aRepha.Zero();
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+ {
+ TChar raChar( TAknFepUiIndicInputManager::RaCharacter( aLanguage ) );
+ TChar virama( TAknFepUiIndicInputManager::Virama( aLanguage ) );
+ aRepha.Append( raChar );
+ aRepha.Append( virama );
+ }
+ break;
+
+ // Other Language
+ default:
+ break;
+ }
+ }
+
+TBool TAknFepUiIndicInputManager::IsCharRakar( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+ {
+ if ( aChar == 0x0972 )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+
+ return( result );
+ }
+
+void TAknFepUiIndicInputManager::GetRakar( TDes& aRakar, TLanguage aLanguage )
+ {
+ aRakar.Zero();
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+ {
+ TChar virama( TAknFepUiIndicInputManager::Virama( aLanguage ) );
+ TChar raChar( TAknFepUiIndicInputManager::RaCharacter( aLanguage ) );
+ aRakar.Append( virama );
+ aRakar.Append( raChar );
+ }
+ break;
+
+ // Other Language
+ default:
+ break;
+ }
+ }
+#ifdef RD_HINDI_PHONETIC_INPUT
+TBool TAknFepUiIndicInputManager :: IsIndicPhoneticLanguage(TLanguage aInputLanguage)
+ {
+ TBool ret = EFalse;
+ switch(aInputLanguage)
+ {
+ case KLangHindiPhonetic:
+ ret = ETrue;
+ break;
+ default:
+ break;
+ }
+ return ret;
+ }
+#endif
+
+
+TBool TAknFepUiIndicInputManager::IsModifierAllowed( TUint aPrevChar,
+ TLanguage aLanguage )
+ {
+ if( IsCharVirama( aPrevChar, aLanguage ) ||
+ IsCharModifier( aPrevChar, aLanguage ) ||
+ IsCharOther( aPrevChar, aLanguage ) )
+ {
+ return EFalse;
+ }
+
+ return ETrue;
+ }
+
+void TAknFepUiIndicInputManager::GetLigature( TDes& aLigature,
+ TUint aCurrChar, TLanguage aLanguage )
+ {
+ aLigature.Zero();
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+ {
+ switch( aCurrChar )
+ {
+ case 0x0973:
+ {
+ // Ksha
+ aLigature.Append( 0x0915 );
+ aLigature.Append( Virama( aLanguage ) );
+ aLigature.Append( 0x0937 );
+ }
+ break;
+
+ case 0x0974:
+ {
+ // Gya(n)
+ aLigature.Append( 0x091C );
+ aLigature.Append( Virama( aLanguage ) );
+ aLigature.Append( 0x091E );
+ }
+ break;
+
+ case 0x0975:
+ {
+ // Shra
+ aLigature.Append( 0x0936 );
+ aLigature.Append( Virama( aLanguage ) );
+ aLigature.Append( 0x0930 );
+ }
+ break;
+
+ case 0x0976:
+ {
+ // Tra
+ aLigature.Append( 0x0924 );
+ aLigature.Append( Virama( aLanguage ) );
+ aLigature.Append( RaCharacter( aLanguage ) );
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ // Other Language
+ default:
+ break;
+ }
+ }
+
+TBool TAknFepUiIndicInputManager::IsCharLigature( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+ {
+ if ( aChar >= 0x0973 && aChar <= 0x0976 )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+
+ return( result );
+ }
+
+TBool TAknFepUiIndicInputManager::IsCharAtStartOfLigature( TUint aChar,
+ TLanguage aLanguage)
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+ {
+ if( aChar == 0x0973 )
+ {
+ // Ksha is the first ligature in the key-map.
+ result = ETrue;
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+ }
+
+ return( result );
+ }
+
+#ifdef RD_HINDI_PHONETIC_INPUT
+TInt TAknFepUiIndicInputManager ::MapCharacterToKeys(TUint aChar, TLanguage aLanguage)
+ {
+ TPtiKey ret = EPtiKeyNone;
+ if( TAknFepUiIndicInputManager::IsCharOther( aChar, aLanguage )
+ || TAknFepUiIndicInputManager::IsCharEmpty( aChar, aLanguage ))
+ {
+ ret = EPtiKey0;
+ }
+ else if(TAknFepUiIndicInputManager::IsCharBaseConsonant( aChar, aLanguage ))
+ {
+ ret = EPtiKey4;
+ }
+ else if( TAknFepUiIndicInputManager::IsCharMatra( aChar, aLanguage )
+ || TAknFepUiIndicInputManager::IsCharAnVowel( aChar, aLanguage ))
+ {
+ ret = EPtiKey2;
+ }
+ else if( TAknFepUiIndicInputManager::IsCharNukta( aChar, aLanguage )
+ || TAknFepUiIndicInputManager::IsCharModifier( aChar, aLanguage )
+ || TAknFepUiIndicInputManager::IsCharVirama( aChar, aLanguage ))
+ {
+ ret = EPtiKey1;
+ }
+ return ret;
+ }
+#endif
+
+TBool TAknFepUiIndicInputManager :: IsScriptDevanagari( TLanguage aInputLanguage )
+ {
+ TBool ret = EFalse;
+ switch(aInputLanguage)
+ {
+ case ELangHindi:
+ case ELangMarathi:
+ ret = ETrue;
+ break;
+
+ default:
+ break;
+ }
+ return ret;
+ }
+
+TBool TAknFepUiIndicInputManager::IsToCommitCharSeq( TIndicInputResponse aResponse )
+ {
+ TBool result = EFalse;
+
+ switch( aResponse )
+ {
+ case EIndicInputResponseInsertZWSandLigature:
+ case EIndicInputResponseInsertViramaZWSandDirectLigature:
+ {
+ result = ETrue;
+ }
+ break;
+ default:
+ break;
+ }
+ return result;
+ }
+
+TBool TAknFepUiIndicInputManager::IsCharNuktaConsonant( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ case ELangHindi:
+#ifdef RD_HINDI_PHONETIC_INPUT
+
+ case KLangHindiPhonetic:
+#endif
+ {
+ if ( aChar == 0x0929 ||
+ aChar == 0x0931 || aChar == 0x0934 ||
+ ( aChar >= 0x0958 && aChar <= 0x095F ) )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+ return( result );
+ }
+
+#ifdef RD_MARATHI
+
+TBool TAknFepUiIndicInputManager::IsCharEyeLashRa( TUint aChar, TLanguage aLanguage )
+ {
+ TBool result = EFalse;
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ {
+ if ( aChar == 0x0977 )
+ {
+ result = ETrue;
+ }
+ }
+ break;
+ default: /*Other Language*/
+ break;
+ }
+
+ return( result );
+ }
+
+void TAknFepUiIndicInputManager::GetEyeLashRa( TDes& aEyeLashRa,
+ TLanguage aLanguage )
+ {
+ aEyeLashRa.Zero();
+
+ switch( aLanguage )
+ {
+ case ELangMarathi:
+ {
+ TChar virama( TAknFepUiIndicInputManager::Virama( aLanguage ) );
+ aEyeLashRa.Append( 0x0931 );
+ aEyeLashRa.Append( virama );
+ aEyeLashRa.Append( ZERO_WIDTH_JOINER );
+ }
+ break;
+ // Other Language
+ default:
+ break;
+ }
+ }
+
+TBool TAknFepUiIndicInputManager::IsCharChandraA( TUint aChar )
+ {
+ // Since Chandra-A is specific to Marathi, we need not
+ // use the Language id check.
+ if ( aChar == 0x0978 )
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+void TAknFepUiIndicInputManager::GetChandraA( TDes& aChandraA,
+ TBool aIsToGetSingleUnicodeValue /* = EFalse */ )
+ {
+ aChandraA.Zero();
+
+ if( aIsToGetSingleUnicodeValue )
+ {
+ aChandraA.Append( 0x0978 );
+ }
+ else
+ {
+ aChandraA.Append( 0x0905 );
+ aChandraA.Append( 0x0945 );
+ }
+ }
+
+#endif //RD_MARATHI
+
+#ifndef RD_INTELLIGENT_TEXT_INPUT
+TBool TAknFepUiIndicInputManager::IsIndicDependantCharacter(TUint aChar, TLanguage aLanguage)
+ {
+
+ return (TAknFepUiIndicInputManager::IsCharModifier(aChar, aLanguage)
+ || TAknFepUiIndicInputManager::IsCharMatra(aChar, aLanguage)
+ || TAknFepUiIndicInputManager::IsCharVirama(aChar, aLanguage)
+ || TAknFepUiIndicInputManager::IsCharNukta(aChar, aLanguage));
+
+
+ }
+#endif //RD_INTELLIGENT_TEXT_INPUT
+//End of File