// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Group window sub-class of CWsWindow

// 

//

#include <e32std.h>

#include "W32STD.H"

#include "W32CLICK.H"

#include "server.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "walkwindowtree.h"

#include "wstop.h"

#include "EVENT.H"

#include "KEYCLICK.H"

#include "PRIKEY.H"

#include "panics.h"

#include "windowelementset.h"

#include "pointer.h"

GLREF_D TPtr nullDescriptor;

GLREF_D CDebugLogBase* wsDebugLog;

#if defined(_DEBUG)

TInt CWsWindowGroup::iSkipCount=0;

#endif

TBool CWsWindowGroup::iEventQueueTest=EFalse;			// For stress testing the EventQueue code

TInt CWsWindowGroup::iIdentifierCount=1;

TBool CWsWindowGroup::iFocusGainPreProcess=EFalse;		//'REMOVEFADINGONFOCUSGAIN' flag in INI file

RPointerArray< TDblQue<CWsWindowGroup> > CWsWindowGroup::iChains(3);

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);

const TInt KArrayMaxGranularity=0x10000000;

CWsWindowGroup* CWsWindowGroup::NewL(CWsClient* aOwner, CScreen* aScreen, 

	const TWsClCmdCreateWindowGroup& aCmd)

	{

	CWsWindowGroup* self = new(ELeave) CWsWindowGroup(aOwner, aScreen);

	CleanupStack::PushL(self);

	self->ConstructL(aCmd);

	CleanupStack::Pop(self);

	return self;

	}

CWsWindowGroup::CWsWindowGroup(CWsClient* aOwner, CScreen* aScreen) : CWsWindowBase(aOwner,WS_HANDLE_GROUP_WINDOW,aScreen)

	{

	__DECLARE_NAME(_S("CWsWindowGroup"));

	iWinType=EWinTypeGroup;

	}

void CWsWindowGroup::PurgeCapturedKeys()

	{

	CWsObjectIx& objix=*WsOwner()->ObjectIndex();

	const TWsObject* ptr=objix.FirstObject();

	const TWsObject* end=ptr+objix.Length();

	while(++ptr<end)		//Fisrt one should always have a NULL object

		{

		const CWsObject* obj=ptr->iObject;

		if (obj 

			&& ((obj->Type()==WS_HANDLE_CAPTURE_KEY && STATIC_CAST(const CWsCaptureKey*,obj)->WindowGroup()==this)

				|| (obj->Type()==WS_HANDLE_CAPTURE_KEY_UPDOWNS && STATIC_CAST(const CWsCaptureKeyUpsAndDowns*,obj)->WindowGroup()==this)

				|| (obj->Type()==WS_HANDLE_CAPTURE_LONG_KEY && STATIC_CAST(const CWsCaptureLongKey*,obj)->WindowGroup()==this)))

			{

			objix.Remove(ptr);

			delete obj;

			}

		}

	objix.Tidy();

	CKeyboardRepeat::CancelRepeat(this);

	}

void CWsWindowGroup::SwitchToOwningWindow(CWsWindowGroup *aClosingWindow)

	{

	if (this==CWsTop::FocusWindowGroup())

		{

		CWsWindowGroup *winGroup=NULL;

//

// First try for an 'owning' window

//

		if (iOwningWindowGroup)

			{

			for(winGroup=RootWindow()->Child();winGroup;winGroup=winGroup->NextSibling())

				if (winGroup->Identifier()==iOwningWindowGroup && winGroup->iOrdinalPriority==iOrdinalPriority)

					goto gotIt;

			}

//

// If that failed look for the frontmost window belonging to the owner of dying window

//

		for(winGroup=RootWindow()->Child();winGroup;winGroup=winGroup->NextSibling())

			if (winGroup!=this && winGroup->WsOwner()==WsOwner() && winGroup->iOrdinalPriority==iOrdinalPriority)

				goto gotIt;

//

// Next try for the nominated default owning window group

//

		winGroup=iScreen->DefaultOwningWindowGroup();

		if (winGroup && winGroup->iOrdinalPriority==iOrdinalPriority)

			{

gotIt:		winGroup->SetOrdinalPosition(0,this);

			return;

			}

		}

	ResetFocus(aClosingWindow);

	}

CWsWindowGroup::~CWsWindowGroup()

	{

	MWsWindowTreeObserver* windowTreeObserver = NULL;

	if (Screen()&& iBaseWinFlags&EBaseWinNodeCreated)

		{

		windowTreeObserver = Screen()->WindowTreeObserver();

		if (windowTreeObserver)

			{

			if( iQueue && (iQueue->Last()!=this) )

				{

				//This node is part of chain, send notification unless this is the last node in the chain

				windowTreeObserver->WindowGroupChainBrokenAfter(*this);

				}

			windowTreeObserver->NodeReleased(*this);

			iBaseWinFlags &= ~EBaseWinNodeCreated;

			}

		}

	DisconnectFloatingSprites();

	if (wsDebugLog)

		{

		TLogMessageText buf;

		_LIT(KWSERVDebugLogGroupWindowId,"Destroying: RWindowGroup[0x%x,%d],Id=%d");

		buf.Format(KWSERVDebugLogGroupWindowId,iClientHandle,LogHandle(),iIdentifier);

		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, buf);

		}

	if (CClick::IsHandler())

		CClick::OtherEvent(EEventGroupWindowClose,reinterpret_cast<TAny*>(iIdentifier));

	if (iQueue)

		{

		if (iQueue->Last()!=this)

			{		//Unlink all the children of the window that is being deleted

			TDblQueIter<CWsWindowGroup> iter(*iQueue);

			CWsWindowGroup* groupWin;

			iter.SetToLast();

			while ((groupWin=iter--)!=this)

				{

				WS_ASSERT_DEBUG(groupWin!=NULL && groupWin->iQueue==iQueue,EWsPanicGroupWindowChainError);

				if ( windowTreeObserver && (iQueue->Last()!=groupWin) )

					{

					//Send notification unless groupWin is the last node in the chain

					windowTreeObserver->WindowGroupChainBrokenAfter(*groupWin);

					}

				groupWin->iChainLink.Deque();

				// coverity[extend_simple_error]

				groupWin->iQueue=NULL;

				}

			}

		WS_ASSERT_DEBUG(iQueue->Last()==this,EWsPanicGroupWindowChainError);

		if(windowTreeObserver && !iQueue->IsEmpty())

			{

			//If there are chained nodes before this one, notify "chain broken" immediately before this node 

			TDblQueIter<CWsWindowGroup> iter(*iQueue);

			iter.SetToLast(); 	//i.e. set to this (see assert above)

			iter--;				//i.e. set to parent

			CWsWindowGroup* parent = iter;

			if(parent)

				{

				windowTreeObserver->WindowGroupChainBrokenAfter(*parent);

				}

			}

		TDblQueLinkBase* parentLink=iChainLink.iPrev;

		iChainLink.Deque();

		if (parentLink->iNext==parentLink->iPrev)		//Check to see chain no longer required

			{

			if (!iQueue->IsEmpty())

				{				//Only the parent is left in queue

				CWsWindowGroup* parent=iQueue->First();

				static_cast<TDblQueLink*>(parentLink)->Deque();

				WS_ASSERT_DEBUG(parent->iQueue==iQueue,EWsPanicGroupWindowChainError);

				// coverity[extend_simple_error]

				parent->iQueue=NULL;

				}

			DeleteQueue(iQueue);

			}

		}

	RemoveAllPriorityKeys();

	PurgeCapturedKeys();

	iTextCursor.Close();

	SetPointerCursor(NULL);

	for(CWsTopClientWindow *win=Child();win;win=win->NextSiblingTop())

		win->SetInactive();

	if (iScreen)

		{

		iScreen->RemoveFromDefaultOwningList(this);

		}

	CWsWindowBase::Shutdown();

	TWindowServerEvent::SendGroupChangedEvents();

	// coverity[extend_simple_error]

	iClientHandle=0;	// To block focus lost events being sent

// Decide which window to give focus to if WServ isn't shutting down

	if (iScreen && !CWsTop::ShuttingDown())

		SwitchToOwningWindow(this);

	delete iGroupName;

	delete iMessageArray;

	}

void CWsWindowGroup::DisconnectFloatingSprites()

	{

	CWsSpriteBase * current = iSpriteList;

	while (current)

		{

		CWsSpriteBase * next = current->Next();

		current->Deactivate();

		current->DisconnectGroupWin();

		current = next;

		}

	}

void CWsWindowGroup::DeleteQueue(TDblQue<CWsWindowGroup>* aQueue)

	{

	iChains.Remove(iChains.Find(aQueue));

	delete aQueue;

	if (iChains.Count()==0)

		{

		iChains.Compress();

		}

	}

void CWsWindowGroup::AdvanceIdentifierCount()

	{

	if (++iIdentifierCount>EMaxIdentifierCount)

		iIdentifierCount=1;		// so limit it to low value

	}

void CWsWindowGroup::ConstructL(const TWsClCmdCreateWindowGroup &aCmd)

	{

#if defined(_DEBUG)

	if (IsClientHandleInUse(aCmd.clientHandle))

		{

		OwnerPanic(EWservPanicDuplicateHandle);

		}

#endif

	NewObjL();

	iFlags=EGroupFlagAutoForeground|EGroupFlagMsgQueueNew;

	if (aCmd.focus)

		{

		iFlags|=EGroupFlagReceivesFocus;

		}

	iTextCursor.ConstructL(this);

	iClientHandle=aCmd.clientHandle;

	if(aCmd.screenDeviceHandle <= 0)

		{

		//Use primary screen. Client should make sure PrimaryScreenDevice is correct set up immediately after establishing session.

		iScreenDevice=iWsOwner->PrimaryScreenDevice();

		}

	else

		{

		//Use the specified screen

		iScreenDevice=STATIC_CAST(DWsScreenDevice*,iWsOwner->HandleToObj(aCmd.screenDeviceHandle,WS_HANDLE_SCREEN_DEVICE));

		}

	iScreen = (iScreenDevice) ? iScreenDevice->Screen() : CWsTop::Screen(); //if no screen device use screen 0

	CWsWindowGroup* parent=NULL;

	if (aCmd.parentId>0)

		{

		parent=CWsWindowGroup::WindowGroupFromIdentifier(aCmd.parentId);

		if (!parent)

			{

			OwnerPanic(EWservPanicWindow);

			}

 		if(parent->Screen() != iScreen)

 			{

 			OwnerPanic(EWservPanicWrongScreen);

 			}

		if (parent->iOrdinalPriorityAdjust>0)

			{

			WS_ASSERT_DEBUG(parent->iQueue==NULL,EWsPanicGroupWindowChainError);

			parent->iOrdinalPriorityAdjust=0;

			parent->UpdateOrdinalPriority(ETrue);

			}

		iOrdinalPriorityBase=parent->iOrdinalPriorityBase;

		iOrdinalPriority=iOrdinalPriorityBase;

		}

	do

		{

		AdvanceIdentifierCount();	// Always advance by at least one to stop re-using last id

		} while (WindowGroupFromIdentifier(iIdentifierCount)); // If current count is in use try again

	iIdentifier=iIdentifierCount;

	CWsWindowBase::ConstructL(RootWindow());

	iScreen->ResetFocus(NULL);

	if (parent)

		{

		TDblQue<CWsWindowGroup>* queue=parent->iQueue;

		if (queue && queue->Last()!=parent)

			User::Leave(KErrInUse);

		if (parent->iWsOwner!=iWsOwner)

			{

			_LIT_SECURITY_POLICY_S0(securityPolicy,parent->iChildSID);

			if (!securityPolicy().CheckPolicy(iWsOwner->ClientMessage()))

				User::Leave(KErrPermissionDenied);

			}

		if (!queue)

			{

			queue=new(ELeave) TDblQue<CWsWindowGroup>(_FOFF(CWsWindowGroup,iChainLink));

			CleanupStack::PushL(queue);

			User::LeaveIfError(iChains.Append(queue));

			CleanupStack::Pop(queue);

			queue->AddFirst(*parent);

			parent->iQueue=queue;			

			}

		iQueue=queue;		//Shouldn't set the queue until after it can leave

		iChainLink.Enque(&parent->iChainLink);

		MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();						

		if (windowTreeObserver)

			{

			windowTreeObserver->WindowGroupChained(*parent, *this);

			}			

		}

	iMessageArray=new(ELeave) CArrayVarSeg<TWsMessage>(1);

	if (CClick::IsHandler())

		{

		TGroupWindowOpenData params;

		params.iIdentifier=iIdentifier;

		params.iClient=iWsOwner->ConnectionHandle();

		params.iNumClientWindowGroups=NumClientWindowGroups()-1;	//Don't include this one

		CClick::OtherEvent(EEventGroupWindowOpen,&params);

		}

	if (wsDebugLog)

		{

		TLogMessageText buf;

		_LIT(KWSERVDebugLogGroupWindowId,"Creating: RWindowGroup[0x%x,%d],Id=%d");

		buf.Format(KWSERVDebugLogGroupWindowId,iClientHandle,LogHandle(),iIdentifier);

		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, buf);

		}

	}

void CWsWindowGroup::UpdateOrdinalPriority(TBool aDoAdjust)

	{

	TInt newPri;

	newPri=iOrdinalPriorityBase;

	if (iWsOwner==CWsTop::FocusWindowGroupOwner())

		newPri+=iOrdinalPriorityAdjust;

	CheckCapability(newPri);

	if (newPri!=iOrdinalPriority)

		{

		iOrdinalPriority=newPri;

		if (aDoAdjust)

			SetOrdinalPosition(0);

		}

	}

void CWsWindowGroup::SetOrdinalPriority(TInt aPos,TInt aPriority)

	{

	if (!iQueue)

		{

		iOrdinalPriorityBase=aPriority;

		UpdateOrdinalPriority(EFalse);

		}

	else

		{

		TDblQueIter<CWsWindowGroup> iter(*iQueue);

		CWsWindowGroup* group;

		while ((group=iter++)!=NULL)

			{

			group->iOrdinalPriorityBase=aPriority;

			group->iOrdinalPriority=aPriority;

			}

		}

	SetOrdinalPosition(aPos);

	}

void CWsWindowGroup::CommandL(TInt aOpcode, const TAny *aCmdData)

	{

#ifdef _DEBUG

	// Save root window for performing CheckTree at the end of this func.

	// When aOpcode is EWsWinOpFree, this object would've been destroyed

	// and a call to RootWindow() in that case would be impossible

	CWsRootWindow* rootWindow=RootWindow();

	// For certain opcodes, check for the 'screen device deleted' condition. If it

	// has occured for the screen device associated with this group window then

	// those op-codes are not valid, and the client is panicked.

	switch (aOpcode)

		{

		case EWsWinOpEnableScreenChangeEvents:

		case EWsWinOpAllowChildWindowGroup:

		case EWsWinOpReceiveFocus:

		case EWsWinOpAutoForeground:

		case EWsWinOpSetOrdinalPositionPri:

		case EWsWinOpSetOrdinalPriorityAdjust:

		case EWsWinOpCaptureKey:

		case EWsWinOpCaptureKeyUpsAndDowns:

		case EWsWinOpCaptureLongKey:

		case EWsWinOpAddPriorityKey:

		case EWsWinOpSetTextCursor:

		case EWsWinOpSetTextCursorClipped:

		case EWsWinOpSetOwningWindowGroup:

		case EWsWinOpDefaultOwningWindow:

		case EWsWinOpSetName:

		case EWsWinOpDisableKeyClick:

		case EWsWinOpSendPointerEvent:

		case EWsWinOpSendAdvancedPointerEvent:

			{

			if (ScreenDeviceDeleted())

				OwnerPanic(EWservPanicGroupWinScreenDeviceDeleted);

			break;				

			};

		}

#endif

	TWsWinCmdUnion pData;

	pData.any=aCmdData;

	if (CWsWindowBase::CommandL(aOpcode,pData)==EFalse)

		{

		switch(aOpcode)

			{

			case EWsWinOpAllowChildWindowGroup:

				iChildSID=*pData.UInt;

				break;

			case EWsWinOpEnableScreenChangeEvents:

				SetScreenChangeEventStateL(ETrue);

				break;

			case EWsWinOpDisableScreenChangeEvents:

				SetScreenChangeEventStateL(EFalse);

				break;

			case EWsWinOpReceiveFocus:

				if (*pData.Bool!=(iFlags&EGroupFlagReceivesFocus))

					{

					iFlags&=~EGroupFlagReceivesFocus;

					if (*pData.Bool)

						iFlags|=EGroupFlagReceivesFocus;

					iScreen->ResetFocus(NULL);

					}

				break;

			case EWsWinOpAutoForeground:

				iFlags&=~EGroupFlagAutoForeground;

				if (*pData.Bool)

					iFlags|=EGroupFlagAutoForeground;

				break;

			case EWsWinOpSetOrdinalPositionPri:

			case EWsWinOpSetOrdinalPositionErr:

				{

				TInt priority=pData.OrdinalPos->ordinalPriority;

				TBool hascap = CheckCapability(priority);

				SetOrdinalPriority(pData.OrdinalPos->pos, priority);

				if (aOpcode == EWsWinOpSetOrdinalPositionErr)

					{

					SetReply(hascap?KErrNone:KErrPermissionDenied);

					}

				}

				break;

			case EWsWinOpSetOrdinalPriorityAdjust:

				if (!iQueue)

					{

					iOrdinalPriorityAdjust=*pData.Int;

					UpdateOrdinalPriority(ETrue);

					}

				break;

			case EWsWinOpCaptureKey:

				{

				if(!KSecurityPolicy_SwEvent().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::CaptureKey API")))

					{

					User::Leave(KErrPermissionDenied);

					}

				CWsCaptureKey *cKey=new(ELeave) CWsCaptureKey(this);

				CleanupStack::PushL(cKey);

				cKey->ConstructL(*pData.CaptureKey);

				CleanupStack::Pop();

				}

				break;

			case EWsWinOpCaptureKeyUpsAndDowns:

				{

				if(!KSecurityPolicy_SwEvent().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::CaptureKeyUpsAndDowns API")))

					{

					User::Leave(KErrPermissionDenied);

					}

				CWsCaptureKeyUpsAndDowns *cKey=new(ELeave) CWsCaptureKeyUpsAndDowns(this);

				CleanupStack::PushL(cKey);

				cKey->ConstructL(*pData.CaptureKey);

				CleanupStack::Pop();

				}

				break;

			case EWsWinOpCaptureLongKey:

				{

				if(!KSecurityPolicy_SwEvent().CheckPolicy(iWsOwner->ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowGroup::CaptureLongKey API")))

					{

					User::Leave(KErrPermissionDenied);

					}

				CWsCaptureLongKey *cKey=new(ELeave) CWsCaptureLongKey(this);

				CleanupStack::PushL(cKey);

				cKey->ConstructL(*pData.CaptureLongKey);

				CleanupStack::Pop();

				}

				break;

			case EWsWinOpCancelCaptureKey:

				if (*pData.UInt!=0)	// Ignore null handle

					{

					CWsObject *destroyObj = iWsOwner->HandleToObj(*pData.UInt, WS_HANDLE_CAPTURE_KEY);

					if (destroyObj)

						{

						delete destroyObj;

						}

					else

						{

#ifdef _DEBUG

						// Attempt to cancel key capture with an incorrect handle

						OwnerPanic(EWservPanicDestroy);  

#endif // _DEBUG

						}