Home

GDI+ Fonts

 

The Spoken and Written Words

 

Introduction

Our most common means of communicating with other people is through the spoken words. This is the type taught very early to babies and infants. For two people A and B to effectively communicate with speech, they must use words that are common to them. There could be other words spoken by two different individuals C and D and that people A and B do not understand. The group of words that two people A and B use to understand each other is called a language. Each language has a name, such as Latin or Aramaic. One or more new languages can be derived from an existing language. Just as done for a C# class, the newly derived language can modify some words of the parent language and can add new language.

One of the limitations of the spoken word is that we must be interacting, somehow directly, with the other person and, after the conversation is over, except for our memory, the whole speech is physically lost, and there is no physical reference that the conversation took place.

An Alphabet and its Letters

Another type of communication, which is sometimes an addition, sometimes an alternative, is the written word. To make this possible, a long time ago (hundreds and sometimes thousands of years ago), a group of symbols were created so that each symbol would have a particular role and meaning. The group of symbols is understandable to a particular language and the group of symbols is called an alphabet. Like everything else, an alphabet has a name, and the name of the alphabet is related to its corresponding language. For example, there is such a thing as the English alphabet. There is the French alphabet, and the German alphabet.

One of the particularities of a regular alphabet is that it must have a specific way to represent its primary basic symbols. In English, the basic symbols are A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, and Z. There are two ways to represent a letter (in most Western languages): uppercase and lowercase.

Besides the regular letters of an alphabet, when creating or representing the written words, a language can add some signs to some words. This can assist in the pronunciation or the variations, which can subsequently make the language richer. For example, both the English and the French languages use the same alphabet, but the French language adds some signs to some of its letters. Examples are: Ma marâtre est peut-être a côté du tronçon fluvial. Many other languages, derived from Latin or not, use this type of mechanism to complement their communication.

As mentioned already, the letters used in the alphabet and the digits used to represent numbers were created a long time ago. The people who created them designed a standard way of representing the letters. For example, they decided that the letter A would be represented as A. A few (hundred) years later, as aesthetic representation was developed to make things look good, some variations of representing the same letter were created. For example, here are three representations the the same word:

  • State
  • State
  • State

Notice that the S on each word is different. With the advent of computers, new demands for better and more sophisticated techniques of representing words were needed.

The Digits

The letters of an alphabet are typically used to create or represent spoken words. To count, to measure, to represent numbers, or to perform calculations, other symbols were created. The Latin-based languages use the symbols 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. Because there are 10 of them, they are referred to as digits. While most (or rather many) languages, including non-Latin-based languages, use or borrow these digits, some other languages use other means of representing numbers.

In spoken words, each of these symbols has a specific name.

To create a represent a number, you use one or a combination of digits.

Getting a Font

A font is an abstract (non-physical) object used to draw some symbols on paper, a computer monitor, or another device (PDA, oscillator, etc).

A font is created by a graphic artist or developed by a corporation. Once the font has been designed, it is created as a computer application and must be installed in the device that will use it. This means that the font must be installed in the computer, the printer, or the device that can then use it. This also means that there are various ways you can get a font to your device. Most computer-related objects (PCs, printers, oscillators, PDAs, etc) come with one or more fonts already installed. You can also purchase a font and install it on a computer. You can also download a free font from the Internet and install it.

The Characteristics of a Font

 

Introduction

A font is a GDI+ object, like a pen or a brush. Like any other object, the primary information of a font is its name. To see the names of fonts installed in a computer that is running Microsoft Windows, in the Control Panel, you can double-click Fonts. Here is an example:

Fonts

Because is something that must be installed on, and can be removed from, the computer, it is likely that two computers would not have the same (list of) fonts. Still, because Microsoft Windows installs some default or popular fonts by default, there are fonts that are likely to be found on every regular installation of Microsoft Windows. This implies that, if you create a (commercial) application that you intend to distribute to people (customers) you do not know, you should assume that your audience would not have most or any of the fancy fonts you have in your computer.

You have two alternatives when selecting the fonts used in your application you intend to distribute. If you own the font, you can distribute it with your application. Another solution, easier solution, is to use only the most likely fonts to be found on most computers.

Creating a Font

In the .NET Framework, the primary piece of information about a font is held by a class named FontFamily. The FontFamly class is equipped with three constructors that each provides a different means of initializing a font.

The list of fonts installed in a a computer is stored in a property of the FontFamily class and that property is named Families. The FontFamily.Families property is collection member declared as a static property.

Like every GDI+ object, before using a font, you must create and initialize it.  To support fonts, the .NET Framework provides the Font class. This class is equipped with various constructors that each provides a particular means of initializing a font.

In order to use a font in an application, you must identify the FontFamily object you want to use and associate it with a Font.

The Name of a Font

The primary piece of information about a font is its name. As seen about, the names of fonts can be seen in the Fonts window of Control Panel. As mentioned already, the name of a font is held by the FontFamily class. If you know the name of the font you want to use, to create a font object (using that name), you can use the following constructor of the FontFamily class:

Public Sub New(name As String)

This constructor takes as argument the name of the font you want to use. Here is an example of using it:

Imports System.Drawing
Imports System.Drawing.Drawing2D
Imports System.Windows.Forms

Module Exercise

    Public Class Starter
        Inherits Form

        Dim components As System.ComponentModel.Container

        Public Sub New()
            InitializeComponent()
        End Sub

        Public Sub InitializeComponent()

        End Sub

        Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim fntWrite As FontFamily = New FontFamily("Times New Roman")

        End Sub
    End Class

    Function Main() As Integer

        Dim frmStart As Starter = New Starter

        Application.Run(frmStart)

        Return 0
    End Function

End Module

When using this constructor, you should make sure the font you use exists in the computer that will run the application. If you provide a name of a font that does not exist in the computer that is running the application, the compiler would throw an ArgumentException exception.

To get the name that a FontFamily object is using, get the value of its Name property. As you can guess, the name of a font is a string.

The Size of a Font

The size of a font is the width and the height that will be used to draw a character. It is important to know that this size refers to the visual 2-dimensional size and not to the memory size. This means that the letters i, N, g, M, l, and W obviously use different visual space but all of them use the same amount of memory space.

When creating a font, to specify its size, you can use the following constructor of the Font class:

Public Sub New(familyName As String, emSize As Single)

The first argument is the name of the font you want to use. The second argument is a floating-point number. Here is an example:

Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim fntWrite As Font = New Font("Verdana", 16.0F)

End Sub

If you had stored the name of the font in a FontFamily variable and want to create a font, you can use the following constructor of the Font class:

Public Sub New(family As FontFamily, emSize As Single)

Here is an example of using this constructor:

Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim ffmWrite As FontFamily = New FontFamily("Times New Roman")
            Dim fntWrite As Font = New Font(ffmWrite, 16.0F)

End Sub

To find out the size of an existing font, you can get the value of the Size property of a Font object.

The Style of a Font

To enhance the appearance of a characters, a font can be underlined, italicized, or bolded, etc. These are referred to as a style. To specify a style when creating a font, you can use the following constructor of the Font class:

Public Sub New(familyName As String, emSize As Single, style As FontStyle)

The first argument is the name of the font. The second argument would be the size of the font. The third argument is of type FontStyle, which is an enumeration. The members of this enumeration are:

  • Regular: The character(s) would not have a particular style
  • Bold: The character(s) would be bolded
  • Italic: The character(s) would be italicized
  • Strikeout: A line would traverse the the character(s)
  • Underline: The character(s) would be underlined

Here is an example of initializing a font by specifying its name, its size, and a style:

Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim fntWrite as Font  = new Font("Verdana", 16.0F, FontStyle.Italic)

End Sub

The above constructor is used to directly specify the name of the font. If you had stored the name of a font in a FontFamily object and you want to specify its style when initializing it, you can use the following constructor when declaring a Font variable:

Public Sub New(family As FontFamily, emSize As Single, style As FontStyle)

Here is an example of using this constructor:

Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim ffmWrite As FontFamily = New FontFamily("Times New Roman")
            Dim fntWrite As Font = New Font(ffmWrite, 16.0F, FontStyle.Strikeout)

End Sub

If you already have an existing font but want to apply a style to it, change its style, or apply a different style to it, you can use the following constructor of the Font class:

Public Sub New(prototype As Font, newStyle As FontStyle)

Here is an example:

Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim ffmWrite As FontFamily = New FontFamily("Times New Roman")
            Dim fntWrite As Font = New Font(ffmWrite, 16.0F, FontStyle.Strikeout)
        
        . . . Use or don't use the font here

            fntWrite = New Font(fntWrite, FontStyle.Bold)

        . . . Use the new font here

End Sub

You can also create a new font based on the previous one but with a different style. Here is an example:

Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim ffmWrite As FontFamily = New FontFamily("Times New Roman")
            Dim fntWrite As Font = New Font(ffmWrite, 16.0F, FontStyle.Strikeout)
        
        . . . Use or don't use the font here

            Dim fntAnother As Font = New Font(fntWrite, FontStyle.Bold)

        . . . Use the new font here

End Sub

You can combine two or more styles to get a fancier effect. To combine the styles, you use the OR bit operator "|". Here are two examples:

Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim ffmWrite As FontFamily = New FontFamily("Times New Roman")
            Dim fntWrite As Font = New Font(ffmWrite, 16.0F, _
                            FontStyle.Strikeout Or FontStyle.Italic)

            '. . . Use or don't use the font here

            fntWrite = New Font(fntWrite, _
                    FontStyle.Italic Or FontStyle.Bold Or FontStyle.Underline)

            '. . . Use the new font here

End Sub

As opposed to applying a style, you may be interested to get the style that a font object holds:

  • To find out whether a character or a word is bolded, get the Boolean value of the Bold property of its font
  • To find out whether a character or a word is italicized, get the Boolean value of the Italic property of its font
  • To find out whether a character or a word in underlined, get the Boolean value of the Underline property of its font
  • To find out whether a character or a word is stricken through, get the Boolean value of the Strikeout property of its font
  • To get all the styles applied to a character, a word, or a group of words, get its Style property

Drawing a String

 

Introduction

Besides the regular geometric and irregular non-geometric shapes we have seen so far, you can draw a string on a graphics object. To support this, the Graphics class is equipped with a method named DrawString that is overloaded with various versions.

One of the versions of the Graphics.DrawString() methods uses the following syntax:

Public Sub DrawString(s As String, _
		   font As Font, _
		   brush As Brush, _
		   x As Single, _
		   y As Single)

The first argument is the string that will be drawn on the graphics object. The second argument is the definition of the font that will be used. The third argument can simply be a color, it can be a pattern, or it can be a complex texture that will be used to paint the character(s) of the string. The last two arguments are the (top-left) coordinates where the beginning of the string would be.

Here is an example of calling this method:

Imports System.Drawing
Imports System.Drawing.Drawing2D
Imports System.Windows.Forms

Module Exercise

    Public Class Starter
        Inherits Form

        Dim components As System.ComponentModel.Container

        Public Sub New()
            InitializeComponent()
        End Sub

        Public Sub InitializeComponent()

        End Sub

        Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim fntFamily As FontFamily = New FontFamily("Times New Roman")
            Dim fntWrite As Font = New Font(fntFamily, 24.0F, FontStyle.Regular)

            e.Graphics.DrawString("Rain Drop", fntWrite, Brushes.Blue, 10.0F, 8.0F)

        End Sub
    End Class

    Function Main() As Integer

        Dim frmStart As Starter = New Starter

        Application.Run(frmStart)

        Return 0
    End Function

End Module

This would produce:

Draw String

The above version of the DrawString() method specifies the coordinates as two floating-point numbers. A logical alternative is to consider the coordinates as a PointF value. This can be done using the following version of the method:

Public Sub DrawString(s As String, _
		    font As Font, _
		    brush As Brush, _
		    point As PointF)

The first three arguments are the same. The last argument is the PointF combination of the two floating-point values of the previous version of the method.

Confining a String to a Rectangle

One of the advantages of using one of the above versions of the Graphics.DrawString() method is that it would draw the whole string. I you draw other strings, there is a possibility that the strings would overlap. Here is an example:

Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim ptF As PointF = New PointF(10.0F, 8.0F)
            Dim fntFamily As FontFamily = New FontFamily("Times New Roman")
            Dim fntWrite As Font = New Font(fntFamily, 18.0F, FontStyle.Regular)

            e.Graphics.DrawString("College Park Auto-Parts", _
			fntWrite, Brushes.Blue, ptF)

            ptF = New PointF(10.0F, 16.0F)
            e.Graphics.DrawString("Georgetown Cleaning Services", _
			fntWrite, Brushes.Red, ptF)

End Sub

This would produce:

Draw String

Of course, this means that it is just a concern you would have to address and there are various ways you can solve this type of problem (unless it is your intention to overlap the strings). One alternative you can use is to draw the string inside of a box and not allow it to go beyond that box. To support this, the DrawString() method has the following version:

Public Sub DrawString(s As String, _
		    font As Font, _
		    brush As Brush, _
		    layoutRectangle As RectangleF)

The last argument is a rectangle value with floating-point numbers. The string would be drawn inside that rectangle. Anything that could go beyond that rectangle would disappear. Here is an example:

Private Sub FormPaint(ByVal sender As Object, _
                              ByVal e As PaintEventArgs) _
                              Handles MyBase.Paint

            Dim fntFamily As FontFamily = New FontFamily("Times New Roman")
            Dim fntWrite As Font = New Font(fntFamily, 20.0F, FontStyle.Regular)
            Dim rect As RectangleF = New RectangleF(10.0F, 8.0F, 160.0F, 20.0F)

            e.Graphics.DrawString("College Park Auto-Parts", _
		fntWrite, Brushes.Blue, rect)

End Sub

This would produce:

Draw String

Notice that, not only is the string too tall for the rectangle, but also the string is too long. This means that you must appropriately define the rectangle.

 

Home Copyright © 2008-2012 FunctionX