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

// CWsWindowRedraw and associated classes definitions

// 

//

#ifndef __WNREDRAW_H__

#define __WNREDRAW_H__

#include "server.h"

#include "panics.h"

class TSurfaceId;

class CPlaybackGc;

class MWsGraphicsContext;

class TBackgroundAttributes;

//

// Base class defining how a window is redrawn, i.e. Backed up, redraw from client, blanked...

//

class CWsWindowRedraw : public CBase

	{

private:

	enum TStateFlags

		{

		EHasElement=0x01,

		EMayContainElement=0x10,

		};

public:

	~CWsWindowRedraw();

	virtual void ConstructL();

	virtual TBool CommandL(TInt aOpcode, TWsWinCmdUnion &aCmd)=0;

	virtual TRgb BackColor() const=0;

	virtual TBool NeedsRedraw() const=0;

	virtual TBool GetRedrawRect(TRect &aRect) const=0;

	virtual const TRegion &BaseDrawRegion() const;

	virtual void ClipInvalidRegion(const TRect &aRect);

	virtual const TRegion& InvalidArea() const;

	virtual void Resize(const TSize &aSize, const TSize &aOldSize);

	virtual CWsBackedUpWindow *Backup() const;

	virtual void Scroll(const TRect &aClipRect, const TPoint &aOffset,const TRect &aRect);

	virtual void UpdateAnimArea();

	virtual void PrepareForResizeL(const TSize &aSize, TSize &aOldSize);

	virtual void Moved() {}

	virtual void ClearRedrawStore(TBool aClearPendingRedraw=EFalse);

	virtual TBool DrawCommand(CWsGc* aGc,const TAny *aCmdData);

	virtual void GcAttributeChange(CWsGc* aGc,const TAny *aCmdData);

	virtual void GcDeactivate(CWsGc* aGc);

	inline CWsWindow *WsWin();	// Link back to main window class

	virtual void ClientExposing();

	virtual void DrawWindow()=0;

	TInt DrawBackgroundColor(const TRegion& aRegion, TBool aDoFillColor);

	virtual TBool Contains(const TArray<TGraphicDrawerId>& aDrawers,const TRegion& aRegion) const;

	const TRegion * RedrawRegion();

	virtual TBool ReleaseMemory(MWsMemoryRelease::TMemoryReleaseLevel aLevel);

	virtual CFbsDevice* OutputDevice() const;

	virtual void VisibleRegionChange();

	virtual TBool ReadyToDraw() const;

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

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

	virtual void Invalidate(const TRect *) {}	

	virtual TInt SizeInBytes() const { return 0; }

	inline TBool HasElement() const;

	inline TBool MayContainElement() const;

	inline void SetHasElement(TBool);

	inline TBool HasElementExtentDefined() const;

	inline void  ClearMayContainElement();

	virtual TBool RedrawingInProgress() const; 

	virtual void WindowClosing();

	virtual TBool IsRedrawStoreEmpty() const { return EFalse; }

	virtual TBool IsBackgroundClearEnabled() const { return ETrue; }

	virtual CFbsBitmap* BitmapFromHandle(TInt /*aHandle*/) const { return NULL; }

	void SetDsaElementL();

	inline void QueueRedraw();

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

protected:

	CWsWindowRedraw(CWsWindow *aWin);

	void SetReply(TInt aReply);

	void OwnerPanic(TClientPanic aPanic);

	inline CScreen* Screen() const;

	inline CWsClientWindow *CliWin() const;

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

	TBackgroundAttributes& AcquireBackgroundElementL();

	void SetBackgroundSurfaceL(const TSurfaceId& aSurface);

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

	void SetElementExtentL(TRect& aNewExtent, TBackgroundAttributes& aAttributes);

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

	void RemoveBackgroundSurface(TBool aTriggerRedraw);

	void RemoveBackgroundElement(TBool aTriggerRedraw);

	void GetBackgroundSurfaceL(TSurfaceConfiguration& aConfiguration);

	void ReleaseBackgroundElement();

	void SetMayContainElementFlags();

private:

	void DoFade(const TRegion& aRegion);

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

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

	TBool HasDsaElement() const;

protected:

	CWsWindow *iWsWin;	// Link back to main window class

	TUint iStateFlags; 	// Flags affecting how drawing is done

	const TRegion * iRedrawRegion; // During a scheduled draw, this is the window area scheduled to be drawn.

	};							   // In ChangeTracking mode, iRedrawRegion doesn't include the area to be drawn by window-sprites, cursors or window-anims.

								   // All of them use the sprite region, declared in CWsWindow::iDirtySpriteRegion.

class CWsBlankWindow : public CWsWindowRedraw

	{

public:

	CWsBlankWindow(CWsWindow *aWin);

	~CWsBlankWindow();

	void ConstructL();

	//from CWsWindowRedraw

	TBool CommandL(TInt aOpcode, TWsWinCmdUnion &aCmd);

	TBool NeedsRedraw() const;

	TBool GetRedrawRect(TRect &aRect) const;

	void DrawWindow();

	void SetColor(TRgb aColor);

	inline void SetBackgroundClear();

	inline TBool IsBackgroundColor();

private:

	TRgb BackColor() const;

private:

	TRgb iColor;

	TBool iNoColor;

	};

#include "window.h"

inline CWsWindow *CWsWindowRedraw::WsWin()

	{

	return iWsWin;

	}

inline CScreen* CWsWindowRedraw::Screen() const

	{

	return iWsWin->Screen();

	}

inline CWsClientWindow *CWsWindowRedraw::CliWin() const

	{

	return (CWsClientWindow *)iWsWin;

	}

inline TBool CWsWindowRedraw::HasElement() const

	{

	return (iStateFlags&EHasElement)>0;

	}

inline void CWsWindowRedraw::SetHasElement(TBool aSet)

	{

	TInt oldStateFlags = iStateFlags; 

	if (aSet)

		{

		iStateFlags|=EHasElement;

		}

	else

		{

		iStateFlags&=~EHasElement;

		}

	if (oldStateFlags!=iStateFlags)

		{

		iWsWin->SetupVisibleRegionTracking(aSet);

		}

	}

inline TBool CWsWindowRedraw::MayContainElement() const

	{

	return (iStateFlags&EMayContainElement)>0;

	}

inline void CWsWindowRedraw::ClearMayContainElement()

	{

	iStateFlags&=~EMayContainElement;

	}

inline void CWsBlankWindow::SetBackgroundClear()

	{

	iNoColor=ETrue;

	}

inline TBool CWsBlankWindow::IsBackgroundColor()

	{

	return !iNoColor;

	}

inline void CWsWindowRedraw::QueueRedraw()

	{

	if (iWsWin->IsActive())

		{

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

		}

	}

inline const TRegion * CWsWindowRedraw::RedrawRegion()

	{

	return iRedrawRegion;

	}

#endif