diff -r 000000000000 -r bde4ae8d615e os/graphics/windowing/windowserver/nga/SERVER/openwfc/redrawmsgwindow.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/windowing/windowserver/nga/SERVER/openwfc/redrawmsgwindow.h Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,231 @@ +// 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& 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& 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 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& 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 iWsBitmapArray; + RPointerArray iWsFontArray; + RArray iDrawerArray; + RPointerArray iWsDrawableSourceArray; + TTime iCreationTime; + private: + CWsRedrawMsgWindow& iRedraw; + RArray 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 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