Using the printer

This is an old revision of Using the printer, edited by Abeomega at . The current revision is 70416.

Added information. Finalized the content.

Introduction

Printing is easy in FreePascal. But, only after you follow some required steps. First steps first. After those first steps, you can branch out to more advanced printing. This article discusses the required steps, as collected from various forum pages and examples. After the basic steps, we are going to print some text. Finally a hint of some more advanced printing is given.

The Basic Steps

The following you must do to be able to use printers.

  1. Add the Printer4Lazarus package to your project requirements.
  2. Add the Printers unit to the uses section of your unit.
  3. Use the existing Printer object.

Adding the Printer4Lazarus package to your project requirements

The Printer4Lazarus package defines a basic printer and provides platform independent printing. The following can thus be used on various platforms.

In the Lazarus IDE, do the following:

  1. In the Project menu, click Project Inspector. A window is shown with a tree view, one of the branches is named Required Packages. By default, the Required Packages branch shows the LCL package.
  2. Click the Add button, the button with the plus sign at the top of the window.
  3. Open the New Requirements page.
  4. From the Package Name list box, select Printer4Lazarus.
  5. Click OK.
  6. Printer4Lazarus is now shown in the Required Packages branch.

Adding the Printers unit to the uses section of your unit

This is simple and straight forward and could look like this:

unit MainUnt;
{$mode objfpc}{$H+}
interface
uses
 Classes, SysUtils, Forms, Printers;

Using the existing Printer object

Assuming you want to click a button to print a text. On you form you put a button called PrintBtn and in the OnClick event you can now use the following:

procedure TForm1.PrintBtnClick(Sender: TObject);
const
  LEFTMARGIN = 100;
  HEADLINE = 'I Printed My Very First Text On ';
var
  YPos, LineHeight, VerticalMargin : Integer;
  SuccessString : String;
  MyPrinter : TPrinter;
begin
  MyPrinter := Printer;
  MyPrinter.BeginDoc;
    MyPrinter.Canvas.Font.Name := 'Courier New';
    MyPrinter.Canvas.Font.Size:=10;
    MyPrinter.Canvas.Font.Color:= clBlack;
    LineHeight := Round(1.2 * Abs(MPrinter.Canvas.TextHeight('I')));
    VerticalMargin := 4 * LineHeight;
    //There we go
    YPos := VerticalMargin;
    SuccessString := HEADLINE + DateTimeToStr(Now);
    MPrinter.Canvas.TextOut(LEFTMARGIN, YPos, SuccessString);
  MyPrinter.EndDoc;
 end;

Did I write basic and simple. The above example is somewhat complex. Next to the basic text output in the bold line, it also provides an example of formatting your text.

From begin to end; the following happens.

In some forums it is suggested that the use of PrintDialog (the printer selection dialog) is required for good functioning, but I did not find this to be true (any more).

Next steps

After the above basic steps, you can do the next steps. I leave it to the reader to try:

In the Lazarus distribution there is an example project that uses Raw printing to the printer. You can find this example with the following location(on Windows): C:\lazarus\components\printers\samples\rawmode\rawmodetest.lpi. Another sample shows how to select another printer: C:\lazarus\components\printers\samples\dialogs\selectprinter.lpi.

Advanced steps

The printer object primarily allows you to draw on a canvas and send that canvas image to the printer. If we continue on the path shown above, then you would use the printer's canvas methods to draw text, ellipses, diamonds and what not. However, this can hardly be interesting to any serious programmer. You are working on a more perfect CAD program or yet another image file sorter and want to print the wonderful result of your program to your printer. Trying to translate the perfect picture into canvas method calls is not the way, you already have the picture.

Each and every control you put on a form, also draws a picture on a TCanvas object just like the printer. We can use that to bring the big picture to the printer. Imagine you are going to make a preview program. You create a form and on this form you put a TPanel, this panel will provide the nice grayish background of the preview. On this panel you put another TPanel object called page. This page will be white and represents the paper. You can nicely size the page. On this page we put a TShape object, for example a nice red, rounded rectangle. Now try the following in the PrintBtnClick event method:

 MyPrinter.BeginDoc;
   page.PaintTo(myPrinter.Canvas, 0, 0);
 MyPrinter.EndDoc;

What happens:

And on we go

The printer uses a lot more pixels per inch on paper than the monitor uses pixels per inch on the screen. As a result, the output that is redirected from the screen to the printer ends up rather smallish on the paper. Scaling and controlling the layout is important for good looking output. It would be nice if you can have an exact sized copy of what you see on the screen.

For the moment we are not striving for the ideal, just for the idea. As said before, controls do not have their own canvas but rely on the canvas of a container or owner. However, there are components that have their own canvas. I chose TBitMap and then it works as follows.

procedure TForm1.PrintBtnClick(Sender: TObject);
var
  MyPrinter : TPrinter;
  myBitMap : TBitMap;
begin
  myBitMap := TBitMap.Create;
  myBitMap.Width := page.Width;
  myBitMap.Height := page.Height;
  page.BorderStyle:=bsNone;
  page.PaintTo(myBitMap.Canvas, 0, 0);
  page.BorderStyle:=bsSingle;
  //
  MyPrinter := Printer;
  MyPrinter.BeginDoc;
    //page.PaintTo(myPrinter.Canvas, 0, 0);
    //myPrinter.Canvas.Draw(0,0, myBitMap);
    myPrinter.Canvas.CopyRect(Classes.Rect(0, 0, myPrinter.PaperSize.Width, myPrinter.PaperSize.Height),
       myBitMap.Canvas, Classes.Rect(0, 0, myBitMap.Width, myBitMap.Height));
  MyPrinter.EndDoc;
  myBitMap.Free;
end;

For this to work do not use the Windows unit. The Windows unit has other definitions for Rect. What you see in the example is the following:

A problem with this way of working is of course that the pixels of the screen will show on the printed paper. As said, it is not ideal but it shows a principle. Controls do not have their own canvas, to print controls we first paint them on an object that does have its own canvas the TBitMap. Now you know how it works, you can figure out a way to create fine artwork or documents. This will need objects that draw themselves properly in a TPanel with low resolution, but also on a TBitMap with high resolution. But, that is food for another article.