diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/coretoolkit/inc/huicanvaspainter.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/coretoolkit/inc/huicanvaspainter.h Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,370 @@ +/* +* Copyright (c) 2006-2007 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: Definition of CHuiCanvasPainter. +* +*/ + + + +#ifndef __HUICANVASPAINTER_H__ +#define __HUICANVASPAINTER_H__ + + +#include +#include +#include +#include +#include "huicanvastexturecache.h" + + +/* Forward declarations. */ +class CHuiControl; +class THuiCanvasDrawImageParams; +class THuiCanvasTextParameters; +class CHuiCanvasGc ; +class CHuiGc; +class CHuiCanvasCommandBuffer; + +const TInt KHuiCanvasCommandBufferRegionGranularity = 5; + +enum THuiCanvasBufferStatusFlags + { + /** Buffer is new */ + EHuiCanvasBufferStatusNew = 0x1, + /** Buffer has been scanned */ + EHuiCanvasBufferStatusScanned = 0x2, + /** Buffer has been drawn */ + EHuiCanvasBufferStatusDrawn = 0x4, + + /** Flag to say wheter buffer really contains somethign that really draws something */ + EHuiCanvasBufferContainsDrawing = 0x8000, + /** All flags, can be used for clearing all flags */ + EHuiCanvasBufferStatusAll = 0xFFFFFFFF + }; + + +NONSHARABLE_CLASS( MHuiCmdBufDestroyObserver ) + { + public: + virtual void DestroyBuffer(CHuiCanvasCommandBuffer *aBuffer)=0; + }; + +NONSHARABLE_CLASS( CHuiCanvasCommandBuffer ) : public CBase + { + public: + CHuiCanvasCommandBuffer() : + iChanged(ETrue), + iStatusFlags(EHuiCanvasBufferStatusNew) + { + iCreationTime.UniversalTime(); + } + ~CHuiCanvasCommandBuffer() + { + TInt count = iObservers.Count(); + for(int i=0;iDestroyBuffer(this); + } + iObservers.Close(); + delete iCommands; + iUpdateRegion.Close(); + iOriginalUpdateRegion.Close(); +#ifdef HUI_DEBUG_TRACK_DRAWING + delete iProcessName; +#endif + } + + void SetStatusFlags(THuiCanvasBufferStatusFlags aStatusFlags) + { + iStatusFlags |= aStatusFlags; + } + + void ClearStatusFlags(THuiCanvasBufferStatusFlags aStatusFlags) + { + iStatusFlags &= ~aStatusFlags; + } + void AddDestroyObserver(MHuiCmdBufDestroyObserver *aObserver ) + { + iObservers.AppendL(aObserver); + } + void RemoveDestroyObserver(MHuiCmdBufDestroyObserver *aObserver) + { + TInt count = iObservers.Count(); + for(int i=count-1;i>=0;i--) + { + if (iObservers[i]==aObserver) + { + iObservers.Remove(i); + } + } + } +public: + /** Buffer containing the drawing commands */ + HBufC8* iCommands; + + /** Optional region which specifies the area where commands are to be drawn */ + RRegionBuf iUpdateRegion; + + /** The original iUpdateRegion before any intersection with the shape region */ + RRegionBuf iOriginalUpdateRegion; + + /** Rect of the visual when command buffer was set/added */ + THuiRealRect iOriginalDisplayRect; + + /** The position of the visual, when the update region was last modfied */ + TPoint iPositionForUpdateRegion; + + /** Internal flag that can be used to track changes. This is similar to visual changed flag. */ + TBool iChanged; + + /** Internal flag that can be used to track buffer status. This is mainly used for optimizing drawing. */ + TInt iStatusFlags; + + /** Time when this buffer has been created */ + TTime iCreationTime; + + /** Display orientation when this buffer has been created */ + CHuiGc::TOrientation iOrientation; + + /** Flag to tell if buffer has unsupported commands (fallback mode is needed) */ + TBool iContainsUnsupportedCommands; + +#ifdef HUI_DEBUG_TRACK_DRAWING + TBool iTrackedBuffer; + + HBufC16* iProcessName; +#endif + + RPointerArray iObservers; + }; + +enum THuiCanvasBufferAction + { + /** Draw buffer content to the canvas */ + EDrawBuffer, + + /** Scan buffer content */ + EScanBuffer + }; + +/** + * This class is used internally by the toolkit and thus should + * not be used by the applications directly. + */ +NONSHARABLE_CLASS (CHuiCanvasPainter) : public CBase + { + +public: + + /** + * Sets buffer that contains canvas drawing commands. This + * method clears previous buffer(s), so this is eqvivalent + * to calling both ClearCommandSet and AddCommandSetL. + * + * @param aCommands Commanbuffer + */ + virtual void SetCommandSetL( const TDesC8& aCommands ); + + /** + * Clears buffer(s) that contains canvas drawing commands. + */ + virtual void ClearCommandSet(); + + /** + * Adds buffer that contains more canvas drawing commands, + * those will be executed after the buffers that has been + * added previously. + * @param aMoreCommands Commanbuffer + */ + virtual void AddCommandSetL( const TDesC8& aMoreCommands ); + + /** + * Adds partial buffer that contains more canvas drawing commands. These + * commands are appended to the commands set previously with this method + * until param aLastPart has value ETrue. After that whole command set + * will be added among possibly already existing command sets and + * it will be drawable. + * + * @param aMoreCommands Commanbuffer + * @param aLastPart EFalse if there are more commands to be added into this + * command set before it is wanted to be available for drawing. ETrue if + * command set is ready and no more parts are expected. + */ + virtual void AddPartialCommandSetL( const TDesC8& aMoreCommands, TBool aLastPart ); + +#ifdef HUI_DEBUG_TRACK_DRAWING + virtual void SetTrackCommandSet( TFileName& aFileName, TBool aTrack ); +#endif + /** + * Clears internal cached texts and images. + */ + virtual void ClearCache()= 0; + + /** + * Handles the command buffer(s), either draws or performs a scan. + * + * @param aDisplayRect Area in screen coordinates where painter is supposed to draw, + * method implementation should modify the given rect to contain the real (smaller) + * area where drawing happens. + * + * @param aAction Action that painter is supposed to do with the buffer. + * + * Possible values are: + * + * EScanBuffer - Painter is supposed to scan the buffer and + * 1) Prepare its internal caches (if it uses such) and other + * similar opearations which may take relatively long time to complete. + * 2) Prepare PaintedAreaCount() and PaintedArea() to contain the + * real rectangles where drawing is going to happen. + * + * EDrawBuffer - Painter is supposed to draw the content of the + * buffer to the given display rect. This action is supposed to + * be as fast as possible. + * + * @param aUser Canvas visual using this painter + * @param aGc Toolkit graphics context + * @param @aPos The current position of the visual. This is used for drawing + * the buffers on correct location, if the visual position changes + */ + virtual void HandleBufferL(TRect& aDisplayRect, TInt aAction, const CHuiCanvasVisual& aUser, CHuiGc* aGc, TPoint aPos ) = 0; + + /** Same as the other handlebuffer, except it allows external command buffers to be provided + * + */ + virtual void HandleBufferL(TRect& aDisplayRect, TInt aAction, const CHuiCanvasVisual& aUser, CHuiGc* aGc, TPoint aPos, TPtrC8 aCommands, CHuiCanvasCommandBuffer *buf) =0; + /** + * Returns the number of rectangular areas which contain something that is + * drawn by the painter. + * + * @return number of painted areas. + * @see PaintedArea() + */ + virtual TInt PaintedAreaCount() const = 0; + + /** + * Returns information of the painted area at given index. + * + * @aIndex Index of the painted area. + * @return Painted area info. + * @see PaintedAreaCount() + */ + virtual THuiCanvasPaintedArea PaintedArea(TInt aIndex) = 0; + + /** + * Draws content of the window in pixel format to the given bitmap. + * This method may not be supported in all commanbuffertype/renderer combinations. + * + * @param aTargetBuffer where content of the window is to be drawn. NULL if the drawing + * is to be stopped. + * + * @return KErrNotSupported if the current renderer/painter does not support the + * feature. Leave happens in other unexpected error situtations. + * + */ + virtual TInt SetCapturingBufferL(CFbsBitmap* /*aTarget*/) = 0; + + /** + * Tells painter to enable/disable render buffer (if it is supported by the + * painter implementation) + * + * @return KErrNotSupported if the current renderer/painter does not support the + * feature. * + */ + virtual TInt EnableRenderBuffer(TBool aEnable = ETrue) = 0; + + /** + * Destructor + */ + virtual ~CHuiCanvasPainter(); + + /** + * Returns reference to used canvas gc + */ + virtual CHuiCanvasGc& CanvasGc() const = 0; + + /** + * Sets canvas visual that this painter draws into + */ + void SetVisual(CHuiCanvasVisual* aVisual); + + /** + * Gets canvas visual that this painter is drawing into. + */ + CHuiCanvasVisual* Visual(); + + /** + * Does this painter have command buffers + */ + TBool HasCommandBuffers(); + + /** + * Is any of the buffers changed + */ + TBool BuffersChanged() const; + + /** + * Clear every buffers changed flag. + */ + void ClearAllBuffersChanged(); + + /** + * Sets every buffers changed flag to the given value. + * @param aChange flag value + */ + void SetAllBuffersChanged(TBool aChanged); + + /** + * Requests env to start refresh of whole visual tree + */ + void RequestContinueRefresh(); + + /** + * Sets given status for every buffer. + */ + void SetAllBufferStatusFlags(THuiCanvasBufferStatusFlags aStatus); + + /** + * Clears given status for every buffer. + */ + void ClearAllBufferStatusFlags(THuiCanvasBufferStatusFlags aStatus); + + /** + * Does this painter have command buffers with given statusflags. + */ + TBool HasCommandBuffers(THuiCanvasBufferStatusFlags aStatusFlags); + + /** + * Does this painter have command buffers without given statusflags. + */ + TBool HasCommandBuffersWithoutFlags(THuiCanvasBufferStatusFlags aStatusFlags); + + /** + * Does this painter have command buffers older than given time. + */ + TBool HasOldCommandBuffers(TInt aLifeTimeInMs); + + TInt NumBuffers() const { return iCommandBuffers.Count(); } + CHuiCanvasCommandBuffer *At(TInt aIndex) const { return iCommandBuffers[aIndex]; } +protected: + + /** Command buffers */ + RPointerArray iCommandBuffers; + + /** Partial command buffer which will be updated with more commands soon. This buffer is not yet ready for drawing */ + HBufC8* iPartialCommandBuffer; + + /** Canvas visual which uses this background */ + CHuiCanvasVisual* iCanvasVisual; + }; +#endif // __HUICANVASPAINTER_H__