// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
// 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:
// Window virtual base class, windows and window groups are derived from this
// 
//

#include <e32std.h>
#include "server.h"
#include "winbase.h"
#include "rootwin.h"
#include "windowgroup.h"
#include "walkwindowtree.h"
#include "wstop.h"
#include "EVQUEUE.H"
#include "EVENT.H"
#include "panics.h"
#include "pointer.h"
#include "windowelementset.h"

CWsWindowBase::CWsWindowBase(CWsClient* aOwner,WH_HANDLES aType, CScreen* aScreen) : CWsScreenObject(aOwner,aType,aScreen)		
	{
	}

void CWsWindowBase::ConstructL(CWsWindowBase *aParent)
	{
	iParent=aParent;
	iSibling=aParent->iChild;
	aParent->iChild=this;
	CScreen* screen = aParent->Screen();
	WS_ASSERT_DEBUG(screen,EWsPanicNoScreen);
	MWsWindowTreeObserver* const windowTreeObserver = screen->WindowTreeObserver();
	if (windowTreeObserver)
		{
		windowTreeObserver->NodeCreated(*this, ParentNode());
		iBaseWinFlags |= EBaseWinNodeCreated;
		}
	SetOrdinalPosition(0);
	iFadeCount = iParent->iFadeCount;
	}

CWsWindowBase *CWsWindowBase::GetPrevSibling() const
	{
	if(iParent == NULL) //RootWindow
		return(NULL);
	
	CWsWindowBase* prev=iParent->iChild;
	CWsWindowBase *ret=NULL;
	while (prev!=this)
		{
		ret=prev;
		prev=prev->iSibling;
		}
	return(ret);
	}

CWsWindowBase *CWsWindowBase::LastSibling() const
	{
	const CWsWindowBase *win;
	for(win=this;win->iSibling;win=win->iSibling)
		{}
	return (CWsWindowBase*)win;
	}

CWsWindowBase *CWsWindowBase::PrevSiblingMultiParent() const
	{
	CWsWindowBase *win=GetPrevSibling();
	if (win)
		return(win);
	for(CWsWindowBase *parent=iParent->GetPrevSibling();parent;parent=parent->GetPrevSibling())
		if ((win=parent->iChild)!=NULL)
			return(win->LastSibling());
	return(NULL);
	}

CWsWindowBase *CWsWindowBase::NextSiblingMultiParent() const
	{
	if (iSibling)
		return(iSibling);
	for(CWsWindowBase *parent=iParent->iSibling;parent;parent=parent->iSibling)
		{
		if (parent->iChild!=NULL)
			return(parent->iChild);
		}
	return(NULL);
	}

TInt CWsWindowBase::OrdinalPosition(TBool aFull) const
	{
	if (!iParent)
		{
		OwnerPanic(EWservPanicParentDeleted);
		}
	CWsWindowBase *win=iParent->iChild;
	if (!aFull)
		while(iOrdinalPriority<win->iOrdinalPriority)
			win=win->iSibling;
	TInt count;
	for(count=0;win!=this;count++)
		win=win->iSibling;
	return(count);
	}

/** Removes a window from the list of siblings maintained by its parent window.

The iSibling stored inside the window we remove is kept unchanged as it may be needed later.

@internalComponent
@released
*/
void CWsWindowBase::RemoveFromSiblingList()
	{
	if (iParent!=NULL)
		{
		CWsWindowBase **prev= &iParent->iChild;
		while ((*prev)!=this)
			prev= &(*prev)->iSibling;
		*prev=iSibling;
		}
	}

CWsWindowGroup *CWsWindowBase::WinGroup() const
	{
	if (iWinType==EWinTypeClient)
		return(((CWsClientWindow *)this)->TopClientWindow()->Parent());
	if (iWinType==EWinTypeGroup)
		return((CWsWindowGroup *)this);
	return(NULL);
	}

TBool CWsWindowBase::CheckOrdinalPositionChange(TInt aPos)
//
// This routine checks to see whether the specified new ordinal position
// will causes a change, if so returns ETrue else EFalse.
//
	{
	CWsWindowBase *win= iParent->iChild;
	CWsWindowBase *prev= NULL;
	while(win==this || (win!=NULL && iOrdinalPriority<win->iOrdinalPriority))
		{
		prev=win;
		win=win->iSibling;
		}
	if (prev==this)
		win=this;
	else if (win==NULL || (win->iSibling==this && iOrdinalPriority>win->iOrdinalPriority))
		return ETrue;
	while(aPos--!=0 && win->iSibling!=NULL && iOrdinalPriority==win->iSibling->iOrdinalPriority)
		win=win->iSibling;
	return(win!=this);
	}

void CWsWindowBase::ChangeWindowPosition(TInt aPos,CWsWindowBase* aNewParent)
	{
	TBool changedWindowGroup = EFalse;
	WS_ASSERT_DEBUG(aNewParent,EWsPanicWindowNull);
	if (aNewParent != iParent)
		{
		iScreen->ScheduleRegionUpdate(NULL);		
		TWalkWindowTreeScheduleRedraws wwt;
		WalkWindowTree(wwt, EWalkChildren);
		changedWindowGroup = ETrue;
		}
	else if (WinType() == EWinTypeClient)
		{
		CWsClientWindow * cliwin = static_cast<CWsClientWindow*>(this);
		if (cliwin->IsVisible())
			{
			iScreen->ScheduleRegionUpdate(NULL);
			if (cliwin->IsTranslucent())
				{
				// There is still room for optimization here.  These redraws are only required if the window
				// moved through another window and BOTH of them were transparent, otherwise the visible
				// region change will sort out the redraws required.
				TWalkWindowTreeScheduleRedraws wwt;
				WalkWindowTree(wwt, EWalkChildren);
				}
			}
		}
	else if (WinType() == EWinTypeGroup)
		{
		iScreen->ScheduleRegionUpdate(NULL);
		if (static_cast<CWsWindowGroup*>(this)->HasVisibleTranslucentChild())
			{
			TWalkWindowTreeScheduleRedraws wwt;
			WalkWindowTree(wwt, EWalkChildren);				
			}
		}

	RemoveFromSiblingList();
	CWsWindowBase **prevWinPtr= &aNewParent->iChild;
	while((*prevWinPtr)!=NULL && iOrdinalPriority<(*prevWinPtr)->iOrdinalPriority)
		{
		prevWinPtr= &(*prevWinPtr)->iSibling;
		}
	while(aPos--!=0 && *prevWinPtr!=NULL && iOrdinalPriority==(*prevWinPtr)->iOrdinalPriority)
		{
		prevWinPtr= &(*prevWinPtr)->iSibling;
		}
	iSibling=*prevWinPtr;
	iParent=aNewParent;
	*prevWinPtr=this;

	Screen()->WindowElements().SortByZOrder();

	MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
	if (windowTreeObserver)
		{
		if(changedWindowGroup && (WinType() == EWinTypeClient))
			{
			windowTreeObserver->MovedToWindowGroup(*this, *(this->WinGroup()));
			}
		else if(!changedWindowGroup)
			{
			windowTreeObserver->SiblingOrderChanged(*this, OrdinalPosition(ETrue));
			}
		else if(changedWindowGroup)
			{
			OwnerPanic(EWservPanicInvalidParameter); //Should be impossible to end up here as only WinType() EWinTypeClient 
			}										 //and EWinTypeGroup can be moved to another windowgroup.
		}											 //@see RWindowBase::MoveToGroup
	}

void CWsWindowBase::SetOrdinalPosition(TInt aPos)
	{
	if (CheckOrdinalPositionChange(aPos))
		ChangeWindowPosition(aPos,iParent);
	}

TEventQueueWalkRet EventPurgeFunc(TAny *aPtr, TWsEvent *aEvent)
//
// Callback function for event queue walk
//
	{
	return(((CWsWindowBase *)aPtr)->EventPurgeCheck(aEvent));
	}

TEventQueueWalkRet CWsWindowBase::EventPurgeCheck(TWsEvent *aEvent)
	{
	if (aEvent->Handle()==ClientHandle())
		return(EEventQueueWalkDeleteEvent);
	return(EEventQueueWalkOk);
	}

void CWsWindowBase::PurgeEvents()
	{
	iWsOwner->EventQueue()->WalkEventQueue(&EventPurgeFunc,this);
	}

void CWsWindowBase::Shutdown()
//
// Destroy a window, disconnects from the window tree and destroys all it's child windows
//
	{
	if (iWsOwner!=NULL)
		PurgeEvents();
	if (iParent!=NULL)	// Check it's connected to something
		{
		CWsWindowBase *win;
		for(win=this;win && win->iParent!=(CWsWindowBase *)RootWindow();win=win->iParent)
			{}
		RemoveFromSiblingList();
		TWalkWindowTreeDisconnect wwt2(win ? ((CWsWindowGroup *)win)->TextCursor() : NULL);
		WalkWindowTree(wwt2,EWalkChildren); // Disconnect all child windows
		iChild=NULL;
		}
	TWindowServerEvent::RemoveFromSwitchOnEventList(*this);
	TWindowServerEvent::RemoveFromErrorMessageList(*this);
	TWindowServerEvent::RemoveFromGroupChangeEventEventList(*this);
	TWindowServerEvent::RemoveFromFocusChangeEventEventList(*this);
	TWindowServerEvent::RemoveFromGroupListChangeEventEventList(*this);
	TWindowServerEvent::RemoveFromModifierChangedEventList(*this);
	TWindowServerEvent::RemoveFromScreenDeviceChangeEventList(*this);
	CWsTop::StopWindowGettingOffEvents(this);
	}

TBool CWsWindowBase::CommandL(TInt aOpcode, TWsWinCmdUnion &aCmd)
//
// If the command is supported by the window base class process it and return ETrue
// if it is not supported return EFalse
//
	{
	switch(aOpcode)
		{
		case EWsWinOpFree:
			{
			delete this;
			break;
			}
		case EWsWinOpSetOrdinalPosition:
			SetOrdinalPosition(*aCmd.Int);
			break;
		case EWsWinOpOrdinalPriority:
			SetReply(iOrdinalPriority);
			break;
		case EWsWinOpOrdinalPosition:
			SetReply(OrdinalPosition(EFalse));
			break;
		case EWsWinOpFullOrdinalPosition:
			SetReply(OrdinalPosition(ETrue));
			break;
		case EWsWinOpClientHandle:
			SetReply(iClientHandle);
			break;
		case EWsWinOpParent:
			if (!iParent)
				{
				OwnerPanic(EWservPanicParentDeleted);
				}
			SetReply(iParent->iClientHandle);
			break;
		case EWsWinOpPrevSibling:
			{
			if (!iParent)
				{
				OwnerPanic(EWservPanicParentDeleted);
				}
			TUint32 reply=NULL;
			for(CWsWindowBase *win=this->GetPrevSibling();win;win=win->GetPrevSibling())
				{
				if (win->iWsOwner==iWsOwner)
					{
					reply=win->iClientHandle;
					break;
					}
				}
			SetReply(reply);
			}
			break;
		case EWsWinOpNextSibling:
			{
			TUint32 reply=NULL;
			for(CWsWindowBase *win=this->iSibling;win;win=win->iSibling)
				{
				if (win->iWsOwner==iWsOwner)
					{
					reply=win->iClientHandle;
					break;
					}
				}
			SetReply(reply);
			}
			break;
		case EWsWinOpChild:
			SetReply(iChild==NULL ? NULL : iChild->iClientHandle);
			break;
		case EWsWinOpScreenNumber:
			SetReply(Screen()->ScreenNumber());
			break;
		case EWsWinOpWindowGroupId:
			{
			TUint32 reply=NULL;
			CWsWindowGroup *wg=WinGroup();
			if (wg)
				{
				reply=wg->Identifier();
				}
			SetReply(reply);
			}
			break;
		case EWsWinOpEnableOnEvents:
			{
			const TEventControl circumstances = *aCmd.EventControl;
			TWindowServerEvent::AddToSwitchOnEventListL(*this, circumstances);
			if (iScreen->ChangeTracking())
				{
				if(circumstances & EEventControlOnlyWhenVisible)
					{
					TWalkWindowTreeSetupVisibleRegionTracking wwt(ETrue);
					WalkWindowTree(wwt, EWalkChildren);
					}
				}
			break;
			}
		case EWsWinOpDisableOnEvents:
			{
			TWindowServerEvent::RemoveFromSwitchOnEventList(*this);
			if (iScreen->ChangeTracking())
				{
				TWalkWindowTreeSetupVisibleRegionTracking wwt(EFalse);
				WalkWindowTree(wwt, EWalkChildren);
				}
			break;
			}
		case EWsWinOpEnableErrorMessages:
			{
			const TEventControl circumstances = *aCmd.EventControl;
			TWindowServerEvent::AddToErrorMessageListL(*this, circumstances);
			if (iScreen->ChangeTracking())
				{
				if(circumstances & EEventControlOnlyWhenVisible)
					{
					TWalkWindowTreeSetupVisibleRegionTracking wwt(ETrue);
					WalkWindowTree(wwt, EWalkChildren);
					}
				}
			break;
			}
		case EWsWinOpDisableErrorMessages:
			{
			TWindowServerEvent::RemoveFromErrorMessageList(*this);
			if (iScreen->ChangeTracking())
				{
				TWalkWindowTreeSetupVisibleRegionTracking wwt(EFalse);
				WalkWindowTree(wwt, EWalkChildren);
				}
			break;
			}
		case EWsWinOpEnableModifierChangedEvents:
			{
			const TInt modifierMask = aCmd.EnableModifierChangedEvents->modifierMask;
			const TEventControl circumstances = aCmd.EnableModifierChangedEvents->circumstances;
			TWindowServerEvent::AddToModifierChangedEventListL(*this, modifierMask, circumstances);
			if (iScreen->ChangeTracking())
				{
				if(circumstances & EEventControlOnlyWhenVisible)
					{
					TWalkWindowTreeSetupVisibleRegionTracking wwt(ETrue);
					WalkWindowTree(wwt, EWalkChildren);
					}
				}
			break;
			}
		case EWsWinOpDisableModifierChangedEvents:
			{
			TWindowServerEvent::RemoveFromModifierChangedEventList(*this);
			if (iScreen->ChangeTracking())
				{
				TWalkWindowTreeSetupVisibleRegionTracking wwt(EFalse);
				WalkWindowTree(wwt, EWalkChildren);
				}
			break;
			}
		case EWsWinOpEnableGroupChangeEvents:
			TWindowServerEvent::AddToGroupChangeEventListL(*this);
			break;
		case EWsWinOpDisableGroupChangeEvents:
			TWindowServerEvent::RemoveFromGroupChangeEventEventList(*this);
			break;
		case EWsWinOpEnableFocusChangeEvents:
			TWindowServerEvent::AddToFocusChangeEventListL(*this);
			break;
		case EWsWinOpDisableFocusChangeEvents:
			TWindowServerEvent::RemoveFromFocusChangeEventEventList(*this);
			break;
		case EWsWinOpEnableGroupListChangeEvents:
			TWindowServerEvent::AddToGroupListChangeEventListL(*this);
			break;
		case EWsWinOpDisableGroupListChangeEvents:
			TWindowServerEvent::RemoveFromGroupListChangeEventEventList(*this);
			break;
		case EWsWinOpSetCustomPointerCursor:
			CWsObject *pointercursor;
			if ((pointercursor=iWsOwner->HandleToObj(*aCmd.Int, WS_HANDLE_POINTER_CURSOR))==NULL)
				OwnerPanic(EWservPanicSprite);
			SetPointerCursor((CWsPointerCursor *)pointercursor);
			break;
		case EWsWinOpSetPointerCursor:
			SetPointerCursorByIndex(*aCmd.UInt);
			break;
		case EWsWinOpClearPointerCursor:
			SetPointerCursor(NULL);
			break;
		case EWsWinOpSetNonFading:
			{
			WS_ASSERT_DEBUG(iScreen, EWsPanicNoScreen);
			// No fading will occur from a graphical perspective, but the fade counts
			// are maintained for BC reasons.
			TWalkWindowTreeSetNonFading wwt(*aCmd.Bool);
			WalkWindowTree(wwt,EWalkChildren);
			}
			break;
		case EWsWinOpSetFade:
			{
			WS_ASSERT_DEBUG(iScreen, EWsPanicNoScreen);
			
			TUint8 blackMap;
			TUint8 whiteMap;
			if (aCmd.SetFaded->UseDefaultMap())
				{
				iScreen->GetFadingParams(blackMap,whiteMap);
				}
			else
				{
				aCmd.SetFaded->GetFadingParams(blackMap,whiteMap);
				}
			
			if (aCmd.SetFaded->IncludeChildren())
				{
				TWalkWindowTreeSetFaded wwt(aCmd.SetFaded->Faded(),this,blackMap,whiteMap);
				WalkWindowTree(wwt,EWalkChildren);
				}
			else
				{
				if (iWinType==EWinTypeGroup)
					OwnerPanic(EWservPanicOpcode);
				
				const TBool KNotifyObserver = ETrue; //yes please
				const TBool KFaded = aCmd.SetFaded->Faded();
				static_cast<CWsClientWindow*>(this)->SetFaded(KFaded, blackMap, whiteMap, KNotifyObserver); 
				}
			}
			break;
			case EWsWinOpEnableAdvancedPointers:
				User::LeaveIfError(IsActivated()?KErrInUse:KErrNone);
				iBaseWinFlags |= EBaseWinAdvancedPointersEnabled;
				break;
		default:
			return(EFalse);
		}
	return(ETrue);
	}

/** @see MWsWindowTreeNode */
MWsWindowTreeNode::TType CWsWindowBase::NodeType() const
	{
	return static_cast<MWsWindowTreeNode::TType>(iWinType); //TWinType is a subset of MWsWindowTreeNode::TType
	}

/** @see MWsWindowTreeNode */
const MWsWindow* CWsWindowBase::Window() const
	{
	return (iWinType!=EWinTypeGroup) ? (static_cast<const CWsWindow*>(this)) : NULL;
	}

/** @see MWsWindowTreeNode */
const MWsSprite* CWsWindowBase::Sprite() const
	{
	return NULL;
	}

/** @see MWsWindowTreeNode */
const MWsStandardTextCursor* CWsWindowBase::StandardTextCursor() const
	{
	return NULL;
	}

/** @see MWsWindowTreeNode */
const MWsWindowGroup* CWsWindowBase::WindowGroup() const
	{
	return static_cast<MWsWindowGroup*>(WinGroup()); 
	}

/** @see MWsWindowTreeNode */
const MWsWindowTreeNode* CWsWindowBase::ParentNode() const
	{
	return iParent;
	}

TBool CWsWindowBase::QueueEvent(TInt aEvent, TInt aIntVal) const
	{
	if (WsOwner())
		return(WsOwner()->EventQueue()->QueueEvent(iClientHandle, aEvent, aIntVal));
	return(EFalse);
	}

void CWsWindowBase::SetPointerCursorByIndex(TInt aIndex)
	{
	SetPointerCursor(CWsClient::SystemPointerCursor(aIndex));
	}

void CWsWindowBase::SetPointerCursor(CWsPointerCursor *aCursor)
	{
	CWsPointerCursor *old=iPointerCursor;
	iPointerCursor=aCursor;
	if (iPointerCursor)
		iPointerCursor->Open();
	TWsPointer::UpdatePointerCursor();
	if (old)
		old->Close();
	}

TBool CWsWindowBase::TreeIsObscured() const
	{
	TBool result;
	TWalkWindowTreeIsObscured wwt(result);
	CONST_CAST(CWsWindowBase *,this)->WalkWindowTree(wwt,EWalkChildren);
	return(result);
	}

CEventQueue *CWsWindowBase::EventQueue() const
	{
	CEventQueue* eventQueue = NULL;
	if (iWsOwner)
		eventQueue = iWsOwner->EventQueue();
	return eventQueue;
	}

TInt CWsWindowBase::Depth() const
	{
	TInt count=0;
	const CWsWindowBase *win=this;
	while (win->WinType()!=EWinTypeRoot)
		{
		++count;
		win=win->iParent;
		}
	return(count);
	}

void CWsWindowBase::WalkWindowTree(TWalkWindowTreeBase &aWalkClass,TWalkMode aMode)
//
// Walks windows in a front to back order
//
// If mode is EWalkBehind
//	call DoIt for all windows that are behind 'this'
// else if mode is EWalkChildren
//  call DoIt for all descendents
// else if mode is EWalkChildrenAndBehind
//  call DoIt for for all descendents and windows behind
//
	{
	if (this!=NULL)
		{
		CWsWindowBase *win=this;
		CWsWindowBase *end=RootWindow();
		CWsWindowBase *sibling=win->iSibling;
		CWsWindowBase *parent=win->iParent;
		if (aMode!=EWalkBehind)
			{
			if (aMode==EWalkChildren)
				end=win;
			goto start;
			}
		do
			{
			if (sibling!=NULL)
				{
				win=sibling;
start:			while(win->iChild!=NULL)
					win=win->iChild;
				}
			else
				win=parent;
			sibling=win->iSibling;	// De-reference win so it can be destroyed by 'DoIt'
			parent=win->iParent;
			if (win->iWinType!=EWinTypeGroup && aWalkClass.DoIt((CWsWindow *)win))
				return;
			} while(win!=end);
		}
	}

/* Walks windows in a front to back order

 If aResume is EFalse the walk is identical to above.
 Otherwise iWin is taken as the restart point, (any child windows will have been
 walked previously).
 */
void CWsWindowBase::WalkWindowTree(TResumableWalkWindowTreeBase& aWalkClass, TWalkMode aMode, TBool aResume)
	{
	if (this != NULL)
		{ // init
		if (!aResume)
			{
			aWalkClass.iWin = this;
			aWalkClass.iEnd = (aMode == EWalkChildren) ? this : RootWindow();
			aWalkClass.iParent = aWalkClass.iWin->iParent;
			if (aMode == EWalkBehind)
				{
				aWalkClass.iNextChild = aWalkClass.iWin->iSibling;
				}
			else
				{ // ensure walk includes this and its child windows
				aWalkClass.iNextChild = this;
				}
			}
		else if (aWalkClass.iWin == aWalkClass.iEnd)
			{
			return; // walk had already reached end
			}

		do
			{
			if (aWalkClass.iNextChild != NULL)
				{ // walk down tree to a leaf window
				aWalkClass.iWin = aWalkClass.iNextChild;
				while (aWalkClass.iWin->iChild != NULL)
					{
					aWalkClass.iWin = aWalkClass.iWin->iChild;
					}
				}
			else
				{ // walk up tree
				aWalkClass.iWin = aWalkClass.iParent;
				}
			// De-reference iWin so it can be destroyed by 'DoIt'
			aWalkClass.iNextChild = aWalkClass.iWin->iSibling;
			aWalkClass.iParent = aWalkClass.iWin->iParent;
			if ( ( aWalkClass.iWin->iWinType != EWinTypeGroup ) && aWalkClass.DoIt(static_cast<CWsWindow *>(aWalkClass.iWin)) )
				{
				return;
				}
			}
		while (aWalkClass.iWin != aWalkClass.iEnd);
		}
	}

void CWsWindowBase::WalkWindowTreeBackToFront(TWalkWindowTreeBase &aWalkClass, TWalkModeBackToFront aMode)
	{
	// Walks windows in a back to front order
	//
	// If mode is EVisitParentNodesFirst
	// call DoIt() on each node before walking their child windows.	
	
	if(iSibling)
		iSibling->WalkWindowTreeBackToFront(aWalkClass,aMode);
	
	if(aMode == EVisitParentNodesFirst)
		aWalkClass.DoIt(static_cast<CWsWindow *>(this));
	
	if(iChild)
		iChild->WalkWindowTreeBackToFront(aWalkClass,aMode);
	
	}

TBool CWsWindowBase::IsDSAHost() const
	{
	return EFalse;
	}

TBool CWsWindowBase::IsActivated() const
	{
	return EFalse;
	}

void CWsWindowBase::AddSprite(CWsSpriteBase * aSprite)
	{
	aSprite->SetNext(iSpriteList);
	iSpriteList = aSprite;
	}
	
void CWsWindowBase::RemoveSprite(CWsSpriteBase * aSprite)
	{
	if (aSprite == iSpriteList)
		{
		iSpriteList = aSprite->Next();
		}
	else
		{
		for (CWsSpriteBase * sprite = iSpriteList; sprite; sprite = sprite->Next())
			{
			if (sprite->Next() == aSprite)
				{
				sprite->SetNext(aSprite->Next());
				}
			}
		}
	aSprite->SetNext(0);
	}

void CWsWindowBase::SendState(MWsWindowTreeObserver& aWindowTreeObserver) const
	{
	//Sprites
	if(iSpriteList)
		iSpriteList->SendState(aWindowTreeObserver);
	}

#if defined(_DEBUG)

void CWsWindowBase::CheckTree()
	{
	TWalkWindowTreeCheck wwt1;
	WalkWindowTree(wwt1,EWalkChildren);
	}

enum {ENullWsHandle=0xFFFFFFFF};	// Events delivered to this handle are thrown away
TBool CWsWindowBase::IsClientHandleInUse(TUint32 aHandle)
	{
	if (aHandle==static_cast<TUint>(ENullWsHandle))		//This value has a special meaning in test code
		return EFalse;
	CWsObjectIx* index=iWsOwner->ObjectIndex();
	const CWsObject* obj;
	TInt length=index->Length();
	TInt ii;
	for (ii=0;ii<length;++ii)
		{
		obj=index->At(ii);
		if (obj && (obj->Type()==WS_HANDLE_WINDOW || obj->Type()==WS_HANDLE_GROUP_WINDOW))
			{
			if (STATIC_CAST(const CWsWindowBase*,obj)->ClientHandle()==aHandle)
				return ETrue;
			}
		}
	return EFalse;
	}

#endif