1 /*

     2 * Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0""

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:           

    15 *       Provides the TAknFepUIIndicInputManager methods.

    16 *

    17 */

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 

    27 

    28 

    29 #include "AknFepUiIndicInputManager.h"

    30 // -----------------------------------------------------------------------------

    31 // TAknFepUiIndicInputManager::ValidateInput

    32 

    33 // This function validates the input text given by PtiEngine. This function

    34 // returns the resopnse code depending on the previous character, current input 

    35 // character and the next character. Depending on the response code apropriate 

    36 // action is taken for inputting the current inputed character. This function 

    37 // incorporates the logic for Devanagari alphabate input.  

    38 // -----------------------------------------------------------------------------

    39 

    40 

    41 TIndicInputResponse TAknFepUiIndicInputManager::ValidateInput( TInt  aKey, 

    42 										  TUint aPrevChar,

    43 										  TUint aCurrChar,

    44 										  TUint /*aNextChar*/, 

    45 										  TBool&  aIsHalantOrMatraAllowed,	

    46 										  TBool aIsStarKeyPressed, 

    47 										  TBool aIsKeyTimerExpired,

    48 										  TPtiTextCase& aNewCase, 

    49 										  TKeyPressLength /*aLength*/,

    50 										  TLanguage aLanguage,

    51 										  TBool aIsRakarPresent /* = EFalse*/,

    52 										  TBool aIsZWSPresent /* = EFalse */ 

    53 #ifdef RD_MARATHI

    54 										  , TBool aIsChandraAPresent /* = EFalse */

    55 #endif // RD_MARATHI

    56 										  )

    57 

    58 	{

    59 	TIndicInputResponse keyResponse =  EIndicInputResponseNone;

    60 

    61 	TPtiTextCase setcase  = EPtiCaseLower;

    62 	

    63 	TAknFepUiIndicInputManager::SetHalantOrMatraAllowed( aPrevChar,

    64 														aIsHalantOrMatraAllowed,

    65 														aIsKeyTimerExpired,

    66 														aLanguage );

    67 	

    68 	switch( aKey )

    69 		{

    70 		case EPtiKey1:

    71 			{

    72 			if( IsCharNukta( aCurrChar, aLanguage ) && 

    73 				( IsCharNuktaConsonant( aPrevChar, aLanguage ) ||

    74 					!IsCharBaseConsonant( aPrevChar, aLanguage ) ) )

    75 				{

    76 				keyResponse = EIndicInputResponseInvalid;

    77 				}

    78 #ifdef RD_MARATHI

    79 			else if( IsCharEyeLashRa( aCurrChar, aLanguage ) )

    80 				{

    81 				keyResponse = EIndicInputResponseInsertEyeLashRa;

    82 				}

    83 #endif // RD_MARATHI

    84 

    85 			else if ( IsCharEmpty( aPrevChar, aLanguage ) )

    86 				{

    87 				// The special characters present in key-1 have to be

    88 				// allowed. So the response is not set to digit directly

    89 				// But at the same time, skip the fallback modifiers.

    90 				if( IsCharModifier( aCurrChar, aLanguage ) )

    91 					{

    92 					keyResponse = EIndicInputResponseInvalid;

    93 					}

    94 				}

    95 			else if( IsCharRakar( aCurrChar, aLanguage ) )

    96 				{

    97 				if( aIsHalantOrMatraAllowed )

    98 					{

    99 					keyResponse = EIndicInputResponseInsertRakar;

   100 					}

   101 				else

   102 					{

   103 					keyResponse = EIndicInputResponseInvalid;

   104 					}

   105 				}

   106 			else if( IsCharRepha( aCurrChar, aLanguage ) )

   107 				{

   108 				if( IsRephaAllowed( aPrevChar, aLanguage ) ||

   109 					( aIsRakarPresent && !aIsKeyTimerExpired ) )

   110 					{

   111 					keyResponse = EIndicInputResponseInsertRepha;

   112 					}

   113 				else

   114 					{

   115 					keyResponse = EIndicInputResponseInvalid;

   116 					}

   117 				}

   118 			else if ( IsCharOther( aPrevChar, aLanguage )

   119 				     || IsCharVirama( aPrevChar, aLanguage ) )	

   120 				{

   121 				// Since the response  cannot be set to digit

   122 				// directly here, validate the modifiers first.

   123 				if( IsCharModifier( aCurrChar, aLanguage ) )

   124 					{

   125 					if( !IsModifierAllowed( aPrevChar, aLanguage ) )

   126 						{

   127 						keyResponse = EIndicInputResponseInvalid;

   128 						}

   129 					}

   130 				}

   131 			else if ( IsCharModifier( aPrevChar, aLanguage ) )

   132 				{

   133 				// Unlike in earlier code, the response  cannot be set to

   134 				// Digit directly here. The special characters present in 

   135 				// key-1 have to be allowed. As a result, the fallback 

   136 				// modifiers need to be skipped.

   137 				if( IsCharModifier( aCurrChar, aLanguage ) )

   138 					{

   139 					if( !IsModifierAllowed( aPrevChar, aLanguage ) )

   140 						{

   141 						keyResponse = EIndicInputResponseInvalid;

   142 						}

   143 					}

   144 				else

   145 					{

   146 					if (  ! aIsHalantOrMatraAllowed  )

   147 						{

   148 						setcase = EPtiCaseUpper;	

   149 						}

   150 					else if ( IsCharVirama( aCurrChar, aLanguage ) )

   151 						{

   152 						keyResponse = EIndicInputResponseInsertZWS;

   153 						}	

   154 					}	

   155 				}

   156 #ifdef RD_MARATHI

   157 			else if( IsCharVirama( aCurrChar, aLanguage ) &&

   158 				aIsHalantOrMatraAllowed )

   159 				{

   160 				keyResponse = EIndicInputResponseInsertZWS;

   161 				}

   162 #endif // RD_MARATHI

   163 

   164 			// In cases where the response cannot be set to digit directly,

   165 			// each character in key-1 has to be validated. Example in an 

   166 			// Here we validate the Virama, Rakara and Repha

   167 			if( IsCharVirama( aCurrChar, aLanguage ) )

   168 				{

   169 				if( keyResponse != EIndicInputResponseInsertZWS )

   170 					{

   171 					keyResponse = EIndicInputResponseInvalid;

   172 					}

   173 				}

   174 			else if( IsCharRakar( aCurrChar, aLanguage ) )

   175 				{

   176 				if( keyResponse != EIndicInputResponseInsertRakar )

   177 					{

   178 					keyResponse = EIndicInputResponseInvalid;

   179 					}

   180 				}

   181 			else if( IsCharRepha( aCurrChar, aLanguage ) )

   182 				{

   183 				// In case of empty editor, all the modifiers, virama

   184 				// and rakar will be skipped. Even the Repha is to be skipped

   185 				if( keyResponse != EIndicInputResponseInsertRepha )

   186 					{

   187 					keyResponse = EIndicInputResponseInvalid;

   188 					}

   189 				}

   190 			}

   191 			break;

   192 	    

   193 	    case EPtiKey2:

   194 	    case EPtiKey3:

   195 	    	{

   196     		if ( IsCharEmpty( aPrevChar, aLanguage )

   197 	    		|| IsCharAnVowel( aPrevChar, aLanguage )

   198         		|| IsCharModifier( aPrevChar, aLanguage ) 

   199 #ifdef RD_MARATHI

   200 				|| ( aIsChandraAPresent && !aIsKeyTimerExpired )

   201 #endif // RD_MARATHI

   202 	    		)

   203     			{

   204 	    		setcase = EPtiCaseUpper;

   205 	    		}

   206 	    	else if( IsCharVirama( aPrevChar, aLanguage ) )

   207 	    		{

   208 	    		setcase = EPtiCaseUpper;

   209 	    		

   210 	    		// Response code changed to EIndicInputResponseNone to avoid

   211 	    		// insertion of ZWS character for Vowels.

   212 	    		keyResponse = EIndicInputResponseNone;

   213 	    		}

   214 	    	else if ( IsCharOther( aPrevChar, aLanguage ) )

   215 	    		{

   216 	    		if ( aIsKeyTimerExpired || IsCharSpace( aPrevChar ) || ( ! aIsHalantOrMatraAllowed ) )

   217 	    			{

   218 	    			setcase = EPtiCaseUpper;	

   219 	    			}

   220 	    		}

   221 	    	else if ( IsCharMatra( aPrevChar, aLanguage ) )

   222 		    	{

   223 	    		if ( aIsKeyTimerExpired )

   224 	    			{

   225 	    			setcase = EPtiCaseUpper;	

   226 	    			}		    	

   227 		    	}		  

   228 	    	else if ( IsCharBaseConsonant( aPrevChar, aLanguage )

   229 		    		|| IsCharNukta( aPrevChar, aLanguage ) )

   230 			    {

   231 			    if ( aIsStarKeyPressed )

   232 			    	{

   233 					setcase = EPtiCaseUpper;	

   234 			    	}					

   235 				}

   236 #ifdef RD_MARATHI

   237             if( IsCharChandraA( aCurrChar ) )

   238 				{

   239 				keyResponse = EIndicInputResponseInsertChandraA;

   240 				}

   241 #endif // RD_MARATHI

   242 	    	}

   243 	    	break;

   244 	    

   245 	    case EPtiKey4:

   246 	    case EPtiKey5:

   247 	    case EPtiKey6:

   248 	    case EPtiKey7:

   249 	    case EPtiKey8:

   250 	    case EPtiKey9:

   251 	    	{

   252 			if ( aIsStarKeyPressed )

   253 				{

   254 				if( IsCharBaseConsonant( aCurrChar, aLanguage )

   255 			       && ( IsCharBaseConsonant( aPrevChar, aLanguage ) || 

   256 			            IsCharNukta( aPrevChar, aLanguage ) ) )

   257 					{

   258 					keyResponse = EIndicInputResponseInsertZWSandLigature;

   259 					}

   260 				else if( IsCharBaseConsonant( aCurrChar, aLanguage )

   261 			       && IsCharVirama( aPrevChar, aLanguage ) )

   262 					{

   263 					keyResponse = EIndicInputResponseZWSandCharacter;

   264 					}

   265 				}

   266 			else if( IsCharVirama( aPrevChar, aLanguage ) )

   267 				{

   268 				keyResponse = EIndicInputResponseZWSandCharacter;	

   269 				}

   270 	    	}

   271 	    	break;

   272 	    

   273 		case EPtiKey0:

   274 			{

   275 			// Special ligatures added in key-0.

   276 			if( IsCharLigature( aCurrChar, aLanguage ) )

   277 				{

   278 				if ( aIsStarKeyPressed && 

   279 						IsCharBaseConsonant( aPrevChar, aLanguage ) )

   280 					{

   281 					keyResponse = EIndicInputResponseInsertViramaZWSandDirectLigature;

   282 					}

   283 				else if( IsCharVirama( aPrevChar, aLanguage ) && 

   284 						IsCharAtStartOfLigature( aCurrChar, aLanguage ) && 

   285 						!aIsZWSPresent )

   286 					{

   287 					keyResponse = EIndicInputResponseZWSandDirectLigature;

   288 					}

   289 				else

   290 					{

   291 					keyResponse = EIndicInputResponseInsertDirectLigature;

   292 					}

   293 				}

   294 			}

   295 	    break;

   296 

   297 	    default:

   298 		  	{

   299 			keyResponse = EIndicInputResponseIgnore;

   300 	      	}

   301 	    	break;

   302 			

   303 		}

   304 	aNewCase = setcase;

   305 	return keyResponse;

   306 	}

   307 

   308 

   309 

   310 // -----------------------------------------------------------------------------

   311 // TAknFepUiIndicInputManager::IsCharOther

   312 

   313 // This function checks for wheather the character is other character. The other 

   314 // character includes numbers, character of other languages and spaces.

   315 // -----------------------------------------------------------------------------

   316 

   317 TBool TAknFepUiIndicInputManager::IsCharOther( TUint aChar, TLanguage aLanguage )

   318 	{

   319 	TBool result = EFalse;	

   320 	

   321 	switch( aLanguage )

   322 		{	

   323 		case ELangMarathi:

   324 		case ELangHindi:

   325 #ifdef RD_HINDI_PHONETIC_INPUT	

   326 		

   327 		case KLangHindiPhonetic:

   328 #endif		

   329 			{

   330 			if ( !( IsCharBaseConsonant( aChar, aLanguage )

   331 					||	IsCharNukta( aChar, aLanguage )

   332 					||	IsCharMatra( aChar, aLanguage )

   333 					||	IsCharAnVowel( aChar, aLanguage )

   334 					||	IsCharModifier( aChar, aLanguage )

   335 					||	IsCharVirama( aChar, aLanguage )

   336 					||  IsCharRakar( aChar, aLanguage )

   337 					||  IsCharRepha( aChar, aLanguage ) 

   338 					||	IsCharLigature( aChar, aLanguage ) 

   339 #ifdef RD_MARATHI

   340 					||	IsCharEyeLashRa( aChar, aLanguage ) 

   341 					||  IsCharChandraA( aChar )

   342 #endif

   343 					) )

   344 				{

   345 				result = ETrue;	

   346 				}

   347 			}

   348 			break;

   349 		default: /*Other Language*/

   350 			break;

   351 		}

   352 	return( result );	

   353 	}	

   354 

   355 // -----------------------------------------------------------------------------

   356 // TAknFepUiIndicInputManager::IsCharEmpty

   357 

   358 // This function checks wheather the character is null

   359 // -----------------------------------------------------------------------------

   360 

   361 TBool TAknFepUiIndicInputManager::IsCharEmpty( TUint aChar, TLanguage aLanguage )

   362 	{

   363 	TBool result = EFalse;	

   364 	

   365 	switch( aLanguage )

   366 		{	

   367 		case ELangMarathi:

   368 		case ELangHindi:

   369 #ifdef RD_HINDI_PHONETIC_INPUT	

   370 		case KLangHindiPhonetic:

   371 #endif		

   372 			{

   373 			if ( aChar == 0 )

   374 				{

   375 				result = ETrue;	

   376 				}

   377 			}

   378 			break;

   379 		default: /*Other Language*/

   380 			break;

   381 		}

   382 	return( result );	

   383 	}	

   384 

   385 

   386 // -----------------------------------------------------------------------------

   387 // TAknFepUiIndicInputManager::IsCharBaseConsonant

   388 

   389 // This function checks wheather the character is base consonant

   390 // -----------------------------------------------------------------------------

   391 

   392 TBool TAknFepUiIndicInputManager::IsCharBaseConsonant( TUint aChar, TLanguage aLanguage )

   393 	{

   394 	TBool result = EFalse;	

   395 	

   396 	switch( aLanguage )

   397 		{	

   398 		case ELangMarathi:

   399 		case ELangHindi:

   400 #ifdef RD_HINDI_PHONETIC_INPUT	

   401 		case KLangHindiPhonetic:

   402 #endif		

   403 			{

   404 			if ( ( aChar >= 0x0915 && aChar <= 0x0939 )

   405 					||( aChar >= 0x0958 && aChar <= 0x095F ) )

   406 				{

   407 				result = ETrue;							

   408 				}

   409 			}

   410 			break;

   411 		default: /*Other Language*/

   412 			break;

   413 		}

   414 	return( result );	

   415 	}

   416 

   417 

   418 // -----------------------------------------------------------------------------

   419 // TAknFepUiIndicInputManager::IsCharNukta

   420 

   421 // This function checks wheather the character is Nukta.

   422 // -----------------------------------------------------------------------------

   423 

   424  TBool TAknFepUiIndicInputManager::IsCharNukta( TUint aChar, TLanguage aLanguage )

   425 	{

   426 	TBool result = EFalse;	

   427 	

   428 	switch( aLanguage )

   429 		{	

   430 		case ELangMarathi:

   431 		case ELangHindi:

   432 #ifdef RD_HINDI_PHONETIC_INPUT	

   433 		case KLangHindiPhonetic:

   434 #endif		

   435 			{

   436 			if ( aChar == 0x093C )

   437 				{

   438 				result = ETrue;	

   439 				}

   440 			}

   441 			break;

   442 		default: /*Other Language*/

   443 			break;

   444 		}

   445 	

   446 	return( result );	

   447 	}

   448 

   449 // -----------------------------------------------------------------------------

   450 // TAknFepUiIndicInputManager::IsCharMatra

   451 

   452 // This function checks wheather the character is Nukta.

   453 // -----------------------------------------------------------------------------

   454 

   455 TBool TAknFepUiIndicInputManager::IsCharMatra( TUint aChar,  TLanguage aLanguage )

   456 	{

   457 	TBool result = EFalse;	

   458 	

   459 	switch( aLanguage )

   460 		{	

   461 		case ELangMarathi:

   462 		case ELangHindi:

   463 #ifdef RD_HINDI_PHONETIC_INPUT	

   464 		case KLangHindiPhonetic:

   465 #endif		

   466 			{

   467 			if ( ( aChar >= 0x093E && aChar <= 0x094C ) 

   468 					||( aChar == 0x0962 || aChar == 0x0963 ) )

   469 				{

   470 				result = ETrue;							

   471 				}

   472 			}

   473 			break;

   474 		default: /*Other Language*/

   475 			break;

   476 		}

   477 	return( result );

   478 	}

   479 

   480 // -----------------------------------------------------------------------------

   481 // TAknFepUiIndicInputManager::IsCharAnVowel

   482 

   483 // This function checks for wheather the character is Nukta.

   484 // -----------------------------------------------------------------------------

   485 

   486  TBool TAknFepUiIndicInputManager::IsCharAnVowel( TUint aChar, TLanguage aLanguage )

   487 	{

   488 	TBool result = EFalse;

   489 	

   490 	switch( aLanguage )

   491 		{	

   492 		case ELangMarathi:

   493 		case ELangHindi:

   494 #ifdef RD_HINDI_PHONETIC_INPUT	

   495 		case KLangHindiPhonetic:

   496 #endif

   497 			{

   498 			if ( ( aChar>=0x0904 && aChar<=0x0914 )

   499 					||( aChar==0x0960 || aChar==0x0961 ) )

   500 				{

   501 				result = ETrue;							

   502 				}

   503 			}

   504 			break;

   505 		default: /*Other Language*/

   506 			break;

   507 		}

   508 	return( result );

   509 	}

   510 

   511 // -----------------------------------------------------------------------------

   512 // TAknFepUiIndicInputManager::IsCharModifier

   513 

   514 // This function checks wheather the character is Modifier.

   515 // -----------------------------------------------------------------------------

   516 

   517  TBool TAknFepUiIndicInputManager::IsCharModifier( TUint aChar, TLanguage aLanguage )

   518 	{	

   519 	TBool result = EFalse;

   520 	

   521 	switch( aLanguage )

   522 		{	

   523 		case ELangMarathi:

   524 		case ELangHindi:

   525 #ifdef RD_HINDI_PHONETIC_INPUT	

   526 		case KLangHindiPhonetic:

   527 #endif		

   528 			{

   529 			if ( aChar>= 0x0901 && aChar <= 0x0903 )

   530 				{

   531 				result = ETrue;	

   532 				}				

   533 			}

   534 			break;

   535 		default: /*Other Language*/

   536 			break;

   537 		}

   538 	

   539 	return( result );

   540 	}

   541 

   542 // -----------------------------------------------------------------------------

   543 // TAknFepUiIndicInputManager::IsCharVirama

   544 

   545 // This function checks wheather the character is Halant.

   546 // -----------------------------------------------------------------------------

   547 

   548 

   549  TBool TAknFepUiIndicInputManager::IsCharVirama( TUint aChar, TLanguage aLanguage )

   550 	{

   551 	TBool result = EFalse;

   552 	

   553 	switch( aLanguage )

   554 		{	

   555 		case ELangMarathi:

   556 		case ELangHindi:

   557 #ifdef RD_HINDI_PHONETIC_INPUT	

   558 		

   559 		case KLangHindiPhonetic:

   560 #endif

   561 			{

   562 			if ( aChar == 0x094D )

   563 				{

   564 				result = ETrue;	

   565 				}

   566 			}

   567 		break;

   568 		default: /*Other Language*/

   569 		break;

   570 		}

   571 		

   572 	return( result );

   573 	}		

   574 	

   575 // -----------------------------------------------------------------------------

   576 // TAknFepUiIndicInputManager::IsCharSpace

   577 

   578 // This function checks wheather the character is Space.

   579 // -----------------------------------------------------------------------------

   580 

   581 TBool TAknFepUiIndicInputManager::IsCharSpace( TUint aChar )

   582 	{

   583 	TBool result = EFalse;

   584 	

   585 	if ( aChar == ( 0x0020 ) )

   586 		{

   587 			result = ETrue;	

   588 		}

   589 	return( result );	

   590 	}

   591 	

   592 // -----------------------------------------------------------------------------

   593 // TAknFepUiIndicInputManager::SetHalantAllowed

   594 

   595 // This function checks wheather the Halant can be inputted at the current curssor

   596 // posiotion.

   597 // -----------------------------------------------------------------------------

   598 	

   599 void TAknFepUiIndicInputManager::SetHalantOrMatraAllowed( TUint aPrevChar, 

   600 													   	TBool& aViramaAllowed,

   601 													   	TBool aIsKeyTimerExpired,

   602 													   	TLanguage aLanguage )

   603 	{

   604 	if ( IsCharAnVowel( aPrevChar, aLanguage ) )

   605 		{

   606 		aViramaAllowed = EFalse;

   607 		}

   608 	else if ( IsCharBaseConsonant( aPrevChar, aLanguage ) || 

   609 		IsCharNukta( aPrevChar, aLanguage ) )

   610 		{

   611 		aViramaAllowed = ETrue;

   612 		}

   613 	if ( ( IsCharMatra( aPrevChar, aLanguage ) || 

   614 		IsCharOther( aPrevChar, aLanguage )  || 

   615 		IsCharVirama( aPrevChar, aLanguage ) ||

   616 		IsCharModifier( aPrevChar, aLanguage ) ) && aIsKeyTimerExpired )

   617 		{

   618 		// The new conditions are required as we are not making the response 

   619 		// to digit as before. We iterate through all the characters in key-1

   620 		// and skip the ones which are not required.

   621 		aViramaAllowed = EFalse;	

   622 		}

   623 	}

   624 

   625 // -----------------------------------------------------------------------------

   626 // TAknFepUiIndicInputManager::Virama

   627 

   628 // This function returns back the unicode value for Halant.

   629 // -----------------------------------------------------------------------------

   630 		

   631 TUint TAknFepUiIndicInputManager::Virama( TLanguage aLanguage )

   632 	{

   633 	TUint ret = 0;

   634 	switch( aLanguage )

   635 		{	

   636 		case ELangMarathi:

   637 		case ELangHindi:

   638 #ifdef RD_HINDI_PHONETIC_INPUT	

   639 		case KLangHindiPhonetic:

   640 #endif		

   641 			{

   642 			ret = 0x094D;	

   643 			}

   644 		break;

   645 		default: /*Other Language*/

   646 		break;

   647 		}

   648 		

   649 	return( ret );	

   650 	}

   651 

   652 TBool TAknFepUiIndicInputManager :: IsIndicLangauge(TLanguage aInputLanguage)

   653 	{	

   654 	TBool ret = EFalse;

   655 	switch(aInputLanguage)

   656 		{

   657 		case ELangHindi:

   658 		case ELangMarathi:

   659 			ret = ETrue;

   660 		break;

   661 

   662 		default: /*Other Language*/

   663 		break;

   664 		}

   665 	return ret;

   666 	}

   667 

   668 TBool TAknFepUiIndicInputManager :: IsIndicDigitsSupported(TLanguage aInputLanguage)

   669 	{	

   670 	TBool ret = EFalse;

   671 	switch(aInputLanguage)

   672 		{

   673 #ifdef RD_HINDI_PHONETIC_INPUT	

   674 		

   675 		case KLangHindiPhonetic:

   676 			ret = ETrue;

   677 		break;

   678 #endif

   679 		default:

   680 			TLanguage uiLanguage = User::Language();

   681 			switch(uiLanguage)

   682 				{

   683 				case ELangHindi:

   684 				case ELangMarathi:

   685 					ret = ETrue;

   686 				}

   687 		}

   688 	return ret;

   689 	}

   690 

   691 TBool TAknFepUiIndicInputManager::IsRephaAllowed( TUint aChar, TLanguage aLanguage )

   692 	{

   693 	TBool result = EFalse;

   694 

   695 	switch( aLanguage )

   696 		{

   697 		case ELangMarathi:

   698 		case ELangHindi:

   699 			{

   700 			if ( IsCharBaseConsonant( aChar, aLanguage ) ||

   701 				 IsCharMatra( aChar, aLanguage ) )

   702 				{

   703 				result = ETrue;

   704 				}

   705 			}

   706 			break;

   707 		default: /*Other Language*/

   708 			break;

   709 		}

   710 	return( result );

   711 	}

   712 

   713 TBool TAknFepUiIndicInputManager::IsCharRepha( TUint aChar, TLanguage aLanguage )

   714 	{

   715 	TBool result = EFalse;

   716 	

   717 	switch( aLanguage )

   718 		{

   719 		case ELangMarathi:

   720 		case ELangHindi:

   721 			{

   722 			if ( aChar == 0x0971 )

   723 				{

   724 				result = ETrue;

   725 				}

   726 			}

   727 		break;

   728 		default: /*Other Language*/

   729 		break;

   730 		}

   731 		

   732 	return( result );

   733 	}

   734 

   735 TUint TAknFepUiIndicInputManager::RaCharacter( TLanguage aLanguage )

   736 	{

   737 	TUint ret = 0;

   738 	switch( aLanguage )

   739 		{	

   740 		case ELangMarathi:

   741 		case ELangHindi:

   742 			{

   743 			ret = 0x0930;

   744 			}

   745 		break;

   746 		

   747 		// Other Language

   748 		default:

   749 		break;

   750 		}

   751 		

   752 	return( ret );

   753 	}

   754 

   755 void TAknFepUiIndicInputManager::GetRepha( TDes& aRepha, TLanguage aLanguage )

   756 	{

   757 	aRepha.Zero();

   758 	

   759 	switch( aLanguage )

   760 		{

   761 		case ELangMarathi:

   762 		case ELangHindi:

   763 			{

   764 			TChar raChar( TAknFepUiIndicInputManager::RaCharacter( aLanguage ) );

   765 			TChar virama( TAknFepUiIndicInputManager::Virama( aLanguage ) );

   766 			aRepha.Append( raChar );

   767 			aRepha.Append( virama );

   768 			}

   769 			break;

   770 			

   771 		// Other Language

   772 		default:

   773 		break;

   774 		}

   775 	}

   776 

   777 TBool TAknFepUiIndicInputManager::IsCharRakar( TUint aChar, TLanguage aLanguage )

   778 	{

   779 	TBool result = EFalse;

   780 	

   781 	switch( aLanguage )

   782 		{	

   783 		case ELangMarathi:

   784 		case ELangHindi:

   785 			{

   786 			if ( aChar == 0x0972 )

   787 				{

   788 				result = ETrue;

   789 				}

   790 			}

   791 		break;

   792 		default: /*Other Language*/

   793 		break;

   794 		}

   795 		

   796 	return( result );

   797 	}

   798 

   799 void TAknFepUiIndicInputManager::GetRakar( TDes& aRakar, TLanguage aLanguage )

   800 	{

   801 	aRakar.Zero();

   802 	

   803 	switch( aLanguage )

   804 		{

   805 		case ELangMarathi:

   806 		case ELangHindi:

   807 			{

   808 			TChar virama( TAknFepUiIndicInputManager::Virama( aLanguage ) );

   809 			TChar raChar( TAknFepUiIndicInputManager::RaCharacter( aLanguage ) );

   810 			aRakar.Append( virama );

   811 			aRakar.Append( raChar );

   812 			}

   813 			break;

   814 			

   815 		// Other Language

   816 		default:

   817 		break;

   818 		}

   819 	}

   820 #ifdef RD_HINDI_PHONETIC_INPUT	

   821 TBool TAknFepUiIndicInputManager :: IsIndicPhoneticLanguage(TLanguage aInputLanguage)

   822 	{

   823 	TBool ret = EFalse;

   824 	switch(aInputLanguage)

   825 		{

   826 		case KLangHindiPhonetic:

   827 			ret = ETrue;

   828 		break;

   829 		default:

   830 		break;

   831 		}

   832 	return ret;	

   833 	}

   834 #endif

   835 

   836 

   837 TBool TAknFepUiIndicInputManager::IsModifierAllowed( TUint aPrevChar, 

   838 		 											TLanguage aLanguage )

   839 	{

   840 	if( IsCharVirama( aPrevChar, aLanguage ) 		||

   841 			IsCharModifier( aPrevChar, aLanguage ) 	|| 

   842 			IsCharOther( aPrevChar, aLanguage ) )

   843 			{

   844 			return EFalse;

   845 			}

   846 

   847 	return ETrue;

   848 	}

   849 

   850 void TAknFepUiIndicInputManager::GetLigature( TDes& aLigature, 

   851 									TUint aCurrChar, TLanguage aLanguage )

   852 	{

   853 	aLigature.Zero();

   854 	

   855 	switch( aLanguage )

   856 		{

   857 		case ELangMarathi:

   858 		case ELangHindi:

   859 			{

   860 			switch( aCurrChar )

   861 				{

   862 				case 0x0973:

   863 					{

   864 					// Ksha

   865 					aLigature.Append( 0x0915 );

   866 					aLigature.Append( Virama( aLanguage ) );

   867 					aLigature.Append( 0x0937 );

   868 					}

   869 					break;

   870 

   871 				case 0x0974:

   872 					{

   873 					// Gya(n)

   874 					aLigature.Append( 0x091C );

   875 					aLigature.Append( Virama( aLanguage ) );

   876 					aLigature.Append( 0x091E );

   877 					}

   878 					break;

   879 

   880 				case 0x0975:

   881 					{

   882 					// Shra

   883 					aLigature.Append( 0x0936 );

   884 					aLigature.Append( Virama( aLanguage ) );

   885 					aLigature.Append( 0x0930 );

   886 					}

   887 					break;

   888 

   889 				case 0x0976:

   890 					{

   891 					// Tra

   892 					aLigature.Append( 0x0924 );

   893 					aLigature.Append( Virama( aLanguage ) );

   894 					aLigature.Append( RaCharacter( aLanguage ) );

   895 					}

   896 					break;

   897 

   898 				default:

   899 				break;

   900 				}

   901 			}

   902 			

   903 		// Other Language

   904 		default:

   905 		break;

   906 		}

   907 	}

   908 

   909 TBool TAknFepUiIndicInputManager::IsCharLigature( TUint aChar, TLanguage aLanguage )

   910 	{

   911 	TBool result = EFalse;

   912 	

   913 	switch( aLanguage )

   914 		{	

   915 		case ELangMarathi:

   916 		case ELangHindi:

   917 			{

   918 			if ( aChar >= 0x0973 && aChar <= 0x0976 )

   919 				{

   920 				result = ETrue;	

   921 				}

   922 			}

   923 		break;

   924 		default: /*Other Language*/

   925 		break;

   926 		}

   927 

   928 	return( result );

   929 	}

   930 

   931 TBool TAknFepUiIndicInputManager::IsCharAtStartOfLigature( TUint aChar, 

   932 													TLanguage aLanguage)

   933 	{

   934 	TBool result = EFalse;

   935 	

   936 	switch( aLanguage )

   937 		{	

   938 		case ELangMarathi:

   939 		case ELangHindi:

   940 			{

   941 			if( aChar == 0x0973 )

   942 				{

   943 				// Ksha is the first ligature in the key-map.

   944 				result = ETrue;

   945 				}

   946 				break;

   947 			default: /*Other Language*/

   948 			break;

   949 			}

   950 		}

   951 

   952 	return( result );

   953 	}

   954 

   955 #ifdef RD_HINDI_PHONETIC_INPUT		

   956 TInt TAknFepUiIndicInputManager ::MapCharacterToKeys(TUint aChar, TLanguage aLanguage)

   957 	{

   958 	TPtiKey ret = EPtiKeyNone;

   959 	if(  TAknFepUiIndicInputManager::IsCharOther( aChar, aLanguage ) 

   960 	  || TAknFepUiIndicInputManager::IsCharEmpty( aChar, aLanguage ))

   961 		{

   962 		ret = EPtiKey0;	

   963 		}

   964 	else if(TAknFepUiIndicInputManager::IsCharBaseConsonant( aChar, aLanguage ))

   965 		{

   966 		ret = EPtiKey4;	

   967 		}

   968 	else if(   TAknFepUiIndicInputManager::IsCharMatra( aChar,  aLanguage )

   969 			|| TAknFepUiIndicInputManager::IsCharAnVowel( aChar, aLanguage ))

   970 		{

   971 		ret = EPtiKey2;	

   972 		}

   973 	else if(   TAknFepUiIndicInputManager::IsCharNukta( aChar, aLanguage )

   974 			|| TAknFepUiIndicInputManager::IsCharModifier( aChar, aLanguage )

   975 			|| TAknFepUiIndicInputManager::IsCharVirama( aChar, aLanguage ))

   976 		{

   977 		ret = EPtiKey1;	

   978 		}

   979 	return ret;

   980 	}

   981 #endif

   982 

   983 TBool TAknFepUiIndicInputManager :: IsScriptDevanagari( TLanguage aInputLanguage )

   984 	{	

   985 	TBool ret = EFalse;

   986 	switch(aInputLanguage)

   987 		{

   988 		case ELangHindi:

   989 		case ELangMarathi:

   990 			ret = ETrue;

   991 		break;

   992 

   993 		default:

   994 		break;

   995 		}

   996 	return ret;

   997 	}

   998 

   999 TBool TAknFepUiIndicInputManager::IsToCommitCharSeq( TIndicInputResponse aResponse )

  1000     {

  1001     TBool result = EFalse;

  1002 

  1003     switch( aResponse )

  1004         {

  1005         case EIndicInputResponseInsertZWSandLigature:

  1006         case EIndicInputResponseInsertViramaZWSandDirectLigature:

  1007             {

  1008             result = ETrue;

  1009             }

  1010             break;

  1011         default:

  1012             break;

  1013         }

  1014     return result;

  1015     }

  1016 

  1017 TBool TAknFepUiIndicInputManager::IsCharNuktaConsonant( TUint aChar, TLanguage aLanguage )

  1018 	{

  1019 	TBool result = EFalse;	

  1020 	

  1021 	switch( aLanguage )

  1022 		{	

  1023 		case ELangMarathi:

  1024 		case ELangHindi:

  1025 #ifdef RD_HINDI_PHONETIC_INPUT	

  1026 		

  1027 		case KLangHindiPhonetic:

  1028 #endif		

  1029 			{

  1030 			if ( aChar == 0x0929 || 

  1031 				aChar == 0x0931 || aChar == 0x0934 || 

  1032 				( aChar >= 0x0958 && aChar <= 0x095F ) )

  1033 				{

  1034 				result = ETrue;

  1035 				}

  1036 			}

  1037 			break;

  1038 		default: /*Other Language*/

  1039 			break;

  1040 		}

  1041 	return( result );

  1042 	}

  1043 

  1044 #ifdef RD_MARATHI

  1045 

  1046 TBool TAknFepUiIndicInputManager::IsCharEyeLashRa( TUint aChar, TLanguage aLanguage )

  1047 	{

  1048 	TBool result = EFalse;

  1049 	

  1050 	switch( aLanguage )

  1051 		{	

  1052 		case ELangMarathi:

  1053 			{

  1054 			if ( aChar == 0x0977 )

  1055 				{

  1056 				result = ETrue;

  1057 				}

  1058 			}

  1059 		break;

  1060 		default: /*Other Language*/

  1061 		break;

  1062 		}

  1063 		

  1064 	return( result );

  1065 	}

  1066 

  1067 void TAknFepUiIndicInputManager::GetEyeLashRa( TDes& aEyeLashRa, 

  1068 											TLanguage aLanguage )

  1069 	{

  1070 	aEyeLashRa.Zero();

  1071 	

  1072 	switch( aLanguage )

  1073 		{

  1074 		case ELangMarathi:

  1075 			{

  1076 			TChar virama( TAknFepUiIndicInputManager::Virama( aLanguage ) );

  1077 			aEyeLashRa.Append( 0x0931 );

  1078 			aEyeLashRa.Append( virama );

  1079 			aEyeLashRa.Append( ZERO_WIDTH_JOINER );

  1080 			}

  1081 		break;

  1082 		// Other Language

  1083 		default:

  1084 		break;

  1085 		}

  1086 	}

  1087 

  1088 TBool TAknFepUiIndicInputManager::IsCharChandraA( TUint aChar )

  1089 	{

  1090 	// Since Chandra-A is specific to Marathi, we need not

  1091 	// use the Language id check.

  1092 	if ( aChar == 0x0978 )

  1093     	{

  1094     	return ETrue;

  1095     	}

  1096 

  1097 	return EFalse;

  1098 	}

  1099 

  1100 void TAknFepUiIndicInputManager::GetChandraA( TDes& aChandraA, 

  1101 											TBool aIsToGetSingleUnicodeValue /* = EFalse */ )

  1102 	{

  1103 	aChandraA.Zero();

  1104 	

  1105 	if( aIsToGetSingleUnicodeValue )

  1106 		{

  1107 		aChandraA.Append( 0x0978 );

  1108 		}

  1109 	else

  1110 		{

  1111 		aChandraA.Append( 0x0905 );

  1112 		aChandraA.Append( 0x0945 );	

  1113 		}

  1114 	}

  1115 

  1116 #endif //RD_MARATHI

  1117 

  1118 #ifndef RD_INTELLIGENT_TEXT_INPUT

  1119 TBool TAknFepUiIndicInputManager::IsIndicDependantCharacter(TUint aChar, TLanguage aLanguage)

  1120 	{

  1121 	

  1122 	return (TAknFepUiIndicInputManager::IsCharModifier(aChar, aLanguage)

  1123 	 				|| TAknFepUiIndicInputManager::IsCharMatra(aChar, aLanguage)

  1124 	  				|| TAknFepUiIndicInputManager::IsCharVirama(aChar, aLanguage)

  1125 	  				|| TAknFepUiIndicInputManager::IsCharNukta(aChar, aLanguage));

  1126 	  			

  1127 	

  1128 	}

  1129 #endif //RD_INTELLIGENT_TEXT_INPUT

  1130 //End of File