--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/fep/aknfep/src/AknFepUiManagerJapanese.cpp Tue Feb 02 01:02:04 2010 +0200
@@ -0,0 +1,866 @@
+/*
+* 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 <e32svr.h> // RDebug stuff...
+#include <txtfrmat.h>
+#include <e32keys.h>
+
+#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 <AknIndicatorContainer.h> // CAknIndicatorContainer::TIndicatorContext
+#include <PtiEngine.h>
+#include <PtiCompositionDataIF.h> // MPtiEngineCompositionDataInterface
+#include <PtiDefs.h> // 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