Catálogo de publicaciones - libros

Some developers hate the headaches of user-interface programming. They assume it’s all about painting icons, rewording text, and endlessly tweaking dialog boxes until an entire company agrees that an application looks attractive. However, developers who are involved in creating and maintaining sophisticated applications realize that there is another set of design considerations for user-interface programming. These are considerations about application architecture.

In Windows Forms, everything begins with the Control class—the fundamental class from which every other control derives. The Control class defines the bare minimum functionality that every control needs, from the properties that let you position it in a window to the events that let you react to key presses and mouse clicks.

Windows are the basic ingredients in any desktop application—so basic that the operating system itself is named after them. However, there’s a fair deal of subtlety in exactly how you use a window, not to mention how you resize its content. This subtlety is what makes windows (or , to use .NET terminology) one of the most intriguing user-interface topics.

This chapter considers some of the most common types of controls, such as labels, text boxes, and buttons. Many of these controls have existed since the dawn of Windows programming and don’t need much description. To keep things interesting, this chapter also presents some related .NET variants. For example, at the same time you look at the label, list box, and domain controls, you will learn about the hyperlink label, checked list box, and rich date controls.

In Chapter 1 you took your first look at code serialization, which is the process Visual Studio uses to generate the code for your form as you configure your controls in the design environment. Code serialization captures all the properties of your controls and components, from the position of a button to the text of a label.

The ListView and TreeView are two of the most widespread and distinctive controls in modern application design. As far as controls go, they have it all—an attractive appearance, a flexible set of features, and the ability to condense a significant amount of information in one place. And thanks to Windows Explorer, most computer users already know how to use the ListView and TreeView to browse through data.

If you’ve programmed rich graphics in the pre-.NET world, odds are you used the GDI (Graphics Device Interface) API. The key idea behind GDI is that your code can paint graphics to different devices (printers, monitors, and video cards) using the same set of functions, without needing to understand the underlying hardware. In turn, Windows ensures compatibility with a wide range of clients, and (to a certain extent) makes use of optimizations that the hardware might provide. Unfortunately, mastering the GDI functions requires coding wizardry and hard work.

Many Windows applications are really just attractive window dressing over a relational database. This is especially true of the internal software that powers most businesses. The chief responsibility of this type of software is to allow highly structured data entry and to generate reports that summarize vast quantities of information.

Custom controls are a key theme in Windows Forms development. They can help you improve encapsulation, simplify your programming model, and make your user interface more “pluggable” (so that you can swap out a control and replace it with a completely different one without rewriting the rest of your application). Of course, custom controls have other benefits, including the way they can transform a generic window into a slick, modern interface with eye-catching graphics.

User controls allow you to build customized controls by combining the existing controls in the Windows Forms toolkit. Typically, a user control consists of a group of ordinary controls that are related in some way. For example, you might create a user control that models a simple record browser, combining navigation buttons with other display controls. Or, you could create a user control that wraps together related input fields and validators. The advantage is that you can build a user control in almost the same way as you build a full-fledged form.