Symbian
Symbian Developer Library

SYMBIAN OS V9.4

Feedback

[Index] [Previous] [Next]

#include <W32STD.H>

Class CWindowGc

class CWindowGc : public CBitmapContext, public MWsClientClass;

Description

Window graphics context.

Most window graphics context drawing functions map to equivalent CFbsBitGc functions. They are implemented on the screen with any co-ordinates being relative to the top left corner of the window. However extra clipping is applied. The drawing will always be clipped to the visible part of the window. In addition it will be clipped to the non-invalid part if you are not doing a redraw and to the region being validated if you are doing a redraw.

Note:

In general, server side functions which encounter conditions which would normally cause a leave, do not leave but instead return an error value indicating the leave condition. In this way the leave can be handled on the appropriate side of the client/server boundary. For example, a client can choose to wrap server calls with User::LeaveIfError(TInt), which causes a leave with the specified error.

The above advice is true of many functions in this class, and in its derived classes.

Derivation

Members

Defined in CWindowGc:

Inherited from CBase:

Inherited from CGraphicsContext:

Inherited from MWsClientClass:

See also:

Construction and destruction

CWindowGc(CWsScreenDevice *)

IMPORT_C CWindowGc(CWsScreenDevice *aDevice);

Description

Constructor which creates, but does not initialise a graphics context.

Parameters

CWsScreenDevice *aDevice

Any screen device owned by the same session. Its life time should be at least as long as the gc itself.

See also:

~CWindowGc()

IMPORT_C virtual ~CWindowGc();

Description

Destructor.

[Top]

Member functions

Construct()

IMPORT_C virtual TInt Construct();

Description

Completes construction.

This function always causes a flush of the window server buffer.

Return value

TInt

KErrNone if successful, otherwise a leave error.

Activate(RDrawableWindow &)

IMPORT_C virtual void Activate(RDrawableWindow &aDevice);

Description

Activates the context for a given window and updates iDevice with the pointer to the screen device of the screen on which aDevice is found.

When drawing is complete, the code using the context should call CWindowGc::Deactivate(). Draw methods invoked after an CWindowGc::Activate(RDrawableWindow &) will affect the window specified. A graphics context can only be active for one window at a time. A panic occurs if a draw function is called before calling this function, or if CWindowGc::Activate(RDrawableWindow &) is called twice without an intervening CWindowGc::Deactivate().

Parameters

RDrawableWindow &aDevice

Deactivate()

IMPORT_C virtual void Deactivate();

Description

Frees the graphics context to be used with another window.

This method should be called when the application has completed drawing to the window.

Device()const

IMPORT_C virtual CGraphicsDevice* Device() const;

Description

Returns a pointer to the device, more specifically a CWsScreenDevice, for the screen that the WindowGc was last activated on. If the WindowGc has not been activated at all, it then returns the device that was passed to its constructor. if SYMBIAN_WSERV_AND_CONE_MULTIPLE_SCREENS) is defined: The user should be careful when calling this function since it can return the screen device of any screen in the system. Hence, the return value of this function will be useful only if the user is aware of how the WindowGc has was used before this function is called.

Return value

CGraphicsDevice *

A pointer to the device for the screen that the WindowGc was last activated on or the device passed at construction

SetOrigin(const TPoint &)

IMPORT_C virtual void SetOrigin(const TPoint &aPoint=TPoint(0, 0));

Description

Sets the position of the co-ordinate origin.

All subsequent drawing operations are then done relative to this origin. The default origin is (0,0), the top left corner of the window.

Parameters

const TPoint &aPoint

A point for the origin, default (0,0).

See also:

SetDrawMode(TDrawMode)

IMPORT_C virtual void SetDrawMode(TDrawMode aDrawingMode);

Description

Sets the drawing mode.

This affects the colour that is actually drawn, because it defines the way that the current screen colour logically combines with the current pen colour and brush colour.

There are 13 drawing modes (see CGraphicsContext::TDrawMode enum), each giving different logical combinations of pen, brush and screen colours. Each mode is produced by ORing together different combinations of seven drawing mode components (see CGraphicsContext::TDrawModeComponents enum).

The three most important modes are TDrawMode::EDrawModePEN, TDrawMode::EDrawModeNOTSCREEN and TDrawMode::EDrawModeXOR. The default drawing mode is TDrawMode::EDrawModePEN.

The drawing mode is over-ridden for line and shape drawing functions when a wide pen line has been selected. It is forced to TDrawMode::EDrawModePEN. This is to prevent undesired effects at line joins (vertexes).

Notes:

TDrawMode::EDrawModeAND gives a "colour filter" effect. For example:

ANDing with white gives the original colour

ANDing with black gives black

TDrawMode::EDrawModeOR gives a "colour boost" effect. For example:

ORing with black gives the original colour

ORing with white gives white

TDrawMode::EDrawModeXOR gives an "Exclusive OR" effect. For example:

white XOR black gives white

white XOR white gives black

black XOR black gives black

Parameters

CGraphicsContext::TDrawMode aDrawingMode

A drawing mode.

See also:

SetClippingRect(const TRect &)

IMPORT_C virtual void SetClippingRect(const TRect &aRect);

Description

Sets a clipping rectangle.

Graphics drawn to the window are clipped, so that only items which fall within the rectangle are displayed.

Note that clipping is additive. If a clipping region has been set using CWindowGc::SetClippingRegion(const TRegion &) then clipping will be to the intersection of that region and this rectangle.

Parameters

const TRect &aRect

The clipping rectangle.

See also:

CancelClippingRect()

IMPORT_C virtual void CancelClippingRect();

Description

Cancels the clipping rectangle.

See also:

Reset()

IMPORT_C virtual void Reset();

Description

Resets the graphics context to its default settings.

The drawing mode is set to TDrawMode::EDrawModePen (pen and brush colours used as they are); there is no clipping rectangle; the pen settings are black, solid, single pixel size; the brush style is null; no text font is selected.

See also:

UseFont(const CFont *)

IMPORT_C virtual void UseFont(const CFont *aFont);

Description

Sets this context's font.

The font is used for text drawing. If the font is already in the font and bitmap server's memory the GDI will share that copy.

Note that this function must be called prior to drawing text or the calling thread will panic.

Parameters

const CFont *aFont

A device font.

See also:

DiscardFont()

IMPORT_C virtual void DiscardFont();

Description

Discards a font.

This frees up the memory used (if the font is not being shared with some other process).

Note that if no font is in use when this function is called, then there is no effect.

See also:

SetUnderlineStyle(TFontUnderline)

IMPORT_C virtual void SetUnderlineStyle(TFontUnderline aUnderlineStyle);

Description

Sets the underline style for all subsequently drawn text.

Parameters

TFontUnderline aUnderlineStyle

The underline style: either on or off.

See also:

SetStrikethroughStyle(TFontStrikethrough)

IMPORT_C virtual void SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle);

Description

Sets the strikethrough style for all subsequently drawn text.

Parameters

TFontStrikethrough aStrikethroughStyle

The strikethrough style: either on or off.

See also:

SetWordJustification(TInt,TInt)

IMPORT_C virtual void SetWordJustification(TInt aExcessWidth, TInt aNumGaps);

Description

Sets word justification.

This function is particularly useful for doing WYSIWYG underlining or strikethrough, as it ensures that the lines extend correctly into the gaps between words. It is not intended for regular use by developers.

Parameters

TInt aExcessWidth

The excess width (in pixels) to be distributed between the specified number of gaps (starting immediately)

TInt aNumGaps

The number of gaps between words

See also:

SetCharJustification(TInt,TInt)

IMPORT_C virtual void SetCharJustification(TInt aExcessWidth, TInt aNumChars);

Description

Sets the character justification.

This function is used primarily to get accurate WYSIWYG, and is not intended for regular use by developers.

The text line that is to be justified has a certain number of characters (this includes the spaces between the words). It also has a distance (in pixels) between the end of the last word and the actual end of the line (right hand margin, usually). These excess width pixels are distributed amongst all the characters, increasing the gaps between them, to achieve full justification of the text line.

This function is particularly useful for WYSIWYG underlining or strikethrough, as it ensures that the lines extend into the gaps between characters.

See CGraphicsContext::SetCharJustification(TInt,TInt) for more information.

Parameters

TInt aExcessWidth

The excess width (in pixels) to be distributed between the specified number of characters.

TInt aNumChars

The number of characters involved

See also:

SetPenColor(const TRgb &)

IMPORT_C virtual void SetPenColor(const TRgb &aColor);

Description

Sets the pen colour.

The effective pen colour depends on the drawing mode (see CWindowGc::SetDrawMode(TDrawMode)).

The default pen colour is black.

Parameters

const TRgb &aColor

The RGB colour for the pen.

See also:

SetPenStyle(TPenStyle)

IMPORT_C virtual void SetPenStyle(TPenStyle aPenStyle);

Description

Sets the line drawing style for the pen.

The pen is used when drawing lines and for the outline of filled shapes. There are 6 pen styles (see CGraphicsContext::TPenStyle enum). If no pen style is set, the default is TPenStyle::ESolidPen.

To use a pen style, its full context must be given, e.g. for a null pen: CGraphicsContext::TPenStyle::ENullPen.

Parameters

CGraphicsContext::TPenStyle aPenStyle

A pen style.

See also:

SetPenSize(const TSize &)

IMPORT_C virtual void SetPenSize(const TSize &aSize);

Description

Sets the line drawing size for the pen.

Lines of size greater than one pixel are drawn with rounded ends that extend beyond the end points, (as if the line is drawn using a circular pen tip of the specified size). Rounded ends of lines drawn with a wide pen are always drawn in TDrawMode::EDrawModePEN mode, overriding whatever mode has been set using CWindowGc::SetDrawMode(TDrawMode).

Parameters

const TSize &aSize

A line size, the default being 1 pixel.

See also:

SetBrushColor(const TRgb &)

IMPORT_C virtual void SetBrushColor(const TRgb &aColor);

Description

Sets the brush colour.

The effective brush colour depends on the drawing mode (see CWindowGc::SetDrawMode(TDrawMode)). If no brush colour has been set, it defaults to white. However the default brush style is null, so when drawing to a window, the default appears to be the window's background colour.

Parameters

const TRgb &aColor

The RGB colour for the brush.

See also:

SetBrushStyle(TBrushStyle)

IMPORT_C virtual void SetBrushStyle(TBrushStyle aBrushStyle);

Description

Sets the line drawing style for the brush.

The GDI provides ten brush styles, including six built-in hatching patterns (see CGraphicsContext::TBrushStyle).

Use TBrushStyle::ENullBrush to draw the outline of a fillable shape on its own, without filling.

If the TBrushStyle::EPatternedBrush style is set, but no bitmap pattern has been selected using CWindowGc::UseBrushPattern(const CFbsBitmap *), then the brush defaults to TBrushStyle::ENullBrush.

Hatching lines are done in the current brush colour, set using CWindowGc::SetBrushColor(const TRgb &). Hatching can be overlaid on other graphics. The hatching pattern starts at the brush origin, set using CWindowGc::SetBrushOrigin(const TPoint &).

Parameters

CGraphicsContext::TBrushStyle aBrushStyle

The brush style.

See also:

SetBrushOrigin(const TPoint &)

IMPORT_C virtual void SetBrushOrigin(const TPoint &aOrigin);

Description

Sets the brush pattern origin.

This specifies the position of the pixel in the top left corner of a reference pattern tile, (in absolute device co-ordinates). Other copies of the pattern tile are then drawn around the reference one. Thus the brush origin can be set as the top left corner of a shape.

The brush pattern may be a built-in style (see CWindowGc::SetBrushStyle(TBrushStyle)), or a bitmap. To use a bitmap, the brush must have a pattern set (see CWindowGc::UseBrushPattern(const CFbsBitmap *)) and the brush style must be set to TBrushStyle::EPatternedBrush.

Notes:

If CWindowGc::SetBrushOrigin(const TPoint &) is not used, then the origin defaults to (0,0).

This brush origin remains in effect for all fillable shapes drawn subsequently, until a new brush origin is set. Shapes can thus be considered as windows onto a continuous pattern field (covering the whole clipping region of a screen device, or the whole device area of a printer).

Parameters

const TPoint &aOrigin

The origin point for the brush.

See also:

UseBrushPattern(const CFbsBitmap *)

IMPORT_C virtual void UseBrushPattern(const CFbsBitmap *aDevice);

Description

Sets the brush pattern to the specified bitmap.

For the brush to actually use the bitmap, TBrushStyle::EPatternedBrush must be used to set the brush style (see CWindowGc::SetBrushStyle(TBrushStyle)). When the brush pattern is no longer required, use CWindowGc::DiscardBrushPattern() to free up the memory used, (if the bitmap is not being shared). If CWindowGc::UseBrushPattern(const CFbsBitmap *) is used again without using CWindowGc::DiscardBrushPattern() then the previous pattern is discarded automatically.

Notes:

When loading a bitmap, the GDI checks to see if the bitmap is already in memory. If the bitmap is already there, then that copy is shared.

The brush does not need to have a pattern set at all. There are several built-in hatching patterns, which can be selected using CWindowGc::SetBrushStyle(TBrushStyle).

Parameters

const CFbsBitmap *aDevice

A bitmap pattern for the brush

See also:

DiscardBrushPattern()

IMPORT_C virtual void DiscardBrushPattern();

Description

Discards a non-built-in brush pattern.

This frees up the memory used for the bitmap, if it is not being shared by another process.

If no brush pattern has been set when this function is called, it has no effect.

See also:

MoveTo(const TPoint &)

IMPORT_C virtual void MoveTo(const TPoint &aPoint);

Description

Moves the internal drawing position relative to the co-ordinate origin, without drawing a line.

A subsequent call to CWindowGc::DrawLineTo(const TPoint &) or CWindowGc::DrawLineBy(const TPoint &) will then use the new internal drawing position as the start point for the line drawn.

Notes:

The operations CWindowGc::DrawLine(const TPoint &,const TPoint &), CWindowGc::DrawLineTo(const TPoint &), CWindowGc::DrawLineBy(const TPoint &) and DrawPolyline() also change the internal drawing position to the last point of the drawn line(s).

The internal drawing position is set to the co-ordinate origin if no drawing or moving operations have yet taken place.

Parameters

const TPoint &aPoint

The point to move the internal drawing position to.

See also:

MoveBy(const TPoint &)

IMPORT_C virtual void MoveBy(const TPoint &aPoint);

Description

Moves the internal drawing position by a vector, without drawing a line.

The internal drawing position is moved relative to its current co-ordinates.

Parameters

const TPoint &aPoint

The vector to move the internal drawing position by.

See also:

Plot(const TPoint &)

IMPORT_C virtual void Plot(const TPoint &aPoint);

Description

Draws a single point.

The point is drawn with the current pen settings using the current drawing mode.

Note: if the pen size is greater than one pixel, a filled circle of the current pen colour is drawn, with the pen size as the diameter and the plotted point as the centre. If the pen size is an even number of pixels, the extra pixels are drawn below and to the right of the centre. See CWindowGc::SetPenSize(const TSize &).

Parameters

const TPoint &aPoint

The point to be drawn.

See also:

DrawArc(const TRect &,const TPoint &,const TPoint &)

IMPORT_C virtual void DrawArc(const TRect &aRect, const TPoint &aStart, const TPoint &aEnd);

Description

Draws an arc (a portion of an ellipse).

The point aStart is used to define one end of a line from the geometric centre of the ellipse. The point of intersection between this line and the ellipse defines the start point of the arc. The point aEnd is used to define one end of a second line from the geometric centre of the ellipse. The point of intersection between this line and the ellipse defines the end point of the arc. The pixels at both the start point and the end point are drawn.

The arc itself is the segment of the ellipse in an anti-clockwise direction from the start point to the end point.

Notes

A rectangle is used in the construction of the ellipse of which the arc is a segment. This rectangle is passed as an argument of type TRect.

A wide line arc is drawn with the pixels distributed either side of a true ellipse, in such a way that the outer edge of the line would touch the edge of the construction rectangle. In other words, the ellipse used to construct it is slightly smaller than that for a single pixel line size.

If aStart or aEnd are the ellipse centre then the line that defines the start/end of the arc defaults to one extending vertically above the centre point.

If aStart and aEnd are the same point, or points on the same line through the ellipse centre then a complete unfilled ellipse is drawn.

Line drawing is subject to pen colour, width and style and draw mode

Parameters

const TRect &aRect

The rectangle in which to draw the ellipse (of which the arc is a segment).

const TPoint &aStart

A point to define the start of the arc.

const TPoint &aEnd

A point to define the end of the arc.

See also:

DrawLine(const TPoint &,const TPoint &)

IMPORT_C virtual void DrawLine(const TPoint &aPoint1, const TPoint &aPoint2);

Description

Draws a straight line between two points.

Parameters

const TPoint &aPoint1

The point at the start of the line.

const TPoint &aPoint2

The point at the end of the line.

See also:

DrawLineTo(const TPoint &)

IMPORT_C virtual void DrawLineTo(const TPoint &aPoint);

Description

Draws a straight line from the current internal drawing position to a point.

Parameters

const TPoint &aPoint

The point at the end of the line.

See also:

DrawLineBy(const TPoint &)

IMPORT_C virtual void DrawLineBy(const TPoint &aPoint);

Description

Draws a straight line relative to the current internal drawing position, using a vector.

The start point of the line is the current internal drawing position. The vector aVector is added to the internal drawing position to give the end point of the line

Parameters

const TPoint &aPoint

The vector to add to the current internal drawing position, giving the end point of the line.

See also:

DrawPolyLine(const CArrayFix< TPoint > *)

IMPORT_C virtual void DrawPolyLine(const CArrayFix< TPoint > *aPointList);

Description

Draws a polyline using points in an array.

A polyline is a series of concatenated straight lines joining a set of points.

Parameters

const CArrayFix< TPoint > *aPointList

An array containing the points on the polyline.

See also:

DrawPolyLine(const TPoint *,TInt)

IMPORT_C virtual void DrawPolyLine(const TPoint *aPointList, TInt aNumPoints);

Description

Draws a polyline using points in a list.

A polyline is a series of concatenated straight lines joining a set of points.

Parameters

const TPoint *aPointList

Pointer to a list of points on the polyline.

TInt aNumPoints

The number of points in the point list.

See also:

DrawPie(const TRect &,const TPoint &,const TPoint &)

IMPORT_C virtual void DrawPie(const TRect &aRect, const TPoint &aStart, const TPoint &aEnd);

Description

Draws and fills a pie-shaped slice of an ellipse.

Outlines are subject to the current pen colour, width, style and draw mode. Set the pen to ENullPen for no outline. The fill is subject to brush style (colour, hash or pattern), the origin and the current drawing mode. Set the brush to ENullBrush for no fill.

The point aStart is used to define one end of a line to the centre of the ellipse. The point of intersection between this line and the ellipse defines the start point of the arc bounding the pie slice. The point aEnd is used to define one end of a second line to the centre of the ellipse. The point of intersection between this line and the ellipse defines the end point of the arc bounding the pie slice. The pixels at the end point are not drawn.

The pie slice itself is the area bounded by: the arc of the ellipse in an anticlockwise direction from the start point to the end point; the straight line from the start point from the geometric centre of the ellipse; the straight line from the end point from the geometric centre of the ellipse.

The line drawn by the pen goes inside the rectangle given by the aRect argument.

Notes:

A rectangle is used in the construction of the pie slice. This rectangle is passed as an argument of type TRect. The curved edge of the pie slice is an arc of an ellipse constructed within the rectangle.

A wide line edged pie slice has the arc drawn with the pixels distributed either side of a true ellipse. This is done in such a way that the outer edge of the line would touch the edge of the construction rectangle. In other words, the ellipse used to construct it is slightly smaller than that for a single pixel line size.

If aStart or aEnd are the ellipse centre then the line that defines the start/end of the arc defaults to one extending vertically above the centre point.

If aStart and aEnd are the same point, or points on the same line through the ellipse centre then a complete filled ellipse is drawn. A line is also drawn from the edge to the ellipse centre.

Parameters

const TRect &aRect

A rectangle in which to draw the ellipse bounding the pie slice

const TPoint &aStart

A point to define the start of the pie slice

const TPoint &aEnd

A point to define the end of the pie slice

See also:

DrawEllipse(const TRect &)

IMPORT_C virtual void DrawEllipse(const TRect &aRect);

Description

Draws and fills an ellipse.

The ellipse is drawn inside the rectangle defined by the aRect argument. Any TRect that has odd pixel dimensions, has the bottom right corner trimmed to give even pixel dimensions before the ellipse is constructed.

The column and row of pixels containing the bottom right co-ordinate of the aRect argument are not part of the rectangle.

Note: a wide outline ellipse is drawn with the pixels distributed either side of a true ellipse, in such a way that the outer edge of the line touches the edge of the construction rectangle. In other words, the ellipse used to construct it is smaller than that for a single pixel line size.

Parameters

const TRect &aRect

The rectangle in which to draw the ellipse

See also:

DrawRect(const TRect &)

IMPORT_C virtual void DrawRect(const TRect &aRect);

Description

Draws and fills a rectangle.

The rectangle's border is drawn with the pen, and it is filled using the brush.

Parameters

const TRect &aRect

The rectangle to be drawn.

See also:

DrawRoundRect(const TRect &,const TSize &)

IMPORT_C virtual void DrawRoundRect(const TRect &aRect, const TSize &aEllipse);

Description

Draws and fills a rectangle with rounded corners.

The rounded corners are each constructed as an arc of an ellipse. The dimensions of each corner (corner size and corner height) are given by aEllipse. See CWindowGc::DrawArc(const TRect &,const TPoint &,const TPoint &) for a description of arc construction.

The line drawn by the pen (if any) goes inside the rectangle given by the TRect argument.

Notes:

Dotted and dashed pen styles cannot be used for the outline of a rounded rectangle.

If either corner size dimension is greater than half the corresponding rectangle length, the corner size dimension is reduced to half the rectangle size.

Parameters

const TRect &aRect

The rectangle to be drawn.

const TSize &aEllipse

The dimensions of each corner.

See also:

DrawPolygon(const CArrayFix< TPoint > *,TFillRule)

IMPORT_C virtual TInt DrawPolygon(const CArrayFix< TPoint > *aPointList, TFillRule aFillRule=EAlternate);

Description

Draws and fills a polygon using points defined in an array.

The first TPoint in the array defines the start of the first side of the polygon. The second TPoint defines the second vertex (the end point of the first side and the start point of the second side) and so on. The final side of the polygon is drawn using the last TPoint from the array or list, and the line drawn to the start point of the first side.

Self-crossing polygons can be filled according to one of two rules, TFillRule::EAlternate (the default), or TFillRule::EWinding. To explain the difference between these rules, the concept of a winding number needs to be introduced. The area outside any of the loops of the polygon has a winding number of zero, and is never filled. An inside a loop which is bounded by an area with winding number 0 has a winding number of 1. If an area is within a loop that is bounded by an area with winding number 1, e.g. a loop within a loop, has a winding number of 2, and so on.

The filling of a polygon proceeds according to this algorithm:

If aFillRule is TFillRule::EAlternate (default) and it has an odd winding number, then fill the surrounding area.

If aFillRule is TFillRule::EWinding and it has a winding number greater than zero, then fill the surrounding area.

This function always causes a flush of the window server buffer.

Parameters

const CArrayFix< TPoint > *aPointList

An array of points, specifying the vertices of the polygon.

CGraphicsContext::TFillRule aFillRule

Either TFillRule::EAlternate (the default) or TFillRule::EWinding.

Return value

TInt

KErrNone if successful, otherwise another of the system-wide error codes.

See also:

DrawPolygon(const TPoint *,TInt,TFillRule)

IMPORT_C virtual TInt DrawPolygon(const TPoint *aPointList, TInt aNumPoints, TFillRule aFillRule=EAlternate);

Description

Draws and fills a polygon using points defined in a list.

The first TPoint in the list defines the start of the first side of the polygon. The second TPoint defines the second vertex (the end point of the first side and the start point of the second side) and so on. The final side of the polygon is drawn using the last TPoint from the array or list, and the line drawn to the start point of the first side.

Self-crossing polygons can be filled according to one of two rules, TFillRule::EAlternate (the default), or TFillRule::EWinding. To explain the difference between these rules, the concept of a winding number needs to be introduced. The area outside any of the loops of the polygon has a winding number of zero, and is never filled. An inside a loop which is bounded by an area with winding number 0 has a winding number of 1. If an area is within a loop that is bounded by an area with winding number 1, e.g. a loop within a loop, has a winding number of 2, and so on.

The filling of a polygon proceeds according to this algorithm:

If aFillRule is TFillRule::EAlternate (default) and it has an odd winding number, then fill the surrounding area.

If aFillRule is TFillRule::EWinding and it has a winding number greater than zero, then fill the surrounding area.

This function always causes a flush of the window server buffer.

Parameters

const TPoint *aPointList

Pointer to a list of points, specifying the vertices of the polygon.

TInt aNumPoints

The number of points in the vertex list

CGraphicsContext::TFillRule aFillRule

Either TFillRule::EAlternate (the default) or TFillRule::EWinding.

Return value

TInt

KErrNone if successful, otherwise another of the system-wide error codes.

See also:

DrawBitmap(const TPoint &,const CFbsBitmap *)

IMPORT_C virtual void DrawBitmap(const TPoint &aTopLeft, const CFbsBitmap *aDevice);

Description

Draws a bitmap at a specified point.

The function does a compress/stretch based on its internally stored size in twips. Note that if the twips value of the bitmap is not set then nothing is drawn (this is the default situation).

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

Note: this member function uses the bitmap's size in twips and does a stretch/compress blit using a linear DDA.

Parameters

const TPoint &aTopLeft

The point where the top left pixel of the bitmap is to be drawn

const CFbsBitmap *aDevice

The source bitmap.

See also:

DrawBitmap(const TRect &,const CFbsBitmap *)

IMPORT_C virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice);

Description

Draws a bitmap in a rectangle.

The bitmap is compressed/stretched to fit the specified rectangle. Note that if the twips value of the bitmap is not set then nothing is drawn (this is the default situation).

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

Notes: this member function uses the bitmap's size in pixels and does a stretch/compress blit using a linear DDA.

Parameters

const TRect &aDestRect

The rectangle within which the bitmap is to be drawn.

const CFbsBitmap *aDevice

The source bitmap.

See also:

DrawBitmap(const TRect &,const CFbsBitmap *,const TRect &)

IMPORT_C virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice, const TRect &aSourceRect);

Description

Draws a specified rectangle from a bitmap into another rectangle.

The function compresses/stretches the specified rectangle from the bitmap to fit the destination rectangle. Note that if the twips value of the bitmap is not set then nothing is drawn (this is the default situation).

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

Note: this member function uses rectangle sizes in pixels and does a stretch/compress blit using a linear DDA.

Parameters

const TRect &aDestRect

The rectangle within which the bitmap is to be drawn.

const CFbsBitmap *aDevice

A source bitmap.

const TRect &aSourceRect

The rectangle in the source bitmap that is copied to the destination rectangle.

See also:

DrawBitmapMasked(const TRect &,const CFbsBitmap *,const TRect &,const CFbsBitmap *,TBool)

IMPORT_C virtual void DrawBitmapMasked(const TRect &aDestRect, const CFbsBitmap *aBitmap, const TRect &aSourceRect, const CFbsBitmap *aMaskBitmap, TBool aInvertMask);

Description

Draws a specified rectangle from a bitmap and its mask into another rectangle.

The function compresses/stretches the specified rectangle from the bitmap to fit the destination rectangle. The mask bitmap can be used as either a positive or negative mask. Masked pixels are not mapped to the destination rectangle.

A black and white (binary) mask bitmap is used. With aInvertMask=EFalse, black pixels in the mask bitmap stop corresponding pixels in the source bitmap from being transferred to the destination rectangle. With aInvertMask=ETrue, white pixels in the mask bitmap stop corresponding pixels in the source bitmap from being transferred to the destination rectangle.

If mask bitmap's display mode is EColor256, the function does AplhaBlending and ignores aInvertMask parameter.

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

Note: this member function uses rectangle sizes in pixels and does a stretch/compress blit using a linear DDA.

Parameters

const TRect &aDestRect

The rectangle within which the masked bitmap is to be drawn.

const CFbsBitmap *aBitmap

A source bitmap.

const TRect &aSourceRect

The rectangle in the source bitmap that is copied to the destination rectangle.

const CFbsBitmap *aMaskBitmap

A mask bitmap.

TBool aInvertMask

If false, a source pixel that is masked by a black pixel is not transferred to the destination rectangle. If true, then a source pixel that is masked by a white pixel is not transferred to the destination rectangle.

DrawBitmapMasked(const TRect &,const CWsBitmap *,const TRect &,const CWsBitmap *,TBool)

IMPORT_C virtual void DrawBitmapMasked(const TRect &aDestRect, const CWsBitmap *aBitmap, const TRect &aSourceRect, const CWsBitmap *aMaskBitmap, TBool aInvertMask);

Description

Draws a specified rectangle from a wserv bitmap and its mask into another rectangle.

The function compresses/stretches the specified rectangle from the bitmap to fit the destination rectangle. The mask bitmap can be used as either a positive or negative mask. Masked pixels are not mapped to the destination rectangle.

A black and white (binary) mask bitmap is used. With aInvertMask=EFalse, black pixels in the mask bitmap stop corresponding pixels in the source bitmap from being transferred to the destination rectangle. With aInvertMask=ETrue, white pixels in the mask bitmap stop corresponding pixels in the source bitmap from being transferred to the destination rectangle.

If mask bitmap's display mode is EColor256, the function does AplhaBlending and ignores aInvertMask parameter.

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

Note: this member function uses rectangle sizes in pixels and does a stretch/compress blit using a linear DDA.

Parameters

const TRect &aDestRect

The rectangle within which the masked bitmap is to be drawn.

const CWsBitmap *aBitmap

A source wserv bitmap.

const TRect &aSourceRect

The rectangle in the source bitmap that is copied to the destination rectangle.

const CWsBitmap *aMaskBitmap

A mask wserv bitmap.

TBool aInvertMask

If false, a source pixel that is masked by a black pixel is not transferred to the destination rectangle. If true, then a source pixel that is masked by a white pixel is not transferred to the destination rectangle.

DrawText(const TDesC &,const TPoint &)

IMPORT_C virtual void DrawText(const TDesC &aBuf, const TPoint &aPos);

Description

Draws horizontal text with no surrounding box.

The appearance of the text is subject to the drawing mode, the font, pen colour, word justification and character justification.

A panic occurs if this function is called when there is no font: see CWindowGc::UseFont(const CFont *).

Parameters

const TDesC16 &aBuf

The string to write.

const TPoint &aPos

The point specifying the position of the baseline at the left end of the text.

See also:

DrawText(const TDesC &,const TRect &,TInt,TTextAlign,TInt)

IMPORT_C virtual void DrawText(const TDesC &aBuf, const TRect &aBox, TInt aBaselineOffset, TTextAlign aHoriz=ELeft, TInt aLeftMrg=0);

Description

Draws horizontal text within a cleared box.

The appearance of the text is subject to the drawing mode, the font, pen colour, word justification and character justification. It is also subject to the background brush (set brush to ENullBrush for no effect on background).

A panic occurs if this function is called when there is no font: see CWindowGc::UseFont(const CFont *).

Note: the text is clipped to the box. You must ensure that the specified string is not too large.

Parameters

const TDesC16 &aBuf

The text to write.

const TRect &aBox

The box to draw the text in.

TInt aBaselineOffset

An offset from the top of the box to the text baseline. Note that the baseline is the line on which letters sit, for instance below r, s, t, and above the tail of q, and y.

CGraphicsContext::TTextAlign aHoriz

The text alignment mode (default is left, rather than centre or right).

TInt aLeftMrg

The left margin for left-aligned text, or the right margin for right-aligned text (default is zero).

See also:

Clear()

IMPORT_C virtual void Clear();

Description

Clears the whole window.

The cleared area is filled with the current brush colour.

See also:

Clear(const TRect &)

IMPORT_C virtual void Clear(const TRect &aRect);

Description

Clears a rectangular area of a window.

The cleared area is filled with the current brush colour.

Parameters

const TRect &aRect

The rectangle to clear.

See also:

CopyRect(const TPoint &,const TRect &)

IMPORT_C virtual void CopyRect(const TPoint &anOffset, const TRect &aRect);

Description

Copies a rectangle from any part of the screen into the window that the gc is active on.

The copy part of the operation applies to the whole rectangle, irrespective of whether or not it within the window, however the "paste" is clipped to the drawing area.

The rectangle is specified in window coordinates (if the top-left of the rectangle is (0,0) then the area of the screen it specifies has its top-left at the top left corner of the window, if it is (-10,-10) then it starts 10 pixels above and to the left of the window).

Note: shadows in the source rectangle will be copied. None of the area drawn to will gain shadowing (even if the window is already in shadow).

This version of this function is only really suitable for testing.

Parameters

const TPoint &anOffset

The offset from the original position to the point where the rectangle is copied.

const TRect &aRect

The rectangular area to be copied. This is in window co-ordinates, e.g. the top left corner of the window is position (0,0) with respect to the rectangle.

See also:

BitBlt(const TPoint &,const CFbsBitmap *)

IMPORT_C virtual void BitBlt(const TPoint &aPos, const CFbsBitmap *aBitmap);

Description

Performs a bitmap block transfer.

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

Parameters

const TPoint &aPos

The position for the top left corner of the bitmap.

const CFbsBitmap *aBitmap

A memory-resident bitmap.

See also:

BitBlt(const TPoint &,const CFbsBitmap *,const TRect &)

IMPORT_C virtual void BitBlt(const TPoint &aDestination, const CFbsBitmap *aBitmap, const TRect &aSource);

Description

Performs a bitmap block transfer of a rectangular piece of a bitmap.

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

Note: if the rectangle aSource is larger than the bitmap then the bitmap will be padded with white.

Parameters

const TPoint &aDestination

The position for the top left corner of the bitmap.

const CFbsBitmap *aBitmap

A memory-resident bitmap

const TRect &aSource

A rectangle defining the piece of the bitmap to be drawn, with co-ordinates relative to the top left corner of the bitmap

See also:

BitBltMasked(const TPoint &,const CFbsBitmap *,const TRect &,const CFbsBitmap *,TBool)

IMPORT_C virtual void BitBltMasked(const TPoint &aPoint, const CFbsBitmap *aBitmap, const TRect &aSourceRect, const CFbsBitmap *aMaskBitmap, TBool aInvertMask);

Description

Performs a masked bitmap block transfer of a memory resident source bitmap.

The mask bitmap can be used as either a positive or negative mask. Masked pixels are not mapped to the destination rectangle.

A black and white (binary) mask bitmap is used. With aInvertMask=EFalse, black pixels in the mask bitmap stop corresponding pixels in the source bitmap from being transferred to the destination rectangle. With aInvertMask=ETrue, white pixels in the mask bitmap stop corresponding pixels in the source bitmap from being transferred to the destination rectangle.

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

Parameters

const TPoint &aPoint

A position for the top left corner of the bitmap.

const CFbsBitmap *aBitmap

A memory-resident source bitmap.

const TRect &aSourceRect

A rectangle defining the piece of the bitmap to be drawn, with co-ordinates relative to the top left corner of the bitmap

const CFbsBitmap *aMaskBitmap

A mask bitmap.

TBool aInvertMask

If false, a source pixel that is masked by a black pixel is not transferred to the destination rectangle. If true, then a source pixel that is masked by a white pixel is not transferred to the destination rectangle.

See also:

BitBlt(const TPoint &,const CWsBitmap *)

IMPORT_C virtual void BitBlt(const TPoint &aPoint, const CWsBitmap *aBitmap);

Description

Performs a bitmap block transfer on a bitmap to which the window server already has a handle.

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

This function should be used in preference to the CFbsBitmap overload if the bitmap is to be used more than once, as it is a lot quicker.

Parameters

const TPoint &aPoint

The position for the top left corner of the bitmap.

const CWsBitmap *aBitmap

A window server bitmap.

See also:

BitBlt(const TPoint &,const CWsBitmap *,const TRect &)

IMPORT_C virtual void BitBlt(const TPoint &aDestination, const CWsBitmap *aBitmap, const TRect &aSource);

Description

Performs a bitmap block transfer of a rectangular piece of a bitmap to which the window server already has a handle.

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

This function should be used in preference to the CFbsBitmap overload if the bitmap is to be used more than once, as it is a lot quicker.

Note: if the rectangle aSource is larger than the bitmap then the bitmap will be padded with white.

Parameters

const TPoint &aDestination

The position for the top left corner of the bitmap.

const CWsBitmap *aBitmap

A window server bitmap.

const TRect &aSource

A rectangle defining the piece of the bitmap to be drawn, with co-ordinates relative to the top left corner of the bitmap

See also:

BitBltMasked(const TPoint &,const CWsBitmap *,const TRect &,const CWsBitmap *,TBool)

IMPORT_C virtual void BitBltMasked(const TPoint &aPoint, const CWsBitmap *aBitmap, const TRect &aSourceRect, const CWsBitmap *aMaskBitmap, TBool aInvertMask);

Description

Performs a masked bitmap block transfer of a window server bitmap.

The mask bitmap can be used as either a positive or negative mask. Masked pixels are not mapped to the destination rectangle.

A black and white (binary) mask bitmap is used. With aInvertMask=EFalse, black pixels in the mask bitmap stop corresponding pixels in the source bitmap from being transferred to the destination rectangle. With aInvertMask=ETrue, white pixels in the mask bitmap stop corresponding pixels in the source bitmap from being transferred to the destination rectangle.

This function should be used in preference to the CFbsBitmap overload if the bitmap is to be used more than once, as it is a lot quicker.

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

Parameters

const TPoint &aPoint

A position for the top left corner of the bitmap.

const CWsBitmap *aBitmap

A window server bitmap.

const TRect &aSourceRect

A rectangle defining the piece of the bitmap to be drawn, with co-ordinates relative to the top left corner of the bitmap.

const CWsBitmap *aMaskBitmap

A window server mask bitmap.

TBool aInvertMask

If false, a source pixel that is masked by a black pixel is not transferred to the destination rectangle. If true, then a source pixel that is masked by a white pixel is not transferred to the destination rectangle.

See also:

MapColors(const TRect &,const TRgb *,TInt,TBool)

IMPORT_C virtual void MapColors(const TRect &aRect, const TRgb *aColors, TInt aNumPairs=2, TBool aMapForwards=ETrue);

Description

Re-maps pixel colours within a rectangle.

aColors is an array of paired colour values. The rectangle is scanned and the colour value of each pixel is looked up in the array, and if found is replaced by the value with which it is paired. The arguments specify the rectangle, the array of pairs, the number of pairs in the array, and the 'direction' of lookup. If no entry is found for the colour value of a given pixel it remains unchanged.

This function was designed for cursor display. A cursor is normally displayed as the XOR of the background against which it appears. However in some graphics modes, certain colours XOR to very similar shades. CWindowGc::MapColors(const TRect &,const TRgb *,TInt,TBool) allows more pleasing maps to be specified.

The effect of this function when applied to transparent pixels when the opaque flag is set is undefined. See CWindowGc::SetOpaque(TBool).

Parameters

const TRect &aRect

Rectangle to be mapped.

const TRgb *aColors

Array of colour value pairs, one value in a pair is the lookup value and the other is the replacement value.

TInt aNumPairs

Number of pairs in the array. aColors must have twice this number of elements. By default the aColors array is assumed to specify 2 colours (i.e. it specifies a single mapping).

TBool aMapForwards

Direction of lookup. ETrue to map forwards, i.e. treat the first value in the pair as the lookup value and the second as the replacement value; EFalse does the opposite.

DrawTextVertical(const TDesC &,const TPoint &,TBool)

IMPORT_C virtual void DrawTextVertical(const TDesC &aText, const TPoint &aPos, TBool aUp);

Description

Draws vertical text in the specified direction.

A panic occurs if this function is called when there is no font: see CWindowGc::UseFont(const CFont *).

Parameters

const TDesC16 &aText

The text to be drawn.

const TPoint &aPos

Point of origin of the text baseline.

TBool aUp

Direction. ETrue for up, EFalse for down.

DrawTextVertical(const TDesC &,const TRect &,TInt,TBool,TTextAlign,TInt)

IMPORT_C virtual void DrawTextVertical(const TDesC &aText, const TRect &aBox, TInt aBaselineOffset, TBool aUp, TTextAlign aVert=ELeft, TInt aMargin=0);

Description

Draws text vertically in the specified direction, within a box of the specified size.

A panic occurs if this function is called when there is no font: see CWindowGc::UseFont(const CFont *).

Parameters

const TDesC16 &aText

The text to be drawn.

const TRect &aBox

The bounding box within which the text should be drawn, and which it is clipped to.

TInt aBaselineOffset

The height of the top of the characters from their text baseline.

TBool aUp

The direction. ETrue for up, EFalse for down.

CGraphicsContext::TTextAlign aVert

The text alignment.

TInt aMargin

The margin.

SetDitherOrigin(const TPoint &)

IMPORT_C virtual void SetDitherOrigin(const TPoint &aPoint);

Description

Sets the origin used for colour dithering.

Parameters

const TPoint &aPoint

New dither origin.

SetClippingRegion(const TRegion &)

IMPORT_C virtual TInt SetClippingRegion(const TRegion &aRegion);

Description

Sets the clipping region.

Drawing is always clipped to the visible area of a window. The region specified by this function is in addition to that area.

This function always causes a flush of the window server buffer.

Parameters

const TRegion &aRegion

Return value

TInt

KErrNone if successful, KErrNoMemory if there is insufficient memory to create the region on the server side, otherwise another error code.

CancelClippingRegion()

IMPORT_C virtual void CancelClippingRegion();

Description

Cancels the current clipping region.

SetOpaque(TBool)

IMPORT_C virtual void SetOpaque(TBool aDrawOpaque=ETrue);

Description

Sets and unsets an opaque flag on the window. When drawing to a transparent window with the opaque flag set, drawing commands will not appear transparent. When drawing to a non-transparent window this command has no effect. The result of non-opaque drawing performed over the top of an area of the window to which opaque drawing has already been done is undefined. The result of opaque alpha blending or color mapping over the top of an area of the window to which opaque drawing has not already been done is undefined. This method is supported from version 8.1

Parameters

TBool aDrawOpaque

If true, opaque mode is switched on. If false, normal drawing will be used.

SetFaded(TBool)

IMPORT_C virtual void SetFaded(TBool aFaded);

Description

Sets whether the graphics context is faded.

Fading is used to make a window appear less colourful so that other windows stand out. For example, a window would be faded when a dialogue is displayed in front of it.

Parameters

TBool aFaded

ETrue to fade the graphics context, EFalse to unfade it.

SetFadingParameters(TUint8,TUint8)

IMPORT_C virtual void SetFadingParameters(TUint8 aBlackMap, TUint8 aWhiteMap);

Description

Sets the fading parameters.

This function allows you to override the map used when drawing with a faded graphics context. However if you draw to a faded window with a faded graphics context, then fading on the graphics context is ignored and it will use the fading of the window.

Fading is used to make a window appear less colourful so that other windows stand out. For example, a window would be faded when a dialogue is displayed in front of it.

You can either make a faded window closer to white or closer to black. The fading map allows you to over-ride the default fading parameters set in RWsSession::SetDefaultFadingParameters(TUint8,TUint8).

Fading re-maps colours to fall between the specified black and white map values. If aBlackMap=0 and aWhiteMap=255 then the colours are mapped unchanged. As the values converge, the colours are mapped to a smaller range, so the differences between colours in the faded graphics context decrease. If the values are reversed then the colours are inverted (i.e. where the gc would be black, it is now white).

Parameters

TUint8 aBlackMap

Black map fading parameter. Unfaded this is 0.

TUint8 aWhiteMap

White map fading parameter. Unfaded this is 255.

See also:

AlphaBlendBitmaps(const TPoint &,const CFbsBitmap *,const TRect &,const CFbsBitmap *,const TPoint &)

IMPORT_C virtual TInt AlphaBlendBitmaps(const TPoint &aDestPt, const CFbsBitmap *aSrcBmp, const TRect &aSrcRect, const CFbsBitmap *aAlphaBmp, const TPoint &aAlphaPt);

Description

Performs an alpha blending of the source data, aSrcBmp, with the window, using the data from aAlphaBmp as an alpha blending factor. The formula used is: (S * A + W * (255 - A)) / 255, where:

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

This method is supported from version 8.1

Parameters

const TPoint &aDestPt

Position in the target the result should be drawn to.

const CFbsBitmap *aSrcBmp

A pointer to the source bitmap.

const TRect &aSrcRect

The part of the source bitmap that should be used.

const CFbsBitmap *aAlphaBmp

A pointer to the bitmap used as an alpha blending factor.

const TPoint &aAlphaPt

Position of the first pixel in the alpha bitmap that should be used as a source for the alpha blending. The size of the area is the same as the source bitmap area - aSrcRect parameter.

Return value

TInt

See also:

AlphaBlendBitmaps(const TPoint &,const CWsBitmap *,const TRect &,const CWsBitmap *,const TPoint &)

IMPORT_C virtual TInt AlphaBlendBitmaps(const TPoint &aDestPt, const CWsBitmap *aSrcBmp, const TRect &aSrcRect, const CWsBitmap *aAlphaBmp, const TPoint &aAlphaPt);

Description

The method performs an alpha blending of the source data, aSrcBmp, with the window, using the data from aAlphaBmp as an alpha blending factor. For information on how this function works, see the other overload.

Windows that store their redraw commands will only store drawing position and a handle to bitmaps that are drawn in it. The bitmap handle is just a pointer to the bitmap in the FBSERV heap. At some point later WSERV may need to draw that window again and it will just replay the stored commands including the draw bitmap. However, if the client has changed the content of the bitmap, WSERV will effectively draw a different bitmap when it replays the commands.

This method is supported from version 8.1

Parameters

const TPoint &aDestPt

Position in the target the result should be drawn to.

const CWsBitmap *aSrcBmp

A pointer to the source bitmap.

const TRect &aSrcRect

The part of the source bitmap that should be used.

const CWsBitmap *aAlphaBmp

A pointer to the bitmap used as an alpha blending factor.

const TPoint &aAlphaPt

Position of the first pixel in the alpha bitmap that should be used as a source for the alpha blending. The size of the area is the same as the source bitmap area - aSrcRect parameter.

Return value

TInt

See also:

APIExtension(TUid,TAny *&,TAny *)

protected: IMPORT_C virtual TInt APIExtension(TUid aUid, TAny *&aOutput, TAny *aInput);

Description

APIExtension can contain as many additional methods as is required by CGraphicsContext after its original conception. It takes 3 parameters. Function is exported due to constrains of retaining BC with earlier versions. This is not used directly by external methods, instead it is called by a named method in CGraphicsContext which passes the relivant arguements including an unique identifier for the required action.

Parameters

TUid aUid

The unique identifier for the method that is required. Selected internally by a series of "if" statements.

TAny *&aOutput

is a TAny pointer to a reference. Used to output data as the structure does not need to be instantiated before the function call this adds greater flexibility.

TAny *aInput

is a TAny pointer used to input data.

Return value

TInt

See also:

Reserved_CGraphicsContext_2()

private: IMPORT_C virtual void Reserved_CGraphicsContext_2();

Description

A reserved virtual function for future use.

Reserved_CBitmapContext_1()

private: IMPORT_C virtual void Reserved_CBitmapContext_1();

Description

Reserved_CBitmapContext_2()

private: IMPORT_C virtual void Reserved_CBitmapContext_2();

Description

Reserved_CBitmapContext_3()

private: IMPORT_C virtual void Reserved_CBitmapContext_3();

Description

DrawWsGraphic(const TWsGraphicId &,const TRect &)

IMPORT_C virtual void DrawWsGraphic(const TWsGraphicId &aId, const TRect &aDestRect);

Description

Draws an abstract artwork. It does nothing if aDestRect values fall outside the window area.

Parameters

const TWsGraphicId &aId

the identifier for the artwork

const TRect &aDestRect

the destination rect within the active window for this artwork

DrawWsGraphic(const TWsGraphicId &,const TRect &,const TDesC8 &)

IMPORT_C virtual void DrawWsGraphic(const TWsGraphicId &aId, const TRect &aDestRect, const TDesC8 &aData);

Description

Draws an abstract artwork. It does nothing if aDestRect values fall outside the window area.

Parameters

const TWsGraphicId &aId

the identifier for the artwork

const TRect &aDestRect

the destination rect within the active window for this artwork

const TDesC8 &aData

opaque datagram to associate with this occasion of drawing. The format is dependent upon the artwork

Reserved_CWindowGc_3()

private: IMPORT_C virtual void Reserved_CWindowGc_3();

Description

Reserved_CWindowGc_4()

private: IMPORT_C virtual void Reserved_CWindowGc_4();

Description

Reserved_CWindowGc_5()

private: IMPORT_C virtual void Reserved_CWindowGc_5();

Description

[Previous] [Top] [Next]