sl@0: // Copyright (c) 1995-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // Group window sub-class of CWsWindow
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include <e32std.h>
sl@0: #include "W32STD.H"
sl@0: #include "W32CLICK.H"
sl@0: #include "server.h"
sl@0: #include "rootwin.h"
sl@0: #include "windowgroup.h"
sl@0: #include "walkwindowtree.h"
sl@0: #include "wstop.h"
sl@0: #include "EVENT.H"
sl@0: #include "KEYCLICK.H"
sl@0: #include "PRIKEY.H"
sl@0: #include "panics.h"
sl@0: #include "windowelementset.h"
sl@0: #include "pointer.h"
sl@0: 
sl@0: GLREF_D TPtr nullDescriptor;
sl@0: GLREF_D CDebugLogBase* wsDebugLog;
sl@0: 
sl@0: #if defined(_DEBUG)
sl@0: TInt CWsWindowGroup::iSkipCount=0;
sl@0: #endif
sl@0: 
sl@0: TBool CWsWindowGroup::iEventQueueTest=EFalse;			// For stress testing the EventQueue code
sl@0: 
sl@0: TInt CWsWindowGroup::iIdentifierCount=1;
sl@0: TBool CWsWindowGroup::iFocusGainPreProcess=EFalse;		//'REMOVEFADINGONFOCUSGAIN' flag in INI file
sl@0: RPointerArray< TDblQue<CWsWindowGroup> > CWsWindowGroup::iChains(3);
sl@0: static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);
sl@0: static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);
sl@0: const TInt KArrayMaxGranularity=0x10000000;
sl@0: 
sl@0: CWsWindowGroup* CWsWindowGroup::NewL(CWsClient* aOwner, CScreen* aScreen, 
sl@0: 	const TWsClCmdCreateWindowGroup& aCmd)
sl@0: 	{
sl@0: 	CWsWindowGroup* self = new(ELeave) CWsWindowGroup(aOwner, aScreen);
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL(aCmd);
sl@0: 	CleanupStack::Pop(self);
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: CWsWindowGroup::CWsWindowGroup(CWsClient* aOwner, CScreen* aScreen) : CWsWindowBase(aOwner,WS_HANDLE_GROUP_WINDOW,aScreen)
sl@0: 	{
sl@0: 	__DECLARE_NAME(_S("CWsWindowGroup"));
sl@0: 	iWinType=EWinTypeGroup;
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::PurgeCapturedKeys()
sl@0: 	{
sl@0: 	CWsObjectIx& objix=*WsOwner()->ObjectIndex();
sl@0: 	const TWsObject* ptr=objix.FirstObject();
sl@0: 	const TWsObject* end=ptr+objix.Length();
sl@0: 	while(++ptr<end)		//Fisrt one should always have a NULL object
sl@0: 		{
sl@0: 		const CWsObject* obj=ptr->iObject;
sl@0: 		if (obj 
sl@0: 			&& ((obj->Type()==WS_HANDLE_CAPTURE_KEY && STATIC_CAST(const CWsCaptureKey*,obj)->WindowGroup()==this)
sl@0: 				|| (obj->Type()==WS_HANDLE_CAPTURE_KEY_UPDOWNS && STATIC_CAST(const CWsCaptureKeyUpsAndDowns*,obj)->WindowGroup()==this)
sl@0: 				|| (obj->Type()==WS_HANDLE_CAPTURE_LONG_KEY && STATIC_CAST(const CWsCaptureLongKey*,obj)->WindowGroup()==this)))
sl@0: 			{
sl@0: 			objix.Remove(ptr);
sl@0: 			delete obj;
sl@0: 			}
sl@0: 		}
sl@0: 	objix.Tidy();
sl@0: 	CKeyboardRepeat::CancelRepeat(this);
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SwitchToOwningWindow(CWsWindowGroup *aClosingWindow)
sl@0: 	{
sl@0: 	if (this==CWsTop::FocusWindowGroup())
sl@0: 		{
sl@0: 		CWsWindowGroup *winGroup=NULL;
sl@0: //
sl@0: // First try for an 'owning' window
sl@0: //
sl@0: 		if (iOwningWindowGroup)
sl@0: 			{
sl@0: 			for(winGroup=RootWindow()->Child();winGroup;winGroup=winGroup->NextSibling())
sl@0: 				if (winGroup->Identifier()==iOwningWindowGroup && winGroup->iOrdinalPriority==iOrdinalPriority)
sl@0: 					goto gotIt;
sl@0: 			}
sl@0: //
sl@0: // If that failed look for the frontmost window belonging to the owner of dying window
sl@0: //
sl@0: 		for(winGroup=RootWindow()->Child();winGroup;winGroup=winGroup->NextSibling())
sl@0: 			if (winGroup!=this && winGroup->WsOwner()==WsOwner() && winGroup->iOrdinalPriority==iOrdinalPriority)
sl@0: 				goto gotIt;
sl@0: //
sl@0: // Next try for the nominated default owning window group
sl@0: //
sl@0: 		winGroup=iScreen->DefaultOwningWindowGroup();
sl@0: 		if (winGroup && winGroup->iOrdinalPriority==iOrdinalPriority)
sl@0: 			{
sl@0: gotIt:		winGroup->SetOrdinalPosition(0,this);
sl@0: 			return;
sl@0: 			}
sl@0: 		}
sl@0: 	ResetFocus(aClosingWindow);
sl@0: 	}
sl@0: 
sl@0: CWsWindowGroup::~CWsWindowGroup()
sl@0: 	{
sl@0: 	MWsWindowTreeObserver* windowTreeObserver = NULL;
sl@0: 	if (Screen()&& iBaseWinFlags&EBaseWinNodeCreated)
sl@0: 		{
sl@0: 		windowTreeObserver = Screen()->WindowTreeObserver();
sl@0: 		if (windowTreeObserver)
sl@0: 			{
sl@0: 			if( iQueue && (iQueue->Last()!=this) )
sl@0: 				{
sl@0: 				//This node is part of chain, send notification unless this is the last node in the chain
sl@0: 				windowTreeObserver->WindowGroupChainBrokenAfter(*this);
sl@0: 				}
sl@0: 			windowTreeObserver->NodeReleased(*this);
sl@0: 			iBaseWinFlags &= ~EBaseWinNodeCreated;
sl@0: 			}
sl@0: 		}
sl@0: 	DisconnectFloatingSprites();
sl@0: 	
sl@0: 	if (wsDebugLog)
sl@0: 		{
sl@0: 		TLogMessageText buf;
sl@0: 		_LIT(KWSERVDebugLogGroupWindowId,"Destroying: RWindowGroup[0x%x,%d],Id=%d");
sl@0: 		buf.Format(KWSERVDebugLogGroupWindowId,iClientHandle,LogHandle(),iIdentifier);
sl@0: 		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, buf);
sl@0: 		}
sl@0: 	if (CClick::IsHandler())
sl@0: 		CClick::OtherEvent(EEventGroupWindowClose,reinterpret_cast<TAny*>(iIdentifier));
sl@0: 	if (iQueue)
sl@0: 		{
sl@0: 		if (iQueue->Last()!=this)
sl@0: 			{		//Unlink all the children of the window that is being deleted
sl@0: 			TDblQueIter<CWsWindowGroup> iter(*iQueue);
sl@0: 			CWsWindowGroup* groupWin;
sl@0: 			iter.SetToLast();
sl@0: 			while ((groupWin=iter--)!=this)
sl@0: 				{
sl@0: 				WS_ASSERT_DEBUG(groupWin!=NULL && groupWin->iQueue==iQueue,EWsPanicGroupWindowChainError);
sl@0: 				if ( windowTreeObserver && (iQueue->Last()!=groupWin) )
sl@0: 					{
sl@0: 					//Send notification unless groupWin is the last node in the chain
sl@0: 					windowTreeObserver->WindowGroupChainBrokenAfter(*groupWin);
sl@0: 					}
sl@0: 				groupWin->iChainLink.Deque();
sl@0: 				// coverity[extend_simple_error]
sl@0: 				groupWin->iQueue=NULL;
sl@0: 				}
sl@0: 			}
sl@0: 		WS_ASSERT_DEBUG(iQueue->Last()==this,EWsPanicGroupWindowChainError);
sl@0: 		if(windowTreeObserver && !iQueue->IsEmpty())
sl@0: 			{
sl@0: 			//If there are chained nodes before this one, notify "chain broken" immediately before this node 
sl@0: 			TDblQueIter<CWsWindowGroup> iter(*iQueue);
sl@0: 			iter.SetToLast(); 	//i.e. set to this (see assert above)
sl@0: 			iter--;				//i.e. set to parent
sl@0: 			CWsWindowGroup* parent = iter;
sl@0: 			if(parent)
sl@0: 				{
sl@0: 				windowTreeObserver->WindowGroupChainBrokenAfter(*parent);
sl@0: 				}
sl@0: 			}
sl@0: 		TDblQueLinkBase* parentLink=iChainLink.iPrev;
sl@0: 		iChainLink.Deque();
sl@0: 		if (parentLink->iNext==parentLink->iPrev)		//Check to see chain no longer required
sl@0: 			{
sl@0: 			if (!iQueue->IsEmpty())
sl@0: 				{				//Only the parent is left in queue
sl@0: 				CWsWindowGroup* parent=iQueue->First();
sl@0: 				static_cast<TDblQueLink*>(parentLink)->Deque();
sl@0: 				WS_ASSERT_DEBUG(parent->iQueue==iQueue,EWsPanicGroupWindowChainError);
sl@0: 				// coverity[extend_simple_error]
sl@0: 				parent->iQueue=NULL;
sl@0: 				}
sl@0: 			DeleteQueue(iQueue);
sl@0: 			}
sl@0: 		}
sl@0: 	RemoveAllPriorityKeys();
sl@0: 	PurgeCapturedKeys();
sl@0: 	iTextCursor.Close();
sl@0: 	SetPointerCursor(NULL);
sl@0: 	for(CWsTopClientWindow *win=Child();win;win=win->NextSiblingTop())
sl@0: 		win->SetInactive();
sl@0: 	if (iScreen)
sl@0: 		{
sl@0: 		iScreen->RemoveFromDefaultOwningList(this);
sl@0: 		}
sl@0: 	CWsWindowBase::Shutdown();
sl@0: 	TWindowServerEvent::SendGroupChangedEvents();
sl@0: 	// coverity[extend_simple_error]
sl@0: 	iClientHandle=0;	// To block focus lost events being sent
sl@0: // Decide which window to give focus to if WServ isn't shutting down
sl@0: 	if (iScreen && !CWsTop::ShuttingDown())
sl@0: 		SwitchToOwningWindow(this);
sl@0: 	delete iGroupName;
sl@0: 	delete iMessageArray;
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::DisconnectFloatingSprites()
sl@0: 	{
sl@0: 	CWsSpriteBase * current = iSpriteList;
sl@0: 	while (current)
sl@0: 		{
sl@0: 		CWsSpriteBase * next = current->Next();
sl@0: 		current->Deactivate();
sl@0: 		current->DisconnectGroupWin();
sl@0: 		current = next;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::DeleteQueue(TDblQue<CWsWindowGroup>* aQueue)
sl@0: 	{
sl@0: 	iChains.Remove(iChains.Find(aQueue));
sl@0: 	delete aQueue;
sl@0: 	if (iChains.Count()==0)
sl@0: 		{
sl@0: 		iChains.Compress();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::AdvanceIdentifierCount()
sl@0: 	{
sl@0: 	if (++iIdentifierCount>EMaxIdentifierCount)
sl@0: 		iIdentifierCount=1;		// so limit it to low value
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::ConstructL(const TWsClCmdCreateWindowGroup &aCmd)
sl@0: 	{
sl@0: #if defined(_DEBUG)
sl@0: 	if (IsClientHandleInUse(aCmd.clientHandle))
sl@0: 		{
sl@0: 		OwnerPanic(EWservPanicDuplicateHandle);
sl@0: 		}
sl@0: #endif
sl@0: 	NewObjL();
sl@0: 	iFlags=EGroupFlagAutoForeground|EGroupFlagMsgQueueNew;
sl@0: 	if (aCmd.focus)
sl@0: 		{
sl@0: 		iFlags|=EGroupFlagReceivesFocus;
sl@0: 		}
sl@0: 	iTextCursor.ConstructL(this);
sl@0: 	iClientHandle=aCmd.clientHandle;
sl@0: 
sl@0: 	if(aCmd.screenDeviceHandle <= 0)
sl@0: 		{
sl@0: 		//Use primary screen. Client should make sure PrimaryScreenDevice is correct set up immediately after establishing session.
sl@0: 		iScreenDevice=iWsOwner->PrimaryScreenDevice();
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		//Use the specified screen
sl@0: 		iScreenDevice=STATIC_CAST(DWsScreenDevice*,iWsOwner->HandleToObj(aCmd.screenDeviceHandle,WS_HANDLE_SCREEN_DEVICE));
sl@0: 		}
sl@0: 
sl@0: 	iScreen = (iScreenDevice) ? iScreenDevice->Screen() : CWsTop::Screen(); //if no screen device use screen 0
sl@0: 
sl@0: 	CWsWindowGroup* parent=NULL;
sl@0: 	if (aCmd.parentId>0)
sl@0: 		{
sl@0: 		parent=CWsWindowGroup::WindowGroupFromIdentifier(aCmd.parentId);
sl@0: 		if (!parent)
sl@0: 			{
sl@0: 			OwnerPanic(EWservPanicWindow);
sl@0: 			}
sl@0: 		
sl@0:  		if(parent->Screen() != iScreen)
sl@0:  			{
sl@0:  			OwnerPanic(EWservPanicWrongScreen);
sl@0:  			}
sl@0: 		
sl@0: 		if (parent->iOrdinalPriorityAdjust>0)
sl@0: 			{
sl@0: 			WS_ASSERT_DEBUG(parent->iQueue==NULL,EWsPanicGroupWindowChainError);
sl@0: 			parent->iOrdinalPriorityAdjust=0;
sl@0: 			parent->UpdateOrdinalPriority(ETrue);
sl@0: 			}
sl@0: 		iOrdinalPriorityBase=parent->iOrdinalPriorityBase;
sl@0: 		iOrdinalPriority=iOrdinalPriorityBase;
sl@0: 		}
sl@0: 
sl@0: 	do
sl@0: 		{
sl@0: 		AdvanceIdentifierCount();	// Always advance by at least one to stop re-using last id
sl@0: 		} while (WindowGroupFromIdentifier(iIdentifierCount)); // If current count is in use try again
sl@0: 	iIdentifier=iIdentifierCount;
sl@0: 
sl@0: 	CWsWindowBase::ConstructL(RootWindow());
sl@0: 	iScreen->ResetFocus(NULL);
sl@0: 	
sl@0: 	if (parent)
sl@0: 		{
sl@0: 		TDblQue<CWsWindowGroup>* queue=parent->iQueue;
sl@0: 		if (queue && queue->Last()!=parent)
sl@0: 			User::Leave(KErrInUse);
sl@0: 		if (parent->iWsOwner!=iWsOwner)
sl@0: 			{
sl@0: 			_LIT_SECURITY_POLICY_S0(securityPolicy,parent->iChildSID);
sl@0: 			if (!securityPolicy().CheckPolicy(iWsOwner->ClientMessage()))
sl@0: 				User::Leave(KErrPermissionDenied);
sl@0: 			}
sl@0: 		if (!queue)
sl@0: 			{
sl@0: 			queue=new(ELeave) TDblQue<CWsWindowGroup>(_FOFF(CWsWindowGroup,iChainLink));
sl@0: 			CleanupStack::PushL(queue);
sl@0: 			User::LeaveIfError(iChains.Append(queue));
sl@0: 			CleanupStack::Pop(queue);
sl@0: 			queue->AddFirst(*parent);
sl@0: 			parent->iQueue=queue;			
sl@0: 			}
sl@0: 		iQueue=queue;		//Shouldn't set the queue until after it can leave
sl@0: 		iChainLink.Enque(&parent->iChainLink);
sl@0: 		
sl@0: 		MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();						
sl@0: 		if (windowTreeObserver)
sl@0: 			{
sl@0: 			windowTreeObserver->WindowGroupChained(*parent, *this);
sl@0: 			}			
sl@0: 		}
sl@0: 	iMessageArray=new(ELeave) CArrayVarSeg<TWsMessage>(1);
sl@0: 	if (CClick::IsHandler())
sl@0: 		{
sl@0: 		TGroupWindowOpenData params;
sl@0: 		params.iIdentifier=iIdentifier;
sl@0: 		params.iClient=iWsOwner->ConnectionHandle();
sl@0: 		params.iNumClientWindowGroups=NumClientWindowGroups()-1;	//Don't include this one
sl@0: 		CClick::OtherEvent(EEventGroupWindowOpen,&params);
sl@0: 		}
sl@0: 	if (wsDebugLog)
sl@0: 		{
sl@0: 		TLogMessageText buf;
sl@0: 		_LIT(KWSERVDebugLogGroupWindowId,"Creating: RWindowGroup[0x%x,%d],Id=%d");
sl@0: 		buf.Format(KWSERVDebugLogGroupWindowId,iClientHandle,LogHandle(),iIdentifier);
sl@0: 		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, buf);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::UpdateOrdinalPriority(TBool aDoAdjust)
sl@0: 	{
sl@0: 	TInt newPri;
sl@0: 	newPri=iOrdinalPriorityBase;
sl@0: 	if (iWsOwner==CWsTop::FocusWindowGroupOwner())
sl@0: 		newPri+=iOrdinalPriorityAdjust;
sl@0: 	CheckCapability(newPri);
sl@0: 	if (newPri!=iOrdinalPriority)
sl@0: 		{
sl@0: 		iOrdinalPriority=newPri;
sl@0: 		if (aDoAdjust)
sl@0: 			SetOrdinalPosition(0);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SetOrdinalPriority(TInt aPos,TInt aPriority)
sl@0: 	{
sl@0: 	if (!iQueue)
sl@0: 		{
sl@0: 		iOrdinalPriorityBase=aPriority;
sl@0: 		UpdateOrdinalPriority(EFalse);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TDblQueIter<CWsWindowGroup> iter(*iQueue);
sl@0: 		CWsWindowGroup* group;
sl@0: 		while ((group=iter++)!=NULL)
sl@0: 			{
sl@0: 			group->iOrdinalPriorityBase=aPriority;
sl@0: 			group->iOrdinalPriority=aPriority;
sl@0: 			}
sl@0: 		}
sl@0: 	SetOrdinalPosition(aPos);
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::CommandL(TInt aOpcode, const TAny *aCmdData)
sl@0: 	{
sl@0: #ifdef _DEBUG
sl@0: 	// Save root window for performing CheckTree at the end of this func.
sl@0: 	// When aOpcode is EWsWinOpFree, this object would've been destroyed
sl@0: 	// and a call to RootWindow() in that case would be impossible
sl@0: 	CWsRootWindow* rootWindow=RootWindow();
sl@0: 
sl@0: 	// For certain opcodes, check for the 'screen device deleted' condition. If it
sl@0: 	// has occured for the screen device associated with this group window then
sl@0: 	// those op-codes are not valid, and the client is panicked.
sl@0: 	switch (aOpcode)
sl@0: 		{
sl@0: 		case EWsWinOpEnableScreenChangeEvents:
sl@0: 		case EWsWinOpAllowChildWindowGroup:
sl@0: 		case EWsWinOpReceiveFocus:
sl@0: 		case EWsWinOpAutoForeground:
sl@0: 		case EWsWinOpSetOrdinalPositionPri:
sl@0: 		case EWsWinOpSetOrdinalPriorityAdjust:
sl@0: 		case EWsWinOpCaptureKey:
sl@0: 		case EWsWinOpCaptureKeyUpsAndDowns:
sl@0: 		case EWsWinOpCaptureLongKey:
sl@0: 		case EWsWinOpAddPriorityKey:
sl@0: 		case EWsWinOpSetTextCursor:
sl@0: 		case EWsWinOpSetTextCursorClipped:
sl@0: 		case EWsWinOpSetOwningWindowGroup:
sl@0: 		case EWsWinOpDefaultOwningWindow:
sl@0: 		case EWsWinOpSetName:
sl@0: 		case EWsWinOpDisableKeyClick:
sl@0: 		case EWsWinOpSendPointerEvent:
sl@0: 		case EWsWinOpSendAdvancedPointerEvent:
sl@0: 			{
sl@0: 			if (ScreenDeviceDeleted())
sl@0: 				OwnerPanic(EWservPanicGroupWinScreenDeviceDeleted);
sl@0: 			break;				
sl@0: 			};
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	TWsWinCmdUnion pData;
sl@0: 	pData.any=aCmdData;
sl@0: 	if (CWsWindowBase::CommandL(aOpcode,pData)==EFalse)
sl@0: 		{
sl@0: 		switch(aOpcode)
sl@0: 			{
sl@0: 			case EWsWinOpAllowChildWindowGroup:
sl@0: 				iChildSID=*pData.UInt;
sl@0: 				break;
sl@0: 			case EWsWinOpEnableScreenChangeEvents:
sl@0: 				SetScreenChangeEventStateL(ETrue);
sl@0: 				break;
sl@0: 			case EWsWinOpDisableScreenChangeEvents:
sl@0: 				SetScreenChangeEventStateL(EFalse);
sl@0: 				break;
sl@0: 			case EWsWinOpReceiveFocus:
sl@0: 				if (*pData.Bool!=(iFlags&EGroupFlagReceivesFocus))
sl@0: 					{
sl@0: 					iFlags&=~EGroupFlagReceivesFocus;
sl@0: 					if (*pData.Bool)
sl@0: 						iFlags|=EGroupFlagReceivesFocus;
sl@0: 					iScreen->ResetFocus(NULL);
sl@0: 					}
sl@0: 				break;
sl@0: 			case EWsWinOpAutoForeground:
sl@0: 				iFlags&=~EGroupFlagAutoForeground;
sl@0: 				if (*pData.Bool)
sl@0: 					iFlags|=EGroupFlagAutoForeground;
sl@0: 				break;
sl@0: 			case EWsWinOpSetOrdinalPositionPri:
sl@0: 			case EWsWinOpSetOrdinalPositionErr:
sl@0: 				{
sl@0: 				TInt priority=pData.OrdinalPos->ordinalPriority;
sl@0: 				TBool hascap = CheckCapability(priority);
sl@0: 				SetOrdinalPriority(pData.OrdinalPos->pos, priority);
sl@0: 				if (aOpcode == EWsWinOpSetOrdinalPositionErr)
sl@0: 					{
sl@0: 					SetReply(hascap?KErrNone:KErrPermissionDenied);
sl@0: 					}
sl@0: 				}
sl@0: 				break;
sl@0: 			case EWsWinOpSetOrdinalPriorityAdjust:
sl@0: 				if (!iQueue)
sl@0: 					{
sl@0: 					iOrdinalPriorityAdjust=*pData.Int;
sl@0: 					UpdateOrdinalPriority(ETrue);
sl@0: 					}
sl@0: 				break;
sl@0: 			case EWsWinOpCaptureKey:
sl@0: 				{
sl@0: 				if(!KSecurityPolicy_SwEvent().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::CaptureKey API")))
sl@0: 					{
sl@0: 					User::Leave(KErrPermissionDenied);
sl@0: 					}
sl@0: 				CWsCaptureKey *cKey=new(ELeave) CWsCaptureKey(this);
sl@0: 				CleanupStack::PushL(cKey);
sl@0: 				cKey->ConstructL(*pData.CaptureKey);
sl@0: 				CleanupStack::Pop();
sl@0: 				}
sl@0: 				break;
sl@0: 			case EWsWinOpCaptureKeyUpsAndDowns:
sl@0: 				{
sl@0: 				if(!KSecurityPolicy_SwEvent().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::CaptureKeyUpsAndDowns API")))
sl@0: 					{
sl@0: 					User::Leave(KErrPermissionDenied);
sl@0: 					}
sl@0: 				CWsCaptureKeyUpsAndDowns *cKey=new(ELeave) CWsCaptureKeyUpsAndDowns(this);
sl@0: 				CleanupStack::PushL(cKey);
sl@0: 				cKey->ConstructL(*pData.CaptureKey);
sl@0: 				CleanupStack::Pop();
sl@0: 				}
sl@0: 				break;
sl@0: 			case EWsWinOpCaptureLongKey:
sl@0: 				{
sl@0: 				if(!KSecurityPolicy_SwEvent().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::CaptureLongKey API")))
sl@0: 					{
sl@0: 					User::Leave(KErrPermissionDenied);
sl@0: 					}
sl@0: 				CWsCaptureLongKey *cKey=new(ELeave) CWsCaptureLongKey(this);
sl@0: 				CleanupStack::PushL(cKey);
sl@0: 				cKey->ConstructL(*pData.CaptureLongKey);
sl@0: 				CleanupStack::Pop();
sl@0: 				}
sl@0: 				break;
sl@0: 			case EWsWinOpCancelCaptureKey:
sl@0: 				if (*pData.UInt!=0)	// Ignore null handle
sl@0: 					{
sl@0: 					CWsObject *destroyObj = iWsOwner->HandleToObj(*pData.UInt, WS_HANDLE_CAPTURE_KEY);
sl@0: 					if (destroyObj)
sl@0: 						{
sl@0: 						// Cancel any repeat that is underway for this capture
sl@0: 						CKeyboardRepeat::CancelRepeat(destroyObj, EFalse);
sl@0: 						delete destroyObj;
sl@0: 						}
sl@0: 					else
sl@0: 						{
sl@0: #ifdef _DEBUG
sl@0: 						// Attempt to cancel key capture with an incorrect handle
sl@0: 						OwnerPanic(EWservPanicDestroy);  
sl@0: #endif // _DEBUG
sl@0: 						}					
sl@0: 					}
sl@0: 				break;
sl@0: 			case EWsWinOpCancelCaptureKeyUpsAndDowns:
sl@0: 				if (*pData.UInt!=0)	// Ignore null handle
sl@0: 					{
sl@0: 					CWsObject *destroyObj = iWsOwner->HandleToObj(*pData.UInt, WS_HANDLE_CAPTURE_KEY_UPDOWNS);
sl@0: 					if (destroyObj)
sl@0: 						{
sl@0: 						delete destroyObj;
sl@0: 						}
sl@0: 					else
sl@0: 						{
sl@0: #ifdef _DEBUG						
sl@0: 						// Attempt to cancel ups and downs key capture with an incorrect handle
sl@0: 						OwnerPanic(EWservPanicDestroy);
sl@0: #endif // _DEBUG
sl@0: 						}					
sl@0: 					}
sl@0: 				break;
sl@0: 			case EWsWinOpCancelCaptureLongKey:
sl@0: 				if (*pData.UInt!=0)	// Ignore null handle
sl@0: 					{
sl@0: 					CWsObject *destroyObj = iWsOwner->HandleToObj(*pData.UInt, WS_HANDLE_CAPTURE_LONG_KEY);
sl@0: 					if (destroyObj)
sl@0: 						{
sl@0: 						// Cancel any repeat that is underway for this capture
sl@0: 						CKeyboardRepeat::CancelRepeat(destroyObj, ETrue);
sl@0: 						delete destroyObj;
sl@0: 						} 
sl@0: 					else
sl@0: 						{
sl@0: #ifdef _DEBUG						
sl@0: 						// Attempt to cancel long key capture with an incorrect handle
sl@0: 						OwnerPanic(EWservPanicDestroy);
sl@0: #endif // _DEBUG
sl@0: 						}					
sl@0: 					}
sl@0: 				break;
sl@0: 			case EWsWinOpAddPriorityKey:
sl@0: 				AddPriorityKeyL(pData.PriorityKey->keycode, pData.PriorityKey->modifierMask, pData.PriorityKey->modifiers);
sl@0: 				break;
sl@0: 			case EWsWinOpRemovePriorityKey:
sl@0: 				RemovePriorityKey(pData.PriorityKey->keycode, pData.PriorityKey->modifierMask, pData.PriorityKey->modifiers);
sl@0: 				break;
sl@0: 			case EWsWinOpSetTextCursor:
sl@0: 				iTextCursor.SetL(*pData.SetTextCursor, EFalse);
sl@0: 				break;
sl@0: 			case EWsWinOpSetTextCursorClipped:
sl@0: 				iTextCursor.SetL(*pData.SetTextCursor, ETrue);
sl@0: 				break;
sl@0: 			case EWsWinOpCancelTextCursor:
sl@0: 				iTextCursor.Cancel();
sl@0: 				break;
sl@0: 			case EWsWinOpSetOwningWindowGroup:
sl@0: 				iOwningWindowGroup=*pData.Int;
sl@0: 				break;
sl@0: 			case EWsWinOpDefaultOwningWindow:
sl@0: 				{
sl@0: 				if(KSecurityPolicy_WriteDeviceData().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::DefaultOwningWindow API")))
sl@0: 					{
sl@0: 					iScreen->SetDefaultOwningWindow(this);
sl@0: 					}
sl@0: 				}
sl@0: 				break;
sl@0: 			case EWsWinOpName:
sl@0: 				iWsOwner->ReplyGroupName(iGroupName,*pData.Int);
sl@0: 				break;
sl@0: 			case EWsWinOpSetName:
sl@0: 				{
sl@0: 				HBufC *newName=NULL;
sl@0: 				const TInt size=*pData.Int;
sl@0: 				if (size>0)
sl@0: 					{
sl@0: 					newName=HBufC::NewLC(size);
sl@0: 					TPtr ptr(newName->Des());
sl@0: 					iWsOwner->RemoteReadL(ptr,0);
sl@0: 					CleanupStack::Pop(newName);
sl@0: 					}
sl@0: 				//Window Group Name is unchanged
sl@0: 				if (iGroupName && newName && *iGroupName == *newName)
sl@0: 					{
sl@0: 					delete newName;
sl@0: 					} 
sl@0: 				else  //Window Group Name is changed
sl@0: 					{  
sl@0: 					delete iGroupName;
sl@0: 					iGroupName=newName;
sl@0: 					TWindowServerEvent::SendGroupChangedEvents();
sl@0: 					if (iScreen && iScreen->ChangeTracking())
sl@0: 					    {
sl@0: 				        MWsWindowTreeObserver* const windowTreeObserver = iScreen->WindowTreeObserver();
sl@0: 				        if (windowTreeObserver)
sl@0: 				            windowTreeObserver->AttributeChanged(*this, MWsWindowTreeObserver::EWindowGroupName);
sl@0: 					    }
sl@0: 					}
sl@0: 				}
sl@0: 				break;
sl@0: 			case EWsWinOpIdentifier:
sl@0: 				SetReply(Identifier());
sl@0: 				break;
sl@0: 			case EWsWinOpDisableKeyClick:
sl@0: 				if (*pData.Bool)
sl@0: 					iFlags|=EGroupFlagDisableKeyClick;
sl@0: 				else
sl@0: 					iFlags&=~EGroupFlagDisableKeyClick;
sl@0: 				if (this==CWsTop::FocusWindowGroup())
sl@0: 					UpdateKeyClickState();
sl@0: 				break;
sl@0: 			case EWsWinOpSendAdvancedPointerEvent:
sl@0: 			case EWsWinOpSendPointerEvent:
sl@0: 				{
sl@0: 				TRawEvent eventCopy = *pData.RawEvent;
sl@0: 				if (TWsPointer::PreProcessClientEvent(eventCopy, aOpcode == EWsWinOpSendAdvancedPointerEvent))
sl@0: 					{
sl@0: 					if (!TWindowServerEvent::MousePress(eventCopy,this))
sl@0: 						{
sl@0: 						OwnerPanic(EWservPanicEventType);
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 				break;
sl@0: 			case EWsWinOpClearChildGroup:
sl@0: 				if(iQueue)
sl@0: 					{
sl@0: 					TBool fBefore=EFalse; 
sl@0: 					TBool fAfter=EFalse; 
sl@0: 					// If there is nothing to clear, return KErrArgument
sl@0: 					if(iQueue->Last()==this)
sl@0: 						{
sl@0: 						SetReply(KErrArgument);
sl@0: 						break;
sl@0: 						}
sl@0: 					// fBefore is True if there is AT LEAST one window group queued before the current one
sl@0: 					else if(iQueue->First()!=this)
sl@0: 						{
sl@0: 						fBefore=ETrue;
sl@0: 						}
sl@0: 					// fAfter is True if there is MORE THAN one window group queued after the current one
sl@0: 					TDblQueIter<CWsWindowGroup> iter(*iQueue);
sl@0: 					iter.SetToLast();
sl@0: 					if(iter--!=this && iter!=this)
sl@0: 						{
sl@0: 						fAfter=ETrue;
sl@0: 						}
sl@0: 					TDblQue<CWsWindowGroup>* queue=NULL;
sl@0: 					// if fBefore and fAfter are True, create a new queue and copy all window groups after the current one into that queue
sl@0: 					if(fBefore && fAfter)
sl@0: 						{
sl@0: 						TInt ret=KErrNoMemory;
sl@0: 						queue=new TDblQue<CWsWindowGroup>(_FOFF(CWsWindowGroup,iChainLink));
sl@0: 						if(queue)
sl@0: 							{
sl@0: 							ret=iChains.Append(queue);	
sl@0: 							if(ret!=KErrNone)
sl@0: 								{
sl@0: 								delete queue;
sl@0: 								queue=NULL; 
sl@0: 								}
sl@0: 							}
sl@0: 						// Check that the queue creation and appending worked (we deque all the child groups even if it didn't) 
sl@0: 						if(ret!=KErrNone)
sl@0: 							{
sl@0: 							SetReply(ret);
sl@0: 							}
sl@0: 						}
sl@0: 					// If we've got zero or one window groups after, don't need to queue them
sl@0: 					if(!fAfter || fBefore)
sl@0: 						{
sl@0: 						iter.SetToLast();
sl@0: 						CWsWindowGroup* groupWin;
sl@0: 						while((groupWin=iter--)!=this)
sl@0: 							{
sl@0: 							groupWin->iChainLink.Deque();
sl@0: 							groupWin->iQueue=queue;
sl@0: 							if(queue)
sl@0: 								queue->AddFirst(*groupWin);
sl@0: 							}
sl@0: 						}
sl@0: 					// if we've got no window groups before, don't need to have a queue for this anymore
sl@0: 					if(!fBefore)
sl@0: 						{
sl@0: 						iChainLink.Deque();
sl@0: 						if (!fAfter)
sl@0: 							{
sl@0: 							DeleteQueue(iQueue);
sl@0: 							}
sl@0: 						iQueue=NULL;						
sl@0: 						}
sl@0: 					if (Screen())
sl@0: 						{
sl@0: 					MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
sl@0: 					if (windowTreeObserver)
sl@0: 						{
sl@0: 						windowTreeObserver->WindowGroupChainBrokenAfter(*this);
sl@0: 							}
sl@0: 						}					
sl@0: 					}
sl@0: 				else // if this window group isn't queued, we can't clear any children
sl@0: 					{
sl@0: 					SetReply(KErrArgument);
sl@0: 					}
sl@0: 				break;
sl@0: 			case EWsWinOpSetChildGroup:
sl@0: 				{
sl@0: 				CWsWindowGroup* childWinGroup = CWsWindowGroup::WindowGroupFromIdentifier(*pData.Int);
sl@0: 				if(!childWinGroup																	//(no child to append)
sl@0: 					|| (iQueue && (!iQueue->IsLast(this) || (childWinGroup->iQueue==iQueue)))		//(GpWin has a child) || (GpWin and childGpWin in the same queue)
sl@0: 					|| (childWinGroup->iQueue && !childWinGroup->iQueue->IsFirst(childWinGroup))	//(childGpWin has a parent)
sl@0: 					|| (childWinGroup == this))														//(childGpWin == GpWin)
sl@0: 					{
sl@0: 					SetReply(KErrArgument);
sl@0: 					break;
sl@0: 					}
sl@0: 				if(iQueue)
sl@0: 				// If we have a chain, we're prepending ourselves to the child window group
sl@0: 				// So we take the childs chain and prepend each of the window groups in our own chain
sl@0: 				// beginning with the current window group and working backward
sl@0: 					{
sl@0: 					TDblQueIter<CWsWindowGroup> iter(*iQueue);
sl@0: 					iter.SetToLast();
sl@0: 					CWsWindowGroup* groupWin;
sl@0: 					if(childWinGroup->iQueue)
sl@0: 						{
sl@0: 						TDblQue<CWsWindowGroup>* oldQueue=iQueue;
sl@0: 						while((groupWin=iter--)!=NULL)
sl@0: 							{
sl@0: 							groupWin->iChainLink.Deque();
sl@0: 							childWinGroup->iQueue->AddFirst(*groupWin);
sl@0: 							groupWin->iQueue=childWinGroup->iQueue;
sl@0: 							}
sl@0: 						DeleteQueue(oldQueue);
sl@0: 						}
sl@0: 					else
sl@0: 						{
sl@0: 						iQueue->AddLast(*childWinGroup);
sl@0: 						childWinGroup->iQueue=iQueue;							
sl@0: 						}
sl@0: 					}
sl@0: 				else
sl@0: 				// 1. If we don't have a chain, and if the child has a chain, we can simply prepend this wg to the child
sl@0: 				// wg chain
sl@0: 				// 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
sl@0: 				//    as the owning member, and prepend our window group
sl@0: 					{
sl@0: 					if(childWinGroup->iQueue)
sl@0: 						{
sl@0: 						childWinGroup->iQueue->AddFirst(*this);
sl@0: 						iQueue=childWinGroup->iQueue;
sl@0: 						}
sl@0: 					else
sl@0: 						{
sl@0: 						TDblQue<CWsWindowGroup>* queue=new TDblQue<CWsWindowGroup>(_FOFF(CWsWindowGroup,iChainLink));
sl@0: 						TInt ret=KErrNoMemory;
sl@0: 						if (queue)
sl@0: 							{
sl@0: 							ret=iChains.Append(queue);
sl@0: 							if(ret!=KErrNone)
sl@0: 								{
sl@0: 								delete queue;
sl@0: 								}
sl@0: 							}
sl@0: 						if(ret!=KErrNone)
sl@0: 							{
sl@0: 							SetReply(ret);
sl@0: 							break;
sl@0: 							}
sl@0: 						queue->AddFirst(*childWinGroup);
sl@0: 						childWinGroup->iQueue=queue;
sl@0: 						queue->AddFirst(*this);
sl@0: 						iQueue=queue;						
sl@0: 						}						
sl@0: 					}
sl@0: 				if (Screen())
sl@0: 					{
sl@0: 				MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();						
sl@0: 				if (windowTreeObserver)
sl@0: 					{
sl@0: 					windowTreeObserver->WindowGroupChained(*this, *childWinGroup);
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 				break;
sl@0: 			default:						// All other window commands disallowed
sl@0: 				OwnerPanic(EWservPanicOpcode);
sl@0: 			}
sl@0: 		}
sl@0: #if defined(_DEBUG)
sl@0: 	rootWindow->CheckTree();
sl@0: #endif
sl@0: 	}
sl@0: 	
sl@0: TPoint CWsWindowGroup::Origin() const
sl@0: 	{
sl@0: 	return TPoint(0,0);
sl@0: 	}
sl@0: 	
sl@0: TRect CWsWindowGroup::AbsRect() const
sl@0: 	{
sl@0: 	return (TRect(RootWindow()->Abs().iTl,RootWindow()->Size()));
sl@0: 	}
sl@0: 
sl@0: TSize CWsWindowGroup::Size() const
sl@0: 	{
sl@0: 	return RootWindow()->Size();
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SendState(MWsWindowTreeObserver& aWindowTreeObserver) const
sl@0: 	{	
sl@0: 	aWindowTreeObserver.NodeCreated(*this, ParentNode());
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SendStateWindowGroupChain(MWsWindowTreeObserver& aWindowTreeObserver) const
sl@0: 	{
sl@0: 	if ( iQueue && (!iQueue->IsEmpty()) && (iQueue->First()==this) )
sl@0: 		{
sl@0: 		TDblQueIter<CWsWindowGroup> iter(*iQueue);
sl@0: 		CWsWindowGroup* groupParent;
sl@0: 		CWsWindowGroup* groupChild;
sl@0: 		
sl@0: 		while ( (groupParent=iter++)!=NULL && (groupChild=iter)!=NULL )
sl@0: 			{
sl@0: 			aWindowTreeObserver.WindowGroupChained(*groupParent, *groupChild);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TInt CWsWindowGroup::Identifier() const
sl@0: 	{
sl@0: 	return iIdentifier;
sl@0: 	}
sl@0: 
sl@0: TPtrC CWsWindowGroup::Name() const
sl@0: 	{
sl@0: 	return (iGroupName) ? *iGroupName : KNullDesC();
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::IsFocusable() const
sl@0: 	{
sl@0: 	return ReceivesFocus();
sl@0: 	}
sl@0: 
sl@0: TInt CWsWindowGroup::OrdinalPriority() const
sl@0: 	{
sl@0: 	return iOrdinalPriorityBase;
sl@0: 	}
sl@0: 
sl@0: const MWsClient * CWsWindowGroup::Client() const
sl@0:     {
sl@0:     return static_cast<const MWsClient*>(WsOwner());
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CWsWindowGroup::UpdateKeyClickState()
sl@0: 	{
sl@0: 	CClick::SetKeyClickOveride(iFlags&EGroupFlagDisableKeyClick);
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::AreaCovered(TRegion &aRegion)
sl@0: 	{
sl@0: 	aRegion.Clear();
sl@0: 	for(CWsClientWindow *win=Child();win;win=win->NextSibling())
sl@0: 		aRegion.Union(*win->BaseArea());
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SetOrdinalPosition(TInt aPos)
sl@0: 	{
sl@0: 	if (aPos==(TInt)KOrdinalPositionSwitchToOwningWindow)
sl@0: 		SwitchToOwningWindow(NULL);
sl@0: 	else
sl@0: 		SetOrdinalPosition(aPos,NULL);
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::SetOrdinalPosition(TInt aPos,CWsWindowGroup* aClosingWindow)
sl@0: 	{
sl@0: 	TBool ret=ETrue;
sl@0: 	
sl@0: 	// Remember if the window group tree is actually changed or not, so that we know whether to 
sl@0: 	// check the render orientation after the re-ordering is done ( see CWsTop::CheckRenderOrientation()
sl@0: 	// call at end of this method
sl@0: 	TBool changed = CheckOrdinalPositionChange(aPos);	
sl@0: 	
sl@0: 	if (!iQueue)
sl@0: 		ret=DoSetOrdinalPosition1(aPos,aClosingWindow);
sl@0: 	else
sl@0: 		{
sl@0: 		TDblQueIter<CWsWindowGroup> iter(*iQueue);
sl@0: 		CWsWindowGroup* group;
sl@0: 		iter.SetToLast();
sl@0: 		TInt after=0;
sl@0: 		TInt before=0;
sl@0: 		TInt* inc=&before;
sl@0: 		while ((group=iter--)!=NULL)
sl@0: 			{
sl@0: 			if (group==this)
sl@0: 				inc=&after;
sl@0: 			++(*inc);
sl@0: 			}
sl@0: 		TInt lastWinGpPos=NumWindowGroupsOnMyScreen(OrdinalPriority())-after;
sl@0: 		if (aPos<0)
sl@0: 			aPos=lastWinGpPos;
sl@0: 		else
sl@0: 			aPos=Min(aPos,lastWinGpPos);
sl@0: 		aPos-=before;
sl@0: 		aPos=Max(aPos,0);
sl@0: 		iter.SetToLast();
sl@0: 		CWsWindowGroup* firstForward=iter--;
sl@0: 		while (firstForward && firstForward->OrdinalPosition(EFalse)<aPos)
sl@0: 			{
sl@0: 			firstForward=iter--;
sl@0: 			++aPos;
sl@0: 			}
sl@0: 		if (!firstForward)
sl@0: 			iter.SetToFirst();
sl@0: 		else
sl@0: 			{
sl@0: 			iter.Set(*firstForward);
sl@0: 			MoveChainedWindows(iter,ETrue,aPos,aClosingWindow);
sl@0: 			iter.Set(*firstForward);
sl@0: 			iter++;
sl@0: 			}
sl@0: 		MoveChainedWindows(iter,EFalse,--aPos,aClosingWindow);
sl@0: #if defined(_DEBUG)
sl@0: 		iter.SetToLast();
sl@0: 		TInt pos1=-1;
sl@0: 		TInt pos2;
sl@0: 		TBool ok=ETrue;
sl@0: 		while ((group=iter--)!=this)
sl@0: 			{
sl@0: 			pos2=group->OrdinalPosition(EFalse);
sl@0: 			if (pos2<=pos1)
sl@0: 				ok=EFalse;
sl@0: 			pos1=pos2;
sl@0: 			}
sl@0: 		WS_ASSERT_DEBUG(ok, EWsPanicGroupWindowChainError);
sl@0: #endif
sl@0: 		}
sl@0: 
sl@0: 	// If the ordinal positions have changed, check to see if there is a new render orientation
sl@0: 	// and publish it if so
sl@0: 	if(changed)
sl@0: 	    CWsTop::CheckRenderOrientation();
sl@0: 	
sl@0: 	return ret;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: void CWsWindowGroup::MoveChainedWindows(TDblQueIter<CWsWindowGroup>& aIter,TBool aForward,TInt aPos,CWsWindowGroup* aClosingWindow)
sl@0: 	{
sl@0: 	CWsWindowGroup* groupWindow;
sl@0: 	while ((groupWindow=(aForward ? aIter-- : aIter++))!=NULL)
sl@0: 		{
sl@0: 		groupWindow->DoSetOrdinalPosition1(aPos,aClosingWindow);
sl@0: 		(aForward ? ++aPos : --aPos);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::DoSetOrdinalPosition1(TInt aPos,CWsWindowGroup* aClosingWindow)
sl@0: 	{
sl@0: 	TBool ret=EFalse;
sl@0: 	if (CheckOrdinalPositionChange(aPos))
sl@0: 		{
sl@0: 		if (Child())	// A group window with no children can not affect shadows
sl@0: 			{
sl@0: 			ret=ETrue;
sl@0: 			}
sl@0: 		DoSetOrdinalPosition2(aPos,aClosingWindow);
sl@0: 		}
sl@0: 	else if (aClosingWindow)    // do not reset focus if current groupwindow did not change its ordinal position
sl@0: 		iScreen->ResetFocus(aClosingWindow);
sl@0: 	return ret;
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::DoSetOrdinalPosition2(TInt aPos, CWsWindowGroup *aClosingWindow)
sl@0: 	{
sl@0: 	ChangeWindowPosition(aPos,iParent);
sl@0: 	ResetFocus(aClosingWindow);
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::LostFocus()
sl@0: 	{
sl@0: 	iTextCursor.LostFocus();
sl@0: 	iWsOwner->UpdateWindowOrdinalPrioritys();
sl@0: 	if (iClientHandle!=0)
sl@0: 		QueueEvent(EEventFocusLost);
sl@0: 	TWalkWindowTreeFocusChanged wwt(EFalse);
sl@0: 	WalkWindowTree(wwt,EWalkChildren);
sl@0: 	iWsOwner->SetClientPriority();
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::ReceivedFocus()
sl@0: 	{
sl@0: 	iWsOwner->UpdateWindowOrdinalPrioritys();
sl@0: 	iTextCursor.ReceivedFocus();
sl@0: 	// Used for event queue testing
sl@0: 	// Calling MoveToFront sets the queue of the focused window to first place, 
sl@0: 	// not doing so puts the queues in unusual situation thus stress testing the queue code. 
sl@0: 	// One such situation is where the focus queue is first but there is a gap before it (iEventPtr>iGlobalEventPtr)" 
sl@0: #if defined(_DEBUG)
sl@0: 	if ((iEventQueueTest) && (++iSkipCount==5))
sl@0: 		{
sl@0: 		iSkipCount=0;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		WsOwner()->EventQueue()->MoveToFront();
sl@0: 		}
sl@0: #else
sl@0: 	WsOwner()->EventQueue()->MoveToFront();
sl@0: #endif
sl@0: 
sl@0: 	QueueEvent(EEventFocusGained);
sl@0: 	TWalkWindowTreeFocusChanged wwt(ETrue);
sl@0: 	WalkWindowTree(wwt,EWalkChildren);
sl@0: 	iWsOwner->SetClientPriority();
sl@0: 	UpdateKeyClickState();
sl@0: 	}
sl@0: 
sl@0: TInt CWsWindowGroup::NumWindowGroups(TBool aAllPriorities, TInt aPriority)
sl@0: 	{
sl@0: 	TInt count=0;
sl@0: 	TInt screenNo;
sl@0: 	for(screenNo=0;screenNo<CWsTop::NumberOfScreens();++screenNo)
sl@0: 		{
sl@0: 		count+=CWsWindowGroup::NumWindowGroupsOnScreen(CWsTop::Screen(screenNo)->RootWindow()->Child(),aAllPriorities,aPriority);
sl@0: 		}
sl@0: 	return(count);
sl@0: 	}
sl@0: 
sl@0: TInt CWsWindowGroup::NumWindowGroupsOnScreen(const CWsWindowGroup* aGroupWin,TBool aAllPriorities,TInt aPriority)
sl@0: 	{
sl@0: 	TInt count=0;
sl@0: 	while (aGroupWin)
sl@0: 		{
sl@0: 		if (aAllPriorities || aGroupWin->iOrdinalPriority==aPriority)
sl@0: 			++count;
sl@0: 		aGroupWin=aGroupWin->NextSibling();
sl@0: 		}
sl@0: 	return count;
sl@0: 	}
sl@0: 
sl@0: inline TInt CWsWindowGroup::NumWindowGroupsOnMyScreen(TInt aPriority)
sl@0: 	{
sl@0: 	return(CWsWindowGroup::NumWindowGroupsOnScreen(Parent()->Child(),EFalse,aPriority));
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::GetFocusWindowGroupL(TInt aScreenNumber)
sl@0: 	{
sl@0: 	CWsWindowGroup *groupWin=(aScreenNumber==KDummyScreenNumber)?CWsTop::FocusWindowGroup():CWsTop::Screen(aScreenNumber)->FocusWindowGroup();	
sl@0: 	if (!groupWin)
sl@0: 		User::Leave(KErrGeneral);
sl@0: 	CWsClient::SetReply(groupWin->Identifier());
sl@0: 	}
sl@0: 
sl@0: TInt CWsWindowGroup::GetWindowGroupListL(TInt aScreenNo,TBool aAllPriorities,TInt aPriority,TInt aCount,CArrayFixFlat<TInt>* aList)
sl@0: 	{
sl@0: 	TInt count=aList->Count();
sl@0: 	CWsWindowGroup* groupWin=CWsTop::Screen(aScreenNo)->RootWindow()->Child();
sl@0: 	while(!aAllPriorities && groupWin && groupWin->iOrdinalPriority!=aPriority)
sl@0: 		groupWin=groupWin->NextSibling();
sl@0: 	while(groupWin && (aAllPriorities || groupWin->iOrdinalPriority==aPriority) && count<aCount)
sl@0: 		{
sl@0: 		aList->AppendL(groupWin->Identifier());
sl@0: 		++count;
sl@0: 		groupWin=groupWin->NextSibling();
sl@0: 		}
sl@0: 	return count;
sl@0: 	}
sl@0: 	
sl@0: TInt CWsWindowGroup::SendWindowGroupListL(TInt aScreenNumber, TBool aAllPriorities, TInt aPriority, TInt aCount)
sl@0: 	{
sl@0: 	if ((aCount<1) || (aCount>(KArrayMaxGranularity/sizeof(TInt))))
sl@0: 		User::Leave(KErrArgument);
sl@0: 	CArrayFixFlat<TInt>* list=new(ELeave) CArrayFixFlat<TInt>(aCount);
sl@0: 	CleanupStack::PushL(list);
sl@0: 	TInt count(0);
sl@0: 	TInt requestedScreen=aScreenNumber;	
sl@0: 	if(requestedScreen==KDummyScreenNumber)
sl@0: 		{
sl@0: 		// get list from current focus screen first
sl@0: 		TInt focusScreenNo=CWsTop::CurrentFocusScreen()->ScreenNumber();
sl@0: 		count=GetWindowGroupListL(focusScreenNo, aAllPriorities, aPriority, aCount, list);
sl@0: 		if(count<aCount)
sl@0: 			{
sl@0: 			// now get from the remaining screen
sl@0: 			TInt screenNo;
sl@0: 			for(screenNo=0;screenNo<CWsTop::NumberOfScreens() && count<aCount;++screenNo)
sl@0: 				{
sl@0: 				// skip focus screen
sl@0: 				if (screenNo==focusScreenNo)
sl@0: 					continue;
sl@0: 				// count hold total number of window groups collected so far
sl@0: 				count=GetWindowGroupListL(screenNo, aAllPriorities, aPriority, aCount, list);
sl@0: 				}			
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		count=GetWindowGroupListL(requestedScreen, aAllPriorities, aPriority, aCount, list);	
sl@0: 		}
sl@0: 	if (list->Count() > 0)	
sl@0: 		CWsClient::ReplyBuf(&list->At(0),count*sizeof(TInt));
sl@0: 	CleanupStack::PopAndDestroy(list);
sl@0: 	return(count);	// How many actually returned, may be less than asked for, but not more
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::GetWindowGroupListAndChainL(TInt aScreen,TBool aAllPriorities,TInt aPriority
sl@0: 																,RArray<RWsSession::TWindowGroupChainInfo>& list,TInt& aCountLeft)
sl@0: 	{
sl@0: 	CWsWindowGroup *groupWin=CWsTop::Screen(aScreen)->RootWindow()->Child();
sl@0: 	while(!aAllPriorities && groupWin && groupWin->iOrdinalPriority!=aPriority)
sl@0: 		groupWin=groupWin->NextSibling();
sl@0: 	while(groupWin && (aAllPriorities || groupWin->iOrdinalPriority==aPriority) && aCountLeft>0)
sl@0: 		{
sl@0: 		RWsSession::TWindowGroupChainInfo windowId;
sl@0: 		windowId.iId=groupWin->Identifier();
sl@0: 		if(!groupWin->IsChained(windowId.iParentId))
sl@0: 			windowId.iParentId=-1;	//Unchained window group
sl@0: 		list.AppendL(windowId);
sl@0: 		--aCountLeft;
sl@0: 		groupWin=groupWin->NextSibling();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TInt CWsWindowGroup::SendWindowGroupListAndChainL(TBool aAllPriorities, TInt aPriority, TInt aCount)
sl@0: 	{
sl@0: 	if ((aCount<1) || (aCount>(KArrayMaxGranularity/sizeof(RWsSession::TWindowGroupChainInfo))))
sl@0: 		User::Leave(KErrArgument);
sl@0: 	RArray<RWsSession::TWindowGroupChainInfo> list(aCount);
sl@0: 	CleanupClosePushL(list);
sl@0: 	TInt count=aCount;
sl@0: 	TInt focusScreenNo=CWsTop::CurrentFocusScreen()->ScreenNumber();
sl@0: 	GetWindowGroupListAndChainL(focusScreenNo,aAllPriorities,aPriority,list,count);
sl@0: 	TInt screenNo;
sl@0: 	for(screenNo=0;screenNo<CWsTop::NumberOfScreens();++screenNo)
sl@0: 		{
sl@0: 		if (screenNo!=focusScreenNo)
sl@0: 			GetWindowGroupListAndChainL(screenNo,aAllPriorities,aPriority,list,count);
sl@0: 		}
sl@0: 	if (list.Count()>0)
sl@0: 		CWsClient::ReplyBuf(&list[0],aCount*sizeof(RWsSession::TWindowGroupChainInfo));
sl@0: 	CleanupStack::PopAndDestroy(&list);
sl@0: 	return(aCount-count);	// How many actually returned, may be less than asked for, but not more
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::SendEventToAllGroups(TBool aAllPriorities,TBool aOnePerClient,const TWsClCmdSendEventToWindowGroup& aData)
sl@0: 	{
sl@0: 	TWsEvent event=aData.event;
sl@0: 	if (event.Type()==EEventKey && event.Key()->iRepeats!=0)
sl@0: 		CKeyboardRepeat::CancelRepeat(NULL);		//Otherwise we will trip an invarient
sl@0: 	TInt priority=aData.parameter;
sl@0: 	TBool sentToAll=ETrue;
sl@0: 	TInt screenNo;
sl@0: 	for(screenNo=0;screenNo<CWsTop::NumberOfScreens();++screenNo)
sl@0: 		{
sl@0: 		CWsWindowGroup *groupWin=CWsTop::Screen(screenNo)->RootWindow()->Child();
sl@0: 		if (!aAllPriorities)
sl@0: 			{
sl@0: 			while(groupWin && groupWin->iOrdinalPriority!=priority)
sl@0: 				groupWin=groupWin->NextSibling();
sl@0: 			}
sl@0: 		CWsWindowGroup* firstGroupWin=groupWin;
sl@0: 		CWsClient* lastOwner=NULL;
sl@0: 		CWsWindowGroup* groupWin2;
sl@0: 		while(groupWin && (aAllPriorities || groupWin->iOrdinalPriority==priority))
sl@0: 			{
sl@0: 			if (aOnePerClient)
sl@0: 				{
sl@0: 				if (lastOwner==groupWin->iWsOwner)
sl@0: 					goto ContinueLoop;
sl@0: 				lastOwner=groupWin->iWsOwner;
sl@0: 				for(groupWin2=firstGroupWin;groupWin2!=groupWin;groupWin2=groupWin2->NextSibling())
sl@0: 					{
sl@0: 					if (groupWin2->iWsOwner==groupWin->iWsOwner)
sl@0: 						break;
sl@0: 					}
sl@0: 				if (groupWin2->iWsOwner==groupWin->iWsOwner && groupWin2!=groupWin)
sl@0: 					goto ContinueLoop;
sl@0: 				}
sl@0: 			event.SetHandle(groupWin->ClientHandle());
sl@0: 			if (!groupWin->EventQueue()->QueueEvent(event))
sl@0: 				sentToAll=EFalse;
sl@0: 		ContinueLoop:
sl@0: 			groupWin=groupWin->NextSibling();
sl@0: 			}
sl@0: 		}
sl@0: 	return sentToAll;
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::ReleasePendedMessagesToAllGroups(CWsClient * aClient)
sl@0: 	{
sl@0: 	TInt screenNo;
sl@0: 	for (screenNo = 0; screenNo < CWsTop::NumberOfScreens(); ++screenNo)
sl@0: 		{
sl@0: 		CWsWindowGroup* groupWin = CWsTop::Screen(screenNo)->RootWindow()->Child();
sl@0: 		while (groupWin)
sl@0: 			{
sl@0: 			if (groupWin->WsOwner() == aClient)
sl@0: 				{
sl@0: 				groupWin->ReleasePendedMessage();
sl@0: 				}
sl@0: 			groupWin = groupWin->NextSibling();
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::ReleasePendedMessage()
sl@0:     {
sl@0:     if (iMessageArray->Count() > 0 && !(iFlags & EGroupFlagMessageSignalled))
sl@0:         {
sl@0:         if (!SignalMessageReady())
sl@0: 			{
sl@0: 			//The event queue is overflow
sl@0: 			// Cannot send a message notification event. 
sl@0: 			WsOwner()->WgMsgQueueOverflow(); // Set flag for client about having pended message(s)
sl@0: 			}
sl@0:         }
sl@0:     }
sl@0: 
sl@0: void CWsWindowGroup::SendMessageToAllGroupsL(CWsClient& aSender,TBool aAllPriorities,const TWsClCmdSendMessageToWindowGroup& aData)
sl@0: 	{
sl@0: 	TInt screenNo;
sl@0: 	for(screenNo=0;screenNo<CWsTop::NumberOfScreens();++screenNo)
sl@0: 		{
sl@0: 		CWsWindowGroup* groupWin=CWsTop::Screen(screenNo)->RootWindow()->Child();		
sl@0: 		if (!aAllPriorities)
sl@0: 			{
sl@0: 			while(groupWin && groupWin->iOrdinalPriority!=aData.identifierOrPriority)
sl@0: 				groupWin=groupWin->NextSibling();
sl@0: 			}
sl@0: 		while(groupWin && (aAllPriorities || (groupWin->iOrdinalPriority==aData.identifierOrPriority)))
sl@0: 			{
sl@0: 			groupWin->QueueMessageL(aData.uid, aData.dataLength, aSender);
sl@0: 			groupWin=groupWin->NextSibling();
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: CWsWindowGroup *CWsWindowGroup::WindowGroupFromIdentifier(TInt aIdentifier)
sl@0: 	{
sl@0: 	// apply to all screens
sl@0: 	TInt screenNo;
sl@0: 	for (screenNo=0; screenNo<CWsTop::NumberOfScreens(); ++screenNo)
sl@0: 		{
sl@0: 		CWsWindowGroup* group;
sl@0: 		for(group=CWsTop::Screen(screenNo)->RootWindow()->Child(); group; group=group->NextSibling())
sl@0: 			{
sl@0: 			if (group->Identifier() == aIdentifier)
sl@0: 				return group;
sl@0: 			}
sl@0: 			
sl@0: 		}
sl@0: 		
sl@0: 	return NULL;
sl@0: 	}
sl@0: 
sl@0: CWsWindowGroup *CWsWindowGroup::WindowGroupFromIdentifierL(TInt aIdentifier)
sl@0: 	{
sl@0: 	CWsWindowGroup *group=WindowGroupFromIdentifier(aIdentifier);
sl@0: 	if (!group)
sl@0: 		User::Leave(KErrNotFound);
sl@0: 	return(group);
sl@0: 	}
sl@0: 
sl@0: CWsWindowGroup *CWsWindowGroup::FindWindowGroupL(CWsClient* aClient, TInt aIdentifier,TInt aOffset,const TPtrC *aMatch,const TThreadId *aThreadId)
sl@0: 	{
sl@0: 	CWsWindowGroup *group;
sl@0: 	if (aIdentifier)
sl@0: 		{
sl@0: 		group=WindowGroupFromIdentifier(aIdentifier);
sl@0: 		if (group)	// NULL group will cause KErrNotFound to be returned
sl@0: 			group=group->NextSibling();
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// get window group for this session
sl@0: 		//
sl@0: 		group = aClient->Screen()->RootWindow()->Child();
sl@0: 		}
sl@0: 
sl@0: 	for(;group;group=group->NextSibling())
sl@0: 		{
sl@0: 		if (aThreadId)
sl@0: 			{
sl@0: 			if (group->WsOwner()->Client().Id()==*aThreadId)
sl@0: 				break;	// Found one
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			const TDesC *groupName=&nullDescriptor;
sl@0: 			if (group->GroupName())
sl@0: 				groupName=group->GroupName();
sl@0: 			if (groupName->Length()>=aOffset && groupName->Mid(aOffset).MatchF(*aMatch)>=0)
sl@0: 				break;	// Found one
sl@0: 			}
sl@0: 		}
sl@0: 	if (!group)
sl@0: 		User::Leave(KErrNotFound);
sl@0: 	return(group);
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::AddPriorityKeyL(TUint aKeycode, TUint aModifierMask, TUint aModifiers)
sl@0: 	{
sl@0: 	iPriorityKeys=new(ELeave) TPriorityKey(aKeycode,aModifierMask,aModifiers,iPriorityKeys);
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::RemovePriorityKey(TUint aKeycode, TUint aModifierMask, TUint aModifiers)
sl@0: 	{
sl@0: 	for(TPriorityKey **ppk=&iPriorityKeys;*ppk;ppk=&((*ppk)->iNext))
sl@0: 		if ((*ppk)->Equals(aKeycode, aModifierMask, aModifiers))
sl@0: 			{
sl@0: 			TPriorityKey *next=(*ppk)->iNext;
sl@0: 			delete *ppk;
sl@0: 			*ppk=next;
sl@0: 			break;
sl@0: 			}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::RemoveAllPriorityKeys()
sl@0: 	{
sl@0: 	TPriorityKey *pk=iPriorityKeys;
sl@0: 	while(pk)
sl@0: 		{
sl@0: 		TPriorityKey *next=pk->iNext;
sl@0: 		delete pk;
sl@0: 		pk=next;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::CheckForPriorityKey(const TKeyEvent &aKeyEvent)
sl@0: 	{
sl@0: 	for(TPriorityKey *pk=iPriorityKeys;pk;pk=pk->iNext)
sl@0: 		{
sl@0: 		if (pk->KeyMatches(aKeyEvent))
sl@0: 			{	
sl@0: 			WsOwner()->PriorityKeyPressed(ClientHandle(), aKeyEvent);
sl@0: 			return(ETrue);
sl@0: 			}
sl@0: 		}
sl@0: 	return(EFalse);
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::StatusDump(TDes &aBuf)
sl@0: 	{
sl@0: 	_LIT(KWSERVStatusDumpWindowGroupInfo,"CWsWindowGroup[0x%x]RWindowGroup[0x%x,%d],Pri=%d,Id=%d,SizeMode=%d");
sl@0: 	aBuf.AppendFormat(KWSERVStatusDumpWindowGroupInfo,this,iClientHandle,LogHandle(),iOrdinalPriority,iIdentifier,iScreenDevice?iScreenDevice->AppMode():0);
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::SignalMessageReady()
sl@0: 	{
sl@0: 	TWsEvent event;
sl@0: 	event.SetType(EEventMessageReady);
sl@0: 	event.SetHandle(ClientHandle());
sl@0: 	event.SetTimeNow();
sl@0: 	SEventMessageReady& eventMessageReady=*(SEventMessageReady*)event.EventData();
sl@0: 	eventMessageReady.iWindowGroupIdentifier=Identifier();
sl@0: 	eventMessageReady.iMessageUid=(*iMessageArray)[0].iUid;
sl@0: 	eventMessageReady.iMessageParametersSize=iMessageArray->Length(0)-sizeof(TUid);
sl@0: 	TBool result = WsOwner()->EventQueue()->QueueEvent(event, EEventPriorityHigh);
sl@0: 	if (result)
sl@0: 		{
sl@0: 		iFlags |= EGroupFlagMessageSignalled;
sl@0: 		}
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::QueueMessageL(TUid aUid, TInt aDataLength, CWsClient& aSender)
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(iFlags&(EGroupFlagMsgQueueActive|EGroupFlagMsgQueueNew) || iMessageArray->Count()>=1,EWsPanicMsgQueueError);
sl@0: 	if (!(iFlags&(EGroupFlagMsgQueueActive|EGroupFlagMsgQueueNew)) && iMessageArray->Count()>=KMaxNumberOfMsgsInInactiveQueue)
sl@0: 		{
sl@0: 		WS_ASSERT_DEBUG(iMessageArray->Count()<=KMaxNumberOfMsgsInInactiveQueue,EWsPanicMsgQueueError);
sl@0: 		iMessageArray->Delete(1,iMessageArray->Count()-1);
sl@0: 		}
sl@0: 	TWsMessage* message=NULL;
sl@0: 	TRAPD(err,message=&iMessageArray->ExtendL(aDataLength+sizeof(aUid)));
sl@0: 	if ((err || (iFlags&EGroupFlagMsgQueueNew)) && iMessageArray->Count()>KMaxNumberOfMsgsInQueue)
sl@0: 		{
sl@0: 		iFlags&=~(EGroupFlagMsgQueueActive|EGroupFlagMsgQueueNew);
sl@0: 		iMessageArray->Delete(1,iMessageArray->Count()-(err?1:2));
sl@0: 		iMessageArray->Compress();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	if (message)
sl@0: 		{
sl@0: 		message->iUid=aUid;
sl@0: 		TPtr8 ptr(&message->iTheRest[0],aDataLength);
sl@0: 		TRAP(err,aSender.RemoteReadL(ptr,0));
sl@0: 		if (err)
sl@0: 			{
sl@0: 			iMessageArray->Delete(iMessageArray->Count()-1);
sl@0: 			User::Leave(err);
sl@0: 			}
sl@0: 		if (!(iFlags & EGroupFlagMessageSignalled))
sl@0: 			{
sl@0: 			if (!SignalMessageReady())
sl@0: 				{
sl@0: 				//The event queue is overflow
sl@0: 				// Cannot send a message notification event. 
sl@0: 				WsOwner()->WgMsgQueueOverflow(); // Set flag for client about having pended message(s)
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::FetchMessageL()
sl@0: 	{
sl@0: 	if (!(iFlags & EGroupFlagMessageSignalled))
sl@0: 		{
sl@0: 		OwnerPanic(EWservPanicFetchMessage);
sl@0: 		}
sl@0: 	CWsClient::ReplyBuf(&((*iMessageArray)[0].iTheRest[0]), (TInt) iMessageArray->Length(0) - sizeof(TUid));
sl@0: 	iMessageArray->Delete(0);
sl@0: 	iFlags |= EGroupFlagMsgQueueActive;
sl@0: 	iFlags &= ~(EGroupFlagMessageSignalled | EGroupFlagMsgQueueNew);
sl@0: 	if (iMessageArray->Count() > 0)
sl@0: 		{
sl@0: 		if (!SignalMessageReady())
sl@0: 			{
sl@0: 			//The event queue is overflow
sl@0: 			// Cannot send a message notification event. 
sl@0: 			WsOwner()->WgMsgQueueOverflow(); // Set flag for client about having pended message(s)
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::ScreenDeviceValid() const
sl@0: 	{
sl@0: 	return(iScreenDevice?iScreenDevice->ScreenDeviceValidState():(iScreen->ScreenSizeMode()==0));
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::CanReceiveFocus() const
sl@0: 	{
sl@0: 	return(ReceivesFocus() && iWsOwner->NotClosing() && (ScreenDeviceValid() || iFlags&EGroupFlagHandlesDeviceChange));
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SetScreenChangeEventStateL(TBool aEnabled)
sl@0: 	{
sl@0: 	iFlags&=~EGroupFlagHandlesDeviceChange;
sl@0: 	if (aEnabled)
sl@0: 		{
sl@0: 		iFlags|=EGroupFlagHandlesDeviceChange;
sl@0: 		TWindowServerEvent::AddToScreenDeviceChangeEventListL(*this);
sl@0: 		if (iScreen->ScreenSizeMode()!=0)
sl@0: 			TWindowServerEvent::SendScreenDeviceChangedEvent(this);
sl@0: 		}
sl@0: 	else
sl@0: 		TWindowServerEvent::RemoveFromScreenDeviceChangeEventList(*this);
sl@0: 	iScreen->ResetFocus(NULL);
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SetScreenDeviceValidState(const DWsScreenDevice *aDevice)
sl@0: 	{
sl@0: 	if (iScreenDevice==aDevice)
sl@0: 		{
sl@0: 		TBool state=ScreenDeviceValid();
sl@0: 		for(CWsTopClientWindow *win=Child();win;win=win->NextSiblingTop())
sl@0: 			{
sl@0: 			win->SetScreenDeviceValidState(state);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SetScreenDeviceValidStates(const DWsScreenDevice *aDevice)
sl@0: 	{
sl@0: 	for(CWsWindowGroup *groupWin=aDevice->RootWindow()->Child();groupWin;groupWin=groupWin->NextSibling())
sl@0: 		groupWin->SetScreenDeviceValidState(aDevice);
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SetScreenDeviceValidStates(CScreen* aScreen)
sl@0: 	{
sl@0: 	CWsRootWindow* rootWindow = aScreen->RootWindow();
sl@0: 
sl@0: 	CWsWindowGroup* groupWin;
sl@0: 	CWsTopClientWindow* win;
sl@0: 	for(groupWin=rootWindow->Child();groupWin;groupWin=groupWin->NextSibling())
sl@0: 		{
sl@0: 		TBool state=groupWin->ScreenDeviceValid();
sl@0: 		for(win=groupWin->Child();win;win=win->NextSiblingTop())
sl@0: 			{
sl@0: 			win->SetScreenDeviceValidStateFlag(state);
sl@0: 			win->ResetHiddenFlagsInParentAndChildren();
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::SetScreenDevice(DWsScreenDevice *aDevice)
sl@0: 	{
sl@0: 	iScreenDevice=aDevice;	
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::NewOrientation(TInt aMode,CFbsBitGc::TGraphicsOrientation aRotation, CWsRootWindow* aRootWindow)
sl@0: 	{
sl@0: 	for(CWsWindowGroup *groupWin=aRootWindow->Child();groupWin;groupWin=groupWin->NextSibling())
sl@0: 		{
sl@0: 		DWsScreenDevice *device=groupWin->Device();
sl@0: 		if (device)
sl@0: 			device->NewOrientation(aMode,aRotation);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsWindowGroup::ResetFocus(CWsWindowGroup *aClosingWindow)
sl@0: 	{
sl@0: 	if (iScreen)
sl@0: 		{
sl@0: 		iScreen->ResetFocus(aClosingWindow);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::IsChained(TInt& aParentId)
sl@0: 	{
sl@0: 	if (!iQueue)
sl@0: 		return EFalse;
sl@0: 	if (iQueue->First()==this)
sl@0: 		aParentId=0;
sl@0: 	else
sl@0: 		aParentId=BeforeInChain()->Identifier();
sl@0: 	return ETrue;
sl@0: 	}
sl@0: 
sl@0: inline CWsWindowGroup* CWsWindowGroup::BeforeInChain()
sl@0: 	{		//You should only call this function if you know the window has a parent
sl@0: 	return reinterpret_cast<CWsWindowGroup*>(PtrSub(iChainLink.iPrev,_FOFF(CWsWindowGroup,iChainLink)));
sl@0: 	}
sl@0: 
sl@0: TBool CWsWindowGroup::CheckCapability(TInt& aOrdinalPriority)
sl@0: 	{
sl@0: 	if(aOrdinalPriority>=KPasswordWindowGroupPriority)
sl@0: 		{
sl@0: 		if(!KSecurityPolicy_SwEvent().CheckPolicy(WsOwner()->Client(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed")))
sl@0: 			{
sl@0: 			aOrdinalPriority=KPasswordWindowGroupPriority-1;
sl@0: 			return EFalse;
sl@0: 			}
sl@0: 		}
sl@0:  	return ETrue;
sl@0: 	}
sl@0: 	
sl@0: TBool CWsWindowGroup::HasVisibleTranslucentChild()
sl@0: 	{
sl@0: 	CWsWindowBase * child = iChild;
sl@0: 	while (child)
sl@0: 		{
sl@0: 		if (child->WinType() == EWinTypeClient)
sl@0: 			{
sl@0: 			CWsClientWindow * cliwin = static_cast<CWsClientWindow *>(child);
sl@0: 			if (cliwin->IsTranslucent() && cliwin->IsVisible())
sl@0: 				return ETrue;
sl@0: 			}
sl@0: 		else if (static_cast<CWsWindowGroup*>(child)->HasVisibleTranslucentChild())
sl@0: 			{
sl@0: 			return ETrue;
sl@0: 			}
sl@0: 		child = child->NextSibling();
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TInt CWsWindowGroup::NumClientWindowGroups()
sl@0: 	{
sl@0: 	CWsObjectIx& objix=*WsOwner()->ObjectIndex();
sl@0: 	const TWsObject* ptr=objix.FirstObject();
sl@0: 	const TWsObject* end=ptr+objix.Length();
sl@0: 	TInt count=0;
sl@0: 	while(++ptr<end)		//First one should always have a NULL object
sl@0: 		{
sl@0: 		const CWsObject* obj=ptr->iObject;
sl@0: 		if (obj && obj->Type()==WS_HANDLE_GROUP_WINDOW)
sl@0: 			++count;
sl@0: 		}
sl@0: 	return count;
sl@0: 	}
sl@0: 	
sl@0: void CWsWindowGroup::SetEventQueueTestState(TBool aEventQueState)
sl@0: 	{
sl@0: 	iEventQueueTest = aEventQueState;
sl@0: 	}