diff -r f1bdd6b078d1 -r 2cb9bae34d17 fep/aknfep/src/AknFepUiManagerJapanese.cpp --- a/fep/aknfep/src/AknFepUiManagerJapanese.cpp Tue Jul 06 14:38:41 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,866 +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 CAknFepUIManagerJapanese methods. -* -*/ - - - - - - - - - - - - -// INCLUDE FILES -#include // RDebug stuff... -#include -#include - -#include "AknFepGlobalEnums.h" -#include "AknFepUiManagerBase.h" -#include "AknFepUIManagerJapanese.h" -#include "AknFepManagerInterface.h" // MAknFepManagerInterface -#include "AknFepUIManagerStateInterface.h" // MAknFepUIManagerStateInterface -#include "AknFepManagerUIInterface.h" -#include "AknFepGlobalEnums.h" -#include "AknFepCaseManager.h" - -#include "AknFepUiInputStateInitialHiraganaKanji.h" -#include "AknFepUiInputStateInitialHiragana.h" -#include "AknFepUiInputStateInitialKatakana.h" -#include "AknFepUiInputStateInitialLatinJapanese.h" -#include "AknFepUiInputStateInitialFullNumber.h" -#include "AknFepUiInputStateEntryJapaneseMultitap.h" -#include "AknFepUiInputStateEntryHiraganaKanji.h" -#include "AknFepUiInputStateEntryKatakana.h" -#include "AknFepUiInputStateEntryLatinJapanese.h" -#include "AknFepUiInputStateConversionHiraganaKanji.h" -#include "AknFepUiInputStateCandidateHiraganaKanji.h" -#include "AknFepUiInputStateCompletionHiraganaKanji.h" -#include "AknFepUiInputStateCompletionPredictiveHiraganaKanji.h" -#include "AknFepUiInputStateCompletionJapaneseMultitap.h" -#include "AknFepUiInputStateCompletionKatakana.h" -#include "AknFepUiInputStateCompletionLatinJapanese.h" -#include "AknFepUiInputStatePredictiveInputJapanese.h" -#include "AknFepUiInputStateNextWordJapanesePredictive.h" -#include "AknFepUICtrlContainerJapanese.h" -#include "AknFepPanic.h" -#include "AknFepUiInputStateCandidateRetroActive.h" - -#include // CAknIndicatorContainer::TIndicatorContext -#include -#include // MPtiEngineCompositionDataInterface -#include // keys - -// CONSTANTS - -// LOCAL FUNCTION PROTOTYPES -static TBool IsNumericKey(TInt aKey); -static TBool IsQwertyKey(TInt aKey); - -//============================ LOCAL FUNCTIONS ============================== - -// ----------------------------------------------------------------------------- -// IsNumericKey -// -// Returns: ETrue is returned if aKey is number key -// -// ----------------------------------------------------------------------------- -// -static TBool IsNumericKey(const TInt aKey) - { - TBool response = EFalse; - if (aKey >= EPtiKeyQwerty0 && aKey <= EPtiKeyQwerty9) - { - response = ETrue; - } - return response; - } - -// ----------------------------------------------------------------------------- -// IsQwertyKey -// -// Returns: ETrue is returned if aKey is qwerty key -// -// ----------------------------------------------------------------------------- -// -static TBool IsQwertyKey(const TInt aKey) - { - TBool response = EFalse; - if ( (aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ) || - IsNumericKey( aKey ) || - aKey == EStdKeySpace || - aKey == EPtiKeyQwertyPlus || - aKey == EPtiKeyQwertyMinus || - aKey == EPtiKeyQwertyComma || - aKey == EPtiKeyQwertySemicolon || - aKey == EPtiKeyQwertyFullstop || - aKey == EPtiKeyQwertyHash || - aKey == EPtiKeyQwertySlash || - aKey == EPtiKeyQwertyApostrophe) - { - response = ETrue; - } - return response; - } - -/** - * CAknFepUIManagerJapanese class. - * - */ -//============================ MEMBER FUNCTIONS ============================== - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::NewL -// -// -// --------------------------------------------------------------------------- -// -CAknFepUIManagerJapanese* CAknFepUIManagerJapanese::NewL(MAknFepManagerUIInterface* aFepMan, - CAknFepCaseManager* aCaseMan, - TLanguage aLanguage) - { - CAknFepUIManagerJapanese* self = new(ELeave)CAknFepUIManagerJapanese(aFepMan, aCaseMan); - CleanupStack::PushL(self); - self->ConstructL(aLanguage); - CleanupStack::Pop(self); - return self; - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::~CAknFepUIManagerJapanese -// -// -// --------------------------------------------------------------------------- -// -CAknFepUIManagerJapanese::~CAknFepUIManagerJapanese() - { - delete iCandidateArray; - delete iContainerPane; - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::SetCase -// -// -// --------------------------------------------------------------------------- -// -void CAknFepUIManagerJapanese::SetCase(TCase aCase) - { - CAknFepUIManagerBase::SetCase(aCase); - - if (iMode != ENumber) - { - if (!iCaseMan->IsAbleChangeCase()) - { - if (iCaseMan->CurrentCase() == EAknEditorLowerCase) - { - TRAP_IGNORE(iPtiEngine->HandleCommandL(EPtiCommandUseLatinCaseLowerOnlyKeyMap)); - } - else if (iCaseMan->CurrentCase() == EAknEditorUpperCase) - { - TRAP_IGNORE(iPtiEngine->HandleCommandL(EPtiCommandUseLatinCaseUpperOnlyKeyMap)); - } - } - else - { - TRAP_IGNORE(iPtiEngine->HandleCommandL(EPtiCommandUseLatinDefaultKeyMap)); - } - } - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::HandleKeyL -// -// -// --------------------------------------------------------------------------- -// -TBool CAknFepUIManagerJapanese::HandleKeyL(TInt aKey, TKeyPressLength aLength, TEventCode /*aEventCode*/) - { - TUIState currentState = iFepUiState.State(); - if (aLength == EShortKeyPress) - { - iInitialFepUIState = currentState; - } - - // If current input mode is Number or Hiragana, - // numeric long keypress doesn't operate. - if (iMode == ENumber || iMode == EHiragana) - { - if (IsNumericKey(aKey) && aLength == ELongKeyPress) - { - return ETrue; - } - } - - if (iMode == EHiragana) - { - if( aKey == EPtiKeyStar && aLength == ELongKeyPress) - { - return ETrue; - } - } - // CBA keypress is valid when input state is Initial, Entry - // Predictive input or NextWord. - switch (aKey) - { - case EKeyCBA1: // ITU-T left softkey - case EKeyCBA2: // ITU-T right softkey - case EStdKeyDevice0: // Qwerty left softkey (=0xa4) - case EStdKeyDevice1: // Qwerty right softkey(=0xa5) - // In case of Latin and Number, all characters must be committed. - if (iMode != EHiraganaKanji) - { - CloseUI(); - } - switch (iStatePtr->State()) - { - case EInitial: - case EEntry: - case EPredictiveInput: - case ENextWord: - return EFalse; - default: - return ETrue; - } - //break; not needed - default: - // move to next line - break; - } - - TPtiTextCase oldPtiCaseMode = iPtiEngine->Case(); - TPtiTextCase caseMode = EPtiCaseLower; - TPtiTextCase shiftedCase = caseMode; - if (IsQwerty()) - { - caseMode = EPtiCaseLower; - if (!FepMan()->IsOnlyNumericPermitted()) - { - caseMode = oldPtiCaseMode; - if (iMode & (EHiraganaKanji|EHiragana|EKatakana)) - { - if (CaseMan()->CurrentCase() == EAknEditorTextCase - && caseMode == EPtiCaseUpper - && iStatePtr->State() == EInitial) - { - iPtiEngine->SetCase(EPtiCaseLower); - caseMode = EPtiCaseLower; - oldPtiCaseMode = EPtiCaseLower; - } - } - else if (iMode == ELatin) - { - switch (CaseMan()->CurrentCase()) - { - case EAknEditorUpperCase: - case EAknEditorTextCase: - caseMode = EPtiCaseUpper; - break; - case EAknEditorLowerCase: - default: - caseMode = EPtiCaseLower; - break; - } - } - } - shiftedCase = caseMode; - if ( FepMan()->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) ) - { - // while pressing Shift key - if ( aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ ) - { - shiftedCase = (caseMode != EPtiCaseUpper)? EPtiCaseUpper : EPtiCaseLower; - } - else - { - // except alpha key - shiftedCase = EPtiCaseUpper; - } - } - else if (!(aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ)) - { - // out of A-Z key - shiftedCase = EPtiCaseLower; - } - - if (shiftedCase != oldPtiCaseMode) - { - iPtiEngine->SetCase(shiftedCase); - } - } - - TBool ret = iStatePtr->HandleKeyL(aKey, aLength); - // If the state was changed by keypress event and not handle keypress event, - // changed state handle it keypress event. - while (!ret && currentState != iFepUiState.State()) - { - // If editor was filled by characters, - // don't handle no more numeric keypress or qwerty keypress - if (iStatePtr->State() == EInitial - && !FepMan()->EditorHasFreeSpace()) - if (!IsQwerty() && IsNumericKey(aKey)) - { - return ETrue; - } - else if (IsQwerty() && IsQwertyKey(aKey)) - { - return ETrue; - } - - if ( (IsQwerty()) - && (iPtiEngine->Case() != shiftedCase) ) - { - iPtiEngine->SetCase(shiftedCase); - } - - currentState = iFepUiState.State(); - ret = iFepUiState.HandleKeyL(aKey, aLength); - } - - if (IsQwerty()) - { - if (oldPtiCaseMode != iPtiEngine->Case()) - { - iPtiEngine->SetCase(oldPtiCaseMode); - } - } - return ret; - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::CloseUI -// -// -// --------------------------------------------------------------------------- -// -void CAknFepUIManagerJapanese::CloseUI() - { - if (iStatePtr->State() != EInitial) - { - iStatePtr->CloseUI(); - if (iStatePtr->State() == EMultiCompletion) - { - ChangeState(EInitial); - } - else - { - // Commit Uncommited string - if (iStatePtr->State() != ENextWord) - { - ChangeState(EMultiCompletion); - } - TRAP_IGNORE(iStatePtr->HandleCommandL(EAknFepAllCompletion)); - } - } - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::GetFormatOfFepInlineText -// -// -// --------------------------------------------------------------------------- -// -void CAknFepUIManagerJapanese::GetFormatOfFepInlineText(TCharFormat& aFormat, - TInt& aNumberOfCharactersWithSameFormat, - TInt aPositionOfCharacter) const - { - TRgb highlightColor1 = AKN_LAF_COLOR_STATIC(244); - TRgb highlightColor2 = AKN_LAF_COLOR_STATIC(210); - TRgb textColor = AKN_LAF_COLOR_STATIC(0); - if ((iFepUiState.State() == EEntry) - || (iFepUiState.State() == EConversion) - || (iFepUiState.State() == ECandidate) - || (iFepUiState.State() == ECandidateRetroActive) - || (iFepUiState.State() == EPredictiveInput)) - { - const MPtiEngineCompositionDataInterface* data = PtiEngine()->CompositionData(); - TInt length = 0; - TInt clauseCount = 0; - TInt preLength = 0; - TPtrC8 clauseChar = data->LengthOfPhrase(); -#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ -#ifdef RD_INTELLIGENT_TEXT_INPUT - if ( clauseChar.Length() ) - { -#endif //RD_INTELLIGENT_TEXT_INPUT -#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ - for (; length < aPositionOfCharacter; ++clauseCount) - { - preLength = length; - length += clauseChar[clauseCount]; - } - if (length == aPositionOfCharacter) - aNumberOfCharactersWithSameFormat = clauseChar[clauseCount]; - else - { - --clauseCount; - aNumberOfCharactersWithSameFormat = clauseChar[clauseCount] - + preLength - - aPositionOfCharacter; - } - switch (data->AttributeOfPhrase()[clauseCount]) - { - //Input phase - case MPtiEngineCompositionDataInterface::EPtiAttributeTransitoryInput: - { - if (iFlagInlineEditUnderline) - { - aFormat.iFontPresentation.iHighlightColor = highlightColor1; - aFormat.iFontPresentation.iHighlightStyle = TFontPresentation:: - EFontHighlightNormal; - } - else - { - } - } - break; - // Conversion phase(no target phrase) - case MPtiEngineCompositionDataInterface::EPtiAttributeNonTargetConvert: - { - aFormat.iFontPresentation.iHighlightColor = highlightColor1; - aFormat.iFontPresentation.iHighlightStyle = TFontPresentation:: - EFontHighlightNormal; - } - break; - // Conversion phase(target Phrase) - case MPtiEngineCompositionDataInterface::EPtiAttributeTargetConvert: - { - aFormat.iFontPresentation.iTextColor = textColor; - aFormat.iFontPresentation.iHighlightColor = highlightColor2; - aFormat.iFontPresentation.iHighlightStyle = TFontPresentation:: - EFontHighlightNormal; - } - break; - default: - break; -#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ -#ifdef RD_INTELLIGENT_TEXT_INPUT - } -#endif // RD_INTELLIGENT_TEXT_INPUT -#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ - } - } - else if (iFepUiState.State() == EMultiCompletion) - { - const MPtiEngineCompositionDataInterface* data = PtiEngine()->CompositionData(); - TInt length = data->CompletedString().Length(); - // Panic in case (aNumberOfCharactersWithSameFormat < 1) - if( !(length > 0) ) - { - length = 1; - } - - aNumberOfCharactersWithSameFormat = length; - } - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::IsValidShiftKeyPress -// -// -// --------------------------------------------------------------------------- -// -TBool CAknFepUIManagerJapanese::IsValidShiftKeyPress() const - { - TBool ret = ETrue; - switch (iMode) - { - case EHiraganaKanji: - // ITU-T has to check Edit-key(= Shift-key). If the state is Initial - // or NextWord, Edit-key is valid, the other states are invalid. - // However, in Qwerty input, shift-key is used for changing Case mode, - // so, shift-key is always valid even if the statue is anything. - if (!iQwerty) - { - if (iStatePtr->State() == EInitial || iStatePtr->State()== ENextWord) - { - ret = ETrue; - } - else - { - ret = EFalse; - } - } - break; - case EHiragana: - ret = EFalse; - break; - case EKatakana: - default: - break; - } - - return ret; - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::ChangeState -// -// -// --------------------------------------------------------------------------- -// -TUIState CAknFepUIManagerJapanese::ChangeState(TUIState aState) - { - switch(aState) - { - case EInitial: - { - switch(iMode) - { - case EHiragana: - iFepUiState = TAknFepUiInputStateInitialHiragana(this, UIContainer()); - break; - case EHiraganaKanji: - iFepUiState = TAknFepUiInputStateInitialHiraganaKanji(this, UIContainer()); - break; - case EKatakana: - iFepUiState = TAknFepUiInputStateInitialKatakana(this, UIContainer()); - break; - case ELatin: - { - iFepUiState = TAknFepUiInputStateInitialLatinJapanese(this, UIContainer()); - } - break; - case ENumber: - iFepUiState = TAknFepUiInputStateInitialFullNumber(this, UIContainer()); - break; - default: - AknFepPanic(EAknFepPanicBadInputState); - break; - } - break; - } - case EEntry: - { - switch(iMode) - { - case EHiraganaKanji: - iFepUiState = TAknFepUiInputStateEntryHiraganaKanji(this, UIContainer()); - break; - case EHiragana: - case EKatakana: - iFepUiState = TAknFepUiInputStateEntryKatakana(this, UIContainer()); - break; - case ELatin: - iFepUiState = TAknFepUiInputStateEntryLatinJapanese(this, UIContainer()); - break; - case ENumber: - iFepUiState = TAknFepUiInputStateEntryJapaneseMultitap(this, UIContainer()); - break; - default: - AknFepPanic(EAknFepPanicBadInputState); - break; - } - } - break; - case ECandidate: - iFepUiState = TAknFepUiInputStateCandidateHiraganaKanji(this, UIContainer()); - break; - case EPredictiveInput: - iFepUiState = TAknFepUiInputStatePredictiveInputJapanese(this, UIContainer()); - break; - case EConversion: - iFepUiState = TAknFepUiInputStateConversionHiraganaKanji(this, UIContainer()); - break; - case EMultiCompletion: // Only Japanese version uses this flag. - switch(iMode) - { - case EHiraganaKanji: - if(iPredictive) - { - if(iFepUiState.State() == EPredictiveInput || - iFepUiState.State() == ENextWord) - { - iFepUiState = TAknFepUiInputStateCompletionPredictiveHiraganaKanji(this, UIContainer()); - } - else - { - iFepUiState = TAknFepUiInputStateCompletionHiraganaKanji(this, UIContainer()); - } - } - else - { - iFepUiState = TAknFepUiInputStateCompletionHiraganaKanji(this, UIContainer()); - } - break; - case EHiragana: - case EKatakana: - { - iFepUiState = TAknFepUiInputStateCompletionKatakana(this, UIContainer()); - } - break; - case ENumber: - iFepUiState = TAknFepUiInputStateCompletionJapaneseMultitap(this, UIContainer()); - break; - case ELatin: - iFepUiState = TAknFepUiInputStateCompletionLatinJapanese(this, UIContainer()); - break; - default: - AknFepPanic(EAknFepPanicBadInputState); - break; - } - break; - case ENextWord: // Only Japanese version uses this flag - { - switch(iMode) - { - case EHiraganaKanji: - if(iPredictive) - { - iFepUiState = TAknFepUiInputStateNextWordJapanesePredictive(this, UIContainer()); - break; - } - default: - AknFepPanic(EAknFepPanicBadInputState); - break; - } - } - break; - case ECandidateRetroActive: - { - switch(iMode) - { - case EHiraganaKanji: - iFepUiState = TAknFepUiInputStateCandidateRetroActive(this, UIContainer()); - break; - default: - AknFepPanic(EAknFepPanicBadInputState); - break; - } - } - break; - default: - AknFepPanic(EAknFepPanicBadInputState); - } - - PtiEngine()->SetObserver(&iFepUiState); - -#ifdef _DEBUG - RDebug::Print(_L("UI Manager: New State: %d"), iFepUiState.State()); -#endif - TRAPD(err, iStatePtr->InitializeStateL()); - if (err != KErrNone) - { -#ifdef _DEBUG - RDebug::Print(_L("UI Manager: Setup Error: Mode = %d, State = %d"), - iMode, iStatePtr->State()); -#endif - CloseUI(); - } - return iStatePtr->State(); - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::CandidateArray -// -// -// --------------------------------------------------------------------------- -// -CDesCArrayFlat* CAknFepUIManagerJapanese::CandidateArray() - { - return iCandidateArray; - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::IsPredictive -// -// -// --------------------------------------------------------------------------- -// -TBool CAknFepUIManagerJapanese::IsPredictive() const - { - return iPredictive; - } - - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::SetInlineEditUnderlineVisibility -// -// -// --------------------------------------------------------------------------- -// -void CAknFepUIManagerJapanese::SetInlineEditUnderlineVisibility(TBool aFlag) - { - iFlagInlineEditUnderline = aFlag; - } - - -// --------------------------------------------------------------------------- -// CAknFepUIManagerBase::SetMode -// -// -// --------------------------------------------------------------------------- -// -#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ -#ifdef RD_INTELLIGENT_TEXT_INPUT -void CAknFepUIManagerJapanese::SetMode(TInt aMode, TBool aPredictive, TBool aQwertyInputMode, TInt aKeyboardType) -#else -void CAknFepUIManagerJapanese::SetMode(TInt aMode, TBool aPredictive, TBool aQwertyInputMode) -#endif // RD_INTELLIGENT_TEXT_INPUT -#else -void CAknFepUIManagerJapanese::SetMode(TInt aMode, TBool aPredictive, TBool aQwertyInputMode) -#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ - { - iMode=aMode; - iPredictive = aPredictive; - iQwerty = aQwertyInputMode; - ChangeState(EInitial); - } - - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::FepUIState -// -// -// --------------------------------------------------------------------------- -// -TAknFepInputStateBase* CAknFepUIManagerJapanese::FepUIState() - { - return &iFepUiState; - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::UIContainer -// -// -// --------------------------------------------------------------------------- -// -MAknFepUICtrlContainerJapanese* CAknFepUIManagerJapanese::UIContainer() const - { - return iContainerPane; - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::CAknFepUIManagerJapanese -// -// -// --------------------------------------------------------------------------- -// -CAknFepUIManagerJapanese::CAknFepUIManagerJapanese(MAknFepManagerUIInterface* aFepMan, - CAknFepCaseManager* aCaseMan) - : CAknFepUIManagerBase(aFepMan, aCaseMan), - iFepUiState(NULL,NULL), - iFlagInlineEditUnderline(ETrue) - { - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::ConstructL -// -// -// --------------------------------------------------------------------------- -// -void CAknFepUIManagerJapanese::ConstructL(TLanguage aLanguage) - { - CAknFepUIManagerBase::ConstructL(aLanguage); - - PtiEngine()->ActivateLanguageL(aLanguage, EPtiEngineInputModeNone); - - iCandidateArray = new(ELeave) CDesCArrayFlat(1); - iContainerPane = FepMan()->UiInterface()->NewAknFepUICtrlContainerJapaneseL(this); - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::IsQwerty -// -// -// --------------------------------------------------------------------------- -// -TBool CAknFepUIManagerJapanese::IsQwerty() const - { - return iQwerty; - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerJapanese::HandleCommandL -// -// --------------------------------------------------------------------------- -// -void CAknFepUIManagerJapanese::HandleCommandL(TInt aCommandId) - { - switch (aCommandId) - { - case EAknFepSoftkeyCommit: - case EAknFepSoftkeySelectCandidate: - { - TUIState currentState = iFepUiState.State(); - iStatePtr->HandleCommandL(aCommandId); - if (currentState != iFepUiState.State()) - { - if (iFepUiState.State() == EMultiCompletion) - { - iFepUiState.HandleKeyL(EKeyOK, EShortKeyPress); - } - } - } - break; - case EAknFepSoftkeyPredictiveOn: - { - MAknFepManagerUIInterface* fepMan = FepMan(); - CPtiEngine* ptiEngine = PtiEngine(); - - // Update of inline editing characters - TPtiEngineInputMode inputmode = (IsQwerty())? - EPtiEngineHiraganaKanjiPredictiveQwerty - : EPtiEngineHiraganaKanjiPredictive; - ptiEngine->SetInputMode(inputmode); - const MPtiEngineCompositionDataInterface* data = ptiEngine->CompositionData(); - TPtrC text = data->CompletedString(); - TPtrC text2 = data->ConvertingString(); - if (text.Length() >0) - { - ChangeState(EMultiCompletion); - fepMan->CommitInlineEditL(text, text.Length()); - if (fepMan->EditorHasFreeSpace()) - { - ChangeState(ENextWord); - } - else - { - CloseUI(); - ChangeState(EInitial); - } - } - else if (text2.Length() > 0) - { - // Change to Predictive State - ChangeState(EPredictiveInput); - iPredictive = ETrue; - iStatePtr->HandleCommandL(aCommandId); - } - } - break; - default: - iStatePtr->HandleCommandL(aCommandId); - break; - } - } - -// --------------------------------------------------------------------------- -// CAknFepUIManagerBase::ResourceChanged -// This API is called when FEP control handles the changing resource event. -// --------------------------------------------------------------------------- -// -void CAknFepUIManagerJapanese::ResourceChanged(TInt /*aType*/) - { - TRAP_IGNORE( iStatePtr->HandleCommandL(EAknFepResourceChanged)); - } - -// End of file