Topics

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


molly the blind tech lover
 

Thanks for this tutorial.

 

From: nvda@nvda.groups.io <nvda@nvda.groups.io> On Behalf Of Joseph Lee
Sent: Monday, December 24, 2018 3:02 PM
To: nvda@nvda.groups.io
Subject: [nvda] 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


Raha Tehrani
 

thanks a million Joseph.
merry Christmas as well.

On 12/24/18, Joseph Lee <@joslee> 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





 

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

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

thanks a million Joseph.
merry Christmas as well.

On 12/24/18, Joseph Lee <@joslee> 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





David Moore
 

That was so awesome, Joseph!

What a great explanation!

I did not know the object navigation commands were based on from the Voice Over commands!

Have a very merry Christmas, Joseph, and thank you so much for all you do for us!

David Moore

 

                                                                                                                                                                                                                Sent from Mail for Windows 10

 

From: Joseph Lee
Sent: Monday, December 24, 2018 3:02 PM
To: nvda@nvda.groups.io
Subject: [nvda] 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

 


Hope Williamson <ladyhope@...>
 

This was pretty epic! I'm starting to get object navigation after using NVDA since 2013 lol.


David Mehler
 

Hello,

Thanks for this tutorial. The light bulb has come on! The various
analogies were quite helpful.

Thanks.
Dave.

On 12/25/18, Hope Williamson <ladyhope@...> wrote:
This was pretty epic! I'm starting to get object navigation after using NVDA
since 2013 lol.




Charles Adkins
 

sorry for such a dumb question, but where can I find this tutorial? Thank you

On Dec 26, 2018, at 1:07 PM, David Mehler <dave.mehler@...> wrote:

Hello,

Thanks for this tutorial. The light bulb has come on! The various
analogies were quite helpful.

Thanks.
Dave.


On 12/25/18, Hope Williamson <ladyhope@...> wrote:
This was pretty epic! I'm starting to get object navigation after using NVDA
since 2013 lol.





Fernando Apan
 

Good morning. I have the same question. thanks for your help.
Fernando Apan

Enviado desde mi iPhone

El 27 dic 2018, a las 5:40, Charles Adkins <cadkins6739@...> escribió:

sorry for such a dumb question, but where can I find this tutorial? Thank you
On Dec 26, 2018, at 1:07 PM, David Mehler <dave.mehler@...> wrote:

Hello,

Thanks for this tutorial. The light bulb has come on! The various
analogies were quite helpful.

Thanks.
Dave.


On 12/25/18, Hope Williamson <ladyhope@...> wrote:
This was pretty epic! I'm starting to get object navigation after using NVDA
since 2013 lol.






Antony Stone
 

The tutorial was posted on this list a few days ago.

https://nvda.groups.io/g/nvda/message/52675

Antony.

On Saturday 29 December 2018 at 13:00:59, Fernando Apan wrote:

Good morning. I have the same question. thanks for your help.
Fernando Apan

Enviado desde mi iPhone

El 27 dic 2018, a las 5:40, Charles Adkins escribió:

sorry for such a dumb question, but where can I find this tutorial? Thank
you

On Dec 26, 2018, at 1:07 PM, David Mehler wrote:

Hello,

Thanks for this tutorial. The light bulb has come on! The various
analogies were quite helpful.

Thanks.
Dave.

On 12/25/18, Hope Williamson wrote:
This was pretty epic! I'm starting to get object navigation after using
NVDA since 2013 lol.
--
Please apologise my errors, since I have a very small device.

Please reply to the list;
please *don't* CC me.