MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/windowing/windowserver/nga/SERVER/EVENT.H
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 // Copyright (c) 1999-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Definition of classes related event handling

    15 // 

    16 //

    17 

    18 

    19 #ifndef __EVENT_H__

    20 #define __EVENT_H__

    21 

    22 #include "EVQUEUE.H"

    23 #include <e32std.h>

    24 #include <e32base.h>

    25 #include <e32svr.h>

    26 #include "W32STD.H"

    27 #include "w32cmd.h"

    28 #include "EVQUEUE.H"

    29 #include <w32adll.h>

    30 #include "graphics/WSGRAPHICDRAWER.H"

    31 #include <graphics/wskeyrouter.h>

    32 

    33 class CWsClient;

    34 class CWsWindowBase;

    35 class CWsWindowGroup;

    36 class MEventHandler;

    37 class CWsHotKey;

    38 class CWsCaptureLongKey;

    39 class CScreen;

    40 class DWsScreenDevice;

    41 

    42 const TInt KRetryInitialDelay = 100000; //0.01 second

    43 

    44 struct TEventRequestItem

    45 	{

    46 	const CWsWindowBase *iWindow;

    47 	TInt iParam;

    48 	TEventControl iCircumstances;

    49 	TSglQueLink iQue;

    50 	};

    51 

    52 class TEventRequestQueue

    53 	{

    54 public:

    55 	TEventRequestQueue();

    56 	TEventRequestItem *FindInEventRequestQueueList(const CWsWindowBase &aWindow);

    57 	void AddToEventRequestListL(const CWsWindowBase &aWindow, TInt aParam, TEventControl aCircumstances);

    58 	void RemoveFromEventRequestListL(const CWsWindowBase &aWindow);

    59 	inline TSglQue<TEventRequestItem> &Queue();

    60 private:

    61 	TSglQue<TEventRequestItem> iQueue;

    62 	};

    63 

    64 class CRawEventReceiver : public CActive

    65 	{

    66 public:

    67 	CRawEventReceiver(TInt aPriority);

    68 	~CRawEventReceiver();

    69 	void ConstructL();

    70 	inline TBool IsReadyToRun() const {return IsActive() && iStatus!=KRequestPending;}

    71 protected:

    72 	void Request();

    73 	void DoCancel();

    74 	void RunL();

    75 private:

    76 	TRawEventBuf iEventBuf;

    77 	};

    78 

    79 class TRepeatKey

    80 	{

    81 public:

    82 	TKeyEventRouterOutput iOutput;

    83 	TInt iInputScanCode;

    84 	};

    85 

    86 class CKeyboardRepeat : public CTimer

    87 	{

    88 public:

    89 	CKeyboardRepeat();

    90 	static void NewL();

    91 	static void Destroy();

    92 	static void KeyDown();

    93 	static void KeyUp(TInt aScanCode);

    94 	static void StartRepeat(TInt aInputScanCode, const TKeyEventRouterOutput& aShortEvent, const TKeyEventRouterOutput* aLongEvent);

    95 	static void CancelRepeat(CWsWindowGroup *aRepeatFocus);

    96 	static void CancelRepeat(const TAny* aCaptureHandle, TBool aLongCaptureFlag);

    97 	static void SetRepeatTime(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime);

    98 	static void GetRepeatTime(TTimeIntervalMicroSeconds32 &aInitialTime, TTimeIntervalMicroSeconds32 &aTime);

    99 	static inline TBool IsAreadyActive();

   100 private:

   101 	enum TRepeatType

   102 		{

   103 		ERepeatNone,

   104 		ERepeatNormal,

   105 		ERepeatLong,

   106 		ERepeatLongRepeated,

   107 		};

   108 private:

   109 	static void doCancelRepeat();

   110 	void RunL();

   111 private:

   112 	static CKeyboardRepeat *iThis; // Needed as CTimer derived parts can't be static

   113 	static TTimeIntervalMicroSeconds32 iInitialTime;

   114 	static TTimeIntervalMicroSeconds32 iTime;

   115 	static TRepeatType iRepeating;

   116 	static TRepeatKey iCurrentRepeat;

   117 	static TRepeatKey iAlternateRepeat;

   118 	static TRepeatKey iLongRepeat;

   119 	static TBool iAlternateRepeatExists;

   120 	static CWsCaptureLongKey* iLongCapture;

   121 	static TInt iRepeatRollover;

   122 	};

   123 

   124 struct SNotificationHandler {CAnim* iAnim; TUint32 iNotifications;};

   125 struct TDrawerHandler

   126 	{

   127 	TDrawerHandler(CWsGraphicDrawer *aDrawer, TUint32 aEvents): iDrawer(aDrawer), iEvents(aEvents) {}

   128 	CWsGraphicDrawer* iDrawer;

   129 	TUint32 iEvents;

   130 	};

   131 

   132 struct TWsEventHandler

   133 	{

   134 	TWsEventHandler(MWsEventHandler *aHandler, TUint32 aEvents): iHandler(aHandler), iEvents(aEvents) {}

   135 	static TBool CompareHandler(const TWsEventHandler& lhs, const TWsEventHandler& rhs) { return lhs.iHandler == rhs.iHandler; }

   136 	MWsEventHandler* iHandler;

   137 	TUint32 iEvents;

   138 	};

   139 

   140 class CEventQueueRetry : public CActive

   141 	{

   142 public:

   143 	static CEventQueueRetry* NewL();

   144 	~CEventQueueRetry();

   145 	void Init(CScreen *aOwner);

   146 	void Retry(TInt aDelay);

   147 	void CancelRetry();

   148 private:

   149 	CEventQueueRetry();

   150 	void ConstructL();

   151 	// From CActive:

   152 	void RunL();

   153 	void DoCancel();

   154 	

   155 private:

   156 	RTimer iTimer;

   157 	CScreen *iOwner;

   158 	TInt iRetrySpinner;

   159 	RPointerArray<CWsClient> iClientArray;

   160 	};

   161 

   162 class TWindowServerEvent

   163 	{

   164 	#define EDefaultInitialRepeatTime TTimeIntervalMicroSeconds32(300000)

   165 	#define EDefaultRepeatTime TTimeIntervalMicroSeconds32(100000)

   166 

   167 	typedef void (*TSendEventFunc)(TEventRequestItem *aQptr, TInt aParam1, TInt aParam2);

   168 public:

   169 	enum {ENumHotKeys=21};

   170 	enum {EOomEventSecondGap=150};	// Don't resend OOM messages unless at least 150 seconds has passed

   171 	enum {ERemovedEventHandlerWhileProcessingRawEvents=0x02};

   172 public:

   173 	static void InitStaticsL();

   174 	static void DeleteStatics();

   175 	static CWsHotKey* ClearHotKeysL(TInt aHotKey);

   176 	static void ResetDefaultHotKeyL(TInt aHotKey);

   177 	static void SetHotKeyL(const TWsClCmdSetHotKey &aHotKey);

   178 	static void AddCaptureKeyL(const TKeyCaptureRequest& aRequest);

   179 	static void UpdateCaptureKeyL(const TKeyCaptureRequest& aRequest);

   180 	static void CancelCaptureKey(TKeyCaptureType aType, TAny* aHandle);

   181 	static void ClientDestroyed(CWsClient *aClient);

   182 	static inline void AddToSwitchOnEventListL(const CWsWindowBase &aWindow, TEventControl aCircumstances);

   183 	static inline void RemoveFromSwitchOnEventList(const CWsWindowBase &aWindow);

   184 	static inline void AddToErrorMessageListL(const CWsWindowBase &aWindow, TEventControl aCircumstances);

   185 	static inline void RemoveFromErrorMessageList(const CWsWindowBase &aWindow);

   186 	static inline void AddToModifierChangedEventListL(const CWsWindowBase &aWindow, TInt aModifierMask, TEventControl aCircumstances);

   187 	static inline void RemoveFromModifierChangedEventList(const CWsWindowBase &aWindow);

   188 	static inline void AddToGroupChangeEventListL(const CWsWindowBase &aWindow);

   189 	static inline void RemoveFromGroupChangeEventEventList(const CWsWindowBase &aWindow);

   190 	static inline void AddToFocusChangeEventListL(const CWsWindowBase &aWindow);

   191 	static inline void RemoveFromFocusChangeEventEventList(const CWsWindowBase &aWindow);

   192 	static inline void AddToGroupListChangeEventListL(const CWsWindowBase &aWindow);

   193 	static inline void RemoveFromGroupListChangeEventEventList(const CWsWindowBase &aWindow);

   194 	static inline void AddToScreenDeviceChangeEventListL(const CWsWindowBase &aWindow);

   195 	static inline void RemoveFromScreenDeviceChangeEventList(const CWsWindowBase &aWindow);

   196 	static TInt GetModifierState();

   197 	static inline TInt GetStoredModifierState();

   198 	static void SetModifierState(TEventModifier aModifier,TModifierState aState);

   199 	static void ProcessRawEvent(const TRawEvent& aRawEvent);

   200 	static void ProcessKeyEvent(const TKeyEvent& aKeyEvent,TInt aRepeats);

   201 	static TBool MousePress(const TRawEvent &aRawEvent, const CWsWindowGroup *aGroupWin);

   202 	static void SendGroupChangedEvents();

   203 	static void SendFocusChangedEvents();

   204 	static void SendGroupListChangedEvents();

   205 	static void SendVisibilityChangedEvents(CWsWindowBase* aWin, TUint aFlags);

   206 	static TBool SendDisplayChangedEvents(CWsClient *aWsClient, TInt aDisplayNumber, TInt aConfigurationChangeId, TInt aResolutionListChangeId);

   207 	static void SendScreenDeviceChangedEvents(CScreen* aScreen);

   208 	static void SendScreenDeviceChangedEvent(const CWsWindowBase *aWindow);

   209 	static TBool ProcessErrorMessages(TWsErrorMessage::TErrorCategory aCategory, TInt aError);

   210 	static void NotifyOom();

   211 	static void ProcessKeyPress(const TKeyEvent& aKeyEvent, TBool aCheckRepeat,TInt aRepeats);

   212 	static void QueueKeyPress(const TKeyEventRouterOutput& aOutput, TBool aIsRepeat, TInt aRepeats);

   213 	static void AddEventHandler(MEventHandler *aEventHandler, TBool aAdvancedPointersEnabled);

   214 	static void RemoveEventHandler(const MEventHandler *aEventHandler);

   215 	static void PotentialEventHandlerL(TInt aNum);

   216 	static TInt AddNotificationHandler(CAnim* aAnim, TUint32 aNotifications);

   217 	static void RemoveNotificationHandler(CAnim* aAnim);

   218 	static void PublishNotification(const TWsEvent& aWsEvent);

   219 	static TInt RegisterDrawerHandler(CWsGraphicDrawer* aDrawer, TUint32 aEvents);

   220 	static TInt UnregisterDrawerHandler(CWsGraphicDrawer* aDrawer);

   221 	static TInt RegisterWsEventHandler(MWsEventHandler * aHandler, TUint32 aEvents);

   222 	static TInt UnregisterWsEventHandler(MWsEventHandler * aHandler);

   223 	static void NotifyDrawer(const TWservCrEvent& aEvent);

   224 	static void NotifyScreenDrawingEvent(const TRegion* aRegion);

   225 	static void NotifyScreenDrawingEvent(const TRect& aRect);

   226 	static inline const CRawEventReceiver* EventReceiver() {return iEventReceiver;}

   227 private:

   228 	class TRawEventHandler

   229 		{

   230 		public:

   231 			inline TRawEventHandler(MEventHandler *aEventHandler, TBool aAdvancedPointersEnabled);

   232 		public:

   233 			MEventHandler *iEventHandler;

   234 			TBool iAdvancedPointersEnabled;

   235 		};

   236 	static void ProcessEventQueue(TEventRequestQueue &aQueue, TSendEventFunc aFunc, TInt aParam1, TInt aParam2);

   237 	static void DeleteHotKeys();

   238 	static void QueueKeyEvent(CWsWindowGroup *aWin, TWsEvent &aEvent, TWservEventPriorities aPriority);

   239 	static void QueueKeyUpDown(const TRawEvent &aRawEvent);

   240 	static void ConstructDefaultHotKeyL(TInt aHotKey, const TWsWinCmdCaptureKey &aSystemKey);

   241 	static void ProcessModifierChanges();

   242 	static void LinkHotKey(CWsHotKey *aWsHotKey);

   243 	static TBool DrawerCompareFunc(const TDrawerHandler& lhs, const TDrawerHandler& rhs);

   244 private:

   245 	static CKeyTranslator *iKeyTranslator;

   246 	static TEventRequestQueue iSwitchOnQueue;

   247 	static TEventRequestQueue iErrorMessageQueue;

   248 	static TEventRequestQueue iModifierChangedQueue;

   249 	static TEventRequestQueue iGroupChangedQueue;

   250 	static TEventRequestQueue iFocusChangedQueue;

   251 	static TEventRequestQueue iGroupListChangedQueue;

   252 	static TEventRequestQueue iScreenDeviceChangedQueue;

   253 	static TTime iPrevOomMessageTime;

   254 	static CCaptureKeys *iCaptureKeys;

   255 	static CKeyEventRouter *iKeyEventRouter;

   256 	static RLibrary iKeyEventRouterLibrary;

   257 	static CWsHotKey *iHotKeys;

   258 	static TInt iModifierState;

   259 	static CRawEventReceiver *iEventReceiver;

   260 	static RArray<TRawEventHandler> iEventHandlers;

   261 	static CArrayFixFlat<SNotificationHandler> *iNotificationHandlers;

   262 	static TInt iPotentialEventHandlers;

   263 	static RArray<TDrawerHandler>* iDrawerHandlers;

   264 	static RArray<TWsEventHandler> iWsEventHandlers;

   265 	static TUint32 iBinaryFlags;

   266 	static TInt iEventHandlerCount;

   267 	};

   268 

   269 

   270 //

   271 // inlines			//

   272 //

   273 

   274 inline TBool CKeyboardRepeat::IsAreadyActive()

   275 	{

   276 	return iThis->IsActive();

   277 	}

   278 

   279 inline TWindowServerEvent::TRawEventHandler::TRawEventHandler(MEventHandler *aEventHandler, TBool aAdvancedPointersEnabled)

   280 : iEventHandler(aEventHandler), iAdvancedPointersEnabled(aAdvancedPointersEnabled)

   281 	{ }

   282 

   283 inline void TWindowServerEvent::AddToSwitchOnEventListL(const CWsWindowBase &aWindow, TEventControl aCircumstances)

   284 	{iSwitchOnQueue.AddToEventRequestListL(aWindow, 0, aCircumstances);}

   285 inline void TWindowServerEvent::AddToErrorMessageListL(const CWsWindowBase &aWindow, TEventControl aCircumstances)

   286 	{iErrorMessageQueue.AddToEventRequestListL(aWindow, 0, aCircumstances);}

   287 inline void TWindowServerEvent::AddToModifierChangedEventListL(const CWsWindowBase &aWindow, TInt aModifierMask, TEventControl aCircumstances)

   288 	{iModifierChangedQueue.AddToEventRequestListL(aWindow, aModifierMask, aCircumstances);}

   289 inline void TWindowServerEvent::AddToGroupChangeEventListL(const CWsWindowBase &aWindow)

   290 	{iGroupChangedQueue.AddToEventRequestListL(aWindow, 0, EEventControlAlways);}

   291 inline void TWindowServerEvent::AddToFocusChangeEventListL(const CWsWindowBase &aWindow)

   292 	{iFocusChangedQueue.AddToEventRequestListL(aWindow, 0, EEventControlAlways);}

   293 inline void TWindowServerEvent::AddToGroupListChangeEventListL(const CWsWindowBase &aWindow)

   294 	{iGroupListChangedQueue.AddToEventRequestListL(aWindow, 0, EEventControlAlways);}

   295 inline void TWindowServerEvent::AddToScreenDeviceChangeEventListL(const CWsWindowBase &aWindow)

   296 	{iScreenDeviceChangedQueue.AddToEventRequestListL(aWindow, 0, EEventControlAlways);}

   297 

   298 inline void TWindowServerEvent::RemoveFromSwitchOnEventList(const CWsWindowBase &aWindow)

   299 	{iSwitchOnQueue.RemoveFromEventRequestListL(aWindow);}

   300 inline void TWindowServerEvent::RemoveFromErrorMessageList(const CWsWindowBase &aWindow)

   301 	{iErrorMessageQueue.RemoveFromEventRequestListL(aWindow);}

   302 inline void TWindowServerEvent::RemoveFromModifierChangedEventList(const CWsWindowBase &aWindow)

   303 	{iModifierChangedQueue.RemoveFromEventRequestListL(aWindow);}

   304 inline void TWindowServerEvent::RemoveFromGroupChangeEventEventList(const CWsWindowBase &aWindow)

   305 	{iGroupChangedQueue.RemoveFromEventRequestListL(aWindow);}

   306 inline void TWindowServerEvent::RemoveFromFocusChangeEventEventList(const CWsWindowBase &aWindow)

   307 	{iFocusChangedQueue.RemoveFromEventRequestListL(aWindow);}

   308 inline void TWindowServerEvent::RemoveFromGroupListChangeEventEventList(const CWsWindowBase &aWindow)

   309 	{iGroupListChangedQueue.RemoveFromEventRequestListL(aWindow);}

   310 inline void TWindowServerEvent::RemoveFromScreenDeviceChangeEventList(const CWsWindowBase &aWindow)

   311 	{iScreenDeviceChangedQueue.RemoveFromEventRequestListL(aWindow);}

   312 inline TInt TWindowServerEvent::GetStoredModifierState()

   313 	{return(iModifierState);}

   314 

   315 #endif
Symaptic