// Copyright (c) 1994-2010 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:

// Client handling

// 

//

#include "CLIENT.H"

#include "ANIM.H"

#include "Direct.H"

#include "EVENT.H"

#include "KEYCLICK.H"

#include "server.h"

#include "gc.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "wstop.h"

#include "panics.h"

#include "../CLIENT/w32comm.h"

#include "password.h"

#include "pointer.h"

#include <u32hal.h> // EHalGroupEmulator

#include "WsMemMgr.h"

#include <e32hashtab.h>  // for RHashMap

#include "registeredsurfacemap.h"

#include <graphics/wselement.h>

#include "windowelementset.h"

#include "drawresource.h"

extern CDebugLogBase* wsDebugLog;

_LIT(KWSERVSessionPanicCategory,"WSERV");

GLREF_D TPtr nullDescriptor;

TWsCmdHeaderBase CWsClient::iCurrentCommand;

TBuf8<EClientBufferMaxSize> CWsClient::iCmdBuf;

TInt CWsClient::iReply;

TInt CWsClient::iReplyOffset;

CWsClient* CWsClient::iCurrentClient;

CWsObject* CWsClient::iDestObj;

const TUint8* CWsClient::iNextCmd;

TUint CWsClient::iConnectionId = CDebugLogBase::EDummyConnectionId+1;

CArrayFixFlat<CWsClient::TWsCursorArrayItem>* CWsClient::iSystemPointerCursors = NULL;

TInt CWsClient::iDefaultSystemPointerCursorIndex = 0;		//Negative when there isn't one

CWsPointerCursor* CWsClient::iDefaultSystemPointerCursor;

CWsClient* CWsClient::iSystemPointerCursorListOwner = NULL;

CArrayFixFlat<CWsClient::TWsCursorArrayItem>* CWsClient::iTextCursorArray = NULL;

TKeyArrayFix CWsClient::iCursorKey(_FOFF(CWsClient::TWsCursorArrayItem,iIndex), ECmpTInt);

/**

Used for enforcing the redraw calling convention in emulator builds.

When enabled this will panic any client calling a CWindowGc draw operation outside a 

RWindow::BeginRedraw() / RWindow::EndRedraw() pair (known as non-redraw drawing).

Enable by adding "debug_wserv_exe_EnforceRedrawCallingConvention X" to epoc.ini 

where X is either 0 (zero) for "off" or 1 (one) for "on". 

Then enable globally in WServ AutoFlush by defining __AUTO_FLUSH in ../client/client.h 

or locally by calling RWsSession::SetAutoFlush(ETrue) for a specific client programatically, 

or locally pressing Ctrl-Alt-Shift-F in the emulator.

*/

TBool CWsClient::iDebug_EnforceRedrawCallingConvention = EFalse;

// Security policy stings

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_PowerMgmt,ECapabilityPowerMgmt);

//

// class CWsClient

// 

CWsClient::CWsClient(RThread aClient) : iClient(aClient), iGraphicMessageQueue(this), iInternalFlags(ERemoveKeyCode|EFinishedProcessingCommands)

	{

	iScreen = CWsTop::Screen();

	}

CWsClient::~CWsClient()

	{

	CWsTop::WindowServer()->RemoveAllGraphicDrawers(*this); // deindexes all graphic drawers owned by this client

	delete iTempCustomTextCursor.iCursor;

	FreeSystemPointerCursorList();

	CWsTop::ClientDestroyed(this);

	if (wsDebugLog)

		{

		_LIT(ClientDestuct,"Client %d destructing");

		wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,ClientDestuct, iConnectionHandle);

		}

	iInternalFlags |= EClientIsClosing;

	delete iObjectIndex;

	delete iEventQueue;

	delete iRedrawQueue;

	delete iPriorityKeyEvent;

	CWsTop::ClearSurfaceMap(this);

	CWsTop::SessionExited(this);

	iClient.Close();

	}

void CWsClient::CompleteInitializationL()

	{

	iObjectIndex = new(ELeave) CWsObjectIx();

	iObjectIndex->ConstructL();

    iEventQueue = new(ELeave) CEventQueue(this);

	iEventQueue->ConstructL();

    iRedrawQueue = new(ELeave) CRedrawQueue(this);

	iRedrawQueue->ConstructL();

    iPriorityKeyEvent = new(ELeave) CPriorityKey(this);

	CWsCliObj::NewL(this);

	iComputeMode = RWsSession::EPriorityControlComputeOff;

	CWsTop::NewSession(this);

#ifdef __WINS__

	TBool halValue = EFalse;

	if (UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty, 

		(TAny*)"debug_wserv_exe_EnforceRedrawCallingConvention", &halValue) == KErrNone)

		{

		iDebug_EnforceRedrawCallingConvention = halValue;

		}

#endif

	iInternalFlags |= EIsInitialised;

	}

TBool CWsClient::DebugEnforceRedrawCallingConvention()

	{

	return iDebug_EnforceRedrawCallingConvention;

	}

void CWsClient::StartInitializationL(TUint aConnectionHandle)

	{

	if (wsDebugLog)

		wsDebugLog->NewClient(aConnectionHandle);

	if (iObjectIndex)

		PPanic(EWservPanicReInitialise);

	else

		{

		iConnectionHandle = aConnectionHandle;

		CompleteInitializationL();

		}

	}

//

// Convert a handle to object checking it is of the correct type.

//

void CWsClient::HandleToWindow(TInt aHandle,CWsWindowBase** pWin)

	{

	if ((*pWin=(CWsWindowBase* )HandleToObjUntyped(aHandle))==NULL ||

		((*pWin)->Type()!=WS_HANDLE_WINDOW && (*pWin)->Type()!=WS_HANDLE_GROUP_WINDOW))

		PPanic(EWservPanicWindow);

	}

//

// Convert a handle to object checking it is of the correct type.

//

void CWsClient::HandleToClientWindow(TInt aHandle,CWsClientWindow** pWin)

	{

	if ((*pWin=(CWsClientWindow*)HandleToObj(aHandle, WS_HANDLE_WINDOW))==NULL)

		PPanic(EWservPanicWindow);

	}

void CWsClient::CreateNewPointerCursorL(const TWsClCmdCreatePointerCursor &aCmd)

	{

	CWsPointerCursor* pc=new(ELeave) CWsPointerCursor(this);

	CleanupStack::PushL(pc);

	pc->ConstructL(aCmd);

	CleanupStack::Pop();

	}

// Create a new custom text cursor

void CWsClient::StartSetCustomTextCursorL(const TWsClCmdCustomTextCursorData& aCmd)

	{

	if (!iTextCursorArray)

		{

		const TInt textCursorArrayGranularity = 4;

		iTextCursorArray = new(ELeave) CArrayFixFlat<TWsCursorArrayItem>(textCursorArrayGranularity);

		}

	TInt arrayIndex = KErrNotFound;

	if (FindCursorArrayItem(iTextCursorArray, aCmd.identifier, arrayIndex))

		User::Leave(KErrAlreadyExists);

	delete iTempCustomTextCursor.iCursor;

	iTempCustomTextCursor.iCursor = NULL;

	iTempCustomTextCursor.iCursor = new(ELeave) CWsCustomTextCursor(this, aCmd.alignment);

	static_cast<CWsCustomTextCursor*>(iTempCustomTextCursor.iCursor)->ConstructL(aCmd.flags);

	iTempCustomTextCursor.iIndex = aCmd.identifier;

	}

// Add new custom text cursor to global list

void CWsClient::CompleteSetCustomTextCursorL(TInt aError)

	{

	if (aError)

		{

		delete iTempCustomTextCursor.iCursor;

		iTempCustomTextCursor.iCursor = NULL;

		User::Leave(aError);

		}

	TWsCursorArrayItem entry = iTempCustomTextCursor;

	iTempCustomTextCursor.iCursor = NULL;

	CleanupStack::PushL(entry.iCursor);

	TInt arrayIndex;

	if (FindCursorArrayItem(iTextCursorArray, entry.iIndex, arrayIndex))

		User::Leave(KErrAlreadyExists);

	else

		iTextCursorArray->InsertIsqL(entry, iCursorKey);

	CleanupStack::Pop(entry.iCursor);

	}

CWsCustomTextCursor* CWsClient::FindCustomTextCursor(TInt aIdentifier)

	{

	TInt arrayIndex;

	if (!FindCursorArrayItem(iTextCursorArray, aIdentifier, arrayIndex))

		return NULL;

	return TextCursor(arrayIndex);

	}

void CWsClient::CreateNewSpriteL(const TWsClCmdCreateSprite &aCmd)

	{

	CWsSprite* sprite = new(ELeave) CWsSprite(this);

	CleanupStack::PushL(sprite);

	sprite->ConstructL(aCmd);

	CleanupStack::Pop();

	}

void CWsClient::CreateNewBitmapL(const TWsClCmdCreateBitmap &aCmd)

	{

	DWsBitmap* bitmap = new(ELeave) DWsBitmap(this);

	CleanupStack::PushL(bitmap);

	bitmap->ConstructL(aCmd);

	CleanupStack::Pop();

	}

/** Creates a new window.

If the parent is a window group then a new CWsTopClientWindow instance is created. If the parent is

a window then a new CWsClientWindow instance is created.

@param aCmd The command received from the client

@internalComponent

@released

*/

void CWsClient::CreateNewWindowL(const TWsClCmdCreateWindow &aCmd)

	{

	CWsWindowBase* parent;

	HandleToWindow(aCmd.parent,&parent);

	CWsClientWindow* win = NULL;

	TBool deviceIsInvalid = EFalse;

	CScreen* screen = parent->Screen();

	if (parent->WinType()==EWinTypeGroup)

		{

		__ASSERT_DEBUG(!((CWsWindowGroup*)parent)->ScreenDeviceDeleted(),PPanic(EWservPanicGroupWinScreenDeviceDeleted));

		win=new(ELeave) CWsTopClientWindow(this, screen);

		deviceIsInvalid=!((CWsWindowGroup*)parent)->ScreenDeviceValid();

		}

	else

		win=new(ELeave) CWsClientWindow(this, screen);

	CleanupStack::PushL(win);

	win->ConstructL(aCmd,parent,deviceIsInvalid);

	CleanupStack::Pop(win);

	}

void CWsClient::CreateNewWindowGroupL(const TWsClCmdCreateWindowGroup &aCmd)

	{

	CWsWindowGroup::NewL(this, NULL, aCmd); //screen is initialised inside the constructL

	}

void CWsClient::CreateNewAnimDllL(const TWsClCmdUnion &aParams)

	{

	CWsAnimDll* animDll = new(ELeave) CWsAnimDll(this);

	CleanupStack::PushL(animDll);

	animDll->LoadL(BufferTPtr((TText*)(aParams.LoadAnimDll+1),aParams.LoadAnimDll->length));

	CleanupStack::Pop();

	}	

void CWsClient::CreateNewScreenDeviceL(TInt aDefaultScreenNumber, TUint aClientScreenDevicePointer)

	{

	DWsScreenDevice* screenDevice = new(ELeave) DWsScreenDevice(this, aDefaultScreenNumber,aClientScreenDevicePointer);

	CleanupStack::PushL(screenDevice);

	screenDevice->ConstructL();

	CleanupStack::Pop(screenDevice);

	if (iPrimaryScreenDevice==NULL)

		{

		iPrimaryScreenDevice=screenDevice;

		// When client create screen device, change default screen to the one specified.

		// Client should do this immediately after establishing session

		iScreen = iPrimaryScreenDevice->Screen();

		InitialiseScreenDevices();

		}

	}

void CWsClient::InitialiseScreenDevices()

	{

	const TWsObject* ptr = iObjectIndex->FirstObject();

	const TWsObject* end = ptr+iObjectIndex->Length();

	WS_ASSERT_DEBUG(ptr->iObject==NULL, EWsPanicObjectIndexError);

	while(++ptr<end)

		{

		if (ptr->iObject && ptr->iObject->Type()==WS_HANDLE_GROUP_WINDOW)

			{

			CWsWindowGroup* gw = static_cast<CWsWindowGroup*>(ptr->iObject);

			if(!gw->Device())

				gw->SetScreenDevice(iPrimaryScreenDevice);

			}

		}

	}

void CWsClient::CreateNewClickHandlerL(const TUid& aUid)

	{

	CClick* click = new(ELeave) CClick(this);

	CleanupStack::PushL(click);

	click->ConstructL(aUid);

	CleanupStack::Pop(click);

	}

void CWsClient::RequestComplete(TRequestStatus*  &aStatus, TInt aErr)

	{

	Client().RequestComplete(aStatus,aErr);

	}

void CWsClient::PanicCurrentClient(TClientPanic aPanic)

	{

	iCurrentClient->PPanic(aPanic);

	}

void CWsClient::PPanic(TClientPanic aPanic) const

//This function is allowed to leave with out the 'L' convention for special reasons

	{

	SessionPanic(aPanic);

	User::Leave(EPanicLeave);

	}

void CWsClient::SessionPanic(TClientPanic aReason) const

	{

	if (wsDebugLog)

		wsDebugLog->Panic(iConnectionHandle, aReason);

	if (!(iInternalFlags&EPanicClientAsSoonAsPossible)) // keep the first error code

		{

		iInternalFlags |= EPanicClientAsSoonAsPossible;

		iPanicReason = aReason;

		}

	}

void CWsClient::SessionTerminate()

	{

	if (wsDebugLog)

		wsDebugLog->Panic(iConnectionHandle, 0);

	const RThread thread=Client();

	RProcess process;

	if (thread.Process(process)==KErrNone)

		{

		process.Terminate(0);

		process.Close();

		}

	}

/**	

Returns the remaining space in the descriptor

*/

TInt CWsClient::ReplyBufSpace() 

	{

	const TInt retVal = iCurrentClient->ClientMessage().GetDesLength(KReplyBufferMessageSlot);

	if (iReplyOffset>=0 && retVal>=iReplyOffset)

		return retVal-iReplyOffset;

	else

		return (retVal<0 ? retVal : KErrBadDescriptor);

	}

void CWsClient::ReplyBuf(const TDesC16 &aDes)	// static

	{

	WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);

	if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot,aDes,iReplyOffset) != KErrNone)

		PanicCurrentClient(EWservPanicDescriptor);

	iReplyOffset += aDes.Length();

	if (wsDebugLog)

		wsDebugLog->ReplyBuf(aDes);

	}

void CWsClient::ReplyBuf(const TDesC8 &aDes)	// static

	{

	WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);

	if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot, aDes, iReplyOffset) != KErrNone)

		PanicCurrentClient(EWservPanicDescriptor);

	iReplyOffset += aDes.Length();

	if (wsDebugLog)

		wsDebugLog->ReplyBuf(aDes);

	}

void CWsClient::ReplyBuf(const TAny* aSource, TInt aLength)	// static

//

// Send a buffer to the client process.

//

	{

	TPtrC8 src(reinterpret_cast<const TUint8*>(aSource),aLength);

	ReplyBuf(src);

	}

void CWsClient::ReplySize(const TSize &aSize)	// static

	{

	ReplyBuf(&aSize, sizeof(aSize));

	}

void CWsClient::ReplyPoint(const TPoint &aPoint)	// static

	{

	ReplyBuf(&aPoint, sizeof(aPoint));

	}

void CWsClient::ReplyRect(const TRect &aRect)	// static

	{

	ReplyBuf(&aRect, sizeof(aRect));

	}

void CWsClient::SetReply(TInt reply)

	{

	iReply = reply;

	if (wsDebugLog)

		wsDebugLog->Reply(reply);

	}

const TUint8* CWsClient::EndOfCommandBuffer()

	{

	return(iCmdBuf.Ptr()+iCmdBuf.Size());

	}

const TPtrC CWsClient::BufferTPtr(TText *aStart,TInt aLen)

	{

	TPtrC ptr;

	if (!BufferTPtrGc(aStart,aLen,ptr))

		PanicCurrentClient(EWservPanicBufferPtr);

	return(ptr);

	}

TBool CWsClient::BufferTPtrGc(TText* aStart,TInt aLen, TPtrC& aPtr)

	{

	if (iCurrentCommand.iOpcode>0)

		{

		if ((REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()

										|| REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))

			return(EFalse);

		}

	else

		{

		if (aLen>=iCurrentCommand.iCmdLength)

			return(EFalse);

		}

	aPtr.Set(aStart,aLen);

	return(ETrue);

	}

const TPtrC8 CWsClient::BufferTPtr8(TUint8* aStart,TInt aLen)

	{

	if (iCurrentCommand.iOpcode>0 && (REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()

										|| REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))

		PanicCurrentClient(EWservPanicBufferPtr);

	return(TPtrC8(aStart,aLen));

	}

/**

Process a command buffer

@internalComponent

@released

*/

void CWsClient::DispatchCommandsInBufL()	// (step #4)

	{		

	if (wsDebugLog)

		{

 		wsDebugLog->CommandBuf(iConnectionHandle);

 		RThread client = Client(); 

 		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, client.FullName());

		}

	const TUint8* endCmd=iCmdBuf.Ptr()+iCmdBuf.Length();

	do

		{

		const TWsCmdHeader* pCmd=

				reinterpret_cast<const TWsCmdHeader*>(iNextCmd);

		TUint opcode = pCmd->iBase.iOpcode;

		TInt headerLen = sizeof(pCmd->iBase);

		iCurrentCommand = pCmd->iBase;

		// For performance reasons the handle is only included

		// if it is different from the previous command. The EWsOpcodeHandle

		// flag indicates whether a new handle has been included in the

		// current command. If not we use the same handle as the previous

		// command.

		if (opcode&EWsOpcodeHandle)

			{

			// Find the WServ object associated with this op code

			opcode &= ~EWsOpcodeHandle;

			iCurrentCommand.iOpcode = reinterpret_cast<TUint16&>(opcode);

			iDestObj=HandleToObjUntyped(pCmd->iDestHandle);

			headerLen = sizeof(*pCmd);

			}

		iNextCmd += headerLen;

		const TAny* cmdParams = iNextCmd;

		iNextCmd += pCmd->iBase.iCmdLength;

		if (!iDestObj || iNextCmd>endCmd)		// Invalid handle or Corrupt buffer

			{

			SessionPanic(iDestObj==NULL ? EWservPanicHandle : EWservPanicBuffer);

			iInternalFlags|=EFinishedProcessingCommands;

			break;

			}

		if (iNextCmd==endCmd)

			iInternalFlags|=EFinishedProcessingCommands;

		if (wsDebugLog)

			wsDebugLog->Command(iDestObj->Type(), opcode, cmdParams, iDestObj->LogHandle());

		// Dispatch the command to the WServ object that will process it

		iDestObj->CommandL(opcode, cmdParams);	// (call #5)

		} 

	while(iNextCmd<endCmd);

	}

void CWsClient::DoServiceCommandBuf() // (step #3.1)

	{

	iCurrentClient=this;

	iInternalFlags&=~EFinishedProcessingCommands;

	TRAPD(err, DispatchCommandsInBufL());	// (call #4)

#if defined(_DEBUG)

	if (err!=KErrNone && !(iInternalFlags&(EFinishedProcessingCommands|EPanicClientAsSoonAsPossible)))

		SessionPanic(EWservPanicFunctionLeave);

#endif

	if (err<KErrNone)

		SetReply(err);

	if (iInternalFlags&(EFinishedProcessingCommands|EPanicClientAsSoonAsPossible))

		CompleteMessage(iClientMessage,iReply);	// (finish)

	iCurrentClient=NULL;

#if defined(_DEBUG)

	User::Heap().Check();

#endif

	}

void CWsClient::ExecuteAsyncClientCommandL(TInt aOpcode, const RMessage2& aMessage)	// (step #3.2)

	{

	switch(aOpcode)

		{

		case EWsClOpEventReady:

			EventReady(aMessage);

			break;

		case EWsClOpPriorityKeyReady:

			PriorityKeyEventReady(aMessage);

			break;

		case EWsClOpRedrawReady:

			RedrawEventReady(aMessage);

			break;

		case EWsClOpGraphicMessageReady:

			iGraphicMessageQueue.EventReady(aMessage);

			break;

		default:

			{

			PPanic(EWservPanicOpcode);

			break;

			}

		}

	}

void CWsClient::ExecuteCommandL(TInt aOpcode, const TAny* aCmdData)	// (step #6)

	{

	TWsClCmdUnion pData;

	pData.any=aCmdData;

	switch(aOpcode)

		{

		case EWsClOpCreateWindowGroup:

			CreateNewWindowGroupL(*pData.CreateWindowGroup);

			break;

		case EWsClOpCreateWindow:

			CreateNewWindowL(*pData.CreateWindow);

			break;

		case EWsClOpCreateGc:

			CWsGc::NewL(this);

			break;

		case EWsClOpCreateAnimDll:

			if (!CheckBuffer(pData.LoadAnimDll->length, KMaxFileName))

				PanicCurrentClient(EWservPanicBufferPtr);

			CreateNewAnimDllL(pData);

			break;

		case EWsClOpCreateGraphic:

			CWsGraphicDrawerObject::NewL(this,pData);

			break;

		case EWsClOpCreateScreenDevice:

			{

			const TInt screenNumber = pData.CreateScreenDevice->screenNumber;

			const TUint clientScreenDevicePointer = pData.CreateScreenDevice->clientScreenDevicePointer;

			if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())

				{

				PPanic(EWservPanicScreenNumber);

				}

			else

				{

				CreateNewScreenDeviceL(screenNumber,clientScreenDevicePointer);

				}

			}

			break;

		case EWsClOpCreateSprite:

			CreateNewSpriteL(*pData.CreateSprite);

			break;

		case EWsClOpCreatePointerCursor:

			CreateNewPointerCursorL(*pData.CreatePointerCursor);

			break;

		case EWsClOpStartSetCustomTextCursor:

			StartSetCustomTextCursorL(*pData.CustomTextCursorData);

			break;

		case EWsClOpCompleteSetCustomTextCursor:

			CompleteSetCustomTextCursorL(*pData.Int);

			break;

		case EWsClOpCreateBitmap:

			CreateNewBitmapL(*pData.CreateBitmap);

			break;

		case EWsClOpCreateDirectScreenAccess:

			CWsDirectScreenAccess::NewL(this,EFalse);

			break;

		case EWsClOpCreateDirectScreenAccessRegionTrackingOnly:

			CWsDirectScreenAccess::NewL(this,ETrue);	//creates a DSA object that will not draw to the screen, but will use just the region tracking functionality

			break;

		case EWsClOpCreateClick:

			CreateNewClickHandlerL(*pData.Uid);

			break;

		case EWsClOpSetHotKey:

			{

			if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetHotKey API")))

				{

				User::Leave(KErrPermissionDenied);

				}

			TWindowServerEvent::SetHotKeyL(*pData.SetHotKey);

			}

			break;

		case EWsClOpClearHotKeys:

			{

			if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::ClearHotKeys API")))

				{

				User::Leave(KErrPermissionDenied);

				}

			TWindowServerEvent::ClearHotKeysL(*pData.UInt);

			}

			break;

		case EWsClOpRestoreDefaultHotKey:

			TWindowServerEvent::ResetDefaultHotKeyL(*pData.UInt);

			break;

		case EWsClOpSetShadowVector:

			PPanic(EWservPanicOpcode); //this op code is deprecated, should never be generated by the client

			break;

		case EWsClOpShadowVector:

			PPanic(EWservPanicOpcode); //this op code is deprecated, should never be generated by the client

			break;

		case EWsClOpSetKeyboardRepeatRate:

			{

			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetKeyboardRepeatRate API")))

				{

				User::Leave(KErrPermissionDenied);

				}

			if ((pData.SetKeyboardRepeatRate->initial.Int()<0) || (pData.SetKeyboardRepeatRate->time.Int()<0))

				{

				User::Leave(KErrArgument);

				}

			CKeyboardRepeat::SetRepeatTime(pData.SetKeyboardRepeatRate->initial,pData.SetKeyboardRepeatRate->time);

			}

			break;

		case EWsClOpGetKeyboardRepeatRate:

			{

			SKeyRepeatSettings settings;

			CKeyboardRepeat::GetRepeatTime(settings.iInitialTime,settings.iTime);

			ReplyBuf(&settings,sizeof(settings));

			}

			break;

		case EWsClOpSetDoubleClick:

			{

			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetDoubleClick API")))

				{

				User::Leave(KErrPermissionDenied);

				}

			TWsPointer::SetDoubleClick(pData.SetDoubleClick->interval,pData.SetDoubleClick->distance);

			}

			break;

		case EWsClOpGetDoubleClickSettings:

			{

			SDoubleClickSettings settings;

			TWsPointer::GetDoubleClickSettings(settings.iInterval,settings.iDistance);

			ReplyBuf(&settings,sizeof(settings));

			}

			break;

		case EWsClOpEventReady:

			// No need to do anything

			break;

		case EWsClOpGetEvent:

			HandleClientRequestForEventData();

			// Check flag if the group message queue is overflow and has pended messages  

			if (iInternalFlags & EWgMsgQueueOverflow)

				{

				iInternalFlags &= ~EWgMsgQueueOverflow;

				CWsWindowGroup::ReleasePendedMessagesToAllGroups(this);

				}

			break;

		case EWsClOpPurgePointerEvents:

			PurgePointerEvents();

			break;

		case EWsClOpEventReadyCancel:

			CancelClientRequestForEventData();

			break;

		case EWsClOpRedrawReady:

			iInternalFlags&=~EIsPerformingRedrawEvent;

			break;

		case EWsClOpRedrawReadyCancel:

			CancelClientRequestForRedrawEvent();

			break;

		case EWsClOpGetRedraw:

			HandleClientRequestForRedrawData();

			break;

		case EWsClOpPriorityKeyReady:

			// No need to do anything

			break;

		case EWsClOpPriorityKeyReadyCancel:

			CancelClientRequestForPriorityKeyEvent();

			break;

		case EWsClOpGetPriorityKey:

			HandleClientRequestForPriorityKeyData();

			break;

		case EWsClOpNumWindowGroups:

			SetReply(CWsWindowGroup::NumWindowGroups(EFalse,* pData.Int));

			break;

		case EWsClOpNumWindowGroupsAllPriorities:

			SetReply(CWsWindowGroup::NumWindowGroups(ETrue, 0));

			break;

		case EWsClOpNumWindowGroupsOnScreen:

			{

			const TInt screenNumber=pData.NumWinGroups->screenNumber;

			if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())

				PPanic(EWservPanicScreenNumber);

			else

				SetReply(CWsWindowGroup::NumWindowGroupsOnScreen(CWsTop::Screen(screenNumber)->RootWindow()->Child(),(pData.NumWinGroups->priority==EAllPriorities),pData.NumWinGroups->priority));

			}

			break;

		case EWsClOpWindowGroupList:

			{

			const TInt screenNumber=pData.WindowGroupList->screenNumber;

			if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())

				PPanic(EWservPanicScreenNumber);

			else

				SetReply(CWsWindowGroup::SendWindowGroupListL(screenNumber,(pData.WindowGroupList->priority==EAllPriorities), pData.WindowGroupList->priority, pData.WindowGroupList->count));

			}

			break;

		case EWsClOpWindowGroupListAllPriorities:

			{

			const TInt screenNumber=pData.WindowGroupList->screenNumber;

			if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())

				PPanic(EWservPanicScreenNumber);

			else

				SetReply(CWsWindowGroup::SendWindowGroupListL(screenNumber,ETrue, 0, pData.WindowGroupList->count));

			}

			break;

		case EWsClOpWindowGroupListAndChain:

			SetReply(CWsWindowGroup::SendWindowGroupListAndChainL(EFalse, pData.WindowGroupList->priority, pData.WindowGroupList->count));

			break;

		case EWsClOpWindowGroupListAndChainAllPriorities:

			SetReply(CWsWindowGroup::SendWindowGroupListAndChainL(ETrue, 0, pData.WindowGroupList->count));

			break;

		case EWsClOpGetDefaultOwningWindow:

			{

			const TInt screenNumber = *pData.Int;

			if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())

				PPanic(EWservPanicScreenNumber);

			else

				{

				CScreen* screen = (screenNumber ==KDummyScreenNumber) ? iScreen : CWsTop::Screen(screenNumber);

				SetReply(screen->DefaultOwningWindowGroup() ? screen->DefaultOwningWindowGroup()->Identifier():0);

				}

			}

			break;

		case EWsClOpGetFocusWindowGroup:

			{

			const TInt screenNumber = *pData.Int;

			if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())

				PPanic(EWservPanicScreenNumber);

			else

				CWsWindowGroup::GetFocusWindowGroupL(screenNumber);

			}

			break;

		case EWsClOpSetWindowGroupOrdinalPosition:

			CWsWindowGroup::WindowGroupFromIdentifierL(pData.SetWindowGroupOrdinalPosition->identifier)->SetOrdinalPosition(pData.SetWindowGroupOrdinalPosition->position);

			break;

		case EWsClOpGetWindowGroupHandle:

			SetReply(CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->ClientHandle());

			break;

		case EWsClOpGetWindowGroupOrdinalPriority:

			SetReply(CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->OrdinalPriority());

			break;

		case EWsClOpGetWindowGroupClientThreadId:

			{

			TThreadId id=CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->WsOwner()->Client().Id();

			ReplyBuf(&id,sizeof(id));

			}

			break;

		case EWsClOpSendEventToWindowGroup:

			{

			CWsWindowGroup* group=CWsWindowGroup::WindowGroupFromIdentifierL(pData.SendEventToWindowGroup->parameter);

			TWsEvent event=pData.SendEventToWindowGroup->event;

			event.SetHandle(group->ClientHandle());

			// Events in enum TEventCode is protected by capabilities

			if (group->WsOwner()!=this && event.Type()>=EEventNull && event.Type()<EEventUser)

				{

				if (event.Type()<EEventPowerMgmt || event.Type()>=EEventReserved)

					{

					if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToWindowGroup API")))

						User::Leave(KErrPermissionDenied);

					}

				else

					{

					if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToWindowGroup API")))

						User::Leave(KErrPermissionDenied);

					}

				}

			if (event.Type()==EEventKey && event.Key()->iRepeats!=0)

				CKeyboardRepeat::CancelRepeat(NULL);		//Otherwise we will trip an invarient

			if (!group->EventQueue()->QueueEvent(event))

				User::Leave(KErrNoMemory);

			}

			break;

		case EWsClOpSendEventToAllWindowGroup:

		case EWsClOpSendEventToAllWindowGroupPriority:

		case EWsClOpSendEventToOneWindowGroupPerClient:

			{

			TWsEvent event=pData.SendEventToWindowGroup->event;

			if (event.Type()<0)

				User::Leave(KErrArgument);

			if(event.Type()<EEventUser)

				{

				if (event.Type()<EEventPowerMgmt || event.Type()>=EEventReserved)

					{

					if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToAllWindowGroup API")))

						User::Leave(KErrPermissionDenied);

					}

				else 

					{

					if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToAllWindowGroup API")))

						User::Leave(KErrPermissionDenied);

					}

				}

			if (!CWsWindowGroup::SendEventToAllGroups(aOpcode!=EWsClOpSendEventToAllWindowGroupPriority

													,aOpcode==EWsClOpSendEventToOneWindowGroupPerClient,*pData.SendEventToWindowGroup))

				User::Leave(KErrNoMemory);

			}

			break;

		case EWsClOpSendMessageToWindowGroup:

			{

			CWsWindowGroup* group=CWsWindowGroup::WindowGroupFromIdentifierL(pData.SendMessageToWindowGroup->identifierOrPriority);

			if (group->WsOwner()!=this)

				{

				if (!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendMessageToWindowGroup API")))

					{

					User::Leave(KErrPermissionDenied);

					}

				}

			group->QueueMessageL(pData.SendMessageToWindowGroup->uid, pData.SendMessageToWindowGroup->dataLength,* this);

			}

			break;

		case EWsClOpSendMessageToAllWindowGroups:

		case EWsClOpSendMessageToAllWindowGroupsPriority:

			{

			if ((pData.SendMessageToWindowGroup->dataLength<0) || (pData.SendMessageToWindowGroup->dataLength>=(KMaxTInt/2)))

				{

				User::Leave(KErrArgument);

				}

			CWsWindowGroup::SendMessageToAllGroupsL(*this,aOpcode==EWsClOpSendMessageToAllWindowGroups,*pData.SendMessageToWindowGroup);

			}

			break;

		case EWsClOpFetchMessage:

			CWsWindowGroup::WindowGroupFromIdentifierL(pData.FetchMessage->windowGroupIdentifier)->FetchMessageL();

			break;

		case EWsClOpGetWindowGroupNameFromIdentifier:

			ReplyGroupName(CWsWindowGroup::WindowGroupFromIdentifierL(pData.GetWindowGroupNameFromIdentifier->identifier)->GroupName(),pData.GetWindowGroupNameFromIdentifier->maxLength);

			break;

		case EWsClOpFindWindowGroupIdentifier:

			{

			if (pData.FindWindowGroupIdentifier->length<0)

				User::Leave(KErrArgument);

			TPtrC ptr(BufferTPtr((TText*)(pData.FindWindowGroupIdentifier+1),pData.FindWindowGroupIdentifier->length));

			SetReply(CWsWindowGroup::FindWindowGroupL(this, pData.FindWindowGroupIdentifier->identifier,

							pData.FindWindowGroupIdentifier->offset,&ptr,NULL)->Identifier());

			}

			break;

		case EWsClOpFindWindowGroupIdentifierThread:

			SetReply(CWsWindowGroup::FindWindowGroupL(this, pData.FindWindowGroupIdentifierThread->identifier,0,NULL,

											&pData.FindWindowGroupIdentifierThread->threadId)->Identifier());

			break;

		case EWsClOpSetBackgroundColor:

			for(TInt i=0;i<CWsTop::NumberOfScreens();i++)

				{

				CWsTop::Screen(i)->RootWindow()->SetColor(*pData.rgb);

				}

			break;

		case EWsClOpGetBackgroundColor:

			SetReply(iScreen->RootWindow()->BackColor().Internal());

			break;

		case EWsClOpClaimSystemPointerCursorList:

			{

			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::ClaimSystemPointerCursorList API")))

				{

				User::Leave(KErrPermissionDenied);

				}

			ClaimSystemPointerCursorListL();

			}

			break;

		case EWsClOpFreeSystemPointerCursorList:

			FreeSystemPointerCursorList();

			break;

		case EWsClOpSetSystemPointerCursor:

			{

			CWsObject* pointercursor = NULL;

			if ((pointercursor=HandleToObj(pData.SetSystemPointerCursor->handle, WS_HANDLE_POINTER_CURSOR))==NULL)

				PPanic(EWservPanicSprite);

			SetSystemPointerCursorL(pData.SetSystemPointerCursor->number, (CWsPointerCursor* )pointercursor);

			}

			break;

		case EWsClOpClearSystemPointerCursor:

			ClearSystemPointerCursor(*pData.Int);

			break;

		case EWsClOpSetPointerCursorArea:

			{

			if(KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorArea API")))

				{

				if (!iScreen->IsValidScreenSizeMode(*pData.Int))

					PPanic(EWservPanicScreenModeNumber);

				iScreen->SetPointerCursorArea(pData.SetPointerCursorArea->mode,pData.SetPointerCursorArea->area);

				}

			}

			break;

		case EWsClOpPointerCursorArea:

			if (!iScreen->IsValidScreenSizeMode(*pData.Int))

				PPanic(EWservPanicScreenModeNumber);

			ReplyRect(iScreen->GetPointerCursorArea(*pData.Int));

			break;

		case EWsClOpSetPointerCursorMode:

			{

			CWsWindowGroup* focusWinGp=CWsTop::FocusWindowGroup();

			if (focusWinGp && focusWinGp->WsOwner()==this)

				{

				TWsPointer::SetPointerCursorMode(*pData.Mode);

				TWsPointer::UpdatePointerCursor();

				}

			}

			break;

		case EWsClOpSetClientCursorMode :

			{

			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorModeIfFocused API")))

				{

				User::Leave(KErrPermissionDenied);