Re: Tutorial/overview: object navigation

Keao Wright <keaow@...>

Thanks for the tutorial, I will read the rest of it later, but I understand how it works.

-----Original Message-----
From: <> On Behalf Of Raha Tehrani
Sent: Monday, December 24, 2018 10:29 AM
Subject: Re: [nvda] Tutorial/overview: object navigation

thanks a million Joseph.
merry Christmas as well.

On 12/24/18, Joseph Lee <> wrote:
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"
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.
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
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

* 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) 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).

* One finger flick right/left: next/previous control everywhere
(regardless of level).
* Two finger flick left/right: next/previous control on the same
* 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.



Join to automatically receive all group messages.