diff -r f1bdd6b078d1 -r 2cb9bae34d17 fep/aknfep/src/AknFepUiIndicInputManager.cpp --- a/fep/aknfep/src/AknFepUiIndicInputManager.cpp Tue Jul 06 14:38:41 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1130 +0,0 @@ -/* -* 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