BrushChanged is a procedure used to perform actions needed when the Brush for the canvas is changed. BrushChanged ensures that state flags for the class instance are updated to remove the value csBrushValid (when present).

ABrush contains the Brush instance which generated the change notification.

BrushChanged is assigned as the OnChange event handler in the TBrush instance used in the Brush property.

FontChanged is a procedure used to performs actions needed when the Font for the canvas is changed. FontChanged ensures that state flags for the canvas are updated to remove the value csFontValid (when present).

AFont is the font instance which generated the change notification.

FontChanged is assigned as the OnChange event handler in the TFont instance used in the Font property.

PenChanged is a procedure used to performs actions needed when the Pen for the canvas is changed. PenChanged ensures that state flags for the canvas are updated to remove the value csPenValid (when present).

APen is the pen instance which generated the change notification.

PenChanged is assigned as the OnChange event handler in the TPen instance used in the Pen property.

RegionChanged is a procedure used to perform actions needed when the Region for the canvas is changed. RegionChanged ensures that state flags for the canvas are updated to remove the value csRegionValid (when present).

ARegion is the region instance which generated the change notification.

RegionChanged is assigned as the OnChange event handler in the TRegion instance used in the Region property.

DoCreateDefaultFont is an overridden method in TCanvas used to create the TFont instance used as the default font for the canvas. The return value contains the TFont instance created in the method.

DoCreateDefaultFont implements the abstract method defined in the TFPCustomCanvas ancestor. It is called from the inherited CreateDefaultFont method, and ensures that a font resource has been allocated for the Font property.

SetColor is a method used to set the value for the indexed Colors property. SetColor implements the abstract virtual method defined in the TFPCustomCanvas ancestor. Equivalent to setting the color value using the Pixels property.

Uses the indexed Pixels property to retrieve the color information for the pixel at the coordinates in x and y. Calls TColorToFPColor to convert the TColor value to the TFPColor type used in the return value.

If a valid Handle for the canvas instance has not been allocated, the value for the property is 0 (zero).

Re-implements the method defined in the TFPCustomCanvas ancestor. Calls MoveTo using the X and Y coordinates specified in Value. Does not call the inherited method.

DoEllipse draws an Arc of 360 degrees within given Bounds, making an ellipse.

Calls the PolyBezier method using the values in Points, NumPts, Filled, and Continuous as arguments.

DoCopyRect checks that SrcCanvas is of correct type then copies coordinates and calls CopyRect.

Overrides the method defined in the TFPCustomCanvas ancestor. Calls the inherited method. Handles conversion of the logical coordinates in the clipping rectangle to device coordinates, and sets the clipping region to the converted values.

CreateBrush is a procedure used to create and/or configure handles for the canvas Brush.

SelectObject is called to get an existing Brush handle, and save a copy of the handle for local access in the canvas. Canvas state flags are updated to indicate that the Brush handle is valid.

The styles stored in Brush are checked for hatched-style brushes. When no hatch styles are used, the background color for the canvas is set to the color specified in Brush. If the Brush style is bsSolid, the background mode is set to OPAQUE. Otherwise, the TRANSPARENT background mode is used.

Gets the handle for the Font from its Reference class. The first time the Font handle is selected, the handle for the default font is returned as saved for use with DeselectHandles.

CreateFont updates the state flags for the canvas to include the value csFontValid. SetTextColor is called to apply the color from the Font to the canvas Handle.

CreateHandle has an empty implementation in TCanvas.

CreatePen is a procedure used to create, configure and position the pen for the canvas.

CreatePen calls SelectObject to get the Handle for the Pen, and saves a copy for local access in the class instance. The MoveTo method is called to position the Pen to the coordinates in the PenPos property. Canvas state flags are updated to indicate that the handle for the Pen is valid.

CreatePen is called when RequiredState is used to check for a valid pen handle.

CreateRegion is a procedure used to ensure that the handle for the rectangular Region in the canvas is valid.

CreateRegion calls SelectObject to the get the handle for the Region, and saves a local copy for access in the class instance. Canvas state flags are updated to indicates that the handle for the Region is valid.

CreateRegion is declared as a virtual method, and may be overridden in descendant classes.

Ensures that canvas state flags indicate both the handle and the pen handle are valid. No actions are performed in the method if either handle is not valid.

Removes the value csPenValid from the canvas state flags, and selects the saved pen handle in the class instance. The internal copy of the saved pen handle is set to 0.

FontChanging is assigned as the OnChanging event handler for the Font property in the constructor for the class instance. It allows the canvas class to be notified and updated when a new font is assigned to the canvas.

FontChanging ensures that both the Handle and the Font for the canvas are valid. No actions are performed in the method if State does not contain the values csFontValid and csHandleValid. It removes csFontValid from the States property and reselects the handle for the Font in the control.

BrushChanging is assigned as the OnChanging event handler for the Brush property in the constructor for the class instance. It allows the canvas class to be notified and updated when a new brush is assigned to the canvas.

BrushChanging ensures that both the Handle and the Brush for the canvas are valid. No actions are performed in the method if State does not contain the values csBrushValid and csHandleValid. It removes csBrushValid from the States property and reselects the handle for the Brush in the control.

RegionChanging is assigned as the OnChanging event handler for the Region property in the constructor for the class instance. It allows the canvas class to be notified and updated when the region for the canvas is modified.

RegionChanging ensures that both the Handle and the Region for the canvas are valid. No actions are performed in the method if State does not contain the values csRegionValid and csHandleValid. It removes csRegionValid from the States property and reselects the handle for the Region on the control.

RealizeAutoRedraw is called when a new value for the AutoRedraw property is assigned. No actions are performed in the method when AutoRedraw is False, or when the Handle for the canvas has not been allocated.

RealizeAutoRedraw calls the DCRedraw method in the widgetset class using the value in Handle as the device context.

RealizeAntialiasing is called when a new value has been assigned to the AntialiasingMode property. No actions are performed in the method if the Handle has not been allocated for the canvas.

RealizeAntialiasing uses the value in AntialiasingMode to determine the action required in the method.

amOn

Calls DCSetAntialiasing in the widgetset to enable anti-aliasing for the Handle.

amOff

Calls DCSetAntialiasing in the widgetset to disable anti-aliasing for the Handle.

amDontCare

Calls DCSetAntialiasing using the default capabilities for the widgetset.

RequiredState is a procedure used to ensure that the canvas state flags include the values specified in the ReqState parameter. The TCanvasStates values represent handles that must be allocated for the canvas.

When a state value is not present in the flags, the corresponding routine used to create the required handle is called.

csHandleValid

Calls CreateHandle, and raises an EInvalidOperation if the handle could not be allocated. Sets the AntialiasingMode for the canvas. Includes csHandleValid in the canvas state flags on success.

csFontValid

Calls CreateFont, and includes csFontValid in the canvas state flags on success.

csPenValid

Calls CreatePen. Includes csBrushValid in the canvas state flags when the Pen style is a Brush pattern (psDash, psDot, psDashDot, psDashDotDot). Includes csPenValid in the canvas state flags on success.

csBrushValid

Calls CreateBrush. Includes csBrushValid in the canvas state flags on success.

RequiredState is called from method implementations prior to performing an operation which requires a specific canvas state (or handles).

De-selects any existing handles in the class instance, and sets the new value for the property. Applies the anti-aliasing mode when the handle is valid. Updates the state flags for the canvas.

FreeHandle is a procedure used to free the Handle for the canvas. FreeHandle sets the value in Handle to 0 (zero) to indicate that it is unassigned.

Create is the constructor for TCanvas. It calls the inherited Create method and sets defaults for many properties and actions.

It also initializes Font, Pen, and Brush properties and assigns their event handlers. It sets default values for Alignment, Layout, Clipping and Opacity.

Destroy is the destructor for TCanvas. It frees handles and regions, and calls the inherited Destroy method, sets font, pen and brush resources to Nil in the TCanvas class instance and makes its resources available.

Calls the LockCanvas method in the TFPCustomCanvas ancestor.

Calls the UnlockCanvas method in the TFPCustomCanvas ancestor.

Calls DeselectHandles to reset the handles to their default values. Requires a valid Handle for the canvas. Saved handles for the Pen, Brush, and Font are released.

Changing is called in methods which perform drawing operations, and occurs before the actions that affect the handles or settings for the canvas.

Changed is called in methods which perform drawing operations, and occurs after the actions that affect the handles or settings for the canvas have been completed.

SaveHandleState is used in the LCL instead of direct calls to SaveDC and RestoreDC in widgetset classes. Used along with RestoreHandleState. It allows multiple device contexts to be captured and handled in a LIFO fashion.

Use Arc to draw an elliptically curved line with the current Pen. Arc is re-introduced in TCanvas to provide additional overloads for the method found in the platform-specific LCL interface object. Parameter values passed to the overloaded methods are in turn passed to the widgetset class for the platform.

ALeft, ATop, ABottom, and ARight represent the canvas bounds in which the drawing operation is performed.

One variant of the method provides the Angle16Deg and Angle16DegLength arguments.

Angle16Deg contains the central angle which defines the direction for the arc endpoint. Positive values indicate a counter-clockwise direction.Zero degrees lies at the 3 o'clock position. These value is expressed in 1/16ths of a degree. For example, a full circle equals 5760 (16*360) increments.

Angle16DegLength contains the arc length used to determine the over-all circumference of the circle for with the arc is a segment.

Another variant provides the SX, SY and EX, EY arguments representing the starting and ending radial points between which the Arc is drawn.

Like the Arc method, but updates the Pen position.

AngleArc is a method used to draw an arc over a specified angle along the circumference of a circle with given radius and center point.

X and Y contain the coordinates for the center of the circle along which the arc is drawn.

Radius is the distance from the center point of the circle to the circumference where the arc is drawn. The LongWord type can contain positive integer values in the range 0..4294967295.

StartAngle and SweepAngle indicate where the arc is drawn on the circumference of the circle. The angle values are specified in degrees.

StartAngle contains the angle from the center of the circle to the starting point on the circumference. Its value is relative to the X-Axis and increments in the counter-clockwise direction.

SweepAngle defines the length of the arc expressed in degrees, and is used to find the ending point for the arc. Its value is relative to the starting point, and increments in the counter-clockwise direction.

Before the arc is drawn, LineTo is used to drawn a line from the current pen position to the starting point of the arc.

The Arc method is called to render the arc using the center point, radius, starting point, and ending point values.

After the arc is drawn, the Pen position is moved to the ending point for the arc.

Update values for the Pen style, mode, color or width prior to calling the method.

The end result is that pixels copied from ABitmap using the color in ATransparentColor are replaced with the brush color for the canvas. This makes the copied area in ASourceRect partially transparent when applied to ADestRect.

Pixels colors from ASourceRect are applied to a temporary image, and the StretchDraw method is called to draw the copied rectangle onto the canvas.

Set the Color property in Brush before calling the method.

Use Chord to draw a filled Chord shape on the canvas.

The angles angle1 and angle2 are 1/16th of a degree. For example, a full circle equals 5760 (16*360).

Positive values of Angle and AngleLength mean counter-clockwise while negative values mean clockwise direction. Zero degrees is at the 3 o'clock position.

Alternatively the starting and ending points may be specified as radial points (sx, sy, ex, ey).

CopyRect is a method used to copy a rectangular area from another TCanvas instance to the specified location on the canvas instance.

No actions are performed in the method if SrcCanvas has not been assigned, or when the width or height in either Source or Dest is zero (0) pixels.

CopyRect calls the StretchBlt routine in the LCL interface to expand or shrink the content in Source to the dimensions in Dest. The CopyMode property provides the raster operation for the block transfer.

CopyRect calls Changing to signal an assigned OnChanging event handler prior to the block transfer. CopyRect calls Changed to signal an assigned OnChange event handler immediately after to the block transfer.

Draw is reintroduced method in TCanvas; it reimplements the inherited method to use the TGraphic instance in SrcGraphic as the container with the image content drawn in the method.

No actions are performed in the method if SrcGraphic has not been assigned.

Draw calls the StretchDraw method to render the content in SrcGraphic on the canvas at the position specified in X and Y. The Width and Height in SrcGraphic set the bounds for the image rectangle applied to the canvas using StretchDraw. Since a stretch mode is not enabled when StretchDraw is called, the source graphic is not enlarged or shrunk to the canvas size. The source graphic is clipped if its bounds exceeds the canvas bounds. The Draw method in SrcGraphic performs the actions needed to position and rendering the content to the Pixels in the canvas.

CopyMode determines the raster operation performed for the Pixels affected on the canvas.

Calling Draw causes the OnChanging and OnChange events to be signalled (when assigned). OnChanging occurs prior to calling Draw in the TGraphic instance. OnChange occurs after calling Draw in the TGraphic instance.

DrawFocusRect is a method used to draw a focus rectangle around the rectangular region specified in ARect.

DrawFocusRect calls Changing to signal an assigned OnChanging event handler prior to drawing the focus rectangle. It calls Changed to signal an assigned OnChange event handler immediately after drawing the focus rectangle.

DrawFocusRect calls the DrawFocusRect routine in the LCL interface to perform the drawing opertation using the Handle for the canvas.

StretchDraw is a reintroduced method in TCanvas; it reimplements the inherited method to use the specified TGraphic content in the drawing operation instead of a TFPCustomImage instance.

No actions are performed in the method if SrcGraphic has not been assigned.

DestRect provides the rectangular area on the canvas where the graphic content is drawn. The Draw method in SrcGraphic is called to draw the image content onto the canvas instance. If the dimensions in DestRect differ from the Width or Height in SrcGraphic, the imgae content is expanded or contracted to fit the destination rectangle. This may causes the aspect ratio for the image content to be changed.

StretchDraw calls Changing to signal an assigned OnChanging event handler immediately before the drawing operation. It calls Changed to signal an assigned OnChange event handler when the drawing operation has been completed.

Ellipse is an overloaded, reintroduced method in TCanvas used to draw a filled ellipse shape. The overloaded variants allow the shape to be defined either as a rectangular area where the shape is drawn, or by using Integer coordinates to establish the major and minor axis for the shape.

ARect is the TRect instance with the bounds for the shape.

x1, y1, x2, and y2 allows the bounds for the shape to be specified as Integer values.

The bounds are used to calculate the vertex, co-vertex, linear eccentricity and focal points for the shape.

When the bounds area is a square, the resulting shape is a circle.

Ellipse calls the Ellipse routine in the LCL interface to perform the drawing operation.

FillRect is an overloaded method used to fill a rectangular area on the canvas using the style, color, or bitmap defined in Brush. The overloaded variants allow the vertices for the rectangle to be specified as either:

• Four separate Integer coordinates representing the top/left and bottom/right of the shape.
• A TRect instance where the vertices are represented as either four Integers, two TPoint instances for TopLeft and BottomRight, or a vector using the TArray4IntegerType.

FillRect calls the routine in the LCL interface used to implement the method for a specific widgetset.

Use Rectangle to draw a filled rectangle with borders. Use FloodFill to fill a rectangular area bounded by a specified color value.

FloodFill is a method used to fill the area at the point specified in X, Y with the style, color, or bitmap defined in Brush.

FillColor contains the color value for the boundary of the fill, or the area to be filled, depending on the value in FillStyle.

FillStyle determines the type of fill operation performed in the method. For example:

fsBorder

The fill area is bounded by pixels with the color specified in FillColor. Pixels are filled in all directions with the Brush until the a pixel with the specified color is found.

fsSurface

The fill area is defined as the color specified in FillColor. Pixels with this color are filled in all directions with the Brush until no more pixels with this color are found.

Please note that comments in the TGraphicsFillStyle source code have these conditions reversed.

FloodFill calls the routine in the LCL interface used to implement the method for the widgetset. The return value from the LCL interface is ignored.

Frame3D is an overloaded method used to draw a frame for the specified rectangle with a 3-dimensional appearance. It draws the frame using the Brush for the canvas with the style, colors, and size passed in the parameter values. Frame3D does not fill the inner area for the rectangle; it draws the frame or borders only.

ARect is the TRect instance with the bounds where the drawing operation is performed. It is a variable parameter updated in the method to return the inner area for the rectangle without the frame area.

The overloaded variants allow the drawing style and size for the 3-dimensional frame to be specified.

Style contains a value from the TGraphicsBevelCut enumeration and is used when a beveled frame is desired.

TColor values can be provided to use colors to simulate 3-Dimensional relief. TopColor is the color used to draw the top and left edges on the frame. BottomColor is used to draw the bottom and right edges on the frame. System colors like cl3DLight, cl3DHilight, cl3DDkShadow, cl3DShadow, and cl3DFace are commonly used in these parameters.

FrameWidth contains the thickness for the 3-D frame; for left and right edges it is the border width, for top and bottom edges it is the border height. The bounds in ARect are inflated by this value before exit.

Frame is method used to draw a border or frame for the specified rectangle use the Pen for the canvas. Overloaded variants of the method are provided which allow the rectangle to be specified as:

• Four separate Integer coordinates representing the top/left and bottom/right of the rectangle.
• A TRect instance where the vertices are represented as either four Integers, two TPoint instances for TopLeft and BottomRight, or a vector using the TArray4IntegerType.

Frame sets the Style property in Brush to bsClear. This suppresses filling the interior of the rectangle with the Color for the Brush. In others words, the area in side the frame is transparent. The Brush style is restored to its previous value prior to exit.

Frame calls the Rectangle method to draw the borders on the frame using the Pen for the canvas.

Set property values in Pen prior to calling the method, including:

• Mode
• Style
• Color
• Width
• JoinStyle
• EndCap

FrameRect is an overloaded method used to draw a frame or border for the specified rectangular area using the Brush for the canvas. Overloaded variants allow the bounds for the rectangle to be defined using:

Four separate Integer values representing the Top/Left and Bottom/Right coordinates for the rectangle.

A TRect instance where the vertices are represented as either four Integers, two TPoint instances for TopLeft and BottomRight, or a vector using the TArray4IntegerType.

FrameRect draws the border for the shape using the style, color, or bitmap defined in Brush. The drawing operation is always performed using a 1 pixel width / height.

FrameRect calls the routine in the LCL interface which implements the method for the widgetset. The return value from the LCL interface is ignored.

Use Frame to draw borders on a rectangle using the Pen for the canvas. Use Frame3D to draw borders using a specified bevel style or colors which simulate 3-dimensional relief.

Calls RequiredState to check state flags for the canvas, and ensure that the Handle and the Font are valid. RequiredState raises an Exception if the Handle for the canvas is not valid.

Calls GetTextMetrics in the LCL interface to retrieve the ascender, descender, and height metrics for the canvas Handle. The values are assigned to members in the TM output argument.

The return value is True when text metrics were successfully retrieved from the widgetset.

GradientFill fills the area inside the specified rectangle using a color gradient with the specified start and stop colors.

No actions are performed in the method when ARect has no discernible area; both the calculated height and width for the rectangle are 0 or a negative number.

The direction for the color gradient is specified in the ADirection argument. gdVertical causes the color variations to be drawn from top to bottom in the rectangle starting with the color in AStart and ending with the color in AStop. gdHorizontal causes the color variations to be draw from left to right in the rectangle, also starting with the color in AStart and ending with the color in AStop.

GradientFill decomposes color values in AStart and AStop into their Red, Green, and Blue component values. The differences between the byte values are varied evenly in the color gradient, and drawn as colored lines oriented in the direction opposite to the color gradient. The color setting in Pen is updated, and LineTo is used to draw the number of 1 pixel lines available in the gradient direction.

Please note that the settings in Pen are not stored on entry, or restored prior to exiting from the method. The Pen color will contain the color in AStop on exit.

Use FloodFill to fill a rectangular area bounded by or filled with a specified color value. Use FillRect to fill a rectangular area with the Brush for the canvas.

Use Pie to draw a filled pie-shaped wedge on the canvas.

The angles StartAngle16Deg and Angle16DegLength are 1/16th of a degree. For example, a full circle equals 5760 (16*360).

Positive values in StartAngle16Deg means counter-clockwise while negative values mean clockwise direction. Zero degrees is at the 3 o'clock position.

Pie is a method used to draw a filled Pie-shaped wedge on the canvas. The pie is part of an ellipse between the points EllipseX1, EllipseY1, EllipseX2, EllipseY2. The values StartX, StartY and EndX, EndY represent the starting and ending radial-points between which the Bounding-Arc is drawn.

Use Polybezier to draw cubic Bézier curves.

The first curve is drawn from the first point to the fourth point with the second and third points being the control points.

If the Continuous flag is True then each subsequent curve requires three more points, using the end-point of the previous Curve as its starting point, the first and second points being used as its control points, and the third point its end-point.

If the Continuous flag is set to False, then each subsequent curve requires 4 additional points, which are used exactly as in the first curve.

If the Filled flag is set to True then a straight line is drawn from the last connected point to the starting point, and the entire curve is filled with the current brush.

Any additional points which do not add up to a full Bézier (4 for Continuous, 3 otherwise) are ignored. There must be at least 4 points to be connected.

Use Polygon to draw a closed, many-sided shape on the canvas, using the Pen for the canvas. After drawing the complete shape, Polygon fills the shape using the canvas Brush.

The Points parameter is an array of points that give the vertices of the polygon.

Winding determines how the polygon is filled. When Winding is True, Polygon fills the shape using the Winding fill algorithm.

When Winding is False, Polygon uses the even-odd (alternative) fill algorithm.

StartIndex gives the index of the first point in the array to use. All points before this are ignored.

NumPts indicates the number of points to use, starting at StartIndex.

If NumPts is -1 (the default), Polygon uses all points from StartIndex to the end of the array. The first point is always connected to the last point.

To draw a polygon on the canvas without filling the internal area, use the Polyline method specifying the first point a second time at the end of the line.

Use Polyline to connect a set of points on the Canvas. If you specify only two points, Polyline draws a single line. The Points parameter is an array of points to be connected.

StartIndex identifies the first point in the array to use.

NumPts indicates the number of points to use. If NumPts is -1 (the default), PolyLine uses all the points from StartIndex to the end of the array.

Calling the MoveTo function with the value of the first point, and then repeatedly calling LineTo with all subsequent points will draw the same image on the canvas. However, unlike LineTo, Polyline does not change the values in PenPos.

Rectangle is an overloaded method reintroduced in TCanvas. It is used to draw a rectangular shape on the drawing area for the canvas. The overloaded variants allow the coordinates to be specified as either:

• Four separate Integer values representing the top, left, bottom, and right vertices for the shape (X1, Y1, X2, Y2).
• A TRect instance where the vertices are represented as either four Integers, two TPoint instances for TopLeft and BottomRight, or a vector using the TArray4IntegerType (Rect).

Rectangle draws an outline (or borders) for the shape using the mode, style and width defined in Pen. The rectangle is also filled using the style, color and/or bitmap defined in Brush.

Use FillRect to fill a rectangular area with the current Brush without drawing its borders. Use FrameRect to draw the borders for the shape using the current Brush without filling the interior. Use Frame to draw borders for the shape using the current Pen and a clear Brush for the interior.

Rectangle calls the routine in the LCL interface used to implement the method for the current widgetset.

RoundRect is an overloaded method in TCanvas used to draw a rectangle with rounded (or radiused) corners. The overloaded variants allow the coordinates to be specified as either:

• Four separate Integer values representing the top, left, bottom, and right vertices for the shape (X1, Y1, X2, Y2).
• A TRect instance where the vertices are represented as either four Integers, two TPoint instances for TopLeft and BottomRight, or a vector using the TArray4IntegerType (Rect).

RX and RY contain the width and height (respectively) for an ellipse used to draw arc segments for the rounded corners on the rectangular shape.

RoundRect (like Rectangle) draws an outline (or borders) for the shape using the mode, style and width defined in Pen. The rounded rectangle is also filled using the style, color and/or bitmap defined in Brush.

RoundRect calls the routine in the LCL interface used to implement the method for the current widgetset.