CHuiCanvasVisual Class Reference

class CHuiCanvasVisual : public CHuiLayout

This class is used internally by the toolkit and thus should not be used by the applications directly.

Inherits from

Public Member Functions
CHuiCanvasVisual ( MHuiVisualOwner &)
~CHuiCanvasVisual ()
void AddChildCanvas ( CHuiCanvasVisual *)
IMPORT_C void AddCommandSetL (const TDesC8 &)
IMPORT_C CHuiCanvasVisual * AddNewL ( CHuiControl &, CHuiLayout *)
IMPORT_C void AddPartialCommandSetL (const TDesC8 &, TBool )
IMPORT_C TInt CanvasFlags ()
CHuiCanvasGc & CanvasGc ()
TBool Changed ()
TBool ChildPos ( TInt , TPoint &)
TInt ChildRect ( TInt , THuiRealRect &)
TBool ChildSize ( TInt , TSize &)
IMPORT_C void ClearCache ()
IMPORT_C void ClearCanvasFlags ( TInt )
IMPORT_C void ClearChanged ()
IMPORT_C void ClearCommandSet ()
const TRegion & ClipRegion ()
IMPORT_C TRect CommandBufferCoverage ( TInt )
void ConstructL ()
THuiRealPoint ConvertPoint (const THuiRealPoint &)
void Draw ( CHuiGc &)
void DrawSelf ( CHuiGc &, const TRect &)
void DrawStoredFullScreenRenderBuffer ( TInt , CHuiGc &)
void DrawStoredVisualRenderBuffer ( TInt )
void ExpandRect ( TRect &, const TRect &)
void ExpandRectWithContent ( TRect &)
IMPORT_C CHuiVisual * ExternalContent ()
IMPORT_C void FreeRenderBuffer ()
IMPORT_C TBool HasCommandBuffers ( TBool )
IMPORT_C TBool HasCustomShape ()
IMPORT_C TBool HasTransParentClear ()
IMPORT_C TBool IsBackgroundDrawingEnabled ()
IMPORT_C TRect & LayerExtent ()
IMPORT_C TBool LayerUsesAlphaFlag ()
IMPORT_C THuiCanvasPaintedArea PaintedArea ( TInt )
IMPORT_C TInt PaintedAreaCount ()
IMPORT_C void PrepareCache ()
TBool PrepareDrawL ()
void RemoveChildCanvas ( CHuiCanvasVisual *)
IMPORT_C void SetBackgroundColor (const TRgb &)
IMPORT_C void SetBackgroundItems (const RArray < THuiDisplayBackgroundItem > &)
IMPORT_C void SetCanvasFlags ( TInt )
IMPORT_C TInt SetCapturingBufferL ( CFbsBitmap *)
IMPORT_C void SetChanged ()
IMPORT_C void SetClearBackground (CHuiDisplay::TClearMode)
IMPORT_C void SetCommandSetL (const TDesC8 &)
IMPORT_C void SetCommandType ( TInt )
IMPORT_C void SetExternalContentL ( CHuiVisual *)
IMPORT_C void SetLayerExtent ( TRect &)
IMPORT_C void SetLayerUsesAlphaFlag ( TBool )
IMPORT_C void SetParentCanvas ( CHuiCanvasVisual *)
IMPORT_C void SetShape (const TPoint &, const TRegion &)
void SetSize (const THuiRealSize &, TInt )
IMPORT_C void SetTrackCommandSet ( TFileName &, TBool )
IMPORT_C TPoint ShapeOrigin ()
IMPORT_C const TRegion & ShapeRegion ()
IMPORT_C void StoreRenderBufferL ()
Protected Member Functions
void VisualExtension (const TUid &, TAny **)
Private Member Functions
TBool CanSkipDrawing ()
THuiCanvasPaintedArea CanvasPaintedArea ( TInt )
TBool ChildTreeChanged ( TInt )
TBool CollectPaintedRegion ( TRegion &, TInt )
TBool CollectRecursivePaintedRegion ( TRegion &, TInt )
void DrawCanvasChildren ( CHuiGc &, TInt , TInt )
void DrawChildren ( CHuiGc &)
TBool EffectActive ()
void HandleBuffer ( TRect &, TInt , CHuiGc *)
TBool IsCanvasClippingEnabled ()
TBool IsContentDrawingEnabled ()
TBool IsContentDrawingLayered ()
TBool IsExternalContentDrawingEnabled ( TBool )
TBool KeepNoCache ()
TBool RecursiveChildTreeChanged ( CHuiVisual *, TInt )
TBool RecursiveHasCommandBuffers ( CHuiVisual *)
TBool RecursiveIsExternalContentDrawingEnabled ( CHuiVisual *)
void SetCommandTypeL ( TInt )
Inherited Functions
CBase::CBase()
CBase::Delete(CBase *)
CBase::Extension_(TUint,TAny *&,TAny *)
CBase::operator new(TUint)
CBase::operator new(TUint,TAny *)
CBase::operator new(TUint,TLeave)
CBase::operator new(TUint,TLeave,TUint)
CBase::operator new(TUint,TUint)
CBase::~CBase()
CHuiLayout::AppendL(CHuiVisual *,TInt)
CHuiLayout::BaseUnit()const
CHuiLayout::BoundingRect()const
CHuiLayout::BrushOpacity()const
CHuiLayout::BrushRect()const
CHuiLayout::BrushSkin()const
CHuiLayout::CHuiLayout(MHuiVisualOwner &)
CHuiLayout::ChildOrdinal(TInt)
CHuiLayout::Count()const
CHuiLayout::DumpTree()const
CHuiLayout::EffectIsAppliedToChildren()const
CHuiLayout::EffectiveLayoutOrdinal(const CHuiVisual &)const
CHuiLayout::EnableScrollingL(TBool)
CHuiLayout::FindTag(const TDesC8 &)
CHuiLayout::FindVisual(const CHuiVisual *)const
CHuiLayout::GetClassName(TDes &)const
CHuiLayout::GetInstanceName(TDes &)const
CHuiLayout::HorizontalInnerPadding()const
CHuiLayout::InnerPadding()const
CHuiLayout::InnerPaddingInBaseUnits()const
CHuiLayout::InnerSize()const
CHuiLayout::InnerTopLeft()const
CHuiLayout::InsertL(CHuiVisual *,TInt,TInt)
CHuiLayout::MetricReferenceForLayoutInPixels(const CHuiLayout *,const THuiXYMetric &)const
CHuiLayout::MetricReferenceForLayoutInPixels(const THuiXYMetric &)const
CHuiLayout::MoveVisualToBack(CHuiVisual &,TInt)
CHuiLayout::MoveVisualToFront(CHuiVisual &,TInt)
CHuiLayout::NotifySkinChangedL()
CHuiLayout::Remove(CHuiVisual *,TInt)
CHuiLayout::RemoveAndDestroyAllD()
CHuiLayout::Reorder(CHuiVisual &,TInt,TInt)
CHuiLayout::ReportChanged()
CHuiLayout::ScrollOffset()
CHuiLayout::ScrollOffset()const
CHuiLayout::Scrolling()const
CHuiLayout::SessionId()const
CHuiLayout::SetBaseUnit(const THuiMetric &)
CHuiLayout::SetBaseUnit(const THuiXYMetric &)
CHuiLayout::SetInnerPadding(const THuiXYMetric &)
CHuiLayout::SetInnerPadding(const TPoint &)
CHuiLayout::SetPos(const THuiRealPoint &,TInt)
CHuiLayout::SetScrollOffsetInBaseUnits(const THuiRealPoint &,TInt)
CHuiLayout::SetSessionId(TInt)
CHuiLayout::SetTransitionTime(TInt)
CHuiLayout::TransitionTime()const
CHuiLayout::Type()const
CHuiLayout::UpdateChildLayout(TInt,TInt)
CHuiLayout::UpdateChildrenLayout(TInt)
CHuiLayout::VerticalInnerPadding()const
CHuiLayout::VirtualSize()const
CHuiLayout::Visual(TInt)const
CHuiLayout::~CHuiLayout()
CHuiVisual::AlignByOrigin(THuiRealPoint &,TBool)const
CHuiVisual::ApplyMirroring(THuiRealPoint &,THuiReferenceState)const
CHuiVisual::BoxMetricToPixelRect(const THuiBoxMetric &,THuiRealRect &)const
CHuiVisual::BoxMetricToPixelRect(const THuiBoxMetric &,THuiRealRect &,THuiReferenceState)const
CHuiVisual::Brushes()
CHuiVisual::Brushes()const
CHuiVisual::CHuiVisual(MHuiVisualOwner &)
CHuiVisual::CachedDisplayRect()const
CHuiVisual::ClearFlag(THuiVisualFlags)
CHuiVisual::ClearFlags(TInt)
CHuiVisual::Clipping()const
CHuiVisual::ConvertMetricLengthToPixels(TReal32 &,const THuiMetric &,TReal32)
CHuiVisual::ConvertPixelsToMetricLength(THuiMetric &,TReal32,TReal32)
CHuiVisual::Display()const
CHuiVisual::DisplayRect()const
CHuiVisual::DisplayRectTarget()const
CHuiVisual::DisplayToLocal(const THuiRealPoint &)const
CHuiVisual::DisplayToLocal(const TPoint &)const
CHuiVisual::DrawBrushes(CHuiGc &,THuiBrushLayer)const
CHuiVisual::DropShadowHandler()const
CHuiVisual::Effect()const
CHuiVisual::Effectable()const
CHuiVisual::EffectiveOpacity()const
CHuiVisual::EnableBrushesL(TBool)
CHuiVisual::EnableDropShadowL(TBool)
CHuiVisual::EnableTransformationL(TBool)
CHuiVisual::EnterLocalProjection(CHuiGc &,TBool,TReal32,const THuiRealRect *)const
CHuiVisual::Env()const
CHuiVisual::FindTacticon(TInt)const
CHuiVisual::Flags()const
CHuiVisual::Freezed()const
CHuiVisual::GetDualAlpha(TReal32,TReal32,TInt &,TInt &)
CHuiVisual::HasTactileFeedback(TInt)const
CHuiVisual::HorizontalOrigin()const
CHuiVisual::IsDelayedEffectSource()const
CHuiVisual::IsTagged()const
CHuiVisual::Layout()const
CHuiVisual::LoadingEffect()const
CHuiVisual::LocalBaseUnit()const
CHuiVisual::LocalPointInPixels(const THuiRealPoint &)const
CHuiVisual::LocalPointInPixels(const THuiRealPoint &,THuiReferenceState)const
CHuiVisual::LocalToDisplay(const THuiRealPoint &)const
CHuiVisual::LocalToDisplay(const TPoint &)const
CHuiVisual::MaxSize()const
CHuiVisual::MaxSizeInBaseUnits()const
CHuiVisual::MetricReferenceInPixels(const THuiXYMetric &)const
CHuiVisual::MetricReferenceInPixels(const THuiXYMetric &,THuiReferenceState)const
CHuiVisual::MetricToPixels(const THuiXYMetric &)const
CHuiVisual::MetricToPixels(const THuiXYMetric &,THuiReferenceState)const
CHuiVisual::Mimic(const CHuiVisual &,TInt)
CHuiVisual::MinSize()const
CHuiVisual::MinSizeInBaseUnits()const
CHuiVisual::Move(const THuiRealPoint &,TInt)
CHuiVisual::Move(const TPoint &,TInt)
CHuiVisual::MoveToFront(TInt)
CHuiVisual::Owner()const
CHuiVisual::Padding()const
CHuiVisual::PaddingInPixels()const
CHuiVisual::PaddingInPixels(THuiReferenceState)const
CHuiVisual::PixelPointInLocal(const THuiRealPoint &)const
CHuiVisual::PixelPointInLocal(const THuiRealPoint &,THuiReferenceState)const
CHuiVisual::PixelPointInUnits(const THuiRealPoint &,const THuiXYMetric &,THuiReferenceState)const
CHuiVisual::PixelsToMetric(const THuiRealPoint &,THuiXYMetric &)const
CHuiVisual::PixelsToMetric(const THuiRealPoint &,THuiXYMetric &,THuiReferenceState)const
CHuiVisual::Pos()
CHuiVisual::Pos()const
CHuiVisual::QueryCanvasFlags()
CHuiVisual::QueryExternalContentDrawingEnabled()
CHuiVisual::QueryHasDrawableContent()
CHuiVisual::RemoveTactileFeedback(TInt)
CHuiVisual::ReportLayoutUpdate()
CHuiVisual::SetCenteredPosAndSize(const THuiRealPoint &,const THuiRealSize &,TInt)
CHuiVisual::SetCenteredPosAndSize(const TPoint &,const TSize &,TInt)
CHuiVisual::SetClipping(TBool)
CHuiVisual::SetDisplay(CHuiDisplay *)
CHuiVisual::SetEffect(CHuiFxEffect *)
CHuiVisual::SetEffectParser(CHuiFxEffectParser *)
CHuiVisual::SetFlag(THuiVisualFlags)
CHuiVisual::SetFlags(TInt)
CHuiVisual::SetFreezeState(TBool)
CHuiVisual::SetLayout(CHuiLayout *)
CHuiVisual::SetLoadingEffect(TBool)
CHuiVisual::SetMaxSize(const THuiRealSize &)
CHuiVisual::SetMaxSize(const TSize &)
CHuiVisual::SetMinSize(const THuiRealSize &)
CHuiVisual::SetMinSize(const TSize &)
CHuiVisual::SetOrigin(THuiVisualHOrigin,THuiVisualVOrigin)
CHuiVisual::SetOwner(MHuiVisualOwner &)
CHuiVisual::SetPadding(TInt)
CHuiVisual::SetPadding(const THuiBoxMetric &)
CHuiVisual::SetPadding(const TPoint &)
CHuiVisual::SetRect(const THuiRealRect &,TInt)
CHuiVisual::SetStoredRenderBuffer(CHuiCanvasRenderBuffer *)
CHuiVisual::SetStoredRenderBufferModificationsEnabled(TBool)
CHuiVisual::SetTactileFeedbackL(TInt,TInt)
CHuiVisual::SetTagL(const TDesC8 &)
CHuiVisual::SetTracking(TBool)
CHuiVisual::Size()
CHuiVisual::Size()const
CHuiVisual::Skin()const
CHuiVisual::StoredRenderBuffer()const
CHuiVisual::TactileFeedback(TInt)const
CHuiVisual::Tag()const
CHuiVisual::Tracking()const
CHuiVisual::Transform(CHuiGc &,TBool,const THuiRealRect *)const
CHuiVisual::Transformation()
CHuiVisual::UpdateSiblingLayout(TInt)
CHuiVisual::VerticalOrigin()const
CHuiVisual::~CHuiVisual()
Public Member Enumerations
enum anonymous { ECommandBufferHui , ECommandBufferSgc }
enum anonymous { ECommandBufferAlf , ECommandBufferWs }
Inherited Enumerations
CHuiLayout:EHuiLayoutChildRect
CHuiLayout:TExpansionFlags
Private Attributes
THuiCanvasVisualData * iCanvasVisualData
Inherited Attributes
CHuiLayout::iHuiLayoutPrivateData
CHuiVisual::iDepthOffset
CHuiVisual::iOpacity
CHuiVisual::iOwner
CHuiVisual::iPreviousDrawn
CHuiVisual::iSessionId
CHuiVisual::iTrackVisual

Constructor & Destructor Documentation

CHuiCanvasVisual(MHuiVisualOwner &)

CHuiCanvasVisual ( MHuiVisualOwner & aOwner )

Constructor.

Parameters

MHuiVisualOwner & aOwner

~CHuiCanvasVisual()

~CHuiCanvasVisual ( )

Destructor.

Member Functions Documentation

AddChildCanvas(CHuiCanvasVisual *)

void AddChildCanvas ( CHuiCanvasVisual * aChild )

Parameters

CHuiCanvasVisual * aChild

AddCommandSetL(const TDesC8 &)

IMPORT_C void AddCommandSetL ( const TDesC8 & aMoreCommands )

Adds buffer that contains more canvas drawing commands, those will be executed after the buffers that has been added previously.

Parameters

const TDesC8 & aMoreCommands Commanbuffer

AddNewL(CHuiControl &, CHuiLayout *)

IMPORT_C CHuiCanvasVisual * AddNewL ( CHuiControl & aOwnerControl,
CHuiLayout * aParentLayout = 0
) [static]

Constructs and appends a new Canvas visual to the owner control.

Parameters

CHuiControl & aOwnerControl Control that will own the new visual.
CHuiLayout * aParentLayout = 0

AddPartialCommandSetL(const TDesC8 &, TBool)

IMPORT_C void AddPartialCommandSetL ( const TDesC8 & aMoreCommands,
TBool aLastPart
)

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.

Parameters

const TDesC8 & aMoreCommands Commanbuffer
TBool 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.

CanSkipDrawing()

TBool CanSkipDrawing ( ) const [private]

CanvasFlags()

IMPORT_C TInt CanvasFlags ( )

Gets canvas flags

CanvasGc()

CHuiCanvasGc & CanvasGc ( ) const

Gets reference to canvas gc

CanvasPaintedArea(TInt)

THuiCanvasPaintedArea CanvasPaintedArea ( TInt aIndex ) const [private]

Parameters

TInt aIndex

Changed()

TBool Changed ( ) const [virtual]

ChildPos(TInt, TPoint &)

TBool ChildPos ( TInt aOrdinal,
TPoint & aPos
) [virtual]

New virtual method. Determines the position of a child visual according to the layout. The child position is determined using the base units of the layout. Derived layout classes should refer to InnerSize() and InnerTopLeft() to determine the area suitable for placing children into.

Parameters

TInt aOrdinal Layout ordinal of the child visual.
TPoint & aPos New position for the child. This goes to CHuiVisual::SetPos() with no conversions.

ChildRect(TInt, THuiRealRect &)

TInt ChildRect ( TInt aOrdinal,
THuiRealRect & aRect
) [virtual]

New virtual method. Determines the position and size of a child visual according to the layout. The child position is determined using the base units of the layout. Derived layout classes should refer to InnerSize() and InnerTopLeft() to determine the area suitable for placing children into.

Parameters

TInt aOrdinal Layout ordinal of the child visual.
THuiRealRect & aRect New position for the child. This is used to set the child size and position with no conversions.

ChildSize(TInt, TSize &)

TBool ChildSize ( TInt aOrdinal,
TSize & aSize
) [virtual]

New virtual method. Determines the size of a child visual according to the layout. The child size is determined using the base units of the layout. Derived layout classes should refer to InnerSize() and InnerTopLeft() to determine the area suitable for placing children into.

Parameters

TInt aOrdinal Layout ordinal of the child visual.
TSize & aSize New target size for the child. This goes to CHuiVisual::SetSize() with no conversions.

ChildTreeChanged(TInt)

TBool ChildTreeChanged ( TInt aExcludeCanvasFlags ) const [private]

Parameters

TInt aExcludeCanvasFlags

ClearCache()

IMPORT_C void ClearCache ( )

Clears internal cached texts and images.

ClearCanvasFlags(TInt)

IMPORT_C void ClearCanvasFlags ( TInt aCanvasFlags )

Clears canvas flags

Parameters

TInt aCanvasFlags flags to be cleared.

ClearChanged()

IMPORT_C void ClearChanged ( ) [virtual]

ClearCommandSet()

IMPORT_C void ClearCommandSet ( )

Clears buffer(s) that contains canvas drawing commands.

ClipRegion()

const TRegion & ClipRegion ( ) const

CollectPaintedRegion(TRegion &, TInt)

TBool CollectPaintedRegion ( TRegion & aRecursivePaintRegion,
TInt aExcludeCanvasFlags
) const [private]

Parameters

TRegion & aRecursivePaintRegion
TInt aExcludeCanvasFlags

CollectRecursivePaintedRegion(TRegion &, TInt)

TBool CollectRecursivePaintedRegion ( TRegion & aRecursivePaintRegion,
TInt aExcludeCanvasFlags
) const [private]

Parameters

TRegion & aRecursivePaintRegion
TInt aExcludeCanvasFlags

CommandBufferCoverage(TInt)

IMPORT_C TRect CommandBufferCoverage ( TInt aOrientation )

Parameters

TInt aOrientation

ConstructL()

void ConstructL ( ) [virtual]

Second-phase constructor.

ConvertPoint(const THuiRealPoint &)

THuiRealPoint ConvertPoint ( const THuiRealPoint & aPointInUnits ) const

Parameters

const THuiRealPoint & aPointInUnits

Draw(CHuiGc &)

void Draw ( CHuiGc & aGc ) const [virtual]

From CHuiVisual . Draws (renders) this layout.

The default implementataion applies transformations (affects the positions of the layout), draws brushes and of course children.

Layout clipping is not affected by transformation.

TodoClipping doesn't work if there is a transformation? No need to draw children that won't be visible.

Parameters

CHuiGc & aGc

DrawCanvasChildren(CHuiGc &, TInt, TInt)

void DrawCanvasChildren ( CHuiGc & aGc,
TInt aIncludeCanvasFlags,
TInt aExcludeCanvasFlags
) const [private]

Parameters

CHuiGc & aGc
TInt aIncludeCanvasFlags
TInt aExcludeCanvasFlags

DrawChildren(CHuiGc &)

void DrawChildren ( CHuiGc & aGc ) const [private]

Parameters

CHuiGc & aGc

DrawSelf(CHuiGc &, const TRect &)

void DrawSelf ( CHuiGc & aGc,
const TRect & aDisplayRect
) const [virtual]

Draw the visual.

Parameters

CHuiGc & aGc
const TRect & aDisplayRect

DrawStoredFullScreenRenderBuffer(TInt, CHuiGc &)

void DrawStoredFullScreenRenderBuffer ( TInt aCanvasDrawMode,
CHuiGc & aGc
) const

Parameters

TInt aCanvasDrawMode
CHuiGc & aGc

DrawStoredVisualRenderBuffer(TInt)

void DrawStoredVisualRenderBuffer ( TInt aCanvasDrawMode ) const

Parameters

TInt aCanvasDrawMode

EffectActive()

TBool EffectActive ( ) const [private]

ExpandRect(TRect &, const TRect &)

void ExpandRect ( TRect & aRectToExpand,
const TRect & aNewRect
) const

Parameters

TRect & aRectToExpand
const TRect & aNewRect

ExpandRectWithContent(TRect &)

void ExpandRectWithContent ( TRect & aRect ) const [virtual]

Expands the dirty region of the visual depending on the content of the visual. This includes any brushes attached to the visual. Used during dirty region reporting.

Parameters

TRect & aRect Dirty region.

ExternalContent()

IMPORT_C CHuiVisual * ExternalContent ( )

Return external content visual of the canvas visual. NULL return value means there is no external content.

FreeRenderBuffer()

IMPORT_C void FreeRenderBuffer ( )

HandleBuffer(TRect &, TInt, CHuiGc *)

void HandleBuffer ( TRect & aDisplayRect,
TInt aAction,
CHuiGc * aGc
) const [private]

Parameters

TRect & aDisplayRect
TInt aAction
CHuiGc * aGc

HasCommandBuffers(TBool)

IMPORT_C TBool HasCommandBuffers ( TBool aAskFromChildren = ETrue ) const

Parameters

TBool aAskFromChildren = ETrue

HasCustomShape()

IMPORT_C TBool HasCustomShape ( ) const

Returns true if shape is different than display rect.

HasTransParentClear()

IMPORT_C TBool HasTransParentClear ( ) const

IsBackgroundDrawingEnabled()

IMPORT_C TBool IsBackgroundDrawingEnabled ( ) const

IsCanvasClippingEnabled()

TBool IsCanvasClippingEnabled ( ) const [private]

IsContentDrawingEnabled()

TBool IsContentDrawingEnabled ( ) const [private]

IsContentDrawingLayered()

TBool IsContentDrawingLayered ( ) const [private]

IsExternalContentDrawingEnabled(TBool)

TBool IsExternalContentDrawingEnabled ( TBool aIncludeChildren = EFalse ) const [private]

Parameters

TBool aIncludeChildren = EFalse

KeepNoCache()

TBool KeepNoCache ( ) const [private]

LayerExtent()

IMPORT_C TRect & LayerExtent ( )

LayerUsesAlphaFlag()

IMPORT_C TBool LayerUsesAlphaFlag ( )

PaintedArea(TInt)

IMPORT_C THuiCanvasPaintedArea PaintedArea ( TInt aIndex )

Returns information of the painted area at given index.

PaintedAreaCount() ()

Parameters

TInt aIndex Index of the painted area.

PaintedAreaCount()

IMPORT_C TInt PaintedAreaCount ( ) const

Returns the number of rectangular areas which contain something that is drawn by the visual.

PaintedArea()

PrepareCache()

IMPORT_C void PrepareCache ( )

Prepares internal cached texts and images.

PrepareDrawL()

TBool PrepareDrawL ( ) [virtual]

From CHuiVisual . Prepares all children of this layout for drawing. The preparation is done in drawing order.

Actually this default implementation is not leaving, since it traps the prepare errors inside and handles the errors by calling the visual owners "prepare draw failed" -callback.

MHuiVisualOwner::VisualPrepareDrawFailed()

RecursiveChildTreeChanged(CHuiVisual *, TInt)

TBool RecursiveChildTreeChanged ( CHuiVisual * aVisual,
TInt aExcludeCanvasFlags
) [private, static]

Parameters

CHuiVisual * aVisual
TInt aExcludeCanvasFlags

RecursiveHasCommandBuffers(CHuiVisual *)

TBool RecursiveHasCommandBuffers ( CHuiVisual * aVisual ) [private, static]

Parameters

CHuiVisual * aVisual

RecursiveIsExternalContentDrawingEnabled(CHuiVisual *)

TBool RecursiveIsExternalContentDrawingEnabled ( CHuiVisual * aVisual ) [private, static]

Parameters

CHuiVisual * aVisual

RemoveChildCanvas(CHuiCanvasVisual *)

void RemoveChildCanvas ( CHuiCanvasVisual * aChild )

Parameters

CHuiCanvasVisual * aChild

SetBackgroundColor(const TRgb &)

IMPORT_C void SetBackgroundColor ( const TRgb & aBackgroundColor )

Sets the background color, if background clearing has been enabled.

SetClearBackgroundL()

Parameters

const TRgb & aBackgroundColor The color to set the background to.

SetBackgroundItems(const RArray< THuiDisplayBackgroundItem > &)

IMPORT_C void SetBackgroundItems ( const RArray < THuiDisplayBackgroundItem > & aItems )

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.

SetBackgroundColor() SetClearBackgroundL()

Parameters

const RArray < THuiDisplayBackgroundItem > & aItems Array of items that specify how to clear the background.

SetCanvasFlags(TInt)

IMPORT_C void SetCanvasFlags ( TInt aCanvasFlags )

Sets canvas flags

Parameters

TInt aCanvasFlags flags to be set

SetCapturingBufferL(CFbsBitmap *)

IMPORT_C TInt SetCapturingBufferL ( CFbsBitmap * aTargetBuffer )

Draws content of the window in pixel format to the given bitmap. This method may not be supported in all commanbuffertype/renderer combinations.

Parameters

CFbsBitmap * aTargetBuffer where content of the window is to be drawn. NULL if the drawing is to be stopped.

SetChanged()

IMPORT_C void SetChanged ( ) [virtual]

Raises the change flag for this visual. Visual will be updated as soon as possible.

SetClearBackground(CHuiDisplay::TClearMode)

IMPORT_C void SetClearBackground ( CHuiDisplay::TClearMode aClearBackground )

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.

SetBackgroundColor()

Parameters

CHuiDisplay::TClearMode aClearBackground Background clearing mode.

SetCommandSetL(const TDesC8 &)

IMPORT_C void SetCommandSetL ( const TDesC8 & aCommands )

Sets buffer that contains canvas drawing commands. This method clears previous buffer(s).

Parameters

const TDesC8 & aCommands Commanbuffer

SetCommandType(TInt)

IMPORT_C void SetCommandType ( TInt aCommandType )

Sets the type of commands in the buffer.

Parameters

TInt aCommandType Type of the command buffer, either ECommandBufferHui or ECommandBufferSgc. In the future more command set types may be supported.

SetCommandTypeL(TInt)

void SetCommandTypeL ( TInt aCommandType ) [private]

Parameters

TInt aCommandType

SetExternalContentL(CHuiVisual *)

IMPORT_C void SetExternalContentL ( CHuiVisual * aVisual )

Set external content visual to be drawn to the canvas visual. Giving a NULL pointer as a parameter removes the external content.

Parameters

CHuiVisual * aVisual the visual that is used as external content

SetLayerExtent(TRect &)

IMPORT_C void SetLayerExtent ( TRect & aExtent )

Parameters

TRect & aExtent

SetLayerUsesAlphaFlag(TBool)

IMPORT_C void SetLayerUsesAlphaFlag ( TBool aEnabled )

Parameters

TBool aEnabled

SetParentCanvas(CHuiCanvasVisual *)

IMPORT_C void SetParentCanvas ( CHuiCanvasVisual * aParent )

Set parent canvas visual. Parent is used for determining clipping region incase canvasflag EHuiCanvasFlagEnableCanvasClipping is set.

Parameters

CHuiCanvasVisual * aParent Canvas visual which is used to determine effective clipregion.

SetShape(const TPoint &, const TRegion &)

IMPORT_C void SetShape ( const TPoint & aOrigin,
const TRegion & aRegion
)

Sets shape. This affects only visible area calculation.

Parameters

const TPoint & aOrigin
const TRegion & aRegion

SetSize(const THuiRealSize &, TInt)

void SetSize ( const THuiRealSize & aSize,
TInt aTransitionTime = 0
) [virtual]

From CHuiVisual . Change the size of the layout. Children's positions and sizes are updated accordingly. Each layout class is responsible for determining how to update children's layout.

Parameters

const THuiRealSize & aSize Size to set the layout to.
TInt aTransitionTime = 0

SetTrackCommandSet(TFileName &, TBool)

IMPORT_C void SetTrackCommandSet ( TFileName & aFileName,
TBool aTrack
)

Parameters

TFileName & aFileName
TBool aTrack

ShapeOrigin()

IMPORT_C TPoint ShapeOrigin ( ) const

Returns origin of window shape.

ShapeRegion()

IMPORT_C const TRegion & ShapeRegion ( ) const

Returns shape as region.

StoreRenderBufferL()

IMPORT_C void StoreRenderBufferL ( )

VisualExtension(const TUid &, TAny **)

void VisualExtension ( const TUid & aExtensionUid,
TAny ** aExtensionParams
) [protected, virtual]

! From HuiVisual

Parameters

const TUid & aExtensionUid
TAny ** aExtensionParams

Member Enumerations Documentation

Enum anonymous

Enumerators

ECommandBufferHui

ECommandBufferSgc

Enum anonymous

Enumerators

ECommandBufferAlf
ECommandBufferWs

Member Data Documentation

THuiCanvasVisualData * iCanvasVisualData

THuiCanvasVisualData * iCanvasVisualData [private]