--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/textinput/peninputcommonctrlsjp/src/peninputhiraganakanji.cpp Wed Sep 01 12:23:33 2010 +0100
@@ -0,0 +1,935 @@
+/*
+* Copyright (c) 2009 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: peninputkanakanji implementation
+*
+*/
+
+
+#include <PtiEngine.h>
+#include <peninputlayout.h>
+#include <PtiCompositionDataIF.h>
+#include <aknlayoutscalable_avkon.cdl.h>
+#include <peninputcommonlayoutglobalenum.h> // EPeninputLayoutEventEnter
+#include <aknfeppeninputenums.h> //command from fep or IME to plugin. for vkb/hwr
+
+#include "peninputeventjp.h"
+#include "peninputhiraganakanji.h"
+#include "peninputcontextfieldjp.h"
+#include "peninputjapanesecandidatewnd.h"
+#include "peninputjapanesepredictivewnd.h"
+
+// CONSTANTS
+const TUint16 KLittleCharCode = 0x5c0f; // little
+
+//default value for long press timer
+const TInt KLongPressInterval = 600000;
+//default value for repeat timer
+const TInt KRepeatInterval = 100000;
+
+// ---------------------------------------------------------
+// Constructor
+// ---------------------------------------------------------
+EXPORT_C CPeninputHiraganaKanji* CPeninputHiraganaKanji::NewL(CPtiEngine* aPtiEngine
+ , CFepUiLayout* aUiLayout
+ , CFepInputContextFieldJp* aInputContextField
+ , CPeninputJapaneseCandidateWnd* aCandidateWnd
+ , CPeninputJapanesePredictiveWnd* aPredictiveWnd)
+ {
+ if (aPtiEngine == NULL
+ || aUiLayout == NULL
+ || aInputContextField == NULL
+ || aCandidateWnd == NULL
+ || aPredictiveWnd == NULL
+ )
+ {
+ User::Leave(KErrArgument);
+ }
+
+ CPeninputHiraganaKanji* self = new (ELeave) CPeninputHiraganaKanji(aPtiEngine
+ , aUiLayout
+ , aInputContextField
+ , aCandidateWnd
+ , aPredictiveWnd);
+
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+
+ return self;
+ }
+
+// ---------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------
+EXPORT_C CPeninputHiraganaKanji::~CPeninputHiraganaKanji()
+ {
+ delete iCandidateArray;
+ delete iChar;
+ CancelRepeat();
+ delete iLongPressTimer;
+ delete iRepeatTimer;
+ }
+
+// ---------------------------------------------------------
+// Handle events in
+// ---------------------------------------------------------
+EXPORT_C void CPeninputHiraganaKanji::HandleControlEventJpL(TInt aEventType, const TDesC& aEventData)
+ {
+ if(EStatusComplete == iStatus || EStatusCompleteAll == iStatus
+ || EStatusCompleteAllfromUiLayout == iStatus) // wait for SetEditorTextL from Editor
+ {
+ return ;
+ }
+ switch (aEventType)
+ {
+ case EEventVirtualKeyUp:
+ if (!aEventData.Length())
+ {
+ UpdateContextFieldL();
+ }
+ else
+ {
+ TUint16* unicode = (TUint16*) aEventData.Ptr();
+ if (EStatusInitial == iStatus)
+ {
+ if (KLittleCharCode != *unicode)
+ {
+ iInputContextField->StartInlineL();
+ iStatus = (!iPredictiveWnd->Hiden())? EStatusPredictiveTransitoryInput : EStatusTransitoryInput;
+ }
+ }
+ else if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ {
+ if (KLittleCharCode != *unicode)
+ {
+ iInputContextField->StartInlineL();
+ iStatus = EStatusPredictiveTransitoryInput;
+ }
+ }
+ if (EStatusPredictiveTransitoryInput == iStatus || EStatusTransitoryInput == iStatus)
+ {
+ // different from editor
+ iStatus = (!iPredictiveWnd->Hiden())? EStatusPredictiveTransitoryInput : EStatusTransitoryInput;
+ HandleInsertL(aEventData);
+ }
+ else if (EStatusConversion == iStatus
+ || EStatusCandidate == iStatus // not take place
+ || EStatusChangeDivision == iStatus)
+ {
+ delete iChar;
+ iChar = NULL;
+ iChar = aEventData.AllocL();
+ CompleteAllL();
+ }
+ }
+ break;
+ case EEventCompleteAllHiraganaKanji: // CompleteALL:from UiLayout
+ if (EStatusInitial != iStatus)
+ {
+ if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ {
+ iStatus = EStatusInitial;
+ UpdateContextFieldL(); // not leave
+ }
+ else
+ {
+ iStatus = EStatusCompleteAllfromUiLayout;
+ CompleteAllL();
+ }
+ }
+ break;
+ case EEventCompleteIfConvertingHiraganaKanji: // Complete:from Hwr UiLayout
+ if (EStatusConversion == iStatus
+ || EStatusCandidate == iStatus // not take place
+ || EStatusChangeDivision == iStatus)
+ {
+ iStatus = EStatusCompleteAllfromUiLayout;
+ CompleteAllL();
+ }
+ break;
+ case EPeninputLayoutEventSelectItem: // select from prediction/convert candidates by pointer
+ case EPeninputLayoutEventEnter:
+ if (EStatusPredictiveTransitoryInput == iStatus || EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ {
+ TInt curr = iPredictiveWnd->CurrentItemIndexOfCandidate();
+ if (curr >= 0)
+ {
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionCompleteCandidate, &curr);
+ CompleteSubL(); // not leave
+ }
+ break;
+ }
+ if (EStatusCandidate == iStatus)
+ {
+ TInt curr = iCandidateWnd->CurrentItemIndex();
+ TInt old = 0;
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionGetCurrentIndexOfCandidates, &old);
+ while(curr > old)
+ {
+ ++old;
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionConvert);
+ }
+ while(curr < old)
+ {
+ --old;
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionPrevious);
+ }
+ }
+ if (EStatusInitial != iStatus)
+ {
+ CompleteL();
+ }
+ break;
+ case EPeninputLayoutEventBack:
+ {
+ switch(iStatus)
+ {
+ case EStatusPredictiveTransitoryInputWithNoChar:
+ {
+ iStatus = EStatusInitial;
+ UpdateContextFieldL(); // not leave
+ }
+ break;
+ case EStatusTransitoryInput:
+ case EStatusPredictiveTransitoryInput:
+ {
+ // different from editor
+ iStatus = (!iPredictiveWnd->Hiden())? EStatusPredictiveTransitoryInput : EStatusTransitoryInput;
+ HandleBackL();
+ }
+ break;
+ case EStatusCandidate:
+ {
+ iStatus = EStatusConversion;
+ UpdateContextFieldL();
+ }
+ break;
+ case EStatusConversion:
+ case EStatusChangeDivision:
+ {
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionCancel);
+ iStatus = EStatusTransitoryInput;
+ UpdateContextFieldL();
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case EEventStdKeyUpArrow:
+ case EEventStdKeyDownArrow:
+ case EPeninputLayoutEventSpace:
+ if (EStatusInitial != iStatus)
+ {
+ if ((EStatusPredictiveTransitoryInput == iStatus || EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ && EPeninputLayoutEventSpace != aEventType)
+ {
+ iPredictiveWnd->MoveTo((EEventStdKeyUpArrow != aEventType)?
+ CPeninputJapanesePredictiveWnd::EScrollDown : CPeninputJapanesePredictiveWnd::EScrollUp);
+ }
+ else if (EStatusPredictiveTransitoryInputWithNoChar == iStatus && EPeninputLayoutEventSpace == aEventType)
+ { // only by space button on vkb peninput
+ iStatus = EStatusInitial;
+ UpdateContextFieldL();
+ iUiLayout->SignalOwner(ESignalKeyEvent,aEventData);
+ }
+ else
+ {
+ iPtiEngine->HandleCommandL(
+ (EEventStdKeyUpArrow != aEventType)? EPtiCommandUserActionConvert : EPtiCommandUserActionPrevious);
+ if (EStatusCandidate == iStatus) // not take place
+ {
+ iCandidateWnd->MoveToL((EEventStdKeyUpArrow != aEventType)?
+ CPeninputJapaneseCandidateWnd::EScrollDown : CPeninputJapaneseCandidateWnd::EScrollUp);
+ }
+ else
+ {
+ iStatus = (EStatusConversion == iStatus)? EStatusCandidate : EStatusConversion;
+ }
+ UpdateContextFieldL();
+ }
+ }
+ break;
+ case EPeninputLayoutEventTab:
+ if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ {
+ iStatus = EStatusCompleteAll; // wait for SetEditorTextL()
+ iUiLayout->SignalOwner(ESignalKeyEvent,aEventData);
+ }
+ break;
+ case EEventCancelHiraganaKanji: // Cancel:from UiLayout not used
+ ClearTextL();
+ break;
+ case EEventStdKeyLeftArrow:
+ case EEventStdKeyRightArrow:
+ if (EStatusTransitoryInput == iStatus)
+ {
+ TInt pos = -1;
+ iPtiEngine->HandleCommandL(
+ (EEventStdKeyLeftArrow == aEventType)? EPtiCommandUserActionLeft : EPtiCommandUserActionRight);
+ const MPtiEngineCompositionDataInterface* data = iPtiEngine->CompositionData();
+ if (data)
+ {
+ pos = data->CursorPosition();
+ }
+ if(0 <= pos)
+ {
+ iInputContextField->SetCursorPosition(pos);
+ }
+ }
+ else if (EStatusPredictiveTransitoryInput == iStatus || EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ {
+ iPredictiveWnd->MoveTo((EEventStdKeyLeftArrow != aEventType)?
+ CPeninputJapanesePredictiveWnd::EScrollRight : CPeninputJapanesePredictiveWnd::EScrollLeft);
+ }
+ else if (EStatusConversion == iStatus || EStatusCandidate == iStatus)
+ {
+ iStatus = EStatusChangeDivision;
+ }
+ if (EStatusChangeDivision == iStatus)
+ {
+ iPtiEngine->HandleCommandL(
+ (EEventStdKeyLeftArrow == aEventType)? EPtiCommandUserActionShorten : EPtiCommandUserActionLengthen);
+ UpdateContextFieldL();
+ }
+ break;
+ case EEventIcfPointerUp: // from ContextField
+ if (EStatusConversion == iStatus || EStatusCandidate == iStatus)
+ {
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionShorten);
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionLengthen);
+ iStatus = EStatusChangeDivision;
+ UpdateContextFieldL();
+ }
+ else if (EStatusTransitoryInput == iStatus
+ || EStatusPredictiveTransitoryInput == iStatus
+ || EStatusPredictiveTransitoryInputWithNoChar == iStatus // not take place
+ || EStatusChangeDivision == iStatus)
+ {
+ TInt pos = -1;
+ TInt cursorPosition = *((TInt*)aEventData.Ptr());
+ const MPtiEngineCompositionDataInterface* data = iPtiEngine->CompositionData();
+ if (data)
+ {
+ pos = data->CursorPosition();
+ if (EStatusChangeDivision == iStatus)
+ {
+ if (data->NumberOfPhrase() > 0)
+ {
+ TPtrC8 clauseChar = data->LengthOfPhrase();
+ pos = clauseChar[0];
+ }
+ }
+ }
+ if(0 <= pos)
+ {
+ TInt posDiff = cursorPosition - pos;
+ if(posDiff)
+ {
+ TPtiEngineCommand cmd;
+ if (EStatusChangeDivision == iStatus)
+ {
+ cmd = (posDiff < 0)? EPtiCommandUserActionShorten : EPtiCommandUserActionLengthen;
+ }
+ else
+ {
+ cmd = (posDiff < 0)? EPtiCommandUserActionLeft : EPtiCommandUserActionRight;
+ }
+ if (posDiff < 0)
+ {
+ posDiff = -posDiff;
+ }
+ while(posDiff > 0)
+ {
+ -- posDiff;
+ iPtiEngine->HandleCommandL(cmd);
+ }
+ }
+ if (EStatusChangeDivision == iStatus)
+ {
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionConvert);
+ iStatus = EStatusConversion;
+ UpdateContextFieldL();
+ }
+ }
+ }
+ break;
+ case EEventIcfCompleteAll: // from ContextField
+ {
+ CompleteL();
+ }
+ break;
+ case EEventICFSelectionChanged: // from ContextField (when whithout transitory input)
+ {
+ }
+ break;
+ case EEventSetAppCursorSelection: // from ContextField
+ { // clear prediction pane
+ if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ {
+ iStatus = EStatusInitial;
+ UpdateContextFieldL();
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CPeninputHiraganaKanji::HandleKeyEvent
+// without implementation
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C TBool CPeninputHiraganaKanji::HandleKeyEvent(const TRawEvent& aData)
+ {
+ TBool ret = EFalse;
+ iPendingEvent = 0;
+ if(EStatusComplete == iStatus || EStatusCompleteAll == iStatus
+ || EStatusCompleteAllfromUiLayout == iStatus) // wait for SetEditorTextL from Editor
+ {
+ return ETrue;
+ }
+ const MPtiEngineCompositionDataInterface* data = iPtiEngine->CompositionData();
+ if (!data)
+ {
+ return ret;
+ }
+ TPtrC text = data->ConvertingString();
+ if (text.Length() > 0 || EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ {
+ TInt key = (aData.ScanCode() & 0x000000FF);
+ TInt evetType = EPeninputLayoutEventEnter;
+ TInt repeat = 0;
+ switch(key)
+ {
+ case EKeyUpArrow:
+ case EStdKeyUpArrow: /* 0x10 */
+ {
+ evetType = EEventStdKeyUpArrow;
+ ret = ETrue;
+ repeat = 1;
+ }
+ break;
+ case EKeyDownArrow:
+ case EStdKeyDownArrow:
+ {
+ evetType = EEventStdKeyDownArrow;
+ ret = ETrue;
+ repeat = 1;
+ }
+ break;
+ case EKeyLeftArrow:
+ case EStdKeyLeftArrow: /* 0x0e */
+ {
+ evetType = EEventStdKeyLeftArrow;
+ ret = ETrue;
+ repeat = 1;
+ }
+ break;
+ case EKeyRightArrow:
+ case EStdKeyRightArrow: /* 0x0f */
+ {
+ evetType = EEventStdKeyRightArrow;
+ ret = ETrue;
+ repeat = 1;
+ }
+ break;
+ case EKeyOK:
+ case EStdKeyDevice3: /* 0xA7 */
+ case EStdKeyEnter: /* 0x03 */
+ case EStdKeyNkpEnter: /* 0x88 */
+ {
+ evetType = EPeninputLayoutEventEnter;
+ ret = ETrue;
+ }
+ break;
+ case EKeyBackspace:
+ case EStdKeyBackspace: /* 0x01 */
+ {
+ evetType = EPeninputLayoutEventBack;
+ ret = ETrue;
+ repeat = 1;
+ }
+ break;
+ case EStdKeyEscape: /* 0x04 */
+ {
+ evetType = EPeninputLayoutEventBack;
+ ret = ETrue;
+ }
+ break;
+ case EStdKeyTab: /* 0x02 */
+ {
+ evetType = EPeninputLayoutEventTab;
+ ret = ETrue;
+ }
+ break;
+ case EStdKeySpace: /* 0x05 */
+ {
+ if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ {
+ iStatus = EStatusInitial;
+ TRAP_IGNORE(UpdateContextFieldL()); // not Leave
+ }
+ else
+ {
+ evetType = EPeninputLayoutEventSpace;
+ ret = ETrue;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ if(ret && TRawEvent::EKeyDown == aData.Type())
+ {
+ iPendingEvent = evetType;
+ iRepeat = repeat;
+ }
+ if(TRawEvent::EKeyUp == aData.Type())
+ {
+ CancelRepeat();
+ }
+ }
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CPeninputHiraganaKanji::HandlePendingEventL
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C TBool CPeninputHiraganaKanji::HandlePendingEventL()
+ {
+ if (iPendingEvent)
+ {
+ if (EPeninputLayoutEventBack == iPendingEvent)
+ {
+ iUiLayout->HandleControlEvent(EPeninputLayoutEventBack, reinterpret_cast<CFepUiBaseCtrl*>(this), KNullDesC);
+ }
+ else // up/down/left/right arrow
+ {
+ HandleControlEventJpL(iPendingEvent, KNullDesC);
+ }
+ if (iRepeat)
+ {
+ iLongPressTimer->SetTimer(KLongPressInterval);
+ }
+ else
+ {
+ iPendingEvent = 0;
+ }
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHiraganaKanji::SetEditorTextL
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+EXPORT_C void CPeninputHiraganaKanji::SetEditorTextL(const TFepInputContextFieldData& aData)
+ {
+ if(EStatusComplete == iStatus || EStatusCompleteAll == iStatus || EStatusCompleteAllfromUiLayout == iStatus)
+ {
+ iCandidateArray->Reset();
+ iCandidateWnd->HidePopup();
+ }
+ if(iInputContextField)
+ {
+ iInputContextField->SetTextL(aData);
+ }
+ if(EStatusComplete == iStatus || EStatusCompleteAll == iStatus || EStatusCompleteAllfromUiLayout == iStatus)
+ {
+ if (EStatusCompleteAllfromUiLayout == iStatus)
+ {
+ iStatus = EStatusInitial;
+ }
+ else if (EStatusCompleteAll == iStatus)
+ {
+ if (!iPredictiveWnd->Hiden())
+ {
+ iStatus = EStatusPredictiveTransitoryInputWithNoChar;
+ iUiLayout->HandleControlEvent(EEventHiraganaKanjiWithoutTransitoryChars, reinterpret_cast<CFepUiBaseCtrl*>(this), KNullDesC);
+ }
+ else
+ {
+ iStatus = EStatusInitial;
+ }
+ if (iChar) // next input exists
+ {
+ UpdateContextFieldL();
+ iUiLayout->HandleControlEvent(EEventVirtualKeyUp, reinterpret_cast<CFepUiBaseCtrl*>(this), *iChar);
+ delete iChar;
+ iChar = NULL;
+ return;
+ }
+ }
+ else
+ {
+ iStatus = EStatusConversion;
+
+ if( iInputContextField != NULL )
+ {
+ iInputContextField->StartInlineL();
+ }
+ }
+ UpdateContextFieldL();
+ }
+ }
+
+// ---------------------------------------------------------
+// Cancel timers for key repeat
+// ---------------------------------------------------------
+//
+EXPORT_C void CPeninputHiraganaKanji::CancelRepeat()
+ {
+ if (iRepeat)
+ {
+ if (iLongPressTimer)
+ {
+ iLongPressTimer->Cancel();
+ }
+ if (iRepeatTimer)
+ {
+ iRepeatTimer->Cancel();
+ }
+ iPendingEvent = 0;
+ iRepeat = 0;
+ }
+ iCandidateWnd->CancelScrollBarRepeat();
+ iPredictiveWnd->CancelRepeat();
+ }
+
+// ---------------------------------------------------------
+// Start timers for clear key repeat
+// ---------------------------------------------------------
+//
+EXPORT_C void CPeninputHiraganaKanji::RepeatClearKeyStart()
+ {
+ if (!iRepeat)
+ {
+ iPendingEvent = EPeninputLayoutEventBack;
+ iRepeat = 1;
+ iLongPressTimer->SetTimer(KLongPressInterval);
+ }
+ }
+
+// ---------------------------------------------------------
+// Time out event handler of both long press timer & repeat timer
+// ---------------------------------------------------------
+//
+void CPeninputHiraganaKanji::HandleTimerOut(const CAknFepTimer* aTimer)
+ {
+ if (aTimer == iLongPressTimer)
+ {
+ iRepeatTimer->SetTimer(KRepeatInterval);
+ }
+ else
+ {
+ if (aTimer == iRepeatTimer)
+ {
+ if (iPendingEvent)
+ {
+ if (EPeninputLayoutEventBack == iPendingEvent)
+ {
+ iUiLayout->HandleControlEvent(EPeninputLayoutEventBack, reinterpret_cast<CFepUiBaseCtrl*>(this), KNullDesC);
+ }
+ else // up/down/left/right arrow
+ {
+ TRAP_IGNORE(HandleControlEventJpL(iPendingEvent, KNullDesC));
+ }
+ iRepeatTimer->SetTimer(KRepeatInterval);
+ }
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// C++ Constructor
+// ---------------------------------------------------------
+CPeninputHiraganaKanji::CPeninputHiraganaKanji(CPtiEngine* aPtiEngine
+ , CFepUiLayout* aUiLayout
+ , CFepInputContextFieldJp* aInputContextField
+ , CPeninputJapaneseCandidateWnd* aCandidateWnd
+ , CPeninputJapanesePredictiveWnd* aPredictiveWnd)
+ : iPtiEngine(aPtiEngine),
+ iUiLayout(aUiLayout),
+ iInputContextField(aInputContextField),
+ iStatus(EStatusInitial),
+ iCandidateWnd(aCandidateWnd),
+ iPredictiveWnd(aPredictiveWnd)
+ {
+ }
+
+// ---------------------------------------------------------
+// 2nd Constructor
+// ---------------------------------------------------------
+void CPeninputHiraganaKanji::ConstructL()
+ {
+ iCandidateArray = new(ELeave) CDesCArrayFlat(1);
+ iCandidateWnd->SetIcf(iInputContextField);
+ iLongPressTimer = CAknFepTimer::NewL(this);
+ iRepeatTimer = CAknFepTimer::NewL(this);
+ }
+
+// ---------------------------------------------------------
+// Insert a key
+// ---------------------------------------------------------
+void CPeninputHiraganaKanji::HandleInsertL(const TDesC& aEventData)
+ {
+ TUint16* unicode = (TUint16*)aEventData.Ptr();
+ TUint ch;
+ for (TInt i = 0; i < aEventData.Length(); i++)
+ {
+ ch = *(unicode + i);
+ iPtiEngine->HandleCommandL(EPtiCommandAppendCharacter, &ch);
+ }
+ UpdateContextFieldL();
+ }
+
+// ---------------------------------------------------------
+// Cancel From UiLayout not used
+// ---------------------------------------------------------
+void CPeninputHiraganaKanji::ClearTextL()
+ {
+ iPtiEngine->ClearCurrentWord();
+ CancelL();
+ UpdateContextFieldL();
+ }
+
+// ---------------------------------------------------------
+// complete
+// ---------------------------------------------------------
+void CPeninputHiraganaKanji::CompleteL()
+ {
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionComplete);
+ CompleteSubL();
+ }
+
+// ---------------------------------------------------------
+// complete all
+// ---------------------------------------------------------
+void CPeninputHiraganaKanji::CompleteAllL()
+ {
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionAllComplete);
+ if (EStatusCompleteAllfromUiLayout == iStatus)
+ {
+ iPredictiveWnd->HidePopup();
+ iCandidateArray->Reset();
+ iCandidateWnd->HidePopup();
+ }
+ CompleteSubL();
+ }
+
+// ---------------------------------------------------------
+// CompleteSubL
+// ---------------------------------------------------------
+void CPeninputHiraganaKanji::CompleteSubL()
+ {
+ const MPtiEngineCompositionDataInterface* data = iPtiEngine->CompositionData();
+ if (!data)
+ {
+ return;
+ }
+ TPtrC completedString = data->CompletedString();
+ TPtrC convertingString = data->ConvertingString();
+ TInt sviStatus = iStatus;
+ if (completedString.Length() > 0)
+ {
+ if (EStatusCompleteAllfromUiLayout != iStatus)
+ {
+ iStatus = (convertingString.Length())? EStatusComplete : EStatusCompleteAll;
+ }
+ if (EStatusPredictiveTransitoryInputWithNoChar != sviStatus)
+ {
+ if (EStatusComplete == iStatus)
+ {
+ iInputContextField->CommitInlineL();
+ }
+ else
+ {
+ iInputContextField->CompleteInlineL();
+ }
+ }
+ iUiLayout->SignalOwner(ESignalKeyEvent,completedString);
+ if (EStatusCompleteAllfromUiLayout == iStatus)
+ {
+ iUiLayout->HandleControlEvent(EEventWaitforEditorTextComing, reinterpret_cast<CFepUiBaseCtrl*>(this), KNullDesC);
+ }
+ }
+ else
+ {
+ if (EStatusPredictiveTransitoryInputWithNoChar == iStatus
+ || EStatusCompleteAllfromUiLayout == iStatus)
+ {
+ if (iStatus == EStatusCompleteAllfromUiLayout) // exceptional case
+ {
+ iInputContextField->CancelInlineL();
+ }
+ iStatus = EStatusInitial;
+ }
+ UpdateContextFieldL(); // not leave
+ }
+ }
+
+// ---------------------------------------------------------
+// Handle back key
+// iStatus
+// EStatusTransitoryInput:
+// EStatusPredictiveTransitoryInput:
+// ---------------------------------------------------------
+void CPeninputHiraganaKanji::HandleBackL()
+ {
+ const MPtiEngineCompositionDataInterface* data = iPtiEngine->CompositionData();
+ if (!data)
+ {
+ return;
+ }
+ TPtrC text = data->ConvertingString();
+ if (!text.Length()) // not take place
+ {
+ return;
+ }
+ iPtiEngine->DeleteKeyPress();
+ const MPtiEngineCompositionDataInterface* dataAfter = iPtiEngine->CompositionData();
+ if (!dataAfter)
+ {
+ return;
+ }
+ TPtrC textAfter = dataAfter->ConvertingString();
+ if (!textAfter.Length())
+ {
+ CancelL();
+ }
+ UpdateContextFieldL();
+ }
+
+// ---------------------------------------------------------
+// Update context field : ConvertingString
+// ---------------------------------------------------------
+//
+void CPeninputHiraganaKanji::UpdateContextFieldL()
+ {
+ const MPtiEngineCompositionDataInterface* data = iPtiEngine->CompositionData();
+ if (!data)
+ {
+ return;
+ }
+ TPtrC text = data->ConvertingString();
+ if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)
+ {
+ iPtiEngine->ClearCurrentWord();
+ iInputContextField->SetCursorVisible( ETrue );
+ // update popup window
+ UpdateCandidateListL();
+ return;
+ }
+ if (EStatusPredictiveTransitoryInput == iStatus || EStatusTransitoryInput == iStatus)
+ {
+ if (text.Length() > 0)
+ {
+ iInputContextField->UpdateInlineL(text, -1);
+ TInt pos = data->CursorPosition();
+ if(0 <= pos)
+ {
+ iInputContextField->SetCursorPosition(pos);
+ }
+ iInputContextField->SetCursorVisible( ETrue );
+ // update popup window
+ UpdateCandidateListL();
+ return;
+ }
+ }
+ if (EStatusConversion == iStatus || EStatusCandidate == iStatus || EStatusChangeDivision == iStatus)
+ {
+ if (text.Length() > 0 && data->NumberOfPhrase() > 0)
+ {
+ TPtrC8 clauseChar = data->LengthOfPhrase();
+ // update inline on ContextField
+ if ( EStatusChangeDivision == iStatus )
+ {
+ iInputContextField->UpdateInlineL(text, clauseChar[0], CFepInputContextFieldJp::ETransitoryInputAreaSwitching);
+ }
+ else
+ {
+ iInputContextField->UpdateInlineL(text, clauseChar[0]);
+ }
+ iInputContextField->SetCursorVisible(EFalse);
+ UpdateCandidateListL();
+ return;
+ }
+ }
+ if (EStatusInitial != iStatus) // can take place : at EEventVirtualKeyUp(data length == 0)
+ {
+ CancelL();
+ }
+ iPtiEngine->ClearCurrentWord();
+ iInputContextField->SetCursorVisible( ETrue );
+ iUiLayout->HandleControlEvent(EEventHiraganaKanjiWithTransitoryChars2Standbyjp, reinterpret_cast<CFepUiBaseCtrl*>(this), KNullDesC);
+ UpdateCandidateListL();
+ }
+
+// ---------------------------------------------------------
+// Update Predictive Popup
+// ---------------------------------------------------------
+void CPeninputHiraganaKanji::UpdateCandidateListL()
+ {
+ if (EStatusPredictiveTransitoryInput == iStatus || EStatusPredictiveTransitoryInputWithNoChar == iStatus || EStatusCandidate == iStatus)
+ {
+ TInt index = 0;
+ iCandidateArray->Reset();
+ iPtiEngine->GetCandidateListL(*iCandidateArray);
+ if (EStatusCandidate == iStatus)
+ {
+ iPtiEngine->HandleCommandL(EPtiCommandUserActionGetCurrentIndexOfCandidates, &index);
+ if (index >= iCandidateArray->Count()) // not take place
+ {
+ index = 0;
+ }
+ iPredictiveWnd->HidePopup();
+ iCandidateWnd->ShowPopupL(iCandidateArray, index);
+ // capture of candidate control removed. Trensitory Input Exists, then the capture flag should be on.
+ //signal the owner that pointer needs be captured
+ {
+ TBool capture = ETrue;
+ TPtrC data;
+ data.Set((const TUint16 *)&capture,sizeof(TBool)/sizeof(TUint16));
+ iUiLayout->LayoutOwner()->SignalOwner(ESignalCapturePointer,data);
+ }
+ }
+ else
+ {
+ iCandidateWnd->HidePopup();
+ iPredictiveWnd->ShowPopupL(iCandidateArray, index);
+ }
+ }
+ else
+ {
+ iPredictiveWnd->HidePopup();
+ iCandidateWnd->HidePopup();
+ }
+ }
+
+// ---------------------------------------------------------
+// Cancel Transitory Input
+// ---------------------------------------------------------
+void CPeninputHiraganaKanji::CancelL()
+ {
+ iStatus = EStatusInitial;
+ iInputContextField->CancelInlineL();
+ }
+
+// End Of File