C# 4 and .NET 4

simple Text example ❘ OC27
draWing TeXT
We have chosen to cover the very important topic of displaying text late in this chapter because drawing text
to the screen is (in general) more complex than drawing simple graphics. Although displaying a line or two
of text when you don’t care about the appearance is extremely easy (it takes one single call to the Graphics.
DrawString() method), if you are trying to display a document that has a fair amount of text in it, then
you will rapidly find that things become a lot more complex. This is for two reasons:
➤
➤
If you are concerned about getting the appearance just right, then you must understand fonts.
Whereas shape drawing requires brushes and pens as helper objects, the process of drawing text
requires fonts as helper objects. Moreover, understanding fonts is not a trivial undertaking.
Text needs to be very carefully laid out in the window. Users generally expect words to follow
naturally from one word to another and to be lined up with clear spaces in between. Doing that
is harder than you might think. For starters, you do not usually know in advance how much
space on the screen a word is going to take up. That has to be calculated (using the Graphics.
MeasureString() method). In addition, the space a word occupies on the screen affects where in the
document every subsequent word is placed. If your application does any line wrapping, then it will
need to assess word sizes carefully before deciding where to place the line break. The next time you
run Microsoft Word, look carefully at the way Word is continually repositioning text as you do your
work; there is a lot of complex processing going on there. Chances are that any GDI+ application
you work on will not be nearly as complex as Word. However, if you need to display any text, many of
the same considerations apply.
In short, high-quality text processing is tricky to get right. However, putting a line of text on the screen,
assuming that you know the font and where you want it to go, is actually very simple. Therefore, the next
section presents a quick example that shows you how to display some text, followed by a short review
of the principles of fonts and font families and a more realistic (and involved) text-processing example,
CapsEditor.
simPle TeXT eXamPle
This example, DisplayText, is your usual Windows Forms effort. This time you override OnPaint() and
add member fields as follows:
private readonly Brush blackBrush = Brushes.Black;
private readonly Brush blueBrush = Brushes.Blue;
private readonly Font haettenschweilerFont = new Font("Haettenschweiler", 12);
private readonly Font boldTimesFont = new Font("Times New Roman", 10,
FontStyle.Bold);
private readonly Font italicCourierFont = new Font("Courier", 11,
FontStyle.Italic | FontStyle.Underline);
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
Graphics dc = e.Graphics;
dc.DrawString("This is a groovy string", haettenschweilerFont, blackBrush,
10, 10);
dc.DrawString("This is a groovy string " +
"with some very long text that will never fit in the box",
boldTimesFont, blueBrush,
new Rectangle(new Point(10, 40), new Size(100, 40)));
dc.DrawString("This is a groovy string", italicCourierFont, blackBrush,
new Point(10, 100));
}
code download DisplayText.sln
www.it-ebooks.info