ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/MISC/HANDICAP/HOTDOTS3.ZIP/MAN2.TXT

Text File | 1991-05-04 | 60.1 KB | 1,252 lines

                     Section 6: Braille Translation

     In most of this section we discuss translation from print into
braille (forward translation). In the very last part of the section we
discuss translation from braille into print (back translation).

                  What translation into Braille means

     Translating a file into braille means taking an inkprint file and
making a braille copy. A grade 2 braille file contains the ASCII
characters which create grade 2 braille on a braille device. When you
examine a braille file on the screen or print it to an inkprint printer,
you see the ASCII representation for each braille character. For
example, the word think comes out as ?9k. The th in an inkprint file
becomes a braille "th" sign in the braille file, represented in ASCII as
a question mark. The letter combination in in an inkprint file becomes
the "in" sign in the braille file, represented in ASCII as the digit 9.

     When you View a file (option 6), the right side of the screen shows
a guide to "ASCII braille" (which braille cells the ASCII characters
represent). The same information is found in the file ASCIIBRL.TXT on
the Hot Dots manual disk.

              Three ways to translate a File into Braille

     There are three ways to translate a file using Hot Dots 3.0. You
can use the DOTS menu, you can use a batch file, or you can use the
G2FWD program at the command line.

Translation from the DOTS Menu

     Type DOTS to get to the menu. Enter 2 followed by <enter> to get to
the translator. You are prompted for an input file and an output file.
Always use the extension .BRL for the output file (to tell the formatter
to format for braille output).

Translation from a batch file

     We supply two batch files that include translation from print to
braille. DOTS1234 <file name> <word processor type> <output device>
takes a file through all four steps (importation, translation,
formatting, and output). DOTS234 <file name> <output device> takes an
existing HD$ file and performs three steps (translation, formatting, and
output).

Translation at the Command Line

     The program that does braille translation is called G2FWD. To
translate a file from the command line, enter G2FWD <input file> <output
file> <enter>. If you give the output file the extension .BRL, it will
receive braille formatting by default in the formatting step which
follows.

                           Quick Experiments

     Use CON (console) for the input file and output file to input at
the keyboard and output to the screen (for quick experiments). Press
<enter> to translate a line, and press <control-Z> <enter> to leave the
translator. In the same way, you can also quickly check the results of
other Hot Dots commands, without creating any temporary files.

              Special Handling: Carriage Returns, Dashes,
            Discretionary Line Breaks, and Accented Letters

     The Print to braille translator turns each carriage return/linefeed
into a space. Therefore, if you want to force a hard return in the
braille output, use an indicator like ( $l ) in the .HD$ file.

     The Print to braille translator turns space, hyphen, space into two
hyphens (with no spaces) in the braille file.

     The translator also places the discretionary line break character
next to hyphens and dashes. This character is ASCII 30, which appears on
the screen as a solid triangle pointing up (block up arrow). The
formatter interprets this character as a signal to move to a new line if
the rest of the word does not fit on the current line. The translator
places this after a hyphen (dots 3-6) and before and after a dash (dots
3-6, 3-6).

     The "extended ASCII" system includes symbols for accented letters.
For these symbols, the Print to braille translator generates dot 4
followed by the base letter. For example, for ASCII 130 (e acute), the
translator creates dot 4 followed by e; for ASCII 144 (capital E acute),
it generates dot 6, dot 4, e. The translator also lets you to create the
special braille cells for accented letters used in foreign language
textbooks (discussed later in this Section in the list of "Other
Translation Codes").

            Translating Nonliterary Punctuation into Braille

     Some punctuation marks, such as the backslash, are not covered by
the grade two rules. These are especially common in text about
computers. Furthermore, punctuation marks which are covered by the grade
2 rules are often used in a position not covered by the grade two rules.
When the Print to braille translator encounters these punctuation marks,
it generates a letter sign (dots 5-6) followed by the CBC symbol for
that character. There are a few exceptions. For the less than sign and
greater than sign, the translator creates dot 4 followed by the CBC
symbol. For comma, semicolon, and period in a nonliterary context, the
translator generates a letter sign followed by the usual grade two
symbol. For a punctuation mark which has a literary (grade two)
translation, you can force the regular translation (grade two) by
placing @r (at-sign r) before the character in the inkprint file. You
can also force the $ub display translation $uf (nonliterary) by placing
@d (at-sign d) before the character.

           Translator Codes for Print to Braille Translation

     There may be times when you want to control the behavior of the
translator. Hot Dots offers a rich supply of specialized codes to
control the action of the translator. All the translator codes start
with an at-sign (@).

Translation Modes

     The Print to braille translator has 4 separate modes. These are
grade two (also known as literary mode), grade one, no translation, and
British mode. The translator starts out in grade two translation. This
produces standard American, contracted (abbreviated) braille. Grade one
translation handles numbers, punctuation, and capitalization as in grade
two, but there are no contractions. With no translation, the print text
is not changed. The characters in the inkprint file are left unchanged
in the braille file. No translation is designed for instances where you
enter the braille directly. Do not confuse "no translation" with grade
one. Ordinary text brailled with "no translation" (sometimes called MIT
computer braille) has nonliterary numbers and punctuation and does not
show capitalization. Finally, British translation mode in Hot Dots
suppresses the use of the capitalization indicator (dot 6). If you turn
on grade one translation while British translation is on, you get
British grade one (no contractions and no capitalization indicators).

     Each code for changing the translation mode consists of three
characters: an at-sign, a lowercase letter, and a space. These three
characters disappear in the braille file, leaving no space. To change
translation modes between words, leaving a space in the braille file,
place a space before the at-sign code in the inkprint original. Here are
the codes for these translation modes:

@l <space> -- literary translation mode (grade two)

@o <space> -- grade one translation mode (when entered from British
     translation mode, does not restore capitalization indicators)

@n <space> -- no translation mode

@b <space> -- British translation mode (no capitalization indicators)

     Make sure you include the final space in these commands. You can
change translation modes inside a word by leaving out the space before
the at-sign, but you still need a space after the code letter. Don't
worry, the Hot Dots translator will take out the space.

     The following data entry gives the word "think" in grade one in the
middle of a sentence in grade two: So therefore, I @o think @l you are
wrong.

Other Translation Codes

     Here is the list of other translation codes. All of them start with
an at-sign (@). Some of them work only if you are in grade one
translation mode.

@a -- accent Acute. Place this after the letter being accented. Use only
     in grade one translation mode.

@g -- accent grave. Place this after the letter being accented. Use only
     in grade one translation mode.

@, -- accent cedilla. Place this after the letter being accented. Use
     only in grade one translation mode.

@" -- accent diaeresis or umlaut. Place this after the letter being
     accented. Use only in grade one translation mode.

@^ -- accent circumflex. Place this after the letter being accented. Use
     only in grade one translation mode.

@s -- Spanish accent. Place this after the letter being accented. Use
     only in grade one translation mode.

@? -- Spanish question mark, regular or up-side-down).

@e -- diphthong with e. Use only in grade one translation mode. Place
     this after the letter being accented.

@` -- generic accent for this letter (put dot 4 in front of it). Place
     the command before the letter.

@; -- force a letter sign here.

@p -- prevent a letter sign.

@i -- inert sequence. To alter translation, place @i between letters
     that you do not want contracted. You can also put @i between other
     characters that you don't want the translator to find next to each
     other. For example, the combination space, hyphen, space becomes
     two hyphens (a braille dash) surrounded by the "discretionary line
     break character." f you do not want this, place @i next to the
     hyphen. As another example, when the translator finds a hyphen
     followed by a letter, it places a discretionary line break
     character after the hyphen. If there is a hyphen where you don't
     want the line broken (as in stammering), place @i after the hyphen.

@f -- force a character. The next character is passed on in the
     translation.

@t -- transcriber mark.

@d -- display punctuation with letter sign. Hot Dots places a letter
     sign in front of non-traditional punctuation (i.e., potentially
     confusing when read in grade 2 braille). An @d in front of
     punctuation forces this special display.

@r -- regular punctuation. place this before punctuation if you want the
     traditional grade two version (no matter how confusing it is).

@' -- regular apostrophe (dot 3, not a single quote).

@o' -- open single quote.

@c' -- close single quote.

@o" -- open double quote.

@c" -- close double quote.

@o- -- opening Spanish conversation sign.

@c- -- closing Spanish conversation sign.

@@ -- at-sign.

Underlining and Italics

     When the file file from your word processor calls for italics,
underlining, or other kinds of emphasis, the file importation program
encloses the material between $$ub and $$uf. To the Hot Dots inkprint
formatter, the $$ub means "underline begin" and the $$uf means
"underline finish". When you print the inkprint file with Hot Dots, the
enclosed words are underlined.

     Underlining in inkprint is indicated in braille with the italics
indicator. The translator looks for the underlining commands and inserts
the correct indicators for braille italics. In an underlined passage of
three or fewer words, the single italics indicator, dots 4-6, precedes
each word. In an underlined passage of four or more words, the double
italics indicator, two cells of dots 4-6, precedes the first word, and a
single italics indicator precedes the last word.

            Report any Irregularities in Braille Translation

     Please report any translation errors you may encounter when using
Hot Dots. At Raised Dot Computing, we strive towards the elusive goal of
a perfect braille translator. You can assist us by reporting any
glitches you encounter.

     From time to time, Raised Dot may offer discounts on future
purchases to those who alert us to a glitch that we were previously
unaware of. To qualify, all reports must be in writing. Contact Raised
Dot Computing for more information about discount offers and
restrictions which may apply.

     Raised Dot Computing will supply to any registered user, upon
request, a description of all known Print to braille translation errors
in Hot Dots 3.0.

                          The Back Translator

     The Back Translator is a poor cousin to the forward translator.
While most Hot Dots users concentrate on translating inkprint into
braille, a few hardy souls want to go in the other direction. Perhaps
you accidentally deleted an inkprint file for which you have a braille
copy. Perhaps you write in grade two on your VersaBraille and you want
an inkprint copy. Whatever your motivation, you will find the Hot Dots
back translator to be excellent and virtually error free.

Two Ways to Translate a File from Braille into Inkprint

     There are two ways to translate a file from braille to print using
Hot Dots 3.0. You can use the DOTS menu, or you can use the G2BACK
program at the command line.

     Type DOTS to get to the Hot Dots main menu. Enter 7 followed by
<enter> to get to the back translator. You are prompted for an input
file and an output file.

     The program that does back translation is called G2BACK. To
translate a file from the command line, enter G2BACK <input file>
<output file> <enter>.

Improving the Back Translation

     The back translator response to the two translation codes @n
<space> for no back translation and @l <space> for literary back
translation (translation from grade two). When material is enclosed
between @n <space> and @l <space>, it is not affected at all by the back
translator. If a passage in grade two might confuse the back translator,
you can use MIT computer braille instead and enclose it between @n
<space> and @l <space>.

     The at-sign is dot 4 on a braille device. But be careful. Dot 4 on
your braille device can also be saved as the accent grave character. You
may need to issue a command on your braille device to make the dot 4
uppercase. In addition, you need to make sure that the letters n and l
in these codes are lowercase. To avoid worrying about this, you may want
to perform Global search and replace before back translation to replace
the accent character with the at-sign and the uppercase letters N and L
with the lowercase letters. The case of characters is not relevant for
any other function of the back translator.

     One troublesome area is unusual punctuation, or punctuation used in
a way not usually seen in normal text. One example is a period inside a
word (as in an MS-DOS filename). If you just use a dropped d, the back
translator creates dd inside the word. Instead, put a letter sign (dots
5-6) before the dropped d. When the back translator sees the letter
sign, dropped d combination, it creates a period in the inkprint file.
Please note: you only need the letter sign when you want to use the
period in a way that would confuse the translator.

     Two other handy codes are letter sign dropped a for comma and
letter sign dropped b for semicolon. For other punctuation marks, you
can use letter sign followed by the CBC representation. For example, you
can use letter sign followed by "st" sign for a slash; letter sign
followed by "ou" sign for a backslash; letter sign, dots 4-5-6, "ou"
sign for a vertical bar; and letter sign followed by the "ch" sign for
an asterisk. The less than sign and greater than sign are exceptions.
Use dot 4 followed by "gh" sign for the less than sign and dot 4
followed by the "ar" sign for the greater than sign. These braille
symbols are also created by the forward translator.

     When you are in doubt, you can use CON as the input file and output
file to back translate individual lines from the keyboard.

Processing a File After Back Translation

     After you have used the back translator to create an inkprint file,
you may want to check it over and edit it. However, you may need to add
carriage returns before you can load it into your word processor. You
can do that with the batch file DIRTY. Just type DIRTY <file name>
<enter> to divide the text into lines of reasonable length and store the
results in the same file. Then, before you run the formatter, remove the
carriage returns with the batch file CLEAN. Type CLEAN <file name>
<enter>, and the same file has the carriage returns removed.

                         Section 7: Formatting

                                Overview

     This section discusses how to control what your text looks like
when you send it out to a printer. After translation and before output,
you need to format your text. Formatting takes a source file that
contains encoded format information (dollar sign format commands) and
creates an output file which is the character-for-character image of the
actual hardcopy pages.

     When you import a file, the importation system places formatting
commands in the Hot Dots .HD$ file. If you want to, you can use your
word processor on the .HD$ file to modify the text or the format
commands. The usual point at which to modify your text for braille
output is after file importation but before translation, formatting, and
output.

                    Braille vs. Inkprint Formatting

     Hot Dots can format text for either braille or inkprint output.
Some format instructions (for paragraphs, page numbering, and
underlining, for example) behave differently when formatted for braille
or for inkprint output. Because the major focus of Hot Dots is braille,
the formatter's default style is braille formatting, unless the carriage
width is over 45. When you establish a carriage width over 45, the
default style is inkprint formatting. When you format a file with the
.BRL extension, the formatter performs braille style formatting (even if
the carriage width is over 45). To force the mode to inkprint or to
braille, use the FTEXT command at the command line with a slash I
(inkprint) or slash B (braille) switch. These switches have the final
say (see Section 10 for details).

                           New Line Commands

     There are four format commands which force a new line. These are as
follows:

$p -- New paragraph symbol.

$l -- New line symbol (just like a carriage return)

$s -- Skip line symbol, same as a paragraph symbol only with an extra
     blank line

$f -- Form feed (new output page)

     Each of these needs a space before it and a space after it. The
paragraph symbol is very flexible. Depending on the previous commands, a
paragraph can vary the indent and the number of blank lines between
paragraphs. For inkprint formatting, the default is two carriage returns
(one blank line) and five spaces. For braille formatting, the default is
one carriage return (no blank line) and 2 spaces.

                      Three ways to Format a File

     There are three ways to format a file with Hot Dots 3.0. You can
use the DOTS menu, you can use a batch file, or you can use the FTEXT
program at the command line.

Formatting from the DOTS Menu

     Type DOTS to get to the menu. Enter 3 followed by <enter> to get to
the formatter. You are prompted for carriage width and form length and
then for an input file and an output file.

Formatting from a Batch File

     We supply two batch files that perform formatting. DOTS1234 <file
name> <word processor type> <output device> takes a file through all
four steps (importation, translation, formatting, and output). DOTS234
<base name> <output device> takes the existing file <base name>.HD$ and
performs three steps (translation, formatting, and output).

From the Command Line

     The program that does formatting at the command line is called
FTEXT. To format a file at the command line, enter FTEXT <input file>
<output file> <enter>. Several switches (slash codes listed on the
command line) are available to establish carriage width, form length,
and braille or print formatting (see Section 10 for details).

                     Dollar Dollar Format Commands

     Most of the format commands start with two dollar signs. Hot Dots
recognizes format commands only when they're entered according to
specific rules. Every $$ command must be preceded and followed by a
space or carriage return. All letters in format commands must be
lowercase. For example, $$np starts page numbering; $$NP just prints two
dollar signs and uppercase NP in your text. Most format commands are
mnemonic; the letters in the command represent the command's function.
Some format commands contain numbers; numbers always follow letters. In
these descriptions, we use #, the number sign, in place of a specific
numeric value.

     When you enter format commands in your text, they appear on screen.
When you format material, the format commands perform their function and
the dollar sign commands do not show up in the formatted text.

     The formatter executes some commands differently when you're
formatting for print than when you're formatting for braille; details of
these differences are covered in the descriptions of individual
commands.

                            Format Commands

     These commands must be preceded and followed by a space or carriage
return. Command letters must be lowercase; when you use braille data
entry, use computer braille for numbers.

$$a# -- advance to line # where # ranges from current line to form
     length. Example: $$a# forces a series of new lines until the next
     material begins on the 8th line.

$$c <space> -- center text in current output line plus all subsequent
     output lines until next command which forces a new line. Use the
     command $$c before text you want to center. At the bottom of a
     page, $$c moves to the next page, to avoid separating a centered
     heading from the text which follows. Compare with $$ve.

$$cx -- centering extended: center all lines until next left margin
     command.

$$d -- reset everything except carriage width and form length to the
     default: clear tabs and margins, clear headers and footers, single
     line spacing, paragraph indent and line spacing as appropriate for
     print or braille format.

( $f ) -- immediately move to new page; form feed format indicator (four
     keystrokes: space, dollar sign, lowercase f, space). Compare with $
     $vn.

$$f# -- set form length (lines per page) to # lines; clears all commands
     that affect a specific line number (such as page numbering or
     running heads). If you use the $$f# command at all, use it at the
     beginning of a file. Otherwise, you would have to reenter all
     page-oriented commands that you still wanted. See the separate
     heading on page size.

$$h -- center and underline current output line and all subsequent
     output lines up to next ( $p ) or ( $s ). Underlines inkprint only;
     does not create italics indicators in braille. Actually, any forced
     new line stops the centering; ( $p ), ( $s ), or $$uf stops the
     underlining.

$$i# -- indent each paragraph to start in absolute position # on the
     line. This command affects subsequent paragraph indicators ( $p )
     and ( $s ). The default is $$i5 for print format, $$i2 for braille
     format. (Note to those who have used Hot Dots before version 3.0,
     BEX, or BRAILLE-EDIT: $$i# now refers to absolute position #; in
     those other programs it is relative to the left margin.)

$$i+# -- indent each paragraph # cells to the right of the current left
     margin.

$$i-# -- outdent each paragraph # cells to the left of the current left
     margin.

$$j -- move to the soft margin indent position. See the entry for $$ms#.

( $l ) -- new line format indicator (four keystrokes: space, dollar
     sign, lowercase l, space).

$$l# (lowercase l, not digit 1) -- line spacing for soft <CR>s and
     explicit hard ( $l ) indicators. Default is $$l1 (single spacing)
     for print and braille. Use $$l2 for double spacing, $$l3 for triple
     spacing. Use single spacing in braille, except in some materials
     for young children.

$$ml# -- set left margin at absolute position #; command letters are
     lowercase m, lowercase l. Default is $$ml0 for print and braille
     format. Use this command to change the position of the left margin.
     The new left margin takes effect at the start of the next line. For
     predictable results, use $$ml# just before forcing a new line with
     ( $l ), ( $p ), etc. The characters set aside for the left margin
     use up some of the carriage width. For example, with a carriage
     width of 40 and a left margin of 4, there is room for a maximum of
     36 characters per line (positions 0 through 3 are set aside as left
     margin, and positions 4 through 39 are available).

$$ml+# -- increase left margin by # spaces; move left margin #
     characters to the right of the current left margin.

$$ml-# -- decrease left margin by # spaces; move left margin #
     characters to the left of the current left margin.

$$ml* -- set left margin at current character position on the output
     line.

$$mr# -- set right margin # characters from the maximum carriage width;
     default is $$mr0. Use this command to change the position of the
     right margin. The new right margin takes effect immediately. It is
     a good idea to use $$mr# right after forcing a new line with ( $l
     ), ( $p ), etc. $$mr# uses up # positions at the right of the
     carriage width. With a carriage width of 40 and $$mr4 in effect,
     positions 36 through 39 are set aside as right margin.

$$mr+# -- increase right margin by # spaces; move right margin #
     characters to the left of the current right margin.

$$mr-# -- decrease right margin by # spaces; move right margin #
     characters to the right of the current right margin.

$$ms# -- soft margin indent of #: at soft returns indent # characters to
     the right of the left margin. Default is $$ms0.

$$ms+# -- increase the soft margin indent by # characters.

$$ms-# -- decrease the soft margin indent by # characters.

$$np -- place page numbers on all pages, as appropriate for print or
     braille format, beginning with page 1. In braille, places grade two
     number in upper right (after at least three spaces). In print,
     centers page number on bottom line and forces next-to-last line to
     be blank.

$$n# -- set next output page number to #; use after a page numbering
     command like $$np. By itself, $$np starts page numbering with 1.
     Place $$n# after $$np to begin with page #. For example, to begin
     page numbering with page 14, use $$np $$n14.

( $p ) -- paragraph indicator (four keystrokes: space, dollar sign,
     lowercase p, space). When the formatter encounters a paragraph
     indicator, it generates carriage returns to move down and spaces to
     indent to the proper position. You can control the number of
     carriage returns with $$s# and the number of spaces with $$i#.
     Default for print paragraphs is $$s2 $$i5; default for braille
     paragraphs is $$s1 $$i2.

$$p# -- place text at absolute character position # on the output line.
     If there was already text there, the new text overwrites it.

$$p+# -- place subsequent text # characters to right of current
     character position on the output line.

$$p-# -- place subsequent text # characters to left of current character
     position on the output line, which may overwrite existing
     characters in output line.

$$r -- place output lines flush against the right margin. Affects
     current output line and subsequent output lines up to the next new
     line forced with ( $l ), ( $p ), etc.

$$s# -- paragraph line spacing: tells formatter to generate # <CR>s for
     each subsequent paragraph indicator ( $p ). Defaults are $$s2 for
     print and $$s1 for braille.

$$tc -- clear all tab stops. See the separate heading on tabs.

$$t# -- set a tab stop at absolute character position #. See the
     separate heading on tabs.

$$t* -- establish a tab stop at the current character position on the
     output line.

$$t+# -- establish a tab stop # characters to the right of the current
     character position on the output line.

$$t-# -- establish a tab stop # characters to the left of the current
     character position on the output line.

$$ <space> -- advance to next tab stop (four keystrokes: space, dollar
     sign, dollar sign, space). See the separate heading on tabs.

$$ub -- underline begin (underlines inkprint only. Signals braille
     translator to place italics indicators. When three or fewer words
     are to be emphasized, the translator places a single cell of dots
     4-6 before each word. When four or more words are to be emphasized,
     the translator places two cells of dots 4-6 before the first word
     and one cell of dots 4-6 before the last word.

$$uf -- underline finish (for inkprint). Signals braille translator to
     finish placing italics indicators. See previous entry.

$$va -- place braille page numbers in lower right corner (after at least
     three spaces).

$$vb -- place braille page numbers in upper right corner (after at least
     three spaces). Same as $$np for braille formatting.

$$vd# -- place line of dropped c cells (dots 2-5) on line # on every
     page. These lines are useful for folding braille letters.

$$ve -- unconditional centering: like $$c <space> but does not refuse to
     center on the bottom line.

$$vf -- interpret current output line as running footer to place on
     bottom line of all output pages; begin and end footer definition
     with ( $p ), ( $l ), or ( $s ).

$$vg -- modify print or braille page numbering to lowercase Roman
     numerals; maximum page number of xc (90); use after page numbering
     command. In braille formatting, $$np $$vg gives Roman numeral page
     numbers in upper right corner (for preliminary pages in "literary
     format").

$$vh# -- interpret current output line as running header to place on
     line # of every output page; begin and end header definition with $
     p ), ( $l ), or ( $s ). Maximum number of headers is four; line 1
     plus three other lines. The text of your running head can contain
     almost anything. You can use other commands, like $$c, $$h, $
     $r, or $$p# to format the text of the running head. However, you
     must make sure that the running head is short enough to fit on a
     single line. In braille formatting, use page numbering command $$np
     before $$vh1 to get page numbers and running head on line 1. In the
     text of the running head, you can use tilde (~) to stand for the
     sequential page number; most useful in inkprint formatting. Here's
     an example. Let's say you want the words "Section 7" to appear
     centered on every page. Enter: $$vh1 $$c Section 7 $p (notice the
     paragraph indicator to finish off the running head).

$$vk -- "kram" following "word" to end of line. Useful in tables of
     contents and menus. See entry for $$vrx.

$$vl# -- move to a new output page if the current output page has fewer
     than # lines remaining (counting the current output line).

$$vln -- clear table mode established by $$vlt (see next entry).

$$vlt -- table mode: do not place text on any line with a page number.
     In textbook format, keeps text off of top and bottom lines.

$$vn -- move to new output page unless that creates a blank page. Acts
     like ( $f ) except when it occurs at the top of an output page.

$$vo# -- make line # ordinary: clear any command affecting the line
     which # references. Use $$vo1 to undo a running head and top line
     page numbering. When # begins with minus sign, count up from the
     bottom line. $$vo-0 refers to bottom line; use to undo running
     footer and bottom line page numbering.

$$vp [word] -- in textbook format, make the following word, shown here
     as [word], the current print page indicator. For example, when $$vt
     is in effect, use $$vp 38 to start print page 38; tells the
     formatter to place print page indicators for print page 38. The
     word after $$vp does not have to be a number. It can be a Roman
     numeral, a hyphenated number, etc.

$$vrx -- repeat any single character, shown here as X, across the output
     line. In braille format, $$vr"$$vk [word] places braille guide dots
     leading up to a word at end of line, shown here as [word]; use with
     a right margin in effect ($$mr6 is recommended). Useful in braille
     tables of contents and menus.

$$vs# -- skip line # on every output page. Handy for creating a blank
     line after a running head or before a running footer. Use $$vs2 to
     skip line 2 (useful if line 1 has running head). When # begins with
     a minus sign, count up from the bottom line. Use $$vs-1 to skip the
     next to last line on each page (useful if bottom line has running
     footer).

$$vt -- begin textbook format (print page indicators in upper right,
     braille page numbers in lower right, line of dashes to start new
     print page in the middle of a braille page).

$$vyx -- place single character prefix, shown here as x, in front of the
     braille page number.

$$vy= (equal sign after the y) -- clear prefix character for braille
     page number.

$$vz -- if on line 2 after a running head, move down to line 3. Use in a
     heading to prevent it from occurring on line 2 after a running
     head.

$$w# -- set carriage width to # characters, clears margins. See separate
     heading on page size.

                                  Tabs

     You can make tabs using Hot Dots formatting commands, but be aware
that they work differently than tabs on a typewriter or in a WYSIWYG
text editor. Here's an overview of the differences. No tabs are set when
you start editing a file; you must establish each tab stop individually.
You can't clear just one tab stop; you must clear them all at once. You
can't use the Tab key on your keyboard to move to a tab stop in Hot
Dots.

     The command to advance to the next tab stop is four keystrokes:
space, dollar sign, dollar sign, space ( $$). To advance two tab stops,
enter this command twice in a row: ( $$ $$). Notice that the trailing
space of the first command serves as the leading space of the next.

     Use $$t#, $$t*, $$t+#, or $$t-# to set a tab stop. For example, $
$t10 sets a tab stop at position 10 on the line.

     The tab stops are completely independent of the margins. When you
enter ( $$) in your text, it positions the text that follows it at the
next tab stop on that line. When there are no tab stops after the
current position on the line, the formatter simply executes the ( $$)
command as a single space. For example, you set tab stops at positions
15 and 30, and type this text:
$l He made $$ $10,000, but she made over $$ $20,000.
The first two words occupy positions 0 through 6; so the $10,000 is
placed at the tab stop at position 15. The words following $10,000
occupy positions 24 through 40; so the second ( $$) command is simply
executed as a single space. The formatter can't put it at the tab stop
at position 30.

     Only $$t#, with # an unsigned number, sets a tab stop at an
absolute position on the line. The asterisk character and numbers with a
plus or minus sign before them set tabs relative to your current
position on the line.

     When you're working in a non-WYSIWYG editor, it's not always
obvious just where your "current position" is. When you want to place a
tab stop at a specific position on the line, use a plain number, or use
the tab command shortly after a format indicator and count spaces. The
asterisk character can be handy, however, when you want to make several
things line up, but you don't care exactly where on the line it happens.
Use the asterisk to tell the formatter, "Set a tab stop right here."

     You can set tabs to the left or right of the current position by
using a number that begins with a plus or minus sign. Enter $$t+10 to
set a tab stop ten positions to the right of the current position. Enter
$$t-5 to set a tab stop five positions to the left of the current
position.

                               Page Size

     When Hot Dots formats your text, it uses a default carriage width
and form length unless it is instructed otherwise. The default carriage
width is 40, and the default form length is 25 (reasonable values for
brailling on 11.5 by 11 inch paper). There are several ways to change
the carriage width and form length in Hot Dots. Here is the list:

Answer carriage width and form length prompts in option 3 - Format in
     the Main Menu.

When you use the command FTEXT, use the switches /w=# to set carriage
     width # and /f=# to set form length #. You can use this when you
     are working directly at the command line or when you are writing or
     modifying a batch file.

Set the environmental variables HDWIDTH and HDLENGTH. The command SET
     HDWIDTH=# sets the carriage width to #; SET HDLENGTH=# sets the
     form length to #. You can put these commands in your AUTOEXEC.BAT
     file. These environmental variables affect carriage width and form
     length only when you use the batch file DOTS1234 or DOTS234. When
     you format with any other method, they have no effect.

Use the commands $$w# and $$f# at the very beginning of your document
     file, before any other commands. The values set by these commands
     have the final say; they override any other settings established
     with a different method. For example, if you have set HDWIDTH to 42
     and use DOTS1234, $$w32 still ensures that that file is formatted
     with carriage width 32.

              Format Commands Placed by the File Importer

     The Hot Dots file importer does its best to interpret the format
information in your original file and place appropriate format commands
in the .HD$ file it creates. Nevertheless, there will be times when you
want to intervene in the process and change the automatically placed
format commands (see Section 3 for the mechanics of editing the .HD$
file). The importer uses margin and paragraph indent commands designed
for braille output. Below we discuss some of the format information
placed by the file importer and the changes that you might want to make.

Page Numbering

     The file importer places $$np at the beginning of your file. When
formatted for braille, this places the sequential braille page number in
the upper right corner of every page (after at least three spaces).
However, you may want a different kind of page numbering. For example, $
$va places the sequential braille page number in the lower right corner
of every page. If the file you imported contains print page numbers, you
may want to use textbook formatting. Begin the file with $$vt instead of
$$np. At the start of each new print page place $$vp followed by the
print page number. The file importer places the inert command $$p+0$$p+0
at each page transition that it knows about. This command sequence does
not do anything to your output. It is there as something you can search
for in order to place $$vp [page number] commands. You will probably
need to move the page number to get it next to the $$vp command. You may
be able to use Global replace for some of this work.

Soft vs. Hard Carriage Returns

     A soft carriage return in your original file is there only because
the next word would not fit on the previous line. On the other hand, a
hard carriage return in your original file was placed there on purpose
to force a new line. For example, a hard carriage return may start a new
paragraph or begin a new line in an address. In making the equivalent
braille document, the goal is to preserve the hard returns but to ignore
the soft returns, turning each soft return into a space. It places a
paragraph indicator ( $p ) where it finds one or two hard returns or ( $
s ) where it find three or more hard returns. It replaces each soft
return with a space. This works well when the file importer can tell the
difference between hard and soft returns in your original file. This
task is easy for files imported from most word processors. This task
calls for more "guesswork" by the file importer when you import an ASCII
textfile. It is our experience that it does a good job at this overall.
However, you may need to remove some paragraph indicators and insert
others.

Tabs

     Where the file importer finds a tab in your original file, it
places a space followed by $$p+1 in your .HD$ file. When formatted, this
creates two spaces. You may find this acceptable in your application. If
not, the formatter does not create $$p+1 for anything else. So you can
change these to something more appropriate for tabs in your application.
You may want to set appropriate tab stops and then use Global to replace
$$p+1 <space> with $$ <space>. Or you may prefer to replace $$p+1
<space> with <semicolon> <space>.

Emphasis

     Where the file importer finds underlining or italics (or both) in
the original file, it places $$ub and $$uf to begin and finish inkprint
underlining and braille italics. For a bold passage in your original
file, it begins with $$ub$$p+0 and finishes with $$uf$$p+0. With the
extra $$p+0, these commands still create inkprint underlining and
braille italics. But they are also recognizable in your .HD$ file. You
may not want to preserve bold from your original file with any special
emphasis in Hot Dots. For example, you may have scanned your file into
the computer with an optical scanner, and the markup for bold may come
from irregularities in the print quality. To remove the emphasis that
came from bold text, just use Global replace to replace each of the two
sequences just mentioned with nothing at all.

Centering

     The file importer places $$cx, the extended centering command,
wherever it finds a centering command in your original file. Where it
finds the end of centering in your original file, it places $$ml+0 or
another left margin command (to terminate the extended centering in Hot
Dots).

     In addition, where the importer finds lines which begin with a lot
of spaces, it places $$c <space>, the ordinary centering command. This
centering lasts only up to the next forced new line. Since the importer
is not so sure about whether this material should be centered, it does
not risk extended centering. In any case, you may want to remove some
occurrences of $$c <space>.

Indent and Runover

     Hot Dots uses the commands $$i# and $$ml# to set the "indent and
runover" of paragraphs. $$i# sets the indent used at subsequent ( $p )
and ( $s ) indicators. We call this the indent for paragraphs. $$ml#
sets the margin used for soft returns (since the importer always leaves
the $$ms# soft margin indent at 0). We call this the runover for
paragraphs. So these two commands set the indent and runover for
paragraphs. If the indent value is bigger than the runover value, the
paragraph is normally indented. If the indent value is smaller than the
runover value, the paragraph is outdented (sometimes called a paragraph
with hanging indent). The importer tries to preserve indented and
outdented paragraphs from your original file in the resulting Hot Dots
file. The importer does not create "blocked paragraphs," paragraphs with
the same value for indent and runover. Where it believes that a
paragraph in your original file is blocked, it creates a normally
indented paragraph in your Hot Dots file by adding 2 to the paragraph
indent.

     To improve the resulting braille format, you may want to change
some of the indent and runover values. For example, you can affect many
subsequent runover values by inserting a $$ms# command to set a soft
margin.

Tables of Contents and Menus

     Where the importer finds 5 or more periods (next to each other or
separated by spaces) it places $$vr"$$vk to create braille guide dots.
To make this format work right, enclose this kind of material between $
$mr6$$vlt and $$mr0$$vln. This prevents conflicts between the text,
flush right words, and sequential page numbers.

                    Section 9: Output to an Embosser

     See Section 12 for details on interfacing embossers to your
computer.

     Once you have created a braille formatted file (a file with the
.BFM extension), you can send it to your braille embosser in several
ways using Hot Dots. You can use the DOTS menu, you can use the Hot Dots
driver programs at the command line, you can use the batch files
supplied with Hot Dots, or you can use a DOS command like PRINT or COPY.
Unless you are writing your own batch files, there is little reason for
using the Hot Dots driver programs at the command line. The

               Four Embossers That Need Special Treatment

     There are four embossers that require special treatment. These are
the Cranmer, the LED-120, the Ohtsuki, and Dipner Dots. In these cases,
we cannot send the raw BFM files to the embossers. For each of the
output methods that are discussed below, special handling is required
for these four embossers.

                        The Supplied Batch Files

     Typing DOTS1234 MAZE.DOC WPF5 LPT1 means you want the WordPerfect
5.0 file MAZE.DOC imported, translated, formatted (as a BFM file), and
directed out through your parallel port (LPT1 is the PC's word for
parallel port number 1). Using the DOTS1234 or DOTS234 batch file is
easy and effective.

     These two batch files use a carriage width of 40 for formatting. If
you need to change the carriage width that the batch files use for
formatting, (for example, if you have a Braille Blazer), use the
environmental variable HDWIDTH. Type SET HDWIDTH=34 <enter> at the
command line or in your AUTOEXEC.BAT file to modify the formatting
carriage width for the batch files.

     If you have one of the 4 special braillers listed above (Cranmer,
LED-120, Ohtsuki, or Dipner Dots), then you have to set the
environmental variable HDDRIVER. Set this variable to one of the
following values: CRANMER, LED120, OHTSUKI, or DIPNER. For example, type
SET HDDRIVER=CRANMER <enter> at the command line or in your AUTOEXEC.BAT
file. When you have done this, the batch files create another file based
on the .BFM file. This .BDV file includes the special handling needed
for the specified brailler.

                          Using the DOTS Menu

     Hot Dots supports output to a wide variety of embossers. Option 4
in the Main Menu is for output to an embosser or inkprint printer. When
you choose option 4, you get the Output Menu with a choice of embosser
types. When you press enter, you get the list of choices. Here is the
list:

Output Menu - output to one of the following devices:
A Bookmaker
B Braille Blazer
C Braillo
D Cranmer Brailler
E Dipner Dots
F Index
G Inkprint printer
H LED-120
I MBOSS-1
J Ohtsuki
K Other brailler or Unknown brailler
L Personal Brailler
M RESUS
N Romeo
O Thiel
P VersaPoint
Q cancel (go to Main Menu)

     When you use the DOTS menu, the program takes care of the special
handling required for the four special embossers. However, inkprint
Dipner Dots and output to the Ohtsuki with normal spacing are not
available from the Output Menu (at the time of writing this manual). See
Section 11 for instructions on getting these special kinds of output
with the Hot Dots batch files.

                 Using the DOS commands PRINT and COPY

     The easiest way to output a braille formatted file (a .BFM file) or
a braille device file (a .BDV file) is with the DOS PRINT command. To
output SOUP.BFM from the command line, just type PRINT SOUP.BFM <enter>.
This prints the file in background, so that you can use your computer
for other purposes.

     Another useful DOS command is COPY. You can type COPY SOUP.BFM COM2
<enter> to send the file SOUP.BFM to your second serial port.

     Do not use a DOS command to send a BFM file if you have a Cranmer,
an LED-120, an Ohtsuki, or Dipner Dots. Instead, use the Output Menu, or
use the DOS commands (PRINT or COPY) on the BDV file created by the
batch files (DOTS1234 or DOTS234).

                  Section 9: Global Search and Replace

                      What You Can Do With Global

     Hot Dots' power is greatly increased by the Global search and
replace option. It allows you to define your own keyboard shortcuts for
words and phrases that you type frequently or for strings of $$
formatting commands. For example, if you have to type "University of
Wisconsin--Madison" a lot, you can substitute "uwm" and then Globally
replace it later. You can use Global search and replace to make
systematic changes in format information, to fix translation errors, or
to perform other massaging needed in going from print to braille or
braille to print.

     When you use the Global search and replace function, you must
provide instructions on what changes to make. There are two main ways to
use Global search and replace. One way is to use a collection of
instructions that is already stored on disk: either one that you wrote
and saved to disk, or one that we supplied with Hot Dots. The other way
is to type new instructions when you need them by answering prompts from
Hot Dots. Before we discuss these methods in detail, we need to define
some terms.

The tools you need

     To use Global search and replace, you need a rules file. A rules
file tells Global what to search for, and what to substitute when it
finds something. The rules files we supplied with Hot Dots are easily
identifiable by the file extension .RUL. A rules file consists of one or
more transformation rules. Each transformation rule consists of a From
string and a To string. The From string is what you're looking for. When
Global search and replace finds the characters in the From string, it
removes them from the text and replaces them with the characters in the
To string.

     Each string may be up to 80 characters long. The To string may be
longer, shorter, or the same length as the From string.

                    Using Global Search and Replace

     Choose option 5 on the Hot Dots Main Menu. Hot Dots prompts for the
name of the input file and then for the name of the output file (the new
file that it creates with the specified changes). Hot Dots then asks:
Load global replacements from disk?. Answer no when you want to type a
new set of rules on the spot. Answer yes when you want to use a set of
rules that already exists in a rules file.

Loading a rules file from disk

     When you choose to load a rules file from disk, Hot Dots prompts
for the rules file name. When you type in the name, give its pathname if
it is not in your current directory. You can enter the name of only one
rules file (which may contain many transformation rules). Press <enter>
to signal that you have entered the name of the rules file. When Global
has found the file on disk, the replacement begins. If Global does not
find the rules file, you get an error message, and Global terminates. So
be sure that the rules file you plan to use is on the disk and directory
you specify.

     If your input file is longer than 30,000 characters, do not give
the output file the same name as the input file (overwriting the input
file). (If you have very little free memory available when you run
Global, the limit is less than 30,000.) If Global does run into a
problem because you use the same input file and output file, it informs
you of this problem and terminates without damaging your file.

     How long Global search and replace takes depends on several
factors: the length of the input file and the number of transformation
rules. With a longer input file and many rules, Global takes more time
than with a shorter input file and few rules.

     An example of using a rules file is using the CLEAN.RUL file
supplied on your Hot Dots disk. This rules file locates all carriage
returns and turns them into spaces. If you use Hot Dots to print an
inkprint file, use this file before using the Hot Dots formatter.
(Translating into braille removes carriage returns; use CLEAN.RUL to
remove carriage returns when you format a file that you have not
translated into braille.)

                         Creating a Rules File

     When you tell Hot Dots that you don't want to load a rules file
from disk, it begins prompting for transformation rules. First it
reminds you Enter a blank rule (just carriage return) to end rule
table.. Then it prompts From:.

     Type in the exact characters you want to search for. Global search
and replace is very literal minded. For example, when you want to
replace a string of characters that sometimes appears in uppercase and
sometimes in lowercase, you must write a separate transformation rule
for each case; Global does not consider "A to Z" to be the same as "a to
z". Press <enter> to end the From string.

     After you enter a From string, Hot Dots prompts To:. Again, type in
exactly the characters you want to create in your new file. Press
<enter> to end the To string.

     When you're finished writing transformation rules, press <enter> by
itself at the From: prompt. How long replacement takes depends on the
same factors as for an already written rules file.

     Here's an example of entering transformation rules directly. The
author always misspells the word "occurrence," and uses a typing
shortcut to represent "Hot Dots". After creating this rules file, we
want to save it to use again later.

     In showing the keyboard entry here, we write <space> where you are
supposed to type a space. Spaces are shown for readability.

Main menu. Enter option: 5
Global search and replace.
Input file: ROUGH.TXT <enter>
Output file: SMOOTH.TXT <enter>
Load global replacements from disk? N <enter>
Enter a blank rule (just carriage return) to end rule table.
From: occurence <enter>
To: occurrence <enter>
From: HD <enter>
To: Hot Dots <enter>
From: <enter>
Save this table in a file (Y or N)? Y <enter>
Table file name? SPELLFIX.RUL <enter>
Search and Replace started ...

Entering control characters in transformation rules

     You can enter control characters in your From and To strings. Alert
Hot Dots that the next character you type will be a control character by
pressing Ctrl-V. (V stands for "verbatim".) Then type the control
character itself. For example, you can enter your own version of
CLEAN.RUL to change carriage returns to spaces. Since pressing <enter>
marks the end of a string, you cannot specify searching for <enter> by
simply pressing <enter>. <enter> is also known as Ctrl-M Ctrl-J, or
carriage return/line feed. To put more than one control character in a
string, you must press Ctrl-V before each one. Type the From and To
strings like this:

From: <Ctrl-V> <Ctrl-M> <Ctrl-V> <Ctrl-J> <enter>
To: <space> <enter>

     The Ctrl-V is very important! In the example above, if you didn't
press Ctrl-V first, Hot Dots would interpret the first <Ctrl-M> as the
end of the From string, and hence the end of the transformation rules.

     Another way to put control characters in a From or To string (using
tilde followed by two hexadecimal digits) is discussed later in this
section, under "Editing a Rules File." That method is also available
here, and you must use that method if you want a From or To string to
include certain characters, like vertical bar or tilde.

Correcting mistakes

     When you're writing transformation rules, you can use the backspace
key to erase mistakes before ending the string with <enter>. (However,
you cannot use the escape key to return to the beginning of the string.)
Once you've pressed <enter>, there's no way to go back and correct a
mistake in a previous string.

Saving a rules file

     Before Global replace transforms your file, it asks Save this table
in a file (Y or N)?. When you answer no, the Global search and replace
function begins and you're returned to the Main menu when finished. When
you answer yes, you're prompted for the name of the rules file. Type the
filename (including extension). After the rules file is saved, Global
begins.

Editing a rules file

     You can edit a rules file just as you can edit any other file. The
From string appears first, and then a vertical bar separates it from the
To string. Do NOT delete this bar or enter any extra vertical bars. If
you did, the structure of the rules file would be changed and Hot Dots
would not be able to use this rules file correctly. You can add, delete,
or change text, but the vertical bar must still separate the From and To
strings.

     A control character in a From string or To string is represented in
the rules file with the tilde (~) character as an identifier followed by
its ASCII value expressed in two hexadecimal digits. Hexadecimal is the
numbering system you use if you have 16 fingers. The most important
character codes to know for control characters are ~0A for line feed,
~0C for form feed, and ~0D for carriage return. If you want to insert
control characters in rules files using an editor, you must use this
tilde/ASCII-hex representation. Also, the character <space> can appear
as ~20. (If you typed the transformation rules on the fly and then saved
the rules file, every <space> you typed appears as ~20.) A tilde or
vertical bar character in a From or To string also has to be represented
in hexadecimal. A tilde is ~7E, and a vertical bar is ~7C.

                         Things to Think About

     Global search and replace is very literal minded. When you create a
From string, Global searches for exactly what you tell it to. Global's
literal mindedness includes the distinction between upper and lower case
letters. As far as global is concerned, "Word" is different from "word".
To replace all occurrences of a word with something else, you may have
to generate multiple rules to cover occurrences of the word with
different capitalization.

     Be careful about unusual letter combinations. For example, if you
use "ppi" to mean "print page indicator", you might change "floppies" to
"floprint page indicators".

                        Cascading rule Problems

     It may be tempting to write one rule to change A to B, and another
rule to change B to C, but it may not work. For each character in the
input file, global looks to see if any of its rules apply. Global only
goes through the input file once.

     This works fine for simple applications. For example, you can have
one rule that says "take two spaces and turn them into a single space".
If your file has 15 spaces in a row, the output file will have only 1
space, since this one rule continues to execute until it is reduced to a
single space. A single space no longer meets the conditions of this
rule. Only when no more rules apply does Hot Dots advance its pointer in
the file.

     If you are aware of how Global works, you can do a lot in its
single pass through the data. For example, suppose you are cleaning up
some data. You write a rules file with transformation rules to change
two spaces into one space and to change $p <space> $p into $p. You know
that some $p indicators are separated by more than one space, but you
expect the rule which changes two spaces into one space to take care of
that. It doesn't! In a place where there are several spaces between two
$p indicators, Global does shrink them down into one space. But by that
time, Global's pointer into the data is already past the first $p and it
cannot go back. However, if one of your rules changes $p followed by two
spaces into $p followed by one space, things work fine.

     If you write a rule that increases the length of the material
(i.e., the replacement string is longer than the original string), the
program jumps to the end of the inserted segment. This prevents infinite
loops. For example, if you wrote a rule that said "turn any occurrence
of x to xx", you would not want Global to fill your hard disk with x's.

     If you really need to "reach back" behind the current position,
then write more than one rules file. First execute Global replace on the
source file, using the first rules file. Then execute global again on
the output from the first Global replace operation, using the second
rules file. We had to do this with the rules files that we use to import
files.