Re: Tutorial/overview: object navigation


Raha Tehrani
 

thanks a million Joseph.
merry Christmas as well.

On 12/24/18, Joseph Lee <joseph.lee22590@gmail.com> 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"
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.