1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/graphics/windowing/windowserver/nga/SERVER/openwfc/GROUPWIN.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1605 @@
1.4 +// Copyright (c) 1995-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 +// Group window sub-class of CWsWindow
1.18 +//
1.19 +//
1.20 +
1.21 +#include <e32std.h>
1.22 +#include "W32STD.H"
1.23 +#include "W32CLICK.H"
1.24 +#include "server.h"
1.25 +#include "rootwin.h"
1.26 +#include "windowgroup.h"
1.27 +#include "walkwindowtree.h"
1.28 +#include "wstop.h"
1.29 +#include "EVENT.H"
1.30 +#include "KEYCLICK.H"
1.31 +#include "PRIKEY.H"
1.32 +#include "panics.h"
1.33 +#include "windowelementset.h"
1.34 +#include "pointer.h"
1.35 +
1.36 +GLREF_D TPtr nullDescriptor;
1.37 +GLREF_D CDebugLogBase* wsDebugLog;
1.38 +
1.39 +#if defined(_DEBUG)
1.40 +TInt CWsWindowGroup::iSkipCount=0;
1.41 +#endif
1.42 +
1.43 +TBool CWsWindowGroup::iEventQueueTest=EFalse; // For stress testing the EventQueue code
1.44 +
1.45 +TInt CWsWindowGroup::iIdentifierCount=1;
1.46 +TBool CWsWindowGroup::iFocusGainPreProcess=EFalse; //'REMOVEFADINGONFOCUSGAIN' flag in INI file
1.47 +RPointerArray< TDblQue<CWsWindowGroup> > CWsWindowGroup::iChains(3);
1.48 +static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);
1.49 +static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);
1.50 +const TInt KArrayMaxGranularity=0x10000000;
1.51 +
1.52 +CWsWindowGroup* CWsWindowGroup::NewL(CWsClient* aOwner, CScreen* aScreen,
1.53 + const TWsClCmdCreateWindowGroup& aCmd)
1.54 + {
1.55 + CWsWindowGroup* self = new(ELeave) CWsWindowGroup(aOwner, aScreen);
1.56 + CleanupStack::PushL(self);
1.57 + self->ConstructL(aCmd);
1.58 + CleanupStack::Pop(self);
1.59 + return self;
1.60 + }
1.61 +
1.62 +CWsWindowGroup::CWsWindowGroup(CWsClient* aOwner, CScreen* aScreen) : CWsWindowBase(aOwner,WS_HANDLE_GROUP_WINDOW,aScreen)
1.63 + {
1.64 + __DECLARE_NAME(_S("CWsWindowGroup"));
1.65 + iWinType=EWinTypeGroup;
1.66 + }
1.67 +
1.68 +void CWsWindowGroup::PurgeCapturedKeys()
1.69 + {
1.70 + CWsObjectIx& objix=*WsOwner()->ObjectIndex();
1.71 + const TWsObject* ptr=objix.FirstObject();
1.72 + const TWsObject* end=ptr+objix.Length();
1.73 + while(++ptr<end) //Fisrt one should always have a NULL object
1.74 + {
1.75 + const CWsObject* obj=ptr->iObject;
1.76 + if (obj
1.77 + && ((obj->Type()==WS_HANDLE_CAPTURE_KEY && STATIC_CAST(const CWsCaptureKey*,obj)->WindowGroup()==this)
1.78 + || (obj->Type()==WS_HANDLE_CAPTURE_KEY_UPDOWNS && STATIC_CAST(const CWsCaptureKeyUpsAndDowns*,obj)->WindowGroup()==this)
1.79 + || (obj->Type()==WS_HANDLE_CAPTURE_LONG_KEY && STATIC_CAST(const CWsCaptureLongKey*,obj)->WindowGroup()==this)))
1.80 + {
1.81 + objix.Remove(ptr);
1.82 + delete obj;
1.83 + }
1.84 + }
1.85 + objix.Tidy();
1.86 + CKeyboardRepeat::CancelRepeat(this);
1.87 + }
1.88 +
1.89 +void CWsWindowGroup::SwitchToOwningWindow(CWsWindowGroup *aClosingWindow)
1.90 + {
1.91 + if (this==CWsTop::FocusWindowGroup())
1.92 + {
1.93 + CWsWindowGroup *winGroup=NULL;
1.94 +//
1.95 +// First try for an 'owning' window
1.96 +//
1.97 + if (iOwningWindowGroup)
1.98 + {
1.99 + for(winGroup=RootWindow()->Child();winGroup;winGroup=winGroup->NextSibling())
1.100 + if (winGroup->Identifier()==iOwningWindowGroup && winGroup->iOrdinalPriority==iOrdinalPriority)
1.101 + goto gotIt;
1.102 + }
1.103 +//
1.104 +// If that failed look for the frontmost window belonging to the owner of dying window
1.105 +//
1.106 + for(winGroup=RootWindow()->Child();winGroup;winGroup=winGroup->NextSibling())
1.107 + if (winGroup!=this && winGroup->WsOwner()==WsOwner() && winGroup->iOrdinalPriority==iOrdinalPriority)
1.108 + goto gotIt;
1.109 +//
1.110 +// Next try for the nominated default owning window group
1.111 +//
1.112 + winGroup=iScreen->DefaultOwningWindowGroup();
1.113 + if (winGroup && winGroup->iOrdinalPriority==iOrdinalPriority)
1.114 + {
1.115 +gotIt: winGroup->SetOrdinalPosition(0,this);
1.116 + return;
1.117 + }
1.118 + }
1.119 + ResetFocus(aClosingWindow);
1.120 + }
1.121 +
1.122 +CWsWindowGroup::~CWsWindowGroup()
1.123 + {
1.124 + MWsWindowTreeObserver* windowTreeObserver = NULL;
1.125 + if (Screen()&& iBaseWinFlags&EBaseWinNodeCreated)
1.126 + {
1.127 + windowTreeObserver = Screen()->WindowTreeObserver();
1.128 + if (windowTreeObserver)
1.129 + {
1.130 + if( iQueue && (iQueue->Last()!=this) )
1.131 + {
1.132 + //This node is part of chain, send notification unless this is the last node in the chain
1.133 + windowTreeObserver->WindowGroupChainBrokenAfter(*this);
1.134 + }
1.135 + windowTreeObserver->NodeReleased(*this);
1.136 + iBaseWinFlags &= ~EBaseWinNodeCreated;
1.137 + }
1.138 + }
1.139 + DisconnectFloatingSprites();
1.140 +
1.141 + if (wsDebugLog)
1.142 + {
1.143 + TLogMessageText buf;
1.144 + _LIT(KWSERVDebugLogGroupWindowId,"Destroying: RWindowGroup[0x%x,%d],Id=%d");
1.145 + buf.Format(KWSERVDebugLogGroupWindowId,iClientHandle,LogHandle(),iIdentifier);
1.146 + wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, buf);
1.147 + }
1.148 + if (CClick::IsHandler())
1.149 + CClick::OtherEvent(EEventGroupWindowClose,reinterpret_cast<TAny*>(iIdentifier));
1.150 + if (iQueue)
1.151 + {
1.152 + if (iQueue->Last()!=this)
1.153 + { //Unlink all the children of the window that is being deleted
1.154 + TDblQueIter<CWsWindowGroup> iter(*iQueue);
1.155 + CWsWindowGroup* groupWin;
1.156 + iter.SetToLast();
1.157 + while ((groupWin=iter--)!=this)
1.158 + {
1.159 + WS_ASSERT_DEBUG(groupWin!=NULL && groupWin->iQueue==iQueue,EWsPanicGroupWindowChainError);
1.160 + if ( windowTreeObserver && (iQueue->Last()!=groupWin) )
1.161 + {
1.162 + //Send notification unless groupWin is the last node in the chain
1.163 + windowTreeObserver->WindowGroupChainBrokenAfter(*groupWin);
1.164 + }
1.165 + groupWin->iChainLink.Deque();
1.166 + // coverity[extend_simple_error]
1.167 + groupWin->iQueue=NULL;
1.168 + }
1.169 + }
1.170 + WS_ASSERT_DEBUG(iQueue->Last()==this,EWsPanicGroupWindowChainError);
1.171 + if(windowTreeObserver && !iQueue->IsEmpty())
1.172 + {
1.173 + //If there are chained nodes before this one, notify "chain broken" immediately before this node
1.174 + TDblQueIter<CWsWindowGroup> iter(*iQueue);
1.175 + iter.SetToLast(); //i.e. set to this (see assert above)
1.176 + iter--; //i.e. set to parent
1.177 + CWsWindowGroup* parent = iter;
1.178 + if(parent)
1.179 + {
1.180 + windowTreeObserver->WindowGroupChainBrokenAfter(*parent);
1.181 + }
1.182 + }
1.183 + TDblQueLinkBase* parentLink=iChainLink.iPrev;
1.184 + iChainLink.Deque();
1.185 + if (parentLink->iNext==parentLink->iPrev) //Check to see chain no longer required
1.186 + {
1.187 + if (!iQueue->IsEmpty())
1.188 + { //Only the parent is left in queue
1.189 + CWsWindowGroup* parent=iQueue->First();
1.190 + static_cast<TDblQueLink*>(parentLink)->Deque();
1.191 + WS_ASSERT_DEBUG(parent->iQueue==iQueue,EWsPanicGroupWindowChainError);
1.192 + // coverity[extend_simple_error]
1.193 + parent->iQueue=NULL;
1.194 + }
1.195 + DeleteQueue(iQueue);
1.196 + }
1.197 + }
1.198 + RemoveAllPriorityKeys();
1.199 + PurgeCapturedKeys();
1.200 + iTextCursor.Close();
1.201 + SetPointerCursor(NULL);
1.202 + for(CWsTopClientWindow *win=Child();win;win=win->NextSiblingTop())
1.203 + win->SetInactive();
1.204 + if (iScreen)
1.205 + {
1.206 + iScreen->RemoveFromDefaultOwningList(this);
1.207 + }
1.208 + CWsWindowBase::Shutdown();
1.209 + TWindowServerEvent::SendGroupChangedEvents();
1.210 + // coverity[extend_simple_error]
1.211 + iClientHandle=0; // To block focus lost events being sent
1.212 +// Decide which window to give focus to if WServ isn't shutting down
1.213 + if (iScreen && !CWsTop::ShuttingDown())
1.214 + SwitchToOwningWindow(this);
1.215 + delete iGroupName;
1.216 + delete iMessageArray;
1.217 + }
1.218 +
1.219 +void CWsWindowGroup::DisconnectFloatingSprites()
1.220 + {
1.221 + CWsSpriteBase * current = iSpriteList;
1.222 + while (current)
1.223 + {
1.224 + CWsSpriteBase * next = current->Next();
1.225 + current->Deactivate();
1.226 + current->DisconnectGroupWin();
1.227 + current = next;
1.228 + }
1.229 + }
1.230 +
1.231 +void CWsWindowGroup::DeleteQueue(TDblQue<CWsWindowGroup>* aQueue)
1.232 + {
1.233 + iChains.Remove(iChains.Find(aQueue));
1.234 + delete aQueue;
1.235 + if (iChains.Count()==0)
1.236 + {
1.237 + iChains.Compress();
1.238 + }
1.239 + }
1.240 +
1.241 +void CWsWindowGroup::AdvanceIdentifierCount()
1.242 + {
1.243 + if (++iIdentifierCount>EMaxIdentifierCount)
1.244 + iIdentifierCount=1; // so limit it to low value
1.245 + }
1.246 +
1.247 +void CWsWindowGroup::ConstructL(const TWsClCmdCreateWindowGroup &aCmd)
1.248 + {
1.249 +#if defined(_DEBUG)
1.250 + if (IsClientHandleInUse(aCmd.clientHandle))
1.251 + {
1.252 + OwnerPanic(EWservPanicDuplicateHandle);
1.253 + }
1.254 +#endif
1.255 + NewObjL();
1.256 + iFlags=EGroupFlagAutoForeground|EGroupFlagMsgQueueNew;
1.257 + if (aCmd.focus)
1.258 + {
1.259 + iFlags|=EGroupFlagReceivesFocus;
1.260 + }
1.261 + iTextCursor.ConstructL(this);
1.262 + iClientHandle=aCmd.clientHandle;
1.263 +
1.264 + if(aCmd.screenDeviceHandle <= 0)
1.265 + {
1.266 + //Use primary screen. Client should make sure PrimaryScreenDevice is correct set up immediately after establishing session.
1.267 + iScreenDevice=iWsOwner->PrimaryScreenDevice();
1.268 + }
1.269 + else
1.270 + {
1.271 + //Use the specified screen
1.272 + iScreenDevice=STATIC_CAST(DWsScreenDevice*,iWsOwner->HandleToObj(aCmd.screenDeviceHandle,WS_HANDLE_SCREEN_DEVICE));
1.273 + }
1.274 +
1.275 + iScreen = (iScreenDevice) ? iScreenDevice->Screen() : CWsTop::Screen(); //if no screen device use screen 0
1.276 +
1.277 + CWsWindowGroup* parent=NULL;
1.278 + if (aCmd.parentId>0)
1.279 + {
1.280 + parent=CWsWindowGroup::WindowGroupFromIdentifier(aCmd.parentId);
1.281 + if (!parent)
1.282 + {
1.283 + OwnerPanic(EWservPanicWindow);
1.284 + }
1.285 +
1.286 + if(parent->Screen() != iScreen)
1.287 + {
1.288 + OwnerPanic(EWservPanicWrongScreen);
1.289 + }
1.290 +
1.291 + if (parent->iOrdinalPriorityAdjust>0)
1.292 + {
1.293 + WS_ASSERT_DEBUG(parent->iQueue==NULL,EWsPanicGroupWindowChainError);
1.294 + parent->iOrdinalPriorityAdjust=0;
1.295 + parent->UpdateOrdinalPriority(ETrue);
1.296 + }
1.297 + iOrdinalPriorityBase=parent->iOrdinalPriorityBase;
1.298 + iOrdinalPriority=iOrdinalPriorityBase;
1.299 + }
1.300 +
1.301 + do
1.302 + {
1.303 + AdvanceIdentifierCount(); // Always advance by at least one to stop re-using last id
1.304 + } while (WindowGroupFromIdentifier(iIdentifierCount)); // If current count is in use try again
1.305 + iIdentifier=iIdentifierCount;
1.306 +
1.307 + CWsWindowBase::ConstructL(RootWindow());
1.308 + iScreen->ResetFocus(NULL);
1.309 +
1.310 + if (parent)
1.311 + {
1.312 + TDblQue<CWsWindowGroup>* queue=parent->iQueue;
1.313 + if (queue && queue->Last()!=parent)
1.314 + User::Leave(KErrInUse);
1.315 + if (parent->iWsOwner!=iWsOwner)
1.316 + {
1.317 + _LIT_SECURITY_POLICY_S0(securityPolicy,parent->iChildSID);
1.318 + if (!securityPolicy().CheckPolicy(iWsOwner->ClientMessage()))
1.319 + User::Leave(KErrPermissionDenied);
1.320 + }
1.321 + if (!queue)
1.322 + {
1.323 + queue=new(ELeave) TDblQue<CWsWindowGroup>(_FOFF(CWsWindowGroup,iChainLink));
1.324 + CleanupStack::PushL(queue);
1.325 + User::LeaveIfError(iChains.Append(queue));
1.326 + CleanupStack::Pop(queue);
1.327 + queue->AddFirst(*parent);
1.328 + parent->iQueue=queue;
1.329 + }
1.330 + iQueue=queue; //Shouldn't set the queue until after it can leave
1.331 + iChainLink.Enque(&parent->iChainLink);
1.332 +
1.333 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.334 + if (windowTreeObserver)
1.335 + {
1.336 + windowTreeObserver->WindowGroupChained(*parent, *this);
1.337 + }
1.338 + }
1.339 + iMessageArray=new(ELeave) CArrayVarSeg<TWsMessage>(1);
1.340 + if (CClick::IsHandler())
1.341 + {
1.342 + TGroupWindowOpenData params;
1.343 + params.iIdentifier=iIdentifier;
1.344 + params.iClient=iWsOwner->ConnectionHandle();
1.345 + params.iNumClientWindowGroups=NumClientWindowGroups()-1; //Don't include this one
1.346 + CClick::OtherEvent(EEventGroupWindowOpen,¶ms);
1.347 + }
1.348 + if (wsDebugLog)
1.349 + {
1.350 + TLogMessageText buf;
1.351 + _LIT(KWSERVDebugLogGroupWindowId,"Creating: RWindowGroup[0x%x,%d],Id=%d");
1.352 + buf.Format(KWSERVDebugLogGroupWindowId,iClientHandle,LogHandle(),iIdentifier);
1.353 + wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, buf);
1.354 + }
1.355 + }
1.356 +
1.357 +void CWsWindowGroup::UpdateOrdinalPriority(TBool aDoAdjust)
1.358 + {
1.359 + TInt newPri;
1.360 + newPri=iOrdinalPriorityBase;
1.361 + if (iWsOwner==CWsTop::FocusWindowGroupOwner())
1.362 + newPri+=iOrdinalPriorityAdjust;
1.363 + CheckCapability(newPri);
1.364 + if (newPri!=iOrdinalPriority)
1.365 + {
1.366 + iOrdinalPriority=newPri;
1.367 + if (aDoAdjust)
1.368 + SetOrdinalPosition(0);
1.369 + }
1.370 + }
1.371 +
1.372 +void CWsWindowGroup::SetOrdinalPriority(TInt aPos,TInt aPriority)
1.373 + {
1.374 + if (!iQueue)
1.375 + {
1.376 + iOrdinalPriorityBase=aPriority;
1.377 + UpdateOrdinalPriority(EFalse);
1.378 + }
1.379 + else
1.380 + {
1.381 + TDblQueIter<CWsWindowGroup> iter(*iQueue);
1.382 + CWsWindowGroup* group;
1.383 + while ((group=iter++)!=NULL)
1.384 + {
1.385 + group->iOrdinalPriorityBase=aPriority;
1.386 + group->iOrdinalPriority=aPriority;
1.387 + }
1.388 + }
1.389 + SetOrdinalPosition(aPos);
1.390 + }
1.391 +
1.392 +void CWsWindowGroup::CommandL(TInt aOpcode, const TAny *aCmdData)
1.393 + {
1.394 +#ifdef _DEBUG
1.395 + // Save root window for performing CheckTree at the end of this func.
1.396 + // When aOpcode is EWsWinOpFree, this object would've been destroyed
1.397 + // and a call to RootWindow() in that case would be impossible
1.398 + CWsRootWindow* rootWindow=RootWindow();
1.399 +
1.400 + // For certain opcodes, check for the 'screen device deleted' condition. If it
1.401 + // has occured for the screen device associated with this group window then
1.402 + // those op-codes are not valid, and the client is panicked.
1.403 + switch (aOpcode)
1.404 + {
1.405 + case EWsWinOpEnableScreenChangeEvents:
1.406 + case EWsWinOpAllowChildWindowGroup:
1.407 + case EWsWinOpReceiveFocus:
1.408 + case EWsWinOpAutoForeground:
1.409 + case EWsWinOpSetOrdinalPositionPri:
1.410 + case EWsWinOpSetOrdinalPriorityAdjust:
1.411 + case EWsWinOpCaptureKey:
1.412 + case EWsWinOpCaptureKeyUpsAndDowns:
1.413 + case EWsWinOpCaptureLongKey:
1.414 + case EWsWinOpAddPriorityKey:
1.415 + case EWsWinOpSetTextCursor:
1.416 + case EWsWinOpSetTextCursorClipped:
1.417 + case EWsWinOpSetOwningWindowGroup:
1.418 + case EWsWinOpDefaultOwningWindow:
1.419 + case EWsWinOpSetName:
1.420 + case EWsWinOpDisableKeyClick:
1.421 + case EWsWinOpSendPointerEvent:
1.422 + case EWsWinOpSendAdvancedPointerEvent:
1.423 + {
1.424 + if (ScreenDeviceDeleted())
1.425 + OwnerPanic(EWservPanicGroupWinScreenDeviceDeleted);
1.426 + break;
1.427 + };
1.428 + }
1.429 +#endif
1.430 +
1.431 + TWsWinCmdUnion pData;
1.432 + pData.any=aCmdData;
1.433 + if (CWsWindowBase::CommandL(aOpcode,pData)==EFalse)
1.434 + {
1.435 + switch(aOpcode)
1.436 + {
1.437 + case EWsWinOpAllowChildWindowGroup:
1.438 + iChildSID=*pData.UInt;
1.439 + break;
1.440 + case EWsWinOpEnableScreenChangeEvents:
1.441 + SetScreenChangeEventStateL(ETrue);
1.442 + break;
1.443 + case EWsWinOpDisableScreenChangeEvents:
1.444 + SetScreenChangeEventStateL(EFalse);
1.445 + break;
1.446 + case EWsWinOpReceiveFocus:
1.447 + if (*pData.Bool!=(iFlags&EGroupFlagReceivesFocus))
1.448 + {
1.449 + iFlags&=~EGroupFlagReceivesFocus;
1.450 + if (*pData.Bool)
1.451 + iFlags|=EGroupFlagReceivesFocus;
1.452 + iScreen->ResetFocus(NULL);
1.453 + }
1.454 + break;
1.455 + case EWsWinOpAutoForeground:
1.456 + iFlags&=~EGroupFlagAutoForeground;
1.457 + if (*pData.Bool)
1.458 + iFlags|=EGroupFlagAutoForeground;
1.459 + break;
1.460 + case EWsWinOpSetOrdinalPositionPri:
1.461 + case EWsWinOpSetOrdinalPositionErr:
1.462 + {
1.463 + TInt priority=pData.OrdinalPos->ordinalPriority;
1.464 + TBool hascap = CheckCapability(priority);
1.465 + SetOrdinalPriority(pData.OrdinalPos->pos, priority);
1.466 + if (aOpcode == EWsWinOpSetOrdinalPositionErr)
1.467 + {
1.468 + SetReply(hascap?KErrNone:KErrPermissionDenied);
1.469 + }
1.470 + }
1.471 + break;
1.472 + case EWsWinOpSetOrdinalPriorityAdjust:
1.473 + if (!iQueue)
1.474 + {
1.475 + iOrdinalPriorityAdjust=*pData.Int;
1.476 + UpdateOrdinalPriority(ETrue);
1.477 + }
1.478 + break;
1.479 + case EWsWinOpCaptureKey:
1.480 + {
1.481 + if(!KSecurityPolicy_SwEvent().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::CaptureKey API")))
1.482 + {
1.483 + User::Leave(KErrPermissionDenied);
1.484 + }
1.485 + CWsCaptureKey *cKey=new(ELeave) CWsCaptureKey(this);
1.486 + CleanupStack::PushL(cKey);
1.487 + cKey->ConstructL(*pData.CaptureKey);
1.488 + CleanupStack::Pop();
1.489 + }
1.490 + break;
1.491 + case EWsWinOpCaptureKeyUpsAndDowns:
1.492 + {
1.493 + if(!KSecurityPolicy_SwEvent().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::CaptureKeyUpsAndDowns API")))
1.494 + {
1.495 + User::Leave(KErrPermissionDenied);
1.496 + }
1.497 + CWsCaptureKeyUpsAndDowns *cKey=new(ELeave) CWsCaptureKeyUpsAndDowns(this);
1.498 + CleanupStack::PushL(cKey);
1.499 + cKey->ConstructL(*pData.CaptureKey);
1.500 + CleanupStack::Pop();
1.501 + }
1.502 + break;
1.503 + case EWsWinOpCaptureLongKey:
1.504 + {
1.505 + if(!KSecurityPolicy_SwEvent().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::CaptureLongKey API")))
1.506 + {
1.507 + User::Leave(KErrPermissionDenied);
1.508 + }
1.509 + CWsCaptureLongKey *cKey=new(ELeave) CWsCaptureLongKey(this);
1.510 + CleanupStack::PushL(cKey);
1.511 + cKey->ConstructL(*pData.CaptureLongKey);
1.512 + CleanupStack::Pop();
1.513 + }
1.514 + break;
1.515 + case EWsWinOpCancelCaptureKey:
1.516 + if (*pData.UInt!=0) // Ignore null handle
1.517 + {
1.518 + CWsObject *destroyObj = iWsOwner->HandleToObj(*pData.UInt, WS_HANDLE_CAPTURE_KEY);
1.519 + if (destroyObj)
1.520 + {
1.521 + // Cancel any repeat that is underway for this capture
1.522 + CKeyboardRepeat::CancelRepeat(destroyObj, EFalse);
1.523 + delete destroyObj;
1.524 + }
1.525 + else
1.526 + {
1.527 +#ifdef _DEBUG
1.528 + // Attempt to cancel key capture with an incorrect handle
1.529 + OwnerPanic(EWservPanicDestroy);
1.530 +#endif // _DEBUG
1.531 + }
1.532 + }
1.533 + break;
1.534 + case EWsWinOpCancelCaptureKeyUpsAndDowns:
1.535 + if (*pData.UInt!=0) // Ignore null handle
1.536 + {
1.537 + CWsObject *destroyObj = iWsOwner->HandleToObj(*pData.UInt, WS_HANDLE_CAPTURE_KEY_UPDOWNS);
1.538 + if (destroyObj)
1.539 + {
1.540 + delete destroyObj;
1.541 + }
1.542 + else
1.543 + {
1.544 +#ifdef _DEBUG
1.545 + // Attempt to cancel ups and downs key capture with an incorrect handle
1.546 + OwnerPanic(EWservPanicDestroy);
1.547 +#endif // _DEBUG
1.548 + }
1.549 + }
1.550 + break;
1.551 + case EWsWinOpCancelCaptureLongKey:
1.552 + if (*pData.UInt!=0) // Ignore null handle
1.553 + {
1.554 + CWsObject *destroyObj = iWsOwner->HandleToObj(*pData.UInt, WS_HANDLE_CAPTURE_LONG_KEY);
1.555 + if (destroyObj)
1.556 + {
1.557 + // Cancel any repeat that is underway for this capture
1.558 + CKeyboardRepeat::CancelRepeat(destroyObj, ETrue);
1.559 + delete destroyObj;
1.560 + }
1.561 + else
1.562 + {
1.563 +#ifdef _DEBUG
1.564 + // Attempt to cancel long key capture with an incorrect handle
1.565 + OwnerPanic(EWservPanicDestroy);
1.566 +#endif // _DEBUG
1.567 + }
1.568 + }
1.569 + break;
1.570 + case EWsWinOpAddPriorityKey:
1.571 + AddPriorityKeyL(pData.PriorityKey->keycode, pData.PriorityKey->modifierMask, pData.PriorityKey->modifiers);
1.572 + break;
1.573 + case EWsWinOpRemovePriorityKey:
1.574 + RemovePriorityKey(pData.PriorityKey->keycode, pData.PriorityKey->modifierMask, pData.PriorityKey->modifiers);
1.575 + break;
1.576 + case EWsWinOpSetTextCursor:
1.577 + iTextCursor.SetL(*pData.SetTextCursor, EFalse);
1.578 + break;
1.579 + case EWsWinOpSetTextCursorClipped:
1.580 + iTextCursor.SetL(*pData.SetTextCursor, ETrue);
1.581 + break;
1.582 + case EWsWinOpCancelTextCursor:
1.583 + iTextCursor.Cancel();
1.584 + break;
1.585 + case EWsWinOpSetOwningWindowGroup:
1.586 + iOwningWindowGroup=*pData.Int;
1.587 + break;
1.588 + case EWsWinOpDefaultOwningWindow:
1.589 + {
1.590 + if(KSecurityPolicy_WriteDeviceData().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::DefaultOwningWindow API")))
1.591 + {
1.592 + iScreen->SetDefaultOwningWindow(this);
1.593 + }
1.594 + }
1.595 + break;
1.596 + case EWsWinOpName:
1.597 + iWsOwner->ReplyGroupName(iGroupName,*pData.Int);
1.598 + break;
1.599 + case EWsWinOpSetName:
1.600 + {
1.601 + HBufC *newName=NULL;
1.602 + const TInt size=*pData.Int;
1.603 + if (size>0)
1.604 + {
1.605 + newName=HBufC::NewLC(size);
1.606 + TPtr ptr(newName->Des());
1.607 + iWsOwner->RemoteReadL(ptr,0);
1.608 + CleanupStack::Pop(newName);
1.609 + }
1.610 + //Window Group Name is unchanged
1.611 + if (iGroupName && newName && *iGroupName == *newName)
1.612 + {
1.613 + delete newName;
1.614 + }
1.615 + else //Window Group Name is changed
1.616 + {
1.617 + delete iGroupName;
1.618 + iGroupName=newName;
1.619 + TWindowServerEvent::SendGroupChangedEvents();
1.620 + if (iScreen && iScreen->ChangeTracking())
1.621 + {
1.622 + MWsWindowTreeObserver* const windowTreeObserver = iScreen->WindowTreeObserver();
1.623 + if (windowTreeObserver)
1.624 + windowTreeObserver->AttributeChanged(*this, MWsWindowTreeObserver::EWindowGroupName);
1.625 + }
1.626 + }
1.627 + }
1.628 + break;
1.629 + case EWsWinOpIdentifier:
1.630 + SetReply(Identifier());
1.631 + break;
1.632 + case EWsWinOpDisableKeyClick:
1.633 + if (*pData.Bool)
1.634 + iFlags|=EGroupFlagDisableKeyClick;
1.635 + else
1.636 + iFlags&=~EGroupFlagDisableKeyClick;
1.637 + if (this==CWsTop::FocusWindowGroup())
1.638 + UpdateKeyClickState();
1.639 + break;
1.640 + case EWsWinOpSendAdvancedPointerEvent:
1.641 + case EWsWinOpSendPointerEvent:
1.642 + {
1.643 + TRawEvent eventCopy = *pData.RawEvent;
1.644 + if (TWsPointer::PreProcessClientEvent(eventCopy, aOpcode == EWsWinOpSendAdvancedPointerEvent))
1.645 + {
1.646 + if (!TWindowServerEvent::MousePress(eventCopy,this))
1.647 + {
1.648 + OwnerPanic(EWservPanicEventType);
1.649 + }
1.650 + }
1.651 + }
1.652 + break;
1.653 + case EWsWinOpClearChildGroup:
1.654 + if(iQueue)
1.655 + {
1.656 + TBool fBefore=EFalse;
1.657 + TBool fAfter=EFalse;
1.658 + // If there is nothing to clear, return KErrArgument
1.659 + if(iQueue->Last()==this)
1.660 + {
1.661 + SetReply(KErrArgument);
1.662 + break;
1.663 + }
1.664 + // fBefore is True if there is AT LEAST one window group queued before the current one
1.665 + else if(iQueue->First()!=this)
1.666 + {
1.667 + fBefore=ETrue;
1.668 + }
1.669 + // fAfter is True if there is MORE THAN one window group queued after the current one
1.670 + TDblQueIter<CWsWindowGroup> iter(*iQueue);
1.671 + iter.SetToLast();
1.672 + if(iter--!=this && iter!=this)
1.673 + {
1.674 + fAfter=ETrue;
1.675 + }
1.676 + TDblQue<CWsWindowGroup>* queue=NULL;
1.677 + // if fBefore and fAfter are True, create a new queue and copy all window groups after the current one into that queue
1.678 + if(fBefore && fAfter)
1.679 + {
1.680 + TInt ret=KErrNoMemory;
1.681 + queue=new TDblQue<CWsWindowGroup>(_FOFF(CWsWindowGroup,iChainLink));
1.682 + if(queue)
1.683 + {
1.684 + ret=iChains.Append(queue);
1.685 + if(ret!=KErrNone)
1.686 + {
1.687 + delete queue;
1.688 + queue=NULL;
1.689 + }
1.690 + }
1.691 + // Check that the queue creation and appending worked (we deque all the child groups even if it didn't)
1.692 + if(ret!=KErrNone)
1.693 + {
1.694 + SetReply(ret);
1.695 + }
1.696 + }
1.697 + // If we've got zero or one window groups after, don't need to queue them
1.698 + if(!fAfter || fBefore)
1.699 + {
1.700 + iter.SetToLast();
1.701 + CWsWindowGroup* groupWin;
1.702 + while((groupWin=iter--)!=this)
1.703 + {
1.704 + groupWin->iChainLink.Deque();
1.705 + groupWin->iQueue=queue;
1.706 + if(queue)
1.707 + queue->AddFirst(*groupWin);
1.708 + }
1.709 + }
1.710 + // if we've got no window groups before, don't need to have a queue for this anymore
1.711 + if(!fBefore)
1.712 + {
1.713 + iChainLink.Deque();
1.714 + if (!fAfter)
1.715 + {
1.716 + DeleteQueue(iQueue);
1.717 + }
1.718 + iQueue=NULL;
1.719 + }
1.720 + if (Screen())
1.721 + {
1.722 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.723 + if (windowTreeObserver)
1.724 + {
1.725 + windowTreeObserver->WindowGroupChainBrokenAfter(*this);
1.726 + }
1.727 + }
1.728 + }
1.729 + else // if this window group isn't queued, we can't clear any children
1.730 + {
1.731 + SetReply(KErrArgument);
1.732 + }
1.733 + break;
1.734 + case EWsWinOpSetChildGroup:
1.735 + {
1.736 + CWsWindowGroup* childWinGroup = CWsWindowGroup::WindowGroupFromIdentifier(*pData.Int);
1.737 + if(!childWinGroup //(no child to append)
1.738 + || (iQueue && (!iQueue->IsLast(this) || (childWinGroup->iQueue==iQueue))) //(GpWin has a child) || (GpWin and childGpWin in the same queue)
1.739 + || (childWinGroup->iQueue && !childWinGroup->iQueue->IsFirst(childWinGroup)) //(childGpWin has a parent)
1.740 + || (childWinGroup == this)) //(childGpWin == GpWin)
1.741 + {
1.742 + SetReply(KErrArgument);
1.743 + break;
1.744 + }
1.745 + if(iQueue)
1.746 + // If we have a chain, we're prepending ourselves to the child window group
1.747 + // So we take the childs chain and prepend each of the window groups in our own chain
1.748 + // beginning with the current window group and working backward
1.749 + {
1.750 + TDblQueIter<CWsWindowGroup> iter(*iQueue);
1.751 + iter.SetToLast();
1.752 + CWsWindowGroup* groupWin;
1.753 + if(childWinGroup->iQueue)
1.754 + {
1.755 + TDblQue<CWsWindowGroup>* oldQueue=iQueue;
1.756 + while((groupWin=iter--)!=NULL)
1.757 + {
1.758 + groupWin->iChainLink.Deque();
1.759 + childWinGroup->iQueue->AddFirst(*groupWin);
1.760 + groupWin->iQueue=childWinGroup->iQueue;
1.761 + }
1.762 + DeleteQueue(oldQueue);
1.763 + }
1.764 + else
1.765 + {
1.766 + iQueue->AddLast(*childWinGroup);
1.767 + childWinGroup->iQueue=iQueue;
1.768 + }
1.769 + }
1.770 + else
1.771 + // 1. If we don't have a chain, and if the child has a chain, we can simply prepend this wg to the child
1.772 + // wg chain
1.773 + // 2. If we don't have a chain, and if the child does not have a chain, need to create a chain with the child
1.774 + // as the owning member, and prepend our window group
1.775 + {
1.776 + if(childWinGroup->iQueue)
1.777 + {
1.778 + childWinGroup->iQueue->AddFirst(*this);
1.779 + iQueue=childWinGroup->iQueue;
1.780 + }
1.781 + else
1.782 + {
1.783 + TDblQue<CWsWindowGroup>* queue=new TDblQue<CWsWindowGroup>(_FOFF(CWsWindowGroup,iChainLink));
1.784 + TInt ret=KErrNoMemory;
1.785 + if (queue)
1.786 + {
1.787 + ret=iChains.Append(queue);
1.788 + if(ret!=KErrNone)
1.789 + {
1.790 + delete queue;
1.791 + }
1.792 + }
1.793 + if(ret!=KErrNone)
1.794 + {
1.795 + SetReply(ret);
1.796 + break;
1.797 + }
1.798 + queue->AddFirst(*childWinGroup);
1.799 + childWinGroup->iQueue=queue;
1.800 + queue->AddFirst(*this);
1.801 + iQueue=queue;
1.802 + }
1.803 + }
1.804 + if (Screen())
1.805 + {
1.806 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.807 + if (windowTreeObserver)
1.808 + {
1.809 + windowTreeObserver->WindowGroupChained(*this, *childWinGroup);
1.810 + }
1.811 + }
1.812 + }
1.813 + break;
1.814 + default: // All other window commands disallowed
1.815 + OwnerPanic(EWservPanicOpcode);
1.816 + }
1.817 + }
1.818 +#if defined(_DEBUG)
1.819 + rootWindow->CheckTree();
1.820 +#endif
1.821 + }
1.822 +
1.823 +TPoint CWsWindowGroup::Origin() const
1.824 + {
1.825 + return TPoint(0,0);
1.826 + }
1.827 +
1.828 +TRect CWsWindowGroup::AbsRect() const
1.829 + {
1.830 + return (TRect(RootWindow()->Abs().iTl,RootWindow()->Size()));
1.831 + }
1.832 +
1.833 +TSize CWsWindowGroup::Size() const
1.834 + {
1.835 + return RootWindow()->Size();
1.836 + }
1.837 +
1.838 +void CWsWindowGroup::SendState(MWsWindowTreeObserver& aWindowTreeObserver) const
1.839 + {
1.840 + aWindowTreeObserver.NodeCreated(*this, ParentNode());
1.841 + }
1.842 +
1.843 +void CWsWindowGroup::SendStateWindowGroupChain(MWsWindowTreeObserver& aWindowTreeObserver) const
1.844 + {
1.845 + if ( iQueue && (!iQueue->IsEmpty()) && (iQueue->First()==this) )
1.846 + {
1.847 + TDblQueIter<CWsWindowGroup> iter(*iQueue);
1.848 + CWsWindowGroup* groupParent;
1.849 + CWsWindowGroup* groupChild;
1.850 +
1.851 + while ( (groupParent=iter++)!=NULL && (groupChild=iter)!=NULL )
1.852 + {
1.853 + aWindowTreeObserver.WindowGroupChained(*groupParent, *groupChild);
1.854 + }
1.855 + }
1.856 + }
1.857 +
1.858 +TInt CWsWindowGroup::Identifier() const
1.859 + {
1.860 + return iIdentifier;
1.861 + }
1.862 +
1.863 +TPtrC CWsWindowGroup::Name() const
1.864 + {
1.865 + return (iGroupName) ? *iGroupName : KNullDesC();
1.866 + }
1.867 +
1.868 +TBool CWsWindowGroup::IsFocusable() const
1.869 + {
1.870 + return ReceivesFocus();
1.871 + }
1.872 +
1.873 +TInt CWsWindowGroup::OrdinalPriority() const
1.874 + {
1.875 + return iOrdinalPriorityBase;
1.876 + }
1.877 +
1.878 +const MWsClient * CWsWindowGroup::Client() const
1.879 + {
1.880 + return static_cast<const MWsClient*>(WsOwner());
1.881 + }
1.882 +
1.883 +
1.884 +void CWsWindowGroup::UpdateKeyClickState()
1.885 + {
1.886 + CClick::SetKeyClickOveride(iFlags&EGroupFlagDisableKeyClick);
1.887 + }
1.888 +
1.889 +void CWsWindowGroup::AreaCovered(TRegion &aRegion)
1.890 + {
1.891 + aRegion.Clear();
1.892 + for(CWsClientWindow *win=Child();win;win=win->NextSibling())
1.893 + aRegion.Union(*win->BaseArea());
1.894 + }
1.895 +
1.896 +void CWsWindowGroup::SetOrdinalPosition(TInt aPos)
1.897 + {
1.898 + if (aPos==(TInt)KOrdinalPositionSwitchToOwningWindow)
1.899 + SwitchToOwningWindow(NULL);
1.900 + else
1.901 + SetOrdinalPosition(aPos,NULL);
1.902 + }
1.903 +
1.904 +TBool CWsWindowGroup::SetOrdinalPosition(TInt aPos,CWsWindowGroup* aClosingWindow)
1.905 + {
1.906 + TBool ret=ETrue;
1.907 +
1.908 + // Remember if the window group tree is actually changed or not, so that we know whether to
1.909 + // check the render orientation after the re-ordering is done ( see CWsTop::CheckRenderOrientation()
1.910 + // call at end of this method
1.911 + TBool changed = CheckOrdinalPositionChange(aPos);
1.912 +
1.913 + if (!iQueue)
1.914 + ret=DoSetOrdinalPosition1(aPos,aClosingWindow);
1.915 + else
1.916 + {
1.917 + TDblQueIter<CWsWindowGroup> iter(*iQueue);
1.918 + CWsWindowGroup* group;
1.919 + iter.SetToLast();
1.920 + TInt after=0;
1.921 + TInt before=0;
1.922 + TInt* inc=&before;
1.923 + while ((group=iter--)!=NULL)
1.924 + {
1.925 + if (group==this)
1.926 + inc=&after;
1.927 + ++(*inc);
1.928 + }
1.929 + TInt lastWinGpPos=NumWindowGroupsOnMyScreen(OrdinalPriority())-after;
1.930 + if (aPos<0)
1.931 + aPos=lastWinGpPos;
1.932 + else
1.933 + aPos=Min(aPos,lastWinGpPos);
1.934 + aPos-=before;
1.935 + aPos=Max(aPos,0);
1.936 + iter.SetToLast();
1.937 + CWsWindowGroup* firstForward=iter--;
1.938 + while (firstForward && firstForward->OrdinalPosition(EFalse)<aPos)
1.939 + {
1.940 + firstForward=iter--;
1.941 + ++aPos;
1.942 + }
1.943 + if (!firstForward)
1.944 + iter.SetToFirst();
1.945 + else
1.946 + {
1.947 + iter.Set(*firstForward);
1.948 + MoveChainedWindows(iter,ETrue,aPos,aClosingWindow);
1.949 + iter.Set(*firstForward);
1.950 + iter++;
1.951 + }
1.952 + MoveChainedWindows(iter,EFalse,--aPos,aClosingWindow);
1.953 +#if defined(_DEBUG)
1.954 + iter.SetToLast();
1.955 + TInt pos1=-1;
1.956 + TInt pos2;
1.957 + TBool ok=ETrue;
1.958 + while ((group=iter--)!=this)
1.959 + {
1.960 + pos2=group->OrdinalPosition(EFalse);
1.961 + if (pos2<=pos1)
1.962 + ok=EFalse;
1.963 + pos1=pos2;
1.964 + }
1.965 + WS_ASSERT_DEBUG(ok, EWsPanicGroupWindowChainError);
1.966 +#endif
1.967 + }
1.968 +
1.969 + // If the ordinal positions have changed, check to see if there is a new render orientation
1.970 + // and publish it if so
1.971 + if(changed)
1.972 + CWsTop::CheckRenderOrientation();
1.973 +
1.974 + return ret;
1.975 + }
1.976 +
1.977 +
1.978 +void CWsWindowGroup::MoveChainedWindows(TDblQueIter<CWsWindowGroup>& aIter,TBool aForward,TInt aPos,CWsWindowGroup* aClosingWindow)
1.979 + {
1.980 + CWsWindowGroup* groupWindow;
1.981 + while ((groupWindow=(aForward ? aIter-- : aIter++))!=NULL)
1.982 + {
1.983 + groupWindow->DoSetOrdinalPosition1(aPos,aClosingWindow);
1.984 + (aForward ? ++aPos : --aPos);
1.985 + }
1.986 + }
1.987 +
1.988 +TBool CWsWindowGroup::DoSetOrdinalPosition1(TInt aPos,CWsWindowGroup* aClosingWindow)
1.989 + {
1.990 + TBool ret=EFalse;
1.991 + if (CheckOrdinalPositionChange(aPos))
1.992 + {
1.993 + if (Child()) // A group window with no children can not affect shadows
1.994 + {
1.995 + ret=ETrue;
1.996 + }
1.997 + DoSetOrdinalPosition2(aPos,aClosingWindow);
1.998 + }
1.999 + else if (aClosingWindow) // do not reset focus if current groupwindow did not change its ordinal position
1.1000 + iScreen->ResetFocus(aClosingWindow);
1.1001 + return ret;
1.1002 + }
1.1003 +
1.1004 +void CWsWindowGroup::DoSetOrdinalPosition2(TInt aPos, CWsWindowGroup *aClosingWindow)
1.1005 + {
1.1006 + ChangeWindowPosition(aPos,iParent);
1.1007 + ResetFocus(aClosingWindow);
1.1008 + }
1.1009 +
1.1010 +void CWsWindowGroup::LostFocus()
1.1011 + {
1.1012 + iTextCursor.LostFocus();
1.1013 + iWsOwner->UpdateWindowOrdinalPrioritys();
1.1014 + if (iClientHandle!=0)
1.1015 + QueueEvent(EEventFocusLost);
1.1016 + TWalkWindowTreeFocusChanged wwt(EFalse);
1.1017 + WalkWindowTree(wwt,EWalkChildren);
1.1018 + iWsOwner->SetClientPriority();
1.1019 + }
1.1020 +
1.1021 +void CWsWindowGroup::ReceivedFocus()
1.1022 + {
1.1023 + iWsOwner->UpdateWindowOrdinalPrioritys();
1.1024 + iTextCursor.ReceivedFocus();
1.1025 + // Used for event queue testing
1.1026 + // Calling MoveToFront sets the queue of the focused window to first place,
1.1027 + // not doing so puts the queues in unusual situation thus stress testing the queue code.
1.1028 + // One such situation is where the focus queue is first but there is a gap before it (iEventPtr>iGlobalEventPtr)"
1.1029 +#if defined(_DEBUG)
1.1030 + if ((iEventQueueTest) && (++iSkipCount==5))
1.1031 + {
1.1032 + iSkipCount=0;
1.1033 + }
1.1034 + else
1.1035 + {
1.1036 + WsOwner()->EventQueue()->MoveToFront();
1.1037 + }
1.1038 +#else
1.1039 + WsOwner()->EventQueue()->MoveToFront();
1.1040 +#endif
1.1041 +
1.1042 + QueueEvent(EEventFocusGained);
1.1043 + TWalkWindowTreeFocusChanged wwt(ETrue);
1.1044 + WalkWindowTree(wwt,EWalkChildren);
1.1045 + iWsOwner->SetClientPriority();
1.1046 + UpdateKeyClickState();
1.1047 + }
1.1048 +
1.1049 +TInt CWsWindowGroup::NumWindowGroups(TBool aAllPriorities, TInt aPriority)
1.1050 + {
1.1051 + TInt count=0;
1.1052 + TInt screenNo;
1.1053 + for(screenNo=0;screenNo<CWsTop::NumberOfScreens();++screenNo)
1.1054 + {
1.1055 + count+=CWsWindowGroup::NumWindowGroupsOnScreen(CWsTop::Screen(screenNo)->RootWindow()->Child(),aAllPriorities,aPriority);
1.1056 + }
1.1057 + return(count);
1.1058 + }
1.1059 +
1.1060 +TInt CWsWindowGroup::NumWindowGroupsOnScreen(const CWsWindowGroup* aGroupWin,TBool aAllPriorities,TInt aPriority)
1.1061 + {
1.1062 + TInt count=0;
1.1063 + while (aGroupWin)
1.1064 + {
1.1065 + if (aAllPriorities || aGroupWin->iOrdinalPriority==aPriority)
1.1066 + ++count;
1.1067 + aGroupWin=aGroupWin->NextSibling();
1.1068 + }
1.1069 + return count;
1.1070 + }
1.1071 +
1.1072 +inline TInt CWsWindowGroup::NumWindowGroupsOnMyScreen(TInt aPriority)
1.1073 + {
1.1074 + return(CWsWindowGroup::NumWindowGroupsOnScreen(Parent()->Child(),EFalse,aPriority));
1.1075 + }
1.1076 +
1.1077 +void CWsWindowGroup::GetFocusWindowGroupL(TInt aScreenNumber)
1.1078 + {
1.1079 + CWsWindowGroup *groupWin=(aScreenNumber==KDummyScreenNumber)?CWsTop::FocusWindowGroup():CWsTop::Screen(aScreenNumber)->FocusWindowGroup();
1.1080 + if (!groupWin)
1.1081 + User::Leave(KErrGeneral);
1.1082 + CWsClient::SetReply(groupWin->Identifier());
1.1083 + }
1.1084 +
1.1085 +TInt CWsWindowGroup::GetWindowGroupListL(TInt aScreenNo,TBool aAllPriorities,TInt aPriority,TInt aCount,CArrayFixFlat<TInt>* aList)
1.1086 + {
1.1087 + TInt count=aList->Count();
1.1088 + CWsWindowGroup* groupWin=CWsTop::Screen(aScreenNo)->RootWindow()->Child();
1.1089 + while(!aAllPriorities && groupWin && groupWin->iOrdinalPriority!=aPriority)
1.1090 + groupWin=groupWin->NextSibling();
1.1091 + while(groupWin && (aAllPriorities || groupWin->iOrdinalPriority==aPriority) && count<aCount)
1.1092 + {
1.1093 + aList->AppendL(groupWin->Identifier());
1.1094 + ++count;
1.1095 + groupWin=groupWin->NextSibling();
1.1096 + }
1.1097 + return count;
1.1098 + }
1.1099 +
1.1100 +TInt CWsWindowGroup::SendWindowGroupListL(TInt aScreenNumber, TBool aAllPriorities, TInt aPriority, TInt aCount)
1.1101 + {
1.1102 + if ((aCount<1) || (aCount>(KArrayMaxGranularity/sizeof(TInt))))
1.1103 + User::Leave(KErrArgument);
1.1104 + CArrayFixFlat<TInt>* list=new(ELeave) CArrayFixFlat<TInt>(aCount);
1.1105 + CleanupStack::PushL(list);
1.1106 + TInt count(0);
1.1107 + TInt requestedScreen=aScreenNumber;
1.1108 + if(requestedScreen==KDummyScreenNumber)
1.1109 + {
1.1110 + // get list from current focus screen first
1.1111 + TInt focusScreenNo=CWsTop::CurrentFocusScreen()->ScreenNumber();
1.1112 + count=GetWindowGroupListL(focusScreenNo, aAllPriorities, aPriority, aCount, list);
1.1113 + if(count<aCount)
1.1114 + {
1.1115 + // now get from the remaining screen
1.1116 + TInt screenNo;
1.1117 + for(screenNo=0;screenNo<CWsTop::NumberOfScreens() && count<aCount;++screenNo)
1.1118 + {
1.1119 + // skip focus screen
1.1120 + if (screenNo==focusScreenNo)
1.1121 + continue;
1.1122 + // count hold total number of window groups collected so far
1.1123 + count=GetWindowGroupListL(screenNo, aAllPriorities, aPriority, aCount, list);
1.1124 + }
1.1125 + }
1.1126 + }
1.1127 + else
1.1128 + {
1.1129 + count=GetWindowGroupListL(requestedScreen, aAllPriorities, aPriority, aCount, list);
1.1130 + }
1.1131 + if (list->Count() > 0)
1.1132 + CWsClient::ReplyBuf(&list->At(0),count*sizeof(TInt));
1.1133 + CleanupStack::PopAndDestroy(list);
1.1134 + return(count); // How many actually returned, may be less than asked for, but not more
1.1135 + }
1.1136 +
1.1137 +void CWsWindowGroup::GetWindowGroupListAndChainL(TInt aScreen,TBool aAllPriorities,TInt aPriority
1.1138 + ,RArray<RWsSession::TWindowGroupChainInfo>& list,TInt& aCountLeft)
1.1139 + {
1.1140 + CWsWindowGroup *groupWin=CWsTop::Screen(aScreen)->RootWindow()->Child();
1.1141 + while(!aAllPriorities && groupWin && groupWin->iOrdinalPriority!=aPriority)
1.1142 + groupWin=groupWin->NextSibling();
1.1143 + while(groupWin && (aAllPriorities || groupWin->iOrdinalPriority==aPriority) && aCountLeft>0)
1.1144 + {
1.1145 + RWsSession::TWindowGroupChainInfo windowId;
1.1146 + windowId.iId=groupWin->Identifier();
1.1147 + if(!groupWin->IsChained(windowId.iParentId))
1.1148 + windowId.iParentId=-1; //Unchained window group
1.1149 + list.AppendL(windowId);
1.1150 + --aCountLeft;
1.1151 + groupWin=groupWin->NextSibling();
1.1152 + }
1.1153 + }
1.1154 +
1.1155 +TInt CWsWindowGroup::SendWindowGroupListAndChainL(TBool aAllPriorities, TInt aPriority, TInt aCount)
1.1156 + {
1.1157 + if ((aCount<1) || (aCount>(KArrayMaxGranularity/sizeof(RWsSession::TWindowGroupChainInfo))))
1.1158 + User::Leave(KErrArgument);
1.1159 + RArray<RWsSession::TWindowGroupChainInfo> list(aCount);
1.1160 + CleanupClosePushL(list);
1.1161 + TInt count=aCount;
1.1162 + TInt focusScreenNo=CWsTop::CurrentFocusScreen()->ScreenNumber();
1.1163 + GetWindowGroupListAndChainL(focusScreenNo,aAllPriorities,aPriority,list,count);
1.1164 + TInt screenNo;
1.1165 + for(screenNo=0;screenNo<CWsTop::NumberOfScreens();++screenNo)
1.1166 + {
1.1167 + if (screenNo!=focusScreenNo)
1.1168 + GetWindowGroupListAndChainL(screenNo,aAllPriorities,aPriority,list,count);
1.1169 + }
1.1170 + if (list.Count()>0)
1.1171 + CWsClient::ReplyBuf(&list[0],aCount*sizeof(RWsSession::TWindowGroupChainInfo));
1.1172 + CleanupStack::PopAndDestroy(&list);
1.1173 + return(aCount-count); // How many actually returned, may be less than asked for, but not more
1.1174 + }
1.1175 +
1.1176 +TBool CWsWindowGroup::SendEventToAllGroups(TBool aAllPriorities,TBool aOnePerClient,const TWsClCmdSendEventToWindowGroup& aData)
1.1177 + {
1.1178 + TWsEvent event=aData.event;
1.1179 + if (event.Type()==EEventKey && event.Key()->iRepeats!=0)
1.1180 + CKeyboardRepeat::CancelRepeat(NULL); //Otherwise we will trip an invarient
1.1181 + TInt priority=aData.parameter;
1.1182 + TBool sentToAll=ETrue;
1.1183 + TInt screenNo;
1.1184 + for(screenNo=0;screenNo<CWsTop::NumberOfScreens();++screenNo)
1.1185 + {
1.1186 + CWsWindowGroup *groupWin=CWsTop::Screen(screenNo)->RootWindow()->Child();
1.1187 + if (!aAllPriorities)
1.1188 + {
1.1189 + while(groupWin && groupWin->iOrdinalPriority!=priority)
1.1190 + groupWin=groupWin->NextSibling();
1.1191 + }
1.1192 + CWsWindowGroup* firstGroupWin=groupWin;
1.1193 + CWsClient* lastOwner=NULL;
1.1194 + CWsWindowGroup* groupWin2;
1.1195 + while(groupWin && (aAllPriorities || groupWin->iOrdinalPriority==priority))
1.1196 + {
1.1197 + if (aOnePerClient)
1.1198 + {
1.1199 + if (lastOwner==groupWin->iWsOwner)
1.1200 + goto ContinueLoop;
1.1201 + lastOwner=groupWin->iWsOwner;
1.1202 + for(groupWin2=firstGroupWin;groupWin2!=groupWin;groupWin2=groupWin2->NextSibling())
1.1203 + {
1.1204 + if (groupWin2->iWsOwner==groupWin->iWsOwner)
1.1205 + break;
1.1206 + }
1.1207 + if (groupWin2->iWsOwner==groupWin->iWsOwner && groupWin2!=groupWin)
1.1208 + goto ContinueLoop;
1.1209 + }
1.1210 + event.SetHandle(groupWin->ClientHandle());
1.1211 + if (!groupWin->EventQueue()->QueueEvent(event))
1.1212 + sentToAll=EFalse;
1.1213 + ContinueLoop:
1.1214 + groupWin=groupWin->NextSibling();
1.1215 + }
1.1216 + }
1.1217 + return sentToAll;
1.1218 + }
1.1219 +
1.1220 +void CWsWindowGroup::ReleasePendedMessagesToAllGroups(CWsClient * aClient)
1.1221 + {
1.1222 + TInt screenNo;
1.1223 + for (screenNo = 0; screenNo < CWsTop::NumberOfScreens(); ++screenNo)
1.1224 + {
1.1225 + CWsWindowGroup* groupWin = CWsTop::Screen(screenNo)->RootWindow()->Child();
1.1226 + while (groupWin)
1.1227 + {
1.1228 + if (groupWin->WsOwner() == aClient)
1.1229 + {
1.1230 + groupWin->ReleasePendedMessage();
1.1231 + }
1.1232 + groupWin = groupWin->NextSibling();
1.1233 + }
1.1234 + }
1.1235 + }
1.1236 +
1.1237 +void CWsWindowGroup::ReleasePendedMessage()
1.1238 + {
1.1239 + if (iMessageArray->Count() > 0 && !(iFlags & EGroupFlagMessageSignalled))
1.1240 + {
1.1241 + if (!SignalMessageReady())
1.1242 + {
1.1243 + //The event queue is overflow
1.1244 + // Cannot send a message notification event.
1.1245 + WsOwner()->WgMsgQueueOverflow(); // Set flag for client about having pended message(s)
1.1246 + }
1.1247 + }
1.1248 + }
1.1249 +
1.1250 +void CWsWindowGroup::SendMessageToAllGroupsL(CWsClient& aSender,TBool aAllPriorities,const TWsClCmdSendMessageToWindowGroup& aData)
1.1251 + {
1.1252 + TInt screenNo;
1.1253 + for(screenNo=0;screenNo<CWsTop::NumberOfScreens();++screenNo)
1.1254 + {
1.1255 + CWsWindowGroup* groupWin=CWsTop::Screen(screenNo)->RootWindow()->Child();
1.1256 + if (!aAllPriorities)
1.1257 + {
1.1258 + while(groupWin && groupWin->iOrdinalPriority!=aData.identifierOrPriority)
1.1259 + groupWin=groupWin->NextSibling();
1.1260 + }
1.1261 + while(groupWin && (aAllPriorities || (groupWin->iOrdinalPriority==aData.identifierOrPriority)))
1.1262 + {
1.1263 + groupWin->QueueMessageL(aData.uid, aData.dataLength, aSender);
1.1264 + groupWin=groupWin->NextSibling();
1.1265 + }
1.1266 + }
1.1267 + }
1.1268 +
1.1269 +CWsWindowGroup *CWsWindowGroup::WindowGroupFromIdentifier(TInt aIdentifier)
1.1270 + {
1.1271 + // apply to all screens
1.1272 + TInt screenNo;
1.1273 + for (screenNo=0; screenNo<CWsTop::NumberOfScreens(); ++screenNo)
1.1274 + {
1.1275 + CWsWindowGroup* group;
1.1276 + for(group=CWsTop::Screen(screenNo)->RootWindow()->Child(); group; group=group->NextSibling())
1.1277 + {
1.1278 + if (group->Identifier() == aIdentifier)
1.1279 + return group;
1.1280 + }
1.1281 +
1.1282 + }
1.1283 +
1.1284 + return NULL;
1.1285 + }
1.1286 +
1.1287 +CWsWindowGroup *CWsWindowGroup::WindowGroupFromIdentifierL(TInt aIdentifier)
1.1288 + {
1.1289 + CWsWindowGroup *group=WindowGroupFromIdentifier(aIdentifier);
1.1290 + if (!group)
1.1291 + User::Leave(KErrNotFound);
1.1292 + return(group);
1.1293 + }
1.1294 +
1.1295 +CWsWindowGroup *CWsWindowGroup::FindWindowGroupL(CWsClient* aClient, TInt aIdentifier,TInt aOffset,const TPtrC *aMatch,const TThreadId *aThreadId)
1.1296 + {
1.1297 + CWsWindowGroup *group;
1.1298 + if (aIdentifier)
1.1299 + {
1.1300 + group=WindowGroupFromIdentifier(aIdentifier);
1.1301 + if (group) // NULL group will cause KErrNotFound to be returned
1.1302 + group=group->NextSibling();
1.1303 + }
1.1304 + else
1.1305 + {
1.1306 + // get window group for this session
1.1307 + //
1.1308 + group = aClient->Screen()->RootWindow()->Child();
1.1309 + }
1.1310 +
1.1311 + for(;group;group=group->NextSibling())
1.1312 + {
1.1313 + if (aThreadId)
1.1314 + {
1.1315 + if (group->WsOwner()->Client().Id()==*aThreadId)
1.1316 + break; // Found one
1.1317 + }
1.1318 + else
1.1319 + {
1.1320 + const TDesC *groupName=&nullDescriptor;
1.1321 + if (group->GroupName())
1.1322 + groupName=group->GroupName();
1.1323 + if (groupName->Length()>=aOffset && groupName->Mid(aOffset).MatchF(*aMatch)>=0)
1.1324 + break; // Found one
1.1325 + }
1.1326 + }
1.1327 + if (!group)
1.1328 + User::Leave(KErrNotFound);
1.1329 + return(group);
1.1330 + }
1.1331 +
1.1332 +void CWsWindowGroup::AddPriorityKeyL(TUint aKeycode, TUint aModifierMask, TUint aModifiers)
1.1333 + {
1.1334 + iPriorityKeys=new(ELeave) TPriorityKey(aKeycode,aModifierMask,aModifiers,iPriorityKeys);
1.1335 + }
1.1336 +
1.1337 +void CWsWindowGroup::RemovePriorityKey(TUint aKeycode, TUint aModifierMask, TUint aModifiers)
1.1338 + {
1.1339 + for(TPriorityKey **ppk=&iPriorityKeys;*ppk;ppk=&((*ppk)->iNext))
1.1340 + if ((*ppk)->Equals(aKeycode, aModifierMask, aModifiers))
1.1341 + {
1.1342 + TPriorityKey *next=(*ppk)->iNext;
1.1343 + delete *ppk;
1.1344 + *ppk=next;
1.1345 + break;
1.1346 + }
1.1347 + }
1.1348 +
1.1349 +void CWsWindowGroup::RemoveAllPriorityKeys()
1.1350 + {
1.1351 + TPriorityKey *pk=iPriorityKeys;
1.1352 + while(pk)
1.1353 + {
1.1354 + TPriorityKey *next=pk->iNext;
1.1355 + delete pk;
1.1356 + pk=next;
1.1357 + }
1.1358 + }
1.1359 +
1.1360 +TBool CWsWindowGroup::CheckForPriorityKey(const TKeyEvent &aKeyEvent)
1.1361 + {
1.1362 + for(TPriorityKey *pk=iPriorityKeys;pk;pk=pk->iNext)
1.1363 + {
1.1364 + if (pk->KeyMatches(aKeyEvent))
1.1365 + {
1.1366 + WsOwner()->PriorityKeyPressed(ClientHandle(), aKeyEvent);
1.1367 + return(ETrue);
1.1368 + }
1.1369 + }
1.1370 + return(EFalse);
1.1371 + }
1.1372 +
1.1373 +void CWsWindowGroup::StatusDump(TDes &aBuf)
1.1374 + {
1.1375 + _LIT(KWSERVStatusDumpWindowGroupInfo,"CWsWindowGroup[0x%x]RWindowGroup[0x%x,%d],Pri=%d,Id=%d,SizeMode=%d");
1.1376 + aBuf.AppendFormat(KWSERVStatusDumpWindowGroupInfo,this,iClientHandle,LogHandle(),iOrdinalPriority,iIdentifier,iScreenDevice?iScreenDevice->AppMode():0);
1.1377 + }
1.1378 +
1.1379 +TBool CWsWindowGroup::SignalMessageReady()
1.1380 + {
1.1381 + TWsEvent event;
1.1382 + event.SetType(EEventMessageReady);
1.1383 + event.SetHandle(ClientHandle());
1.1384 + event.SetTimeNow();
1.1385 + SEventMessageReady& eventMessageReady=*(SEventMessageReady*)event.EventData();
1.1386 + eventMessageReady.iWindowGroupIdentifier=Identifier();
1.1387 + eventMessageReady.iMessageUid=(*iMessageArray)[0].iUid;
1.1388 + eventMessageReady.iMessageParametersSize=iMessageArray->Length(0)-sizeof(TUid);
1.1389 + TBool result = WsOwner()->EventQueue()->QueueEvent(event, EEventPriorityHigh);
1.1390 + if (result)
1.1391 + {
1.1392 + iFlags |= EGroupFlagMessageSignalled;
1.1393 + }
1.1394 + return result;
1.1395 + }
1.1396 +
1.1397 +void CWsWindowGroup::QueueMessageL(TUid aUid, TInt aDataLength, CWsClient& aSender)
1.1398 + {
1.1399 + WS_ASSERT_DEBUG(iFlags&(EGroupFlagMsgQueueActive|EGroupFlagMsgQueueNew) || iMessageArray->Count()>=1,EWsPanicMsgQueueError);
1.1400 + if (!(iFlags&(EGroupFlagMsgQueueActive|EGroupFlagMsgQueueNew)) && iMessageArray->Count()>=KMaxNumberOfMsgsInInactiveQueue)
1.1401 + {
1.1402 + WS_ASSERT_DEBUG(iMessageArray->Count()<=KMaxNumberOfMsgsInInactiveQueue,EWsPanicMsgQueueError);
1.1403 + iMessageArray->Delete(1,iMessageArray->Count()-1);
1.1404 + }
1.1405 + TWsMessage* message=NULL;
1.1406 + TRAPD(err,message=&iMessageArray->ExtendL(aDataLength+sizeof(aUid)));
1.1407 + if ((err || (iFlags&EGroupFlagMsgQueueNew)) && iMessageArray->Count()>KMaxNumberOfMsgsInQueue)
1.1408 + {
1.1409 + iFlags&=~(EGroupFlagMsgQueueActive|EGroupFlagMsgQueueNew);
1.1410 + iMessageArray->Delete(1,iMessageArray->Count()-(err?1:2));
1.1411 + iMessageArray->Compress();
1.1412 + }
1.1413 + User::LeaveIfError(err);
1.1414 + if (message)
1.1415 + {
1.1416 + message->iUid=aUid;
1.1417 + TPtr8 ptr(&message->iTheRest[0],aDataLength);
1.1418 + TRAP(err,aSender.RemoteReadL(ptr,0));
1.1419 + if (err)
1.1420 + {
1.1421 + iMessageArray->Delete(iMessageArray->Count()-1);
1.1422 + User::Leave(err);
1.1423 + }
1.1424 + if (!(iFlags & EGroupFlagMessageSignalled))
1.1425 + {
1.1426 + if (!SignalMessageReady())
1.1427 + {
1.1428 + //The event queue is overflow
1.1429 + // Cannot send a message notification event.
1.1430 + WsOwner()->WgMsgQueueOverflow(); // Set flag for client about having pended message(s)
1.1431 + }
1.1432 + }
1.1433 + }
1.1434 + }
1.1435 +
1.1436 +void CWsWindowGroup::FetchMessageL()
1.1437 + {
1.1438 + if (!(iFlags & EGroupFlagMessageSignalled))
1.1439 + {
1.1440 + OwnerPanic(EWservPanicFetchMessage);
1.1441 + }
1.1442 + CWsClient::ReplyBuf(&((*iMessageArray)[0].iTheRest[0]), (TInt) iMessageArray->Length(0) - sizeof(TUid));
1.1443 + iMessageArray->Delete(0);
1.1444 + iFlags |= EGroupFlagMsgQueueActive;
1.1445 + iFlags &= ~(EGroupFlagMessageSignalled | EGroupFlagMsgQueueNew);
1.1446 + if (iMessageArray->Count() > 0)
1.1447 + {
1.1448 + if (!SignalMessageReady())
1.1449 + {
1.1450 + //The event queue is overflow
1.1451 + // Cannot send a message notification event.
1.1452 + WsOwner()->WgMsgQueueOverflow(); // Set flag for client about having pended message(s)
1.1453 + }
1.1454 + }
1.1455 + }
1.1456 +
1.1457 +TBool CWsWindowGroup::ScreenDeviceValid() const
1.1458 + {
1.1459 + return(iScreenDevice?iScreenDevice->ScreenDeviceValidState():(iScreen->ScreenSizeMode()==0));
1.1460 + }
1.1461 +
1.1462 +TBool CWsWindowGroup::CanReceiveFocus() const
1.1463 + {
1.1464 + return(ReceivesFocus() && iWsOwner->NotClosing() && (ScreenDeviceValid() || iFlags&EGroupFlagHandlesDeviceChange));
1.1465 + }
1.1466 +
1.1467 +void CWsWindowGroup::SetScreenChangeEventStateL(TBool aEnabled)
1.1468 + {
1.1469 + iFlags&=~EGroupFlagHandlesDeviceChange;
1.1470 + if (aEnabled)
1.1471 + {
1.1472 + iFlags|=EGroupFlagHandlesDeviceChange;
1.1473 + TWindowServerEvent::AddToScreenDeviceChangeEventListL(*this);
1.1474 + if (iScreen->ScreenSizeMode()!=0)
1.1475 + TWindowServerEvent::SendScreenDeviceChangedEvent(this);
1.1476 + }
1.1477 + else
1.1478 + TWindowServerEvent::RemoveFromScreenDeviceChangeEventList(*this);
1.1479 + iScreen->ResetFocus(NULL);
1.1480 + }
1.1481 +
1.1482 +void CWsWindowGroup::SetScreenDeviceValidState(const DWsScreenDevice *aDevice)
1.1483 + {
1.1484 + if (iScreenDevice==aDevice)
1.1485 + {
1.1486 + TBool state=ScreenDeviceValid();
1.1487 + for(CWsTopClientWindow *win=Child();win;win=win->NextSiblingTop())
1.1488 + {
1.1489 + win->SetScreenDeviceValidState(state);
1.1490 + }
1.1491 + }
1.1492 + }
1.1493 +
1.1494 +void CWsWindowGroup::SetScreenDeviceValidStates(const DWsScreenDevice *aDevice)
1.1495 + {
1.1496 + for(CWsWindowGroup *groupWin=aDevice->RootWindow()->Child();groupWin;groupWin=groupWin->NextSibling())
1.1497 + groupWin->SetScreenDeviceValidState(aDevice);
1.1498 + }
1.1499 +
1.1500 +void CWsWindowGroup::SetScreenDeviceValidStates(CScreen* aScreen)
1.1501 + {
1.1502 + CWsRootWindow* rootWindow = aScreen->RootWindow();
1.1503 +
1.1504 + CWsWindowGroup* groupWin;
1.1505 + CWsTopClientWindow* win;
1.1506 + for(groupWin=rootWindow->Child();groupWin;groupWin=groupWin->NextSibling())
1.1507 + {
1.1508 + TBool state=groupWin->ScreenDeviceValid();
1.1509 + for(win=groupWin->Child();win;win=win->NextSiblingTop())
1.1510 + {
1.1511 + win->SetScreenDeviceValidStateFlag(state);
1.1512 + win->ResetHiddenFlagsInParentAndChildren();
1.1513 + }
1.1514 + }
1.1515 + }
1.1516 +
1.1517 +void CWsWindowGroup::SetScreenDevice(DWsScreenDevice *aDevice)
1.1518 + {
1.1519 + iScreenDevice=aDevice;
1.1520 + }
1.1521 +
1.1522 +void CWsWindowGroup::NewOrientation(TInt aMode,CFbsBitGc::TGraphicsOrientation aRotation, CWsRootWindow* aRootWindow)
1.1523 + {
1.1524 + for(CWsWindowGroup *groupWin=aRootWindow->Child();groupWin;groupWin=groupWin->NextSibling())
1.1525 + {
1.1526 + DWsScreenDevice *device=groupWin->Device();
1.1527 + if (device)
1.1528 + device->NewOrientation(aMode,aRotation);
1.1529 + }
1.1530 + }
1.1531 +
1.1532 +void CWsWindowGroup::ResetFocus(CWsWindowGroup *aClosingWindow)
1.1533 + {
1.1534 + if (iScreen)
1.1535 + {
1.1536 + iScreen->ResetFocus(aClosingWindow);
1.1537 + }
1.1538 + }
1.1539 +
1.1540 +TBool CWsWindowGroup::IsChained(TInt& aParentId)
1.1541 + {
1.1542 + if (!iQueue)
1.1543 + return EFalse;
1.1544 + if (iQueue->First()==this)
1.1545 + aParentId=0;
1.1546 + else
1.1547 + aParentId=BeforeInChain()->Identifier();
1.1548 + return ETrue;
1.1549 + }
1.1550 +
1.1551 +inline CWsWindowGroup* CWsWindowGroup::BeforeInChain()
1.1552 + { //You should only call this function if you know the window has a parent
1.1553 + return reinterpret_cast<CWsWindowGroup*>(PtrSub(iChainLink.iPrev,_FOFF(CWsWindowGroup,iChainLink)));
1.1554 + }
1.1555 +
1.1556 +TBool CWsWindowGroup::CheckCapability(TInt& aOrdinalPriority)
1.1557 + {
1.1558 + if(aOrdinalPriority>=KPasswordWindowGroupPriority)
1.1559 + {
1.1560 + if(!KSecurityPolicy_SwEvent().CheckPolicy(WsOwner()->Client(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed")))
1.1561 + {
1.1562 + aOrdinalPriority=KPasswordWindowGroupPriority-1;
1.1563 + return EFalse;
1.1564 + }
1.1565 + }
1.1566 + return ETrue;
1.1567 + }
1.1568 +
1.1569 +TBool CWsWindowGroup::HasVisibleTranslucentChild()
1.1570 + {
1.1571 + CWsWindowBase * child = iChild;
1.1572 + while (child)
1.1573 + {
1.1574 + if (child->WinType() == EWinTypeClient)
1.1575 + {
1.1576 + CWsClientWindow * cliwin = static_cast<CWsClientWindow *>(child);
1.1577 + if (cliwin->IsTranslucent() && cliwin->IsVisible())
1.1578 + return ETrue;
1.1579 + }
1.1580 + else if (static_cast<CWsWindowGroup*>(child)->HasVisibleTranslucentChild())
1.1581 + {
1.1582 + return ETrue;
1.1583 + }
1.1584 + child = child->NextSibling();
1.1585 + }
1.1586 + return EFalse;
1.1587 + }
1.1588 +
1.1589 +
1.1590 +TInt CWsWindowGroup::NumClientWindowGroups()
1.1591 + {
1.1592 + CWsObjectIx& objix=*WsOwner()->ObjectIndex();
1.1593 + const TWsObject* ptr=objix.FirstObject();
1.1594 + const TWsObject* end=ptr+objix.Length();
1.1595 + TInt count=0;
1.1596 + while(++ptr<end) //First one should always have a NULL object
1.1597 + {
1.1598 + const CWsObject* obj=ptr->iObject;
1.1599 + if (obj && obj->Type()==WS_HANDLE_GROUP_WINDOW)
1.1600 + ++count;
1.1601 + }
1.1602 + return count;
1.1603 + }
1.1604 +
1.1605 +void CWsWindowGroup::SetEventQueueTestState(TBool aEventQueState)
1.1606 + {
1.1607 + iEventQueueTest = aEventQueState;
1.1608 + }