Instructions, help and resources

Getting started

The TReportPrinter Component encapsulates a printing system with optional Preview

Output to Printer and save to images is supported.

Other output options are under development however for output to PDF it is currently recommended to use a PDF printer such as Bullzip.

Page structure

Page structure is available to assist the developer to control text flow however the print Cursor can access the whole print Canvas for text and graphics regardless of the current report band or other formatting.

Each page has 3 bands: Header, Footer and Body.
The print Cursor is positioned at the top left of each band at the start of the relevant OnPrintHeader, OnPrint (or OnPrintPage) or OnPrintFooter event.

Inside each report band you can set any number of text columns that will fit between the left and right margins.
There will always be a minimum of one column so that "ClearColumns" will set a single column occupying the width between the margins and for the remaining height of the current report band (or until a call to "SetColumns" is made).

TabStops can be set within a column relative to the left edge of the column.

Incompatibilities with RaveReports

Whilst most commonly used methods are code compatible, a number are deprecated in order to help with project migration to Firemonkey. The compiler "hints" will assist you with locating and updating deprecated methods.

The Sender parameter passed in the various OnPrintxx events is TBaseReport, not TObject so you will need to replace "TObject" with "TBaseReport" to enable the HBReports TReportPrinter events to point to your TRvSystem event methods.

TabStops start from the Left edge of the Current Column so the first TabStop Left will be 0 or NA rather than MarginLeft.

The final parameter of the SetTab method is the fill color not the fill shade.
You will need to find all your calls to SetTab and replace the final parameter. Use NA or no parameter for a transparent tab cell. Whilst you are doing this you should replace the deprecated Boxlines Word parameter to a TSides parameter.

For RaveReports

TBaseReport(Sender).SetTab(MarginLeft, pjLeft, 2, 0.1, 0, 0);
TBaseReport(Sender).SetTab(NA, pjLeft, 2.5, 0.1, 3, 50);

For HBReports

Sender.SetTab(0, pjLeft, 2, 0.1, [], NA);
Sender.SetTab(NA, pjLeft, 2.5 0.1, [TSide.Left, TSide.Right], TColor.clLightGrey);
// pjLeft deprecated: use TPrintJustify.Leading

TReportPrinter Component Usage

Click the properties and methods below for detailed information including C++ Builder syntax.

The following Properties are published

The initial settings at the start or a print job:

  property DefaultFill: TBrush;

  property DefaultFont: TFont;

  property DefaultPaperSize: TPrintPaperSize;

  property DefaultStroke: TPen;

  property LineHeightMethod: TLineHeightMethod;

  property LineHeightProperty: TAbstractLineHeight;

Set the height of the Header and Footer and if to print on the first page:

  property Header: TReportHeaderFooter;

  property Footer: TReportHeaderFooter;

Page margins may be increased by the print job if they are less than the print device capability:

  property MarginBottom: Single read FMarginBottom write SetMarginBottom;

  property MarginLeft: Single read FMarginLeft write SetMarginLeft;

  property MarginRight: Single read FMarginRight write SetMarginRight;

  property MarginTop: Single read FMarginTop write SetMarginTop;

Set the following False for silent printing:

  property ShowPreview: Boolean;

  property ShowPrintDialog: Boolean;

Other properties

  property StatusLabel: TLabel;

  property Title: string;

The position and dimension Units used in the report (Inch, Centimeter or Millimeter):

  property Units: TPrintPageUnits;

Published Events

The Events are called for the Prieview pass and again when the report is output to the print device.


For your initialisation and clean-up code. The print canvas is not available:

  property OnBeforePrint: TPrintNotifyEvent;

  property OnAfterPrint: TPrintNotifyEvent;

Put your report code inside the following "OnPrint" events. The preview or print Canvas is available:

  property OnPrintHeader: TPrintNotifyEvent;

  property OnPrint: TPrintNotifyEvent;

  property OnPrintPage: TPrintPageEvent;

  property OnPrintFooter: TPrintNotifyEvent;

  property OnNewColumn: TPrintNotifyEvent;

  property OnNewPage: TPrintNotifyEvent;

Use "OnPrint" for reports where the content is different on each page. Call "NewPage" within "OnPrint" to create each new page.

Use "OnPrintPage" for tabulation reports where for instance you may be writing out the rows in one or more data tables.
Check "LinesLeft" after printing each row and return "True" if there are more pages to be printed.

If you do not define OnPrintHeader or OnPrintFooter then the whole page is available for the report Body band and the Header/Footer heights are ignored.

Executing and stopping the report.

Call function Execute: Boolean; to run a print job. This will generate a Preview and then output the report to the print device using the "OnPrint" events.

You can provide the user with the option to stop the report. Call procedure Abort; to set the Aborted flag to True and send Abort to the printer device if it is active.
Check Aborted within the "OnPrint" event implementation to see if the user stopped the report.

Report creation using the "OnPrint events": OnPrintHeader, OnPrint (or OnPrintPage) and OnPrintFooter.

The following properties are available to the active print job.

  property Aborted: Boolean;

  property BackgroundColor: TColor;

  property Body: TReportBody read FBody;

  property Bold: Boolean;

  property BoxLineColor: TColor;

  property Canvas: TCanvas;

  property ColumnNum: Integer;

  property Columns: Integer;

  property CurrentColumn: TReportColumn;

  property CurrentPage: Integer;

  property CursorXPos: Single;

  property CursorYPos: Single;

  property FontColor: TColor;

  property FontName: string;

  property Fonts: TStrings;

  property FontSize: Single;

  property Italic: Boolean;

  property LineHeight: Single;

  property LineNum: Integer;

  property LinePaddingByFont: Single;

  property LinesPerInch: Single;

  property MinMarginBottom: Single;

  property MinMarginLeft: Single;

  property MinMarginRight: Single;

  property MinMarginTop: Single;

  property Orientation: TPrinterOrientation;

  property PageCount: Integer;

  property PageHeight: Single;

  property Pages: TObjectList;

  property PageWidth: Single;

  property Printing: Boolean;

  property ReportDateTime: TDateTime;

  property StatusText: string;

  property Strikeout: Boolean;

  property Underline: Boolean;

  property XDPI: Integer;

  property YDPI: Integer;

The following methods are available to the active print job.

  procedure Arc(const Left, Top, Right, Bottom, StartX, StartY, EndX, EndY: Single);

  procedure Arc(const Center: TPointF; Radius, StartAngle, SweepAngle: Single);

  procedure ClearColumns;

  procedure ClearTabs;

  function ColumnLinesLeft: Integer;

  procedure Cr;

  procedure CrLf;

  procedure DrawRectangleSides(const ARect: TRectF; const ASides: TSides; const Stroke: TPen);

  procedure Ellipse(const Left, Top, Right, Bottom: Single; const FillColor: TColor);

  

  procedure FloodFill(X, Y: Single; Color: TColor; FillStyle: TFillStyle);

  function GetTextExtent(const NoTabText: string): TPointF;

  procedure GotoXY(const NewXPos, NewYPos: Single);

  procedure Home;

  procedure Lf;

  function LinesLeft: Integer;

  function LineStartPos: Single;

  procedure LineTo(const EndXPos, EndYPos: Single; const AOpacity: Extended);

  procedure NewColumn;

  procedure NewLine(const NumberOfLines: Integer = 1);

  procedure NewPage;

  procedure Pie(const Left, Top, Right, Bottom, StartX, StartY, EndX, EndY: Single; const FillColor: TColor);

  procedure Pie(const Center, Radius: TPointF; StartAngle, SweepAngle: Single; const FillColor: TColor);

  procedure Polygon(const Points: array of TPointF; const FillColor: TColor);

  procedure Polyline(const Points: array of TPointF);

  procedure Print(const Text: string);

  procedure PrintBitmap(const Left, Top, Right, Bottom: Single; const AGraphic: TGraphic);

  procedure PrintBitmap(const ARect: TRectF; const AGraphic: TGraphic); overload;

  procedure PrintBlock(const NoTabText: string; PrintWidth: Single);

  procedure PrintCenter(const NoTabText: string; PrintWidth: Single);

  procedure PrintCharJustify(const NoTabText: string; const Ch: char; PrintWidth: Single);

  procedure PrintJustify(const NoTabText: string; StartCursorXPos: Single; const Justify: TPrintJustify; Margin: Single; PrintWidth: Single);

  procedure PrintJustify(const NoTabText: string; const Justify: TPrintJustify; Margin: Single; PrintWidth: Single);

  procedure PrintLeft(NoTabText: string; PrintWidth: Single = NA);

  procedure PrintLn(const Text: string);

  procedure PrintMemo(const NoTabMemo: TStrings; const IndentFirstLine : Single; Indent: Single; const RightIndent: Single; const Justify: TPrintJustify);

  procedure PrintParagraph(const NoTabText: string; const IndentFirstLine, Indent: Single; const RightIndent: Single; const Justify: TPrintJustify);

  procedure PrintRight(const NoTabText: string; PrintWidth: Single = NA);

  procedure PrintTab(NoTabText: string);

  procedure PrintXY(const Left, Top: Single; NoTabText: string; const Justify: TPrintJustify; Margin: Single; PrintWidth: Single);

  procedure Rectangle(const Left, Top, Right, Bottom: Single; const CornerRadiusX: Single; const CornerRadiusY: Single; const FillColor: TColor);

  procedure Rectangle(const Rect: TRectF; const CornerRadiusX: Single; const CornerRadiusY: Single; const FillColor: TColor);

  procedure Reset;

  procedure ResetFont;

  procedure ResetLineHeight;

  procedure ResetTabs;;

  function RestorePos(const Index: Integer): Boolean;

  function RestoreTabs(const Index: integer): Boolean;

  function SavePos(const Index: Integer): Boolean;

  procedure SaveTabs(const Index: integer);

  function SetColumns(const NewColumns: Integer; const Between:Single; ColHeight: Single; const LeftIndent: Single; const RightIndent: Single): Single;

  procedure SetColumnWidth(const ColWidth, Between: Single; ColHeight: Single; const LeftIndent: Single);

  procedure SetFill(NewColor: TColor);

  procedure SetFont(AFontFamilyName: string; AFontSize: Single);

  procedure SetStroke(const NewColor: TColor; const NewWidth: Single; const NewStyle: TPenStyle; const NewMode: TPenMode);

  procedure SetTab(const Left: Single; const Justify: TPrintJustify; const Width, Margin: Single; const BoxLines: TSides; const FillColor: TColor);

  procedure Tab;

  procedure TextRect(const Rect: TRectF; const NoTabText: string; const ATextAlign: TTextFormats; const WordWrap: Boolean; const Flags: TTextFormat; const AVTextAlign: TTextFormats);

  function TextWidth(const NoTabText: string): Single;

  function TruncateText(var NoTabText: string; const Width: Single; const WholeWords: Boolean): string;

X
Vcl and Firemonkey
procedure Abort; virtual;
virtual void __fastcall Abort(void);
Summary

   Sets FAborted to True to stop an active print job
   Sends Abort to the current print device if active.
  

Notes

   FAborted is set to False before OnBeforePrint is called
   Test FAborted whilst generating your report to see if the user has cancelled the print job
  

X
Vcl
procedure Arc(const Left, Top, Right, Bottom, StartX, StartY, EndX, EndY: Single); overload;
void __fastcall Arc(const float Left, const float Top, const float Right, const float Bottom, const float StartX, const float StartY, const float EndX, const float EndY)/* overload */;
Summary

   Draws an arc on the image along the perimeter of the ellipse bounded by the specified rectangle.
  
   Use Arc to draw an elliptically curved line with the current Pen. The arc traverses the perimeter of an ellipse that is bounded by the points (X1,Y1) and
   (X2,Y2). The arc is drawn following the perimeter of the ellipse, counterclockwise, from the starting point to the ending point. The starting point is
   defined by the intersection of the ellipse and a line defined by the center of the ellipse and (StartX, StartY). The ending point is defined by the
   intersection of the ellipse and a line defined by the center of the ellipse and (EndX, EndY).
  

Notes

   VCL only
   Must only be called within the various OnPrint events.
   The drawing direction can be changed to clockwise using the Windows API call SetArcDirection.
  

X
Vcl
procedure Arc(const Center: TPointF; Radius, StartAngle, SweepAngle: Single); overload;
void __fastcall Arc(const System::Types::TPointF &Center, float Radius, float StartAngle, float SweepAngle)/* overload */;
Firemonkey
procedure Arc(const Center, Radius: TPointF; StartAngle, SweepAngle: Single; const FillColor: TAlphaColor = 0; const AOpacity: Extended = 1);
void __fastcall Arc(const System::Types::TPointF &Center, const System::Types::TPointF &Radius, float StartAngle, float SweepAngle, const System::Uitypes::TAlphaColor FillColor = (System::Uitypes::TAlphaColor)(0x0), const System::Extended AOpacity = 1.000000E+00);
Summary

   Draws an Arc
  

Notes

   Can be drawn filled on Firemonkey. Use FloodFill on VCL
  

X
Vcl and Firemonkey
procedure ClearColumns;
void __fastcall ClearColumns(void);
Summary

   Clears the current report band columns and sets a single column at the CursorYPos, spanning the available print width (between margins) and for the
   remaining height of the current report band
  

X
Vcl and Firemonkey
procedure ClearTabs;
void __fastcall ClearTabs(void);
Summary

   Clears the TabStops in the current report band
  

Notes

   Use SaveTabs and RestoreTabs to resume the current TabStop settings
  

X
Vcl and Firemonkey
function ColumnLinesLeft: Integer;
int __fastcall ColumnLinesLeft(void);
Summary

   Returns the number of lines which could be printed using the current Font fron the CursorYPos to the bottom of the current column plus in any
   remaining columns in the current report band.
  

Returns Integer

X
Vcl and Firemonkey
procedure Cr;
void __fastcall Cr(void);
Summary

   Sets the CursorXPos to the left edge of the current column (to MarginLeft if it is the first column)
  

X
Vcl and Firemonkey
procedure CrLf;
void __fastcall CrLf(void);
Summary

   Does a Cr followed by Lf.
  

Notes

   Does not check to see if the CursorYPos moves beyond the bottom of the current column.
   Use NewLine to get position checking to follow the current column and current report band limits
  

X
Vcl
procedure DrawRectangleSides(const ARect: TRectF; const ASides: TSides; const Stroke: TPen = nil);
void __fastcall DrawRectangleSides(const System::Types::TRectF &ARect, const Vcl::Hbdefine::TSides ASides, Vcl::Graphics::TPen* const Stroke = (Vcl::Graphics::TPen*)(0x0));
Firemonkey
procedure DrawRectangleSides(const ARect: TRectF; const ASides: TSides; const Stroke: TStrokeBrush = nil);
void __fastcall DrawRectangleSides(const System::Types::TRectF &ARect, const Fmx::Types::TSides ASides, Fmx::Graphics::TStrokeBrush* const Stroke = (Fmx::Graphics::TStrokeBrush*)(0x0));
Summary

   Draws an unfilled box
  

X
Vcl
procedure Ellipse(const Left, Top, Right, Bottom: Single; const FillColor: TColor = NA);
void __fastcall Ellipse(const float Left, const float Top, const float Right, const float Bottom, const System::Uitypes::TColor FillColor = (System::Uitypes::TColor)(0xffffffff));
Firemonkey
procedure Ellipse(const Left, Top, Right, Bottom: Single; const FillColor: TAlphaColor = 0; const AOpacity: Extended = 1); overload;
void __fastcall Ellipse(const float Left, const float Top, const float Right, const float Bottom, const System::Uitypes::TAlphaColor FillColor = (System::Uitypes::TAlphaColor)(0x0), const System::Extended AOpacity = 1.000000E+00)/* overload */;
Summary

   Drws an Ellipse within the bounding rectangle.
  

X
Firemonkey
procedure Ellipse(const ARect: TRectF; const FillColor: TAlphaColor = 0; const AOpacity: Extended = 1); overload;
void __fastcall Ellipse(const System::Types::TRectF &ARect, const System::Uitypes::TAlphaColor FillColor = (System::Uitypes::TAlphaColor)(0x0), const System::Extended AOpacity = 1.000000E+00)/* overload */;
Summary

   Draws an Ellipse within the bounding rectangle.
  

X
Vcl and Firemonkey
function Execute: Boolean; virtual;
virtual bool __fastcall Execute(void);
Summary

   Generates an optional report preview then outputs the report to the user-selected print device
  

Returns True if printed okay.

X
Vcl
procedure FloodFill(X, Y: Single; Color: TColor; FillStyle: TFillStyle);
void __fastcall FloodFill(float X, float Y, System::Uitypes::TColor Color, Vcl::Graphics::TFillStyle FillStyle);
Summary

   Fill a possibly non-rectangular region of the image with the value of Brush. The boundaries of the region to be filled are determined by moving
   outward from the point (X,Y) until a color boundary involving the Color parameter is encountered.
  

Notes

   Use the Pixels property to get the exact value of the color at the point (X,Y) when using a FillStyle of fsSurface. Similarly, when FillStyle is fsBorder,
   use Pixels to get the exact value of the boundary color if a point on the boundary is known.
  

X
Vcl and Firemonkey
function GetTextExtent(const NoTabText: string): TPointF;
System::Types::TPointF __fastcall GetTextExtent(const System::UnicodeString NoTabText);
Summary

   Returns a PointF containing the width and height of a string in Units using the current canvas Font
  

Returns X width and Y the height of the text

X
Vcl and Firemonkey
procedure GotoXY(const NewXPos, NewYPos: Single);
void __fastcall GotoXY(const float NewXPos, const float NewYPos);
Summary

   Sets the CursorXPos and CursorYPos relative to the edges of the paper.
  

Notes

   Page edges, margins and other formatting is ignored. The developer should ensure that the print Cursor remains on the bage.
  

X
Vcl and Firemonkey
procedure Home;
void __fastcall Home(void);
Summary

   Sets the CursorXPos to the left edge of the Body report band and the CursorYPos to the top of the Body report band
  

Notes

   Clears any columns (Sets a single column occupying the Body printable area).
  

X
Vcl and Firemonkey
procedure Lf;
void __fastcall Lf(void);
Summary

   Moves the CursorYPos down one current line height. The CursorXPos is unchanged.
  

Notes

   No position checking is done. The developer should use LinesLeft to test that the CursorYPos does not go below the page formatting constraints
   (columns and margins)
  

X
Vcl and Firemonkey
function LinesLeft: Integer;
int __fastcall LinesLeft(void);
Summary

   Returns the number of lines (using the current Font) which would fit in the current column below the CursorYPos
  

Notes

   Use ColumnsLinesLeft to include remaiing columns where there is more than one column.
  

Returns Integer

X
Vcl and Firemonkey
function LineStartPos: Single;
float __fastcall LineStartPos(void);
Summary

   Returns the distance in Units from the left edge of the paper to the Left of the current column (this is MarginLeft for the first or only column)
  

Returns Single in Units

X
Vcl and Firemonkey
procedure LineTo(const EndXPos, EndYPos: Single; const AOpacity: Extended = 1);
void __fastcall LineTo(const float EndXPos, const float EndYPos, const System::Extended AOpacity = 1);
Summary

   Draw a line from the current CursorXPos, CursorYPos to the EndXPos, EndYPos
  

Notes

   Page formatting is ignored. The developer should ensure that the print Cursor remains on the page.
   The CursorXPos, CursorYPos is set to EndXPos, EndYPos when finished
  

X
Vcl and Firemonkey
procedure NewColumn;
void __fastcall NewColumn(void);
Summary

   Sets the CursorXPos, CursorYPos to the top left of the next column.
  

Notes

   In Body if there are no more columns then does NewPage else the print Cursor is not moved.
  

X
Vcl and Firemonkey
procedure NewLine(const NumberOfLines: Integer = 1);
void __fastcall NewLine(const int NumberOfLines = 0x1);
Summary

   Sets the CursorXPos to the LineStartPosition.
   Moves CursorYPos down the requested NumberOfLines..
  

Notes

   If there are no LinesLeft then does NewColumn.
  

X
Vcl and Firemonkey
procedure NewPage;
void __fastcall NewPage(void);
Summary

   Prints the footer then creates a new page.
  

X
Vcl
procedure Pie(const Left, Top, Right, Bottom, StartX, StartY, EndX, EndY: Single; const FillColor: TColor = NA); overload;
void __fastcall Pie(const float Left, const float Top, const float Right, const float Bottom, const float StartX, const float StartY, const float EndX, const float EndY, const System::Uitypes::TColor FillColor = (System::Uitypes::TColor)(0xffffffff))/* overload */;
Summary

   Draws a pie-shaped wedge on the page. The wedge is defined by the ellipse bounded by the rectangle determined by the points Left, Top, Right,
   Bottom. The section drawn is determined by two lines radiating from the center of the ellipse through the points StartX, StartY and EndX, EndY.
  
   The wedge is outlined using the current Pen, and filled using FillColor or current Brush.
  
  

X
Vcl
procedure Pie(const Center, Radius: TPointF; StartAngle, SweepAngle: Single; const FillColor: TColor = NA); overload;
void __fastcall Pie(const System::Types::TPointF &Center, const System::Types::TPointF &Radius, float StartAngle, float SweepAngle, const System::Uitypes::TColor FillColor = (System::Uitypes::TColor)(0xffffffff))/* overload */;
Firemonkey
procedure Pie(const Center, Radius: TPointF; StartAngle, SweepAngle: Single; const FillColor: TAlphaColor = 0; const AOpacity: Extended = 1);
void __fastcall Pie(const System::Types::TPointF &Center, const System::Types::TPointF &Radius, float StartAngle, float SweepAngle, const System::Uitypes::TAlphaColor FillColor = (System::Uitypes::TAlphaColor)(0x0), const System::Extended AOpacity = 1.000000E+00);
Summary

   Draws an arc. The arc is created as a path containing the part of an ellipse contour.
  
  

X
Vcl
procedure Polygon(const Points: array of TPointF; const FillColor: TColor = NA);
void __fastcall Polygon(System::Types::TPointF const *Points, const int Points_High, const System::Uitypes::TColor FillColor = (System::Uitypes::TColor)(0xffffffff));
Firemonkey
procedure Polygon(const Points: array of TPointF; const FillColor: TAlphaColor = 0; const AOpacity: Extended = 1);
void __fastcall Polygon(System::Types::TPointF const *Points, const int Points_High, const System::Uitypes::TAlphaColor FillColor = (System::Uitypes::TAlphaColor)(0x0), const System::Extended AOpacity = 1.000000E+00);
Summary

   Draws a filled polygon around the Points.
   The last Point is closed to the first Point.
  

X
Vcl
procedure Polyline(const Points: array of TPointF);
void __fastcall Polyline(System::Types::TPointF const *Points, const int Points_High);
Firemonkey
procedure PolyLine(const Points: array of TPointF; const AOpacity: Extended = 1);
void __fastcall PolyLine(System::Types::TPointF const *Points, const int Points_High, const System::Extended AOpacity = 1.000000E+00);
Summary

   Draws a polyline around the Points
  

X
Vcl and Firemonkey
procedure Print(const Text: string);
void __fastcall Print(const System::UnicodeString Text);
Summary

   Prints the Text at the current CursorXPos, CursorYPos
  

Notes

   The Tab character #9 embedded in Text will set CursorXPos at the next TabStop position. The TabStop rectangle is drawn and the Text after the #9
   output.
   When finished the CursorXPos is set immediately after the last character printed.
  

X
Vcl
procedure PrintBitmap(const Left, Top, Right, Bottom: Single; const AGraphic: TGraphic); overload;
void __fastcall PrintBitmap(const float Left, const float Top, const float Right, const float Bottom, Vcl::Graphics::TGraphic* const AGraphic)/* overload */;
Firemonkey
procedure PrintBitmap(const Left, Top, Right, Bottom: Single; Bitmap: TBitmap; const AOpacity: Extended = 1); overload;
void __fastcall PrintBitmap(const float Left, const float Top, const float Right, const float Bottom, Fmx::Graphics::TBitmap* Bitmap, const System::Extended AOpacity = 1.000000E+00)/* overload */;
Summary

   Prints a picture scaled to fit the bounding rectangle
  

X
Vcl
procedure PrintBitmap(const ARect: TRectF; const AGraphic: TGraphic); overload;
void __fastcall PrintBitmap(const System::Types::TRectF &ARect, Vcl::Graphics::TGraphic* const AGraphic)/* overload */;
Firemonkey
procedure PrintBitmap(const ARect: TRectF; const Bitmap: TBitmap; const AOpacity: Extended = 1); overload;
void __fastcall PrintBitmap(const System::Types::TRectF &ARect, Fmx::Graphics::TBitmap* const Bitmap, const System::Extended AOpacity = 1.000000E+00)/* overload */;
Summary

   Prints a picture scaled to fit the bounding rectangle
  

X
Vcl and Firemonkey
procedure PrintBlock(const NoTabText: string; PrintWidth: Single = NA);
void __fastcall PrintBlock(const System::UnicodeString NoTabText, float PrintWidth = NA);
Summary

   Prints NoTabText left/right justified in the width
  

Notes

   If PrintWidth is not specified then width is the current TabStop width or if the print Cursor is not on a TabStop then width is the remaining width in
   the CurrentColumn
  

X
Vcl and Firemonkey
procedure PrintCenter(const NoTabText: string; PrintWidth: Single = NA);
void __fastcall PrintCenter(const System::UnicodeString NoTabText, float PrintWidth = NA);
Summary

   Prints NoTabText Centered in the PrintWidth
  

Notes

   When finished the CursorXPos is set immediately after the PrintWidth.
   If PrintWidth is not specified then width is the current TabStop width or if the print Cursor is not on a TabStop then width is the remaining width in
   the CurrentColumn
  

X
Vcl and Firemonkey
procedure PrintCharJustify(const NoTabText: string; const Ch: char; PrintWidth: Single = NA);
void __fastcall PrintCharJustify(const System::UnicodeString NoTabText, const System::WideChar Ch, float PrintWidth = -1.000000E+00f);
Summary

   Prints NoTabText in the PrintWidth.
   The string to the left of the first ocurrence of Ch is printed left aligned.
   The string to the right and including Ch are printed right aligned.
  

Notes

   When finished the CursorXPos is set immediately after the PrintWidth.
   If PrintWidth is not specified then width is the current TabStop width or if the print Cursor is not on a TabStop then width is the remaining width in
   the CurrentColumn
  

X
Vcl
procedure PrintJustify(const NoTabText: string; StartCursorXPos: Single = NA; const Justify: TPrintJustify = TPrintJustify.Leading; Margin: Single = 0; PrintWidth: Single = NA); overload;
void __fastcall PrintJustify(const System::UnicodeString NoTabText, float StartCursorXPos = NA, const Vcl::Hbdefine::TPrintJustify Justify = (Vcl::Hbdefine::TPrintJustify)(0x1), float Margin = 0.000000E+00f, float PrintWidth = -1.000000E+00f)/* overload */;
Firemonkey
procedure PrintJustify(const NoTabText: string; StartCursorXPos: Single = NA; const Justify: TPrintJustify = TPrintJustify.Leading; Margin: Single = 0; PrintWidth: Single = NA); overload;
void __fastcall PrintJustify(const System::UnicodeString NoTabText, float StartCursorXPos = NA, const Fmx::Hbdefine::TPrintJustify Justify = (Fmx::Hbdefine::TPrintJustify)(0x1), float Margin = 0.000000E+00f, float PrintWidth = -1.000000E+00f)/* overload */;
Summary

   Print the text within the width according to the parameters
  

Notes

   When finished the CursorXPos is set immediately after the PrintWidth.
   If PrintWidth is not specified then width is the current TabStop width or if the print Cursor is not on a TabStop then width is the remaining width in
   the CurrentColumn
  

X
Vcl
procedure PrintJustify(const NoTabText: string; const Justify: TPrintJustify = TPrintJustify.Leading; Margin: Single = 0; PrintWidth: Single = NA); overload;
void __fastcall PrintJustify(const System::UnicodeString NoTabText, const Vcl::Hbdefine::TPrintJustify Justify = (Vcl::Hbdefine::TPrintJustify)(0x1), float Margin = 0.000000E+00f, float PrintWidth = -1.000000E+00f)/* overload */;
Firemonkey
procedure PrintJustify(const NoTabText: string; const Justify: TPrintJustify = TPrintJustify.Leading; Margin: Single = 0; PrintWidth: Single = NA); overload;
void __fastcall PrintJustify(const System::UnicodeString NoTabText, const Fmx::Hbdefine::TPrintJustify Justify = (Fmx::Hbdefine::TPrintJustify)(0x1), float Margin = 0.000000E+00f, float PrintWidth = -1.000000E+00f)/* overload */;
Summary

   Prints NoTabText within the PrintWidth
  

Notes

   When finished the CursorXPos is set immediately after the PrintWidth.
   If PrintWidth is not specified then width is the current TabStop width or if the print Cursor is not on a TabStop then width is the remaining width in
   the CurrentColumn
  

X
Vcl
procedure PrintLeft(NoTabText: string; PrintWidth: Single = NA);
void __fastcall PrintLeft(System::UnicodeString NoTabText, float PrintWidth = NA);
Firemonkey
procedure PrintLeft(NoTabText: string; PrintWidth: Single = NA);
void __fastcall PrintLeft(System::UnicodeString NoTabText, float PrintWidth =NA);
Summary

   Prints the NoTabText left justified trimmed within the PrintWidth
  

Notes

   When finished the CursorXPos is set immediately after the PrintWidth.
   If PrintWidth is not specified then width is the current TabStop width or if the print Cursor is not on a TabStop then width is the remaining width in
   the CurrentColumn
  

X
Vcl and Firemonkey
procedure PrintLn(const Text: string);
void __fastcall PrintLn(const System::UnicodeString Text);
Summary

   Does Print followed by NewLine
  

Notes

   When finished the CursorXPos is set at LineStartPosition.
   If there are no LinesLeft then does NewColumn
  

X
Vcl
procedure PrintMemo(const NoTabMemo: TStrings; const IndentFirstLine : Single = 0; Indent: Single = 0; const RightIndent: Single = 0; const Justify: TPrintJustify = TPrintJustify.Leading);
void __fastcall PrintMemo(System::Classes::TStrings* const NoTabMemo, const float IndentFirstLine = 0.000000E+00f, float Indent = 0.000000E+00f, const float RightIndent = 0.000000E+00f, const Vcl::Hbdefine::TPrintJustify Justify = (Vcl::Hbdefine::TPrintJustify)(0x1));
Firemonkey
procedure PrintMemo(const NoTabMemo: TStrings; const IndentFirstLine : Single = 0; Indent: Single = 0; const RightIndent: Single = 0; const Justify: TPrintJustify = TPrintJustify.Leading);
void __fastcall PrintMemo(System::Classes::TStrings* const NoTabMemo, const float IndentFirstLine = 0.000000E+00f, float Indent = 0.000000E+00f, const float RightIndent = 0.000000E+00f, const Fmx::Hbdefine::TPrintJustify Justify = (Fmx::Hbdefine::TPrintJustify)(0x1));
Summary

   Prints a TStrings, each line as a new Paragraph
  

X
Vcl
procedure PrintParagraph(const NoTabText: string; const IndentFirstLine, Indent: Single; const RightIndent: Single = 0; const Justify: TPrintJustify = TPrintJustify.Leading);
void __fastcall PrintParagraph(const System::UnicodeString NoTabText, const float IndentFirstLine, const float Indent, const float RightIndent = 0.000000E+00f, const Vcl::Hbdefine::TPrintJustify Justify = (Vcl::Hbdefine::TPrintJustify)(0x1));
Firemonkey
procedure PrintParagraph(const NoTabText: string; const IndentFirstLine, Indent: Single; const RightIndent: Single = 0; const Justify: TPrintJustify = TPrintJustify.Leading);
void __fastcall PrintParagraph(const System::UnicodeString NoTabText, const float IndentFirstLine, const float Indent, const float RightIndent = 0.000000E+00f, const Fmx::Hbdefine::TPrintJustify Justify = (Fmx::Hbdefine::TPrintJustify)(0x1));
Summary

   Prints NoTabText formatted as a paragraph
  

Notes

   When finished the CursorXPos is set immediately after the last character printed.
   Will flow to a NewColumn idf no LinesLeft
  

X
Vcl and Firemonkey
procedure PrintRight(const NoTabText: string; PrintWidth: Single = NA);
void __fastcall PrintRight(const System::UnicodeString NoTabText, float PrintWidth = -1.000000E+00f);
Summary

  

X
Vcl and Firemonkey
procedure PrintTab(NoTabText: string);
void __fastcall PrintTab(System::UnicodeString NoTabText);
Summary

   Does Tab then prints NoTabText according to the TabStop properties
  

Notes

   When finished the CursorXPos is set immediately after the last character printed.
   If A TabStop is not found then prints NoTabText at the current CursorXPos
  

X
Vcl
procedure PrintXY(const Left, Top: Single; NoTabText: string; const Justify: TPrintJustify = TPrintJustify.Leading; Margin: Single = 0; PrintWidth: Single = NA);
void __fastcall PrintXY(const float Left, const float Top, System::UnicodeString NoTabText, const Vcl::Hbdefine::TPrintJustify Justify = (Vcl::Hbdefine::TPrintJustify)(0x1), float Margin = 0.000000E+00f, float PrintWidth = -1.000000E+00f);
Firemonkey
procedure PrintXY(const Left, Top: Single; NoTabText: string; const Justify: TPrintJustify = TPrintJustify.Leading; Margin: Single = 0; PrintWidth: Single = NA);
void __fastcall PrintXY(const float Left, const float Top, System::UnicodeString NoTabText, const Fmx::Hbdefine::TPrintJustify Justify = (Fmx::Hbdefine::TPrintJustify)(0x1), float Margin = 0.000000E+00f, float PrintWidth = -1.000000E+00f);
Summary

   Prints NoTabText at Left, Top ignoring all page layout formatting.
  

Notes

   When finished the CursorXPos is set immediately after the PrintWidth.
   If PrintWidth is not specified then width is the current TabStop width or if the print Cursor is not on a TabStop then width is the remaining width in
   the CurrentColumn
  

X
Vcl
procedure Rectangle(const Left, Top, Right, Bottom: Single; const CornerRadiusX: Single = 0; const CornerRadiusY: Single = 0; const FillColor: TColor = NA); overload;
void __fastcall Rectangle(const float Left, const float Top, const float Right, const float Bottom, const float CornerRadiusX = 0.000000E+00f, const float CornerRadiusY = 0.000000E+00f, const System::Uitypes::TColor FillColor = (System::Uitypes::TColor)(0xffffffff))/* overload */;
Firemonkey
procedure Rectangle(const Left, Top, Right, Bottom: Single; CornerRadiusX: Single = 0; CornerRadiusY: Single = 0; const FillColor: TAlphaColor = 0; const AOpacity: Extended = 1); overload;
void __fastcall Rectangle(const float Left, const float Top, const float Right, const float Bottom, float CornerRadiusX = 0.000000E+00f, float CornerRadiusY = 0.000000E+00f, const System::Uitypes::TAlphaColor FillColor = (System::Uitypes::TAlphaColor)(0x0), const System::Extended AOpacity = 1.000000E+00)/* overload */;
Summary

   Prints a Rectangle
  

X
Vcl
procedure Rectangle(const Rect: TRectF; const CornerRadiusX: Single = 0; const CornerRadiusY: Single = 0; const FillColor: TColor = NA); overload;
void __fastcall Rectangle(const System::Types::TRectF &Rect, const float CornerRadiusX = 0, const float CornerRadiusY = 0, const System::Uitypes::TColor FillColor = (System::Uitypes::TColor)(0xffffffff))/* overload */;
Firemonkey
procedure Rectangle(const Rect: TRectF; const CornerRadiusX: Single = 0; CornerRadiusY: Single = 0; const FillColor: TAlphaColor = 0; const AOpacity: Extended = 1); overload;
void __fastcall Rectangle(const System::Types::TRectF &Rect, const float CornerRadiusX = 0, float CornerRadiusY = 0, const System::Uitypes::TAlphaColor FillColor = (System::Uitypes::TAlphaColor)(0x0), const System::Extended AOpacity = 1.000000E+00)/* overload */;
Summary

   Prints a Rectangle
  

X
Vcl and Firemonkey
procedure Reset;
void __fastcall Reset(void);
Summary

  

X
Vcl and Firemonkey
procedure ResetFont;
void __fastcall ResetFont(void);
Summary

   Assigns the Default Font to the canvas
  

X
Vcl and Firemonkey
procedure ResetLineHeight;
void __fastcall ResetLineHeight(void);
Summary

   Resets LineHeightMethod to the default and Lineheight (if by Font) then to the current canvas Font.
  

X
Vcl and Firemonkey
procedure ResetTabs; deprecated 'Not required? - please send feedback';
void __fastcall ResetTabs _DEPRECATED_ATTRIBUTE1("Not required? - please send feedback") (void);
Summary

   Unsets the current TabStop so that it is ignored by Print
  

X
Vcl and Firemonkey
function RestorePos(const Index: Integer): Boolean;
bool __fastcall RestorePos(const int Index);
Summary

   Sets CursorXPos, CursorYPos to a position previously saved by SavePos
  

Notes

   Ignored if the matching SavePos record is not found.
  

Returns True if a SavePos record is found.

X
Vcl and Firemonkey
function RestoreTabs(const Index: integer): Boolean;
bool __fastcall RestoreTabs(const int Index);
Summary

   Restores a set of TabStops previously saved by SaveTabs
  

Notes

   Does nothing if a matching SaveTabs record is not found
  

Returns True if a matching SaveTabs record is found

X
Vcl and Firemonkey
function SavePos(const Index: Integer): Boolean;
bool __fastcall SavePos(const int Index);
Summary

   Saves the current CursorXPos, CursorYPos
  

Notes

   Applies to the current report band.
  

Returns False if an error ocurred

X
Vcl and Firemonkey
procedure SaveTabs(const Index: integer);
void __fastcall SaveTabs(const int Index);
Summary

   Saves the current set of TabStops
  

Notes

   Applies to the current report band.
  

X
Vcl and Firemonkey
function SetColumns(const NewColumns: Integer; const Between:Single; ColHeight: Single = NA; const LeftIndent: Single = 0; const RightIndent: Single = 0): Single;
float __fastcall SetColumns(const int NewColumns, const float Between, float ColHeight = NA, const float LeftIndent = 0, const float RightIndent = 0.000000E+00f);
Summary

   Sets one or more columns for text printing
  

Notes

   If ColHeight is not specified then height is the maximum remaining space available in the current report band
  

X
Vcl and Firemonkey
procedure SetColumnWidth(const ColWidth, Between: Single; ColHeight: Single = NA; const LeftIndent: Single = 0);
void __fastcall SetColumnWidth(const float ColWidth, const float Between, float ColHeight = NA, const float LeftIndent = 0);
Summary

   Sets one or more columns for text printing
  

Notes

   The number of columns is calculated from the available space between the Margins then the RightIndent of the last column from the MarginRight is
   calculated.
   If ColHeight is not specified then height is the maximum remaining space available in the current report band
  

X
Vcl
procedure SetFill(NewColor: TColor);
void __fastcall SetFill(System::Uitypes::TColor NewColor);
Firemonkey
procedure SetFill(NewColor: TAlphaColor);
void __fastcall SetFill(System::Uitypes::TAlphaColor NewColor);
Summary

   Set the canvas fill brush color
  

X
Vcl and Firemonkey
procedure SetFont(AFontFamilyName: string; AFontSize: Single);
void __fastcall SetFont(System::UnicodeString AFontFamilyName, float AFontSize);
Summary

   Set the canvas Font
  

X
Vcl
procedure SetStroke(const NewColor: TColor; const NewWidth: Single = NA; const NewStyle: TPenStyle = TPenStyle.psSolid; const NewMode: TPenMode = TPenMode.pmCopy);
void __fastcall SetStroke(const System::Uitypes::TColor NewColor, const float NewWidth = -1.000000E+00f, const Vcl::Graphics::TPenStyle NewStyle = (Vcl::Graphics::TPenStyle)(0x0), const Vcl::Graphics::TPenMode NewMode = (Vcl::Graphics::TPenMode)(0x4));
Firemonkey
procedure SetStroke(const NewColor: TAlphaColor; const NewThickness: Single);
void __fastcall SetStroke(const System::Uitypes::TAlphaColor NewColor, const float NewThickness);
Summary

   Set the canvas Stroke (Pen)
  

X
Vcl
procedure SetTab(const Left: Single; const Justify: TPrintJustify; const Width, Margin: Single; const BoxLines: TSides; const FillColor: TColor = NA); overload;
void __fastcall SetTab(const float Left, const Vcl::Hbdefine::TPrintJustify Justify, const float Width, const float Margin, const Vcl::Hbdefine::TSides BoxLines, const System::Uitypes::TColor FillColor = (System::Uitypes::TColor)(0xffffffff))/* overload */;
Firemonkey
procedure SetTab(const Left: Single; const Justify: TPrintJustify; const Width, Margin: Single; const BoxLines: TSides; const FillColor: TAlphaColor = 0); overload;
void __fastcall SetTab(const float Left, const Fmx::Hbdefine::TPrintJustify Justify, const float Width, const float Margin, const Fmx::Types::TSides BoxLines, const System::Uitypes::TAlphaColor FillColor = (System::Uitypes::TAlphaColor)(0x0))/* overload */;
Summary

   Set a TabStop
  

Notes

   TabStops should be contained within the CurrentColumn width
   If Left is NA then the TabStop Left is the previous tab Right or the CurrentColumn Left if it is the first TabStop
  

X
Vcl and Firemonkey
procedure Tab;
void __fastcall Tab(void);
Summary

   Moves the CursorXPos to the next TabStop Left and draws the Tab Boxlines and fill (if any)
  

Notes

   Does nothing if no TabStop is found
  

X
Vcl
procedure TextRect(const Rect: TRectF; const NoTabText: string; const ATextAlign: TTextFormats = TTextFormats.tfLeft; const WordWrap: Boolean = False; const Flags: TTextFormat = []; const AVTextAlign: TTextFormats = TTextFormats.tfVerticalCenter);
void __fastcall TextRect(const System::Types::TRectF &Rect, const System::UnicodeString NoTabText, const Vcl::Graphics::TTextFormats ATextAlign = (Vcl::Graphics::TTextFormats)(0x8), const bool WordWrap = false, const Vcl::Graphics::TTextFormat Flags = Vcl::Graphics::TTextFormat() , const Vcl::Graphics::TTextFormats AVTextAlign = (Vcl::Graphics::TTextFormats)(0x10));
Firemonkey
procedure TextRect(const Rect: TRectF; const NoTabText: string; const ATextAlign: TTextAlign = TTextAlign.Leading; const WordWrap: Boolean = False; const Flags: TFillTextFlags = []; const AVTextAlign: TTextAlign = TTextAlign.Center; const AOpacity: Single = 1);
void __fastcall TextRect(const System::Types::TRectF &Rect, const System::UnicodeString NoTabText, const Fmx::Types::TTextAlign ATextAlign = (Fmx::Types::TTextAlign)(0x1), const bool WordWrap = false, const Fmx::Graphics::TFillTextFlags Flags = Fmx::Graphics::TFillTextFlags() , const Fmx::Types::TTextAlign AVTextAlign = (Fmx::Types::TTextAlign)(0x0), const float AOpacity = 1.000000E+00f);
Summary

   Prints the NoTabText within the bounding rectangle
  

X
Vcl and Firemonkey
function TextWidth(const NoTabText: string): Single;
float __fastcall TextWidth(const System::UnicodeString NoTabText);
Summary

   Returns the print width of the NoTabText in Units
  

Returns Single width in Units

X
Vcl and Firemonkey
function TruncateText(var NoTabText: string; const Width: Single; const WholeWords: Boolean = False): string;
System::UnicodeString __fastcall TruncateText(System::UnicodeString &NoTabText, const float Width, const bool WholeWords = false);
Summary

   Returns NoTabText truncated to the Width specified.
  

Notes

   After the function is called, NoTabText contains the remainder which was cut off
  

Returns text to fit Width

X
Vcl and Firemonkey
property Aborted: Boolean read FAborted;
__property bool Aborted = {read=FAborted, nodefault};
Summary

   Check to see if the print job has been aborted by the user.
  

Notes

   Call Abort to set to True from the user interface.
  

Returns Boolean

X
Vcl
property BackgroundColor: TColor read FBackgroundColor write FBackgroundColor;
__property System::Uitypes::TColor BackgroundColor = {read=FBackgroundColor, write=FBackgroundColor, nodefault};
Firemonkey
property BackgroundColor: TAlphaColor read FBackgroundColor write FBackgroundColor;
__property System::Uitypes::TAlphaColor BackgroundColor = {read=FBackgroundColor, write=FBackgroundColor, nodefault};
Summary

   Background color of the page.
  

Notes

   Painted on the NewPage canvas immediately it is created.
  

X
Vcl and Firemonkey
property Body: TReportBody read FBody;
__property TReportBody* Body = {read=FBody};
Summary

   THe Body report band
  

Notes

   Occupies the whole page area between the header and footer (or the whole page between the top and bottom margins if there is no header and/or
   footer).
  

X
Vcl and Firemonkey
property Bold: Boolean read GetBold write SetBold;
__property bool Bold = {read=GetBold, write=SetBold, nodefault};
Summary

  Set/unset the canvas font to Bold
  

X
Vcl
property BoxLineColor: TColor read FBoxLineColor write FBoxLineColor default clBlack;
__property System::Uitypes::TColor BoxLineColor = {read=FBoxLineColor, write=FBoxLineColor, default=0};
Firemonkey
property BoxLineColor: TAlphaColor read FBoxLineColor write SetBoxLineColor default TAlphaColorRec.Black;
__property System::Uitypes::TAlphaColor BoxLineColor = {read=FBoxLineColor, write=SetBoxLineColor, default=-16777216};
Summary

   The BoxLine color for TabStop borders
  

X
Vcl
property Canvas: TCanvas read GetCanvas;
__property Vcl::Graphics::TCanvas* Canvas = {read=GetCanvas};
Firemonkey
property Canvas: TCanvas read GetCanvas;
__property Fmx::Graphics::TCanvas* Canvas = {read=GetCanvas};
Summary

   The current print or prieview canvas
  

Notes

   Only available inside the OnPrint events
  

X
Vcl and Firemonkey
property ColumnNum: Integer read FColumnNum write SetColumnNum;
__property int ColumnNum = {read=FColumnNum, write=SetColumnNum, nodefault};
Summary

  The CurrentColumn number with 1 being the first column
  

X
Vcl and Firemonkey
property Columns: Integer read GetColumns;
__property int Columns = {read=GetColumns, nodefault};
Summary

  Number of columns
  

X
Vcl and Firemonkey
property CurrentColumn: TReportColumn read FCurrentColumn;
__property TReportColumn* CurrentColumn = {read=FCurrentColumn};
Summary

   The current column for text printing
  

X
Vcl and Firemonkey
property CurrentPage: Integer read FCurrentPage;
__property int CurrentPage = {read=FCurrentPage, nodefault};
Summary

   Current page number with 1 being the first page
  

Notes

   Use for printing the page number in a header/footer
  

X
Vcl and Firemonkey
property CursorXPos: Single read GetCursorXPos write SetCursorXPos;
__property float CursorXPos = {read=GetCursorXPos, write=SetCursorXPos};
Summary

   The print Cursor distance in Units from the left edge of the paper
  

X
Vcl and Firemonkey
property CursorYPos: Single read GetCursorYPos write SetCursorYPos;
__property float CursorYPos = {read=GetCursorYPos, write=SetCursorYPos};
Summary

   The print Cursor distance in Units from the top edge of the paper
  

X
Vcl
property DefaultFill: TBrush read FDefaultFill;
__property Vcl::Graphics::TBrush* DefaultFill = {read=FDefaultFill};
Firemonkey
property DefaultFill: TBrush read FDefaultFill;
__property Fmx::Graphics::TBrush* DefaultFill = {read=FDefaultFill};
Summary

   The default fill color when a report is commenced
  

X
Vcl
property DefaultFont: TFont read FDefaultFont write FDefaultFont;
__property Vcl::Graphics::TFont* DefaultFont = {read=FDefaultFont, write=FDefaultFont};
Firemonkey
property DefaultFont: TFont read FDefaultFont write FDefaultFont;
__property Fmx::Graphics::TFont* DefaultFont = {read=FDefaultFont, write=FDefaultFont};
Summary

   The default Font when a report is commenced
  

X
Vcl
property DefaultPaperSize: TPrintPaperSize read FDefaultPaperSize write SetDefaultPaperSize;
__property Vcl::Hbdefine::TPrintPaperSize DefaultPaperSize = {read=FDefaultPaperSize, write=SetDefaultPaperSize, nodefault};
Firemonkey
property DefaultPaperSize: TPrintPaperSize read FDefaultPaperSize write SetDefaultPaperSize;
__property Fmx::Hbdefine::TPrintPaperSize DefaultPaperSize = {read=FDefaultPaperSize, write=SetDefaultPaperSize, nodefault};
Summary

   The default paper size until it is overruled by the print device
  

X
Vcl
property DefaultStroke: TPen read FDefaultStroke;
__property Vcl::Graphics::TPen* DefaultStroke = {read=FDefaultStroke};
Firemonkey
property DefaultStroke: TStrokeBrush read FDefaultStroke;
__property Fmx::Graphics::TStrokeBrush* DefaultStroke = {read=FDefaultStroke};
Summary

   The default stroke/pen color when a report is commenced
  

X
Vcl
property FontColor: TColor read GetFontColor write SetFontColor;
__property System::Uitypes::TColor FontColor = {read=GetFontColor, write=SetFontColor, nodefault};
Firemonkey
property FontColor: TAlphaColor read FFontColor write FFontColor;
__property System::Uitypes::TAlphaColor FontColor = {read=FFontColor, write=FFontColor, nodefault};
Summary

   The default font color when a report is commenced
  

X
Vcl
property FontName: string read GetFontName write SetFontName;
__property System::UnicodeString FontName = {read=GetFontName, write=SetFontName};
Firemonkey
property FontFamily: string read GetFontFamily write SetFontFamily;
__property System::UnicodeString FontFamily = {read=GetFontFamily, write=SetFontFamily};
Summary

   The canvas Font family name
  

X
Vcl and Firemonkey
property Fonts: TStrings read GetFonts;
__property System::Classes::TStrings* Fonts = {read=GetFonts};
Summary

   The available fonts on the print device (or if unavailable then from the computer).
  

X
Vcl and Firemonkey
property FontSize: Single read GetFontSize write SetFontSize;
__property float FontSize = {read=GetFontSize, write=SetFontSize};
Summary

   The default Font size when a report is commenced
  

X
Vcl and Firemonkey
property Italic: Boolean read GetItalic write SetItalic;
__property bool Italic = {read=GetItalic, write=SetItalic, nodefault};
Summary

   Set/unset the canvas font to Italic
  

X
Vcl and Firemonkey
property LineHeight: Single read FLineHeight write SetLineHeight;
__property float LineHeight = {read=FLineHeight, write=SetLineHeight};
Summary

   Text line height
  

X
Vcl
property LineHeightMethod: TLineHeightMethod read FLineHeightMethod write SetLineHeightMethod;
__property Vcl::Hbdefine::TLineHeightMethod LineHeightMethod = {read=FLineHeightMethod, write=SetLineHeightMethod, nodefault};
Firemonkey
property LineHeightMethod: TLineHeightMethod read FLineHeightMethod write SetLineHeightMethod;
__property Fmx::Hbdefine::TLineHeightMethod LineHeightMethod = {read=FLineHeightMethod, write=SetLineHeightMethod, nodefault};
Summary

   Line height method
  

X
Vcl and Firemonkey
property LineHeightProperty: TAbstractLineHeight read FLineHeightProperty;
__property TAbstractLineHeight* LineHeightProperty = {read=FLineHeightProperty};
Summary

  Property to match the line height method
  

X
Vcl and Firemonkey
property LineNum: Integer read FLineNum write SetLineNum;
__property int LineNum = {read=FLineNum, write=SetLineNum, nodefault};
Summary

   The CursorYPos as the number of lines from the top of the current column
  

X
Vcl and Firemonkey
property LinePaddingByFont: Single read FLinePaddingByFont write SetLinePaddingByFont;
__property float LinePaddingByFont = {read=FLinePaddingByFont, write=SetLinePaddingByFont};
Summary

   The line height as a proportion of the text height alowing for ascent and decent
  

X
Vcl and Firemonkey
property LinesPerInch: Single read FLinesPerInch write SetLinesPerInch;
__property float LinesPerInch = {read=FLinesPerInch, write=SetLinesPerInch};
Summary

   Lines per vertical inch
  

X
Vcl and Firemonkey
property MarginBottom: Single read FMarginBottom write SetMarginBottom;
__property float MarginBottom = {read=FMarginBottom, write=SetMarginBottom};
Summary

   Waste at the bottom of a page cannot be less than the print device bottom waste
  

X
Vcl and Firemonkey
property MarginLeft: Single read FMarginLeft write SetMarginLeft;
__property float MarginLeft = {read=FMarginLeft, write=SetMarginLeft};
Summary

   Waste at the left of a page cannot be less than the print device left waste
  

X
Vcl and Firemonkey
property MarginRight: Single read FMarginRight write SetMarginRight;
__property float MarginRight = {read=FMarginRight, write=SetMarginRight};
Summary

   Waste at the right of a page cannot be less than the print device right waste
  

X
Vcl and Firemonkey
property MarginTop: Single read FMarginTop write SetMarginTop;
__property float MarginTop = {read=FMarginTop, write=SetMarginTop};
Summary

   Waste at the top of a page cannot be less than the print device top waste
  

X
Vcl and Firemonkey
property MinMarginBottom: Single read GetMinMarginBottom;
__property float MinMarginBottom = {read=GetMinMarginBottom};
Summary

   The print device bottom waste
  

X
Vcl and Firemonkey
property MinMarginLeft: Single read GetMinMarginLeft;
__property float MinMarginLeft = {read=GetMinMarginLeft};
Summary

   The print device left waste
  

X
Vcl and Firemonkey
property MinMarginRight: Single read GetMinMarginRight;
__property float MinMarginRight = {read=GetMinMarginRight};
Summary

   The print device right waste
  

X
Vcl and Firemonkey
property MinMarginTop: Single read GetMinMarginTop;
__property float MinMarginTop = {read=GetMinMarginTop};
Summary

   The print device top waste
  

X
Vcl and Firemonkey
property Orientation: TPrinterOrientation read GetOrientation write SetOrientation default TPrinterOrientation.poPortrait;
__property System::Uitypes::TPrinterOrientation Orientation = {read=GetOrientation, write=SetOrientation, default=0};
Summary

   Page orientation
  

X
Vcl and Firemonkey
property PageCount: Integer read GetPageCount;
__property int PageCount = {read=GetPageCount, nodefault};
Summary

   Total pages in an report
  

Notes

   Only available after the Preview is generated
  

X
Vcl and Firemonkey
property PageHeight: Single read GetPageHeight;
__property float PageHeight = {read=GetPageHeight};
Summary

   Paper height in Units
  

X
Vcl and Firemonkey
property Pages: TObjectList read FPages;
__property System::Generics::Collections::TObjectList__1* Pages = {read=FPages};
Summary

   The report pages
  

X
Vcl and Firemonkey
property PageWidth: Single read GetPageWidth;
__property float PageWidth = {read=GetPageWidth};
Summary

   Paper width in Units
  

X
Vcl and Firemonkey
property Printing: Boolean read GetPrinting;
__property bool Printing = {read=GetPrinting, nodefault};
Summary

   Is the print device printing?
  

X
Vcl and Firemonkey
property ReportDateTime: TDateTime read FReportDateTime write FReportDateTime;
__property System::TDateTime ReportDateTime = {read=FReportDateTime, write=FReportDateTime};
Summary

   Captured before OnBeforePrint is called
  

Notes

   Print the report date in the Header/Footer
  

X
Vcl
property StatusLabel: TLabel read FStatusLabel write SetStatusLabel;
__property Vcl::Stdctrls::TLabel* StatusLabel = {read=FStatusLabel, write=SetStatusLabel};
Firemonkey
property StatusLabel: TLabel read FStatusLabel write SetStatusLabel;
__property Fmx::Stdctrls::TLabel* StatusLabel = {read=FStatusLabel, write=SetStatusLabel};
Summary

   UI Status TLabel to show the print status
  

X
Vcl
property StatusText: string read FStatusText write SetStatusText;
__property System::UnicodeString StatusText = {read=FStatusText, write=SetStatusText};
Firemonkey
property StatusText: string read GetStatusText write SetStatusText;
__property System::UnicodeString StatusText = {read=GetStatusText, write=SetStatusText};
Summary

   Status text to show in the Status Label
  

X
Vcl and Firemonkey
property Strikeout: Boolean read GetStrikeout write SetStrikeout;
__property bool Strikeout = {read=GetStrikeout, write=SetStrikeout, nodefault};
Summary

   Set/unset the canvas font to Strikeout
  

X
Vcl and Firemonkey
property Title: string read FTitle write FTitle;
__property System::UnicodeString Title = {read=FTitle, write=FTitle};
Summary

   The report Title
  

X
Vcl and Firemonkey
property Underline: Boolean read GetUnderline write SetUnderline;
__property bool Underline = {read=GetUnderline, write=SetUnderline, nodefault};
Summary

   Set/unset the canvas font to Underline
  

X
Vcl
property Units: TPrintPageUnits read GetUnits write SetUnits;
__property Vcl::Hbdefine::TPrintPageUnits Units = {read=GetUnits, write=SetUnits, nodefault};
Firemonkey
property Units: TPrintPageUnits read GetUnits write SetUnits;
__property Fmx::Hbdefine::TPrintPageUnits Units = {read=GetUnits, write=SetUnits, nodefault};
Summary

   The repprt units of measurement
  

Notes

   Should be fixed before you hard-code positions and dimentions in the OnPrint events!
  

X
Vcl and Firemonkey
property XDPI: Integer read GetXDPI write SetXDPI;
__property int XDPI = {read=GetXDPI, write=SetXDPI, nodefault};
Summary

   The default report X DPI (for preview) until it is overruled by the print device
  

X
Vcl and Firemonkey
property YDPI: Integer read GetYDPI write SetYDPI;
__property int YDPI = {read=GetYDPI, write=SetYDPI, nodefault};
Summary

   The default report Y DPI (for preview) until it is overruled by the print device
  

X
Vcl and Firemonkey
property OnAfterPrint: TPrintNotifyEvent read FOnAfterPrint write FOnAfterPrint;
__property TPrintNotifyEvent OnAfterPrint = {read=FOnAfterPrint, write=FOnAfterPrint};
Summary

   Write clean-up code here
  

X
Vcl and Firemonkey
property OnBeforePrint: TPrintNotifyEvent read FOnBeforePrint write FOnBeforePrint;
__property TPrintNotifyEvent OnBeforePrint = {read=FOnBeforePrint, write=FOnBeforePrint};
Summary

   Put before print code here.
  

Notes

   Called before generating the preview and again before output to the print device
  

X
Vcl and Firemonkey
property OnNewColumn: TPrintNotifyEvent read FOnNewColumn write FOnNewColumn;
__property TPrintNotifyEvent OnNewColumn = {read=FOnNewColumn, write=FOnNewColumn};
Summary

   Called when the print cursor is set to the top of the next column
  

X
Vcl and Firemonkey
property OnNewPage: TPrintNotifyEvent read FOnNewPage write FOnNewPage;
__property TPrintNotifyEvent OnNewPage = {read=FOnNewPage, write=FOnNewPage};
Summary

   Called when a new page is generated either by the preview or the print device
  

X
Vcl and Firemonkey
property OnPrint: TPrintNotifyEvent read FOnPrint write SetOnPrint;
__property TPrintNotifyEvent OnPrint = {read=FOnPrint, write=SetOnPrint};
Summary

   Write the report generation code here.
  

Notes

   The developer is responsible for calling NewPage as required
   You may not also code the OnPrintPage event
  

X
Vcl and Firemonkey
property OnPrintFooter: TPrintNotifyEvent read FOnPrintFooter write FOnPrintFooter;
__property TPrintNotifyEvent OnPrintFooter = {read=FOnPrintFooter, write=FOnPrintFooter};
Summary

   The Current report band is Footer
  

X
Vcl and Firemonkey
property OnPrintHeader: TPrintNotifyEvent read FOnPrintHeader write FOnPrintHeader;
__property TPrintNotifyEvent OnPrintHeader = {read=FOnPrintHeader, write=FOnPrintHeader};
Summary

   The Current reort band is Header
  

X
Vcl and Firemonkey
property OnPrintPage: TPrintPageEvent read FOnPrintPage write SetOnPrintPage;
__property TPrintPageEvent OnPrintPage = {read=FOnPrintPage, write=SetOnPrintPage};
Summary

   Code this event when all pages have the same structure, for instance when outputing the contents of a data table in grid form.
  

Notes

   The developer is responsible for calling NewPage as required
   You may not also code the OnPrint event
  

Returns True if there are more pages to print