1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/graphics/windowing/windowserver/nga/SERVER/openwfc/CLIENT.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2245 @@
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 +#include <e32hashtab.h> // for RHashMap
1.39 +#include "registeredsurfacemap.h"
1.40 +#include <graphics/wselement.h>
1.41 +
1.42 +#include "windowelementset.h"
1.43 +#include "drawresource.h"
1.44 +
1.45 +extern CDebugLogBase* wsDebugLog;
1.46 +_LIT(KWSERVSessionPanicCategory,"WSERV");
1.47 +
1.48 +GLREF_D TPtr nullDescriptor;
1.49 +
1.50 +TWsCmdHeaderBase CWsClient::iCurrentCommand;
1.51 +TBuf8<EClientBufferMaxSize> CWsClient::iCmdBuf;
1.52 +TInt CWsClient::iReply;
1.53 +TInt CWsClient::iReplyOffset;
1.54 +CWsClient* CWsClient::iCurrentClient;
1.55 +CWsObject* CWsClient::iDestObj;
1.56 +const TUint8* CWsClient::iNextCmd;
1.57 +
1.58 +TUint CWsClient::iConnectionId = CDebugLogBase::EDummyConnectionId+1;
1.59 +CArrayFixFlat<CWsClient::TWsCursorArrayItem>* CWsClient::iSystemPointerCursors = NULL;
1.60 +TInt CWsClient::iDefaultSystemPointerCursorIndex = 0; //Negative when there isn't one
1.61 +CWsPointerCursor* CWsClient::iDefaultSystemPointerCursor;
1.62 +CWsClient* CWsClient::iSystemPointerCursorListOwner = NULL;
1.63 +CArrayFixFlat<CWsClient::TWsCursorArrayItem>* CWsClient::iTextCursorArray = NULL;
1.64 +
1.65 +TKeyArrayFix CWsClient::iCursorKey(_FOFF(CWsClient::TWsCursorArrayItem,iIndex), ECmpTInt);
1.66 +
1.67 +/**
1.68 +Used for enforcing the redraw calling convention in emulator builds.
1.69 +When enabled this will panic any client calling a CWindowGc draw operation outside a
1.70 +RWindow::BeginRedraw() / RWindow::EndRedraw() pair (known as non-redraw drawing).
1.71 +
1.72 +Enable by adding "debug_wserv_exe_EnforceRedrawCallingConvention X" to epoc.ini
1.73 +where X is either 0 (zero) for "off" or 1 (one) for "on".
1.74 +
1.75 +Then enable globally in WServ AutoFlush by defining __AUTO_FLUSH in ../client/client.h
1.76 +or locally by calling RWsSession::SetAutoFlush(ETrue) for a specific client programatically,
1.77 +or locally pressing Ctrl-Alt-Shift-F in the emulator.
1.78 +*/
1.79 +TBool CWsClient::iDebug_EnforceRedrawCallingConvention = EFalse;
1.80 +
1.81 +// Security policy stings
1.82 +static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);
1.83 +static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);
1.84 +static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_PowerMgmt,ECapabilityPowerMgmt);
1.85 +
1.86 +//
1.87 +// class CWsClient
1.88 +//
1.89 +
1.90 +CWsClient::CWsClient(RThread aClient) : iClient(aClient), iGraphicMessageQueue(this), iInternalFlags(ERemoveKeyCode|EFinishedProcessingCommands)
1.91 + {
1.92 + iScreen = CWsTop::Screen();
1.93 + }
1.94 +
1.95 +CWsClient::~CWsClient()
1.96 + {
1.97 + CWsTop::WindowServer()->RemoveAllGraphicDrawers(*this); // deindexes all graphic drawers owned by this client
1.98 +
1.99 + delete iTempCustomTextCursor.iCursor;
1.100 + FreeSystemPointerCursorList();
1.101 + CWsTop::ClientDestroyed(this);
1.102 + if (wsDebugLog)
1.103 + {
1.104 + _LIT(ClientDestuct,"Client %d destructing");
1.105 + wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,ClientDestuct, iConnectionHandle);
1.106 + }
1.107 +
1.108 + iInternalFlags |= EClientIsClosing;
1.109 + delete iObjectIndex;
1.110 + delete iEventQueue;
1.111 + delete iRedrawQueue;
1.112 + delete iPriorityKeyEvent;
1.113 + CWsTop::ClearSurfaceMap(this);
1.114 +
1.115 + CWsTop::SessionExited(this);
1.116 + iClient.Close();
1.117 + }
1.118 +
1.119 +void CWsClient::CompleteInitializationL()
1.120 + {
1.121 + iObjectIndex = new(ELeave) CWsObjectIx();
1.122 + iObjectIndex->ConstructL();
1.123 +
1.124 + iEventQueue = new(ELeave) CEventQueue(this);
1.125 + iEventQueue->ConstructL();
1.126 +
1.127 + iRedrawQueue = new(ELeave) CRedrawQueue(this);
1.128 + iRedrawQueue->ConstructL();
1.129 +
1.130 + iPriorityKeyEvent = new(ELeave) CPriorityKey(this);
1.131 +
1.132 + CWsCliObj::NewL(this);
1.133 +
1.134 + iComputeMode = RWsSession::EPriorityControlComputeOff;
1.135 +
1.136 + CWsTop::NewSession(this);
1.137 +
1.138 +#ifdef __WINS__
1.139 + TBool halValue = EFalse;
1.140 + if (UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty,
1.141 + (TAny*)"debug_wserv_exe_EnforceRedrawCallingConvention", &halValue) == KErrNone)
1.142 + {
1.143 + iDebug_EnforceRedrawCallingConvention = halValue;
1.144 + }
1.145 +#endif
1.146 +
1.147 + iInternalFlags |= EIsInitialised;
1.148 + }
1.149 +
1.150 +TBool CWsClient::DebugEnforceRedrawCallingConvention()
1.151 + {
1.152 + return iDebug_EnforceRedrawCallingConvention;
1.153 + }
1.154 +
1.155 +void CWsClient::StartInitializationL(TUint aConnectionHandle)
1.156 + {
1.157 + if (wsDebugLog)
1.158 + wsDebugLog->NewClient(aConnectionHandle);
1.159 +
1.160 + if (iObjectIndex)
1.161 + PPanic(EWservPanicReInitialise);
1.162 + else
1.163 + {
1.164 + iConnectionHandle = aConnectionHandle;
1.165 + CompleteInitializationL();
1.166 + }
1.167 + }
1.168 +
1.169 +//
1.170 +// Convert a handle to object checking it is of the correct type.
1.171 +//
1.172 +void CWsClient::HandleToWindow(TInt aHandle,CWsWindowBase** pWin)
1.173 + {
1.174 + if ((*pWin=(CWsWindowBase* )HandleToObjUntyped(aHandle))==NULL ||
1.175 + ((*pWin)->Type()!=WS_HANDLE_WINDOW && (*pWin)->Type()!=WS_HANDLE_GROUP_WINDOW))
1.176 + PPanic(EWservPanicWindow);
1.177 + }
1.178 +
1.179 +//
1.180 +// Convert a handle to object checking it is of the correct type.
1.181 +//
1.182 +void CWsClient::HandleToClientWindow(TInt aHandle,CWsClientWindow** pWin)
1.183 + {
1.184 + if ((*pWin=(CWsClientWindow*)HandleToObj(aHandle, WS_HANDLE_WINDOW))==NULL)
1.185 + PPanic(EWservPanicWindow);
1.186 + }
1.187 +
1.188 +void CWsClient::CreateNewPointerCursorL(const TWsClCmdCreatePointerCursor &aCmd)
1.189 + {
1.190 + CWsPointerCursor* pc=new(ELeave) CWsPointerCursor(this);
1.191 + CleanupStack::PushL(pc);
1.192 + pc->ConstructL(aCmd);
1.193 + CleanupStack::Pop();
1.194 + }
1.195 +
1.196 +// Create a new custom text cursor
1.197 +void CWsClient::StartSetCustomTextCursorL(const TWsClCmdCustomTextCursorData& aCmd)
1.198 + {
1.199 + if (!iTextCursorArray)
1.200 + {
1.201 + const TInt textCursorArrayGranularity = 4;
1.202 + iTextCursorArray = new(ELeave) CArrayFixFlat<TWsCursorArrayItem>(textCursorArrayGranularity);
1.203 + }
1.204 +
1.205 + TInt arrayIndex = KErrNotFound;
1.206 + if (FindCursorArrayItem(iTextCursorArray, aCmd.identifier, arrayIndex))
1.207 + User::Leave(KErrAlreadyExists);
1.208 +
1.209 + delete iTempCustomTextCursor.iCursor;
1.210 + iTempCustomTextCursor.iCursor = NULL;
1.211 + iTempCustomTextCursor.iCursor = new(ELeave) CWsCustomTextCursor(this, aCmd.alignment);
1.212 +
1.213 + static_cast<CWsCustomTextCursor*>(iTempCustomTextCursor.iCursor)->ConstructL(aCmd.flags);
1.214 + iTempCustomTextCursor.iIndex = aCmd.identifier;
1.215 + }
1.216 +
1.217 +// Add new custom text cursor to global list
1.218 +void CWsClient::CompleteSetCustomTextCursorL(TInt aError)
1.219 + {
1.220 + if (aError)
1.221 + {
1.222 + delete iTempCustomTextCursor.iCursor;
1.223 + iTempCustomTextCursor.iCursor = NULL;
1.224 + User::Leave(aError);
1.225 + }
1.226 +
1.227 + TWsCursorArrayItem entry = iTempCustomTextCursor;
1.228 + iTempCustomTextCursor.iCursor = NULL;
1.229 + CleanupStack::PushL(entry.iCursor);
1.230 +
1.231 + TInt arrayIndex;
1.232 + if (FindCursorArrayItem(iTextCursorArray, entry.iIndex, arrayIndex))
1.233 + User::Leave(KErrAlreadyExists);
1.234 + else
1.235 + iTextCursorArray->InsertIsqL(entry, iCursorKey);
1.236 +
1.237 + CleanupStack::Pop(entry.iCursor);
1.238 + }
1.239 +
1.240 +CWsCustomTextCursor* CWsClient::FindCustomTextCursor(TInt aIdentifier)
1.241 + {
1.242 + TInt arrayIndex;
1.243 + if (!FindCursorArrayItem(iTextCursorArray, aIdentifier, arrayIndex))
1.244 + return NULL;
1.245 +
1.246 + return TextCursor(arrayIndex);
1.247 + }
1.248 +
1.249 +void CWsClient::CreateNewSpriteL(const TWsClCmdCreateSprite &aCmd)
1.250 + {
1.251 + CWsSprite* sprite = new(ELeave) CWsSprite(this);
1.252 + CleanupStack::PushL(sprite);
1.253 + sprite->ConstructL(aCmd);
1.254 + CleanupStack::Pop();
1.255 + }
1.256 +
1.257 +void CWsClient::CreateNewBitmapL(const TWsClCmdCreateBitmap &aCmd)
1.258 + {
1.259 + DWsBitmap* bitmap = new(ELeave) DWsBitmap(this);
1.260 + CleanupStack::PushL(bitmap);
1.261 + bitmap->ConstructL(aCmd);
1.262 + CleanupStack::Pop();
1.263 + }
1.264 +
1.265 +/** Creates a new window.
1.266 +
1.267 +If the parent is a window group then a new CWsTopClientWindow instance is created. If the parent is
1.268 +a window then a new CWsClientWindow instance is created.
1.269 +
1.270 +@param aCmd The command received from the client
1.271 +@internalComponent
1.272 +@released
1.273 +*/
1.274 +void CWsClient::CreateNewWindowL(const TWsClCmdCreateWindow &aCmd)
1.275 + {
1.276 + CWsWindowBase* parent;
1.277 + HandleToWindow(aCmd.parent,&parent);
1.278 + CWsClientWindow* win = NULL;
1.279 + TBool deviceIsInvalid = EFalse;
1.280 + CScreen* screen = parent->Screen();
1.281 + if (parent->WinType()==EWinTypeGroup)
1.282 + {
1.283 + __ASSERT_DEBUG(!((CWsWindowGroup*)parent)->ScreenDeviceDeleted(),PPanic(EWservPanicGroupWinScreenDeviceDeleted));
1.284 + win=new(ELeave) CWsTopClientWindow(this, screen);
1.285 + deviceIsInvalid=!((CWsWindowGroup*)parent)->ScreenDeviceValid();
1.286 + }
1.287 + else
1.288 + win=new(ELeave) CWsClientWindow(this, screen);
1.289 +
1.290 + CleanupStack::PushL(win);
1.291 + win->ConstructL(aCmd,parent,deviceIsInvalid);
1.292 + CleanupStack::Pop(win);
1.293 + }
1.294 +
1.295 +void CWsClient::CreateNewWindowGroupL(const TWsClCmdCreateWindowGroup &aCmd)
1.296 + {
1.297 + CWsWindowGroup::NewL(this, NULL, aCmd); //screen is initialised inside the constructL
1.298 + }
1.299 +
1.300 +void CWsClient::CreateNewAnimDllL(const TWsClCmdUnion &aParams)
1.301 + {
1.302 + CWsAnimDll* animDll = new(ELeave) CWsAnimDll(this);
1.303 + CleanupStack::PushL(animDll);
1.304 + animDll->LoadL(BufferTPtr((TText*)(aParams.LoadAnimDll+1),aParams.LoadAnimDll->length));
1.305 + CleanupStack::Pop();
1.306 + }
1.307 +
1.308 +void CWsClient::CreateNewScreenDeviceL(TInt aDefaultScreenNumber, TUint aClientScreenDevicePointer)
1.309 + {
1.310 + DWsScreenDevice* screenDevice = new(ELeave) DWsScreenDevice(this, aDefaultScreenNumber,aClientScreenDevicePointer);
1.311 + CleanupStack::PushL(screenDevice);
1.312 + screenDevice->ConstructL();
1.313 + CleanupStack::Pop(screenDevice);
1.314 + if (iPrimaryScreenDevice==NULL)
1.315 + {
1.316 + iPrimaryScreenDevice=screenDevice;
1.317 + // When client create screen device, change default screen to the one specified.
1.318 + // Client should do this immediately after establishing session
1.319 + iScreen = iPrimaryScreenDevice->Screen();
1.320 + InitialiseScreenDevices();
1.321 + }
1.322 + }
1.323 +
1.324 +void CWsClient::InitialiseScreenDevices()
1.325 + {
1.326 + const TWsObject* ptr = iObjectIndex->FirstObject();
1.327 + const TWsObject* end = ptr+iObjectIndex->Length();
1.328 + WS_ASSERT_DEBUG(ptr->iObject==NULL, EWsPanicObjectIndexError);
1.329 + while(++ptr<end)
1.330 + {
1.331 + if (ptr->iObject && ptr->iObject->Type()==WS_HANDLE_GROUP_WINDOW)
1.332 + {
1.333 + CWsWindowGroup* gw = static_cast<CWsWindowGroup*>(ptr->iObject);
1.334 + if(!gw->Device())
1.335 + gw->SetScreenDevice(iPrimaryScreenDevice);
1.336 + }
1.337 + }
1.338 + }
1.339 +
1.340 +void CWsClient::CreateNewClickHandlerL(const TUid& aUid)
1.341 + {
1.342 + CClick* click = new(ELeave) CClick(this);
1.343 + CleanupStack::PushL(click);
1.344 + click->ConstructL(aUid);
1.345 + CleanupStack::Pop(click);
1.346 + }
1.347 +
1.348 +void CWsClient::RequestComplete(TRequestStatus* &aStatus, TInt aErr)
1.349 + {
1.350 + Client().RequestComplete(aStatus,aErr);
1.351 + }
1.352 +
1.353 +void CWsClient::PanicCurrentClient(TClientPanic aPanic)
1.354 + {
1.355 + iCurrentClient->PPanic(aPanic);
1.356 + }
1.357 +
1.358 +void CWsClient::PPanic(TClientPanic aPanic) const
1.359 +//This function is allowed to leave with out the 'L' convention for special reasons
1.360 + {
1.361 + SessionPanic(aPanic);
1.362 + User::Leave(EPanicLeave);
1.363 + }
1.364 +
1.365 +void CWsClient::SessionPanic(TClientPanic aReason) const
1.366 + {
1.367 + if (wsDebugLog)
1.368 + wsDebugLog->Panic(iConnectionHandle, aReason);
1.369 +
1.370 + if (!(iInternalFlags&EPanicClientAsSoonAsPossible)) // keep the first error code
1.371 + {
1.372 + iInternalFlags |= EPanicClientAsSoonAsPossible;
1.373 + iPanicReason = aReason;
1.374 + }
1.375 + }
1.376 +
1.377 +void CWsClient::SessionTerminate()
1.378 + {
1.379 + if (wsDebugLog)
1.380 + wsDebugLog->Panic(iConnectionHandle, 0);
1.381 +
1.382 + const RThread thread=Client();
1.383 + RProcess process;
1.384 + if (thread.Process(process)==KErrNone)
1.385 + {
1.386 + process.Terminate(0);
1.387 + process.Close();
1.388 + }
1.389 + }
1.390 +
1.391 +/**
1.392 +Returns the remaining space in the descriptor
1.393 +*/
1.394 +TInt CWsClient::ReplyBufSpace()
1.395 + {
1.396 + const TInt retVal = iCurrentClient->ClientMessage().GetDesLength(KReplyBufferMessageSlot);
1.397 +
1.398 + if (iReplyOffset>=0 && retVal>=iReplyOffset)
1.399 + return retVal-iReplyOffset;
1.400 + else
1.401 + return (retVal<0 ? retVal : KErrBadDescriptor);
1.402 + }
1.403 +
1.404 +void CWsClient::ReplyBuf(const TDesC16 &aDes) // static
1.405 + {
1.406 + WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);
1.407 +
1.408 + if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot,aDes,iReplyOffset) != KErrNone)
1.409 + PanicCurrentClient(EWservPanicDescriptor);
1.410 +
1.411 + iReplyOffset += aDes.Length();
1.412 + if (wsDebugLog)
1.413 + wsDebugLog->ReplyBuf(aDes);
1.414 + }
1.415 +
1.416 +void CWsClient::ReplyBuf(const TDesC8 &aDes) // static
1.417 + {
1.418 + WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);
1.419 +
1.420 + if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot, aDes, iReplyOffset) != KErrNone)
1.421 + PanicCurrentClient(EWservPanicDescriptor);
1.422 +
1.423 + iReplyOffset += aDes.Length();
1.424 + if (wsDebugLog)
1.425 + wsDebugLog->ReplyBuf(aDes);
1.426 + }
1.427 +
1.428 +void CWsClient::ReplyBuf(const TAny* aSource, TInt aLength) // static
1.429 +//
1.430 +// Send a buffer to the client process.
1.431 +//
1.432 + {
1.433 + TPtrC8 src(reinterpret_cast<const TUint8*>(aSource),aLength);
1.434 + ReplyBuf(src);
1.435 + }
1.436 +
1.437 +void CWsClient::ReplySize(const TSize &aSize) // static
1.438 + {
1.439 + ReplyBuf(&aSize, sizeof(aSize));
1.440 + }
1.441 +
1.442 +void CWsClient::ReplyPoint(const TPoint &aPoint) // static
1.443 + {
1.444 + ReplyBuf(&aPoint, sizeof(aPoint));
1.445 + }
1.446 +
1.447 +void CWsClient::ReplyRect(const TRect &aRect) // static
1.448 + {
1.449 + ReplyBuf(&aRect, sizeof(aRect));
1.450 + }
1.451 +
1.452 +void CWsClient::SetReply(TInt reply)
1.453 + {
1.454 + iReply = reply;
1.455 + if (wsDebugLog)
1.456 + wsDebugLog->Reply(reply);
1.457 + }
1.458 +
1.459 +const TUint8* CWsClient::EndOfCommandBuffer()
1.460 + {
1.461 + return(iCmdBuf.Ptr()+iCmdBuf.Size());
1.462 + }
1.463 +
1.464 +const TPtrC CWsClient::BufferTPtr(TText *aStart,TInt aLen)
1.465 + {
1.466 + TPtrC ptr;
1.467 + if (!BufferTPtrGc(aStart,aLen,ptr))
1.468 + PanicCurrentClient(EWservPanicBufferPtr);
1.469 + return(ptr);
1.470 + }
1.471 +
1.472 +TBool CWsClient::BufferTPtrGc(TText* aStart,TInt aLen, TPtrC& aPtr)
1.473 + {
1.474 + if (iCurrentCommand.iOpcode>0)
1.475 + {
1.476 + if ((REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()
1.477 + || REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))
1.478 + return(EFalse);
1.479 + }
1.480 + else
1.481 + {
1.482 + if (aLen>=iCurrentCommand.iCmdLength)
1.483 + return(EFalse);
1.484 + }
1.485 + aPtr.Set(aStart,aLen);
1.486 + return(ETrue);
1.487 + }
1.488 +
1.489 +const TPtrC8 CWsClient::BufferTPtr8(TUint8* aStart,TInt aLen)
1.490 + {
1.491 + if (iCurrentCommand.iOpcode>0 && (REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()
1.492 + || REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))
1.493 + PanicCurrentClient(EWservPanicBufferPtr);
1.494 +
1.495 + return(TPtrC8(aStart,aLen));
1.496 + }
1.497 +
1.498 +/**
1.499 +Process a command buffer
1.500 +
1.501 +@internalComponent
1.502 +@released
1.503 +*/
1.504 +void CWsClient::DispatchCommandsInBufL() // (step #4)
1.505 + {
1.506 + if (wsDebugLog)
1.507 + {
1.508 + wsDebugLog->CommandBuf(iConnectionHandle);
1.509 + RThread client = Client();
1.510 + wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, client.FullName());
1.511 + }
1.512 + const TUint8* endCmd=iCmdBuf.Ptr()+iCmdBuf.Length();
1.513 + do
1.514 + {
1.515 + const TWsCmdHeader* pCmd=
1.516 + reinterpret_cast<const TWsCmdHeader*>(iNextCmd);
1.517 + TUint opcode = pCmd->iBase.iOpcode;
1.518 + TInt headerLen = sizeof(pCmd->iBase);
1.519 + iCurrentCommand = pCmd->iBase;
1.520 +
1.521 + // For performance reasons the handle is only included
1.522 + // if it is different from the previous command. The EWsOpcodeHandle
1.523 + // flag indicates whether a new handle has been included in the
1.524 + // current command. If not we use the same handle as the previous
1.525 + // command.
1.526 + if (opcode&EWsOpcodeHandle)
1.527 + {
1.528 + // Find the WServ object associated with this op code
1.529 + opcode &= ~EWsOpcodeHandle;
1.530 + iCurrentCommand.iOpcode = reinterpret_cast<TUint16&>(opcode);
1.531 + iDestObj=HandleToObjUntyped(pCmd->iDestHandle);
1.532 + headerLen = sizeof(*pCmd);
1.533 + }
1.534 +
1.535 + iNextCmd += headerLen;
1.536 + const TAny* cmdParams = iNextCmd;
1.537 + iNextCmd += pCmd->iBase.iCmdLength;
1.538 + if (!iDestObj || iNextCmd>endCmd) // Invalid handle or Corrupt buffer
1.539 + {
1.540 + SessionPanic(iDestObj==NULL ? EWservPanicHandle : EWservPanicBuffer);
1.541 + iInternalFlags|=EFinishedProcessingCommands;
1.542 + break;
1.543 + }
1.544 +
1.545 + if (iNextCmd==endCmd)
1.546 + iInternalFlags|=EFinishedProcessingCommands;
1.547 +
1.548 + if (wsDebugLog)
1.549 + wsDebugLog->Command(iDestObj->Type(), opcode, cmdParams, iDestObj->LogHandle());
1.550 +
1.551 + // Dispatch the command to the WServ object that will process it
1.552 + iDestObj->CommandL(opcode, cmdParams); // (call #5)
1.553 + }
1.554 + while(iNextCmd<endCmd);
1.555 +
1.556 + }
1.557 +
1.558 +void CWsClient::DoServiceCommandBuf() // (step #3.1)
1.559 + {
1.560 + iCurrentClient=this;
1.561 + iInternalFlags&=~EFinishedProcessingCommands;
1.562 + TRAPD(err, DispatchCommandsInBufL()); // (call #4)
1.563 +
1.564 +#if defined(_DEBUG)
1.565 + if (err!=KErrNone && !(iInternalFlags&(EFinishedProcessingCommands|EPanicClientAsSoonAsPossible)))
1.566 + SessionPanic(EWservPanicFunctionLeave);
1.567 +#endif
1.568 +
1.569 + if (err<KErrNone)
1.570 + SetReply(err);
1.571 +
1.572 + if (iInternalFlags&(EFinishedProcessingCommands|EPanicClientAsSoonAsPossible))
1.573 + CompleteMessage(iClientMessage,iReply); // (finish)
1.574 +
1.575 + iCurrentClient=NULL;
1.576 +#if defined(_DEBUG)
1.577 + User::Heap().Check();
1.578 +#endif
1.579 + }
1.580 +
1.581 +void CWsClient::ExecuteAsyncClientCommandL(TInt aOpcode, const RMessage2& aMessage) // (step #3.2)
1.582 + {
1.583 + switch(aOpcode)
1.584 + {
1.585 + case EWsClOpEventReady:
1.586 + EventReady(aMessage);
1.587 + break;
1.588 + case EWsClOpPriorityKeyReady:
1.589 + PriorityKeyEventReady(aMessage);
1.590 + break;
1.591 + case EWsClOpRedrawReady:
1.592 + RedrawEventReady(aMessage);
1.593 + break;
1.594 + case EWsClOpGraphicMessageReady:
1.595 + iGraphicMessageQueue.EventReady(aMessage);
1.596 + break;
1.597 + default:
1.598 + {
1.599 + PPanic(EWservPanicOpcode);
1.600 + break;
1.601 + }
1.602 + }
1.603 + }
1.604 +
1.605 +
1.606 +
1.607 +void CWsClient::ExecuteCommandL(TInt aOpcode, const TAny* aCmdData) // (step #6)
1.608 + {
1.609 + TWsClCmdUnion pData;
1.610 + pData.any=aCmdData;
1.611 + switch(aOpcode)
1.612 + {
1.613 + case EWsClOpCreateWindowGroup:
1.614 + CreateNewWindowGroupL(*pData.CreateWindowGroup);
1.615 + break;
1.616 + case EWsClOpCreateWindow:
1.617 + CreateNewWindowL(*pData.CreateWindow);
1.618 + break;
1.619 + case EWsClOpCreateGc:
1.620 + CWsGc::NewL(this);
1.621 + break;
1.622 + case EWsClOpCreateAnimDll:
1.623 + if (!CheckBuffer(pData.LoadAnimDll->length, KMaxFileName))
1.624 + PanicCurrentClient(EWservPanicBufferPtr);
1.625 + CreateNewAnimDllL(pData);
1.626 + break;
1.627 + case EWsClOpCreateGraphic:
1.628 + CWsGraphicDrawerObject::NewL(this,pData);
1.629 + break;
1.630 + case EWsClOpCreateScreenDevice:
1.631 + {
1.632 + const TInt screenNumber = pData.CreateScreenDevice->screenNumber;
1.633 + const TUint clientScreenDevicePointer = pData.CreateScreenDevice->clientScreenDevicePointer;
1.634 + if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())
1.635 + {
1.636 + PPanic(EWservPanicScreenNumber);
1.637 + }
1.638 + else
1.639 + {
1.640 + CreateNewScreenDeviceL(screenNumber,clientScreenDevicePointer);
1.641 + }
1.642 + }
1.643 + break;
1.644 + case EWsClOpCreateSprite:
1.645 + CreateNewSpriteL(*pData.CreateSprite);
1.646 + break;
1.647 + case EWsClOpCreatePointerCursor:
1.648 + CreateNewPointerCursorL(*pData.CreatePointerCursor);
1.649 + break;
1.650 + case EWsClOpStartSetCustomTextCursor:
1.651 + StartSetCustomTextCursorL(*pData.CustomTextCursorData);
1.652 + break;
1.653 + case EWsClOpCompleteSetCustomTextCursor:
1.654 + CompleteSetCustomTextCursorL(*pData.Int);
1.655 + break;
1.656 + case EWsClOpCreateBitmap:
1.657 + CreateNewBitmapL(*pData.CreateBitmap);
1.658 + break;
1.659 + case EWsClOpCreateDirectScreenAccess:
1.660 + CWsDirectScreenAccess::NewL(this,EFalse);
1.661 + break;
1.662 + case EWsClOpCreateDirectScreenAccessRegionTrackingOnly:
1.663 + CWsDirectScreenAccess::NewL(this,ETrue); //creates a DSA object that will not draw to the screen, but will use just the region tracking functionality
1.664 + break;
1.665 + case EWsClOpCreateClick:
1.666 + CreateNewClickHandlerL(*pData.Uid);
1.667 + break;
1.668 + case EWsClOpSetHotKey:
1.669 + {
1.670 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetHotKey API")))
1.671 + {
1.672 + User::Leave(KErrPermissionDenied);
1.673 + }
1.674 + TWindowServerEvent::SetHotKeyL(*pData.SetHotKey);
1.675 + }
1.676 + break;
1.677 + case EWsClOpClearHotKeys:
1.678 + {
1.679 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::ClearHotKeys API")))
1.680 + {
1.681 + User::Leave(KErrPermissionDenied);
1.682 + }
1.683 + TWindowServerEvent::ClearHotKeysL(*pData.UInt);
1.684 + }
1.685 + break;
1.686 + case EWsClOpRestoreDefaultHotKey:
1.687 + TWindowServerEvent::ResetDefaultHotKeyL(*pData.UInt);
1.688 + break;
1.689 + case EWsClOpSetShadowVector:
1.690 + PPanic(EWservPanicOpcode); //this op code is deprecated, should never be generated by the client
1.691 + break;
1.692 + case EWsClOpShadowVector:
1.693 + PPanic(EWservPanicOpcode); //this op code is deprecated, should never be generated by the client
1.694 + break;
1.695 + case EWsClOpSetKeyboardRepeatRate:
1.696 + {
1.697 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetKeyboardRepeatRate API")))
1.698 + {
1.699 + User::Leave(KErrPermissionDenied);
1.700 + }
1.701 + if ((pData.SetKeyboardRepeatRate->initial.Int()<0) || (pData.SetKeyboardRepeatRate->time.Int()<0))
1.702 + {
1.703 + User::Leave(KErrArgument);
1.704 + }
1.705 + CKeyboardRepeat::SetRepeatTime(pData.SetKeyboardRepeatRate->initial,pData.SetKeyboardRepeatRate->time);
1.706 + }
1.707 + break;
1.708 + case EWsClOpGetKeyboardRepeatRate:
1.709 + {
1.710 + SKeyRepeatSettings settings;
1.711 + CKeyboardRepeat::GetRepeatTime(settings.iInitialTime,settings.iTime);
1.712 + ReplyBuf(&settings,sizeof(settings));
1.713 + }
1.714 + break;
1.715 + case EWsClOpSetDoubleClick:
1.716 + {
1.717 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetDoubleClick API")))
1.718 + {
1.719 + User::Leave(KErrPermissionDenied);
1.720 + }
1.721 + TWsPointer::SetDoubleClick(pData.SetDoubleClick->interval,pData.SetDoubleClick->distance);
1.722 + }
1.723 + break;
1.724 + case EWsClOpGetDoubleClickSettings:
1.725 + {
1.726 + SDoubleClickSettings settings;
1.727 + TWsPointer::GetDoubleClickSettings(settings.iInterval,settings.iDistance);
1.728 + ReplyBuf(&settings,sizeof(settings));
1.729 + }
1.730 + break;
1.731 + case EWsClOpEventReady:
1.732 + // No need to do anything
1.733 + break;
1.734 + case EWsClOpGetEvent:
1.735 + HandleClientRequestForEventData();
1.736 + // Check flag if the group message queue is overflow and has pended messages
1.737 + if (iInternalFlags & EWgMsgQueueOverflow)
1.738 + {
1.739 + iInternalFlags &= ~EWgMsgQueueOverflow;
1.740 + CWsWindowGroup::ReleasePendedMessagesToAllGroups(this);
1.741 + }
1.742 + break;
1.743 + case EWsClOpPurgePointerEvents:
1.744 + PurgePointerEvents();
1.745 + break;
1.746 + case EWsClOpEventReadyCancel:
1.747 + CancelClientRequestForEventData();
1.748 + break;
1.749 + case EWsClOpRedrawReady:
1.750 + iInternalFlags&=~EIsPerformingRedrawEvent;
1.751 + break;
1.752 + case EWsClOpRedrawReadyCancel:
1.753 + CancelClientRequestForRedrawEvent();
1.754 + break;
1.755 + case EWsClOpGetRedraw:
1.756 + HandleClientRequestForRedrawData();
1.757 + break;
1.758 + case EWsClOpPriorityKeyReady:
1.759 + // No need to do anything
1.760 + break;
1.761 + case EWsClOpPriorityKeyReadyCancel:
1.762 + CancelClientRequestForPriorityKeyEvent();
1.763 + break;
1.764 + case EWsClOpGetPriorityKey:
1.765 + HandleClientRequestForPriorityKeyData();
1.766 + break;
1.767 + case EWsClOpNumWindowGroups:
1.768 + SetReply(CWsWindowGroup::NumWindowGroups(EFalse,* pData.Int));
1.769 + break;
1.770 + case EWsClOpNumWindowGroupsAllPriorities:
1.771 + SetReply(CWsWindowGroup::NumWindowGroups(ETrue, 0));
1.772 + break;
1.773 + case EWsClOpNumWindowGroupsOnScreen:
1.774 + {
1.775 + const TInt screenNumber=pData.NumWinGroups->screenNumber;
1.776 + if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())
1.777 + PPanic(EWservPanicScreenNumber);
1.778 + else
1.779 + SetReply(CWsWindowGroup::NumWindowGroupsOnScreen(CWsTop::Screen(screenNumber)->RootWindow()->Child(),(pData.NumWinGroups->priority==EAllPriorities),pData.NumWinGroups->priority));
1.780 + }
1.781 + break;
1.782 + case EWsClOpWindowGroupList:
1.783 + {
1.784 + const TInt screenNumber=pData.WindowGroupList->screenNumber;
1.785 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.786 + PPanic(EWservPanicScreenNumber);
1.787 + else
1.788 + SetReply(CWsWindowGroup::SendWindowGroupListL(screenNumber,(pData.WindowGroupList->priority==EAllPriorities), pData.WindowGroupList->priority, pData.WindowGroupList->count));
1.789 + }
1.790 + break;
1.791 + case EWsClOpWindowGroupListAllPriorities:
1.792 + {
1.793 + const TInt screenNumber=pData.WindowGroupList->screenNumber;
1.794 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.795 + PPanic(EWservPanicScreenNumber);
1.796 + else
1.797 + SetReply(CWsWindowGroup::SendWindowGroupListL(screenNumber,ETrue, 0, pData.WindowGroupList->count));
1.798 + }
1.799 + break;
1.800 + case EWsClOpWindowGroupListAndChain:
1.801 + SetReply(CWsWindowGroup::SendWindowGroupListAndChainL(EFalse, pData.WindowGroupList->priority, pData.WindowGroupList->count));
1.802 + break;
1.803 + case EWsClOpWindowGroupListAndChainAllPriorities:
1.804 + SetReply(CWsWindowGroup::SendWindowGroupListAndChainL(ETrue, 0, pData.WindowGroupList->count));
1.805 + break;
1.806 + case EWsClOpGetDefaultOwningWindow:
1.807 + {
1.808 + const TInt screenNumber = *pData.Int;
1.809 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.810 + PPanic(EWservPanicScreenNumber);
1.811 + else
1.812 + {
1.813 + CScreen* screen = (screenNumber ==KDummyScreenNumber) ? iScreen : CWsTop::Screen(screenNumber);
1.814 + SetReply(screen->DefaultOwningWindowGroup() ? screen->DefaultOwningWindowGroup()->Identifier():0);
1.815 + }
1.816 + }
1.817 + break;
1.818 + case EWsClOpGetFocusWindowGroup:
1.819 + {
1.820 + const TInt screenNumber = *pData.Int;
1.821 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.822 + PPanic(EWservPanicScreenNumber);
1.823 + else
1.824 + CWsWindowGroup::GetFocusWindowGroupL(screenNumber);
1.825 + }
1.826 + break;
1.827 + case EWsClOpSetWindowGroupOrdinalPosition:
1.828 + CWsWindowGroup::WindowGroupFromIdentifierL(pData.SetWindowGroupOrdinalPosition->identifier)->SetOrdinalPosition(pData.SetWindowGroupOrdinalPosition->position);
1.829 + break;
1.830 + case EWsClOpGetWindowGroupHandle:
1.831 + SetReply(CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->ClientHandle());
1.832 + break;
1.833 + case EWsClOpGetWindowGroupOrdinalPriority:
1.834 + SetReply(CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->OrdinalPriority());
1.835 + break;
1.836 + case EWsClOpGetWindowGroupClientThreadId:
1.837 + {
1.838 + TThreadId id=CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->WsOwner()->Client().Id();
1.839 + ReplyBuf(&id,sizeof(id));
1.840 + }
1.841 + break;
1.842 + case EWsClOpSendEventToWindowGroup:
1.843 + {
1.844 + CWsWindowGroup* group=CWsWindowGroup::WindowGroupFromIdentifierL(pData.SendEventToWindowGroup->parameter);
1.845 + TWsEvent event=pData.SendEventToWindowGroup->event;
1.846 + event.SetHandle(group->ClientHandle());
1.847 + // Events in enum TEventCode is protected by capabilities
1.848 + if (group->WsOwner()!=this && event.Type()>=EEventNull && event.Type()<EEventUser)
1.849 + {
1.850 + if (event.Type()<EEventPowerMgmt || event.Type()>=EEventReserved)
1.851 + {
1.852 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToWindowGroup API")))
1.853 + User::Leave(KErrPermissionDenied);
1.854 + }
1.855 + else
1.856 + {
1.857 + if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToWindowGroup API")))
1.858 + User::Leave(KErrPermissionDenied);
1.859 + }
1.860 + }
1.861 + if (event.Type()==EEventKey && event.Key()->iRepeats!=0)
1.862 + CKeyboardRepeat::CancelRepeat(NULL); //Otherwise we will trip an invarient
1.863 + if (!group->EventQueue()->QueueEvent(event))
1.864 + User::Leave(KErrNoMemory);
1.865 + }
1.866 + break;
1.867 + case EWsClOpSendEventToAllWindowGroup:
1.868 + case EWsClOpSendEventToAllWindowGroupPriority:
1.869 + case EWsClOpSendEventToOneWindowGroupPerClient:
1.870 + {
1.871 + TWsEvent event=pData.SendEventToWindowGroup->event;
1.872 + if (event.Type()<0)
1.873 + User::Leave(KErrArgument);
1.874 + if(event.Type()<EEventUser)
1.875 + {
1.876 + if (event.Type()<EEventPowerMgmt || event.Type()>=EEventReserved)
1.877 + {
1.878 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToAllWindowGroup API")))
1.879 + User::Leave(KErrPermissionDenied);
1.880 + }
1.881 + else
1.882 + {
1.883 + if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToAllWindowGroup API")))
1.884 + User::Leave(KErrPermissionDenied);
1.885 + }
1.886 + }
1.887 + if (!CWsWindowGroup::SendEventToAllGroups(aOpcode!=EWsClOpSendEventToAllWindowGroupPriority
1.888 + ,aOpcode==EWsClOpSendEventToOneWindowGroupPerClient,*pData.SendEventToWindowGroup))
1.889 + User::Leave(KErrNoMemory);
1.890 + }
1.891 + break;
1.892 + case EWsClOpSendMessageToWindowGroup:
1.893 + {
1.894 + CWsWindowGroup* group=CWsWindowGroup::WindowGroupFromIdentifierL(pData.SendMessageToWindowGroup->identifierOrPriority);
1.895 + if (group->WsOwner()!=this)
1.896 + {
1.897 + if (!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendMessageToWindowGroup API")))
1.898 + {
1.899 + User::Leave(KErrPermissionDenied);
1.900 + }
1.901 + }
1.902 + group->QueueMessageL(pData.SendMessageToWindowGroup->uid, pData.SendMessageToWindowGroup->dataLength,* this);
1.903 + }
1.904 + break;
1.905 + case EWsClOpSendMessageToAllWindowGroups:
1.906 + case EWsClOpSendMessageToAllWindowGroupsPriority:
1.907 + {
1.908 + if ((pData.SendMessageToWindowGroup->dataLength<0) || (pData.SendMessageToWindowGroup->dataLength>=(KMaxTInt/2)))
1.909 + {
1.910 + User::Leave(KErrArgument);
1.911 + }
1.912 + CWsWindowGroup::SendMessageToAllGroupsL(*this,aOpcode==EWsClOpSendMessageToAllWindowGroups,*pData.SendMessageToWindowGroup);
1.913 + }
1.914 + break;
1.915 + case EWsClOpFetchMessage:
1.916 + CWsWindowGroup::WindowGroupFromIdentifierL(pData.FetchMessage->windowGroupIdentifier)->FetchMessageL();
1.917 + break;
1.918 + case EWsClOpGetWindowGroupNameFromIdentifier:
1.919 + ReplyGroupName(CWsWindowGroup::WindowGroupFromIdentifierL(pData.GetWindowGroupNameFromIdentifier->identifier)->GroupName(),pData.GetWindowGroupNameFromIdentifier->maxLength);
1.920 + break;
1.921 + case EWsClOpFindWindowGroupIdentifier:
1.922 + {
1.923 + if (pData.FindWindowGroupIdentifier->length<0)
1.924 + User::Leave(KErrArgument);
1.925 + TPtrC ptr(BufferTPtr((TText*)(pData.FindWindowGroupIdentifier+1),pData.FindWindowGroupIdentifier->length));
1.926 + SetReply(CWsWindowGroup::FindWindowGroupL(this, pData.FindWindowGroupIdentifier->identifier,
1.927 + pData.FindWindowGroupIdentifier->offset,&ptr,NULL)->Identifier());
1.928 + }
1.929 + break;
1.930 + case EWsClOpFindWindowGroupIdentifierThread:
1.931 + SetReply(CWsWindowGroup::FindWindowGroupL(this, pData.FindWindowGroupIdentifierThread->identifier,0,NULL,
1.932 + &pData.FindWindowGroupIdentifierThread->threadId)->Identifier());
1.933 + break;
1.934 + case EWsClOpSetBackgroundColor:
1.935 + for(TInt i=0;i<CWsTop::NumberOfScreens();i++)
1.936 + {
1.937 + CWsTop::Screen(i)->RootWindow()->SetColor(*pData.rgb);
1.938 + }
1.939 + break;
1.940 + case EWsClOpGetBackgroundColor:
1.941 + SetReply(iScreen->RootWindow()->BackColor().Internal());
1.942 + break;
1.943 + case EWsClOpClaimSystemPointerCursorList:
1.944 + {
1.945 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::ClaimSystemPointerCursorList API")))
1.946 + {
1.947 + User::Leave(KErrPermissionDenied);
1.948 + }
1.949 + ClaimSystemPointerCursorListL();
1.950 + }
1.951 + break;
1.952 + case EWsClOpFreeSystemPointerCursorList:
1.953 + FreeSystemPointerCursorList();
1.954 + break;
1.955 + case EWsClOpSetSystemPointerCursor:
1.956 + {
1.957 + CWsObject* pointercursor = NULL;
1.958 + if ((pointercursor=HandleToObj(pData.SetSystemPointerCursor->handle, WS_HANDLE_POINTER_CURSOR))==NULL)
1.959 + PPanic(EWservPanicSprite);
1.960 +
1.961 + SetSystemPointerCursorL(pData.SetSystemPointerCursor->number, (CWsPointerCursor* )pointercursor);
1.962 + }
1.963 + break;
1.964 + case EWsClOpClearSystemPointerCursor:
1.965 + ClearSystemPointerCursor(*pData.Int);
1.966 + break;
1.967 + case EWsClOpSetPointerCursorArea:
1.968 + {
1.969 + if(KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorArea API")))
1.970 + {
1.971 + if (!iScreen->IsValidScreenSizeMode(*pData.Int))
1.972 + PPanic(EWservPanicScreenModeNumber);
1.973 + iScreen->SetPointerCursorArea(pData.SetPointerCursorArea->mode,pData.SetPointerCursorArea->area);
1.974 + }
1.975 + }
1.976 + break;
1.977 + case EWsClOpPointerCursorArea:
1.978 + if (!iScreen->IsValidScreenSizeMode(*pData.Int))
1.979 + PPanic(EWservPanicScreenModeNumber);
1.980 +
1.981 + ReplyRect(iScreen->GetPointerCursorArea(*pData.Int));
1.982 + break;
1.983 + case EWsClOpSetPointerCursorMode:
1.984 + {
1.985 + CWsWindowGroup* focusWinGp=CWsTop::FocusWindowGroup();
1.986 + if (focusWinGp && focusWinGp->WsOwner()==this)
1.987 + {
1.988 + TWsPointer::SetPointerCursorMode(*pData.Mode);
1.989 + TWsPointer::UpdatePointerCursor();
1.990 + }
1.991 + }
1.992 + break;
1.993 + case EWsClOpSetClientCursorMode :
1.994 + {
1.995 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorModeIfFocused API")))
1.996 + {
1.997 + User::Leave(KErrPermissionDenied);
1.998 + }
1.999 + TWsPointer::SetPointerCursorMode(*pData.Mode);
1.1000 + TWsPointer::UpdatePointerCursor();
1.1001 + }
1.1002 + break;
1.1003 + case EWsClOpPointerCursorMode:
1.1004 + SetReply(TWsPointer::PointerCursorMode());
1.1005 + break;
1.1006 + case EWsClOpSetDefaultSystemPointerCursor:
1.1007 + SetDefaultSystemPointerCursor(*pData.Int);
1.1008 + break;
1.1009 + case EWsClOpClearDefaultSystemPointerCursor:
1.1010 + SetDefaultSystemPointerCursor(ENoDefaultSystemPointerCursor);
1.1011 + break;
1.1012 + case EWsClOpSetPointerCursorPosition:
1.1013 + {
1.1014 + CWsWindowGroup* focusWinGp=CWsTop::FocusWindowGroup();
1.1015 + if ((!focusWinGp || focusWinGp->WsOwner()!=this)&&
1.1016 + (!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorPosition API"))))
1.1017 + {
1.1018 + User::Leave(KErrPermissionDenied);
1.1019 + }
1.1020 + TWsPointer::SetPointerCursorPos(*pData.Point);
1.1021 + }
1.1022 + break;
1.1023 + case EWsClOpPointerCursorPosition:
1.1024 + ReplyPoint(TWsPointer::PointerCursorPos());
1.1025 + break;
1.1026 + case EWsClOpSetModifierState:
1.1027 + {
1.1028 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetModifierState API")))
1.1029 + {
1.1030 + User::Leave(KErrPermissionDenied);
1.1031 + }
1.1032 + TWindowServerEvent::SetModifierState(pData.SetModifierState->modifier,pData.SetModifierState->state);
1.1033 + }
1.1034 + break;
1.1035 + case EWsClOpGetModifierState:
1.1036 + SetReply(TWindowServerEvent::GetModifierState());
1.1037 + break;
1.1038 + case EWsClOpHeapCount:
1.1039 + SetReply(CWsMemoryManager::Static()->Count());
1.1040 + break;
1.1041 + case EWsClOpDebugInfo:
1.1042 + DebugInfoL(pData.DebugInfo->iFunction,pData.DebugInfo->iParam,EFalse);
1.1043 + break;
1.1044 + case EWsClOpDebugInfoReplyBuf:
1.1045 + DebugInfoL(pData.DebugInfo->iFunction,pData.DebugInfo->iParam,ETrue);
1.1046 + break;
1.1047 + case EWsClOpResourceCount:
1.1048 + SetReply(iObjectIndex->Count());
1.1049 + break;
1.1050 + case EWsClOpHeapSetFail:
1.1051 + {
1.1052 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::HeapSetFail API")))
1.1053 + {
1.1054 + PPanic(EWservPanicPermissionDenied);
1.1055 + }
1.1056 +#if !defined(_DEBUG)
1.1057 + if (pData.HeapSetFail->type!=RHeap::ENone)
1.1058 + TWindowServerEvent::NotifyOom();
1.1059 +#endif
1.1060 + // if there is a memory manager and we are making the allocator fail next or
1.1061 + // deteministic we want to make sure we test both when the memory manager
1.1062 + // succeeds and fails in allocating after freeing up memory. we do that by
1.1063 + // remapping the rate and explicitly telling the memory manager to fail:
1.1064 + // requested rate | fail on retry, actual rate
1.1065 + // 1 | true , 1
1.1066 + // 2 | false , 1
1.1067 + // 3 | true , 2
1.1068 + CWsMemoryManager* memoryManager = NULL;
1.1069 + TInt rate = pData.HeapSetFail->value;
1.1070 + TBool memoryManagerRetryFail = EFalse;
1.1071 + if((pData.HeapSetFail->type == RAllocator::EFailNext || pData.HeapSetFail->type == RAllocator::EDeterministic))
1.1072 + {
1.1073 + memoryManager = CWsMemoryManager::Static();
1.1074 + if(memoryManager)
1.1075 + {
1.1076 + memoryManagerRetryFail = (rate % 2 == 1);
1.1077 + rate = rate / 2 + (memoryManagerRetryFail ? 1 : 0);
1.1078 + }
1.1079 + }
1.1080 +
1.1081 + switch (pData.HeapSetFail->type)
1.1082 + { //This log message means you can safely ignore the allocation failures in between
1.1083 + //see CWindowServer::ReleaseMemory()
1.1084 + case RAllocator::ENone:
1.1085 + RDebug::Printf("WSERV Heap: __DbgSetAllocFail() <<<ENone");
1.1086 + break;
1.1087 + case RAllocator::EReset:
1.1088 + RDebug::Printf("WSERV Heap: __DbgSetAllocFail() <<<EReset");
1.1089 + break;
1.1090 + default:
1.1091 + if (memoryManagerRetryFail)
1.1092 + RDebug::Printf("WSERV Heap: Memory Manager set to fail on retry");
1.1093 + RDebug::Printf("WSERV Heap: __DbgSetAllocFail(EUser,%i,%i)>>>", pData.HeapSetFail->type, rate);
1.1094 + break;
1.1095 + }
1.1096 +
1.1097 + if (memoryManager && memoryManagerRetryFail)
1.1098 + memoryManager->SetFailNextRetry();
1.1099 +
1.1100 + if (pData.HeapSetFail->burst >= 0)
1.1101 + User::__DbgSetBurstAllocFail(RHeap::EUser, pData.HeapSetFail->type, rate, pData.HeapSetFail->burst);
1.1102 + else
1.1103 + User::__DbgSetAllocFail(RHeap::EUser, pData.HeapSetFail->type, rate);
1.1104 + break;
1.1105 + }
1.1106 + case EWsClOpRawEvent:
1.1107 + {
1.1108 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SimulateRawEvent API")))
1.1109 + {
1.1110 + PPanic(EWservPanicPermissionDenied);
1.1111 + }
1.1112 + TRawEvent event(*pData.RawEvent);
1.1113 + if (TWsPointer::PreProcessDriverEvent(event))
1.1114 + TWindowServerEvent::ProcessRawEvent(event);
1.1115 + }
1.1116 + break;
1.1117 + case EWsClOpKeyEvent:
1.1118 + {
1.1119 + if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SimulateKeyEvent API")))
1.1120 + {
1.1121 + PPanic(EWservPanicPermissionDenied);
1.1122 + }
1.1123 + TWindowServerEvent::ProcessKeyEvent(*pData.KeyEvent,0);
1.1124 + }
1.1125 + break;
1.1126 + case EWsClOpLogMessage:
1.1127 + if (wsDebugLog)
1.1128 + {
1.1129 + if (CheckBuffer(*pData.Int, KLogMessageLength))
1.1130 + wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,BufferTPtr((TText* )(pData.Int+1),*pData.Int),0);
1.1131 + }
1.1132 + break;
1.1133 + case EWsClOpPasswordEntered:
1.1134 + CWsPassword::PasswordEntered(this);
1.1135 + break;
1.1136 + case EWsClOpComputeMode:
1.1137 + SetComputeMode(*pData.ComputeMode);
1.1138 + break;
1.1139 + case EWsClOpSendOffEventsToShell:
1.1140 + {
1.1141 + if(!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::RequestOffEvents API")))
1.1142 + {
1.1143 + User::Leave(KErrPermissionDenied);
1.1144 + }
1.1145 + SetReply(CWsTop::SetSendOffEventsToShell(this,*pData.OffEventsToShell));
1.1146 + }
1.1147 + break;
1.1148 + case EWsClOpGetDefModeMaxNumColors:
1.1149 + {
1.1150 + SDefModeMaxNumColors colors;
1.1151 + const TInt screenNumber = *pData.Int;
1.1152 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.1153 + PPanic(EWservPanicScreenNumber);
1.1154 + else
1.1155 + {
1.1156 + CScreen* screen = (screenNumber==KDummyScreenNumber)?iScreen:CWsTop::Screen(screenNumber);
1.1157 + screen->MaxNumColors(colors.iColors,colors.iGrays);
1.1158 + colors.iDisplayMode=screen->FirstDefaultDisplayMode();
1.1159 + }
1.1160 + ReplyBuf(&colors,sizeof(colors));
1.1161 + }
1.1162 + break;
1.1163 + case EWsClOpGetColorModeList:
1.1164 + {
1.1165 + const TInt screenNumber = *pData.Int;
1.1166 + if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())
1.1167 + PPanic(EWservPanicScreenNumber);
1.1168 + else
1.1169 + SetReply((screenNumber==KDummyScreenNumber) ? iScreen->ColorModesFlag() : CWsTop::Screen(screenNumber)->ColorModesFlag());
1.1170 + }
1.1171 + break;
1.1172 + case EWsClOpSetDefaultFadingParams:
1.1173 + {
1.1174 + if(KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetDefaultFadingParameters API")))
1.1175 + {
1.1176 + iScreen->SetFadingParams(WservEncoding::ExtractFirst8BitValue(*pData.UInt),WservEncoding::ExtractSecond8BitValue(*pData.UInt));
1.1177 + }
1.1178 + }
1.1179 + break;
1.1180 + case EWsClOpPrepareForSwitchOff:
1.1181 + {
1.1182 + if(KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::PrepareForSwitchOff API")))
1.1183 + {
1.1184 + }
1.1185 + }
1.1186 + break;
1.1187 + case EWsClOpSetFaded:
1.1188 + {
1.1189 + // Deprecated - retained for BC with applications that retrieve the fade count
1.1190 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetSystemFaded API")))
1.1191 + User::Leave(KErrPermissionDenied);
1.1192 +
1.1193 + TUint8 blackMap;
1.1194 + TUint8 whiteMap;
1.1195 + if (pData.SetSystemFaded->UseDefaultMap())
1.1196 + iScreen->GetFadingParams(blackMap,whiteMap);
1.1197 + else
1.1198 + pData.SetSystemFaded->GetFadingParams(blackMap,whiteMap);
1.1199 +
1.1200 + iScreen->RootWindow()->SetSystemFaded(pData.SetSystemFaded->Faded(),blackMap,whiteMap);
1.1201 + }
1.1202 + break;
1.1203 + case EWsClOpLogCommand:
1.1204 + CWsTop::LogCommand(*pData.LogCommand);
1.1205 + break;
1.1206 +#if defined(__WINS__)
1.1207 + case EWsClOpRemoveKeyCode:
1.1208 + iInternalFlags&=~ERemoveKeyCode;
1.1209 + if (*pData.Bool)
1.1210 + iInternalFlags|=ERemoveKeyCode;
1.1211 + break;
1.1212 + case EWsClOpSimulateXyInput:
1.1213 + TWsPointer::SetXyInputType(static_cast<TXYInputType>(*pData.XyInput));
1.1214 + break;
1.1215 +#endif
1.1216 + case EWsClOpNoFlickerFree:
1.1217 + PPanic(EWservPanicOpcode); //not supported anymore
1.1218 + break;
1.1219 + case EWsClOpSetFocusScreen:
1.1220 + {
1.1221 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetFocusScreen API")))
1.1222 + {
1.1223 + User::Leave(KErrPermissionDenied);
1.1224 + }
1.1225 + TInt focusScreen=*pData.Int;
1.1226 + if (focusScreen>=0 && focusScreen<CWsTop::NumberOfScreens())
1.1227 + SetReply(CWsTop::SetCurrentFocusScreen(focusScreen));
1.1228 + else
1.1229 + SessionPanic(EWservPanicScreenNumber);
1.1230 + break;
1.1231 + }
1.1232 + case EWsClOpGetFocusScreen:
1.1233 + SetReply(CWsTop::CurrentFocusScreen()->ScreenNumber());
1.1234 + break;
1.1235 + case EWsClOpGetNumberOfScreens:
1.1236 + SetReply(CWsTop::NumberOfScreens());
1.1237 + break;
1.1238 + case EWsClOpClearAllRedrawStores:
1.1239 + CWsTop::ClearAllRedrawStores();
1.1240 + break;
1.1241 + case EWsClOpGetGraphicMessage:
1.1242 + iGraphicMessageQueue.GetGraphicMessage();
1.1243 + break;
1.1244 + case EWsClOpGraphicMessageCancel:
1.1245 + iGraphicMessageQueue.CancelRead();
1.1246 + break;
1.1247 + case EWsClOpGraphicAbortMessage:
1.1248 + iGraphicMessageQueue.AbortMessage(*pData.Int);
1.1249 + break;
1.1250 + case EWsClOpGraphicFetchHeaderMessage:
1.1251 + SetReply(iGraphicMessageQueue.TopClientHandle());
1.1252 + break;
1.1253 + case EWsClOpRegisterSurface:
1.1254 + SetReply(RegisterSurface(pData));
1.1255 + break;
1.1256 + case EWsClOpUnregisterSurface:
1.1257 + UnregisterSurface(pData);
1.1258 + break;
1.1259 + case EWsClOpSetCloseProximityThresholds:
1.1260 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),
1.1261 + __PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetCloseProximityThresholds")))
1.1262 + {
1.1263 + User::Leave(KErrPermissionDenied);
1.1264 + }
1.1265 + SetReply(TWsPointer::SetCloseProximityThresholds(pData.ZThresholdPair->enterThreshold,
1.1266 + pData.ZThresholdPair->exitThreshold));
1.1267 + break;
1.1268 + case EWsClOpSetHighPressureThresholds:
1.1269 + if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),
1.1270 + __PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetHighPressureThresholds")))
1.1271 + {
1.1272 + User::Leave(KErrPermissionDenied);
1.1273 + }
1.1274 + SetReply(TWsPointer::SetHighPressureThresholds(pData.ZThresholdPair->enterThreshold,
1.1275 + pData.ZThresholdPair->exitThreshold));
1.1276 + break;
1.1277 + case EWsClOpGetEnterCloseProximityThreshold:
1.1278 + SetReply(TWsPointer::GetEnterCloseProximityThreshold());
1.1279 + break;
1.1280 + case EWsClOpGetExitCloseProximityThreshold:
1.1281 + SetReply(TWsPointer::GetExitCloseProximityThreshold());
1.1282 + break;
1.1283 + case EWsClOpGetEnterHighPressureThreshold:
1.1284 + SetReply(TWsPointer::GetEnterHighPressureThreshold());
1.1285 + break;
1.1286 + case EWsClOpGetExitHighPressureThreshold:
1.1287 + SetReply(TWsPointer::GetExitHighPressureThreshold());
1.1288 + break;
1.1289 + case EWsClOpCreateDrawableSource:
1.1290 + CreateDrawableSourceL(*pData.CreateDrawableSource);
1.1291 + break;
1.1292 + case EWsClOpIndicateAppOrientation:
1.1293 + IndicateAppOrientation(*pData.Orientation);
1.1294 + break;
1.1295 + case EWsClOpUnregisterAllTFXEffect:
1.1296 + RDebug::Printf("[Bug 3344] OpCode EWsClOpUnregisterAllTFXEffect not supported.");
1.1297 + break;
1.1298 + default:
1.1299 + PPanic(EWservPanicOpcode);
1.1300 + break;
1.1301 + }
1.1302 + }
1.1303 +/** Debug information accessor.
1.1304 + *
1.1305 + *
1.1306 + **/
1.1307 +void CWsClient::DebugInfoL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const
1.1308 + {
1.1309 + if (aFunction & EWsDebugClassMask)
1.1310 + SetReply(DebugInfoClassifiedL(aFunction,aParam,aHasReplyBuf));
1.1311 + else
1.1312 + DebugInfoUnclassifiedL(aFunction,aParam,aHasReplyBuf);
1.1313 + }
1.1314 +
1.1315 +/** A wide variety of generally unconnected debug enquiries.
1.1316 + *
1.1317 + *
1.1318 + **/
1.1319 +void CWsClient::DebugInfoUnclassifiedL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const
1.1320 + {
1.1321 + switch(aFunction)
1.1322 + {
1.1323 + case EWsDebugInfoHeap:
1.1324 + if (aHasReplyBuf)
1.1325 + {
1.1326 + TWsDebugHeapInfo heapInfo;
1.1327 + RHeap& heap=User::Heap();
1.1328 + heapInfo.iCount=heap.AllocSize(heapInfo.iTotal);
1.1329 + heapInfo.iAvailable=heap.Available(heapInfo.iLargestAvailable);
1.1330 + ReplyBuf(&heapInfo,sizeof(heapInfo));
1.1331 + }
1.1332 + SetReply(KErrArgument);
1.1333 + break;
1.1334 + case EWsDebugSetCheckHeapOnDisconnectClient:
1.1335 + if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::DebugInfo API")))
1.1336 + {
1.1337 + User::Leave(KErrPermissionDenied);
1.1338 + }
1.1339 + CWsTop::SetCheckHeapOnDisconnectClient(this);
1.1340 + break;
1.1341 + case EWsDebugSetCheckHeapOnDisconnectMode:
1.1342 + if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::DebugInfo API")))
1.1343 + {
1.1344 + User::Leave(KErrPermissionDenied);
1.1345 + }
1.1346 + CWsTop::SetCheckHeapOnDisconnectMode(STATIC_CAST(TWsCheckHeapOnDisconnectMode,aParam));
1.1347 + break;
1.1348 + case EWsDebugFetchCheckHeapResult:
1.1349 + SetReply(CWsTop::FetchCheckHeapResult());
1.1350 + break;
1.1351 + case EWsDebugSetEventQueueTest:
1.1352 + CWsWindowGroup::SetEventQueueTestState(aParam);
1.1353 + break;
1.1354 + default:
1.1355 + SetReply(KErrNotSupported);
1.1356 + break;
1.1357 + }
1.1358 + }
1.1359 +
1.1360 +/** Selects a debug function based on the class of debug query.
1.1361 + *
1.1362 + *
1.1363 + **/
1.1364 +TInt CWsClient::DebugInfoClassifiedL(TInt aFunction, TInt aParam, TBool aHasReplyBuf) const
1.1365 + {//Duplicating the meanings of Classified... this would be a good place for a security check
1.1366 + //first part of param is always screen number
1.1367 + TInt buffSpace=aHasReplyBuf?ReplyBufSpace():0;
1.1368 + if (buffSpace<0)
1.1369 + return (buffSpace);
1.1370 +
1.1371 + const TInt screenNumber = (aParam&EWsDebugArgScreenMask)>>EWsDebugArgScreenShift;
1.1372 + const TInt functionClass = (aFunction&EWsDebugClassMask);
1.1373 + CScreen* screen = NULL;
1.1374 + if (functionClass<EWsDebugClassNonScreen)
1.1375 + {
1.1376 + if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())
1.1377 + return (KErrArgument);
1.1378 +
1.1379 + screen = CWsTop::Screen(screenNumber);
1.1380 + }
1.1381 + WS_ASSERT_DEBUG(screen, EWsPanicNoScreen);
1.1382 + switch (aFunction&EWsDebugClassMask)
1.1383 + {
1.1384 + case EWsDebugClassScreenUiElement:
1.1385 + return DebugInfoScreenUiL(aFunction,aParam,buffSpace,*screen);
1.1386 + case EWsDebugClassScreenElementSet:
1.1387 + return DebugInfoScreenElementSetL(aFunction, aParam, buffSpace, *screen);
1.1388 + case EWsDebugClassElementSetWindow:
1.1389 + return DebugInfoElementSetWindowL(aFunction, aParam, buffSpace, *screen);
1.1390 + case EWsDebugClassElementSetElement:
1.1391 + return DebugInfoElementSetElementL(aFunction, aParam, buffSpace, *screen);
1.1392 +
1.1393 + case EWsDebugClassClientWindow:
1.1394 + default:
1.1395 + return (KErrNotSupported);
1.1396 + }
1.1397 + }
1.1398 +
1.1399 +/** Returns debug info about the UIElement entries for a screen.
1.1400 + * This describes the general state or size of the element set.
1.1401 + * It is indexed via screen num, and optionally element index.
1.1402 + * Element index MUST BE 0 when not required.
1.1403 + * @return size of buffer required or error code.
1.1404 + **/
1.1405 +TInt CWsClient::DebugInfoScreenUiL(TInt aFunction, TInt /* aParam */, TInt aReplyBufSize, CScreen& aScreen) const
1.1406 + {
1.1407 + switch(aFunction)
1.1408 + {
1.1409 + case EWsDebugGetFastpathMode:
1.1410 + {
1.1411 + // obsolete through preq2669
1.1412 + WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);
1.1413 + return KErrNotSupported;
1.1414 + }
1.1415 +
1.1416 + case EWsDebugSetFastpathMode:
1.1417 + {
1.1418 + // obsolete through preq2669
1.1419 + WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);
1.1420 + return KErrNotSupported;
1.1421 + }
1.1422 +
1.1423 + case EWsDebugGetUIElementInfoList:
1.1424 + {
1.1425 + // obsolete through preq2669
1.1426 + WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);
1.1427 + return KErrNotSupported;
1.1428 + }
1.1429 +
1.1430 + case EWsDebugGetUIElementBase:
1.1431 + {
1.1432 + // obsolete through preq2669
1.1433 + WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);
1.1434 + return KErrNotSupported;
1.1435 + }
1.1436 +
1.1437 + case EWsDebugGetUIElementIds:
1.1438 + {
1.1439 + // obsolete through preq2669
1.1440 + WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);
1.1441 + return KErrNotSupported;
1.1442 + }
1.1443 +
1.1444 + case EWsDebugGetSceneElementIdOrder:
1.1445 + {
1.1446 + // obsolete through preq2669
1.1447 + WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);
1.1448 + return KErrNotSupported;
1.1449 + }
1.1450 + case EWsDebugSetFastpathTestMode:
1.1451 + {
1.1452 + // obsolete through preq2669
1.1453 + WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);
1.1454 + return KErrNotSupported;
1.1455 + }
1.1456 +
1.1457 + case EWsDebugSetFastpathOomMode:
1.1458 + {
1.1459 + // obsolete through preq2669
1.1460 + WS_ASSERT_DEBUG(EFalse, EWsPanicDrawCommandsInvalidState);
1.1461 + return KErrNotSupported;
1.1462 + }
1.1463 + case EWsDebugGetUIElementConfig:
1.1464 + {
1.1465 + return DebugReturnConfig(aReplyBufSize,&aScreen.UiElement(),0);
1.1466 +
1.1467 + }
1.1468 + default:
1.1469 + return (KErrNotSupported);
1.1470 + }
1.1471 + }
1.1472 +
1.1473 +/** Returns debug info about the CWindowElementSet entry for a screen.
1.1474 + * This describes the general state or size of the element set
1.1475 + * It is indexed via screen num.
1.1476 + * @return size of buffer required or error code.
1.1477 + **/
1.1478 +TInt CWsClient::DebugInfoScreenElementSetL(TInt aFunction, TInt /*aParam*/, TInt aReplyBufSize, const CScreen& aScreen) const
1.1479 + {
1.1480 + const CWindowElementSet& elementSet = aScreen.WindowElements();
1.1481 + switch (aFunction)
1.1482 + {
1.1483 + case EWsDebugSerialSurfacesUpdated:
1.1484 + return 0;
1.1485 +
1.1486 + case EWsDebugSurfaceWindowList:
1.1487 + {
1.1488 + TInt outSize = elementSet.Count() * sizeof(TWsDebugWindowId);
1.1489 + if (outSize<=aReplyBufSize)
1.1490 + {//can stream, so I shall!
1.1491 + for (TInt index = 0; index < elementSet.Count(); index++)
1.1492 + {
1.1493 + const CWsClientWindow& win = *elementSet.DebugWindowAt(index);
1.1494 + TWsDebugWindowId id=
1.1495 + {
1.1496 + win.ClientHandle(), 0
1.1497 + };
1.1498 + if (win.WsOwner()!=this)
1.1499 + id.iOtherGroupId=win.WinGroup()->Identifier();
1.1500 + ReplyBuf(&id, sizeof(id));
1.1501 + }
1.1502 + }
1.1503 + return outSize;
1.1504 + }
1.1505 + default:
1.1506 + return (KErrNotSupported);
1.1507 +
1.1508 + }
1.1509 + }
1.1510 +
1.1511 +/** Returns debug info about a CWindowElement entry.
1.1512 + * This describes the window or the background element(s)
1.1513 + * It is indexed via screen num, and index in elementset.
1.1514 + * @return size of buffer required or error code.
1.1515 + **/
1.1516 +TInt CWsClient::DebugInfoElementSetWindowL(TInt aFunction, TInt aParam,
1.1517 + TInt aReplyBufSize, const CScreen& aScreen) const
1.1518 + {
1.1519 + const CWindowElementSet& elementSet = aScreen.WindowElements();
1.1520 + TUint winIndex = (aParam & EWsDebugArgWindowMask) >> EWsDebugArgWindowShift;
1.1521 + const TAttributes* winElement = elementSet.DebugBackgroundAt(winIndex);
1.1522 + if (winElement == NULL)
1.1523 + {
1.1524 + return KErrArgument;
1.1525 + }
1.1526 +
1.1527 + MWsElement* backElement = winElement->iElement;
1.1528 + TInt placedCount = elementSet.DebugPlacedCountAt(winIndex);
1.1529 + switch (aFunction)
1.1530 + {
1.1531 + case EWsDebugElementIdList:
1.1532 + {
1.1533 + TInt retVal = (placedCount + 1) * sizeof(MWsElement*);
1.1534 + if (retVal<aReplyBufSize)
1.1535 + {
1.1536 + ReplyBuf(&backElement, sizeof(MWsElement*));
1.1537 + for (TInt index=0; index<placedCount; index++)
1.1538 + ReplyBuf(&elementSet.DebugPlacedAt(winIndex, index)->iElement, sizeof(MWsElement*));
1.1539 + }
1.1540 + return retVal;
1.1541 + }
1.1542 + case EWsDebugBackgroundConfig:
1.1543 + if (backElement == NULL)
1.1544 + return KErrNotFound;
1.1545 + else
1.1546 + return DebugReturnConfig(aReplyBufSize, backElement,
1.1547 + winElement->DebugFlags());
1.1548 + case EWsDebugBackgroundBase:
1.1549 + if (backElement == NULL)
1.1550 + return KErrNotFound;
1.1551 + else
1.1552 + return DebugReturnBase(aReplyBufSize, backElement);
1.1553 + case EWsDebugBackgroundFlags:
1.1554 + return DebugReturnFlags(aReplyBufSize, backElement,
1.1555 + winElement->DebugFlags());
1.1556 + default:
1.1557 + return KErrNotSupported;
1.1558 + //This method can also be extended to return region and state information from the associated window
1.1559 + }
1.1560 + }
1.1561 +
1.1562 +/** Returns debug info about a placed element.
1.1563 + * It is indexed via screen num, index in elementset, and index in placed element array.
1.1564 + * @return size of buffer required or error code.
1.1565 + **/
1.1566 +TInt CWsClient::DebugInfoElementSetElementL(TInt aFunction, TInt aParam,
1.1567 + TInt aReplyBufSize, const CScreen& aScreen) const
1.1568 + {
1.1569 + const CWindowElementSet& elementSet = aScreen.WindowElements();
1.1570 + TUint winIndex = (aParam & EWsDebugArgWindowMask) >> EWsDebugArgWindowShift;
1.1571 + TUint placeIndex = (aParam & EWsDebugArgElementMask) >> EWsDebugArgElementShift;
1.1572 + const TAttributes* placedElement = elementSet.DebugPlacedAt(winIndex, placeIndex);
1.1573 + if (placedElement == NULL)
1.1574 + {
1.1575 + return KErrArgument;
1.1576 + }
1.1577 +
1.1578 + MWsElement* element = placedElement->iElement;
1.1579 + if (element == NULL)
1.1580 + {
1.1581 + return KErrNotFound;
1.1582 + }
1.1583 +
1.1584 + switch (aFunction)
1.1585 + {
1.1586 + case EWsDebugPlacedConfig:
1.1587 + return DebugReturnConfig(aReplyBufSize, element,
1.1588 + placedElement->DebugFlags());
1.1589 + case EWsDebugPlacedBase:
1.1590 + return DebugReturnBase(aReplyBufSize, element);
1.1591 + case EWsDebugPlacedFlags:
1.1592 + return DebugReturnFlags(aReplyBufSize, element,
1.1593 + placedElement->DebugFlags());
1.1594 + default:
1.1595 + return KErrNotSupported;
1.1596 + }
1.1597 + }
1.1598 +
1.1599 +/** Returns a filled in TSurfaceConfiguration from an MWsElement.
1.1600 + * Data is usually copied if the buffer is big enough
1.1601 + * @return the size of buffer required, or zero if the buffer is acceptable
1.1602 + **/
1.1603 +TInt CWsClient::DebugReturnConfig(TInt aReplyBufSize, MWsElement* aElement, TInt /*aFlags*/) const
1.1604 + {
1.1605 + if (aElement == NULL)
1.1606 + {
1.1607 + return KErrNotReady;
1.1608 + }
1.1609 +
1.1610 + TSurfaceConfiguration config(aReplyBufSize);
1.1611 + TInt retVal=config.Size();
1.1612 + if (aReplyBufSize)
1.1613 + {
1.1614 + retVal = CWindowElementSet::GetConfiguration(config, *aElement);
1.1615 + if (retVal==KErrNone)
1.1616 + {
1.1617 + ReplyBuf(&config, config.Size()); //return code is 0 = "just right"
1.1618 + }
1.1619 + }
1.1620 + return retVal;
1.1621 + }
1.1622 +
1.1623 +/** Returns the base region of the element.
1.1624 + * This region is element relative. There are a number of ways that this does not match the input region:
1.1625 + * First, if no region is specified then the extent rectangle is returned
1.1626 + * Any region returned has all negative ordinate values clipped.
1.1627 + * Positive values may exceed the extent, but negative values are never returned.
1.1628 + * Internally, a region which is only negative is "remembered illegally", but an empty region is returned.
1.1629 + **/
1.1630 +TInt CWsClient::DebugReturnBase(TInt /*aReplyBufSize*/, const MWsElement* /*aElement*/)const
1.1631 + {
1.1632 + return KErrNotSupported;
1.1633 + }
1.1634 +
1.1635 +/** Returns the flags associated with the given element.
1.1636 + * 2 words are inserted.
1.1637 + * One represents the MWsElement flags, the other represents CWindowElement or UIElement flags
1.1638 + * @return length of two words
1.1639 + **/
1.1640 +TInt CWsClient::DebugReturnFlags(TInt aReplyBufSize, const MWsElement* /*aElement*/, TInt aFlags)const
1.1641 + {
1.1642 + const TInt KArraySize=2;
1.1643 + if (aReplyBufSize>KArraySize*sizeof(TInt))
1.1644 + {
1.1645 + // First field is for flags from scene element if any
1.1646 + TInt returns[KArraySize]=
1.1647 + {
1.1648 + 0, aFlags
1.1649 + };
1.1650 + ReplyBuf(returns,KArraySize*sizeof(TInt));
1.1651 + }
1.1652 + return KArraySize*sizeof(TInt);
1.1653 + }
1.1654 +
1.1655 +/** Packages a region for return ans an array of rectangles.
1.1656 + * If the buffer is big enough the data is transferred
1.1657 + * @return the buffer size required, or an error code if an empty or null pointer is passed in
1.1658 + **/
1.1659 +TInt CWsClient::DebugReturnRegion(TInt aReplyBufSize, const TRegion* aRegion, TInt aErrCodeIfEmpty)const
1.1660 + {
1.1661 + if (aRegion==NULL)
1.1662 + return KErrNotReady;
1.1663 +
1.1664 + const TInt returnSize=aRegion->Count()*sizeof(TRect);
1.1665 + if (returnSize==0)
1.1666 + return aErrCodeIfEmpty;
1.1667 +
1.1668 + if (returnSize<=aReplyBufSize)
1.1669 + ReplyBuf(aRegion->RectangleList(),returnSize);
1.1670 +
1.1671 + return returnSize;
1.1672 + }
1.1673 +
1.1674 +void CWsClient::ReplyGroupName(HBufC* aName, TInt aMaxLength) // static
1.1675 + {
1.1676 + if (aName)
1.1677 + {
1.1678 + if (aName->Length()>aMaxLength)
1.1679 + {
1.1680 + ReplyBuf(aName->Left(aMaxLength));
1.1681 + SetReply(KErrOverflow);
1.1682 + }
1.1683 + else
1.1684 + ReplyBuf(*aName);
1.1685 + }
1.1686 + else
1.1687 + ReplyBuf(KNullDesC);
1.1688 + }
1.1689 +
1.1690 +void CWsClient::TriggerRedraw()
1.1691 + {
1.1692 + RedrawQueue()->TriggerRedraw();
1.1693 + }
1.1694 +
1.1695 +void CWsClient::UpdateWindowOrdinalPrioritys()
1.1696 + {
1.1697 + for(CWsWindowGroup* win=iScreen->RootWindow()->Child();win;win=win->NextSibling())
1.1698 + {
1.1699 + if (win->WsOwner()==this)
1.1700 + win->UpdateOrdinalPriority(ETrue);
1.1701 + }
1.1702 + }
1.1703 +
1.1704 +void CWsClient::DeleteSystemPointerListEntry(TInt aIndex)
1.1705 + {
1.1706 + PointerCursor (aIndex)->Close();
1.1707 + iSystemPointerCursors->Delete(aIndex);
1.1708 + }
1.1709 +
1.1710 +CWsPointerCursor* CWsClient::SystemPointerCursor(TInt aIndex)
1.1711 + {
1.1712 + TInt arrayIndex;
1.1713 + if (iSystemPointerCursors)
1.1714 + {
1.1715 + if (FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))
1.1716 + return PointerCursor(arrayIndex);
1.1717 +
1.1718 + // Cursor not defined so try for default cursor
1.1719 + if (FindCursorArrayItem(iSystemPointerCursors, 0, arrayIndex))
1.1720 + return PointerCursor(arrayIndex);
1.1721 + }
1.1722 +
1.1723 + // If that fails simply return NULL for no cursor
1.1724 + return NULL;
1.1725 + }
1.1726 +
1.1727 +void CWsClient::SetSystemPointerCursorL(TInt aIndex, CWsPointerCursor* aCursor)
1.1728 + {
1.1729 + if (iSystemPointerCursorListOwner!=this)
1.1730 + PPanic(EWservPanicNotSystemPointerCursorListOwner);
1.1731 +
1.1732 + TInt arrayIndex = KErrNotFound;
1.1733 + if (FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))
1.1734 + {
1.1735 + PointerCursor(arrayIndex)->Close();
1.1736 + PointerCursor(arrayIndex) = aCursor;
1.1737 + }
1.1738 + else
1.1739 + {
1.1740 + TWsCursorArrayItem entry;
1.1741 + entry.iIndex=aIndex;
1.1742 + entry.iCursor=aCursor;
1.1743 + iSystemPointerCursors->InsertIsqL(entry, iCursorKey);
1.1744 + }
1.1745 +
1.1746 + aCursor->Open();
1.1747 + if (aIndex==iDefaultSystemPointerCursorIndex)
1.1748 + iDefaultSystemPointerCursor=aCursor;
1.1749 + TWsPointer::UpdatePointerCursor();
1.1750 + }
1.1751 +
1.1752 +void CWsClient::ClearSystemPointerCursor(TInt aIndex)
1.1753 + {
1.1754 + if (iSystemPointerCursorListOwner!=this)
1.1755 + PPanic(EWservPanicNotSystemPointerCursorListOwner);
1.1756 +
1.1757 + TInt arrayIndex;
1.1758 + if (FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))
1.1759 + {
1.1760 + DeleteSystemPointerListEntry(arrayIndex);
1.1761 + if (aIndex==iDefaultSystemPointerCursorIndex)
1.1762 + iDefaultSystemPointerCursor=NULL;
1.1763 + }
1.1764 + }
1.1765 +
1.1766 +void CWsClient::ClaimSystemPointerCursorListL()
1.1767 + {
1.1768 + if (iSystemPointerCursorListOwner)
1.1769 + User::Leave(KErrInUse);
1.1770 +
1.1771 + const TInt systemPointerCursorGranularity = 4;
1.1772 + iSystemPointerCursors = new(ELeave) CArrayFixFlat<TWsCursorArrayItem> (systemPointerCursorGranularity);
1.1773 + iSystemPointerCursorListOwner=this;
1.1774 + }
1.1775 +
1.1776 +void CWsClient::FreeSystemPointerCursorList()
1.1777 + {
1.1778 + if(iSystemPointerCursorListOwner == this)
1.1779 + {
1.1780 + iSystemPointerCursorListOwner = NULL;
1.1781 +
1.1782 + while(iSystemPointerCursors->Count()>0)
1.1783 + DeleteSystemPointerListEntry(0);
1.1784 +
1.1785 + iDefaultSystemPointerCursor = NULL;
1.1786 + iDefaultSystemPointerCursorIndex = 0;
1.1787 +
1.1788 + delete iSystemPointerCursors;
1.1789 + iSystemPointerCursors = NULL;
1.1790 + }
1.1791 + }
1.1792 +
1.1793 +void CWsClient::SetDefaultSystemPointerCursor(TInt aIndex)
1.1794 + {
1.1795 + TInt arrayIndex;
1.1796 + if (iSystemPointerCursorListOwner != this)
1.1797 + PPanic(EWservPanicNotSystemPointerCursorListOwner);
1.1798 +
1.1799 + iDefaultSystemPointerCursorIndex = aIndex;
1.1800 + iDefaultSystemPointerCursor = NULL;
1.1801 +
1.1802 + if (aIndex != ENoDefaultSystemPointerCursor &&
1.1803 + FindCursorArrayItem(iSystemPointerCursors, aIndex, arrayIndex))
1.1804 + iDefaultSystemPointerCursor = PointerCursor (arrayIndex);
1.1805 + else
1.1806 + iDefaultSystemPointerCursor = NULL;
1.1807 +
1.1808 + TWsPointer::UpdatePointerCursor();
1.1809 + }
1.1810 +
1.1811 +TBool CWsClient::FindCursorArrayItem(CArrayFixFlat<TWsCursorArrayItem>* aCursorArray,
1.1812 + TInt aIndex,TInt& aPosition)
1.1813 + {
1.1814 + if (!aCursorArray)
1.1815 + return EFalse; // No hit if the array isn't even allocated
1.1816 +
1.1817 + TWsCursorArrayItem entry;
1.1818 + entry.iIndex = aIndex;
1.1819 + return aCursorArray->FindIsq(entry, iCursorKey, aPosition)==KErrNone;
1.1820 + }
1.1821 +
1.1822 +void CWsClient::SetClientPriority()
1.1823 + {
1.1824 + if (iComputeMode!=RWsSession::EPriorityControlDisabled)
1.1825 + {
1.1826 + Client().SetProcessPriority(
1.1827 + iComputeMode==RWsSession::EPriorityControlComputeOn
1.1828 + || CWsTop::FocusWindowGroupOwner()!=this
1.1829 + ? EPriorityBackground
1.1830 + : EPriorityForeground);
1.1831 + }
1.1832 + }
1.1833 +
1.1834 +void CWsClient::SetComputeMode(RWsSession::TComputeMode aComputeMode)
1.1835 + {
1.1836 + if (aComputeMode!=RWsSession::EPriorityControlDisabled
1.1837 + && aComputeMode !=RWsSession::EPriorityControlComputeOn
1.1838 + && aComputeMode !=RWsSession::EPriorityControlComputeOff)
1.1839 + PPanic(EWservPanicSetComputeMode);
1.1840 + iComputeMode=aComputeMode;
1.1841 + SetClientPriority();
1.1842 + }
1.1843 +
1.1844 +void CWsClient::CompleteMessage(const RMessage2& aMessage,TInt aReason)
1.1845 + {
1.1846 + WS_ASSERT_DEBUG(!aMessage.IsNull(),EWsPanicPanicFlagError);
1.1847 + if (iInternalFlags&EPanicClientAsSoonAsPossible)
1.1848 + {
1.1849 + aMessage.Panic(KWSERVSessionPanicCategory,iPanicReason);
1.1850 + iInternalFlags&=~EPanicClientAsSoonAsPossible;
1.1851 + }
1.1852 + else
1.1853 + {
1.1854 + if(!iResponseHandle)
1.1855 + aMessage.Complete(aReason);
1.1856 + else
1.1857 + {
1.1858 + aMessage.Complete(*iResponseHandle);
1.1859 + iResponseHandle=NULL;
1.1860 + }
1.1861 + }
1.1862 + }
1.1863 +
1.1864 +void CWsClient::ServiceError(const RMessage2& /*aMessage*/,TInt aError)
1.1865 + {
1.1866 + CompleteMessage(iClientMessage,aError); // (finish)
1.1867 + }
1.1868 +
1.1869 +void CWsClient::ServiceL(const RMessage2 &aMessage) // (step ##1)
1.1870 +//
1.1871 +// Handle messages for the window server server.
1.1872 +//
1.1873 + {
1.1874 + iClientMessage=aMessage; // from now on use always the message stored in the session
1.1875 + if (iInternalFlags&EPanicClientAsSoonAsPossible)
1.1876 + {
1.1877 + iClientMessage.Panic(KWSERVSessionPanicCategory,iPanicReason);
1.1878 + }
1.1879 + else
1.1880 + {
1.1881 + iPanicReason=KErrNone;
1.1882 + iReply=KErrNone;
1.1883 + TBool completeRequest=ETrue;
1.1884 + DoServiceL(iClientMessage, completeRequest); // (call #2)
1.1885 + if (completeRequest)
1.1886 + CompleteMessage(iClientMessage,iReply); // (finish)
1.1887 + }
1.1888 + }
1.1889 +
1.1890 +void CWsClient::SetResponseHandle(RHandleBase* aHandle)
1.1891 + {
1.1892 + iResponseHandle = aHandle;
1.1893 + }
1.1894 +
1.1895 +void CWsClient::DoServiceL(const RMessage2& aMessage, TBool& aCompleteRequest) // (step #2)
1.1896 + {
1.1897 + if (aMessage.IsNull())
1.1898 + PPanic(EWservPanicNullMessageFromClient);
1.1899 +
1.1900 + WS_ASSERT_DEBUG(iInternalFlags&EFinishedProcessingCommands,EWsPanicCommandBufferStillBeingProcessed);
1.1901 +
1.1902 + const TInt function = aMessage.Function();
1.1903 + switch (function)
1.1904 + {
1.1905 + case EWservMessInit:
1.1906 + StartInitializationL(iConnectionId++);
1.1907 + break;
1.1908 + case EWservMessSyncMsgBuf:
1.1909 + case EWservMessCommandBuffer: // Process command buffer containing draw ops
1.1910 + {
1.1911 + if (!IsInitialised())
1.1912 + PPanic(EWservPanicUninitialisedClient);
1.1913 +
1.1914 + const TInt err = aMessage.Read(KBufferMessageSlot, iCmdBuf);
1.1915 + if (!err)
1.1916 + {
1.1917 + iReplyOffset=0;
1.1918 + iDestObj=NULL;
1.1919 + iNextCmd=iCmdBuf.Ptr();
1.1920 + DoServiceCommandBuf(); // (call #3.1)
1.1921 + }
1.1922 + else if (err!=KErrDied)
1.1923 + PPanic(EWservPanicDescriptor);
1.1924 +
1.1925 + if(function == EWservMessCommandBuffer && CWsTop::FinishEveryFlush())
1.1926 + Screen()->DoRedrawNow();
1.1927 + else
1.1928 + aCompleteRequest=EFalse;
1.1929 + }
1.1930 + break;
1.1931 + case EWservMessShutdown:
1.1932 + {
1.1933 + if(!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for EWservMessShutdown message ")))
1.1934 + PPanic(EWservPanicPermissionDenied);
1.1935 +
1.1936 + if (aMessage.Int0() == EWservShutdownCheck)
1.1937 + CWsTop::Exit();
1.1938 + else
1.1939 + PPanic(EWservPanicHandle);
1.1940 + }
1.1941 + break;
1.1942 + case EWservMessFinish:
1.1943 + Screen()->DoRedrawNow();
1.1944 + break;
1.1945 + default:
1.1946 + if (function&EWservMessAsynchronousService)
1.1947 + {
1.1948 + TRAPD(err, ExecuteAsyncClientCommandL((function&~EWservMessAsynchronousService), aMessage)); // (call #3.2)
1.1949 + aCompleteRequest = (err!=KErrNone);
1.1950 + WS_ASSERT_DEBUG((!(iInternalFlags&EPanicClientAsSoonAsPossible))==(!aCompleteRequest), EWsPanicPanicFlagError);
1.1951 + }
1.1952 + else if (function&EWservMessAnimDllAsyncCommand)
1.1953 + {
1.1954 + CWsAnimDll* const animDll = static_cast<CWsAnimDll*>(HandleToObj(aMessage.Int0(), WS_HANDLE_ANIM_DLL));
1.1955 + if (!animDll)
1.1956 + {
1.1957 + SessionPanic(EWservPanicHandle);
1.1958 + break;
1.1959 + }
1.1960 +
1.1961 + // 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.1962 + TRAPD(err, animDll->AnimObjectL(aMessage.Int1())->CommandReply(function&~EWservMessAnimDllAsyncCommand,NULL));
1.1963 + aCompleteRequest=(err!=KErrNone);
1.1964 + WS_ASSERT_DEBUG((!(iInternalFlags&EPanicClientAsSoonAsPossible))==(!aCompleteRequest), EWsPanicPanicFlagError);
1.1965 + }
1.1966 + else
1.1967 + SetReply(KErrNotSupported);
1.1968 + }
1.1969 + }
1.1970 +void CWsClient::RemoteRead(TDes16& aDes, TInt aOffset)
1.1971 + {
1.1972 + if (iClientMessage.Read(KRemoteBufferMessageSlot,aDes,aOffset)!=KErrNone)
1.1973 + SessionPanic(EWservPanicDescriptor);
1.1974 + }
1.1975 +
1.1976 +void CWsClient::RemoteRead(TDes8& aDes, TInt aOffset)
1.1977 + {
1.1978 + if (iClientMessage.Read(KRemoteBufferMessageSlot,aDes,aOffset)!=KErrNone)
1.1979 + SessionPanic(EWservPanicDescriptor);
1.1980 + }
1.1981 +
1.1982 +void CWsClient::RemoteReadL(TDes16& aDes, TInt aOffset)
1.1983 + {
1.1984 + iClientMessage.ReadL(KRemoteBufferMessageSlot,aDes,aOffset);
1.1985 + }
1.1986 +
1.1987 +void CWsClient::RemoteReadL(TDes8& aDes, TInt aOffset)
1.1988 + {
1.1989 + iClientMessage.ReadL(KRemoteBufferMessageSlot,aDes,aOffset);
1.1990 + }
1.1991 +
1.1992 +void CWsClient::InitStaticsL()
1.1993 + {
1.1994 + }
1.1995 +
1.1996 +void CWsClient::DeleteStatics()
1.1997 + {
1.1998 + if (iTextCursorArray)
1.1999 + {
1.2000 + const TInt count = iTextCursorArray->Count();
1.2001 + for (TInt index=0;index<count;index++)
1.2002 + delete iTextCursorArray->At(index).iCursor;
1.2003 +
1.2004 + delete iTextCursorArray;
1.2005 + iTextCursorArray = NULL;
1.2006 + }
1.2007 +
1.2008 + // coverity[extend_simple_error]
1.2009 + }
1.2010 +
1.2011 +/* CWsClient implementing MWsClient */
1.2012 +
1.2013 +TBool CWsClient::HasCapability(TCapability aCapability) const
1.2014 + {
1.2015 + return iClient.HasCapability(aCapability);
1.2016 + }
1.2017 +
1.2018 +TSecureId CWsClient::SecureId() const
1.2019 + {
1.2020 + return iClient.SecureId();
1.2021 + }
1.2022 +
1.2023 +TVendorId CWsClient::VendorId() const
1.2024 + {
1.2025 + return iClient.VendorId();
1.2026 + }
1.2027 +
1.2028 +/**
1.2029 +Makes a new copy of the aData. so it could be deleted after this call.
1.2030 +*/
1.2031 +TInt CWsClient::SendMessage(const CWsGraphicDrawer* aOnBehalfOf,const TDesC8& aData)
1.2032 + {
1.2033 + CWsGraphicMessageQueue::CMessage* msg = CWsGraphicMessageQueue::CMessage::New(aData);
1.2034 + if(msg)
1.2035 + return SendMessage(aOnBehalfOf, *msg);
1.2036 +
1.2037 + return KErrGeneral;
1.2038 + }
1.2039 +
1.2040 +/** adds a message to the message queue
1.2041 +@return a postive number to uniquely identify the message
1.2042 +*/
1.2043 +TInt CWsClient::SendMessage(const CWsGraphicDrawer* aOnBehalfOf,CWsMessageData& aData)
1.2044 + {
1.2045 + WS_ASSERT_DEBUG(aData.Data().Size(), EWsPanicWsGraphic);
1.2046 + const CWsGraphicDrawerObject* obj = DrawerObject(aOnBehalfOf);
1.2047 + WS_ASSERT_DEBUG(obj, EWsPanicWsGraphic);
1.2048 + if(obj)
1.2049 + {
1.2050 + // assign message id
1.2051 + if(iMessageIdSeq == KMaxTInt) // Wrap if iMessageIdSeq has reached KMaxTInt
1.2052 + iMessageIdSeq = 0;
1.2053 +
1.2054 + iMessageIdSeq++;
1.2055 + // correct other handles
1.2056 + aData.iClientHandle = (obj->ClientHandle() | (EWsGraphMessageTypeUser & 0x03));
1.2057 + aData.iDrawer = obj->Drawer();
1.2058 + aData.iId = iMessageIdSeq;
1.2059 + iGraphicMessageQueue.Queue(&aData);
1.2060 + return iMessageIdSeq;
1.2061 + }
1.2062 +
1.2063 + return KErrGeneral;
1.2064 + }
1.2065 +
1.2066 +
1.2067 +CWsGraphicDrawerObject* CWsClient::DrawerObject(const CWsGraphicDrawer* aDrawer)
1.2068 + {
1.2069 + const TInt count = ObjectIndex()->Length();
1.2070 + for(TInt i=0; i<count; i++)
1.2071 + {
1.2072 + CWsObject* obj = const_cast<CWsObject*>(ObjectIndex()->At(i));
1.2073 + if(obj && (WS_HANDLE_GRAPHIC_DRAWER == obj->Type()))
1.2074 + {
1.2075 + CWsGraphicDrawerObject* candidate = static_cast<CWsGraphicDrawerObject*>(obj);
1.2076 + if(candidate->Drawer() == aDrawer)
1.2077 + return candidate;
1.2078 + }
1.2079 + }
1.2080 +
1.2081 + return NULL;
1.2082 + }
1.2083 +
1.2084 +const CWsGraphicDrawerObject* CWsClient::DrawerObject(const CWsGraphicDrawer* aDrawer) const
1.2085 + {
1.2086 + CWsObjectIx* objectIndex = const_cast<CWsClient*>(this)->ObjectIndex();
1.2087 + const TInt count = objectIndex->Length();
1.2088 + for(TInt i=0; i<count; i++)
1.2089 + {
1.2090 + CWsObject* obj = const_cast<CWsObject*>(objectIndex->At(i));
1.2091 + if(obj && (WS_HANDLE_GRAPHIC_DRAWER == obj->Type()))
1.2092 + {
1.2093 + const CWsGraphicDrawerObject* candidate = static_cast<CWsGraphicDrawerObject*>(obj);
1.2094 + if(candidate->Drawer() == aDrawer)
1.2095 + return candidate;
1.2096 + }
1.2097 + }
1.2098 +
1.2099 + return NULL;
1.2100 + }
1.2101 +
1.2102 +TInt CWsClient::RegisterSurface(const TWsClCmdUnion& pData)
1.2103 + {
1.2104 + TInt screenNumber = pData.SurfaceRegister->screenNumber;
1.2105 + if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())
1.2106 + {
1.2107 + PPanic(EWservPanicScreenNumber);
1.2108 + }
1.2109 + if (pData.SurfaceRegister->surfaceId.Type() == TSurfaceId::EScreenSurface
1.2110 + || pData.SurfaceRegister->surfaceId.IsNull())
1.2111 + {
1.2112 + PPanic(EWservPanicInvalidSurface);
1.2113 + }
1.2114 +
1.2115 + CRegisteredSurfaceMap* surfaceMap = CWsTop::Screen(screenNumber)->SurfaceMap();
1.2116 + const TSurfaceId& surfaceId = pData.SurfaceRegister->surfaceId;
1.2117 + TInt err = surfaceMap->Add(*this,surfaceId);
1.2118 +
1.2119 + switch(err)
1.2120 + {
1.2121 + case KErrNone:
1.2122 + case KErrNoMemory:
1.2123 + case KErrInUse:
1.2124 + case KErrArgument:
1.2125 + break;
1.2126 + default:
1.2127 + PPanic(EWservPanicInvalidSurface);
1.2128 + }
1.2129 + return err;
1.2130 + }
1.2131 +
1.2132 +void CWsClient::UnregisterSurface(const TWsClCmdUnion& pData)
1.2133 + {
1.2134 + TInt screenNumber = pData.SurfaceRegister->screenNumber;
1.2135 + if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())
1.2136 + {
1.2137 + PPanic(EWservPanicScreenNumber);
1.2138 + }
1.2139 + TInt err = CWsTop::Screen(screenNumber)->SurfaceMap()->Remove(*this,pData.SurfaceRegister->surfaceId);
1.2140 + WS_ASSERT_DEBUG((err==KErrNone||err==KErrNotFound), EWsPanicSurfaceMapError);
1.2141 + }
1.2142 +
1.2143 +void CWsClient::CreateDrawableSourceL(const TWsClCmdCreateDrawableSource& aDrawableSourceData)
1.2144 + {
1.2145 + CWsDrawableSource* drawableSource = new(ELeave) CWsDrawableSource(this);
1.2146 + CleanupStack::PushL(drawableSource);
1.2147 + drawableSource->ConstructL(aDrawableSourceData);
1.2148 + CleanupStack::Pop();
1.2149 + }
1.2150 +
1.2151 +void CWsClient::IndicateAppOrientation(TRenderOrientation aOrientation)
1.2152 + {
1.2153 + iIndicatedAppOrientation = aOrientation;
1.2154 + CWsTop::CheckRenderOrientation();
1.2155 + }
1.2156 +
1.2157 +TInt CWsClient::GetIndicatedAppOrientation()
1.2158 + {
1.2159 + return iIndicatedAppOrientation;
1.2160 + }
1.2161 +
1.2162 +//
1.2163 +// class CWsCliObj
1.2164 +//
1.2165 +
1.2166 +CWsCliObj* CWsCliObj::NewL(CWsClient* aOwner)
1.2167 + {
1.2168 + CWsCliObj* self = new(ELeave) CWsCliObj(aOwner);
1.2169 + CleanupStack::PushL(self);
1.2170 + self->ConstructL();
1.2171 + CleanupStack::Pop(self);
1.2172 + return self;
1.2173 + }
1.2174 +
1.2175 +CWsCliObj::CWsCliObj(CWsClient *aOwner) :
1.2176 + CWsObject(aOwner, WS_HANDLE_CLIENT)
1.2177 + {
1.2178 + }
1.2179 +
1.2180 +void CWsCliObj::ConstructL()
1.2181 + {
1.2182 + NewObjL();
1.2183 + }
1.2184 +
1.2185 +void CWsCliObj::CommandL(TInt aOpcode, const TAny* aCmdData) // (step #5)
1.2186 + {
1.2187 + iWsOwner->ExecuteCommandL(aOpcode,aCmdData); // (call #6)
1.2188 + }
1.2189 +
1.2190 +CWsObject* CWsClient::HandleToObjUntyped(TInt aHandle)
1.2191 + {
1.2192 + return iObjectIndex->HandleToObject(aHandle);
1.2193 + }
1.2194 +
1.2195 +const CWsObject* CWsClient::HandleToObjUntyped(TInt aHandle) const
1.2196 + {
1.2197 + return const_cast<CWsClient*>(this)->HandleToObjUntyped(aHandle);
1.2198 + }
1.2199 +
1.2200 +CWsObject* CWsClient::HandleToObj(TInt aHandle, WH_HANDLES aType)
1.2201 + {
1.2202 + CWsObject* object = HandleToObjUntyped(aHandle);
1.2203 + return (object && object->Type() == aType) ? object : NULL;
1.2204 + }
1.2205 +
1.2206 +
1.2207 +const CWsObject* CWsClient::HandleToObj(TInt aHandle, WH_HANDLES aType) const
1.2208 + {
1.2209 + return const_cast<CWsClient*>(this)->HandleToObj(aHandle, aType);
1.2210 + }
1.2211 +
1.2212 +void CWsClient::SetRetryFlag(TEventCode aEventCode)
1.2213 + {
1.2214 + switch(aEventCode)
1.2215 + {
1.2216 + //To be expanded
1.2217 + case EEventDisplayChanged:
1.2218 + {
1.2219 + iInternalFlags |= ERetryDisplayEvent;
1.2220 + }
1.2221 + break;
1.2222 +
1.2223 + }
1.2224 + }
1.2225 +TBool CWsClient::RetryEvent(TEventCode aEventCode)
1.2226 + {
1.2227 + switch(aEventCode)
1.2228 + {//To be expanded
1.2229 + case EEventDisplayChanged:
1.2230 + {
1.2231 + return (iInternalFlags & ERetryDisplayEvent);
1.2232 + }
1.2233 + }
1.2234 + return EFalse;
1.2235 + }
1.2236 +
1.2237 +void CWsClient::RemoveRetryFlag(TEventCode aEventCode)
1.2238 + {
1.2239 + switch(aEventCode)
1.2240 + {//To be expanded
1.2241 + case EEventDisplayChanged:
1.2242 + {
1.2243 + iInternalFlags &= ~ERetryDisplayEvent;
1.2244 + }
1.2245 + break;
1.2246 + }
1.2247 + }
1.2248 +