In movies and on TV, the main characters are typically an
exaggeration of the people you encounter in real life.
They’re more attractive, they react more quickly, and they
somehow always know exactly what to do. The same could
be said about the software they use.
This first struck me back in 1994 when watching the movie
Disclosure, starring Michael Douglas, Demi Moore, and an
email program that looks nothing like Microsoft Outlook!
Throughout the movie, we’re treated to various visual
features of the program: a spinning three-dimensional “e,”
messages that unfold when you open them and crumple
when you delete them, hints of inking support, and slick
animations when you print messages. (The email program
isn’t even the most unrealistic software in the movie. I’ll
just say “virtual reality database” and leave it at that.)
Usability issues aside, Hollywood has been telling us for a
long time that software in the real world isn’t as
compelling as it should be. You can probably think of
several examples on your own of TV shows and movies
with comically unrealistic software. But lately, real-world
software has been catching up to Hollywood’s standards!
You can already see it in traditional operating systems (yes,
even in Windows), on the web, and in software for devices
such as the iPhone, iPad, Zune, TiVo, Wii, Xbox, Windows
phones, and many more. Users have increasing expectations
for the experience of using software, and companies
are spending a great deal of time and money on user interfaces
that differentiate themselves from the competition.
This isn’t limited to consumer-facing software; even business
applications and internal tools can greatly benefit
from a polished user interface.
With higher demands placed on user interfaces, traditional software development
processes and technologies often fall short. Modern software usually needs to support
rapid iteration and major user interface changes throughout the process—whether such
changes are driven by professional graphic designers, developers with a knack for designing
user interfaces, or a boss who wants the product to be more “shiny” and animated.
For this to be successful, you need technology and tools that make it natural to separate
the user interface from the rest of the implementation as much as possible and to decouple
visual behavior from the underlying program logic. Developers should be able to
create a fully functional “ugly” application that designers can directly retheme without
requiring developers to translate their artwork. The Win32 style of programming, in
which controls directly contain code to paint and repaint themselves, makes rapid user
interface iteration far too difficult for most projects.
In 2006, Microsoft released a technology to help people create 21st-century software that
meets these high demands: Windows Presentation Foundation (WPF). With the release of
WPF 4 in 2010, the technology is better than ever at delivering amazing results for just
about any kind of software. Almost a decade after Tom Cruise helped popularize the idea
of multi-touch computer input in the movie Minority Report, and after successful multitouch
implementations in a variety of devices (most notably the iPhone), WPF 4 and
Windows 7 are bringing multi-touch to the masses. Hollywood better start coming up
with some fresh ideas!
A Look at the Past
The primary technologies behind many Windows-based user interfaces—the graphics
device interface (GDI) and USER subsystems—were introduced with Windows 1.0 in 1985.
That’s almost prehistoric in the world of technology! In the early 1990s, OpenGL (created
by Silicon Graphics) became a popular graphics library for doing advanced two-dimensional
(2D) and three-dimensional (3D) graphics on both Windows and non-Windows
systems. This was leveraged by people creating computer-aided design (CAD) programs,
scientific visualization programs, and games. DirectX, a Microsoft technology introduced
in 1995, provided a new high-performance alternative for 2D graphics, input, communication,
sound, and eventually 3D (introduced with DirectX 2 in 1996).
Over the years, many enhancements have been made to both GDI and DirectX. GDI+,
introduced in the Windows XP time frame, tried to improve upon GDI by adding support
for features such as alpha blending and gradient brushes. It ended up being slower than
GDI due to its complexity and lack of hardware acceleration. DirectX (which, by the way,
is the technology behind Xbox) continually comes out with new versions that push the
limits of what can be done with computer graphics. With the introduction of .NET and
managed code in 2002, developers were treated to a highly productive model for creating
Windows (and web) applications. In this world, Windows Forms (built on top of GDI+)
became the primary way a C#, Visual Basic, and (to a lesser degree) C++ developer started
to create new user interfaces on Windows. Windows Forms has been a successful and
productive technology, but it still has all the fundamental limitations of GDI+ and USER.
Starting with DirectX 9, Microsoft shipped a DirectX framework for managed code (much
like it shipped libraries specifically for Visual Basic in the past), which eventually was
supplanted by the XNA Framework. Although this enables C# developers to use DirectX
without most of the complications of .NET/COM interoperability, these managed frameworks
aren’t significantly easier to use than their unmanaged counterparts unless you’re
writing a game. (The XNA Framework makes writing a game easier because it includes
new libraries specifically for game development and works with compelling tools such as
the XNA Framework Content Pipeline and XNA Game Studio Express.)
So although you could have developed a Windows-based email program with the 3D
effects seen in Disclosure ever since the mid-1990s with non-GDI technologies (actually,
probably mixing DirectX or OpenGL with GDI), such technologies are rarely used in
mainstream Windows applications even more than a decade later. There are several
reasons for this: The hardware required to get a decent experience hasn’t been ubiquitous
until recently, it has been at least an order of magnitude harder to use alternative technologies,
and GDI-based experiences have been considered “good enough.”
Graphics hardware continues to get better and cheaper and consumer expectations
continue to rise, but until WPF, the difficulty of creating modern user experiences had not
been addressed. Some developers would take matters into their own hands to get coolerlooking
applications and controls on Windows. A simple example of this is using bitmaps
for buttons instead of using the standard button control. These types of customizations
can not only be expensive to develop, but they also often produce a flakier experience.
Such applications often aren’t as accessible as they should be, don’t handle high dots-perinch
(DPI) settings very well, and have other visual glitches.
Enter WPF
Microsoft recognized that something brand new was needed that escaped the limitations
of GDI+ and USER yet provided the kind of productivity that people enjoy with frameworks
like Windows Forms. And with the continual rise of cross-platform applications
based on HTML and JavaScript, Windows desperately needed a technology that’s as fun
and easy to use as these, yet with the power to exploit the capabilities of the local
computer. Windows Presentation Foundation (WPF) is the answer for software developers
and graphic designers who want to create modern user experiences without having to
master several difficult technologies. Although “Presentation” sounds like a lofty term for
what I would simply call a user interface, it’s probably more appropriate for describing the
higher level of visual polish that’s expected of today’s applications and the wide range of
functionality included in WPF!
The highlights of WPF include the following:
. Broad integration—Prior to WPF, a Windows developer who wanted to use 3D,
video, speech, and rich document viewing in addition to normal 2D graphics and
controls would have to learn several independent technologies with a number of
inconsistencies and attempt to blend them together without much built-in support.
But WPF covers all these areas with a consistent programming model as well as tight
integration when each type of media gets composited and rendered. You can apply
the same kind of effects consistently across different media types, and many of the
techniques you learn in one area apply to all the other areas.
. Resolution independence—Imagine a world in which moving to a higher resolution
or DPI setting doesn’t mean that everything gets smaller; instead, graphics and
text simply get crisper! Envision user interfaces that look reasonable on a small
netbook as well as on a 60-inch TV! WPF makes this easy and gives you the power
to shrink or enlarge elements on the screen independently from the screen’s resolution.
A lot of this is possible because of WPF’s emphasis on vector graphics.
. Hardware acceleration—WPF is built on Direct3D, so content in a WPF application—
whether 2D or 3D, graphics, or text—is converted to 3D triangles, textures,
and other Direct3D objects and then rendered by hardware. This means that WPF
applications get the benefits of hardware acceleration for smoother graphics and allaround
better performance (due to work being offloaded to graphics processing
units [GPUs] instead of central processor units [CPUs]). It also ensures that all WPF
applications (not just high-end games) receive benefits from new hardware and
drivers, whose advances typically focus on 3D capabilities. But WPF doesn’t require
high-end graphics hardware; it has a software rendering pipeline as well. This
enables features not yet supported by hardware, enables high-fidelity printing of
any content on the screen, and is used as a fallback mechanism when encountering
inadequate hardware resources (such as an outdated graphics card or even a highend
one that has simply run out of GPU resources such as video memory).
. Declarative programming—Declarative programming is not unique to WPF, as
Win16/Win32 programs have used declarative resource scripts to define the layout
of dialog boxes and menus for over 25 years. And .NET programs of all types often
leverage declarative custom attributes plus configuration and resource files based on
Extensible Markup Language (XML). But WPF takes declarative programming to the
next level with Extensible Application Markup Language (XAML; pronounced
“Zammel”). The combination of WPF and XAML is similar to using HTML to define
a user interface—but with an incredible range of expressiveness. This expressiveness
even extends beyond the bounds of user interfaces; WPF uses XAML as a document
format, a representation of 3D models, and more. The result is that graphic designers
are empowered to contribute directly to the look and feel of applications, as well
as some behavior for which you’d typically expect to have to write code. The next
chapter examines XAML in depth.
. Rich composition and customization—WPF controls can be composed in ways
never before seen. You can create a ComboBox filled with animated Buttons or a Menu
filled with live video clips! Although these particular customizations might sound
horrible, it’s important that you don’t have to write a bunch of code (or any code!)
to customize controls in ways that the control authors never imagined (unlike
owner-draw in prior technologies). Along the same lines, WPF makes it quite easy to
“skin” applications with radically different looks (covered in Chapter 14, “Styles,
Templates, Skins, and Themes”).In short, WPF aims to combine the best
attributes of systems such as DirectX
(3D and hardware acceleration),
Windows Forms (developer productivity),
Adobe Flash (powerful animation
support), and HTML (declarative
markup). With the help of this book, I
think you’ll find that WPF gives you
more productivity, power, and fun than
any other technology you’ve worked
with in the past!
