Understanding the Graphics Class

PartPageUnitOne - Introducing C# andThesetheproperties.NET Platformallow you to configure the point of origin for your

Chapter 1 - The Philosophyrenderingof .NET operations, as well as configure the unit of measurement. PageScale

Chapter 2 - Building C# Applications

DpiX

Part Two - The C# Programming Language

List of Figures

List of Tables

The GDI+ CoordinateC# and the .NETSystemsPlatfor , Second Edition

Next up, you need a bit of background regarding the underlying coordinate system. GDI+ defines three

Apress © 2003 (1200 pages)

distinct coordinate systems (Table 14-10), which are used by the runtime to determine the location and

This comprehensive text starts with a brief overview of the size of the elementC#tolanguagebe renderedand then. quickly moves to key technical and

architectural issues for .NET developers.

Table 14-10: The GDI+ Coordinate Systems

Chapter 2 - Building C# Applications

For example, if you draw a rectangle using the dimensions of (0, 0, 100,

Part Two - The C# Programming Language

100), you have specified a rectangle 100 × 100 "things" in size.

Part Three - Programming with .NET Assemblies

For example, if you have a Form that needs to maintain a 100 × 100 pixel

Chapter 9 - Understanding .NET Assemblies

border, you can specify a (100 ×100) page coordinate to allow all rending to

Chapter 10 - Processes, AppDomains, Contexts, and Threads

begin at point (100 × 100). In your code base however, you are able to

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

specify simple world coordinates (thereby avoiding the need to manually

Part Four - Leveraging the .NET Libraries

calculate the offset).

Chapter 16 - The System.IO Namespace

When you are programming with GDI+, you tend to think in terms of "world coordinates." Simply put, this

Chapter 17 - Data Access with ADO.NET

coordinate system is the baseline used to determine the size and location of a GDI+ type:

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

// Render a rectangle by specifying world coordinates.

Chapter 19 - ASP.NET Web Applications

myGraphicsObject.DrawRectangle(10, 10, 100, 100);

Chapter 20 - XML Web Services

Index

List of Figures

List of Tables

Under the hood of GDI+, your world coordinates are automatically mapped in terms of page coordinates, and are then mapped into device coordinates. In many cases, you will never directly make use of page or device coordinates unless you wish to apply some sort of graphical transformation. Given that the previous line of code did not specify any transformational page coordinate logic, the world, page, and device coordinates are identical.

If you do wish to apply various transformations before rendering your GDI+ logic, you will make use of various members of the Graphics type (such as the TranslateTransform() method) to specify various "page coordinates" to your existing world coordinate system before the rendering operation. The result is the set of device coordinates that will be used to render the GDI+ type to the target device:

// Specify page coordinate offsets (10 * 10).

myGraphicsObject.TranslateTransform(10, 10);

//Render a rectangle by specifying world coordinates.

//However! Given the previous offset,

//this rectangle is really drawn at (20 ,20)

// and is 110 * 110 pixels in size.

C# and the .NET Platform, Second Edition myGraphicsObject.DrawRectangle(10, 10, 100, 100);

Apress © 2003 (1200 pages)

In this case, the rectangleThis comprehensiveis actuallytextrenderedstarts withitha upperbrief overviewleft pointofofthe(20, 20) and a lower right point of (110, 110). C# language and then quickly moves to key technical and

architectural issues for .NET developers.

The Default Unit of Measure

Table of Contents

As suggested in the last example, the default unit of measure is pixel-based and places the origin in the

C# and the .NET Platform, Second Edition

upper left corner with the x-axis increasing to the right and the y-axis increasing downward (Figure 14-2).

Introduction

Part One - Introducing C# and the .NET Platform

Chapter

Chapter

Part

Chapter

Chapter

Chapter

Chapter

Chapter

Chapter

Part

Chapter

Chapter Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Figure 14-2: The default coordinate system of GDI+

Part Four - Leveraging the .NET Libraries

ChapterAgain, if12you- ObjectrenderSerializationRectangleandasthefollows:.NET Remoting Layer

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

private void MainForm_Paint(object sender, PaintEventArgs e)

Chapter 15 - Programming with Windows Forms Controls

{

Chapter //16 -SetThe Systemup world.IO Namespacecoordinates using the default unit of measure.

Chapter Graphics17 - Data Accessg = withe.Graphics;ADO.NET

Part Fiveg-.WebDrawRectangle(newApplic tions and XMLPen(ColorWeb Services.Red, 5), 10, 10, 100, 100);

Chapter} 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

you would see a square rendered 10 pixels down and in from the top left client edge of the Form, which

Index

spans 90 pixels in both directions (Figure 14-3). Given that you have not applied any page transformations,

the world, page, and device coordinate values are identical.

List of Tables

Figure 14-3: Rendering via pixel units

In most cases, the default measurement system will most likely be your unit of choice. However, like most things in the .NET Framework, you are able to configure the GDI+ mapping mode to your liking.

SpecifyingC#anandAlternativehe .NET Platform,UnitSecondof MeasureEdition

If you do not wish to render images using a pixel-based unit of measure, you are able to change this

Apress © 2003 (1200 pages)

default setting by setting the PageUnit property of the Graphics object to alter the units used by the page

This comprehensive text starts with a brief overview of the

coordinate systemC#. ThelanguPageUnitand thenpropertyquicklycanmovesbe assignedto key technicalany memberand of the GraphicsUnit enumeration (Table 14-11). architectural issues for .NET developers.

Table 14-11: The GraphicsUnit Enumeration

ChapterDocument1 - The Philosophy of .NETSpecifies the document unit (1/300 inch) as the unit of measure

For example, if you update your previous rendering code as follows:

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

private void MainForm_Paint(object sender, PaintEventArgs e)

Chapter 10 - Processes, AppDomains, Contexts, and Threads

{

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

// Draw a rectangle in inches...not pixels.

Part Four - Leveraging the .NET Libraries

Graphics g = e.Graphics;

Chapter 12 - Object Serialization and the .NET Remoting Layer g.PageUnit = GraphicsUnit.Inch;

Chapter 13 - Building a Better Window (Introducing Windows Forms) g.DrawRectangle(new Pen(Color.Red, 5), 0, 0, 100, 100);

Chapter 14 - A Better Painting Framework (GDI+)

}

Chapter 15 - Programming with Windows Forms Controls Chapter 16 - The System.IO Namespace

Chapteryou find17a -radicallyData Accessdifferentwith rectangleADO.NET (Figure 14-4).

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter

Chapter

Index

List of

List of

Figure 14-4: Rendering via inch units

The reason that 95% (or so) of the Form's client area is now filled in is due to the fact that you have configured a Pen with a five inch nib! The rectangle itself is 100 × 100 inches in size! In fact, the small gray box you see located in the lower right corner is the upper left interior of the rectangle! As you would guess, if you specify alternative values to the Graphics.PageUnit property, you would find the rectangle rendered in various units of measurement.

Recall that when you make use of the default coordinate and measurement system, point (0, 0) is at the

extreme upper left of the client area. Again, this is typically what you desire. However, what if you wish to

This comprehensive text starts with a brief overview of the

alter the location where rendering begins? For example, let's assume that your application always needs

to reserve a 100-pixel boundary around the Form's client area (for whatever reason). You need to ensure architectural issues for .NET developers.

that all GDI+ operations take place somewhere within this internal region.

One approach you could take is to offset all your rendering code manually. This, of course, is a huge

Table of Contents

bother, in that you would need to constantly apply some offset value to each and every rendering

operation. It would be far better (and simpler) if you could set a property that says, in effect, "Although I

Introduction

might say render a rectangle with a point of origin at (0, 0), make sure you begin at point (100, 100)." This

would simplify your life a great deal, as you can continue to specify your plotting points without

Chapter 1 - The Philosophy of .NET modification.

Chapter 2 - Building C# Applications

PartIn GDI+,Two -youThecanC# Programmingadjust the pointLanguageof origin by setting the transformation value using the

ChapterTranslateTransform()3 - C# LanguagemethodFun amentalsof the Graphics class, which allows you to specify a page coordinate system

Chapterthat will4be-appliedObject-Orientedto your originalProgrammingworld coordinatewith C# specifications. For example:

Chapter 5 - Exceptions and Object Lifetime

Chapter 6 - Interfaces and Collections

private void MainForm_Paint(object sender, PaintEventArgs e)

Chapter{ 7 - Callback Interfaces, Delegates, and Events

Chapter Graphics8 - Advancedg C#= Type.Graphics;Construction Techniques

Part Three//- ProgrammingSet page coordinatewith .NET Assembliesto (100, 100).

Chapter g9.TranslateTransform(100,- Understanding .NET Assemblies 100);

// World origin is still (0, 0, 100, 100),

Chapter 10 - Processes, AppDomain , Contexts, and Threads

// however device origin is now (100, 100, 200, 200).

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

g.DrawRectangle(new Pen(Color.Red, 5), 0, 0, 100, 100);

Part Four - Leveraging the .NET Libraries

}

Chapter 12 - Object Serialization and the .NET Remoting Layer Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

Here, we have set our world coordinate values (0, 0, 100, 100). However, the page coordinate values have

Chapter 15 - Programming with Windows Forms Controls

specified an offset of (100, 100). Given this, the device coordinates map to (100, 100, 200, 200). Thus,

Chapter 16 - The System.IO Namespace

although the call to DrawRectangle() looks as if you are rendering a rectangle on the upper left of the

Chapter 17 - Data Access with ADO.NET

Form, the following rendering has taken place (Figure 14-5).

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter

Chapter

Index

List of

List of

Figure 14-5: The result of applying page offsets

To help you experiment with some of the ways to alter the default GDI+ mapping system, the companion code contains a sample application named CoorSystem. Using two topmost menu items, you are able to alter the point of origin as well as the unit of measurement (Figure 14-6).

C# and the .NET Platform, Second Edition

ISBN:1590590554

of the

and

Table

C# and

Part

Chapter

Chapter

Part Two - The C# Programming Language

Figure 14-6: Altering coordinate and measurement modes

Chapter 3 - C# Language Fundamentals

Chapter 4 - Object-Oriented Programming with C#

Now that you have a better understanding of the underlying transformations used to determine where to

Chapter 5 - Exceptions and Object Lifetime

render a given GDI+ type onto a target device, the next order of business is to examine details of color

Chapter 6 - Interfaces and Collections

manipulation.

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

SOURCE The CoorSystem project is included under the Chapter 14 subdirectory.

Part Three - Programming with .NET Assemblies

CODE

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Index

List of Figures

List of Tables

EstablishingC#and Activethe .NET Platform,Color Second Edition

Many of the rendering methods defined by the Graphics class require you to specify the color that should

Apress © 2003 (1200 pages)

be used during the drawing process. The System.Drawing.Color structure represents an alpha-red-green-

This comprehensive text starts with a brief overview of the

blue (ARGB) colorC#constantlanguage. Mostand thenof thequicklyColormovestype'stofunctionalitykey technicalcomesand by way of a number of static read-only properties,architecturalwhich returnissuesafornew.NET(correctlydeve opersconfigured),. Color type:

// One of many predefined colors...

Table of Contents

Color c = Color.PapayaWhip;

C# and the .NET Platform, Second Edition

Introduction

PartThereOneare- Introducingother waysC#youandcanthecreate.NET aPlatformColor type. Regardless of the method you use, you are then able Chapterto extract1 relevant- The Phinformationlosophy .NETusing any of the members listed in Table 14-12 (in addition to the set of

Chstaticpterread2 -onlyBuildingproperties)C# Applications.

Part Two - The C# Programming Language

ChTablept r 143 -12:- C#MembersLanguageofFundamentalsthe Color Type

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

ChapterFromArgb()6 - Interfaces andReturnsCollectionsa new Color object based on numerical red, green, and blue

Chapter 7 - Callback Interfvaluesces,.Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

FromKnownColor() Returns a new Color object based on a member of the KnownColor

Part Three - Programming with .NET Assemblies

enumeration.

Chapter 9 - Understanding .NET Assemblies

ChapterFromName()10 - Processes, AppDomains,Returns newContexts,ColorandobjectThrebasedds on a string name (e.g., "Red").

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

List of Tables

Examining the ColorDialog Class

On a related note, the System.Windows.Forms namespace provides a predefined dialog box class (ColorDialog) that can be used to prompt the end user for his or her color selection (Figure 14-7).

Edition

ISBN:1590590554

a brief overview of the

to key technical and

.

Table

C# and

Part One - Introducing C# and the .NET Platform

Figure 14-7: The stock .NET color dialog

Chapter 1 - The Philosophy of .NET

Chapter 2 - Building C# Applications

PartWorkingTwo -withThe thisC# Programmingdialog is simple:Languageusing a valid instance of the ColorDialog type, call ShowDialog() to

display the dialog modally. Once the user has closed the dialog, you can extract the corresponding Color

Chapter 3 - C# Language Fundamentals

object using the ColorDialog.Color property.

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

For example, assume you wish to allow the user to configure the background color of the Form's client

Chapter 6 - Interfaces and Collections

area using the ColorDialog. To keep things simple, let's assume that when the user clicks anywhere on

Chapter 7 - Callback Interfaces, Delegates, and Events

the client area, you show the ColorDialog object and act accordingly. Here is the code:

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

public class ColorDlgForm : System.Windows.Forms.Form

Chapter 9 - Understanding .NET Assemblies

{

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming private ColorDialog colorDlg;

Part Four - Leveraging the .NET Libraries

public ColorDlgForm()

Chapter 12 - Object Serialization and the .NET Remoting Layer

{

Chapter 13 - Building a Better Window (Introducing Windows Forms)

colorDlg = new ColorDialog();

Chapter 14 - A Better Painting Framework (GDI+)

Text = "Click on me to change the color";

Chapter 15 - Programming with Windows Forms Controls this.MouseUp +=

Chapter 16 - The Systemnew.IOMouseEventHandler(thisNamespace .ColorDlgForm_MouseUp);

Chapter }17 - Data Access with ADO.NET

Part...Five - Web Applications and XML Web Services

Chapter private18 - ASP.NETvoidWebColorDlgFormPages and Web ControlsMouseUp(object sender, MouseEventArgs e)

{

Chapter 19 - ASP.NET Web Applications

if (colorDlg.ShowDialog() != DialogResult.Cancel)

Chapter 20 - XML Web Services

Index {

currColor = colorDlg.Color;

List of Figures

this.BackColor = currColor;

List of Tables

// Show current color.

string strARGB = colorDlg.Color.ToString();

MessageBox.Show(strARGB, "Color is:");

}

}

}

Although there has not yet been a formal discussion of how to manipulate dialog boxes, the previous code should not raise too many eyebrows. Notice that you are able to determine which button has been clicked (OK or Cancel) by testing the return value of ShowDialog() against the DialogResult enumeration. You will see additional stock dialog boxes used in this chapter. Later, in Chapter 15, you learn how to build custom dialogs to gather (and validate) user input.

SOURCE The ColorDlg application is included under the Chapter 14 subdirectory.

CODE

C# and the .NET Platform, Second Edition

Apress © 2003 (1200 pages)

This comprehensive text starts with a brief overview of the C# language and then quickly moves to key technical and architectural issues for .NET developers.

Table of Contents

C# and the .NET Platform, Second Edition

Introduction

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

Chapter 3 - C# Language Fundamentals

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Index

List of Figures

List of Tables

ManipulatingC# andFontsthe .NET Platform, Second Edition

Next, let's examine the specifics of the Font class (and related types). The System.Drawing.Font type

Apress © 2003 (1200 pages)

represents a given font installed on the user's machine. While the Font class defines a number of

This comprehensive text starts with a brief overview of the overloaded constructors,C# languagehereandarethensomequicklycommonmovesoptions:o key technical and

architectural issues for .NET developers.

// Create a Font of a given type name and size.

Font f = new Font("Times New Roman", 12);

Table of Contents

// Create a Font with a given name, size, and style set.

C# and the .NET Platform, Second Edition

Font f2 = new Font("WingDings", 50, FontStyle.Bold | FontStyle.Underline);

Introduction

Part One - Introducing C# and the .NET Platform

ChapterHere, f21 has- ThebeenPhilosophycreated ofusing.NETa set of FontStyle flags. The members of this enumeration allow you to

Chapterconfigure2 a- nBuildingmberC#of propertiesAp licationsof the Font object such as bold or italic (if you require more than one

PartFontStyle,Two - ThesimplyC# ProgrammOR eachitemng Lantogether)uage . Table 14-13 lists your choices.

Chapter 3 - C# Language Fundamentals

ChTablept r 144 -13:- ObjectThe-FontStyleOriented PrograEnumerationming with C#

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Strikeout Text with a line through the middle

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Chapter 12 - Object Serialization and the .NET Remoting Layer

ChaptOnceryou13 -haveBuildingconfigureda BettertheWindlookwand(Introducingfeel of yourWindFontwsobject,Forms)the next obvious task is to pass it as a Chparameterpter 14 -toA theBetterGraphicsPainting.DrawString()Framework (GDI+)method. Although DrawString() has also been overloaded a

number of times, each variation typically requires the same basic information: a string to draw, the font to

Chapter 15 - Programming with Windows Forms Controls

draw it in, a brush used for rendering, and a location to place it. For example:

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Part// FiveOne- Wversion:b ApplicationsvoidandDrawString(String,XML Web Services Font, Brush, Point);

Chapterg.DrawString("My18 - ASP.NET Webstring",Pages and newW b ControlsFont("Pop", 25),

new SolidBrush(Color.Black), new Point(0,0));

Chapter 19 - ASP.NET Web Applications

// Another version: void DrawString(String, Font, Brush, float, float);

Chapter 20 - XML Web Services

g.DrawString("Another string", new Font("Times New Roman", 16),

Index

new SolidBrush(Color.Red), 40, 40);

List of Figures

List of Tables

In each of these examples, you have made use of a SolidBrush type (of a particular color). It is possible to configure a number of brush types. For the time being, a solid brush fits the bill; you see more exotic brush types a bit later in this chapter. Once you have created a valid Font type, you are able to extract its current settings using a number of properties (e.g., Bold, Italic, Unit, Height, Size, FontFamily, and so forth).

Working with Font Families

The System.Drawing namespace also defines the FontFamily type, which abstracts a group of typefaces having a similar basic design but having certain style variations (such as point size). A family of fonts, like Verdana, can include several fonts that differ in style and size. For example, 12-point Verdana bold and 24point Verdana italic are different fonts within the Verdana font family.

The constructor of the FontFamily type takes a string representing the name of the font family you are attempting to capture. Once you create the generic family, you are then able to create a more specific Font object (in the following code, assume "g" is an object of type Graphics):

C# and the .NET Platform, Second Edition

// Make a family of fonts.

by Andrew Troelsen ISBN:1590590554

FontFamily myFamily = new FontFamily("Verdana");

Apress © 2003 (1200 pages)

// Pass family into ctor of Font.

This comprehensive text starts with a brief overview of the

Font myFont = new Font(myFamily, 12);

C# language and then quickly moves to key technical and g.DrawString("Hello?", myFont, Brushes.Blue, 10, 10);

architectural issues for .NET developers.

Of greater interest is the ability to gather statistics regarding a given family of fonts. For example, let's say

Table of Contents

you were building a text-processing application and wish to determine the average width of a character in a

C# and the .NET Platform, Second Edition

particular FontFamily. What if you wish to know the ascending and descending values for a given

Introduction

character? To answer such questions, the FontFamily type defines the key members shown in Table 14-14.

Chapter //20 -ShowXML WebunitsServicesof measurement for FontFamily members.

Index this.Text = "Measurements are in GraphicsUnit." + myFont.Unit.ToString();

g.DrawString("The Verdana family.", myFont, Brushes.Blue, 10, y);

List of Figures

y += 20;

List of Tables

// Print our family ties...

g.DrawString("Ascent for bold Verdana: " + myFamily.GetCellAscent(FontStyle.Bold), myFont, Brushes.Black, 10, y + fontHeight);

y += 20;

g.DrawString("Descent for bold Verdana: " + myFamily.GetCellDescent(FontStyle.Bold), myFont, Brushes.Black, 10, y + fontHeight);

y += 20;

g.DrawString("Line spacing for bold Verdana: " + myFamily.GetLineSpacing(FontStyle.Bold), myFont, Brushes.Black, 10, y + fontHeight);

y += 20;

g.DrawString("Height for bold Verdana: " + myFamily.GetEmHeight(FontStyle.Bold),

Building a FontC# andApplicationthe .NET Platform, Second Edition

Now, let's build a more complex application that allows the user to manipulate a Font object maintained by

Apress © 2003 (1200 pages)

a main Form. The application will allow the user to select the current font face from a predefined set using

This comprehensive text starts with a brief overview of the the "Configure | FontC# languageFace" menuand thenselectionquickly. moves to key technical and

architectural issues for .NET developers.

Let's also allow the user to indirectly control the size of the Font object using a Windows Forms Timer object. If the user activates the Timer using the "Configure | Swell?" menu item, the size of the Font object

Tableincreasesof Contentsat a regular interval (to a maximum upper limit). In this way, the text appears to swell and thus

C#providesand thea.NETsimplePlatforanimation, Secondof "breathing"Edition text.

Introduction

Finally, add a final menu item under the Configure menu named "List All Fonts," which will be used to list all

Part One - Introducing C# and the .NET Platform

fonts installed on the end-user's machine. Figure 14-10 shows the menu UI logic (the File menu simply

Chapter 1 - The Philosophy of .NET allows the user to exit the application).

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

Chapter

Chapter

Chapter

Chapter

Chapter

Chapter

Part

Chapter

Chapter

Part

Chapter

Chapter

Chapter

Chapter 15 - Programming with Windows Forms Controls

Figure 14-10: Menu layout of the FontApp project

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

To begin implementing our application, update the main Form with a Timer member variable (named

Part Five - Web Applications and XML Web Services

timer), a string to represent the current font face (named fontFace), and an integer (named swellValue) to

Chapter 18 - ASP.NET Web Pages and Web Controls

represent the amount to adjust the font size. In addition to configuring the basic look and feel of the Form,

Chapter 19 - ASP.NET Web Applications

configure your timer to emit a Tick event every 100 milliseconds:

public FontForm()

{

// The menu system has been designed using the IDE...

InitializeComponent(); timer = new Timer(); Text = "Font App"; Width = 425;

Height = 150;

BackColor = Color.Honeydew;

CenterToScreen();

// Configure the Timer.

timer.Enabled = true;

timer.Interval = 100;

timer.Tick += new EventHandler(FontForm_OnTimer);

This comprehensive text starts with a brief overview of the

In the Tick event C#handler,languageincreaseand thenthe quicklyvalue ofmovesthe swellValueto key technicdatalmember,and and refresh your client area

architectural issues for .NET developers.

via the Invalidate() method. Recall that the swellValue integer will be added to the current font size to provide a simple animation (assume swellValue has a maximum upper limit of 50). To help reduce the

flicker that can occur when redrawing the entire client area, you only refresh the minimum dirty rectangular

Table of Contents region:

C# and the .NET Platform, Second Edition

Introduction

private void FontForm_OnTimer(object sender, EventArgs e)

Part One - Introducing C# and the .NET Platform

{

Chapter 1 - The Philosophy of .NET

// Increase current swellValue by 5.

Chapter 2 - Building C# Applications swellValue += 5;

Part Two - The C# Programming Language

// If this value is greater than or equal to 50, reset to zero.

Chapter 3 - C# Language Fundamentals if(swellValue >= 50)

Chapter 4 - Object-Oriented Programming with C# swellValue = 0;

Chapter 5 - Exceptions and Object Lifetime

// Just invalidate the 'minimal dirty rectangle to help reduce flicker.

Chapter 6 - Interfaces and Collections

Invalidate(new Rectangle(0, 0, ClientRectangle.Width, 100));

Chapter 7 - Callback Interfaces, Delegates, and Events

}

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

Now that the upper 100 pixels of your client area are refreshed with each tick of the Timer, you better have

Chapter 9 - Understanding .NET Assemblies

something to render! In the Form's Paint handler, create a Font object based on the user-defined font face

Chapter 10 - Processes, AppDomains, Contexts, and Threads

(as selected from the appropriate menu item) and current swellValue (as dictated by the timer). Once you

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

have your Font object fully configured, render a message into the center of the dirty rectangle:

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

private void FontForm_Paint(object sender, PaintEventArgs e)

Chapter 13 - Building a Better Window (Introducing Windows Forms)

{

Chapter 14 - A Better Painting Framework (GDI+)

Graphics g = e.Graphics;

Chapter 15 - Programming with Windows Forms Controls

// The font size can be between 12 and 62,

Chapter 16 - The System.IO Namespace

// based on the current swellValue.

Chapter 17 - Data Access with ADO.NET

Font theFont = new Font(fontFace, 12 + swellValue);

Part Five - Web Applications and XML Web Services

string message = "Hello GDI+";

Chapter 18 - ASP.NET Web Pages and Web Controls

// Display message in the center of the rect.

Chapter 19 - ASP.NET Web Applications

float windowCenter = this.DisplayRectangle.Width/2;

Chapter 20 - XML Web Services

SizeF stringSize = g.MeasureString(message, theFont);

Index float startPos = windowCenter - (stringSize.Width/2);

List of Figures

g.DrawString(message, theFont, new SolidBrush(Color.Blue), startPos, 10);

List of Tables

}

As you would guess, if a user selects a specific font face, the Clicked handler for each menu selection is in charge of updating the fontFace string variable and invalidating the client area. The sample code for this example takes this a bit further to ensure that the user's font of preference is identified with a check mark. Given that the previous chapter has already pounded out the details of menu manipulations, I'll assume you will implement these details as you see fit.

The menu handler for the Swell menu item will be used to allow the user to stop or start the swelling of the text (i.e., enable or disable the animation). Thus, configure the Clicked handler to enable or disable the Timer as follows:

private void ConfigSwell_Clicked(object sender, EventArgs e)

{

timer.Enabled = !timer.Enabled;

mainMenu.MenuItems[1].MenuItems[0].Checked = timer.Enabled;

C# and the .NET Platform, Second Edition

}

Apress © 2003 (1200 pages)

This comprehensive text starts with a brief overview of the

C# language and then quickly moves to key technical and

EnumeratingarchitecturInstalledissuesFontsf r .NET deve(a laopersSystem. .Drawing.Text)

Next, let's expand the FontApp to programmatically discover the set of installed fonts on the target machine.

TableDoingofsoContentsgives you a chance to explore another namespace of GDI+, System.Drawing.Text. This

namespace contains a (small) handful of useful types that can be used to discover and manipulate the set

C# and the .NET Platform, Second Edition

Part Three - Programming with .NET Assemblies

TextRenderingHint Another enumeration that allows you to specify the quality of the

Chapter 9 - Understanding .NET Assemblies

current text rendering operation. For example, the Text value

Chapter 10 - Processes, AppDomains,representsContext , and Threads

a fast (but low quality) rendering. AntiAliased marks

Chapter 11 - Type Reflection, Late Binding,better qualityand Attributea slower-Bas drenderingProgrammingcycle.

Part Four - Leveraging the .NET Libraries

ChapterWhen the12 -userObjectselectsSerializationthe "Configureand the|.ListNET AllRemFonts"ting Layermenu item, the corresponding Clicked handler

Chaptercreates13an-instanceBuilding aofBetterthe InstalledFontCollectionWindow (I tr ducing Windowsclass. ThisForms)class maintains an array named FontFamily,

Chapterwhich represents14 - A BetterthePaintingset of allFramewfonts onrkthe(GDI+)target machine, and may be obtained using the ChapterInstalledFontCollection15 - Programming.Familieswith Windpropertyws Forms. UsingControlsthe FontFamily.Name property, you are able to extract the

font face (e.g., Times New Roman, Arial, etc.) for each font.

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Here, you have added a private string data member named installedFonts to hold each font face. The logic in the "List Installed Fonts" menu handler creates an instance of the InstalledFontCollection type, reads the

name of each string, and adds the new font face to the private installedFonts data member:

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

public class FontForm : System.Windows.Forms.Form

Index

{

List of Figures

// Holds the list of fonts.

List of Tables

private string installedFonts;

// Menu handler to get the list of installed fonts.

private void mnuConfigShowFonts_Clicked(object sender, EventArgs e)

{

InstalledFontCollection fonts = new InstalledFontCollection(); for(int i = 0; i < fonts.Families.Length; i++)

installedFonts += fonts.Families[i].Name + " ";

//This time, we need to invalidate the entire client area,

//as we will paint the installedFonts string on the lower half

//of the client rectangle.

Invalidate();

}

...

}

The final task is to render the installedFonts string to the client area, directly below the screen real estate

C# and the .NET Platform, Second Edition that is used for your swelling text:

Apress © 2003 (1200 pages)

private void FontForm_Paint(object sender, PaintEventArgs e)

This comprehensive text starts with a brief overview of the

{

C# language and then quickly moves to key technical and

Graphics g = e.Graphics;

architectural issues for .NET developers.

Font theFont = new Font(fontFace, 12 + swellValue);

string message = "Hello GDI+";

Table of //ContentsDisplay message in the center of the window!

float windowCenter = this.DisplayRectangle.Width/2;

C# and the .NET Platform, Second Edition

SizeF stringSize = e.Graphics.MeasureString(message, theFont);

Introduction

float startPos = windowCenter - (stringSize.Width/2);

Part One - Introducing C# and the .NET Platform

g.DrawString(message, theFont, new SolidBrush(Color.Blue), startPos, 10);

Chapter 1 - The Philosophy of .NET

// Show installed fonts in the rectangle below the swell area.

Chapter 2 - Building C# Applications

Rectangle myRect = new Rectangle(0, 100,

Part Two - The C# Programming Language

ClientRectangle.Width, ClientRectangle.Height);

Chapter 3 - C# Language Fundamentals

// Paint this area of the Form black.

Chapter 4 - Object-Oriented Programming with C#

g.FillRectangle(new SolidBrush(Color.Black), myRect);

Chapter 5 - Exceptions and Object Lifetime g.DrawString(installedFonts, new Font("Arial", 12),

Chapter 6 - Interfaces and Collections

new SolidBrush(Color.White), myRect);

Chapter 7 - Callback Interfaces, Delegates, and Events

}

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

ChapterRecall 9that-theUnderstandingsize of the "dirty.NET Assemblirectangle"s has been mapped to the upper 100 pixels of the client rectangle.

ChapterBecause10you- Processes,Tick handlerAppDonlymains,invalidatesCont xts,a portionand Threadsof the Form, the remaining area is not redrawn when

Chapterthe Tick11event- TypehasReflection,been sentLate(toBinding,help optimizeand Attheributerendering-Based Programmiof the clientgarea).

Part Four - Leveraging the .NET Libraries

As a final touch, to ensure proper redrawing let's handle the Resize event to ensure that if the user resizes

Chapter 12 - Object Serialization and the .NET Remoting Layer

the Form, the lower part of client rectangle is redrawn correctly:

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

private void FontForm_Resize(object sender, System.EventArgs e)

Chapter 15 - Programming with Windows Forms Controls

{

Chapter 16 - The System.IO Namespace

Rectangle myRect = new Rectangle(0, 100,

Chapter 17 - Data Access with ADO.NET

ClientRectangle.Width, ClientRectangle.Height);

Part Five - Web Applications and XML Web Services

Invalidate(myRect);

Chapter 18 - ASP.NET Web Pages and Web Controls

}

Chapter 19 - ASP.NET Web Applications Chapter 20 - XML Web Services

IndexWith that, Figure 14-11 shows the result.

List of Figures

List of Tables

Figure 14-11: The FontApp application in action

SOURCE The FontApp application is included under the Chapter 14 subdirectory.

CODE

Survey of theC# andSystemthe .NET.DrawingPlatform, Second.Drawing2DEdition Namespace

Now that you have manipulated Font types, the next task is to examine how to manipulate Pen and Brush

Apress © 2003 (1200 pages)

objects to render geometric patterns. While you could do so making use of nothing more than the types

This comprehensive text starts with a brief overview of the

found in the SystemC#.languageDrawing namespace,and then quicklyyoumovesshouldtobekeyawaretechnicthatl manyand of the more "sexy" pen and brush configurationsarchitectur(for example,l issuestheforHatchBrush.NET developerstype. used at the beginning of this chapter) require types defined within the System.Drawing.Drawing2D namespace.

TableThisofadditionalContentsGDI+ namespace (which is substantially smaller than System.Drawing) provides a number C#of andclassesthe .thatNET allowP atform,youSecondto modifyEditionthe line cap (triangle, diamond, etc.) used for a given pen, build

textured brushes, as well as work with vector graphic manipulations. Some core types to be aware of,

Introduction

grouped by related functionality, are shown in Table 14-16.

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

Table 14-16: The Classes of System.Drawing.Drawing2D

Chapter 2 - Building C# Applications

Part Five - Web Applications and XML Web Services

Also be aware that the System.Drawing.Drawing2D namespace defines another set of enumerations that

Chapter 18 - ASP.NET Web Pages and Web Controls

are used in conjunction with these core types. Table 14-17 gives a quick rundown.

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Table 14-17: The Enumerations of System.Drawing.Drawing2D

Index

List of Figures

List of Tables

private void MainForm_Paint(object sender, PaintEventArgs e)

C# and the .NET Platform, Second Edition

{

Graphics g = e.Graphics;

Apress © 2003 (1200 pages)

// Set quality of GDI+ object rendering.

This comprehensive text starts with a brief overview of the g.SmoothingMode = SmoothingMode.AntiAlias;

C# language and then quickly moves to key technical and

...

architectural issues for .NET developers.

}

Table of Contents

Be aware that the SmoothingMode property is only used to control the quality of rendering GDI+ objects,

not textual information. If you wish to modify the rendering quality for Font types, you need to set the

Introduction

TextRenderingHint property using the related System.Drawing.Text.TextRenderingHint enumeration:

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

public enum System.Drawing.Text.TextRenderingHint

Chapter 2 - Building C# Applications

{

Part Two - The C# Programming Language

AntiAlias, AntiAliasGridFit,

Chapter 3 - C# Language Fundamentals

ClearTypeGridFit, SingleBitPerPixel,

Chapter 4 - Object-Oriented Programming with C#

SingleBitPerPixelGridFit, SystemDefault

Chapter 5 - Exceptions and Object Lifetime

}

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

Working with Pens

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

GDI+ Pen objects are used to draw lines (not too much of a stretch there!). However, a pen in and of itself

Chapter 10 - Processes, AppDomains, Contexts, and Threads

is of little value. When you need to render a geometric shape onto a Control-derived type, you send a pass

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

valid Pen type to any number of render methods defined by the Graphics class. In general, the

Part Four - Leveraging the .NET Libraries

DrawXXXX() methods are used to render some set of lines to a graphics surface, and are typically used

Chapter 12 - Object Serialization and the .NET Remoting Layer

with Pen objects. The Graphics class also defines a number of FillXXXX() methods that render an image

Chapter 13 - Building a Better Window (Introducing Windows Forms) using some sort of Brush-derived type (more on those in just a minute).

Chapter 14 - A Better Painting Framework (GDI+)

Although you have seen many drawing members earlier in the chapter, here they are again (Table 14-19)

Chapter 15 - Programming with Windows Forms Controls

in a bit more detail (be aware that each of these methods have been overloaded a number of times).

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Table 14-19: Drawing Members of the Graphics Class

Part Five - Web Applications and XML Web Services

Pen bluePen = new Pen(Color.Blue, 20);

C# and the .NET Platform, Second Edition

// Get a stock pen from the Pens type.

C# language and then quickly moves to key technical and g.DrawLine(pen2, 10, 130, 110, 130);

architectural issues for .NET developers. g.DrawPie(Pens.Black, 150, 10, 120, 150, 90, 80);

// Draw a purple dashed polygon as well...

Pen pen3 = new Pen(Color.Purple, 5);

Table of Contents

pen3.DashStyle = DashStyle.DashDotDot;

C# and the .NET Platform, Second Edition

g.DrawPolygon(pen3, new Point[]{new Point(30, 140),

Introduction

new Point(265, 200), new Point(100, 225),

new Point(190, 190), new Point(50, 330),

Chapter 1 - The Philosophy of .NET

new Point(20, 180)});

Chapter 2 - Building C# Applications

// And a rectangle containing some text...

Part Two - The C# Programming Language

Rectangle r = new Rectangle(150, 10, 130, 60);

Chapter 3 - C# Language Fundamentals g.DrawRectangle(Pens.Blue, r);

Chapter 4 - Object-Oriented Programming with C# g.DrawString("Hello out there...How are ya?",

Chapter 5 - Exceptions and Object Lifetime

new Font("Arial", 12), Brushes.Black, r);

Chapter 6 - Interfaces and Collections

}

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

Notice that the Pen that is used to render your polygon makes use of the DashStyle enumeration (defined

Chapter 9 - Understanding .NET Assemblies

in System.Drawing.Drawing2D). This is the .NET equivalent of the raw Win32 pen style flags (e.g.,

Chapter 10 - Processes, AppDomains, Contexts, and Threads

PS_SOLID).Table 14-21 lists your choices.

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Part Four - Leveraging the .NET Libraries

ChapterDashDotDot19 - ASP.NET Web SpecifiesA plicationsline comprised of an alternating pattern of dash-dot-dot-dash-

Chapter 20 - XML Web Servicesdot-dot

In addition to the preconfigured DashStyles, you are also able to define custom dash types using the DashPattern property of the Pen type: (see Figure 14-13 for complete output).

ISBN:1590590554

overview of the technical and

Table

C# and

Part

Chapter

Chapter

Part

Chapter

Chapter

Chapter

Chapter

Chapter

Chapter

Part Three - Programming with .NET Assemblies

Figure 14-13: Working with Pen types

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

// Draw custom dash pattern all around the boarder of the form.

Part Four - Leveraging the .NET Libraries

Pen customDashPen = new Pen(Color.BlueViolet, 5);

Chapter 12 - Object Serialization and the .NET Remoting Layer float[] myDashes = { 5.0f, 2 0f, 1.0f, 3.0f} ;

ChaptercustomDashPen13 - Building.DashPatternBetter Window=(IntroducingmyDashes;Windows Forms)

Chapterg.DrawRectangle(customDashPen,14 - A Better Painting Framework (GDI+)ClientRectangle);

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

SOURCE The PenApp project is included under the Chapter 14 subdirectory.

Chapter 17 - Data Access with ADO.NET

CODE

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

ChapterWorking19 - ASPwith.NET WebPenApplicCapstions

Chapter 20 - XML Web Services

If you examined the output of the previous pen example, you should have noticed that the beginning and

Index

end of each line was rendered using a standard pen protocol (an end cap composed of 90 degree angles). Using the LineCap enumeration however, you are able to build Pens that exhibit a bit more flair. The core values of this enumeration are seen in Table 14-22.

Table 14-22: LineCap Values

Part Two - The C# Programming Language

To illustrate, the following Pens application draws a series of lines using each of the LineCap styles. First,

Chapter 3 - C# Language Fundamentals

the result can be seen in Figure 14-14.

Chapter 4 - Object-Oriented Programming with C# Chapter 5 - Exceptions and Object Lifetime Chapter

Chapter

Chapter

Part

Figure 14-14: Working with pen caps

The code simply loops through each member of the LineCap enumeration, and prints out the name of the item (e.g., ArrowAnchor) and then configures and draws a line with the current cap:

private void MainForm_Paint(object sender, PaintEventArgs e)

{

Graphics g = e.Graphics;

Apress © 2003 (1200 pages)

Array obj = Enum.GetValues(typeof(LineCap));

This comprehensive text starts with a brief overview of the

// Draw a line with a LineCap member.

C# language and then quickly moves to key technical and for(int x = 0; x < obj.Length; x++)

architectural issues for .NET developers.

{

// Get next cap and configure pen.

LineCap temp = (LineCap)obj.GetValue(x);

Table of Contents

thePen.StartCap = temp;

C# and the .NET Platform, Second Edition thePen.EndCap = temp;

Introduction

// Print name of LineCap enum.

Part One - Introducing C# and the .NET Platform

g.DrawString(temp.ToString(), new Font("Times New Roman", 10),

Chapter 1 - The Philosophy of .NET

new SolidBrush(Color.Black), 0, yOffSet);

Chapter 2 - Building C# Applications

// Draw a line with the correct cap.

Part Two - The C# Programming Language

g.DrawLine(thePen, 100, yOffSet, Width - 50, yOffSet);

Chapter 3 - C# Language Fundamentals

yOffSet += 40;

Chapter 4 - Object-Oriented Programming with C#

}

Chapter 5 - Exceptions and Object Lifetime

}

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

SOURCE The PenCapApp project is included under the Chapter 14 subdirectory.

Chapter 9 - Understanding .NET Assemblies

CODE

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

PartWorkingFour - Leveragingwith theSolid.NET LibBrushesaries

Chapter 12 - Object Serialization and the .NET Remoting Layer

So much for drawing lines. GDI+ Brush-derived types are used to fill the space between the lines, with a

Chapter 13 - Building a Better Window (Introducing Windows Forms)

given color, pattern, or image. Recall that the Brush class is an abstract type, and cannot be directly

Chapter 14 - A Better Painting Framework (GDI+)

created. Rather, this type serves as a base class to the other related brush types (for example, SolidBrush,

Chapter 15 - Programming with Windows Forms Controls

HatchBrush, LinearGradientBrush, and so forth). In addition to the aforementioned Brush-derived types, the System.Drawing namespace also defines two types that return a configured brush using a number of static properties: Brushes and SystemBrushes. Using a properly configured brush, you are able to call any number of methods [such as DrawString()], as well as the following set of FillXXXX() methods (Table 14-

Chapter 18 - ASP.NET Web Pages and Web Controls

23).

Chapter 19 - ASP.NET Web Applications