Discrete and Contiguous Selection

Users generally select data objects, not verbs, which are operations on objects. When you invoke a verb (in other words, a command), you may do it with the same type of click action you used to select the data; however, commands are rarely presented as objects that possess a selection state. Selectable objects are typically those that can be operated upon, and that means data. The basic variants of selection, then, depend on the basic variants of selectable data, and there are two broad categories of data.

Some programs represent data as distinct visual objects that can be manipulated independently of other objects. The icons on the desktop and graphic objects in draw programs are examples. These objects are also selected independently of each other. They are discrete data, and selection of them is discrete selection.

Discrete data is not necessarily homogeneous, and discrete selection is not necessarily contiguous.

Conversely, some programs represent their data as a matrix of many little contiguous pieces of data. The text in a word processor or the cells in a spreadsheet are made up of hundreds or thousands of similar little objects that together form a coherent whole. These objects are often selected in contiguous groups, and so we call them contiguous data and selection within them contiguous selection.

Both contiguous selection and discrete selection support single-click selection and click-and-drag selection. Single-clicking selects the smallest possible discrete amount and clicking and dragging selects some larger quantity, but there are other significant differences.

There is a natural order to the text in a word processor's document—it consists of contiguous data. Scrambling the order of the letters destroys the sense of the document. The characters flow from the beginning to the end in a meaningful continuum and selecting a word or paragraph makes sense in the context of the data, whereas random, disconnected selections are generally meaningless. Although it is theoretically possible to allow a discontiguous selection—several disconnected paragraphs, for example—the user's task of visualizing the selections and avoiding inadvertent, unwanted operations on them is more trouble than it is worth. Generally, if contiguous data can be scrolled off-screen, it shouldn't be discontiguously selectable.

Discrete data, on the other hand, has no inherent order, like peas on your plate; the order in which you select and eat them is immaterial. In a drawing program, where various graphic objects reside on the screen, the objects are independent. No relationship is integral to their meaning, and even the z-order, the order in which they overlay each other on the screen, is only significant if they directly overlay each other. Scrambling the order of the objects might have no effect whatsoever on the collective image (again, except where objects overlay each other). Because there is no inherent order in these objects, contiguous selection has no meaning in this context, and each object is selected discretely.

Most drawing programs offer a grouping facility that allows two or more discrete objects to be logically grouped together to form a single, new discrete object. That group object now behaves as though it were a single discrete object regardless of the number of component pieces it contains.

Of course, you can always select more than one discrete object, but it remains a series of independent selections rather than a subset of ordered data.

Mutual Exclusion

Typically, when a selection is made, any previous selection is unmade. This behavior is called mutual exclusion, as the selection of one excludes the selection of the other. Typically, the user clicks on an object and it becomes selected. That object remains selected until the user selects something else. Mutual exclusion is the rule in both discrete and contiguous selection.

Some discrete systems allow a selected object to be deselected by clicking on it a second, canceling time. This can lead to a curious condition in which nothing at all is selected, and there is no insertion point. You must decide whether this condition is appropriate for your application.

Additive Selection

Mutual exclusion is necessary in contiguous selection because the user cannot see or know what effect his actions will have if his selections can readily be scrolled off the screen. Imagine being able to select several independent paragraphs of text in a long document. It might be useful, but it isn't easily controllable. Scrolling, not the contiguous selection, creates the problem, but most programs that manage contiguous data are scrollable.

However, if mutual exclusion is turned off in discrete selection, the user can select many independent objects by clicking on them sequentially, in what is called additive selection. A list box, for example, can allow the user to make as many selections as desired. An entry is then deselected by clicking it a second time. After the user has selected the desired objects, the terminating verb acts on them collectively.

Most discrete-selection systems implement mutual exclusion by default and allow additive selection only by using a meta-key. The Shift meta-key is used most frequently for this; the Ctrl key is also frequently used. In a draw program, for example, after you've clicked to select one graphical object, you typically can add another one to your selection by Shift-clicking.

Contiguous selection systems generally should not allow additive selection because of the control issues discussed previously (one could, however, imagine an interface with an overview display that might make additive selections manageable). However, contiguous-selection systems do need to enable their single allowable selection to be extended, and again, meta-keys are used. Unfortunately, there is little consensus regarding whether it should be the Ctrl or the Shift key that performs this role. In Word, the Shift key causes everything between the initial selection and the Shift-click to be selected. It is easy to find programs with similar additive selection functions that have made different choices of meta-key variations. There is little practical difference between choices, so this is an area where following the market leader is best because it offers the user the small-but-real advantage of consistency.

Some list boxes, as well as the file views in Windows (both examples of discrete data), do something a bit strange with additive selection. They use the Ctrl key to implement "normal" discrete additive selection; but then they use the Shift key to extend the selection, as if it were contiguous, not discrete data. In most cases this mapping simply adds to confusion, because it conflicts with the common idiom for discrete additive selection. There are also few times that someone would want to select, say, three adjacent items in a list box simply because they are adjacent, which is really the purpose of the contiguous selection extension idiom that is being misapplied here. There's a bit more argument for this idiom in file views, but group selection (see the next section) handles this almost equally well. The Macintosh uses the more typical (and more appropriate) mapping of Shift-click to discontiguously add to the selection in file views, which adds to the cognitive overhead of switching between the Mac and Windows, if like the authors, you work on both systems.

Insertion and Replacement

As we've established, selection indicates on which data the next function will operate. If that next function is a write command, the incoming data (keystrokes or a PASTE command) writes onto the selected object. In discrete selection, one or more discrete objects are selected, and the incoming data is handed to the selected discrete objects, which process the data in their own ways. This may cause a replacement action, where the incoming data replaces the selected object. Alternatively, the selected object may treat the incoming data as fodder for some standard function. In PowerPoint, for example, when a shape is selected, incoming keystrokes result in a text annotation of the selected shape.

In contiguous selection, however, the incoming data always replaces the currently selected data. When you type in a word processor or text entry box, you replace what is selected with what you are typing. Contiguous selection exhibits a unique quirk: The selection can simply indicate a location between two elements of contiguous data, rather than any particular element of the data. This in-between place is called the insertion point.

In a word processor, the caret (usually a dark, blinking, vertical line indicating where the next character will go) indicates a position between two characters in the text, without actually selecting either one of them. By pointing and clicking anywhere else, you can easily move the caret, but if you drag to extend the selection, the caret disappears and is replaced by the contiguous selection of text.

Another way to think of the insertion point is as a null selection. By definition, typing into a selection replaces that selection with the new characters, but if the selection is null, the new characters replace nothing; they are merely inserted. In other words, insertion is the trivial case of replacement.

Spreadsheets also use contiguous selection but implement it somewhat differently than word processors. The selection is contiguous because the cells form a contiguous matrix of data, but there is no concept of selecting the space between two cells. In the spreadsheet, a single-click will select exactly one whole cell. There is currently no concept of an insertion point in a spreadsheet, although the design possibilities are intriguing (that is, select the line between the top and bottom of two vertically adjacent cells and start typing to insert a row and fill a new cell in a single action).

A blend of these two idioms is possible as well. In PowerPoint's slide-sorter view, insertion-point selection is allowed, but single slides can be selected, too. If you click on a slide, that slide is selected, but if you click in between two slides, a blinking insertion-point caret is placed there.

If a program allows an insertion point, objects must be selected by clicking and dragging. To select even a single character in a word processor, the mouse must be dragged across it. This means that the user will be doing quite a bit of clicking and dragging in the normal course of using the program, with the side effect that any drag-and-drop idiom will be more difficult to express. You can see this in Word, where dragging and dropping text involves first a click-and-drag operation to make the selection, then another mouse move back into the selection to click and drag again for the actual move. To do the same thing, Excel makes you find a special pliant zone (only a pixel or two wide) on the border of the selected cell. To move a discrete selection, the user must click and drag on the object in a single motion.

To relieve the click-and-drag burden of selection in word processors, other direct manipulation shortcuts are also implemented, like double-clicking to select a word.

Group Selection

The click-and-drag operation is also the basis for group selection. For contiguous data, it means "extend the selection" from the mouse-down point to the mouse-up point. This can also be modified with meta-keys. In Word, for example, Ctrl-click selects a complete sentence, so a Ctrl-drag extends the selection sentence-by-sentence. Sovereign applications should rightly enrich their interaction with these sorts of variants as appropriate. Experienced users will eventually come to memorize and use them, as long as the variants are manually simple.

In a collection of discrete objects, the click-and-drag operation generally begins a drag-and-drop move. If the mouse button is clicked in an area between objects, rather than on any specific object, it has a special meaning. It creates a drag rectangle, shown in Figure 22-1.

Figure 22-1: When the cursor is not on any particular object at mouse-down time, the click-and-drag operation normally creates a drag rectangle that selects any object wholly enclosed by it when the mouse button is released. This is a familiar idiom to users of drawing programs and many word processors. This example is taken from Windows XP, selecting files displayed within a file folder. The rectangle has been dragged from lower right to upper left.

A drag rectangle is a dynamically sizable rectangle whose upper-left corner is the mouse-down point and whose lower-right corner is the mouse-up point. When the mouse button is released, any and all objects enclosed within the drag rectangle are selected as a group.