1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/graphics/windowing/windowserver/nonnga/SERVER/CLIENT.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1719 @@
1.4 +// Copyright (c) 1994-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// Client handling
1.18 +//
1.19 +//
1.20 +
1.21 +#include "CLIENT.H"
1.22 +
1.23 +#include "ANIM.H"
1.24 +#include "Direct.H"
1.25 +#include "EVENT.H"
1.26 +#include "KEYCLICK.H"
1.27 +#include "server.h"
1.28 +#include "gc.h"
1.29 +#include "rootwin.h"
1.30 +#include "windowgroup.h"
1.31 +#include "wstop.h"
1.32 +#include "panics.h"
1.33 +#include "../CLIENT/w32comm.h"
1.34 +#include "password.h"
1.35 +#include "pointer.h"
1.36 +#include <u32hal.h> // EHalGroupEmulator
1.37 +#include "WsMemMgr.h"
1.38 +
1.39 +GLREF_C void HeapDump();
1.40 +
1.41 +GLREF_D CDebugLogBase *wsDebugLog;
1.42 +
1.43 +GLREF_D TPtr nullDescriptor;
1.44 +
1.45 +TWsCmdHeaderBase CWsClient::iCurrentCommand;
1.46 +TBuf8<EClientBufferMaxSize> CWsClient::iCmdBuf;
1.47 +TUint CWsClient::iConnectionId=CDebugLogBase::EDummyConnectionId+1;
1.48 +CArrayFixFlat<TWsCursorArrayItem> *CWsClient::iSystemPointerCursors=NULL;
1.49 +TInt CWsClient::iDefaultSystemPointerCursorIndex=0; //Negative when there isn't one
1.50 +CWsPointerCursor *CWsClient::iDefaultSystemPointerCursor;
1.51 +CWsClient *CWsClient::iSystemPointerCursorListOwner=NULL;
1.52 +CArrayFixFlat<TWsCursorArrayItem> *CWsClient::iTextCursorArray=NULL;
1.53 +TInt CWsClient::iReply;
1.54 +TInt CWsClient::iReplyOffset;
1.55 +CWsClient *CWsClient::iCurrentClient;
1.56 +
1.57 +/**
1.58 +Used for enforcing the redraw calling convention (in preparation for BR2412) in emulator builds.
1.59 +When enabled this will panic any client calling a CWindowGc draw operation outside a
1.60 +RWindow::BeginRedraw() / RWindow::EndRedraw() pair (known as non-redraw drawing).
1.61 +
1.62 +Enable by adding "debug_wserv_exe_EnforceRedrawCallingConvention X" to epoc.ini
1.63 +where X is either 0 (zero) for "off" or 1 (one) for "on".
1.64 +
1.65 +Then enable globaly in WServ AutoFlush by defining __AUTO_FLUSH in ../client/client.h
1.66 +or locally by calling RWsSession::SetAutoFlush(ETrue) for a specific client programatically,
1.67 +or locally pressing Ctrl-Alt-Shift-F in the emulator.
1.68 +*/
1.69 +TBool CWsClient::iDebug_EnforceRedrawCallingConvention = EFalse;
1.70 +
1.71 +_LIT(KWSERVSessionPanicCategory,"WSERV");
1.72 +
1.73 +TKeyArrayFix CursorKey(_FOFF(TWsCursorArrayItem,iIndex),ECmpTInt);
1.74 +
1.75 +static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);
1.76 +static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);
1.77 +static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_PowerMgmt,ECapabilityPowerMgmt);
1.78 +
1.79 +CWsClient::CWsClient(RThread aClient) : iClient(aClient), iGraphicMessageQueue(this), iIsInitialised(EFalse)
1.80 +
1.81 +#if defined(__WINS__)
1.82 + ,iRemoveKeyCode(ETrue)
1.83 +#endif
1.84 + {
1.85 + iScreen=CWsTop::Screen(); //## Need to find better way to set this
1.86 + }
1.87 +
1.88 +CWsClient::~CWsClient()
1.89 + {
1.90 + WindowServer().RemoveAllGraphicDrawers(*this); // deindexes all graphic drawers owned by this client
1.91 +
1.92 + delete iTempCustomTextCursor.iCursor;
1.93 + FreeSystemPointerCursorList();
1.94 + CWsTop::ClientDestroyed(this);
1.95 + if (wsDebugLog)
1.96 + {
1.97 + _LIT(ClientDestuct,"Client %d destructing");
1.98 + wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,ClientDestuct, iConnectionHandle);
1.99 + }
1.100 + iInternalFlags|=EClientIsClosing;
1.101 + delete iObjectIndex;
1.102 + delete iEventQueue;
1.103 + delete iRedrawQueue;
1.104 + delete iPriorityKeyEvent;
1.105 +
1.106 + CWsTop::SessionExited(this);
1.107 + iScreen->Update(); /* Mathias: Don't care about multiple screens yet
1.108 + CWsTop::UpdateAllScreens(EFalse);
1.109 +*/
1.110 + iClient.Close();
1.111 + }
1.112 +
1.113 +void CWsClient::CompleteInitializationL()
1.114 + {
1.115 + iObjectIndex=new(ELeave) CWsObjectIx();
1.116 + iObjectIndex->ConstructL();
1.117 + iEventQueue=new(ELeave) CEventQueue(this);
1.118 + iEventQueue->ConstructL();
1.119 + iRedrawQueue=new(ELeave) CRedrawQueue(this);
1.120 + iRedrawQueue->ConstructL();
1.121 + iPriorityKeyEvent=new(ELeave) CPriorityKey(this);
1.122 + CWsCliObj::NewL(this);
1.123 + iComputeMode=RWsSession::EPriorityControlComputeOff;
1.124 + CWsTop::NewSession(this);
1.125 +
1.126 +#ifdef __WINS__
1.127 + TBool halValue = EFalse;
1.128 + if (UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty,
1.129 + (TAny*)"debug_wserv_exe_EnforceRedrawCallingConvention", &halValue) == KErrNone)
1.130 + {
1.131 + iDebug_EnforceRedrawCallingConvention = halValue;
1.132 + }
1.133 +#endif
1.134 +
1.135 + iIsInitialised = ETrue;
1.136 + }
1.137 +
1.138 +TBool CWsClient::DebugEnforceRedrawCallingConvention()
1.139 + {
1.140 + return iDebug_EnforceRedrawCallingConvention;
1.141 + }
1.142 +
1.143 +void CWsClient::StartInitializationL(TUint aConnectionHandle)
1.144 + {
1.145 + if (wsDebugLog)
1.146 + wsDebugLog->NewClient(aConnectionHandle);
1.147 + if (iObjectIndex)
1.148 + {
1.149 + PPanic(EWservPanicReInitialise);
1.150 + }
1.151 + else
1.152 + {
1.153 + iConnectionHandle=aConnectionHandle;
1.154 + CompleteInitializationL();
1.155 + }
1.156 + }
1.157 +
1.158 +void CWsClient::HandleToWindow(TInt handle,CWsWindowBase **pWin)
1.159 +//
1.160 +// Convert a handle to object checking it is of the correct type.
1.161 +//
1.162 + {
1.163 + if ((*pWin=(CWsWindowBase *)HandleToObjUntyped(handle))==NULL ||
1.164 + ((*pWin)->Type()!=WS_HANDLE_WINDOW && (*pWin)->Type()!=WS_HANDLE_GROUP_WINDOW))
1.165 + PPanic(EWservPanicWindow);
1.166 + }
1.167 +
1.168 +void CWsClient::HandleToClientWindow(TInt handle,CWsClientWindow **pWin)
1.169 +//
1.170 +// Convert a handle to object checking it is of the correct type.
1.171 +//
1.172 + {
1.173 + if ((*pWin=(CWsClientWindow *)HandleToObj(handle, WS_HANDLE_WINDOW))==NULL)
1.174 + PPanic(EWservPanicWindow);
1.175 + }
1.176 +
1.177 +void CWsClient::CreateNewPointerCursorL(const TWsClCmdCreatePointerCursor &aCmd)
1.178 + {
1.179 + CWsPointerCursor *pc=new(ELeave) CWsPointerCursor(this);
1.180 + CleanupStack::PushL(pc);
1.181 + pc->ConstructL(aCmd);
1.182 + CleanupStack::Pop();
1.183 + }
1.184 +
1.185 +// Create a new custom text cursor
1.186 +void CWsClient::StartSetCustomTextCursorL(const TWsClCmdCustomTextCursorData& aCmd)
1.187 + {
1.188 + if (!iTextCursorArray)
1.189 + {
1.190 + const TInt textCursorArrayGranularity = 4;
1.191 + iTextCursorArray = new(ELeave) CArrayFixFlat<TWsCursorArrayItem>(textCursorArrayGranularity);
1.192 + }
1.193 + TInt arrayIndex;
1.194 + if (FindCursorArrayItem(iTextCursorArray, aCmd.identifier, arrayIndex))
1.195 + User::Leave(KErrAlreadyExists);
1.196 + delete iTempCustomTextCursor.iCursor;
1.197 + iTempCustomTextCursor.iCursor = NULL;
1.198 + iTempCustomTextCursor.iCursor = new(ELeave) CWsCustomTextCursor(this, aCmd.alignment);
1.199 + static_cast<CWsCustomTextCursor*>(iTempCustomTextCursor.iCursor)->ConstructL(aCmd.flags);
1.200 + iTempCustomTextCursor.iIndex = aCmd.identifier;
1.201 + }
1.202 +
1.203 +// Add new custom text cursor to global list
1.204 +void CWsClient::CompleteSetCustomTextCursorL(TInt aError)
1.205 + {
1.206 + if (aError != KErrNone)
1.207 + {
1.208 + delete iTempCustomTextCursor.iCursor;
1.209 + iTempCustomTextCursor.iCursor = NULL;
1.210 + User::Leave(aError);
1.211 + }
1.212 +
1.213 + TWsCursorArrayItem entry = iTempCustomTextCursor;
1.214 + iTempCustomTextCursor.iCursor = NULL;
1.215 + CleanupStack::PushL(entry.iCursor);
1.216 +
1.217 + TInt arrayIndex;
1.218 + if (FindCursorArrayItem(iTextCursorArray, entry.iIndex, arrayIndex))
1.219 + {
1.220 + User::Leave(KErrAlreadyExists);
1.221 + }
1.222 + else
1.223 + {
1.224 + iTextCursorArray->InsertIsqL(entry, CursorKey);
1.225 + }
1.226 +
1.227 + CleanupStack::Pop(entry.iCursor);
1.228 + }
1.229 +
1.230 +CWsCustomTextCursor* CWsClient::FindCustomTextCursor(TInt aIdentifier)
1.231 + {
1.232 + TInt arrayIndex;
1.233 + if (!FindCursorArrayItem(iTextCursorArray, aIdentifier, arrayIndex))
1.234 + {
1.235 + return NULL;
1.236 + }
1.237 + return TextCursor(arrayIndex);
1.238 + }
1.239 +
1.240 +void CWsClient::CreateNewSpriteL(const TWsClCmdCreateSprite &aCmd)
1.241 + {
1.242 + CWsSprite *sprite=new(ELeave) CWsSprite(this);
1.243 + CleanupStack::PushL(sprite);
1.244 + sprite->ConstructL(aCmd);
1.245 + CleanupStack::Pop();
1.246 + }
1.247 +
1.248 +void CWsClient::CreateNewBitmapL(const TWsClCmdCreateBitmap &aCmd)
1.249 + {
1.250 + DWsBitmap *bitmap=new(ELeave) DWsBitmap(this);
1.251 + CleanupStack::PushL(bitmap);
1.252 + bitmap->ConstructL(aCmd);
1.253 + CleanupStack::Pop();
1.254 + }
1.255 +
1.256 +/** Creates a new window.
1.257 +
1.258 +@param aCmd The command received from the client
1.259 +@internalComponent
1.260 +@released
1.261 +*/
1.262 +void CWsClient::CreateNewWindowL(const TWsClCmdCreateWindow &aCmd)
1.263 + {
1.264 + CWsWindowBase *parent;
1.265 + HandleToWindow(aCmd.parent,&parent);
1.266 + CWsClientWindow *win=NULL;
1.267 + TBool deviceIsInvalid=EFalse;
1.268 + CScreen* screen = parent->Screen();
1.269 +
1.270 + if (parent->WinType()==EWinTypeGroup)
1.271 + {
1.272 + __ASSERT_DEBUG(!((CWsWindowGroup*)parent)->ScreenDeviceDeleted(),PPanic(EWservPanicGroupWinScreenDeviceDeleted));
1.273 + win=new(ELeave) CWsClientWindow(this, screen);
1.274 + deviceIsInvalid=!((CWsWindowGroup *)parent)->ScreenDeviceValid();
1.275 + }
1.276 + else
1.277 + {
1.278 + win=new(ELeave) CWsClientWindow(this, screen);
1.279 + }
1.280 + CleanupStack::PushL(win);
1.281 + win->ConstructL(aCmd,parent,deviceIsInvalid);
1.282 + CleanupStack::Pop(win);
1.283 + }
1.284 +
1.285 +void CWsClient::CreateNewWindowGroupL(const TWsClCmdCreateWindowGroup &aCmd)
1.286 + {
1.287 + CWsWindowGroup::NewL(this, NULL, aCmd); //Screen is set inside the ConstructL since support for multiple screens was introduced
1.288 + }
1.289 +
1.290 +void CWsClient::CreateNewAnimDllL(const TWsClCmdUnion &aParams)
1.291 + {
1.292 + CWsAnimDll *animDll=new(ELeave) CWsAnimDll(this);
1.293 + CleanupStack::PushL(animDll);
1.294 + animDll->LoadL(BufferTPtr((TText *)(aParams.LoadAnimDll+1),aParams.LoadAnimDll->length));
1.295 + CleanupStack::Pop();
1.296 + }
1.297 +
1.298 +void CWsClient::CreateNewScreenDeviceL( TInt aDefaultScreenNumber, TUint aClientScreenDevicePointer)
1.299 + {
1.300 + DWsScreenDevice *screenDevice=new(ELeave) DWsScreenDevice( this, aDefaultScreenNumber,aClientScreenDevicePointer);
1.301 + CleanupStack::PushL(screenDevice);
1.302 + screenDevice->ConstructL();
1.303 + CleanupStack::Pop(screenDevice);
1.304 + if (iPrimaryScreenDevice==NULL)
1.305 + {
1.306 + iPrimaryScreenDevice=screenDevice;
1.307 + // When client create screen device, change default screen to the one specified.
1.308 + // Client should do this immediately after establishing session
1.309 + iScreen = iPrimaryScreenDevice->Screen();
1.310 + InitialiseScreenDevices();
1.311 + }
1.312 + }
1.313 +
1.314 +void CWsClient::InitialiseScreenDevices()
1.315 + {
1.316 + const TWsObject* ptr=iObjectIndex->FirstObject();
1.317 + const TWsObject* end=ptr+iObjectIndex->Length();
1.318 + WS_ASSERT_DEBUG(ptr->iObject==NULL, EWsPanicObjectIndexError);
1.319 + while(++ptr<end)
1.320 + {
1.321 + if (ptr->iObject && ptr->iObject->Type()==WS_HANDLE_GROUP_WINDOW)
1.322 + {
1.323 + CWsWindowGroup *gw =STATIC_CAST(CWsWindowGroup*,ptr->iObject);
1.324 + if(gw->Device()==NULL)
1.325 + {
1.326 + gw->SetScreenDevice(iPrimaryScreenDevice);
1.327 + }
1.328 + }
1.329 + }
1.330 + }
1.331 +
1.332 +void CWsClient::CreateNewClickL(const TUid& aUid)
1.333 + {
1.334 + CClick *click=new(ELeave) CClick(this);
1.335 + CleanupStack::PushL(click);
1.336 + click->ConstructL(aUid);
1.337 + CleanupStack::Pop(click);
1.338 + }
1.339 +
1.340 +void CWsClient::RequestComplete(TRequestStatus * &aStatus, TInt aErr)
1.341 + {
1.342 + Client().RequestComplete(aStatus,aErr);
1.343 + }
1.344 +
1.345 +void CWsClient::PanicCurrentClient(TClientPanic aPanic)
1.346 + {
1.347 + iCurrentClient->PPanic(aPanic);
1.348 + }
1.349 +
1.350 +void CWsClient::PPanic(TClientPanic aPanic) const
1.351 +//This function is allowed to leave with out the 'L' convention for special reasons
1.352 + {
1.353 + SessionPanic(aPanic);
1.354 + User::Leave(EPanicLeave);
1.355 + }
1.356 +
1.357 +void CWsClient::SessionPanic(TClientPanic aReason) const
1.358 + {
1.359 + if (wsDebugLog)
1.360 + wsDebugLog->Panic(iConnectionHandle, aReason);
1.361 + if (!iInternalFlags&EPanicClientAsSoonAsPossible) // keep the first error code
1.362 + {
1.363 + iInternalFlags|=EPanicClientAsSoonAsPossible;
1.364 + iPanicReason=aReason;
1.365 + }
1.366 + }
1.367 +
1.368 +void CWsClient::SessionTerminate()
1.369 + {
1.370 + if (wsDebugLog)
1.371 + wsDebugLog->Panic(iConnectionHandle, 0);
1.372 +
1.373 + const RThread thread=Client();
1.374 + RProcess process;
1.375 + if (thread.Process(process)==KErrNone)
1.376 + {
1.377 + process.Terminate(0);
1.378 + process.Close();
1.379 + }
1.380 + }
1.381 +
1.382 +void CWsClient::ReplyBuf(const TDesC16 &aDes)
1.383 + {
1.384 + WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);
1.385 + if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot,aDes,iReplyOffset) != KErrNone)
1.386 + PanicCurrentClient(EWservPanicDescriptor);
1.387 + iReplyOffset+=aDes.Length();
1.388 + if (wsDebugLog)
1.389 + wsDebugLog->ReplyBuf(aDes);
1.390 + }
1.391 +
1.392 +void CWsClient::ReplyBuf(const TDesC8 &aDes)
1.393 + {
1.394 + WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);
1.395 + if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot,aDes,iReplyOffset) != KErrNone)
1.396 + PanicCurrentClient(EWservPanicDescriptor);
1.397 + iReplyOffset+=aDes.Length();
1.398 + if (wsDebugLog)
1.399 + wsDebugLog->ReplyBuf(aDes);
1.400 + }
1.401 +
1.402 +void CWsClient::ReplyBuf(const TAny *aSource, TInt aLength)
1.403 +//
1.404 +// Send a buffer to the client process.
1.405 +//
1.406 + {
1.407 + TPtrC8 src(reinterpret_cast<const TUint8*>(aSource),aLength);
1.408 + ReplyBuf(src);
1.409 + }
1.410 +
1.411 +void CWsClient::ReplySize(const TSize &aSize)
1.412 + {
1.413 + ReplyBuf(&aSize,sizeof(aSize));
1.414 + }
1.415 +
1.416 +void CWsClient::ReplyPoint(const TPoint &aPoint)
1.417 + {
1.418 + ReplyBuf(&aPoint,sizeof(aPoint));
1.419 + }
1.420 +
1.421 +void CWsClient::ReplyRect(const TRect &aRect)
1.422 + {
1.423 + ReplyBuf(&aRect,sizeof(aRect));
1.424 + }
1.425 +
1.426 +void CWsClient::SetReply(TInt reply)
1.427 + {
1.428 + iReply=reply;
1.429 + if (wsDebugLog)
1.430 + wsDebugLog->Reply(reply);
1.431 + }
1.432 +
1.433 +const TUint8 *CWsClient::EndOfCommandBuffer()
1.434 + {
1.435 + return(iCmdBuf.Ptr()+iCmdBuf.Size());
1.436 + }
1.437 +
1.438 +const TPtrC CWsClient::BufferTPtr(TText *aStart,TInt aLen)
1.439 + {
1.440 + TPtrC ptr;
1.441 + if (!BufferTPtrGc(aStart,aLen,ptr))
1.442 + PanicCurrentClient(EWservPanicBufferPtr);
1.443 + return(ptr);
1.444 + }
1.445 +
1.446 +TBool CWsClient::BufferTPtrGc(TText* aStart,TInt aLen, TPtrC& aPtr)
1.447 + {
1.448 + if (iCurrentCommand.iOpcode>0)
1.449 + {
1.450 + if ((REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()
1.451 + || REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))
1.452 + return(EFalse);
1.453 + }
1.454 + else
1.455 + {
1.456 + if (aLen>=iCurrentCommand.iCmdLength)
1.457 + return(EFalse);
1.458 + }
1.459 + aPtr.Set(aStart,aLen);
1.460 + return(ETrue);
1.461 + }
1.462 +
1.463 +const TPtrC8 CWsClient::BufferTPtr8(TUint8* aStart,TInt aLen)
1.464 + {
1.465 + if (iCurrentCommand.iOpcode>0 && (REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()
1.466 + || REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))
1.467 + PanicCurrentClient(EWservPanicBufferPtr);
1.468 + return(TPtrC8(aStart,aLen));
1.469 + }
1.470 +
1.471 +/**
1.472 +Process a command buffer
1.473 +
1.474 +@internalComponent
1.475 +@released
1.476 +*/
1.477 +void CWsClient::CommandBufL()
1.478 + {
1.479 + if (wsDebugLog)
1.480 + {
1.481 + wsDebugLog->CommandBuf(iConnectionHandle);
1.482 + RThread client = Client();
1.483 + wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, client.FullName());
1.484 + }
1.485 + iReplyOffset=0;
1.486 + iCurrentClient=this;
1.487 + CWsObject *destObj=NULL;
1.488 + const TUint8 *nextCmd=iCmdBuf.Ptr();
1.489 + const TUint8 *endCmd=nextCmd+iCmdBuf.Length();
1.490 +
1.491 + do
1.492 + {
1.493 + const TWsCmdHeader *pCmd=(TWsCmdHeader *)nextCmd;
1.494 + TUint opcode=pCmd->iBase.iOpcode;
1.495 + TInt headerLen=sizeof(pCmd->iBase);
1.496 + iCurrentCommand=pCmd->iBase;
1.497 +
1.498 + // For performance reasons the handle is only included
1.499 + // if it is different from the previous command. The EWsOpcodeHandle
1.500 + // flag indicates whether a new handle has been included in the
1.501 + // current command. If not we use the same handle as the previous
1.502 + // command.
1.503 + if (opcode&EWsOpcodeHandle)
1.504 + {
1.505 + opcode&=~EWsOpcodeHandle;
1.506 + iCurrentCommand.iOpcode=reinterpret_cast<TUint16&>(opcode);
1.507 + destObj=HandleToObjUntyped(pCmd->iDestHandle);
1.508 + headerLen=sizeof(*pCmd);
1.509 + }
1.510 + nextCmd+=headerLen;
1.511 + const TAny *cmdParams=nextCmd;
1.512 + nextCmd+=pCmd->iBase.iCmdLength;
1.513 + if (destObj==NULL || nextCmd>endCmd) // Invalid handle or Corrupt buffer
1.514 + {
1.515 + SessionPanic(destObj==NULL ? EWservPanicHandle : EWservPanicBuffer);
1.516 + break;
1.517 + }
1.518 + #if defined(_DEBUG)
1.519 + iLastCommand=(nextCmd==endCmd);
1.520 + #endif
1.521 + // Storing destObj->Type() to a temporary variable objType allows the value of destObj->Type()
1.522 + // to be used if destObj is deleted during destObj->CommandL().
1.523 + WH_HANDLES objType=destObj->Type();
1.524 + if (wsDebugLog)
1.525 + wsDebugLog->Command(objType, opcode, cmdParams, destObj->LogHandle());
1.526 + destObj->CommandL(opcode, cmdParams);
1.527 +
1.528 + } while(nextCmd<endCmd);
1.529 +
1.530 +#if defined(_DEBUG)
1.531 + User::Heap().Check();
1.532 +#endif
1.533 + }
1.534 +
1.535 +void CWsClient::CommandL(TInt aOpcode, const RMessage2& aMessage)
1.536 + {
1.537 + switch(aOpcode)
1.538 + {
1.539 + case EWsClOpEventReady:
1.540 + EventReady(aMessage);
1.541 + break;
1.542 + case EWsClOpPriorityKeyReady:
1.543 + PriorityKeyEventReady(aMessage);
1.544 + break;
1.545 + case EWsClOpRedrawReady:
1.546 + RedrawEventReady(aMessage);
1.547 + break;
1.548 + case EWsClOpGraphicMessageReady:
1.549 + iGraphicMessageQueue.EventReady(aMessage);
1.550 + break;
1.551 + default:
1.552 + {
1.553 + PPanic(EWservPanicOpcode);
1.554 + break;
1.555 + }
1.556 + }
1.557 + }
1.558 +
1.559 +void CWsClient::CommandL(TInt aOpcode, const TAny *aCmdData)
1.560 + {
1.561 + TWsClCmdUnion pData;
1.562 + pData.any=aCmdData;
1.563 + switch(aOpcode)
1.564 + {
1.565 + case EWsClOpCreateWindowGroup:
1.566 + CreateNewWindowGroupL(*pData.CreateWindowGroup);
1.567 + break;
1.568 + case EWsClOpCreateWindow:
1.569 + CreateNewWindowL(*pData.CreateWindow);
1.570 + break;
1.571 + case EWsClOpCreateGc:
1.572 + CWsGc::NewL(this);
1.573 + break;
1.574 + case EWsClOpCreateAnimDll:
1.575 + if (!CheckBuffer(pData.LoadAnimDll->length, KMaxFileName))
1.576 + PanicCurrentClient(EWservPanicBufferPtr);
1.577 + CreateNewAnimDllL(pData);
1.578 + break;
1.579 + case EWsClOpCreateGraphic:
1.580 + CWsGraphicDrawerObject::NewL(this,pData);
1.581 + break;
1.582 + case EWsClOpCreateScreenDevice:
1.583 + {
1.584 + TInt screenNumber = pData.CreateScreenDevice->screenNumber;
1.585 + TUint clientScreenDevicePointer = pData.CreateScreenDevice->clientScreenDevicePointer;
1.586 + if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())
1.587 + {
1.588 + PPanic(EWservPanicScreenNumber);
1.589 + }
1.590 + else
1.591 + {
1.592 + CreateNewScreenDeviceL(screenNumber,clientScreenDevicePointer);
1.593 + }
1.594 + }
1.595 + break;
1.596 + case EWsClOpCreateSprite:
1.597 + CreateNewSpriteL(*pData.CreateSprite);
1.598 + break;
1.599 + case EWsClOpCreatePointerCursor:
1.600 + CreateNewPointerCursorL(*pData.CreatePointerCursor);
1.601 + break;
1.602 + case EWsClOpStartSetCustomTextCursor:
1.603 + StartSetCustomTextCursorL(*pData.CustomTextCursorData);
1.604 + break;
1.605 + case EWsClOpCompleteSetCustomTextCursor:
1.606 + CompleteSetCustomTextCursorL(*pData.Int);
1.607 + break;
1.608 + case EWsClOpCreateBitmap:
1.609 + CreateNewBitmapL(*pData.CreateBitmap);
1.610 + break;
1.611 + case EWsClOpCreateDirectScreenAccess:
1.612 + CWsDirectScreenAccess::NewL(this);
1.613 + break;
1.614 + case EWsClOpCreateClick:
1.615 + CreateNewClickL(*pData.Uid);
1.616 + break;
1.617 + case EWsClOpSetHotKey:
1.618 + {
1.619 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetHotKey API")))
1.620 + {
1.621 + User::Leave(KErrPermissionDenied);
1.622 + }
1.623 + TWindowServerEvent::SetHotKeyL(*pData.SetHotKey);
1.624 + }
1.625 + break;
1.626 + case EWsClOpClearHotKeys:
1.627 + {
1.628 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::ClearHotKeys API")))
1.629 + {
1.630 + User::Leave(KErrPermissionDenied);
1.631 + }
1.632 + TWindowServerEvent::ClearHotKeysL(*pData.UInt);
1.633 + }
1.634 + break;
1.635 + case EWsClOpRestoreDefaultHotKey:
1.636 + TWindowServerEvent::ResetDefaultHotKeyL(*pData.UInt);
1.637 + break;
1.638 + case EWsClOpSetShadowVector:
1.639 + {
1.640 + for(TInt i=0;i<CWsTop::NumberOfScreens();i++)
1.641 + {
1.642 + CScreen *screen = CWsTop::Screen(i);
1.643 + screen->SetShadowVector(*pData.Point);
1.644 + }
1.645 + }
1.646 + break;
1.647 + case EWsClOpShadowVector:
1.648 + {
1.649 + TPoint vector(iScreen->ShadowVector());
1.650 + ReplyBuf(&vector,sizeof(TPoint));
1.651 + }
1.652 + break;
1.653 + case EWsClOpSetKeyboardRepeatRate:
1.654 + {
1.655 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetKeyboardRepeatRate API")))
1.656 + {
1.657 + User::Leave(KErrPermissionDenied);
1.658 + }
1.659 + if ((pData.SetKeyboardRepeatRate->initial.Int()<0) || (pData.SetKeyboardRepeatRate->time.Int()<0))
1.660 + {
1.661 + User::Leave(KErrArgument);
1.662 + }
1.663 + CKeyboardRepeat::SetRepeatTime(pData.SetKeyboardRepeatRate->initial,pData.SetKeyboardRepeatRate->time);
1.664 + }
1.665 + break;
1.666 + case EWsClOpGetKeyboardRepeatRate:
1.667 + {
1.668 + SKeyRepeatSettings settings;
1.669 + CKeyboardRepeat::GetRepeatTime(settings.iInitialTime,settings.iTime);
1.670 + ReplyBuf(&settings,sizeof(settings));
1.671 + }
1.672 + break;
1.673 + case EWsClOpSetDoubleClick:
1.674 + {
1.675 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetDoubleClick API")))
1.676 + {
1.677 + User::Leave(KErrPermissionDenied);
1.678 + }
1.679 + WsPointer::SetDoubleClick(pData.SetDoubleClick->interval,pData.SetDoubleClick->distance);
1.680 + }
1.681 + break;
1.682 + case EWsClOpGetDoubleClickSettings:
1.683 + {
1.684 + SDoubleClickSettings settings;
1.685 + WsPointer::GetDoubleClickSettings(settings.iInterval,settings.iDistance);
1.686 + ReplyBuf(&settings,sizeof(settings));
1.687 + }
1.688 + break;
1.689 + case EWsClOpEventReady:
1.690 + break;
1.691 + case EWsClOpGetEvent:
1.692 + GetEventData();
1.693 + break;
1.694 + case EWsClOpPurgePointerEvents:
1.695 + PurgePointerEvents();
1.696 + break;
1.697 + case EWsClOpEventReadyCancel:
1.698 + CancelEvent();
1.699 + break;
1.700 + case EWsClOpRedrawReady:
1.701 + break;
1.702 + case EWsClOpRedrawReadyCancel:
1.703 + CancelRedrawEvent();
1.704 + break;
1.705 + case EWsClOpGetRedraw:
1.706 + GetRedrawData();
1.707 + break;
1.708 + case EWsClOpPriorityKeyReady:
1.709 + break;
1.710 + case EWsClOpPriorityKeyReadyCancel:
1.711 + CancelPriorityKeyEvent();
1.712 + break;
1.713 + case EWsClOpGetPriorityKey:
1.714 + GetPriorityKeyData();
1.715 + break;
1.716 + case EWsClOpNumWindowGroups:
1.717 + SetReply(CWsWindowGroup::NumWindowGroups(EFalse, *pData.Int));
1.718 + break;
1.719 + case EWsClOpNumWindowGroupsAllPriorities:
1.720 + SetReply(CWsWindowGroup::NumWindowGroups(ETrue, 0));
1.721 + break;
1.722 + case EWsClOpNumWindowGroupsOnScreen:
1.723 + {
1.724 + TInt screenNumber=pData.NumWinGroups->screenNumber;
1.725 + if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())
1.726 + {
1.727 + PPanic(EWservPanicScreenNumber);
1.728 + }
1.729 + else
1.730 + {
1.731 + SetReply(CWsWindowGroup::NumWindowGroupsOnScreen(CWsTop::Screen(screenNumber)->RootWindow()->Child(),(pData.NumWinGroups->priority==EAllPriorities),pData.NumWinGroups->priority));
1.732 + }
1.733 + }
1.734 + break;
1.735 + case EWsClOpWindowGroupList:
1.736 + {
1.737 + TInt screenNumber=pData.WindowGroupList->screenNumber;
1.738 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.739 + {
1.740 + PPanic(EWservPanicScreenNumber);
1.741 + }
1.742 + else
1.743 + {
1.744 + SetReply(CWsWindowGroup::SendWindowGroupListL(screenNumber,(pData.WindowGroupList->priority==EAllPriorities), pData.WindowGroupList->priority, pData.WindowGroupList->count));
1.745 + }
1.746 + }
1.747 + break;
1.748 + case EWsClOpWindowGroupListAllPriorities:
1.749 + {
1.750 + TInt screenNumber=pData.WindowGroupList->screenNumber;
1.751 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.752 + {
1.753 + PPanic(EWservPanicScreenNumber);
1.754 + }
1.755 + else
1.756 + {
1.757 + SetReply(CWsWindowGroup::SendWindowGroupListL(screenNumber,ETrue, 0, pData.WindowGroupList->count));
1.758 + }
1.759 + }
1.760 + break;
1.761 + case EWsClOpWindowGroupListAndChain:
1.762 + SetReply(CWsWindowGroup::SendWindowGroupListAndChainL(EFalse, pData.WindowGroupList->priority, pData.WindowGroupList->count));
1.763 + break;
1.764 + case EWsClOpWindowGroupListAndChainAllPriorities:
1.765 + SetReply(CWsWindowGroup::SendWindowGroupListAndChainL(ETrue, 0, pData.WindowGroupList->count));
1.766 + break;
1.767 + case EWsClOpGetDefaultOwningWindow:
1.768 + {
1.769 + TInt screenNumber = *pData.Int;
1.770 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.771 + {
1.772 + PPanic(EWservPanicScreenNumber);
1.773 + }
1.774 + else
1.775 + {
1.776 + CScreen* screen = (screenNumber ==KDummyScreenNumber) ? iScreen : CWsTop::Screen(screenNumber);
1.777 + SetReply(screen->DefaultOwningWindowGroup() ? screen->DefaultOwningWindowGroup()->Identifier():0);
1.778 + }
1.779 + }
1.780 + break;
1.781 + case EWsClOpGetFocusWindowGroup:
1.782 + {
1.783 + TInt screenNumber = *pData.Int;
1.784 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.785 + {
1.786 + PPanic(EWservPanicScreenNumber);
1.787 + }
1.788 + else
1.789 + {
1.790 + CWsWindowGroup::GetFocusWindowGroupL(screenNumber);
1.791 + }
1.792 + }
1.793 + break;
1.794 + case EWsClOpSetWindowGroupOrdinalPosition:
1.795 + CWsWindowGroup::WindowGroupFromIdentifierL(pData.SetWindowGroupOrdinalPosition->identifier)->SetOrdinalPosition(pData.SetWindowGroupOrdinalPosition->position);
1.796 + break;
1.797 + case EWsClOpGetWindowGroupHandle:
1.798 + SetReply(CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->ClientHandle());
1.799 + break;
1.800 + case EWsClOpGetWindowGroupOrdinalPriority:
1.801 + SetReply(CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->OrdinalPriority());
1.802 + break;
1.803 + case EWsClOpGetWindowGroupClientThreadId:
1.804 + {
1.805 + TThreadId id=CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->WsOwner()->Client().Id();
1.806 + ReplyBuf(&id,sizeof(id));
1.807 + }
1.808 + break;
1.809 + case EWsClOpSendEventToWindowGroup:
1.810 + {
1.811 + CWsWindowGroup *group=CWsWindowGroup::WindowGroupFromIdentifierL(pData.SendEventToWindowGroup->parameter);
1.812 + TWsEvent event=pData.SendEventToWindowGroup->event;
1.813 + event.SetHandle(group->ClientHandle());
1.814 + // Events in enum TEventCode is protected by capabilities
1.815 + if (group->WsOwner()!=this && event.Type()>=EEventNull && event.Type()<EEventUser)
1.816 + {
1.817 + if (event.Type()<EEventPowerMgmt || event.Type()>=EEventReserved)
1.818 + {
1.819 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToWindowGroup API")))
1.820 + User::Leave(KErrPermissionDenied);
1.821 + }
1.822 + else
1.823 + {
1.824 + if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToWindowGroup API")))
1.825 + User::Leave(KErrPermissionDenied);
1.826 + }
1.827 + }
1.828 + if (event.Type()==EEventKey && event.Key()->iRepeats!=0)
1.829 + CKeyboardRepeat::CancelRepeat(NULL); //Otherwise we will trip an invarient
1.830 + if (!group->EventQueue()->QueueEvent(event))
1.831 + User::Leave(KErrNoMemory);
1.832 + }
1.833 + break;
1.834 + case EWsClOpSendEventToAllWindowGroup:
1.835 + case EWsClOpSendEventToAllWindowGroupPriority:
1.836 + case EWsClOpSendEventToOneWindowGroupPerClient:
1.837 + {
1.838 + TWsEvent event=pData.SendEventToWindowGroup->event;
1.839 + if (event.Type()<0)
1.840 + {
1.841 + User::Leave(KErrArgument);
1.842 + }
1.843 + if(event.Type()<EEventUser)
1.844 + {
1.845 + if (event.Type()<EEventPowerMgmt || event.Type()>=EEventReserved)
1.846 + {
1.847 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToAllWindowGroup API")))
1.848 + User::Leave(KErrPermissionDenied);
1.849 + }
1.850 + else
1.851 + {
1.852 + if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToAllWindowGroup API")))
1.853 + User::Leave(KErrPermissionDenied);
1.854 + }
1.855 + }
1.856 + if (!CWsWindowGroup::SendEventToAllGroups(aOpcode!=EWsClOpSendEventToAllWindowGroupPriority
1.857 + ,aOpcode==EWsClOpSendEventToOneWindowGroupPerClient,*pData.SendEventToWindowGroup))
1.858 + User::Leave(KErrNoMemory);
1.859 + }
1.860 + break;
1.861 + case EWsClOpSendMessageToWindowGroup:
1.862 + {
1.863 + CWsWindowGroup *group=CWsWindowGroup::WindowGroupFromIdentifierL(pData.SendMessageToWindowGroup->identifierOrPriority);
1.864 + if (group->WsOwner()!=this)
1.865 + {
1.866 + if (!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendMessageToWindowGroup API")))
1.867 + {
1.868 + User::Leave(KErrPermissionDenied);
1.869 + }
1.870 + }
1.871 + group->QueueMessageL(pData.SendMessageToWindowGroup->uid, pData.SendMessageToWindowGroup->dataLength, *this);
1.872 + }
1.873 + break;
1.874 + case EWsClOpSendMessageToAllWindowGroups:
1.875 + case EWsClOpSendMessageToAllWindowGroupsPriority:
1.876 + {
1.877 + if ((pData.SendMessageToWindowGroup->dataLength<0) || (pData.SendMessageToWindowGroup->dataLength>=(KMaxTInt/2)))
1.878 + {
1.879 + User::Leave(KErrArgument);
1.880 + }
1.881 + CWsWindowGroup::SendMessageToAllGroupsL(*this,aOpcode==EWsClOpSendMessageToAllWindowGroups,*pData.SendMessageToWindowGroup);
1.882 + }
1.883 + break;
1.884 + case EWsClOpFetchMessage:
1.885 + CWsWindowGroup::WindowGroupFromIdentifierL(pData.FetchMessage->windowGroupIdentifier)->FetchMessageL();
1.886 + break;
1.887 + case EWsClOpGetWindowGroupNameFromIdentifier:
1.888 + ReplyGroupName(CWsWindowGroup::WindowGroupFromIdentifierL(pData.GetWindowGroupNameFromIdentifier->identifier)->GroupName(),pData.GetWindowGroupNameFromIdentifier->maxLength);
1.889 + break;
1.890 + case EWsClOpFindWindowGroupIdentifier:
1.891 + {
1.892 + if (pData.FindWindowGroupIdentifier->length<0)
1.893 + User::Leave(KErrArgument);
1.894 + TPtrC ptr(BufferTPtr((TText *)(pData.FindWindowGroupIdentifier+1),pData.FindWindowGroupIdentifier->length));
1.895 + SetReply(CWsWindowGroup::FindWindowGroupL(this, pData.FindWindowGroupIdentifier->identifier,
1.896 + pData.FindWindowGroupIdentifier->offset,&ptr,NULL)->Identifier());
1.897 + }
1.898 + break;
1.899 + case EWsClOpFindWindowGroupIdentifierThread:
1.900 + SetReply(CWsWindowGroup::FindWindowGroupL(this, pData.FindWindowGroupIdentifierThread->identifier,0,NULL,
1.901 + &pData.FindWindowGroupIdentifierThread->threadId)->Identifier());
1.902 + break;
1.903 + case EWsClOpSetBackgroundColor:
1.904 + for(TInt i=0;i<CWsTop::NumberOfScreens();i++)
1.905 + {
1.906 + CWsTop::Screen(i)->RootWindow()->SetColor(*pData.rgb);
1.907 + }
1.908 + break;
1.909 + case EWsClOpGetBackgroundColor:
1.910 + SetReply(iScreen->RootWindow()->BackColor().Internal());
1.911 + break;
1.912 + case EWsClOpClaimSystemPointerCursorList:
1.913 + {
1.914 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::ClaimSystemPointerCursorList API")))
1.915 + {
1.916 + User::Leave(KErrPermissionDenied);
1.917 + }
1.918 + ClaimSystemPointerCursorListL();
1.919 + }
1.920 + break;
1.921 + case EWsClOpFreeSystemPointerCursorList:
1.922 + FreeSystemPointerCursorList();
1.923 + break;
1.924 + case EWsClOpSetSystemPointerCursor:
1.925 + CWsObject *pointercursor;
1.926 + if ((pointercursor=HandleToObj(pData.SetSystemPointerCursor->handle, WS_HANDLE_POINTER_CURSOR))==NULL)
1.927 + PPanic(EWservPanicSprite);
1.928 + SetSystemPointerCursorL(pData.SetSystemPointerCursor->number, (CWsPointerCursor *)pointercursor);
1.929 + break;
1.930 + case EWsClOpClearSystemPointerCursor:
1.931 + ClearSystemPointerCursor(*pData.Int);
1.932 + break;
1.933 + case EWsClOpSetPointerCursorArea:
1.934 + {
1.935 + if(KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorArea API")))
1.936 + {
1.937 + if (!iScreen->IsValidScreenSizeMode(*pData.Int))
1.938 + PPanic(EWservPanicScreenModeNumber);
1.939 + iScreen->SetPointerCursorArea(pData.SetPointerCursorArea->mode,pData.SetPointerCursorArea->area);
1.940 + }
1.941 + }
1.942 + break;
1.943 + case EWsClOpPointerCursorArea:
1.944 + if (!iScreen->IsValidScreenSizeMode(*pData.Int))
1.945 + PPanic(EWservPanicScreenModeNumber);
1.946 + ReplyRect(iScreen->GetPointerCursorArea(*pData.Int));
1.947 + break;
1.948 + case EWsClOpSetPointerCursorMode:
1.949 + {
1.950 + CWsWindowGroup* focusWinGp=CWsTop::FocusWindowGroup();
1.951 + if (focusWinGp && focusWinGp->WsOwner()==this)
1.952 + {
1.953 + WsPointer::SetPointerCursorMode(*pData.Mode);
1.954 + WsPointer::UpdatePointerCursor();
1.955 + }
1.956 + }
1.957 + break;
1.958 + case EWsClOpSetClientCursorMode :
1.959 + {
1.960 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorModeIfFocused API")))
1.961 + {
1.962 + User::Leave(KErrPermissionDenied);
1.963 + }
1.964 + WsPointer::SetPointerCursorMode(*pData.Mode);
1.965 + WsPointer::UpdatePointerCursor();
1.966 + }
1.967 + break;
1.968 + case EWsClOpPointerCursorMode:
1.969 + SetReply(WsPointer::PointerCursorMode());
1.970 + break;
1.971 + case EWsClOpSetDefaultSystemPointerCursor:
1.972 + SetDefaultSystemPointerCursor(*pData.Int);
1.973 + break;
1.974 + case EWsClOpClearDefaultSystemPointerCursor:
1.975 + SetDefaultSystemPointerCursor(ENoDefaultSystemPointerCursor);
1.976 + break;
1.977 + case EWsClOpSetPointerCursorPosition:
1.978 + {
1.979 + CWsWindowGroup* focusWinGp=CWsTop::FocusWindowGroup();
1.980 + if ((!focusWinGp || focusWinGp->WsOwner()!=this)&&
1.981 + (!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorPosition API"))))
1.982 + {
1.983 + User::Leave(KErrPermissionDenied);
1.984 + }
1.985 + WsPointer::SetPointerCursorPos(*pData.Point);
1.986 + }
1.987 + break;
1.988 + case EWsClOpPointerCursorPosition:
1.989 + ReplyPoint(WsPointer::PointerCursorPos());
1.990 + break;
1.991 + case EWsClOpSetModifierState:
1.992 + {
1.993 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetModifierState API")))
1.994 + {
1.995 + User::Leave(KErrPermissionDenied);
1.996 + }
1.997 + TWindowServerEvent::SetModifierState(pData.SetModifierState->modifier,pData.SetModifierState->state);
1.998 + }
1.999 + break;
1.1000 + case EWsClOpGetModifierState:
1.1001 + SetReply(TWindowServerEvent::GetModifierState());
1.1002 + break;
1.1003 + case EWsClOpHeapCount:
1.1004 + SetReply(CWsMemoryManager::Static()->Count());
1.1005 + break;
1.1006 + case EWsClOpDebugInfo:
1.1007 + DebugInfoL(pData.DebugInfo->iFunction,pData.DebugInfo->iParam,EFalse);
1.1008 + break;
1.1009 + case EWsClOpDebugInfoReplyBuf:
1.1010 + DebugInfoL(pData.DebugInfo->iFunction,pData.DebugInfo->iParam,ETrue);
1.1011 + break;
1.1012 + case EWsClOpResourceCount:
1.1013 + SetReply(iObjectIndex->Count());
1.1014 + break;
1.1015 + case EWsClOpHeapSetFail:
1.1016 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::HeapSetFail API")))
1.1017 + {
1.1018 + PPanic(EWservPanicPermissionDenied);
1.1019 + }
1.1020 +#if !defined(_DEBUG)
1.1021 + if (pData.HeapSetFail->type!=RHeap::ENone)
1.1022 + TWindowServerEvent::NotifyOom();
1.1023 +#endif
1.1024 + User::__DbgSetAllocFail(RHeap::EUser,pData.HeapSetFail->type,pData.HeapSetFail->value);
1.1025 + //__UHEAP_SETFAIL(pData.HeapSetFail->type,pData.HeapSetFail->value);
1.1026 + break;
1.1027 + case EWsClOpRawEvent:
1.1028 + {
1.1029 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SimulateRawEvent API")))
1.1030 + {
1.1031 + PPanic(EWservPanicPermissionDenied);
1.1032 + }
1.1033 + TRawEvent event(*pData.RawEvent);
1.1034 + if (WsPointer::PreProcessEvent(event))
1.1035 + TWindowServerEvent::ProcessRawEvent(event);
1.1036 + }
1.1037 + break;
1.1038 + case EWsClOpKeyEvent:
1.1039 + {
1.1040 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SimulateKeyEvent API")))
1.1041 + {
1.1042 + PPanic(EWservPanicPermissionDenied);
1.1043 + }
1.1044 + TWindowServerEvent::ProcessKeyEvent(*pData.KeyEvent,0);
1.1045 + }
1.1046 + break;
1.1047 + case EWsClOpLogMessage:
1.1048 + if (wsDebugLog)
1.1049 + {
1.1050 + if (CheckBuffer(*pData.Int, KLogMessageLength))
1.1051 + wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,BufferTPtr((TText *)(pData.Int+1),*pData.Int),0);
1.1052 + }
1.1053 + break;
1.1054 + case EWsClOpPasswordEntered:
1.1055 + CWsPassword::PasswordEntered(this);
1.1056 + break;
1.1057 + case EWsClOpComputeMode:
1.1058 + SetComputeMode(*pData.ComputeMode);
1.1059 + break;
1.1060 + case EWsClOpSendOffEventsToShell:
1.1061 + {
1.1062 + if(!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::RequestOffEvents API")))
1.1063 + {
1.1064 + User::Leave(KErrPermissionDenied);
1.1065 + }
1.1066 + SetReply(CWsTop::SetSendOffEventsToShell(this,*pData.OffEventsToShell));
1.1067 + }
1.1068 + break;
1.1069 + case EWsClOpGetDefModeMaxNumColors:
1.1070 + {
1.1071 + SDefModeMaxNumColors colors;
1.1072 + TInt screenNumber = *pData.Int;
1.1073 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.1074 + {
1.1075 + PPanic(EWservPanicScreenNumber);
1.1076 + }
1.1077 + else
1.1078 + {
1.1079 + CScreen* screen = (screenNumber==KDummyScreenNumber)?iScreen:CWsTop::Screen(screenNumber);
1.1080 + screen->MaxNumColors(colors.iColors,colors.iGrays);
1.1081 + colors.iDisplayMode=screen->FirstDefaultDisplayMode();
1.1082 + }
1.1083 + ReplyBuf(&colors,sizeof(colors));
1.1084 + }
1.1085 + break;
1.1086 + case EWsClOpGetColorModeList:
1.1087 + {
1.1088 + TInt screenNumber = *pData.Int;
1.1089 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.1090 + {
1.1091 + PPanic(EWservPanicScreenNumber);
1.1092 + }
1.1093 + else
1.1094 + {
1.1095 + SetReply((screenNumber==KDummyScreenNumber) ? iScreen->ColorModesFlag() : CWsTop::Screen(screenNumber)->ColorModesFlag());
1.1096 + }
1.1097 + }
1.1098 + break;
1.1099 + case EWsClOpSetDefaultFadingParams:
1.1100 + {
1.1101 + if(KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetDefaultFadingParameters API")))
1.1102 + {
1.1103 + iScreen->SetFadingParams(WservEncoding::ExtractFirst8BitValue(*pData.UInt),WservEncoding::ExtractSecond8BitValue(*pData.UInt));
1.1104 + }
1.1105 + }
1.1106 + break;
1.1107 + case EWsClOpPrepareForSwitchOff:
1.1108 + {
1.1109 + if(KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::PrepareForSwitchOff API")))
1.1110 + {
1.1111 + // Andy - this used to stop the heartbeat - should it now stop animations?
1.1112 + }
1.1113 + }
1.1114 + break;
1.1115 + case EWsClOpSetFaded:
1.1116 + {
1.1117 + // Deprecated - retained for BC with applications that retrieve the fade count
1.1118 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetSystemFaded API")))
1.1119 + {
1.1120 + User::Leave(KErrPermissionDenied);
1.1121 + }
1.1122 + TUint8 blackMap;
1.1123 + TUint8 whiteMap;
1.1124 + if (pData.SetSystemFaded->UseDefaultMap())
1.1125 + {
1.1126 + iScreen->GetFadingParams(blackMap,whiteMap);
1.1127 + }
1.1128 + else
1.1129 + {
1.1130 + pData.SetSystemFaded->GetFadingParams(blackMap,whiteMap);
1.1131 + }
1.1132 + iScreen->RootWindow()->SetSystemFaded(pData.SetSystemFaded->Faded(),blackMap,whiteMap);
1.1133 + if (CWsTop::IsFadeEnabled())
1.1134 + {
1.1135 + Screen()->AcceptFadeRequest( iScreen->RootWindow(),
1.1136 + pData.SetSystemFaded->Faded(),
1.1137 + EFalse,
1.1138 + ETrue );
1.1139 + }
1.1140 + }
1.1141 + break;
1.1142 + case EWsClOpLogCommand:
1.1143 + CWsTop::LogCommand(*pData.LogCommand);
1.1144 + break;
1.1145 +#if defined(__WINS__)
1.1146 + case EWsClOpRemoveKeyCode:
1.1147 + iRemoveKeyCode=*pData.Bool;
1.1148 + break;
1.1149 + case EWsClOpSimulateXyInput:
1.1150 + WsPointer::SetXyInputType(static_cast<TXYInputType>(*pData.XyInput));
1.1151 + break;
1.1152 +#endif
1.1153 + case EWsClOpNoFlickerFree:
1.1154 + {
1.1155 + // should only be used by WServ test code
1.1156 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for EWsClOpNoFlickerFree message")))
1.1157 + {
1.1158 + PPanic(EWservPanicPermissionDenied);
1.1159 + }
1.1160 + iScreen->FreeOffScreenBitmap();
1.1161 + break;
1.1162 + }
1.1163 + case EWsClOpSetFocusScreen:
1.1164 + {
1.1165 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetFocusScreen API")))
1.1166 + {
1.1167 + User::Leave(KErrPermissionDenied);
1.1168 + }
1.1169 + TInt focusScreen=*pData.Int;
1.1170 + if (focusScreen>=0 && focusScreen<CWsTop::NumberOfScreens())
1.1171 + SetReply(CWsTop::SetCurrentFocusScreen(focusScreen));
1.1172 + else
1.1173 + SessionPanic(EWservPanicScreenNumber);
1.1174 + break;
1.1175 + }
1.1176 + case EWsClOpGetFocusScreen:
1.1177 + SetReply(CWsTop::CurrentFocusScreen()->ScreenNumber());
1.1178 + break;
1.1179 + case EWsClOpGetNumberOfScreens:
1.1180 + SetReply(CWsTop::NumberOfScreens());
1.1181 + break;
1.1182 + case EWsClOpClearAllRedrawStores:
1.1183 + CWsTop::ClearAllRedrawStores();
1.1184 + break;
1.1185 + case EWsClOpGetGraphicMessage:
1.1186 + iGraphicMessageQueue.GetGraphicMessage();
1.1187 + break;
1.1188 + case EWsClOpGraphicMessageCancel:
1.1189 + iGraphicMessageQueue.CancelRead();
1.1190 + break;
1.1191 + case EWsClOpGraphicAbortMessage:
1.1192 + iGraphicMessageQueue.AbortMessage(*pData.Int);
1.1193 + break;
1.1194 + case EWsClOpGraphicFetchHeaderMessage:
1.1195 + SetReply(iGraphicMessageQueue.TopClientHandle());
1.1196 + break;
1.1197 + default:
1.1198 + PPanic(EWservPanicOpcode);
1.1199 + break;
1.1200 + }
1.1201 + }
1.1202 +
1.1203 +void CWsClient::DebugInfoL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const
1.1204 + {
1.1205 + switch(aFunction)
1.1206 + {
1.1207 + case EWsDebugInfoHeap:
1.1208 + if (aHasReplyBuf)
1.1209 + {
1.1210 + TWsDebugHeapInfo heapInfo;
1.1211 + RHeap& heap=User::Heap();
1.1212 + heapInfo.iCount=heap.AllocSize(heapInfo.iTotal);
1.1213 + heapInfo.iAvailable=heap.Available(heapInfo.iLargestAvailable);
1.1214 + ReplyBuf(&heapInfo,sizeof(heapInfo));
1.1215 + }
1.1216 + SetReply(KErrArgument);
1.1217 + break;
1.1218 + case EWsDebugSetCheckHeapOnDisconnectClient:
1.1219 + if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::DebugInfoL API")))
1.1220 + {
1.1221 + User::Leave(KErrPermissionDenied);
1.1222 + }
1.1223 + CWsTop::SetCheckHeapOnDisconnectClient(this);
1.1224 + break;
1.1225 + case EWsDebugSetCheckHeapOnDisconnectMode:
1.1226 + if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::DebugInfoL API")))
1.1227 + {
1.1228 + User::Leave(KErrPermissionDenied);
1.1229 + }
1.1230 + CWsTop::SetCheckHeapOnDisconnectMode(STATIC_CAST(TWsCheckHeapOnDisconnectMode,aParam));
1.1231 + break;
1.1232 + case EWsDebugFetchCheckHeapResult:
1.1233 + SetReply(CWsTop::FetchCheckHeapResult());
1.1234 + break;
1.1235 + default:
1.1236 + SetReply(KErrNotSupported);
1.1237 + break;
1.1238 + }
1.1239 + }
1.1240 +
1.1241 +void CWsClient::ReplyGroupName(HBufC *aName, TInt aMaxLength) const
1.1242 + {
1.1243 + if (aName)
1.1244 + {
1.1245 + if (aName->Length()>aMaxLength)
1.1246 + {
1.1247 + ReplyBuf(aName->Left(aMaxLength));
1.1248 + SetReply(KErrOverflow);
1.1249 + }
1.1250 + else
1.1251 + ReplyBuf(*aName);
1.1252 + }
1.1253 + else
1.1254 + ReplyBuf(nullDescriptor);
1.1255 + }
1.1256 +
1.1257 +void CWsClient::TriggerRedraw()
1.1258 + {
1.1259 + RedrawQueue()->TriggerRedraw();
1.1260 + }
1.1261 +
1.1262 +void CWsClient::UpdateWindowOrdinalPrioritys()
1.1263 + {
1.1264 + for(CWsWindowGroup *win=iScreen->RootWindow()->Child();win;win=win->NextSibling())
1.1265 + if (win->WsOwner()==this)
1.1266 + win->UpdateOrdinalPriority(ETrue);
1.1267 + }
1.1268 +
1.1269 +void CWsClient::DeleteSystemPointerListEntry(TInt aIndex)
1.1270 + {
1.1271 + PointerCursor (aIndex)->Close();
1.1272 + iSystemPointerCursors->Delete(aIndex);
1.1273 + }
1.1274 +
1.1275 +CWsPointerCursor *CWsClient::SystemPointerCursor(TInt aIndex)
1.1276 + {
1.1277 + TInt arrayIndex;
1.1278 + if (iSystemPointerCursors)
1.1279 + {
1.1280 + if (FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))
1.1281 + {
1.1282 + return PointerCursor (arrayIndex);
1.1283 + }
1.1284 + // Cursor not defined so try for default cursor
1.1285 + if (FindCursorArrayItem(iSystemPointerCursors, 0, arrayIndex))
1.1286 + {
1.1287 + return PointerCursor (arrayIndex);
1.1288 + }
1.1289 + }
1.1290 + // If that fails simply return NULL for no cursor
1.1291 + return(NULL);
1.1292 + }
1.1293 +
1.1294 +void CWsClient::SetSystemPointerCursorL(TInt aIndex, CWsPointerCursor *aCursor)
1.1295 + {
1.1296 + if (iSystemPointerCursorListOwner!=this)
1.1297 + PPanic(EWservPanicNotSystemPointerCursorListOwner);
1.1298 + TInt arrayIndex;
1.1299 + if (FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))
1.1300 + {
1.1301 + PointerCursor (arrayIndex)->Close();
1.1302 + PointerCursor (arrayIndex) = aCursor;
1.1303 + }
1.1304 + else
1.1305 + {
1.1306 + TWsCursorArrayItem entry;
1.1307 + entry.iIndex=aIndex;
1.1308 + entry.iCursor=aCursor;
1.1309 + iSystemPointerCursors->InsertIsqL(entry, CursorKey);
1.1310 + }
1.1311 + aCursor->Open();
1.1312 + if (aIndex==iDefaultSystemPointerCursorIndex)
1.1313 + iDefaultSystemPointerCursor=aCursor;
1.1314 + WsPointer::UpdatePointerCursor();
1.1315 + }
1.1316 +
1.1317 +void CWsClient::ClearSystemPointerCursor(TInt aIndex)
1.1318 + {
1.1319 + if (iSystemPointerCursorListOwner!=this)
1.1320 + PPanic(EWservPanicNotSystemPointerCursorListOwner);
1.1321 + TInt arrayIndex;
1.1322 + if (FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))
1.1323 + {
1.1324 + DeleteSystemPointerListEntry(arrayIndex);
1.1325 + if (aIndex==iDefaultSystemPointerCursorIndex)
1.1326 + iDefaultSystemPointerCursor=NULL;
1.1327 + }
1.1328 + }
1.1329 +
1.1330 +void CWsClient::ClaimSystemPointerCursorListL()
1.1331 + {
1.1332 + if (iSystemPointerCursorListOwner)
1.1333 + User::Leave(KErrInUse);
1.1334 + const TInt systemPointerCursorGranularity = 4;
1.1335 + iSystemPointerCursors = new(ELeave) CArrayFixFlat<TWsCursorArrayItem> (systemPointerCursorGranularity);
1.1336 + iSystemPointerCursorListOwner=this;
1.1337 + }
1.1338 +
1.1339 +void CWsClient::FreeSystemPointerCursorList()
1.1340 + {
1.1341 + if (iSystemPointerCursorListOwner==this)
1.1342 + {
1.1343 + iSystemPointerCursorListOwner=NULL;
1.1344 + while(iSystemPointerCursors->Count()>0)
1.1345 + DeleteSystemPointerListEntry(0);
1.1346 + iDefaultSystemPointerCursor=NULL;
1.1347 + iDefaultSystemPointerCursorIndex=0;
1.1348 + delete iSystemPointerCursors;
1.1349 + iSystemPointerCursors=NULL;
1.1350 + }
1.1351 + }
1.1352 +
1.1353 +void CWsClient::SetDefaultSystemPointerCursor(TInt aIndex)
1.1354 + {
1.1355 + TInt arrayIndex;
1.1356 + if (iSystemPointerCursorListOwner!=this)
1.1357 + PPanic(EWservPanicNotSystemPointerCursorListOwner);
1.1358 + iDefaultSystemPointerCursorIndex=aIndex;
1.1359 + iDefaultSystemPointerCursor=NULL;
1.1360 + if (aIndex != ENoDefaultSystemPointerCursor &&
1.1361 + FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))
1.1362 + iDefaultSystemPointerCursor = PointerCursor (arrayIndex);
1.1363 + else
1.1364 + iDefaultSystemPointerCursor=NULL;
1.1365 + WsPointer::UpdatePointerCursor();
1.1366 + }
1.1367 +
1.1368 +TBool CWsClient::FindCursorArrayItem(CArrayFixFlat<TWsCursorArrayItem>* aCursorArray,
1.1369 + TInt aIndex,TInt& aPosition)
1.1370 + {
1.1371 + if (!aCursorArray)
1.1372 + {
1.1373 + return EFalse; // No hit if the array isn't even allocated
1.1374 + }
1.1375 + TWsCursorArrayItem entry;
1.1376 + entry.iIndex=aIndex;
1.1377 + return aCursorArray->FindIsq(entry, CursorKey, aPosition)==KErrNone;
1.1378 + }
1.1379 +
1.1380 +void CWsClient::SetClientPriority()
1.1381 + {
1.1382 + if (iComputeMode!=RWsSession::EPriorityControlDisabled)
1.1383 + {
1.1384 + Client().SetProcessPriority(
1.1385 + iComputeMode==RWsSession::EPriorityControlComputeOn || CWsTop::FocusWindowGroupOwner()!=this ?
1.1386 + EPriorityBackground :
1.1387 + EPriorityForeground);
1.1388 + }
1.1389 + }
1.1390 +
1.1391 +void CWsClient::SetComputeMode(RWsSession::TComputeMode aComputeMode)
1.1392 + {
1.1393 + if (aComputeMode!=RWsSession::EPriorityControlDisabled &&
1.1394 + aComputeMode!=RWsSession::EPriorityControlComputeOn &&
1.1395 + aComputeMode!=RWsSession::EPriorityControlComputeOff)
1.1396 + PPanic(EWservPanicSetComputeMode);
1.1397 + iComputeMode=aComputeMode;
1.1398 + SetClientPriority();
1.1399 + }
1.1400 +
1.1401 +void CWsClient::CompleteMessage(const RMessage2& aMessage,TInt aReason)
1.1402 + {
1.1403 + if (!aMessage.IsNull())
1.1404 + {
1.1405 + if (iInternalFlags&EPanicClientAsSoonAsPossible)
1.1406 + {
1.1407 + aMessage.Panic(KWSERVSessionPanicCategory,iPanicReason);
1.1408 + iInternalFlags&=~EPanicClientAsSoonAsPossible;
1.1409 + }
1.1410 + else
1.1411 + {
1.1412 + aMessage.Complete(aReason);
1.1413 + }
1.1414 + }
1.1415 + }
1.1416 +
1.1417 +void CWsClient::ServiceError(const RMessage2& /*aMessage*/,TInt aError)
1.1418 + {
1.1419 + CompleteMessage(iClientMessage,aError);
1.1420 + }
1.1421 +
1.1422 +void CWsClient::ServiceL(const RMessage2 &aMessage)
1.1423 +//
1.1424 +// Handle messages for the window server server.
1.1425 +//
1.1426 + {
1.1427 + iClientMessage=aMessage; // from now on use always the message stored in the session
1.1428 + if (iInternalFlags&EPanicClientAsSoonAsPossible)
1.1429 + {
1.1430 + iClientMessage.Panic(KWSERVSessionPanicCategory,iPanicReason);
1.1431 + }
1.1432 + else
1.1433 + {
1.1434 + iPanicReason=KErrNone;
1.1435 + iReply=KErrNone;
1.1436 + TBool completeRequest=ETrue;
1.1437 + DoServiceL(iClientMessage, completeRequest);
1.1438 + if (completeRequest)
1.1439 + {
1.1440 + if(!iResponseHandle)
1.1441 + {
1.1442 + CompleteMessage(iClientMessage,iReply);
1.1443 + }
1.1444 + else
1.1445 + {
1.1446 +// Prior to 9.0 RMessagePtr2.Complete doesn't have the option of sending a handle back
1.1447 +// However, since the security is lower simply sending the handle id is ok
1.1448 + iClientMessage.Complete(*iResponseHandle);
1.1449 + iResponseHandle = NULL;
1.1450 + }
1.1451 + }
1.1452 + }
1.1453 + }
1.1454 +
1.1455 +void CWsClient::SetResponseHandle(RHandleBase* aHandle)
1.1456 + {
1.1457 + iResponseHandle = aHandle;
1.1458 + }
1.1459 +
1.1460 +void CWsClient::DoServiceL(const RMessage2& aMessage, TBool& aCompleteRequest)
1.1461 + {
1.1462 + const TInt function=aMessage.Function();
1.1463 + switch (function)
1.1464 + {
1.1465 + case EWservMessInit:
1.1466 + StartInitializationL(iConnectionId++);
1.1467 + break;
1.1468 + case EWservMessSyncMsgBuf:
1.1469 + case EWservMessCommandBuffer:
1.1470 + {
1.1471 + if (!IsInitialised())
1.1472 + {
1.1473 + PPanic(EWservPanicUninitialisedClient);
1.1474 + }
1.1475 +
1.1476 + const TInt err=aMessage.Read(KBufferMessageSlot,iCmdBuf);
1.1477 + if (err==KErrNone)
1.1478 + {
1.1479 + TRAPD(error,CommandBufL());
1.1480 + iCurrentClient=NULL;
1.1481 +#if defined(_DEBUG)
1.1482 + if (!iLastCommand && err!=KErrNone)
1.1483 + {
1.1484 + SessionPanic(EWservPanicFunctionLeave);
1.1485 + }
1.1486 +#endif
1.1487 + if (error<KErrNone)
1.1488 + SetReply(error);
1.1489 + }
1.1490 + else if (err!=KErrDied)
1.1491 + {
1.1492 + PPanic(EWservPanicDescriptor);
1.1493 + }
1.1494 + if(function == EWservMessCommandBuffer && CWsTop::FinishEveryFlush())
1.1495 + {
1.1496 + if(Screen()->IsUpdatePending())
1.1497 + Screen()->DoRedrawNow();
1.1498 + }
1.1499 + else
1.1500 + aCompleteRequest=(function!=EWservMessAsynchronousService);
1.1501 + break;
1.1502 + }
1.1503 + case EWservMessShutdown:
1.1504 + {
1.1505 + if(!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for EWservMessShutdown message ")))
1.1506 + {
1.1507 + PPanic(EWservPanicPermissionDenied);
1.1508 + }
1.1509 + if (aMessage.Int0()==EWservShutdownCheck)
1.1510 + CWsTop::Exit();
1.1511 + else
1.1512 + {
1.1513 + PPanic(EWservPanicHandle);
1.1514 + }
1.1515 + }
1.1516 + break;
1.1517 + case EWservMessFinish:
1.1518 + {
1.1519 + if(Screen()->IsUpdatePending())
1.1520 + Screen()->DoRedrawNow();
1.1521 + break;
1.1522 + }
1.1523 + default:
1.1524 + if (function&EWservMessAsynchronousService)
1.1525 + {
1.1526 + TRAPD(err,CommandL((function&~EWservMessAsynchronousService), aMessage));
1.1527 + aCompleteRequest=(err!=KErrNone);
1.1528 + WS_ASSERT_DEBUG((!(iInternalFlags&EPanicClientAsSoonAsPossible))==(!aCompleteRequest), EWsPanicPanicFlagError);
1.1529 + }
1.1530 + else if (function&EWservMessAnimDllAsyncCommand)
1.1531 + {
1.1532 + CWsAnimDll* const animDll=STATIC_CAST(CWsAnimDll*,HandleToObj(aMessage.Int0(), WS_HANDLE_ANIM_DLL));
1.1533 + if (!animDll)
1.1534 + {
1.1535 + SessionPanic(EWservPanicHandle);
1.1536 + break;
1.1537 + }
1.1538 + // 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
1.1539 + TRAPD(err,animDll->AnimObjectL(aMessage.Int1())->CommandReply(function&~EWservMessAnimDllAsyncCommand,NULL));
1.1540 + aCompleteRequest=(err!=KErrNone);
1.1541 + WS_ASSERT_DEBUG((!(iInternalFlags&EPanicClientAsSoonAsPossible))==(!aCompleteRequest), EWsPanicPanicFlagError);
1.1542 + }
1.1543 + else
1.1544 + {
1.1545 + SetReply(KErrNotSupported);
1.1546 + }
1.1547 + break;
1.1548 + }
1.1549 + }
1.1550 +
1.1551 +void CWsClient::RemoteRead(TDes16& aDes, TInt aOffset)
1.1552 + {
1.1553 + if (iClientMessage.Read(KRemoteBufferMessageSlot,aDes,aOffset)!=KErrNone)
1.1554 + {
1.1555 + SessionPanic(EWservPanicDescriptor);
1.1556 + }
1.1557 + }
1.1558 +
1.1559 +void CWsClient::RemoteRead(TDes8& aDes, TInt aOffset)
1.1560 + {
1.1561 + if (iClientMessage.Read(KRemoteBufferMessageSlot,aDes,aOffset)!=KErrNone)
1.1562 + {
1.1563 + SessionPanic(EWservPanicDescriptor);
1.1564 + }
1.1565 + }
1.1566 +
1.1567 +void CWsClient::RemoteReadL(TDes16& aDes, TInt aOffset)
1.1568 + {
1.1569 + iClientMessage.ReadL(KRemoteBufferMessageSlot,aDes,aOffset);
1.1570 + }
1.1571 +
1.1572 +void CWsClient::RemoteReadL(TDes8& aDes, TInt aOffset)
1.1573 + {
1.1574 + iClientMessage.ReadL(KRemoteBufferMessageSlot,aDes,aOffset);
1.1575 + }
1.1576 +
1.1577 +void CWsClient::DeleteStatics()
1.1578 + {
1.1579 + if (iTextCursorArray)
1.1580 + {
1.1581 + const TInt count = iTextCursorArray->Count();
1.1582 + for (TInt index=0;index<count;index++)
1.1583 + {
1.1584 + delete iTextCursorArray->At(index).iCursor;
1.1585 + }
1.1586 + delete iTextCursorArray;
1.1587 + iTextCursorArray = NULL;
1.1588 + }
1.1589 + }
1.1590 +
1.1591 +// CWsClient implementing MWsClient \\\\\\\\\\\\\\\\\\\\\\\\
1.1592 +
1.1593 +TBool CWsClient::HasCapability(TCapability aCapability) const
1.1594 + {
1.1595 + return iClient.HasCapability(aCapability);
1.1596 + }
1.1597 +
1.1598 +TSecureId CWsClient::SecureId() const
1.1599 + {
1.1600 + return iClient.SecureId();
1.1601 + }
1.1602 +
1.1603 +TVendorId CWsClient::VendorId() const
1.1604 + {
1.1605 + return iClient.VendorId();
1.1606 + }
1.1607 +/**
1.1608 +Makes a new copy of the aData. so it could be deleted after this call.
1.1609 +*/
1.1610 +TInt CWsClient::SendMessage(const CWsGraphicDrawer* aOnBehalfOf,const TDesC8& aData)
1.1611 + {
1.1612 + CWsGraphicMessageQueue::CMessage* msg = CWsGraphicMessageQueue::CMessage::New(aData);
1.1613 + if(msg)
1.1614 + {
1.1615 + return SendMessage(aOnBehalfOf,*msg);
1.1616 + }
1.1617 + return KErrGeneral;
1.1618 + }
1.1619 +
1.1620 +TInt CWsClient::SendMessage(const CWsGraphicDrawer* aOnBehalfOf,CWsMessageData& aData)
1.1621 + {
1.1622 + WS_ASSERT_DEBUG(aData.Data().Size(), EWsPanicWsGraphic);
1.1623 + const CWsGraphicDrawerObject* obj = DrawerObject(aOnBehalfOf);
1.1624 + WS_ASSERT_DEBUG(obj, EWsPanicWsGraphic);
1.1625 + if(obj)
1.1626 + {
1.1627 + // assign message id
1.1628 + if(iMessageIdSeq == KMaxTInt) // Wrap if iMessageIdSeq has reached KMaxTInt
1.1629 + iMessageIdSeq = 0;
1.1630 + iMessageIdSeq++;
1.1631 + // correct other handles
1.1632 + aData.iClientHandle = (obj->ClientHandle() | (EWsGraphMessageTypeUser & 0x03));
1.1633 + aData.iDrawer = obj->Drawer();
1.1634 + aData.iId = iMessageIdSeq;
1.1635 + iGraphicMessageQueue.Queue(&aData);
1.1636 + return iMessageIdSeq;
1.1637 + }
1.1638 + return KErrGeneral;
1.1639 + }
1.1640 +
1.1641 +/** adds a message to the message queue
1.1642 +@return a postive number to uniquely identify the message
1.1643 +*/
1.1644 +
1.1645 +
1.1646 +CWsGraphicDrawerObject* CWsClient::DrawerObject(const CWsGraphicDrawer* aDrawer)
1.1647 + {
1.1648 + const TInt count = ObjectIndex()->Length();
1.1649 + for(TInt i=0; i<count; i++)
1.1650 + {
1.1651 + CWsObject* obj = const_cast<CWsObject*>(ObjectIndex()->At(i));
1.1652 + if(obj && (WS_HANDLE_GRAPHIC_DRAWER == obj->Type()))
1.1653 + {
1.1654 + CWsGraphicDrawerObject* candidate = static_cast<CWsGraphicDrawerObject*>(obj);
1.1655 + if(candidate->Drawer() == aDrawer)
1.1656 + {
1.1657 + return candidate;
1.1658 + }
1.1659 + }
1.1660 + }
1.1661 + return NULL;
1.1662 + }
1.1663 +
1.1664 +const CWsGraphicDrawerObject* CWsClient::DrawerObject(const CWsGraphicDrawer* aDrawer) const
1.1665 + {
1.1666 + CWsObjectIx* objectIndex = const_cast<CWsClient*>(this)->ObjectIndex();
1.1667 + const TInt count = objectIndex->Length();
1.1668 + for(TInt i=0; i<count; i++)
1.1669 + {
1.1670 + CWsObject* obj = const_cast<CWsObject*>(objectIndex->At(i));
1.1671 + if(obj && (WS_HANDLE_GRAPHIC_DRAWER == obj->Type()))
1.1672 + {
1.1673 + const CWsGraphicDrawerObject* candidate = static_cast<CWsGraphicDrawerObject*>(obj);
1.1674 + if(candidate->Drawer() == aDrawer)
1.1675 + {
1.1676 + return candidate;
1.1677 + }
1.1678 + }
1.1679 + }
1.1680 + return NULL;
1.1681 + }
1.1682 +
1.1683 +//
1.1684 +
1.1685 +CWsCliObj* CWsCliObj::NewL(CWsClient *aOwner)
1.1686 + {
1.1687 + CWsCliObj* self = new(ELeave) CWsCliObj(aOwner);
1.1688 + CleanupStack::PushL(self);
1.1689 + self->ConstructL();
1.1690 + CleanupStack::Pop(self);
1.1691 + return self;
1.1692 + }
1.1693 +
1.1694 +CWsCliObj::CWsCliObj(CWsClient *aOwner) : CWsObject(aOwner,WS_HANDLE_CLIENT)
1.1695 + {
1.1696 + __DECLARE_NAME(_S("CWsCliObj"));
1.1697 + }
1.1698 +
1.1699 +void CWsCliObj::ConstructL()
1.1700 + {
1.1701 + NewObjL();
1.1702 + }
1.1703 +
1.1704 +void CWsCliObj::CommandL(TInt aOpcode, const TAny *aCmdData)
1.1705 + {
1.1706 + iWsOwner->CommandL(aOpcode,aCmdData);
1.1707 + }
1.1708 +
1.1709 +CWsObject* CWsClient::HandleToObjUntyped(TInt aHandle)
1.1710 + {
1.1711 + return(iObjectIndex->HandleToObject(aHandle));
1.1712 + }
1.1713 +
1.1714 +CWsObject* CWsClient::HandleToObj(TInt aHandle, WH_HANDLES aType)
1.1715 + {
1.1716 + CWsObject* object = HandleToObjUntyped(aHandle);
1.1717 + if (object && object->Type() == aType)
1.1718 + {
1.1719 + return object;
1.1720 + }
1.1721 + return NULL;
1.1722 + }