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()
voidAddChildCanvas(CHuiCanvasVisual *)
IMPORT_C voidAddCommandSetL(const TDesC8 &)
IMPORT_C CHuiCanvasVisual *AddNewL(CHuiControl &, CHuiLayout *)
IMPORT_C voidAddPartialCommandSetL(const TDesC8 &, TBool)
IMPORT_C TIntCanvasFlags()
CHuiCanvasGc &CanvasGc()
TBool Changed()
TBool ChildPos(TInt, TPoint &)
TInt ChildRect(TInt, THuiRealRect &)
TBool ChildSize(TInt, TSize &)
IMPORT_C voidClearCache()
IMPORT_C voidClearCanvasFlags(TInt)
IMPORT_C voidClearChanged()
IMPORT_C voidClearCommandSet()
const TRegion &ClipRegion()
IMPORT_C TRectCommandBufferCoverage(TInt)
voidConstructL()
THuiRealPoint ConvertPoint(const THuiRealPoint &)
voidDraw(CHuiGc &)
voidDrawSelf(CHuiGc &, const TRect &)
voidDrawStoredFullScreenRenderBuffer(TInt, CHuiGc &)
voidDrawStoredVisualRenderBuffer(TInt)
voidExpandRect(TRect &, const TRect &)
voidExpandRectWithContent(TRect &)
IMPORT_C CHuiVisual *ExternalContent()
IMPORT_C voidFreeRenderBuffer()
IMPORT_C TBoolHasCommandBuffers(TBool)
IMPORT_C TBoolHasCustomShape()
IMPORT_C TBoolHasTransParentClear()
IMPORT_C TBoolIsBackgroundDrawingEnabled()
IMPORT_C TRect &LayerExtent()
IMPORT_C TBoolLayerUsesAlphaFlag()
IMPORT_C THuiCanvasPaintedAreaPaintedArea(TInt)
IMPORT_C TIntPaintedAreaCount()
IMPORT_C voidPrepareCache()
TBool PrepareDrawL()
voidRemoveChildCanvas(CHuiCanvasVisual *)
IMPORT_C voidSetBackgroundColor(const TRgb &)
IMPORT_C voidSetBackgroundItems(const RArray< THuiDisplayBackgroundItem > &)
IMPORT_C voidSetCanvasFlags(TInt)
IMPORT_C TIntSetCapturingBufferL(CFbsBitmap *)
IMPORT_C voidSetChanged()
IMPORT_C voidSetClearBackground(CHuiDisplay::TClearMode)
IMPORT_C voidSetCommandSetL(const TDesC8 &)
IMPORT_C voidSetCommandType(TInt)
IMPORT_C voidSetExternalContentL(CHuiVisual *)
IMPORT_C voidSetLayerExtent(TRect &)
IMPORT_C voidSetLayerUsesAlphaFlag(TBool)
IMPORT_C voidSetParentCanvas(CHuiCanvasVisual *)
IMPORT_C voidSetShape(const TPoint &, const TRegion &)
voidSetSize(const THuiRealSize &, TInt)
IMPORT_C voidSetTrackCommandSet(TFileName &, TBool)
IMPORT_C TPointShapeOrigin()
IMPORT_C const TRegion &ShapeRegion()
IMPORT_C voidStoreRenderBufferL()
Protected Member Functions
voidVisualExtension(const TUid &, TAny **)
Private Member Functions
TBool CanSkipDrawing()
THuiCanvasPaintedAreaCanvasPaintedArea(TInt)
TBool ChildTreeChanged(TInt)
TBool CollectPaintedRegion(TRegion &, TInt)
TBool CollectRecursivePaintedRegion(TRegion &, TInt)
voidDrawCanvasChildren(CHuiGc &, TInt, TInt)
voidDrawChildren(CHuiGc &)
TBool EffectActive()
voidHandleBuffer(TRect &, TInt, CHuiGc *)
TBool IsCanvasClippingEnabled()
TBool IsContentDrawingEnabled()
TBool IsContentDrawingLayered()
TBool IsExternalContentDrawingEnabled(TBool)
TBool KeepNoCache()
TBool RecursiveChildTreeChanged(CHuiVisual *, TInt)
TBool RecursiveHasCommandBuffers(CHuiVisual *)
TBool RecursiveIsExternalContentDrawingEnabled(CHuiVisual *)
voidSetCommandTypeL(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
enumanonymous { ECommandBufferHui, ECommandBufferSgc }
enumanonymous { 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 *)

voidAddChildCanvas(CHuiCanvasVisual *aChild)

Parameters

CHuiCanvasVisual * aChild

AddCommandSetL(const TDesC8 &)

IMPORT_C voidAddCommandSetL(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 & aMoreCommandsCommanbuffer

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 & aOwnerControlControl that will own the new visual.
CHuiLayout * aParentLayout = 0

AddPartialCommandSetL(const TDesC8 &, TBool)

IMPORT_C voidAddPartialCommandSetL(const TDesC8 &aMoreCommands,
TBoolaLastPart
)

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 & aMoreCommandsCommanbuffer
TBool aLastPartEFalse 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 TIntCanvasFlags()

Gets canvas flags

CanvasGc()

CHuiCanvasGc &CanvasGc()const

Gets reference to canvas gc

CanvasPaintedArea(TInt)

THuiCanvasPaintedAreaCanvasPaintedArea(TIntaIndex)const [private]

Parameters

TInt aIndex

Changed()

TBool Changed()const [virtual]

From CHuiVisual

ChildPos(TInt, TPoint &)

TBool ChildPos(TIntaOrdinal,
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 aOrdinalLayout ordinal of the child visual.
TPoint & aPosNew position for the child. This goes to CHuiVisual::SetPos() with no conversions.

ChildRect(TInt, THuiRealRect &)

TInt ChildRect(TIntaOrdinal,
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 aOrdinalLayout ordinal of the child visual.
THuiRealRect & aRectNew position for the child. This is used to set the child size and position with no conversions.

ChildSize(TInt, TSize &)

TBool ChildSize(TIntaOrdinal,
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 aOrdinalLayout ordinal of the child visual.
TSize & aSizeNew target size for the child. This goes to CHuiVisual::SetSize() with no conversions.

ChildTreeChanged(TInt)

TBool ChildTreeChanged(TIntaExcludeCanvasFlags)const [private]

Parameters

TInt aExcludeCanvasFlags

ClearCache()

IMPORT_C voidClearCache()

Clears internal cached texts and images.

ClearCanvasFlags(TInt)

IMPORT_C voidClearCanvasFlags(TIntaCanvasFlags)

Clears canvas flags

Parameters

TInt aCanvasFlagsflags to be cleared.

ClearChanged()

IMPORT_C voidClearChanged()[virtual]

From CHuiVisual

ClearCommandSet()

IMPORT_C voidClearCommandSet()

Clears buffer(s) that contains canvas drawing commands.

ClipRegion()

const TRegion &ClipRegion()const

CollectPaintedRegion(TRegion &, TInt)

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

Parameters

TRegion & aRecursivePaintRegion
TInt aExcludeCanvasFlags

CollectRecursivePaintedRegion(TRegion &, TInt)

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

Parameters

TRegion & aRecursivePaintRegion
TInt aExcludeCanvasFlags

CommandBufferCoverage(TInt)

IMPORT_C TRectCommandBufferCoverage(TIntaOrientation)

Parameters

TInt aOrientation

ConstructL()

voidConstructL()[virtual]

Second-phase constructor.

ConvertPoint(const THuiRealPoint &)

THuiRealPoint ConvertPoint(const THuiRealPoint &aPointInUnits)const

Parameters

const THuiRealPoint & aPointInUnits

Draw(CHuiGc &)

voidDraw(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)

voidDrawCanvasChildren(CHuiGc &aGc,
TIntaIncludeCanvasFlags,
TIntaExcludeCanvasFlags
)const [private]

Parameters

CHuiGc & aGc
TInt aIncludeCanvasFlags
TInt aExcludeCanvasFlags

DrawChildren(CHuiGc &)

voidDrawChildren(CHuiGc &aGc)const [private]

Parameters

CHuiGc & aGc

DrawSelf(CHuiGc &, const TRect &)

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

Draw the visual.

Parameters

CHuiGc & aGc
const TRect & aDisplayRect

DrawStoredFullScreenRenderBuffer(TInt, CHuiGc &)

voidDrawStoredFullScreenRenderBuffer(TIntaCanvasDrawMode,
CHuiGc &aGc
)const

Parameters

TInt aCanvasDrawMode
CHuiGc & aGc

DrawStoredVisualRenderBuffer(TInt)

voidDrawStoredVisualRenderBuffer(TIntaCanvasDrawMode)const

Parameters

TInt aCanvasDrawMode

EffectActive()

TBool EffectActive()const [private]

ExpandRect(TRect &, const TRect &)

voidExpandRect(TRect &aRectToExpand,
const TRect &aNewRect
)const

Parameters

TRect & aRectToExpand
const TRect & aNewRect

ExpandRectWithContent(TRect &)

voidExpandRectWithContent(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 & aRectDirty 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 voidFreeRenderBuffer()

HandleBuffer(TRect &, TInt, CHuiGc *)

voidHandleBuffer(TRect &aDisplayRect,
TIntaAction,
CHuiGc *aGc
)const [private]

Parameters

TRect & aDisplayRect
TInt aAction
CHuiGc * aGc

HasCommandBuffers(TBool)

IMPORT_C TBoolHasCommandBuffers(TBoolaAskFromChildren = ETrue)const

Parameters

TBool aAskFromChildren = ETrue

HasCustomShape()

IMPORT_C TBoolHasCustomShape()const

Returns true if shape is different than display rect.

HasTransParentClear()

IMPORT_C TBoolHasTransParentClear()const

IsBackgroundDrawingEnabled()

IMPORT_C TBoolIsBackgroundDrawingEnabled()const

IsCanvasClippingEnabled()

TBool IsCanvasClippingEnabled()const [private]

IsContentDrawingEnabled()

TBool IsContentDrawingEnabled()const [private]

IsContentDrawingLayered()

TBool IsContentDrawingLayered()const [private]

IsExternalContentDrawingEnabled(TBool)

TBool IsExternalContentDrawingEnabled(TBoolaIncludeChildren = EFalse)const [private]

Parameters

TBool aIncludeChildren = EFalse

KeepNoCache()

TBool KeepNoCache()const [private]

LayerExtent()

IMPORT_C TRect &LayerExtent()

LayerUsesAlphaFlag()

IMPORT_C TBoolLayerUsesAlphaFlag()

PaintedArea(TInt)

IMPORT_C THuiCanvasPaintedAreaPaintedArea(TIntaIndex)

Returns information of the painted area at given index.

PaintedAreaCount()()

Parameters

TInt aIndexIndex of the painted area.

PaintedAreaCount()

IMPORT_C TIntPaintedAreaCount()const

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

PaintedArea()

PrepareCache()

IMPORT_C voidPrepareCache()

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,
TIntaExcludeCanvasFlags
)[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 *)

voidRemoveChildCanvas(CHuiCanvasVisual *aChild)

Parameters

CHuiCanvasVisual * aChild

SetBackgroundColor(const TRgb &)

IMPORT_C voidSetBackgroundColor(const TRgb &aBackgroundColor)

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

SetClearBackgroundL()

Parameters

const TRgb & aBackgroundColorThe color to set the background to.

SetBackgroundItems(const RArray< THuiDisplayBackgroundItem > &)

IMPORT_C voidSetBackgroundItems(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 > & aItemsArray of items that specify how to clear the background.

SetCanvasFlags(TInt)

IMPORT_C voidSetCanvasFlags(TIntaCanvasFlags)

Sets canvas flags

Parameters

TInt aCanvasFlagsflags to be set

SetCapturingBufferL(CFbsBitmap *)

IMPORT_C TIntSetCapturingBufferL(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 * aTargetBufferwhere content of the window is to be drawn. NULL if the drawing is to be stopped.

SetChanged()

IMPORT_C voidSetChanged()[virtual]

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

SetClearBackground(CHuiDisplay::TClearMode)

IMPORT_C voidSetClearBackground(CHuiDisplay::TClearModeaClearBackground)

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 aClearBackgroundBackground clearing mode.

SetCommandSetL(const TDesC8 &)

IMPORT_C voidSetCommandSetL(const TDesC8 &aCommands)

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

Parameters

const TDesC8 & aCommandsCommanbuffer

SetCommandType(TInt)

IMPORT_C voidSetCommandType(TIntaCommandType)

Sets the type of commands in the buffer.

Parameters

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

SetCommandTypeL(TInt)

voidSetCommandTypeL(TIntaCommandType)[private]

Parameters

TInt aCommandType

SetExternalContentL(CHuiVisual *)

IMPORT_C voidSetExternalContentL(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 * aVisualthe visual that is used as external content

SetLayerExtent(TRect &)

IMPORT_C voidSetLayerExtent(TRect &aExtent)

Parameters

TRect & aExtent

SetLayerUsesAlphaFlag(TBool)

IMPORT_C voidSetLayerUsesAlphaFlag(TBoolaEnabled)

Parameters

TBool aEnabled

SetParentCanvas(CHuiCanvasVisual *)

IMPORT_C voidSetParentCanvas(CHuiCanvasVisual *aParent)

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

Parameters

CHuiCanvasVisual * aParentCanvas visual which is used to determine effective clipregion.

SetShape(const TPoint &, const TRegion &)

IMPORT_C voidSetShape(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)

voidSetSize(const THuiRealSize &aSize,
TIntaTransitionTime = 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 & aSizeSize to set the layout to.
TInt aTransitionTime = 0

SetTrackCommandSet(TFileName &, TBool)

IMPORT_C voidSetTrackCommandSet(TFileName &aFileName,
TBoolaTrack
)

Parameters

TFileName & aFileName
TBool aTrack

ShapeOrigin()

IMPORT_C TPointShapeOrigin()const

Returns origin of window shape.

ShapeRegion()

IMPORT_C const TRegion &ShapeRegion()const

Returns shape as region.

StoreRenderBufferL()

IMPORT_C voidStoreRenderBufferL()

VisualExtension(const TUid &, TAny **)

voidVisualExtension(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]