PrnUtils Delphi Documentation Version 0A.2.3

Copyright © 1989-2010 by Joe C. Hecht All Rights Reserved
Copyright © 2011-2018 by CODE4SALE, LLC All Rights Reserved

Contact CODE4SALE, LLC - Joe Hecht.

TExcellent home page

TExcellent documentation home page!

Try TExcellentFormPrinter!   Buy TExcellentFormPrinter!
Try TExcellentImagePrinter!   Buy TExcellentImagePrinter!

Product names, trademarks, and servicemarks mentioned are owned by their respective owners.


Changes since version 3.4

All TExcellent products have now been upgraded to be compatible with all 32 and 64 bit versions of the Delphi and C++ Builder Windows compilers, and the TExcellent version number has been adjusted to now reflect compatibility with RAD Studio compiler version numbers.

Please note that TExcellentFormPrinter and the PrnUtils dialog are very VCL specific.

Non VCL notes: While TExcellent products are VCL and Windows specific, and FireMonkey is not officially supported, we have found that some TExcellent products are in fact usable in non-VCL projects. For example, TExcellentImagePrinter can be used in a FireMonkey Windows application (complete with the PrnUtils abort dialog) with minimal changes to your calling code. For example, creating our printing abort / status dialog can be accomplished with the following code:

C++Builder:

  AbortDialog := CreateAbortDialog(FMX.Platform.Win.FormToHWND(this),
                                   this);

Delphi:
  AbortDialog := CreateAbortDialog(FMX.Platform.Win.FormToHWND(self),
                                   self);


TExcellentCompilerDefs.inc: Not required by the TExcellent products themselves. The example and demo projects now make use of an include file to help determine the compiler version and capabilities in use, and is

PrnDibBuildMode.inc: An include file used to determine the build mode (Currently demo/release) and is required to compile release (non-demo) versions of TExcellent products.

Some Types have been renamed to reflect the name of the unit they are used in (to avoid scoping and compiler errors, and to allow the C and Pascal source to have greater symmetry).

Pointer types traditionally passed to callback functions as typecast integer values have been typed to a pointer sized integer (size_t where practical and a 32 unsigned integer where not practical) and renamed as follows:

UNITNAME_PTR_UINT
UNITNAME_PTR_AS_UINT

Example:

PRNFORM_PTR_AS_UINT
PRNFORM_PTR_UINT

TAppCallbackFn() has been renamed to:

TPrnFormAppCallbackFn (TExcellentFormPrinter)
TPrnDibAppCallbackFn (TExcellentImagePrinter)

Pointers to character strings used in filenames and captions hsve changed to TCaption and TFilename types!

In some cases, pointers to untyped pointer types (void *) have changed to (PVOID *).


Functions and structures:

Installation
GetPrnPageInfo
TPrnPageInfo
TScaleInfo
ScaleToFitX
ScaleToFitY
ScaleToBestFit
TPixelSizeInfo
GetPixelSizeInfo
GetNumPagesRequired
GetMemEx
FreeMemEx
LoadDIBFromStream
LoadDIBFromFile
LoadDIBFromTBitmap
TAbortDialog
TPrinterAbortDialog
CreateAbortDialog
FreeAbortDialog
AbortDialogSetCaption
AbortDialogUserHasCanceled
CreatePrinterAbortDialog
FreePrinterAbortDialog
PrinterAbortDialogSetCaption
PrinterAbortDialogAborted


Installation

If you are using TExcellentFormPrinter, please see the TExcellentFormPrinter documentation.

If you are using TExcellentImagePrinter, please see the TExcellentImagePrinter documentation.

Back to Functions and Structures


GetPrnPageInfo

function GetPrnPageInfo(dc : HDC;
                        lpPrnPageInfo : PPrnPageInfo) : BOOL; stdcall;

Location: PrnUtils.pas

This function is usefull for retrieving page information from a given device context. It accepts a dc (Canvas.Handle) and a pointer to a TPrnPageInfo structure. Retruns TRUE if successfull.

Example:

uses
  PrnUtils;

var
  PrnPageInfo : TPrnPageInfo;
begin
  GetPrnPageInfo(Printer.Canvas.Handle,
                 @PrnPageInfo);
end;

Back to Functions and Structures


TPrnPageInfo

type
  PPrnPageInfo = ^TPrnPageInfo;
  TPrnPageInfo = packed record
    Margin : TRect;                { normal margins to printing area }
    PageSize : TPoint;             { normal page or paper size }
    PageArea : TPoint;             { normal page image size }
    AdjustedMargin : TRect;        { adjusted margins (equal on all sizes) }
    AdjustedPageArea : TPoint;     { page image size adjusted for equal margins }
    AdjustedMarginOffset : TPoint; { amount to offset output for adjusted margins }
    DPI : TPoint;                  { pixels per inch of the device }
  end;

Location: PrnUtils.pas

Note: Not all devices have equal margins on all sides. This function is used with the GetPrnPageInfo() function and retrieves margin and page information and calculates the "adjusted margins" for the device allowing you to offset either the device context, or offset your drawing operations, to obtain page output that is equally centered on the page. All values are returned in pixel coordinates. The Margin and AdjustedMargin members are the distances from the edge of the device to the edge of the corrisponding rect. In other words, given that the margins are:

Margin.Left = 150;
Margin.Top = 100;
Margin.Right = 25;
Margin.Bottom = 50;

The Adjusted margines would be:

AdjustedMargin.Left = 150;
AdjustedMargin.Top = 150;
AdjustedMargin.Right = 150;
AdjustedMargin.Bottom = 150;

This structures "Adjusted" members also adjusts for super high resolution devices that have a page area that exceed 32000 pixels wide or high. Under Win9x platforms, it is an error condition when output coordinates exceed 32000 pixels. The adjusted page size accounts for this limitation, allowing you a safe working area under all Windows platforms on all devices.

Back to Functions and Structures


TScaleInfo

type
  PScaleInfo = ^TScaleInfo;
  TScaleInfo = packed record
    OriginalSize_X : double;
    OriginalSize_Y : double;
    ScaledSize_X : double;
    ScaledSize_Y : double;
    ScaleFactor_X : double;
    ScaleFactor_Y : double;
  end;

Location: PrnUtils.pas

This structure is used with many of the scaling functions included in the PrnUtils unit.

Back to Functions and Structures


ScaleToFitX

function ScaleToFitX(lpScaleInfo : PScaleInfo) : BOOL; stdcall;

Location: PrnUtils.pas

This function accepts a pointer to a TScaleInfo structure. Given an original(X,Y) and an X size to fit, this function calculates the scaled Y size (in proportion to X), and the scale factors used. Returns TRUE if successfull.

TScaleInfo On Input:
  OriginalSize_X : Horizontal size of the original.
  OriginalSize_Y : Vertical size of the original.
  ScaledSize_X   : Horizontal size to fit.
  ScaledSize_Y   : Not filled in.
  ScaleFactor_X  : Not filled in.
  ScaleFactor_Y  : Not filled in.

TScaleInfo On Output:
  OriginalSize_X : Horizontal size of the original.
  OriginalSize_Y : Vertical size of the original.
  ScaledSize_X   : Horizontal size to fit.
  ScaledSize_Y   : OriginalSize_Y scaled in proportion to X.
  ScaleFactor_X  : Horizontal scaling factor.
  ScaleFactor_Y  : Vertical scaling factor.

Example:

uses
  PrnUtils;

var
  ScaleInfo : TScaleInfo;
begin
  ScaleInfo.OriginalSize_X := 100;
  ScaleInfo.OriginalSize_Y := 200;
  ScaleInfo.ScaledSize_X := 1000;
  ScaleToFitX(@ScaleInfo);
 {Note:}
 {ScaledSize_X now equals 1000}
 {ScaledSize_Y now equals 2000}
 {ScaleFactor_X now equals 10}
 {ScaleFactor_Y now equals 10}
end;

Back to Functions and Structures


ScaleToFitY

function ScaleToFitY(lpScaleInfo : PScaleInfo) : BOOL; stdcall;

Location: PrnUtils.pas

This function accepts a pointer to a TScaleInfo structure. Given an Original(X,Y) and any Y size to fit, this function calculates the scaled X size (in proportion to Y), and the scale factors used. Returns TRUE if successfull.

TScaleInfo On Input:
  OriginalSize_X : Horizontal size of the original.
  OriginalSize_Y : Vertical size of the original.
  ScaledSize_X   : Not filled in.
  ScaledSize_Y   : Vertical size to fit.
  ScaleFactor_X  : Not filled in.
  ScaleFactor_Y  : Not filled in.

TScaleInfo On Output:
  OriginalSize_X : Horizontal size of the original.
  OriginalSize_Y : Vertical size of the original.
  ScaledSize_X   : OriginalSize_X scaled in proportion to Y.
  ScaledSize_Y   : Vertical size to fit.
  ScaleFactor_X  : Horizontal scaling factor.
  ScaleFactor_Y  : Vertical scaling factor.

Example:

uses
  PrnUtils;

var
  ScaleInfo : TScaleInfo;
begin
  ScaleInfo.OriginalSize_X := 100;
  ScaleInfo.OriginalSize_Y := 200;
  ScaleInfo.ScaledSize_Y := 1000;
  ScaleToFitY(@ScaleInfo);
 {Note:}
 {ScaledSize_X now equals 500}
 {ScaledSize_Y now equals 1000}
 {ScaleFactor_X now equals 5}
 {ScaleFactor_Y now equals 5}
end;

Back to Functions and Structures


ScaleToBestFit

function ScaleToBestFit(lpScaleInfo : PScaleInfo) : BOOL; stdcall;

Location: PrnUtils.pas

This function accepts a pointer to a TScaleInfo structure. Given an original(X,Y) and an (X,Y) size to fit, this function calculates the "best fit" scaled X and Y size and the scale factors used. The scaling is done in proportion, and *either* the ScaledSize X or Y will fit in the maximum area allowed, and the other "side" will be scaled for a "best fit". If you wish to use the returned scaling factors to stretch drawing coordinates, always multiply *both* the x and y coordinates you wish to scale using the *smaller* of the ScaleFactor_X or ScaleFactor_Y value returned from the function. Returns TRUE if successful.

TScaleInfo On Input:
  OriginalSize_X : Horizontal size of the original.
  OriginalSize_Y : Vertical size of the original.
  ScaledSize_X   : Maximum horizontal size to fit.
  ScaledSize_Y   : Maximum vertical size to fit.
  ScaleFactor_X  : Not filled in.
  ScaleFactor_Y  : Not filled in.

TScaleInfo On Output:
  OriginalSize_X : Horizontal size of the original.
  OriginalSize_Y : Vertical size of the original.
  ScaledSize_X   : OriginalSize_X scaled to best fit.
  ScaledSize_Y   : OriginalSize_Y scaled to best fit.
  ScaleFactor_X  : Horizontal scaling factor.
  ScaleFactor_Y  : Vertical scaling factor.

Example:

uses
  PrnUtils;

var
  ScaleInfo : TScaleInfo;
  SmallestScaleFactor : double;
begin
  ScaleInfo.OriginalSize_X := 100;
  ScaleInfo.OriginalSize_Y := 200;
  ScaleInfo.ScaledSize_X := 1000;
  ScaleInfo.ScaledSize_Y := 1000;
  ScaleToBestFit(@ScaleInfo);
 {Note:}
 {ScaledSize_X now equals 500}
 {ScaledSize_Y now equals 1000}
 {ScaleFactor_X now equals 10}
 {ScaleFactor_Y now equals 5}
 if (ScaleInfo.ScaleFactor_X < ScaleInfo.ScaleFactor_Y) then begin
   SmallestScaleFactor := ScaleInfo.ScaleFactor_X;
 end else begin
   SmallestScaleFactor := ScaleInfo.ScaleFactor_Y;
 end;
 Canvas.MoveTo(0, 0);
 Canvas.LineTo(Trunc(SmallestScaleFactor * 100),
               Trunc(SmallestScaleFactor * 200));
end;

Back to Functions and Structures


TPixelSizeInfo

type
  PPixelSizeInfo = ^TPixelSizeInfo;
  TPixelSizeInfo = packed record
    DotsPerInch_X : double;
    DotsPerInch_Y : double;
    DotsPerMillimeter_X : double;
    DotsPerMillimeter_Y : double;
    DotsPerPoint_X : double;
    DotsPerPoint_Y : double;
  end;

Location: PrnUtils.pas

This structure is used with the GetPixelSizeInfo() function and returns information pixel measurements in several popular measuring units. Note that the DotsPerPoint member is a "Printers Point" where their 72 points equal one inch. Additional information: 12 points equal one pica, and 6 picas equals one inch.

Back to Functions and Structures


GetPixelSizeInfo

function GetPixelSizeInfo(dc : HDC;
                          lpPixelSizeInfo : PPixelSizeInfo) : BOOL; stdcall;

Location: PrnUtils.pas

This function accepts a given device context (Canvas.Handle), and a pointer to a TPixelSizeInfo structure, and correctly fills out the TPixelSizeInfo structure. If dc value passed in is zero, then information returned is from the screen dc. Returns TRUE if successful.

Example:

uses
  PrnUtils;

var
  PixelSizeInfo : TPixelSizeInfo;
begin
  GetPixelSizeInfo(Printer.Canvas.Handle,
                   @PixelSizeInfo);
end;

Back to Functions and Structures


GetNumPagesRequired

function GetNumPagesRequired(PrinterPageSize : DWORD;
                             ImageSize : DWORD) : DWORD; stdcall;

Location: PrnUtils.pas

Given the page size of a device (x or y), and an image size you wish to print (x or y), returns the number of pages (across or down) required to print imagesize in the direction given.

Example:

uses
  PrnUtils;

var
  NumberOfPagesToPrintAcross : DWORD;
  NumberOfPagesToPrintDown : DWORD;
begin
  NumberOfPagesToPrintAcross := GetNumPagesRequired(Printer.PageWidth,
                                                    20000);
  NumberOfPagesToPrintDown := GetNumPagesRequired(Printer.PageHeight,
                                                  10000);
end;

Back to Functions and Structures


GetMemEx

function GetMemEx(size : PRNUTILS_PTR_UINT) : pointer; stdcall;

Location: PrnUtils.pas

Allocates a memory block and zeros out the memory block. Returns null on failure. This function is preferable over the RTL memory functions when allocating memory for graphics used in a threaded enviroment. Please use the FreeMemEx() function to free the memory block allocated.

Example:

uses
  PrnUtils;

var
  p : pointer;
begin
  p := GetMemEx(1024);
  p := FreeMemEx(p);
end;

Back to Functions and Structures


FreeMemEx

function FreeMemEx(p : pointer) : pointer; stdcall;

Location: PrnUtils.pas

Frees a memory block allocated using the GetMemEx() function. Returns nill on success or returns the original pointer on failure.

Example:

uses
  PrnUtils;

var
  p : pointer;
begin
  p := GetMemEx(1024);
  p := FreeMemEx(p);
end;

Back to Functions and Structures


LoadDIBFromStream

function LoadDIBFromStream(TheStream : TStream;
                           var lpBitmapInfo : pointer;
                           var lpBits : Pointer;
                           var BitmapWidth : integer;
                           var BitmapHeight : integer) : BOOL; stdcall;

Location: PrnUtils.pas

This function loads a DIB (device independent bitmap from a TStream object. The function allocates the neccessary memory for the DIBInfoHeader and the DIB Bits using the GetMemEx() function, and fills in the lpBitmapInfo, lpBits, BitmapWidth, and BitmapHeight parameters. You must use the FreeMemEx() function to free the memory for the lpBitmapInfo and lpBits when you are finished using them.

Note: The stream objects current position is advanced. In the case of a failure (the bitmap is not valid), the stream objects current position may be invalid. If you are storing multiple DIB images in a stream, it is recommended that you either create a table of StreamOffsets for each DIB, or use a header for each bitmap indicating the exact size that the DIB occupies, there may be times when a given DIB may report an invalid size (or the size must be calculated and the DIB Header may be invalid). Using this method will allow you to recover from a read of an improperly formatted DIB image.

Returns TRUE if successful, else returns FALSE.

Example:

uses
  PrnUtils,
  PrnDIB; {A unit from out TExcellentImagePrinter product!}

var
  TheStream : TFileStream;       {a stream}
  BitmapInfo : PBITMAPINFO;      {pointer to a BitmapInfo structure}
  Bits : pointer;                {pointer to the bits}
  BitmapWidth : integer;         {bitmap width}
  BitmapHeight : integer;        {bitmap height}
begin
  TheFileStream := TFileStream.Create('test.bmp',
                                      fmOpenRead OR
                                      fmShareDenyWrite);
  if (NOT LoadDIBFromStream(TheStream,
                            pointer(BitmapInfo),
                            Bits,
                            BitmapWidth,
                            BitmapHeight)) then begin
    TheStream.Free;
    ShowMessage('Bitmap load error');
    exit;
  end;
  TheStream.Free;
  Printer.BeginDoc;
 {A function from out TExcellentImagePrinter product!}
  PrintDIBitmap(Printer.Canvas.Handle,
                BitmapInfo,
                Bits,
                TRUE,
                TRUE);
  Printer.EndDoc;
  FreeMemEx(BitmapInfo);
  FreeMemEx(Bits);
  ShowMessage('Printing Completed!');
end;

Back to Functions and Structures


LoadDIBFromFile

function LoadDIBFromFile(const FileName : string;
                         var lpBitmapInfo : pointer;
                         var lpBits : Pointer;
                         var BitmapWidth : integer;
                         var BitmapHeight : integer) : BOOL; stdcall;

Location: PrnUtils.pas

This function loads a DIB (device independent bitmap) from a file. The function allocates the neccessary memory for the DIBInfoHeader and the DIB Bits using the GetMemEx() function, and fills in the lpBitmapInfo, lpBits, BitmapWidth, and BitmapHeight parameters. You must use the FreeMemEx() function to free the memory for the lpBitmapInfo and lpBits when you are finished using them. Returns TRUE if successful, else returns FALSE.

Example:

uses
  PrnUtils,
  PrnDIB; {A unit from out TExcellentImagePrinter product!}

var
  BitmapInfo : PBITMAPINFO;      {pointer to a BitmapInfo structure}
  Bits : pointer;                {pointer to the bits}
  BitmapWidth : integer;         {bitmap width}
  BitmapHeight : integer;        {bitmap height}
begin
  if (NOT LoadDIBFromFile('test.bmp',
                          pointer(BitmapInfo),
                          Bits,
                          BitmapWidth,
                          BitmapHeight)) then begin
    ShowMessage('Bitmap load error');
    exit;
  end;
  Printer.BeginDoc;
 {A function from out TExcellentImagePrinter product!}
  PrintDIBitmap(Printer.Canvas.Handle,
                BitmapInfo,
                Bits,
                TRUE,
                TRUE);
  Printer.EndDoc;
  FreeMemEx(BitmapInfo);
  FreeMemEx(Bits);
  ShowMessage('Printing Completed!');
end;

LoadDIBFromTBitmap

function LoadDIBFromTBitmap(ABitmap : TBitmap;
                            var lpBitmapInfo : pointer;
                            var lpBits : Pointer;
                            var BitmapWidth : integer;
                            var BitmapHeight : integer) : BOOL; stdcall;

Location: PrnUtils.pas

This function loads a DIB (device independent bitmap) from a VCL TBitmap. The function allocates the neccessary memory for the DIBInfoHeader and the DIB Bits using the GetMemEx() function, and fills in the lpBitmapInfo, lpBits, BitmapWidth, and BitmapHeight parameters. You must use the FreeMemEx() function to free the memory for the lpBitmapInfo and lpBits when you are finished using them.

Note: This function is only as accurate as the VCL in its ability to save a bitmap to a stream. We simply ask the VCL to save the TBitmap to a stream, then we load it from the stream. In some versions of the VCL, the bitmap format may change in the process. Note that LoadDIBFromTBitmap() has proven to be much more reliable than the VCL's GetDibSizes() and GetDIBBits() functions, where we have seen many real world failures (even though the VCL may use these functions internally to save the same bitmap to a stream). This is especially true in a threaded enviroment.

Returns TRUE if successful, else returns FALSE.

Example:

uses
  PrnUtils,
  PrnDIB; {A unit from out TExcellentImagePrinter product!}

var
  BitmapInfo : PBITMAPINFO;      {pointer to a BitmapInfo structure}
  Bits : pointer;                {pointer to the bits}
  BitmapWidth : integer;         {bitmap width}
  BitmapHeight : integer;        {bitmap height}
begin
  if (NOT LoadDIBFromTBitmap(Image1.Picture.Bitmap,
                             pointer(BitmapInfo),
                             Bits,
                             BitmapWidth,
                             BitmapHeight)) then begin
    ShowMessage('Bitmap load error');
    exit;
  end;
  Printer.BeginDoc;
 {A function from a TExcellentImagePrinter product!}
  PrintDIBitmap(Printer.Canvas.Handle,
                BitmapInfo,
                Bits,
                TRUE,
                TRUE);
  Printer.EndDoc;
  FreeMemEx(BitmapInfo);
  FreeMemEx(Bits);
  ShowMessage('Printing Completed!');
end;

Back to Functions and Structures


TAbortDialog

type
  TAbortDialog = class(TForm)
    btnCancel: TButton;
    procedure btnCancelClick(Sender: TObject);
  private
    { Private declarations }
    Canceled : BOOL;
  public
    { Public declarations }
    function Aborted : BOOL;
  end;

Location: PrnUtils.pas

An abort dialog box used by the TExcellentPrinter family of products. We have designed wrapper functions to create, query, and free this dialog class. While you are free to use the class directly, we discourage this practice, as it may not be upwardly compatible with updates to the TExcellentPrinter family of products. In addition, by using the wrapper functions, we can assure compatibility with many of our products when used from other non-VCL languages, as we plan to offer many of our products in a DLL format where the wrapper functions can be called.

Back to Functions and Structures


TPrinterAbortDialog

type
  TPrinterAbortDialog = TAbortDialog;

Location: PrnUtils.pas

A backwards compatible Abort Dialog prototype for use with code that was written for earlier versions of our products.

Back to Functions and Structures


CreateAbortDialog

function CreateAbortDialog(ApplicationHandle : THandle;
                           AOwner: TComponent) : TAbortDialog; stdcall;

Location: PrnUtils.pas

Creates and shows an abort dialog. ApplicationHandle should be set to Application.Handle when called from an executable, and should be set to the Application.Handle of the calling executable when used from a Dynamic Link Library. Returns a 32bit object reference to an TAbortDialog if successful, or nil on failure.

Example:

uses
  PrnUtils,

var
  AbortDialog : TAbortDialog; {any 32 bit type will so if calling from a non VCL language}
begin
  AbortDialog := CreateAbortDialog(Application.Handle,
                                   self);
  AbortDialogSetCaption(AbortDialog,
                        'Printing');
 {do some lengthy operation}
  if (AbortDialogUserHasCanceled(AbortDialog)) then begin
    {Abort the process}
  end;
  FreeAbortDialog(AbortDialog);
end;

Back to Functions and Structures


FreeAbortDialog

procedure FreeAbortDialog(AbortDialog : TAbortDialog); stdcall;

Location: PrnUtils.pas

Frees an abort dialog.

Example:

uses
  PrnUtils,

var
  AbortDialog : TAbortDialog; {any 32 bit type will so if calling from a non VCL language}
begin
  AbortDialog := CreateAbortDialog(Application.Handle,
                                   self);
  AbortDialogSetCaption(AbortDialog,
                        'Printing');
 {do some lengthy operation}
  if (AbortDialogUserHasCanceled(AbortDialog)) then begin
    {Abort the process}
  end;
  FreeAbortDialog(AbortDialog);
end;

Back to Functions and Structures


AbortDialogSetCaption

procedure AbortDialogSetCaption(AbortDialog : TAbortDialog;
                                s : pChar); stdcall;

Location: PrnUtils.pas

Sets the caption of an abort dialog.

Example:

uses
  PrnUtils,

var
  AbortDialog : TAbortDialog; {any 32 bit type will so if calling from a non VCL language}
begin
  AbortDialog := CreateAbortDialog(Application.Handle,
                                   self);
  AbortDialogSetCaption(AbortDialog,
                        'Printing');
 {do some lengthy operation}
  if (AbortDialogUserHasCanceled(AbortDialog)) then begin
    {Abort the process}
  end;
  FreeAbortDialog(AbortDialog);
end;

Back to Functions and Structures


AbortDialogUserHasCanceled

function AbortDialogUserHasCanceled(AbortDialog : TAbortDialog) : BOOL; stdcall;

Location: PrnUtils.pas

Returns TRUE if the user has pressed the cancel button of an abort dialog.

Example:

uses
  PrnUtils,

var
  AbortDialog : TAbortDialog; {any 32 bit type will so if calling from a non VCL language}
begin
  AbortDialog := CreateAbortDialog(Application.Handle,
                                   self);
  AbortDialogSetCaption(AbortDialog,
                        'Printing');
 {do some lengthy operation}
  if (AbortDialogUserHasCanceled(AbortDialog)) then begin
    {Abort the process}
  end;
  FreeAbortDialog(AbortDialog);
end;

Back to Functions and Structures


CreatePrinterAbortDialog

function CreatePrinterAbortDialog(ApplicationHandle : THandle;
                                  AOwner: TComponent) : TPrinterAbortDialog; stdcall;

Location: PrnUtils.pas

This is a backwards compatible wrapper function for code that was written for earlier versions of our products. We now encourage you to use the newer CreateAbortDialog() function where possible. The documentation for this function is the same as the CreateAbortDialog() function.

Back to Functions and Structures


FreePrinterAbortDialog

procedure FreePrinterAbortDialog(AbortDialog : TPrinterAbortDialog); stdcall;

Location: PrnUtils.pas

This is a backwards compatible wrapper function for code that was written for earlier versions of our products. We now encourage you to use the newer FreeAbortDialog() function where possible. The documentation for this function is the same as the FreeAbortDialog() function.

Back to Functions and Structures


PrinterAbortDialogSetCaption

procedure PrinterAbortDialogSetCaption(AbortDialog : TPrinterAbortDialog;
                                       ACaption : TCaption); stdcall;

Location: PrnUtils.pas

This is a backwards compatible wrapper function for code that was written for earlier versions of our products. We now encourage you to use the newer AbortDialogSetCaption() function where possible. The documentation for this function is the same as the AbortDialogSetCaption() function.

Back to Functions and Structures


PrinterAbortDialogAborted

function PrinterAbortDialogAborted(AbortDialog : TPrinterAbortDialog) : BOOL; stdcall;

Location: PrnUtils.pas

This is a backwards compatible wrapper function for code that was written for earlier versions of our products. We now encourage you to use the newer AbortDialogUserHasCanceled() function where possible. The documentation for this function is the same as the AbortDialogUserHasCanceled() function.

Back to Functions and Structures


Validate HTML