diff -r ebd48d2de13c -r ecbabf52600f textinput/peninputhwrboxjp/src/peninputhwrboxlayout.cpp --- /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 // hiraganakanji +#include // use ui state mgr +#include +#include //command from fep or IME to plugin. for vkb/hwr, range defination +#include // EPeninputLayoutEventEnter +#include +#include //define TWidthChar +#include +#include +#include + +// 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 +#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(iDataMgr)->Predictive() + && static_cast(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 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(&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(&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(iDataMgr)->SetFullHalf( + (val & EPenInputJapaneseSettingCharacterWidth)? 1: 0); + static_cast(iDataMgr)->SetPredictive( + (val & EPenInputJapaneseSettingPredictive)? ETrue: EFalse); + static_cast(iDataMgr)->SetConversion( + (val & EPenInputJapaneseSettingConversion)? ETrue: EFalse); + static_cast(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 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(iDataMgr)->SetCurrentCharacterRangeIndex(*data); + switch(static_cast(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(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(iDataMgr)->Predictive() + && static_cast(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 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(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(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(UiStateMgr()->CurrentUiState())->HandleControlEvent(aEventType,aEventData) ) + { + TRAP_IGNORE(iHiraganaKanji->HandleControlEventJpL(aEventType,aEventData)); + } + break; + case EPeninputLayoutEventSpace: // convert + if ( UiStateMgr()->CurrentUiState() + && !static_cast(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(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(iUiStatePenMgr->CurrentUiState()); + TBuf 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(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 aBufBck; + aBufBck.Append((TChar)aChar); + + if (UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars)) + { + static_cast(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(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(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(iLayoutWindow); + Initialize(); + { + TInt penSpeed = static_cast(iDataMgr)->WritingSpeed(); + TPtr ptr((TUint16*)&penSpeed,sizeof(TInt)/sizeof(TUint16)); + SendEventToWindow(EPeninputLayoutHwrEventWritingSpeedChange, NULL, ptr); + } + { + TSize penSize = static_cast(iDataMgr)->PenSize(); + TPtr ptr((TUint16*)&penSize,sizeof(TSize)/sizeof(TUint16)); + SendEventToWindow(EPeninputLayoutHwrEventPenSizeChange, NULL, ptr); + } + { + TRgb penColor = static_cast(iDataMgr)->PenColor(); + TPtr ptr((TUint16*)&penColor,sizeof(TRgb)/sizeof(TUint16)); + SendEventToWindow(EPeninputLayoutHwrEventPenColorChange, NULL, ptr); + } + //create hiraganakanji + iHiraganaKanji = CPeninputHiraganaKanji::NewL(static_cast(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(iDataMgr)->SetEngineInputMode(currentRange); // PtiEngine:SetInputMode() + + if ( currentRange == ERangeHiraganaKanji && static_cast(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(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(aThis)->DoKeyEventL()); + if (KErrNone != err) + { + static_cast(aThis)->HandleControlEvent(EPeninputLayoutEventClose, NULL, KNullDesC); + } + return err; + } + return 0; + } + +TInt CPeninputHwrBoxLayout::PointerEventCallback(TAny* aThis) + { + if (aThis) + { + static_cast(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(aThis)->DoKeyClearEventL()); + if (KErrNone != err) + { + static_cast(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 characterRange; + switch(static_cast(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