Tutorial/overview: object navigation


 

Hi all,

 

First, Merry Christmas (for those celebrating it).

 

The following tutorial/overview came from several requests on this forum regarding explanation of object navigation. Although I’ll try my best to go over things you need to know, there are some things you won’t find in this tutorial (either not important or I may have forgotten small details).

 

IMPORTAN: The below document does not replace user guide nor various tutorials on this subject. For a more complete overview (including some more examples), I recommend looking at Basic Training module from NV Access.

 

Let’s imagine a friend of yours invited you to a party (or have some drinks or a date, if you will). The friend tells you, “I live on a certain street in a certain neighborhood”. Once you get his or her street address, you type it into your computer (or a smartphone or ask Alexa for directions). When you look at the map your computer displays, you realize that your friend lives on the other side of town. You then get some directions and off you go.

 

While you were on your way, you took the wrong turn. The GPS you’re using tells you to turn back to the street you were before and continue straight. After five minutes of frustrations, you decide to follow what the GPS says, and after ten minutes of walking (or driving or flying, etc.), you arrive at your friend’s house. Thereupon your friend says, “hey, what took you so long?” You then say, “I took a wrong turn.”

 

Unless you know the town very well, you may have encountered situations like this: getting some directions, somehow getting lost, and you somehow get back on track. Or, you need to parse a slightly complicated street address and don’t know how to get there unless you look at landmarks.

 

It turns out there is a subtle application of what I just described: NVDA’s object navigation feature. You can use certain commands to explore what’s around you, and in some cases, access certain parts of programs you wouldn’t normally can with keyboard commands. For some of us used to a certain interaction technology, this may ring a bell, and I’ll explain that connection later in this overview.

 

First, a few basic definitions:

 

When you think of the word ‘object”, several things can come to your mind – perhaps things you can touch (like a desk), a goal (“… the object of the game …”), and many more interpretations. In computing, an object may either mean something you can see or interact with, or something defined in code coming to life (the latter strays into programming, so I won’t go there). For purposes of this overview, we can say that an “object” is something you can explore and interact with (a graphical control, if you will), and throughout this overview, you’ll see me refer to objects as “controls” – they are really the same thing.

 

Since objects are something we can explore and interact with (on screen, to be exact), there must be means of differentiating between all sorts of objects, with hundreds of them active at once (on screen, invisible, etc.). Each object or a control has a name (sometimes called a “label”) and the type of control (called a “role”). For example, a control that allows you to type something into it may have a name such as “document”, “file name”, “address”, and so on, with the control type being an edit window. A second control on the screen may look like a button with labels such as “OK”, “Cancel”, “Open”, and so on, with the type being a “button”. Still, another control may present a checkmark next to text that says, “don’t show me this message”, “ask before saving” and so on, with the control type being a “checkbox”. In addition to label and role, some controls have states such as “checked”, “selected”, and so on.

 

But if your computer only showed the three controls described above, it won’t be that exciting. In reality, a program you’re working with may include tens of hundreds of different controls, organized into what’s termed “hierarchy” or groupings. A control may include other controls inside, and the container control may itself be part of a larger group of related (or sometimes unrelated) controls. For example, suppose we open “save as” dialog in many programs (such as Notepad, Microsoft Word, etc.). The controls for file name (an edit field), a button to save the document, or a checkbox to not show file extensions may be grouped under a single toolbar. This toolbar in turn is housed inside the “Save as” dialog, with the dialog itself being home to additional larger groups of controls besides file name toolbar.

 

The relationship between the “save as” dialog, the file name toolbar, and controls inside this toolbar is sometimes termed “parent-child relationship”. The whole dialog is the “parent” of file name toolbar and other controls. The file name toolbar, a “child” of the dialog, is itself a parent of file name controls, with the controls termed “children”.

 

Another way to look at this relationship is that of an outline with different levels. For people taught to write an outline before writing anything (essays, speeches, plays, etc.), outlining helps us organize what we wish to say in writing. For example:

 

Level 1: a big idea

Level 2 (inside level 1): a smaller idea

Level 2: another smaller idea

Level 3 (inside second level 2): an example

Level 2: a third smaller idea

Level 1: second big idea

 

And so forth. Now let us transform the “save as” dialog into an outline:

 

Level 0: the app itself (Notepad, Word, etc.)

Level 1: Save as dialog

Level 2: File name toolbar

Level 3: file name edit field

Level 3: show extensions checkbox

Level 3: Save button

Level 2: file browser window

Level 3: files list

Level 3: folder navigation buttons

Level 1: Ok button

Level 1: Cancel button

 

Side note: later in this document, I’ll use a “camera lens” analogy when talking about object navigation commands.

 

So Joseph, where did “level 0” come from? Every application (except for a period when we had full screen Microsoft Store apps) and things it shows on screen are housed inside a host window (level 0). There is actually a “level minus 1”, and this is the shell window (the desktop area where all the action takes place throughout the screen).

 

In NVDA world, there is one special object NVDA likes to use: navigator. The navigator object is the control you (and sometimes, NvDA) wish to work with and explore. You can move system focus to it, you can ask NVDA to move to system focus, learn how much screen real estate the control takes (location), and for power users, find out what kind of control one is dealing with (developer info). In effect, when you use object navigation commands (see below), you’re moving the control of interest to different areas of an app (or to other programs).

 

Okay Joseph, how can I move through this “object outline”? This is done through object navigation commands (NVDA+Numpad keys on desktop layout, NVDA+Shift+arrows in laptop layout; for consistency, I’ll use “Numpad arrows” for desktop layout commands) as follows:

 

  • NVDA+Numpad 5 (NVDA+Shift+O in laptop layout): current control/object NVDA is looking at.
  • NVDA+Numpad right arrow/Numpad 6 (NVDA+Shift+Right arrow in laptop layout): next control at the same level.
  • NVDA+Numpad left arrow/Numpad 4 (NVDA+Shift+Left arrow in laptop layout): previous control at the same level.
  • NVDA+Numpad down arrow/Numpad 2 (NVDA+Shift+Down arrow in laptop layout): move down one level if there are controls and choose the first one (first child).
  • NVDA+Numpad up arrow/Numpad 8 (NVDA+Shift+Up arrow in laptop layout): move up one level (parent).

 

Or, if you are into photography or video production (creation/editing, etc.), you can think of it as a camera lens (or for audio gurus, where you place your microphone):

 

  • Current object: the focus of the camera.
  • Next or previous object: focusing on something else.
  • Child object: zoom in (narrow the focus of the camera to something).
  • Parent object: zoom out (expand camera focus to include other things besides the thing you were looking at).

 

And going one step further, using the street address example from the beginning:

 

  • Current control: where you are at.
  • Next/previous control: nearby street addresses or streets.
  • Child control: house/apartment/building, etc.
  • Parent: the town.

 

For those who’d like to learn by examples, try:

 

Example 1: Notepad:

  1. Open Notepad (the fastest way to open Notepad (or for that matter, any program or folder) is searching for it from Start menu/screen).
  2. Use object navigation commands to move around Notepad. For instance, when Notepad first opens, navigator object will be placed on the document window. Moving to the next object, you’ll find status bar (unless disabled), and moving to previous objects will let you explore system menu and application menu bar (not the menus themselves). As you move through next or previous controls. If NVDA says “no next” or “no previous”, then you’ve reached the end of group of controls for the current level.
  3. Try moving inside one of the controls (for example, move down one level from document window). If NVDA says, “no objects inside”, then you’ve reached the bottommost level.
  4. Move up to a parent control from document window. You’ll find yourself “looking” at Notepad window. Moving up some more, you’ll eventually hear NVDA say, “no containing object”, which means you’ve reached the topmost control.

 

Example 2: Settings app (Windows 10 only):

  1. Press Windows+I to open Settings.
  2. Go to System category (press Tab to move to categories first), then go to About item and press Enter.
  3. Move up one level (NVDA+Numpad up arrow/NVDA+Shift+Up arrow), then move to the next group of controls. You’ll find out various status for security, firewall and so on.
  4. When you meet a grouping such as “Device specifications” or “Windows specifications”, move one level down (NVDA+Numpad down arrow/NVDA+Shift+Down arrow) and explore the specifications for your device or Windows installation (after moving down, move to next (NVDA+Numpad right arrow/NVDA+Shift+Right arrow) or previous (NVDA+Numpad left arrow/NVDA+Shift+Left arrow) controls).
  5. After exploring a grouping, move up one level and explore other controls on screen (or another program if you wish).
  6. If you want, you can activate controls by pressing NVDA+Numpad enter/NVDA+Enter in laptop layout).

 

But wait a minute Joseph, all these commands sound familiar. If you are coming from (or currently using) any touch-based smartphone with built-in screen readers, you may have noticed that the commands described above are exactly the kind of technique you would (or taught to) use when navigating the touchscreen interface for the first time. In fact, NVDA’s object navigation commands for touchscreens were inspired by VoiceOver (iOS). Specifically:

 

  • One finger flick right/left: next/previous control everywhere (regardless of level).
  • Two finger flick left/right: next/previous control on the same level.
  • One finger flick up/down: move up/down one level.
  • One finger double tap: activate the control you’re on.

 

A very keen person may have noticed that, while practicing object navigation commands, NVDA would skip some controls. Why? Because some controls on screen are present for layout purposes, and NvDA will skip them if simple review mode is turned on (by default, it is on). If you wish to explore layout controls (and explore the whole object hierarchy), you need to turn off simple review mode (NVDA Settings/Review cursor/simple review mode).

 

Because the overview was meant for users, I didn’t go over additional commands related to objects. They can be found in the user guide (for some of them). Again if you wish to see more examples and slightly more in-depth explanations, I highly recommend getting Basic Training module for NVDA from NV Access (it is cheap and is more authoritative than this overview).

 

Hope this helps.

Cheers,

Joseph

Join nvda@nvda.groups.io to automatically receive all group messages.