// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Definition of classes for the class that deals with client communication

// 

//

#ifndef __CLIENT_H__

#define __CLIENT_H__

#include <graphics/wsgraphicdrawerinterface.h>

#include "WSGRAPHICDRAWERARRAY.H"

#include <e32std.h>

#include <e32base.h>

#include <w32std.h>

#include "w32cmd.h"

#include "WSOBJIX.H"

#include "EVQUEUE.H"

#include "PRIKEY.H"

#include "wstypes.h"

class CWsWindowBase;

class CWsClientWindow;

class CWsPointerCursor;

class CWsCustomTextCursor;

class CWsSpriteBase;

class DWsScreenDevice;

class CScreen;

class RHandleBase;

class CWindowServer;

class CWsGraphicDrawerObject;

class CWsGraphicDrawer;

class TWsCursorArrayItem

	{

public:

	CWsSpriteBase *iCursor;

	TInt iIndex;

	};

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

@internalComponent

@released

*/

class CWsClient : public CSession2, public MWsClient

	{

private:

	enum{EObjectGranularity=5};

	enum{ENoDefaultSystemPointerCursor=-1};

public:

	enum{EPanicLeave=1};

public:

	CWsClient(RThread aClient);

	~CWsClient();

	inline const RThread& Client() const;

	inline CWindowServer& WindowServer();

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

	void StartInitializationL(TUint aConnectionHandle);

	static const TUint8 *EndOfCommandBuffer();

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

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

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

	void CommandBufL();

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

	static void ReplyBuf(const TDesC8 &aDes);

	static void ReplyBuf(const TDesC16 &aDes);

	static void ReplySize(const TSize &aSize);

	static void ReplyPoint(const TPoint &aPoint);

	static void ReplyRect(const TRect &aRect);

	static void SetReply(TInt reply);

	static void PanicCurrentClient(TClientPanic aPanic);

	void PPanic(TClientPanic aPanic) const;

	void HandleToWindow(TInt handle,CWsWindowBase **pWin);

	void HandleToClientWindow(TInt handle,CWsClientWindow **pWin);

	inline CEventQueue *EventQueue() const;

	inline CRedrawQueue *RedrawQueue() const;

	inline CWsObjectIx *ObjectIndex();

	CWsObject *HandleToObjUntyped(TInt aHandle);

	CWsObject *HandleToObj(TInt aHandle, WH_HANDLES aType);

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

//

	inline void EventReady(const RMessagePtr2& aEventMsg);

	inline void GetEventData();

	inline void CancelEvent();

	inline void PurgePointerEvents();

	inline void RedrawEventReady(const RMessagePtr2& aEventMsg);

	inline void CancelRedrawEvent();

	inline void GetRedrawData();

	inline void PriorityKeyEventReady(const RMessagePtr2& aEventMsg);

	inline void CancelPriorityKeyEvent();

	inline void GetPriorityKeyData();

	inline void PriorityKeyPressed(TInt aHandle, const TKeyData &aKey, TInt aScanCode);

	void TriggerRedraw();

	void SessionPanic(TClientPanic aReason) const;

	void SessionTerminate();

	void UpdateWindowOrdinalPrioritys();

	void CreateNewWindowGroupL(const TWsClCmdCreateWindowGroup &aCmd);

	void CreateNewWindowL(const TWsClCmdCreateWindow &aCmd);

	void CreateNewAnimDllL(const TWsClCmdUnion &aParams);

//

	void CreateNewSpriteL(const TWsClCmdCreateSprite &aCmd);

	void CreateNewPointerCursorL(const TWsClCmdCreatePointerCursor &aCmd);

	void StartSetCustomTextCursorL(const TWsClCmdCustomTextCursorData& aCmd);

	void CompleteSetCustomTextCursorL(TInt aErr);

	static CWsCustomTextCursor* FindCustomTextCursor(TInt aIdentifier);

	void CreateNewScreenDeviceL( TInt aDefaultScreenNumber, TUint aClientScreenDevicePointer);

	void CreateNewBitmapL(const TWsClCmdCreateBitmap &aCmd);

	void CreateNewClickL(const TUid& aUid);

//

	void ReplyGroupName(HBufC *aName, TInt aMaxLength) const;

	inline TInt ObjectHandle(const CWsObject *aThis);

	void SetSystemPointerCursorL(TInt aIndex, CWsPointerCursor *aCursor);

	void ClearSystemPointerCursor(TInt aIndex);

	void ClaimSystemPointerCursorListL();

	void FreeSystemPointerCursorList();

	static CWsPointerCursor *SystemPointerCursor(TInt aIndex);

	static inline CWsPointerCursor *DefaultSystemPointerCursor();

	void SetDefaultSystemPointerCursor(TInt aIndex);

	void SetComputeMode(RWsSession::TComputeMode aComputeMode);

	void SetClientPriority();

	inline TInt ConnectionHandle() const;

	inline DWsScreenDevice *PrimaryScreenDevice() const;

 	inline void NotifyScreenDeviceDeleted(DWsScreenDevice* aDeletedScreenDevice);

	inline CScreen* Screen() const;

	inline TBool NotClosing() const;

	inline const RMessage2& ClientMessage() const;

	void RemoteRead(TDes16& aDes, TInt aOffset);

	void RemoteRead(TDes8& aDes, TInt aOffset);

	void RemoteReadL(TDes16& aDes, TInt aOffset);

	void RemoteReadL(TDes8& aDes, TInt aOffset);

	static void DeleteStatics();

	void SetResponseHandle(RHandleBase* aHandle);

	// from MWsClient

	TBool HasCapability(TCapability aCapability) const;

	TSecureId SecureId() const;

	TVendorId VendorId() const;

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

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

	CWsGraphicDrawerObject* DrawerObject(const CWsGraphicDrawer* aDrawer);

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

	static inline CWsClient* CurrentClient();

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

 	static TBool DebugEnforceRedrawCallingConvention();

private: // from CSession2

	void ServiceL(const RMessage2 &aMessage);

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

private:

	void CompleteInitializationL();

	static void DeleteSystemPointerListEntry(TInt aIndex);

	static TBool FindCursorArrayItem (CArrayFixFlat<TWsCursorArrayItem>* aCursorArray,

									  TInt aIndex, TInt& aPosition);

	static inline CWsPointerCursor*& PointerCursor (TInt aPosition);

	static inline CWsCustomTextCursor*& TextCursor (TInt aPosition);

	void CommandL(TInt aOpcode, const RMessage2& aMessage);

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

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

	void InitialiseScreenDevices();

	inline TBool IsInitialised();

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

public:

	static TWsCmdHeaderBase iCurrentCommand;

private:

	enum TInternalFlags

		{

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

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

		};

private:	// Private data

	RThread iClient;

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

	CEventQueue *iEventQueue;

	CRedrawQueue *iRedrawQueue;

	CPriorityKey *iPriorityKeyEvent;

	CWsGraphicMessageQueue iGraphicMessageQueue;

	RWsSession::TComputeMode iComputeMode;

	CWsObjectIx *iObjectIndex;

	DWsScreenDevice *iPrimaryScreenDevice;

	TWsCursorArrayItem iTempCustomTextCursor;

	CScreen* iScreen;		//## This needs updating

	mutable TInt iPanicReason;

	mutable TInt iInternalFlags;

	RMessage2 iClientMessage;

	RHandleBase* iResponseHandle;

	TInt iMessageIdSeq;

	TBool iIsInitialised;

#if defined(_DEBUG)

	TBool iLastCommand;

#endif

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

	static TInt iReply;					// Value to reply

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

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

	static CWsPointerCursor *iDefaultSystemPointerCursor;

	static CArrayFixFlat<TWsCursorArrayItem> *iSystemPointerCursors;

	static CWsClient *iSystemPointerCursorListOwner;

	static CArrayFixFlat<TWsCursorArrayItem> *iTextCursorArray;

	static TBuf8<EClientBufferMaxSize> iCmdBuf;

	static TUint iConnectionId;

 	static TBool iDebug_EnforceRedrawCallingConvention;

#if defined(__WINS__)

	TBool iRemoveKeyCode;

public:

	inline TBool RemoveKeyCode();

#endif

	};

//

// inlines			//

//

//

inline const RThread& CWsClient::Client() const

	{return iClient;}

inline CWindowServer& CWsClient::WindowServer()

	{return *reinterpret_cast<CWindowServer*>(const_cast<CServer2*>(Server()));}

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

	{iEventQueue->EventReady(aEventMsg);}

inline void CWsClient::GetEventData()

    {iEventQueue->GetData();}

inline void CWsClient::PurgePointerEvents()

	{iEventQueue->PurgePointerEvents();}

inline void CWsClient::CancelEvent()

	{iEventQueue->CancelRead();}

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

    {iRedrawQueue->EventReady(aEventMsg);}

inline void CWsClient::GetRedrawData()

    {iRedrawQueue->GetData();}

inline void CWsClient::CancelRedrawEvent()

	{iRedrawQueue->CancelRead();}

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

    {iPriorityKeyEvent->EventReady(aEventMsg);}

inline void CWsClient::CancelPriorityKeyEvent()

	{iPriorityKeyEvent->CancelRead();}

inline void CWsClient::GetPriorityKeyData()

	{iPriorityKeyEvent->GetData();}

inline void CWsClient::PriorityKeyPressed(TInt aHandle, const TKeyData &aKey, TInt aScanCode)

	{iPriorityKeyEvent->PriorityKey(aHandle,aKey,aScanCode);}

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

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

#if defined(__WINS__)

inline TBool CWsClient::RemoveKeyCode()

	{return iRemoveKeyCode;}

#endif

//

inline CEventQueue *CWsClient::EventQueue() const

	{return(iEventQueue);}

inline CRedrawQueue *CWsClient::RedrawQueue() const

	{return(iRedrawQueue);}

inline CWsObjectIx *CWsClient::ObjectIndex()

	{return(iObjectIndex);}

inline TInt CWsClient::ConnectionHandle() const

	{return(iConnectionHandle);}

inline DWsScreenDevice *CWsClient::PrimaryScreenDevice() const

	{return(iPrimaryScreenDevice);}

inline void CWsClient::NotifyScreenDeviceDeleted(DWsScreenDevice* aDeletedScreenDevice)

	{

	if (iPrimaryScreenDevice == aDeletedScreenDevice)

		iPrimaryScreenDevice = NULL;

	}

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

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

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

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

inline const RMessage2& CWsClient::ClientMessage() const

	{return iClientMessage;}

inline CScreen* CWsClient::Screen() const

	{return iScreen;}

inline TBool CWsClient::NotClosing() const

	{return !(iInternalFlags&EClientIsClosing);}

inline CWsClient* CWsClient::CurrentClient()

	{return iCurrentClient;}

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

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

inline TBool CWsClient::IsInitialised()

	{return iIsInitialised;}

#endif