The FontFamily class has two primary purposes: to create a FontFamily object that is later used to create an instance of a Font, or to provide the names of all font families available on the user's computer system.

public FontFamily (string name);
public FontFamily (GenericFontFamilies genfamilies);

FontFamily ff = new FontFamily("Arial");  // Arial family

FontFamily ff = new FontFamily(GenericFontFamilies.Monospace);

string txt = "";
foreach (FontFamily ff in FontFamily.Families)
{
   txt += ff.Name;
   if (ff.IsStyleAvailable(FontStyle.Bold))txt= += " (B)";
   txt += "
"; // Line feed
}
textBox1.Text = txt;   // Place font family names in textbox

Although several constructors are available for creating fonts, they fall into two categories based on whether their first parameter is a FontFamily type or a string containing the name of a FontFamily. Other parameters specify the size of the font, its style, and the units to be used for sizing. Here are the most commonly used constructors:

Constructors:

public Font(FontFamily ff, Float emSize);
public Font(FontFamily ff, Float emSize, FontStyle style);
public Font(FontFamily ff, Float emSize, GraphicsUnit unit);
public Font(FontFamily ff, Float emSize, FontStyle style,
            GraphicsUnit unit);

public Font(String famname, Float emSize);
public Font(String famname, Float emSize, FontStyle style);
public Font(String famname, Float emSize, GraphicsUnit unit);
public Font(String famname, Float emSize, FontStyle style,
            GraphicsUnit unit); 

Parameters:

GraphicsUnits and sizing are discussed later in this section.

FontFamily ff = new FontFamily("Arial");
Font normFont = new Font(ff,10);      // Arial Regular 10 pt.

Font normFont = new Font("Arial",10)  // Arial Regular 10 point

Font boldFont = new Font("Arial",10,FontStyle.Bold);
Font bldItFont = new Font("Arial",10,
      FontStyle.Bold | FontStyle.Italic); // Arial bold italic 10

using (Font normFont = new Font("Arial",12)) {

Using Font Metrics to Determine Font Height

The term font metrics refers to the characteristics that define the height of a font family. .NET provides both Font and FontClass methods to expose these values. To best understand them, it is useful to look at the legacy of typesetting and the terms that have been carried forward from the days of Gutenberg's printing press to the .NET Framework Class Library.

In typography, the square grid (imagine graph paper) used to lay out the outline (glyph) of a font is referred to as the em square. It consists of thousands of cells—each measured as one design unit. The outline of each character is created in an em square and consists of three parts: a descent, which is the part of the character below the established baseline for all characters; the ascent, which is the part above the baseline; and the leading, which provides the vertical spacing between characters on adjacent lines (see Figure 9-2).

Figure 9-2. Font metrics: the components of a font

Table 9-1 lists the methods and properties used to retrieve the metrics associated with the em height, descent, ascent, and total line space for a font family. Most of the values are returned as design units, which are quite easy to convert to a GraphicsUnit. The key is to remember that the total number of design units in the em is equivalent to the base size argument passed to the Font constructor. Here is an example of retrieving metrics for an Arial 20-point font:

FontFamily ff = new FontFamily("Arial");
Font myFont   = new Font(ff,20);   // Height is 20 points
int emHeight  = ff.GetEmHeight(FontStyle.Regular);     // 2048
int ascHeight = ff.GetCellAscent(FontStyle.Regular);   // 1854
int desHeight = ff.GetCellDescent(FontStyle.Regular);  // 434
int lineSpace = ff.GetLineSpacing(FontStyle.Regular);  // 2355
// Get Line Height in Points (20 x (2355/2048))
float guHeight = myFont.Size * (lineSpace / emHeight); // 22.99
float guHeight2 = myFont.GetHeight(); // 30.66 pixels

Table 9-1. Using Font and FontFamily to Obtain Font Metrics

Member	Units	Description
FontFamily.GetEmHeight	Design units	The height of the em square used to design the font family. TrueType fonts usually have a value of 2,048.
FontFamily.GetCellAscent	Design units	The height of a character above the base line.
FontFamily.GetCellDescent	Design units	The height of a character below the base line.
FontFamily.GetLineSpacing	Design units	The total height reserved for a character plus line spacing. The sum of CellAscent, CellDescent, and Leading (see Figure 9-2). This value is usually 12 to 15 percent greater than the em height.
Font.Size	Graphics unit	The base size (size passed to constructor).
Font.SizeInPoints	Points	The base size in points.
Font.GetHeight	Pixels	The total height of a line. Calculated by converting LineSpacing value to pixels.

The primary value of this exercise is to establish familiarity with the terms and units used to express font metrics. Most applications that print or display lines of text are interested primarily in the height of a line. This value is returned by the Font.GetHeight method and is also available through the Graphics.MeasureString method described in the next section.

Definitions:
cell height	=	ascent + descent
em height	=	cell height – internal leading
line spacing	=	cell height + external leading

Several Drawstring overloads receive a rectangle to define where the output string is drawn. Text drawn into these rectangular areas is automatically wrapped to the next line if it reaches beyond the rectangle's boundary. The following code displays the fragment of poetry in an area 200 pixels wide and 50 pixels high.

String s = "and ice mast high came floating by as green 
   as emerald."
// All units in pixels
RectangleF rf = new RectangleF(20,5,200,50); 
// Fit text in rectangle
g.Drawstring(s,regFont,Brushes.Black, rf); 

Word wrapping is often preferable to line truncation, but raises the problem of determining how many lines of text must be accommodated. If there are more lines of text than can fit into the rectangle, they are truncated. To avoid truncation, you could calculate the height of the required rectangle by taking into account the font (f), total string length(s), and rectangle width (w). It turns out that .NET Graphics.MeasureString method performs this exact operation. One of its overloads takes the string, font, and desired line width as arguments, and returns a SizeF object whose Width and Height properties provide pixel values that define the required rectangle.

SizeF sf = g.MeasureString(String s, Font f, int w);

Using this method, the preceding code can be rewritten to handle the dynamic creation of the bounding rectangle:

Font regFont = new Font("Tahoma",12);
String s = "and ice mast high came floating by as green 
   as emerald."
int lineWidth = 200;
SizeF sf = g.MeasureString(s, regFont, lineWidth);
// Create rectangular drawing area based on return 
// height and width
RectangleF rf = new RectangleF(20,5,sf.Width, sf.Height); 
// Draw text in rectangle
g.Drawstring(s,regFont,Brushes.Black, rf); 
// Draw rectangle around text
g.DrawRectangle(Pens.Red,20F,5F,rf.Width, rf.Height);

Note that DrawString recognizes newline ( ) characters and creates a line break when one is encountered.

When passed as an argument to the DrawString method, a StringFormat object can provide a number of formatting effects. It can be used to define tab positions, set column widths, apply right or left justification, and control text wrapping and truncation. As we will see in the next section, it is the primary tool for creating formatted reports. The members that we will make heaviest use of are shown in Table 9-2.

Tab stops provide a way to align proportionate-spaced font characters into columns. To set up tab stops, you create a StringFormat object, use its SetTabStops method to define an array of tab positions, and then pass this object to the DrawString method along with the text string containing tab characters ( ).

Core Note

If no tab stops are specified, default tab stops are set up at intervals equal to four times the size of the font. A 10-point font would have default tabs every 40 points.

As shown in Table 9-2, the SetTabStops method takes two arguments: the offset from the beginning of the line and an array of floating point values that specify the distance between tab stops. Here is an example that demonstrates various ways to define tab stops:

float[] tStops = {50f, 100f, 100f};  //Stops at: 50, 150, and 250
float[] tStops = {50f};        // Stops at: 50, 100, 150

You can see that it is not necessary to specify a tab stop for every tab. If a string contains a tab for which there is no corresponding tab stop, the last tab stop in the array is repeated. Listing 9-1 demonstrates using tabs to set column headers.

private void RePaint(object sender, PaintEventArgs e)
{
   Graphics g = e.Graphics;
   Font hdrFont = new Font("Arial", 10,FontStyle.Bold);
   Font bdyFont = new Font("Arial", 10); 
   // (1) Create StringFormat Object
   StringFormat strFmt = new StringFormat();
   // (2) Define Tab stops
   float[] ts = {140,60,40};
   strFmt.SetTabStops(0, ts);
   // (3) Define column header text to be printed with tabs
   string header = "Artist	Country	Born	Died";
   // (4) Print column headers
   g.DrawString(header, hdrFont, Brushes.Black,10,10,strFmt);
   // Print one line below header
   string artist = "Edouard Manet	England	1832	1892";
   g.DrawString(artist,bdyFont,Brushes.Black,10,
                10 + bdyFont.GetHeight(), strFmt); 
   bdyFont.Dispose();
   hdrFont.Dispose();
}

Figure 9-3 shows the four-column output from this code. Note that the second column begins at the x coordinate 150, which is the first tab stop (140) plus the x coordinate (10) specified in DrawString.

Figure 9-3. Printing with tab stops

The unit of measurement in this example is a pixel. This unit of measurement is determined by the Graphics.PageUnit property. To override the default (pixels), set the property to a GraphicsUnit enumeration value—for example, g.PageUnit = GraphicsUnit.Inch. Be aware that all subsequent drawing done with the Graphics object will use these units.

Core Note

The use of tab spaces only supports left justification for proportionate fonts. If you need right justification—a virtual necessity for displaying financial data—pass a rectangle that has the appropriate coordinates to the DrawString method. Then, set the Alignment property of StringFormat to StringAlignment.Far.

The StringFormat Trimming and Alignment properties dictate how text is placed within a RectangleF object. Alignment works as you would expect, allowing you to center, right justify, or left justify a string. Trimming specifies how to truncate a string that extends beyond the boundaries of a rectangle when wrapping is not in effect. The basic options are to truncate on a word or character.

The following code segments demonstrate some of the common ways these properties can be used to format text strings.

Example 1: Printing Without a StringFormat Object

Font fnt = new Font("Tahoma",10,FontStyle.Bold);
RectangleF r = new RectangleF(5,5,220,60);
string txt = "dew drops are the gems of morning";
g.DrawString(txt,fnt,Brushes.Black,r);
g.DrawRectangle(Pens.Red,r.X,r.Y,r.Width,r.Height);

Example 2: Printing with NoWrap Option

StringFormat strFmt = new StringFormat();
strFmt.FormatFlags = StringFormatFlags.NoWrap;
g.DrawString(txt,fnt,Brushes.Black,r,strFmt);

Example 3: Printing with NoWrap and Clipping on a Word

StringFormat strFmt = new StringFormat();
strFmt.FormatFlags = StringFormatFlags.NoWrap;
strFmt.Trimming = StringTrimming.Word;
g.DrawString(txt,fnt,Brushes.Black,r,strFmt);

Example 4: Printing with NoWrap, Clipping on Word, and Right Justification

StringFormat strFmt = new StringFormat();
strFmt.FormatFlags = StringFormatFlags.NoWrap;
strFmt.Trimming = StringTrimming.Word;
strFmt.Alignment = StringAlignment.Far;
g.DrawString(txt,fnt,Brushes.Black,r,strFmt);

StringFormat also has a LineAlignment property that permits a text string to be centered vertically within a rectangle. To demonstrate, let's add two statements to Example 4:

strFmt.Alignment = StringAlignment.Center;
strFmt.LineAlignment = StringAlignment.Center;

The PrintDocument class—a member of the System.Drawing.Printing namespace—provides the methods, properties, and events that control the print process. Consequently, the first step in setting up a program that sends output to a printer is to create a PrintDocument object.

PrintDocument pd = new PrintDocument();

The printing process in initiated when the PrintDocument.Print method is invoked. As shown in Figure 9-4, this triggers the BeginPrint and PrintPage events of the PrintDocument class.

Figure 9-4. PrintDocument events that occur during the printing process

An event handler wired to the PrintPage event contains the logic and statements that produce the output. This routine typically determines how many lines can be printed—based on the page size—and contains the DrawString statements that generate the output. It is also responsible for notifying the underlying print controller whether there are more pages to print. It does this by setting the HasMorePages property, which is passed as an argument to the event handler, to true or false.

The basic PrintDocument events can be integrated with print dialog boxes that enable a user to preview output, select a printer, and specify page options. Listing 9-2 displays a simple model for printing that incorporates the essential elements required. Printing is initiated when btnPrint is clicked.

using System.Drawing;
using System.Drawing.Printing;
using System.Windows.Forms;
// Code for Form class goes here
   // Respond to button click
   private void btnPrint_Click(object sender, 
                               System.EventArgs e)
   { PrintReport();   }
   // Set up overhead for printing
   private void PrintReport() 
   {
      // (1) Create PrintDocument object
      PrintDocument pd = new PrintDocument();
      // (2) Create PrintDialog
      PrintDialog pDialog = new PrintDialog();
      pDialog.Document = pd;
      // (3) Create PrintPreviewDialog
      PrintPreviewDialog prevDialog = new PrintPreviewDialog();
      prevDialog.Document = pd;
      // (4) Tie event handler to PrintPage event
      pd.PrintPage += new PrintPageEventHandler(Inven_Report);
      // (5) Display Print Dialog and print if OK received
      if (pDialog.ShowDialog()== DialogResult.OK) 
      {
         pd.Print(); // Invoke PrintPage event
      }
   }
   private void Inven_Report(object sender, 
                             PrintPageEventArgs e)
   {
      Graphics g = e.Graphics;
      Font myFont = new Font("Arial",10);
      g.DrawString("Sample Output",myFont,Brushes.Black,10,10);
      myFont.Dispose();
   }
}

This simple example illustrates the rudiments of printing, but does not address issues such as handling multiple pages or fitting multiple lines within the boundaries of a page. To extend the code to handle these real-world issues, we need to take a closer look at the PrintDocument class.

Figure 9-5 should make it clear that the PrintDocument object is involved in just about all aspects of printing: It provides access to paper size, orientation, and document margins through the DefaultPageSettings class; PrinterSettings allows selection of a printer as well as the number of copies and range of pages to be printed; and event handlers associated with the PrintDocument events take care of initialization and cleanup chores related to the printing process. The PrintController class works at a level closer to the printer. It is used behind the scenes to control the print preview process and tell the printer exactly how to print a document.

Figure 9-5. Selected PrintDocument properties and events

An understanding of these classes and events is essential to implementing a robust and flexible printing application that provides users full access to printing options.

The PrinterSettings object maintains properties that specify the printer to be used and how the document is to be printed—page range, number of copies, and whether collating or duplexing is used. These values can be set programmatically or by allowing the user to select them from the Windows PrintDialog component. Note that when a user selects an option on the PrintDialog dialog box, he is actually setting a property on the underlying PrinterSettings object.

PrintDocument pd = new PrintDocument();
PrintDialog pDialog = new PrintDialog();
pDialog.Document = pd;
if (pDialog.ShowDialog()== DialogResult.OK) 
{
   pd.Print(); // Invoke PrintPage event
}

// Place names of printer in printerList ListBox
foreach(string pName in PrinterSettings.InstalledPrinters)
printerList.Items.Add(pName);

string printer= 
      printerList.Items[printerList.SelectedIndex].ToString();
pd.PrinterSettings.PrinterName = printer;

pDialog.AllowSomePages = true;
pd.PrinterSettings.FromPage =1;
pd.PrinterSettings.ToPage = maxPg;
pd.PrinterSettings.MinimumPage=page 1;
pd.PrinterSettings.MaximumPage= maxPg;
if (pDialog.ShowDialog()== DialogResult.OK) 
{
   maxPg = 5;    // Last page to print
   currPg= 1;    // Current page to print
   if (pDialog.PrinterSettings.PrintRange == 
       PrintRange.SomePages)
   {
       currPg = pd.PrinterSettings.FromPage;
       maxPg  = pd.PrinterSettings.ToPage;
   }
   pd.Print(); // Invoke PrintPage event
}

foreach (PrinterResolution pr in 
         pd.PrinterSettings.PrinterResolutions)
{
   if (pr.Kind == PrinterResolutionKind.High)
   {
      pd.PageSettings.PrinterResolution = pr;
      break;
   }
}

The properties of the PageSettings class define the layout and orientation of the page being printed to. Just as the PrinterSettings properties correspond to the PrintDialog, the PageSettings properties reflect the values of the PageSetupDialog.

PageSetupDialog ps = new PageSetupDialog();
ps.Document = pd;   // Assign reference to PrinterDocument 
ps.ShowDialog();

This dialog box lets the user set all the margins, choose landscape or portrait orientation, select a paper type, and set printer resolution. These values are exposed through the DefaultPageSettings properties listed in Figure 9-5. As we will see, they are also made available to the PrintPage event handler through the PrintPageEventArgs parameter and to the QueryPageSettingsEvent through its QueryPageSettingsEventArgs parameter. The latter can update the values, whereas PrintPage has read-only access.

Figure 9-6 illustrates the layout of a page that has the following DefaultPageSettings values:

Bounds.X = 0;
Bounds.Y = 0;
Bounds.Width = 850;
Bounds.Height = 1100;
PaperSize.PaperName = "Letter";
PaperSize.Height = 1100;
PaperSize.Width = 850;
Margins.Left = 100;
Margins.Right = 100;
Margins.Top = 100;
Margins.Bottom = 100;

Figure 9-6. Page settings layout

All measurements are in hundredths of an inch. The MarginBounds rectangle shown in the figure represents the area inside the margins. It is not a PrinterSettings property and is made available only to the PrintPage event handler.

Core Note

Many printers preserve an edge around a form where printing cannot occur. On many laser printers, for example, this is one-quarter of an inch. In practical terms, this means that all horizontal coordinates used for printing are shifted; thus, if DrawString is passed an x coordinate of 100, it actually prints at 125. It is particularly important to be aware of this when printing on preprinted forms where measurements must be exact.

Four PrintDocument events are triggered during the printing process: BeginPrint, QueryPageSettingsEvent, PrintPage, and EndPrint. As we've already seen, PrintPage is the most important of these from the standpoint of code development because it contains the logic and statements used to generate the printed output. It is not necessary to handle the other three events, but they do provide a handy way to deal with the overhead of initialization and disposing of resources when the printing is complete.

pd.BeginPrint += new PrintEventHandler(Rpt_BeginPrint);

private void Rpt_BeginPrint(object sender, PrintEventArgs e)
{
   rptFont = new Font("Arial",10);
   lineHeight= (int)rptFont.GetHeight(); // Line height
}

pd.EndPrint += new PrintEventHandler(Rpt_EndPrint);

private void Rpt_EndPrint(object sender, PrintEventArgs e)
{
   rptFont.Dispose();
}

pd.QueryPageSettings += new 
      QueryPageSettingsEventHandler(Rpt_Query);

private void Rpt_Query(object sender,
                       QueryPageSettingsEventArgs e)
{
   // This is the last chance to change page settings 
   // If first page, change margins for title
   if (currPg ==1) e.PageSettings.Margins = 
                       new Margins(200,200,200,200);
   else e.PageSettings.Margins = new Margins(100,100,100,100);
}

The steps required to create and print a report fall into two categories: setting up the print environment and actually printing the report. The PrinterSettings and PageSettings classes that have been discussed are central to defining how the report will look. After their values are set, it's the responsibility of the PrintPage event handler to print the report to the selected printer, while being cognizant of the paper type, margins, and page orientation.

Figure 9-7 lists some of the generic tasks that an event handler must deal with in generating a report. Although the specific implementation of each task varies by application, it's a useful outline to follow in designing the event handler code. We will see an example shortly that uses this outline to implement a simple report application.

Figure 9-7. Tasks required to print a report

public delegate void PrintPageEventHandler(
      object sender, PrintPageEventArgs e);

The capability to preview a report onscreen prior to printing—or as a substitute for printing—is a powerful feature. It is particularly useful during the development process where a screen preview can reduce debugging time, as well as your investment in print cartridges.

To preview the printer output, you must set up a PrintPreviewDialog object and set its Document property to an instance of the PrintDocument:

PrintPreviewDialog prevDialog = new PrintPreviewDialog();
      prevDialog.Document = pd;

The preview process is invoked by calling the ShowDialog method:

prevDialog.ShowDialog();

After this method is called, the same steps are followed as in actually printing the document. The difference is that the output is displayed in a special preview window (see Figure 9-8). This provides the obvious advantage of using the same code for both previewing and printing.

Figure 9-8. Report can be previewed before printing

This example is intended to illustrate the basic elements of printing a multi-page report. It includes a data source that provides an unknown number of records, a title and column header for each page, and detailed rows of data consisting of left-justified text and right-justified numeric data.

1000761,1050,2PC/DRESSER/MIRROR,185.50 

// Using System.IO namespace is required
// StreamReader sr; is set up in class declaration
sr = new StreamReader("c:\inventory.txt");

Code for the Application

Listing 9-3 contains the code for the PrintDocument event handlers implemented in the application. Because you cannot pass your own arguments to an event handler, the code must rely on variables declared at the class level to maintain state information. These include the following:

StreamReader sr;   // StreamReader to read inventor from file
string[]prtLine;   // Array containing fields for one record
Font rptFont;      // Font for report body
Font hdrFont;      // Font for header
string title= "Acme Furniture: Inventory Report";
float lineHeight;  // Height of a line (100ths inches)

The fonts and StreamReader are initialized in the BeginPrint event handler. The corresponding EndPrint event handler then disposes of the two fonts and closes the StreamReader.

Example 9-3. Creating a Report

// pd.PrintPage  += new PrintPageEventHandler(Inven_Report);
// pd.BeginPrint += new PrintEventHandler(Rpt_BeginPrint);
// pd.EndPrint   += new PrintEventHandler(Rpt_EndPrint);
//
// BeginPrint event handler
private void Rpt_BeginPrint(object sender, PrintEventArgs e)
{
   // Create fonts to be used and get line spacing.
   rptFont = new Font("Arial",10);
   hdrFont = new Font(rptFont,FontStyle.Bold);
   // insert code here to set up Data Source...
}
// EndPrint event Handler
private void Rpt_EndPrint(object sender, PrintEventArgs e)
{
   // Remove Font resources
   rptFont.Dispose();
   hdrFont.Dispose();
   sr.Close();       // Close StreamReader
}
// PrintPage event Handler
private void Inven_Report(object sender, PrintPageEventArgs e)
{
   Graphics g = e.Graphics;
   int xpos= e.MarginBounds.Left;
   int lineCt = 0;
   // Next line returns 15.97 for Arial-10 
   lineHeight = hdrFont.GetHeight(g);
   // Calculate maximum number of lines per page
   int linesPerPage = int((e.MarginBounds.Bottom – 
             e.MarginBounds.Top)/lineHeight –2);
   float yPos = 2* lineHeight+ e.MarginBounds.Top;
   int hdrPos = e.MarginBounds.Top;
   // Call method to print title and column headers
   PrintHdr(g,hdrPos, e.MarginBounds.Left);  
   string prod;
   char[]delim=  {','};
   while(( prod =sr.ReadLine())!=null)
   {
      prtLine= prod.Split(delim,4);
      yPos += lineHeight;   // Get y coordinate of line
      PrintDetail(g,yPos);  // Print inventory record
      if(lineCt > linesPerPage)
      {
         e.HasMorePages= true;
         break;
      }
   }
}
private void PrintHdr( Graphics g, int yPos, int xPos) 
{
   // Draw Report Title
   g.DrawString(title,hdrFont,Brushes.Black,xPos,yPos);
   // Draw Column Header
   float[] ts = {80, 80,200};
   StringFormat strFmt = new StringFormat();
   strFmt.SetTabStops(0,ts);
   g.DrawString("Code	Vendor	Description	Cost", 
         hdrFont,Brushes.Black,xPos,yPos+2*lineHeight,strFmt);
}
private void PrintDetail(Graphics g, float yPos)
{
   int xPos = 100;
   StringFormat strFmt = new StringFormat();
   strFmt.Trimming = StringTrimming.EllipsisCharacter;
   strFmt.FormatFlags = StringFormatFlags.NoWrap;
   RectangleF r = new RectangleF(xPos+160,yPos,
                                 200,lineHeight);
   // Get data fields from array
   string invenid = prtLine[0];
   string vendor  = prtLine[1];
   string desc    = prtLine[2];
   decimal price  = decimal.Parse(prtLine[3]);
   g.DrawString(invenid, rptFont,Brushes.Black,xPos, yPos);
   g.DrawString(vendor, rptFont,Brushes.Black,xPos+80, yPos);
   // Print description within a rectangle
   g.DrawString(desc, rptFont,Brushes.Black,r,strFmt);
   // Print cost right justified 
   strFmt.Alignment = StringAlignment.Far;  // Right justify
   strFmt.Trimming= StringTrimming.None; 
   g.DrawString(price.ToString("#,###.00"), 
        rptFont,Brushes.Black, xPos+400,yPos,strFmt);
}

The PrintPage event handler Inven_Report directs the printing process by calling PrintHdr to print the title and column header on each page and PrintDetail to print each line of inventory data. Its responsibilities include the following:

• Using the MarginBounds rectangle to set the x and y coordinates of the title at the upper-left corner of the page within the margins.

• Calculating the maximum number of lines to be printed on a page. This is derived by dividing the distance between the top and bottom margin by the height of a line. It then subtracts 2 from this to take the header into account.

• Setting the HasMorePages property to indicate whether more pages remain to be printed.

The PrintHdr routine is straightforward. It prints the title at the coordinates passed to it, and then uses tabs to print the column headers. The PrintDetail method is a bit more interesting, as it demonstrates some of the classes discussed earlier in the chapter. It prints the inventory description in a rectangle and uses the StringFormat class to prevent wrapping and specify truncation on a character. StringFormat is also used to right justify the price of an item in the last column.

Figure 9-9 shows an example of output from this application. Measured from the left margin, the first three columns have an x coordinate of 0, 80, and 160, respectively. Note that the fourth column is right justified, which means that its x coordinate of 400 specifies where the right edge of the string is positioned. Vertical spacing is determined by the lineHeight variable that is calculated as

float lineHeight = hdrFont.GetHeight(g);

Figure 9-9. Output from the report example

This form of the GetHeight method returns a value based on the GraphicsUnit of the Graphics object passed to it. By default, the Graphics object passed to the BeginPrint event handler has a GraphicsUnit of 100 dpi. The margin values and all coordinates in the example are in hundredths of an inch. .NET takes care of automatically scaling these units to match the printer's resolution.

The generic PrintDocument class is easy to use, but has shortcomings with regard to data encapsulation. In the preceding example, it is necessary to declare variables that have class-wide scope—such as the StreamReader—to make them available to the various methods that handle PrintDocument events. A better solution is to derive a custom PrintDocument class that accepts parameters and uses properties and private fields to encapsulate information about line height, fonts, and the data source. Listing 9-4 shows the code from the preceding example rewritten to support a derived PrintDocument class.

Creating a custom PrintDocument class turns out to be a simple and straightforward procedure. The first step is to create a class that inherits from PrintDocument. Then, private variables are defined that support the fonts and title that are now exposed as properties. Finally, the derived class overrides the OnBeginPrint, OnEndPrint, and OnPrintPage methods of the base PrintDocument class.

The overhead required before printing the report is reduced to creating the new ReportPrintDocument object and assigning property values.

string myTitle = "Acme Furniture: Inventory Report";
ReportPrintDocument rpd = new ReportPrintDocument(myTitle);
rpd.TitleFont = new Font("Arial",10, FontStyle.Bold);
rpd.ReportFont = new Font("Arial",10);
PrintPreviewDialog prevDialog = new PrintPreviewDialog();
prevDialog.Document = rpd;
prevDialog.ShowDialog();   // Preview Report
// Show Print Dialog and print report
PrintDialog pDialog = new PrintDialog();
pDialog.Document = rpd;
if (pDialog.ShowDialog() == DialogResult.OK) 
{
   rpd.Print();
}

The preceding code takes advantage of the new constructor to pass in the title when the object is created. It also sets the two fonts used in the report.

// Derived Print Document Class
public class ReportPrintDocument: PrintDocument
{
   private Font hdrFont;
   private Font rptFont;
   private string title;
   private StreamReader sr;
   private float lineHeight;
   // Constructors
   public ReportPrintDocument()
   {}
   public ReportPrintDocument(string myTitle)
   {
      title = myTitle;
   }
   // Property to contain report title
   public string ReportTitle
   {
      get {return title;}
      set {title = value;}
   }
   // Fonts are exposed as properties
   public Font TitleFont
   {
      get {return hdrFont;}
      set {hdrFont = value;}
   }
   public Font ReportFont
   {
      get {return rptFont;}
      set {rptFont = value;}
   }
   // BeginPrint event handler
   protected override void OnBeginPrint(PrintEventArgs e)
   {
      base.OnBeginPrint(e);
      // Assign Default Fonts if none selected
      if (TitleFont == null) 
      {
         TitleFont = 
              new Font("Arial",10,FontStyle.Bold);
         ReportFont = new Font("Arial",10);
      }
      / Code to create StreamReader or other data source
      // goes here ...
      sr = new StreamReader(inputFile);
   }
   protected override void OnEndPrint(PrintEventArgs e)
   {
      base.OnEndPrint(e);
      TitleFont.Dispose();
      ReportFont.Dispose();
      sr.Close();
   }
   // Print Page event handler
   protected override void OnPrintPage(PrintPageEventArgs e)
   {
      base.OnPrintPage(e);
      // Remainder of code for this class is same as in 
      // Listing 9-3 for Inven_Report, PrintDetail, and 
      // PrintHdr
   }
}

This example is easily extended to include page numbering and footers. For frequent reporting needs, it may be worth the effort to create a generic report generator that includes user selectable data source, column headers, and column totaling options.