Symaptic: os/graphics/windowing/windowserver/nga/SERVER/openwfc/CLIENT.CPP@260cb5ec6c19

     1 // Copyright (c) 1994-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 // Client handling

    15 //

    16 //

    18 #include "CLIENT.H"

    20 #include "ANIM.H"

    21 #include "Direct.H"

    22 #include "EVENT.H"

    23 #include "KEYCLICK.H"

    24 #include "server.h"

    25 #include "gc.h"

    26 #include "rootwin.h"

    27 #include "windowgroup.h"

    28 #include "wstop.h"

    29 #include "panics.h"

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

    31 #include "password.h"

    32 #include "pointer.h"

    33 #include <u32hal.h> // EHalGroupEmulator

    34 #include "WsMemMgr.h"

    35 #include <e32hashtab.h>  // for RHashMap

    36 #include "registeredsurfacemap.h"

    37 #include <graphics/wselement.h>

    39 #include "windowelementset.h"

    40 #include "drawresource.h"

    42 extern CDebugLogBase* wsDebugLog;

    43 _LIT(KWSERVSessionPanicCategory,"WSERV");

    45 GLREF_D TPtr nullDescriptor;

    47 TWsCmdHeaderBase CWsClient::iCurrentCommand;

    48 TBuf8<EClientBufferMaxSize> CWsClient::iCmdBuf;

    49 TInt CWsClient::iReply;

    50 TInt CWsClient::iReplyOffset;

    51 CWsClient* CWsClient::iCurrentClient;

    52 CWsObject* CWsClient::iDestObj;

    53 const TUint8* CWsClient::iNextCmd;

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

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

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

    58 CWsPointerCursor* CWsClient::iDefaultSystemPointerCursor;

    59 CWsClient* CWsClient::iSystemPointerCursorListOwner = NULL;

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

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

    64 /**

    65 Used for enforcing the redraw calling convention in emulator builds.

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

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

    69 Enable by adding "debug_wserv_exe_EnforceRedrawCallingConvention X" to epoc.ini

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

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

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

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

    75 */

    76 TBool CWsClient::iDebug_EnforceRedrawCallingConvention = EFalse;

    78 // Security policy stings

    79 static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);

    80 static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);

    81 static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_PowerMgmt,ECapabilityPowerMgmt);

    83 //

    84 // class CWsClient

    85 //

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

    88 	{

    89 	iScreen = CWsTop::Screen();

    90 	}

    92 CWsClient::~CWsClient()

    93 	{

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

    96 	delete iTempCustomTextCursor.iCursor;

    97 	FreeSystemPointerCursorList();

    98 	CWsTop::ClientDestroyed(this);

    99 	if (wsDebugLog)

   100 		{

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

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

   103 		}

   105 	iInternalFlags |= EClientIsClosing;

   106 	delete iObjectIndex;

   107 	delete iEventQueue;

   108 	delete iRedrawQueue;

   109 	delete iPriorityKeyEvent;

   110 	CWsTop::ClearSurfaceMap(this);

   112 	CWsTop::SessionExited(this);

   113 	iClient.Close();

   114 	}

   116 void CWsClient::CompleteInitializationL()

   117 	{

   118 	iObjectIndex = new(ELeave) CWsObjectIx();

   119 	iObjectIndex->ConstructL();

   121     iEventQueue = new(ELeave) CEventQueue(this);

   122 	iEventQueue->ConstructL();

   124     iRedrawQueue = new(ELeave) CRedrawQueue(this);

   125 	iRedrawQueue->ConstructL();

   127     iPriorityKeyEvent = new(ELeave) CPriorityKey(this);

   129 	CWsCliObj::NewL(this);

   131 	iComputeMode = RWsSession::EPriorityControlComputeOff;

   133 	CWsTop::NewSession(this);

   135 #ifdef __WINS__

   136 	TBool halValue = EFalse;

   137 	if (UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty,

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

   139 		{

   140 		iDebug_EnforceRedrawCallingConvention = halValue;

   141 		}

   142 #endif

   144 	iInternalFlags |= EIsInitialised;

   145 	}

   147 TBool CWsClient::DebugEnforceRedrawCallingConvention()

   148 	{

   149 	return iDebug_EnforceRedrawCallingConvention;

   150 	}

   152 void CWsClient::StartInitializationL(TUint aConnectionHandle)

   153 	{

   154 	if (wsDebugLog)

   155 		wsDebugLog->NewClient(aConnectionHandle);

   157 	if (iObjectIndex)

   158 		PPanic(EWservPanicReInitialise);

   159 	else

   160 		{

   161 		iConnectionHandle = aConnectionHandle;

   162 		CompleteInitializationL();

   163 		}

   164 	}

   166 //

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

   168 //

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

   170 	{

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

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

   173 		PPanic(EWservPanicWindow);

   174 	}

   176 //

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

   178 //

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

   180 	{

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

   182 		PPanic(EWservPanicWindow);

   183 	}

   185 void CWsClient::CreateNewPointerCursorL(const TWsClCmdCreatePointerCursor &aCmd)

   186 	{

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

   188 	CleanupStack::PushL(pc);

   189 	pc->ConstructL(aCmd);

   190 	CleanupStack::Pop();

   191 	}

   193 // Create a new custom text cursor

   194 void CWsClient::StartSetCustomTextCursorL(const TWsClCmdCustomTextCursorData& aCmd)

   195 	{

   196 	if (!iTextCursorArray)

   197 		{

   198 		const TInt textCursorArrayGranularity = 4;

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

   200 		}

   202 	TInt arrayIndex = KErrNotFound;

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

   204 		User::Leave(KErrAlreadyExists);

   206 	delete iTempCustomTextCursor.iCursor;

   207 	iTempCustomTextCursor.iCursor = NULL;

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

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

   211 	iTempCustomTextCursor.iIndex = aCmd.identifier;

   212 	}

   214 // Add new custom text cursor to global list

   215 void CWsClient::CompleteSetCustomTextCursorL(TInt aError)

   216 	{

   217 	if (aError)

   218 		{

   219 		delete iTempCustomTextCursor.iCursor;

   220 		iTempCustomTextCursor.iCursor = NULL;

   221 		User::Leave(aError);

   222 		}

   224 	TWsCursorArrayItem entry = iTempCustomTextCursor;

   225 	iTempCustomTextCursor.iCursor = NULL;

   226 	CleanupStack::PushL(entry.iCursor);

   228 	TInt arrayIndex;

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

   230 		User::Leave(KErrAlreadyExists);

   231 	else

   232 		iTextCursorArray->InsertIsqL(entry, iCursorKey);

   234 	CleanupStack::Pop(entry.iCursor);

   235 	}

   237 CWsCustomTextCursor* CWsClient::FindCustomTextCursor(TInt aIdentifier)

   238 	{

   239 	TInt arrayIndex;

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

   241 		return NULL;

   243 	return TextCursor(arrayIndex);

   244 	}

   246 void CWsClient::CreateNewSpriteL(const TWsClCmdCreateSprite &aCmd)

   247 	{

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

   249 	CleanupStack::PushL(sprite);

   250 	sprite->ConstructL(aCmd);

   251 	CleanupStack::Pop();

   252 	}

   254 void CWsClient::CreateNewBitmapL(const TWsClCmdCreateBitmap &aCmd)

   255 	{

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

   257 	CleanupStack::PushL(bitmap);

   258 	bitmap->ConstructL(aCmd);

   259 	CleanupStack::Pop();

   260 	}

   262 /** Creates a new window.

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

   265 a window then a new CWsClientWindow instance is created.

   267 @param aCmd The command received from the client

   268 @internalComponent

   269 @released

   270 */

   271 void CWsClient::CreateNewWindowL(const TWsClCmdCreateWindow &aCmd)

   272 	{

   273 	CWsWindowBase* parent;

   274 	HandleToWindow(aCmd.parent,&parent);

   275 	CWsClientWindow* win = NULL;

   276 	TBool deviceIsInvalid = EFalse;

   277 	CScreen* screen = parent->Screen();

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

   279 		{

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

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

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

   283 		}

   284 	else

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

   287 	CleanupStack::PushL(win);

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

   289 	CleanupStack::Pop(win);

   290 	}

   292 void CWsClient::CreateNewWindowGroupL(const TWsClCmdCreateWindowGroup &aCmd)

   293 	{

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

   295 	}

   297 void CWsClient::CreateNewAnimDllL(const TWsClCmdUnion &aParams)

   298 	{

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

   300 	CleanupStack::PushL(animDll);

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

   302 	CleanupStack::Pop();

   303 	}

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

   306 	{

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

   308 	CleanupStack::PushL(screenDevice);

   309 	screenDevice->ConstructL();

   310 	CleanupStack::Pop(screenDevice);

   311 	if (iPrimaryScreenDevice==NULL)

   312 		{

   313 		iPrimaryScreenDevice=screenDevice;

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

   315 		// Client should do this immediately after establishing session

   316 		iScreen = iPrimaryScreenDevice->Screen();

   317 		InitialiseScreenDevices();

   318 		}

   319 	}

   321 void CWsClient::InitialiseScreenDevices()

   322 	{

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

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

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

   326 	while(++ptr<end)

   327 		{

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

   329 			{

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

   331 			if(!gw->Device())

   332 				gw->SetScreenDevice(iPrimaryScreenDevice);

   333 			}

   334 		}

   335 	}

   337 void CWsClient::CreateNewClickHandlerL(const TUid& aUid)

   338 	{

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

   340 	CleanupStack::PushL(click);

   341 	click->ConstructL(aUid);

   342 	CleanupStack::Pop(click);

   343 	}

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

   346 	{

   347 	Client().RequestComplete(aStatus,aErr);

   348 	}

   350 void CWsClient::PanicCurrentClient(TClientPanic aPanic)

   351 	{

   352 	iCurrentClient->PPanic(aPanic);

   353 	}

   355 void CWsClient::PPanic(TClientPanic aPanic) const

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

   357 	{

   358 	SessionPanic(aPanic);

   359 	User::Leave(EPanicLeave);

   360 	}

   362 void CWsClient::SessionPanic(TClientPanic aReason) const

   363 	{

   364 	if (wsDebugLog)

   365 		wsDebugLog->Panic(iConnectionHandle, aReason);

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

   368 		{

   369 		iInternalFlags |= EPanicClientAsSoonAsPossible;

   370 		iPanicReason = aReason;

   371 		}

   372 	}

   374 void CWsClient::SessionTerminate()

   375 	{

   376 	if (wsDebugLog)

   377 		wsDebugLog->Panic(iConnectionHandle, 0);

   379 	const RThread thread=Client();

   380 	RProcess process;

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

   382 		{

   383 		process.Terminate(0);

   384 		process.Close();

   385 		}

   386 	}

   388 /**

   389 Returns the remaining space in the descriptor

   390 */

   391 TInt CWsClient::ReplyBufSpace()

   392 	{

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

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

   396 		return retVal-iReplyOffset;

   397 	else

   398 		return (retVal<0 ? retVal : KErrBadDescriptor);

   399 	}

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

   402 	{

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

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

   406 		PanicCurrentClient(EWservPanicDescriptor);

   408 	iReplyOffset += aDes.Length();

   409 	if (wsDebugLog)

   410 		wsDebugLog->ReplyBuf(aDes);

   411 	}

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

   414 	{

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

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

   418 		PanicCurrentClient(EWservPanicDescriptor);

   420 	iReplyOffset += aDes.Length();

   421 	if (wsDebugLog)

   422 		wsDebugLog->ReplyBuf(aDes);

   423 	}

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

   426 //

   427 // Send a buffer to the client process.

   428 //

   429 	{

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

   431 	ReplyBuf(src);

   432 	}

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

   435 	{

   436 	ReplyBuf(&aSize, sizeof(aSize));

   437 	}

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

   440 	{

   441 	ReplyBuf(&aPoint, sizeof(aPoint));

   442 	}

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

   445 	{

   446 	ReplyBuf(&aRect, sizeof(aRect));

   447 	}

   449 void CWsClient::SetReply(TInt reply)

   450 	{

   451 	iReply = reply;

   452 	if (wsDebugLog)

   453 		wsDebugLog->Reply(reply);

   454 	}

   456 const TUint8* CWsClient::EndOfCommandBuffer()

   457 	{

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

   459 	}

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

   462 	{

   463 	TPtrC ptr;

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

   465 		PanicCurrentClient(EWservPanicBufferPtr);

   466 	return(ptr);

   467 	}

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

   470 	{

   471 	if (iCurrentCommand.iOpcode>0)

   472 		{

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

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

   475 			return(EFalse);

   476 		}

   477 	else

   478 		{

   479 		if (aLen>=iCurrentCommand.iCmdLength)

   480 			return(EFalse);

   481 		}

   482 	aPtr.Set(aStart,aLen);

   483 	return(ETrue);

   484 	}

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

   487 	{

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

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

   490 		PanicCurrentClient(EWservPanicBufferPtr);

   492 	return(TPtrC8(aStart,aLen));

   493 	}

   495 /**

   496 Process a command buffer

   498 @internalComponent

   499 @released

   500 */

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

   502 	{

   503 	if (wsDebugLog)

   504 		{

   505  		wsDebugLog->CommandBuf(iConnectionHandle);

   506  		RThread client = Client();

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

   508 		}

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

   510 	do

   511 		{

   512 		const TWsCmdHeader* pCmd=

   513 				reinterpret_cast<const TWsCmdHeader*>(iNextCmd);

   514 		TUint opcode = pCmd->iBase.iOpcode;

   515 		TInt headerLen = sizeof(pCmd->iBase);

   516 		iCurrentCommand = pCmd->iBase;

   518 		// For performance reasons the handle is only included

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

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

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

   522 		// command.

   523 		if (opcode&EWsOpcodeHandle)

   524 			{

   525 			// Find the WServ object associated with this op code

   526 			opcode &= ~EWsOpcodeHandle;

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

   528 			iDestObj=HandleToObjUntyped(pCmd->iDestHandle);

   529 			headerLen = sizeof(*pCmd);

   530 			}

   532 		iNextCmd += headerLen;

   533 		const TAny* cmdParams = iNextCmd;

   534 		iNextCmd += pCmd->iBase.iCmdLength;

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

   536 			{

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

   538 			iInternalFlags|=EFinishedProcessingCommands;

   539 			break;

   540 			}

   542 		if (iNextCmd==endCmd)

   543 			iInternalFlags|=EFinishedProcessingCommands;

   545 		if (wsDebugLog)

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

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

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

   550 		}

   551 	while(iNextCmd<endCmd);

   553 	}

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

   556 	{

   557 	iCurrentClient=this;

   558 	iInternalFlags&=~EFinishedProcessingCommands;

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

   561 #if defined(_DEBUG)

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

   563 		SessionPanic(EWservPanicFunctionLeave);

   564 #endif

   566 	if (err<KErrNone)

   567 		SetReply(err);

   569 	if (iInternalFlags&(EFinishedProcessingCommands|EPanicClientAsSoonAsPossible))

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

   572 	iCurrentClient=NULL;

   573 #if defined(_DEBUG)

   574 	User::Heap().Check();

   575 #endif

   576 	}

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

   579 	{

   580 	switch(aOpcode)

   581 		{

   582 		case EWsClOpEventReady:

   583 			EventReady(aMessage);

   584 			break;

   585 		case EWsClOpPriorityKeyReady:

   586 			PriorityKeyEventReady(aMessage);

   587 			break;

   588 		case EWsClOpRedrawReady:

   589 			RedrawEventReady(aMessage);

   590 			break;

   591 		case EWsClOpGraphicMessageReady:

   592 			iGraphicMessageQueue.EventReady(aMessage);

   593 			break;

   594 		default:

   595 			{

   596 			PPanic(EWservPanicOpcode);

   597 			break;

   598 			}

   599 		}

   600 	}

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

   605 	{

   606 	TWsClCmdUnion pData;

   607 	pData.any=aCmdData;

   608 	switch(aOpcode)

   609 		{

   610 		case EWsClOpCreateWindowGroup:

   611 			CreateNewWindowGroupL(*pData.CreateWindowGroup);

   612 			break;

   613 		case EWsClOpCreateWindow:

   614 			CreateNewWindowL(*pData.CreateWindow);

   615 			break;

   616 		case EWsClOpCreateGc:

   617 			CWsGc::NewL(this);

   618 			break;

   619 		case EWsClOpCreateAnimDll:

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

   621 				PanicCurrentClient(EWservPanicBufferPtr);

   622 			CreateNewAnimDllL(pData);

   623 			break;

   624 		case EWsClOpCreateGraphic:

   625 			CWsGraphicDrawerObject::NewL(this,pData);

   626 			break;

   627 		case EWsClOpCreateScreenDevice:

   628 			{

   629 			const TInt screenNumber = pData.CreateScreenDevice->screenNumber;

   630 			const TUint clientScreenDevicePointer = pData.CreateScreenDevice->clientScreenDevicePointer;

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

   632 				{

   633 				PPanic(EWservPanicScreenNumber);

   634 				}

   635 			else

   636 				{

   637 				CreateNewScreenDeviceL(screenNumber,clientScreenDevicePointer);

   638 				}

   639 			}

   640 			break;

   641 		case EWsClOpCreateSprite:

   642 			CreateNewSpriteL(*pData.CreateSprite);

   643 			break;

   644 		case EWsClOpCreatePointerCursor:

   645 			CreateNewPointerCursorL(*pData.CreatePointerCursor);

   646 			break;

   647 		case EWsClOpStartSetCustomTextCursor:

   648 			StartSetCustomTextCursorL(*pData.CustomTextCursorData);

   649 			break;

   650 		case EWsClOpCompleteSetCustomTextCursor:

   651 			CompleteSetCustomTextCursorL(*pData.Int);

   652 			break;

   653 		case EWsClOpCreateBitmap:

   654 			CreateNewBitmapL(*pData.CreateBitmap);

   655 			break;

   656 		case EWsClOpCreateDirectScreenAccess:

   657 			CWsDirectScreenAccess::NewL(this,EFalse);

   658 			break;

   659 		case EWsClOpCreateDirectScreenAccessRegionTrackingOnly:

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

   661 			break;

   662 		case EWsClOpCreateClick:

   663 			CreateNewClickHandlerL(*pData.Uid);

   664 			break;

   665 		case EWsClOpSetHotKey:

   666 			{

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

   668 				{

   669 				User::Leave(KErrPermissionDenied);

   670 				}

   671 			TWindowServerEvent::SetHotKeyL(*pData.SetHotKey);

   672 			}

   673 			break;

   674 		case EWsClOpClearHotKeys:

   675 			{

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

   677 				{

   678 				User::Leave(KErrPermissionDenied);

   679 				}

   680 			TWindowServerEvent::ClearHotKeysL(*pData.UInt);

   681 			}

   682 			break;

   683 		case EWsClOpRestoreDefaultHotKey:

   684 			TWindowServerEvent::ResetDefaultHotKeyL(*pData.UInt);

   685 			break;

   686 		case EWsClOpSetShadowVector:

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

   688 			break;

   689 		case EWsClOpShadowVector:

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

   691 			break;

   692 		case EWsClOpSetKeyboardRepeatRate:

   693 			{

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

   695 				{

   696 				User::Leave(KErrPermissionDenied);

   697 				}

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

   699 				{

   700 				User::Leave(KErrArgument);

   701 				}

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

   703 			}

   704 			break;

   705 		case EWsClOpGetKeyboardRepeatRate:

   706 			{

   707 			SKeyRepeatSettings settings;

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

   709 			ReplyBuf(&settings,sizeof(settings));

   710 			}

   711 			break;

   712 		case EWsClOpSetDoubleClick:

   713 			{

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

   715 				{

   716 				User::Leave(KErrPermissionDenied);

   717 				}

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

   719 			}

   720 			break;

   721 		case EWsClOpGetDoubleClickSettings:

   722 			{

   723 			SDoubleClickSettings settings;

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

   725 			ReplyBuf(&settings,sizeof(settings));

   726 			}

   727 			break;

   728 		case EWsClOpEventReady:

   729 			// No need to do anything

   730 			break;

   731 		case EWsClOpGetEvent:

   732 			HandleClientRequestForEventData();

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

   734 			if (iInternalFlags & EWgMsgQueueOverflow)

   735 				{

   736 				iInternalFlags &= ~EWgMsgQueueOverflow;

   737 				CWsWindowGroup::ReleasePendedMessagesToAllGroups(this);

   738 				}

   739 			break;

   740 		case EWsClOpPurgePointerEvents:

   741 			PurgePointerEvents();

   742 			break;

   743 		case EWsClOpEventReadyCancel:

   744 			CancelClientRequestForEventData();

   745 			break;

   746 		case EWsClOpRedrawReady:

   747 			iInternalFlags&=~EIsPerformingRedrawEvent;

   748 			break;

   749 		case EWsClOpRedrawReadyCancel:

   750 			CancelClientRequestForRedrawEvent();

   751 			break;

   752 		case EWsClOpGetRedraw:

   753 			HandleClientRequestForRedrawData();

   754 			break;

   755 		case EWsClOpPriorityKeyReady:

   756 			// No need to do anything

   757 			break;

   758 		case EWsClOpPriorityKeyReadyCancel:

   759 			CancelClientRequestForPriorityKeyEvent();

   760 			break;

   761 		case EWsClOpGetPriorityKey:

   762 			HandleClientRequestForPriorityKeyData();

   763 			break;

   764 		case EWsClOpNumWindowGroups:

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

   766 			break;

   767 		case EWsClOpNumWindowGroupsAllPriorities:

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

   769 			break;

   770 		case EWsClOpNumWindowGroupsOnScreen:

   771 			{

   772 			const TInt screenNumber=pData.NumWinGroups->screenNumber;

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

   774 				PPanic(EWservPanicScreenNumber);

   775 			else

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

   777 			}

   778 			break;

   779 		case EWsClOpWindowGroupList:

   780 			{

   781 			const TInt screenNumber=pData.WindowGroupList->screenNumber;

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

   783 				PPanic(EWservPanicScreenNumber);

   784 			else

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

   786 			}

   787 			break;

   788 		case EWsClOpWindowGroupListAllPriorities:

   789 			{

   790 			const TInt screenNumber=pData.WindowGroupList->screenNumber;

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

   792 				PPanic(EWservPanicScreenNumber);

   793 			else

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

   795 			}

   796 			break;

   797 		case EWsClOpWindowGroupListAndChain:

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

   799 			break;

   800 		case EWsClOpWindowGroupListAndChainAllPriorities:

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

   802 			break;

   803 		case EWsClOpGetDefaultOwningWindow:

   804 			{

   805 			const TInt screenNumber = *pData.Int;

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

   807 				PPanic(EWservPanicScreenNumber);

   808 			else

   809 				{

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

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

   812 				}

   813 			}

   814 			break;

   815 		case EWsClOpGetFocusWindowGroup:

   816 			{

   817 			const TInt screenNumber = *pData.Int;

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

   819 				PPanic(EWservPanicScreenNumber);

   820 			else

   821 				CWsWindowGroup::GetFocusWindowGroupL(screenNumber);

   822 			}

   823 			break;

   824 		case EWsClOpSetWindowGroupOrdinalPosition:

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

   826 			break;

   827 		case EWsClOpGetWindowGroupHandle:

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

   829 			break;

   830 		case EWsClOpGetWindowGroupOrdinalPriority:

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

   832 			break;

   833 		case EWsClOpGetWindowGroupClientThreadId:

   834 			{

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

   836 			ReplyBuf(&id,sizeof(id));

   837 			}

   838 			break;

   839 		case EWsClOpSendEventToWindowGroup:

   840 			{

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

   842 			TWsEvent event=pData.SendEventToWindowGroup->event;

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

   844 			// Events in enum TEventCode is protected by capabilities

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

   846 				{

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

   848 					{

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

   850 						User::Leave(KErrPermissionDenied);

   851 					}

   852 				else

   853 					{

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

   855 						User::Leave(KErrPermissionDenied);

   856 					}

   857 				}

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

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

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

   861 				User::Leave(KErrNoMemory);

   862 			}

   863 			break;

   864 		case EWsClOpSendEventToAllWindowGroup:

   865 		case EWsClOpSendEventToAllWindowGroupPriority:

   866 		case EWsClOpSendEventToOneWindowGroupPerClient:

   867 			{

   868 			TWsEvent event=pData.SendEventToWindowGroup->event;

   869 			if (event.Type()<0)

   870 				User::Leave(KErrArgument);

   871 			if(event.Type()<EEventUser)

   872 				{

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

   874 					{

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

   876 						User::Leave(KErrPermissionDenied);

   877 					}

   878 				else

   879 					{

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

   881 						User::Leave(KErrPermissionDenied);

   882 					}

   883 				}

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

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

   886 				User::Leave(KErrNoMemory);

   887 			}

   888 			break;

   889 		case EWsClOpSendMessageToWindowGroup:

   890 			{

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

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

   893 				{

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

   895 					{

   896 					User::Leave(KErrPermissionDenied);

   897 					}

   898 				}

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

   900 			}

   901 			break;

   902 		case EWsClOpSendMessageToAllWindowGroups:

   903 		case EWsClOpSendMessageToAllWindowGroupsPriority:

   904 			{

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

   906 				{

   907 				User::Leave(KErrArgument);

   908 				}

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

   910 			}

   911 			break;

   912 		case EWsClOpFetchMessage:

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

   914 			break;

   915 		case EWsClOpGetWindowGroupNameFromIdentifier:

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

   917 			break;

   918 		case EWsClOpFindWindowGroupIdentifier:

   919 			{

   920 			if (pData.FindWindowGroupIdentifier->length<0)

   921 				User::Leave(KErrArgument);

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

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

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

   925 			}

   926 			break;

   927 		case EWsClOpFindWindowGroupIdentifierThread:

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

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

   930 			break;

   931 		case EWsClOpSetBackgroundColor:

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

   933 				{

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

   935 				}

   936 			break;

   937 		case EWsClOpGetBackgroundColor:

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

   939 			break;

   940 		case EWsClOpClaimSystemPointerCursorList:

   941 			{

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

   943 				{

   944 				User::Leave(KErrPermissionDenied);

   945 				}

   946 			ClaimSystemPointerCursorListL();

   947 			}

   948 			break;

   949 		case EWsClOpFreeSystemPointerCursorList:

   950 			FreeSystemPointerCursorList();

   951 			break;

   952 		case EWsClOpSetSystemPointerCursor:

   953 			{

   954 			CWsObject* pointercursor = NULL;

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

   956 				PPanic(EWservPanicSprite);

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

   959 			}

   960 			break;

   961 		case EWsClOpClearSystemPointerCursor:

   962 			ClearSystemPointerCursor(*pData.Int);

   963 			break;

   964 		case EWsClOpSetPointerCursorArea:

   965 			{

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

   967 				{

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

   969 					PPanic(EWservPanicScreenModeNumber);

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

   971 				}

   972 			}

   973 			break;

   974 		case EWsClOpPointerCursorArea:

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

   976 				PPanic(EWservPanicScreenModeNumber);

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

   979 			break;

   980 		case EWsClOpSetPointerCursorMode:

   981 			{

   982 			CWsWindowGroup* focusWinGp=CWsTop::FocusWindowGroup();

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

   984 				{

   985 				TWsPointer::SetPointerCursorMode(*pData.Mode);

   986 				TWsPointer::UpdatePointerCursor();

   987 				}

   988 			}

   989 			break;

   990 		case EWsClOpSetClientCursorMode :

   991 			{

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

   993 				{

   994 				User::Leave(KErrPermissionDenied);

   995 				}

   996 			TWsPointer::SetPointerCursorMode(*pData.Mode);

   997 			TWsPointer::UpdatePointerCursor();

   998 			}

   999 			break;

  1000 		case EWsClOpPointerCursorMode:

  1001 			SetReply(TWsPointer::PointerCursorMode());

  1002 			break;

  1003 		case EWsClOpSetDefaultSystemPointerCursor:

  1004 			SetDefaultSystemPointerCursor(*pData.Int);

  1005 			break;

  1006 		case EWsClOpClearDefaultSystemPointerCursor:

  1007 			SetDefaultSystemPointerCursor(ENoDefaultSystemPointerCursor);

  1008 			break;

  1009 		case EWsClOpSetPointerCursorPosition:

  1010 			{

  1011 			CWsWindowGroup* focusWinGp=CWsTop::FocusWindowGroup();

  1012 			if ((!focusWinGp || focusWinGp->WsOwner()!=this)&&

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

  1014 				{

  1015 				User::Leave(KErrPermissionDenied);

  1016 				}

  1017 			TWsPointer::SetPointerCursorPos(*pData.Point);

  1018 			}

  1019 			break;

  1020 		case EWsClOpPointerCursorPosition:

  1021 			ReplyPoint(TWsPointer::PointerCursorPos());

  1022 			break;

  1023 		case EWsClOpSetModifierState:

  1024 			{

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

  1026 				{

  1027 				User::Leave(KErrPermissionDenied);

  1028 				}

  1029 			TWindowServerEvent::SetModifierState(pData.SetModifierState->modifier,pData.SetModifierState->state);

  1030 			}

  1031 			break;

  1032 		case EWsClOpGetModifierState:

  1033 			SetReply(TWindowServerEvent::GetModifierState());

  1034 			break;

  1035 		case EWsClOpHeapCount:

  1036 			SetReply(CWsMemoryManager::Static()->Count());

  1037 			break;

  1038  		case EWsClOpDebugInfo:

  1039 			DebugInfoL(pData.DebugInfo->iFunction,pData.DebugInfo->iParam,EFalse);

  1040  			break;

  1041  		case EWsClOpDebugInfoReplyBuf:

  1042 			DebugInfoL(pData.DebugInfo->iFunction,pData.DebugInfo->iParam,ETrue);

  1043  			break;

  1044 		case EWsClOpResourceCount:

  1045 			SetReply(iObjectIndex->Count());

  1046 			break;

  1047 		case EWsClOpHeapSetFail:

  1048 			{

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

  1050 				{

  1051 				PPanic(EWservPanicPermissionDenied);

  1052 				}

  1053 #if !defined(_DEBUG)

  1054 			if (pData.HeapSetFail->type!=RHeap::ENone)

  1055 				TWindowServerEvent::NotifyOom();

  1056 #endif

  1057 			// if there is a memory manager and we are making the allocator fail next or

  1058 			// deteministic we want to make sure we test both when the memory manager

  1059 			// succeeds and fails in allocating after freeing up memory. we do that by

  1060 			// remapping the rate and explicitly telling the memory manager to fail:

  1061 			// requested rate  | fail on retry, actual rate

  1062 			//        1        |    true      ,    1

  1063 			//        2        |    false     ,    1

  1064 			//        3        |    true      ,    2

  1065 			CWsMemoryManager* memoryManager = NULL;

  1066 			TInt rate = pData.HeapSetFail->value;

  1067 			TBool memoryManagerRetryFail = EFalse;

  1068 			if((pData.HeapSetFail->type == RAllocator::EFailNext || pData.HeapSetFail->type == RAllocator::EDeterministic))

  1069 				{

  1070 				memoryManager = CWsMemoryManager::Static();

  1071 				if(memoryManager)

  1072 					{

  1073 					memoryManagerRetryFail = (rate % 2 == 1);

  1074 					rate = rate / 2 + (memoryManagerRetryFail ? 1 : 0);

  1075 					}

  1076 				}

  1078 			switch (pData.HeapSetFail->type)

  1079 				{	//This log message means you can safely ignore the allocation failures in between

  1080 					//see CWindowServer::ReleaseMemory()

  1081 				case RAllocator::ENone:

  1082 					RDebug::Printf("WSERV Heap: __DbgSetAllocFail() <<<ENone");

  1083 					break;

  1084 				case RAllocator::EReset:

  1085 					RDebug::Printf("WSERV Heap: __DbgSetAllocFail() <<<EReset");

  1086 					break;

  1087 				default:

  1088 					if (memoryManagerRetryFail)

  1089 						RDebug::Printf("WSERV Heap: Memory Manager set to fail on retry");

  1090 					RDebug::Printf("WSERV Heap: __DbgSetAllocFail(EUser,%i,%i)>>>", pData.HeapSetFail->type, rate);

  1091 					break;

  1092 				}

  1094 			if (memoryManager && memoryManagerRetryFail)

  1095 				memoryManager->SetFailNextRetry();

  1097 			if (pData.HeapSetFail->burst >= 0)

  1098 				User::__DbgSetBurstAllocFail(RHeap::EUser, pData.HeapSetFail->type, rate, pData.HeapSetFail->burst);

  1099 			else

  1100 				User::__DbgSetAllocFail(RHeap::EUser, pData.HeapSetFail->type, rate);

  1101 			break;

  1102 			}

  1103 		case EWsClOpRawEvent:

  1104 			{

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

  1106 				{

  1107 				PPanic(EWservPanicPermissionDenied);

  1108 				}

  1109 			TRawEvent event(*pData.RawEvent);

  1110 			if (TWsPointer::PreProcessDriverEvent(event))

  1111 				TWindowServerEvent::ProcessRawEvent(event);

  1112 			}

  1113 			break;

  1114 		case EWsClOpKeyEvent:

  1115 			{

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

  1117 				{

  1118 				PPanic(EWservPanicPermissionDenied);

  1119 				}

  1120 			TWindowServerEvent::ProcessKeyEvent(*pData.KeyEvent,0);

  1121 			}

  1122 			break;

  1123 		case EWsClOpLogMessage:

  1124 			if (wsDebugLog)

  1125 				{

  1126 				if (CheckBuffer(*pData.Int, KLogMessageLength))

  1127 					wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,BufferTPtr((TText* )(pData.Int+1),*pData.Int),0);

  1128 				}

  1129 			break;

  1130 		case EWsClOpPasswordEntered:

  1131 			CWsPassword::PasswordEntered(this);

  1132 			break;

  1133 		case EWsClOpComputeMode:

  1134 			SetComputeMode(*pData.ComputeMode);

  1135 			break;

  1136 		case EWsClOpSendOffEventsToShell:

  1137 			{

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

  1139 				{

  1140 				User::Leave(KErrPermissionDenied);

  1141 				}

  1142 			SetReply(CWsTop::SetSendOffEventsToShell(this,*pData.OffEventsToShell));

  1143 			}

  1144 			break;

  1145 		case EWsClOpGetDefModeMaxNumColors:

  1146 			{

  1147 			SDefModeMaxNumColors colors;

  1148 			const TInt screenNumber = *pData.Int;

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

  1150 				PPanic(EWservPanicScreenNumber);

  1151 			else

  1152 				{

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

  1154 				screen->MaxNumColors(colors.iColors,colors.iGrays);

  1155 				colors.iDisplayMode=screen->FirstDefaultDisplayMode();

  1156 				}

  1157 			ReplyBuf(&colors,sizeof(colors));

  1158 			}

  1159 			break;

  1160 		case EWsClOpGetColorModeList:

  1161 			{

  1162 			const TInt screenNumber = *pData.Int;

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

  1164 				PPanic(EWservPanicScreenNumber);

  1165 			else

  1166 				SetReply((screenNumber==KDummyScreenNumber) ? iScreen->ColorModesFlag() : CWsTop::Screen(screenNumber)->ColorModesFlag());

  1167 			}

  1168 			break;

  1169 		case EWsClOpSetDefaultFadingParams:

  1170 			{

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

  1172 				{

  1173 				iScreen->SetFadingParams(WservEncoding::ExtractFirst8BitValue(*pData.UInt),WservEncoding::ExtractSecond8BitValue(*pData.UInt));

  1174 				}

  1175 			}

  1176 			break;

  1177 		case EWsClOpPrepareForSwitchOff:

  1178 			{

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

  1180 				{

  1181 				}

  1182 			}

  1183 			break;

  1184 		case EWsClOpSetFaded:

  1185 			{

  1186 			// Deprecated - retained for BC with applications that retrieve the fade count

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

  1188 				User::Leave(KErrPermissionDenied);

  1190 			TUint8 blackMap;

  1191 			TUint8 whiteMap;

  1192 			if (pData.SetSystemFaded->UseDefaultMap())

  1193 				iScreen->GetFadingParams(blackMap,whiteMap);

  1194 			else

  1195 				pData.SetSystemFaded->GetFadingParams(blackMap,whiteMap);

  1197 			iScreen->RootWindow()->SetSystemFaded(pData.SetSystemFaded->Faded(),blackMap,whiteMap);

  1198 			}

  1199 		break;

  1200 		case EWsClOpLogCommand:

  1201 			CWsTop::LogCommand(*pData.LogCommand);

  1202 			break;

  1203 #if defined(__WINS__)

  1204 		case EWsClOpRemoveKeyCode:

  1205 			iInternalFlags&=~ERemoveKeyCode;

  1206 			if (*pData.Bool)

  1207 				iInternalFlags|=ERemoveKeyCode;

  1208 			break;

  1209 		case EWsClOpSimulateXyInput:

  1210 			TWsPointer::SetXyInputType(static_cast<TXYInputType>(*pData.XyInput));

  1211 			break;

  1212 #endif

  1213 		case EWsClOpNoFlickerFree:

  1214 			PPanic(EWservPanicOpcode); //not supported anymore

  1215 			break;

  1216 		case EWsClOpSetFocusScreen:

  1217 			{

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

  1219 				{

  1220 				User::Leave(KErrPermissionDenied);

  1221 				}

  1222 			TInt focusScreen=*pData.Int;

  1223 			if (focusScreen>=0 && focusScreen<CWsTop::NumberOfScreens())

  1224 				SetReply(CWsTop::SetCurrentFocusScreen(focusScreen));

  1225 			else

  1226 				SessionPanic(EWservPanicScreenNumber);

  1227 			break;

  1228 			}

  1229 		case EWsClOpGetFocusScreen:

  1230 			SetReply(CWsTop::CurrentFocusScreen()->ScreenNumber());

  1231 			break;

  1232 		case EWsClOpGetNumberOfScreens:

  1233 			SetReply(CWsTop::NumberOfScreens());

  1234 			break;

  1235 		case EWsClOpClearAllRedrawStores:

  1236 			CWsTop::ClearAllRedrawStores();

  1237 			break;

  1238 		case EWsClOpGetGraphicMessage:

  1239 			iGraphicMessageQueue.GetGraphicMessage();

  1240 			break;

  1241 		case EWsClOpGraphicMessageCancel:

  1242 			iGraphicMessageQueue.CancelRead();

  1243 			break;

  1244 		case EWsClOpGraphicAbortMessage:

  1245 			iGraphicMessageQueue.AbortMessage(*pData.Int);

  1246 			break;

  1247 		case EWsClOpGraphicFetchHeaderMessage:

  1248 			SetReply(iGraphicMessageQueue.TopClientHandle());

  1249 			break;

  1250 		case EWsClOpRegisterSurface:

  1251 			SetReply(RegisterSurface(pData));

  1252 			break;

  1253 		case EWsClOpUnregisterSurface:

  1254 			UnregisterSurface(pData);

  1255 			break;

  1256 		case EWsClOpSetCloseProximityThresholds:

  1257 			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),

  1258 					__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetCloseProximityThresholds")))

  1259 				{

  1260 				User::Leave(KErrPermissionDenied);

  1261 				}

  1262 			SetReply(TWsPointer::SetCloseProximityThresholds(pData.ZThresholdPair->enterThreshold,

  1263 															 pData.ZThresholdPair->exitThreshold));

  1264 			break;

  1265 		case EWsClOpSetHighPressureThresholds:

  1266 			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),

  1267 					__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetHighPressureThresholds")))

  1268 				{

  1269 				User::Leave(KErrPermissionDenied);

  1270 				}

  1271 			SetReply(TWsPointer::SetHighPressureThresholds(pData.ZThresholdPair->enterThreshold,

  1272 					 									   pData.ZThresholdPair->exitThreshold));

  1273 			break;

  1274 		case EWsClOpGetEnterCloseProximityThreshold:

  1275 			SetReply(TWsPointer::GetEnterCloseProximityThreshold());

  1276 			break;

  1277 		case EWsClOpGetExitCloseProximityThreshold:

  1278 			SetReply(TWsPointer::GetExitCloseProximityThreshold());

  1279 			break;

  1280 		case EWsClOpGetEnterHighPressureThreshold:

  1281 			SetReply(TWsPointer::GetEnterHighPressureThreshold());

  1282 			break;

  1283 		case EWsClOpGetExitHighPressureThreshold:

  1284 			SetReply(TWsPointer::GetExitHighPressureThreshold());

  1285 			break;

  1286 		case EWsClOpCreateDrawableSource:

  1287 			CreateDrawableSourceL(*pData.CreateDrawableSource);

  1288 			break;

  1289 		case EWsClOpIndicateAppOrientation:

  1290 			IndicateAppOrientation(*pData.Orientation);

  1291 			break;

  1292 		case EWsClOpUnregisterAllTFXEffect:

  1293 			RDebug::Printf("[Bug 3344] OpCode EWsClOpUnregisterAllTFXEffect not supported.");

  1294 			break;

  1295 		default:

  1296 			PPanic(EWservPanicOpcode);

  1297 			break;

  1298 		}

  1299 	}

  1300 /**	Debug information accessor.

  1301  *

  1302  *

  1303  **/

  1304 void CWsClient::DebugInfoL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const

  1305 	{

  1306 	if (aFunction & EWsDebugClassMask)

  1307 		SetReply(DebugInfoClassifiedL(aFunction,aParam,aHasReplyBuf));

  1308 	else

  1309 		DebugInfoUnclassifiedL(aFunction,aParam,aHasReplyBuf);

  1310 	}

  1312 /**	A wide variety of generally unconnected debug enquiries.

  1313  *

  1314  *

  1315  **/

  1316 void CWsClient::DebugInfoUnclassifiedL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const

  1317 	{

  1318 	switch(aFunction)

  1319 		{

  1320 		case EWsDebugInfoHeap:

  1321 			if (aHasReplyBuf)

  1322 				{

  1323 				TWsDebugHeapInfo heapInfo;

  1324 				RHeap& heap=User::Heap();

  1325 				heapInfo.iCount=heap.AllocSize(heapInfo.iTotal);

  1326 				heapInfo.iAvailable=heap.Available(heapInfo.iLargestAvailable);

  1327 				ReplyBuf(&heapInfo,sizeof(heapInfo));

  1328 				}

  1329 			SetReply(KErrArgument);

  1330 			break;

  1331 		case EWsDebugSetCheckHeapOnDisconnectClient:

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

  1333 				{

  1334 				User::Leave(KErrPermissionDenied);

  1335 				}

  1336 			CWsTop::SetCheckHeapOnDisconnectClient(this);

  1337 			break;

  1338 		case EWsDebugSetCheckHeapOnDisconnectMode:

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

  1340 				{

  1341 				User::Leave(KErrPermissionDenied);

  1342 				}

  1343 			CWsTop::SetCheckHeapOnDisconnectMode(STATIC_CAST(TWsCheckHeapOnDisconnectMode,aParam));

  1344 			break;

  1345 		case EWsDebugFetchCheckHeapResult:

  1346 			SetReply(CWsTop::FetchCheckHeapResult());

  1347 			break;

  1348 		case EWsDebugSetEventQueueTest:

  1349 			CWsWindowGroup::SetEventQueueTestState(aParam);

  1350 			break;

  1351 		default:

  1352 			SetReply(KErrNotSupported);

  1353 			break;

  1354 		}

  1355 	}

  1357 /**	Selects a debug function based on the class of debug query.

  1358  *

  1359  *

  1360  **/

  1361 TInt CWsClient::DebugInfoClassifiedL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const

  1362 	{//Duplicating the meanings of Classified... this would be a good place for a security check

  1363 	//first part of param is always screen number

  1364 	TInt buffSpace=aHasReplyBuf?ReplyBufSpace():0;

  1365 	if (buffSpace<0)

  1366 		return (buffSpace);

  1368 	const TInt screenNumber = (aParam&EWsDebugArgScreenMask)>>EWsDebugArgScreenShift;

  1369 	const TInt functionClass = (aFunction&EWsDebugClassMask);

  1370 	CScreen* screen = NULL;

  1371 	if (functionClass<EWsDebugClassNonScreen)

  1372 		{

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

  1374 			return (KErrArgument);

  1376 		screen = CWsTop::Screen(screenNumber);

  1377 		}

  1378 	WS_ASSERT_DEBUG(screen, EWsPanicNoScreen);

  1379 	switch (aFunction&EWsDebugClassMask)

  1380 		{

  1381 		case EWsDebugClassScreenUiElement:

  1382 			return DebugInfoScreenUiL(aFunction,aParam,buffSpace,*screen);

  1383 		case EWsDebugClassScreenElementSet:

  1384 			return DebugInfoScreenElementSetL(aFunction, aParam, buffSpace, *screen);

  1385 		case EWsDebugClassElementSetWindow:

  1386 			return DebugInfoElementSetWindowL(aFunction, aParam, buffSpace, *screen);

  1387 		case EWsDebugClassElementSetElement:

  1388 			return DebugInfoElementSetElementL(aFunction, aParam, buffSpace, *screen);

  1390 		case EWsDebugClassClientWindow:

  1391 		default:

  1392 			return (KErrNotSupported);

  1393 		}

  1394 	}

  1396 /**	Returns debug info about the UIElement entries for a screen.

  1397  * 	This describes the general state or size of the element set.

  1398  * 	It is indexed via screen num, and optionally element index.

  1399  * 	Element index MUST BE 0 when not required.

  1400  * 	@return size of buffer required or error code.

  1401  **/

  1402 TInt CWsClient::DebugInfoScreenUiL(TInt aFunction, TInt /* aParam */, TInt aReplyBufSize, CScreen& aScreen) const

  1403 	{

  1404 	switch(aFunction)

  1405 		{

  1406 		case EWsDebugGetFastpathMode:

  1407 			{

  1408 			// obsolete through preq2669

  1409             WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);

  1410 			return KErrNotSupported;

  1411 			}

  1413 		case EWsDebugSetFastpathMode:

  1414 			{

  1415             // obsolete through preq2669

  1416             WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);

  1417             return KErrNotSupported;

  1418 			}

  1420 		case EWsDebugGetUIElementInfoList:

  1421 			{

  1422             // obsolete through preq2669

  1423             WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);

  1424             return KErrNotSupported;

  1425 			}

  1427 		case EWsDebugGetUIElementBase:

  1428 			{

  1429             // obsolete through preq2669

  1430             WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);

  1431             return KErrNotSupported;

  1432 			}

  1434 		case EWsDebugGetUIElementIds:

  1435 			{

  1436             // obsolete through preq2669

  1437             WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);

  1438             return KErrNotSupported;

  1439 			}

  1441 		case EWsDebugGetSceneElementIdOrder:

  1442 			{

  1443             // obsolete through preq2669

  1444             WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);

  1445             return KErrNotSupported;

  1446 			}

  1447 		case EWsDebugSetFastpathTestMode:

  1448 			{

  1449             // obsolete through preq2669

  1450             WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);

  1451             return KErrNotSupported;

  1452 			}

  1454 		case EWsDebugSetFastpathOomMode:

  1455 			{

  1456             // obsolete through preq2669

  1457             WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);

  1458             return KErrNotSupported;

  1459 			}

  1460 		case EWsDebugGetUIElementConfig:

  1461 			{

  1462 			return DebugReturnConfig(aReplyBufSize,&aScreen.UiElement(),0);

  1464 			}

  1465 		default:

  1466 			return (KErrNotSupported);

  1467 		}

  1468 	}

  1470 /**	Returns debug info about the CWindowElementSet entry for a screen.

  1471  * 	This describes the general state or size of the element set

  1472  * 	It is indexed via screen num.

  1473  * 	@return size of buffer required or error code.

  1474  **/

  1475 TInt CWsClient::DebugInfoScreenElementSetL(TInt aFunction, TInt /*aParam*/, TInt aReplyBufSize, const CScreen& aScreen) const

  1476 	{

  1477 	const CWindowElementSet& elementSet = aScreen.WindowElements();

  1478 	switch (aFunction)

  1479 		{

  1480 		case EWsDebugSerialSurfacesUpdated:

  1481 			return 0;

  1483 		case EWsDebugSurfaceWindowList:

  1484 			{

  1485 			TInt outSize = elementSet.Count() * sizeof(TWsDebugWindowId);

  1486 			if (outSize<=aReplyBufSize)

  1487 				{//can stream, so I shall!

  1488 				for (TInt index = 0; index < elementSet.Count(); index++)

  1489 					{

  1490 					const CWsClientWindow& win = *elementSet.DebugWindowAt(index);

  1491 					TWsDebugWindowId id=

  1492 						{

  1493 						win.ClientHandle(), 0

  1494 						};

  1495 					if (win.WsOwner()!=this)

  1496 						id.iOtherGroupId=win.WinGroup()->Identifier();

  1497 					ReplyBuf(&id, sizeof(id));

  1498 					}

  1499 				}

  1500 			return outSize;

  1501 			}

  1502 		default:

  1503 			return (KErrNotSupported);

  1505 		}

  1506 	}

  1508 /**	Returns debug info about a CWindowElement entry.

  1509  * 	This describes the window or the background element(s)

  1510  * 	It is indexed via screen num, and index in elementset.

  1511  * 	@return size of buffer required or error code.

  1512  **/

  1513 TInt CWsClient::DebugInfoElementSetWindowL(TInt aFunction, TInt aParam,

  1514 		TInt aReplyBufSize, const CScreen& aScreen) const

  1515 	{

  1516 	const CWindowElementSet& elementSet = aScreen.WindowElements();

  1517 	TUint winIndex = (aParam & EWsDebugArgWindowMask) >> EWsDebugArgWindowShift;

  1518 	const TAttributes* winElement = elementSet.DebugBackgroundAt(winIndex);

  1519 	if (winElement == NULL)

  1520 		{

  1521 		return KErrArgument;

  1522 		}

  1524 	MWsElement* backElement = winElement->iElement;

  1525 	TInt placedCount = elementSet.DebugPlacedCountAt(winIndex);

  1526 	switch (aFunction)

  1527 		{

  1528 		case EWsDebugElementIdList:

  1529 			{

  1530 			TInt retVal = (placedCount + 1) * sizeof(MWsElement*);

  1531 			if (retVal<aReplyBufSize)

  1532 				{

  1533 				ReplyBuf(&backElement, sizeof(MWsElement*));

  1534 				for (TInt index=0; index<placedCount; index++)

  1535 					ReplyBuf(&elementSet.DebugPlacedAt(winIndex, index)->iElement, sizeof(MWsElement*));

  1536 				}

  1537 			return retVal;

  1538 			}

  1539 		case EWsDebugBackgroundConfig:

  1540 			if (backElement == NULL)

  1541 				return KErrNotFound;

  1542 			else

  1543 				return DebugReturnConfig(aReplyBufSize, backElement,

  1544 						winElement->DebugFlags());

  1545 		case EWsDebugBackgroundBase:

  1546 			if (backElement == NULL)

  1547 				return KErrNotFound;

  1548 			else

  1549 				return DebugReturnBase(aReplyBufSize, backElement);

  1550 		case EWsDebugBackgroundFlags:

  1551 			return DebugReturnFlags(aReplyBufSize, backElement,

  1552 					winElement->DebugFlags());

  1553 		default:

  1554 			return KErrNotSupported;

  1555 		//This method can also be extended to return region and state information from the associated window

  1556 		}

  1557 	}

  1559 /**	Returns debug info about a placed element.

  1560  * 	It is indexed via screen num, index in elementset, and index in placed element array.

  1561  * 	@return size of buffer required or error code.

  1562  **/

  1563 TInt CWsClient::DebugInfoElementSetElementL(TInt aFunction, TInt aParam,

  1564 		TInt aReplyBufSize, const CScreen& aScreen) const

  1565 	{

  1566 	const CWindowElementSet& elementSet = aScreen.WindowElements();

  1567 	TUint winIndex = (aParam & EWsDebugArgWindowMask) >> EWsDebugArgWindowShift;

  1568 	TUint placeIndex = (aParam & EWsDebugArgElementMask) >> EWsDebugArgElementShift;

  1569 	const TAttributes* placedElement = elementSet.DebugPlacedAt(winIndex, placeIndex);

  1570 	if (placedElement == NULL)

  1571 		{

  1572 		return KErrArgument;

  1573 		}

  1575 	MWsElement* element = placedElement->iElement;

  1576 	if (element == NULL)

  1577 		{

  1578 		return KErrNotFound;

  1579 		}

  1581 	switch (aFunction)

  1582 		{

  1583 		case EWsDebugPlacedConfig:

  1584 			return DebugReturnConfig(aReplyBufSize, element,

  1585 					placedElement->DebugFlags());

  1586 		case EWsDebugPlacedBase:

  1587 			return DebugReturnBase(aReplyBufSize, element);

  1588 		case EWsDebugPlacedFlags:

  1589 			return DebugReturnFlags(aReplyBufSize, element,

  1590 					placedElement->DebugFlags());

  1591 		default:

  1592 			return KErrNotSupported;

  1593 		}

  1594 	}

  1596 /**	Returns a filled in TSurfaceConfiguration from an MWsElement.

  1597  * 	Data is usually copied if the buffer is big enough

  1598  * 	@return the size of buffer required, or zero if the buffer is acceptable

  1599  **/

  1600 TInt CWsClient::DebugReturnConfig(TInt aReplyBufSize, MWsElement* aElement, TInt /*aFlags*/) const

  1601 	{

  1602 	if (aElement == NULL)

  1603 		{

  1604 		return KErrNotReady;

  1605 		}

  1607 	TSurfaceConfiguration config(aReplyBufSize);

  1608 	TInt retVal=config.Size();

  1609 	if (aReplyBufSize)

  1610 		{

  1611 		retVal = CWindowElementSet::GetConfiguration(config, *aElement);

  1612 		if (retVal==KErrNone)

  1613 			{

  1614 			ReplyBuf(&config, config.Size()); //return code is 0 = "just right"

  1615 			}

  1616 		}

  1617 	return retVal;

  1618 	}

  1620 /**	Returns the base region of the element.

  1621  * 	This region is element relative. There are a number of ways that this does not match the input region:

  1622  * 	First, if no region is specified then the extent rectangle is returned

  1623  * 	Any region returned has all negative ordinate values clipped.

  1624  * 	Positive values may exceed the extent, but negative values are never returned.

  1625  *  Internally, a region which is only negative is "remembered illegally", but an empty region is returned.

  1626  **/

  1627 TInt CWsClient::DebugReturnBase(TInt /*aReplyBufSize*/, const MWsElement* /*aElement*/)const

  1628 	{

  1629 	return KErrNotSupported;

  1630 	}

  1632 /**	Returns the flags associated with the given element.

  1633  * 	2 words are inserted.

  1634  * 	One represents the MWsElement flags, the other represents CWindowElement or UIElement flags

  1635  * 	@return length of two words

  1636  **/

  1637 TInt CWsClient::DebugReturnFlags(TInt aReplyBufSize, const MWsElement* /*aElement*/, TInt aFlags)const

  1638 	{

  1639 	const TInt KArraySize=2;

  1640 	if (aReplyBufSize>KArraySize*sizeof(TInt))

  1641 		{

  1642 		// First field is for flags from scene element if any

  1643 		TInt returns[KArraySize]=

  1644 			{

  1645 			0, aFlags

  1646 			};

  1647 		ReplyBuf(returns,KArraySize*sizeof(TInt));

  1648 		}

  1649 	return KArraySize*sizeof(TInt);

  1650 	}

  1652 /**	Packages a region for return ans an array of rectangles.

  1653  * 	If the buffer is big enough the data is transferred

  1654  * 	@return the buffer size required, or an error code if an empty or null pointer is passed in

  1655  **/

  1656 TInt CWsClient::DebugReturnRegion(TInt aReplyBufSize, const TRegion* aRegion, TInt aErrCodeIfEmpty)const

  1657 	{

  1658 	if (aRegion==NULL)

  1659 		return KErrNotReady;

  1661 	const TInt returnSize=aRegion->Count()*sizeof(TRect);

  1662 	if (returnSize==0)

  1663 		return aErrCodeIfEmpty;

  1665 	if (returnSize<=aReplyBufSize)

  1666 		ReplyBuf(aRegion->RectangleList(),returnSize);

  1668 	return returnSize;

  1669 	}

  1671 void CWsClient::ReplyGroupName(HBufC* aName, TInt aMaxLength)	// static

  1672 	{

  1673 	if (aName)

  1674 		{

  1675 		if (aName->Length()>aMaxLength)

  1676 			{

  1677 			ReplyBuf(aName->Left(aMaxLength));

  1678 			SetReply(KErrOverflow);

  1679 			}

  1680 		else

  1681 			ReplyBuf(*aName);

  1682 		}

  1683 	else

  1684 		ReplyBuf(KNullDesC);

  1685 	}

  1687 void CWsClient::TriggerRedraw()

  1688 	{

  1689 	RedrawQueue()->TriggerRedraw();

  1690 	}

  1692 void CWsClient::UpdateWindowOrdinalPrioritys()

  1693 	{

  1694 	for(CWsWindowGroup* win=iScreen->RootWindow()->Child();win;win=win->NextSibling())

  1695 		{

  1696 		if (win->WsOwner()==this)

  1697 			win->UpdateOrdinalPriority(ETrue);

  1698 		}

  1699 	}

  1701 void CWsClient::DeleteSystemPointerListEntry(TInt aIndex)

  1702 	{

  1703 	PointerCursor (aIndex)->Close();

  1704 	iSystemPointerCursors->Delete(aIndex);

  1705 	}

  1707 CWsPointerCursor* CWsClient::SystemPointerCursor(TInt aIndex)

  1708 	{

  1709 	TInt arrayIndex;

  1710 	if (iSystemPointerCursors)

  1711 		{

  1712 		if (FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))

  1713 			return PointerCursor(arrayIndex);

  1715 		// Cursor not defined so try for default cursor

  1716 		if (FindCursorArrayItem(iSystemPointerCursors, 0, arrayIndex))

  1717 			return PointerCursor(arrayIndex);

  1718 		}

  1720 	// If that fails simply return NULL for no cursor

  1721 	return NULL;

  1722 	}

  1724 void CWsClient::SetSystemPointerCursorL(TInt aIndex, CWsPointerCursor* aCursor)

  1725 	{

  1726 	if (iSystemPointerCursorListOwner!=this)

  1727 		PPanic(EWservPanicNotSystemPointerCursorListOwner);

  1729 	TInt arrayIndex = KErrNotFound;

  1730 	if (FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))

  1731 		{

  1732 		PointerCursor(arrayIndex)->Close();

  1733 		PointerCursor(arrayIndex) = aCursor;

  1734 		}

  1735 	else

  1736 		{

  1737 		TWsCursorArrayItem entry;

  1738 		entry.iIndex=aIndex;

  1739 		entry.iCursor=aCursor;

  1740 		iSystemPointerCursors->InsertIsqL(entry, iCursorKey);

  1741 		}

  1743 	aCursor->Open();

  1744 	if (aIndex==iDefaultSystemPointerCursorIndex)

  1745 		iDefaultSystemPointerCursor=aCursor;

  1746 	TWsPointer::UpdatePointerCursor();

  1747 	}

  1749 void CWsClient::ClearSystemPointerCursor(TInt aIndex)

  1750 	{

  1751 	if (iSystemPointerCursorListOwner!=this)

  1752 		PPanic(EWservPanicNotSystemPointerCursorListOwner);

  1754 	TInt arrayIndex;

  1755 	if (FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))

  1756 		{

  1757 		DeleteSystemPointerListEntry(arrayIndex);

  1758 		if (aIndex==iDefaultSystemPointerCursorIndex)

  1759 			iDefaultSystemPointerCursor=NULL;

  1760 		}

  1761 	}

  1763 void CWsClient::ClaimSystemPointerCursorListL()

  1764 	{

  1765 	if (iSystemPointerCursorListOwner)

  1766 		User::Leave(KErrInUse);

  1768 	const TInt systemPointerCursorGranularity = 4;

  1769 	iSystemPointerCursors = new(ELeave) CArrayFixFlat<TWsCursorArrayItem> (systemPointerCursorGranularity);

  1770 	iSystemPointerCursorListOwner=this;

  1771 	}

  1773 void CWsClient::FreeSystemPointerCursorList()

  1774 	{

  1775 	if(iSystemPointerCursorListOwner == this)

  1776 		{

  1777 		iSystemPointerCursorListOwner = NULL;

  1779 		while(iSystemPointerCursors->Count()>0)

  1780 			DeleteSystemPointerListEntry(0);

  1782 		iDefaultSystemPointerCursor = NULL;

  1783 		iDefaultSystemPointerCursorIndex = 0;

  1785 		delete iSystemPointerCursors;

  1786 		iSystemPointerCursors = NULL;

  1787 		}

  1788 	}

  1790 void CWsClient::SetDefaultSystemPointerCursor(TInt aIndex)

  1791 	{

  1792 	TInt arrayIndex;

  1793 	if (iSystemPointerCursorListOwner != this)

  1794 		PPanic(EWservPanicNotSystemPointerCursorListOwner);

  1796 	iDefaultSystemPointerCursorIndex = aIndex;

  1797 	iDefaultSystemPointerCursor = NULL;

  1799 	if (aIndex != ENoDefaultSystemPointerCursor &&

  1800 		FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))

  1801 		iDefaultSystemPointerCursor = PointerCursor (arrayIndex);

  1802 	else

  1803 		iDefaultSystemPointerCursor = NULL;

  1805 	TWsPointer::UpdatePointerCursor();

  1806 	}

  1808 TBool CWsClient::FindCursorArrayItem(CArrayFixFlat<TWsCursorArrayItem>* aCursorArray,

  1809 									 TInt aIndex,TInt& aPosition)

  1810 	{

  1811 	if (!aCursorArray)

  1812 		return EFalse; // No hit if the array isn't even allocated

  1814 	TWsCursorArrayItem entry;

  1815 	entry.iIndex = aIndex;

  1816 	return aCursorArray->FindIsq(entry, iCursorKey, aPosition)==KErrNone;

  1817 	}

  1819 void CWsClient::SetClientPriority()

  1820 	{

  1821 	if (iComputeMode!=RWsSession::EPriorityControlDisabled)

  1822 		{

  1823 		Client().SetProcessPriority(

  1824 				iComputeMode==RWsSession::EPriorityControlComputeOn

  1825 			||	CWsTop::FocusWindowGroupOwner()!=this

  1826 				?	EPriorityBackground

  1827 			  	:	EPriorityForeground);

  1828 		}

  1829 	}

  1831 void CWsClient::SetComputeMode(RWsSession::TComputeMode aComputeMode)

  1832 	{

  1833 	if (aComputeMode!=RWsSession::EPriorityControlDisabled

  1834 		&& aComputeMode	!=RWsSession::EPriorityControlComputeOn

  1835 		&& aComputeMode	!=RWsSession::EPriorityControlComputeOff)

  1836 		PPanic(EWservPanicSetComputeMode);

  1837 	iComputeMode=aComputeMode;

  1838 	SetClientPriority();

  1839 	}

  1841 void CWsClient::CompleteMessage(const RMessage2& aMessage,TInt aReason)

  1842 	{

  1843 	WS_ASSERT_DEBUG(!aMessage.IsNull(),EWsPanicPanicFlagError);

  1844 	if (iInternalFlags&EPanicClientAsSoonAsPossible)

  1845 		{

  1846 		aMessage.Panic(KWSERVSessionPanicCategory,iPanicReason);

  1847 		iInternalFlags&=~EPanicClientAsSoonAsPossible;

  1848 		}

  1849 	else

  1850 		{

  1851 		if(!iResponseHandle)

  1852 			aMessage.Complete(aReason);

  1853 		else

  1854 			{

  1855 			aMessage.Complete(*iResponseHandle);

  1856 			iResponseHandle=NULL;

  1857 			}

  1858 		}

  1859 	}

  1861 void CWsClient::ServiceError(const RMessage2& /*aMessage*/,TInt aError)

  1862 	{

  1863 	CompleteMessage(iClientMessage,aError);	// (finish)

  1864 	}

  1866 void CWsClient::ServiceL(const RMessage2 &aMessage)	// (step ##1)

  1867 //

  1868 // Handle messages for the window server server.

  1869 //

  1870 	{

  1871 	iClientMessage=aMessage; // from now on use always the message stored in the session

  1872 	if (iInternalFlags&EPanicClientAsSoonAsPossible)

  1873 		{

  1874 		iClientMessage.Panic(KWSERVSessionPanicCategory,iPanicReason);

  1875 		}

  1876 	else

  1877 		{

  1878 		iPanicReason=KErrNone;

  1879 		iReply=KErrNone;

  1880 		TBool completeRequest=ETrue;

  1881 		DoServiceL(iClientMessage, completeRequest);	// (call #2)

  1882 		if (completeRequest)

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

  1884 		}

  1885 	}

  1887 void CWsClient::SetResponseHandle(RHandleBase* aHandle)

  1888 	{

  1889 	iResponseHandle = aHandle;

  1890 	}

  1892 void CWsClient::DoServiceL(const RMessage2& aMessage, TBool& aCompleteRequest)	// (step #2)

  1893 	{

  1894 	if (aMessage.IsNull())

  1895 		PPanic(EWservPanicNullMessageFromClient);

  1897 	WS_ASSERT_DEBUG(iInternalFlags&EFinishedProcessingCommands,EWsPanicCommandBufferStillBeingProcessed);

  1899 	const TInt function = aMessage.Function();

  1900 	switch (function)

  1901 		{

  1902 	case EWservMessInit:

  1903 		StartInitializationL(iConnectionId++);

  1904 		break;

  1905 	case EWservMessSyncMsgBuf:

  1906 	case EWservMessCommandBuffer:	// Process command buffer containing draw ops

  1907 		{

  1908 		if (!IsInitialised())

  1909 			PPanic(EWservPanicUninitialisedClient);

  1911 		const TInt err = aMessage.Read(KBufferMessageSlot, iCmdBuf);

  1912 		if (!err)

  1913 			{

  1914 			iReplyOffset=0;

  1915 			iDestObj=NULL;

  1916 			iNextCmd=iCmdBuf.Ptr();

  1917 			DoServiceCommandBuf();	// (call #3.1)

  1918 			}

  1919 		else if (err!=KErrDied)

  1920 			PPanic(EWservPanicDescriptor);

  1922 		if(function == EWservMessCommandBuffer && CWsTop::FinishEveryFlush())

  1923 			Screen()->DoRedrawNow();

  1924 		else

  1925 			aCompleteRequest=EFalse;

  1926 		}

  1927 		break;

  1928 	case EWservMessShutdown:

  1929 		{

  1930 		if(!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for EWservMessShutdown message ")))

  1931 			PPanic(EWservPanicPermissionDenied);

  1933 		if (aMessage.Int0() == EWservShutdownCheck)

  1934 			CWsTop::Exit();

  1935 		else

  1936 			PPanic(EWservPanicHandle);

  1937 		}

  1938 		break;

  1939 	case EWservMessFinish:

  1940 		Screen()->DoRedrawNow();

  1941 		break;

  1942 	default:

  1943 		if (function&EWservMessAsynchronousService)

  1944 			{

  1945 			TRAPD(err, ExecuteAsyncClientCommandL((function&~EWservMessAsynchronousService), aMessage));	// (call #3.2)

  1946 			aCompleteRequest = (err!=KErrNone);

  1947 			WS_ASSERT_DEBUG((!(iInternalFlags&EPanicClientAsSoonAsPossible))==(!aCompleteRequest), EWsPanicPanicFlagError);

  1948 			}

  1949 		else if (function&EWservMessAnimDllAsyncCommand)

  1950 			{

  1951 			CWsAnimDll* const animDll = static_cast<CWsAnimDll*>(HandleToObj(aMessage.Int0(), WS_HANDLE_ANIM_DLL));

  1952 			if (!animDll)

  1953 				{

  1954 				SessionPanic(EWservPanicHandle);

  1955 				break;

  1956 				}

  1958 			// it looks wrong to call CommandReply here (not AsyncCommandReply, or something, which doesn't exist), but basically, we can't add a virtual AsyncCommandReplyL to CAnim to correspond to RAnim::AsyncCommandReply as that would break binary and source compatibility for Anim plug-ins; instead asynchronous commands are done by the plug-in having to complete the RMessagePtr2 returned by iFunctions->Message() (or a copy of of that object) for asynchronous commands only

  1959 			TRAPD(err, animDll->AnimObjectL(aMessage.Int1())->CommandReply(function&~EWservMessAnimDllAsyncCommand,NULL));

  1960 			aCompleteRequest=(err!=KErrNone);

  1961 			WS_ASSERT_DEBUG((!(iInternalFlags&EPanicClientAsSoonAsPossible))==(!aCompleteRequest), EWsPanicPanicFlagError);

  1962 			}

  1963 		else

  1964 			SetReply(KErrNotSupported);

  1965 		}

  1966 	}

  1967 void CWsClient::RemoteRead(TDes16& aDes, TInt aOffset)

  1968 	{

  1969 	if (iClientMessage.Read(KRemoteBufferMessageSlot,aDes,aOffset)!=KErrNone)

  1970 		SessionPanic(EWservPanicDescriptor);

  1971 	}

  1973 void CWsClient::RemoteRead(TDes8& aDes, TInt aOffset)

  1974 	{

  1975 	if (iClientMessage.Read(KRemoteBufferMessageSlot,aDes,aOffset)!=KErrNone)

  1976 		SessionPanic(EWservPanicDescriptor);

  1977 	}

  1979 void CWsClient::RemoteReadL(TDes16& aDes, TInt aOffset)

  1980 	{

  1981 	iClientMessage.ReadL(KRemoteBufferMessageSlot,aDes,aOffset);

  1982 	}

  1984 void CWsClient::RemoteReadL(TDes8& aDes, TInt aOffset)

  1985 	{

  1986 	iClientMessage.ReadL(KRemoteBufferMessageSlot,aDes,aOffset);

  1987 	}

  1989 void CWsClient::InitStaticsL()

  1990 	{

  1991 	}

  1993 void CWsClient::DeleteStatics()

  1994 	{

  1995 	if (iTextCursorArray)

  1996 		{

  1997 		const TInt count = iTextCursorArray->Count();

  1998 		for (TInt index=0;index<count;index++)

  1999 			delete iTextCursorArray->At(index).iCursor;

  2001 		delete iTextCursorArray;

  2002 		iTextCursorArray = NULL;

  2003 		}

  2005 	// coverity[extend_simple_error]

  2006 	}

  2008 /* CWsClient implementing MWsClient */

  2010 TBool CWsClient::HasCapability(TCapability aCapability) const

  2011 	{

  2012 	return iClient.HasCapability(aCapability);

  2013 	}

  2015 TSecureId CWsClient::SecureId() const

  2016 	{

  2017 	return iClient.SecureId();

  2018 	}

  2020 TVendorId CWsClient::VendorId() const

  2021 	{

  2022 	return iClient.VendorId();

  2023 	}

  2025 /**

  2026 Makes a new copy of the aData. so it could be deleted after this call.

  2027 */

  2028 TInt CWsClient::SendMessage(const CWsGraphicDrawer* aOnBehalfOf,const TDesC8& aData)

  2029 	{

  2030 	CWsGraphicMessageQueue::CMessage* msg = CWsGraphicMessageQueue::CMessage::New(aData);

  2031 	if(msg)

  2032 		return SendMessage(aOnBehalfOf, *msg);

  2034 	return KErrGeneral;

  2035 	}

  2037 /** adds a message to the message queue

  2038 @return a postive number to uniquely identify the message

  2039 */

  2040 TInt CWsClient::SendMessage(const CWsGraphicDrawer* aOnBehalfOf,CWsMessageData& aData)

  2041 	{

  2042 	WS_ASSERT_DEBUG(aData.Data().Size(), EWsPanicWsGraphic);

  2043 	const CWsGraphicDrawerObject* obj = DrawerObject(aOnBehalfOf);

  2044 	WS_ASSERT_DEBUG(obj, EWsPanicWsGraphic);

  2045 	if(obj)

  2046 		{

  2047 		// assign message id

  2048 		if(iMessageIdSeq == KMaxTInt) // Wrap if iMessageIdSeq has reached KMaxTInt

  2049 			iMessageIdSeq = 0;

  2051 		iMessageIdSeq++;

  2052 		// correct other handles

  2053 		aData.iClientHandle = (obj->ClientHandle() | (EWsGraphMessageTypeUser & 0x03));

  2054 		aData.iDrawer = obj->Drawer();

  2055 		aData.iId = iMessageIdSeq;

  2056 		iGraphicMessageQueue.Queue(&aData);

  2057 		return iMessageIdSeq;

  2058 		}

  2060 	return KErrGeneral;

  2061 	}

  2064 CWsGraphicDrawerObject* CWsClient::DrawerObject(const CWsGraphicDrawer* aDrawer)

  2065 	{

  2066 	const TInt count = ObjectIndex()->Length();

  2067 	for(TInt i=0; i<count; i++)

  2068 		{

  2069 		CWsObject* obj = const_cast<CWsObject*>(ObjectIndex()->At(i));

  2070 		if(obj && (WS_HANDLE_GRAPHIC_DRAWER == obj->Type()))

  2071 			{

  2072 			CWsGraphicDrawerObject* candidate = static_cast<CWsGraphicDrawerObject*>(obj);

  2073 			if(candidate->Drawer() == aDrawer)

  2074 				return candidate;

  2075 			}

  2076 		}

  2078 	return NULL;

  2079 	}

  2081 const CWsGraphicDrawerObject* CWsClient::DrawerObject(const CWsGraphicDrawer* aDrawer) const

  2082 	{

  2083 	CWsObjectIx* objectIndex = const_cast<CWsClient*>(this)->ObjectIndex();

  2084 	const TInt count = objectIndex->Length();

  2085 	for(TInt i=0; i<count; i++)

  2086 		{

  2087 		CWsObject* obj = const_cast<CWsObject*>(objectIndex->At(i));

  2088 		if(obj && (WS_HANDLE_GRAPHIC_DRAWER == obj->Type()))

  2089 			{

  2090 			const CWsGraphicDrawerObject* candidate = static_cast<CWsGraphicDrawerObject*>(obj);

  2091 			if(candidate->Drawer() == aDrawer)

  2092 				return candidate;

  2093 			}

  2094 		}

  2096 	return NULL;

  2097 	}

  2099 TInt CWsClient::RegisterSurface(const TWsClCmdUnion& pData)

  2100 	{

  2101 	TInt screenNumber = pData.SurfaceRegister->screenNumber;

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

  2103 		{

  2104 		PPanic(EWservPanicScreenNumber);

  2105 		}

  2106 	if (pData.SurfaceRegister->surfaceId.Type() == TSurfaceId::EScreenSurface

  2107 			|| pData.SurfaceRegister->surfaceId.IsNull())

  2108 		{

  2109 		PPanic(EWservPanicInvalidSurface);

  2110 		}

  2112 	CRegisteredSurfaceMap* surfaceMap = CWsTop::Screen(screenNumber)->SurfaceMap();

  2113 	const TSurfaceId& surfaceId = pData.SurfaceRegister->surfaceId;

  2114 	TInt err = surfaceMap->Add(*this,surfaceId);

  2116 	switch(err)

  2117 		{

  2118 	case KErrNone:

  2119 	case KErrNoMemory:

  2120 	case KErrInUse:

  2121 	case KErrArgument:

  2122 		break;

  2123 	default:

  2124 		PPanic(EWservPanicInvalidSurface);

  2125 		}

  2126 	return err;

  2127 	}

  2129 void CWsClient::UnregisterSurface(const TWsClCmdUnion& pData)

  2130 	{

  2131 	TInt screenNumber = pData.SurfaceRegister->screenNumber;

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

  2133 		{

  2134 		PPanic(EWservPanicScreenNumber);

  2135 		}

  2136 	TInt err = CWsTop::Screen(screenNumber)->SurfaceMap()->Remove(*this,pData.SurfaceRegister->surfaceId);

  2137 	WS_ASSERT_DEBUG((err==KErrNone||err==KErrNotFound), EWsPanicSurfaceMapError);

  2138 	}

  2140 void CWsClient::CreateDrawableSourceL(const TWsClCmdCreateDrawableSource& aDrawableSourceData)

  2141 	{

  2142 	CWsDrawableSource* drawableSource = new(ELeave) CWsDrawableSource(this);

  2143 	CleanupStack::PushL(drawableSource);

  2144 	drawableSource->ConstructL(aDrawableSourceData);

  2145 	CleanupStack::Pop();

  2146 	}

  2148 void CWsClient::IndicateAppOrientation(TRenderOrientation aOrientation)

  2149 	{

  2150 	iIndicatedAppOrientation = aOrientation;

  2151 	CWsTop::CheckRenderOrientation();

  2152 	}

  2154 TInt CWsClient::GetIndicatedAppOrientation()

  2155 	{

  2156 	return iIndicatedAppOrientation;

  2157 	}

  2159 //

  2160 // class CWsCliObj

  2161 //

  2163 CWsCliObj* CWsCliObj::NewL(CWsClient* aOwner)

  2164 	{

  2165 	CWsCliObj* self = new(ELeave) CWsCliObj(aOwner);

  2166 	CleanupStack::PushL(self);

  2167 	self->ConstructL();

  2168 	CleanupStack::Pop(self);

  2169 	return self;

  2170 	}

  2172 CWsCliObj::CWsCliObj(CWsClient *aOwner) :

  2173 	CWsObject(aOwner, WS_HANDLE_CLIENT)

  2174 	{

  2175 	}

  2177 void CWsCliObj::ConstructL()

  2178 	{

  2179 	NewObjL();

  2180 	}

  2182 void CWsCliObj::CommandL(TInt aOpcode, const TAny* aCmdData)	// (step #5)

  2183 	{

  2184 	iWsOwner->ExecuteCommandL(aOpcode,aCmdData);	// (call #6)

  2185 	}

  2187 CWsObject* CWsClient::HandleToObjUntyped(TInt aHandle)

  2188 	{

  2189 	return iObjectIndex->HandleToObject(aHandle);

  2190 	}

  2192 const CWsObject* CWsClient::HandleToObjUntyped(TInt aHandle) const

  2193 	{

  2194 	return const_cast<CWsClient*>(this)->HandleToObjUntyped(aHandle);

  2195 	}

  2197 CWsObject* CWsClient::HandleToObj(TInt aHandle, WH_HANDLES aType)

  2198 	{

  2199 	CWsObject* object = HandleToObjUntyped(aHandle);

  2200 	return (object && object->Type() == aType) ? object : NULL;

  2201 	}

  2204 const CWsObject* CWsClient::HandleToObj(TInt aHandle, WH_HANDLES aType) const

  2205 	{

  2206 	return const_cast<CWsClient*>(this)->HandleToObj(aHandle, aType);

  2207 	}

  2209 void CWsClient::SetRetryFlag(TEventCode aEventCode)

  2210 	{

  2211 	switch(aEventCode)

  2212 		{

  2213 		//To be expanded

  2214 		case EEventDisplayChanged:

  2215 			{

  2216 			iInternalFlags |= ERetryDisplayEvent;

  2217 			}

  2218 		break;

  2220 		}

  2221 	}

  2222 TBool CWsClient::RetryEvent(TEventCode aEventCode)

  2223 	{

  2224 	switch(aEventCode)

  2225 		{//To be expanded

  2226 		case EEventDisplayChanged:

  2227 			{

  2228 			return (iInternalFlags & ERetryDisplayEvent);

  2229 			}

  2230 		}

  2231 	return EFalse;

  2232 	}

  2234 void CWsClient::RemoveRetryFlag(TEventCode aEventCode)

  2235 	{

  2236 	switch(aEventCode)

  2237 		{//To be expanded

  2238 		case EEventDisplayChanged:

  2239 			{

  2240 			iInternalFlags &= ~ERetryDisplayEvent;

  2241 			}

  2242 		break;

  2243 		}

  2244 	}

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