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

// TWalkWindowTreeBase and associated classes definitions

// 

//

#ifndef __WALKWINDOWTREE_H__

#define __WALKWINDOWTREE_H__

#include "server.h"

class CWsWindow;

class CWsWindowBase;

class RWsTextCursor;

class TWalkWindowTreeBase

	{

public:

	virtual TBool DoIt(CWsWindow *aWin)=0;

	};

class TResumableWalkWindowTreeBase

	{

public:

	virtual TBool DoIt(CWsWindow *aWin)=0;

private: // walk state

	friend class CWsWindowBase;

	CWsWindowBase* iWin;

	CWsWindowBase* iEnd;

	CWsWindowBase* iNextChild;

	CWsWindowBase* iParent;

	};

class TWalkWindowTreeRegionBase : public TWalkWindowTreeBase

	{

public:

	enum TTranslucentBehaviour

		{

		EDontWalkTranslucent,              //< Default behaviour - stop when you reach a window

		EWalkTranslucent,                  //< Walk through translucent parts of windows

		};

protected:

	TWalkWindowTreeRegionBase(RWsRegion *aRegion, TTranslucentBehaviour aTranslucentBehaviour = EDontWalkTranslucent);

	TBool DoIt(CWsWindow *aWin);

	virtual void DoIt2(CWsWindow *aWin)=0;

	virtual TBool DoIt3(CWsWindow *aWin);

protected:

	TTranslucentBehaviour iTranslucentBehaviour;

	RWsRegion *iRegion;

	RWsRegion *iSubRegion;

	};

/**

This tree walker calculates the visible regions of all windows and schedules

redraws for anywhere which has changed.

*/

class TWalkWindowTreeUpdateRegions : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeUpdateRegions(CScreen & aScreen);

	TBool DoIt(CWsWindow * aWin);

	void Walk();

private:

	CScreen & iScreen;

	RWsRegion iVisible;

	RWsRegion iTop;

	RWsRegion iRemainsOfFadableScreen; // The remains after the accumulation of already faded regions

	};

/**

This schedules the visible regions of all windows walked for redraw.

*/

class TWalkWindowTreeScheduleRedraws : public TWalkWindowTreeBase

	{

public:

	enum TBitMask

		{

		ERedrawFilterNoFilter	= 0x00,

		ERedrawFilterOmitDSA	= 0x01

		};

public:

	TWalkWindowTreeScheduleRedraws();

	TWalkWindowTreeScheduleRedraws( TUint32 aFilter );

	TBool DoIt(CWsWindow * aWin);

private:

	TUint32	iScheduleRedrawFilter;

	};

/**

This offsets all the transparent regions

*/

class TWalkWindowTreeOffsetTransparentRegions : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeOffsetTransparentRegions(const TPoint& aOffset);

	TBool DoIt(CWsWindow * aWin);

private:

	const TPoint & iOffset;	

	};

/**

This recalculates the user opaque regions

*/

class TWalkWindowTreeRecalcOpaque : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeRecalcOpaque();

	TBool DoIt(CWsWindow * aWin);

	};

// Tree walkers which schedule a set of windows to be drawn derive from this

class TWalkWindowTreeSchedule: public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeSchedule();

	CWsWindow * HeadWindow() const;

	virtual const TRegion& WindowRegion(const CWsWindow& aWin) const = 0;

	virtual const TRegion& SpriteRegion(const CWsWindow& aWin) const = 0;

protected:

	CWsWindow* iHead;

	};

class TWalkWindowListSchedule : public TWalkWindowTreeSchedule

	{

public:

	TWalkWindowListSchedule(CWsWindow* aHeadWin, TRegion& aScreenUpdateRegion);

	TBool DoIt(CWsWindow* aWin);

	const TRegion& WindowRegion(const CWsWindow& aWin) const;

	const TRegion& SpriteRegion(const CWsWindow& aWin) const;

	void WalkWindowList();

private:

	TBool DoWindow(CWsWindow& aWin);

	TBool DoSprites(CWsWindow& aWin);

private:

	TRegion& iScreenUpdateRegion;

	};

// This walker uses regions to work out the minimum set of pixels that need updating

// It requires memory allocation, and so can fail.  Check ScheduledRegionsOk before

// relying on the results.

class TWalkWindowTreeScheduleRegions: public TWalkWindowTreeSchedule

	{

public:

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

	TBool DoIt(CWsWindow *aWin);

	TBool ScheduledRegionsOk() const;

	const TRegion& WindowRegion(const CWsWindow& aWin) const;

	const TRegion& SpriteRegion(const CWsWindow& aWin) const;

private:

	TRegion& iRegion;

	const TRegion &iTopElement;

	TBool iScheduledRegionsOk;

	};

// This walker uses the screens fallback mechanism.  This does not require memory

// allocation and so should never fail, but is significantly less efficient than the

// region based walker.

class TWalkWindowTreeScheduleFallback: public TWalkWindowTreeSchedule

	{

public:

	TWalkWindowTreeScheduleFallback(CScreen::CFallbackMap * aFallbackMap);

	TBool DoIt(CWsWindow *aWin);

	const TRegion& WindowRegion(const CWsWindow& aWin) const;

	const TRegion& SpriteRegion(const CWsWindow& aWin) const;

private:

	CScreen::CFallbackMap * iFallbackMap;

	};

class TWalkWindowTreeFocusChanged : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeFocusChanged(TBool aNewFocusState);

	TBool DoIt(CWsWindow *aWin);

// Data	

private:

	TBool iNewFocusState;

	};

class TResumableWalkWindowTreeFindInvalid : public TResumableWalkWindowTreeBase

	{

public:

	TResumableWalkWindowTreeFindInvalid(CWsWindowRedraw** aResult);

	TBool DoIt(CWsWindow* aWin);

// Data

private:

	CWsWindowRedraw** iResult;

	};

class TWalkWindowTreeDisconnect : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeDisconnect(RWsTextCursor *aCursor);

	TBool DoIt(CWsWindow *aWin);

private:

	RWsTextCursor *iTextCursor;

	};

class TWalkWindowTreeIsObscured : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeIsObscured(TBool &aResult);

	TBool DoIt(CWsWindow *aWin);

// Data	

	TBool *iResult;

	};

class TWalkWindowTreeSetupVisibleRegionTracking : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeSetupVisibleRegionTracking(TBool aRegister);

	TBool DoIt(CWsWindow *aWin);

// Data	

	TBool iRegister;

	};

class TWalkWindowTreeSetNonFading : public TWalkWindowTreeBase  

	{

public:

	TWalkWindowTreeSetNonFading(TBool aNonFading);

	TBool DoIt(CWsWindow *aWin);

// Data	

	const TBool iNonFading;

	};

class TWalkWindowTreeSetFaded : public TWalkWindowTreeBase 

	{

public:

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

//from TWalkWindowTreeBase

	TBool DoIt(CWsWindow *aWin);

// Data	

	const TUint8 iBlackMap;

	const TUint8 iWhiteMap;

	const TBool iFaded;

	const CWsWindowGroup* iGroup;

	};

class TWalkWindowTreeSetSystemFaded : public TWalkWindowTreeSetFaded 

	{

public:

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

//from TWalkWindowTreeBase

	TBool DoIt(CWsWindow *aWin);

// Data	

	TBool& iStateChanged;

	};

class TWalkWindowTreePurgeEvents : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreePurgeEvents();

	TBool DoIt(CWsWindow *aWin);

	};

class TWalkWindowTreeCalcInvalidGraphics: public TWalkWindowTreeRegionBase

	{

public:

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

	void CalcInvalid(CScreen& aScreen);

	TBool CreateSubRegion();

	void DoIt2(CWsWindow */*aWin*/) {}

	TBool DoIt3(CWsWindow *aWin);

	void DestroyRegions();

private:

	TRegion& iDirty;

	const TArray<TGraphicDrawerId>& iInvalid;

	};

#if defined(_DEBUG)

class TWalkWindowTreeCheck : public TWalkWindowTreeBase

	{

public:

	TBool DoIt(CWsWindow *aWin);

	};	

#endif

class TWalkWindowTreeRedrawStoreSize : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeRedrawStoreSize();

	TBool DoIt(CWsWindow *aWin);

	TInt iTotalSize;

	};

// We can't do a proper find_if unless we are prepared to write our own

// mem_fun, but this isn't a bad start

class TWalkWindowTreeFindWithFlag : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeFindWithFlag(TUint aFlag) : iFlag(aFlag), iFound(0) { }

	TBool DoIt(CWsWindow *aWin);

	CWsWindow * Found() { return iFound; }

private:

	TUint iFlag;

	CWsWindow * iFound;

	};

class TWalkWindowTreeFindByHandle : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeFindByHandle(TUint32 aHandle) : iHandle(aHandle) { }

	TBool DoIt(CWsWindow * aWin);

	CWsWindow * Found() { return iFound; }

private:

	TUint32 iHandle;

	CWsWindow * iFound;

	};

class TWalkWindowTreeSendState : public TWalkWindowTreeBase

	{

public:

	TWalkWindowTreeSendState(MWsWindowTreeObserver& aWindowTreeObserver);

	TBool DoIt(CWsWindow *aWin);

private:

	MWsWindowTreeObserver& iWindowTreeObserver;

	};

#endif