diff -r 000000000000 -r 15bf7259bb7c uiaccelerator_plat/alf_core_toolkit_api/inc/uiacceltk/HuiCanvasVisual.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiaccelerator_plat/alf_core_toolkit_api/inc/uiacceltk/HuiCanvasVisual.h Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,422 @@ +/* +* 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 CHuiCanvasVisual. +* +*/ + + + +#ifndef __HUICANVASVISUAL_H__ +#define __HUICANVASVISUAL_H__ + + +#include +#include +#include +#include +#include +#include + + +/* Forward declarations. */ +class CHuiControl; +class THuiCanvasDrawImageParams; +class THuiCanvasTextParameters; +class CHuiCanvasGc; +class MHuiCanvasPainter; + + +/** Public initial values for ws painter */ +#define KHuiWsDefaultUserClipRect TRect(0,0,0,0) +#define KHuiWsDefaultLastPrintPosition TPoint(0,0) +#define KHuiWsDefaultPenColor KRgbBlack +#define KHuiWsDefaultPenStyle CGraphicsContext::ESolidPen +#define KHuiWsDefaultPenSize TSize(1,1) +#define KHuiWsDefaultDrawMode CGraphicsContext::EDrawModePEN +#define KHuiWsDefaultLinePosition TPoint(0,0) +#define KHuiWsDefaultOrigin TPoint(0,0) +#define KHuiWsDefaultBrushUsed EFalse +#define KHuiWsDefaultBrushColor KRgbWhite +#define KHuiWsDefaultBrushOrigin TPoint(0,0) +#define KHuiWsDefaultBrushStyle CGraphicsContext::ENullBrush +#define KHuiWsDefaultCharJustExcess 0 +#define KHuiWsDefaultCharJustNum 0 +#define KHuiWsDefaultWordJustExcess 0 +#define KHuiWsDefaultWordJustNum 0 +#define KHuiWsDefaultDitherOrigin TPoint(0,0) +#define KHuiWsDefaultDotLength 0 +#define KHuiWsDefaultDotMask 0 +#define KHuiWsDefaultDotParam 0 +#define KHuiWsDefaultDotDirection 1 +#define KHuiWsDefaultShadowMode CFbsDrawDevice::ENoShadow +#define KHuiWsDefaultStrikethrough EStrikethroughOff +#define KHuiWsDefaultUnderline EUnderlineOff +#define KHuiWsDefaultUserDisplayMode ENone +#define KHuiWsDefaultShadowColor KRgbGray +#define KHuiWsDefaultFadeColor 0x80FFFFFF + +enum THuiCanvasPaintType + { + /** Transparent or semitransparent */ + EHuiCanvasPaintTypeTransparent, + + /** Fully opaque */ + EHuiCanvasPaintTypeOpaque + }; + +NONSHARABLE_STRUCT (THuiCanvasPaintedArea) + { + /** Painted area in the canvas */ + THuiRealRect iPaintedRect; + + /** Paint type of the area */ + TInt iPaintType; + + /** Reserved for future */ + TInt iFlags; + }; + +enum THuiCanvasFlags + { + /** Disables canvas from drawing the canvas content */ + EHuiCanvasFlagDisableCanvasContent = 0x1, + /** Disables canvas from drawing the canvas background (if set) */ + EHuiCanvasFlagDisableCanvasBackground = 0x2, + /** Canvas is drawn with external fade effect */ + EHuiCanvasFlagExternalFade = 0x4, + /** Canvas drawing is clipped to own and parent canvas intersection */ + EHuiCanvasFlagEnableCanvasClipping = 0x8, + /** External fade effect (if enabled) is extended to children */ + EHuiCanvasFlagExternalFadeToChildren = 0x10, + /** External fade effect (if enabled) is set to a parent (or grandparent) */ + EHuiCanvasFlagExternalFadeByParent = 0x40, + /** Effect is excluded from parent (or grandparent) effect (if it has effect which is applied to children) */ + EHuiCanvasFlagExcludeFromParentEffect = 0x80, + /** Hint flag which is used for optimizations. Tells if fade effect(s) exist in visual tree */ + EHuiCanvasFlagExternalFadeExistsInsideVisualTree = 0x100 + }; + +/** + * This class is used internally by the toolkit and thus should + * not be used by the applications directly. + */ +class CHuiCanvasVisual : public CHuiLayout + { +public: + + enum + { + /** @deprecated */ + ECommandBufferHui, + /** @deprecated */ + ECommandBufferSgc + }; + + enum + { + ECommandBufferAlf, + ECommandBufferWs + }; + + /* Constructors and destructor. */ + + /** + * Constructs and appends a new Canvas visual to the owner control. + * + * @param aOwnerControl Control that will own the new visual. + * + * @param aCanvasType The enumerator describing the type of concrete Canvas + * to be created. + * + * @return The new visual. + */ + IMPORT_C static CHuiCanvasVisual* AddNewL(CHuiControl& aOwnerControl, + CHuiLayout* aParentLayout = 0); + + /** + * Constructor. + */ + CHuiCanvasVisual(MHuiVisualOwner& aOwner); + + /** + * Second-phase constructor. + */ + void ConstructL(); + + /** + * Destructor. + */ + ~CHuiCanvasVisual(); + + /** + * Sets buffer that contains canvas drawing commands. This + * method clears previous buffer(s). + * + * @param aCommands Commanbuffer + */ + IMPORT_C void SetCommandSetL( const TDesC8& aCommands ); + + /** + * Sets the type of commands in the buffer. + * + * @param aCommandType Type of the command buffer, either + * ECommandBufferHui or ECommandBufferSgc. In the future + * more command set types may be supported. + * + */ + IMPORT_C void SetCommandType( TInt aCommandType ); + + /** + * Clears buffer(s) that contains canvas drawing commands. + */ + IMPORT_C void ClearCommandSet(); + + IMPORT_C void SetTrackCommandSet( TFileName& aFileName, TBool aTrack ); + + /** + * Adds buffer that contains more canvas drawing commands, + * those will be executed after the buffers that has been + * added previously. + * @param aMoreCommands Commanbuffer + */ + IMPORT_C 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. + */ + IMPORT_C void AddPartialCommandSetL( const TDesC8& aMoreCommands, TBool aLastPart ); + + /** + * Clears internal cached texts and images. + */ + IMPORT_C void ClearCache(); + + /** + * Prepares internal cached texts and images. + */ + IMPORT_C void PrepareCache(); + + /** + * Sets the flag that tells the canvas to clear the background before + * doing a refresh. + * + * Note1: EClearWithSkinBackground is not (yet) supported. + * Note2: EClearWithColor does not do alphablending, it just clears the area + * and writes alpha values to the rendering surface. + * + * @param aClearBackground Background clearing mode. + * @see SetBackgroundColor() + */ + IMPORT_C void SetClearBackground(CHuiDisplay::TClearMode aClearBackground); + + /** + * Sets the background color, if background clearing has + * been enabled. + * + * @param aBackgroundColor The color to set the background to. + * @see SetClearBackgroundL() + */ + IMPORT_C void SetBackgroundColor(const TRgb& aBackgroundColor); + + /** + * Sets the items that specify how to clear display before display refresh. + * Items may have overlapping rectangles, drawing order is same as item order + * in the parameter array. But having lots of overlapping drawing + * causes negative performance impact. + * + * This method is alternative to SetClearBackgroundL and SetBackgroundColor + * methods. + * + * @see SetBackgroundColor() + * @see SetClearBackgroundL() + * @param aItems Array of items that specify how to clear the background. + */ + IMPORT_C void SetBackgroundItems(const RArray& aItems); + + /** + * Returns the number of rectangular areas which contain something that is + * drawn by the visual. + * + * @return number of painted areas. + * @see PaintedArea() + */ + IMPORT_C TInt PaintedAreaCount() const; + + /** + * Returns information of the painted area at given index. + * + * @param aIndex Index of the painted area. + * @return Painted area info. + * @see PaintedAreaCount()() + */ + IMPORT_C THuiCanvasPaintedArea PaintedArea(TInt aIndex); + + /** + * 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. + * + */ + IMPORT_C TInt SetCapturingBufferL(CFbsBitmap* aTargetBuffer); + + /** + * Sets canvas flags + * @param aCanvasFlags flags to be set + * + */ + IMPORT_C void SetCanvasFlags(TInt aCanvasFlags); + + /** + * Clears canvas flags + * @param aCanvasFlags flags to be cleared. + * + */ + IMPORT_C void ClearCanvasFlags(TInt aCanvasFlags); + + /** + * Gets canvas flags + * @return flags + * + */ + IMPORT_C TInt CanvasFlags(); + + /** + * Set external content visual to be drawn to the canvas visual. + * Giving a NULL pointer as a parameter removes the external content. + * @param aVisual the visual that is used as external content + * + */ + IMPORT_C void SetExternalContentL(CHuiVisual* aVisual); + + /** + * Return external content visual of the canvas visual. + * NULL return value means there is no external content. + * @return NULL or the visual that is used as external content + */ + IMPORT_C CHuiVisual* ExternalContent(); + + /** + * Set parent canvas visual. Parent is used for determining clipping + * region incase canvasflag EHuiCanvasFlagEnableCanvasClipping is set. + * + * @param aParent Canvas visual which is used to determine effective + * clipregion. + */ + IMPORT_C void SetParentCanvas(CHuiCanvasVisual* aParent); + + /** + * Gets reference to canvas gc + */ + CHuiCanvasGc& CanvasGc() const; + + IMPORT_C TBool IsBackgroundDrawingEnabled() const; + + const TRegion& ClipRegion() const; + + void AddChildCanvas(CHuiCanvasVisual* aChild); + + void RemoveChildCanvas(CHuiCanvasVisual* aChild); + + IMPORT_C TBool HasCommandBuffers(TBool aAskFromChildren = ETrue) const; + + // to handle background surface that may be set to the Window +public: + + IMPORT_C TBool LayerUsesAlphaFlag(); + IMPORT_C void SetLayerUsesAlphaFlag(TBool aEnabled); + IMPORT_C TRect& LayerExtent(); + IMPORT_C void SetLayerExtent(TRect& aExtent); + +public: + + void SetSize(const THuiRealSize& aSize, TInt aTransitionTime=0); + TBool ChildSize(TInt aOrdinal, TSize& aSize); + TBool ChildPos(TInt aOrdinal, TPoint& aPos); + TInt ChildRect(TInt aOrdinal, THuiRealRect& aRect); + + +private: + + void HandleBuffer(TRect& aDisplayRect, TInt aAction, CHuiGc* aGc) const; + + void SetCommandTypeL(TInt aCommandType); + + TBool IsContentDrawingLayered() const; + + TBool IsContentDrawingEnabled() const; + + TBool IsExternalContentDrawingEnabled(TBool aIncludeChildren = EFalse) const; + + TBool IsCanvasClippingEnabled() const; + + TBool EffectActive() const; + +public: // From CHuiVisual + + TBool PrepareDrawL(); + + void Draw(CHuiGc& aGc) const; + + /** + * Draw the visual. + */ + void DrawSelf(CHuiGc& aGc, const TRect& aDisplayRect) const; + + TBool Changed() const; + + IMPORT_C void SetChanged(); + + IMPORT_C void ClearChanged(); + + void ExpandRectWithContent(TRect& aRect) const; + THuiRealPoint ConvertPoint(const THuiRealPoint& aPointInUnits) const; + void ExpandRect(TRect& aRectToExpand, const TRect& aNewRect) const; + +public: + IMPORT_C void StoreRenderBufferL(); + void DrawStoredVisualRenderBuffer() const; + void DrawStoredFullScreenRenderBuffer(CHuiGc& aGc) const; + IMPORT_C void FreeRenderBuffer(); + +private: + + THuiCanvasPaintedArea CanvasPaintedArea(TInt aIndex) const; + + void DrawChildren(CHuiGc& aGc) const; + void DrawCanvasChildren(CHuiGc& aGc, TInt aIncludeCanvasFlags, TInt aExcludeCanvasFlags) const; + TBool ChildTreeChanged(TInt aExcludeCanvasFlags) const; + +private: + + struct THuiCanvasVisualData; + THuiCanvasVisualData* iCanvasVisualData; + + + }; + +#endif // __HUICANVASVISUAL_H__