--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/textinput/peninputhwrboxjp/src/peninputhwrboxlayout.cpp Wed Sep 01 12:23:33 2010 +0100
@@ -0,0 +1,1452 @@
+/*
+* 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: Implementation of the hwr layout
+*
+*/
+
+
+// system includes
+#include <peninputhiraganakanji.h> // hiraganakanji
+#include <peninputuistatemgr.h> // use ui state mgr
+#include <peninputdataconverter.h>
+#include <aknfeppeninputenums.h> //command from fep or IME to plugin. for vkb/hwr, range defination
+#include <peninputcommonlayoutglobalenum.h> // EPeninputLayoutEventEnter
+#include <peninputeventjp.h>
+#include <AknFepGlobalEnums.h> //define TWidthChar
+#include <PtiEngine.h>
+#include <peninputjapanesecandidatewnd.h>
+#include <peninputjapanesepredictivewnd.h>
+
+// user includes
+#include "peninputhwrboxlayout.h"
+#include "peninputhwrboxuistatetype.h" // UI state
+#include "peninputhwrboxwindow.h" // use hwr window, which derived from base window
+#include "peninputhwrboxdatamgr.h" // use data mgr
+#include "peninputhwrboxuistatestandby.h"
+#include "peninputhwrboxuistatestandbyjp.h"
+#include "peninputhwrboxuistatewithtransitorychars.h"
+#include "peninputhwrboxuistatepenstandby.h"
+#include "peninputhwrboxuistatepenbeginwriting.h"
+#include "peninputhwrboxuistatepenendwriting.h"
+#include "peninputhwrboxuistatepencandidateselecting.h"
+#include "peninputhwrevent.h"
+#include "peninputhwrboxgroup.h"
+
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+#include <PeninputHwrStrokeLogConst.h>
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+
+// constant definition
+const TInt KMaxCandidateLen = 128;
+const TUint16 KBackRep = 0x2408;
+const TUint16 KEnterRep = 0xF801;
+const TUint16 KSpaceRep = 0xF800;
+const TInt KDelay = 100000; //1/10 second
+const TInt KPeninputBufLen = 16;
+const TInt KPeninputBufLen8 = 8;
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::NewL
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CPeninputHwrBoxLayout* CPeninputHwrBoxLayout::NewL(MLayoutOwner* aLayoutOwner,
+ const TAny* aInitData)
+ {
+ CPeninputHwrBoxLayout* self = new (ELeave) CPeninputHwrBoxLayout(aLayoutOwner);
+
+ CleanupStack::PushL(self);
+ self->ConstructL(aInitData);
+ CleanupStack::Pop(self);
+
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::~CPeninputHwrBoxLayout
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CPeninputHwrBoxLayout::~CPeninputHwrBoxLayout()
+ {
+ delete iHiraganaKanji;
+ delete iKeyEventAsync;
+ delete iKeyEventClearAsync;
+ delete iPointerEventAsync;
+ delete iUiStatePenMgr;
+ delete iSubmitText;
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ if (iLogger.LogValid())
+ {
+ iLogger.CloseLog();
+ }
+ iLogger.Close();
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::HandleEventL
+// handle event from window server
+// ---------------------------------------------------------------------------
+//
+TBool CPeninputHwrBoxLayout::HandleEventL(TEventType aType, const TAny* aData)
+ {
+ TRawEvent event=*((TRawEvent*)aData);
+ CFepUiBaseCtrl* ctrl = NULL;
+ if(ERawEvent == aType)
+ {
+ if (TRawEvent::EButton1Down == event.Type() && iHiraganaKanji)
+ {
+ iHiraganaKanji->CancelRepeat();
+ }
+ // DropDownList expanded and PointerDown on drawing area ---> cancel input and to StandBy
+ if (iExpanded
+ && TRawEvent::EButton1Down == event.Type()
+ && iUiStatePenMgr->CurrentUiState() == iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenCandidateSelecting)
+ && iDropdownList
+ && iHwrWindow->BoxGroup())
+ {
+ TPoint point = event.Pos() - Position ();
+ if (!iDropdownList->Rect().Contains(point)
+ && iHwrWindow->BoxGroup()->Rect().Contains(point))
+ {
+ ClearInputToPenStandByL();
+ return ETrue;
+ }
+ }
+ if(TRawEvent::EButton1Up == event.Type())
+ {
+ ctrl = RootControl()->CtrlCapPointer();
+ }
+ }
+ TBool handled = CPeninputCommonLayout::HandleEventL(aType,aData);
+ // if dropdownlist expanded, capture off
+ // as the dropdownlist is the 1st control in the clientpane controlgroup, capture is not need.
+ if (TRawEvent::EButton1Up == event.Type() && !ctrl)
+ {
+ CFepUiBaseCtrl* capture = RootControl()->CtrlCapPointer();
+ if (capture && capture->ControlId() == EPeninutWindowCtrlIdDropDownList)
+ { // dropdownlist expanded
+ iDropdownList = capture;
+ capture->CapturePointer(EFalse);
+ SetCapturePointerEventAgain(); // capture for transitory input on
+ HandleControlEvent(EPeninputLayoutHwrEventDropDownListExpanded, capture, KNullDesC);
+ }
+ }
+ // if a control do capture off, capture for transitory input on.
+ if (ctrl && !RootControl()->CtrlCapPointer())
+ {
+ SetCapturePointerEventAgain();
+ }
+ return handled;
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::HandleCommand
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+TInt CPeninputHwrBoxLayout::HandleCommand(TInt aCmd, TUint8* aData)
+ {
+ // Handle command from fep or IME to this layout
+ TUint* data = (TUint*) aData;
+
+ switch ( aCmd )
+ {
+ case ECmdPenInputPermittedRange: // different from common layout
+ // this command comes after ECmdPenInputJapaneseSetting
+ if (iDataMgr)
+ {
+ // in SetData, SetPermittedRanges() and SetCharacterRangePopupLare() called.
+ SetData(EPeninputDataTypePermittedRange, aData);
+ }
+ break;
+ case ECmdPenInputLanguage:
+ {
+ CPeninputCommonLayout::HandleCommand(aCmd, aData);
+ }
+ break;
+ case ECmdPenInputWindowOpen:
+ if (iHwrWindow)
+ {
+ iHwrWindow->Opened();
+ iLayoutWindow->Hide(EFalse); // before Hide Check or Change, parent controlgroup should be Hide Off.
+ TInt curRange = CPeninputDataConverter::AnyToInt(RequestData(EPeninputDataTypeCurrentRange));
+ TBool currHide = iHwrWindow->PredictiveWindow()->Hiden();
+ TBool newHide = ETrue;
+ if (static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->Predictive()
+ && static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->Conversion()
+ && ERangeHiraganaKanji == curRange)
+ {
+ newHide = EFalse;
+ }
+ if (newHide && !currHide || !newHide && currHide)
+ {
+ iHwrWindow->PredictiveWindow()->Hide(newHide);
+ iHwrWindow->SizeChanged(ETrue);
+ }
+ CPeninputCommonLayout::HandleCommand( aCmd, aData );
+ if (*data != EPenInputOpenManually && Position() == TPoint(0,0))
+ { // position is not yet set.(English --> Japanese)
+ SendEventToWindow(EPeninputLayoutEventMovePosition, NULL, KNullDesC);
+ }
+ iHwrWindow->ICFEnableRegionUpdating(); // ICF::OnActivate()
+ }
+ ToPenStandBy();
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ if (iLogger.Handle())
+ {
+ if (iLogger.LogValid())
+ {
+ iLogger.CloseLog();
+ }
+ // Generate file name based on date.
+ TTime time;
+ time.HomeTime();
+ TDateTime datetime = time.DateTime();
+ TBuf<KHwrStrokeLogFileNameMaxLen> name;
+ name.Format(KHwrStrokeLogFileExt(),
+ datetime.Year(), TInt(datetime.Month()+1), datetime.Day()+1,
+ datetime.Hour(), datetime.Minute(), datetime.Second());
+ // Open(or create) log file
+ iLogger.CreateLog( KHwrStrokeLogDir(), name, EFileLoggingModeAppend);
+ // Disable date and time
+ iLogger.SetDateAndTime(EFalse, EFalse);
+ // Write log
+ iLogger.Write(KHwrStrokeLogOpen());
+ WriteHwrStrokeLogRange();
+ }
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+ break;
+ case ECmdPenInputWindowClose:
+ SendEventToWindow(EPeninputLayoutEventCloseCharacterRange, NULL, KNullDesC);
+ HiraganaKanjiCompleteAll();
+ CPeninputCommonLayout::HandleCommand( aCmd, aData );
+ UiStateMgr()->SetCurrentUiState( EPeninputHwrUiStateNone );
+ Initialize();
+ SetCapturePointerEvent(EFalse);
+ iHwrWindow->Closed();
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ if (iLogger.LogValid())
+ {
+ iLogger.Write(KHwrStrokeLogClose());
+ iLogger.CloseLog();
+ }
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+ break;
+ case ECmdPenInputRange: // different from common layout:control. ptiEngine.
+ {
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ iLogOff = 1;
+#endif
+ // this command comes after ECmdPenInputJapaneseSetting, ECmdPenInputPermittedRange
+ if (iLayoutWindow)
+ {
+ iHwrWindow->ICFDisableRegionUpdating(); // ICF::OnDeActivate()
+ iLayoutWindow->Hide(EFalse); // before Hide Check or Change, parent controlgroup should be Hide Off.
+ }
+ if (iDataMgr)
+ {
+ TUint range = TranslateRangeHullHalf(*data);
+ TUint8* rangedata = reinterpret_cast<TUint8*>(&range);
+ // SetData(SetPremaryRange) and SizeChangedForBaseWindow and ChangeClientLayout
+ CPeninputCommonLayout::HandleCommand( aCmd, rangedata );
+ iRangeOrg = range;
+ TInt permittedRange = CPeninputDataConverter::AnyToInt(RequestData(EPeninputDataTypePermittedRange));
+ if (permittedRange & (ERangeHiraganaKanji | ERangeKatakana | ERangeFullWidthKatakana))
+ {
+ TInt index = 0;
+ if (range == ERangeEnglish || range == ERangeFullWidthEnglish)
+ {
+ index = 2; // see CPeninputHwrBoxDataMgr::SetCharacterRangePopupL()
+ }
+ if (range == ERangeNumber || range == ERangeFullWidthNumeric)
+ {
+ index = (permittedRange & (ERangeEnglish | ERangeFullWidthEnglish))? 3:2;
+ // see CPeninputHwrBoxDataMgr::SetCharacterRangePopupL()
+ }
+ if (index)
+ {
+ TPtrC dataPtr;
+ dataPtr.Set(reinterpret_cast<TUint16*>(&index),sizeof(TInt)/sizeof(TUint16));
+ HandleControlEvent(EPeninputLayoutEventRange,NULL,dataPtr); // call DoSetCurrentRange()
+ }
+ else
+ {
+ DoSetCurrentRange();
+ }
+ }
+ else
+ {
+ DoSetCurrentRange();
+ }
+ }
+ }
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ iLogOff = 0;
+#endif
+ break;
+ case ECmdPenInputJapaneseSetting: // Japanese setting information
+ // this command comes before ECmdPenInputPermittedRange, ECmdPenInputRange
+ if (iDataMgr)
+ {
+ iDataMgr->Reset();
+ TUint val = *data;
+ TInt sctDimmFlag = (val & EPenInputJapaneseSettingLunchSCT)? 0: 1;
+ TPtr ptr((TUint16*)&sctDimmFlag, sizeof(TInt)/sizeof(TUint16));
+ SendEventToWindow(EEventSetDimmedSctBtn, NULL, ptr);
+ static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetFullHalf(
+ (val & EPenInputJapaneseSettingCharacterWidth)? 1: 0);
+ static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetPredictive(
+ (val & EPenInputJapaneseSettingPredictive)? ETrue: EFalse);
+ static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetConversion(
+ (val & EPenInputJapaneseSettingConversion)? ETrue: EFalse);
+ static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetClear(
+ (val & EPenInputJapaneseSettingDeletingDirection)? 1: 0);
+ }
+ break;
+ case ECmdPenInputEnableSettingBtn:
+ iHwrWindow->SetEnableSettingBtnJp(*data);
+ break;
+ case ECmdPenInputSendEditorTextAndCurPos:
+ CFepUiLayout::HandleCommand( aCmd, aData );
+ break;
+ default:
+ CPeninputCommonLayout::HandleCommand( aCmd, aData );
+ break;
+ }
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::HandleControlEvent
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::HandleControlEvent(TInt aEventType, CFepUiBaseCtrl* aCtrl, const TDesC& aEventData)
+ {
+ // Handle event from control
+ TInt* data = (TInt*)aEventData.Ptr();
+ TBool handled = EFalse;
+
+ if (EEventDraggingEnd == aEventType)
+ {
+ CPeninputCommonLayout::HandleControlEvent(aEventType, aCtrl, aEventData);
+ }
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ if (EPeninputLayoutEventBack == aEventType)
+ {
+ WriteHwrStrokeLogClear();
+ }
+ if (EPeninputLayoutHwrEventCandidateSelected == aEventType && iLogger.LogValid())
+ {
+ if (aEventData.Length() > 1)
+ {
+ //get the candidate index
+ const TInt cellNo = aEventData[aEventData.Length()-1] + 1;
+ iLogger.WriteFormat(KHwrStrokeLogSelected(), cellNo);
+ }
+ }
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+
+ if (iUiStatePenMgr != NULL)
+ {
+ handled = HandleControlEventPen(aEventType, aCtrl, aEventData);
+ }
+ if (handled)
+ {
+ return;
+ }
+
+ //deal with the event from all controls in layout
+ switch (aEventType)
+ {
+ case EPeninputLayoutEventClose:
+ case EPeninputLayoutEventOption:
+ case EPeninputLayoutEventToVkb:
+ HiraganaKanjiCompleteAll(); // call ToPenStandBy()
+ SetCapturePointerEvent(EFalse);
+ if (EPeninputLayoutEventClose == aEventType)
+ {
+ Initialize(); //jump to init state
+ }
+ if (EPeninputLayoutEventToVkb == aEventType)
+ {
+ TBuf<KPeninputBufLen8> buf;
+ TBool switchByMode = ETrue;
+ TInt mode = EPluginInputModeVkb;
+ CPeninputDataConverter::CombinationToDesc( switchByMode,
+ mode, buf );
+ SignalOwner( ESignalLayoutUIChanged, buf );
+ }
+ else
+ {
+ CPeninputCommonLayout::HandleControlEvent(aEventType, aCtrl, aEventData);
+ }
+ break;
+ case EPeninputLayoutEventSct:
+ HiraganaKanjiCompleteAll();
+ SetCapturePointerEvent(EFalse);
+ SignalOwner(ESignalHwNotifySctPopup);
+ break;
+ case EPeninputLayoutEventSwitchLanguage: // nop
+ break;
+
+ case EPeninputLayoutEventRange: // from character range popup or when accept ECmdPenInputRange command
+ {
+ TInt permittedRange = CPeninputDataConverter::AnyToInt(RequestData(EPeninputDataTypePermittedRange));
+ TInt currentRange = CPeninputDataConverter::AnyToInt( RequestData( EPeninputDataTypeCurrentRange ) );
+ TInt range = currentRange;
+ TInt deActive = 0; // 0:none 1:ICF 2:display off
+ static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetCurrentCharacterRangeIndex(*data);
+ switch(static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->CharacterRangeId())
+ {
+ case EPeninutCharacterRangeIdAll:
+ if (permittedRange & (ERangeHiraganaKanji | ERangeKatakana | ERangeFullWidthKatakana))
+ {
+ if (!(range & (ERangeHiraganaKanji | ERangeKatakana | ERangeFullWidthKatakana)))
+ {
+ range = (permittedRange & ERangeHiraganaKanji)? ERangeHiraganaKanji : ERangeKatakana;
+ }
+ }
+ break;
+ case EPeninutCharacterRangeIdKanaKanji:
+ permittedRange &= (ERangeHiraganaKanji | ERangeKatakana | ERangeFullWidthKatakana);
+ if (!(permittedRange & range))
+ {
+ range = (permittedRange & ERangeHiraganaKanji)? ERangeHiraganaKanji : ERangeKatakana;
+ }
+ break;
+ case EPeninutCharacterRangeIdLatin:
+ permittedRange &= (ERangeEnglish | ERangeFullWidthEnglish);
+ range = ERangeEnglish;
+ break;
+ case EPeninutCharacterRangeIdNumber:
+ permittedRange &= (ERangeNumber | ERangeFullWidthNumeric);
+ range = ERangeNumber;
+ break;
+ default:
+ break;
+ }
+ static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetPermittedRanges(permittedRange);
+ range = TranslateRangeHullHalf(range);
+ if (!(range & permittedRange))
+ {
+ range = iRangeOrg;
+ }
+ if (aCtrl) // from character range popup
+ {
+ TBool currHide = iHwrWindow->PredictiveWindow()->Hiden();
+ TBool newHide = ETrue;
+ if (static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->Predictive()
+ && static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->Conversion()
+ && ERangeHiraganaKanji == range)
+ {
+ newHide = EFalse;
+ }
+ if (newHide && !currHide || !newHide && currHide)
+ {
+ LayoutOwner()->Hide(ETrue); // display off
+ deActive = 2;
+ iHwrWindow->PredictiveWindow()->Hide(newHide);
+ iHwrWindow->SizeChanged(ETrue);
+ }
+ else
+ {
+ iHwrWindow->ICFDisableRegionUpdating(); // ICF::OnDeActivate()
+ deActive = 1;
+ }
+ iHwrWindow->CharacterRangeWindow()->HidePopup();
+ }
+ if (aCtrl && range != currentRange) // from character range popup
+ {
+ // SetData(SetPremaryRange) and Sendkey( ESignalRange,...)
+ TPtrC rangeptr((TUint16*)(&range), sizeof(TInt)/sizeof(TUint16));
+ CPeninputCommonLayout::HandleControlEvent(aEventType, aCtrl, rangeptr);
+ if (ERangeEnglish != range && ERangeNumber != range)
+ {
+ TInt native = ERangeNative;
+ TBuf<KPeninputBufLen> buf;
+ CPeninputDataConverter::CombinationToDesc( native, range, buf );
+ Sendkey( ESignalRange, buf );
+ }
+ }
+ else
+ {
+ SetData(EPeninputDataTypeCurrentRange, &range);
+ }
+ DoSetCurrentRange();
+ if (deActive == 2)
+ {
+ LayoutOwner()->Hide(EFalse); // display on
+ }
+ else if (deActive == 1)
+ {
+ iHwrWindow->ICFEnableRegionUpdating(); // ICF Cursor On
+ }
+ }
+ break;
+
+ // from HiraganaKanji
+ case EEventHiraganaKanjiWithTransitoryChars2Standbyjp:
+ if (UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ UiStateMgr()->SetCurrentUiState(EPeninputHwrUiStateStandbyjp);
+ SetCapturePointerEvent(EFalse);
+ ToPenStandBy();
+ }
+ break;
+ // from HiraganaKanji
+ case EEventHiraganaKanjiWithoutTransitoryChars:
+ if (UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ SetCapturePointerEvent(EFalse);
+ }
+ break;
+
+ case EEventVirtualKeyUp:
+ if ( UiStateMgr()->CurrentUiState()
+ && !static_cast<CPeninputHwrBoxUiState*>(UiStateMgr()->CurrentUiState())->HandleControlEvent(aEventType,aEventData) )
+ {
+ SetCapturePointerEvent(ETrue);
+ HiraganaHandleControlEventJp(aEventType, aEventData);
+ }
+ break;
+ case EPeninputLayoutEventBack:
+ {
+ TInt clear = EKeyBackspace;
+ TPtrC clearptr((TUint16*)(&clear), 1);
+ if ( UiStateMgr()->CurrentUiState()
+ && !static_cast<CPeninputHwrBoxUiState*>(UiStateMgr()->CurrentUiState())->HandleControlEvent(aEventType,clearptr) )
+ {
+ HiraganaHandleControlEventJp(aEventType, clearptr);
+ }
+ }
+ break;
+ case EPeninputLayoutEventEnter:
+ case EPeninputLayoutEventSelectItem: // select from prediction/convert candidates by pointer
+ case EPeninputLayoutEventTab:
+ if (EPeninputLayoutEventEnter == aEventType && IsPredictiveWithNoChar())
+ { // without transitory chars and next word prediction candidates are offered
+ // Enter button should clear Prediction and enter a newline
+ TRAP_IGNORE(iHiraganaKanji->HandleControlEventJpL(EPeninputLayoutEventBack,KNullDesC));
+ }
+ if ( UiStateMgr()->CurrentUiState()
+ && !static_cast<CPeninputHwrBoxUiState*>(UiStateMgr()->CurrentUiState())->HandleControlEvent(aEventType,aEventData) )
+ {
+ TRAP_IGNORE(iHiraganaKanji->HandleControlEventJpL(aEventType,aEventData));
+ }
+ break;
+ case EPeninputLayoutEventSpace: // convert
+ if ( UiStateMgr()->CurrentUiState()
+ && !static_cast<CPeninputHwrBoxUiState*>(UiStateMgr()->CurrentUiState())->HandleControlEvent(aEventType, aEventData) )
+ {
+ HiraganaHandleControlEventJp(aEventType, aEventData);
+ }
+ break;
+ case EEventIcfPointerUp: // from ContextField
+ case EEventIcfCompleteAll: // from ContextField
+ TRAP_IGNORE(iHiraganaKanji->HandleControlEventJpL(aEventType,aEventData));
+ break;
+ case EEventShowCandidateWnd: // CandidateWnd On
+ {
+ iHwrWindow->SetDimmed(ETrue);
+ }
+ break;
+ case EEventHideCandidateWnd: // CandidateWnd Off
+ {
+ iHwrWindow->SetDimmed(EFalse);
+ }
+ break;
+ case EEventWaitforEditorTextComing: // may use, someday.
+ {
+ iWaitforEditorTextComing = 1;
+ }
+ break;
+ case EEventDraggingEnd:
+ break;
+ case EPeninputLayoutEventSwitchCharacterRange:
+ if (static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->CharacterRangeArray()->Count() > 1)
+ {
+ HiraganaKanjiCompleteAll();
+ SendEventToWindow(aEventType, aCtrl, aEventData);
+ }
+ break;
+ case EEventICFSelectionChanged: // from ContextField (when whithout transitory input)
+ if (iHiraganaKanji)
+ { // update saved data
+ TRAP_IGNORE(iHiraganaKanji->HandleControlEventJpL(aEventType,aEventData));
+ }
+ break;
+ case EEventSetAppCursorSelection: // from ContextField
+ if (UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ TRAP_IGNORE(iHiraganaKanji->HandleControlEventJpL(aEventType,aEventData));
+ }
+ break;
+ case EPeninputLayoutHwrEventDropDownListExpanded:
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ if (iLogger.LogValid())
+ {
+ iLogger.Write(KHwrStrokeLogExpand());
+ }
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+ CPeninputCommonLayout::HandleControlEvent(aEventType, aCtrl, aEventData);
+ iExpanded = ETrue;
+ break;
+ default:
+ CPeninputCommonLayout::HandleControlEvent(aEventType, aCtrl, aEventData);
+ break;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::HandleControlEventPen
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+TBool CPeninputHwrBoxLayout::HandleControlEventPen(TInt aEventType, CFepUiBaseCtrl* /*aCtrl*/, const TDesC& aEventData)
+ {
+ TBool handled = EFalse;
+ CPeninputHwrBoxUiState* current = static_cast<CPeninputHwrBoxUiState*>(iUiStatePenMgr->CurrentUiState());
+ TBuf<KMaxCandidateLen> charCode;
+ //filter un-related events
+ if (aEventType != EEventSetAppCursorSelection
+ && aEventType != EPeninputLayoutEventClose
+ && aEventType != EPeninputLayoutEventBack
+ && aEventType != EPeninputLayoutEventEnter
+ && (aEventType != EPeninputLayoutEventSpace || !iCapturePointerEvent)
+ && aEventType != EPeninputLayoutEventRange
+ && aEventType != EPeninputLayoutEventOption
+ && aEventType != EPeninputLayoutEventSct
+ && aEventType != EPeninputLayoutEventSwitchCharacterRange
+ && aEventType != EEventDraggingEnd
+ && (aEventType >= EPeninputLayoutHwrEventLast || aEventType < EPeninputLayoutHwrEventBeginWriting))
+ {
+ return handled;
+ }
+ TRAPD(err, current->HandleControlEventPenL(aEventType, aEventData, *this, charCode, handled));
+ if (KErrNone != err)
+ { // close peninput
+ HiraganaKanjiCompleteAll(); // call ToPenStandBy()
+ SetCapturePointerEvent(EFalse);
+ Initialize(); //jump to init state
+ CPeninputCommonLayout::HandleControlEvent(EPeninputLayoutEventClose, NULL, KNullDesC);
+ handled = ETrue;
+ }
+ return handled;
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::OnAppEditorTextComing
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+TInt CPeninputHwrBoxLayout::OnAppEditorTextComing(const TFepInputContextFieldData& aData)
+ {
+ iWaitforEditorTextComing = 0;
+ // Handle edit text coming
+ if (iHiraganaKanji)
+ {
+ TRAPD(err, iHiraganaKanji->SetEditorTextL(aData));
+ if (KErrNone != err)
+ {
+ HandleControlEvent(EPeninputLayoutEventClose, NULL, KNullDesC);
+ }
+ return err;
+ }
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------
+// Submit the char code.
+// ---------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::SubmitL(const TDesC& aCharCode)
+ {
+ TInt len = 0;
+ if (iSubmitText && !(*iSubmitText).CompareC(aCharCode)
+ || !UiStateMgr()
+ || !UiStateMgr()->CurrentUiState())
+ {
+ return;
+ }
+ if (iSubmitText)
+ {
+ len = iSubmitText->Length();
+ if (len > 1
+ && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ len = 1;
+ }
+ }
+ delete iSubmitText;
+ iSubmitText = NULL;
+ iSubmitText = aCharCode.AllocL();
+
+ TInt eventType = EEventVirtualKeyUp;
+ TPtr charcode(iSubmitText->Des());
+
+ //if charcode is enter or back or space, translate them back
+ TPtrC16 ptr;
+ ptr.Set(&KBackRep, sizeof(KBackRep)/sizeof(TUint16));
+
+ if (charcode.CompareC(ptr) == 0)
+ {
+ charcode.Zero();
+ charcode.Append((TChar)EKeyBackspace);
+ eventType = EPeninputLayoutEventBack;
+ }
+ else
+ {
+ ptr.Set(&KSpaceRep, sizeof(KSpaceRep)/sizeof(TUint16));
+ if (charcode.CompareC(ptr) == 0)
+ {
+ charcode.Zero();
+ charcode.Append((TChar)EKeySpace);
+ eventType = EPeninputLayoutEventSpace;
+ }
+ else
+ {
+ ptr.Set(&KEnterRep, sizeof(KEnterRep)/sizeof(TUint16));
+ if (charcode.CompareC(ptr) == 0)
+ {
+ charcode.Zero();
+ charcode.Append((TChar)EKeyEnter);
+ eventType = EPeninputLayoutEventEnter;
+ }
+ }
+ }
+ if (len > 0 &&
+ (EEventVirtualKeyUp != eventType
+ || UiStateMgr()->CurrentUiState() != UiStateMgr()->GetUiState(EPeninputHwrUiStateStandby)))
+ {
+ for (TInt i = 0; i < len; i++)
+ {
+ DeleteL(EKeyDelete);
+ }
+ }
+
+ if (len > 0 &&
+ (EEventVirtualKeyUp == eventType
+ && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateStandby)))
+ {
+ // len == 1 or 2, charcode.Length() == 1 or 2.
+ TInt diff = charcode.Length() - len;
+ if (diff > 0)
+ {
+ HBufC* p = HBufC::NewL(charcode.Length() + 2);
+ p->Des().Append((TUint16*)&len, 2);
+ p->Des().Append(charcode.Left(len));
+ Sendkey( ESignalReplaceTextJp, *p );
+ delete p;
+ Sendkey( ESignalKeyEvent, charcode.Right(diff));
+ }
+ else
+ {
+ while (len > charcode.Length())
+ {
+ DeleteL(EKeyDelete);
+ --len;
+ }
+ HBufC* p = HBufC::NewL(charcode.Length() + 2);
+ p->Des().Append((TUint16*)&len, 2);
+ p->Des().Append(charcode);
+ Sendkey( ESignalReplaceTextJp, *p );
+ delete p;
+ }
+ }
+ else if ( !static_cast<CPeninputHwrBoxUiState*>(UiStateMgr()->CurrentUiState())->HandleControlEvent(eventType,charcode) )
+ {
+ SetCapturePointerEvent(ETrue);
+ iHiraganaKanji->HandleControlEventJpL(eventType, charcode);
+ }
+ if (EEventVirtualKeyUp != eventType)
+ {
+ delete iSubmitText;
+ iSubmitText = NULL;
+ }
+ }
+
+// ---------------------------------------------------------
+// Delete the previous charcode
+// ---------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::DeleteL(TInt aChar/* = EKeyBackspace*/)
+ {
+ //delete the last char
+ const TInt len = sizeof(aChar);
+ TBuf<len> aBufBck;
+ aBufBck.Append((TChar)aChar);
+
+ if (UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->PtiEngine()->HandleCommandL(EPtiCommandBackSpaceByForce);
+ }
+ else
+ {
+ SignalOwner(ESignalKeyEvent, aBufBck);
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::HandleRawKeyEventL
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+TBool CPeninputHwrBoxLayout::HandleRawKeyEventL(const TRawEvent& aKeyEvent)
+ {
+ TBool rs = EFalse;
+ if (iHiraganaKanji)
+ {
+ iHiraganaKanji->CancelRepeat();
+ }
+ if (iUiStatePenMgr)
+ {
+ CPeninputUiStateBase* current = iUiStatePenMgr->CurrentUiState();
+ if (iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenBeginWriting) == current)
+ { // temporary
+ return ETrue;
+ }
+ if (iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenEndWriting) == current
+ || iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenCandidateSelecting) == current)
+ {
+ TInt key = (aKeyEvent.ScanCode() & 0x000000FF);
+ switch(key)
+ { // Handle clear key
+ case EKeyBackspace:
+ case EStdKeyBackspace: /* 0x01 */
+ case EStdKeyEscape: /* 0x04 */
+ {
+ // if TRawEvent::EKeyDown, return at once.
+ if (TRawEvent::EKeyDown == aKeyEvent.Type())
+ {
+ iKeyEventClearAsync->CallBack();
+ }
+ return ETrue;
+ }
+ default:
+ ToPenStandBy();
+ break;
+ }
+ }
+ }
+ if (UiStateMgr() && UiStateMgr()->CurrentUiState())
+ {
+ rs = UiStateMgr()->CurrentUiState()->HandleKeyEventL(aKeyEvent);
+ if (rs && iHiraganaKanji)
+ {
+ if (EStdKeyEnter == (aKeyEvent.ScanCode() & 0x000000FF) && IsPredictiveWithNoChar())
+ { // without transitory chars and next word prediction candidates are offered
+ // Enter button should clear Prediction and enter a newline
+ TRAP_IGNORE(iHiraganaKanji->HandleControlEventJpL(EPeninputLayoutEventBack,KNullDesC));
+ return UiStateMgr()->GetUiState(EPeninputHwrUiStateStandby)->HandleKeyEventL(aKeyEvent);
+ }
+ rs = iHiraganaKanji->HandleKeyEvent(aKeyEvent);
+ }
+ }
+ if (!iWaitforEditorTextComing && TRawEvent::EKeyDown == aKeyEvent.Type() && TRawEvent::ENone == iKeyEvent.Type())
+ {
+ if (!rs)
+ {
+ SendEventToWindow(EPeninputLayoutEventCloseCharacterRange, NULL, KNullDesC);
+ HiraganaKanjiCompleteAll();
+ if (iWaitforEditorTextComing) // complete done.
+ {
+ rs = ETrue;
+ iKeyEvent = aKeyEvent;
+ iKeyEventAsync->CallBack(); // for key that hiraganakanji do not handle
+ }
+ }
+ else if (iHiraganaKanji)
+ {
+ iKeyEventAsync->CallBack(); // for pending event
+ }
+ }
+ return rs;
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::OnPointerEventOutsideLayout
+// Call back when the pointer down/up event happends outside of the layout
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+TBool CPeninputHwrBoxLayout::OnPointerEventOutsideLayout(const TRawEvent& aEvent)
+ {
+ if (TRawEvent::EButton1Down == aEvent.Type()) // this if is not necessary. only EButton1Down.
+ {
+ HandleControlEventPen(EPeninputLayoutHwrEventPointerOutsideWnd, NULL, KNullDesC);
+ SendEventToWindow(EPeninputLayoutEventCloseCharacterRange, NULL, KNullDesC);
+ HiraganaKanjiCompleteAll();
+ if (iCapturePointerEvent)
+ {
+ iPointerEventDown = aEvent;
+ SetCapturePointerEvent(EFalse);
+ iPointerEventAsync->CallBack();
+ }
+ }
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::DataMgr
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+CPeninputHwrBoxDataMgr* CPeninputHwrBoxLayout::DataMgr(TInt /*aDummy*/)
+ {
+ return static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr);
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::HwrBoxWindow
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+CPeninputHwrBoxWindow* CPeninputHwrBoxLayout::HwrBoxWindow()
+ {
+ return iHwrWindow;
+ }
+
+void CPeninputHwrBoxLayout::ToPenStandBy(TBool aNotStandBy/* = EFalse*/)
+ {
+ if (iUiStatePenMgr)
+ {
+ CPeninputUiStateBase* current = iUiStatePenMgr->CurrentUiState();
+ if (iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenEndWriting) == current
+ || iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenCandidateSelecting) == current)
+ {
+ static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->ClearCandidates();
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ if (iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenEndWriting) == current && !aNotStandBy)
+ {
+ WriteHwrStrokeLogNew();
+ }
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+ }
+ if (!aNotStandBy)
+ {
+ iUiStatePenMgr->SetCurrentUiState(EPeninputHwrUiStatePenStandBy);
+
+ if( iHwrWindow != NULL )
+ {
+ iHwrWindow->CancelWriting(); // Standby::OnEntry()
+ iHwrWindow->DimInputContextField(EFalse);
+ }
+ }
+ delete iSubmitText;
+ iSubmitText = NULL;
+ iExpanded = EFalse;
+ }
+ }
+
+void CPeninputHwrBoxLayout::Initialize()
+ {
+ if (iUiStatePenMgr)
+ {
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ CPeninputUiStateBase* current = iUiStatePenMgr->CurrentUiState();
+ if (iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenEndWriting) == current
+ || iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenBeginWriting) == current)
+ {
+ WriteHwrStrokeLogNew();
+ }
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+ iUiStatePenMgr->SetCurrentUiState(EPeninputHwrUiStateNone);
+ }
+ if (iHwrWindow)
+ {
+ iHwrWindow->CancelWriting();
+ iHwrWindow->Hide(ETrue);
+ iExpanded = EFalse;
+ }
+ }
+
+void CPeninputHwrBoxLayout::CompleteIfConvertingL()
+ {
+ if (iCapturePointerEvent // Transitory Input Exists
+ && UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ iWaitforEditorTextComing = 0;
+ if (iHiraganaKanji)
+ {
+ iHiraganaKanji->HandleControlEventJpL(EEventCompleteIfConvertingHiraganaKanji, KNullDesC);
+ }
+ if (iWaitforEditorTextComing) // the status of hiraganakanji was converting ---> complete,but should not capture off
+ {
+ UiStateMgr()->SetCurrentUiState(EPeninputHwrUiStateStandbyjp);
+ iCapturePointerEvent = EFalse;
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::ClearInputToPenStandByL()
+// clear last input char and goto PenStandBy
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::ClearInputToPenStandByL()
+ {
+ if (iSubmitText)
+ {
+ TInt len = iSubmitText->Length();
+ if (len > 1 &&
+ UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ len = 1;
+ }
+ for (TInt i = 0; i < len; i++)
+ {
+ DeleteL(EKeyDelete);
+ }
+ }
+ ToPenStandBy();
+
+ if ( iHiraganaKanji != NULL && UiStateMgr() &&
+ UiStateMgr()->CurrentUiState() ==
+ UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ iHiraganaKanji->HandleControlEventJpL(EEventVirtualKeyUp,KNullDesC);
+ }
+ }
+
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::WriteHwrStrokeLogNew
+// write log "New"
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::WriteHwrStrokeLogNew()
+ {
+ if (iLogger.LogValid())
+ {
+ iLogger.Write(KHwrStrokeLogNew());
+ }
+ }
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::CPeninputHwrBoxLayout
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CPeninputHwrBoxLayout::CPeninputHwrBoxLayout(MLayoutOwner* aLayoutOwner)
+ : CPeninputCommonLayout( aLayoutOwner ),
+ iCapturePointerEvent(EFalse),
+ iExpanded(EFalse)
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::ConstructL
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::ConstructL(const TAny* aInitData)
+ {
+ CPeninputCommonLayout::ConstructL( aInitData );
+
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ User::LeaveIfError( iLogger.Connect() );
+ // Make directory
+ RFs fs;
+ if (fs.Connect() == KErrNone)
+ {
+ TInt ret = fs.MkDirAll(KHwrStrokeLogBaseDir());
+ fs.Close();
+ }
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+
+ iUiStatePenMgr = CPeninputUiStateMgr::NewL( this );
+
+ CPeninputUiStateBase* initialState =
+ CPeninputUiStateBase::NewL( UiStateMgr(), this );
+ UiStateMgr()->AddUiState( initialState, EPeninputHwrUiStateNone );
+
+ CPeninputHwrBoxUiStateStandby* standbyState =
+ CPeninputHwrBoxUiStateStandby::NewL( UiStateMgr(), this );
+ UiStateMgr()->AddUiState( standbyState, EPeninputHwrUiStateStandby );
+
+ CPeninputHwrBoxUiStateStandbyjp* standbyjpState =
+ CPeninputHwrBoxUiStateStandbyjp::NewL( UiStateMgr(), this );
+ UiStateMgr()->AddUiState( standbyjpState, EPeninputHwrUiStateStandbyjp );
+
+ CPeninputHwrBoxUiStateWithTransitoryChars* transitoryState =
+ CPeninputHwrBoxUiStateWithTransitoryChars::NewL( UiStateMgr(), this );
+ UiStateMgr()->AddUiState( transitoryState, EPeninputHwrUiStateWithTransitoryChars );
+
+ UiStateMgr()->SetCurrentUiState( initialState );
+
+ CPeninputUiStateBase* penInitialState =
+ CPeninputHwrBoxUiState::NewL( iUiStatePenMgr, this );
+
+ iUiStatePenMgr->AddUiState( penInitialState, EPeninputHwrUiStateNone );
+ CPeninputHwrBoxUiStatePenStandby* penStandbyState =
+ CPeninputHwrBoxUiStatePenStandby::NewL( iUiStatePenMgr, this );
+ iUiStatePenMgr->AddUiState( penStandbyState, EPeninputHwrUiStatePenStandBy );
+
+ CPeninputHwrBoxUiStatePenBeginWriting* penBeginState =
+ CPeninputHwrBoxUiStatePenBeginWriting::NewL( iUiStatePenMgr, this );
+ iUiStatePenMgr->AddUiState( penBeginState, EPeninputHwrUiStatePenBeginWriting );
+
+ CPeninputHwrBoxUiStatePenEndWriting* penEndState =
+ CPeninputHwrBoxUiStatePenEndWriting::NewL( iUiStatePenMgr, this );
+ iUiStatePenMgr->AddUiState( penEndState, EPeninputHwrUiStatePenEndWriting );
+
+ CPeninputHwrBoxUiStatePenCandidateSelecting* penCandidateSelectingState =
+ CPeninputHwrBoxUiStatePenCandidateSelecting::NewL( iUiStatePenMgr, this );
+ iUiStatePenMgr->AddUiState( penCandidateSelectingState, EPeninputHwrUiStatePenCandidateSelecting );
+
+ iUiStatePenMgr->SetCurrentUiState( penInitialState );
+
+ iHwrWindow = static_cast<CPeninputHwrBoxWindow*>(iLayoutWindow);
+ Initialize();
+ {
+ TInt penSpeed = static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->WritingSpeed();
+ TPtr ptr((TUint16*)&penSpeed,sizeof(TInt)/sizeof(TUint16));
+ SendEventToWindow(EPeninputLayoutHwrEventWritingSpeedChange, NULL, ptr);
+ }
+ {
+ TSize penSize = static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->PenSize();
+ TPtr ptr((TUint16*)&penSize,sizeof(TSize)/sizeof(TUint16));
+ SendEventToWindow(EPeninputLayoutHwrEventPenSizeChange, NULL, ptr);
+ }
+ {
+ TRgb penColor = static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->PenColor();
+ TPtr ptr((TUint16*)&penColor,sizeof(TRgb)/sizeof(TUint16));
+ SendEventToWindow(EPeninputLayoutHwrEventPenColorChange, NULL, ptr);
+ }
+ //create hiraganakanji
+ iHiraganaKanji = CPeninputHiraganaKanji::NewL(static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->PtiEngine()
+ , this
+ , iHwrWindow->InputContextField()
+ , iHwrWindow->CandidateWindow()
+ , iHwrWindow->PredictiveWindow());
+ TCallBack cb(KeyEventCallback, this);
+ TCallBack cbpointer(PointerEventCallback, this);
+ iKeyEventAsync = new(ELeave) CAsyncCallBack(cb, CActive::EPriorityHigh);
+ iPointerEventAsync = new(ELeave) CAsyncCallBack(cbpointer, CActive::EPriorityStandard);
+ TCallBack cbClear(KeyEventClearCallback, this);
+ iKeyEventClearAsync = new(ELeave) CAsyncCallBack(cbClear, CActive::EPriorityHigh);
+
+ iKeyEvent.Set(TRawEvent::ENone,0);
+ iPointerEventDown.Set(TRawEvent::ENone,0);
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::DoSetCurrentRange
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::DoSetCurrentRange()
+ {
+ TInt currentRange = CPeninputDataConverter::AnyToInt( RequestData( EPeninputDataTypeCurrentRange ) );
+ static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetEngineInputMode(currentRange); // PtiEngine:SetInputMode()
+
+ if ( currentRange == ERangeHiraganaKanji && static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->Conversion())
+ {
+ UiStateMgr()->SetCurrentUiState(EPeninputHwrUiStateStandbyjp);
+ }
+ else
+ {
+ UiStateMgr()->SetCurrentUiState(EPeninputHwrUiStateStandby);
+ }
+ SetCapturePointerEvent(EFalse);
+ ToPenStandBy();
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ WriteHwrStrokeLogRange();
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::CompleteAllHiraganaKanji
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::HiraganaKanjiCompleteAll()
+ {
+ ToPenStandBy();
+ if( UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ if (iHiraganaKanji)
+ { // CompleteALL
+ TRAP_IGNORE(iHiraganaKanji->HandleControlEventJpL(EEventCompleteAllHiraganaKanji, KNullDesC));
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::CreateLayoutWindowL
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::CreateLayoutWindowL()
+ {
+ iLayoutWindow = CPeninputHwrBoxWindow::NewL( this, this );
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::CreateDataMgrL
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::CreateDataMgrL( const TAny* /*aInitData*/ )
+ {
+ iDataMgr = CPeninputHwrBoxDataMgr::NewL( this );
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::LayoutType
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+TInt CPeninputHwrBoxLayout::LayoutType()
+ {
+ return EPluginInputModeHwr;
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::SemiTransparencyRequired
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+TBool CPeninputHwrBoxLayout::SemiTransparencyRequired()
+ {
+ return ETrue;
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::TranslateRangeHullHalf
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+TInt CPeninputHwrBoxLayout::TranslateRangeHullHalf(TInt aRange) const
+ {
+ TInt newRange = aRange;
+ if (static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->FullHalf()) // Full
+ {
+ switch (aRange)
+ {
+ case ERangeEnglish:
+ newRange = ERangeFullWidthEnglish;
+ break;
+ case ERangeNumber:
+ newRange = ERangeFullWidthNumeric;
+ break;
+ case ERangeKatakana:
+ newRange = ERangeFullWidthKatakana;
+ break;
+ default:
+ break;
+ }
+ }
+ else // half
+ {
+ switch (aRange)
+ {
+ case ERangeFullWidthEnglish:
+ newRange = ERangeEnglish;
+ break;
+ case ERangeFullWidthNumeric:
+ newRange = ERangeNumber;
+ break;
+ case ERangeFullWidthKatakana:
+ newRange = ERangeKatakana;
+ break;
+ default:
+ break;
+ }
+ }
+ return newRange;
+ }
+
+TInt CPeninputHwrBoxLayout::KeyEventCallback(TAny* aThis)
+ {
+ if (aThis)
+ {
+ TRAPD(err,static_cast<CPeninputHwrBoxLayout*>(aThis)->DoKeyEventL());
+ if (KErrNone != err)
+ {
+ static_cast<CPeninputHwrBoxLayout*>(aThis)->HandleControlEvent(EPeninputLayoutEventClose, NULL, KNullDesC);
+ }
+ return err;
+ }
+ return 0;
+ }
+
+TInt CPeninputHwrBoxLayout::PointerEventCallback(TAny* aThis)
+ {
+ if (aThis)
+ {
+ static_cast<CPeninputHwrBoxLayout*>(aThis)->DoPointerEvent();
+ }
+ return 0;
+ }
+
+void CPeninputHwrBoxLayout::DoKeyEventL()
+ {
+ TBool ret = iHiraganaKanji->HandlePendingEventL();
+ if (!ret && TRawEvent::ENone != iKeyEvent.Type())
+ {
+ iKeyEvent.Set(TRawEvent::EKeyUp,iKeyEvent.ScanCode());
+ CCoeEnv::Static()->WsSession().SimulateRawEvent(iKeyEvent);
+ iKeyEvent.Set(TRawEvent::EKeyDown,iKeyEvent.ScanCode());
+ CCoeEnv::Static()->WsSession().SimulateRawEvent(iKeyEvent);
+ iKeyEvent.Set(TRawEvent::EKeyUp,iKeyEvent.ScanCode());
+ CCoeEnv::Static()->WsSession().SimulateRawEvent(iKeyEvent);
+ iKeyEvent.Set(TRawEvent::ENone,0);
+ }
+ }
+
+void CPeninputHwrBoxLayout::DoPointerEvent()
+ {
+ if (TRawEvent::ENone != iPointerEventDown.Type())
+ {
+ User::After(KDelay);
+ CCoeEnv::Static()->WsSession().SimulateRawEvent(iPointerEventDown);
+ iPointerEventDown.Set(TRawEvent::EButton1Up,iPointerEventDown.Pos().iX,iPointerEventDown.Pos().iY);
+ CCoeEnv::Static()->WsSession().SimulateRawEvent(iPointerEventDown);
+ iPointerEventDown.Set(TRawEvent::ENone,0);
+ }
+ }
+
+TInt CPeninputHwrBoxLayout::KeyEventClearCallback(TAny* aThis)
+ {
+ if (aThis)
+ {
+ TRAPD(err,static_cast<CPeninputHwrBoxLayout*>(aThis)->DoKeyClearEventL());
+ if (KErrNone != err)
+ {
+ static_cast<CPeninputHwrBoxLayout*>(aThis)->HandleControlEvent(EPeninputLayoutEventClose, NULL, KNullDesC);
+ }
+ return err;
+ }
+ return 0;
+ }
+
+void CPeninputHwrBoxLayout::DoKeyClearEventL()
+ {
+ ClearInputToPenStandByL();
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+ WriteHwrStrokeLogClear();
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+ if (iHiraganaKanji)
+ {
+ iHiraganaKanji->RepeatClearKeyStart();
+ }
+ }
+
+void CPeninputHwrBoxLayout::SetCapturePointerEvent(TBool aFlag)
+ {
+ if (iCapturePointerEvent && !aFlag || !iCapturePointerEvent && aFlag)
+ {
+ TBool dimmFlag = (aFlag)? EFalse : ETrue;
+ TPtr ptr((TUint16*)&dimmFlag,sizeof(TBool)/sizeof(TUint16));
+ SendEventToWindow(EPeninputLayoutEventSetConversion, NULL, ptr);
+ //signal the owner that pointer needs not be captured
+ TBool capture = aFlag;
+ TPtrC captureData;
+ captureData.Set((const TUint16*)&capture,sizeof(TBool)/sizeof(TUint16));
+ SignalOwner(ESignalCapturePointer,captureData);
+ iCapturePointerEvent = aFlag;
+ }
+ }
+
+void CPeninputHwrBoxLayout::SetCapturePointerEventAgain()
+ {
+ if (iCapturePointerEvent)
+ {
+ //signal the owner that pointer needs not be captured
+ TBool capture = ETrue;
+ TPtrC captureData;
+ captureData.Set((const TUint16*)&capture,sizeof(TBool)/sizeof(TUint16));
+ SignalOwner(ESignalCapturePointer,captureData);
+ }
+ }
+
+void CPeninputHwrBoxLayout::HiraganaHandleControlEventJp(TInt aEventType, const TDesC& aEventData)
+ {
+ if (iHiraganaKanji)
+ {
+ TRAPD(err, iHiraganaKanji->HandleControlEventJpL(aEventType,aEventData));
+ if (KErrNone != err)
+ { // close peninput
+ HiraganaKanjiCompleteAll(); // call ToPenStandBy()
+ SetCapturePointerEvent(EFalse);
+ Initialize(); //jump to init state
+ CPeninputCommonLayout::HandleControlEvent(EPeninputLayoutEventClose, NULL, KNullDesC);
+ }
+ }
+ }
+
+TBool CPeninputHwrBoxLayout::IsPredictiveWithNoChar() const
+ {
+ if (!iCapturePointerEvent // without transitory chars
+ && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))
+ {
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+#ifdef __PENINPUT_HWR_STROKE_LOG_ON
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::WriteHwrStrokeLogClear
+// write log "Clear"
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::WriteHwrStrokeLogClear()
+ {
+ if (iLogger.LogValid())
+ {
+ iLogger.Write(KHwrStrokeLogClear());
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPeninputHwrBoxLayout::WriteHwrStrokeLogRange
+// write log characterrange
+// (other items were commented in a header)
+// ---------------------------------------------------------------------------
+//
+void CPeninputHwrBoxLayout::WriteHwrStrokeLogRange()
+ {
+ if (iLogger.LogValid() && !iLogOff)
+ {
+ TBuf<KHwrStrokeLogCharacterRangeLen> characterRange;
+ switch(static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->CharacterRangeId())
+ {
+ case EPeninutCharacterRangeIdKanaKanji:
+ characterRange.Append(KHwrStrokeLogRangeKanaKanji());
+ break;
+ case EPeninutCharacterRangeIdLatin:
+ characterRange.Append(KHwrStrokeLogRangeLatin());
+ break;
+ case EPeninutCharacterRangeIdNumber:
+ characterRange.Append(KHwrStrokeLogRangeNumber());
+ break;
+ default:
+ characterRange.Append(KHwrStrokeLogRangeAllTypes());
+ break;
+ }
+ iLogger.WriteFormat(KHwrStrokeLogCharacterRange(), &characterRange);
+ }
+ }
+#endif // __PENINPUT_HWR_STROKE_LOG_ON
+// End Of File