Designing with Windows Presentation Foundation
Windows Presentation Foundation (WPF) is a user interface development environment that provides access to more advanced visuals, such as interfaces that incorporate documents, media, two- and three-dimensional graphics, animations, Web-like characteristics, and more. For a general overview, see Introducing Windows Presentation Foundation.
When used appropriately, the WPF in Windows can help you create an engaging, productive experience your target users will love. If misused, it could lead to programs that are frustrating and difficult to use. The guidelines that follow will help you understand the difference, and use this technology appropriately.
While the Windows User Experience Guidelines (or "UX Guide") were written specifically for Windows, nearly all of these guidelines apply to programs using WPF as well. However, this shouldn't be a surprise—the primary goal of these guidelines is to establish a high-quality, consistent baseline for all Windows-based applications, no matter how they are implemented.
While Windows Presentation Foundation gives you the flexibility to create a broad range of user experiences—from traditional Microsoft Windows to highly customized—you should never feel that using WPF obligates you to abandon the Windows look and feel. In fact, WPF gives you the traditional Windows look and feel by default, and includes advanced versions of the Aero and Windows XP themes. Regardless of how your program looks, your WPF-based program can benefit from powerful capabilities such as a rich application model, dynamic layout, and data binding.
Among other things, WPF makes it possible to completely change your program's look to match your corporate branding, or to use a custom interaction model to give your program a "unique" feel. You can even customize a drop-down list to look like a slider! But when are such changes from a traditional experience genuinely appropriate?
WPF offers an exciting set of advanced capabilities. With this step forward comes the desire to create better—or "cooler"—software. All too often these attempts don't seem to hit the mark. To understand why, let's make a distinction between what makes a program cool and what doesn't.
A program really is "cool" when it has:
- Features appropriate for the program and its target users.
- Aesthetically pleasing look and feel, often in a subtle way.
- Improved usability and flow, without harming performance.
- A lasting good impression—it's just as enjoyable the 100th time as the first.
A program fails to be "cool" when it has:
- Use or abuse of a technology just because it can.
- Features that detract from usability, flow, or performance.
- Is in the user's face, constantly drawing unnecessary attention to itself.
- A fleeting good impression. It might have been fun the first time, but the enjoyment wears off quickly.
Just as in a painter's palette there are no intrinsically good or bad colors, there aren't intrinsically good or bad capabilities in WPF. Rather, for specific programs and their target users, we believe there are appropriate designs and inappropriate designs. Truly cool programs use technology because they should, not because they can.
To achieve coolness, start not by thinking about what the technology can do, but by focusing on what your target users really need. Before adding that "cool" feature, make sure there are clear user scenarios that support it.
Designing great software boils down to a series of decisions about what functionality you present to the user and how it is presented. For great software, those decisions must be made based on the goals of the software and its intended audience. A good design decision must be made for the benefit of the target users—never for yourself, or because the platform made it easy.
To understand your target users, make a list of their knowledge, their goals, and their preferences. You should understand their motivation in using your program, how often they will use it, and their work environment. Also, consider creating user personas, which are fictitious people designed from real data, intended to represent classes of real users.
The type of program you are creating also factors into your decisions. Here are the characteristics of some common program types:
- Target users: Knowledge workers.
- Goals: Productivity, reduce costs.
- Usage: Used often for long periods of time, possibly all day.
- User expectation: Familiarity, consistency, immediate productivity.
- Appropriate use of WPF: Help users get their work done productively.
- Examples: Microsoft Office, line-of-business applications.
- Target users: Consumers.
- Goals: For users, perform a specific set of tasks. For ISVs, to sell well.
- Usage: Used occasionally (perhaps weekly) for short periods of time.
- User expectation: An enjoyable experience that performs targeted tasks well.
- Appropriate use of WPF: Help users perform tasks; some branding.
- Examples: Multimedia reference apps, media players and tools, security tools.
- Target users: Consumers.
- Goals: Entertainment.
- Usage: Used occasionally for moderate periods of time.
- User expectation: An immersive experience.
- Appropriate use of WPF: Custom look, possibly custom interaction.
- Examples: Simple games, online games.
- Target users: Walkup users.
- Goals: Perform a specific task, get information.
- Usage: Once.
- User expectation: Perform task immediately, without learning anything.
- Appropriate use of WPF: Custom look, possibly custom interaction (touch, drag-and-drop), animations for visual explanations.
- Examples: Airport kiosks, museum kiosks.
IT Pro utilities
- Target users: Developed and used by IT professionals.
- Goals: Perform a task or obtain information quickly.
- Usage: As needed, typically for short periods of time.
- User expectation: Get the job done.
- Appropriate use of WPF: Help IT pro develop and test UIs quickly.
Some design ideas are good simply because they improve usability. Here are some common ways to improve usability with WPF:
- Model the real world. You can use custom visuals and interactions to make specific controls look and behave like their real-world counterparts. This technique is best used when users are familiar with the real-world object, and the real-world approach is the best, most efficient way to perform the task. For example, simple utilities like calculators just work better when they model their real-world counterparts.
- Show instead of explain. You can use animations and transitions to show relationships, causes, and effects. This technique is best used to provide information that would otherwise require text to explain or might be missed by users. For example, a book for young children could animate page turns to show how the controls work. Normal page turns would be harder for a young child to understand.
- Improve affordance.Affordance is a property of an object that suggests how the object is used (as opposed to using a label to explain it). You can use custom control visuals and animations to suggest how nonstandard controls are used.
- Use natural mapping. Natural mapping is a clear relationship between what the user wants to do and how to do it. You can use custom appearances and interactions to create natural mappings when the standard common controls won't do.
- Reduce knowledge. You can use custom interactions to limit the number of ways to perform an operation and the amount of knowledge required to perform a task.
- Improve feedback. You can use custom control visuals and animations to give feedback to show that something is being done correctly or incorrectly, or to show progress. For example, the Address bar in Windows Internet Explorer shows the progress for loading the page in the background.
- Make objects easier to interact with. Fitts' law states that the effort required to click on a target is proportional to its distance and inversely proportional to its size. For example, you can use animations to make objects larger when the pointer is near and smaller when the pointer is far. Doing so makes the objects easier to click. It also allows you to use screen space more efficiently, by making objects normally smaller.
- Focus. You can use rich layout and custom visuals to emphasize screen elements that are crucial to the task, and to de-emphasize secondary elements.
Now, let's put all these factors together. Should you use that transition effect idea you have for your program? Don't start by thinking about the fact that you can do it, or that it's really clever or easy to do. Those factors don't matter to your target users.
Instead, consider the usability of the feature itself. Does the feature benefit from the transition, perhaps because it clarifies an object's source or destination? How quick is the transition? Would overall program performance be harmed?
Consider your target users. Do they perform the task only occasionally and do their time constraints make that transition annoying? And finally, are such transitions appropriate for your program type? Simple transitions that aid in usability are appropriate for nearly all programs, whereas complex animations that don't aid in usability are—at best—suitable for programs intended to entertain users, such as games.
By asking yourself the right questions and giving thoughtful answers, you can use the power of the WPF appropriately to create a great user experience.
At Microsoft, the four tenets of design are that software should be useful, usable, desirable, and feasible. We believe that this is the right list, and that it's in the right order. Appropriately applied, Windows Presentation Foundation helps you better satisfy all four of these tenets.
As a general rule, application theming is appropriate for programs where the overall experience is more important than productivity. Highly themed applications should be immersive, yet only used for short periods of time. This rule makes theming suitable for games and kiosk applications, but unsuitable for productivity applications.
However, theming isn't an all-or-nothing deal. You can use customized control visuals for specific controls to give them a custom look. For branded consumer applications, you can use simple, subtle application theming to create a sense of brand.
- Use the standard Windows theme for productivity applications.
- Consider using subtle, brand-related application theming for consumer applications.
- Games and kiosk applications may use heavy application theming to achieve an immersive experience.
- Theme selectively, subtly, and with restraint. Deciding to use a theme doesn't mean that you have to theme everything or make everything appear radically different.
- If your program models real-world objects, consider using custom visuals to make controls look and behave like those real-world objects, but only if that real-world approach offers the best, most efficient way to perform tasks. (This is a very high bar.)
- Consider using theming to emphasize screen elements that are crucial to the task, and de-emphasize elements that are secondary.
- Have professional graphic artists create your themes. Successful themes require an understanding of color, focus, contrast, texture, and use of dimension.
- Don't theme window non-client areas unless the application is an immersive experience, run at full screen with no other programs.
- When in doubt, don't theme.
In a competitive marketplace, companies brand their products to help differentiate them from the competition. However, having your programs look and act weird doesn't make for a strong brand identity. Rather, your goal should be to create a program with character—a product that stands out while fitting in.
Ultimately, users are most impressed by high quality programs that serve their purpose well. They are unlikely to be impressed by branding that is distracting, or harms usability or performance.
- Choose good product names and logos, which are the foundation of your brand. Theming isn't.
- Consider having a link to your product's Web site from its About box and Help file. A product Web site is a far more effective way to sell your brand and support your product than branding within the product itself.
- If you must brand, consider low-impact branding:
- Small, subtle company or product logos, placed out of workflow.
- Small, subtle theme color changes that suggest your company or product colors.
- Don't use branding that is distracting or harms usability or performance.
- Don't use custom controls for branding. Rather, use custom controls when necessary to create a special immersive experience or when special functionality is needed.
- Don't use animated splash screens for branding. In fact, don't use any splash screens for programs that load quickly.
- Don't use animated logos.
- Don't plaster company or product logos on every UI surface.
- Limit product and company logos to at most two different surfaces, such as the main window or home page and the About box.
- Limit product and company logos to at most twice on any single surface.
- Limit product and company names to at most three times on any surface.
For more guidelines and examples, see Branding.
The Windows common controls are familiar, consistent, flexible, and accessible. They require no learning from experienced Windows users and they are the right choice in almost all situations.
That said, common controls work best for the usage patterns they were designed for. For example, before the slider control became standard, scroll bars were sometimes used instead. But scroll bars are intended for scrolling documents, not choosing from a continuous range of values. Before the standard slider control, it was a good idea to use a custom control for this interaction.
- Use custom controls for unusual behaviors that aren't supported by the common controls.
- Ensure custom controls support system metrics and colors and respect all user changes to these settings.
- Ensure custom controls conform to the Windows Accessibility guidelines.
- Don't assign nonstandard behaviors to the common controls. Use standard behaviors if you can, and custom controls only if you must.
- Don't underestimate the work required to use custom controls correctly.
- Use 3-D graphics to help users visualize, examine, and interact with three-dimensional objects, charts, and graphics.
- Make sure there are clear user scenarios that support the need for 3-D graphics features.
- Don't use 3-D graphics just because you can.
There are five basic types of animations:
- Illustration animations communicate information visually instead of verbally.
- Effect animations create interactions to model their real-world counterparts.
- Relationship animations show relationships between objects (where objects come from, went to).
- Transition animations show major UI state changes.
- Feedback animations show that something is being done correctly or incorrectly, or show processing progress.
The human eye is sensitive to motion, especially peripheral motion. If you use animation to draw attention to something, make sure that attention is well deserved and worthy of interrupting the user's train of thought.
Animations don't have to demand attention to be successful. In fact, many successful animations are so natural that users aren't even aware of them.
- Use illustration animations that have a single interpretation. They have little value if confusing.
- Show one thing at a time to avoid overwhelming users.
- Play at the optimal speed—not so fast they are difficult to understand, but not so slow they are tedious to watch.
- Gradually increase the speed of repeated animations. Viewers will already be familiar with the animation, so increasing speed slowly will feel right.
- Use timing to emphasize importance, such as slowing down for important parts.
- Use effect animations for objects that the user is currently interacting with. Such animations aren't distracting because the user is already focused on the object.
- Minimize use of effect animations that show status. Make sure:
- They have real value by providing additional information users can actually use. Examples include transient status changes and emergencies.
- They are subtle.
- They are short in duration and therefore not running most of the time.
- They can be turned off.
- Keep effect animations low-key so they don't draw too much attention to themselves. Avoid movement or use small movements, but prefer fades and changes in overlays.
- Must start or end with the selected object. Don't show relationships between objects the user isn't currently interacting with.
- Must complete within a half-second or less.
- Use to show relationships between states. Animating state changes makes them easier to understand and appear smoother.
- Make sure transitions have natural mappings. For example, an opening window transition should be upward and expand; a closing window transition should be downward and contract.
- Must complete within a half-second or less.
- Must have clearly identifiable completion and failure states.
- Must stop showing progress when the underlying process isn't making progress.
- Don't use animations that affect performance noticeably. Consider performance over slow network connections or when many objects are involved.
- Don't draw attention to things that aren't worthy of attention.
With WPF, you can use progressive disclosure to show or hide additional information. Progressive disclosure promotes simplicity by focusing on the essential, yet revealing additional detail as needed.
Progressive disclosure controls are usually displayed without direct labels that describe their behavior, so users must be able to do the following based solely on the control's appearance:
- Recognize that the control provides progressive disclosure.
- Determine if the current state is expanded or collapsed.
- Determine if additional information, options, or commands are needed to perform the task.
- Determine how to restore the original state, if desired.
While users can determine the above by trial and error, try to make such experimentation unnecessary.
- Make sure the progressive disclosure mechanism is visible at all times.
- Use the appropriate glyph. Use double or single chevrons for surfaces that slide open to show the remaining items in hidden content.
- Point the glyph in the right direction. Chevrons point in the direction where the action will occur.
- Don't depend upon mouse hover effects to reveal progressive disclosure.
With WPF, you can use direct manipulation to let users interact directly with objects using their mouse, instead of indirectly with the keyboard, dialog boxes, or menus.
Direct manipulation is a natural way to perform many tasks. It is easy to learn, and convenient to use. But there are many challenges, the most important being to prevent accidental manipulation of important data.
- Make direct manipulation visible by:
- Changing the pointer to a hand on mouseover.
- Showing drag handles on object selection.
- Showing movement when an object is dragged, then show appropriate drop targets. Also, clearly show when an object is successfully dropped or when the drop is cancelled.
- Showing an in-place text box on double selection for renaming.
- Showing most useful properties with tooltips.
- Prevent accidental manipulation by:
- Locking by default objects that are crucial or likely to be manipulated accidentally. Provide a way to unlock in the object's context menu.
- Providing an obvious way to undo accidental manipulations.
- Make direct manipulation accessible by always providing alternatives.
- Don't overuse direct manipulation by providing it where there is very little value. Overuse can lead to a UI so fragile that users are reluctant to interact with it.
You have the option of hosting your WPF-based program in a browser.
- Host your program in the browser to navigate from a Web page to your program.
- Don't host your program in the browser when:
- It is used to edit rich content (for example, a word processor).
- It requires multiple windows.
- It is a background task that would be broken or interrupted if users were to navigate away (for example, a media player).