This post goes out to all you VB geeks that are wondering what happened to Printer.Print in VB. This may be a dated topic but I have a feeling there are a few out there longing for those VB6 days when the printer was always sitting there loyal and waiting. The VB6 programmer’s best friend. Well, when you needed to print something anyway. Once upon a time you could just write a few lines of code and *poof* you created a page of information for your users. Now you have this PrintDocument thing and PrintDialogs and PrintPreviewDialogs and Graphics objects and the list just goes on and on.
Let me re-introduce you to printing in .NET. Once you get through the slight grade of the learning curve, you’ll be convinced that .Net printing is better than anything you did with the printer object in VB6.
The task - print a smiley face on a piece of paper. Lines of code in VB6 - about 6. Lines of code the .net way - about 22 (but you could consolidate…).
That doesn’t sound like a good trade off. It seems its easier in VB6. However - what if you wanted to create a bitmap of the smiley face and then use that bitmap in various places as well as print it here and there? How many line of code do you need now?
In VB6 - I have no idea. You would need to drop down to the API level and call graphics functions against a Device Independent Bitmap device context making sure you clean up after yourself in those places where cleanup is necessary. Then you would need to save that bitmap to a file and/or have an image control somewhere that you could set using the memory bitmap (again using API calls). Then perhaps you could print the smiley here and there using some similar printing code.
In .NET - its the same 22 lines of code and you can run those lines of code against any “Device Context” (using API terminology) by simply passing a Graphics object to the code that actually creates the smiley. You could even create a bitmap object and simply use that bitmap throughout your program without ever getting close to the windows API.
Here are my CreateSmiley functions:
private void DrawSmiley(Graphics g, int Width)
{
Pen p=new Pen(Color.Black);
SolidBrush b = new SolidBrush(Color.Black);
SolidBrush YellowBrush = new SolidBrush(Color.Yellow);
Point Origin = new Point(0, 0);
Size HeadSize=new Size(Width,Width);
Rectangle Container=new Rectangle(Origin, HeadSize);
Point LeftEye=Origin;
Point RightEye=Origin;
Point SmileTopLeft = Origin;
LeftEye.Offset((int)(HeadSize.Width*.25), (int)(HeadSize.Width*.20));
RightEye.Offset((int)(HeadSize.Width*.65), (int)(HeadSize.Width*.20));
SmileTopLeft.Offset((int)(HeadSize.Width *.20), (int)(HeadSize.Width * .40));
Size SmileSize = new Size((int)(HeadSize.Width*.60), (int)(HeadSize.Width*.40));
Size EyeSize=new Size((int)(HeadSize.Width * .10),(int)(HeadSize.Width * .10));
g.FillEllipse(YellowBrush, Container);
g.DrawEllipse(p, Container);
g.FillEllipse(b, new Rectangle(LeftEye, EyeSize));
g.FillEllipse(b, new Rectangle(RightEye, EyeSize));
g.DrawArc(p, new Rectangle(SmileTopLeft, SmileSize), 180, -180);
b.Dispose();
YellowBrush.Dispose();
p.Dispose();
}
private Bitmap CreateSmiley(int Width)
{
Bitmap Smiley = new Bitmap(Width, Width);
Graphics g=Graphics.FromImage(Smiley);
DrawSmiley(g, Smiley.Width);
g.Dispose();
return Smiley;
}
Pretty basic stuff and different than you did in VB6. You have access to all the API stuff without dropping down the the API level. Now as far as printing goes - there are a few objects that need your attention. The PrintDocument, PrintDialog, and PrintPreviewDialog objects. The PrintDocument object is the container for all your drawing methods. It handles paging and rendering of the stuff you are printing. The PrintDialog and PrintPreviewDialog objects manage the actual device you are printing to. The PrintDialog as you may have guessed will print to a printer while the PrintPreviewDialog prints to a preview window.
Here is some code that uses a PrintPreviewDialog and calls the printing methods above:
private void button1_Click(object sender, EventArgs e)
{
PrintDocument pdoc = new PrintDocument();
// hook up the event handler for the printpage event
pdoc.PrintPage += new PrintPageEventHandler(pdoc_PrintPage);
PrintPreviewDialog pdialog = new PrintPreviewDialog();
pdialog.Document = pdoc;
pdialog.ClientSize = new Size(640, 480);
pdialog.Show();
}
void pdoc_PrintPage(object sender, PrintPageEventArgs e)
{
Bitmap smiley=CreateSmiley(300);
e.Graphics.DrawImage(smiley, new Point(150, 150));
e.HasMorePages = false;
}
The VB.Net code is virtually the same. Just change the declaration variables around, change the curly braces to Sub/End Sub, remove the semi-colons and your 80% done.
This method of printing is easy to hook up and offers a great deal of flexibility but if you want real reporting power - there is no substitute for a good reporting engine such as SQL Server Reporting Services or Business Objects’ Crystal Reports. There are others. I’m a convert. I was a Crystal Reports bigot but if you’re using a SQL Server database - you get reporting services for free and I must admit after running SQL RS through its paces - I like it better than Crystal Reports. That, of course, is my opinion.
