Category : Music and Digitized Voice
Archive   : TTDOC142.ZIP
Filename : CHAPT3.DOC

Output of file : CHAPT3.DOC contained in archive : TTDOC142.ZIP


This chapter describes the facilities that Tinytalk provides you with while
you're running an application: immediate output, keyboard echo, cursor
tracking, hot keys, the independent cursor, automatic pop-up window
reading, form filling and continuous document reading.

While discussing these facilities, we're sometimes going to need to talk
about settings. For example, keyboard echo can be set to read your
keystrokes as letters, words, or not at all. In the next chapter, we'll
discuss in detail how to change these settings, since changing them is
something that you do in review mode. If you find yourself getting lost in
a discussion of settings, skim over the section that's giving you trouble
and then come back to it after you've read the section in Chapter 4
regarding settings.


Tinytalk will automatically speak anything that the application program
puts on the screen using DOS or BIOS output. The utilities supplied with
DOS use this method of output, but most full-screen application programs
don't use it. Immediate output will pick up the DOS prompt, directory
listings, and anything that you display using the DOS "type" command, for

Some programs that use DOS or BIOS output will talk too much, so Tinytalk
provides you with several ways of suppressing this excess output. We'll
talk about one of them (timed shutup) later in this chapter, another one
(verbosity setting) in the next chapter when we go into detail about
settings, and yet another (silent windows) when we talk about how to set up
window definitions.


Tinytalk watches what you type at the keyboard and "echoes" your keystrokes
so that you know whether you really typed what you intended to type. Since
different people have different ideas of how much they want to hear,
Tinytalk lets you choose whether you want keystrokes to be echoed whenever
you type a single letter, only when you type a whole word, or not at all.
In addition, you can choose whether you want each keystroke to shut up any
speech that's still going out. You can choose what, if any, punctuation
keys you want to hear echoed, regardless of what punctuation symbols you
want to hear in other cases (for example, many people want to hear when
they've typed a comma, but don't want to hear commas when they're reading
existing text).

Tinytalk normally echoes only those keystrokes that generate printable
characters (letters, numbers, punctuation and spaces). Cursor-movement
keys cause Tinytalk to read whatever the cursor moves to (see below).
Function keys, modifier keys (shift, control and alt) and the ENTER key
normally don't get echoed at all. If you want, though, you can use
Tinytalk's key labelling feature (see Chapter 4, Section 8) to specify a
"label" that will be spoken when you press those keys.

You can set an option (see Chapter 4, Section 2) for Tinytalk to announce
changes in the state of the "locks"--caps lock, scroll lock and num lock.
If you turn this option on, Tinytalk will say "caps lock on" or "caps lock
off" whenever you press the Caps Lock key, for example.

Tinytalk provides a couple other facilities that are related to keyboard
echo. If you forget that you have Caps Lock turned on and start typing
regular text, Tinytalk will buzz the speaker if you hold down the shift key
and type a letter, alerting you that your text is going to come out in
reversed case (everything capitalized except the first word in a sentence).
You can also set a right margin bell that will ring when you type beyond a
certain column; you might want to do this if you were using a text editor
(such as the message editors on some on-line services) that didn't wrap

If you fill out printed forms by loading a blank form into a word processor
or editor and then filling in the blanks, you can activate Tinytalk's
"typeover alert" which will cause the speaker to beep when you're within
three characters of typing over existing text.


When you use cursor-movement keys, Tinytalk will track the cursor and read
the part of the screen it moves to. In many cases this will let you find
your context in a word processor or database program without having to go
into review mode. Tinytalk recognizes three kinds of cursor moves, based
on the key you use: Horizontal moves, vertical moves, and word moves.
Tinytalk performs an action (usually reading part of the screen) for each
kind of move; you can specify what these actions should be. Tinytalk also
tracks your use of the backspace and delete keys.


If you use the left or right arrow keys (or the Wordstar equivalents
control-s or control-d) or the home or end keys, Tinytalk will assume
you're moving horizontally. By default, Tinytalk will speak the character
that you move onto. There are several other choices for what to speak;
these will be discussed in Chapter 4, Section 2.


If you use the up or down arrow keys (or control-e or control-x), Tinytalk
will assume you're moving vertically. The default action is to speak the
entire line that you move to. As with horizontal moves, you can choose to
have other portions of the screen spoken.

In some applications, the tab and enter keys act as cursor movement keys
(moving between fields in a database record, for example). You can tell
Tinytalk to perform the vertical movement action when you press these keys.


If you use control-leftarrow or control-rightarrow (or the Wordstar
equivalents control-a or control-f), Tinytalk will read the entire word you
move onto.

Applications have different ideas about what a word is. For example, some
word processors treat the phrase "user-friendly software" as two words
while others treat it as three. Tinytalk needs to know which is which so
that it can read the appropriate amount ("user" or "user-friendly"); this
is the "word terminator" option that will be discussed in Chapter 4,
Section 2.


If you use the backspace or delete key, Tinytalk will try to speak the
character that got deleted. In most programs, the backspace key deletes
the character to the left of the cursor and moves the cursor left one
position; the delete key deletes the character the cursor is on and "pulls"
any text to the right of the cursor left one position. If you backspace
past a line boundary, Tinytalk may not be able to find the character that
got deleted.

If you use Control-Y, the command for deleting a line in many editors,
Tinytalk will read the next line.


If Tinytalk is reading a character at a time and comes across a graphic
character, it will announce it as either "corner" (if it's one of the box-
corner symbols), "linedraw" (if it's a line-drawing symbol other than a
corner) or "graphic" (if it's none of the above). Tinytalk will then read
the 3-digit ASCII code for the graphic character (there's an option you can
set to stop this if you aren't interested in the codes). You can define
your own names for graphic characters; see Chapter 4, Section 10.


Tinytalk will sometimes pause slightly before speaking when you move the
cursor. It has to do this because some applications move the cursor to an
intermediate location before putting it in its final position. For
example, some editors will briefly move the cursor to a status line. The
pause ensures that the right text will be read.


Hot keys are keystrokes that tell Tinytalk to do something when you're in
application mode. The key combinations have been chosen to be ones that
application programs are unlikely to use. If you want to change them, you
can use the "hotkey remapping" feature (see Chapter 4, Section 7). If an
application program needs to use one of these keystrokes, you can tell
Tinytalk to pass it through to the program.


Pressing the Alt key will stop whatever is being spoken and flush the
synthesizer's speech buffer.


Pressing Alt-slash will stop whatever is being spoken and also prevent any
further speech until either you press a key or five seconds go by with no
attempted output. You might use timed shutup if you're capturing text in a
terminal program; once the text starts coming, you press Alt-slash and
Tinytalk shuts up until the text stops. Tinytalk will beep to get your
attention once the output is finished. You can change the five-second


Pressing Alt-space will read the line under the cursor.


Pressing Alt-comma will read the word under the cursor (see the discussion
of word terminators in Section 3). If you press it a second time without
moving the cursor, the word will be spelled out. If you press it a third
time, the word will be spelled out phonetically ("able," "baker" etc.).


Pressing Alt-equal will read the character under the cursor. If you press
it a second time without moving the cursor, the character will be read
phonetically if it's a letter.


Pressing Alt-period will read the two lines above the current one.


Pressing Alt-left bracket will read the entire screen


If you're running an application like a word processor, where you can move
through a document using the downarrow key, you can have Tinytalk read you
the entire document. Pressing Alt-downarrow will cause Tinytalk to read
the current line and then "fake" a downarrow keypress to your application.
This will continue until you press the Alt key to shut speech up.

Speech synthesizers usually have a fair amount of buffering and can receive
characters faster than they can speak them. As a result, when you stop a
continuous read the cursor is likely to have moved well past the last thing
you heard. Some synthesizers have a feature called "indexing" which lets
the synthesizer tell Tinytalk whenever it finishes speaking a given line or
word. If your synthesizer supports indexing and you enable it (see chapter
4, section 2), Tinytalk will wait for the synthesizer to catch up before
faking the downarrow key, and will make sure that the cursor is in the
right place when you stop a continuous read. Tinytalk has no way of
knowing that it's reached the bottom of the document, so the last line will
be read over and over again until you press Alt.

By default, Tinytalk uses the downarrow key on the numeric keypad rather
than the extra downarrow key found on 101-key keyboards. This is necessary
because some laptops have keyboards that claim to be "extended" but don't
have all the extra keys. If you have a 101-key keyboard, you can remap
this to the separate downarrow key; see Chapter 4, Section 7.


Pressing Alt-minus will announce the row and column where the cursor is.


If you're using forms mode to fill out a data entry screen (see Section 7),
pressing Alt-backslash will re-read the prompt and field value for the
current field.


Pressing Alt-enter will put Tinytalk into review/control mode.


We'll be talking more about windows in the next chapter, but suffice it to
say that you can define 10 areas of the screen and give them numbers from 0
to 9 (you do this in review mode). In application mode, you can read any
of them by pressing Alt-0 through Alt-9.


Your synthesizer settings, Tinytalk mode settings, window definitions and
the like are called a configuration. Configurations will be discussed in
more detail in Chapter 4, Section 5. Since different programs (or
different parts of a program) often need different settings, Tinytalk lets
you keep 30 configurations in memory at one time; each of them has a
number, and you can also give them names. To switch to a new
configuration, press Alt-right bracket. Tinytalk will say "load config"
and then say the name or number of the first configuration (0). At this
point you have three options: you can enter a number and press ENTER, you
can type in the name of the configuration and press ENTER, or you can step
through the list of configurations by hitting the space bar until you hear
the name or number of the one you want. Pressing ENTER will pick the
configuration. If you choose to type in the configuration name, you don't
have to type in all the characters, just enough to let Tinytalk find it.
For example, if you had a configuration called "DBASE" you could just type
in "DB" (assuming you don't have any other configurations that begin with


Pressing Alt-semicolon will re-read the most-recently read automatic pop-up
window if it's still on the screen (see Section 6). If more than one
automatic pop-up window is still up, repeatedly pressing the key will read
each one in turn.


Pressing Alt-grave accent (the key usually located immediately to the left
of the "1" key) will force the next unit of text you read (line, word,
window, etc.) to be spelled out. For example, pressing Alt-grave accent
followed by Alt-space would spell out the current line.

Pressing Alt-grave accent twice in a row will cause everything to be
spelled out until you turn off "spell all" mode by pressing Alt-grave
accent again.


Pressing Alt-escape will make Tinytalk ignore the next keystroke. Use this
if your application program needs one of the above keystrokes.


In addition to Tinytalk's pre-defined hotkeys, you can define your own
hotkeys for changing Tinytalk's settings. For example, you might want to
turn case identification on and off from within an application program.
You could define Alt-C, for example, as a "menu shortcut" hotkey for doing
this; you'll see how in Chapter 4, Section 7.


Tinytalk provides several hotkeys which let you review parts of the screen
without having to go into review mode. Tinytalk maintains an "independent
cursor" which you can think of as a speech cursor separate from the system
cursor. For example, if you're editing a document and you want to go back
and check what you wrote a few lines above, you can move the independent
cursor up without losing your place in the document.

By default, the independent cursor stays put unless you use one of these
hotkeys to move it. However, you can set an option so that whenever the
system cursor moves, the independent cursor will follow it (see Chapter 4,
Section 2).

Most of the independent cursor keys are arranged in a "triplet" pattern.
The keys on the middle row move the cursor horizontally by character, the
keys on the top row move the cursor horizontally by word, and three keys
arranged vertically move the cursor up or down (you don't have to stick
with this arrangement; you can remap these keys like any other hotkeys).


Pressing Alt-j will move the independent cursor left, and alt-l will move
it right. They will always read a single character.


Pressing Alt-k will read the character under the independent cursor.
Repeats will work as they do for the "read current character" hotkey. Note
that this key is between the character left and right keys.


Pressing Alt-u or Alt-o will move the independent cursor left or right one
word. Note that these are directly above the character left and right


Pressing Alt-i will read the word the independent cursor is on. Repeats
will work as they do for the "read current word" hotkey. Note that this
key is between the word left and word right keys, and above the read
character key.

Pressing Alt-y or alt-n will move the independent cursor up or down one
line. They will read whatever you have defined for vertical cursor


Pressing Alt-h will read the line the independent cursor is on. Note that
this key is between the line up and line down keys.


Pressing Alt-Home will move the independent cursor to the first character
of the line it's on; pressing Alt-End will move it to the last character.
In either case, the character will be read. If you have a 101-key
keyboard, the cursorpad Home and End keys are the ones used by default for
these commands.


Pressing Alt-PgUp will move the independent cursor to the top left corner
of the screen; pressing Alt-PgDn will move it to the bottom right corner.
In either case, the line will be read. Once again, these are the cursorpad
keys rather than the extra keys.


Pressing Alt-p will announce the row and column of the independent cursor.


Pressing Alt-t will put the independent cursor where the system cursor is.


Pressing Alt-r will attempt to put the system cursor where the independent
cursor is. Tinytalk will send "fake" cursor movement keys to the
application to move the application cursor into place. For this to work,
the cursor keys must move the cursor in the expected directions and the
independent cursor must be in a place where the application can put it
(most word processors won't let you move the cursor to a status line, for
example). Some database programs will move the cursor horizontally in
response to vertical movement keys, and some editors won't let you put the
cursor on the bottom line of text. If Tinytalk can't get the cursor into
position, it will say "failed."


Ordinarily the independent cursor can be moved anywhere on the screen.
Sometimes you might want to restrict it to moving within a portion of the
screen; you might be using an application that puts some text in the middle
of the screen, surrounded by irrelevant information. As you might have
guessed, you do this by using defined windows. Pressing Alt-apostrophe
will cause Tinytalk to prompt you for a window. Selecting 0 through 9 will
put the independent cursor on the top left corner of that window and will
restrict the independent cursor to its boundaries. Pressing Alt-t (track
system cursor) will restore the independent cursor to the full screen.


Tinytalk can automatically detect most pop-up windows and read them without
you having to do any setup. If you have automatic pop-up detection turned
on and an application program draws a box around an area of the screen,
Tinytalk will read the text in the box and try to guess whether the box
contains a lightbar menu. If it does, moving the cursor will read off the
choices as they're highlighted.

When a pop-up window doesn't have a lightbar menu, you have three choices
as to what to do when the text in the window changes. You can have
Tinytalk do nothing (often the safest choice if the window has a clock
display or something else that constantly changes), read it over again
automatically, or beep on subsequent changes. The beep option is
especially useful for doing file transfers in communication programs, which
usually pop up a window at the beginning of the transfer and periodically
update it with a progress report.

Applications often display more than one boxed window at a time. If a
newer window overlaps an older one (common in pull-down menu systems),
Tinytalk will suppress re-reading of the older one until the newer one
disappears. The older window will be re-read as if it just popped up. If
several non-overlapping windows pop up at the same time, they will all be
read. Tinytalk has rules for how to read "child" windows (windows that are
completely inside other windows). If the child window appears at the same
time as it's "parent" window, only the parent will be read. If a child
window changes or has a lightbar menu, only the child will be read.

In determining whether or not a window has a lightbar menu, Tinytalk
normally looks only for changes in background attributes. If you need to
detect lightbar menus that use only foreground color changes, you can
change a setting (see Chapter ?, Section ?) to force Tinytalk to look at
both foreground and background attributes; however, this increases the
likelihood that the guess will be wrong. Many applications allow you to
set the colors used in lightbar menus; if you're using one of these, make
sure you set the "highlight" color to a different background color than the
"normal" color.

There's a momentary delay between the time a pop-up window appears on the
screen and the time Tinytalk reads it. This is necessary because some
programs use a visual effect called "exploding windows" where a window is
repeatedly drawn and erased, getting bigger each time.


Many programs, especially database applications, treat part of the screen
as a form to be filled out, with text prompts followed by highlighted entry
fields. The cursor, tab and enter keys move the cursor between these
fields. There are often several fields on the same line. Tinytalk offers
a "forms mode" to make these data entry screens speak naturally.
When forms mode is on, Tinytalk watches the cursor to see if it's moving
between fields. When the cursor moves to a new field, Tinytalk will read
any non-highlighted text before the field and then read the field itself.
This lets you hear each field prompt (as well as any default value in the
field) in the correct order. If there are multiple fields on the line, you
will hear only the one you're working on.

When you activate forms mode, you need to tell Tinytalk which end of the
field your application puts the cursor on. For example, programs created
with DBase put the cursor at the beginning (left end) of the field, whereas
Paradox applications put the cursor at the end (right). Tinytalk needs to
know which is which so it can figure out which is the prompt and which is
the field.

As mentioned earlier, you can re-read the field you're on using the "read
current field" hotkey (Alt-backslash).


Users who have learning disabilities often find that their reading
comprehension and writing quality improve when they can both see and hear
the text they're working with. Tinytalk facilitates this by providing a
text highlighting option. When this is turned on, Tinytalk will visually
highlight each word or line is it's spoken.

Tinytalk will highlight all text read in response to cursor movements,
independent cursor commands, review commands, window-reading commands,
continuous reading and automatic window reading. It won't highlight text
in lightbar menus (since the application will be doing its own
highlighting) or BIOS text. See Chapter 4, section 2 for more details.