--- 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 <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