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

// CWsRedrawMsgWindow and associated classes definitions

// 

//

#ifndef __REDRAWMSGWINDOW_H__

#define __REDRAWMSGWINDOW_H__

#include "wnredraw.h"

#include "redrawmsgwindow.h"

class CWsFbsFont;

class CWsDrawableSource;

// This class is intended to be used in cases, where it's needed to track how many times a CFbsBitmap

// is referenced, e.g. in redraws, where already drawn bitmaps need to be re-drawn in different position.

class CFbsBitmapRef : public CFbsBitmap

    {

public:

    CFbsBitmapRef();

    ~CFbsBitmapRef();

    inline TInt RefCount() const;

    inline void IncRefCount();

    inline void DecRefCount();

private:

    TInt iRefCount;

    };

class CWsRedrawMsgWindow : public CWsWindowRedraw

	{

	class CRedrawSegment;

	enum TFlags

		{

		EBackgroundClear=0x0001,		//Clear background when starting redraw

		EBeginEndRedraw=0x0002,			//This window is currently in the middle of a redraw, that is between client calls to BeginRedraw and EndRedraw.

		EPendingScheduledDraw=0x0004,   //We have scheduled a redraw but it hasn't happened yet

		EStoringEntireWindow=0x0008,    //If store commands for the entire window or only the viewport

		ECurrentRedrawFailedStorage=0x0010,		//The current redraw failed to store a command (is reset for each redraw). Is used to make sure we only request a redraw from the client once per failing redraw

		EPreviousRedrawFailedStorage=0x0020,	//The previous redraw failed to store a command. Is used to avoid infinite loops -- if two consecutive redraws fail (i.e. current and previous) then there is no use requesting yet another redraw from the client

		};

	enum TScope

		{

		EStoreEntireWindow,             //We try to obtain draw commands for the entire window

		EStoreViewport                  //We only try to obtain commands for the on screen viewport

		};

public:

	enum TRedrawSegmentType

		{

		ESegmentTypePendingRedraw,      // A redraw segment still being received

		ESegmentTypeRedraw              // A segment received between a begin and end redraw

		};

public:

	static void StaticInitL();

	CWsRedrawMsgWindow(CWsWindow *aWin);

	~CWsRedrawMsgWindow();

	void AddFbsBitmapsL(TInt aHandle, TInt aMaskHandle);

	void AddFbsBitmapRefL(TInt aHandle);

	void AddWsBitmapsL(TInt aHandle, TInt aMaskHandle);

	void AddWsFontL(TInt aHandle);

	void AddWsDrawableSourceL(TInt aHandle);

	void SetScope(TScope aStore);

	void CleanupBitmapRefArray(const RArray<TInt>& aHandleArray);

public:	//from CWsWindowRedraw		

	void ConstructL();

	TBool CommandL(TInt aOpcode, TWsWinCmdUnion &aCmd);

	void ClipInvalidRegion(const TRect &aRect);

	TBool NeedsRedraw() const;

	TBool GetRedrawRect(TRect &aRect) const;

	const TRegion& BaseDrawRegion() const;

	const TRegion& InvalidArea() const;

	void ClearRedrawStore(TBool aClearPendingRedraw=EFalse);

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

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

	void GcDeactivate(CWsGc* aGc);

	void ClientExposing();

	void DrawWindow();

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

	void Moved();

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

	TBool ReleaseMemory(MWsMemoryRelease::TMemoryReleaseLevel aLevel);

	void VisibleRegionChange();

	TBool ReadyToDraw() const;

	TInt SizeInBytes() const;

	TBool RedrawingInProgress() const;

	void WindowClosing();

	TBool IsRedrawStoreEmpty() const;

	TBool IsBackgroundClearEnabled() const;

	CFbsBitmap* BitmapFromHandle(TInt aHandle) const;

private: //from CWsWindowRedraw	

	void Invalidate(const TRect * aRect = 0);

	TRgb BackColor() const;

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

private:

	void RemoveFromRedrawQueueIfEmpty();

	const TRegion * ReadRegion(const TInt aRegionNum);

	void BeginRedraw(const TRect* aRect);

	void DoBeginRedrawL(const TRect* aRect);

	void SubtractRectFromSegmentArray(const TRect& aRect);

	void EndRedraw();

	void ValidateRect(const TRect *aRect);

	void StoreDrawCommandL(CWsGc* aGc,const TAny *aCmdData);

	void AppendCommandL(const TAny* aCmdData, const TUint16 aOpcodeFlags = 0);

	void StoreAllGcAttributesL(CWsGc* aGc);

	void DrawCommandsL();

	void DiscardStoredCommands();

	TBool DiscardSegmentsOutsideViewport();

	inline TBool NoBuffer() const;

	void DiscardStoredCommandsIfError(TInt aError);

	inline TBool IsFbsBitmapOperation(TInt aOpCode) const;

	inline TBool IsWsBitmapOperation(TInt aOpCode) const;

	inline TBool IsRemoteReadRequired(TInt aOpCode) const;

	inline TBool IsWsFontOperation(TInt aOpCode) const;

	inline TBool IsDrawWsGraphicOperation(TInt aOpCode) const;

	inline TBool IsWsDrawableSourceOperation(TInt aOpCode) const;

	void ReplaceAndAppendCommandL(TInt aOpcode,const TAny* aCmdData);

	// CRedrawSegment related methods

	inline TInt CurrentCommandBufferWritePos() const;

	inline CBufSeg* CurrentDrawCommandBuffer() const;

	void ExpandCommandBufferL(TInt aLength);

	void CommandBufferWrite(const TDesC8& aDes, TInt aLength);

	void CommandBufferWrite(const TAny* aPtr,TInt aLength);

	void CreateNewSegmentL(const TRect& aRect, TRedrawSegmentType aRegionType);

	inline TBool InRedraw() const;

	void PromotePendingSegment();

	void Lock();

	void Unlock();

	void ReleaseRedrawSegments();

private:

	static TBool iAtomic;

	RPointerArray<CFbsBitmapRef> iFbsBitmapRefArray;

private:

	class CRedrawSegment : public CBase

		{

	public:

		static CRedrawSegment* NewLC(const TRect& aRect, TRedrawSegmentType aNewRegionType, CWsRedrawMsgWindow& aRedraw);

		~CRedrawSegment();

		void AddWsBitmapL(DWsBitmap* bitmap);

		void AddWsDrawableSourceL(CWsDrawableSource* aDrawableSource);

		void AddDrawerL(TGraphicDrawerId aDrawerId);

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

		TInt SizeInBytes() const;

		TBool AppendNonDuplicateBitmapHandleL(TInt aHandle);

	private:

		CRedrawSegment(CWsRedrawMsgWindow& aRedraw);

		void ConstructL(const TRect& aRect, TRedrawSegmentType aNewRegionType);

		void ReleaseFontsBitmapsDrawableSources();

	public:

		TRedrawSegmentType iRedrawSegmentType;

		CBufSeg* iDrawCommands;

		TInt iCurrentCommandBufferWritePos;

		RWsRegion iRegion;

		RPointerArray<DWsBitmap> iWsBitmapArray;

		RPointerArray<CWsFbsFont> iWsFontArray;

		RArray<TGraphicDrawerId> iDrawerArray;

		RPointerArray<CWsDrawableSource> iWsDrawableSourceArray;

		TTime iCreationTime;

	private:

	    CWsRedrawMsgWindow& iRedraw;

	    RArray<TInt> iBitmapHandleArray;

		};

	RWsRegion iInvalid; // Region we haven't been sent a begin redraw for.

	TRect iRedrawRect;

	TRgb iBackColor;

	TInt iFlags;

	// Regions currently in use for drawing this window:

	RPointerArray<CRedrawSegment> iRedrawSegments;

	// The segment we are currently storing to.  This is allowed to be null!

	CRedrawSegment * iCurrentSegment;

	// The last GC we drew with so we can detect changes

	CWsGc* iLastDrawGc;

	// During a scheduled draw, this is the area being drawn to (see comments on ReadRegion)

	RWsRegion iLocalRedrawRegion;

	TInt iMemoryLock;

	TBool iOSBStatus;

	};

inline TBool CWsRedrawMsgWindow::IsRemoteReadRequired(TInt aOpCode) const

	{

	return (aOpCode==EWsGcOpDrawTextPtr || aOpCode==EWsGcOpDrawTextVerticalPtr || 

		aOpCode==EWsGcOpDrawBoxTextPtr || aOpCode==EWsGcOpDrawBoxTextVerticalPtr);

	}

inline TInt CWsRedrawMsgWindow::CurrentCommandBufferWritePos() const

	{

	WS_ASSERT_DEBUG(iCurrentSegment, EWsPanicDrawCommandsInvalidState);

	return iCurrentSegment->iCurrentCommandBufferWritePos;

	}

inline CBufSeg* CWsRedrawMsgWindow::CurrentDrawCommandBuffer() const

	{

	WS_ASSERT_DEBUG(iCurrentSegment, EWsPanicDrawCommandsInvalidState);

	return iCurrentSegment->iDrawCommands;

	}

inline TBool CWsRedrawMsgWindow::InRedraw() const

	{

	return iFlags&EBeginEndRedraw;

	}

inline TInt CFbsBitmapRef::RefCount() const

    {

    return iRefCount;

    }

inline void CFbsBitmapRef::IncRefCount()

    {

    ++iRefCount;

    }

inline void CFbsBitmapRef::DecRefCount()

    {

    WS_ASSERT_DEBUG(iRefCount>0,EWsPanicCounterValue);

    --iRefCount;

    }

#endif