// Copyright (c) 2006-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:

 //

 #include "walkwindowtree.h"

 #include "cliwin.h"

 #include "rootwin.h"

 #include "ANIM.H"

 #include "tcursor.h"

 #include "pointer.h"

 TWalkWindowTreeFocusChanged::TWalkWindowTreeFocusChanged(TBool aNewFocusState) :

 	iNewFocusState(aNewFocusState)

 	{

 	}

 TBool TWalkWindowTreeFocusChanged::DoIt(CWsWindow *aWin)

 //

 // Walk all windows that have had their focus state changed

 //

 	{

 	aWin->FocusChanged(iNewFocusState);

 	return(EFalse);

 	}

 TResumableWalkWindowTreeFindInvalid::TResumableWalkWindowTreeFindInvalid(CWsWindowRedraw** aResult) :

 	iResult(aResult)

 	{

 	}

 TBool TResumableWalkWindowTreeFindInvalid::DoIt(CWsWindow* aWin)

 //

 // Find a window with an invalid area

 //

 	{

 	WS_ASSERT_DEBUG(aWin->WinType()==EWinTypeClient, EWsPanicWindowType);

 	CWsWindowRedraw *redraw=((CWsClientWindow *)aWin)->Redraw();

 	if (redraw->NeedsRedraw()>0)

 		{

 		*iResult=redraw;

 		return(ETrue);

 		}

 	return(EFalse);

 	}

 TWalkWindowTreeDisconnect::TWalkWindowTreeDisconnect(RWsTextCursor *aCursor) :

 	iTextCursor(aCursor)

 	{}

 TBool TWalkWindowTreeDisconnect::DoIt(CWsWindow *aWin)

 //

 // Disconnect a window

 //

 	{

 	if (aWin->WinType()==EWinTypeClient)

 		{

 		CWsClientWindow *win=(CWsClientWindow *)aWin;

 		win->iRedraw->WindowClosing();

 		/* XXX jonas: the defect fix for PDEF114190 moved deactivation of sprites from CWsWindow::Shutdown() to here. Check that DeactivateAllSprites() is equivalent to SpriteManager::DeactivateSprites().

 		win->SpriteManager()->DeactivateSprites(win);

 		*/

 		win->DeactivateAllSprites();

 		if (iTextCursor)

 			iTextCursor->WindowDisconnected(win);

 		CWsAnim::WindowClosing(win->iAnimList);	// Destroy any animated objects attached to this window

 		TWsPointer::WindowDisconnected(aWin);

 		win->iParent=NULL;

 		win->iSibling=NULL;

 		win->iChild=NULL;

 		win->iFlags&=~EFlagActive;

 		win->ResetHiddenFlag();

 		}

 	return(EFalse);

 	}

 TWalkWindowTreeRegionBase::TWalkWindowTreeRegionBase(RWsRegion *aRegion, TTranslucentBehaviour aTranslucentBehaviour) :

 	iTranslucentBehaviour(aTranslucentBehaviour), iRegion(aRegion), iSubRegion(NULL)

 	{}

 TBool TWalkWindowTreeRegionBase::DoIt(CWsWindow *aWin)

 	{

 	if (aWin->IsVisible())

 		{

 		DoIt2(aWin);

 		if (aWin->WinType()!=EWinTypeRoot)

 			{

 			STACK_REGION tmp;

 			switch(iTranslucentBehaviour)

 				{

 				case EDontWalkTranslucent:

 					static_cast<CWsClientWindow *>(aWin)->GetClippedBaseArea(tmp);

 					iRegion->SubRegion(tmp,iSubRegion);

 					break;

 				case EWalkTranslucent:

 					static_cast<CWsClientWindow *>(aWin)->GetClippedBaseArea(*iSubRegion);

 					iSubRegion->Intersect(*iRegion);

 					if (iSubRegion->Count() > 0)

 						{

 						static_cast<CWsClientWindow *>(aWin)->GetOpaqueClippedBaseArea(tmp);

 						iRegion->SubRegion(tmp);

 						}

 					break;

 				}

 			tmp.Close();

 			}

 		else if(iSubRegion)

 			{

 			iSubRegion->Copy(*iRegion);

 			}

 		if (iSubRegion && (iSubRegion->Count()>0 || iSubRegion->CheckError()))

 			{

 			if (DoIt3(aWin))

 				return ETrue;

 			iSubRegion->Clear();

 			}

 		}

 	return(iRegion->IsEmpty());

 	}

 TBool TWalkWindowTreeRegionBase::DoIt3(CWsWindow*)

 	{return EFalse;}

 TWalkWindowTreeSchedule::TWalkWindowTreeSchedule() :

 	TWalkWindowTreeBase(),

 	iHead(0)

 	{

 	}

 CWsWindow * TWalkWindowTreeSchedule::HeadWindow() const

 	{

 	return iHead;

 	}

 TWalkWindowListSchedule::TWalkWindowListSchedule(CWsWindow* aHeadWin, TRegion& aScreenUpdateRegion)

 	: TWalkWindowTreeSchedule(), iScreenUpdateRegion(aScreenUpdateRegion)

 	{

 	iHead = aHeadWin;

 	}

 void TWalkWindowListSchedule::WalkWindowList()

 	{

 	CWsWindow* win = iHead;

 	CWsWindow* previous = NULL;

 	while (win)

 		{

 		if (!DoIt(win))

 			{

 			// Remove win from list, as it doesn't need to be rendered

 			if (win == iHead)

 				{

 				iHead = win->NextScheduled();

 				}

 			else

 				{

 				WS_ASSERT_DEBUG(previous,EWsPanicWindowNull);

 				previous->SetNextScheduled(win->NextScheduled());

 				}

 			}

 		else

 			{

 			previous = win;

 			}

 		win = win->NextScheduled();

 		}

 	}

 /**

 @return ETrue if aWin has content that needs to be rendered, otherwise EFalse. 

 */

 TBool TWalkWindowListSchedule::DoIt(CWsWindow* aWin)

 	{

 	if (aWin->IsVisible())

 		{

 		//In case we don't have all content, queue a request for the client to provide it.

 		CWsWindowRedraw& redrawWin = *(aWin->Redraw());

 		if(!redrawWin.InvalidArea().IsEmpty())

 			{

 			redrawWin.QueueRedraw();

 			}

 		//Schedule all we got for now

 		const TBool scheduledWindowContent = DoWindow(*aWin);

 		const TBool scheduledSpriteContent = DoSprites(*aWin);

 		return (scheduledWindowContent || scheduledSpriteContent);

 		}

 	return EFalse;

 	}

 TBool TWalkWindowListSchedule::DoWindow(CWsWindow& aWin)

 	{

 	if (!aWin.DirtyWindowRegion().IsEmpty())

 		{

 		//Schedule

 		aWin.ScheduleDirtyWindowRegion();

 		//And ensure this part of the screen is updated

 		iScreenUpdateRegion.Union(aWin.ScheduledRegion());

 		return ETrue;

 		}

 	return EFalse;

 	} 

 TBool TWalkWindowListSchedule::DoSprites(CWsWindow& aWin)

 	{

 	if (!aWin.DirtySpriteRegion().IsEmpty())

 		{

 		//Schedule

 		aWin.ScheduleDirtySpriteRegion();

 		//And ensure this part of the screen is updated

 		iScreenUpdateRegion.Union(aWin.ScheduledSpriteRegion());

 		return ETrue;

 		}

 	return EFalse;

 	}

 const TRegion& TWalkWindowListSchedule::WindowRegion(const CWsWindow& aWin) const

 	{

 	return aWin.ScheduledRegion();

 	}

 const TRegion& TWalkWindowListSchedule::SpriteRegion(const CWsWindow& aWin) const

 	{

 	return aWin.ScheduledSpriteRegion();

 	}

 TWalkWindowTreeScheduleRegions::TWalkWindowTreeScheduleRegions(TRegion& aRegion, const TRegion& aTopElement) :

 	TWalkWindowTreeSchedule(),

 	iRegion(aRegion),

 	iTopElement(aTopElement),

 	iScheduledRegionsOk(ETrue)

 	{

 	}

 // This is similar to TWalkWindowTreeRegionBase::DoIt

 TBool TWalkWindowTreeScheduleRegions::DoIt(CWsWindow *aWin)

 	{

 	WS_ASSERT_DEBUG((aWin != iHead), EWsPanicScheduledRedraw);

 	if (aWin->IsVisible())

 		{

 		// Calculate the region we care about for this window:

 		STACK_REGION region;

 		if (aWin->WinType()==EWinTypeRoot)

 			{

 			region.Copy(iRegion);

 			}

 		else

 			{

 			static_cast<CWsClientWindow *>(aWin)->GetClippedBaseArea(region);

 			region.Intersect(iRegion);

 			}

 		// If there is a region we care about, remember the window:

 		// NOTE: Even if there are no redraw segments (ReadyToDraw is false) the window should

 		//       be scheduled if it has a element so that the background surface is made visible

 		//  or if it has some animations which should be redrawn via the PostDrawWindow method (cf def131912)

 		if (!region.IsEmpty() && (aWin->ReadyToDraw() || aWin->HasElement() || aWin->HasAnimation() || aWin->HasSprite()) )

 			{

 			// Add window to linked list:

 			aWin->SetNextScheduled(iHead);

 			iHead = aWin;

 			// Set the window scheduled region to something appropriate:

 			if (iScheduledRegionsOk)

 				{

 				if (region.CheckError())

 					{

 					iScheduledRegionsOk = EFalse;

 					}

 				else

 					{

 					iScheduledRegionsOk = aWin->SetScheduledRegion(region);

 					}

 				}

 			}

 		if (aWin->WinType()!=EWinTypeRoot)

 			{

 			// Remove the opaque part from our working region:

 			STACK_REGION opaqueRegion;

 			static_cast<CWsClientWindow *>(aWin)->GetOpaqueClippedBaseArea(opaqueRegion);

 			iRegion.SubRegion(opaqueRegion);

 			opaqueRegion.Close();

 			// Where we were drawing transparent and doing top element only, remove

 			// that bit too:

 			if (!iTopElement.IsEmpty())

 				{

 				region.Intersect(iTopElement);

 				iRegion.SubRegion(region);

 				}

 			}

 		region.Close();

 		}

 	return(iRegion.IsEmpty() || !iScheduledRegionsOk);

 	}

 const TRegion& TWalkWindowTreeScheduleRegions::WindowRegion(const CWsWindow& aWin) const

 	{

 	WS_ASSERT_DEBUG(iScheduledRegionsOk, EWsPanicScheduledRedraw);

 	return aWin.ScheduledRegion();

 	}

 const TRegion& TWalkWindowTreeScheduleRegions::SpriteRegion(const CWsWindow& aWin) const

 	{

 	//Intentionally returning WindowRegion as TWalkWindowTreeScheduleRegions do not

 	//make use of ScheduledSpriteRegion

 	return aWin.ScheduledRegion();

 	}

 TBool TWalkWindowTreeScheduleRegions::ScheduledRegionsOk() const

 	{

 	return iScheduledRegionsOk;

 	}

 TWalkWindowTreeScheduleFallback::TWalkWindowTreeScheduleFallback(CScreen::CFallbackMap * aFallbackMap) :

 	TWalkWindowTreeSchedule(),

 	iFallbackMap(aFallbackMap)

 	{

 	}

 // This is similar to TWalkWindowTreeRegionBase::DoIt

 TBool TWalkWindowTreeScheduleFallback::DoIt(CWsWindow *aWin)

 	{

 	WS_ASSERT_DEBUG((aWin != iHead), EWsPanicScheduledRedraw);

 	if (aWin->IsVisible())

 		{

 		if (aWin == aWin->RootWindow())

 			{

 			aWin->SetNextScheduled(iHead);

 			return ETrue;

 			}

 		else

 			{

 			TBool addWindow = EFalse;

 			CWsClientWindow* cliWin = static_cast<CWsClientWindow *>(aWin);

 			if (cliWin->IsTranslucent())

 				{

 				addWindow = ETrue; // costs more to work out than it is worth

 				const TRegion * opaque = cliWin->GetUserOpaqueRegion();

 				if (opaque && !opaque->CheckError())

 					iFallbackMap->FillRegion(*opaque);

 				}

 			else

 				{

 				addWindow = iFallbackMap->FillRegion(*cliWin->BaseArea());

 				}

 			if (addWindow)

 				{

 				aWin->SetNextScheduled(iHead);

 				iHead = aWin;

 				}

 			}

 		}

 	return(iFallbackMap->Count() < 1);

 	}

 const TRegion& TWalkWindowTreeScheduleFallback::WindowRegion(const CWsWindow& aWin) const

 	{

 	if (&aWin == aWin.RootWindow())

 		return *(iFallbackMap->Region());

 	else

 		{

 		const CWsClientWindow& win = static_cast<const CWsClientWindow&>(aWin);

 		const TRegion* region = win.VisibleRegionIfValid();

 		if (!region)

 			region = win.BaseArea();

 		return *region;

 		}

 	}

 const TRegion& TWalkWindowTreeScheduleFallback::SpriteRegion(const CWsWindow& aWin) const

 	{

 	return WindowRegion(aWin);

 	}

 TWalkWindowTreeIsObscured::TWalkWindowTreeIsObscured(TBool &aResult) :

 	iResult(&aResult)

 	{

 	aResult=ETrue;

 	}

 TBool TWalkWindowTreeIsObscured::DoIt(CWsWindow *aWin)

 	{

 	if (!aWin->VisibleRegion().IsEmpty())

 		{

 		*iResult=EFalse;

 		return(ETrue);

 		}

 	return(EFalse);

 	}

 TWalkWindowTreeSetupVisibleRegionTracking::TWalkWindowTreeSetupVisibleRegionTracking(TBool aRegister) : iRegister(aRegister)

 	{

 	}

 TBool TWalkWindowTreeSetupVisibleRegionTracking::DoIt(CWsWindow *aWin)

 	{

 	ASSERT(aWin->WinType() == EWinTypeClient);

 	if(aWin->WinType() == EWinTypeClient)

 		{

 		aWin->SetupVisibleRegionTracking(iRegister);

 		}

 	return(EFalse);

 	}

 TWalkWindowTreeSetNonFading::TWalkWindowTreeSetNonFading(TBool aNonFading) :

 	iNonFading(aNonFading)

 	{}

 TBool TWalkWindowTreeSetNonFading::DoIt(CWsWindow *aWin)

 	{

 	aWin->SetNonFading(iNonFading); 

 	return EFalse;

 	}

 TWalkWindowTreeSetFaded::TWalkWindowTreeSetFaded(TBool aFaded,CWsWindowBase* aWin,TUint8 aBlackMap,TUint8 aWhiteMap) :

 	iBlackMap(aBlackMap), iWhiteMap(aWhiteMap), iFaded(aFaded), iGroup(aWin->WinGroup())

 	{

 	}

 TBool TWalkWindowTreeSetFaded::DoIt(CWsWindow *aWin)

 	{

 	if (aWin->WinGroup()!=iGroup)

 		return ETrue;

 	const TBool KNotifyObserver = ETrue;

 	TBool dummy; //not used in this case

 	((CWsClientWindow*)aWin)->SetFaded(iFaded, iBlackMap, iWhiteMap, KNotifyObserver, dummy); 

 	return EFalse;

 	}

 TWalkWindowTreeSetSystemFaded::TWalkWindowTreeSetSystemFaded(TBool aFaded, CWsWindowBase* aWin, TUint8 aBlackMap, TUint8 aWhiteMap, TBool& aStateChanged) :

 	TWalkWindowTreeSetFaded(aFaded, aWin, aBlackMap, aWhiteMap), 

 	iStateChanged(aStateChanged)

 	{

 	}

 TBool TWalkWindowTreeSetSystemFaded::DoIt(CWsWindow *aWin)

 	{

 	if (aWin->WinGroup()!=iGroup)

 		return ETrue;

 	const TBool KNotifyObserver = EFalse; //don't send fade state change notification

 	TBool stateChanged = EFalse; 

 	((CWsClientWindow*)aWin)->SetFaded(iFaded, iBlackMap, iWhiteMap, KNotifyObserver, stateChanged);

 	iStateChanged = iStateChanged || stateChanged;

 	return EFalse;

 	}

 TWalkWindowTreePurgeEvents::TWalkWindowTreePurgeEvents()

 	{}

 TBool TWalkWindowTreePurgeEvents::DoIt(CWsWindow *aWin)

 	{

 	aWin->PurgeEvents();

 	return EFalse;

 	}

 TWalkWindowTreeCalcInvalidGraphics::TWalkWindowTreeCalcInvalidGraphics(RWsRegion *aRegion,TRegion &aDirty,const TArray<TGraphicDrawerId>& aInvalid):

 	TWalkWindowTreeRegionBase(aRegion, EWalkTranslucent),

 	iDirty(aDirty),

 	iInvalid(aInvalid)

 	{

 	}

 void TWalkWindowTreeCalcInvalidGraphics::DestroyRegions()

 	{

 	if(iSubRegion)

 		{

 		iSubRegion->Close();

 		}

 	delete iSubRegion;

 	iSubRegion = NULL;	

 	iDirty.Clear();

 	}	

 void TWalkWindowTreeCalcInvalidGraphics::CalcInvalid(CScreen& aScreen)

 	{

 	if(aScreen.RootWindow())

 		{

 		aScreen.RootWindow()->WalkWindowTree(*this,EWalkChildren);

 		if(iRegion->CheckError())

 			{

 			iDirty.ForceError();

 			}

 		}

 	}

 TBool TWalkWindowTreeCalcInvalidGraphics::CreateSubRegion()

 	{

 	iSubRegion=new RWsRegion;

 	return iSubRegion!=NULL;

 	}

 TBool TWalkWindowTreeCalcInvalidGraphics::DoIt3(CWsWindow *aWin) 

 	{

 	if (!iDirty.CheckError() && aWin->Redraw() && 

 				aWin->Redraw()->Contains(iInvalid,aWin->VisibleRegion()) &&

 				!aWin->Redraw()->RedrawingInProgress())

 		{

 		STACK_REGION intersection;

 		intersection.Intersection(*iSubRegion,aWin->VisibleRegion());

 		iDirty.Union(intersection);

 		intersection.Close();

 		}

 	return iDirty.CheckError();	//causes pessimistic full-screen redraw if failed

 	}

 #if defined(_DEBUG)

 TBool TWalkWindowTreeCheck::DoIt(CWsWindow *aWin)

 	{

 	if (aWin->WinType()==EWinTypeRoot)

 		{

 		WS_ASSERT_DEBUG(aWin->BaseParent()==NULL, EWsPanicWindowCheck);

 		WS_ASSERT_DEBUG(aWin->NextSibling()==NULL, EWsPanicWindowCheck);

 		}

 	else

 		{

 		WS_ASSERT_DEBUG(aWin->WinType()==EWinTypeClient, EWsPanicWindowCheck);

 		}

 	if (aWin->BaseChild())

 		{

 		WS_ASSERT_DEBUG(aWin->BaseChild()->BaseParent()==aWin, EWsPanicWindowCheck);

 		}

 	if (aWin->NextSibling())

 		{

 		WS_ASSERT_DEBUG(aWin->NextSibling()->GetPrevSibling()==aWin, EWsPanicWindowCheck);

 		}

 	return(EFalse);

 	}

 TBool TWalkWindowTreeFindWithFlag::DoIt(CWsWindow *aWin)

 	{

 	if (aWin->iFlags & iFlag)

 		{

 		iFound = aWin;

 		return ETrue;

 		}

 	return EFalse;

 	}

 #endif

 #include "wnredraw.h"	

 TWalkWindowTreeRedrawStoreSize::TWalkWindowTreeRedrawStoreSize() : iTotalSize(0)

 	{

 	}

 TBool TWalkWindowTreeRedrawStoreSize::DoIt(CWsWindow *aWin)

 	{

 	iTotalSize += aWin->Redraw()->SizeInBytes();

 	return EFalse;

 	}

 TBool TWalkWindowTreeFindByHandle::DoIt(CWsWindow *aWin)

 	{

 	if (aWin->ClientHandle() == iHandle)

 		{

 		iFound = aWin;

 		return ETrue;

 		}

 	return EFalse;

 	}

 TWalkWindowTreeUpdateRegions::TWalkWindowTreeUpdateRegions(CScreen & aScreen) :

 	iScreen(aScreen)

 	{

 	}

 void TWalkWindowTreeUpdateRegions::Walk()

 	{

 	STACK_REGION floatingSpriteRgn;

 	iScreen.SpriteManager()->CalcFloatingSpriteRgn( floatingSpriteRgn, iScreen.RootWindow()->AbsRect() );

 	iVisible.AddRect(iScreen.RootWindow()->AbsRect());

 	iTop.AddRect(iScreen.RootWindow()->AbsRect());

 	iRemainsOfFadableScreen.AddRect( iScreen.RootWindow()->AbsRect() );

 	iTop.SubRegion(floatingSpriteRgn);

 	iScreen.RootWindow()->WalkWindowTree(*this, EWalkChildren);

 	iTop.Close();

 	iVisible.Close();	

 	iRemainsOfFadableScreen.Close();

 	floatingSpriteRgn.Close();

 	}

 TBool TWalkWindowTreeUpdateRegions::DoIt(CWsWindow * aWin)

 	{	

 	if (aWin->IsVisible() && !iVisible.IsEmpty())

 		{

 		// Calculate the region we care about for this window:

 		STACK_REGION newVisibleRegion;

 		STACK_REGION newFadableRegion;

 		if (aWin->WinType()==EWinTypeRoot)

 			{

 			newVisibleRegion.Copy(iVisible);

 			}

 		else

 			{

 			static_cast<CWsClientWindow *>(aWin)->GetClippedBaseArea(newVisibleRegion);

 			newVisibleRegion.Intersect(iVisible);

 			if (!aWin->IsTranslucent())

 				{

 				iVisible.SubRegion(newVisibleRegion);

 				}

 			else

 				{

 				STACK_REGION opaque;

 				static_cast<CWsClientWindow *>(aWin)->GetOpaqueClippedBaseArea(opaque);

 				iVisible.SubRegion(opaque);				

 				opaque.Close();

 				}

 			//If the window has been faded calculate what region actually needs fading 

 			//(i.e. subtract what has already been faded)

 			if ( aWin->FadeCount() && !aWin->IsNonFading() && aWin->IsVisible()  && !iRemainsOfFadableScreen.IsEmpty() )

 				{

 				newFadableRegion.Copy( newVisibleRegion );

 				newFadableRegion.Intersect( iRemainsOfFadableScreen );

 				}

 			}

 		aWin->SetVisibleRegion(newVisibleRegion, &iTop);

 		aWin->SetFadeableRegion(newFadableRegion, iTop);

 		iRemainsOfFadableScreen.SubRegion( newFadableRegion );

 		newFadableRegion.Close();

 		iTop.SubRegion(newVisibleRegion);

 		newVisibleRegion.Close();

 		}

 	else

 		{

 		if (!aWin->VisibleRegion().IsEmpty())

 			{

 			aWin->ClearVisibleRegion();

 			}

 		}	

 	return(EFalse);

 	}

 TWalkWindowTreeScheduleRedraws::TWalkWindowTreeScheduleRedraws():

 	iScheduleRedrawFilter( ERedrawFilterNoFilter )

 	{

 	}

 TWalkWindowTreeScheduleRedraws::TWalkWindowTreeScheduleRedraws( TUint32 aFilter ):

 	iScheduleRedrawFilter( aFilter )

 	{

 	}

 TBool TWalkWindowTreeScheduleRedraws::DoIt(CWsWindow * aWin)

 	{

 	if (aWin->WinType() != EWinTypeClient || static_cast<CWsClientWindow *>(aWin)->HasBeenDrawnToScreen())

 		{

 		TBool ban = (iScheduleRedrawFilter & ERedrawFilterOmitDSA) && ( aWin->IsDSAHost() );

 		if ( !ban )

 			{

 			aWin->Screen()->AddRedrawRegion(aWin->VisibleRegion());

 			}

 		}

 	return EFalse;

 	}

 TWalkWindowTreeOffsetTransparentRegions::TWalkWindowTreeOffsetTransparentRegions(const TPoint& aOffset) :

 	iOffset(aOffset)

 	{

 	}

 TBool TWalkWindowTreeOffsetTransparentRegions::DoIt(CWsWindow * aWin)

 	{

 	if (aWin != aWin->RootWindow())

 		static_cast<CWsClientWindow *>(aWin)->OffsetUserTransparentRegion(iOffset);

 	return EFalse;

 	}

 TWalkWindowTreeRecalcOpaque::TWalkWindowTreeRecalcOpaque()

 	{

 	}

 TBool TWalkWindowTreeRecalcOpaque::DoIt(CWsWindow * aWin)

 	{

 	if (aWin != aWin->RootWindow())

 		static_cast<CWsClientWindow *>(aWin)->SetUserOpaqueRegion();

 	return EFalse;

 	}

 TWalkWindowTreeSendState::TWalkWindowTreeSendState(MWsWindowTreeObserver& aWindowTreeObserver)

 	: iWindowTreeObserver(aWindowTreeObserver)

 	{

 	}

 TBool TWalkWindowTreeSendState::DoIt(CWsWindow * aWin)

 	{

 	aWin->SendState(iWindowTreeObserver);

 	return EFalse;

 	}