Switch Access and Row-Column Scanning

A switch is a single binary input: one button, one puff of breath, one blink detected by a sensor. It carries one bit of information, on or off, pressed or released. A user who can operate only a switch cannot point, cannot type directly, and cannot press more than one key. Yet switch access lets such a user drive an entire interface, by trading time for input bandwidth: the machine offers choices one at a time, and the user’s single bit decides when to accept the current offer. The mechanism that does this is scanning.

Scanning as a timed offer

Scanning turns the interface into a sequence of highlighted candidates. The system highlights one item, waits a fixed interval, moves the highlight to the next item, and repeats. When the item the user wants is highlighted, the user presses the switch, and that item is selected. The fundamental trade is direct and quantifiable: with one switch, selecting the nth item in a list of N costs at most N scan intervals, whereas a pointer costs one movement. The switch user pays in time what the pointer user pays in dexterity.

The scan interval is the single most consequential parameter. It must be long enough for the user to perceive the highlight and react, but short enough that traversing a long list does not take minutes. Typical intervals sit in the range of roughly one to several seconds, and the system usually lets the user adjust it. A user with fast reaction but low endurance sets it short; a user with a long motor delay sets it long. Because the interval multiplies across every item in a list, halving it halves the worst-case selection time across the whole interface.

The highlight itself must be perceptible to the user’s remaining senses, which is not always vision. A scanning interface can move a visible focus rectangle for a user who can see it, or speak each candidate aloud for a user who cannot, or do both. The scan order is a linearization of what is really a two-dimensional screen, and the choice of order determines how long a given control takes to reach.

Row-column scanning reduces the wait

A linear scan of every control on a dense screen is slow: with fifty controls, reaching the last one costs fifty intervals. Row-column scanning restructures the problem into two phases. The system first scans the rows of the screen, or the major groups of controls, one at a time. The user selects a row with the switch. The system then scans the items within that row, and the user selects the item. The total cost is the row’s index plus the item’s index within the row, which for a screen laid out as R rows and C columns is at most R plus C intervals instead of R times C.

This is the same divide that makes a two-dimensional grid addressable with two one-dimensional scans, and it is why the screen layout matters enormously to switch users. A screen with ten rows of five items reaches any item in at most fifteen intervals under row-column scanning, but the same fifty items laid out as a single long list need fifty. The layout a sighted designer treats as cosmetic is a performance characteristic for the switch user.

Hierarchical scanning generalizes this recursively. Groups contain subgroups contain items, and the user drills down through the levels. The cost is the sum of the indices at each level rather than their product, which is why deep grouping pays off for large screens, at the cost of requiring the user to remember which group contains which item. There is a genuine trade between the number of levels and the memory load: more levels mean fewer intervals per selection but more decisions and more chances to descend the wrong branch.

Automatic scanning versus manual stepping

The system can advance the highlight automatically on a timer, or it can advance only when the user operates the switch. The two modes correspond to two ways of splitting the switch’s one bit between two jobs.

In automatic, or timed, scanning, the switch has one meaning: select. The system advances on its own clock. The advantage is that the user makes only one kind of decision and one kind of physical action. The disadvantage is that the clock is not negotiable: if the user needs longer, the system has moved on, and the user must wait for the next full cycle to come back around. This is the “miss and wait a whole lap” penalty.

In manual, or step, scanning, the user presses the switch once to advance and holds it, or presses a second distinct switch, to select. With a single switch the distinction is usually a press versus a press-and-hold, which requires timing the user must learn. Step scanning removes the arbitrary clock but demands twice as many physical actions and a way to express the two different intents through one input. Many systems offer both modes and let the user choose, because the two failure modes differ: timed scanning punishes slow reaction, step scanning punishes low endurance.

Interaction with the keyboard model

Switch access is usually implemented on top of the same focus model that keyboard access uses. Each selectable item in the scan order is a focusable element, and selecting it is equivalent to moving focus to it and activating it. This is why the WCAG keyboard-operability requirement is the foundation that switch access builds on: if a control cannot be reached and operated by a keyboard, no scanning system can reach it either, because scanning is a different way of driving the same focus machinery, not a separate parallel mechanism.

The link runs deeper for text entry. To type with a switch, the system presents an on-screen keyboard as a scannable grid, and the user scans rows and columns to pick each character. The cost of a single character is a full row-column traversal, so a word of five characters costs five traversals. Text entry by switch is therefore orders of magnitude slower than touch typing, and the systems that mitigate this use word prediction to let a few selections produce whole words. The prediction itself is a topic that belongs to a later article, but its necessity is a direct consequence of the per-character cost that scanning imposes.

Failure modes

The first failure is an item that is visible but not in the scan order, which happens when a control is rendered outside the keyboard focus order. It is reachable by pointer and invisible to the switch. The second is an interval too short for the user’s reaction, which produces the lap-around penalty repeatedly and can make the interface effectively unusable even though every control is technically reachable. The third is a scan order that does not match the visual layout, so the user watches the highlight jump in a pattern that contradicts where the controls appear; the row-column optimization only helps if the rows correspond to what the user perceives as rows.

Timing is the axis every other switch mechanism trades on. Debounce, dwell, and repeat filtering takes the opposite approach to time, but the scanning loop here is the reference point: it is the most general way to turn a single bit into full control, and every faster method is an optimization of it.