The following code shows a form that iterates through the font collection when it is first created. Every time it finds a font, it creates a new Label control that will display the font name in the given font face (at a size of 14 points). The Label is added to a Panel control named pnlFonts with AutoScroll set to true, allowing the user to scroll through the list of available fonts.

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Text;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_01: Form
    {
        public Recipe08_01()
        {
            InitializeComponent();
        }

        private void Recipe08_01_Load(object sender, EventArgs e)
        {

// Create the font collection.
            using (InstalledFontCollection fontFamilies =
                new InstalledFontCollection())
            {
                // Iterate through all font families.
                int offset = 10;
                foreach (FontFamily family in fontFamilies.Families)
                {
                    try
                    {
                        // Create a label that will display text in this font.
                        Label fontLabel = new Label();
                        fontLabel.Text = family.Name;
                        fontLabel.Font = new Font(family, 14);
                        fontLabel.Left = 10;
                        fontLabel.Width = pnlFonts.Width;
                        fontLabel.Top = offset;

                        // Add the label to a scrollable Panel.
                        pnlFonts.Controls.Add(fontLabel);
                        offset += 30;
                    }
                    catch
                    {
                        // An error will occur if the selected font does
                        // not support normal style (the default used when
                        // creating a Font object). This problem can be
                        // harmlessly ignored.
                    }
                }
            }
        }
    }
}

Figure 8-1 shows this simple test application.

Figure 8.1. A list of installed fonts

The following example shows a form that creates a Rectangle and a GraphicsPath. By default, these two shapes are given light-blue backgrounds. However, an event handler responds to the Form.MouseMove event, checks to see whether the mouse pointer is in one of these shapes, and updates the background to bright pink if the pointer is there.

Note that the highlighting operation takes place directly inside the MouseMove event handler. The painting is performed only if the current selection has changed. For simpler code, you could invalidate the entire form every time the mouse pointer moves in or out of a region and handle all the drawing in the Form.Paint event handler, but this would lead to more drawing and generate additional flicker as the entire form is repainted.

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Drawing2D;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_02 : Form
    {
        // Define the shapes used on this form.
        private GraphicsPath path;
        private Rectangle rectangle;

        // Define the flags that track where the mouse pointer is.
        private bool inPath = false;
        private bool inRectangle = false;

// Define the brushes used for painting the shapes.
        Brush highlightBrush = Brushes.HotPink;
        Brush defaultBrush = Brushes.LightBlue;

        public Recipe08_02()
        {
            InitializeComponent();
        }

        private void Recipe08_02_Load(object sender, EventArgs e)
        {
            // Create the shapes that will be displayed.
            path = new GraphicsPath();
            path.AddEllipse(10, 10, 100, 60);
            path.AddCurve(new Point[] {new Point(50, 50),
                      new Point(10,33), new Point(80,43)});
            path.AddLine(50, 120, 250, 80);
            path.AddLine(120, 40, 110, 50);
            path.CloseFigure();

            rectangle = new Rectangle(100, 170, 220, 120);
        }

        private void Recipe08_02_Paint(object sender, PaintEventArgs e)
        {
            Graphics g = e.Graphics;

            // Paint the shapes according to the current selection.
            if (inPath)
            {
                g.FillPath(highlightBrush, path);
                g.FillRectangle(defaultBrush, rectangle);
            }
            else if (inRectangle)
            {
                g.FillRectangle(highlightBrush, rectangle);
                g.FillPath(defaultBrush, path);
            }
            else
            {
                g.FillPath(defaultBrush, path);
                g.FillRectangle(defaultBrush, rectangle);
            }
            g.DrawPath(Pens.Black, path);
            g.DrawRectangle(Pens.Black, rectangle);
        }

private void Recipe08_02_MouseMove(object sender, MouseEventArgs e)
        {
            using (Graphics g = this.CreateGraphics())
            {
                // Perform hit testing with rectangle.
                if (rectangle.Contains(e.X, e.Y))
                {
                    if (!inRectangle)
                    {
                        inRectangle = true;

                        // Highlight the rectangle.
                        g.FillRectangle(highlightBrush, rectangle);
                        g.DrawRectangle(Pens.Black, rectangle);
                    }
                }
                else if (inRectangle)
                {
                    inRectangle = false;

                    // Restore the unhighlighted rectangle.
                    g.FillRectangle(defaultBrush, rectangle);
                    g.DrawRectangle(Pens.Black, rectangle);
                }

                // Perform hit testing with path.
                if (path.IsVisible(e.X, e.Y))
                {
                    if (!inPath)
                    {
                        inPath = true;

                        // Highlight the path.
                        g.FillPath(highlightBrush, path);
                        g.DrawPath(Pens.Black, path);
                    }
                }
                else if (inPath)
                {
                    inPath = false;

                    // Restore the unhighlighted path.
                    g.FillPath(defaultBrush, path);
                    g.DrawPath(Pens.Black, path);
                }
            }
        }
    }
}

Figure 8-2 shows the application in action.

Figure 8.2. Hit testing with a Rectangle and a GraphicsPath object

The following example creates an irregularly shaped form (shown in Figure 8-3) using two curves made of multiple points, which are converted into a closed figure using the GraphicsPath.CloseAllFigures method.

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Drawing2D;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_03 : Form
    {
        public Recipe08_03()
        {
            InitializeComponent();
        }

        private void Recipe08_03_Load(object sender, EventArgs e)
        {
            GraphicsPath path = new GraphicsPath();

            Point[] pointsA = new Point[]
                {
                    new Point(0, 0),
                    new Point(40, 60),
                    new Point(this.Width - 100, 10)
                };
            path.AddCurve(pointsA);

            Point[] pointsB = new Point[]
                {
                    new Point(this.Width - 40, this.Height - 60),
                    new Point(this.Width, this.Height),
                    new Point(10, this.Height)
                };
            path.AddCurve(pointsB);

            path.CloseAllFigures();

            this.Region = new Region(path);
        }

private void cmdClose_Click(object sender, EventArgs e)
        {
            this.Close();
        }
    }
}

Figure 8.3. A nonrectangular form

For an example that demonstrates a nonrectangular control, refer to recipe 8-4.

The following example shows a control that represents a simple ellipse shape on a form. All controls are associated with a rectangular region on a form, so the EllipseShape control generates an ellipse that fills these boundaries (provided through the Control.ClientRectangle property). Once the shape has been generated, the Control.Region property is set according to the bounds on the ellipse. This ensures that events such as MouseMove, MouseDown, Click, and so on, will occur only if the mouse is over the ellipse, not the entire client rectangle.

The following code shows the full EllipseShape code:

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Drawing2D;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class EllipseShape : Control
    {
        public EllipseShape()
        {
            InitializeComponent();
        }

        private GraphicsPath path = null;

private void RefreshPath()
        {
            // Create the GraphicsPath for the shape (in this case
            // an ellipse that fits inside the full control area)
            // and apply it to the control by setting
            // the Region property.
            path = new GraphicsPath();
            path.AddEllipse(this.ClientRectangle);
            this.Region = new Region(path);
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            if (path != null)
            {
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
                e.Graphics.FillPath(new SolidBrush(this.BackColor), path);
                e.Graphics.DrawPath(new Pen(this.ForeColor, 4), path);
            }
        }

        protected override void OnResize(System.EventArgs e)
        {
            base.OnResize(e);
            RefreshPath();
            this.Invalidate();
        }
    }
}

You could define the EllipseShape control in a separate class library assembly so that you could add it to the Microsoft Visual Studio .NET toolbox and use it at design time. However, even without taking this step, it is easy to create a simple test application. The following Windows Forms application creates two ellipses and allows the user to drag both of them around the form, simply by holding the mouse down and moving the pointer:

using System;
using System.Drawing;
using System.Windows.Forms;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_04 : Form
    {
        public Recipe08_04()
        {
            InitializeComponent();
        }

// Tracks when drag mode is on.
        private bool isDraggingA = false;
        private bool isDraggingB = false;

        // The ellipse shape controls.
        private EllipseShape ellipseA, ellipseB;

        private void Recipe08_04_Load(object sender, EventArgs e)
        {
            // Create and configure both ellipses.
            ellipseA = new EllipseShape();
            ellipseA.Width = ellipseA.Height = 100;
            ellipseA.Top = ellipseA.Left = 30;
            ellipseA.BackColor = Color.Red;
            this.Controls.Add(ellipseA);

            ellipseB = new EllipseShape();
            ellipseB.Width = ellipseB.Height = 100;
            ellipseB.Top = ellipseB.Left = 130;
            ellipseB.BackColor = Color.Azure;
            this.Controls.Add(ellipseB);

            // Attach both ellipses to the same set of event handlers.
            ellipseA.MouseDown += Ellipse_MouseDown;
            ellipseA.MouseUp += Ellipse_MouseUp;
            ellipseA.MouseMove += Ellipse_MouseMove;

            ellipseB.MouseDown += Ellipse_MouseDown;
            ellipseB.MouseUp += Ellipse_MouseUp;
            ellipseB.MouseMove += Ellipse_MouseMove;
        }

        private void Ellipse_MouseDown(object sender, MouseEventArgs e)
        {
            // Get the ellipse that triggered this event.
            Control control = (Control)sender;

            if (e.Button == MouseButtons.Left)
            {
                control.Tag = new Point(e.X, e.Y);
                if (control == ellipseA)
                {
                    isDraggingA = true;
                }
                else
                {
                    isDraggingB = true;
                }
            }
        }

private void Ellipse_MouseUp(object sender, MouseEventArgs e)
        {
            isDraggingA = false;
            isDraggingB = false;
        }

        private void Ellipse_MouseMove(object sender, MouseEventArgs e)
        {
            // Get the ellipse that triggered this event.
            Control control = (Control)sender;

            if ((isDraggingA && control == ellipseA) ||
             (isDraggingB && control == ellipseB))
            {
                // Get the offset.
                Point point = (Point)control.Tag;

                // Move the control.
                control.Left = e.X + control.Left - point.X;
                control.Top = e.Y + control.Top - point.Y;
            }
        }
    }
}

Figure 8-4 shows the user about to drag an ellipse.

Figure 8.4. Dragging custom shape controls on a form

The following example creates an image that represents a document. The image is generated as an in-memory bitmap, and several lines of text are added using the Graphics.DrawString method. The image is then bound to a picture box, which is shown in a scrollable panel, as shown in Figure 8-5.

using System;
using System.Drawing;
using System.Windows.Forms;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_05 : Form
    {
        public Recipe08_05()
        {
            InitializeComponent();
        }

        private void Recipe08_05_Load(object sender, EventArgs e)
        {
            string text = "The quick brown fox jumps over the lazy dog.";
            using (Font font = new Font("Tahoma", 20))
            {

// Create an in-memory bitmap.
                Bitmap b = new Bitmap(600, 600);
                using (Graphics g = Graphics.FromImage(b))
                {
                    g.FillRectangle(Brushes.White, new Rectangle(0, 0,
                        b.Width, b.Height));

                    // Draw several lines of text on the bitmap.
                    for (int i = 0; i < 10; i++)
                    {
                        g.DrawString(text, font, Brushes.Black,
                            50, 50 + i * 60);
                    }
                }

                // Display the bitmap in the picture box.
                pictureBox1.BackgroundImage = b;
                pictureBox1.Size = b.Size;
            }
        }
    }
}

Figure 8.5. Adding scrolling support to custom content

The following example captures the screen and displays it in a picture box. It first creates a new Bitmap object and then invokes CopyFromScreen to draw onto the Bitmap. After drawing, the image is assigned to the picture box, as shown in Figure 8-6.

using System;
using System.Drawing;
using System.Windows.Forms;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_06 : Form
    {
        public Recipe08_06()
        {
            InitializeComponent();
        }

        private void cmdCapture_Click(object sender, EventArgs e)
        {
            Bitmap screen = new Bitmap(Screen.PrimaryScreen.Bounds.Width,
                Screen.PrimaryScreen.Bounds.Height);

            using (Graphics g = Graphics.FromImage(screen))
            {
                g.CopyFromScreen(0, 0, 0, 0, screen.Size);
            }

pictureBox1.Image = screen;
        }
    }
}

Figure 8.6. Capturing the screen contents

The following example sets the DoubleBuffered property of the form to true and shows an animation of an image alternately growing and shrinking on the page. The drawing logic takes place in the Form.Paint event handler, and a timer invalidates the form in a preset interval so that the image can be redrawn. The user can choose whether to enable double buffering through a check box on the form. Without double buffering, the form flickers noticeably. When double buffering is enabled, however, the image grows and shrinks with smooth, flicker-free animation.

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Drawing2D;

namespace Apress.VisualCSharpRecipes.Chapter08
{
   public partial class Recipe08_07 : Form
   {
       public Recipe08_07()
       {
           InitializeComponent();
       }

       // Track the image size and the type of animation
       // (expanding or shrinking).
       private bool isShrinking = false;
       private int imageSize = 0;

       // Store the logo that will be painted on the form.
       private Image image;

private void Recipe08_07_Load(object sender, EventArgs e)
       {
          // Load the logo image from the file.
          image = Image.FromFile("test.jpg");

           // Start the timer that invalidates the form.
           tmrRefresh.Start();
       }

       private void tmrRefresh_Tick(object sender, EventArgs e)
       {
           // Change the desired image size according to the animation mode.
           if (isShrinking)
           {
               imageSize--;
           }
           else
           {
               imageSize++;
           }

           // Change the sizing direction if it nears the form border.
           if (imageSize > (this.Width - 150))
           {
               isShrinking = true;
           }
           else if (imageSize < 1)
           {
               isShrinking = false;
           }

           // Repaint the form.
           this.Invalidate();
       }

       private void Recipe08_07_Paint(object sender, PaintEventArgs e)
       {
           Graphics g;

           g = e.Graphics;

           g.SmoothingMode = SmoothingMode.HighQuality;

           // Draw the background.
           g.FillRectangle(Brushes.Yellow, new Rectangle(new Point(0, 0),
           this.ClientSize));

           // Draw the logo image.
           g.DrawImage(image, 50, 50, 50 + imageSize, 50 + imageSize);
       }

private void chkUseDoubleBuffering_CheckedChanged(object sender, EventArgs e)
       {
           this.DoubleBuffered = chkUseDoubleBuffering.Checked;
       }
   }
}

The following example reads a bitmap file and generates a thumbnail that is not greater than 200×200 pixels while preserving the original aspect ratio:

using System;
using System.Drawing;
using System.Windows.Forms;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_08 : Form
    {
        public Recipe08_08()
        {
            InitializeComponent();
        }

        Image thumbnail;

        private void Recipe08_08_Load(object sender, EventArgs e)
        {
            using (Image img = Image.FromFile("test.jpg"))
            {
                int thumbnailWidth = 0, thumbnailHeight = 0;

                // Adjust the largest dimension to 200 pixels.
                // This ensures that a thumbnail will not be larger than
                // 200x200 pixels.
                // If you are showing multiple thumbnails, you would reserve a
                // 200x200-pixel square for each one.
                if (img.Width > img.Height)
                {
                    thumbnailWidth = 200;
                    thumbnailHeight = Convert.ToInt32(((200F / img.Width) *
                      img.Height));
                }
                else
                {
                    thumbnailHeight = 200;
                    thumbnailWidth = Convert.ToInt32(((200F / img.Height) *
                      img.Width));
                }

                thumbnail = img.GetThumbnailImage(thumbnailWidth, thumbnailHeight,
                  null, IntPtr.Zero);
            }
        }

        private void Recipe08_08_Paint(object sender, PaintEventArgs e)
        {
            e.Graphics.DrawImage(thumbnail, 10, 10);
        }
    }
}

The following example plays two different beeps and the asterisk sound in succession, using the Console and SystemSound classes:

using System;
using System.Windows.Forms;
using System.Media;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_09 : Form
    {
        public Recipe08_09()
        {
            InitializeComponent();
        }

private void Recipe08_09_Load(object sender, EventArgs e)
        {
            // Play a beep with default frequency
            // and duration (800 and 200, respectively).
            Console.Beep();
            Thread.Sleep(500);

            // Play a beep with frequency as 200 and duration as 300.
            Console.Beep(200, 300);
            Thread.Sleep(500);

            // Play the sound associated with the Asterisk event.
            SystemSounds.Asterisk.Play();
        }
    }
}

The following example shows a simple form that allows users to open any WAV file and play it:

using System;
using System.Windows.Forms;
using System.Media;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_10 : Form
    {
        public Recipe08_10()
        {
            InitializeComponent();
        }

        private void cmdOpen_Click(object sender, EventArgs e)
        {
            // Allow the user to choose a file.
            OpenFileDialog openDialog = new OpenFileDialog();
            openDialog.InitialDirectory = "C:\Windows\Media";
            openDialog.Filter = "WAV Files|*.wav|All Files|*.*";

            if (DialogResult.OK == openDialog.ShowDialog())
            {
                SoundPlayer player = new SoundPlayer(openDialog.FileName);

                try
                {
                    player.Play();
                }
                catch (Exception)
                {
                    MessageBox.Show("An error occurred while playing media.");
                }
                finally
                {
                    player.Dispose();
                }
            }
        }
    }
}

The following example shows a simple form that allows you to open any audio file and play it.

You can also use the Quartz library to show movie files, as demonstrated in recipe 8-12.

using System;
using System.Windows.Forms;
using QuartzTypeLib;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_11 : Form
    {
        public Recipe08_11()
        {
            InitializeComponent();
        }

        private void cmdOpen_Click(object sender, EventArgs e)
        {
            // Allow the user to choose a file.
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter =
                "Media Files|*.wav;*.mp3;*.mp2;*.wma|All Files|*.*";

            if (DialogResult.OK == openFileDialog.ShowDialog())
            {

// Access the IMediaControl interface.
                QuartzTypeLib.FilgraphManager graphManager =
                  new QuartzTypeLib.FilgraphManager();
                QuartzTypeLib.IMediaControl mc =
                  (QuartzTypeLib.IMediaControl)graphManager;

                // Specify the file.
                mc.RenderFile(openFileDialog.FileName);

                // Start playing the audio asynchronously.
                mc.Run();
            }
        }
    }
}

The following example shows a simple form that allows users to access a video file and play it back in the provided picture box. The picture box is anchored to all sides of the form, so it changes size as the form resizes. The code responds to the PictureBox.SizeChanged event to change the size of the corresponding video window.

using System;
using System.Windows.Forms;
using QuartzTypeLib;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_12 : Form
    {
        public Recipe08_12()
        {
            InitializeComponent();
        }

        // Define constants used for specifying the window style.
        private const int WS_CHILD = 0x40000000;
        private const int WS_CLIPCHILDREN = 0x2000000;

        // Hold a form-level reference to the media control interface,
        // so the code can control playback of the currently loaded
        // movie.
        private IMediaControl mc = null;

        // Hold a form-level reference to the video window in case it
        // needs to be resized.
        private IVideoWindow videoWindow = null;

        private void cmdOpen_Click(object sender, EventArgs e)
        {
            // Allow the user to choose a file.
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter =
            "Media Files|*.mpg;*.avi;*.wma;*.mov;*.wav;*.mp2;*.mp3|" +
            "All Files|*.*";

            if (DialogResult.OK == openFileDialog.ShowDialog())
            {
                // Stop the playback for the current movie, if it exists.
                if (mc != null) mc.Stop();

                // Load the movie file.
                FilgraphManager graphManager = new FilgraphManager();
                graphManager.RenderFile(openFileDialog.FileName);

// Attach the view to a picture box on the form.
                try
                {
                    videoWindow = (IVideoWindow)graphManager;
                    videoWindow.Owner = (int)pictureBox1.Handle;
                    videoWindow.WindowStyle = WS_CHILD | WS_CLIPCHILDREN;
                    videoWindow.SetWindowPosition(
                      pictureBox1.ClientRectangle.Left,
                      pictureBox1.ClientRectangle.Top,
                      pictureBox1.ClientRectangle.Width,
                      pictureBox1.ClientRectangle.Height);
                }
                catch
                {
                    // An error can occur if the file does not have a video
                    // source (for example, an MP3 file).
                    // You can ignore this error and still allow playback to
                    // continue (without any visualization).
                }

                // Start the playback (asynchronously).
                mc = (IMediaControl)graphManager;
                mc.Run();
            }
        }

        private void pictureBox1_SizeChanged(object sender, EventArgs e)
        {
            if (videoWindow != null)
            {
                try
                {
                    videoWindow.SetWindowPosition(
                        pictureBox1.ClientRectangle.Left,
                        pictureBox1.ClientRectangle.Top,
                        pictureBox1.ClientRectangle.Width,
                        pictureBox1.ClientRectangle.Height);
                }
                catch
                {
                    // Ignore the exception thrown when resizing the form
                    // when the file does not have a video source.
                }
            }
        }
    }
}

Figure 8-7 shows an example of the output you will see.

Figure 8.7. Playing a video file

The following code shows a console application that finds all the printers installed on a computer and displays information about the paper sizes and the resolutions supported by each one.

You do not need to take this approach when creating an application that provides printing features. As you will see in recipe 8-14, you can use the PrintDialog class 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.

using System;
using System.Drawing.Printing;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    class Recipe08_13
    {
        static void Main(string[] args)
        {
            foreach (string printerName in PrinterSettings.InstalledPrinters)
            {
                // Display the printer name.
                Console.WriteLine("Printer: {0}", printerName);

                // Retrieve the printer settings.
                PrinterSettings printer = new PrinterSettings();
                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)
                {
                    // Display the list of valid resolutions.
                    Console.WriteLine("Supported Resolutions:");

                    foreach (PrinterResolution resolution in
                      printer.PrinterResolutions)
                    {
                        Console.WriteLine("  {0}", resolution);
                    }
                    Console.WriteLine();

// Display the list of valid paper sizes.
                    Console.WriteLine("Supported Paper Sizes:");

                    foreach (PaperSize size in printer.PaperSizes)
                    {
                        if (Enum.IsDefined(size.Kind.GetType(), size.Kind))
                        {
                            Console.WriteLine("  {0}", size);
                        }
                    }
                    Console.WriteLine();
                }
            }
            Console.ReadLine();
        }
    }
}

Here is 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

. . .

The following example provides a form with a single button. When the user clicks the button, the application creates a new PrintDocument, allows the user to configure print settings, and then starts an asynchronous print operation (provided the user clicks OK). An event handler responds to the PrintPage event and writes several lines of text and an image.

This example has one limitation: it can print only a single page. To print more complex documents and span multiple pages, you will want to create a specialized class that encapsulates the document information, the current page, and so on. Recipe 8-15 demonstrates this technique.

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Printing;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_14 : Form
    {
        public Recipe08_14()
        {
            InitializeComponent();
        }

        private void cmdPrint_Click(object sender, EventArgs e)
        {
            // Create the document and attach an event handler.
            PrintDocument doc = new PrintDocument();
            doc.PrintPage += this.Doc_PrintPage;

            // Allow the user to choose a printer and specify other settings.
            PrintDialog dlgSettings = new PrintDialog();
            dlgSettings.Document = doc;

            // If the user clicked OK, print the document.
            if (dlgSettings.ShowDialog() == DialogResult.OK)
            {

                // This method returns immediately, before the print job starts.
                // The PrintPage event will fire asynchronously.
                doc.Print();
            }
        }

        private void Doc_PrintPage(object sender, PrintPageEventArgs e)
        {
            // Define the font.
            using (Font font = 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).
                float x = e.MarginBounds.Left;
                float y = e.MarginBounds.Top;

                // Determine the height of a line (based on the font used).
                float lineHeight = font.GetHeight(e.Graphics);

                // Print five lines of text.
                for (int i = 0; i < 5; i++)
                {

                    // Draw the text with a black brush,
                    // using the font and coordinates we have determined.
                    e.Graphics.DrawString("This is line " + i.ToString(),
                      font, Brushes.Black, x, y);

                    // Move down the equivalent spacing of one line.
                    y += lineHeight;
                }
                y += lineHeight;

                // Draw an image.
                e.Graphics.DrawImage(
                   Image.FromFile(
                       Path.Combine(Application.StartupPath,"test.jpg")
                       ),
                   x, y);
            }
        }
    }
}

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 : PrintDocument {

    private string[] text;
    private int pageNumber;
    private int offset;

    public string[] Text {
        get {return text;}
        set {text = value;}
    }

    public int PageNumber {
        get {return pageNumber;}
        set {pageNumber = value;}
    }

    public int Offset {
        get {return offset;}
        set {offset = value;}
    }

    public TextDocument(string[] text) {
        this.Text = text;
    }
}

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. This is especially important because the printing process runs in a new dedicated thread. As a consequence, the user is able to keep working in the application and therefore update your data while the pages are printing. So, this dedicated class should contain a copy of the data to print to avoid any concurrency problems.

The code that initiates printing is the same as in recipe 8-14, only now it creates a TextDocument instance instead of a PrintDocument instance. The PrintPage event handler keeps track of the current line and checks whether the page has space 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 deemed complete. This simple code sample does not take into account whether a line fits into the width of the page; refer to recipe 8-16 for a solution to this problem.

The full form code is as follows:

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Printing;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_15 : Form
    {
        public Recipe08_15()
        {
            InitializeComponent();
        }

        private void cmdPrint_Click(object sender, EventArgs e)
        {
            // Create a document with 100 lines.
            string[] printText = new string[101];
            for (int i = 0; i < 101; i++)
            {
                printText[i] = i.ToString();
                printText[i] +=
                    ": The quick brown fox jumps over the lazy dog.";
            }

            PrintDocument doc = new TextDocument(printText);
            doc.PrintPage += this.Doc_PrintPage;

            PrintDialog dlgSettings = new PrintDialog();
            dlgSettings.Document = doc;

            // If the user clicked OK, print the document.
            if (dlgSettings.ShowDialog() == DialogResult.OK)
            {
                doc.Print();
            }
        }

private void Doc_PrintPage(object sender, PrintPageEventArgs e)
        {
            // Retrieve the document that sent this event.
            TextDocument doc = (TextDocument)sender;

            // Define the font and determine the line height.
            using (Font font = new Font("Arial", 10))
            {
                float lineHeight = font.GetHeight(e.Graphics);

                // Create variables to hold position on page.
                float x = e.MarginBounds.Left;
                float y = 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.

                while ((y + lineHeight) < e.MarginBounds.Bottom &&
                  doc.Offset <= doc.Text.GetUpperBound(0))
                {
                    e.Graphics.DrawString(doc.Text[doc.Offset], font,
                      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;
                }

                if (doc.Offset < doc.Text.GetUpperBound(0))
                {
                    // There is still at least one more page.
                    // Signal this event to fire again.
                    e.HasMorePages = true;
                }
                else
                {
                    // Printing is complete.
                    doc.Offset = 0;
                }
            }
        }
    }
}

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.

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Printing;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_16 : Form
    {
        public Recipe08_16()
        {
            InitializeComponent();
        }

        private void cmdPrint_Click(object sender, EventArgs e)
        {
            // Create the document and attach an event handler.
            string text = "Windows Server 2003 builds on the core strengths " +
              "of the Windows family of operating systems--security, " +
              "manageability, reliability, availability, and scalability. " +
              "Windows Server 2003 provides an application environment to " +
              "build, deploy, manage, and run XML Web services. " +

"Additionally, advances in Windows Server 2003 provide many " +
              "benefits for developing applications.";
            PrintDocument doc = new ParagraphDocument(text);
            doc.PrintPage += this.Doc_PrintPage;

            // Allow the user to choose a printer and specify other settings.
            PrintDialog dlgSettings = new PrintDialog();
            dlgSettings.Document = doc;

            // If the user clicked OK, print the document.
            if (dlgSettings.ShowDialog() == DialogResult.OK)
            {
                doc.Print();
            }
        }

        private void Doc_PrintPage(object sender, PrintPageEventArgs e)
        {
            // Retrieve the document that sent this event.
            ParagraphDocument doc = (ParagraphDocument)sender;

            // Define the font and text.
            using (Font font = new Font("Arial", 15))
            {
                e.Graphics.DrawString(doc.Text, font, Brushes.Black,
                   e.MarginBounds, StringFormat.GenericDefault);
            }
        }
    }

    public class ParagraphDocument : PrintDocument
    {
        private string text;
        public string Text
        {
            get { return text; }
            set { text = value; }
        }

        public ParagraphDocument(string text)
        {
            this.Text = text;
        }
    }
}

Figure 8-9 shows the wrapped text.

Figure 8.9. The printed document with wrapping

The following example is the complete for code that incorporates a PrintPreviewControl and allows the user to select a zoom setting:

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Printing;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_17 : Form
    {
        public Recipe08_17()
        {
            InitializeComponent();
        }

        private PrintDocument doc;
        // (PrintDocument.PrintPage event handler code omitted.
        // See code in recipe 8-15.)

        private void Recipe08_17_Load(object sender, EventArgs e)
        {
            // Set the allowed zoom settings.
            for (int i = 1; i <= 10; i++)
            {
                lstZoom.Items.Add((i * 10).ToString());
            }

// Create a document with 100 lines.
            string[] printText = new string[100];
            for (int i = 0; i < 100; i++)
            {
                printText[i] = i.ToString();
                printText[i] += ": The quick brown fox jumps over the lazy dog.";
            }

            doc = new TextDocument(printText);
            doc.PrintPage += this.Doc_PrintPage;

            lstZoom.Text = "100";
            printPreviewControl.Zoom = 1;
            printPreviewControl.Document = doc;
            printPreviewControl.Rows = 2;
        }

        private void cmdPrint_Click(object sender, EventArgs e)
        {
            // Set the zoom.
            printPreviewControl.Zoom = Single.Parse(lstZoom.Text) / 100;

            // Show the full two pages, one above the other.
            printPreviewControl.Rows = 2;

            // Rebind the PrintDocument to refresh the preview.
            printPreviewControl.Document = doc;
        }
    }

    // (TextDocument class code omitted. See recipe 8-15.)
}

The following code shows a Windows application that interacts with the print queue. It performs a WMI query to get a list of all the outstanding jobs on the computer and displays the job ID for each one in a list box. When the user selects the item, a more complete WMI query is performed, and additional details about the print job are displayed in a text box. Finally, the user can click the Pause and Resume buttons after selecting a job to change its status.

Remember that Windows permissions might prevent you from pausing or removing a print job created by another user. In fact, permissions might even prevent you from retrieving status information and could cause a security exception to be thrown.

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Management;
using System.Collections;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    public partial class Recipe08_18 : Form
    {
        public PrintQueueTest()
        {
            InitializeComponent();
        }

        private void cmdRefresh_Click(object sender, EventArgs e)
        {
            // Select all the outstanding print jobs.
            string query = "SELECT * FROM Win32_PrintJob";
            using (ManagementObjectSearcher jobQuery =
              new ManagementObjectSearcher(query))
            {
                using (ManagementObjectCollection jobs = jobQuery.Get())
                {
                    // Add the jobs in the queue to the list box.
                    lstJobs.Items.Clear();
                    txtJobInfo.Text = "";

foreach (ManagementObject job in jobs)
                    {
                        lstJobs.Items.Add(job["JobID"]);
                    }
                }
            }
        }

        private void Recipe08_18_Load(object sender, EventArgs e)
        {
            cmdRefresh_Click(null, null);
        }

        // This helper method performs a WMI query and returns the
        // WMI job for the currently selected list box item.
        private ManagementObject GetSelectedJob()
        {
            try
            {
                // Select the matching print job.
                string query = "SELECT * FROM Win32_PrintJob " +
                  "WHERE JobID='" + lstJobs.Text + "'";
                ManagementObject job = null;
                using (ManagementObjectSearcher jobQuery =
                  new ManagementObjectSearcher(query))
                {
                    ManagementObjectCollection jobs = jobQuery.Get();
                    IEnumerator enumerator = jobs.GetEnumerator();
                    enumerator.MoveNext();
                    job = (ManagementObject)enumerator.Current;
                }
                return job;
            }
            catch (InvalidOperationException)
            {
                // The Current property of the enumerator is invalid.
                return null;
            }
        }

        private void lstJobs_SelectedIndexChanged(object sender, EventArgs e)
        {
          ManagementObject job = GetSelectedJob();
          if (job == null)
          {
              txtJobInfo.Text = "";
              return;
          }

// Display job information.
          StringBuilder jobInfo = new StringBuilder();
          jobInfo.AppendFormat("Document: {0}", job["Document"].ToString());
          jobInfo.Append(Environment.NewLine);
          jobInfo.AppendFormat("DriverName: {0}", job["DriverName"].ToString());
          jobInfo.Append(Environment.NewLine);
          jobInfo.AppendFormat("Status: {0}", job["Status"].ToString());
          jobInfo.Append(Environment.NewLine);
          jobInfo.AppendFormat("Owner: {0}", job["Owner"].ToString());
          jobInfo.Append(Environment.NewLine);

          jobInfo.AppendFormat("PagesPrinted: {0}", job["PagesPrinted"].ToString());
          jobInfo.Append(Environment.NewLine);
          jobInfo.AppendFormat("TotalPages: {0}", job["TotalPages"].ToString());

          if (job["JobStatus"] != null)
          {
              txtJobInfo.Text += Environment.NewLine;
              txtJobInfo.Text += "JobStatus: " + job["JobStatus"].ToString();
          }
          if (job["StartTime"] != null)
          {
              jobInfo.Append(Environment.NewLine);
              jobInfo.AppendFormat("StartTime: {0}", job["StartTime"].ToString());
          }

          txtJobInfo.Text = jobInfo.ToString();
      }

      private void cmdPause_Click(object sender, EventArgs e)
      {
          if (lstJobs.SelectedIndex == −1) return;
          ManagementObject job = GetSelectedJob();
          if (job == null) return;

          // Attempt to pause the job.
          int returnValue = Int32.Parse(
            job.InvokeMethod("Pause", null).ToString());

          // Display information about the return value.
          if (returnValue == 0)
          {
              MessageBox.Show("Successfully paused job.");
          }
          else
          {
              MessageBox.Show("Unrecognized return value when pausing job.");
          }
      }

private void cmdResume_Click(object sender, EventArgs e)
      {
          if (lstJobs.SelectedIndex == −1) return;
          ManagementObject job = GetSelectedJob();
          if (job == null) return;

          if ((Int32.Parse(job["StatusMask"].ToString()) & 1) == 1)
          {
              // Attempt to resume the job.
              int returnValue = Int32.Parse(
                job.InvokeMethod("Resume", null).ToString());

              // Display information about the return value.
              if (returnValue == 0)
              {
                  MessageBox.Show("Successfully resumed job.");
              }
              else if (returnValue == 5)
              {
                  MessageBox.Show("Access denied.");
              }
              else
              {
                  MessageBox.Show(
                    "Unrecognized return value when resuming job.");
              }
          }
        }
    }
}

Figure 8-10 shows the window for this application.

Figure 8.10. Retrieving information from the print queue

The following example displays information about each speech synthesis voice installed on the local machine, and then enters a loop where lines of text read from the console are passed to the Speak method of a SpeechSynthesizer instance.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Speech.Synthesis;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    class Recipe08_19
    {
        static void Main(string[] args)
        {
            // Create a new synthesizer.
            SpeechSynthesizer mySynth = new SpeechSynthesizer();

            Console.WriteLine("--- Start of voices list ---");
            foreach (InstalledVoice voice in mySynth.GetInstalledVoices())
            {
                Console.WriteLine("Voice: {0}", voice.VoiceInfo.Name);
                Console.WriteLine("Gender: {0}", voice.VoiceInfo.Gender);
                Console.WriteLine("Age: {0}", voice.VoiceInfo.Age);
                Console.WriteLine("Culture: {0}", voice.VoiceInfo.Culture);
                Console.WriteLine("Description: {0}", voice.VoiceInfo.Description);
            }
            Console.WriteLine("--- End of voices list ---");

            while (true)
            {
                Console.WriteLine("Enter string to speak");
                mySynth.Speak(Console.ReadLine());
                Console.WriteLine("Completed");
            }
        }
    }
}

The following example loads an image called ocr.GIF (which we have included in the sample code for this chapter) and performs OCR on it. Each word found is printed out, along with the

RecognitionConfidence value.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MODI;

namespace Apress.VisualCSharpRecipes.Chapter08
{
    class Recipe08_20
    {
        static void Main(string[] args)
        {
            // Create the new document instance.
            Document myOCRDoc = new Document();
            // Load the sample file.
            myOCRDoc.Create(@"....ocr.GIF");

            // Perform the OCR.
            myOCRDoc.OCR();

// Get the processed document.
            Image image = (Image)myOCRDoc.Images[0];
            Layout layout = image.Layout;

            // Print out each word that has been found.
            foreach (Word word in layout.Words)
            {
                Console.WriteLine("Word: {0} Confidence: {1}",
word.Text, word.RecognitionConfidence);
            }
        }
    }
}