/*
* 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 <gdi.h>
#include <bitdraw.h>
#include <e32base.h>
#include <uiacceltk/HuiOwnedPointer.h>
#include <uiacceltk/HuiLayout.h>
#include <uiacceltk/HuiDisplay.h>
/* 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<THuiDisplayBackgroundItem>& 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(TInt aCanvasDrawMode) const;
void DrawStoredFullScreenRenderBuffer(TInt aCanvasDrawMode, CHuiGc& aGc) const;
IMPORT_C void FreeRenderBuffer();
protected:
virtual void VisualExtension(const TUid& aExtensionUid, TAny** aExtensionParams);
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;
static TBool RecursiveChildTreeChanged(CHuiVisual* aVisual, TInt aExcludeCanvasFlags);
static TBool RecursiveIsExternalContentDrawingEnabled(CHuiVisual* aVisual);
static TBool RecursiveHasCommandBuffers(CHuiVisual* aVisual);
private:
struct THuiCanvasVisualData;
THuiCanvasVisualData* iCanvasVisualData;
};
#endif // __HUICANVASVISUAL_H__