diff -r 000000000000 -r eb1f2e154e89 textinput/peninputarc/src/peninputserverapp/peninputserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textinput/peninputarc/src/peninputserverapp/peninputserver.cpp Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,2922 @@ +/* +* Copyright (c) 2005-2007 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 for peninput server +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include +#include +#include +#include // KCRUidSensorSettings + +#ifdef RD_TACTILE_FEEDBACK +#include +#endif //RD_TACTILE_FEEDBACK +#include "peninputclientserver.h" +#include "peninputserver.h" +#include "peninputserversession.h" +#include +#include +#include +#include "peninputanimclientobj.h" +#include "peninputuilayoutowner.h" +//#include "aknfeppeninputenums.h" +#include +#include "penuiwndctrl.h" +#include "keyrotator.h" +#include +#include +#include + +#include "peninputcrpclient.h" +//#define __WND_TEST_ + +// CONSTANTS +const TSize KInitialPeninputSize= TSize( 10, 10 ); +const TInt KMsgQueueLen = 1000; +const TInt KMsgResponseQueueLen = 10; + +const TInt KWsSessionFlushPerioid = 50000;//50ms +const TInt KInvalidValue = -1; + +enum TActivationFlag + { + ECmdDeactivate = EFalse, + ECmdActivate = ETrue, + }; + +enum TUpdateFlag + { + EPartialUpdate = EFalse, + EFullUpdate = ETrue + }; + +#ifdef __LOG_WNDGROU__ + +#ifdef __WINS__ +_LIT(KLogFile,"c:\\penwndgroup.txt"); +#else +_LIT(KLogFile,"\\penwndgroup.txt"); +#endif + +#endif //__LOG_WNDGROU__ + +TUid GetAppUidByWndGroupIdL( RWsSession &aWs, TInt aWndGroupId ) + { + CApaWindowGroupName* wg = CApaWindowGroupName::NewLC(aWs,aWndGroupId); + TUid id = wg->AppUid(); + CleanupStack::PopAndDestroy(wg); + return id; + } + +TUid GetFocusAppUid() + { + RWsSession &ws = CCoeEnv::Static()->WsSession(); + TInt wgId =ws.GetFocusWindowGroup(); + TUid id = TUid::Null(); + TRAP_IGNORE( id = GetAppUidByWndGroupIdL( ws, wgId ) ); + return id; + } + +#ifdef __LOG_WNDGROU__ +void Des2Des8(const TDesC& aSrc, TDes8& aDest) + { + aDest.Zero(); + const TUint16* ptr = aSrc.Ptr(); + for(TInt i = 0; i < aSrc.Length(); ++i) + { + aDest.Append(*((TUint8*)ptr)); + ptr++; + } + } + +#endif + + +#ifdef __LOG_WNDGROU__ +void WriteDeactivateLogL( RFile& aFile ) + { + TInt ret = aFile.Open(CCoeEnv::Static()->FsSession(),KLogFile,EFileShareAny|EFileWrite); + if(ret == KErrNone) + { + _LIT8 (KNotesID, "Notes id: %d \r\n"); + TBuf8<30> buf; + buf.Zero(); + + TInt off = 0; + aFile.Seek(ESeekEnd,off); + + RWsSession &ws = CCoeEnv::Static()->WsSession(); + TInt wgId =ws.GetFocusWindowGroup(); + CApaWindowGroupName* wgname = CApaWindowGroupName::NewLC(ws,wgId); + + TInt focusuid = GetFocusAppUid().iUid; + buf.Format(KNotesID, focusuid); + + + HBufC8* name = HBufC8::NewLC(wgname->Caption().Length()); + TPtr8 nameStr = name->Des(); + Des2Des8(wgname->Caption(),nameStr); + aFile.Write(_L8(" ...")); + aFile.Write(nameStr); + aFile.Write(buf); + aFile.Write(_L8(" Close UI. \r\n")); + aFile.Close(); + CleanupStack::PopAndDestroy(name); + CleanupStack::PopAndDestroy(wgname); + } + } +#endif + +TBool IsGlobalNotesApp(TUid& aUid) + { + const TInt KAknCapServerUid = 0x10207218; + const TInt KAknNotifySrvUid = 0x10281EF2; + if(aUid.iUid == KAknCapServerUid || aUid.iUid == KAknNotifySrvUid) + return ETrue; + return EFalse; + } + + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// CPeninputServer::CPeninputServer +// --------------------------------------------------------------------------- +// +CPeninputServer::CPeninputServer ( TInt aPriority) : CServer2 ( aPriority,ESharableSessions ), + iActive(EFalse),iDispMode(ENone), + iDispModeForMask(ENone), + iFullUpdate(EFalse), + iPrevActive(EFalse),iUILayoutReady(EFalse), + iSupportFeedback(EFalse) + { + AknIconConfig::TPreferredDisplayMode displayMode; + + AknIconConfig::PreferredDisplayMode(displayMode, AknIconConfig::EImageTypeIcon); + + iDispMode = displayMode.iBitmapMode; + iDispModeForMask = displayMode.iMaskMode; + + iSpriteMember.iBitmap = NULL; + iSpriteMember.iMaskBitmap = NULL; + iLayoutId.iUid = 0; + iPrevLayoutId = iLayoutId; + + iSpriteSize = KInitialPeninputSize; + iSpritePosition = TPoint(0,0); + //iDispMode = iDispModeForMask= CCoeEnv::Static()->WsSession().GetDefModeMaxNumColors(col,grey); + iPreNonGloebalNotesWndGrpId = -1; + iNoNeedClean = EFalse; + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::NewL +// --------------------------------------------------------------------------- +// +CPeninputServer* CPeninputServer::NewL() + { + CPeninputServer* pS = new (ELeave) CPeninputServer( + CActive::EPriorityStandard); + CleanupStack::PushL( pS ); + pS->ConstructL( ); + CleanupStack::Pop(pS); + return pS; + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::ConstructL +// --------------------------------------------------------------------------- +// +void CPeninputServer::ConstructL( ) + { +#ifdef RD_TACTILE_FEEDBACK + //KS: QUICK FIX FOR EGSN-7BCBWS + FeatureManager::InitializeLibL(); + //KS: QUICK FIX FOR EGSN-7BCBWS + iSupportFeedback = FeatureManager::FeatureSupported( KFeatureIdTactileFeedback ); + +#endif //RD_TACTILE_FEEDBACK + + // start server, leaves if server already running + StartL( KPeninputServerName ); + + User::LeaveIfError( iKeyEventSemaphore.CreateGlobal( + KAnimKeyEventSemaphore,0) ); + + iEventBufferQueue = CEventQueue::NewL(this,KMsgEventBufferQueue); + + iKeyMsgResponseQueue.CreateGlobal(KMsgEventResponseQueue,KMsgResponseQueueLen); + + iFlushTimer = CPeriodic::NewL(CActive::EPriorityHigh); + + iHardwareLayoutChangeWatcher = CAknLayoutChangeWatcher::NewL(this, + KUikLayoutState); + iSoftwareLayoutChangeWatcher = CAknLayoutChangeWatcher::NewL(this, + KUikPreferredOrientation); + iHardwareLayoutChangeWatcher->StartWatching(); + iSoftwareLayoutChangeWatcher->StartWatching(); + + RWindowGroup& rootWin = CCoeEnv::Static()->RootWin(); + rootWin.EnableFocusChangeEvents (); // For cover UI/status pane refresh problems + rootWin.EnableGroupListChangeEvents(); + rootWin.EnableReceiptOfFocus(EFalse); + rootWin.AutoForeground(EFalse); + + ConstructSpriteL(); + + //create animation object + iAnimObj = CPeninputAnimObj::NewL(iSpriteMember); + + iLayoutOwner = CPeninputUiLayoutOwner::NewL( *this ); + iPenUiCtrl = new(ELeave) CPenUiWndCtrl(CCoeEnv::Static()->RootWin(),iSpriteMember.iBitmap); + iInternalBackgroundCtrl = new(ELeave) CInternalBkCtrl(CCoeEnv::Static()->RootWin()); + iInternalBackgroundCtrl->ConstructL(); + iPenUiCtrl->ConstructL(); + + iCurScreenFocusedWndGrpId = GetFocusAppUid().iUid; +#ifdef __LOG_WNDGROU__ + iLogFile.Replace(CCoeEnv::Static()->FsSession(),KLogFile,EFileShareAny|EFileWrite); + iLogFile.Close(); + +#endif + + iCurScrMode = CCoeEnv::Static()->ScreenDevice()->CurrentScreenMode(); + iCrpService = CPenInputCrpServiceClient::NewL(); + iSensorRepository = CRepository::NewL(KCRUidSensorSettings); + } + +void CPeninputServer::CleanAll() + { + if(iNoNeedClean) + return; + + delete iHardwareLayoutChangeWatcher; + delete iSoftwareLayoutChangeWatcher; + if(iAppGc) + CCoeEnv::Static()->SwapSystemGc(iAppGc); + + delete iPtiEngine; + + iKeyEventSemaphore.Close(); + iUiHandlerArray.Close(); + // iSprite will be closed by iWsSession.Close() + // but the sprite member bitmaps must be deleted + // explicitly + /* + // iPrevUiLayout is not used any more + if(iPrevUiLayout && iPrevUiLayout!=iUiLayout) + { + iPrevUiLayout->Destroy(); + iPrevUiLayout = iUiLayout; + } + */ + if(iUiLayout) + { + iUILayoutReady = EFalse; + iDestroyingLayout = ETrue; + iUiLayout->Destroy(); + iUiLayout = NULL; + } + delete iBitmapDevice; + delete iMaskBitmapDevice; + delete iSpriteGc; + delete iSpriteMember.iBitmap; + delete iSpriteMember.iMaskBitmap; + + delete iWindowGc; + delete iLayoutEng; + + delete iLayoutOwner; + + delete iEventBufferQueue; + iKeyMsgResponseQueue.Close(); + if(iFlushTimer) + { + iFlushTimer->Cancel(); + delete iFlushTimer; + } + + +#ifdef RD_TACTILE_FEEDBACK + //KS: QUICK FIX FOR EGSN-7BCBWS + FeatureManager::UnInitializeLib(); + //KS: QUICK FIX FOR EGSN-7BCBWS + iFeedbackAreaArray.Close(); +#endif // RD_TACTILE_FEEDBACK + delete iPenUiCtrl; + delete iInternalBackgroundCtrl; + + iClientProcess.Close(); + iClientLayouts.Close(); +#ifdef __LOG_WNDGROU__ + iLogFile.Close(); +#endif + delete iAnimObj; + iAnimObj = NULL; + + iNoNeedClean = ETrue; + + delete iCrpService; + iCrpService = NULL; + } +// --------------------------------------------------------------------------- +// CPeninputServer::~CPeninputServer +// Destructor +// --------------------------------------------------------------------------- +// +CPeninputServer::~CPeninputServer() + { + CleanAll(); +#ifdef __WINS__ + iCloseServer = ETrue; +#endif + delete iSensorRepository; + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::IncreaseSessionCount +// --------------------------------------------------------------------------- +// +void CPeninputServer::IncreaseSessionCount() + { + ++iSessionCount; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::DecreaseSessionCount +// --------------------------------------------------------------------------- +// +void CPeninputServer::DecreaseSessionCount(CPeninputServerSession* aSession) + { + if( aSession == iForegroundSession) + { + iForegroundSession = NULL; + Hide(); + } + else + { + if( aSession == iForegroundUiHandler ) + { + iForegroundUiHandler = NULL; + } + } + + //remove the session from list + for(TInt i = 0; i < iUiHandlerArray.Count(); i++) + { + if( aSession == iUiHandlerArray[i] ) + iUiHandlerArray.Remove(i); + } + + --iSessionCount; + +#ifdef __WINS__ + if ( iSessionCount == 0 && !iCloseServer) + { + DeactivateSprite(); + PrepareExit(); + CActiveScheduler::Stop(); + } +#endif + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::ActivateSpriteInGlobalNotesL() +// Activate sprite +// --------------------------------------------------------------------------- +// +void CPeninputServer::ActivateSpriteInGlobalNotesL() + { + if(iActive) + { + if(iUseWindowCtrl) + { +/* RWsSession &ws = CCoeEnv::Static()->WsSession(); + TInt wgId =ws.GetFocusWindowGroup(); + //TInt wgHandle = ws.GetWindowGroupHandle(wgId); + + + TInt priority; + //TInt pos; + //wg.Construct(wgHandle); + //pos = wg.FullOrdinalPosition(); + priority = ws.GetWindowGroupOrdinalPriority(wgId);*/ + //wg.Close(); + //iPenUiCtrl->ShowPenUi(); + ActivatePenUiLayout(EFalse); + iDimmed = EFalse; + iPenUiCtrl->ShowPenUiL(iDimmed); + } + return; + } + + TBool bNeedWait = AnimOpNeedWaiting(ESignalPenUiActivated); + //add animation command + + /* + if(iAnimObj->AddActivationCmd(ECmdActivate,bNeedWait)) + { + if(bNeedWait) + iForegroundUiHandler->AddDelayedCmd(); + //iUiLayout->OnActivate(); + ActivatePenUiLayout(); + + DrawSprite(); + + iEventBufferQueue->GetEvent(); + + iActive = ETrue; + + if(iUseWindowCtrl) + iPenUiCtrl->ShowPenUi(); + } + */ + if(ActivatePenUiLayout(bNeedWait)) + { + if(bNeedWait) + iForegroundUiHandler->AddDelayedCmd(); + + DrawSprite(); + + iActive = ETrue; + + if(iUseWindowCtrl) + { + /*RWsSession &ws = CCoeEnv::Static()->WsSession(); + TInt wgId =ws.GetFocusWindowGroup(); + //TInt wgHandle = ws.GetWindowGroupHandle(wgId); + + + TInt priority; + //TInt pos; + //wg.Construct(wgHandle); + //pos = wg.FullOrdinalPosition(); + priority = ws.GetWindowGroupOrdinalPriority(wgId);*/ + //wg.Close(); + iPenUiCtrl->ShowPenUiL(iDimmed); + } + } + } +// --------------------------------------------------------------------------- +// CPeninputServer::ActivateSprite +// Activate sprite +// --------------------------------------------------------------------------- +// +void CPeninputServer::ActivateSprite(TInt aRequiredScrMode) + { + if(!iUiLayout) + return; + + if(iCurScrMode != aRequiredScrMode) + { + iUiLayout->OnResourceChange(KEikDynamicLayoutVariantSwitch); + iCurScrMode = aRequiredScrMode; + } + ActivateSprite(); + } +// --------------------------------------------------------------------------- +// CPeninputServer::ActivateSprite +// Activate sprite +// --------------------------------------------------------------------------- +// +void CPeninputServer::ActivateSprite() + { + //do nothing if we don't have ui layout or already activated. + TUid focusApp = GetFocusAppUid(); + if(!IsGlobalNotesApp(focusApp)) + iPreNonGloebalNotesWndGrpId = focusApp.iUid; + + if(!iUiLayout) + return; + + // move it out from if(!iActive) to make sure that msg bubble can be + // shown if fast swap from other application to msg application. + TBool bNeedWait = AnimOpNeedWaiting(ESignalPenUiActivated); + + if(!iActive) + { + /* + TInt scrMode = CCoeEnv::Static()->ScreenDevice()->CurrentScreenMode(); + TBool bScrRotated = scrMode != iCurScrMode; + + if(bScrRotated) + { + iCurScrMode = scrMode; + iUiLayout->OnResourceChange(KEikDynamicLayoutVariantSwitch); + } + */ + //TBool bNeedWait = AnimOpNeedWaiting(ESignalPenUiActivated); + //add animation command + + /* + if(iAnimObj->AddActivationCmd(ECmdActivate,bNeedWait)) + { + if(bNeedWait) + iForegroundUiHandler->AddDelayedCmd(); + //iUiLayout->OnActivate(); + ActivatePenUiLayout(); + + DrawSprite(); + + iEventBufferQueue->GetEvent(); + + iActive = ETrue; + + if(iUseWindowCtrl) + iPenUiCtrl->ShowPenUi(); + } + */ + + if(ActivatePenUiLayout(bNeedWait, ETrue)) + { + if(bNeedWait) + iForegroundUiHandler->AddDelayedCmd(); + + DrawSprite(); + + iActive = ETrue; + + if(iUseWindowCtrl) + { + TRAP_IGNORE( iPenUiCtrl->ShowPenUiL(iDimmed) ); + + if (iPreNonGloebalNotesWndGrpId != focusApp.iUid && + IsGlobalNotesApp(focusApp) && !iInGlobalEditorState ) + { + iDimmed = ETrue; + DimPenUi(); + } + } + } + } + else + { + //actived but dimmed by global notes + if(iUseWindowCtrl) + { + ActivatePenUiLayout(EFalse); + + if (iDimmed && (iInGlobalNotesApp || iInGlobalEditorState)) + { + DeactivatePenUiLayout(EFalse); + return; + } + + TRAP_IGNORE( iPenUiCtrl->ShowPenUiL(iDimmed) ); + iDimmed = EFalse; + } + } + } + +// --------------------------------------------------------------------------- +// CPeninputServer::ActivatePenUiLayout +// --------------------------------------------------------------------------- +// +TBool CPeninputServer::ActivatePenUiLayout(TBool aWaitFlag, TBool aSkipDraw) + { + RecoverSimulatedKeyEventState(); + RecoverButtonEventState(); + + if (iAnimObj && iAnimObj->AddActivationCmd(ECmdActivate,aWaitFlag)) + { + if (iUiLayout) + { + iUiLayout->OnActivate(); + if( !aSkipDraw ) + iUiLayout->Draw(); + } + + iEventBufferQueue->GetEvent(); + + if (iUseWindowCtrl) + { + CPenUiWndCtrl::EditorType type; + + if (iInGlobalEditorState) + { + type = CPenUiWndCtrl::EGlobleNotesWithEditor; + } + else + { + TUid focusApp = GetFocusAppUid(); + if(IsGlobalNotesApp(focusApp)) + { + type = CPenUiWndCtrl::EGlobleNotes; + } + else + { + type = CPenUiWndCtrl::ENoremalEditor; + } + } + + iPenUiCtrl->OnActivate(type); + //iPenUiCtrl->ShowPenUi(); + } + return ETrue; + } + return EFalse; + } + + +void CPeninputServer::DimPenUiWnd(TBool aFlag) + { + RecoverSimulatedKeyEventState(); + if(aFlag) + { + iEventBufferQueue->Cancel(); + iUiLayout->OnDeActivate(); + if(iUseWindowCtrl) + iPenUiCtrl->OnDeactivate(); //disable non fading + } + else + { + iEventBufferQueue->GetEvent(); + iUiLayout->OnActivate(); + if(iUseWindowCtrl) + iPenUiCtrl->OnActivate(CPenUiWndCtrl::ENoremalEditor); //disable non fading + } + + } +// --------------------------------------------------------------------------- +// CPeninputServer::DeactivatePenUiLayout +// --------------------------------------------------------------------------- +// +TBool CPeninputServer::DeactivatePenUiLayout(TBool aWaitFlag) + { + //iEventBufferQueue->Cancel(); + + if (iAnimObj && iAnimObj->AddActivationCmd(ECmdDeactivate,aWaitFlag)) + { + if (iUiLayout) + { + RecoverSimulatedKeyEventState(); + RecoverButtonEventState(); + iUiLayout->OnDeActivate(); + if(iUseWindowCtrl) + iPenUiCtrl->OnDeactivate(); //disable non fading + } + + return ETrue; + } + return EFalse; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::DeactivatePenUiLayout +// --------------------------------------------------------------------------- +// +TBool CPeninputServer::DeactivateDimPenUiLayout(TBool aWaitFlag) + { + //iEventBufferQueue->Cancel(); + + if (iAnimObj && iAnimObj->AddActivationCmd(ECmdDeactivate,aWaitFlag)) + { + if (iUiLayout) + { + RecoverSimulatedKeyEventState(); + iUiLayout->OnDeActivate(); + } + + return ETrue; + } + return EFalse; + } + +// CPeninputServer::DeactivateSprite +// --------------------------------------------------------------------------- +// +void CPeninputServer::DeactivateSprite(TBool aImmediateHideFlag, TBool aRotation) + { + if (!iActive || !iUiLayout) + return; +#ifdef __LOG_WNDGROU__ + // TRAP_IGNORE( WriteDeactivateLogL(iLogFile) ) ; +#endif + + aRotation = aRotation || iResourceChange; + + iActive = EFalse; + if (!aRotation) + { + iDimmed = EFalse; + iInGlobalNotesState = EFalse; + } + iFlushTimer->Cancel(); + TBool bNeedWait = !aImmediateHideFlag && + AnimOpNeedWaiting(ESignalPenUiDeActivated); + + + if (DeactivatePenUiLayout(bNeedWait) && bNeedWait) + iForegroundUiHandler->AddDelayedCmd(); + + if (iUseWindowCtrl) + iPenUiCtrl->ClosePenUi(aRotation); + + //save current screen mode + iCurScrMode = CCoeEnv::Static()->ScreenDevice()->CurrentScreenMode(); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::HandleMessageL +// Handle client message +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::HandleMessageL(const RMessage2& aMessage) + { + //It's traped in server session + TInt err = KErrNone; + if(!iPtiEngine || !iLayoutEng) + DoIdleConstructL(); + + TBool isForeground = IsForegroundSession( + static_cast(aMessage.Session())); + //message requests UI attribute is always handled. + switch(aMessage.Function()) + { + + case EPeninputRequestUiIsVisible: + { + TPckg msg(iActive); + + aMessage.WriteL(0,msg); + } + + break; + case EPeninputRequestUiGetUiPos: + { + TPckgC msg(iSpritePosition); + TPckgC msgSize(iSpriteSize); + + aMessage.WriteL(0,msg); + aMessage.WriteL(1,msgSize); + } + break; + + case EPenInputRequestGetPenSupportLanguages: + GetPenSupportLanguagesL(aMessage); + break; + case EPenInputRequestGetImePluginIdList: + GetImePluginIdListL(aMessage); + break; + case EPeninputRequestRelinquishForeground: + { + if(isForeground) + iForegroundSession = NULL; + } + break; + case EPeninputRequestSetForeground: + { + TInt msgGroupId; + TPckg msgIdData(msgGroupId); + aMessage.ReadL(KMsgSlot0,msgIdData); + + //TInt curFocusId = GetFocusAppUid().iUid; + TBool mustOpenFlag; + TPckg msgFlagData(mustOpenFlag); + aMessage.ReadL(KMsgSlot1,msgFlagData); + + //ignore the command if it's from another focused group. + /*******************************************************************/ + //This is a fix to web browse case. When swithing to web, device changeded + // to landscape mode automatically, but previous app with pen UI, e.g. + // Notepad, will gain the foregound, thus open the UI. + /*******************************************************************/ + if(!mustOpenFlag && msgGroupId != iCurScreenFocusedWndGrpId) //screen has changed, but foreground is wrong. + { + //only check this if it's not openned by pen click + err = KErrNotWrongFocusedWindowGroup; + //iForegroundSession = NULL; + } + else + { + CPeninputServerSession* session = + static_cast(aMessage.Session()); + /*if(!IsSameProcess(iForegroundSession, session)) + { + // + }*/ + iForegroundSession = session; + + //check whether there is ui notification handler from the same process + if(iUiHandlerArray.Count()) + SetForeGroundUiHandlerL(); + } + + TPckgC msg(iForegroundSession != NULL); + aMessage.WriteL(KMsgSlot2,msg); + } + break; + + case EPeninputRequestIsForeground: + { + TPckgC msg(isForeground); + aMessage.WriteL(0,msg); + } + break; + + case EPeninputRequestIsLayoutDimmed: + { + TPckgC msg(iDimmed); + aMessage.WriteL(0,msg); + } + break; + + //other message is only handled when the request session is foreground session. + + case EPeninputRequestUiSetUiPos: + if(isForeground) + { + TPoint pt; + TPckg msg(pt); + aMessage.ReadL(KMsgSlot0,msg); + + SetPosition(pt); + } + else + { + err = KErrNotForegroundSession; + } + break; + case EPeninputServerRequestSetDisplayMode: + if(isForeground) + { + TDisplayMode mode; + TDisplayMode maskMode; + TPckg data1(mode); + TPckg data2(maskMode); + + aMessage.ReadL(KMsgSlot0,data1); + aMessage.ReadL(KMsgSlot1,data2); + + ChangeDisplayModeL(mode,maskMode); + } + else + { + err = KErrNotForegroundSession; + } + + break; + case EPeninputRequestActivateLayout: + if(isForeground) + { + iInGlobalEditorState = EFalse; + TBool bFlag ; + + TPckg msg(bFlag ); + aMessage.ReadL(KMsgSlot0,msg); + if(bFlag) + { + TInt requiredMode; + TPckg scrMsg(requiredMode); + aMessage.ReadL(KMsgSlot1,scrMsg); + + ActivateSprite(requiredMode); + static_cast( + aMessage.Session())->DoUpdateAppInfo(); + } + else + { + DeactivateSprite(); + } + } + else + { + err = KErrNotForegroundSession; + } + break; + case EPeninputRequestActivateLayoutInGlobalNotes: + //if(isForeground) + { + iCurGlobalNotesId = GetFocusAppUid().iUid; + iInGlobalEditorState = ETrue; + ActivateSpriteInGlobalNotesL(); + } + /*else + { + err = KErrNotForegroundSession; + }*/ + break; + + case EPeninputRequestInternalDimLayout: + { + if(iUseWindowCtrl && iActive) + { + TBool dim; + TPckg msg(dim); + aMessage.ReadL(KMsgSlot0,msg); + TInt priority; + TPckg priorityMsg(priority); + aMessage.ReadL(KMsgSlot1,priorityMsg); + + TInt bmpHandle = iSpriteMember.iBitmap->Handle(); + TPckg handleMsg(bmpHandle); + aMessage.WriteL(KMsgSlot2,handleMsg); + + TRect pos = iPenUiCtrl->Rect(); + pos.Move(iPenUiCtrl->Position()); + TPckg extMsg(pos); + aMessage.WriteL(KMsgSlot3,extMsg); + iDimmed = dim; + DimPenInternalUi(iDimmed,priority); + } + } + break; + case EPeninputRequestDimLayout: + if(iUseWindowCtrl && iActive) + { + TBool dim; + TPckg msg(dim); + aMessage.ReadL(KMsgSlot0,msg); + TInt priority; + TPckg priorityMsg(priority); + aMessage.ReadL(KMsgSlot1,priorityMsg); + + + TInt bmpHandle = iSpriteMember.iBitmap->Handle(); + TPckg handleMsg(bmpHandle); + aMessage.WriteL(KMsgSlot2,handleMsg); + + TRect pos = iPenUiCtrl->Rect(); + pos.Move(iPenUiCtrl->Position()); + TPckg extMsg(pos); + aMessage.WriteL(KMsgSlot3,extMsg); + if(dim != iDimmed) + { + iDimmed = dim; + DimPenUi(); + /*if(iDimmed) + //DeactivatePenUiLayout(EFalse); + DeactivateSprite(); + else + ActivatePenUiLayout(EFalse); + */ + } + } + break; + case EPeninputRequestSetUiLayoutId: + case EPeninputRequestSetUiLayoutIdWithData: + if(isForeground || iDimmed) + { + err = CreateLayoutL(aMessage); + } + else + { + err = KErrNotForegroundSession; + } + + break; + case EPeninputRequestResourceChanged: + if(isForeground) + { + if(!iUiLayout) + return KErrNoLayout; + + if(iPrevActive) + { + ActivateSprite(); + iPrevActive = EFalse; + } + } + else + { + err = KErrNotForegroundSession; + } + + break; + case EPeninputRequestAddUiObserver: + { + TInt type ; + + TPckg msg(type); + aMessage.ReadL(KMsgSlot0,msg); + static_cast(aMessage.Session())-> + RegisterPenUiType(type); + + iUiHandlerArray.Append(static_cast(aMessage.Session())); + if(iForegroundSession) + SetForeGroundUiHandlerL(); + } + break; + + case EPeninputRequestRemoveUiObserver: + { + CPeninputServerSession* s =static_cast + (aMessage.Session()); + if( s == iForegroundUiHandler) + { + s->ProcessPendingEventBeforeExit(); + iForegroundUiHandler = NULL; + } + + for(TInt i = 0; i < iUiHandlerArray.Count();i++) + { + if(s == iUiHandlerArray[i]) + { + iUiHandlerArray.Remove(i); + break; + } + } + } + break; + /*case EPeninputRequestGetDisableLayout: + { + TInt layoyts = 0; + CPeninputServerSession* pSession = static_cast(aMessage.Session()); + GetProcessLayouts( pSession->ClientProcessId(), layoyts ); + + TPckg msg(layoyts); + + aMessage.WriteL(0,msg); + } + break; + case EPeninputRequestDisableLayout: + { + TInt layouts = aMessage.Int0(); + CPeninputServerSession* pSession = static_cast(aMessage.Session()); + SetProcessLayouts( pSession->ClientProcessId(), layouts ); + } + break;*/ + case EPeninputRequestServerThreadId: + { + RThread thread; + TThreadId id = thread.Id(); + TPckg msg(id); + + aMessage.WriteL(0,msg); + thread.Close(); + } + break; + case EPeninputBackgroudDefaultOri: + { + TInt flag = 0; + TPckg msg(flag); + + aMessage.ReadL(0,msg); + BackgroudDefaultOri( flag ); + } + break; + case EPeninputRequestDimResChangeLayout: + { + TInt flag = 0; + TPckg msg(flag); + + aMessage.ReadL(0,msg); + + iResourceChange = flag; + + if(iUseWindowCtrl) + iPenUiCtrl->SetResourceChange(iResourceChange); + } + break; + case EPeninputRequestSupportInputMode: + { + TInt supportMode = GetSupportModeL(); + + TPckg msg(supportMode); + + aMessage.WriteL(0,msg); + } + break; + + case EPeninputRequestSetInputLanguage: + { + TPckg msg(iInputLanguage); + aMessage.ReadL(0,msg); + if(iUiLayout) + { + iUiLayout->HandleCommand(ECmdPenInputLanguage, + (unsigned char*)&iInputLanguage); + } + } + break; + default: //Let user pluging handling the user command + break; + } + return err; + } +// --------------------------------------------------------------------------- +// CPeninputServer::HandleCommandL +// Handle client command +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::HandleCommandL(const RMessage2& aMessage) + { + //let UI layout handles the command + TInt err = KErrNone; + + //command is only handled when the request session is foreground session. + /*CPeninputServerSession* s = + static_cast(aMessage.Session()); + if( iForegroundSession == static_cast( + aMessage.Session()) )*/ + if(IsForegroundSession(static_cast(aMessage.Session()))) + { + //get cmd id + TInt cmdId; + TPckg cmdMsg(cmdId); + aMessage.ReadL(KMsgSlot0,cmdMsg); + + TInt len = aMessage.GetDesLength(KMsgSlot1); + HBufC8* dataBuf = HBufC8::NewLC(len); + TPtr8 msgData = dataBuf->Des(); + aMessage.ReadL(KMsgSlot1,msgData); + + if(iUiLayout) + { + err = iUiLayout->HandleCommand(cmdId,(unsigned char*)msgData.Ptr()); + TPckg msg(err); + aMessage.WriteL(KMsgSlot2,msg); + } + + CleanupStack::PopAndDestroy(dataBuf); + } + else + { + err = KErrNotForegroundSession; + } + return err; + + } + +TInt CPeninputServer::CreateLayoutL(const RMessage2& aMessage ) +{ + //check initialization status + //if(!iAppGc) + // iAppGc = CCoeEnv::Static()->SwapSystemGc(iWindowGc); + + TInt id; + TPckg msg(id); + aMessage.Read(KMsgSlot0,msg); + TUid uid; + uid.iUid = id; + + + if(iLayoutId == uid && iUiLayout) + return KErrNone; + + iLayoutId = uid; + + //clear sprite before delete ui layout + iUILayoutReady = EFalse; + if(iUiLayout) + { + ClearSpriteGc(); + DeactivateSprite(); + iDestroyingLayout = ETrue; + iUiLayout->Destroy(); + iUiLayout = NULL; + iDestroyingLayout = EFalse; + if(iAnimObj) + { + iAnimObj->AddFlushSessionCmd(); + } + #ifdef RD_TACTILE_FEEDBACK + //remove all registered feedback area + const TInt KRemoveAllId = -1; + TTactileFeedbackArea area = {KRemoveAllId,TRect(0,0,0,0)}; + RemoveFeedbackArea(area); + #endif + } + if(aMessage.Function() == EPeninputRequestSetUiLayoutId) + { + TPeninputLayoutData layoutData = + { + iPtiEngine, + //iPenUiCtrl + iInternalBackgroundCtrl, + }; + //iUiLayout = iLayoutEng->GetUiLayout(iLayoutId,iLayoutOwner,iPtiEngine); + iUiLayout = iLayoutEng->GetUiLayout(iLayoutId,iLayoutOwner,&layoutData); + } + else + { + TInt len = aMessage.GetDesLength(KMsgSlot1); + HBufC8* dataBuf = HBufC8::NewLC(len); + TPtr8 msgData = dataBuf->Des(); + aMessage.ReadL(KMsgSlot1,msgData); + + iUiLayout=iLayoutEng->GetUiLayout(iLayoutId,iLayoutOwner,msgData.Ptr()); + CleanupStack::PopAndDestroy(dataBuf); + } + + if(!iUiLayout) + return KErrNoLayout; + + iSpriteMember.iInvertMask = EFalse; + TRect layoutRect; + //do we need transparency? + TBool bTransparency = iUiLayout->SemiTransparencyRequired(); + if(bTransparency) + { +#ifdef __ALPHA_TRANCEPARENCY__ + ChangeDisplayModeL(iDispMode,EGray256); +#else + ChangeDisplayModeL(iDispMode,EColor16MU); +#endif + } + else + { + ChangeDisplayModeL(iDispMode,EGray2); //use black-white mask + } + + layoutRect = iUiLayout->Init(); + + if( layoutRect.IsEmpty() ) + {//this is a temp solution for VKB, the layout size can not + //be determined at construct time + TPixelsTwipsAndRotation ptSize; + CCoeEnv::Static()->ScreenDevice()->GetDefaultScreenSizeAndRotation( ptSize ); + layoutRect = TRect( TPoint(), ptSize.iPixelSize ); + } + iUILayoutReady = ETrue; + // register feedback area + /*if(iSupportFeedback && iFeedbackAreaArray.Count()) + { + iAnimObj->AddRegisterFeedbackAreaCmd(iFeedbackAreaArray); + iFeedbackAreaArray.Reset(); }*/ + + //flush the command + if(iAnimObj) + { + iAnimObj->AddFlushSessionCmd(); + } + + TSize layoutSize = layoutRect.Size(); + + iSpriteSize = layoutSize; +/* iBitmapDevice->Resize( layoutSize); + iMaskBitmapDevice->Resize( layoutSize); + + //gc must be adjusted + iSpriteGc->Activate(iBitmapDevice); + iSpriteGc->Resized(); + */ + ResizeDrawingDevice(layoutSize); + if(iAnimObj) + { + iAnimObj->AddChangeSizeCmd(layoutSize); + } + + SetPosition(layoutRect.iTl); + if(iUiLayout->PenInputType() == EPluginInputModeItut || + iUiLayout->PenInputType() == EPluginInputModeFSQ || + iUiLayout->PenInputType() == EPluginInputModeFingerHwr ) + { + iOpaqueUi = ETrue; + iUseWindowCtrl = ETrue; + + if(iUseWindowCtrl) + { + iPenUiCtrl->SetExtent(layoutRect.iTl,layoutSize); + if(iAnimObj) + { + iAnimObj->AddEnalbeSpriteCmd(EFalse); + } + //must swap back when using window background + if(iAppGc) + { + CCoeEnv::Static()->SwapSystemGc(iAppGc); + } + } + else + { + if(iAnimObj) + { + iAnimObj->AddEnalbeSpriteCmd(ETrue); + } + + iAppGc = CCoeEnv::Static()->SwapSystemGc(iWindowGc); + + } + } + else + { + iOpaqueUi = EFalse; + if(iUseWindowCtrl && iAnimObj) //previous window control used + { + iUseWindowCtrl = EFalse; + iAnimObj->AddEnalbeSpriteCmd(ETrue); + } + } + + TInt type = iUiLayout->PenInputType(); + TPckg typeMsg(type); + + aMessage.WriteL(KMsgSlot2,typeMsg); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::SignalObserverL +// Signal oberver +// --------------------------------------------------------------------------- +// +void CPeninputServer::SignalObserverL(TInt aEventId,const TDesC& aEventData) + { + if(iForegroundSession) + iForegroundSession->SignalClientL(aEventId,aEventData); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::NewSessionL +// --------------------------------------------------------------------------- +// +CSession2* CPeninputServer::NewSessionL(const TVersion& aVersion, + const RMessage2& aMessage) const + { + // check we're the right version + TVersion v( KPeninputServerMajorVersionNumber, + KPeninputServerMinorVersionNumber, + KPeninputServerBuildVersionNumber ); + + if ( !User::QueryVersionSupported(v,aVersion) ) + { + User::Leave( KErrNotSupported ); + } + + // create new session + RThread client; + CleanupClosePushL(client); + CSession2* ret = 0; + + if(KErrNone == aMessage.Client(client)) + { + //create new one + ret = CPeninputServerSession::NewL(client, + const_cast(*this));\ + } + CleanupStack::PopAndDestroy(&client); + return ret; + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::RunError +// Handle an error from CPeninputServerSession::ServiceL() +// Reports the error to the client and completes the message +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::RunError( TInt aError ) + { + Message().Complete( aError ); + + // The leave will result in an early return from CServer::RunL(), skipping + // the call to request another message. So do that now in order to keep the + // server running. + ReStart(); + return KErrNone;// handled the error fully + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::ConstructSpriteAnimL +// --------------------------------------------------------------------------- +// +void CPeninputServer::ConstructSpriteL() + { + // create bitmaps for sprite + iSpriteMember.iBitmap = CreateBitmapL( iSpriteSize, iDispMode ); +#ifdef __ALPHA_TRANCEPARENCY__ + iSpriteMember.iMaskBitmap = CreateBitmapL( iSpriteSize, EGray256); + iDispModeForMask = EGray256; + +#else + iSpriteMember.iMaskBitmap = CreateBitmapL( iSpriteSize, iDispModeForMask); + iSpriteMember.iInvertMask = EFalse; +#endif + + // set spritemember attributes + iSpriteMember.iOffset.iX = 0; + iSpriteMember.iOffset.iY = 0; + iSpriteMember.iInterval = 0; + + iBitmapDevice = CFbsBitmapDevice::NewL(iSpriteMember.iBitmap); + iMaskBitmapDevice = CFbsBitmapDevice::NewL( + iSpriteMember.iMaskBitmap ); + iSpriteGc = CFbsBitGc::NewL(); + iSpriteGc->Reset(); + + CWsScreenDevice *screenDevice = CCoeEnv::Static()->ScreenDevice(); + iWindowGc = CWindowToBitmapMappingGc::NewL(*screenDevice,*iSpriteGc); + + /*iBitmapDevice->Resize( iSpriteSize); + iMaskBitmapDevice->Resize( iSpriteSize); */ + ResizeDrawingDevice(iSpriteSize); + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::CreateBitmapL +// --------------------------------------------------------------------------- +// +CFbsBitmap* CPeninputServer::CreateBitmapL( const TSize& aBitmapSize, + TDisplayMode aDisplayMode ) const + { + CFbsBitmap* const bitmap = new ( ELeave ) CFbsBitmap; + CleanupStack::PushL( bitmap ); + // bitmaps are automatically cleared to white when first created + User::LeaveIfError( bitmap->Create( aBitmapSize, aDisplayMode ) ); + CleanupStack::Pop(bitmap); + return bitmap; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::ChangeDisplayMode +// --------------------------------------------------------------------------- +// +void CPeninputServer::ChangeDisplayModeL(TDisplayMode aMode, + TDisplayMode aMaskMode) + { + if(aMode == iDispMode && aMaskMode == iDispModeForMask) + return; + + if(iDispMode != aMode) + { + //use initial size to create small one in the first + CFbsBitmap* bmp = CreateBitmapL( iSpriteSize, aMode ); + delete iSpriteMember.iBitmap; + iSpriteMember.iBitmap = bmp; + iDispMode = aMode; + delete iBitmapDevice; + iBitmapDevice = NULL; + iBitmapDevice = CFbsBitmapDevice::NewL(iSpriteMember.iBitmap); + } + + if(iDispModeForMask != aMaskMode) + { + CFbsBitmap* maskbmp = CreateBitmapL( iSpriteSize, aMaskMode); + delete iSpriteMember.iMaskBitmap; + iSpriteMember.iMaskBitmap = maskbmp; + delete iMaskBitmapDevice; + iMaskBitmapDevice = NULL; + iMaskBitmapDevice = CFbsBitmapDevice::NewL( + iSpriteMember.iMaskBitmap ); + iDispModeForMask = aMaskMode; + } + if(iAnimObj) + { + iAnimObj->AddChangeDispModeCmd(iSpriteMember); + } + } +// --------------------------------------------------------------------------- +// CPeninputServer::ClearSpriteGc +// Clears the bitmap - and mask bitmap devices. +// --------------------------------------------------------------------------- +// +void CPeninputServer::ClearSpriteGc() + { + //bitmap device + TPoint pt(0,0); + TRect rect(pt,iSpriteSize); + iSpriteGc->Activate( iBitmapDevice ); + iSpriteGc->SetBrushStyle( CGraphicsContext::ESolidBrush ); + iSpriteGc->SetBrushColor( KRgbWhite ); + iSpriteGc->Clear(rect); + + //mask bitmap device + iSpriteGc->Activate( iMaskBitmapDevice ); + iSpriteGc->SetBrushColor( KRgbBlack ); //transparent + iSpriteGc->SetBrushStyle( CGraphicsContext::ESolidBrush ); + iSpriteGc->Clear(rect); + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::DrawSprite +// Draw the sprite +// --------------------------------------------------------------------------- +// +void CPeninputServer::DrawSprite() + { + + if(!iUiLayout) + return; + ClearSpriteGc(); + + iUiLayout->Draw(); + + TRect r(TPoint(0,0),iSpriteSize); + + if(iUseWindowCtrl) + { + iPenUiCtrl->Invalidate(r,EFullUpdate); + return; + } + else + { + if(iAnimObj) + { + iAnimObj->AddUpdateUiCmd(r,EFullUpdate); + } + + //The best place for the timer should also in animation object. Can be refactored + //later + if(!iFlushTimer->IsActive()) + { + iFlushTimer->Start(KWsSessionFlushPerioid, KWsSessionFlushPerioid, + TCallBack(FlushTimerCallBack,this)); + } + iCurRectNumInBuf = 0; + } + return; + } + +//MLayoutOwner +// --------------------------------------------------------------------------- +// CPeninputServer::UpdateArea +// Update sprite rect +// --------------------------------------------------------------------------- +// +void CPeninputServer::UpdateArea(const TRect& aRect,TBool /*aFullUpdate*/, + TBool aImmedFlag) + { + if (!iActive) //only update when sprite is active + return; + + if(iUseWindowCtrl) + { + iPenUiCtrl->Invalidate(aRect,EFalse); + return; + } + + TRect rect; + if(aRect.IsEmpty()) + { + iSpriteGc->RectDrawnTo(rect); + } + else + rect = aRect; + + // if (iOpaqueUi) + // aFullUpdate = EFalse; //never does full update to screen. + + TUpdateArea area = + { + aRect,EFalse + }; + AddFlushArea(area); + if(aImmedFlag) + { + FlushTimerCallBack(this); + } + else + { + if(!iFlushTimer->IsActive()) + { + iFlushTimer->Start(KWsSessionFlushPerioid, KWsSessionFlushPerioid, + TCallBack(FlushTimerCallBack,this)); + } + } + } + +//from MLayuoutOwner + +// --------------------------------------------------------------------------- +// CPeninputServer::BitmapContext +// Get bitmap context +// --------------------------------------------------------------------------- +// +CBitmapContext* CPeninputServer::BitmapContext() + { + return iSpriteGc; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::BitmapDevice +// Get bitmap device +// --------------------------------------------------------------------------- +// +CFbsBitmapDevice* CPeninputServer::BitmapDevice() + { + return iBitmapDevice; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::MaskBmpDevice +// Get mask bitmap device +// --------------------------------------------------------------------------- +// +CFbsBitmapDevice* CPeninputServer::MaskBmpDevice() + { + return iMaskBitmapDevice; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::Hide +// Hide/show sprite +// --------------------------------------------------------------------------- +// +void CPeninputServer::Hide(TBool aHideFlag) + { + if(aHideFlag) + { + DeactivateSprite(); + } + else + { + ActivateSprite(); + } + } + +// --------------------------------------------------------------------------- +// CPeninputServer::LayoutSizeChanged +// Handle layout size change +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::LayoutSizeChanged(const TSize& aSize, TBool aNeedUpdate) + { + TInt ret = KErrNone; + if(iUiLayout) + { + //This is the tricky place. We need to deactivate and activate the sprite, + //otherwise blank area appears. + + TSize layoutSize = aSize; + TRect layoutRect = iUiLayout->Init(); + layoutSize = layoutRect.Size(); + + layoutSize.iWidth = layoutSize.iWidth > aSize.iWidth ? + layoutSize.iWidth : aSize.iWidth; + + layoutSize.iHeight = layoutSize.iHeight > aSize.iHeight ? + layoutSize.iHeight : aSize.iHeight; + + if(iSpriteSize != layoutSize) + { + //deactive sprite first + TBool bRestoreActive = iActive; + //DeactivateSprite(); + iSpriteSize = layoutSize; + //iBitmapDevice->Resize( layoutSize); + //iMaskBitmapDevice->Resize( layoutSize); + ResizeDrawingDevice(layoutSize); + if (aNeedUpdate) + { + FlushWsSession(); + } + if(iAnimObj) + { + iAnimObj->AddChangeSizeCmd(layoutSize); + } + + if(bRestoreActive ) + { + //ActivateSprite(); + } + } + + if (iUseWindowCtrl) + { + iPenUiCtrl->SetExtent(LayoutRect().iTl,layoutSize); + //DrawSprite(); + } + } + return ret; + } + +void CPeninputServer::DimPenUi() + { + if(iDimmed) + { + RecoverButtonEventState(); + DeactivateDimPenUiLayout(EFalse); + if(iUseWindowCtrl) + { + iPenUiCtrl->DimPenUiForMenu(); + } + } + else + { + ActivatePenUiLayout(EFalse); + } + } + +void CPeninputServer::DimPenInternalUi(TBool /*aFlag*/,TInt aPriority) + { + if(iDimmed) + { + RecoverButtonEventState(); + DeactivateDimPenUiLayout(EFalse); + + if(iUseWindowCtrl) + { + iPenUiCtrl->DimInternalPenUiForMenu(aPriority); + + } + } + else + { + ActivatePenUiLayout(EFalse); + } + } + +void CPeninputServer::DimPenUiForMenu(TInt aPriority) + { + if(iUseWindowCtrl) + { + iPenUiCtrl->DimPenUiForMenu(aPriority); + } + } +// --------------------------------------------------------------------------- +// CPeninputServer::SignalOwner +// Signal owner +// --------------------------------------------------------------------------- +// +void CPeninputServer::SignalOwner(TInt aEventType, const TDesC& aEventData) + { + //send fep related event to observer ( application) + if(ESignalFepEventBase <= aEventType) + { + TRAP_IGNORE(SignalObserverL(aEventType,aEventData)); + } + else + { + switch(aEventType) + { + case ESignalCapturePointer: //request capture pointer + { + TUint16* buf = const_cast( aEventData.Ptr() ); + TBool flag = *(TBool*)aEventData.Ptr(); + TInt captureID = *(TInt* )( buf + sizeof(TUint16)); + if(iAnimObj) + { + iAnimObj->AddCapturePointerCmd(flag, captureID); + } + } + break; + + case ESignalSimulateEvent: //request simulate event + { + //TBool* flag = (TBool*)aEventData.Ptr(); + const TRawEvent* event = reinterpret_cast(aEventData.Ptr()); + TRawEvent* modifyEvent = const_cast( event ); + modifyEvent->SetTip( ETrue ); + if(iAnimObj) + { + iAnimObj->AddSimulateEventCmd(*event); + } + if( event->Type() == TRawEvent::EKeyDown ) + { + static_cast(CEikonEnv::Static()->EikAppUi())-> + DisableNextKeySound( event->ScanCode() ); + } + iLastSimulatedKeyEvent = *event; + } + break; + case ESignalImmeSimulateEvent: + { + const TRawEvent* event = reinterpret_cast( aEventData.Ptr() ); + TRawEvent* modifyEvent = const_cast( event ); + modifyEvent->SetTip( ETrue ); + if(iAnimObj) + { + iAnimObj->ExecuteSimulateEventCmd(*event); + } + + if( event->Type() == TRawEvent::EKeyDown ) + { + static_cast(CEikonEnv::Static()->EikAppUi())-> + DisableNextKeySound( event->ScanCode() ); + } + iLastSimulatedKeyEvent = *event; + } + break; +#ifdef RD_TACTILE_FEEDBACK + case ESignalRegisterFeedbackArea: + { + if(!iSupportFeedback) + return; + AddFeedbackArea(FeedbackData(aEventData)); + } + break; + case ESignalDeRegisterFeedbackArea: + { + if(!iSupportFeedback) + return; + + RemoveFeedbackArea(FeedbackData(aEventData)); + } + break; + case ESignalChangeFeedbackArea: + { + if(!iSupportFeedback) + return; + + ChangeFeedbackArea(FeedbackData(aEventData)); + } + break; + case ESignalChangeFeedbackType: + { + if(!iSupportFeedback) + return; + + ChangeFeedbackType(FeedbackData(aEventData)); + } + break; + +#endif // RD_TACTILE_FEEDBACK + case ESignalGetAllowedInputMode: + { + TInt disabled = 0; + if ( iForegroundSession ) + { + //GetProcessLayouts( iForegroundSession->ClientProcessId(),disabled ); + disabled = iForegroundSession->DisabledUiType() | DisabledByOrientation(); + + if( iForegroundSession->DsaEverHappened() ) + { + disabled |= DisabledByDSAFromAnim(); + } + } + TInt allowed = SetDisabledLayouts( disabled ); + TUint16* buf = const_cast( aEventData.Ptr() ); + TInt* retVal = reinterpret_cast< TInt* > ( buf ); + *retVal = allowed; + } + break; + + case ESignalPopupWnd: + { + if(iUseWindowCtrl) + { + TUint16* buf = const_cast( aEventData.Ptr() ); + TRect* rects = reinterpret_cast( buf ); + TRect rectInLayout = *rects; + TRect rectTrimLayout = *(rects+1); + TRect rectInScreen = rectInLayout; + rectInScreen.Move( iSpritePosition ); + + iPenUiCtrl->ShowPopup( rectInScreen, rectInLayout, rectTrimLayout ); + } + } + break; + + case ESignalPopupWndClosed: + { + if(iUseWindowCtrl) + { + iPenUiCtrl->ClosePopup(); + } + } + break; + default: + break; + } + } + + } + +// --------------------------------------------------------------------------- +// CPeninputServer::LayoutRect +// Get sprite size and position +// --------------------------------------------------------------------------- +// +TRect CPeninputServer::LayoutRect() + { + return TRect(iSpritePosition,iSpriteSize); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::SetPosition +// called when sprite has been moved +// --------------------------------------------------------------------------- +// + +TPoint CPeninputServer::SetPosition(const TPoint& aNewPos) + { + if(iSpritePosition != aNewPos) + { + iSpritePosition = aNewPos; + + if(iUseWindowCtrl) + iPenUiCtrl->SetPosition(aNewPos); + + if(iAnimObj) + { + iAnimObj->AddSetPosCmd(iSpritePosition); + } + } + return iSpritePosition; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::FlushTimerCallBack +// CPeriodic callback function: Flush window session +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::FlushTimerCallBack(TAny *aPtr) + { + CPeninputServer* self = static_cast(aPtr); + + self->FlushWsSession(); + + return EFalse; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::FlushWsSession +// Flush window session +// --------------------------------------------------------------------------- +// +void CPeninputServer::FlushWsSession() + { + if (iCurRectNumInBuf) + { + if(iAnimObj) + { + iAnimObj->AddUpdateUiCmd(iFlushArea,iCurRectNumInBuf); + } + + iCurRectNumInBuf = 0; + { + iFullUpdate = EFalse; + //cancel the timer + iFlushTimer->Cancel(); + } + } + } + +// --------------------------------------------------------------------------- +// CPeninputServer::DoIdleConstructL +// Do idle construction. +// --------------------------------------------------------------------------- +// +void CPeninputServer::DoIdleConstructL() + { + if(!iPtiEngine) + { + iPtiEngine = CPtiEngine::NewL(ETrue); + } + + if(!iLayoutEng) + { + iLayoutEng = CFepLayoutEngine::NewL(iPtiEngine); + } + + //this will only do once + } + +// --------------------------------------------------------------------------- +// CPeninputServer::HandleResourceChange +// Handle application resource change +// --------------------------------------------------------------------------- +// +void CPeninputServer::HandleResourceChange(TInt aType) + { + if(iUiLayout && !(iUiLayout->PenInputType() & DisabledByOrientation()) ) + { + //hide the layout if it's already shown + + iUiLayout->OnResourceChange(aType); + //show the layout if it's active + } + } + +// --------------------------------------------------------------------------- +// CPeninputServer::GetImePluginIdListL +// Get IME plugin implementation id list +// --------------------------------------------------------------------------- +// +void CPeninputServer::GetImePluginIdListL(const RMessage2& aMessage) + { + TInt language = aMessage.Int0(); + TInt mode = aMessage.Int1(); + TInt maxlen = aMessage.Int2(); + + const RArray& implList = iLayoutEng->ImePluginListL(language, mode); + // +1 means there is extra position for count + TInt count = implList.Count() > (maxlen/sizeof(TInt) - 1)? + (maxlen/sizeof(TInt) - 1): implList.Count(); + + HBufC8* buf = HBufC8::NewLC((count + 1)*sizeof(TInt)); + TPtr8 bufPtr = buf->Des(); + RDesWriteStream writeStream; + writeStream.Open(bufPtr); + CleanupClosePushL(writeStream); + writeStream.WriteInt32L(count); + for(TInt ii = 0; ii < count; ++ii) + { + writeStream.WriteInt32L(implList[ii]); + } + writeStream.CommitL(); + + aMessage.WriteL(KMsgSlot3, *buf); + + CleanupStack::PopAndDestroy(&writeStream); + CleanupStack::PopAndDestroy(buf); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::GetPenSupportLanguagesL +// Get touch input support language lists +// --------------------------------------------------------------------------- +// +void CPeninputServer::GetPenSupportLanguagesL(const RMessage2& aMessage) + { + TInt maxlen = aMessage.Int0(); + + const RArray& implList = iLayoutEng->TouchSupportLanguagesL(); + // +1 means there is extra position for count + TInt count = implList.Count() > (maxlen/sizeof(TInt) - 1)? + (maxlen/sizeof(TInt) - 1): implList.Count(); + + HBufC8* buf = HBufC8::NewLC((count + 1)*sizeof(TInt)); + TPtr8 bufPtr = buf->Des(); + RDesWriteStream writeStream; + writeStream.Open(bufPtr); + CleanupClosePushL(writeStream); + writeStream.WriteInt32L(count); + for(TInt ii = 0; ii < count; ++ii) + { + writeStream.WriteInt32L(implList[ii]); + } + + writeStream.CommitL(); + aMessage.WriteL(KMsgSlot1, *buf); + CleanupStack::PopAndDestroy(&writeStream); + CleanupStack::PopAndDestroy(buf); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::PropertyChangeCallBack +// Handle proproty change +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::PropertyChangeCallBack(TAny* aData) + { + TRAP_IGNORE(static_cast(aData)->HideLayoutTemporaryL()); + return 0; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::HideLayoutTemporary +// Temporarily hide the layout +// --------------------------------------------------------------------------- +// +void CPeninputServer::HideLayoutTemporaryL() + { +/* if (iUseWindowCtrl) + { + if (iActive && iUiLayout && + iUiLayout->PenInputType() == EPluginInputModeItut) + { + iUiLayout->HandleCommand(ECmdPenInputRotation, NULL); + ClearSpriteGc(); + iPenUiCtrl->ClosePenUi(ETrue); + iActive = EFalse; + } + return; + } +*/ if(iActive && !iPrevActive && + iUiLayout->PenInputType() != EPluginInputModeFSQ && + iBackgroudDefaultOri == CAknAppUiBase::EAppUiOrientationUnspecified ) + { + + iPrevActive = ETrue; + ClearSpriteGc(); + //Close the UI immediately, without notify UI handler + DeactivateSprite(ETrue, ETrue); + } + } + +// --------------------------------------------------------------------------- +// CPeninputServer::SetDisabledLayouts +// Temporarily hide the layout +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::SetDisabledLayouts( TInt aDisabledLayouts ) + { + // No spcified logic now, so just store the disabled layout in the CFepUiLayoutBase class. + TInt allowedPlugin = EPluginInputModeNone;// EPluginInputModeHwr | EPluginInputModeVkb | EPluginInputModeItut | EPluginInputModeFSc; + TInt curLanguage = iInputLanguage; + + if (curLanguage == 401) curLanguage = 102; + if (curLanguage == 402) curLanguage = 103; + + + TInt testMode = EPluginInputModeHwr; + while ( testMode < EPluginInputModeAll ) + { + if ( iLayoutEng->IsSupportPluginMode( ( TLanguage )curLanguage, + ( TPluginInputMode )testMode ) + && !( aDisabledLayouts & testMode ) ) + { + allowedPlugin |= testMode; + } + testMode<<=1; + } + return allowedPlugin; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::GetProcessLayouts +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::GetProcessLayouts( const TProcessId& aProcessId, TInt& aLayouts ) + { + for ( int i = 0 ; i < iClientProcess.Count() ; i ++ ) + { + if ( aProcessId == iClientProcess[i] ) + { + aLayouts = iClientLayouts[i]; + return KErrNone; + } + } + return KErrNotFound; + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::SetProcessLayouts +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::SetProcessLayouts( const TProcessId& aProcessId, TInt aLayouts) + { + + for ( int i = 0 ; i < iClientProcess.Count() ; i ++ ) + { + if ( aProcessId == iClientProcess[i] ) + { + iClientLayouts[i] = aLayouts; + return KErrNone; + } + } + // not found, Insert + iClientProcess.Append( aProcessId ); + iClientLayouts.Append( aLayouts ); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::DelProcessLayouts +// --------------------------------------------------------------------------- +// +void CPeninputServer::DelProcessLayouts( const TProcessId& /*aProcessId*/ ) + { + } + +void CPeninputServer::ExecutePendingAnimCmd() + { + if( iAnimObj ) + { + iAnimObj->ExeOnePendingAnimCmd(); + } + } + +void CPeninputServer::SetForeGroundUiHandlerL() + { + if(iForegroundUiHandler) + { + iForegroundUiHandler->ProcessPendingEventBeforeExit(); + iForegroundUiHandler = NULL; + } + + TBool bContinue = ETrue; + for(TInt i = iUiHandlerArray.Count()-1 ; i >= 0 && bContinue; i--) + { + if( (iForegroundSession == iUiHandlerArray[i]) // same session + || (iForegroundSession->ClientId() == iUiHandlerArray[i]->ClientId())) //same thread + { + iForegroundUiHandler = iUiHandlerArray[i]; + bContinue = EFalse; //found, break the loop + } + else + { + //check whether it's from same process + bContinue = !IsSameProcess(iForegroundSession,iUiHandlerArray[i]); + } + } + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::HandleRawEventL +// Handle event from event queue, i.e, from animation dll +// --------------------------------------------------------------------------- +// +void CPeninputServer::HandleRawEventL(const TRawEvent& aEvent) + { + if(iActive) + { + if( aEvent.Type() == TRawEvent::ENone && + aEvent.IsTip() && + iCrpService->IsDsaActive() ) + { + SignalOwner( ESignalLayoutClosed, KNullDesC ); + } + + TBool handled = iUiLayout->HandleEventL(ERawEvent,&aEvent); + + if (TRawEvent::EButton1Down == aEvent.Type()) + { + iLastRawEvent = aEvent; + } + else if (TRawEvent::EPointerMove != aEvent.Type()) + { + iLastRawEvent.Set(TRawEvent::EButton1Up); + } + + if(aEvent.Type() == TRawEvent::EKeyDown || + aEvent.Type() == TRawEvent::EKeyUp) + { + //write response to response queue + iKeyMsgResponseQueue.Send(handled); + //signal the semaphore + iKeyEventSemaphore.Signal(); + + } + } + } + + +// --------------------------------------------------------------------------- +// CPeninputServer::HandleRawEventL +// Handle event from window server +// --------------------------------------------------------------------------- +// +void CPeninputServer::HandleWsEventL(const TWsEvent &aEvent, + CCoeControl* /*aDestination*/) + { + switch(aEvent.Type()) + { + case EEventWindowGroupListChanged: + { + iCurScreenFocusedWndGrpId = GetFocusAppUid().iUid; + } + break; + case EEventFocusGroupChanged: + { + TUid focusApp = GetFocusAppUid(); + if(IsGlobalNotesApp(focusApp)) + { + iInGlobalNotesApp = ETrue; + } + else + { + iInGlobalNotesApp = EFalse; + } + if(!(iUiLayout && iActive )) + return; + + if(iUseWindowCtrl) + { +/* //Switch to akncapserver or leave + if(iUiLayout->PenInputType() == EPluginInputModeItut || + iUiLayout->PenInputType() == EPluginInputModeFSQ ) + { + DeactivatePenUiLayout(EFalse); + iPenUiCtrl->DimPenUiForMenu(); + break; + } + */ + if(IsGlobalNotesApp(focusApp)) + { + iInGlobalNotesState = ETrue; + break; + } + +/* else if (focusApp.iUid == 0x102750f0) + { + DeactivateSprite(); + } +*/ else + { + if(iInGlobalNotesState) + { + //fix for fast swap case + iInGlobalNotesState = EFalse; + if(iPreNonGloebalNotesWndGrpId != focusApp.iUid) + { + iPreNonGloebalNotesWndGrpId = focusApp.iUid; + + DeactivateSprite(ETrue);//hide pen ui immediately if switched to another application + iForegroundSession = NULL; + } + } + else + { + DeactivateSprite(ETrue); + } + } + break; + } + DeactivateSprite(ETrue);//hide pen ui immediately + } + break; + default: + break; + } + + } + +#ifdef RD_TACTILE_FEEDBACK +// --------------------------------------------------------------------------- +// CPeninputServer::AddFeedbackArea +// add the feedback area +// --------------------------------------------------------------------------- +// +void CPeninputServer::AddFeedbackArea(const TTactileFeedbackArea& aAreaData) + { + if( iDestroyingLayout || !iAnimObj ) + { + return; + } + iAnimObj->AddRegisterFeedbackAreaCmd(aAreaData,iUILayoutReady); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::RemoveFeedbackArea +// remove the feedback area +// --------------------------------------------------------------------------- +// +void CPeninputServer::RemoveFeedbackArea(const TTactileFeedbackArea& aAreaData) + { + if( iDestroyingLayout || !iAnimObj ) + { + return; + } + iAnimObj->AddDeRegisterFeedbackAreaCmd(aAreaData,iUILayoutReady); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::ChangeFeedbackArea +// change the feedback area +// --------------------------------------------------------------------------- +// +void CPeninputServer::ChangeFeedbackArea(const TTactileFeedbackArea& aAreaData) + { + if( iDestroyingLayout || !iAnimObj ) + { + return; + } + iAnimObj->AddChangeFeedbackAreaCmd(aAreaData,iUILayoutReady); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::ChangeFeedbackType +// change the feedback type +// --------------------------------------------------------------------------- +// +void CPeninputServer::ChangeFeedbackType(const TTactileFeedbackArea& aAreaData) + { + if( iDestroyingLayout || !iAnimObj) + { + return; + } + iAnimObj->AddChangeFeedbackTypeCmd(aAreaData,iUILayoutReady); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::FindFeedbackArea +// Find the feedback area +// --------------------------------------------------------------------------- +// +TInt CPeninputServer::FindFeedbackArea(const TTactileFeedbackArea& aArea) + { + for(TInt i = 0; i < iFeedbackAreaArray.Count(); ++i) + { + TTactileFeedbackArea temp = iFeedbackAreaArray[i]; + if(iFeedbackAreaArray[i].iId == aArea.iId) + return i; + } + return KErrNotFound; + } + +#endif // RD_TACTILE_FEEDBACK + +// --------------------------------------------------------------------------- +// CPeninputServer::AnimOpNeedWaiting +// Check command for this type of event whether needs waiting. +// --------------------------------------------------------------------------- +// +TBool CPeninputServer::AnimOpNeedWaiting(TInt aSignalCode) + { + TBool bNeedWait = EFalse; + if(ESignalPenUiDeActivated == aSignalCode) + { + return EFalse; + } + if(iForegroundUiHandler) + { + TInt uiType = iUiLayout->PenInputType(); + bNeedWait = iForegroundUiHandler->SignalUiActivationObserver( + aSignalCode,uiType); + } + return bNeedWait; + } + +// --------------------------------------------------------------------------- +// CPeninputServer::RecoverSimulatedKeyEventState +// --------------------------------------------------------------------------- +// +void CPeninputServer::RecoverSimulatedKeyEventState() + { + if(!iAnimObj) + { + return; + } + + if(iLastSimulatedKeyEvent.Type() == TRawEvent::EKeyDown) + { + //key up event is missing, we must manually simulate the up event. + iLastSimulatedKeyEvent.Set(TRawEvent::EKeyUp,iLastSimulatedKeyEvent.ScanCode()); + iAnimObj->AddSimulateEventCmd(iLastSimulatedKeyEvent); + } + } + +void CPeninputServer::RecoverButtonEventState() + { + if (TRawEvent::EButton1Down == iLastRawEvent.Type()) + { + iLastRawEvent.Set(TRawEvent::EButton1Up);//,iLastSimulatedKeyEvent.ScanCode() + TRAP_IGNORE( iUiLayout->HandleEventL(ERawEvent,&iLastRawEvent) ); + } + } + +void CPeninputServer::EnsureUpdateBuffer() + { + if(!iAnimObj) + { + return; + } + + if(iCurRectNumInBuf >= KMaxRectNumInBuf-1) + { + //flush previous buffer + iAnimObj->AddUpdateUiCmd(iFlushArea,iCurRectNumInBuf); + iCurRectNumInBuf = 0; + } + } + +inline TBool ContainsEachOther(const TRect aRt1, const TRect aRt2 ) + { + TRect rt(aRt1); + rt.BoundingRect( aRt2 ); + return rt == aRt1 || rt == aRt2; + } + +void CPeninputServer::PackFlushArea() + { + for( TInt i = iCurRectNumInBuf - 1; i > 0; i-- ) + { + for( TInt j = i -1; j >=0; j-- ) + { + if( ContainsEachOther(iFlushArea[i].iRect, iFlushArea[j].iRect) ) + { + iFlushArea[j].iRect.BoundingRect(iFlushArea[i].iRect); + iCurRectNumInBuf--; + } + } + } + } + +void CPeninputServer::AddFlushArea(const TUpdateArea& aArea) + { + for(TInt i = 0 ; i < iCurRectNumInBuf; ++i) + { + if(iFlushArea[i].iRect == aArea.iRect) + { + iFlushArea[i].iFullUpdateFlag |= aArea.iFullUpdateFlag; + return; + } + else if( iFlushArea[i].iFullUpdateFlag == aArea.iFullUpdateFlag ) + { + TRect rt(aArea.iRect); + rt.BoundingRect(iFlushArea[i].iRect); + if( rt == iFlushArea[i].iRect || rt == aArea.iRect ) + { + iFlushArea[i].iRect = rt; + //PackFlushArea(); + return; + } + } + } + //Ensure buffer can hold new data + EnsureUpdateBuffer(); + iFlushArea[iCurRectNumInBuf++] = aArea; + } +void CPeninputServer::PrepareExit() + { + CleanAll(); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::MonitorWsGroupEvent +// Request to enable or disable window group change event +// --------------------------------------------------------------------------- +// +void CPeninputServer::MonitorWsGroupEvent(TBool aMonitorFlag) + { + RWindowGroup& rootWin = CCoeEnv::Static()->RootWin(); + if(aMonitorFlag) + { + rootWin.EnableFocusChangeEvents (); // For cover UI/status pane refresh problems + //rootWin.EnableGroupListChangeEvents(); + } + else + { + rootWin.DisableFocusChangeEvents (); // For cover UI/status pane refresh problems + //rootWin.DisableGroupListChangeEvents(); + } + } + +void CPeninputServer::CheckSessionValidL(CPeninputServerSession* aSession1, + CPeninputServerSession* aSession2) const + { + __ASSERT_DEBUG(aSession1 && aSession2, User::Leave(ENullSession)); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::IsSameProcess +// Tests whether two sessions from same process +// --------------------------------------------------------------------------- +// +inline TBool CPeninputServer::IsSameProcess(CPeninputServerSession* aSession1, + CPeninputServerSession* aSession2) const + { + TRAP_IGNORE(CheckSessionValidL(aSession1, aSession2)); + return aSession1->ClientProcessId().Id() == aSession2->ClientProcessId().Id(); + } +// --------------------------------------------------------------------------- +// CPeninputServer::IsForegroundSession +// Tests whether current session is the foreground session. +// --------------------------------------------------------------------------- +// +inline TBool CPeninputServer::IsForegroundSession(CPeninputServerSession* aSession) const + { + if(!iForegroundSession) + return EFalse; + + if(iForegroundSession == aSession) + return ETrue; + + //same thread? + if(iForegroundSession->ClientId() == aSession->ClientId()) + return ETrue; + + //check whether the session is from the same process of foreground session + return IsSameProcess(iForegroundSession,aSession); + } + +// --------------------------------------------------------------------------- +// CPeninputServer::ResizeDrawingDevice +// Resize the drawing device +// --------------------------------------------------------------------------- +// +void CPeninputServer::ResizeDrawingDevice(const TSize& aSize) + { + iSpriteMember.iBitmap->Resize(aSize); + iSpriteMember.iMaskBitmap->Resize(aSize); + + iBitmapDevice->Resize( aSize); + iMaskBitmapDevice->Resize( aSize); + + //gc must be adjusted + iSpriteGc->Activate(iBitmapDevice); + iSpriteGc->Resized(); + } + +TInt CPeninputServer::HandleAppInfoChange(CPeninputServerSession* aSession, + const TDesC& aAppInfo, TPeninputAppInfo aType) const + { + if(!iUiLayout) + return KErrNoLayout; + + TInt err = KErrNone; + if(IsForegroundSession(aSession)) + { + iUiLayout->HandleAppInfoChange(aAppInfo,aType); + } + else + { + err = KErrNotForegroundSession; + } + return err; + } + +void CPeninputServer::BackgroudDefaultOri( TInt aOri) + { + iBackgroudDefaultOri = aOri; + } + + +TInt CPeninputServer::DisabledByDSA() + { + TInt disabled = 0; + TBool dsaOn = iCrpService->IsDsaActive(); + //iAnimObj->GetDSAState(dsaOn); + if(dsaOn) + { + disabled = EPluginInputModeVkb | EPluginInputModeHwr | EPluginInputModeFSc; + } + return disabled; + } + +TInt CPeninputServer::DisabledByDSAFromAnim() + { + TInt disabled = 0; + TBool dsaOn = EFalse; + if(!iAnimObj) + { + return disabled; + } + + iAnimObj->GetDSAState(dsaOn); + if(dsaOn) + { + disabled = EPluginInputModeVkb | EPluginInputModeHwr | EPluginInputModeFSc; + } + return disabled; + } +TInt CPeninputServer::DisabledByOrientation() + { + TInt disabled = 0; + TBool sensorOn = EFalse; + if ( iSensorRepository ) + { + iSensorRepository->Get( KSenSettingsSensorsOn, sensorOn ); + if ( sensorOn ) + { + TInt turnCtrl = 0; + iSensorRepository->Get( KSenSettingsTurnCtrl, turnCtrl ); + turnCtrl = turnCtrl >> 2; + + if ( turnCtrl ) + { + TPixelsTwipsAndRotation size; + CCoeEnv::Static()->ScreenDevice()->GetDefaultScreenSizeAndRotation(size); + + if( size.iPixelSize.iWidth < size.iPixelSize.iHeight ) + { + return disabled |= EPluginInputModeFSQ; + } + if( size.iPixelSize.iWidth > size.iPixelSize.iHeight ) + { + return disabled |= EPluginInputModeItut; + } + } + } + } + return disabled; + } + +TInt CPeninputServer::GetSupportModeL() + { + TInt curLanguage = iInputLanguage; + + if (curLanguage == 401) curLanguage = 102; + if (curLanguage == 402) curLanguage = 103; + + + TInt supportMode = EPluginInputModeNone; + TInt tempMode = EPluginInputModeHwr; + + iLayoutEng->InitializeL(); + + while ( tempMode < EPluginInputModeAll ) + { + if ( iLayoutEng->IsSupportPluginMode( ( TLanguage )curLanguage, + ( TPluginInputMode )tempMode ) ) + { + supportMode |= tempMode; + } + tempMode<<=1; + } + return supportMode; + } + +// ======== class CEventQueue======== +// +// --------------------------------------------------------------------------- +// CEventQueue::CEventQueue +// Constructor. Adds the active object to the active scheduler +// and issues a request for server notification. +// --------------------------------------------------------------------------- +// + +CEventQueue::CEventQueue(MRawEventHandler* aHandler):CActive( EPriorityHigh ), + iHandler(aHandler) + { + // issue asynchronous request and set this object active + CActiveScheduler::Add( this ); + } + +// --------------------------------------------------------------------------- +// CEventQueue::NewL +// factory constructor. +// --------------------------------------------------------------------------- +// +CEventQueue* CEventQueue::NewL(MRawEventHandler* aHandler,const TDesC& aName) + { + CEventQueue* queue = new(ELeave)CEventQueue(aHandler); + CleanupStack::PushL(queue); + queue->ConstructL(aName); + CleanupStack::Pop(queue); + return queue; + } + +// --------------------------------------------------------------------------- +// CEventQueue::ConstructL +// 2nd phase constructor +// --------------------------------------------------------------------------- +// +void CEventQueue::ConstructL(const TDesC& aName) + { + //create message queue + User::LeaveIfError(iMsgBufQueue.CreateGlobal(aName,KMsgQueueLen)); + } +// --------------------------------------------------------------------------- +// CEventQueue::CEventQueue +// Destructor. Cancels any outstanding requests +// --------------------------------------------------------------------------- +// +CEventQueue::~CEventQueue() + { + Cancel(); + iMsgBufQueue.Close(); + } + +// --------------------------------------------------------------------------- +// CEventQueue::DoCancel +// Cancels the notification requests +// --------------------------------------------------------------------------- +// +void CEventQueue::DoCancel() + { + iMsgBufQueue.CancelDataAvailable(); + } + + +// --------------------------------------------------------------------------- +// CEventQueue::RunL +// --------------------------------------------------------------------------- +// +void CEventQueue::RunL() + { + //iHandler is always there. No need to check it + TRawEventBuffer events; + iMsgBufQueue.Receive(events); + for(TInt i = 0; i < events.iNum; i++) + { + iHandler->HandleRawEventL(events.iEvent[i]); + } + // re-issue request + GetEvent(); + } + +// --------------------------------------------------------------------------- +// CEventQueue::RunError +// --------------------------------------------------------------------------- +// +TInt CEventQueue::RunError(TInt /*aError*/) + { + // re-issue request + GetEvent(); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CEventQueue::GetEvent +// Reissue request for event +// --------------------------------------------------------------------------- +// +void CEventQueue::GetEvent() + { + if(IsActive()) + return; + iMsgBufQueue.NotifyDataAvailable(iStatus); + SetActive(); + } + + +// ======== class CAknLayoutChangeWatcher======== +// + +// --------------------------------------------------------------------------- +// CAknLayoutChangeWatcher::NewL +// Factory constructor. +// --------------------------------------------------------------------------- +// +CAknLayoutChangeWatcher* CAknLayoutChangeWatcher::NewL( + CPeninputServer* aHandler,TUint aKey) + { + CAknLayoutChangeWatcher* self = new(ELeave)CAknLayoutChangeWatcher( + aHandler,aKey); + CActiveScheduler::Add(self); + return self; + } + +// --------------------------------------------------------------------------- +// CAknLayoutChangeWatcher::~CAknLayoutChangeWatcher +// Destructor +// --------------------------------------------------------------------------- +// +CAknLayoutChangeWatcher::~CAknLayoutChangeWatcher() + { + Cancel(); + } + +// --------------------------------------------------------------------------- +// CAknLayoutChangeWatcher::CAknLayoutChangeWatcher +// Default constructor +// --------------------------------------------------------------------------- +// +CAknLayoutChangeWatcher::CAknLayoutChangeWatcher(CPeninputServer* aHandler, + TUint aKey) + : CActive( EPriorityHigh ),iHandler(aHandler) + { + iProperty.Attach(KPSUidUikon,aKey); + iLayoutState = KInvalidValue; + iOrientationState = KInvalidValue; + } + +// --------------------------------------------------------------------------- +// CAknLayoutChangeWatcher::StartWatching +// Start to monitor +// --------------------------------------------------------------------------- +// +void CAknLayoutChangeWatcher::StartWatching() + { + iProperty.Subscribe(iStatus); + SetActive(); + } + +// --------------------------------------------------------------------------- +// CAknLayoutChangeWatcher::DoCancel +// Cancels the notification requests +// --------------------------------------------------------------------------- +// +void CAknLayoutChangeWatcher::DoCancel() + { + iProperty.Cancel(); + } + + +// --------------------------------------------------------------------------- +// CAknLayoutChangeWatcher::RunL +// --------------------------------------------------------------------------- +// +void CAknLayoutChangeWatcher::RunL() + { + TInt layoutstate = KInvalidValue; + TInt orientstate = KInvalidValue; + iProperty.Get(KPSUidUikon, KUikLayoutState, layoutstate); + iProperty.Get(KPSUidUikon, KUikPreferredOrientation, orientstate); + if(layoutstate != iLayoutState || orientstate != iOrientationState) + { + // save the previous state + iLayoutState = layoutstate; + iOrientationState = orientstate; + + // hide layout when monitered object change state + iHandler->HideLayoutTemporaryL(); + } + StartWatching(); + } + +// --------------------------------------------------------------------------- +// CEventQueue::RunError +// --------------------------------------------------------------------------- +// +TInt CAknLayoutChangeWatcher::RunError(TInt /*aError*/) + { + // re-issue request + StartWatching(); + return KErrNone; + } + +// ======== GLOBAL FUNCTIONS ======== +// --------------------------------------------------------- +// PanicServer +// --------------------------------------------------------- +// +GLDEF_C void PanicServer(TPeninputServerPanic aPanic) + { + User::Panic( KPeninputServerName, aPanic ); + } +// End of File +