This appendix provides information about printing and the graphics classes used by Windows Forms applications. Printing is different in Windows Forms and WPF applications. The next sections explain how to print in a Windows Forms application. The sections after that explain how to print in a WPF application.

Windows Forms Printing

The following section explains the basic printing process in a Windows Forms application. The section after that summarizes graphics classes and methods used to print in that kind of application.

Printing Steps

The following steps summarize how to print in a Windows Forms application.

1. Create a PrintDocument object either at design time or at run time.
2. Start the printing process by doing one of the following:
   1. To send a printout to a printer, call the PrintDocument object’s Print method.
   2. To display a print preview in a PrintPreviewDialog:
      1. Create a PrintPreviewDialog object either at design time or at run time.
      2. Set the object’s Document property equal to the PrintDocument object you created in Step 1.
      3. Call the dialog’s ShowDialog method to display it.
   3. To display a print preview in a PrintPreviewControl:
      1. Create a PrintPreviewControl object either at design time or at run time.
      2. Set the object’s Document property equal to the PrintDocument object you created in Step 1.
3. Catch the PrintDocument object’s events to generate the printout.

The following list summarizes the events raised by the PrintDocument object.

• BeginPrint—This event indicates that printing is about to begin. The program can use this event to prepare for printing.
• QueryPageSettings—This event occurs when the PrintDocument object is about to generate a new page. The program can use this event to make changes that are specific to the page it is about to print.
• PrintPage—This event is raised to generate a page of output. The program catches this event and uses the e.Graphics parameter to generate output. After it finishes printing the page, the program sets the value e.HasMorePages to indicate whether there are more pages to print.
• EndPrint—This event is raised when printing is finished. The program can use it to clean up any data structures or resources it used while printing.

The PrintPage event receives a parameter e that includes several properties that are useful when printing. The following list summarizes those properties.

• Cancel—Set this to true to cancel the printout.
• Graphics—This is a Graphics object that the program can use to produce graphics.
• HasMorePages—Set this to true or false to indicate whether there are more pages to print after the current one.
• MarginBounds—This indicates the page boundaries inside the page’s margins. Normally you should draw inside these bounds.
• PageBounds—This indicates the page’s printable boundaries.
• PageSettings—This gives the page settings such as the paper size, a value indicating whether the page is printing in landscape mode, and the printer’s resolution.

Graphics Namespaces

The following list summarizes the most important graphics namespaces and their most useful classes, structures, and enumerated values.

• System.Drawing—This namespace defines the most important graphics objects including Bitmap, Brush, Color, Font, FontFamily, Graphics, Icon, Image, Metafile, Pen, Pens, Point, PointF, Rectangle, RectangleF, Region, Size, SizeF, and SolidBrush.
• System.Drawing.Drawing2D—This namespace contains classes for more advanced two-dimensional drawing and classes that refine more basic drawing classes. Classes and enumerations defined in this namespace include Blend, ColorBlend, DashCap, DashStyle, GraphicsPath, HatchBrush, HatchStyle, LinearGradientBrush, LineCap, LineJoin, Matrix, and PathGradientBrush.
• System.Drawing.Imaging—This namespace contains classes that deal with more advanced bitmap graphics including ColorMap, ColorPalette, ImageFormat, Metafile, MetafileHeader, MetaHeader, and WmfPlaceableFileHeader.
• System.Drawing.Printing—This namespace contains objects used for printing and managing the printer’s characteristics including Margins, PageSettings, PaperSize, PaperSource, PrinterResolution, and PrinterSettings.
• System.Drawing.Text—This namespace contains classes for working with installed fonts including FontCollection, InstalledFontCollection, and PrivateFontCollection.

Drawing Graphics

The basic steps for drawing in C# are to obtain a Graphics object and use its methods to draw shapes. Brush classes determine how shapes are filled, and Pen classes determine how lines are drawn.

The following sections describe the most useful properties and methods provided by key drawing classes.

Graphics

The Graphics object represents a drawing surface. The following table lists the Graphics object’s drawing methods.

The following table lists the Graphics object’s area filling methods.

The following table lists other useful Graphics object properties and methods.

Pen

The Pen object determines the appearance of drawn lines. The following table lists the Pen object’s most useful properties and methods.

Brushes

The Brush class is an abstract class, so you cannot make instances of it. Instead, you must make instances of one of its derived classes. The following table briefly describes these derived classes.

GraphicsPath

The GraphicsPath object represents a path defined by lines, curves, text, and other drawing commands. The following table lists the GraphicsPath object’s most useful properties and methods.

StringFormat

The StringFormat object determines how text is formatted. The following table lists the StringFormat object’s most useful properties and methods.

Image

The Image class represents the underlying physical drawing surface hidden below the logical layer created by the Graphics class. The Image is abstract, so you cannot directly instantiate it. Instead, you must instantiate its child classes Bitmap and Metafile. The following table describes the Image class’s most useful properties and methods, which are inherited by the Bitmap and Metafile classes.

Bitmap

The Bitmap class represents an image defined by pixel data. The following table describes the class’s most useful methods that are not inherited from the Image class.

Metafile

The Metafile class represents an image defined by metafile records. The following table describes the class’s most useful methods that are not inherited from the Image class.

WPF Printing

To create a printout, a WPF application creates objects that represent lines, shapes, text, and whatever else needs to be printed. The program can scale those objects as necessary to fit the printout and the result takes advantage of the printer’s capabilities.

There are several ways a WPF application can produce printouts. The following sections describe two of the more useful: using a paginator and creating documents.

Using a Paginator

A paginator is an object that generates a printout’s pages. To create a printout by using a paginator, derive a new class from the DocumentPaginator class. Override the GetPage method to create the document’s pages. Also override the following properties.

• IsPageCountValid—Returns true if all pages have been created. Returns false if some pages have not yet been generated
• PageCount—Returns the number of pages that have been formatted
• PageSize—Gets or sets the suggested size of the printed page
• Source—Returns the element being paginated

Creating Documents

The FlowDocument and FixedDocument classes allow you to arrange objects on a printout. The classes automatically arrange the objects appropriately. For example, they let you make text flow around other objects. The following sections describe these two document classes.

FlowDocuments

A FlowDocument object holds other objects that represent graphical output such as text, images, and shapes. It arranges its objects to take best advantage of whatever space is available, much as a web browser rearranges its contents when it is resized.

The following code shows a short FlowDocument.

<Window x:Class="WpfFlowDocument.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="WpfFlowDocument" Height="350" Width="525">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="30"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Button Grid.Row="0"
            Content="Print" Click="printButton_Click"
            Width="100" Height="30" VerticalAlignment="Top"/>
        <FlowDocumentReader Grid.Row="1" VerticalAlignment="Top">
            <FlowDocument Name="sampleFlowDocument">
                <Paragraph FontSize="20" FontWeight="Bold">
                    Chapter 1. Lorem Ipsum
                </Paragraph>

                <Paragraph FontSize="16" FontWeight="Bold">
                    Dolor Sit Amet
                </Paragraph>

                <Paragraph>
                    <Floater HorizontalAlignment="Right">
                        <Paragraph>
                            <Grid Width="100" Height="100">
                                <Border BorderBrush="Black" BorderThickness="1"/>
                                <Polygon 
                                    Points="50,5 95,50 50,95 5,50"
                                    Stroke="Black" StrokeThickness="5" />
                            </Grid>
                        </Paragraph>
                    </Floater>
                    Consectetur adipiscing elit ...
                </Paragraph>
                <Paragraph>
                    Nullam dapibus dapibus ...
                </Paragraph>

                <Paragraph>
                    Etiam lacus eros ...
                </Paragraph>

            </FlowDocument>
        </FlowDocumentReader>
    </Grid>
</Window>

See the WPF documentation for information about the classes that you can use to produce output.

FixedDocuments

Like a FlowDocument, a FixedDocument holds graphical objects. Instead of rearranging its objects as space permits, a FixedDocument always places its objects in the same positions. This is similar to the way a PostScript document displays items at fixed positions.

The following code shows XAML that defines a FixedDocument inside a DocumentViewer.

<DocumentViewer Grid.Row="1">
    <FixedDocument Name="sampleFixedDocument">
        <PageContent Width="850" Height="1100">
            <FixedPage Width="850" Height="1100" Margin="100">
                ... Page 1 content elements ...
            </FixedPage>
        </PageContent>
        <PageContent Width="850" Height="1100">
            <FixedPage Width="850" Height="1100" Margin="100">
                ... Page 1 content elements ...
            </FixedPage>
        </PageContent>
    </FixedDocument>
</DocumentViewer>