// 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:

       if(!IsActivated())

           {

           // Must call this BEFORE activating the window.

           iBaseWinFlags |= EBaseWinAdvancedPointersEnabled;

           }

       else

           {                    

           // Called after activation, so panic the client.                

           OwnerPanic(EWservPanicUnableToEnableAdvPointer);

           }

 			break;

 		case EWsWinOpSetSurfaceTransparency:

 			RDebug::Printf("[Bug 3343] OpCode EWsWinOpSetSurfaceTransparency not supported.");

 			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