// Copyright (c) 1995-2010 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 redraw code, three sorts of redrawing are supported

 // Sending a redraw message to the client (see redrawmsgwindow.cpp)

 // Drawing from backup bitmap

 // Simply clearing the window

 // 

 //

 #include "wnredraw.h"

 #include "server.h"

 #include "playbackgc.h"

 #include "wstop.h"

 #include "ANIM.H"

 #include "EVQUEUE.H"

 #include <s32mem.h>

 #include <gdi.h>

 #include "panics.h"

 #include "inifile.h"

 #include "rootwin.h"

 #include "EVENT.H"

 #include "wstypes.h"

 #include <graphics/surface.h>

 #include <graphics/wselement.h>

 #include <graphics/wsscreendevice.h>

 #include "windowelementset.h"

 struct TFadingParams

 	{

 	TUint8 blackMap;

 	TUint8 whiteMap;

 	};

 CWsWindowRedraw::CWsWindowRedraw(CWsWindow *aWin) : iWsWin(aWin)

 	{

 	}

 CWsWindowRedraw::~CWsWindowRedraw()

 	{

 	if (iWsWin->WsOwner())

 		{

 		iWsWin->WsOwner()->RedrawQueue()->RemoveInvalid(this);

 		}

 	if (HasElement())

 		{

 		iWsWin->Screen()->WindowElements().ReleaseAllElements(*CliWin());

 		}

 	}

 void CWsWindowRedraw::ConstructL()

 	{

 	}

 const TRegion& CWsWindowRedraw::InvalidArea() const

 	{

 	return(nullRegion);

 	}

 const TRegion &CWsWindowRedraw::BaseDrawRegion() const

 	{

 	return(iWsWin->VisibleRegion());

 	}

 void CWsWindowRedraw::ClipInvalidRegion(const TRect &)

 	{

 	}

 void CWsWindowRedraw::Resize(const TSize &, const TSize &)

 	{

 	}

 void CWsWindowRedraw::SetReply(TInt aReply)

 	{

 	iWsWin->WsOwner()->SetReply(aReply);

 	}

 void CWsWindowRedraw::OwnerPanic(TClientPanic aPanic)

 	{

 	iWsWin->OwnerPanic(aPanic);

 	}

 CWsBackedUpWindow *CWsWindowRedraw::Backup() const

 	{

 	return(NULL);

 	}

 void CWsWindowRedraw::Scroll(const TRect &, const TPoint &,const TRect &)

 	{

 	}

 void CWsWindowRedraw::UpdateAnimArea()

 	{

 	}

 void CWsWindowRedraw::PrepareForResizeL(const TSize& /* aNewSize */, TSize& /* aOldSize */)

 	{

 	}

 TBool CWsWindowRedraw::DrawCommand(CWsGc*,const TAny*)

 	{

 	return ETrue;

 	}

 void CWsWindowRedraw::GcAttributeChange(CWsGc*,const TAny*)

 	{

 	}

 void CWsWindowRedraw::GcDeactivate(CWsGc*)

 	{

 	}

 CFbsDevice* CWsWindowRedraw::OutputDevice() const

 	{

 	return NULL;

 	}

 void CWsWindowRedraw::ClientExposing()

 	{

 	}

 void CWsWindowRedraw::ClearRedrawStore(TBool)

 	{}

 void CWsWindowRedraw::PreDrawWindow(MWsGraphicsContext* aGc, const TRegion& aWindowRegion)

 	{

 	WS_ASSERT_DEBUG(iRedrawRegion == NULL, EWsPanicScheduledRedraw);

 	iRedrawRegion = &aWindowRegion;

 	CPlaybackGc::Instance()->SetTargetRegion(iRedrawRegion);

 	CWsClient::iCurrentCommand.iOpcode=0;

 	CPlaybackGc::Instance()->Activate(CliWin(), aGc, iRedrawRegion);

 	}

 void CWsWindowRedraw::PostDrawWindow(MWsGraphicsContext* aGc, const TRegion& aWindowChildNodeRegion)

 	{

 	WS_ASSERT_DEBUG(iRedrawRegion, EWsPanicScheduledRedraw);

 	CPlaybackGc::Instance()->Deactivate();

 	CPlaybackGc::Instance()->SetTargetRegion(NULL);

 	if(!Screen()->ChangeTracking())

 		{

 		DoFade(*iRedrawRegion);

 		}

 	AnnotateWindowRedrawEnd(*iWsWin);	

 	DrawWindowAnims(aGc, aWindowChildNodeRegion);

 	DrawCursorAndSprites(aGc, aWindowChildNodeRegion);

 	iRedrawRegion = 0;

 	}

 void CWsWindowRedraw::Fade(MWsGraphicsContext * aGc, const TRegion& aRegion)

 	{

 	LOG_WINDOW_FADE_START(WsWin());	

 	AnnotateWindowRedrawStart(*iWsWin, aRegion);

 	aGc->Reset();

 	DoFade(aRegion);

 	AnnotateWindowRedrawEnd(*iWsWin);		

 	LOG_WINDOW_FADE_END(WsWin());	

 	}

 void CWsWindowRedraw::DoFade(const TRegion& aRegion)

 	{

 	if( CWsTop::IsFadeEnabled() && iWsWin && iWsWin->FadeCount()>0 && !(iWsWin->IsNonFading()) && !(iWsWin->FadableRegion().IsEmpty()) && !(iWsWin->IsDSAHost()) )

 		{

 		MWsFader* fader = static_cast<MWsFader*>(iWsWin->Screen()->ResolveObjectInterface(KMWsFader));

 		if(fader)

 			{

 		  	TFadingParams parameters;

 	  		iWsWin->GetFadingParams(parameters.blackMap,parameters.whiteMap);

 	      	TPckgBuf<TFadingParams> buf(parameters);

 	      	fader->SetFadingParameters(buf);

 		  	// Only fade the region that hasn't been faded before

 	  		STACK_REGION fdRgn;

 	  		fdRgn.Copy( aRegion );

 			fdRgn.Intersect( iWsWin->FadableRegion() );

 			if(!fdRgn.CheckError())

 				{

 				fader->FadeArea( fdRgn );

 				LOG_WINDOW_FADE_REGION(&fdRgn);

 				}

 	  		fdRgn.Close();

 	      	}

 		}

 	}

 void CWsWindowRedraw::DrawWindowAnims(MWsGraphicsContext * aGc, const TRegion& aRegion)

 	{

 	if (iWsWin->iAnimList)

 		{

 		// If an anim panics, it will leave and set the panic flag on the client

 		// The client itself won't actually panic yet, and we don't want to leave from here.

 		TRAP_IGNORE(DrawWindowAnimsL(aGc, aRegion));

 		}

 	}

 void CWsWindowRedraw::DrawWindowAnimsL(MWsGraphicsContext * aGc, const TRegion& aRegion)

 	{

 	for (CWsAnim * anim = iWsWin->iAnimList; anim; anim = anim->Next())

 		{

 		AnnotateWindowAnimRedrawStart(*iWsWin, *anim, aRegion);

 		//Animate and redraw

 		TRAPD(err,anim->RedrawWindowAnimL(Screen()->Now(), aGc, &aRegion));

 		if(err!=KErrNone)

 			{

 			AnnotateWindowAnimRedrawEnd(*iWsWin, *anim);

 			anim->Panic(EWservPanicAnimLeave);

 			return;

 			}

 		AnnotateWindowAnimRedrawEnd(*iWsWin, *anim);

 		}

 	}

 void CWsWindowRedraw::DrawCursorAndSprites(MWsGraphicsContext * aGc, const TRegion& aRegion)

 	{	

 	// Draw standard text cursor if required

 	RWsTextCursor* const cursor = CWsTop::CurrentTextCursor();

 	if (!iWsWin->Screen()->ChangeTracking() && cursor && cursor->Win() == iWsWin && cursor->IsStandardCursorActive())

 		{

 		// Standard text cursor is active on this window

 		const TBool flashing = cursor->IsFlashing();

 		TFlashState flashState = EFlashOn;

 		if (flashing)

 			{

 			flashState = cursor->CurrentCursorFlashState();

 			}

 		if (flashState == EFlashOn)

 			{

 			// Cursor should be visible, so draw it

 			cursor->Draw(aRegion);

 			}

 		if (flashing)

 			{

 			// Reschedule to flash the standard cursor on or off

 			Screen()->ScheduleAnimation(ETextCursor, cursor->RectRelativeToScreen(), Screen()->SpriteManager()->NextCursorFlashStateChange(), 0, 0, iWsWin);

 			}

 		}

 	for (CWsSpriteBase * sprite = iWsWin->iSpriteList; sprite; sprite = sprite->Next())

 		{

         TBool hasRedrawBegun = EFalse;

 		STACK_REGION redrawRegion;

 		sprite->CalcRedrawRegion(aRegion, redrawRegion);

 		if(redrawRegion.CheckError() || !redrawRegion.IsEmpty())

 			{

 			if (sprite->IsFlashingEnabled() || sprite->IsDirty() || sprite->HasAnimation())

 				{

                 if (sprite->IsDirty() || sprite->HasAnimation())

                     {

                     AnnotateSpriteRedrawStart(*iWsWin, *sprite, redrawRegion);

                     hasRedrawBegun = ETrue;

                     }

 				if(sprite->HasAnimation())

 					{

 					CWsAnim* anim = static_cast<CWsSprite*>(sprite)->iAnim;

 					WS_ASSERT_DEBUG(anim,EWsPanicAnim);

 					//Animate and...

 					TRAPD(err, anim->AnimateSpriteAnimL(Screen()->Now()));

 					if(err!=KErrNone)

 						{

 						AnnotateSpriteRedrawEnd(*iWsWin, *sprite);

 						anim->Panic(EWservPanicAnimLeave);

 						return;

 						}

 					}

 				//...call Redraw on the sprite

 				if (hasRedrawBegun)

 				    {

                     aGc->Reset();

 				    }

 				sprite->Redraw(aGc, redrawRegion);

 				if (hasRedrawBegun)

 				    {

                     AnnotateSpriteRedrawEnd(*iWsWin, *sprite);

 				    }

 				}

 			}

 		redrawRegion.Close();

 		}

 	}

 TBool CWsWindowRedraw::Contains(const TArray<TGraphicDrawerId>& /*aDrawers*/,const TRegion& aRegion) const

 	{

 	// if in doubt, assume we do

 	return !aRegion.IsEmpty();

 	}

 TInt CWsWindowRedraw::DrawBackgroundColor(const TRegion& aRegion, TBool	aDoFillColor)

 	{

 	if (BackColor().Alpha() == 0 && !HasElement())

 		return KErrNone;

 	if(aRegion.IsEmpty())

 		return KErrNone;

 	TRect winAbs(CliWin()->AbsRect());	//fill size for background color fill

 	TRect surfaceAbs(0,0,0,0);			//fill size for background surface fill - initially disabled

 	if (HasElement())

 		{

 		TBackgroundAttributes* backgroundAttributes = CliWin()->Screen()->WindowElements().FindBackgroundElement(*CliWin());

 		WS_ASSERT_DEBUG(backgroundAttributes,EWsPanicNoWindowElement);

 		if (backgroundAttributes->iElement)

 			{

 			if (backgroundAttributes->ExplicitExtent())

 				{

 				backgroundAttributes->iElement->GetDestinationRectangle(surfaceAbs);

 				surfaceAbs.Intersection(winAbs);

 				if (surfaceAbs==winAbs)

 					{

 					winAbs.iBr.iX=winAbs.iTl.iX;	//disable background color fill

 					}

 				}

 			else

 				{

 				surfaceAbs=winAbs;

 				winAbs.iBr.iX=winAbs.iTl.iX;	//disable background color fill

 				}

 			}

 		if (!aDoFillColor)

 			{

 			winAbs.iBr.iX=winAbs.iTl.iX;	//disable background color fill

 			}

 		}

 	CPlaybackGc* playback = CPlaybackGc::Instance();

 	MWsGraphicsContext* gc = static_cast<MWsGraphicsContext*>(playback->ResolveObjectInterface(KMWsGraphicsContext));

 	gc->SetClippingRegion(aRegion);

 	gc->SetBrushStyle(MWsGraphicsContext::ESolidBrush);

 	gc->SetPenStyle(MWsGraphicsContext::ENullPen);

 	TInt err = KErrNone;

 	if (!winAbs.IsEmpty())

 		{

 		gc->SetBrushColor(BackColor());

 		gc->DrawRect(winAbs);

 		}

 	if (!surfaceAbs.IsEmpty())

 		{

 		gc->SetDrawMode(MWsGraphicsContext::EDrawModeWriteAlpha);

 		gc->SetBrushColor(TRgb(0,0,0,0));

 		gc->DrawRect(surfaceAbs);

 		gc->SetBrushColor(BackColor());		//leave in a sensible state

 		gc->SetDrawMode(MWsGraphicsContext::EDrawModePEN);

 		}

 	gc->ResetClippingRegion();

 	return err;

 	}

 TBool CWsWindowRedraw::ReleaseMemory(MWsMemoryRelease::TMemoryReleaseLevel)

 	{

 	return EFalse;

 	}

 void CWsWindowRedraw::VisibleRegionChange()

 	{

 	}

 TBool CWsWindowRedraw::ReadyToDraw() const

 	{

 	return ETrue;

 	}

 TBool CWsWindowRedraw::RedrawingInProgress() const

 	{

 	return EFalse;	

 	}

 void CWsWindowRedraw::WindowClosing()

 	{

 	ReleaseBackgroundElement();

 	}

 TBool CWsWindowRedraw::HasDsaElement() const

 	{

 	TBool hasDsaElement = EFalse;

 	if (HasElement())

 		{

 		CWsClientWindow* cliWin = CliWin();

 		CWindowElementSet& set = cliWin->Screen()->WindowElements();

 		TBackgroundAttributes* backgroundAttributes = set.FindBackgroundElement(*cliWin);

 		WS_ASSERT_DEBUG(backgroundAttributes,EWsPanicNoWindowElement);

 		if (backgroundAttributes->iElement)

 			{

 			MWsElement& element = *(backgroundAttributes->iElement);

 			hasDsaElement = (element.ConnectedSurface() == cliWin->Screen()->DsaSurface());

 			}

 		}

 	return hasDsaElement;

 	}

 void CWsWindowRedraw::SetDsaElementL()

 	{

 	TRect extent(TPoint(0,0), WsWin()->Screen()->DSASizeInPixels());

 	MWsDisplayMapping *dispMap = WsWin()->Screen()->DisplayMapping();

 	TRect extentOut;

 	TRect extentInDSA;

 	if(dispMap)

 		{

 		dispMap->MapCoordinates(EDirectScreenAccessSpace,extent,EApplicationSpace,extentOut);

 		//DSA extent in application space intersects window extent in application space

 		extentOut.Intersection(WsWin()->FullRect());		

 		if(extentOut.IsEmpty())

 			{

 			extentOut.SetRect(0,0,0,0);

 			}

 		//use DSA coordinates to determine the viewport

 		dispMap->MapCoordinates(EApplicationSpace, extentOut, EDirectScreenAccessSpace, extentInDSA);

 		}

 	else

 		{

 		extentOut = extent;

 		extentInDSA = extent;

 		extentOut.Intersection(WsWin()->FullRect());

 		}

 	if (!HasDsaElement())

 		{

 		WsWin()->Screen()->ClearDsaSurface(extent, BackColor());

 		}

 	TSurfaceConfiguration sc;

 	sc.SetSurfaceId(WsWin()->Screen()->DsaSurface());

 	sc.SetExtent(extentOut.Size());

 	sc.SetViewport(extentInDSA);

 	SetBackgroundSurfaceL(sc, ETrue, ETrue);

 	}

 TBackgroundAttributes& CWsWindowRedraw::AcquireBackgroundElementL()

 	{

 	// Only client windows can have elements set

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

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

 	CScreen* screen = cliWin->Screen();

 	WS_ASSERT_DEBUG(screen,EWsPanicNoScreen);

 	CWindowElementSet& set = screen->WindowElements();

 	SetHasElement(EFalse);

 	TBackgroundAttributes& backgroundAttributes = set.AcquireBackgroundElementL(*cliWin);

 	MWsElement& element = *(backgroundAttributes.iElement);

 	element.SetGlobalAlpha(cliWin->IsVisible() ? 0xFF : 0);

 	SetHasElement(ETrue);

 	screen->ElementAdded();

 	return backgroundAttributes;

 	}

 void CWsWindowRedraw::SetBackgroundSurfaceL(const TSurfaceId& aSurface)

 	{

 	if (aSurface.Type() == TSurfaceId::EScreenSurface || aSurface.IsNull())

 		{

 		OwnerPanic(EWservPanicInvalidSurface);

 		}

 	CWsClientWindow* cliWin = CliWin();

 	CScreen* screen = cliWin->Screen();

 	CWindowElementSet& set = screen->WindowElements();

 	TBackgroundAttributes& backgroundAttributes = AcquireBackgroundElementL();

 	MWsElement& element = *(backgroundAttributes.iElement);

     TInt err = set.RegisterSurface(aSurface);

     if (err != KErrNone)

         {

         ReleaseBackgroundElement();

         User::Leave(err);

         }

 	err = element.ConnectSurface(aSurface); 

 	if (err != KErrNone)

 		{

 		set.UnregisterSurface(aSurface);

 		ReleaseBackgroundElement();

 		User::Leave(err);

 		}

 	TRect winExtent = cliWin->FullRect();

 	element.SetDestinationRectangle(winExtent);

 	// By default Element's source rectangle is set to its surface rectangle

 	TRect srcRect;

 	element.GetSourceRectangle(srcRect);

 	cliWin->SetOriginalSrcElementRect(srcRect);

 	cliWin->SetOriginalDestElementRect(winExtent);

 	SetMayContainElementFlags();

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

 	if (windowTreeObserver)

 		{

 		windowTreeObserver->ElementAdded(*iWsWin, element);

 		}

 	}

 void CWsWindowRedraw::SetBackgroundSurfaceL(const TSurfaceConfiguration& aConfiguration, TBool aTriggerRedraw, TBool aAllowScreenSurface)

 	{

 	if (aConfiguration.Size() < sizeof(TSurfaceConfiguration))

 		{

 		__ASSERT_COMPILE(sizeof(TSurfaceConfiguration2)==sizeof(TSurfaceConfiguration));

 		if (aConfiguration.Size() != sizeof(TSurfaceConfiguration1))

 			{

 			OwnerPanic(EWservPanicInvalidSurfaceConfiguration);

 			}

 		}

 	TSurfaceId surfaceId;

 	aConfiguration.GetSurfaceId(surfaceId);

 	if ((surfaceId.Type() == TSurfaceId::EScreenSurface && !aAllowScreenSurface) || surfaceId.IsNull())

 		{

 		OwnerPanic(EWservPanicInvalidSurface);

 		}

 	CFbsBitGc::TGraphicsOrientation tempOrientation = aConfiguration.Orientation();

 	__ASSERT_COMPILE(CFbsBitGc::EGraphicsOrientationNormal==0 && 

 			CFbsBitGc::EGraphicsOrientationRotated270 == 3);

 	if(tempOrientation < CFbsBitGc::EGraphicsOrientationNormal || 

 			tempOrientation > CFbsBitGc::EGraphicsOrientationRotated270)

 		{

 		OwnerPanic(EWservPanicInvalidSurfaceConfiguration);

 		}

 	CWsClientWindow* cliWin = CliWin();

 	CScreen* screen = cliWin->Screen();

 	__ASSERT_DEBUG(screen, Panic(EWsPanicNoScreen));

 	CWindowElementSet& set = screen->WindowElements();

 	TBool mustRegister = ETrue;

 	TRect oldExtent(0,0,0,0);

 	MWsElement::TElementRotation oldRotation = MWsElement::EElementAntiClockwise0;

 	TBool oldFlip = EFalse;

 	TRect oldViewport(0,0,0,0);

 	TSurfaceId oldSurfaceId = TSurfaceId::CreateNullId();

 	// If a element has already been set

 	if (HasElement())

 		{

 		TBackgroundAttributes* backgroundAttributes = set.FindBackgroundElement(*cliWin);

 		WS_ASSERT_DEBUG(backgroundAttributes,EWsPanicNoWindowElement);

 		if (backgroundAttributes->iElement)

 			{

 			MWsElement& element = *(backgroundAttributes->iElement);

 			element.GetDestinationRectangle(oldExtent);

 			element.GetSourceRectangle(oldViewport);

 			oldRotation = element.SourceRotation();

 			oldFlip = element.SourceFlipping();

 			oldSurfaceId = element.ConnectedSurface();

 			mustRegister = EFalse;

 			// If it is a different surface, flag to register the new surface

 			if (element.ConnectedSurface() != surfaceId)

 				{

 				mustRegister = ETrue;

 				}

 			}

 		}

 	//the call to AcquireBackgroundElementL() will remove any existing background element

 	TBackgroundAttributes& backgroundAttributes = mustRegister ? 

 			AcquireBackgroundElementL() : *(set.FindBackgroundElement(*cliWin));

 	MWsElement& element = *(backgroundAttributes.iElement);

 	TInt err = KErrNone;

 	if (mustRegister)

 		{

         err = set.RegisterSurface(surfaceId);

         switch(err)

             {

         case KErrBadHandle:

             // Invalid surface IDs have to return KErrArgument

             err = KErrArgument;

             // drop through

         case KErrNoMemory:

         case KErrArgument:

             ReleaseBackgroundElement();

             User::Leave(err);

         case KErrNone:

             break;

         default:

             // No need to release layer here since session closure will do it

             // automatically when the client thread is panicked.

             OwnerPanic(EWservPanicInvalidSurface);

             }

 		err = element.ConnectSurface(surfaceId);

 		if (err != KErrNone)

 			{

 			set.UnregisterSurface(surfaceId);

 			ReleaseBackgroundElement();	//Releasing new empty element

 			User::Leave(err);

 			}

 		if (screen->DsaSurface() == surfaceId)

 			{

 	         TUint32 flags; 

 	         element.GetRenderStageFlags(flags);

 	         flags |= MWsElement::EElementIsDirectlyRenderedUserInterface;

 	         element.SetRenderStageFlags(flags);

 			}

 		}

 	SetHasElement(ETrue);		//set element flag

 	SetMayContainElementFlags();

 	err = CWindowElement::SetElement(element,aConfiguration,ETrue);	//set viewport and orientation

 	if (err == KErrArgument)

 		{

 		OwnerPanic(EWservPanicInvalidSurfaceConfiguration);

 		}

     TRect srcRect;

     aConfiguration.GetViewport(srcRect);

     if (!srcRect.IsEmpty())

         backgroundAttributes.SetExplicitViewPort();

     element.GetSourceRectangle(srcRect);

     cliWin->SetOriginalSrcElementRect(srcRect);

 	//Set Extent

 	TRect newExtent;

 	aConfiguration.GetExtent(newExtent);

 	SetElementExtentL(newExtent, backgroundAttributes);

 	cliWin->SetOriginalDestElementRect(newExtent);

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

 	if (windowTreeObserver && mustRegister)

 		{

 		windowTreeObserver->ElementAdded(*iWsWin, element);

 		}

 	//If set, redraw

 	if (aTriggerRedraw)

 		{

 		TRect newViewport;

 		aConfiguration.GetViewport(newViewport);

 		CFbsBitGc::TGraphicsOrientation orientation = aConfiguration.Orientation();

 		MWsElement::TElementRotation newRotation = GcToElementRotation(orientation);

 		TBool newFlip = aConfiguration.Flip();

 		//The following parameter guarantees that update will be scheduled. 

 		//This will trigger the composition.

 		TBool alwaysScheduleUpdate = (oldSurfaceId != surfaceId) || 

 									(oldExtent != newExtent) ||

 									(oldViewport != newViewport) ||

 									(oldRotation != newRotation)||

 									(oldFlip != newFlip);

 		ElementRedraw(oldExtent,newExtent,alwaysScheduleUpdate);

 		}

 	}

 /**

 Sets the EMayContainElement flag for parent window.

 Sets the flag for all ancestor windows.

 **/

 void CWsWindowRedraw::SetMayContainElementFlags()

 	{

 	CWsWindowBase* parent = CliWin()->BaseParent();

 	TInt type = parent->WinType();

 	while(type ==EWinTypeClient)

 			{

 			CWsClientWindow* win = static_cast<CWsClientWindow*>(parent);

 			win->Redraw()->iStateFlags |= EMayContainElement;

 			parent=parent->BaseParent();

 			type = parent->WinType();

 			}

 	}

 void CWsWindowRedraw::SetElementExtentL(TRect& aNewExtent, TBackgroundAttributes& aAttributes)

 	{

 	CWsClientWindow* cliWin = CliWin();

 	MWsElement& element = *(aAttributes.iElement);

 	if (aNewExtent.IsEmpty())

 		{

 		aNewExtent = cliWin->FullRect();

 		aAttributes.SetExplicitExtent(EFalse);

 		}

 	else

 		{

 		TRect tempWindowPosition = cliWin->FullRect();		//get window absolute coordinates

 		aNewExtent.Move(tempWindowPosition.iTl);				//shift user defined extent to absolute coordinates

 		aAttributes.SetExplicitExtent(ETrue);

 		}

 	element.SetDestinationRectangle(aNewExtent);

 	}

 void CWsWindowRedraw::ElementRedraw(const TRect& aOldExtent, const TRect& aNewExtent, TBool aAlwaysScheduleUpdate)

 	{

 	if (!aOldExtent.IsEmpty())

 		{

 		//If the previous extent was different

 		if (aOldExtent != aNewExtent)

 			{

 			STACK_REGION tempRegion;

 			tempRegion.AddRect(aOldExtent);

 			tempRegion.AddRect(aNewExtent);

 			//Calculate the difference between

 			TRect tempRect = aOldExtent;

 			tempRect.Intersection(aNewExtent);			//intersect both regions

 			tempRegion.SubRect(tempRect);		//cut unaltered region

 			Screen()->ScheduleRegionUpdate(&tempRegion);

 			tempRegion.Close();

 			}

 		else

 			{

 			if(aAlwaysScheduleUpdate)

 				{

 				TTimeIntervalMicroSeconds interval(0);

 				Screen()->ScheduleRender(interval);

 				}

 			}

 		}

 	else

 		{

 		TRegionFix<1> region(aNewExtent);

 		Screen()->ScheduleRegionUpdate(&region);

 		}

 	}

 void CWsWindowRedraw::RemoveBackgroundSurface(TBool aTriggerRedraw)

 	{

 	if (HasElement())

 		{

 		TBackgroundAttributes* backgroundAttributes = CliWin()->Screen()->

 				WindowElements().FindBackgroundElement(*CliWin());

 		WS_ASSERT_DEBUG(backgroundAttributes,EWsPanicNoWindowElement);

 		if (backgroundAttributes->iElement)

 			{

 			RemoveBackgroundElement(aTriggerRedraw);

 			}

 		}

 	}

 void CWsWindowRedraw::RemoveBackgroundElement(TBool aTriggerRedraw)

 	{

 	CWsClientWindow* cliWin = CliWin();

 	CScreen* screen = cliWin->Screen();

 	TRect tempRect;

 	if (aTriggerRedraw)

 		{

 		TBackgroundAttributes* backgroundAttributes = screen->WindowElements().FindBackgroundElement(*CliWin());

 		WS_ASSERT_DEBUG(backgroundAttributes,EWsPanicNoWindowElement);

 		if (backgroundAttributes->ExplicitExtent())

 			{

 			backgroundAttributes->iElement->GetDestinationRectangle(tempRect);

 			backgroundAttributes->SetExplicitExtent(EFalse);

 			}

 		else

 			{

 			tempRect = cliWin->FullRect();

 			}

 		}

 	ReleaseBackgroundElement();

     if (aTriggerRedraw)

         {

         if (screen->ChangeTracking())

             {

             TTimeIntervalMicroSeconds interval(0);

             screen->ScheduleRender(interval);

             }

         else

             {

             TRegionFix<1> region(tempRect);

             screen->ScheduleRegionUpdate(&region);

             }

         }

 	}

 void CWsWindowRedraw::GetBackgroundSurfaceL(TSurfaceConfiguration& aConfiguration)

 	{

 	if (aConfiguration.Size() < sizeof(TSurfaceConfiguration))

 		{

 		__ASSERT_COMPILE(sizeof(TSurfaceConfiguration2)==sizeof(TSurfaceConfiguration));

 		if (aConfiguration.Size() != sizeof(TSurfaceConfiguration1))

 			{

 			OwnerPanic(EWservPanicInvalidSurfaceConfiguration);

 			}

 		}

 	CWsClientWindow* cliWin = CliWin();

 	TBackgroundAttributes* backgroundAttributes = NULL;

 	if (HasElement())

 		{

 		backgroundAttributes = cliWin->Screen()->WindowElements().FindBackgroundElement(*cliWin);

 		WS_ASSERT_DEBUG(backgroundAttributes,EWsPanicNoWindowElement);

 		if (!backgroundAttributes->iElement)

 			{

 			User::Leave(KErrNotFound);

 			}

 		}

 	else

 		{

 		User::Leave(KErrNotFound);

 		}

 	MWsElement& element = *(backgroundAttributes->iElement);

 	TInt errCode=CWindowElementSet::GetConfiguration(aConfiguration,element);

 	// Get source rect

 	if (errCode>=KErrNone)

 	    {

 	    if (!backgroundAttributes->ExplicitViewPort())

 	        {

 	        aConfiguration.SetViewport(TRect());

 	        }

 	    else

 	        {

 	        TRect tempExtent = cliWin->GetOriginalSrcElementRect();

 	        aConfiguration.SetViewport(tempExtent);

 	        }

 	    }

 	//Convert and copy extent

 	if (errCode>=KErrNone)

 		{

 		if (!backgroundAttributes->ExplicitExtent())

 			{

 			aConfiguration.SetExtent(TRect());

 			}

 		else	//translate to window coordinates

 			{

 			TRect tempExtent = cliWin->GetOriginalDestElementRect();

 			tempExtent.Move(-cliWin->Origin());

 			aConfiguration.SetExtent(tempExtent);

 			}

 		}

 	}

 void CWsWindowRedraw::ReleaseBackgroundElement()

 	{

 	if (HasElement())

 		{

 		CWsClientWindow* cliWin = CliWin();

 		CScreen* screen = cliWin->Screen();

 		screen->WindowElements().ReleaseBackgroundElement(*cliWin, ETrue);

 		screen->ElementRemoved();

 		}

 	}

 //

 // Blank window //

 //

 CWsBlankWindow::CWsBlankWindow(CWsWindow *aWin) : CWsWindowRedraw(aWin), iColor(iWsWin->RootWindow()->DefaultBackgroundColor()), iNoColor(EFalse)

 	{

 	}

 CWsBlankWindow::~CWsBlankWindow()

 	{

 	}

 void CWsBlankWindow::ConstructL()

 	{

 	CWsWindowRedraw::ConstructL();

 	if (Screen()->ChangeTracking())

 		{

 		STACK_REGION dirtyRegion;

 		dirtyRegion.Copy(iWsWin->WindowArea());

 		dirtyRegion.Offset(-iWsWin->Origin());

 		iWsWin->AddDirtyWindowRegion(dirtyRegion);

 		dirtyRegion.Close();

 		}

 	}

 void CWsBlankWindow::SetColor(TRgb aColor)

 	{

 	iColor=aColor;

 	iNoColor=EFalse;

 	if (Screen()->ChangeTracking())

 		{

 		STACK_REGION dirtyRegion;

 		dirtyRegion.Copy(iWsWin->WindowArea());

 		dirtyRegion.Offset(-iWsWin->Origin());

 		iWsWin->AddDirtyWindowRegion(dirtyRegion);

 		dirtyRegion.Close();

 		if (iWsWin->IsActive() && iWsWin->IsVisible())

 			{

 			Screen()->ScheduleWindow(iWsWin);

 			}

 		}

 	else

 		{

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

 		}

 	}

 TBool CWsBlankWindow::CommandL(TInt aOpcode, TWsWinCmdUnion &aCmd)

 	{

 	switch(aOpcode)

 		{

 		case EWsWinOpSetBackgroundSurface:

 			SetBackgroundSurfaceL(*aCmd.Surface);

 			break;

 		case EWsWinOpSetBackgroundSurfaceConfig:

 			SetBackgroundSurfaceL(aCmd.SurfaceConfigurationAndTrigger->surfaceConfig, aCmd.SurfaceConfigurationAndTrigger->triggerRedraw, EFalse);

 			break;

 		case EWsWinOpRemoveBackgroundSurface:

 			RemoveBackgroundSurface(*aCmd.Bool);

 			break;

 		case EWsWinOpGetBackgroundSurfaceConfig:

 			{

 			TSurfaceConfiguration tempConfiguration = *aCmd.SurfaceConfiguration;

 			GetBackgroundSurfaceL(tempConfiguration);

 			TInt tempSize = aCmd.SurfaceConfiguration->Size();

 			if (sizeof(TSurfaceConfiguration)<tempSize)

 				tempSize = sizeof(TSurfaceConfiguration);

 			CWsClient::ReplyBuf(&tempConfiguration,tempSize);

 			}

 			break;

 		case EWsWinOpSetColor:

 			SetColor(*aCmd.rgb);

 			break;

 		case EWsWinOpSetNoBackgroundColor:

 			SetBackgroundClear();

 			break;

 		default:

 			return(EFalse);

 		}

 	return(ETrue);

 	}

 TRgb CWsBlankWindow::BackColor() const

 	{

 	return(iColor);

 	}

 TBool CWsBlankWindow::GetRedrawRect(TRect &) const

 	{

 	if (!iNoColor || iWsWin->iAnimList)

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

 	return(EFalse);

 	}

 TBool CWsBlankWindow::NeedsRedraw() const

 	{

 	return(EFalse);

 	}

 void CWsBlankWindow::DrawWindow()

 	{

 	if ((!iNoColor)||HasElement())

 		{

 		DrawBackgroundColor(*iRedrawRegion,!iNoColor);

 		}

 	}