FCL/sf/mw/inputmethods: comparison textinput/ptienginev2/src/PtiEngineImpl.cpp

equal deleted inserted replaced

-:ebd48d2de13c
+:ecbabf52600f
 #include <Languages.hrh>
 #endif
 #include <AknUtils.h>
 #include <e32property.h>
 #include <AknFepInternalCRKeys.h>
+#include <AknFepInternalPSKeys.h>
 #include <AvkonInternalCRKeys.h>
 const TInt KDefaultLanguageGran = 5;
 const TInt KDefaultLangNamesGran = 40;
 const TInt KPhraseSeparator = 0x0020;
 const TInt16 KStrokeUnicode = 0x2461;
 const TInt16 KZhuyinIndicator = 0x2462;
 // Local method declarations.
 LOCAL_C TInt RemapVietnameseAccentedCharacter(TUint16 aChr);
+LOCAL_C TBool IsRegionalLang(TInt aVariantCode, TInt& aMainCode)
+{
+TBool ret = ETrue;
+switch(aVariantCode)
+{
+case ELangBrazilianPortuguese:
+aMainCode = ELangPortuguese;
+break;
+case ELangCanadianFrench:
+aMainCode = ELangFrench;
+break;
+case ELangLatinAmericanSpanish:
+aMainCode = ELangSpanish;
+break;
+case ELangEnglish_Taiwan:
+case ELangEnglish_HongKong:
+case ELangEnglish_Prc:
+aMainCode = ELangEnglish;
+break;
+default:
+aMainCode = aVariantCode;
+ret = EFalse;
+}
+return ret;
+}
+LOCAL_C TBool AlreadyExistLang(CArrayPtrFlat<CPtiCoreLanguage>* aLangArray, TInt aLangCode)
+{
+if (aLangArray)
+{
+for (TInt i=0; i < aLangArray->Count(); i++)
+{
+if (aLangArray->At(i)->LanguageCode() == aLangCode)
+{
+return ETrue;
+}
+}
+}
+return EFalse;
+}
+const TUid KXt9ImplementationUid = {0x102830B9};
 //
 // CPtiEngineImpl implementation
 //
 				}
 			}
 #endif
 		for (TInt i = 0; i < count; i++)
 			{
+		    TInt code = 0;
 			if ((iLanguages->At(i)->LanguageCode() != ELangNumeric)
 #ifdef RD_HINDI_PHONETIC_INPUT
 				&& (iLanguages->At(i)->LanguageCode() != KLangHindiPhonetic)
 #endif
 )
 				{
-				aResult->AppendL(iLanguages->At(i)->LanguageCode());
+			    if(IsRegionalLang(iLanguages->At(i)->LanguageCode(),code))
+{
+if(AlreadyExistLang(iLanguages,code))
+{
+continue;
+}
+}
+				aResult->AppendL(code);
 #ifdef RD_HINDI_PHONETIC_INPUT
 				if (iLanguages->At(i)->LanguageCode() == ELangHindi && isIndicPhoneticInputPresent)
 					aResult->AppendL(KLangHindiPhonetic);
 #endif
 				}
 		else if (!iCurrentLanguage->HasInputMode(aMode))
 			{
 			return KErrNoSuitableCore;
 			}
 		}
-iInputMode = aMode;
+	if (iInputMode != aMode)
+		{
+		OnInputModeChanged(iInputMode, aMode);
+		iInputMode = aMode;
+		}
 	TFileName temp;
 	temp.Copy(iTextBuffer);
 	return SetCurrentWord( temp );
 	}
+void CPtiEngineImpl::OnInputModeChanged(TPtiEngineInputMode /*aOldMode*/, TPtiEngineInputMode aNewMode)
+	{
+	if (aNewMode == EPtiEngineQwertyPredictive)
+		{
+		HBufC16* oldTextBuf = iTextBuffer.Alloc();
+		ClearCurrentWord();
+		if (oldTextBuf)
+			{
+			// why assigned here? eh, I don't want to do that either.
+			// SetCurrentWord will use core(), which will use iInputMode, and
+			// obviously, the core should return the new core, that is why.
+			iInputMode = aNewMode;
+			SetCurrentWord(oldTextBuf->Des());
+			delete oldTextBuf;
+			}
+		}
+	}
 // ---------------------------------------------------------------------------
 // CPtiEngineImpl::CountToneMarks
 //
 // ---------------------------------------------------------------------------
 		case EPtiEngineStrokeQwerty:
 		case EPtiEngineStrokePhraseHalfQwerty:
 		case EPtiEngineStrokePhraseQwerty:
 			{
-			TPtiKeyboardType keyboardType = EPtiKeyboardNone;
+			TPtiKeyboardType keyboardType = ActiveKeyboardType();
 			TBool IsStokeKey = EFalse;
-TRAP_IGNORE(keyboardType = ActiveKeyboardTypeL());
 if(EPtiKeyboardQwerty4x10 == keyboardType ||
 EPtiKeyboardQwerty3x11 == keyboardType )
 {
 TBuf<KMaxName> lowerdata;
 TInt StrokeUnicodePosition =0;
 	__ASSERT_DEBUG(iCurrentLanguage, User::Panic(KPtiEngineImplPanic, KErrCorrupt));
 	// Predictive QWERTY (XT9) changes ---->
 	// PtiXt9Core handles the capitalization it self, and it should not be overriden
 	// byt the PtiEngine.
-	if ( iInputMode==EPtiEngineQwertyPredictive )
+	if ( IsCurrentCoreSupportCaseInfo() )
 	    {
 	    return;
 	    }
 	// Predictive QWERTY (XT9) changes <----
 //
 // ---------------------------------------------------------------------------
 //
 void CPtiEngineImpl::GetModeNameIndexL(TPtiChineseVariant aVariant, RArray<TInt>& aResult)
 	{
+	CleanupClosePushL( aResult );
 	TResourceReader reader;
 	TFileName fileName;
 	TParse* fp = new(ELeave) TParse();
 	fp->Set(KCEResourceFile, &KDC_RESOURCE_FILES_DIR, NULL);
 			User::LeaveIfError(aResult.Append(value));
 			}
 		}
 	CleanupStack::PopAndDestroy(3);   // fsSession, rsFile, rBuffer
+CleanupStack::Pop();
 	}
 // ---------------------------------------------------------------------------
 // CPtiEngineImpl::IsValidKey
 //
 // ---------------------------------------------------------------------------
 //
 void CPtiEngineImpl::GetAvailableLanguagesL(RArray<TInt>& aResult)
 	{
+	CleanupClosePushL( aResult );
 	aResult.Reset();
 	const TInt count = iLanguages->Count();
 	for (TInt i = 0; i < count; i++)
 		{
+	    TInt code = 0;
 		if (iLanguages->At(i)->LanguageCode() != ELangNumeric)
 			{
-			aResult.AppendL(iLanguages->At(i)->LanguageCode());
+		    if(IsRegionalLang(iLanguages->At(i)->LanguageCode(),code))
-			}
+		        {
-		}
+		        if(AlreadyExistLang(iLanguages,code))
+		            {
+		            continue;
+			        }
+		        }
+			aResult.AppendL(code);
+		    }
+		}
+CleanupStack::Pop();
 	}
 // ---------------------------------------------------------------------------
 // CPtiEngineImpl::CreateDefaultUserDictionaryFileL
 void CPtiEngineImpl::NumericModeKeysForQwertyL(TInt aLanguage,
 RArray<TPtiNumericKeyBinding>& aResult,
 TBool aUseExtendedSet,
 TPtiKeyboardType aKeyboardType)
 	{
+	CleanupClosePushL( aResult );
 	aResult.Reset();
 	TPtiNumericKeyBinding bind;
 	TPtiKeyboardType keyboardType = aKeyboardType;
 	if (keyboardType == EPtiKeyboardNone)
 	    {
-	    keyboardType = ActiveKeyboardTypeL();
+	    keyboardType = ActiveKeyboardType();
 	    if (keyboardType == EPtiKeyboard12Key ||
 	        keyboardType == EPtiKeyboardNone)
 	        {
 	        keyboardType = FindFirstAvailableQwertyKeyboardType(aLanguage);
 	    }
 	if (keyboardType == EPtiKeyboard12Key ||
 	    keyboardType == EPtiKeyboardNone)
 	    {
+		CleanupStack::Pop();
 	    // No qwerty data available, can't go on.
 	    return;
 	    }
 	if (aLanguage == ELangJapanese)
 		for (TInt i = 0; i < count; i++)
 			{
 			bind = NumericModeKeysForNonLatinNumberLanguages[i];
 			User::LeaveIfError(aResult.Append(bind));
 			}
+		CleanupStack::Pop();
 		return;
 		}
 TPtiEngineInputMode mode = EPtiEngineQwerty;
 {
 qmappings->SetKeyboardType(origKeyb);
 }
 			}
 		}
+	CleanupStack::Pop();
 	}
 // ---------------------------------------------------------------------------
 // CPtiEngineImpl::GetNumericModeKeysForQwertyL
 {
 return maps->KeyboardType();
 }
 return EPtiKeyboardNone;*/
-	TInt keyboardLayout = 0;
+	TInt keyboardLayout = ActiveKeyboardType();
-RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);
 if (keyboardLayout <= 0 ||
 keyboardLayout > EPtiKeyboardMaxLayout - 1)
 {
 return EPtiKeyboardNone;
 // ---------------------------------------------------------------------------
 //
 void CPtiEngineImpl::KeyboardTypesSupportedByLanguageL(TInt aLanguage,
 RArray<TPtiKeyboardType>& aResult)
 {
+	CleanupClosePushL( aResult );
 CPtiCoreLanguage* lang = NULL;
 if (iCurrentLanguage && iCurrentLanguage->LanguageCode() == aLanguage)
 {
 lang = iCurrentLanguage;
 hmaps->KeyMapData()->KeyData(EPtiKeyboardHalfQwerty, tmpSize))
 {
 User::LeaveIfError(aResult.Append(EPtiKeyboardHalfQwerty));
 }
 }
+CleanupStack::Pop();
 }
 // ---------------------------------------------------------------------------
-// CPtiEngineImpl::ActiveKeyboardTypeL
+// CPtiEngineImpl::ActiveKeyboardType
 //
 // ---------------------------------------------------------------------------
 //
-TPtiKeyboardType CPtiEngineImpl::ActiveKeyboardTypeL()
+TPtiKeyboardType CPtiEngineImpl::ActiveKeyboardType() const
 {
-// Qwerty Keyboard layout
+	TInt keyboardType = EPtiKeyboardNone;
-TInt keyboardLayout = 0;
+#ifdef RD_SCALABLE_UI_V2
+	// Get physical keyboard type
-RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);
+	RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardType );
-if (keyboardLayout <= 0 ||
+	// When active keyboard is virtual keyboard,
-keyboardLayout > EPtiKeyboardMaxLayout - 1)
+	// need to get the active virtual keyboard type
-{
+	// and set keyboardType again.
-return EPtiKeyboardNone;
-}
+	// When the default physical keyboard is 0,
+	// it means that there is no physical keyboard,
-return (TPtiKeyboardType)keyboardLayout;
+	// also need to get the active virtual keyboard type.
+	TInt isQwertyOn = 0;
+	RProperty::Get(KCRUidAvkon, KAknQwertyInputModeActive, isQwertyOn);
+	TInt isVirtualInputActive = 0;
+	RProperty::Get( KPSUidAknFep, KAknFepTouchInputActive,
+					isVirtualInputActive );
+	if (( isVirtualInputActive > 0 || keyboardType == 0) && !isQwertyOn)
+		{
+		// Active keyboard is virtual keyboard
+		RProperty::Get( KPSUidAknFep, KAknFepVirtualKeyboardType,
+						keyboardType );
+		}
+#else
+	// Get physical keyboard type
+	RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardType );
+#endif
+	if ( keyboardType <= 0 || keyboardType >= EPtiKeyboardMaxLayout )
+		{
+	    keyboardType = EPtiKeyboardNone;
+		}
+	return (TPtiKeyboardType)keyboardType;
 }
 // ---------------------------------------------------------------------------
 // CPtiEngineImpl::GetNumericModeKeysForQwertyL
 //
 // ---------------------------------------------------------------------------
 return err;
 }
 #endif //FF_DUAL_LANGUAGE_SUPPORT
+TBool CPtiEngineImpl::IsCurrentCoreSupportCaseInfo()
+{
+if ( Core() )
+{
+if ( Core()->GetCoreInfo()->Uid() == KXt9ImplementationUid.iUid )
+{
+return ETrue;
+}
+}
+return EFalse;
+}
 // End of file

branch	RCL_3
changeset 44	ecbabf52600f
parent 43	ebd48d2de13c
child 46	bd83ceabce89