Symaptic: os/graphics/windowing/windowserver/nga/SERVER/openwfc/CLIENT.H@bde4ae8d615e

     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 for the class that deals with client communication

    15 //

    16 //

    18 #ifndef __CLIENT_H__

    19 #define __CLIENT_H__

    21 #include <graphics/WSGRAPHICDRAWERINTERFACE.H>

    22 #include "WSGRAPHICDRAWERARRAY.H"

    24 #include <e32std.h>

    25 #include <e32base.h>

    26 #include "W32STD.H"

    27 #include "w32cmd.h"

    28 #include "WSOBJIX.H"

    29 #include "EVQUEUE.H"

    30 #include "PRIKEY.H"

    31 #include "wstypes.h"

    32 #include <e32hashtab.h>  //RHashMap

    34 class CWsWindowBase;

    35 class CWsClientWindow;

    36 class CWsPointerCursor;

    37 class CWsCustomTextCursor;

    38 class CWsSpriteBase;

    39 class DWsScreenDevice;

    40 class CScreen;

    41 class RHandleBase;

    42 class CWsGraphicDrawerObject;

    43 class CWsGraphicDrawer;

    44 class MWsElement;

    45 class TSurfaceConfiguration;

    46 class CWsRedrawMsgWindow;

    48 /** Server-side object for a client session.

    50 @internalComponent

    51 @released

    52 */

    53 class CWsClient : public CSession2, public MWsClient

    54 	{

    55 private:

    56 	friend class CWsRedrawMsgWindow;

    57 private:

    58 	class TWsCursorArrayItem;

    59 	enum{EObjectGranularity=5};

    60 	enum{ENoDefaultSystemPointerCursor=-1};

    61 public:

    62 	enum{EPanicLeave=1};

    63 public: // from MWsClient

    64 	TBool HasCapability(TCapability aCapability) const;

    65 	TSecureId SecureId() const;

    66 	TVendorId VendorId() const;

    67 public:

    68 	CWsClient(RThread aClient);

    69 	~CWsClient();

    70 	static void InitStaticsL();

    71 	static void DeleteStatics();

    72 	inline TBool NotClosing() const;

    73 	inline CWsObjectIx* ObjectIndex();

    75 	inline const RMessage2& ClientMessage() const;

    77 	inline const RThread& Client() const;

    78 	static inline CWsClient* CurrentClient();

    79 	inline TInt ConnectionHandle() const;

    80 	inline DWsScreenDevice* PrimaryScreenDevice();

    81 	inline const DWsScreenDevice* PrimaryScreenDevice() const;

    82 	inline CScreen* Screen();

    83 	inline const CScreen* Screen() const;

    84 	static CWsPointerCursor* SystemPointerCursor(TInt aIndex);

    85 	static inline CWsPointerCursor* DefaultSystemPointerCursor();

    86 	static CWsCustomTextCursor* FindCustomTextCursor(TInt aIdentifier);

    87 	void SessionPanic(TClientPanic aReason) const;

    89 	// Window object access from handle

    90 	void HandleToWindow(TInt aHandle, CWsWindowBase** pWin);

    91 	void HandleToClientWindow(TInt aHandle, CWsClientWindow** pWin);

    93 	// Generic WsObject access from handle

    94 	CWsObject* HandleToObj(TInt aHandle, WH_HANDLES aType);

    95 	const CWsObject* HandleToObj(TInt aHandle, WH_HANDLES aType) const;

    96 	CWsObject* HandleToObjUntyped(TInt aHandle);

    97 	const CWsObject* HandleToObjUntyped(TInt aHandle) const;

    99 	CWsGraphicDrawerObject* DrawerObject(const CWsGraphicDrawer* aDrawer);

   100 	const CWsGraphicDrawerObject* DrawerObject(const CWsGraphicDrawer* aDrawer) const;

   102 	// Handle from object

   103 	inline TInt ObjectHandle(const CWsObject* aThis) const;

   105 	// Queue access

   106 	inline CEventQueue* EventQueue();

   107 	inline const CEventQueue* EventQueue() const;

   108 	inline CRedrawQueue* RedrawQueue();

   109 	inline const CRedrawQueue* RedrawQueue() const;

   111 	// Execute client command from buffer

   112 	void ExecuteCommandL(TInt aOpcode, const TAny* aCmdData);

   113 	static const TUint8* EndOfCommandBuffer();

   114 	static const TPtrC BufferTPtr(TText* aStart,TInt aLen);

   115 	static TBool BufferTPtrGc(TText* aStart,TInt aLen,TPtrC& aPtr);

   116 	static const TPtrC8 BufferTPtr8(TUint8* aStart,TInt aLen);

   118 	// Remote read data from client

   119 	void RemoteRead(TDes16& aDes, TInt aOffset);

   120 	void RemoteRead(TDes8& aDes, TInt aOffset);

   121 	void RemoteReadL(TDes16& aDes, TInt aOffset);

   122 	void RemoteReadL(TDes8& aDes, TInt aOffset);

   124 	// Send the reply to the client's request

   125 	void SetResponseHandle(RHandleBase* aHandle);

   126 	static void ReplyBuf(const TAny* aSource, TInt aLength);

   127 	static void ReplyBuf(const TDesC8 &aDes);

   128 	static void ReplyBuf(const TDesC16 &aDes);

   129 	static void ReplySize(const TSize &aSize);

   130 	static void ReplyPoint(const TPoint &aPoint);

   131 	static void ReplyRect(const TRect &aRect);

   132 	static void ReplyGroupName(HBufC* aName, TInt aMaxLength);

   133 	static void SetReply(TInt reply);

   134 	void RequestComplete(TRequestStatus*& aStatus, TInt aErr);

   136 	// Panic or terminate the client

   137 	static void PanicCurrentClient(TClientPanic aPanic);

   138 	static TInt ReplyBufSpace()  ;

   139 	void PPanic(TClientPanic aPanic) const;

   140 	void SessionTerminate();

   142 	// All events

   143 	inline void EventReady(const RMessagePtr2& aEventMsg);

   145 	// Pointer events

   146 	inline void PurgePointerEvents();

   148 	// Key events

   149 	inline void PriorityKeyPressed(TInt aHandle, const TKeyEvent &aKeyEvent);

   151 	// Notification of misc events

   152 	void AddNotificationL(TInt aKey, const RMessage2& aClientMsg);

   153 	void CompleteNotification(TInt aKey, TInt aReason);

   154 	inline void NotifyScreenDeviceDeleted(DWsScreenDevice* aDeletedScreenDevice);

   156 	// Redraw

   157 	void TriggerRedraw();

   159 	// Misc

   160 	void UpdateWindowOrdinalPrioritys();

   161 	void SetClientPriority();	// boost when in foreground

   163 	void CreateDrawableSourceL(const TWsClCmdCreateDrawableSource& aDrawableSourceData);

   165 	//retry putting events on event queue

   166 	void SetRetryFlag(TEventCode aEventCode);

   167 	void RemoveRetryFlag(TEventCode aEventCode);

   168 	TBool RetryEvent(TEventCode aEventCode);

   170     inline void WgMsgQueueOverflow();// Set flag  window group message queue is overflow and has pending messages

   172     //Get orientation value that app indicated

   173     TInt GetIndicatedAppOrientation();

   175 private: // from MWsClient

   176 	TInt SendMessage(const CWsGraphicDrawer* aOnBehalfOf, const TDesC8& aData);

   177 	TInt SendMessage(const CWsGraphicDrawer* aOnBehalfOf, CWsMessageData& aData);

   179 private: // from CSession2

   180 	void ServiceL(const RMessage2 &aMessage);

   181 	void ServiceError(const RMessage2& aMessage,TInt aError);

   182 private:

   183 	// Construction and destruction

   184 	inline TBool IsInitialised();

   185 	void StartInitializationL(TUint aConnectionHandle);

   186 	void CompleteInitializationL();

   187 	void InitialiseScreenDevices();

   189 	// Service client commands by dispatching them to the object associated with the op code

   190 	void DoServiceL(const RMessage2& aMessage, TBool& aCompleteRequest);

   191 	void DoServiceCommandBuf();

   192 	void DispatchCommandsInBufL();

   193 	void CompleteMessage(const RMessage2& aMessage,TInt aReason);

   195 	// Execute async client commands

   196 	void ExecuteAsyncClientCommandL(TInt aOpcode, const RMessage2& aMessage);

   197 	static inline TBool CheckBuffer(TInt aLength, TInt aMaxLength);

   198 	static TBool DebugEnforceRedrawCallingConvention();

   200 	// Create new objects

   201 	void CreateNewWindowGroupL(const TWsClCmdCreateWindowGroup &aCmd);

   202 	void CreateNewWindowL(const TWsClCmdCreateWindow &aCmd);

   203 	void CreateNewAnimDllL(const TWsClCmdUnion &aParams);

   204 	void CreateNewSpriteL(const TWsClCmdCreateSprite &aCmd);

   205 	void CreateNewPointerCursorL(const TWsClCmdCreatePointerCursor &aCmd);

   206 	void CreateNewBitmapL(const TWsClCmdCreateBitmap &aCmd);

   207 	void CreateNewClickHandlerL(const TUid& aUid);

   208 	void CreateNewScreenDeviceL( TInt aDefaultScreenNumber, TUint aClientScreenDevicePointer);

   210 	// Surface management

   211 	TInt RegisterSurface(const TWsClCmdUnion& pData);

   212 	void UnregisterSurface(const TWsClCmdUnion& pData);

   214 	// Text cursor

   215 	static inline CWsCustomTextCursor*& TextCursor (TInt aPosition);

   216 	void StartSetCustomTextCursorL(const TWsClCmdCustomTextCursorData& aCmd);

   217 	void CompleteSetCustomTextCursorL(TInt aErr);

   219 	// Pointer cursor

   220 	static inline CWsPointerCursor*& PointerCursor (TInt aPosition);

   221 	void SetSystemPointerCursorL(TInt aIndex, CWsPointerCursor* aCursor);

   222 	void ClearSystemPointerCursor(TInt aIndex);

   223 	void ClaimSystemPointerCursorListL();

   224 	void FreeSystemPointerCursorList();

   225 	void SetDefaultSystemPointerCursor(TInt aIndex);

   226 	static void DeleteSystemPointerListEntry(TInt aIndex);

   228 	static TBool FindCursorArrayItem(CArrayFixFlat<TWsCursorArrayItem>* aCursorArray,

   229 									  TInt aIndex, TInt& aPosition);

   231 	// Key events

   232 	inline void CancelClientRequestForPriorityKeyEvent();

   233 	inline void HandleClientRequestForPriorityKeyData();

   234 	inline void PriorityKeyEventReady(const RMessagePtr2& aEventMsg);

   236 	// Redraw events

   237 	inline void CancelClientRequestForRedrawEvent();

   238 	inline void HandleClientRequestForRedrawData();

   239 	inline void RedrawEventReady(const RMessagePtr2& aEventMsg);

   240 	inline TBool ClientProcessingRedrawEvent();

   242 	// Client event requests

   243 	inline void HandleClientRequestForEventData();

   244 	inline void CancelClientRequestForEventData();

   246 	// Debugging

   247 	void DebugInfoL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const;

   248 	void DebugInfoUnclassifiedL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const;

   249 	TInt DebugInfoClassifiedL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const;

   250 	TInt DebugInfoScreenUiL(TInt aFunction, TInt aParam, TInt aReplyBufSize, CScreen& aScreen) const;

   251 	TInt DebugInfoScreenElementSetL(TInt aFunction, TInt aParam, TInt aReplyBufSize,const CScreen& aScreen) const;

   252 	TInt DebugInfoElementSetWindowL(TInt aFunction, TInt aParam, TInt aReplyBufSize,const CScreen& aScreen) const;

   253 	TInt DebugInfoElementSetElementL(TInt aFunction, TInt aParam, TInt aReplyBufSize,const CScreen& aScreen) const;

   254 	TInt DebugReturnConfig(TInt aReplyBufSize, MWsElement* aElement, TInt aFlags=0)const;

   255 	TInt DebugReturnBase(TInt aReplyBufSize, const MWsElement* aElement) const;

   256 	TInt DebugReturnFlags(TInt aReplyBufSize, const MWsElement* aElement, TInt aFlags=0) const;

   257 	TInt DebugReturnRegion(TInt aReplyBufSize, const TRegion* aRegion, TInt aErrCodeIfEmpty) const;

   259 	// Misc

   260 	void SetComputeMode(RWsSession::TComputeMode aComputeMode);

   262 	//Set orientation that application indicated

   263 	void IndicateAppOrientation(TRenderOrientation aOrientation);

   265 public:

   266 	static TWsCmdHeaderBase iCurrentCommand;

   267 private:

   268 	class TWsCursorArrayItem

   269 		{

   270 	public:

   271 		CWsSpriteBase* iCursor;

   272 		TInt iIndex;

   273 		};

   275 	enum TInternalFlags

   276 		{

   277 		EIsInitialised = 0x01,

   278 		EPanicClientAsSoonAsPossible = 0x02,		//The client should be panicked, but we have no way to panic him now

   279 		EClientIsClosing = 0x04,		//The client is closing down, so the screen device may no longer be valid

   280 		EFinishedProcessingCommands=0x08,	//Reached last command in command buffer or otherwised finihsed processing it

   281 		ERemoveKeyCode=0x10,		//Remove the Win32 keycode emulator only

   282 		ERetryDisplayEvent=0x20,

   283 		EIsPerformingRedrawEvent=0x40,         //The client is performing a RedrawEvent

   284 		EWgMsgQueueOverflow =0x80,

   285 		};

   286 private:

   287 	RThread iClient;

   288 	CScreen* iScreen;		//## This needs updating

   289 	TUint iConnectionHandle; // Connection ID, only needed for logging, could bin this

   290 	CEventQueue* iEventQueue;

   291 	CRedrawQueue* iRedrawQueue;

   292 	CPriorityKey* iPriorityKeyEvent;

   293 	CWsGraphicMessageQueue iGraphicMessageQueue;

   294 	RWsSession::TComputeMode iComputeMode;

   295 	CWsObjectIx* iObjectIndex;

   296 	DWsScreenDevice* iPrimaryScreenDevice;

   297 	TWsCursorArrayItem iTempCustomTextCursor;

   298 	mutable TInt iPanicReason;

   299 	mutable TUint iInternalFlags;

   300 	RMessage2 iClientMessage;

   301 	RHandleBase* iResponseHandle;

   302 	TInt iMessageIdSeq;

   303 	TInt iIndicatedAppOrientation;

   305 	//Members for procerssing command buffer

   306 	static CWsClient* iCurrentClient;	// Client who's buffer is currently being processed

   307 	static TInt iReply;					// Value to reply

   308 	static TInt iReplyOffset;			// Offset into reply to write next block of data

   309 	static TBuf8<EClientBufferMaxSize> iCmdBuf; // Buffer contain a block of client commands

   310 	static CWsObject* iDestObj;			// Current object client command is for

   311 	static const TUint8* iNextCmd;		// Pointer in buffer to the next command to be processed

   313 	static TInt iDefaultSystemPointerCursorIndex;		// Negative when there isn't one

   314 	static CWsPointerCursor* iDefaultSystemPointerCursor;

   315 	static CArrayFixFlat<TWsCursorArrayItem>* iSystemPointerCursors;

   316 	static CWsClient* iSystemPointerCursorListOwner;

   317 	static CArrayFixFlat<TWsCursorArrayItem>* iTextCursorArray;

   318 	static TUint iConnectionId;

   319 	static TKeyArrayFix iCursorKey;

   320  	static TBool iDebug_EnforceRedrawCallingConvention;

   321 #if defined(__WINS__)

   322 public:

   323 	inline TBool RemoveKeyCode();

   324 #endif

   325 	};

   328 //

   329 // inlines			//

   330 //

   332 inline const RThread& CWsClient::Client() const

   333 	{return iClient;}

   335 inline void CWsClient::EventReady(const RMessagePtr2& aEventMsg)

   336 	{iEventQueue->EventReady(aEventMsg);}

   338 inline void CWsClient::HandleClientRequestForEventData()

   339     {iEventQueue->GetData();}

   341 inline void CWsClient::CancelClientRequestForEventData()

   342 	{iEventQueue->CancelRead();}

   344 inline void CWsClient::PurgePointerEvents()

   345 	{iEventQueue->PurgePointerEvents();}

   347 inline void CWsClient::RedrawEventReady(const RMessagePtr2& aEventMsg)

   348     {

   349     iInternalFlags&=~EIsPerformingRedrawEvent;

   350     iRedrawQueue->EventReady(aEventMsg);

   351     }

   353 inline TBool CWsClient::ClientProcessingRedrawEvent()

   354 	{return !!(iInternalFlags&EIsPerformingRedrawEvent);}

   356 inline void CWsClient::HandleClientRequestForRedrawData()

   357     {

   358     iInternalFlags|=EIsPerformingRedrawEvent;

   359     iRedrawQueue->GetData();

   360     }

   362 inline void CWsClient::CancelClientRequestForRedrawEvent()

   363 	{iRedrawQueue->CancelRead();}

   365 inline void CWsClient::PriorityKeyEventReady(const RMessagePtr2& aEventMsg)

   366     {iPriorityKeyEvent->EventReady(aEventMsg);}

   368 inline void CWsClient::CancelClientRequestForPriorityKeyEvent()

   369 	{iPriorityKeyEvent->CancelRead();}

   371 inline void CWsClient::HandleClientRequestForPriorityKeyData()

   372 	{iPriorityKeyEvent->GetData();}

   374 inline void CWsClient::PriorityKeyPressed(TInt aHandle, const TKeyEvent &aKeyEvent)

   375 	{iPriorityKeyEvent->PriorityKey(aHandle, aKeyEvent);}

   377 inline TInt CWsClient::ObjectHandle(const CWsObject* aThis) const

   378 	{return(iObjectIndex->At(aThis));}

   380 #if defined(__WINS__)

   381 inline TBool CWsClient::RemoveKeyCode()

   382 	{return iInternalFlags&ERemoveKeyCode;}

   383 #endif

   385 inline CEventQueue* CWsClient::EventQueue()

   386 	{return(iEventQueue);}

   388 inline const CEventQueue* CWsClient::EventQueue() const

   389 	{return(iEventQueue);}

   391 inline CRedrawQueue* CWsClient::RedrawQueue()

   392 	{return(iRedrawQueue);}

   394 inline const CRedrawQueue* CWsClient::RedrawQueue() const

   395 	{return(iRedrawQueue);}

   397 inline CWsObjectIx* CWsClient::ObjectIndex()

   398 	{return(iObjectIndex);}

   400 inline TInt CWsClient::ConnectionHandle() const

   401 	{return(iConnectionHandle);}

   403 inline DWsScreenDevice* CWsClient::PrimaryScreenDevice()

   404 	{return(iPrimaryScreenDevice);}

   406 inline const DWsScreenDevice* CWsClient::PrimaryScreenDevice() const

   407 	{return(iPrimaryScreenDevice);}

   409 inline void CWsClient::NotifyScreenDeviceDeleted(DWsScreenDevice* aDeletedScreenDevice)

   410 	{

   411 	if (iPrimaryScreenDevice == aDeletedScreenDevice)

   412 		iPrimaryScreenDevice = NULL;

   413 	}

   415 inline CWsPointerCursor*& CWsClient::PointerCursor(TInt aIndex)

   416 	{return (CWsPointerCursor*&)(*iSystemPointerCursors)[aIndex].iCursor;}

   418 inline CWsCustomTextCursor*& CWsClient::TextCursor(TInt aIndex)

   419 	{return (CWsCustomTextCursor*&)(*iTextCursorArray)[aIndex].iCursor;}

   421 inline const RMessage2& CWsClient::ClientMessage() const

   422 	{return iClientMessage;}

   424 inline CScreen* CWsClient::Screen()

   425 	{return iScreen;}

   427 inline const CScreen* CWsClient::Screen() const

   428 	{return iScreen;}

   430 inline TBool CWsClient::NotClosing() const

   431 	{return !(iInternalFlags&EClientIsClosing);}

   433 inline CWsClient* CWsClient::CurrentClient()

   434 	{return iCurrentClient;}

   436 inline TBool CWsClient::CheckBuffer(TInt aLength, TInt aMaxLength)

   437 	{return TBool((aLength>=0) && (aLength<=aMaxLength));}

   439 inline TBool CWsClient::IsInitialised()

   440 	{return iInternalFlags&EIsInitialised; }

   442 inline void CWsClient::WgMsgQueueOverflow()

   443     {iInternalFlags |= EWgMsgQueueOverflow;}

   445 #endif

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--