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