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:
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):
And going one step further, using the street address example from the beginning:
For those who’d like to learn by examples, try:
Example 1: Notepad:
Example 2: Settings app (Windows 10 only):
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:
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.