// 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 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())

		{