C# 4 and .NET 4

editing a Text Document: The Capseditor example ❘ OC31
constructor for Font — there are many more that allow additional options to be specified. The constructor
takes two parameters, the name of the family and the size of the font:
Font f = new Font(family.Name, 10);
This constructor builds a font that has the regular style. To be on the safe side, however, you first check that
this style is available for each font family before attempting to display anything using that font. This is done
using the FontFamily.IsStyleAvailable() method. This check is important because not all fonts are
available in all styles:
if (family.IsStyleAvailable(FontStyle.Regular))
FontFamily.IsStyleAvailable() takes one parameter, a FontStyle enumeration. This enumeration
contains a number of flags that might be combined with the bitwise OR operator. The possible flags are
Bold, Italic, Regular, Strikeout, and Underline.
Finally, note that you use a property of the Font class, Height, which returns the height needed to display
text of that font, to work out the line spacing:
Font f = new Font(family.Name, 10);
Point topLeftCorner = new Point(margin, verticalCoordinate);
verticalCoordinate += f.Height;
Again, to keep things simple, this version of OnPaint() reveals some bad programming practices.
For example, you have not bothered to check what area of the document actually needs drawing —
you just tried to display everything. Also, instantiating a Font is, as remarked earlier, a computationally
intensive process, so you really ought to save the fonts rather than instantiating new copies every time
OnPaint() is called. Because of the way the code has been designed, you might note that this example
actually takes a noticeable amount of time to paint itself. To try to conserve memory and help the garbage
collector, you do, however, call Dispose() on each font instance after you have finished with it. If you did
not, after 10 or 20 paint operations, there would be a lot of wasted memory storing fonts that are no
longer needed.
ediTing a TeXT doCumenT: The CaPsediTor eXamPle
You now come to the extended example in this chapter. The CapsEditor example is designed to
demonstrate how the principles of drawing that you have learned so far have to be applied in a more
realistic context. The CapsEditor example does not require any new material, apart from responding to
user input via the mouse, but it shows how to manage the drawing of text so that the application maintains
performance while ensuring that the contents of the client area of the main window are always kept
up-to-date.
The CapsEditor program allows the user to read in a text file, which is then displayed line by line in the
client area. If the user double-clicks any line, then that line will be changed to all uppercase. That is literally
all the example does. Even with this limited set of features, you will find that the work involved in making
sure everything is displayed in the right place while considering performance issues is quite complex. In
particular, you have a new element here: the contents of the document can change — either when the user
selects the menu option to read a new file, or when she double-clicks to capitalize a line. In the first case,
you need to update the document size so the scrollbars still work correctly, and you have to redisplay
everything. In the second case, you need to check carefully whether the document size has changed, and
what text needs to be redisplayed.
This section starts by reviewing the appearance of CapsEditor. When the application is first run, it has no
document loaded and resembles Figure 48-17.
www.it-ebooks.info