Printing and Drawing with GDI+
Overview
The Microsoft .NET Framework includes a new model for two-dimensional drawing and printing. It's called GDI+, and it's represented by the types in the System.Drawing namespace. GDI+ isn't an entirely new drawing system—in fact, it's really just a .NET wrapper on top of the classic GDI (Graphics Device Interface) functions in the Microsoft Windows API. However, the GDI+ classes make it much easier to draw complex shapes, work with coordinates and transforms, and control image processing and rendering quality. GDI+ is also used for printing.
In this chapter, the recipes deal with two uses of GDI+. First you'll learn about printing, using GDI+ to print simple and complex documents (recipes 12.2 and 12.3). You'll also learn the techniques needed to center and wrap text (recipes 12.4 and 12.5), create a print preview (recipe 12.7), and retrieve information about print queues (recipes 12.8 and 12.9).
The second portion of this chapter deals with custom on-screen drawing and image manipulation, using shapes, fonts, bitmaps, and more. You'll learn how to convert images (12.11), how to use painting techniques (recipes 12.12 and 12.13), and how to remove flicker with double buffering (recipe 12.18). We'll also consider examples that show irregularly shaped windows (recipe 12.19) and owner-drawn controls (recipes 12.20 and 12.21).
Find All Installed Printers
Problem
You need to retrieve a list of available printers.
Solution
Read the names in the PrinterSettings.InstalledPrinters collection.
Discussion
The System.Drawing.Printing.PrinterSettings class encapsulates the settings for a printer and information about the printer. For example, you can use the PrinterSettings class to determine supported paper sizes, paper sources, and resolutions and check for the ability to print color or double-sided (or duplexed) pages. In addition, you can retrieve default page settings for margins, page orientation, and so on.
The PrinterSettings class provides a shared InstalledPrinters collection, which includes the name of every printer that's installed on the computer. If you want to find out more information about the settings for a specific printer, you simply need to create a PrinterSettings instance and set the PrinterName property accordingly.
The following code shows a Console application that finds all the printers that are installed on a computer and displays information about the paper sizes and the resolutions supported by each one. In order to use the example as written, you must import the System.Drawing.Printing namespace.
Public Module PrinterListTest
Public Sub Main()
Dim Printer As New PrinterSettings()
Dim PrinterName As String
For Each PrinterName In PrinterSettings.InstalledPrinters
' Display the printer name.
Console.WriteLine("Printer: " & PrinterName)
' Retrieve the printer settings.
Printer.PrinterName = PrinterName
' Check that this is a valid printer.
' (This step might be required if you read the printer name
' from a user-supplied value or a registry or configuration file
' setting.)
If Printer.IsValid Then
' Display the list of valid resolutions.
Console.WriteLine("Supported Resolutions:")
Dim Resolution As PrinterResolution
For Each Resolution In Printer.PrinterResolutions
Console.WriteLine(" " & Resolution.ToString())
Next
Console.WriteLine()
' Display the list of valid paper sizes.
Console.WriteLine("Supported Paper Sizes:")
Dim Size As PaperSize
For Each Size In Printer.PaperSizes
If System.Enum.IsDefined(Size.Kind.GetType, Size.Kind) Then
Console.WriteLine(" " & Size.ToString())
End If
Next
Console.WriteLine()
End If
Next
Console.ReadLine()
End Sub
End Module
Here's the type of output this utility displays:
Printer: HP LaserJet 5L Supported Resolutions: [PrinterResolution High] [PrinterResolution Medium] [PrinterResolution Low] [PrinterResolution Draft] [PrinterResolution X=600 Y=600] [PrinterResolution X=300 Y=300] Supported Paper Sizes: [PaperSize Letter Kind=Letter Height=1100 Width=850] [PaperSize Legal Kind=Legal Height=1400 Width=850] [PaperSize Executive Kind=Executive Height=1050 Width=725] [PaperSize A4 Kind=A4 Height=1169 Width=827] [PaperSize Envelope #10 Kind=Number10Envelope Height=950 Width=412] [PaperSize Envelope DL Kind=DLEnvelope Height=866 Width=433] [PaperSize Envelope C5 Kind=C5Envelope Height=902 Width=638] [PaperSize Envelope B5 Kind=B5Envelope Height=984 Width=693] [PaperSize Envelope Monarch Kind=MonarchEnvelope Height=750 Width=387] Printer: Generic PostScript Printer . . .
You don't necessarily need to take this approach when creating an application that provides printing features. As you'll see in recipe 12.2, you can use the PrintDialog to prompt the user to choose a printer and its settings. The PrintDialog class can automatically apply its settings to the appropriate PrintDocument without any additional code.
| Note |
You can print a document in almost any type of application. However, your application must include a reference to the System.Drawing.dll assembly. If you are using a project type in Microsoft Visual Studio .NET that wouldn't normally have this reference (such as a Console application), you must add it. |
Print a Simple Document
Problem
You need to print text or images.
Solution
Handle the PrintDocument.PrintPage event, and use the DrawString and DrawImage methods of the Graphics class to print data to the page.
Discussion
.NET uses an asynchronous event-based printing model. To print a document, you create a System.Drawing.Printing.PrintDocument instance, configure its properties, and then call its Print method, which schedules the print job. The common language runtime will then fire the BeginPrint, PrintPage, and EndPrint events of the PrintDocument class on a new thread. You handle these events and use the provided System.Drawing.Graphics object to output data to the page.
Printer settings are configured through the PrintDocument.PrinterSettings and PrintDocument.DefaultPageSettings properties. The PrinterSettings property returns a full PrinterSettings object (as described in recipe 12.1), which identifies the printer that will be used. The DefaultPageSettings property provides a full PageSettings object that specifies printer resolution, margins, orientation, and so on. You can configure these properties in code, or you can use the System.Windows.Forms.PrintDialog class to let the user make the changes using the standard Windows print dialog (shown in Figure 12-1).
Figure 12-1: The PrintDialog.
In the print dialog box, the user can select a printer and choose a number of copies. The user can also click the Properties button to configure advanced settings like page layout and printer resolution. Finally, the user can either accept or cancel the print operation by clicking OK or Cancel.
Before showing the PrintDialog, you must explicitly attach it to a PrintDocument object by setting the PrintDialog.Document property. Then, any changes the user makes in the print dialog will be automatically applied to the PrintDocument object. The next example creates a new document, allows the user to configure print settings, and then starts an asynchronous print operation. It all starts when the user clicks a button.
Private Sub cmdPrint_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles cmdPrint.Click ' Create the document and attach an event handler. Dim MyDoc As New PrintDocument() AddHandler MyDoc.PrintPage, AddressOf MyDoc_PrintPage ' Allow the user to choose a printer and specify other settings. Dim dlgSettings As New PrintDialog() dlgSettings.Document = MyDoc Dim Result As DialogResult = dlgSettings.ShowDialog() ' If the user clicked OK, print the document. If Result = DialogResult.OK Then ' This method returns immediately, before the print job starts. ' The PrintPage event will fire asynchronously. MyDoc.Print() End If End Sub
| Note |
In some cases, you might show the PrintDialog simply to allow the user to configure settings, not to start a print job. In this case, your code would not call the Print method when the user clicks the OK button. |
The actual printing logic is shown in the following code. In .NET, printing to a page is exactly the same as drawing to a window using GDI+. You use the same Graphics class, with its methods for drawing shapes, texts, and images. You must also track your position, because every Graphics class method requires explicit coordinates that indicate where to draw on the page. You can retrieve the page margins from the passed-in PrintPageEventArgs object.
Private Sub MyDoc_PrintPage(ByVal sender As Object, _
ByVal e As PrintPageEventArgs)
' Define the font.
Dim MyFont As New Font("Arial", 30)
' Determine the position on the page.
' In this case, we read the margin settings
' (although there is nothing that prevents your code
' from going outside the margin bounds.)
Dim x As Single = e.MarginBounds.Left
Dim y As Single = e.MarginBounds.Top
' Determine the height of a line (based on the font used).
Dim LineHeight As Single = MyFont.GetHeight(e.Graphics)
' Print five lines of text.
Dim i As Integer
For i = 0 To 4
' Draw the text with a black brush,
' using the font and coordinates we have determined.
e.Graphics.DrawString("This is line " & i.ToString(), _
MyFont, Brushes.Black, x, y)
' Move down the equivalent spacing of one line.
y += LineHeight
Next
y += LineHeight
' Draw an image.
e.Graphics.DrawImage(Image.FromFile(Application.StartupPath & _
" est.bmp"), x, y)
End Sub
The printed document is shown, in Adobe Acrobat, in Figure 12-2.
Figure 12-2: The printed document.
This example has one limitation: it can only print a single page. To print more complex documents and span multiple pages, you will probably want to create a specialized class that encapsulates the document information, the current page, and so on. This technique is demonstrated in recipe 12.3.
Print a Document That Has Multiple Pages
Problem
You want to print complex documents with multiple pages and possibly print several different documents at once.
Solution
Place the information you want to print into a custom class that derives from PrintDocument, and set the PrintPageEventArgs.HasMorePages property to True as long as there are pages remaining.
Discussion
The PrintDocument.PrintPage event allows you to print only a single page. If you need to print more pages, you need to set the PrintPageEventArgs.HasMorePages property to True in the PrintPage event handler. As long as HasMorePages is True, the PrintDocument class will continue firing PrintPage events, one for each page. However, it's up to you to track what page you are on, what data should be placed on each page, and so on. To facilitate this tracking, it's a good idea to create a custom class.
The following example shows a class called TextDocument. This class inherits from PrintDocument and adds three properties. Text stores an array of text lines, PageNumber reflects the last printed page, and Offset indicates the last line that was printed from the Text array.
Public Class TextDocument Inherits PrintDocument Private _Text() As String Private _PageNumber As Integer Private _Offset As Integer Public Property Text() As String() Get Return _Text End Get Set(ByVal Value As String()) _Text = Value End Set End Property Public Property PageNumber() As Integer Get Return _PageNumber End Get Set(ByVal Value As Integer) _PageNumber = Value End Set End Property Public Property Offset() As Integer Get Return _Offset End Get Set(ByVal Value As Integer) _Offset = Value End Set End Property Public Sub New(ByVal text() As String) Me.Text = text End Sub End Class
Depending on the type of material you are printing, you might want to modify this class. For example, you could store an array of image data, some content that should be used as a header or footer on each page, font information, or even the name of a file from which you want to read the information. Encapsulating the information in a single class makes it easier to print more than one document at the same time.
The code that initiates printing is the same as in recipe 12.2, only now it creates a TextDocument instance instead of a PrintDocument instance:
' Generate some text. Dim PrintText(100) As String Dim i As Integer For i = 0 To 100 PrintText(i) = i.ToString() PrintText(i) &= " - lorum ipso facto lorum ipso facto lorum ipso" Next ' Create the custom document. Dim MyDoc As New TextDocument(PrintText) AddHandler MyDoc.PrintPage, AddressOf MyDoc_PrintPage ' Allow the user to choose the printer and settings. Dim dlgSettings As New PrintDialog() dlgSettings.Document = MyDoc Dim Result As DialogResult = dlgSettings.ShowDialog() If Result = DialogResult.OK Then MyDoc.Print() End If
The PrintPage event handler keeps track of the current line and checks if there is space on the page before attempting to print the next line. If a new page is needed, the HasMorePages property is set to True and the PrintPage event fires again for the next page. If not, the print operation is completed.
Private Sub MyDoc_PrintPage(ByVal sender As Object, _
ByVal e As PrintPageEventArgs)
' Retrieve the document that sent this event.
' You could store the document in a class member variable,
' but this approach allows you to use the same event handler
' to handle multiple print documents at once.
Dim Doc As TextDocument = CType(sender, TextDocument)
' Define the font and determine the line height.
Dim MyFont As New Font("Arial", 10)
Dim LineHeight As Single = MyFont.GetHeight(e.Graphics)
' Create variables to hold position on page.
Dim x As Single = e.MarginBounds.Left
Dim y As Single = e.MarginBounds.Top
' Increment the page counter (to reflect the page that is about to be
' printed).
Doc.PageNumber += 1
' Print all the information that can fit on the page.
' This loop ends when the next line would go over the margin bounds,
' or there are no more lines to print.
Do
e.Graphics.DrawString(Doc.Text(Doc.Offset), MyFont, _
Brushes.Black, x, y)
' Move to the next line of data.
Doc.Offset += 1
' Move the equivalent of one line down the page.
y += LineHeight
Loop Until (y + LineHeight) > e.MarginBounds.Bottom Or _
Doc.Offset > Doc.Text.GetUpperBound(0)
If Doc.Offset < Doc.Text.GetUpperBound(0) Then
' There is still at least one more page.
' Signal this event to fire again.
e.HasMorePages = True
Else
' Printing is complete.
Doc.Offset = 0
End If
End Sub
Print Centered Text
Problem
You want to center text vertically or horizontally on a page.
Solution
Calculate the available space between the margins, subtract the width or height of the text you want to print (using the Graphics.MeasureString and Font.GetHeight methods), and divide by two to find the appropriate coordinate.
Discussion
Printing centered text is easy. The only caveat is that you need to perform the coordinate calculations, as with all print operations.
Here is a code snippet that prints a block of three lines of text that are centered horizontally and vertically:
Private Sub MyDoc_PrintPage(ByVal sender As Object, _
ByVal e As PrintPageEventArgs)
' Define the font and text.
Dim Font As New Font("Arial", 35)
Dim Text As String = "This is a centered line of text."
Dim LineHeight As Single = Font.GetHeight(e.Graphics)
Dim LineWidth As Single = e.Graphics.MeasureString(Text, Font).Width
' Calculate the starting left and top coordinates.
Dim x, y As Single
x = (e.PageBounds.Width - LineWidth) / 2
y = (e.PageBounds.Height - LineHeight * 3) / 2
' Print three lines of text.
Dim i As Integer
For i = 0 To 2
' Draw the text with a black brush,
' using the font and coordinates we have determined.
e.Graphics.DrawString(Text, Font, Brushes.Black, x, y)
' Move down the equivalent spacing of one line.
y += LineHeight
Next
End Sub
There are actually two approaches to measure the height of a given line of text. You can use the height component returned from the Graphics.MeasureString method or the value returned from Font.GetHeight. These values are not necessarily the same—in fact, for most fonts the Font.GetHeight value will be slightly smaller.
For the purposes of line spacing, it's recommended that you always use Font.GetHeight. You should be aware, however, that there is more than one version of the GetHeight method. You must use the overloaded version that allows you to specify a Graphics object. Otherwise, the height you receive will be calculated for display purposes, not for the printer.
| Note |
You can also print centered text by using an overloaded version of the DrawString method that takes a bounding rectangle, inside which you can center text. This approach surrenders some flexibility (for example, it won't help if you need to center mixed content that includes different fonts or graphics), but it requires less code. See recipe 12.5 for an example. |
Print Wrapped Text
Problem
You want to parse a large block of text into distinct lines that fit on a page.
Solution
Use the Graphics.DrawString method overload that accepts a bounding rectangle. Or, if you need custom wrapping ability, write code that moves through the text word by word and measures it using the Graphics.MeasureString method until the line exceeds a set threshold.
Discussion
Often, you'll need to break a large block of text into separate lines that can be printed individually on a page. In .NET, you can take two approaches: one that performs the wrapping for you, and one by which your code controls the wrapping process.
To use automatic wrapping, you simply need to use the version of the Graphics.DrawString method that accepts a bounding rectangle. You specify a rectangle that represents where you want the text to be displayed. The text is then wrapped automatically to fit within those confines.
The following code demonstrates this approach using the bounding rectangle that represents the printable portion of the page. It prints a large block of text from a text box on the form. Notice that the shared RectangleF.op_Implicit method is used to convert the Rectangle structure that represents page margins to a RectangleF, which is required for the DrawString method.
Private Sub MyDoc_PrintPage(ByVal sender As Object, _
ByVal e As PrintPageEventArgs)
' Define the font and text.
Dim Font As New Font("Arial", 15)
e.Graphics.DrawString(txtData.Text, Font, Brushes.Black, _
RectangleF.op_Implicit(e.MarginBounds), StringFormat.GenericDefault)
End Sub
The wrapped text is shown in Figure 12-3.
Figure 12-3: The printed document with wrapping.
You can also modify the StringFormat parameter to specify different options for the text alignment. For example, the next code snippet centers the block of text vertically on the page, and then centers each line of wrapped text.
Private Sub MyDoc_PrintPage(ByVal sender As Object, _
ByVal e As PrintPageEventArgs)
' Define the font and text.
Dim Font As New Font("Arial", 15)
Dim Format As StringFormat = StringFormat.GenericDefault
' Center the block of text on the page (vertically).
Format.LineAlignment = StringAlignment.Center
' Center the individual lines of text (horizontally).
Format.Alignment = StringAlignment.Center
e.Graphics.DrawString(txtData.Text, Font, Brushes.Black, _
RectangleF.op_Implicit(e.MarginBounds), StringFormat.GenericDefault)
End Sub
| Note |
Although you can configure the StringFormat object to right-align text (using an Alignment value of StringAlignment.Far), the results will be far from ideal. This right-alignment does not take into account the precise size of the text based on font hinting and kerning, so the right margin of the text will not line up perfectly. |
Complex document-oriented applications often require fine-grained control over the wrapping process. In this case, you can use an alternate approach and perform the text wrapping manually. Because most fonts are nonproportional (meaning each character has a different width), you can't use the number of characters to decide where to divide a sentence. Instead, you need to manually walk through the sentence character by character, looking for spaces. Every time a space is found, you add the current word to the line text, and decide whether or not to start printing the next line (based on its length).
The following code wraps a block of text manually. Notice that the string manipulation code uses the StringBuilder class whenever possible, which is faster when appending characters.
Private Sub MyDoc_PrintPage(ByVal sender As Object, _
ByVal e As PrintPageEventArgs)
' Define the font and text.
Dim Font As New Font("Arial", 15)
Dim LineHeight As Single = Font.GetHeight(e.Graphics)
' Create variables to hold position on page.
Dim x As Single = e.MarginBounds.Left
Dim y As Single = e.MarginBounds.Top
' Once the amount of border at the end of the line
' drops below the threshold, the line is wrapped
' (provided you are at the end of the word.)
' Depending on the font size, you will need to tweak the threshold.
' Generally, the larger the font, the larger the threshold
' will need to be to prevent a long word that will run off the page.
Dim Threshold As Integer = 200
' Retrieve data from a text box.
Dim TextToPrint As New System.Text.StringBuilder(txtData.Text)
' Contains a single printed line.
Dim Line As New System.Text.StringBuilder()
Do
' Take one character from the text, and
' add it to the current line.
Line.Append(TextToPrint.Chars(0))
TextToPrint = TextToPrint.Remove(0, 1)
' Check if you have reached a word break.
If Line.Chars(Line.Length - 1) = " " Then
' It's time to decide whether to
' print the line or add another word.
Dim LineString As String = Line.ToString()
If e.Graphics.MeasureString(LineString, Font).Width > _
(e.PageBounds.Width - Threshold) Then
e.Graphics.DrawString(LineString, Font, Brushes.Black, x, y)
y += LineHeight
Line = New System.Text.StringBuilder()
End If
End If
Loop While TextToPrint.Length > 0
' Print the last line.
e.Graphics.DrawString(Line.ToString(), Font, Brushes.Black, x, y)
End Sub
You can make this algorithm quite a bit more intelligent. Currently, it's possible (although unlikely) that an extremely large word could occur, taking the line from an accepted width to an unacceptable width (and simultaneously crossing both the threshold and the page boundary). You'll see that this becomes a problem for extremely large fonts.
To prevent this problem, you can check for this condition and then remove the added word if a problem occurs. In this case, you'd also need to check that no single word exceeds the width of the page, in which case the word can't be printed (without hyphenation, anyway). A really intelligent wrapping algorithm would compare the possible line lengths with or without a word and choose the option that deviates the least from the threshold. Finally, you could also add support for multipage printing by checking for the end of the page (as in recipe 12.3).
Print from a File
Problem
You want to print data from a file without loading it into memory first.
Solution
Use the PrintDocument.BeginPrint event to open a stream to the file and the PrintDocument.EndPrint event to close the stream.
Discussion
When printing a large document, you might want to save the memory overhead by printing the data as it's read from a stream. This way, the entire document doesn't need to be held in memory at the same time.
The easiest way to use this approach is to adopt the design from recipe 12.3 and derive a custom PrintDocument class. This class would track the filename of the document and hold a reference to the underlying file stream. This class would also encapsulate the logic for opening and closing the file stream by overriding the OnBeginPrint and OnEndPrint methods, which saves you from needing to handle the corresponding events.
The TextFileDocument class, shown in the following code, provides an example. TextFileDocument abstracts access to the underlying file stream by providing a ReadWord method that allows the printing code to retrieve the next word. This approach allows you to easily wrap the text as you print it.
Public Class TextFileDocument
Inherits PrintDocument
' The filename that will be opened when the print job starts.
Private _Filename As String
' Indicates if data is available in the stream.
Private _DataAvailable As Boolean = False
' These private variables track the open file.
' The client using this class cannot access these details directly.
Private Stream As System.IO.FileStream
Private Reader As System.IO.StreamReader
Public ReadOnly Property Filename() As String
Get
Return _Filename
End Get
End Property
Public ReadOnly Property DataAvailable() As Boolean
Get
Return _DataAvailable
End Get
End Property
Public Sub New(ByVal filename As String)
' Make sure we are using a fully-qualified path
' (in case the working directory changes before the print job starts).
_Filename = System.IO.Path.GetFullPath(filename)
If Not System.IO.File.Exists(_Filename) Then
Throw New System.IO.FileNotFoundException(_Filename)
End If
End Sub
Protected Overrides Sub OnBeginPrint( _
ByVal e As System.Drawing.Printing.PrintEventArgs)
' Open the file.
Stream = New System.IO.FileStream(Filename, IO.FileMode.Open)
Reader = New System.IO.StreamReader(Stream)
_DataAvailable = True
End Sub
Protected Overrides Sub OnEndPrint( _
ByVal e As System.Drawing.Printing.PrintEventArgs)
' Close the file.
Reader.Close()
Stream.Close()
Stream = Nothing
Reader = Nothing
_DataAvailable = False
End Sub
Public Function ReadWord() As String
If Reader Is Nothing Then
Throw New ApplicationException("File not open.")
End If
Dim Character As Char
Dim CharNumber As Integer
Dim Word As New System.Text.StringBuilder()
' This loop adds letters until a whole word is finished.
' The word is deemed complete when the file ends
' or a space is encountered.
Do
' Read a single character out of the file.
' A -1 signals the end of the file.
CharNumber = Reader.Read()
If CharNumber <> -1 Then
Character = Chr(CharNumber)
Word.Append(Character)
End If
Loop Until Character = " " Or CharNumber = -1
' Set a property to indicate when the file is out of data.
If CharNumber = -1 Then
_DataAvailable = False
End If
Return Word.ToString()
End Function
End Class
The client application creates a TextFileDocument instance (supplying the filename to read), attaches an event handler, and starts printing:
' Create the document and attach an event handler.
Dim MyDoc As TextFileDocument
Try
MyDoc = New TextFileDocument(Application.StartupPath & " ext.txt")
Catch Err As System.IO.FileNotFoundException
MessageBox.Show("File not found.")
Return
End Try
AddHandler MyDoc.PrintPage, AddressOf MyDoc_PrintPage
' Allow the user to choose a printer and specify other settings.
Dim dlgSettings As New PrintDialog()
dlgSettings.Document = MyDoc
Dim Result As DialogResult = dlgSettings.ShowDialog()
' If the user clicked OK, print the document.
If Result = DialogResult.OK Then
' This method returns immediately, before the print job starts.
' The PrintPage event will fire asynchronously.
MyDoc.Print()
End If
Finally, the printing code reads the words one by one and wraps the text manually.
Private Sub MyDoc_PrintPage(ByVal sender As Object, _
ByVal e As PrintPageEventArgs)
' Retrieve the TextFileDocument that is being printed.
Dim Doc As TextFileDocument = CType(sender, TextFileDocument)
' Define the font and text.
Dim Font As New Font("Arial", 15)
Dim LineHeight As Single = Font.GetHeight(e.Graphics)
' Create variables to hold position on page.
Dim x As Single = e.MarginBounds.Left
Dim y As Single = e.MarginBounds.Top
Dim Threshold As Integer = 200
' Contains a single printed line.
Dim Line As New System.Text.StringBuilder()
Do
' Add one word to the current line.
Line.Append(Doc.ReadWord())
' It's time to decide whether to print the line or add another word.
Dim LineString As String = Line.ToString()
If e.Graphics.MeasureString(LineString, Font).Width > _
(e.PageBounds.Width - Threshold) Then
e.Graphics.DrawString(LineString, Font, Brushes.Black, x, y)
y += LineHeight
Line = New System.Text.StringBuilder()
End If
Loop While Doc.DataAvailable
' Print the last line.
e.Graphics.DrawString(Line.ToString(), Font, Brushes.Black, x, y)
End Sub
Display a Dynamic Print Preview
Problem
You want to use an on-screen preview that shows how a printed document will look.
Solution
Use the PrintPreviewControl or PrintPreviewDialog.
Discussion
As described earlier, the code used to print a document to a page is almost identical to the code used to draw graphics on a window. This makes it possible for you to create code that can print or draw a print preview with equal ease. However, you don't need to go to this extra step because .NET already provides a control that can take a print document, run your printing code, and use it to generate a graphical on-screen preview. In fact, .NET provides two such controls: PrintPreviewDialog, which shows a preview in a standalone window, and PrintPreviewControl, which shows a preview in one of your own custom forms.
To use a standalone print preview, you simply create a PrintPrevewDialog object, assign the document, and call the PrintPreviewDialog.Show method.
Dim dlgPreview As New PrintPreviewDialog() dlgPreview.Document = MyDoc dlgPreview.Show()
The print preview window (shown in Figure 12-4) provides all the controls the user needs to move from page to page, zoom in, and so on. The window even provides a print button that allows the user to send the document directly to the printer. You can tailor the window to some extent by modifying the PrintPreviewDialog properties.
Figure 12-4: The PrintPreviewDialog.
You can also add the PrintPreviewControl to any of your forms to show a preview alongside other information. Visual Studio .NET will then add the following control declaration to the designer code:
Friend WithEvents Preview As System.Windows.Forms.PrintPreviewControl
In this case, you don't need to call the Show method. As soon as you set the PrintPreviewControl.Document property, the preview is generated. To clear the preview, set the Document property to Nothing, and to refresh the preview, simply reassign the Document property.
Preview.Document = MyDoc
PrintPreviewControl only shows the preview pages, not any additional controls. However, you can add your own controls for zooming, tiling multiple pages, and so on. You simply need to adjust the PrintPreviewControl properties accordingly.
For example, the following code changes the zoom to 20 percent.
Preview.Zoom = 0.2
This code shows a two-by-three grid of pages (allowing up to six pages to be shown at the same time):
Preview.Columns = 2 Preview.Rows = 3
Figure 12-5 shows the PrintPreviewControl in a custom window with some added controls for zooming.
Figure 12-5: The PrintPreviewControl in a custom window.
Retrieve Print Queue Information
Problem
You want to determine the status of all jobs in the print queue.
Solution
Use Windows Management Instrumentation to perform a query with the Win32_PrintJob class.
Discussion
Windows Management Instrumentation, or WMI, allows you to retrieve a vast amount of system information using a query-like syntax. One of the tasks you can perform with WMI is to retrieve a list of outstanding print jobs, along with information about each one.
In order to use WMI, you need to add a reference to the System.Management.dll assembly. You should then import the System.Management namespace. The following code assumes you have added a reference to the System.Management.dll assembly. It retrieves a list of all the print jobs in the queue and displays information about each one in the Console window.
Public Module PrintQueueTest
Public Sub Main()
' Select all the outstanding print jobs.
' You could customize this expression to get jobs from a
' specific printer or user.
Dim Query As String = "SELECT * FROM Win32_PrintJob"
Dim JobQuery As New ManagementObjectSearcher(query)
Dim Jobs As ManagementObjectCollection = JobQuery.Get()
' Display information for all jobs in the queue.
Dim Job As ManagementObject
For Each Job In Jobs
Console.WriteLine("Caption: " & Job("Caption"))
Console.WriteLine("DataType: " & Job("DataType"))
Console.WriteLine("Description: " & Job("Description"))
Console.WriteLine("Document: " & Job("Document"))
Console.WriteLine("DriverName: " & Job("DriverName"))
Console.WriteLine("ElapsedTime: " & Job("ElapsedTime"))
Console.WriteLine("HostPrintQueue: " & Job("HostPrintQueue"))
Console.WriteLine("InstallDate: " & Job("InstallDate"))
Console.WriteLine("JobId: " & Job("JobId").ToString())
Console.WriteLine("JobStatus: " & Job("JobStatus"))
Console.WriteLine("Name: " & Job("Name"))
Console.WriteLine("Notify: " & Job("Notify"))
Console.WriteLine("Owner: " & Job("Owner"))
Console.WriteLine("PagesPrinted: " & _
Job("PagesPrinted").ToString())
Console.WriteLine("Parameters: " & Job("Parameters"))
Console.WriteLine("PrintProcessor: " & Job("PrintProcessor"))
Console.WriteLine("Priority: " & Job("Priority").ToString())
Console.WriteLine("Size: " & Job("Size").ToString())
Console.WriteLine("StartTime: " & Job("StartTime"))
Console.WriteLine("Status: " & Job("Status"))
Console.WriteLine("StatusMask: " & Job("StatusMask").ToString())
Console.WriteLine("TimeSubmitted: " & Job("TimeSubmitted"))
Console.WriteLine("TotalPages: " & Job("TotalPages").ToString())
Console.WriteLine("UntilTime: " & Job("UntilTime"))
Next
Console.ReadLine()
End Sub
End Module
Here's the sample output you might see if the queue holds a single job:
Caption: Acrobat Distiller, 58 DataType: RAW Description: Acrobat Distiller, 58 Document: http://www.google.ca/ DriverName: AdobePS Acrobat Distiller ElapsedTime: HostPrintQueue: \FARIAMAT InstallDate: JobId: 58 JobStatus: Paused | Printing Name: Acrobat Distiller, 58 Notify: Matthew Owner: Matthew PagesPrinted: 0 Parameters: PrintProcessor: WinPrint Priority: 1 Size: 2293760 StartTime: Status: Degraded StatusMask: 17 TimeSubmitted: 20030117095826.632000-300 TotalPages: 1 UntilTime:
| Note |
To test this code, you might want to pause a printer (using the Printers and Faxes window) and then print a document. As long as the printer is paused, the document will remain in the queue. |
This example assumes that you don't have Option Explicit enabled. If you do, you will need to check for a null reference before you can retrieve the Job properties, and then call the ToString method to convert each piece of the job information to a string. For example, the InstallDate field is not always available. In order to display this information if it exists without causing an error if it doesn't, you must use the following lengthier code:
Console.WriteLine("InstallDate: ")
If Not Job("InstallDate") Is Nothing
Console.WriteLine(Job("InstallDate").ToString())
End If
Manage Print Jobs
Problem
You want to pause or resume a print job or print queue.
Solution
Use the Pause and Resume methods of the WMI Win32_PrintJob and Win32_Printer classes.
Discussion
WMI isn't limited to information retrieval tasks (such as those shown in recipe 12.8). You can also execute certain WMI class methods to interact with the Windows operating system. One example is the Pause and Resume methods that allow you to manage printers and print jobs.
The following Console application provides a straightforward example. Every time the application finds a print job in the queue, it checks to see if the job or the printer is paused. If so, it tries to resume the job or the printer. Note that Windows permissions might prevent you from pausing or removing a print job created by another user. In fact, depending on the permissions of the current user account, a System.Management.ManagementException exception may be thrown when you attempt to retrieve status information for a print job.
Public Module PrintQueueTest
Public Sub Main()
' Select all the outstanding print jobs.
Dim Query As String = "SELECT * FROM Win32_PrintJob"
Dim JobQuery As New ManagementObjectSearcher(Query)
Dim Jobs As ManagementObjectCollection = JobQuery.Get()
' Examine all jobs in the queue.
Dim Job As ManagementObject
For Each Job In Jobs
' Check if the job is paused (has Status 1).
If (CType(Job("StatusMask").ToString(), Integer) And 1) = 1 Then
Console.WriteLine("Job is paused. Attempting to resume.")
' Attempt to resume the job.
Dim ReturnValue As Integer
ReturnValue = CType( _
Job.InvokeMethod("Resume", Nothing).ToString(), Integer)
' Display information about the return value.
If ReturnValue = 0 Then
Console.WriteLine("Successfully resumed job.")
ElseIf ReturnValue = 5 Then
Console.WriteLine("Access denied.")
Else
Console.WriteLine( _
"Unrecognized return value when resuming job.")
End If
End If
' Find the corresponding printer for this job.
Query = "SELECT * FROM Win32_Printer WHERE DriverName='" & _
Job("DriverName") & "'"
Dim PrinterQuery As New ManagementObjectSearcher(Query)
Dim Printers As ManagementObjectCollection = PrinterQuery.Get()
' Examine each matching printer (should be exactly one match).
Dim Printer As ManagementObject
For Each Printer In Printers
' Check if the printer is paused
' (has ExtendedPrinterStatus 8).
If (CType(Printer("ExtendedPrinterStatus").ToString(), _
Integer) And 8) = 8 Then
Console.WriteLine("Printer is paused. " & _
"Attempting to resume.")
' Attempt to resume the printer.
Dim ReturnValue As Integer
ReturnValue = Val(Printer.InvokeMethod( _
"Resume", Nothing).ToString())
' Display information about the return value.
If ReturnValue = 0 Then
Console.WriteLine( _
"Successfully resumed printing.")
ElseIf ReturnValue = 5 Then
Console.WriteLine("Access denied.")
Else
Console.WriteLine( _
"Unrecognized return value when resuming printer.")
End If
End If
Next
Next
Console.ReadLine()
End Sub
End Module
Other WMI methods that you might use in a printing scenario include AddPrinterConnection, SetDefaultPrinter, CancelAllJobs, and PrintTestPage, all of which work with the Win32_Printer class. For more information about using WMI to retrieve information about Windows hardware, refer to the MSDN documentation at http://msdn.microsoft.com/library/en-us/wmisdk/wmi/computer_system_hardware_classes.asp.
| Note |
The Pause and Resume methods might not be supported in versions of Windows earlier than Windows XP. In that case, you might need to use Windows API functions such as the SetPrinter function from winspool.drv. |
Find All Installed Fonts
Problem
You want to retrieve a list of all the fonts on the current computer.
Solution
Create a new instance of the System.Drawing.Text.InstalledFontCollection class, which contains a collection of FontFamily objects representing all the installed fonts.
Discussion
The InstalledFontCollection class allows you to retrieve information about currently installed fonts. The following code uses this technique to fill a list box named lstFonts with a list of valid font names:
Dim FontFamilies As New System.Drawing.Text.InstalledFontCollection() Dim Family As FontFamily For Each Family In FontFamilies.Families lstFonts.Items.Add(Family.Name) Next
When an entry is chosen in the list box, the font of a label control is updated:
Private Sub lstFonts_SelectedIndexChanged(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles lstFonts.SelectedIndexChanged lblSample.Font = New Font(lstFonts.Text, 30) End Sub
Figure 12-6 shows a screen shot of this simple test application.
Figure 12-6: Testing fonts.
Convert the Format of an Image
Problem
You want to batch convert the format of one or more image files.
Solution
Use the Image.FromFile method to load the image, and use the Image.Save method overload that allows you to specify a new ImageFormat.
Discussion
.NET includes an impressive set of image-processing features. The core class is System.Drawing.Image, which allows you to open and save multiple types of images. The Image class supports the following formats:
- Bitmap (BMP)
- Enhanced Windows metafile image (EMF)
- Exchangeable Image File (EXIF)
- Graphics Interchange Format (GIF)
- Windows icon (ICO)
- Joint Photographic Experts Group (JPEG)
- Memory bitmap (BMP)
- W3C Portable Network Graphics (PNG)
- Tag Image File Format (TIFF)
- Windows metafile (WMF)
These formats are defined by the ImageFormat class in the System.Drawing.Imaging namespace. Using the Image class and the ImageFormat class, you can specify a new format to use when saving a file. The Console application shown here uses this technique—it reads all the BMP files in a directory and saves JPEG versions of each one. In order to use this code as written, you must import the System.Drawing, System.Drawing.Imaging and System.IO namespaces.
Public Module ImageConverter
Public Sub Main()
Dim Dir As New DirectoryInfo(Directory.GetCurrentDirectory())
Console.WriteLine("Processing images in " & Dir.FullName)
' Retrieve all the bitmap files in this directory.
Dim File As FileInfo
For Each File In Dir.GetFiles("*.bmp")
Console.WriteLine("Converting: " & File.Name)
' Load the image into memory.
Dim Image As Image = Image.FromFile(File.FullName)
' Create a new filename.
Dim JpgName As String
JpgName = Path.GetFileNameWithoutExtension(File.FullName) & ".jpg"
' Save the filename as a JPEG.
Image.Save(JpgName, ImageFormat.Jpeg)
Console.WriteLine("Saved: " & JpgName)
Console.WriteLine()
Next
Console.ReadLine()
End Sub
End Module
Not only can you convert between any image file types, but you can also specify additional parameters that influence how the image data is processed. For example, you might change the compression of a TIFF file to the quality of a JPEG file. You can do this using Encoder objects, which you supply to an overloaded version of the Image.Save method. Many useful Encoder objects can be retrieved from the shared properties of the System.Drawing.Imaging.Encoder class. These properties include ChrominanceTable, ColorDepth, Compression, LuminanceTable, Quality, RenderMethod, SaveFlag, ScanMethod, Transformation, and Version.
More information is available in the MSDN reference. In addition, the next example shows how you can use an Encoder object to save JPEG files with different quality parameters.
Public Module ImageConverter
Public Sub Main()
' Get an ImageCodecInfo object that represents the JPEG codec.
' This is accomplished by searching for the corresponding MIME type.
Dim CodecInfo As ImageCodecInfo = GetEncoderInfo("image/jpeg")
' Create an Encoder object based for the Quality parameter.
Dim Enc As Encoder = Encoder.Quality
' Create the array that will hold all encoding parameters.
' In this case, it will only hold the quality parameter.
Dim EncParams As New EncoderParameters(1)
Dim Dir As New DirectoryInfo(Directory.GetCurrentDirectory())
Console.WriteLine("Processing images in " & Dir.FullName)
' Retrieve all the bitmap files in the current directory.
Dim File As FileInfo
For Each File In Dir.GetFiles("*.bmp")
Console.WriteLine("Converting: " & File.Name)
' Load the image into memory.
Dim Image As Image = Image.FromFile(File.FullName)
' Create a new filename.
Dim JpgName As String
' Save the bitmap as a JPEG file with quality level 25.
EncParams.Param(0) = New EncoderParameter(Enc, 25L)
JpgName = Path.GetFileNameWithoutExtension(File.FullName) & _
"25" & ".jpg"
Image.Save(JpgName, CodecInfo, EncParams)
Console.WriteLine("Saved: " & JpgName)
' Save the bitmap as a JPEG file with quality level 50.
EncParams.Param(0) = New EncoderParameter(Enc, 50L)
JpgName = Path.GetFileNameWithoutExtension(File.FullName) & _
"50" & ".jpg"
Image.Save(JpgName, CodecInfo, EncParams)
Console.WriteLine("Saved: " & JpgName)
' Save the bitmap as a JPEG file with quality level 75.
EncParams.Param(0) = New EncoderParameter(Enc, 75L)
JpgName = Path.GetFileNameWithoutExtension(File.FullName) & _
"75" & ".jpg"
Image.Save(JpgName, CodecInfo, EncParams)
Console.WriteLine("Saved: " & JpgName)
Console.WriteLine()
Next
Console.ReadLine()
End Sub
Private Function GetEncoderInfo(ByVal mimeType As String) _
As ImageCodecInfo
Dim i As Integer
Dim Encoders() As ImageCodecInfo = ImageCodecInfo.GetImageEncoders()
For i = 0 To Encoders.Length - 1
If Encoders(i).MimeType = mimeType Then
Return Encoders(i)
End If
Next
Return Nothing
End Function
End Module
The output for this console application will look like this:
Processing images in C:TempRecipe 12-11in Converting: test.bmp Saved: test25.jpg Saved: test50.jpg Saved: test75.jpg
Paint Static Content
Problem
You want to draw custom elements on a form and make sure they are not erased when the form is minimized or obscured.
Solution
Place all your drawing code in an event handler for the Control.Paint or Form.Paint events.
Discussion
When any part of a form disappears from view, Windows automatically discards all of its graphical information. When the form reappears, Windows fires the Paint event to instruct the form to redraw itself. Thus, any custom painting logic should always be coded in a Paint event handler so that the window is refreshed accurately. To make matters even easier, the Paint event always provides a PaintEventArgs parameter. This PaintEventArgs references a Graphics object that represents the drawing surface for the control or the form. You use the Graphics object's methods to draw text, shapes, or images.
Here's an example that draws a gradient rectangle on the background of the form (as shown in Figure 12-7):
Private Sub TestForm_Paint(ByVal sender As Object, _ ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint Dim Rectangle As New Rectangle(5, 5, Me.ClientRectangle.Width - 10, _ Me.ClientRectangle.Height - 10) ' Draw the rectangle border. Dim DrawingPen As New Pen(Color.Blue, 2) e.Graphics.DrawRectangle(DrawingPen, Rectangle) ' Fill the rectangle with a gradient. Dim DrawingBrush As New _ System.Drawing.Drawing2D.LinearGradientBrush( _ Rectangle, Color.Blue, Color.Gold, 45) e.Graphics.FillRectangle(DrawingBrush, Rectangle) End Sub
Figure 12-7: A form with a gradient rectangle.
In this example, the drawing code uses the size of the form. Thus, it's a good idea to add an additional bit of logic to invalidate the form if the size changes, ensuring that the form will be redrawn with a gradient background that fills the form:
Private Sub Form1_Resize(ByVal sender As Object, _ ByVal e As System.EventArgs) Handles MyBase.Resize ' Indicate that the form is no longer valid, ' and Windows should trigger a repaint. Me.Invalidate() End Sub
This approach is easy to implement for static forms in which the graphical content is always the same. In this case, you can hardcode the drawing logic in the Paint event handler. It's not as easy if you are using a dynamic form, in which the graphical content changes. In that case, you will need to use form-level variables to track the drawn content so that it can be refreshed in the Paint event handler. This approach is shown in recipe 12.13.
Paint Dynamic Content
Problem
You want to draw a combination of elements on a form and track them so that they can be redrawn later.
Solution
Place all your drawing code in an event handler for the Form.Paint event. When you need to update the form, call the Form.Invalidate method.
Discussion
In many applications, drawing takes place in response to another action, such as a user clicking a button or clicking directly on the form surface. Consider the example shown in Figure 12-8, in which the user can draw a small square object anywhere on a form simply by clicking with the mouse.
Figure 12-8: Custom drawing.
In this case, you have two choices:
- Use drawing and refreshing logic. When the user clicks on the form, draw the square and store some information about it. When the Paint event fires, redraw all the squares that have been drawn so far.
- Use invalidation.When the user clicks on the form, store some information about the square and invalidate the portion of the form where the user clicked. Then Windows will fire the Paint event and refresh that portion of the screen.
In most cases, the second option is the most elegant because it concentrates all your drawing logic into a single function. The following code shows how you would implement this approach.
Public Class DrawTest Inherits System.Windows.Forms.Form ' (Designer code omitted.) ' This ArrayList tracks the user-drawn shapes. Private Points As New ArrayList() Private Sub DrawTest_Paint(ByVal sender As Object, _ ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint Dim DrawingPen As New Pen(Color.Blue, 2) ' Draw all the shapes that have been drawn so far. Dim Point As Rectangle For Each Point In Points e.Graphics.DrawRectangle(DrawingPen, Point) Next pnlPoints.Text = " " & Points.Count.ToString() & " Points" End Sub Private Sub DrawTest_MouseDown(ByVal sender As Object, _ ByVal e As System.Windows.Forms.MouseEventArgs) Handles MyBase.MouseDown If e.Button = MouseButtons.Left Then ' Define the new shape. Dim Point As New Rectangle(e.X, e.Y, 20, 20) ' Store the shape for later refreshes. Points.Add(Point) ' Invalidate the portion of the form where the new shape will be. ' Windows will call your Paint event, and update only this region. Me.Invalidate(Rectangle.Inflate(Point, 3, 3)) End If End Sub End Class
When you invalidate a portion of the form, all your drawing code will execute. However, Windows will only refresh the portion of the form that you specified when calling the Invalidate method. That means that screen flicker will be kept to a minimum, but the drawing speed might decrease if the logic in your Paint event handler is very complex or time-consuming. In that case, it would be better to use separate drawing and refreshing logic, as shown here:
Public Class DrawTest Inherits System.Windows.Forms.Form ' (Designer code omitted.) ' This ArrayList tracks the user-drawn shapes. Private Points As New ArrayList() Private Sub DrawTest_Paint(ByVal sender As Object, _ ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint ' Draw all the shapes that have been drawn so far. Dim Point As Rectangle For Each Point In Points DrawShape(e.Graphics, Point) Next pnlPoints.Text = " " & Points.Count.ToString() & " Points" End Sub Private Sub DrawTest_MouseDown(ByVal sender As Object, _ ByVal e As System.Windows.Forms.MouseEventArgs) Handles MyBase.MouseDown If e.Button = MouseButtons.Left Then ' Define the new shape. Dim Point As New Rectangle(e.X, e.Y, 20, 20) ' Store the shape for later refreshes. Points.Add(Point) ' Draw the shape. ' Note that you need to explicitly create the ' GDI+ drawing surface for the form. Dim g As Graphics = Me.CreateGraphics() DrawShape(g, Point) g.Dispose() pnlPoints.Text = " " & Points.Count.ToString() & " Points" End If End Sub Private Sub DrawShape(ByVal g As Graphics, ByVal shape As Rectangle) ' Draw the actual shape using the supplied Graphics object. Dim DrawingPen As New Pen(Color.Blue, 2) g.DrawRectangle(DrawingPen, shape) End Sub End Class
Use System Colors
Problem
You want to use system-defined colors when drawing.
Solution
Use the properties of the System.Drawing.SystemColors class.
Discussion
When mixing standard Windows interface elements with your own drawing code, you need to take special care that you follow the system color scheme. Otherwise, you might end up with illegible text—or just garishly ugly windows.
Retrieving system color information is easy. You can simply use the shared properties of the System.Drawing.SystemColors class. In addition, you can use the System.Drawing.KnownColors enumeration to retrieve a list of friendly (human-readable) color names and system color names.
Here's an example that draws text on a form using the background and foreground colors of the form title bar:
Private Sub Form_Paint(ByVal sender As Object, _
ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint
Dim BrushText As New SolidBrush(SystemColors.ActiveCaptionText)
Dim BrushBackground As New SolidBrush(SystemColors.ActiveCaption)
e.Graphics.FillRectangle(BrushBackground, 5, 5, _
Me.ClientRectangle.Width - 10, Me.ClientRectangle.Height - 10)
e.Graphics.DrawString("Test", New Font("Arial", 14), BrushText, 10, 10)
End Sub
Improve the Rendering Quality
Problem
You want to ensure that drawn shapes are rendered in the best possible detail.
Solution
Set the SmoothingMode and TextRenderingHint properties of the Graphics object before drawing.
Discussion
The Graphics object provides two stateful properties that configure the rendering quality. SmoothingMode allows you to use automatic antialiasing, which improves the look of curves with shading. For example, if you draw a black circle on a white background, antialiasing might add a small amount of gray shading to take away the jaggedness. TextRenderingHint performs analogous control that affects text you draw using the Graphics.DrawString method.
The following code snippet draws two ellipses with two captions, using the default quality first and then a higher-quality version. Figure 12-9 shows the results.
Figure 12-9: Customizing rendering quality.
Private Sub Form_Paint(ByVal sender As Object, _
ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint
Dim Pen As New Pen(Color.Green, 3)
Dim Font As New Font("Arial", 12, FontStyle.Bold)
' Draw using the default quality.
e.Graphics.DrawEllipse(Pen, 10, 10, 200, 200)
e.Graphics.DrawString("Low Quality", Font, Brushes.Black, 50, 220)
' Specify higher-quality antialiasing.
e.Graphics.SmoothingMode = Drawing.Drawing2D.SmoothingMode.AntiAlias
e.Graphics.TextRenderingHint = _
Drawing.Text.TextRenderingHint.ClearTypeGridFit
e.Graphics.DrawEllipse(Pen, 250, 10, 200, 200)
e.Graphics.DrawString("High Quality", Font, Brushes.Black, 300, 220)
End Sub
| Note |
By default, no aliasing is used for drawing shapes. Thus, it's often advantageous to modify the SmoothingMode property if drawing speed isn't a concern. On the other hand, the default text quality depends on system settings. The text quality setting is usually configured to use antialiasing already (or advanced optimizations for LCD screens), and thus doesn't need to be modified in your code. |
Perform Hit Testing with Shapes
Problem
You want to detect if a user clicks inside a shape.
Solution
Test the point where the user clicked with the Rectangle.Contains or GraphicsPath.IsVisible method.
Discussion
If you are creating a program that has custom graphical elements the user can interact with, you need to be able to determine when the user's mouse is inside or outside a given shape. The .NET Framework provides two methods that can help with this task. The first is the Rectangle.Contains method, which takes a point and returns True if the point is inside the rectangle.
For example, you might add the following code to the drawing program demonstrated in recipe 12.13 to check if the point where the user right-clicked lies inside any of the squares on the form.
Private Sub DrawTest_MouseDown(ByVal sender As Object, _
ByVal e As System.Windows.Forms.MouseEventArgs) Handles MyBase.MouseDown
If e.Button = MouseButtons.Left Then
' (Drawing code omitted.)
ElseIf e.Button = MouseButtons.Right Then
' Check if a square was clicked.
Dim Point As Rectangle
Dim Inside As Boolean = False
For Each Point in Points
If Point.Contains(e.X, e.Y) Then
Inside = True
End If
Next
If Inside Then
MessageBox.Show("Point lies in a square.")
Else
MessageBox.Show("Point does not lie in a square.")
End If
End If
End Sub
In many cases, you can retrieve a rectangle for another type of shape. For example, you can use Image.GetBounds to retrieve the invisible rectangle that represents the image boundaries.
The second approach is to use the GraphicsPath class in the System.Drawing.Drawing2D namespace. This approach is useful if you want to test if a point is contained inside a non-rectangular shape. The first step is to create a new GraphicsPath and add the shape (or add multiple shapes) to the GraphicsPath. Then, you can use the IsVisible method with the clicked point. For example, you can create a GraphicsPath that contains an ellipse and a square with this code:
Dim Path As New System.Drawing.Drawing2D.GraphicsPath() Private Sub Form_Load(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles MyBase.Load Path.AddEllipse(60, 60, 100, 100) Path.AddRectangle(New Rectangle(10, 10, 50, 50)) End Sub
The painting code draws and fills the GraphicsPath:
Private Sub Form_Paint(ByVal sender As Object, _ ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint e.Graphics.SmoothingMode = Drawing.Drawing2D.SmoothingMode.AntiAlias Dim Pen As New Pen(Color.Green, 4) e.Graphics.DrawPath(Pen, Path) e.Graphics.FillPath(Brushes.Yellow, Path) End Sub
Now you can see if the user clicks inside the ellipse using IsVisible:
Private Sub Form_MouseDown(ByVal sender As Object, _
ByVal e As System.Windows.Forms.MouseEventArgs) Handles MyBase.MouseDown
If Path.IsVisible(e.X, e.Y) Then
MessageBox.Show("You clicked inside the GraphicsPath.")
End If
End Sub
Figure 12-10 shows the application in action.
Figure 12-10: Hit testing with a GraphicsPath object.
Draw Picture Thumbnails
Problem
You want to draw a scaled-down version of a larger image.
Solution
Use the Image.GetThumbnailImage method, and specify the size of thumbnail that you want.
Discussion
The Image class provides the built-in smarts for generating thumbnails through the GetThumbnailImage method. You simply need to pass the width and height of the thumbnail you want, and the Image class will create a new Image object that fits these criteria. Antialiasing is used when reducing the image to ensure the best possible image quality, although some blurriness and loss of detail is inevitable. In addition, you can supply a notification callback, allowing you to create thumbnails asynchronously.
The following code generates a 50-by-50-pixel thumbnail:
Dim Img As Image = Image.FromFile("test.jpg")
Dim Thumbnail As Image = Img.GetThumbnailImage(50, 50, Nothing, Nothing)
When generating a thumbnail, it's important to ensure that the aspect ratio remains constant. For example, if you reduce a 200-by-100 picture to a 50-by-50 thumbnail, the width will be compressed to one quarter and the height will be compressed to one half, distorting the image. To ensure that the aspect ratio remains constant, you can change either the width or height to a fixed size, and then adjust the other dimension proportionately.
The following code reads a graphic from a file, creates a proportional thumbnail, and then displays it on a form:
Private Sub Form_Paint(ByVal sender As Object, _
ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint
' Read the image from a file.
Dim Img As Image = Image.FromFile("test.jpg")
Dim ThumbnailWidth, ThumbnailHeight As Integer
' Adjust the largest dimension to a set 50 pixels.
' This ensures that a thumbnail will not be larger than 50x50 pixels.
' If you are showing multiple thumbnails, you would reserve a
' 50x50 pixel square for each one.
If ThumbnailWidth > ThumbnailHeight Then
ThumbnailWidth = 50
' Scale the height proportionately.
ThumbnailHeight = CInt((50 / Img.Width) * Img.Height)
Else
ThumbnailHeight = 50
' Scale the width proportionately.
ThumbnailWidth = CInt((50 / Img.Height) * Img.Width)
End If
' Create the thumbnail.
Img = Img.GetThumbnailImage(ThumbnailWidth, ThumbnailHeight, _
Nothing, Nothing)
' Display the thumbnail.
e.Graphics.DrawImage(Img, 10, 10)
End Sub
Use Double Buffering to Increase Redraw Speed
Problem
You want to optimize drawing for a form that is frequently refreshed and want to reduce flicker.
Solution
Render the graphics to an in-memory bitmap, and then copy the finalized bitmap to the form.
Discussion
In some applications you need to repaint a form or control frequently. This is commonly the case when performing animation. For example, you might use a timer to invalidate your form every second. Your painting code could then redraw an image at a new location, creating the illusion of motion. The problem with this approach is that every time you invalidate the form, Windows repaints the window background (clearing the form), and then runs your painting code, which draws the graphic element by element. This can cause substantial on-screen flicker.
Double buffering is a technique you can implement to reduce this flicker. With double buffering, your drawing logic writes to an in-memory bitmap, which is copied to the form at the end of the drawing operation in a single, seamless repaint operation. Flickering is reduced dramatically.
The first step when implementing double buffering is to ensure that the form background isn't repainted automatically when the form is invalidated. This automatic clearing is the most significant cause of flicker, because it replaces your image with a blank frame (if only for a fraction of a second). To prevent background painting, override the form's OnPaintBackground method so that it takes no action.
Protected Overrides Sub OnPaintBackground( _ ByVal pevent As System.Windows.Forms.PaintEventArgs) ' Do nothing. End Sub
The next step is to create the painting code. Here is an example that animates a rising and falling ball as it traces an ellipse across a form:
' Indicates whether the animation is currently being shown. Private Animating As Boolean = False ' Track the speed and position of the ball (in the Y-axis). Private BallInitialVelocity As Double Private BallPosition As Double ' Track how long the ball has been in motion. Private StartTime As DateTime Private Sub Form_Paint(ByVal sender As Object, _ ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint ' Check if the animation is in progress. If Animating Then ' Create an in-memory bitmap with the same size as the form. Dim Drawing As New Bitmap(Me.ClientRectangle.Width, _ Me.ClientRectangle.Height, e.Graphics) ' Get the GDI+ drawing surface for the in-memory bitmap. Dim g As Graphics = Graphics.FromImage(Drawing) g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality ' Paint the background. g.FillRectangle(Brushes.Yellow, New Rectangle(New Point(0, 0), _ Me.ClientSize)) ' Calculate the new velocity and position of the ball. Dim Elapsed As Double = DateTime.Now.Subtract(StartTime).TotalSeconds Dim BallVelocity As Double = BallInitialVelocity + 50 * Elapsed BallPosition += (BallVelocity * Elapsed) / 10 ' Draw the ball. Dim Pen As New Pen(Color.Blue, 10) g.DrawEllipse(Pen, CInt(Elapsed * 100), CInt(BallPosition), 10, 10) ' Copy the final image to the form. e.Graphics.DrawImageUnscaled(Drawing, 0, 0) ' Release the GDI+ resources for the in-memory image. g.Dispose() If BallPosition > Me.ClientRectangle.Height Then ' Stop the animation. tmrInvalidate.Stop() Animating = False End If Else ' There is no animation underway. Paint the background. MyBase.OnPaintBackground(e) End If End Sub
To start the animation, the user clicks a button. The event-handling code sets the initial properties of the ball and starts a timer.
Private Sub cmdStart_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles cmdStart.Click Animating = True BallInitialVelocity = -100 BallPosition = Me.ClientRectangle.Height - 10 StartTime = DateTime.Now tmrInvalidate.Start() End Sub
The timer simply invalidates the form (in this case, every 20 milliseconds). The result is smooth, flicker-free animation.
Private Sub tmrInvalidate_Tick(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles tmrInvalidate.Tick Me.Invalidate() End Sub
Display an Irregularly Shaped Window
Problem
You want to create a non-rectangular form.
Solution
Create a new Region object that has the shape you want for the form, and assign it to the Form.Region property.
Discussion
To create a non-rectangular form, you first need to define the shape you want. The easiest approach is to use the System.Drawing.Drawing2D.GraphicsPath object, which can accommodate any combination of ellipses, rectangles, and closed curves. You can add shapes to a GraphicsPath instance using methods such as AddEllipse, AddRectangle, and AddClosedCurve. Once you are finished defining the shape you want, you can create a Region object from this GraphicsPath—just submit the GraphicsPath in the Region class constructor. Finally, you can assign the Region to the form.
In the example that follows, an irregularly shaped form (shown in Figure 12-11) is created using two curves made of multiple points, which are converted into a closed figure using the GraphicsPath.CloseAllFigures method.
Figure 12-11: A non-rectangular form.
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
Dim Path As New System.Drawing.Drawing2D.GraphicsPath()
Dim PointsA() As Point = {New Point(0, 0), New Point(40, 60), _
New Point(Me.Width - 100, 10)}
Path.AddCurve(PointsA)
Dim PointsB() As Point = {New Point(Me.Width - 40, Me.Height - 60), _
New Point(Me.Width, Me.Height), New Point(10, Me.Height)}
Path.AddCurve(PointsB)
Path.CloseAllFigures()
Me.Region = New Region(Path)
End Sub
| Note |
When creating a non-rectangular form, you may omit the title bar portion, which will make it impossible for the user to move the form. If you want to add this ability using custom code, refer to recipe 11.17. |
Create an Owner Drawn Menu
Problem
You want to create a menu that includes pictures, formatted text, or colored item backgrounds.
Solution
Set the OwnerDraw property to True for each MenuItem control you want to draw, and handle the MeasureItem and DrawItem events.
Discussion
The MenuItem class that is included with the .NET Framework is fairly limited. It doesn't provide any ability to change menu font, colors, or even add the common thumbnail icon. To add any of these enhancements, you'll need to combine your menu with custom drawing logic.
Fortunately, .NET makes it easy to replace the standard drawing logic with your own custom code. All you need to do is set the OwnerDraw property for a MenuItem to True. A context menu or main menu can contain a mix of owner-drawn and ordinary menu items, but typically you will perform the drawing work for all items except the top-level headings. Regardless of whether a menu item is owner-drawn or not, it will have its standard appearance in the Visual Studio .NET design-time environment.
Once you set the OwnerDraw property to True, you must handle two MenuItem events. First you must respond to the MeasureItem event to indicate the size the menu item should have. Second you must respond to the DrawItem event to actually draw the shapes, the text, and the images on the provided GDI+ surface, which represents the menu item.
The following example shows a basic implementation of an owner-drawn menu that uses the default menu font and colors. These event handlers are used to draw three different menu items. The appearance of these menu items is very similar to the normal menu control.
Private Sub mnu_MeasureItem(ByVal sender As System.Object, _
ByVal e As System.Windows.Forms.MeasureItemEventArgs) _
Handles mnuNew.MeasureItem, mnuOpen.MeasureItem, mnuSave.MeasureItem
' Retrieve current item.
Dim mnuItem As MenuItem = CType(sender, MenuItem)
Dim MenuFont As New Font("Tahoma", 8)
' Measure size needed to display text.
e.ItemHeight = CInt(e.Graphics.MeasureString( _
mnuItem.Text, MenuFont).Height + 5)
e.ItemWidth = CInt(e.Graphics.MeasureString( _
mnuItem.Text, MenuFont).Width + 5)
End Sub
Private Sub mnu_DrawItem(ByVal sender As Object, _
ByVal e As System.Windows.Forms.DrawItemEventArgs) _
Handles mnuNew.DrawItem, mnuOpen.DrawItem, mnuSave.DrawItem
' Retrieve current item.
Dim mnuItem As MenuItem = CType(sender, MenuItem)
e.DrawBackground()
' Draw the text with the supplied colors and in the set region.
e.Graphics.DrawString(mnuItem.Text, e.Font, _
New SolidBrush(e.ForeColor), e.Bounds.Left + 7, e.Bounds.Top + 3)
End Sub
You can now modify this menu to add shapes, formatting, or images. The challenge when creating a custom menu is deciding how to associate the formatting-related information for the menu (such as the font size, background color, associated image, and so on) with the menu item. A good approach is to derive a custom class that includes this information by deriving from MenuItem. This class can also override the OnMeasureItem and OnDrawItem methods to perform the custom drawing logic in the class, so your form code won't need to handle these events.
The ColoredMenuItem class shown here adds three menu enhancements: support for a custom background color, support for a custom foreground color, and support for a custom font. The drawing code simply reads these values directly from the class instance.
Public Class ColoredMenuItem Inherits MenuItem Private _ForeColor As Color Private _BackColor As Color Private _Font As Font Public Property ForeColor() As Color Get Return _ForeColor End Get Set(ByVal Value As Color) _ForeColor = Value End Set End Property Public Property BackColor() As Color Get Return _BackColor End Get Set(ByVal Value As Color) _BackColor = Value End Set End Property Public Property Font() As Font Get Return _Font End Get Set(ByVal Value As Font) _Font = Value End Set End Property ' To enhance this class, you can add additional constructors that don't ' need all this information. In your drawing logic, you can then use ' default values for menu colors and the menu font if you find this ' information has not been supplied by the user. Public Sub New(ByVal text As String, ByVal foreColor As Color, _ ByVal backColor As Color, ByVal font As Font) Me.Text = text Me.ForeColor = foreColor Me.BackColor = backColor Me.Font = font ' This menu item will always be owner drawn. Me.OwnerDraw = True End Sub Protected Overrides Sub OnMeasureItem( _ ByVal e As System.Windows.Forms.MeasureItemEventArgs) ' Measure size needed to display text. e.ItemHeight = CInt(e.Graphics.MeasureString(Text, Font).Height + 5) e.ItemWidth = CInt(e.Graphics.MeasureString(Text, Font).Width + 5) End Sub Protected Overrides Sub OnDrawItem( _ ByVal e As System.Windows.Forms.DrawItemEventArgs) ' Reverse the background and foreground colors ' if the item is selected. Dim ForeBrush, BackBrush As Brush If (e.State And DrawItemState.Selected) = DrawItemState.Selected Then ForeBrush = New SolidBrush(BackColor) BackBrush = New SolidBrush(ForeColor) Else ForeBrush = New SolidBrush(ForeColor) BackBrush = New SolidBrush(BackColor) End If ' Draw the menu item background. e.Graphics.FillRectangle(BackBrush, e.Bounds) ' Draw the menu item text. e.Graphics.DrawString(Text, Font, ForeBrush, e.Bounds.Left + 7, _ e.Bounds.Top + 3) End Sub End Class
Using the ColoredMenuItem class is slightly more work than using the basic MenuItem class. The problem is that you can't design menus that use the ColoredMenuItem class with the Visual Studio .NET menu editor. Instead, you'll need to create and configure the menu programmatically through code.
Private Sub Form_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
' Define the font for all menu items.
Dim Font As New Font("Tahoma", 8, FontStyle.Bold)
' Create the menu items.
Dim Blue As New ColoredMenuItem("Blue", Color.White, Color.Blue, Font)
Dim Green As New ColoredMenuItem("Green", Color.White, Color.Green, Font)
Dim Lavender As New ColoredMenuItem("Lavender", Color.White, _
Color.Lavender, Font)
Dim Crimson As New ColoredMenuItem("Crimson", Color.White, _
Color.Crimson, Font)
' Add the items to the main menu.
mnuColors.MenuItems.AddRange( _
New MenuItem() {Blue, Green, Lavender, Crimson})
End Sub
The custom-colored menu is shown in Figure 12-12.
Figure 12-12: An owner-drawn menu.
Using the approach shown in this recipe, you can create your own rich menus that mimic the new look of the menus in Office XP and Visual Studio .NET. However, this task requires a significant amount of carefully tweaked painting logic. An easier approach might be to adapt a menu component that has been developed by a third party. The online downloads for this book and the companion site at http:// www.prosetech.com provide links to free sample menu controls that are available on the Internet.
Create an Owner Drawn List Box
Problem
You want to create a list box that includes pictures, formatted text, or colored item backgrounds.
Solution
Set the list box DrawMode to OwnerDrawVariable, and handle the MeasureItem and DrawItem events.
Discussion
By implementing an owner-drawn list box, you can draw custom content in a list box item in the same way that you would draw graphics in a Paint event handler. The only challenge is deciding where to store item-specific graphics or formatting information.
To create a basic owner-drawn list box, set the ListBox.DrawMode property to OwnerDrawVariable (or you can use OwnerDrawFixed if you know that every list item will have the same height). This signals that you want to write the drawing logic for the control. Next you need to handle two events: MeasureItem, in which you specify the size of an item row, and DrawItem, in which you use the GDI+ Graphics class to output images, shapes, or text.
The following code shows the simplest possible owner-drawn list box. It uses a fixed item height (15 pixels), calls ToString on the list object and outputs the text using the current list box font. The cell is given white text if it's selected (in which case it will have a blue background). The operation of this control matches the ordinary list box behavior fairly closely.
Private Sub lstFonts_MeasureItem(ByVal sender As Object, _ ByVal e As System.Windows.Forms.MeasureItemEventArgs) _ Handles lstFonts.MeasureItem ' Set a fixed height. e.ItemHeight = 15 End Sub Private Sub lstFonts_DrawItem(ByVal sender As Object, _ ByVal e As System.Windows.Forms.DrawItemEventArgs) Handles lstFonts.DrawItem ' Draw the background. e.DrawBackground() ' Determine the color based on whether or not the item is selected. Dim Brush As Brush If (e.State And DrawItemState.Selected) = DrawItemState.Selected Then e.DrawFocusRectangle() Brush = Brushes.White Else Brush = Brushes.Black End If ' Draw the item text. e.Graphics.DrawString(lstFonts.Items.Item(e.Index).ToString(), _ lstFonts.Font, Brush, e.Bounds.X, e.Bounds.Y) End Sub
To create a more interesting list box, you can customize these event handlers to use different colors, formatting, or images. (This approach is shown in the QuickStart samples included with Visual Studio .NET.) However, a much better approach is to let the items themselves determine their own formatting using a custom class. This class should encapsulate all the information you need to draw the object, possibly including display text, a font, an image, a foreground and background color, and so on.
The CustomListItem class shown here allows each list item to specify its own font:
Public Class CustomListItem Private _Text As String Private _Font As Font Public Property Text() As String Get Return _Text End Get Set(ByVal Value As String) _Text = Value End Set End Property Public Property Font() As Font Get Return _Font End Get Set(ByVal Value As Font) _Font = Value End Set End Property Public Sub New(ByVal text As String, ByVal font As Font) Me.Text = text Me.Font = font End Sub Public Overrides Function ToString() As String Return Text End Function End Class
Now the DrawItem event handler retrieves the custom CustomListItem instance for the row and draws the text using the specified font:
Private Sub lstFonts_DrawItem(ByVal sender As Object, _ ByVal e As System.Windows.Forms.DrawItemEventArgs) Handles lstFonts.DrawItem ' Draw the background. e.DrawBackground() ' Determine the color based on whether or not the item is selected. Dim Brush As Brush If (e.State And DrawItemState.Selected) = DrawItemState.Selected Then e.DrawFocusRectangle() Brush = Brushes.White Else Brush = Brushes.Black End If ' Get the font from the current item. Dim Font As Font Font = CType(lstFonts.Items(e.Index), CustomListItem).Font ' Draw the item text. e.Graphics.DrawString(lstFonts.Items.Item(e.Index).ToString(), _ Font, Brush, e.Bounds.X, e.Bounds.Y) End Sub
The MeasureItem event handler also needs to take the size of the font into consideration:
Private Sub lstFonts_MeasureItem(ByVal sender As Object, _ ByVal e As System.Windows.Forms.MeasureItemEventArgs) _ Handles lstFonts.MeasureItem ' Get the height from the current item's font. Dim Font As Font Font = CType(lstFonts.Items(e.Index), CustomListItem).Font e.ItemHeight = Font.Height End Sub
To test this application, you can use the technique from recipe 12.10 to create a CustomListItemFont instance for every installed font. Remember, the custom-drawn content won't appear in the Visual Studio .NET design-time environment.
Private Sub Form_Load(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles MyBase.Load Dim FontFamilies As New System.Drawing.Text.InstalledFontCollection() Dim Family As FontFamily For Each Family In FontFamilies.Families Try Dim Font As New Font(Family.Name, 12) Dim Item As New CustomListItem(Family.Name, Font) lstFonts.Items.Add(Item) Catch ' Ignore fonts that don't support the default size. End Try Next End Sub
The resulting list box is shown in Figure 12-13.
Figure 12-13: An owner-drawn list box.
Remember, you can extend this control by creating a new list item object. For example, you could create list boxes that accommodate thumbnail images by adding a property of type Image to the CustomListItem class.
Introduction
- Strings and Regular Expressions
- Numbers, Dates, and Other Data Types
- Arrays and Collections
- Objects, Interfaces, and Patterns
- Files and Directories
- XML
- Multithreading
- Network Programming
- Reflection
- Windows Programming
- Windows Controls
- Printing and Drawing with GDI+
- Windows Services
- ADO.NET
- ASP.NET Web Applications
- Web Services
- Remoting and Enterprise Services
- Security and Cryptography
- Useful COM Interop
EAN: 2147483647
Pages: 376
