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