In VB6 it was a simple call to Printer.Print and voila your document would print. But it's not that simple in VB.Net. VB.Net, beings that it is now an Object Orientated Language, requires that the developer set up the print area, determine how many lines can fit in that print area, determine print area size, margins, font and size, the works. This, as you can imagine, has been giving legacy VB programmers fits, and that is the purpose of this tutorial.
In this tutorial we will create our own printing class, and unlike many of the samples provided by Microsoft themselves, this one actually works right. Our class will inherit from the PrintDocument Class, located in the System.Drawing.Printing Namespace. Doing it this way will give us all the functionality of the PrintDocument, while allowing us, the developers, to determine items and override the default methods it contains. So now lets jump into some code (I know thats what you're waiting for).
Creating Our Class
As with any class, before we can use any of the Classes, Events and Objects available to us in the .Net Framework we need to import the Namespaces we need. For this we need but 2:
Imports System.Drawing Imports System.Drawing.Printing
Now for the inheriting of the PrintDocument Class. To inherit from a class you need to tell your class you're inheriting from something, in our case it is the PrintDocument Class, to do this, make the following change to the declaration of your class:
Public Class PCPrint : Inherits Printing.PrintDocument End Class
So now we have a shell to work with that inherits from the PrintDocument Class, so lets add some functionality and other code to our class. In our class we will have 2 properties, one to hold the text that we are printing, and one to hold the Font we will be using when printing our document.
Adding the Font property allows us to override the default font. As with all properties, we need private modifiers for them, these are just private variables that will represent the values of our Properties. We make them private because we don't want their values to be changed directly. These will then be used for setting the value of our properties. First the variables:
#Region " Property Variables " ''' <summary> ''' Property variable for the Font the user wishes to use ''' </summary> ''' <remarks></remarks> Private _font As Font ''' <summary> ''' Property variable for the text to be printed ''' </summary> ''' <remarks></remarks> Private _text As String #End Region
NOTE: You will notice all the code I offer in this tutorial is separated into sections using the #Region...#End Region blocks. This makes for faster finding of code, especially if you have a large code file.
Now for the properties, our properties are Read/Write properties so they have both a Get and Set area, allowing us to set their value, and retrieve their value:
#Region " Class Properties " ''' <summary> ''' Property to hold the text that is to be printed ''' </summary> ''' <value></value> ''' <returns>A string</returns> ''' <remarks></remarks> Public Property TextToPrint() As String Get Return _text End Get Set(ByVal Value As String) _text = Value End Set End Property ''' <summary> ''' Property to hold the font the users wishes to use ''' </summary> ''' <value></value> ''' <returns></returns> ''' <remarks></remarks> Public Property PrinterFont() As Font ' Allows the user to override the default font Get Return _font End Get Set(ByVal Value As Font) _font = Value End Set End Property #End Region
Next we will incorporate some Constructors for our class. If you dont add Constructors, the CLR assumes an empty Constructor, this allows you to instantiate your class so you can use it. We will add both an empty Constructor, and one that accepts a parameter, the parameter will be the text we want to print.
Since we are inheriting from a seperate class, we need to call the Constructor of the base class. This is done by using MyBase.New(), this will call the Constructor of our base class, the PrintDocument Class:
#Region " Class Constructors " ''' <summary> ''' Empty constructor ''' </summary> ''' <remarks></remarks> Public Sub New() 'Call the base classes constructor MyBase.New() 'Instantiate out Text property to an empty string _text = String.Empty End Sub ''' <summary> ''' Constructor to initialize our printing object ''' and the text it's supposed to be printing ''' </summary> ''' <param name="str">Text that will be printed</param> ''' <remarks></remarks> Public Sub New(ByVal str As String) 'Call the base classes constructor MyBase.New() 'Set our Text property value _text = str End Sub #End Region
Now we have our Properties and our Constructors, next we will add a couple methods to our class. In our printing class we will be overriding 2 of the PrintDocument Methods, those will be the onbeginPrint Method and the onbeginPring Method. In the onbeginPrint Method we will override the default font with the font we specify, and in the OnPrintPage we will be setting up the specifics of our page. We will be setting the following properties:
- Page Size
- Page Orientation (Landscape, Portrait)
- Top Margin
- Left Margin
#Region " onbeginPrint " ''' <summary> ''' Override the default onbeginPrint method of the PrintDocument Object ''' </summary> ''' <param name="e"></param> ''' <remarks></remarks> Protected Overrides Sub onbeginPrint(ByVal e As Printing.PrintEventArgs) ' Run base code MyBase.onbeginPrint(e) 'Check to see if the user provided a font 'if they didnt then we default to Times New Roman If _font Is Nothing Then 'Create the font we need _font = New Font("Times New Roman", 10) End If End Sub #End Region
As you can see, here we call the base classes onbeginPrint Method, then we check to see if a font was provided, if one wasnt we default to Times New Roman. The OnPrintpage Method is quite a bit larger and complex, this is where we will be doing the bulk of our work.
In this method we will be setting the size of the print area (the page size), we will determine if the user selected Landscape or Portrait as the print style, we will determine how many lines we are printing and how many lines will fit in our page size, and finally we will tell the printer whether we have more pages to print. Lets take a look at our overridden OnPrintPage Method:
#Region " OnPrintPage " ''' <summary> ''' Override the default OnPrintPage method of the PrintDocument ''' </summary> ''' <param name="e"></param> ''' <remarks>This provides the print logic for our document</remarks> Protected Overrides Sub OnPrintPage(ByVal e As Printing.PrintPageEventArgs) ' Run base code MyBase.OnPrintPage(e) 'Declare local variables needed Static curChar As Integer Dim printHeight As Integer Dim printWidth As Integer Dim leftMargin As Integer Dim rightMargin As Integer Dim lines As Int32 Dim chars As Int32 'Set print area size and margins With MyBase.DefaultPageSettings printHeight = .PaperSize.Height - .Margins.Top - .Margins.Bottom printWidth = .PaperSize.Width - .Margins.Left - .Margins.Right leftMargin = .Margins.Left 'X rightMargin = .Margins.Top 'Y End With 'Check if the user selected to print in Landscape mode 'if they did then we need to swap height/width parameters If MyBase.DefaultPageSettings.Landscape Then Dim tmp As Integer tmp = printHeight printHeight = printWidth printWidth = tmp End If 'Now we need to determine the total number of lines 'we're going to be printing Dim numLines As Int32 = CInt(printHeight / PrinterFont.Height) 'Create a rectangle printing are for our document Dim printArea As New RectangleF(leftMargin, rightMargin, printWidth, printHeight) 'Use the StringFormat class for the text layout of our document Dim format As New StringFormat(StringFormatFlags.LineLimit) 'Fit as many characters as we can into the print area e.Graphics.MeasureString(_text.Substring(RemoveZeros(curChar)), PrinterFont, New SizeF(printWidth, printHeight), format, chars, lines) 'Print the page e.Graphics.DrawString(_text.Substring(RemoveZeros(curChar)), PrinterFont, Brushes.Black, printArea, format) 'Increase current char count curChar += chars 'Detemine if there is more text to print, if 'there is the tell the printer there is more coming If curChar < _text.Length Then e.HasMorePages = True Else e.HasMorePages = False curChar = 0 End If End Sub #End Region
You will notice that in this method we reference a function called RemoveZeros. This is the last function in our class, and it has an important role. Instead of using the legacy IIF function, or ugly nested If..Else statements, we will create a function that will check our value, and if it's a 0 (zero) we will replace it with a 1 (one). Zero's can cause bad things to happen when it comes to printing and determining page size and margins, so to alleviate that we use our RemoveZeros Function:
#Region " RemoveZeros " ''' <summary> ''' Function to replace any zeros in the size to a 1 ''' Zero's will mess up the printing area ''' </summary> ''' <param name="value">Value to check</param> ''' <returns></returns> ''' <remarks></remarks> Public Function RemoveZeros(ByVal value As Integer) As Integer 'Check the value passed into the function, 'if the value is a 0 (zero) then return a 1, 'otherwise return the value passed in Select Case value Case 0 Return 1 Case Else Return value End Select End Function #End Region
Using Our Class
And there you have it, our completed printing class. Now I know some are asking "I see this class, but how do I use it?". Well I'm glad you asked, this class is much easier to use than one would imagine. In your Form's code I would create a procedure, lets name it printDocument, then inside that procedure we would create an instance of our printer class, set its properties (PrinterFont, TextToPrint), then issue a print command, like this:
#Region " PrintDocument " Public Sub PrintDocument() 'Create an instance of our printer class Dim printer As New PCPrint() 'Set the font we want to use printer.PrinterFont = New Font("Verdana", 10) 'Set the TextToPrint property printer.TextToPrint = Textbox1.Text 'Issue print command printer.Print() End Sub #End Region
Then in the click event of your print button call PrintDocument, and your document will print. Thats it, thats how easy it is to use your new printer class. This class is reusable, you can incorporate it anywhere you have documents that need to be printed. If you wanted to print graphics some functionality would need to be added, those changes will be in a completely separate tutorial.
I hope you found this tutorial on Printing in VB.Net to be useful and informative, and I thank you for reading. I will be including the class used in this tutorial, but remember it is under the GPL - General Public License. With this license you can modify this code to suite your needs, but the license header must remain in tact.
Number of downloads: 28876
This post has been edited by skyhawk133: 24 February 2008 - 10:38 AM