![[Index]](../../../stock/btn_index.gif){kind=small}
![[Glossary]](../../../stock/btn_glossary.gif){kind=small}
![[Previous]](../../../stock/btn_prev.gif){kind=small}
![[Next]](../../../stock/btn_next.gif){kind=small}
| |
|
| |
Location:
gdi.h
Link against: gdi.lib
CGraphicsContext
Supported from 5.0
Abstract, device independent, interface to graphics contexts.
The class CBitmapContext is derived from this
class.
See CGraphicsContext::Reset() for the default settings
of a graphics context immediately after construction.
|
Defined in CGraphicsContext:
CancelClippingRect(), Device(), DiscardBrushPattern(), DiscardFont(), DrawArc(), DrawBitmap(), DrawEllipse(), DrawLine(), DrawLineBy(), DrawLineTo(), DrawPie(), DrawPolyLine(), DrawPolygon(), DrawRect(), DrawRoundRect(), DrawText(), EAlternate, EAnd, ECenter, EDashedPen, EDiamondCrossHatchBrush, EDotDashPen, EDotDotDashPen, EDottedPen, EDrawModeAND, EDrawModeANDNOT, EDrawModeNOTAND, EDrawModeNOTANDNOT, EDrawModeNOTOR, EDrawModeNOTORNOT, EDrawModeNOTPEN, EDrawModeNOTSCREEN, EDrawModeNOTXOR, EDrawModeOR, EDrawModeORNOT, EDrawModePEN, EDrawModeXOR, EForwardDiagonalHatchBrush, EHorizontalHatchBrush, EInvertPen, EInvertScreen, ELeft, ELogicalOp, ENullBrush, ENullPen, EOr, EPatternedBrush, EPenmode, ERearwardDiagonalHatchBrush, ERight, ESolidBrush, ESolidPen, ESquareCrossHatchBrush, EVerticalHatchBrush, EWinding, EXor, JustificationInPixels(), MoveBy(), MoveTo(), Plot(), Reset(), SetBrushColor(), SetBrushOrigin(), SetBrushStyle(), SetCharJustification(), SetClippingRect(), SetDrawMode(), SetOrigin(), SetPenColor(), SetPenSize(), SetPenStyle(), SetStrikethroughStyle(), SetUnderlineStyle(), SetWordJustification(), TBrushStyle, TDrawMode, TDrawModeComponents, TDrawTextParam, TFillRule, TPenStyle, TTextAlign, UseBrushPattern(), UseFont()
Inherited from CBase:
operator new()
virtual CGraphicsDevice* Device() const=0;
Gets a pointer to the graphics context’s graphics device.
|
|
virtual void Reset()=0;
Resets the graphics context to its default settings:
the drawing mode is 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
|
virtual void SetDrawMode(TDrawMode aDrawingMode)=0;
Sets the drawing mode.
The way that the pen and brush draw depends on the drawing mode. The drawing mode 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, 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.
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
|
virtual void SetOrigin(const TPoint& aPos=TPoint(0,0))=0;
Sets the position of the co-ordinate origin.
All subsequent drawing operations are done relative to this origin.
|
|
virtual void MoveTo(const TPoint& aPoint)=0;
Sets the drawing point relative to the co-ordinate origin.
A subsequent call to DrawLineTo() or
DrawLineBy() uses the new drawing point as the start point for the
line drawn.
Notes
The operations DrawLine(),
DrawLineTo(), DrawLineBy() 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.
|
virtual void MoveBy(const TPoint& aVector)=0;
Sets the drawing point relative to the current co-ordinates.
A subsequent call to DrawLineTo() or
DrawLineBy() uses the new drawing point as the start point for the
line drawn.
Notes
The operations DrawLine(),
DrawLineTo(), DrawLineBy() 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.
|
|
virtual void SetClippingRect(const TRect& aRect)=0;
Sets the clipping rectangle.
The area of visible drawing depends on the clipping region. The default clipping rectangle is the full device area.
|
virtual void CancelClippingRect()=0;
Cancels any clipping rectangle.
Clipping thus reverts to the full device area, the default.
|
virtual void SetPenColor(const TRgb& aColor)=0;
Sets the pen colour.
The effective pen colour depends on the drawing mode. The default pen colour is black.
Note:
The pen is used to draw lines, the outlines of filled shapes, and text. The class provides member functions to set the colour of the pen, the style of line and the line size drawn.
|
virtual void SetPenStyle(TPenStyle aPenStyle)=0;
Sets the line drawing style for the pen.
There are 6 pen styles. If no pen style is set, then 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
Notes:
The pen is used to draw lines, the outlines of filled
shapes, and text. CGraphicsContext member functions are provided
to set the colour of the pen, the style of line and the line size drawn.
The TPenStyle::ENullPen style should be used
if a border is not required around a filled shape.
Dotted and dashed pen styles have a device dependant
implementation, always give single-pixel size lines on the
screen — whatever the pen size set by
SetPenSize() — and can only be used for straight
lines, polylines, non-rounded rectangles and polygons.
The dotted/dashed pattern is continued, without re-starting, for all consecutively drawn straight lines, i.e.
the outlines of rectangles — the pattern starts in the top left corner. It is reset at the end of the function call.
the outlines of polygons — the pattern starts at the first point. It is reset at the end of the function call.
polylines and straight lines — the pattern
starts at the first point initially. Consecutive calls to
DrawLine() and/or DrawPolyLine(), whether the lines
are concatenated or not, continue the pattern. It can be reset by a further
call to SetPenStyle() using the same dotted/dashed style
parameter.
|
virtual void SetPenSize(const TSize& aSize)=0;
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).
are always drawn in TDrawMode::EDrawModePEN
mode, overriding whatever mode has been set using
SetDrawMode().
Notes:
The pen is used to draw lines, the outlines of filled shapes, and text. The class provides member functions to set the colour of the pen, the style of line and the line size drawn.
Wide straight lines and arcs have rounded ends so that concatenated wide lines have smoothly rounded corners at the vertexes.
When lines are made wide, the extra strips of pixels are added equally to both sides of the line. This works precisely for lines of odd pixel size (3, 5, 7, etc.). Wide lines of even pixel size, (2, 4, 6, etc.), have the extra strip of pixels added to the right and/or below the line.
Wide outlines of ellipses and wide line arcs are drawn with the pixels distributed either side of a thin (single pixel wide) true ellipse constructed in the normal manner. Wide ellipses and arcs of even pixel size have the extra strip of pixels added to the right and/or below the curved line. This gives a slight asymmetry to ellipses.
If the pen style is dotted or dashed, the size specification is ignored: a single-pixel wide primitive is drawn, (this is device dependant).
A line size of zero is handled as if the pen style had been
set to TPenStyle::ENullPen.
|
|
virtual void SetBrushColor(const TRgb& aColor)=0;
Sets the brush colour.
The effective brush colour depends on the drawing mode.
Notes:
The brush is used for filling shapes and the background of text boxes. The brush has colour, style, pattern and pattern origin parameters.
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.
|
virtual void SetBrushStyle(TBrushStyle aBrushStyle)=0;
Sets the brush style.
Ten brush styles are provided, including six built-in hatching
patterns (see TBrushStyle).
Note:
The brush is used for filling shapes and the background of text boxes. The brush has colour, style, pattern and pattern origin parameters.
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
UseBrushPattern(), then the function panics.
Hatching lines are done in the current brush colour, set
using SetBrushColor(). Hatching can be overlaid on other graphics.
The hatching pattern starts at the brush origin, set using
SetBrushOrigin().
|
virtual void SetBrushOrigin(const TPoint& aOrigin)=0;
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 file are then tiled 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, or a bitmap. To use
a bitmap, the brush must have a pattern set and the brush style must be set to
TBrushStyle::EPatternedBrush.
Notes
The brush is used for filling shapes and the background of text boxes. The brush has colour, style, pattern and pattern origin parameters.
If SetBrushOrigin() 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).
|
virtual void UseBrushPattern(const CFbsBitmap* aBitmap)=0;
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.
When the brush pattern is no longer required, use
DiscardBrushPattern() to free up the memory used, if the bitmap is
not being shared. If UseBrushPattern() is used again without using
DiscardBrushPattern() then the previous pattern is discarded
automatically.
Notes:
The brush is used for filling shapes and the background of text boxes. The brush has colour, style, pattern and pattern origin parameters.
When loading a bitmap, the bitmap is checked to see if it 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
SetBrushStyle().
|
virtual void DiscardBrushPattern()=0;
Discards a non-built-in brush pattern.
This frees up the memory used by the bitmap, if it is not being shared by another process.
Notes:
The brush is used for filling shapes and the background of text boxes. The brush has colour, style, pattern and pattern origin parameters.
If DiscardBrushPattern() is used, with no
brush pattern set, then there is no effect.
|
virtual void UseFont(const CFont* aFont)=0;
Sets the device font to be used for text drawing.
If the font is already in memory, then that copy is shared.
Notes:
The CFont* argument must have been previously
initialised by calling MGraphicsDeviceMap::GetNearestFontInTwips()
with the required font-specification. If the CFont* has not been
initialised correctly, and therefore does not point to an available
font-bitmap, then a panic is raised.
When the font is no longer required, use
DiscardFont() to free up the memory used. If
UseFont() is used again without using DiscardFont()
then the previous font is discarded automatically.
If no font has been selected, and an attempt is made to
draw text with DrawText(), then a panic is raised.
|
virtual void DiscardFont()=0;
Discards a font.
This frees up the memory used, if the font is not being shared.
The function can be called when no font is in use.
virtual void SetWordJustification(TInt aExcessWidth,TInt aNumGaps)=0;
Adjusts the spaces between words to stretch or squeeze to a certain width.
The function is required by the Text Views API, and is not intended for regular use by developers.
The text line that is to be justified has a certain number of gaps (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 the gaps between the words to achieve full justification of the text line. Spaces become fat spaces to keep underlining/strikethrough consistent. Pixels are distributed to the inter-word gaps starting from the left end of the string. The spacing between characters in each word remains unchanged.
After a call to SetWordJustification(), subsequent
calls to either of the two DrawText() functions are affected until
the number of spaces specified by aNumSpaces is used up.
The easiest way to find out the excess width and number of
spaces is to call CFont::MeasureText(). This function can also
perform counting, which is finding how much of some text will fit into a given
width.
Use CFont::TextCount() to return the excess
width.
For example, in the string "To be, or not to be", there are five inter-word gaps. If there are six excess pixels they will be distributed in the proportion 2, 1, 1, 1, 1 between the words. If there are nine excess pixels they will be distributed in the proportion 2, 2, 2, 2, 1 between the words.
Notes:
If the excess width is zero, then calling
SetWordJustification() has no effect.
At first sight it may appear that
SetWordJustification() is not required because you can simply call
DrawText() for each word. However, underlined justified text does
not work using this strategy — you get a non-underlined gap between the
space and the beginning of the next word.
|
virtual void SetCharJustification(TInt aExcessWidth,TInt aNumChars)=0;
Sets character justification.
This function is required by the Text Views API, and is not intended for regular use by developers.
It affects the strings of text used in the calls to
DrawText() that follow, until the number of characters drawn
equals aNumChars.
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.
Use CFont::TextCount() to return the excess
width.
Notes:
This function is provided to allow simulation of printer fonts on screen. Due to the fact that fully-scalable fonts are not used before ER5, large printer fonts can be simulated by using the nearest smaller font and widening it slightly.
If the excess width is zero, then calling
SetCharJustification() has no effect.
SetCharJustification() is required for WYSIWYG
where the layout uses printer font metrics but screen fonts have to be drawn on
the screen. Because continuously scalable typefaces (c.f. TrueType) are not
used before ER5 and because screen fonts are coarser and less numerous in their
variety than the printer fonts, the best matching smaller screen font must be
used with character justification to simulate the printer font on the
screen.
There is also a situation where the gaps between characters on screen have to be reduced with character clipping. The screen font that best matches the printer font may have the required height, but has characters that are too wide. A line of text that works on the printer will then be too long on the screen, unless it is squashed horizontally. The number of pixels that overlap the end of the screen line must now be removed from the gaps between the characters, i.e. there is a negative excess width. This situation is especially important where adding a TAB on screen gives perfectly acceptable printout, but would push the last character of the line off the right hand side of the screen.
In practice what you do in printer layout mode is:
Calculate where the line breaks will come on the printer. To do this you use a printer font (which in practice means a table of character widths of the font that the printer will use).
Now change to use a screen font that is the closest font which is no taller that the printer font. In practice it will often be fatter maybe only for certain characters such as 'i'.
You have to recalculate the width of the characters using
the screen fonts. You can do this using CFont::TextWidth() as you
have already determined how many characters will fit on the line.
If, in the screen font, the characters are not as wide as the line then you can just use word justification to expand the line. You would only do this if the text is to be justified.
If, however, the characters are wider than the line then you would use character justification to clip each character. You would need to do this even if the line is not justified.
Thus, in practice, character justification will only very rarely be used to expand a line of characters.
|
static TInt JustificationInPixels(TInt& aExcessPixels,TInt& aTotalUnits);
Gets the amount of space in pixels by which to adjust the current letter or word spacing, and also retrieves the number of excess pixels and word spaces remaining after the adjustment is performed.
The arguments are the number of remaining pixels (character groups) and units (word spaces) over which justification is to occur. The function can be called repetitively until the number of units is zero, and hence justification is complete. A panic occurs if the number of units is less than one or the amount of pixels is zero.
|
|
static TInt JustificationInPixels(TInt aExcessPixels,TInt aTotalUnits,TInt aFirstUnit,TInt aNumUnits);
Gets the amount of space in pixels by which to adjust letter or word spacing, given the total number of words and spaces, a start space, and the number of units to be adjusted.
The first two arguments are the number of pixels (character groups) and the number of units (word spaces) over which justification is to occur. The third argument specifies the current character group or word space, while the final argument specifies the number of units that are to be adjusted.
A panic occurs if aExcessPixels is 0,
aTotalUnits is not greater than 0, or aFirstUnit is
not less than aTotalUnits.
|
|
|
virtual void SetUnderlineStyle(TFontUnderline aUnderlineStyle)=0;
Sets the underline style.
This is applied to all subsequently drawn text.
|
virtual void SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle)=0;
Sets the strikethrough style.
This is applied to all subsequently drawn text.
|
|
virtual void Plot(const TPoint& aPoint)=0;
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.
|
|
There are a number of important facts regarding all line drawing:
Straight lines can be drawn between two given points, to a single given point from the current internal drawing position, or by moving the internal drawing position by a given vector.
Functions are provided to draw straight lines, polylines (concatenated sequences of straight lines) and curved arcs.
All lines are drawn with the current pen settings using the current drawing mode.
Straight lines, one pixel wide, are drawn without their final point. This enables sequences of concatenated lines to be easily drawn with each pixel only being drawn once.
If the pen size is greater than one pixel, a straight line is drawn as a rectangular shaped region of pixels, with rounded ends that extend beyond the start and end points.
virtual void DrawLine(const TPoint& aPoint1,const TPoint& aPoint2)=0;
Draws a straight line between two points.
|
virtual void DrawLineTo(const TPoint& aPoint)=0;
Draws a straight line from the current drawing point to a specified point.
|
virtual void DrawLineBy(const TPoint& aVector)=0;
Draws a straight line relative to the current drawing point, using a vector.
The start point of the line is the current drawing point. The specified vector is added to the drawing point to give the end point of the line
|
virtual void DrawPolyLine(const CArrayFix<TPoint>* aPointList)=0;
Draws a polyline from a set of points in an array.
A polyline is a series of concatenated straight lines joining a set of points.
|
virtual void DrawPolyLine(const TPoint* aPointList,TInt aNumPoints)=0;
Draws a polyline from a set of points in a list.
A polyline is a series of concatenated straight lines joining a set of points.
|
virtual void DrawArc(const TRect& aRect,const TPoint& aStart,const TPoint& aEnd)=0;
Draws an arc.
The arc is considered a portion of an ellipse. The ellipse is
defined by the TRect argument.
The pixels at both the start point and the end point are drawn.
The arc itself is the segment of the ellipse drawn 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 the specified start or end point is at the centre of the ellipse, then the line that defines the start or end of the arc defaults to one extending vertically above the centre point.
If the start and end point are the same point or are points on the same line through the ellipse centre then a complete unfilled ellipse is drawn.
|
|
All the fillable shape drawing primitives, except
DrawPolygon(), either use a rectangle directly or use it to define
the position of an ellipse. This rectangle is passed as an argument of type
TRect.
The outlines are drawn with the pen, and the shapes are filled with the brush. Set the pen or brush to null to omit drawing of either component. All shapes are clipped to the current clipping region.
Shapes are filled using the brush, and thus subject to the brush
style (colour, hash or pattern) and brush pattern origin. The effective fill
colour depends on the drawing mode. The brush style should be set to
TBrushStyle::ENullBrush if no fill is required.
The outlines of fillable shapes are drawn with the pen, and thus
subject to pen colour, pen size and pen style settings. The effective outline
colour depends on the drawing mode. Straight lines are drawn between vertexes
in the same way that lines are drawn using DrawLine(), with each
point being drawn only once, (see SetPenSize() for a discussion of
line size effects). If the pen size has been set to greater than or equal to
half the size of the shape then the shape will be filled with solid pen colour.
The pen style should be set to TPenStyle::ENullPen if no outline
is required.
There are five shape drawing primitives: pie slice, ellipse, rectangle, rounded rectangle, and polygon. All may be drawn with or without an outline.
virtual void DrawRect(const TRect& aRect)=0;
Draws and fills a rectangle.
|
virtual void DrawEllipse(const TRect& aRect)=0;
Draws and fills an ellipse.
The ellipse is drawn inside the rectangle defined by the
TRect argument. Any rectangle that has odd pixel dimensions, has
the bottom right corner trimmed to give even pixel dimensions before the
ellipse is constructed.
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.
|
virtual void DrawRoundRect(const TRect& aRect,const TSize& aCornerSize)=0;
Draws and fills a rectangle with rounded corners.
The rounded corners are each constructed as an arc of an ellipse.
The line drawn by the pen, if any, goes inside the specified rectangle.
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.
|
virtual void DrawPie(const TRect& aRect,const TPoint& aStart,const TPoint& aEnd)=0;
Draws and fills a pie slice.
The pie slice is an area bounded by:
the arc of an ellipse drawn in an anticlockwise direction from the start point to the end point
the straight line drawn to the start point from the geometric centre of the ellipse.
the straight line to the end point from the geometric centre of the ellipse.
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.
The line drawn by the pen goes inside the specified rectangle.
The pixels at the end point of the arc are not drawn.
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 touches 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 the specified start or end point is at the centre of the ellipse, then the line that defines the start or end of the arc defaults to one extending vertically above the centre point.
If the start and end point are the same point or are 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.
|
virtual TInt DrawPolygon(const CArrayFix<TPoint>* aPointList,TFillRule aFillRule=EAlternate)=0;
Draws and fills a polygon defined using an array of points.
The first point in the array defines the start of the first side of the polygon. The second point defines the second vertex (the end point of the first side and the start point of the second side).
The final side of the polygon is drawn using the last point from the array, and the line is drawn to the start point of the first side.
Self-crossing polygons are filled according to the specified fill rule.
|
|
virtual TInt DrawPolygon(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule=EAlternate)=0;
Draws and fills a polygon defined using a list of points.
The first point in the list defines the start of the first side of the polygon. The second point defines the second vertex (the end point of the first side and the start point of the second side).
The final side of the polygon is drawn using the last point from the list, and the line is drawn to the start point of the first side.
Self-crossing polygons are filled according to the specified fill rule.
|
|
|
virtual void DrawText(const TDesC& aString,const TPoint& aPosition)=0;
Draws text without a surrounding box.
The text baseline is aligned with the y co-ordinate of the specified point, and the left end of the text is aligned with the left end of the text.
Note:
Text drawing is done with the pen, and is subject to the pen colour. The effective text colour also depends on the drawing mode. The size and style of the text depends on the font used. The layout of the text depends on the justification mode set.
|
virtual void DrawText(const TDesC& aString,const TRect& aBox,TInt aBaselineOffset,TTextAlign aHoriz=ELeft,TInt aLeftMrg=0)=0;
Draws text inside a box.
The surrounding box is filled with the current brush colour
(not a pattern) and is drawn without any outline. The effective box colour
depends on the drawing mode — if a brush colour has not been set
then the brush defaults to white. The brush may be set to
TBrushStyle::ENullBrush if text positioning relative to a box is
required, but the box should not be filled.
The font used is that set by UseFont(). If no font
is in use then a panic occurs.
The alignment of the text within the box can be specified.
Text drawn within a box is also clipped to that box. Unless you
intend to clip the top off the text, aBaselineOffset should be
greater than or equal to the ascent of the current font.
Offsets:
If the offset is negative, zero, or less than font height this is handled as would be expected, i.e. no text will be seen in the box in the first two instances, and the top of the text will be clipped in the latter case.
Margins:
For the drawing of right-aligned text, aMargin
indicates the margin from the right of aBox — where a
positive value results in a leftwards offset.
Negative margins can be used to display portions of the text string clipped by the box. A negative margin for left aligned text would clip the start of the text string. Similarly, a negative margin for right aligned text would clip the end of the text string.
If the margin is greater than the width of the box then no text will be visible.
The margin is still honoured for centred text — centred text will not be centred in the box, unless the margin is zero.
Note:
Text drawing is done with the pen, and is thus subject to the pen colour. The effective text colour also depends on the drawing mode. The size and style of the text depends on the used font. The layout of the text depends on the justification mode set.
|
virtual void DrawText(const TDesC& aString,const TPoint& aPosition,const TDrawTextParam& aParam);
Supported from 6.0
Reserved for future use.
|
The actual ‘real world’ size of a bitmap is given in twips. A bitmap also has x and y dimensions in pixels. There are therefore two ways that a bitmap can be drawn to a graphics device:
starting at a certain point, stretched or compressed to its size in twips
stretched or compressed to fit a rectangle of a given size and position
virtual void DrawBitmap(const TPoint& aTopLeft,const CFbsBitmap* aSource)=0;
Draws a bitmap at the specified point.
The point specifies the top left hand corner of the bitmap. The bitmap is compressed or stretched based on its internally stored size in twips.
Notes:
This member function uses the bitmap's size in twips and does a stretch/compress blit using a linear DDA.
As this function scales the bitmap, it is unavoidably slow.
Therefore, where possible, use CBitmapContext::BitBlt() instead.
If the bitmap has to be scaled, consider creating another bitmap along with an
CFbsBitmapDevice etc., doing DrawBitmap() once and
using BitBlt() subsequently.
Note that all bitmaps are clipped to the device boundaries.
|
virtual void DrawBitmap(const TRect& aDestRect,const CFbsBitmap* aSource)=0;
Draws a bitmap to fit a given rectangle.
The bitmap is compressed or stretched based on its internally stored size in pixels.
Notes:
This member function uses the bitmap's size in pixels and does a stretch/compress blit using a linear DDA.
As this function scales the bitmap, it is unavoidably slow.
Therefore, where possible, use CBitmapContext::BitBlt() instead.
If the bitmap has to be scaled, consider creating another bitmap along with an
CFbsBitmapDevice etc., doing DrawBitmap() once and
using BitBlt() subsequently.
Note that all bitmaps are clipped to the device boundaries.
|
virtual void DrawBitmap(const TRect& aDestRect,const CFbsBitmap* aSource,const TRect& aSourceRect)=0;
Draws a specified rectangle of a source bitmap to fit into a given destination rectangle.
Notes:
This member function uses rectangle sizes in pixels and does a stretch/compress blit using a linear DDA.
As this function scales the bitmap, it is unavoidably slow.
Therefore, where possible, use CBitmapContext::BitBlt() instead.
If the bitmap has to be scaled, consider creating another bitmap along with an
CFbsBitmapDevice etc., doing DrawBitmap() once and
using BitBlt() subsequently.
Note that all bitmaps are clipped to the device boundaries.
|
|
TBrushStyle
Brush styles.
|
TDrawModeComponents
Drawing mode components.
This enum is not intended to be used directly, but provides
components for the easy specification of drawing modes in the
TDrawMode enum.
|
TDrawMode
Drawing modes.
This enum builds on the drawing mode components in the
TDrawModeComponents enum.
If the pen colour is p, brush colour is
b and screen colour is s, the effect of
TDrawMode::EDrawModeAND is P=p&s and
B=b&s. In other words, the effective colour of the pen on the
screen, P, is that produced by the bitwise ANDing of the current
screen colour and the current pen colour. The effect is similar for the
effective brush colour, B.
The effective pen and brush colour are given in the table using the key
Inputs: pen colour is p, brush colour is b and screen colour is s
Outputs: effective brush colour is B, effective pen colour is P.
|
TFillRule
Rules used to fill self crossing polygons.
The filling of a polygon proceeds as follows: for a given point in the polygon, then
if the rule is TFillRule::EAlternate (default)
and it has an odd winding number, then fill the surrounding area.
if the rule is TFillRule::EWinding and it has
a winding number greater than zero, then fill the surrounding area.
|
TPenStyle
Pen styles. The screen pattern unit in each definition below describes the pattern drawn by the line — 1 represents a pixel drawn, 0 represents a pixel that is not affected.
|
TTextAlign
Text alignment.
|
TDrawTextParam
Supported from 6.0
Reserved for future use.
Copyright ©2002 Symbian Ltd. 6.1-00174 |
|
![[Top]](../../../stock/arrow_up_2.gif){kind=icon}
![[Top]](../../../stock/arrow_up.gif){kind=icon}