Symaptic: os/graphics/windowing/windowserver/nonnga/SERVER/server.h@260cb5ec6c19

     1 // Copyright (c) 1999-2009 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 // Window server C++ Class definitions

    15 //

    16 //

    18 #ifndef __SERVER_H__

    19 #define __SERVER_H__

    21 #include <e32std.h>

    22 #include <w32std.h>

    23 #include "w32cmd.h"

    24 #include <bitstd.h>

    25 #include <bitdev.h>

    26 #include <e32svr.h>

    27 #include "OBJECT.H"

    28 #include "CLIENT.H"

    29 #include "ScrDev.H"

    30 #include <Graphics/WSGRAPHICDRAWERINTERFACE.H>

    31 #include "Graphics/wsgraphicdrawerinternal.h"

    32 #include "WSGRAPHICDRAWERARRAY.H"

    33 #include "panics.h"

    35 class CWsGc;

    36 class CWsDirectScreenAccess;

    37 class CWsAnim;

    38 class CWsPluginManager;

    40 const TUid KDllUid={0x10000079};

    42 const TUint KMaxNumberOfMsgsInQueue=20;

    43 const TUint KMaxNumberOfMsgsInInactiveQueue=2;

    45 enum TWservActiveObjectPriorities

    46 	{

    47 	EWsGraphicAnimateAwaitIdlePriority=0, // lowest of all, when the system is really idle

    48 	EWsGraphicAnimatePriority=50,		// used by the default animation scheduler; custom schedulers might use other priorities as they see fit

    49 	EMainServerPriority=100,

    50 	ESpriteAnimatePriority=900,			// Below normal heartbeat

    51 	EPointerCursorPriority=950,

    52 	EHeartBeatPriority=1000,

    53 	EKeyRepeatPriority=1990,	// Just below normal events

    54 	EPointerRepeatPriority=1990,// Same as for key repeats

    55 	EEventPriority=2000,

    56 	EWsShellLogonPriority=3000,	// Log on to the shell dying

    57 	EDirectTimeOut=4000,

    58 	EDirectAbort=4010,

    59 	};

    61 enum {ETidyCountSetting=8};

    63 class CWsClient;

    64 class DWsScreenDevice;

    66 GLREF_C RWsRegion *GetRegionFromClientL(CWsClient *aClient, TInt aCount);

    68 //---------------------------

    69 // The event queue

    70 //---------------------------

    72 #define WS_EVENT_QUEUE_SIZE 50

    74 // Forward references

    76 class CWsRedrawMsgWindow;

    77 class CWsWindowRedraw;

    78 class CWsWindow;

    79 class CWsWindowBase;

    80 class CWsWindowGroup;

    81 class CWsClientWindow;

    82 class CWsClient;

    83 class CWsBackedUpWindow;

    84 class CWsPointerCursor;

    85 class TWindowServerEvent;

    86 class CWsRootWindow;

    88 enum TFlashState {EFlashOn,EFlashOff};

    90 struct TPointerKeyList

    91 	{

    92 	TRect iRect;

    93 	TInt iScanCode;

    94 	TBool iActivatedByPointerSwitchOn;

    95 	TDblQueLink iQue;

    96 	};

    98 struct TWsMessage

    99 	{

   100 	TUid iUid;

   101 	TUint8 iTheRest[4];	// Dummy elemnt where a variable length component will be

   102 	};

   104 class WsKeyboardEmulator

   105 	{

   106 public:

   107 	static TBool PointerEvent(TPointerEvent::TType type,const TPoint &aPoint, TDblQue<TPointerKeyList> *iPointerKeyList);

   108 private:

   109 	static void RawKeyEvent(TRawEvent::TType aType);

   110 private: // Private data

   111 	static TBool iKeyIsDown;

   112 	static TInt iCurrentKeyDown;

   113 	};

   115 struct TPointerEventInternal

   116 	{

   117 	TPointerEvent::TType iType;		// Type of pointer event

   118 	TUint iModifiers;	// State of pointing device and associated buttons

   119 	TPoint iPosition; 	// Screen co-ordinates of mouse event

   120 	};

   122 //------------------------------

   123 // Client object

   124 //------------------------------

   126 class CWsCliObj : public CWsObject

   127 	{

   128 public:

   129 	static CWsCliObj* NewL(CWsClient *aOwner);

   130 private:

   131 	CWsCliObj(CWsClient *aOwner);

   132 	void ConstructL();

   133 public: //from CWsObject

   134 	void CommandL(TInt aOpcode, const TAny *aCmdData);

   135 	};

   138 //---------------------------

   139 // Capture Key

   140 //---------------------------

   141 class CWsCaptureKey : public CWsObject

   142 	{

   143 public:

   144 	CWsCaptureKey(CWsWindowGroup *owner);

   145 	~CWsCaptureKey();

   146 	void ConstructL(const TWsWinCmdCaptureKey &aCaptureKey);

   147 	void SetL(const TWsWinCmdCaptureKey &aCaptureKey);

   148 	void CommandL(TInt aOpcode, const TAny *aCmdData);

   149 	inline CWsWindowGroup *WindowGroup();

   150 	inline const CWsWindowGroup *WindowGroup() const;

   151 private:

   152 	void CmdToParams(const TWsWinCmdCaptureKey &aCaptureKey, TCaptureKey &aParams);

   153 private:

   154 	CWsWindowGroup *iWindowGroup;

   155 	};

   157 class CWsHotKey : public CBase

   158 	{

   159 public:

   160 	CWsHotKey(TInt aHotKey, TBool aIsDefault);

   161 	~CWsHotKey();

   162 	void ConstructLD(const TWsWinCmdCaptureKey &aCaptureKey);

   163 	inline TInt HotKeyType() const;

   164 	inline TInt KeyHandle() const;

   165 	inline TBool IsDefault() const;

   166 	inline void SetLink(CWsHotKey *aLink);

   167 	void SetL(const TWsWinCmdCaptureKey &aCaptureKey);

   168 public:

   169 	CWsHotKey *iNext;

   170 private:

   171 	TInt iHotKeyType;

   172 	TBool iIsDefault;

   173 	CWsCaptureKey *iCaptureKey;

   174 	};

   176 class CWsCaptureKeyUpsAndDowns : public CWsObject

   177 	{

   178 public:

   179 	CWsCaptureKeyUpsAndDowns(CWsWindowGroup *owner);

   180 	~CWsCaptureKeyUpsAndDowns();

   181 	void ConstructL(const TWsWinCmdCaptureKey &aCaptureKey);

   182 	void CommandL(TInt aOpcode, const TAny *aCmdData);

   183 	static CWsWindowGroup *CheckForCapture(TUint aScanCode, TUint aModifiers);

   184 	inline CWsWindowGroup *WindowGroup();

   185 	inline const CWsWindowGroup *WindowGroup() const;

   186 private:

   187 	TUint iModifierValue;

   188 	TUint iModifierMask;

   189 	TUint iScanCode;

   190 	static TPriQue<CWsCaptureKeyUpsAndDowns> iCaptureKeysUpsAndDowns;

   191 	TPriQueLink iLink;

   192 	CWsWindowGroup *iWindowGroup;

   193 	};

   195 class CWsCaptureLongKey : public CWsObject

   196 	{

   197 	friend class CKeyboardRepeat;

   198 public:

   199 	CWsCaptureLongKey(CWsWindowGroup *owner);

   200 	~CWsCaptureLongKey();

   201 	void ConstructL(const TWsWinCmdCaptureLongKey &aCaptureKey);

   202 	void CommandL(TInt aOpcode, const TAny *aCmdData);

   203 	inline CWsWindowGroup *WindowGroup();

   204 	inline const CWsWindowGroup *WindowGroup() const;

   205 	static CWsCaptureLongKey* CheckForCapture(TUint aKeyCode, TInt aModifiers);

   206 public:

   207 	static TPriQue<CWsCaptureLongKey> iCaptureLongKeys;

   208 private:

   209 	TPriQueLink iLink;

   210 	CWsWindowGroup *iWindowGroup;

   211 	TWsWinCmdCaptureLongKey iData;

   212 	};

   214 //--------------------------------

   215 // Owner of CWsGraphicDrawer

   216 //--------------------------------

   218 class CWsGraphicDrawerObject: public CWsObject

   219 	{

   220 public:

   221 	static CWsGraphicDrawerObject* NewL(CWsClient* aClient,const TWsClCmdUnion &aParams);

   222 	~CWsGraphicDrawerObject();

   223 	// from CWsObject

   224 	void CommandL(TInt aOpcode, const TAny *aCmdData);

   225 	// access

   226 	CWsGraphicDrawer* Drawer();

   227 	const CWsGraphicDrawer* Drawer() const;

   228 	inline TInt ClientHandle() const;

   229 private:

   230 	CWsGraphicDrawerObject(CWsClient* aOwner);

   231 	void ConstructL(TUid aType,MWsGraphicDrawerEnvironment& aEnv,const TGraphicDrawerId& aId,const TDesC8& aData,TInt aClientHandle);

   232 private:

   233 	static TInt TransientSequence;

   234 	static TBool RollOver;

   235 	CWsGraphicDrawer* iDrawer;

   236 	TInt iClientHandle;

   237 	};

   239 //----------------------------

   240 // Window's

   241 //----------------------------

   243 enum TWalkMode

   244 	{

   245 	EWalkBehind,

   246 	EWalkChildren,

   247 	EWalkChildrenAndBehind

   248 	};

   249 enum TWindowFlags

   250 	{

   251 	EFlagHidden=0x1,			// True if the window is invisble for any reason

   252 	EFlagPointerCaptured=0x2,

   253 	EFlagPointerGrab=0x4,

   254 	EFlagInvisible=0x8,			// True if the client has requested the window to be invisible

   255 	EFlagActive=0x10,			// True if the window has been activated

   256 	//0x20

   257 	//0x40

   258 	EFlagDrawnToScreen=0x80,    // True if the window has been drawn to the screen since it became visible

   259 	//0x100

   260 	EFlagPointerCaptureDragDrop=0x200,	// True if pointure capture in Drag/Drop mode

   261 	EFlagPointerCaptureAllGroups=0x400,	// True if pointer capture affects all groups

   262 	EFlagUsingPointerBuffer=0x800,		// True if using a pointer event buffer

   263 	EFlagHasPointerBuffer=0x1000,		// True if has pointer event buffer allocated

   264 	//0x2000

   265 	EFlagFadeBehind=0x4000,             // True if fade behind requested for this window

   266 	//0x8000

   267 	EFlagNonFadingWindow=0x00010000,		//True if the window should never be faded

   268 	EFlagScreenDeviceInvalid=0x00020000,

   269 	EFlagShutDownInProgress=0x00040000,		// True if the window is currently being shut down

   270 	//0x00080000,

   271 	//0x00100000,

   272 	//0x00200000,

   273 	//0x00400000,

   274 	//0x00800000,

   275 	EFlagGeneratesVisibilityEvents=0x02000000,	// True if visibility events are enabled for this window

   276 	EFlagCanBeSeen=0x04000000,					// True if the last visibility event indicated that part of the window was visible

   277 //	EFlagTransparencyAlphaChannel=0x08000000, // True if the window is transparent with an alpha channel (and no transparency mask)

   278 	EFlagNotCantBeSeen=0x10000000,					// True if the last visibility event did not indicate that part of the window was not visible

   279 //	EFlagTransparencyPolicyFreezeUnder=0x20000000,	// True if the transparent window enables freezing under policy

   280 //	EFlagChildClippedRegionValid=0x40000000,  // True if the ChildClippedRegion is valid

   281 	EFlagHasAlpha=            0x80000000,  // Equivalent to EFlagTransperencyAlphaChannel - new name to prevent confusion

   282 	};

   284 //

   285 // Sprites

   286 //

   288 class TWsDeltaTimerEntry

   289 	{

   290 	friend class CWsDeltaTimer;

   291 public:

   292 	inline TWsDeltaTimerEntry(TCallBack& aCallback);

   293 	inline TWsDeltaTimerEntry();

   294 	inline void Set(TCallBack& aCallback);

   295 	inline TBool IsPending();

   296 private:

   297 	TCallBack iCallBack;

   298 	TDeltaQueLink iLink;

   299 	};

   300 class CWsDeltaTimer : public CActive

   301 	{

   302 	enum {CWsDeltaTimerGranularity=100000};

   303 public:

   304 	static CWsDeltaTimer* NewL(TInt aPriority);

   305 	void Queue(TTimeIntervalMicroSeconds32 aTimeInMicroSeconds,TWsDeltaTimerEntry& aHandle);

   306 	void Remove(TWsDeltaTimerEntry& anEntry);

   307 	void Activate();

   308 	~CWsDeltaTimer();

   309 private:

   310 	CWsDeltaTimer(TInt aPriority);

   311 	void DoCancel();

   312 	void RunL();

   313 protected:

   314 	RTimer iTimer;

   315 	TDeltaQue<TWsDeltaTimerEntry> iQueue;

   316 	};

   318 //---------------------------

   319 // Top level command class

   320 //---------------------------

   322 /** The main server class.

   324 @internalComponent

   325 @released

   326 */

   327 class CWindowServer : public CPolicyServer, public MWsGraphicDrawerEnvironment, public MWsMemoryRelease, public MWsRawEventServer

   328 	{

   329 public:

   330 	static CWindowServer *NewL();

   331 	~CWindowServer();

   332 	TInt SessionCount();

   333 	MWsAnimationScheduler* AnimationScheduler();

   334 	CWsPluginManager * PluginManager();

   335 	TBool ReleaseMemory();

   336 public:	// from MWsGraphicDrawerEnvironment

   337 	const CWsGraphicDrawer* ResolveGraphic(const TGraphicDrawerId& aId) const;

   338 	void Invalidate(const TGraphicDrawerId& aId);

   339 	TInt ScreenCount() const;

   340 	MWsScreen* Screen(TInt aIndex);

   341 	const MWsScreen* Screen(TInt aIndex) const;

   342 	TBool SetCustomAnimationScheduler(MWsAnimationScheduler* aScheduler);

   343 	TBool HasCustomAnimationScheduler() const;

   344 	TBool ClearCustomAnimationScheduler(MWsAnimationScheduler* aCurrentScheduler);

   345 	TInt RegisterEventHandler(CWsGraphicDrawer* aDrawer, MWsEventHandler* aHandler, TUint32 aEventMask);

   346 	TInt UnregisterEventHandler(CWsGraphicDrawer* aDrawer);

   347 	TInt RegisterWsEventHandler(MWsEventHandler* aHandler, TUint32 aEventMask);

   348 	TInt UnregisterWsEventHandler(MWsEventHandler* aHandler);

   349 	void Log(TInt aPriority,const TDesC &aFmt,TInt aParam=0);

   350 	TInt RegisterMemoryRelease(MWsMemoryRelease * aMemoryRelease);

   351 	void UnregisterMemoryRelease(MWsMemoryRelease * aMemoryRelease);

   353 public: // from MWsRawEventServer

   354 	TInt RegisterRawEventHandler(MEventHandler * aHandler);

   355 	void UnregisterRawEventHandler(MEventHandler * aHandler);

   356 	void PostRawEvent(const TRawEvent & aEvent);

   357 	void PostKeyEvent(const TKeyEvent & aEvent);

   359 public:

   360 	// CWsGraphicDrawer master index

   361 	TInt AddGraphicDrawer(CWsGraphicDrawer* aDrawer);

   362 	TInt SwapGraphicDrawer(CWsGraphicDrawer* aDrawer);

   363 	TInt RemoveGraphicDrawer(const TGraphicDrawerId& aId);

   364 	TInt RemoveAllGraphicDrawers(const MWsClient& aOwner);

   365 public: // from MWsMemoryRelease

   366 	TBool ReleaseMemory(TMemoryReleaseLevel aLevel);

   367 private:

   368 	CWindowServer();

   369 	void ConstructL();

   370 	TAny* ResolveObjectInterface(TUint aTypeId);

   371 private:	// from CServer2

   372 	CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

   373 private:

   374 	class CDefaultAnimationScheduler;

   375 	CDefaultAnimationScheduler* iDefaultAnimationScheduler;

   376 	CWsPluginManager* iPluginManager;

   377 	RPointerArray<MWsMemoryRelease> iMemoryReleases;

   378 	/** An index to all the CWsGraphicDrawer objects.

   380 	All the CWsGraphicDrawer objects are created and owned by the CWsClient objects but they are

   381 	indexed centrally because some operations require access to the full list.

   382 	*/

   383 	CWsGraphicDrawerArray iDrawerMasterIndex;

   384 	};

   386 //

   387 inline CWsWindowGroup *CWsCaptureKey::WindowGroup()

   388 	{return(iWindowGroup);}

   389 inline const CWsWindowGroup *CWsCaptureKey::WindowGroup() const

   390 	{return(iWindowGroup);}

   391 //

   392 inline CWsWindowGroup *CWsCaptureKeyUpsAndDowns::WindowGroup()

   393 	{return(iWindowGroup);}

   394 inline const CWsWindowGroup *CWsCaptureKeyUpsAndDowns::WindowGroup() const

   395 	{return(iWindowGroup);}

   396 //

   397 inline CWsWindowGroup *CWsCaptureLongKey::WindowGroup()

   398 	{return(iWindowGroup);}

   399 inline const CWsWindowGroup *CWsCaptureLongKey::WindowGroup() const

   400 	{return(iWindowGroup);}

   401 //

   402 inline CWsPointerCursor *CWsClient::DefaultSystemPointerCursor()

   403 	{return(iDefaultSystemPointerCursor);}

   404 //

   405 inline TInt CWsHotKey::HotKeyType() const

   406 	{return(iHotKeyType);}

   407 inline TInt CWsHotKey::KeyHandle() const

   408 	{return((TInt)iCaptureKey);}

   409 inline TBool CWsHotKey::IsDefault() const

   410 	{return(iIsDefault);}

   411 inline void CWsHotKey::SetLink(CWsHotKey *aLink)

   412 	{iNext=aLink;}

   413 //

   414 inline TWsDeltaTimerEntry::TWsDeltaTimerEntry(TCallBack& aCallback)

   415 	{iCallBack=aCallback;}

   416 inline TWsDeltaTimerEntry::TWsDeltaTimerEntry()

   417 	{}

   418 inline void TWsDeltaTimerEntry::Set(TCallBack& aCallback)

   419 	{iCallBack=aCallback;}

   420 inline TBool TWsDeltaTimerEntry::IsPending()

   421 	{return(iLink.iNext!=NULL);}

   422 //

   423 inline TInt CWsGraphicDrawerObject::ClientHandle() const

   424 	{return iClientHandle;}

   426 #endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--