Using Fonts

Working with fonts requires a unique vocabulary. A typeface is a specific style of drawing a character. Arial, Times New Roman, and Garamond are all names of typefaces. A collection of descriptions that describe how to draw a set of characters using the same display characteristics and the same typeface is a font. The font is traditionally referred to by its typeface name along with any style modifiers, as in Arial Bold and Garamond Italic.

Fonts can be monospace (sometimes called fixed-pitch fonts), such as Courier New and Lucida Console, or they can be variable-pitched, like Arial and Times New Roman. Characters drawn with a monospace font all have the same width, whereas in a variable-pitched font, the width of the characters varies on a character-by-character basis.

Serif fonts include an extra flourish at the end of strokes. Examples of serif fonts include Times New Roman, Courier New, and Garamond. Sans serif fonts don’t have serifs and include fonts such as Arial and Helvetica.

The FontStyle enumeration is used to identify common variations in fonts, using the following values:

• Bold

• Italic

• Regular

• Underline

• Strikeout

• Underline

Values from the FontStyle enumeration can be combined, so to specify a boldface italic font, you would use code like this:

FontStyle style = FontStyle.Bold ¦ FontStyle.Italic; 

Every font is part of a font family, which serves as a grouping for fonts that have the same typeface and similar styles. Variations of a font that differ based on their FontStyle characteristics are generally in the same font family. However, it’s not unusual for one typeface to be shared by multiple font families—for example, there are several font families that use variations of the Arial typeface.

The FontFamily class is used to interact with the font families installed on a computer. There are three constructors used to create FontFamily objects. The first constructor accepts a value from the GenericFontFamilies enumeration and creates an instance of FontFamily that represents one of the generic font families, as shown here:

FontFamily monoFont = new FontFamily(GenericFontFamilies.Monospace);

This code creates a FontFamily object that represents a generic monospace font family. The GenericFontFamilies enumeration values are provided in Table 14-12.

The second FontFamily constructor enables you to specify the font family by name and create a FontFamily object to represent it, as shown here:

FontFamily arialFamily = new FontFamily("Arial");

The third FontFamily constructor is used to create a FontFamily object based on a font that’s stored in an instance of PrivateFontCollection, which will be discussed in the next section.

In addition to the FontFamily constructors, you also can obtain references to FontFamily objects through static methods and properties exposed by the FontFamily class. The following static properties are used to obtain references to FontFamily objects that represent generic fonts:

• GenericMonospace  Returns a FontFamily object that refers to a generic monospace font, such as Courier New

• GenericSansSerif  Returns a FontFamily object that refers to a generic sans serif font, such as Microsoft Sans Serif

• GenericSerif  Returns a FontFamily object that refers to a generic serif font, such as Times New Roman

In the next section, you’ll learn how to retrieve an array of FontFamily objects that represents all the installed fonts.

The FontFamily class exposes one non-static property—the Name property, which returns the name of the font family, as shown here:

FontFamily arialFamily = new FontFamily("Arial");
string familyName = arialFamily.Name; 

The FontFamily class exposes several useful methods, including the IsStyleAvailable method. If you attempt to create a font with an unsupported style, an exception will be thrown. For example, some font families don’t support the boldface or italic font styles. The IsStyleAvailable method provides a useful way to determine whether a specific font style is supported by a font family, as shown here:

if(arialFamily.IsStyleAvailable(FontStyle.Bold))
{
    // Font can be safely created.
    
    

}

The FontCollection base class is used to store a collection of fonts available for use. There are two sealed subclasses:

• InstalledFontCollection  Class that represents the collection of fonts that are installed on the user’s computer

• PrivateFontCollection  Class that represents a collection of fonts used for the application only and not installed in the operating system’s collection of installed fonts

The InstalledFontCollection class is useful when you want to determine whether a particular font family has been installed. If your application requires a specific font, you can use this collection to determine whether the font is available for use. The following code displays all the installed fonts in a message box:

static void Main() 
{
    StringBuilder familyNames = new StringBuilder();            
    InstalledFontCollection ifc = new InstalledFontCollection();
    FontFamily[] families = ifc.Families;
    foreach(FontFamily family in families)
    {
        familyNames.AppendFormat("{0}\n", family.Name);
    }
    MessageBox.Show(familyNames.ToString());
}

This example creates an instance of InstalledFontCollection and retrieves an array of FontFamily objects that represent all the fonts installed on the computer. Next the code iterates over the array of FontFamily objects and displays the names in a message box, as shown in Figure 14-13.

Figure 14-13.

A message box displaying currently installed font families.

Fonts are measured using a variety of metrics, including points, em sizes, and design units. In this section, these terms are defined, and you’ll learn how to collect font metrics.

A good place to begin is with the point. A point is about 1/72 of an inch and is a common unit used to describe relative font sizes. On a computer screen, the point sizes don’t refer to physical dimensions and are really useful only for comparison purposes. The default font size for Windows is 10 points, whereas the default font size for Windows Forms is 8.25 points. A common unit of measurement in Windows Forms is the document unit, which is 1/300 of an inch, or about 4.16 document units per point.

When working with font metrics, you’ll often see references to the em size. An em is the point size of a given font. If the font is 10 points, the em size will be 10 points. A value of 2 ems is twice the size of the current font (for example, 20 points if the current font is 10 points).

The following methods from the FontFamily class can be used to collect information about font metrics:

• GetCellAscent  Returns the vertical size reserved for an ascender (the portion of a font drawn above the baseline) for a specified font style

• GetCellDescent  Returns the vertical size reserved for a descender (the portion of a font drawn below the baseline) for a specified font style

• GetEmHeight  Returns the height of an em for a specified font style

• GetLineSpacing  Returns the spacing between lines for a specified font style

Font = new Font(oldFont, newStyle);

private void ToggleBoldStyle()
{
    // Get the current font and style.
    Font oldFont = Font;
    // Flip the Bold style flag.
    FontStyle newStyle = Font.Style ^ FontStyle.Bold;
    // Use the old font and the new style to create a new Font object.
    Font = new Font(oldFont, newStyle);
    // Clean up.
    oldFont.Dispose();
    Invalidate();
} 

FontFamily family = new FontFamily("Trebuchet MS");
Font labelFont = new Font(family, 20.0f);
Font statusFont = new Font("Garamond", 20.0f);

Font labelFont = new Font(family, 20.0f, FontStyle.Underline); 
Font statusFont = new Font("Garamond", 20.0f, FontStyle.Bold);

Font labelFont = new Font(family, 
                          20.0f,
                          GraphicsUnit.Document);
Font statusFont = new Font("Garamond", 
                           20.0f,
                           GraphicsUnit.Document);

Font labelFont = new Font(family, 
                          20.0f,
                          FontStyle.Underline,
                          GraphicsUnit.Document);
Font statusFont = new Font("Garamond", 
                           20.0f,
                           FontStyle.Bold,
                           GraphicsUnit.Document); 

// From WinGDI.h
const byte OEM_CHARSET = 255;
Font labelFont = new Font(family, 
                          20.0f,
                          FontStyle.Underline,
                          GraphicsUnit.Point,
                          OEM_CHARSET);
Font statusFont = new Font("Garamond", 
                            20.0f,
                            FontStyle.Bold,
                            GraphicsUnit.Point,
                            OEM_CHARSET); 

Font labelFont = new Font(family, 
                          20.0f,
                          FontStyle.Underline,
                          GraphicsUnit.Point,
                          OEM_CHARSET,
                          true);
Font statusFont = new Font("Garamond", 
                            20.0f,
                            FontStyle.Bold,
                            GraphicsUnit.Point,
                            OEM_CHARSET,
                            true);

Adding support for selectable fonts to an application is easy using Microsoft Visual C# .NET and the .NET Framework. The companion CD includes a new version of the SimpleEdit example originally presented in Chapter 13. The version included in this chapter enables the user to select the font used to display the edited text. The code required to make this change spans just a few lines, as shown below.

private void editFontMenuItem_Click(object sender, System.EventArgs e)
{
    FontDialog dialog = new FontDialog();
    dialog.Font = Font;
    if(dialog.ShowDialog() == DialogResult.OK)
    {
        Font = dialog.Font;
        Invalidate();
    }
}

This code is simple, but it improves the user’s experience with the SimpleEdit application because the user is now free to use any available font when editing a text file. The editFontMenuItem_Click method starts by creating an instance of the FontDialog class and then passes the form’s font to the common dialog box. As with the ColorDialog class, discussed earlier in this chapter, in the section “The Color Common Dialog Box,” it’s a good idea to pass the current context information (in this case, the font) to the dialog box before it’s displayed to the user. This lets the user see the current settings before making changes.