ClasX Manual copyright 1988 by Raised Dot Computing, Inc. All Rights Reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means--electronic, mechanical, audio recording, photocopying, or otherwise--without the prior written permission of the publisher.
Pages 91-92 from the PostScript Language Tutorial and Cookbook, copyright 1985 by Adobe Systems, Inc., reprinted on pages C3:13-14 by kind permission of the publisher, Addison-Wesley Publishing Co., Reading, Massachusetts.
November 1987 Open-Apple magazine, copyright 1987 by Tom Weishaar, reprinted on pages C5:22-29 by kind permission of the copyright holder.
ClasX program design, coding, & documentation: Caryn Navy, Jesse Kaysen, and David Holladay
The following folks helped us enormously by answering questions and testing software: Darleen Bogart, Tim Cranmer, Bill Davis, Warren Figueiredo, Chris Gray, Priscilla Harris, Don McDowell, and Sandy Ruconich. And our undying gratitude for service above and beyond the call of duty "or telephone" Gloria Buntrock and Conchita Gilbertson
While these individuals kindly assisted us in understanding the requirements and implementation of the relevant braille codes, they are in no way responsible for the accuracy of the information presented here.
Written and edited with BEX. The large print edition coded with BEX and output to the LaserWriter Plus by Jesse Kaysen, using JustText on the Macintosh. Body type is Palatino with Courier; headlines are Bookman-Bold-Italic. Duplicated under Betty's watchful eye at OmniPress in Madison, Wisconsin. The braille edition was transcribed with TranscriBEX and ClasX by Phyllis Herrington and David Holladay, then embossed on our trusty Thiel here at RDC.
These manuals are transcribed in Grade 2 Braille and in the Code for Computer Braille Notation, as adopted May 1987 by BANA. Since the Code for Computer Braille Notation "CBC" is still new, here's a quick overview: A complete paragraph transcribed in CBC is preceded and followed by one blank line. CBC embedded within a Grade 2 paragraph begins with dots 4-5-6, 3-4-6 _+ and ends with dots 4-5-6, 1-5-6 _:. Dots 4-5-6 _ precedes a single capital letter. Dots 4-5-6, 3-4-5 _> signals caps lock; caps release is shown either by a space or by dots 4-5-6, 1-2-6 _<. Dots 4-5-6, 1-6 _* begins emphasis and dots 4-5-6, 3-4 _/ ends emphasis. If embedded CBC starts in caps lock or emphasis, then the begin emphasis or caps lock indicator is substituted for the generic begin CBC indicator, dots 4-5-6, 3-4-6 _+. The continuation indicator, dots 4-5-6, 1-2-3-4-6 _&, appears at the end of braille lines when one inkprint line requires more than one braille line. Dots 4-5-6 _ precedes any isolated lower-cell sign. When five or more spaces are significant, CBC uses a countable space indicator, whose total length shows total spaces in inkprint. This countable spaces indicator begins with space, dots 4-5-6 and ends with one space; with full cells in between. Pages C2:3 and C2:4 contain charts showing how CBC represents each printable ASCII character.
Transcribing a braille edition of an inkprint manual on transcribing software presents some special challenges. The inkprint contains many instances with an inkprint sample, followed by the data entry codes, followed by the resultant braille. For a braille edition, this "resultant braille" does double duty: it shows the original inkprint as well as what our software produces. We have replaced the inkprint samples with the transcriber's note saying "Inkprint sample omitted". The braille reader is invited to skip ahead to read the braille version. After reading the braille, skip back to look at the data entry sequences. If the braille has some unusual feature "such as a strange inkprint symbol", this is also noted in the transcriber's note.
The braille samples are all formatted for full 40 cell lines. To avoid any interaction with the page numbers, lines 25 and 1 are not used when printing braille samples. These skipped lines do not represent a change in context.
FINETUNE-COAT's EffectsRED1RED2ClasX is a collection of tools you use in conjunction with TranscriBEX and BEX. The ClasX package is actually two sets of tools. ClasX-CBC helps you create braille transcriptions conforming to the Computer Braille Code, 1987, "which we abbreviate to CBC". ClasX-LBF helps you create braille transcriptions for linear electronic braille devices, following the Provisional Guidelines for Literary Linear Braille Format, 1987, "which we refer to as LBF". This Overview gives you the background you need before you tackle either the ClasX-CBC Manual or the ClasX-LBF Manual. Each Manual has its own Table of Contents and page numbering.
ClasX-CBC, combined with TranscriBEX, creates paper braille documents that can include grade 1, grade 2, and CBC braille codes. Part 4 provides an overview of CBC transcription. ClasX-LBF, combined with TranscriBEX, creates linear braille documents in grade 2 and grade 1. Part 5 explains just what a "linear braille" device is, and how you format braille for it. You can also use both ClasX-CBC and ClasX-LBF to create linear braille transcriptions that include CBC braille.
RDC has designed the TranscriBEX and ClasX systems to help increase the availability of braille reading materials. While we have made every effort to make our software conform to the rules for braille format and translation established by the Braille Authority of North America, the TranscriBEX and ClasX Manuals are in no way a substitute for the braille code books. The code books exist for a good reason: so braille readers can depend on consistency in all their reading materials. The format tools available in braille are inherently limited: the code books maximize the use of the few techniques available.
Producing correct braille with RDC's braille translation and format tools depends on the combination of three elements:
Parts 4 and 5 contain ordering instructions for the relevant code books. When our software fails to conform exactly to the rules, we point this out.
In order to use ClasX, you need five things:
As introduced in Section 3, Part 1 of the TranscriBEX Manual, TranscriBEX is a route through particular neighborhoods in BEX. ClasX is similarly a route through the world of BEX, a path that helps you create CBC and LBF braille. Late in 1987, some new high-rises appeared in the neighborhoods of braille translation and formatting. That's why you need BEX 3.0 to use ClasX: earlier versions of BEX could not translate inkprint to Computer Braille Code. You could use BEX 2.2 or earlier to do data entry for ClasX, but you must use BEX 3.0 to translate and format your text.
When BEX 3.0 was released in late 1987, ClasX development was still in progress. The October, 1987 version of BEX does not fully support ClasX. The "ClasX Installer Disk" enhances your BEX 3.0 disk so that all the ClasX features work correctly. Before you use ClasX, you must run the Installer and enhance your BEX disks.
Boot the Installer disk on a two-drive Apple system,
and follow the copious instructions--there's also a BEX chapter named
The BEX 3.0 software is designed for a 128K Apple II
computer. An Apple IIgs or Apple IIc always has at least 128K memory; you
must install an extended 80-column card in an Apple IIe to
bring its memory up to 128K.ClasX is incompatible with an Apple II Plus.
Two disk drives are an absolute minimum: installing a memory expansion
card allows you to use RAM drives, which will greatly speed up your ClasX
use.
Since ClasX and TranscriBEX are both dependent on BEX,
it's important that you have the BEX Dox to answer your questions as you
use the program. In the ClasX-CBC and ClasX-LBF Manuals, all references to
the BEX Dox are based on the manuals dated "BEX version 3.0, October
1987." Earlier versions of the BEX Dox may not explain all the tools you
need; contact RDC for information on purchasing updated documentation.
ClasX-LBF and ClasX-CBC are extensions of TranscriBEX.
Before you can make sense of the ClasX-CBC and ClasX-LBF materials, you
should be familiar with the TranscriBEX process. "Familiar" means you can
use BEX's Editor to create data, entering text and TranscriBEX \\
commands. You can use Replace characters and the The ClasX disks contain many transformation chapters
and sample data at every step of the ClasX process. The ClasX-CBC and
ClasX-LBF Manuals explain how you use these tools.
When people first connected braille devices to
computers, they needed to establish some correspondence between print
characters and braille cells. The de facto standard in the U.S. became the
"M.I.T. Terminal Code," often called "computer braille." When you send
untranslated, inkprint material directly to a braille embosser or
paperless brailler, the resulting braille is computer braille.
The American Standard Code for Information
Interchange, abbreviated ASCII, defines how computers
represent characters with numerical values. The ASCII system includes 95
printable characters. The M.I.T. Terminal Code defines which braille cell
is embossed for every printable character. Since there are only 64 braille
cells, this system is not perfect. In Part 4, we give you an overview of
how the Computer Braille Code resolves these imperfections.
The concept of "computer braille" can be a little
confusing at first. The M.I.T. Terminal Code actually serves two
functions. It's a standard for how every inkprint character is represented
on a braille device. And it's also the way that software manufacturers
like RDC know which characters to use when translating inkprint to grade 2
braille, and which characters to send to a braille device to create
comprehensible grade 2 output.
Here's a quick sample: the inkprint asterisk character
is dots 1-6 in the M.I.T. Terminal Code. Dots 1-6 is the "ch" sign in
grade 2 braille. When BEX translates the word When showing samples of braille output in these
Manuals, we use screen braille, or the inkprint characters
that are sent to a braille device to create braille output. The screen
braille version is what BEX's Grade 2 translator creates from your
inkprint data. The back cover of the TranscriBEX Reference Card shows the
dot patterns for each screen braille character.
In grade 2 braille, the ea sign is dot 2,
while the er sign is dots 1-2-4-5-6. To make a braille device
display an ea sign, you send it ASCII value 48. When the
Apple puts this ASCII 48 character on the screen, it shows the inkprint
digit 1. To make a braille device display an er sign, you
send it ASCII value 93, which appears on the inkprint computer screen as
the As we introduced in the TranscriBEX Manual, when we
show you the exact characters you type in your chapters, we enclose them
within parentheses: (reader) means type six characters; you don't type the
parentheses themselves. When we show the translated result in screen
braille, we enclose the characters within braces: r1d] shows
four characters; the braces are not part of the translation. Any spaces
shown within the parentheses or braces are meaningful spaces.
As we said in Part 3, the "M.I.T. Terminal Code," "or
small c "computer braille" is the de facto standard for
representing printing characters with braille cells. When you send
untranslated, inkprint material directly to a braille embosser or
paperless brailler, the resulting braille is computer braille.
In this system, both the lowercase and uppercase
versions of a letter are shown by the same braille cell. The computer
braille standard provides no way for the braille reader to distinguish
between lowercase a and uppercase A; they are
both embossed as dot 1. In Because the difference between a and
A or ~ and ^ can be crucially
important, manufacturers of braille devices have developed various ways to
reduce the ambiguity inherent in the computer braille system. Some braille
embossers allow you to choose 8-dot braille, where one of the extra dots
indicates capitalization. Some paperless braille devices use pin vibration
or audio tones to show capitalization. Whether it's eight dots or
vibrating pins, hardware like this allows the braille reader to know
exactly what the inkprint looks like. But there's a significant drawback
to these strategies: they require a particular arrangement of hardware, or
as the computer professionals would say, they are "device-dependent."
In May of 1987, the Braille Authority of North America
formally adopted the Computer Braille Code, which is
device-independent. Using combinations of the standard 64
braille cells, it provides a way to precisely and consistently distinguish
between a and A, or ^ and
~. CBC also establishes standard ways of representing
inkprint horizontal spacing in a useful and clear fashion. Although it's
conceivable that manufacturers of braille devices could incorporate CBC
translators into embossers or paperless braillers, that's not the main
purpose of the Computer Braille Code. Rather, CBC is designed for
reference materials about computers and using them.
The Computer Braille Code uses dots 4-5-6, the
underbar _ in screen braille, as a multipurpose symbol to
resolve ambiguity and to clarify format. For example, lowercase (a)
appears as a, while uppercase (A) is shown as _a
in CBC. The caret (^) appears as ^ in CBC, while the tilde
(~) appears as _^. You don't have to manually enter the
underbar characters when you use ClasX-CBC; the translator places them
automatically.
The definitive reference for CBC is the Computer
Braille Code, 1987 code book, available from the American Printing
House for the Blind.
In addition, the National Braille Association
regularly sponsors continuing-education workshops for its members on
transcribing issues. Between its adoption and the writing of this Manual,
the NBA presented several CBC workshops which greatly assisted our
understanding of the Code. Training materials from the NBA workshops are
often available, in print and braille, at minimal charge. If you're doing
a lot of braille transcribing of any form, consider joining the NBA. Their
quarterly Newsletter is full of useful information, and they can help you
locate certified transcribers to assist you in structuring your
transcriptions.
Linear braille devices first appeared in the late
1970s. Also called "paperless" or "refreshable" braille devices, their
braille cells consist of pins that move up and down under computer
control. As of early 1988, all these devices contain just one line of
braille cells--hence "linear" braille--varying from 10 to 40 cells in
length. Some brand names of linear braille devices are the tape-based
VersaBraille and the disk-based VersaBraille II "from Telesensory Systems,
Inc."; the Braille Display Processor "from VTEK, Inc."; and the
PortaBraille "originally from the Kentucky Dept. for the Blind, and soon
to be available from the American Printing House for the Blind".
Aside from a single line of refreshable braille cells,
these devices differ in their design. All allow the user some degree of
"scrolling," the ability to view various portions of the braille text
through the limited braille cell display. Some devices include a storage
medium: cassette tape, 3.5-inch floppy disk, or battery-backed computer
chip. Some devices are actually stand-alone computer systems, complete
with built-in braille translation and terminal emulation capabilities.
While there is a lot of variety out there, all these devices know how to
interpret the M.I.T. Terminal Code.
Designing formats for a short, one-line braille
display is a challenge. Imagine cutting a small rectangular hole in a
sheet of paper that's one braille cell high and ten braille cells wide.
Now try to read a book through this window, shifting it back and forth to
get access to all the characters on the page. You can see why paper
braille's indent and runover variations and skipped lines are not
particularly helpful for linear transcriptions.
The Provisional Guidelines for Literary Linear
Braille Format, 1987 address this problem through a host of
explicit "format symbols." The general pattern of these symbols is one
space, followed by dots 1-2-4-6, $ in screen braille,
followed by an abbreviated group of characters, and finally one space.
Following these guidelines, a conventional paragraph is shown as
#[_$]#$p#[_$">\TX]#.
Most importantly, BEX and TranscriBEX data entry are
not line-oriented. Some computerized transcription tools require that you
format the braille text manually: you must press <CR> at the end of
each braille line. To create a new braille paragraph, you press <CR>
once, then braille two spaces. A lot of effort is required to
create linear versions of this kind of data: you would have to manually
delete all the <CR>s and spaces, and insert LBF's explicit symbols
in the right spots.
The LBF paragraph #[_$]#$p#[_$">\TX]# and
#[_$]#$l#[_$">\TX]# new-line "format symbols" are the same as
BEX's ( $p ) and ( $l ) indicators. When you print to a paper
braille device, then BEX executes ( $p ) and ( $l ) with the appropriate
number of <CR>s and spaces for indent. When you send braille text
from BEX to a paperless braille device, you're not printing
the text, you're merely transferring it character-for-character. Well, not
exactly character-for-character. BEX filters out some
characters that would only confuse a linear braille device--more on this
in ClasX-LBF Section 3.
Almost all the format information that's expressed
with indent and runover in paper braille becomes an explicit dollar-sign
indicator in LBF. The current authority for LBF is the Provisional
Guidelines for Literary Linear Braille Format, 1987; it's available
from the American Printing House for the Blind.
The Computer Braille Code "CBC" was
adopted by the Braille Authority of North America in May 1987. CBC defines
the rules for precisely representing computer-related material in braille.
CBC uses no contractions; similar to Grade 1 transcription, the CBC
version of an inkprint passage always requires more cells than there are
inkprint characters. Because of this, you would never transcribe an entire
manual in CBC.
The rest of this Section provides you with the general
pattern of how you use ClasX-CBC. Section 2 is devoted to the individual
ClasX-CBC commands. Section 3 is a tutorial, which steps you through the
transcription of two pages from the PostScript Language Tutorial and
Cookbook. Sections 4 and 5 explain how you can begin your braille
transcription with an existing computer file from the publisher.
Using a variety of contextual clues, you must decide
what portions of the inkprint need CBC, and what parts are comprehensible
when transcribed in Grade 2. Generally, CBC is used for program listings,
sample outputs, filenames, and any other situation where the braille
reader must know the exact inkprint characters. In addition to the digits
and lower- and uppercase letters found on a typewriter keyboard,
computer-related material will generally include some of the symbols
commonly found on computer keyboards. Fortunately, most computer manuals
use an explicit system for differentiating prose and precise computer
notation: some manuals use quotes, some manuals use italics, some use
underlining, etc.
In the absence of a specific system, a variety of
inkprint clues signal the need for CBC transcription: a special type style
"especially a monospaced, typewriter-like typeface"; the presence of
numbered program lines or systematic indentation; and the use of special
punctuation that signals a "comment." Section 2, Part 2 explains the
ClasX-CBC commands you use to switch between CBC and Grade 2 braille
translation and format.
There's one significant difference between the
ClasX-CBC process and the TranscriBEX process: ClasX-CBC requires inkprint
data entry. With TranscriBEX, experienced transcribers can enter all the
text directly in contracted braille, but this is not possible with
ClasX-CBC.
To explain why, let's start with a quick review of the
TranscriBEX process when doing inkprint data entry:
When you proofread your text after Step 1, all
text appears as uniform paragraphs. You are only checking for typos and
the correct \\ commands. When you're finished with step 2, you have
inkprint chapters with braille format. You can proofread this data by
printing to a Braille Previewer or SW "the 80-column screen". Since the
data is inkprint, it's a different length than the final chapters of step
4, but once you've reached step 2, you can check to see that you haven't
mistyped a TranscriBEX command and your braille format is essentially
correct.
You take your data through the same five steps with
ClasX-CBC, but their effects are not exactly parallel.
There are two important differences for
ClasX-CBC: You can't proofread your format until step 4, and steps 4 and 5
require a 128K Apple.
You may have noticed the mention of "machine-readable
text" in ClasX-CBC Step 1. "Machine-readable" means that the inkprint
version of a document exists on some computer system already: it may be a
typesetter's nine-track tape, a database or information system accessible
by modem, an IBM-PC word processor file, or an Apple textfile. Nowadays,
almost all inkprint materials are created with the help of a
computer, and you can use machine-readable text as the basis of
TranscriBEX data entry as well as ClasX-CBC data entry.
In ClasX-CBC Step 2, we mentioned two transformation
chapters: ClasX-CBC requires BEX version 3.0 or later, and BEX
3.0 is designed for a 128K Apple. It's possible to do some ClasX-CBC
activities on a 64K Apple: Inkprint data entry, Replace characters, and
the Grade 2 translator all function correctly. However, ClasX-CBC Steps 4
and 5 require a 128K Apple II computer.
In ClasX-CBC Step 3, we mention a FINETUNE-C chapter:
it's supplied on the ClasX-CBC disk. In TranscriBEX Section 8, we discuss
the FINETUNE transformation chapter that corrects errors made by BEX's
Grade 2 Translator. It's quite possible that a combination of characters
that's incorrect grade 2 is totally correct CBC. For example, the first
name of a wonderful Hungarian composer Bela Bartok should not use any
contractions. BEX's Grade 2 translator incorrectly uses the be sign, so
FINETUNE changes ,2la to ,bela
Now that you have an overview of the function of the
Code for Computer Braille Notation, it's time to explain the
ClasX-CBC commands that create its format and translation. This Section
begins with an overview of the commands, and then proceeds through 14
numbered Parts covering all the situations you can encounter when
transcribing inkprint into literary and CBC braille.
We use an extension of the system used in Sections 8
and 17 of the TranscriBEX Manual. Material within parentheses is what you
type in your inkprint: (\\cb) means you type backslash, backslash,
lowercase c, lowercase b, space. You
don't type the parentheses themselves, only every character
enclosed within them.
The transformed and translated data is shown as screen
braille within braces: _+ shows three characters: space,
underbar, plus sign; "or in braille cells, space, dots 4-5-6, 3-4-6". All
spaces shown within parentheses or braces are significant.
As we discussed in Section 1, ClasX-CBC involves both
format and translation. And unlike plain TranscriBEX, some $$ commands are
placed by Some ClasX commands look like TranscriBEX commands:
two backslashes followed by mnemonic lowercase letters "and occasionally
numbers". For example, to show the main level in an indented program
listing, you type (\\0c). Other ClasX commands look like the translator
controls "TCs" introduced in TranscriBEX Section 17: they start with
underbar and are followed by one or two mnemonic characters. (_e) signals
the beginning of emphasized text within CBC, and (_f) finishes up
emphasized text within CBC. The ClasX-CBC commands beginning with the
underbar character always appear within CBC.
You may have noticed that we're not showing spaces on
both sides of the commands mentioned so far. A single space can play a
crucial role in the meaning of computer-related material. While
The Code for Computer Braille Notation prescribes how
to show each printable ASCII character. It uses the M.I.T. Terminal Code
as its starting point. CBC reserves one of the 64 braille cells as a
multipurpose symbol: dots 4-5-6, or underbar in screen braille. Only one
ASCII character--the underbar itself--requires any special data entry on
your part; your inkprint data entry simply copies the original document
for all the other ASCII characters. The process of translation adds dots
4-5-6 to characters that require it.
A single uppercase letter is preceded by dots 4-5-6.
So _a means one uppercase A, while
a represents one lowercase a. As with
TranscriBEX, use the shift key to enter uppercase characters in your print
chapters. The translator places all capitalization symbols.
For the digits 1 through 0, both computer braille and
CBC use dropped a through dropped j, commonly
called "Nemeth digits." So 1 in CBC represents the digit 1.
Your data entry is identical with the translated result: enter (1) to get
1.
For 20 other ASCII symbols, CBC and computer braille
use the same system: what you type in inkprint is what you get in CBC:
Dots 4-5-6 is how CBC distinguishes between the
ten ambiguous symbols mentioned in Section 1. Your print data entry is the
exact character in inkprint; the translator adds the dots 4-5-6 where
needed.
Because CBC uses dots 4-5-6 as its multipurpose
symbol, it requires special effort to show an underbar as a character
under discussion. Each single underbar in inkprint is shown by two dots
4-5-6s in CBC. To help keep the underbars straight, remember that in CBC a
single dots 4-5-6 never appears alone. Dots 4-5-6 is always the first cell
of a two-cell pair.
The inkprint underbar is the only character that
requires special data entry on your part. You must type two underbars for
every single underbar you're transcribing. As you will soon see, most of
the ClasX-CBC commands used within CBC begin with the
underbar character as well. Since you type every meaningful
underbar as two underbars, ClasX is able to tell the difference between
underbars-as-data and underbars-as-commands.
When you are reformatting data captured from machine
readable text, you should change every meaningful underbar to two
underbars before you enter any other ClasX-CBC commands.
While the ASCII list of characters is sufficient for
many purposes, some programming languages use additional characters. For
this situation, CBC provides a method for transcribers to
systematically create new representations. You have two tools: the CBC
Shape The preceding discussion addresses the
printing ASCII characters. The ASCII system also includes a
number of non-printing control characters, which control the
behavior of a computer or peripheral device. By definition you can't show
these characters directly; inkprint texts use a variety of strategies to
put them on the page. In RDC's manuals, for example, the control-M
character, also known as "carriage return," is shown between angle
brackets: The possibilities are almost endless. When the
inkprint shows pictures of computer keys, CBC uses the Shape
Indicators--see Part 10. Otherwise, type exactly what you see in inkprint.
If you see:
#[style=Trans note]# Inkprint sample omitted
#[Xstyle=Trans note]#
then you type:
A> dir [Enter]
and the ClasX-CBC process creates:
_a> dir [_enter]
When a manual uses more than one braille code, it's
important that the braille reader know which code they're seeing at any
one point. One potentially tricky aspect of CBC is that there are a
variety of ways to signal the braille reader "Hey, we're starting CBC
now." We will point out the possibilities as we go along; we've designed
the ClasX-CBC commands to be as consistent as possible.
Material transcribed with CBC falls into two basic
classes: "embedded" and "set-off." "Embedded" CBC is used whenever the
inkprint shows computer words or symbols within a text The different formats for embedded and set-off CBC are
similar to how inkprint handles the formatting for short and long
quotations. A quotation of 25 words or less is generally enclosed within
double quotes in the middle of a paragraph. When the quote is longer, you
generally place it in its own paragraph, with wider left and right
margins, and you don't enclose it within double quotes.
Set-off CBC is separated from Grade 2 text by one
blank line. To begin set-off transcription, type ( $s \\cbs) in your
inkprint chapters. The command letters stand for CBC Begin Set-off. The (
$s ) puts in the required blank line, while the (\\cbs) establishes the
appropriate format and translation mode. When you are
finished with the set-off CBC, type (\\cfs $s) in your inkprint. The
command letters stand for CBC Finish Set-off. The grade 2 text following
starts at the paragraph indent because of the skip-line indicator. When
you don't want a paragraph indent when you return to the primary code, end
the set-off CBC with (\\cfs $s \\left). No special signs "other than the
blank lines before and after" are needed to show the beginning or ending
of the computer braille segment.
Here's a quick sample that illustrates the ClasX-CBC
commands for set-off CBC. The inkprint looks like:
#[style=Trans note]# Inkprint sample omitted
#[Xstyle=Trans note]#
The translated result, when formatted on a 40-cell
line, is:
Set-off CBC indents to cell 1 and runs over to cell 2;
this format is automatically established by (\\cbs) and turned off by
(\\cfs). The _& characters at the end of braille lines 1,
3, and 4 are "Continuation Indicators," detailed in Part 4. ClasX-CBC
automatically places these continuation indicators when any inkprint
expression requires more than one braille line.
When CBC is embedded within a grade 2 paragraph, then
an explicit symbol tells the braille reader where CBC begins and ends. The
two-cell generic "Begin CBC Indicator" is _+, dots 4-5-6,
3-4-6. The two-cell generic "CBC Termination Indicator" is _:
dots 4-5-6, 1-5-6. These indicators touch the CBC material.
The ClasX-CBC command to begin embedded CBC is (\\cb),
and to finish embedded CBC is (\\cf). When the inkprint shows:
The ClasX data entry is
Use the \\cb print \\cf statement.
And the resulting Grade 2 plus CBC transcription is:
,use ! _+print_: /ate;t4
When the inkprint puts computer notation in quotes, or
some other symbol of enclosure, place the ClasX-CBC commands
inside the quotes. Your inkprint is:
#[style=Trans note]# Inkprint sample omitted
#[Xstyle=Trans note]#
Your ClasX-CBC data entry is:
The '\\cb bind \\cf' command, whose syntax is "\\cb
bind proc bind \\cf".
And the grade 2 plus CBC translation looks like:
,! ,8_+bind_:0' -m&1 ^: syntax is 8_+bind proc
bind_:04
The generic Begin CBC indicator is
_+. There are four other indicators that can signal the start
of embedded CBC: the Caps Lock indicator "see Part 3"; the Begin Emphasis
indicator "see Part 5"; the Begin Shape indicator "see Part 8"; and the
Begin Nemeth Code indicator "see Part 12". Since these indicators are
unique to CBC, a transcription containing the Begin CBC indicator
immediately followed by one of these indicators would be redundant. So the
Code says you suppress the generic Begin CBC indicator in favor of one of
the other four.
#[style=Trans note]# We've designed the ClasX-CBC data entry codes to be
as consistent as possible. You always begin embedded CBC with (\\cb). When
your inkprint shows: The ClasX data entry is
Use the \\cb PRINT \\cf statement.
And the resulting Grade 2 plus CBC transcription is:
,use ! _>print_: /ate;t4
ClasX-CBC automatically suppresses the generic Begin
CBC indicator _+ in favor of the Caps Lock indicator
_>. The full details on the commands for the Begin
Emphasis, Begin Shape, and Begin Nemeth code indicators are provided in
the relevant Parts.
The only way to get into the CBC translation and
printing system is to use (\\cb), (\\cbs), or "as discussed in Part 12" to
leave Nemeth Code. The only way to return to grade 2 translation and
format is with (\\cf) or (\\cfs). It is very important to
balance these critical "gatekeeper" commands. You can't
start out with (\\cb) and finish off with (\\cfs); be sure to check that
these pairs balance when you proofread your inkprint data entry.
As we introduced in the ClasX Overview, the M.I.T.
Terminal Code doesn't provide a way to distinguish between uppercase and
lowercase letters, while CBC does. The information in this part is to
assist you in proofreading CBC materials, as the translator places all the
capitalization symbols automatically.
As mentioned in Part 1, a single uppercase letter is
preceded with dots 4-5-6. When you enter (A) the translator creates
_a. The uppercase letter may appear within a word. For
example, the program token (MouseDown) would appear as
_mouse_down.
Here's a trickier example: to show the inkprint
expression \\is f1Mouse_Downf15 \\xs your data
entry is (Mouse__Down); you type two underbars in your transcription for
each underbar in inkprint. Once When there's more than one uppercase letter, CBC uses
the Caps Lock indicator: _> dots 4-5-6, 3-4-5. Two
different symbols can cancel Caps Lock: one space, or the explicit "Caps
Release" indicator _< dots 4-5-6, 1-2-6. The translator
places the Caps Lock and Caps Release indicators; your print data entry
just copies the capitalization of your original. Here are some samples:
Some computer languages are all lowercase, some all
uppercase, and some are a mixture. If you were transcribing a book about
Applesoft BASIC, almost all the CBC would be in Caps Lock. CBC's "Reverse
Capitalization" rule provides significant space-saving in this situation.
You alert the braille reader to Reverse Caps with a transcriber's note,
and then the _< and _> indicators reverse
their meanings. A single underbar before a letter means a single lowercase
letter; dots 4-5-6, 3-4-5 means "Lowercase Lock;" and space or dots 4-5-6,
1-2-6 means "Lowercase Release."
When transcribed in Reverse Caps mode, the samples
above would appear as:
The ClasX-CBC command for Reverse Caps looks like a
translator control: (_rc) space, underbar, lowercase r,
lowercase c, space. As with all of ClasX-CBC's underbar
commands, you must type it within CBC: after the (\\cb) or
(\\cbs) command that starts CBC translation and format. For one
translation session, you continue in Reverse Caps mode until you
explicitly cancel it with space, underbar, lowercase n,
lowercase c, space (_nc). You must return to Normal
Capitalization within CBC translation. If you type (_nc)
outside CBC, then the Grade 2 translator produces .nc instead
of cancelling Reverse Caps mode.
Reverse Caps only affects CBC translation; Grade 2
text is unchanged. When an entire book uses Reverse Caps, you only mention
this once on the Transcriber's Notes page. When a book contains both
normal and Reverse Caps CBC, your transcriber's notes must make clear
which is being used.
Here's a quick sample that illustrates using Reverse
Caps with the ClasX-CBC commands for set-off CBC. The inkprint looks like:
#[style=Trans note]# Inkprint sample omitted
#[Xstyle=Trans note]#
Since all the letters in this sample are uppercase, it
is a good candidate for Reverse Caps mode. Let's suppose that other text
in this transcription doesn't use Reverse Caps mode, so this program
fragment would need a transcriber's note. The ClasX data entry looks like:
$s \\cbs _rc 15 ST = 130 * 256:CD = 114 * 256:DIR =
149 * 256
<CR>20 HOME : HIMEM: 29184
<CR>30 D$ = CHR$ "4"
<CR>50 U = 30 * 256:EC = 14 * 256:UQ = U + 109
_nc \\cfs
$s Program line 30 shows a common Applesoft convention
...
Since other CBC samples won't necessarily use Reverse
Caps mode, we returned to Normal Caps by typing (_nc) immediately before
we ended the CBC segment. The translated result, when formatted on a
40-cell line, is:
\\bs
''' ,"h >e five l9es f ? program3
,',foll[+ uses rev]se
capitaliz,n4,'
15 st = 130 * 256:cd = 114 * 256:dir _&
= 149 * 256
20 home : himem: 29184
30 d$ = chr$ "4"
50 u = 30 * 256:ec = 14 * 256:uq = u _&
+ 109
,program l9e #cj %[s a -mon ,apples(t
3v5;n '''
The _& characters that appear on
braille lines 5 and 9 are the "Continuation Indicator." They show when one
inkprint line continues on subsequent braille lines, and they're detailed
in Part 5.
Every time BEX loads option G - Grade 2 translator on
the Main Menu, you begin in Normal Capitalization mode. For every BEX
Here's what can happen when you don't include the
(_rc) command in every chapter. Suppose you have two chapters:
In addition to indent and runover variation, some CBC
formats require the addition of characters in transcription. Fortunately,
these situations are handled automatically by ClasX-CBC. The information
here serves as a guide to proofreading your formatted, translated
chapters.
The Code prohibits any isolated
lower-cell signs. "Isolated" means a single cell preceded or followed by a
space or the end of a braille line. "Lower-cell" means any braille cell
that doesn't contain dots 1 or 4. For example, the inkprint digit 2 is
represented by dots 2-3 in CBC. When the CBC digit 2 appears with spaces
on both sides, or starts or ends the braille line, the braille reader
can't be sure what cell it is. The Code resolves this
ambiguity by preceding the lower-cell sign with our friend dots 4-5-6.
There are fifteen characters that are preceded with
dots 4-5-6 when they appear isolated in a CBC transcription: quotation
mark, apostrophe, comma, hyphen, semicolon, and the digits 1 through 0.
ClasX-CBC handles this automatically: The underbar prefix is added
$s \\cbs 1 - Copy Files<CR>
2 - Delete Files<CR>
3 - Rename Files \\cfs $s
then the CBC transcription is:
\\bs
_1 _- _copy _files
_2 _- _delete _files
_3 _- _rename _files
These underbars are automatically added to lower-cell
signs in both set-off CBC like this sample, and embedded CBC.
Most computer screens display at least 80 characters
on the line, while braille is limited to 41 cells or less. The
"Continuation Indicator" provides the braille reader with a clear picture
of how the inkprint original is broken into lines. This pair of two cells,
_& dots 4-5-6, 1-2-3-4-6, shows when a single inkprint
line of computer notation runs over to the next braille line. The
subsequent material runs over to cell 2 on the next braille line for
set-off material, or the current braille margin for embedded material.
In ClasX-CBC, the translator and formatter work
together to handle the Continuation Indicator automatically. The
Code provides several criteria for when it's OK to break the
braille line and place the Continuation Indicator. Considering that
computers are a lot dumber than humans, ClasX-CBC does a pretty good job
of following these guidelines. In Section 3, Part 5 we detail how you can
"tweak" the final data in the rare situations where the line
breaks too early.
Program line 15 is one line in the inkprint original.
There's one space between the The Code recommends that embedded CBC
appears on one braille line, wherever possible. When the CBC expression is
short, then it can just fit in to the regular pattern of braille lines.
But if the CBC expression is 12 cells long, for example, and it would
start in cell 35, you break the line early and start the CBC at the
current braille margin of the next line. The grade 2 material that follows
the embedded CBC resumes on the same braille line.
When the embedded CBC is more than 40 cells, it's
impossible for it to all fit on one braille line. In this case, the
Code says to move to a new line to begin the embedded CBC,
and then use the Continuation Indicator as needed. Suppose your inkprint
data entry is:
$pThe statement \\cb
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,;:?/"-+=$"
''', \\cf defines which characters are acceptable input.
The translated result, when formatted to a 40 cell
braille line, is:
\\bs
,! /ate;t
_>abcdefghijklmnopqrstuvwxyz_<abcdefgh_&
ijklmnopqrstuvwxyz0123456789.;,:?/()-+_&
=$"''',_: def9es : "*s >e a3epta# 9put4
As per the Code's recommendations,
ClasX-CBC moves to a new braille line after the word "statement". The next
two braille lines This example is clearly a "worst case scenario." It's
much more likely that your embedded CBC occupies less than 40 cells. As
your text is translated from inkprint to CBC, the translator places the
discretionary line break <DLB> control character at good spots to
break the line. These <DLB> characters prevent any grade 2
punctuation that touches CBC from being "orphaned" at the start of a
braille line.
Many computer materials distinguish between what a
human types and how the computer responds. The inkprint may use
underlining, or lighter and bolder typefaces. The Code for Computer
Braille Notation uses "Emphasis Indicators." The Begin Emphasis indicator
is _* dots 4-5-6, 1-6 and the End Emphasis indicator is
_/ dots 4-5-6, 3-4. Note that there's an
explicit End Emphasis indicator; the generic CBC Termination
indicator does not terminate emphasis. When your inkprint uses more than
two styles of type, then you need to use "Transcriber's Option" symbols
"Part 10" in addition to Emphasis indicators.
Distinguishing computer notation with CBC's Emphasis
indicators is similar to enclosing text in parentheses. A single Begin
Emphasis indicator means that all the cells up to the End Emphasis
indicator are emphasized. The Begin Emphasis and End Emphasis indicators
touch the words or symbols that are emphasized.
When embedded computer braille starts out emphasized,
then the generic Begin CBC indicator is suppressed. Since _*
is only meaningful in CBC, its presence is sufficient to signal the start
of embedded CBC notation. However, the End Emphasis indicator is always
required, so the final embedded, emphasized CBC word ClasX-CBC commands for Emphasis look like translator
controls: (_e) underbar, lowercase e, space places the Begin
Emphasis indicator, while (_f) space, underbar, lowercase f,
places the End Emphasis indicator. When the inkprint shows:
#[style=Trans note]# Inkprint sample "showing A greater than emphasized"
omitted
#[Xstyle=Trans note]#
you could transcribe the bolder type with emphasis.
Your data entry would be:
_eA>_f dir [Enter]
and the formatted translated result is:
_*_a>_/ dir [_enter]
When your embedded CBC begins with emphasis, place the
ClasX-CBC Begin Emphasis command immediately after the CBC Begin command:
(\\cb_e). ClasX-CBC automatically suppresses the Begin CBC _+
indicator in favor of the Begin Emphasis _* indicator.
Similarly, when the emphasis ends at the point where
you switch back to grade 2, place the ClasX-CBC End Emphasis command
immediately before the CBC Finish command: (_f\\cf).
For example, suppose the inkprint shows:
#[style=Trans note]# Inkprint sample omitted
#[Xstyle=Trans note]#
Then your inkprint data entry would be:
$pAs with the \\cb _e A> _f \\cf prompt, the \\cb
_e B> _f \\cf prompt shows which drive DOS is currently working with.
...
\\bs
,z )! _*_a>_/_: prompt1 ! _*_b>_/_:
prompt %[s : drive ,,dos is curr5tly "w+
)4 '''
\\xs
Emphasis only works within CBC. If you entered these
ClasX-CBC commands outside the CBC notation, then you would definitely
notice it when proofreading to the Braille Previewer. When the translator
encounters (_e) or (_f) in grade 2 mode, it produces a single italic
letter with the letter sign: .;e or .;f.
The Code for Computer Braille Notation provides two
ways to transcribe spaces, because they can serve two roles in computer
material. When spaces appear at the start of a computer program line they
are generally illuminating the structure of the program. These spaces are
showing levels of indentation, and the Code provides a
pattern of braille indent and runover variation to precisely transcribe
systematic inkprint indentation. Spaces can also appear inside computer
notation; in that case they are usually "meaningful," "significant" or
countable spaces. Four or less countable spaces are simply
shown with the same number of braille spaces; five or more spaces are
transcribed with CBC's "Countable Spaces" indicator.
Deciding what role spaces play in the document is part
of structuring. Fortunately, most computer-related texts start with a
notation key explaining the roles spaces have in that document. Some
computer materials will use a unique printing character to stand for every
space, to assist the sighted reader in counting spaces where they are
crucial. Check with your certified transcriber or proofreader: you might
transcribe this symbol as a space, or you may use one of the Transcriber's
Option symbols "Part 10".
When in doubt, spaces at the start of the line are
considered as levels of indentation, not as "countable spaces." The
braille lines follow the same pattern of indentation as the
print, but do not necessarily use the same number of spaces.
Systematically indented computer notation is always transcribed as set-off
CBC, inside ($s \\cbs) and (\\cfs $s) commands. The first level indents to
cell 1, the second level indents to cell 3, the third level indents to
cell 5, and so on by two-cell jumps. As with all set-off CBC, every
runover begins in cell 2, regardless of the level of indentation.
The ClasX-CBC commands for indented material use the
general pattern (<CR>\\#c), substituting a digit between 0 and 7 for
the number sign. Type (<CR>\\0c) at the start of program lines that
begin at the inkprint left margin; the first level of inkprint indentation
is shown with (<CR>\\1c), the second level of indent by
(<CR>\\2c), and so forth. The highest level supported by ClasX-CBC
is (<CR>\\7c), which indents to cell 15. The (\\#c) commands only
affect indent; the runover to cell 2 is accomplished by the ($s \\cbs) and
(\\cfs $s) which must enclose the computer notation.
(\\cfs $s) returns your text to the standard braille
paragraph values--indent to cell 3, runover to cell 1. When the grade 2
that precedes and follows the set-off CBC uses a different indent and
runover, you must repeat the appropriate TranscriBEX command. For example,
if the systematically indented CBC appears within a bulleted list in
inkprint, then your ClasX-CBC data entry would follow this general
pattern:
\\items$p[grade 2 item in list]
$p[grade 2 item in list]
$s \\cbs\\0c[CBC program line]
<CR>\\1c[CBC program line]\\cfs\\items
$s [grade 2 item in list]
$p [grade 2 item in list]
CBC treats significant spaces differently depending on
how many appear in series. For up to four spaces in a row in inkprint, you
simply represent these with braille spaces, while you use the Countable
Spaces indicator when there are five or more spaces. The Countable Spaces
indicator's total length is equal to the number of meaningful spaces. It
starts with one space, then dots 4-5-6, followed by a variable number of
= full cells, finished by a single space. The number of full
cells is three less than the number of meaningful inkprint spaces.
For example, the inkprint looks like:
#[style=Trans note]# Inkprint sample "showing many spaces after the first
quote mark in each line" omitted
#[Xstyle=Trans note]#
Program line 10 contains 12 meaningful spaces, while
line 20 contains 12 meaningful spaces, a digit, then four meaningful
spaces. The CBC transcription on a 40-cell line looks like:
10 _>print _" _========= _press _one _&
_number"
20 _>print _" _========= _1_save _&
_files"
,h[ wd ! \tput *ange if l9e #bj 0
*ang$ to
8_+20 _>print _" _===================_&
=== _1 _======= _save _files"_:08
The Code defines two criteria to meet
before breaking a Countable Spaces indicator between lines: at least two
full cells must precede the Continuation Indicator, and at
least three full cells must appear on the runover line. ClasX-CBC takes
care of this automatically.
While in CBC mode, BEX's translator changes five or
more spaces to the appropriate-length Countable Spaces indicator. If you
are a careful typist, you can enter significant spaces in your inkprint
chapters by pressing the space bar the correct number of times. But you
must be a very careful typist. Many typists have the habit of
typing two spaces at the end of a sentence, which is great for inkprint
but incorrect for braille. To make TranscriBEX more forgiving, plain
ClasX-CBC provides another way to enter meaningful
spaces: the (\\sp#) command. "sp" stands for spaces, and yes, there are
two number signs. That's because the numerical value of the
(\\sp#) commands must always be a two-digit number. To enter four
meaningful spaces, you enter (\\sp04) in your inkprint; to enter 12
meaningful spaces, you type (\\sp12) in your inkprint. The spaces on
either side of this command are not counted in the "meaningful" total:
more details in Part 14.
$pHow would the output change if line 20 was changed
to "\\cb 20 PRINT "1Save Files" \\cf"?
The alternative is using the (\\sp#) command:
$pHow would the output change if line 20 was changed
to "\\cb 20 PRINT " \\sp25 1 \\sp09 Save Files" \\cf"?
The When you always use the (\\sp#) command for more than
one meaningful space, then you can use Replace characters to change two
spaces to one before you process your original \\ command
chapters through Here's a fragment from a Pascal program:
#[style=Trans note]# Inkprint sample "showing systematic indentation"
omitted
#[Xstyle=Trans note]#
Here's one way to transcribe it, where you type the
exact number of spaces "notice that every underbar in the original becomes
two underbars in the data entry":
$s \\cbs\\nobreak11\\0c begin
<CR>\\1c if o__rand then
<CR>\\1c begin
<CR>\\2c index := random "length
"keyboard[o__diff]" - 1" +1;
<CR>\\3c { random index into keyboard array }
<CR>\\2c nextchar := keyboard [o__diff][index];{
use it to get character }
<CR>\\1c end
<CR>\\1c else{ working from a file }\\cfs $s
And here's an alternative way to type it, using the
data entry shortcut and the (\\sp#) explicit spaces command:
<CR>\\1c if o__rand then
<CR>begin
<CR>\\2c index := random "length
"keyboard[o__diff]" - 1" +1;
<CR>\\3c { random index into keyboard array }
<CR>\\2c nextchar := keyboard [o__diff][index];
\\sp02 { use it to get character }
<CR>\\1c end
<CR>else \\sp08 { working from a file }\\cfs$s
The (\\nobreak11) command prevents the program from
being split between two braille pages--more details in Part 7. No matter
which way you do the data entry, the result is identical. Here's how it
looks when brailled on a 40-cell line "we've added a row of asterisks top
and bottom to assist you in counting the spaces"
\\bs
****************************************
begin
if o__rand then
begin
index := random (length (keyboard[_&
o__diff]) _- 1) +1;
_[ random index into keyboard _&
array _]
nextchar := keyboard [o__diff][ind_&
ex];_[ use it to get character _]
end
else _===== _[ working from a file _]
****************************************
\\xs
In an ideal world, all program listings would fit on
one braille page. The Code's formats for program listings
depend on whether they do indeed fit on one page. We'll call a program
that uses less than 25 braille lines a "short" program, while one 25 lines
or more is a "long" program.
"Long" program listings are transcribed on their own
braille pages. When the program has a label, then that's included in an
identifying running footer. The grade 2 text ends, then you move to a new
braille page to start the listing "and footer, if present". When the
listing is finished, you move to a new braille page, "cancel the footer"
and resume braille text. The transition between braille pages, like the
skipped lines, alerts the braille reader to the change in codes.
"Short" program listings by definition fit in one
braille page. Literary text may end early on one braille page to allow a
short listing to begin at the top of the next braille page, and this move
to a new braille page includes the "skipped line" that signals the
transition to CBC. When the listing is done, there's a skipped line and
the grade 2 text resumes on the same braille page.
The commands for "short" programs are already
explained in Section 6; you start with ($s\\cbs) and end with (\\cfs$s).
In order to insure that a "short" program won't be divided between braille
pages, add the (\\nobreak#) command "introduced in Section 6, page 6-13 of
the TranscriBEX Manual" after the (\\cbs). Replace the number sign with
the number of braille lines required for the program; BEX then moves to a
new braille page if there is not enough room. In the samples for Part 6,
the listing began ($s\\cbs\\nobreak11\\0c). "As explained in TranscriBEX
pages 18-7 through 18-8, placing $$vl11 in your final "$2" chapters has
the same result."
Three commands do all the work. (\\listing) moves to a
new Since the move to a new braille page signals the
switch in codes, this transcribing situation is unique in ClasX. You don't
use ($s) skip-line indicators to introduce and finish set-off notation. A
"long" program listing without an identifying label follows this pattern:
[literary text.] \\listing\\cbs[Start of program]
...
[end of program]\\endlisting\\cfs[literary text at
cell 1]
In this case, the literary text starts in cell 1. When
you want a paragraph indent, add a paragraph indicator to the end:
[literary text.]\\listing\\cbs[Start of program]
...
[end of program]\\endlisting\\cfs$p[Literary text at
cell 3]
Notice that you use ( $p ), not ($s) when
you finish up a program listing with paragraph indent. When you do have an
identifying label to place as a running footer, follow this pattern:
[literary text.] \\listing\\footer [Program
Label]<CR>
\\cbs[Start of program]
...
[end of program]\\endlisting\\cfs[Literary text at
cell 1.]
Again, for a paragraph indent, add the paragraph ( $p
) indicator. (\\endlisting) returns to standard braille paragraphs: indent
to cell 3, runover to cell 1. When the program listing is within a
different indent and runover format, repeat the TranscriBEX command that
establishes the format.
(\\footer[Program Label]<CR>) is just like
TranscriBEX's (\\runninghead[Text]<CR>) command, except it affects
the bottom line, not the top. Be sure that you place the
Here's the beginning and ending of a "long" program,
taken from Adobe System's PostScript Language Tutorial and
Cookbook. The full transcription appears in Section 3.
\\textbookformat \\pp 92 \\setnumber99 ...$s\\mh
Putting Codes into Strings \\rt$pThe following program uses \\cb _e put _f
\\cf to generate a table of the characters whose standard codes are
greater than 160. Note that some of the codes listed have no characters
associated with them. \\listing \\cbs \\0c % -------- Variables &
Procedures -------- <CR>
/Times-Roman findfont 10 scalefont setfont <CR>
... 24 intervening program lines ...
\\0c 161 1 208 {PrintCodeandChar} for \\pp 93
<CR>
/LM 144 def <CR>
LM 600 moveto <CR>
225 1 251 {PrintCodeandChar} for <CR><CR>
showpage \\endlisting \\cfs$pThe \\cb prt-n \\cf
procedure defined above takes a number from the stack and prints it on the
current page. ...
Notice that the program line beginning with Some programming languages, like BASIC, number every
program line. You type these numbers as part of the CBC, as shown in the
preceding samples. Programming books may also show "reference" line
numbers that help the reader identify a particular program line. These
reference line numbers are not part of the computer program, and they
should not be transcribed in CBC. ClasX-CBC handles these reference line
numbers just like TranscriBEX handles line-numbered poetry and prose: with
the (\\numberedlines), (\\endnumberedlines), (\\ln[number]), and
(\\rightzone#) commands.
The (\\ln[number]) command places the
Before you can precede each numbered line with the
appropriate (\\ln[number]) command, you must establish the line number
zone with (\\numberedlines). The default size of the line number zone is 6
cells: you can change this with the (\\rightzone#) command. "To maximize
space on each line, use a # value one greater than the longest inkprint
line number." Once you've established a line number zone, ClasX-CBC
respects its left boundary when placing Continuation Indicators. To free
up the last 6 cells on the line for text again, cancel the line number
zone with (\\endnumberedlines). Place these (\\numberedlines) and
(\\endnumberedlines) commands inside the set-off CBC.
#[style=Trans note]# When the inkprint looks like: Your ClasX-CBC data entry would be
$s\\cbs \\nobreak15 \\numberedlines \\rightzone2 \\ln
1 \\0c { TYPDRILL is a program that drills the user in typing speed and
accuracy }
<CR>
<CR>\\ln 2 {$V-} \\sp04 "* allow small strings
to be passed to procedures *"
<CR>\\ln 3 {$I screenio.pas} \\sp02 "* handles
function keys and command lines *"
<CR>
<CR>\\ln 4 type \\sp03 string14 = string [14];
<CR>\\ln 5 \\1c string80 = string [80];
<CR>\\ln 6 string5 \\sp02 = string [ 5];
<CR>\\ln 7 \\0c const \\sp02 n__diff = 6; \\sp10
{ number of degrees of difficulty }
<CR>\\ln 8 \\1c time__incr = 100; \\sp05 { 100
msec timer increments for measuring speed } \\endnumberedlines \\cfs$s
And the braille result, formatted on a 40-cell line,
looks like:_
drills the user in typing speed _&
and accuracy _]
_[$_v-_](* allow small strings _&b
to be passed to procedures *)
_[$_i screenio.pas_](* handles _&c
function keys and command lines *)
typestring14 = string [14];d
string80 = string [80];e
string5= string [ 5];f
constn__diff = 6; _======= _[ _&g
number of degrees of difficulty _]
time__incr = 100; _== _[ 100 msec _& h
timer increments for measuring _&
speed _]
The CBC Shape Indicators allow the representation of
non-ASCII characters. The Begin Shape indicator is _$ dots
4-5-6, 1-2-4-6. The End Shape indicator is CBC's generic Termination
Indicator _: dots 4-5-6, 1-5-6. Between these symbols, the
transcriber places one or more characters that clearly describe the
inkprint characters. Often the cells enclosed are selected from Nemeth
code.
For example, when a programming language uses an open
box character, the CBC transcription could be _ $$4_: dots
4-5-6, 1-2-4-6, 1-2-4-6, 2-5-6, 4-5-6, 1-5-6. The $4
construct is borrowed from Nemeth code. Many inkprint computer manuals
show pictures of individual keys with the character name inside a small
box. For these "keycaps," CBC uses the letter k followed by
the key name, enclosed in the shape indicators. So when the manual always
shows a rounded-corner box labelled "Enter", the CBC transcription would
be _$k_enter_:.
Shape indicators can appear in both set-off and
embedded CBC transcriptions. Begin the Shape Indicator with (_s), followed
by the characters you have chosen, and finished with (_t). "As with all
ClasX-CBC underbar commands, these only work within CBC."
Just like the Caps Lock and Begin Emphasis indicators, the CBC Begin Shape
indicator implies the beginning of embedded CBC. When an embedded CBC
shape indicator is the first CBC symbol, the explicit CBC indicator
_+ is suppressed in favor of the CBC Shape indicator
_$. ClasX-CBC handles this automatically, as you'll see in
the next sample.
While the Begin Shape indicator replaces the Begin CBC
indicator, the termination indicator that finishes up the Shape indicator
does not necessarily mean the end of CBC. When the last embedded CBC word
is a Shape Indicator, then you see two termination indicators in a row.
The inkprint shows:
#[style=Trans note]# Inkprint sample "showing keycaps of solid Apple and
left arrow keys" omitted
#[Xstyle=Trans note]#
One way to transcribe these keycaps would be the
letters SA to stand for the picture of the solid Apple, and
the Nemeth code "left arrow" construct for the picture of the left arrow
key. Our ClasX-CBC data entry is:
Press the \\cb _s kSA _t \\cf with \\cb _s k$[ _t \\cf
to move back one word.
The translated result would be:
,press ! _$k_>sa_:_: ) _$k$[_:_: 6move back "o ^w4
While generally computer notation sticks to the
baseline, you may encounter some superscripted or subscripted characters
in your inkprint texts. Number bases other than ten are sometimes shown
with subscripts: 150 subscript 16 would mean the hexadecimal "base
sixteen" The CBC marks a half-shift down with _?
dots 4-5-6, 1-4-5-6. A half-shift up is shown by _# dots
4-5-6, 3-4-5-6. Similar to the Caps Lock indicator, there are two ways to
signal the return to the baseline. When the half-shift up or down is
followed by a space, then the return to the baseline is implicit. When the
return to the baseline occurs within a word, CBC uses the generic
Termination Indicator _: dots 4-5-6, 1-5-6.
The ClasX commands for half line shifts look like
translator controls. Enter (_u) for half-line shift up and (_d) for
half-line shift down. You return to the baseline with (_b). Example 15-2
in the Code shows the inkprint as:
#[style=Trans note]# Inkprint sample "showing t subscript 5 and t
subscript 6" omitted
#[Xstyle=Trans note]#
The ClasX-CBC data entry is:
... A listener may set NDAC low "shown between \\cb
t_d 5 _b and t_d 6 _b \\cf" but, it must do so before NRFD is set high at
\\cb t_d 6 _b \\cf.
The first half shift down is terminated with a space.
The second and third half shifts need the explicit _:
command, because the CBC is embedded within grade 2 punctuation. The
translated result, when formatted to a 40-cell braille line, is:
''' ,a li/5] may set ,,ndac l[ 7%[n 2t
_+t_?5 and t_?6_:_:7 b1 x m/ d s 2f
,,nrfd is set hi< at _+t_?6_:_:4
Notice the two termination signs in a row in the
braille: one to terminate the shift down, and one to terminate the
Computer Braille Code.
In addition to explaining how you represent almost
every imaginable computer text, the Code for Computer Braille Notation
gives you tools for transcribing types of computer text as yet unimagined.
The two "Transcriber's Option" symbols can serve any function you assign
to them. The "Primary" symbol is _! dots 4-5-6, 2-3-4-6; the
"Secondary" symbol is _. dots 4-5-6, 4-6.
Don't let the "primary" label overwhelm you: it simply
means that if you only need to use one of the Transcriber's Option
symbols, use _! instead of _.. Since CBC doesn't
give any particular meaning to _! and _., it's
crucial that you explain how you are using the Transcriber's Option
symbols in a transcriber's note.
The Code proposes two uses for the
Transcriber's Option symbols. When a text frequently includes a character
that's not on the ASCII list, then you can assign that character to one of
the Transcriber's Option symbols. This technique saves a lot of space,
since either Transcriber's Option symbol is just two cells, while the
Shape Indicators "Part 8" are a minimum of six cells long.
When the inkprint distinguishes between three kinds of
computer notation, then you use a Transcriber's Option symbol as another
kind of emphasis indicator. For example, when a manual uses light and bold
typefaces and underlining, then the light type is unmarked,
the bold type is marked with Emphasis indicators, and the underlined type
is marked with Transcriber's Option symbols. In that situation, the
underlined type would begin with the Transcriber's Option symbol and
terminate with the _: generic Termination Indicator.
The commands for these symbols pass through
Suppose your computer text shows a backwards
L with an arrowhead to represent the "Return" key, and you
decide to transcribe this with the Primary _! Transcriber's
Option symbol. The inkprint looks like:
#[style=Trans note]# Inkprint sample omitted
#[Xstyle=Trans note]#
Your ClasX-CBC data entry would be:
We show one press of the "Return" key with the \\cb _!
\\cf symbol. For example:$s\\cbs]CATALOG_! \\cfs$s
Typing (\\cb_!\\cf) is a lot of characters. You can
use Replace characters to cut down on your work. Create a short and unique
cluster of characters, like (|||), and then expand the three vertical bars
to (\\cb_!\\cf) before you proofread your inkprint data entry.
When you are using a Transcriber's Option symbol as an
emphasis indicator, you must manually enter the generic _:
Termination Indicator. Again, what you enter is what you get: type (_:) in
inkprint to get _: in your braille chapter. Here's an
example: The inkprint mainly uses plain and bold monospaced type for
computer notation. Occasionally, an italic monospaced type shows up, like
this:
#[style=Trans note]# Inkprint sample "showing a right paren and the
characters ddd in bold type and the word newline in italics" omitted
#[Xstyle=Trans note]#
You decide to use the Emphasis indicator for the bold
type, and the Secondary Transcriber's Option symbol for the italic type.
Since the \\tn Dots 4-5-6, 4-6 marks italic type
\\endtn<CR>
\\cb \_e " _f \\cf prints one right parenthesis; \\cb
\_e ddd _f \\cf prints character code ddd "octal"; \\cb \_.newline_: \\cf
prints no character; both are ignored.
The translated result, when formatted to a 40-cell
line, looks like:
\\bs
,',dots #d-e-f1 #d-f m>ks italic
type,'
_+\_*)_/_: pr9ts "o "r p>5!sis2
_+\_*ddd_/_: pr9ts "* code ddd 7octal72
_+\_.newline_:_: pr9ts no "*2 bo? >e
ignor$4
\\xs
The Code urges you to cut down on
flip-flops between CBC and the primary braille code. When just a few
literary words separate CBC notation, you can save space by transcribing
the intervening words in CBC as well. Consider the second example in Part
8, where the inkprint is:
#[style=Trans note]# Inkprint sample "showing solid Apple key and left
arrow key" omitted
#[Xstyle=Trans note]#
Just to demonstrate the commands, we exited CBC to
transcribe the word with in literary braille, then reentered
CBC for the left arrow shape indicator. This switch in codes doesn't
improve readability; you'd more likely do your data entry as:
Press the \\cb _s kSA _t with _s k$[ _t \\cf to move
back one word.
,press ! _$k_>sa_: with _$k$[_:_: 6move back "o ^w4
The goal is readability. Especially when literary
punctuation touches CBC, the switch in code can improve clarity. When the
inkprint shows:
#[style=Trans note]# Inkprint sample "showing literary quotes around two
episodes of computer notation" omitted
#[Xstyle=Trans note]#
#[style=Trans note]# then transcribing the word and in CBC
results in massive confusion. This version is unambiguous:
#[Xstyle=Trans note]#
The "\\cb print \\cf" and "\\cb ? \\cf" tokens are
interchangeable ...
,! 8_+print_:0 & 8_+?_:0 tok5s >e 9t]*angea#
'''
While this version
The "\\cb print" and "? \\cf" tokens are
interchangeable ...
,! 8_+print" and "?_:0 tok5s >e 9t]*angea# '''
Repetitive \\cb LOAD \\cfs burden the processor ...
You know the second command is (\\cf),
followed by one lowercase, literary s. However, the computer
is too dumb to recognize this: Repetitive \\cb LOAD \\cf<control-\>s burden the
processor ...
Computer texts can contain mathematical notation
requiring Nemeth Code transcription. Symptoms of the need for Nemeth
include purely mathematical formulas and equations, a horizontal fraction
line, or a dot used for multiplication. There is no Nemeth code translator
hidden deep in BEX's option G - Grade 2 translator. You are
the Nemeth Code translator: you enter any and all Nemeth The Computer Braille Code provides an orderly system
for including Nemeth code within CBC. While it's an orderly
system, it does deal with the intersection of three braille codes. That's
why this Part is a lot longer than the others in the ClasX-CBC Manual.
Before we can tell you the ClasX-CBC data entry codes, you must understand
how to signal the change in codes, and the translation and format issues.
Take a look at example 12-3 in the Computer Braille Code
before you read the next paragraph.
So far, we've said that CBC allows you to include
Nemeth, as long as the Nemeth is included inside CBC. Imagine
Nemeth Code as a box: that box can contain both Nemeth symbols and Grade 2
text. CBC is also a box: CBC symbols and Nemeth symbols can go in there,
but grade 2 text can't. However, when you put the Nemeth box in the CBC
box, you also get the contents of the Nemeth box, which can include Grade
2. So you can end up with Grade 2 inside CBC, as long as the
Grade 2 is within Nemeth that's within CBC. Got that?
Good, because there's yet another level of nesting as
well. Within CBC, Nemeth can, in turn, contain CBC. For example, a formula
describing how a program functions could include a program variable name.
Once you begin manual Nemeth data entry in ClasX-CBC, you may also do
manual CBC data entry within that Nemeth. The sample on page
C2:42 illustrates that this situation is easier to code than it is to
explain.
The Computer Braille Code defines a
variety of ways to signal the switch from Grade 2 to CBC, from CBC to
Nemeth, from Nemeth to CBC, and finally, from CBC out to Grade 2 again. In
CBC, the beginning of Nemeth code is shown by _% dots 4-5-6,
1-4-6. The end of Nemeth code is shown with CBC's Generic Termination
indicator, _: dots 4-5-6, 1-5-6. There are five possible
combinations of code switching. In the chart below, we use three full
cells === to stand for any Nemeth expression, and three
at-signs CBC, Grade 2, and Nemeth each have separate and
different rules for The commands for manual Nemeth only occur within CBC,
so they begin with one underbar. To begin Nemeth type (_%) underbar,
percent; to finish Nemeth, type (_:) underbar, colon. You see the same
_% and _: characters in your final braille
chapter, but a lot of work goes on behind the scenes.
Once the translator encounters (_%) it places the
"leave CBC format" $$ command and shuts down almost entirely; it changes
no characters until it sees the (_:) that terminates manual Nemeth data
entry. Fortunately, CBC's designers made sure that the Generic Termination
_: indicator has no meaning in Nemeth code. When the
translator encounters the (_:), it resumes CBC translation mode and places
the "start CBC format" $$ command.
You enclose all your manual Nemeth code within (_%)
and (_:). Again, we use three full cells === to stand for any
Nemeth expression, and three at-signs \\@ to stand for any
CBC expression. Here's how you do ClasX data entry for the five cases
shown above:
In this last situation, we show the generic (_+)
Begin CBC Indicator, but you could just as well use any valid CBC
indicator. Since (_:) exits manual Nemeth and returns to CBC translation
and format, you can't type (_:) when you're exiting manual CBC to return
to manual Nemeth. Use ClasX-CBC's general-purpose special character,
control-backslash, to prevent the translator from resuming CBC--more on
<control-\> in Part 13.
The following inkprint clearly requires Nemeth
transcription:
#[style=Trans note]# Inkprint sample omitted. The sample shows a program
line and an equation. The variables in the equation need to be transcribed
in computer notation. Exponentiation in BASIC is demonstrated in program
line 301:$s\\cbs301 LET YVAL = "XTRA/3"^2"+1 \\cfs$s\\left Expressed
algebraically, this program line
means:$s\\cbs_%_>yval_<control-\>: .k
"?_>xtra_<control-\>:/3#"^2"+1_:\\cfs$s\\leftNotice how
parentheses insure that the entire quantity ...
The names of the variables \\bs
,expon5ti,n 9 ,,basic is demon/rat$ 9
program l9e #cja3
301 _>let _>yval = "_>xtra/3"2"+1
,express$ algebraic,y1 ? program l9e
m1ns3
_%_>yval_: .k (?_>xtra_:/3#)^2"+1_:
,notice h[ p>5!ses 9sure t ! 5tire
quant;y '''
\\xs
Various arrangements of ASCII characters control how
BEX, TranscriBEX, and ClasX operate. It's perfectly possible that some
computer notation you're transcribing includes characters that
Your inkprint data entry must be:
When the \\cb $<control-\>$wellDone \\cf
variable is executed, each sequence of \\cb $<control-\>s
\<control-\>\i7 \\cf is noted with \\cb __- \\cf; the expression
\\cb count__even \\cf is temporarily suppressed.
When the translated result is embossed on a 40-cell
line, it looks like:
,:5 ! _+ $$well_done_: v>ia# is
execut$1 ea* sequ;e " _+$s \\i7_: is
not$ " _+__-_:2 ! expres.n
_+count__even_: tempor>ily suppress$4
\\xs
If you neglect to include control-backslash, you are
sure to notice the problem! When you don't put <control-\> between
two backslashes or two carets, then you get the <beep>***Error***
message. "After When you don't type <control-\> between two
dollar signs, you can encounter both translation and formatting trouble.
BEX's Grade 2 translator "knows" about $$ commands, and doesn't try to
translate them. All translation modes--grade 2, grade 1, and CBC--turn off
entirely after two dollar signs. Translation resumes only after a
<space> or <CR If you don't type <control-\> between the
two dollar signs for The BEX format command ( $$w#) establish # characters
per line. BEX requires a number after the w. When a number
isn't there, BEX uses a default value of zero. If you neglect to place
<control-\>, then the formatter changes to a carriage width of zero
as soon as it encounters Up to this point, we haven't told you the entire truth
about how ClasX handles spaces around commands. What we have said in the
preceding Parts works fine. This Part is optional reading for people who
want to keep their keystrokes to the absolute minimum.
The general rule is: spaces on the "inside" of
the transcription are optional. All ClasX commands come in pairs:
one command starts something, while the second command ends something. The
ClasX process eliminates a single space that follows a
beginning ClasX command. The ClasX process also suppresses a
single space that precedes a finishing ClasX command. In the
previous 13 Parts, we have always shown that optional space. Since a CBC
transcription can look like a lot of gobbledegook, we allow these spaces
to make it easier to proofread your ClasX command entry. It's a matter of
personal preference whether or not you type these spaces.
Here's an example with the commands that start and end
embedded CBC notation. Since the four characters backslash, backslash,
lowercase c, lowercase b are the "begin"
command, (\\cb) and (\\cb) create the same result. Since the four
characters backslash, backslash, lowercase c, lowercase
f are the "ending" command, (\\cf) and (\\cf) function
identically.
Now you know about the spaces on one side of ClasX-CBC
commands. It's important to understand that the spaces on the opposite
side are left alone. The space before a beginning command is
"significant": if you want a space there, type a space; if you don't want
a space, don't type one. The mirror image is true for ending commands:
when you type one space after them, you get one space in your final $$
chapters.
In Part 6, we discussed the (\\sp#) and (\\#c)
commands for showing countable spaces and indented program listings.
Both the initial and final space in the (\\sp#) command are
$pHow would the output change if line 20 was changed
to "\\cb 20 PRINT " \\sp25 1 \\sp09 Save Files" \\cf"?
$pHow would the output change if line 20 was changed
to "\\cb20 PRINT "\\sp251\\sp09Save Files"\\cf"?
In Part 10, we discussed the Transcriber's Option
symbols. The second ClasX data entry sample in Part 10 looks like:
\\tn Dots 4-5-6, 4-6 marks italic type
\\endtn<CR>
\\cb \_e " _f \\cf prints one right parenthesis; \\cb
\_e ddd _f \\cf prints character code ddd "octal"; \\cb \_.newline_: \\cf
prints no character; both are ignored.
This sample shows the "optional" spaces which are
suppressed after a beginning command and before an ending command. The
following version uses none of these optional spaces:
\\tn Dots 4-5-6, 4-6 marks italic type
\\endtn<CR>
\\cb\_e"_f\\cf prints one right parenthesis;
\\cb\_eddd_f\\cf prints character code ddd "octal"; \\cb\_.newline_:\\cf
prints no character; both are ignored.
In Part 9, we discussed the ClasX-CBC commands for
half-line shifts up (_u) and down (_d). Since both commands signal the
beginning of a change in baseline, (_u) and (_d) are
acceptable alternatives. To return to the baseline, we told you to use the
(_b) When the half-line shift up or down ends with the
current word, you don't have to use the (_b) command to return to the
baseline. The sample in Part 9 looked like:
... A listener may set NDAC low "shown between \\cb
t_d 5 _b and t_d 6 _b \\cf" but, it must do so before NRFD is set high at
\\cb t_d 6 _b \\cf.
An equally effective alternative is:
... A listener may set NDAC low "shown between \\cb
t_d5 and t_d6 \\cf" but, it must do so before NRFD is set high at \\cb
t_d6_b \\cf.
You still must use the (_b) command for the last CBC
word, because that word ends with punctuation.
As you gain experience in ClasX-CBC data entry, these
spacing issues will become second nature. We hope the following chart
helps you develop a feel for how the various commands covered in this
Section can be combined, as well as how the CBC braille looks when you do
it all right.
The process of creating final braille documents with
ClasX-CBC is very similar to the TranscriBEX process described in Section
7 of the TranscriBEX Manual. The crucial first step for both TranscriBEX
and ClasX-CBC, structuring the transcription, is outside the scope of this
Manual. In consultation with a certified transcriber, you must develop a
plan for how the inkprint will be represented in braille. This plan
includes deciding whether to use literary or textbook format, how
illustrations will be handled, and a host of other issues. In terms of the
CBC portions of the document, you should check to see if there are any
non-ASCII symbols. You also need to consider the roles of spaces in the
computer output: whether they should be transcribed as meaningful spaces
or as levels of indentation.
The Accurate CBC translation and format depend on your
using the right version of BEX on the right kind of equipment. You must
have version 3.0 or later--press U at the Starting Menu to
check the Update Date. To preview or emboss CBC, your Apple must have 128K
memory.
Once the document is structured you can begin data
entry. It's always worthwhile to check to see if the document already
exists in machine-readable form, saving you the effort of typing in all
the text. In Section 5, we show two sample transcriptions that begin as
machine-readable texts.
You may use BEX on a 64K Apple for ClasX-CBC data
entry. In fact, you can use any word processing program you're comfortable
with, as long as it can create DOS 3.3 or ProDOS textfiles. When you're
finished with the bulk of your data entry in a "foreign" word
For the literary portions of the document, you use the
full range of TranscriBEX commands. When your document uses line-for-line
tables or the "do-it-yourself" (\\i#r#) commands, make a note of this
fact, as it affects which transformation chapter you use in Step 2.
When you encounter computer notation within a grade 2
paragraph, enclose it between (\\cb) and (\\cf) commands. For computer
notation displayed in its own inkprint paragraph, use ClasX-CBC's set-off
commands: ($s\\cbs) to start and either (\\cfs$s) or (\\cfs$s\\left) to
finish. When you proofread your inkprint data entry, make sure to confirm
that every (\\cb) is balanced by a (\\cf), and every ($s\\cbs) is balanced
by a (\\cfs$s).
When typing the material that will appear as CBC
braille, make sure to type two underbar characters for every single
underbar in inkprint. Use control-backslash to tell ClasX-CBC that two "or
more" backslashes, carets, or dollar-signs are not commands.
We use the The PostScript Language Tutorial and
Cookbook uses three type fonts for computer notation. Within
literary paragraphs, defined PostScript program tokens appear in italics
and PostScript keywords appear in boldface. The displayed computer
notation all uses one sans-serif typefont; no emphasis or distinction
appears Print the The PostScript Cookbook uses italics for
two different roles: on the first inkprint line of page 92, italics show
the book title. We coded this with TranscriBEX's braille italics commands:
(\\ib) to begin and (\\if) to finish. In the first literary paragraph of
page 93, you see how italics are also used to show PostScript program
tokens: we coded this as CBC within (\\cb) and (\\cf) commands. After the
"Putting Codes into Strings" minor heading, the first sentence has some
emphasized CBC, coded within (\\cb_e) and (_f\\cf) ClasX commands.
Starting on page 92, there a program listing that's 32
lines in inkprint, so it can't fit in a single, 25-line braille page. We
code this with the (\\listing\\cbs) command that moves to a new braille
page and begins set-off CBC. We don't use the (\\footer[text]<CR>)
command as the program is unlabeled in inkprint.
All the program listings in this book are indented
relative to the literary text, but the program line beginning with On print page 93, notice that the set-off CBC
one-liner The displayed material at the bottom of page 93 is a
"short" program listing; we start it with ($s\\cbs\\nobreak5) to prevent
the CBC breaking between braille pages. The value 5 was an
educated guess: there are four inkprint lines, but since the first line
includes some countable spaces, there's a chance it will require two lines
in braille. "When we actually did data entry, we didn't type this
material: we used the clipboard to copy it verbatim, commands and all,
from the long program listing."
In the It's hard to give succinct guidelines for how many
characters to type in each BEX page, because a number of factors interact
to determine data expansion during the ClasX-CBC process. The most
important factor is the proportion of CBC to literary text in the
document. While Grade 2 braille is generally 20% shorter than the inkprint
equivalent, the CBC braille is always slightly longer than the inkprint
original. When the computer notation mixes many lowercase and uppercase
letters, or uses many isolated digits, the CBC braille expands even more.
Some ClasX-CBC commands expand significantly: (\\cfs) becomes 19
characters long when you use For literary text that has a sprinkling of computer
notation, start out limiting each BEX page to 3100 characters. When you're
transcribing program listings that use both systematic indentation and
countable spaces, use a test limit of 2800 characters per BEX page. The
BEX Thick Reference Card ends with a four-column line-for-line table that
uses both Grade 2 and CBC: we had to limit each BEX page to 850
characters.
Once you've finished data entry and reviewed the text
for typos, you use Replace characters to change the \\ commands to $$
commands. Most of the time, your document doesn't contain line-for-line
tables or (\\i#r#) commands, so you can use the "faster"
Your source chapters are your print data entry and
your target chapters are the "scratch" $ chapters. The Get to BEX's Main Menu, remove your BEX disk from
drive 1 and replace it with your ClasX-CBC disk. Place the data disk with
your copy of In this case, we used a shortcut way to name target
chapters. We could also have simply typed With TranscriBEX, you can proofread your chapters at
this point to check whether the format is essentially working. This is not
the case with ClasX-CBC. If you printed the The With your BEX disk in drive 1 and the This dialogue shows another handy shortcut: we told
BEX to present a numbered list of all the chapters on drive 2 that end
with the dollar sign by typing Once you replace and translate your chapters, use the
Braille Previewer to confirm that the format and translation is correct.
You want to review all the literary TranscriBEX formats, of course, and
you also want to check for CBC accuracy.
Print the The first braille page, 99, contains embedded CBC at
the start of braille line 9. This is emphasized CBC: we entered it as
(\\cb_eput_f\\cf) and the result is _*put_/_:. Because we
used the (\\listing) command, the program listing that starts on print
page 92 begins at the top of braille page 100. The translator has changed
every inkprint brace ({) to the two-cell CBC brace _[.
Five-cell Countable Spaces Indicators _== appears before the
Once you have proofread the $2 chapters and all is
well, you are ready to emboss your braille. When you don't have a braille
embosser yourself, and you send your disks to a central location that
does, make sure you mark your disk as ClasX-CBC data. Unless
your central location also has ClasX, the CBC format won't be correct.
When you're not familiar with computers, it can be
tricky to distinguish transcription errors from incomprehensible
computerspeak. To help you develop this skill, we supply two chapters
Check for the spacing around embedded CBC
commands--remember that the spaces on the outside of the
commands are meaningful, while the inside spaces are
optional. "Review Section 2, Part 14 for the full details."
Make sure that the _& indicators are
not appearing in literary text. If they do, it means you omitted a (\\cf)
or (\\cfs) command, and you need to correct the \\ chapters and reprocess.
When the text you're transcribing includes double backslashes, double
carets, and double dollar-signs, preview with extra care. When you neglect
to separate these characters with <control-\>, then translation or
format or both can go crazy.
When you are an experienced transcriber, you can make
minor changes in the $2 chapters to create perfect braille. RDC has tried
hard to make ClasX-CBC do a good job: if you're not sure as to what
changes to make in the final chapters, then you're probably better off
leaving them alone.
In TranscriBEX Section 8, we discuss the
When you encounter systematic translation errors, add
transformation rules to
<CR>c"unc;n<CR><CR>cofunc;n<CR><CR><CR>
;
Always modify a copy of CBC cautions you against splitting one inkprint
program line between two braille pages. This requirement is identical to
the Code of Braille Textbook Formats and Techniques's
suggestion that long lines of poetry should not straddle a braille page
break. The TranscriBEX (\\nobreak#) command can prevent this sort of
problem. You Section 2, Part 4 discusses CBC's _&
Continuation Indicator, and asserts that ClasX-CBC does a good job of
breaking lines in accordance with the CBC guidelines. In the rare cases
where the Continuation Indicator appears "early," you can juggle
discretionary line break <DLB> characters to improve the final
output. It's up to you to decide if this sort of manual tweaking is worth
the effort. As we were writing this explanation, it took us more than two
hours of experimentation to find data that would fail. And even this
output failure was still readable, as you will soon see.
The <DLB> appears on screen as an uppercase
R nestled into a backwards uppercase L. When you
arrow over it, the voice says "ASCII 30." You type a <DLB> character
by pressing control-6. "You don't have to first press control-C, and then
another character, which is the way you enter most control characters." As
its name suggests, the DLB does not force a new line. Rather,
it tells the formatter, "Well, if you have to break the line somewhere,
here's a good spot."
As your chapters are translated from inkprint to CBC,
the translator places <DLB> characters near the end of long embedded
CBC When you are dissatisfied with how the program breaks
CBC material between lines, modify your final translated and formatted $2
chapter. You may delete <DLB> when the line breaks too early, or add
a <DLB> to force a break. To insert the <DLB> in a word, press
control-I control-6 control-N. Here's the inkprint data entry
for the "failing" example we worked so long to create:
#[style=Trans note]# Inkprint sample omitted
#[Xstyle=Trans note]#
When processed through ClasX-CBC and formatted to a
40-cell braille page, the result is
\\bs
,2c ? v>ia# is n def9$1 !
8_+_if_then_else _paint_window do _&
_zoom_window do _close_window _execut_&
e_:0 l9e won't "w4
The program breaks the last CBC word between braille
lines 3 and 4. Carefully counting, however, you see that, once you take
away the final Continuation Indicator, four cells are carried over to line
4 but 4 cells remain on line 3. When you edit the final $2 chapter, the
data looks like this:
,2c ? v>ia# is n def9$1 ! $$mq 8_+_if_then_else
_paint_window do _zoom_window do _close_window
_execut<DLB>e_:0<control-T> $$md<control-T> l9e won't
"w4
<DLB> represents the single control character
that prevents isolated grade 2 punctuation carrying over to a second
braille line. Since BEX had permission to break the line at the
<DLB> character, it did. To include \\bs
,2c ? v>ia# is n def9$1 !
8_+_if_then_else _paint_window do _&
_zoom_window do _close_window _execute_:0
l9e won't "w4
#[style=Trans note]# Inkprint pages C3:13-14 omitted. These pages show
inkprint samples. The final braille follows.
#[Xstyle=Trans note]#
#[style=Trans note]# $$vn $$vp #ib 2f !y c 2 us$ 7see ! .,po/,script
.,language .,cookbook74 ,=a -plete li/ (! "*s & correspond+
codes availa# 9 ! /&>d ,po/,script fonts1 ref] 6!
..,po/,script ,language ,ref];e .,manual4
#[Xstyle=Trans note]#
,"* codes may 2 directly us$ 9 two ways3 !y may 2
9s]t$ 96a /r+ )a $$mq _*put_/_: $$md op],n or us$ directly 9 a /r+s z an
octal 7base ei<t7 numb]4 $$vm
$$vl2 $$vz $$ml4 $$ms0 $$p4 ,putt+ ,codes 96,/r+s
$$ml0 $$ms0 $$mr0 $$i2
,! foll[+ program uses $$mq _*put_/_: $$md 6g5]ate a
ta# (! "*s ^: /&>d codes >e grt] ?an #afj4 ,note t "s (! codes
li/$ h no "*s associat$ ) !m4 $$vn $$p0 $$mc $$ml0 $$ms1 $$ml0 $$p0 $$ms1
% -------- _variables & _procedures --------
/_times-_roman findfont 10 scalefont setfont
/char _1 string def
/nstr _3 string def
/newline
$$ml2 $$p2 $$ms0 $$ms-1 _[ currentpoint 11 sub
$$ml4 $$p4 $$ms0 $$ms-3 exch pop _>lm
exch moveto _] def
$$ml0 $$p0 $$ms1 (/prt-n _== %stack: code
$$ml2 $$p2 $$ms0 $$ms-1 _[nstr cvs show_] def
$$ml0 $$p0 $$ms1 /prtchar _== %stack: code
$$ml2 $$p2 $$ms0 $$ms-1 _[ char _0
$$ml4 $$p4 $$ms0 $$ms-3 _3 -1 roll put
char show _] def
$$ml0 $$p0 $$ms1 /_print_codeand_char _== %stack: code
$$ml2 $$p2 $$ms0 $$ms-1 _[ dup prt-n
$$ml4 $$p4 $$ms0 $$ms-3 ( ) show
prtchar newline _] def
$$ml0 $$p0 $$ms1 % -------- _begin _program --------
/_>lm 72 def
_>lm 600 moveto
161 _1 208 _[_print_codeand_char_] for $$vp #ic
/_>lm 144 def
_>lm 600 moveto
225 _1 251 _[_print_codeand_char_] for
showpage $$vn $$vo-0 $$md $$ms0 $$ml0 $$mr0
,! $$mq _+prt-n_: $$md proc$ure def9$ abv takes a
numb] f ! /ack & pr9ts x on ! curr5t page4
$$mq _+_prtchar_: $$md takes a num]ic code f ! /ack
& pr9ts ! correspod+ "*4 ,! proc$ure does ? 0putt+ ! numb]s 96a "o-"*
/r+ & !n pr9t+ ! /r+4 ,! f/ l9e $$vm
$$p0 $$mc $$ml0 $$ms1 char _0 $$md $$ms0 $$ml0 $$mr0
$$vm
$$p0 places ! /r+ &! 9dex =! $$mq _+put_: $$md on
! /ack4 7,note t ! only posi;n 9 a "o-"* /r+ is z]o4 ,! next l9e $$vm
$$p0 $$mc $$ml0 $$ms1 _3 -1 roll put $$md $$ms0 $$ml0
$$mr0 $$vm
$$p0 br+s ! num]ic code 6! top (! /ack & puts x
9to $$mq _+char_:4 $$md ,f9,y1 ! proc$ure pr9ts $$mq _+char_:1 $$md : n[
3ta9s \r "* code4
,! proc$ure $$mq _+_print_codeand_char_: $$md calls
$$mq _+prt-n_:1 $$md pr9ts ?ree spaces1 & !n calls $$mq _+prtchar_:1
$$md "!by pr9t+ "o l9e ( \r ta#4 $$vm
$$p0 $$mc $$ml0 $$ms1 $$vl5 $$ml0 $$p0 $$ms1
/_print_codeand_char _== %stack: code
$$ml2 $$p2 $$ms0 $$ms-1 _[ dup prt-n
$$ml4 $$p4 $$ms0 $$ms-3 ( ) show
prtchar newline _] def $$md $$ms0 $$ml0 $$mr0 $$vm
,! program xf sets $$mq _>lm_:1 $$md \r left
m>g91 to $$mq _+72_:1 $$md moves 6! top (! page1 & !n calls $$mq
_+_print_codeand_char_: $$md = ea* numb] 2t $$mq _+161 and 208_:4 $$md ,x
!n resets ! left m>g9 to $$mq _+144_:1 $$md & pr9ts ta# 5tries =!
numb]s f $$mq _+225 to 251_:4 $$md ,! codes f $$mq _+209 through 224_:
$$md >e skipp$ 2c !y h no "*s assign$ 6!m 9 ! /&>d 5cod+4
$$ml4 $$ms0 $$i2 $$p6 ,',program \tput appe>s 9 two
n>r[ columns 9 ! left m>g9 ( pr9t page #ib4 ,ea* column 3ta9s a
?ree-digit numb] plus semicolon a4$ 9 transcrip;n1 !n ! 9kpr9t symbol1 5d+
) p]iod a4$ 9 transcrip;n4 ,all \tput is 9 ! same typeface4 ,symbol "ns or
descrip;ns >e sub/itut$ =! 9kpr9t symbols %[n4,' $$ml0 $$ms0 $$i2
,left column3 $$ml2 $$ms0 $$i-2
#afa2 upside-d[n exclam,n po9t4
#afb2 c5ts symbol4
#afc2 ,briti% p.d sign4
#afd2 sla%4
#afe2 ,japanese y5 symbol4
#aff2 flor9 symbol4
#afg2 sec;n m>k4
#afh2 curr5cy symbol4
#afi2 /rai<t s+le quote4
#agj2 left d\# quote4
#aga2 left d\# guillemot4
#agb2 left s+le guillemot4
#agc2 "r s+le guillemot4
#agd2 l[]case lrs 8fi0 ligature4
#age2 l[]case lrs 8fl0 ligature4
#agf2 blank4
#agg2 en-da%4
#agh2 da7]4
#agi2 d\# da7]4
#ahj2 c5t]$ dot4
#aha2 blank4
#ahb2 p>agraph symbol4
#ahc2 bullet4
#ahd2 "r s+le quote at basel9e4
#ahe2 "r d\# quote at basel9e4
#ahf2 "r d\# quote4
#ahg2 "r d\# guillemot4
#ahh2 ellipsis4
#ahi2 p]-?\s& symbol4
#aij2 blank4
#aia2 upside-d[n "q m>k4
#aib2 blank4
#aic2 grave a35t4
#aid2 acute a35t4
#aie2 circumflex4
#aif2 tilde4
#aig2 macron4
#aih2 breve4
#aii2 a35t dot4
#bjj2 umlaut4
#bja2 blank4
#bjb2 op5 circle a35t4
#bjc2 c$illa4
#bjd2 blank4
#bje2 "r-slant+ umlaut4
#bjf2 og"ok4
#bjg2 c>on4
#bjh2 em-da%4 $$ml0 $$i2
,"r column3 $$ml2 $$ms0 $$i-2
#bbe2 upp]case lrs 8,,ae0 ligature4
#bbf2 blank4
#bbg2 sup]script1 "ul9$ l[]case lr 8a04
#bbh "? #bca2 blank4
#bcb2 sla%$ upp]case lr 8;,l04
#bcc2 sla%$ upp]case lr 8,o04
#bcd2 upp]case lrs 8,,oe0 ligature4
#bce2 sup]script1 "ul9$ l[]case lr 8o04
#bcf "? #bdj2 blank4
#bda2 l[]case lrs 8ae0 ligature4
#bdb "? #bdd2 blank4
#bde2 l[]case lr 8i0 )\t dot4
#bdf & #bdg2 blank4
#bdh2 sla%$ l[]case lr 8;l04
#bdi2 sla%$ l[]case lr 8o04
#bej2 l[]case lrs 8oe0 ligature4
#bea2 ,g]man d\# lr 8;,s04 $$ml0 $$i2
More and more inkprint materials are prepared with the
assistance of a computer. This is especially true of computer manuals and
reference materials. The author may write the original document on a word
processor, and submit the document to the publisher electronically. When
all the author's typing has been saved to disk, you may not have to retype
it yourself to create a braille version. Even when the author uses a
manual typewriter to create the manuscript, the publisher generally types
the text into a computerized typesetting system to generate the finished
book.
Before you begin transcribing a computer manual, you
should check to see if it's available in machine-readable
form. By machine-readable, we mean text that's stored as a
file in some computer system. Machine-readable text includes two types of
data: content and markup. The
content is the text itself "what you'd read aloud", while
the markup defines the format. In TranscriBEX, for example,
paragraph ( $p ) and skip-line ($s) indicators, \\ commands, and TCs are
markup: the rest is content.
This Section is devoted to some of the important
issues surrounding machine-readable text. Part 1 addresses the
intellectual talents and software/hardware tools you need to handle
machine-readable text efficiently. Part 2 discusses the various ways
computers store text, and how you know when the type of file you have
access to is a good candidate for a braille transcription. Part 3 explains
the inkprint-specific format information that can appear in
machine-readable text. The following pages will equip you to ask the
source of machine-readable text two crucial questions: "For this file, "1"
is the content correct and "2" is the markup easy to deal with?" Section 5
steps through the transcription of two documents that begin life as
machine readable text.
A successful "data jockey" uses both concrete and
intellectual tools. First and foremost, you must understand that data is
inherently malleable. As long as your original file defines its format
with some coherent markup system, you can use BEX's Replace
characters to BEX's option R - Replace characters was designed for
the exact task of transforming machine-readable text into useful braille.
Before you even think about using machine-readable text, you must be
comfortable with basic Replace "see User Level Section 8". In many cases,
contextual Replace "Master Level Section 6" will save you hours, or even
days, of manual work. In Section 5 we demonstrate a variety of Replace
characters techniques that give you a running start on transforming your
data.
Some types of text need several trips through Replace
characters before they have the right commands. When you're working with
floppy disks, you can end up waiting a long time for BEX to read and write
all that data. At BEX's Master Level, a memory expansion card can be used
for RAM drives. Reading and writing to RAM drives is very fast, because
they are electronic, not mechanical. A modest investment "from $150 to
$300" in a memory expansion card can reap enormous benefits in time saved.
BEX has several features to simplify working with data
from other computer programs. When your machine-readable text is stored as
an Apple file on disk, consult BEX User Level Section 10 - Textfiles. Once
you're familiar with that discussion, you know the difference between a
binary file and a textfile, and how to copy a ProDOS or DOS 3.3 textfile
to a BEX chapter with option R - Read textfiles on the Second Menu.
Getting the data into BEX chapters may require wiring
another computer to your Apple. User Level Section 12 explains option I -
Input through slot, which lets you create BEX chapters by capturing ASCII
text output from any other serial computer.
Most braille transcribers are experts at detail work;
this expertise serves you well as you learn to work with machine-readable
text. However, you may personally prefer fixing things manually to
developing the tools that can fix things automatically. When you enjoy the
challenge of understanding someone else's format scheme, you can use
machine-readable text to make your transcriptions more timely and more
accurate.
Using machine-readable text can ensure accuracy.
Unless you happen to be familiar with the software, hardware, or
programming language under discussion, transcribing computer-related texts
involves typing a lot of seemingly meaningless characters. When you begin
with the right kind of machine-readable version, you know that the content
is correct.
Starting with machine-readable text can save a lot of
time. Computers and their attendant literature change very rapidly.
Software instruction manuals can undergo three meaningful revisions in as
many years. Braille readers are best served when braille editions can be
prepared quickly; sometimes a six-month delay can render a braille
transcription useless.
Basing your transcription on machine-readable text is
not always possible. Depending on a host of factors, starting with
machine-readable text can require more work than manually typing in the
inkprint original. Contacting the publisher, obtaining the files,
determining their format, and designing transformation chapters takes
time. Some files are inherently easy to transform, while others require
multiple, subtle transformations. You must weigh this "massage" time
against the time required for manual data entry.
One important factor is the length of the document.
When the inkprint original is only 40 pages it's certainly quicker to just
type in the text from scratch. On the other hand, when you're transcribing
a 600-page textbook, the time you spend developing tools can be amortized
across a significant number of braille volumes.
In addition to these "hard" issues, there's a crucial
human component as well. The ClasX development team simply doesn't like
typing, and loves fooling around with Replace characters. We
enjoy working with machine-readable text! When you're the
type of person who finds inkprint data entry soothing, by all means,
ignore machine-readable text.
Publishers have been struggling with the variability
of electronic manuscripts for years. As more and more authors use word
processors, it became clear that, without some standard, Babel would
triumph. The International Organization for Standardization "ISO" is a
world-wide group that helps standardize all sorts of things, including the
length of an angstrom, the dimensions of an envelope, and the weight of a
kilogram.
In hopes of bringing sense to electronic manuscripts,
the ISO has proposed a "Standardized Generalized Markup Language" or
"SGML." The SGML is a system of marking all functional
divisions in a manuscript with explicit printing characters. Instead of
marking a heading implicitly with format instructions, such as "14 point
Bookman Bold on 16 point leading," authors provide a tag such
as This strategy is familiar to TranscriBEX users,
because some TranscriBEX \\ commands are like an SGML. Instead of marking
an outdented list with commands that establish indent at cell 1 and
runover at cell 3, you bracket the list with (\\items) and (\\enditems).
The creation of the $$ chapters with The University of Chicago Press has long provided
authors with thorough and witty guidance through the Chicago Manual
of Style. Their Chicago Guide to Preparing Electronic
Manuscripts for Authors and Publishers, 1987 is an excellent
resource on the concept and execution of SGML. It's eminently readable and
brief: chances are good that it provided guidance for the preparer of the
machine-readable text you're working with. We strongly recommend that you
invest in the Chicago Guide to Preparing Electronic Manuscripts for
Authors and Publishers. "Its ISBN is 0-226-10393-5 in paperback;
your local bookstore should be able to order it without fuss." In the
following pages we make frequent reference to this helpful resource; we
abbreviate its title as the Chicago Guide. It's as handy as
the Instruction Manual for Braille Transcribing; the
Chicago Guide can help you understand the various ways text
can be formatted, and most importantly, it helps you communicate clearly
with the publishers when you're trying to get your hands on the
machine-readable data.
If you're intrigued by the issues raised in the
Chicago Guide, you may want to go straight to the source for
the full details. The American Association of Publishers has created a
suite of reference works implementing one version of SGML for American
authors and publishers. The AAP's "Electronic Manuscript Project" has
prepared a brief "Author's Guide to Electronic Manuscript Preparation and
Markup," as well as a thicker "Reference Manual on Electronic Manuscript
Preparation and Markup," and several other handbooks on tabular and
mathematical materials. In our occasional references to these documents,
we use the term "EMP Almost every computer program has a different way of
storing text. It's crucial that you understand what sorts of files are
workable; just because text is stored on a computer doesn't mean that it's
appropriate for ClasX-CBC data entry.
The single trickiest step in working with
machine-readable text is finding out if machine-readable versions of an
inkprint document exist, and then getting your hands on them. You can
expect several phone calls and letters as you work your way from the
publisher's marketing department "which usually handles customer contact"
to the publications department "which actually oversees producing the
manuals". The publications department may not even be the last step: many
computer companies subcontract manual production to outside documentation
consultants.
Once you have tracked down the right person "let's
call her or him the File Czar", you must work together to develop a common
vocabulary. Although standards are slowly evolving, neither a universal
format nor a universal nomenclature exists at present. In this Part, we
provide an overview of the important format issues. The Chicago
Guide can give you insight into the vocabulary of files from the
publisher's point-of-view. Once you understand these distinctions, you
must be able to communicate them to your File Czar. Together you will
discover whether the format of machine-readable text is specific enough to
be of any use.
Ideally, the content of a machine-readable file
exactly matches the final inkprint. The accuracy of the machine-readable
version of a document is intimately related to how the inkprint version
was When the publisher uses conventional typesetting
technology, the machine-readable version may contain many minor errors.
Conventional typesetting is frequently a subcontracted activity. It would
be too expensive to re-typeset an entire page that contains an error.
Instead, small corrections of one to 10 lines are typeset and then pasted
in place. It's important for you to ascertain whether these corrections
are also fixed in the original machine-readable text.
When there are a lot of corrections
pasted in by hand, then you would probably save time if you just type in
all the inkprint manually. Some correction files are simpler to work with
than others: the easy ones label each correction with the page they belong
to. A small group of clearly-labelled corrections doesn't disqualify the
data. The "Open-Apple" sample in Section 5 includes a file containing
nothing but corrections, which is a clear signal that you need to compare
some portions of the processed chapter against the inkprint original.
Even when the content of a machine-readable file
exactly matches the inkprint, some portions of the document may be
missing. Charts, diagrams, tables, photo or figure captions, and title
pages are often typeset using a different technology. For our purposes,
this "missing" data is not a problem. These types of inkprint material
require differential handling in the braille edition: you often have to
enter these sorts of data manually anyway.
When we talked about computer braille in the ClasX
Overview, we discussed the 95 printing ASCII characters: these are the 94
characters on your Apple keyboard, plus the space character. To be useful,
the only printing characters in your source file must be
these 95 ASCII characters. Just to keep things more confusing, this type
of file is known by various names: "plain ASCII" or "plain text"
While some word processing software always stores data
as textfiles, many programs have a unique native file format.
Only the program itself knows how to interpret information in a "native"
file--BEX and AppleWorks are two good examples. In the IBM-PC and
Macintosh environments, this native file format can include 256 different
ASCII characters, some printing and some control characters. This type of
file is also known by a variety of names: "extended ASCII" or "high-order
ASCII" or "eight-bit ASCII" or, as we'll refer to it, high
bit ASCII text.
High bit ASCII creates two problems for the ClasX-CBC
transcriber. First off, no universal standard exists for mapping the ASCII
characters from 128 to 255 on to printing characters. One program stores
the letter E with an accent grave as ASCII 201, while another
program stores the same character as ASCII 148. In addition to accented
letters, the "curling" quotation marks and "curling" single quotes are
always high bit characters, as well as the heavy centered dot "typesetters
call this the "bullet" and trademark and copyright symbols. And secondly,
BEX doesn't handle high bit characters. You can't type high bit text in
BEX's Editor.
The first step when working with a high-bit file is to
globally change these characters to multiple-character sequences that are
appropriate in a braille transcription. For example, you can change the
trademark symbol to the four characters <!HELP> The BEX result is
The "registered trademark" symbol becomes a left
parenthesis; the "fi" ligature becomes a caret; the em-dash is uppercase
Q; the left curling quote is uppercase R, the
right curling quote is uppercase S, and the "fl" ligature
becomes one underbar. While it's conceivable to use contextual Replace to
fix this sort of problem, it requires great care and some manual
confirmation. It's a lot faster to handle these characters in the native
file.
Most microcomputers store data with the ASCII system,
but your machine readable file may come from a minicomputer, mainframe
computer, or dedicated typesetting system that stores characters
differently. If the publisher can't supply ASCII data, then the
machine-readable data won't be useful. A common technique to create ASCII
data is to send the data over the phone lines, since the
telecommunications standards require ASCII characters.
You use communications or
terminal software in combination with a modem to send and
receive data over the phone lines. This capability is not built in to BEX,
but all Apple terminal programs do allow you to save data as either a DOS
3.3 or ProDOS textfile. When your source file is not stored on a
microcomputer, then telecommunicating it may be the only way to get your
hands on the data. When the telecommunicated file uses a completely
generic coding system, then telecommunicating the data does not reduce
All textfiles represent content with the same ASCII
values, but there are crucial differences in how they're formatted. The
more format information present in the textfile, the easier the massage
into braille becomes.
An input file contains commands for a
computer program to use in creating the format. This markup can be generic
tags like the system described in the Chicago Guide. Your \\
command chapters are input files that contain commands only TranscriBEX
knows how to interpret. Since they're mnemonic, it would be relatively
easy for a TranscriBEX newcomer to understand the function of the
TranscriBEX \\ commands. Generally, the only <CR>s in input files
are those signalling a new paragraph or a meaningful new line.
An output file shows the
result of the markup, not the intent. Output files contain
format commands that control a particular brand of printer or typesetting
device--we'll call this type of information device-specific.
When you work with an output file, you won't see markup like
A truly generic input file conforms to the SGML ideal.
All elements in the document, "including headings, type changes,
paragraphs, and meaningful new lines", are explicitly tagged with printing
characters labelling the elements' function. Comparing the inkprint with
the textfile, you assign TranscriBEX and ClasX commands to the explicit
tags. Once this analysis is complete, you write one or However, there's a potential drawback to this type of
data. As a document moves from the manuscript stage to the final
production phase, it undergoes two types of revisions: the content is
copy-edited, and the author's generic tags are transformed to
program-specific or device-specific commands. The alterations in content
due to copy-editing must appear in the file you work with; a
generic tag structure is useless when the basic text doesn't match the
inkprint.
You can also encounter program-specific input files.
Paragraphs and new lines are marked with by <CR>s or other control
characters. Headings, margins, and changes in typeface are marked up with
some combination of printing characters or control characters. Your
TranscriBEX $$ chapters are program-specific: only BEX's formatter knows
how to interpret those long strings of $$ commands. One of the challenging
qualities of this type of file is that some formats don't need explicit
commands, because the program "knows" how to handle the format
automatically. Many typesetting programs automatically suppress the output
of more than one space in a row. An input file specific to that program
could include many multiple spaces; you have to decide if they are
meaningful spaces or not.
But sometimes the smartness of the program can make
life easier for you. Many typesetting programs are clever enough to
generate curling quotation marks automatically. The publisher simply types
straight quotes, and the program generates left and right \\is
f4cc170thcc186f1
5 \\xs quotes appropriately. The input file contains the straight
quotes that the Grade 2 translator needs--you don't have to worry about
changing the curling quotes to straight ones.
Section 5 shows techniques you use to capture this
type of data. The "Open-Apple" sample contains a host of control
characters that create various styles of print on the author's dot matrix
printer. You must compare the hardcopy with the disk file to see what
patterns of characters create what kind of type. Then, you must decide how
It's important to understand the limitations of output
files, since almost every word processing program makes it easy to create
this type of data. When you tell your average microcomputer user, "I want
a machine-readable textfile of that document, please" then half the time
you'll get a device-specific output file. Device-specific files are
preferred because every change in typeface is preserved in the data, which
makes it much easier to identify headings and computer notation.
Unfortunately, you'll frequently get generic output
files, which have the least amount of format information: they're suitable
for telecommunications. It's the "lowest common denominator" for file
types: you can send this sort of data from just about any computer to just
about any other computer. The only "format tools" available are
<CR>s and spaces, but the clever user can convey a lot
of information this way. After all, these are the basic format tools for
braille documents, and you can convey just about any information with
them!
Emphasis can be shown with capitalization and careful
use of double or single quotes. A major head could be flush left and all
caps, while a minor head could be indented ten spaces and upper- and
lowercase. On the negative side, you must throw away most of the
<CR>s that are only relevant to the print format. See the
September/October 1987 RDC Newsletter for ways to do this
painlessly.
In the past few years, a standard way to communicate
with different brands of printers and typesetters has emerged. It's a
"page description language" called PostScript, designed and supported by
Adobe Systems, Inc. Essentially, any computer program on any brand of
computer can write a PostScript description of a page--it's typesetting
Esperanto. The PostScript description is sent to the A PostScript description of a page shares many of the
qualities you desire in the ideal machine-readable file. PostScript
programs use just the plain 95 printing ASCII characters. Carriage returns
and linefeeds are irrelevant; the division of text into lines and
paragraphs is always marked with printing characters. If your File Czar
says that the machine-readable file is a PostScript file, it may be
possible for you to work with it. Then again, it may require ten times as
much effort as typing the text manually.
PostScript is more than a way to put ink on
paper--it's a full-fledged programming language. Each word processing
program that writes PostScript has its own way of doing it: there are
literally an infinite number of ways to center a line of text using
PostScript commands. Before you can decipher a PostScript description of a
page, you must understand the PostScript routines that control where the
characters go. "Good" PostScript programs contain internal documentation
that explain how they work. However, "bad" PostScript programs can set
wonderful type, so you can't depend on internal documentation. We don't
like to say that it's impossible, but the task of reformatting a
PostScript page description into useful TranscriBEX data entry is
definitely not for the faint-hearted.
Word processors and publishing systems use one of two
basic markup strategies. A "tagged text" system uses explicit printing
characters to control format. TranscriBEX is a tagged text system; during
print data entry, you don't see the final braille format. From the
standpoint of TranscriBEX, a tagged textfile is much easier to work with.
You use Replace characters to find a series of printing characters and
change them to the appropriate TranscriBEX or ClasX command.
When an author sits down to write a 200-page manual,
it can be a real pain to remember the exact same formats for each
structural element. To make this task easier, many word processing
programs offer a "format style sheet" capability. The author could assign
"bold 14-point Bookman with 6 points of linespacing above and a 2-point
rule below" to a specific style sheet. Immediately before the author
starts typing the heading text, that program's "use style sheet" option is
invoked.
The advantage of the style sheet approach is twofold.
First, the data entry is consistent, which makes your reformatting task a
lot easier. Secondly, the creating word processor "knows" about the
structural elements in the document. Some software, for example Microsoft
WORD and PageMaker 3.0, can create plain textfiles that include explicit
tags for each style sheet element.
Ask your File Czar whether the creating program is
WYSIWYG or "tagged text." If it's WYSIWYG, then explain how important tags
are for the task of braille transcription. If the program can't create a
tagged textfile, then you have to settle for a device-specific output
file, which may mean a lot more work for you.
For brevity's sake in this Manual, we say things like
"replace the generic tags in the textfile with ClasX-CBC commands."
However, you can't use Replace characters on actual textfiles. Before you
can use BEX's tools to modify the data, it must be stored in BEX chapters.
Two BEX Second Menu options let you do this.
You can begin with a DOS 3.3 or ProDOS textfile, and
use option R - Read textfile to chapter. Or, you can wire another computer
to the Apple, tell the other computer to send the data over a serial
The easiest file transfer is when the foreign file is
already a DOS 3.3 or ProDOS textfile: you're just one Second Menu option
away from BEX chapters. Some common word processors that create Apple
textfiles are FrEdWriter, ProWORDS, and AppleWriter "both DOS 3.3 and
ProDOS". The "Open-Apple" sample in Section 5 starts out as an AppleWriter
ProDOS textfile.
Many other word processors save data in a native file
format unique to that program. See User Level Section 10, Part 6 for
detailed instructions on how you create textfiles within AppleWorks. For
other Apple word processors, check the manual for "File Export" or
"Telecommunication" to learn how to make a textfile.
When the file begins life as an IBM-PC or Macintosh
word processor, then you have several alternatives for moving the data to
the Apple. The first step is using the creating word processor to change
any native file format into a textfile. Some word processors can create
textfiles with printing format characters. For example, in Microsoft Word,
you should choose to save a document as "RTF text," which records all the
format information as printing characters. The sample in Section 5 starts
as a Microsoft Word "RTF" file.
When you have access to the creating computer and
software, one way to move the data from an IBM or Macintosh to the Apple
is over a cable. Use BEX's option I - Input through slot to save the data
as a BEX chapter, and you're ready to roll. BEX User Level Section 12
tells you how to send textfiles with DOS commands on the IBM. You can use
any terminal program on the Macintosh, even a free public domain utility
like Freeterm or the ASLtalk Desk Accessory.
There are software and hardware tools that enable you
to read and write "foreign" disks in "native" disk drives. Keep your eye
on the RDC Newsletter for details. Radio Shack markets a
special disk drive that lets you read and write Apple data in IBM drives.
Apple The markup in your source textfile helps you to
automatically place the majority of ClasX and TranscriBEX commands.
Unfortunately, no single standard guides the format of machine-readable
text, so you need to tap in to your own wit and intuition to create good
braille. This Part addresses the most important issues you need to analyze
as you develop your transformation chapters. Since the Chicago
Guide examines a manuscript from both the authors' and publishers'
point-of-view, it's particularly helpful background for this topic.
When you're working with a generically coded input
file, then the changes are almost one-to-one: the major heading tagged
with The 600-year history of type has generated a lot of
jargon connected with the field. "And the introduction of the Macintosh
has muddied the waters considerably, since Apple uses all the jargon
incorrectly!" Following the typesetting conventions, we refer to the
"regular," "plain," or "base" typestyle as roman type. In
addition to roman type, a document may use style variations on the same
typeface: underlining, italics, boldface, boldface italics, caps and small
caps. When these typestyle changes are significant, they're all generally
represented with braille italics.
A document may also use two or more distinct type
fonts: in RDC's manuals, for example, the text font is Palatino and the
display or The markup to change font or typestyle in headings can
help you zero in on the distinction between headings and text; see the
"Headings" discussion below for details. The font and typestyle changes in
text can help you locate computer notation, as well as emphasized text
that needs braille italics or grade 1. When a computer manual always uses
a distinctive typeface for file names, commands, and so forth, then you
can replace the "start computer type" markup with (\\cb) and the "end
computer type" markup with (\\cf). Be aware that some text that's set in
the roman font may still need CBC; you add the ClasX-CBC commands by hand
in that case.
Word processing and publishing programs can use two
different techniques to signal a change in typeface. Each requires a
different style of BEX transformation, so it's important to recognize
which technique your source textfile employs.
This method calls a particular typestyle or font, and
then explicitly cancels that style. This is how TranscriBEX
handles italics: (\\ib) is the "italic begin" command and (\\if) is the
"italic finish" command. It's also how ClasX-CBC handles CBC material:
(\\cb) begins and (\\cf) finishes.
The Chicago Guide recommends
The second approach begins by explicitly calling a
special typeface "italics, monospace, etc." and finishes by returning to
the roman typeface. You have a variety of different "starts,' but the
"stop" is common to all of them. A TranscriBEX parallel is the (\\rt)
"return to text" command; it cancels any change in paragraph format caused
by a minor heading, poetry, indexes, and so on.
The EMP Guides recommend the
At first glance, you may think the only way to decide
if the This can be one of the crankiest areas in reformatting
machine-readable text. Traditionally, punctuation touching an italics or
boldface word is typeset in the roman typeface. You must carefully
Check the inkprint to see which typeface is used for
touching punctation. It's tricky to discern with a small comma or period,
but becomes clearer when the punctuation is a tall question mark or
parenthesis. Here's a silly sample:
#[style=Trans note]# Inkprint sample "showing roman punctation on both
sides of italics words" omitted
#[Xstyle=Trans note]#
Due partly to more non-typographers setting type with
computers, the style books are soft-pedalling this requirement. The
Chicago Guide and Chicago Manual of Style now
recommend the easier approach of setting any touching punctuation in the
same typeface, where the silly sample appears as:
#[style=Trans note]# Inkprint sample "showing italics punctuation
surrounding italics words" omitted
#[Xstyle=Trans note]#
The braille italics composition sign
precedes the emphasized word. As far as the rules for
literary braille are concerned, it doesn't matter whether the closing
quote touching an italic word is set in italics or roman type. But the
Grade 2 translator can't create the right result when your \\ chapter
looks like:
When I " \\ib grokked \\if " her \\ib intent \\if ,
did she " \\ib reluctantly \\if " say \\ib Get Lost \\if ?
The transformation chapters discussed in Section 5,
Part 2, demonstrate how to avoid these spaced-out italics commands. It's
important to remember, however, that the braille reader does need to see
some mid-word changes in typeface, and TranscriBEX has When a typeface change shows the transition between
literary and computer notation, then your transcription must show the
correct code. Recognizing this, the begin and finish CBC commands for the
translator can be embedded within a word. You definitely don't want your
transformation chapters to transpose punctuation in this situation.
Headings are formatted with a wide variety of tools,
including any or all of the following: explicit tags; additional space
above or below; a change to a larger type size; a change to an italic or
bold typestyle; a change to a different type font; lines "typesetters call
them "rules" above or below; and more space at the start of the line
"evidence of centering".
When identifying headings in generic input files,
check for mnemonics with "h" for heading or "t" for title. Both the
Chicago Guide and the EMP Guides recommend an
"empty end-tag" of Headings are hardest to identify in generic output
files. Look for patterns of length and vocabulary: a heading is generally
less than ten words, and it frequently contains terms like "Chapter,"
"Section," "Part," or "Unit." Computer reference works often number
headings: a line beginning with "2.35:" is a good bet for a heading. Also
check for extra <CR>s before a heading, and perhaps some decorative
punctuation at the start.
The start of a heading may include the markup that
means "start a new paragraph," which you change to the paragraph ( $p )
indicator later on in the transformation. When you find the heading and
change it to the TranscriBEX command, place the skip-line ($s) indicator
as well as the (\\hd) or (\\mh) command. If your chapter has ($p$s\\hd),
then it's easy to delete the The single most important piece of format information
is how the text is broken into lines and paragraphs. Once you know which
strategy is used in your textfile, you know what sort of transformation
chapter you need to write. You want to put BEX's paragraph ( $p )
indicator at the start of every paragraph, and BEX's new-line ( $l )
indicator at the start of some meaningful lines. Then you want to replace
any other <CR>s with spaces, since they are only relevant to the
page layout of the inkprint original.
Just to keep things interesting, meaningful new lines
in inkprint are not always transcribed with <CR> or ( $l ) in your
\\ chapters. For example, when a computer manual moves to a new line to
display computer notation, your \\ chapter shows ($s\\cbs). For poetry,
indexes, and computer program listings, you do use ( $l ) to create
meaningful braille lines that parallel the inkprint structure.
The simplest format marks new paragraphs with printing
characters. For example, the Chicago Guide recommends three
spaces followed by the "begin paragraph" tag: The Chicago Guide addresses meaningful
new lines within the context of numbered and unnumbered "lists;" where the
first item in the list is tagged with Explicit tags for paragraphs and new lines are rare.
In most input files, each paragraph begins with exactly one <CR The
horizontal Markup for meaningful new lines varies widely. Some
programs--AppleWorks, for example--don't give you this capability at all.
When you want to start a new line that doesn't use the paragraph indent
and line spacing, then you have to change the paragraph indent and line
spacing and start a new paragraph. Use the presence of the markup that
changes indent and line spacing to place BEX's new-line ( $l ) indicator.
In more sophisticated word processors, a new line is signalled by a
control character--in Microsoft Word for the Mac, you press shift-Return.
This "special" <CR> is sometimes stored as a high bit set character,
so it can be lost in the transfer to BEX.
Since output files are "printed to disk," every output
line ends with <CR "IBM textfiles end each line with a pair of
characters: control-M Control-J <CR><LF When working with IBM
data, we always strip out the <LF> characters first, making an
Apple-like textfile." You must find a distinguishing feature for
paragraphs: look for two <CR>s, or <CR> followed
by a set number of spaces. In this situation, your replacements must go in
order from most information to least information. Even if you can't find a
distinctive paragraph format, you may be able to use the techniques
discussed in the September/October 1987 RDC Newsletter.
A typeset document contains more characters than those
found on an Apple keyboard. Your source textfile often includes
combinations of characters that make for professional-looking type. You
need to identify these characters and change them to the appropriate ASCII
characters so that the translator creates the right result. The following
overview is by no means inclusive: see Words into Type
"Prentice Hall, 1974" for a deeper explanation.
The prime example are "curling" quotation marks, where
the beginning double quote looks like \\is
f4cc170f15 \\xs and the ending
quote looks like \\is f4cc186f15
\\xs. Braille also uses different signs for opening and closing double
quotes, but the Grade 2 translator places the correct one based on
context. You must identify how curling quotes are coded in your source
textfile, and replace them with the "straight" \\is
f4cc34f15 \\xs quote mark before
translation.
The EMP Guides recommend
As mentioned in Part 2, when your source file is
high-bit ASCII, then these curling quotes are stored as one character. You
must globally replace these curling quotes to "straight" quotes \\is
f4cc34f15 \\xs before
you transfer the file to BEX.
Single quotes can also curl. In typeset output, the
same character is used for the closing single quote and the apostrophe.
When this \\is f4cc39f15 \\xs
character appears at the start of a word, you want to globally change it
to (') so the translator creates an initial apostrophe instead of an
opening single quote. Change all other single quotes to the "straight" (')
character; the translator creates an opening quote, closing quote, or
apostrophe based on context.
The computer keyboard provides one "hyphen" character;
when you type two in a row, you create a "dash." Typeset print, on the
other hand, has a range of horizontal separators: from longest to
shortest, typesetters use the em-dash, the en-dash, the hyphen, and the
minus sign. An em-dash between words should be two hyphens in your ClasX
chapters; a hyphen or minus sign should be a single hyphen. The en-dash is
always used to separate digits, as in 1985-87. In this situation, replace
the en-dash with one hyphen. The en-dash takes the place of a hyphen when
a compound adjective includes a phrase or hyphenated word: Library of
Congress-certified uses the en-dash, not a hyphen. Particularly in British
books, the en-dash may carry the separating function of the em-dash; your
replacement depends on your analysis of the en-dash's purpose in your
source textfile.
Various characters can introduce each item in an
unnumbered list, including dashes, bullets and boxes. Typographers use the
lovely term "dingbats" to describe all other decorative marks using stars,
flowers, arrows, and pointing hands. Generally, bullets and the like are
omitted from the braille transcription: the (\\items) format, with indent
to cell 1 and runover to cell 3, sufficiently conveys to the braille
reader the "itemness" of the entries.
In a generically coded input file, these
attention-getting characters may not appear. The start of a list is coded
with The spaces between words in justified type expand and
contract to make the margins even. Typesetters also use "fixed spaces"
that always have the same width. These spaces can be defined
proportionally to the typesize: an "em" space is as wide as the uppercase
letter M. Paragraph indents are commonly created with one or
two "ems" of fixed space. The presence of "em" markup in an input file can
help you identify paragraphs: this would be replaced with BEX's paragraph
( $p ) indicator. An "em" of fixed The "en" space is as wide as a numeral "or an "en"
dash"; when a list of left-aligned numbers varies in length, the "en"
space precedes the shorter numbers to make everything line up. On the
cover of the inkprint TranscriBEX Reference Card, for example, most of the
digits are preceded with two "en" spaces. This ensures that the row of
guide dots ends at the same place whether it's a one digit number or two
digits separated by an "en" dash. Generally you replace these "en" spaces
with a single space. However, when you're transcribing left-aligned
numerals in tables, you can replace this "en" space with a
<control-S> sticky space to achieve the same result in braille. The
"thin" space is as wide as punctuation characters. When a double quote
touches a single quote, frequently a "thin" space between the characters
clarifies the inkprint.
You may also encounter markup that define absolute
spaces with numbers. These numbers may be in inches, millimeters, picas "6
of these to an inch", or points "72 to the inch, 12 to the pica".
Microsoft Corp., just to be different, uses twips or
twentieths-of-a-point.
Larger horizontal spaces may serve to separate columns
in a table; you can replace these with (\\hw#), (\\w#), (\\fc), or (\\nc)
commands. In a two-column format, you may replace the absolute spaces with
braille dashes or colons. For poetry, indexes, program listings, and other
heirarchical formats, replace the horizontal indent with the appropriate
\\ commands. Some files won't have explicit indent markup; the varying
space at the start of a line is accomplished with tabs. Depending on the
program, pressing Tab can insert a specified number of spaces in the line,
or it can place a <control-I> character in the file.
As in braille, vertical space in inkprint can make
headings stand out or show a change in context or an extract. Use the
presence of vertical space markup to place skip-line ($s) indicators.
Extra vertical space also defines paragraphs that don't indent; usually
the numerical value of this space will be less than the space before
headings. Use the presence of this vertical space markup to place the
paragraph ( $p ) indicators.
"Fully justified" text has even left and right
margins. Text that's aligned to the left margin is variously called "quad
left," "flush left," or "rag right," while text that's even on the right
margin is known as "quad right," "flush right," or "rag left." Finally,
centered text can be referred to a "center justified" or "quad center."
The presence of the markup for justification can help you zero in on
headings, notes, captions, and extracts. Both generic and device-specific
output files can accomplish fully justified margins by "padding out" each
line with extra spaces. When the file also contains meaningful multiple
spaces--showing indented program listings for example--then you must
selectively delete the multiple spaces.
In input files, the (-) hyphen character is "hard":
that hyphen always appears, no matter where the word shows up on the line.
The user may also be able to enter "soft" hyphens giving the program
permission to break the line only when needed. These are usually stored as
<ASCII 31>--just like BEX's discretionary hyphen. Unlike BEX,
powerful formatting software uses dictionaries to hyphenate words
automatically. This is a case where the native software, since it knows
about a format, makes your job easier.
However, when working with output files, hyphens and
fully justified text can be a major issue. When you encounter the (-)
hyphen character immediately before the end of a line in an output file,
you have to make a decision. Is this a soft hyphen inserted by the
program, which should be deleted? Or is it a hard hyphen that should be
preserved in the braille transcription?
Any tagged text system reserves one or two characters
that delimit the actual markup commands. For ClasX-CBC, all commands begin
with two backslashes. When you want to include two backslashes as content
in your transcription, we tell you to separate them with one
control-backslash.
In the Chicago Guide, all markup commands
are enclosed within less-than and greater-than symbols. To show the actual
less-than and greater-than symbols in the manuscript, the author must
code Section 4 discusses a lot of the theoretical issues;
this Section puts that theory into practice. Part 1 summarizes your job as
a data jockey. Part 2, the "Open-Apple" sample, is the longest. It
provides an in-depth narrative of the file massage process, where the data
begins life as program specific input ProDOS textfiles. Part 3 explains
the "Galloping Gobble Technique, which can dramatically increase the
efficiency of your contextual transformation chapters. Part 4 touches on
the wealth of format information available in Microsoft's RTF format--it
started out as a Microsoft WORD file on the Macintosh.
To keep the ClasX Manual workably brief, our examples
are not complete. We highlight some of the handier Replace techniques, and
point you in the right direction when it comes to analyzing format
information. With these tools on your belt, you will be able to complete
the transcriptions yourself. Contextual Replace is definitely your ally
when massaging data--Master Level Section 6 is good background reading for
this Section. In fact, Parts 3 and 4 won't make much sense unless you're
familiar with contextual Replace.
We've slanted these examples to demonstrate just how
much flexibility is inherent in the data. Please don't look
to these samples for guidance in structuring or interpretation of the
braille codes--that's the role of your certified transcriber.
To summarize the information from Section 4, before
you can even think about transformation chapters, you must complete five
tasks.
You must contact the publisher to discover the person,
department, or outside consultant responsible for actual manual/book
production. "You may be able to integrate the search for files with your
request for permission to transcribe a copyrighted work." Once you've
tracked down this "File Czar," discuss the availability and suitability of
files. Important things to mention here are:
When the file is already an Apple II textfile, use
BEX's Read textfile option. When it's a Macintosh file, use the creating
program to make a textfile, then use Apple File Exchange to make ProDOS
textfiles. When it's an IBM file, use the creating program to make a
textfile. You may be able to use a hardware utility to write a ProDOS
textfile in an IBM drive. Alternatively, when it's a file on any serial
computer, cable the machine to BEX and use Input through slot. When the
file isn't ASCII, then get the publisher to telecommunicate the data
"ideally a generic input file". Use a terminal program on the Apple to
capture to disk as textfiles, then use BEX from there. BEX User Level 10
discusses textfiles; User Level 12 explains Input through slot.
Take a quick look at the data to see if it's even
worth proceeding further. Compare your sample with the inkprint: is the
textfile complete and correct? Are there textfiles containing seemingly
random short paragraphs? "If so, these are probably correction files." Are
there any "high bit" problems? Are all font changes present in your
version of the file? Can you figure out how paragraphs are shown?
As you develop your transformation chapters, you are
certainly going to process the data several times. It would take forever
to test your transformations on the entire file. Instead, find a
representative chunk of data. It should meet these qualifications:
These tasks complete, it's time to put on your
Sherlock Holmes cap. You must match the format information in your
textfile to the structural elements of your document. You can't write
effective transformation chapters until you've identified
all the format techniques. It's very tempting to
incrementally alter the data: as soon as you realize the function of a
particular cluster of characters, you want to do something
about it. If you succumb to this temptation, you can create more work for
yourself down the line.
While you are waiting for the files to arrive from the
File Czar, prepare a three-column chart. In the first column, note the
structural elements present in the inkprint. In the second column, jot
down the appropriate TranscriBEX and ClasX-CBC commands. Once the
textfiles arrive, print them to the screen or examine them in the Editor,
noting the markup system associated with each element on your chart.
When the markup use control characters, you may not be
able to print the text to the screen. Some control characters make the
screen display go nuts: a <control-Q> printed to the 80-column
screen abruptly changes the display to 40-column. We recommend you change
the control characters to unique combinations of printing characters that
don't appear as data in the textfile. See Part 2 for how we did this in
the "Open-Apple" sample.
The completed chart of structural elements and markup
in hand, you begin to design your transformation chapters. Look through
the chart for repetitive elements. When both "major headings" and "minor
headings" use a "bold font" command, then the presence of the bold font is
not sufficient to define the headings. Instead, you must find a
combination of bold font plus something else that distinguishes the two
levels of headings. Perhaps "major headings" start with two <CR>s
plus the bold font command, while "minor headings" start with one
<CR> plus the bold font command.
Many times a single transformation chapter can't do
all the changing. Instead, you need to have successive
transformation chapters. The first chapter can place markers used by the
second chapter, that are then removed by a third chapter. With successive
transformations, it's crucial you develop a naming strategy to keep things
straight. Otherwise you may try to use the third transformation on the
original data, yielding an unsatisfactory result.
Once your transformation chapters are designed, and
you've run them on the test data to make sure they work correctly, it's
time to actually process the bulk of your textfiles. Especially when
you're running the data through a succession of transformations,
"automatic procedure chapters" "Master Level Section 7" can help you
ensure that all the data goes through the process. Although it's crucial
to make modified copies when you're testing, in final production modified
copies are a waste of disks.
How we went about creating the braille edition of the
BEX Dox here at RDC shows just how automated this process can be. We
started out with "generically tagged input chapters"; they contained some
TranscriBEX commands and then many commands specific to the large print
version. This data went through six transformations to reach the "original
\\ chapters" stage.
The first transformation copied the modified data to a
"working" RAM drive, adding the final letter P.
Transformations two through six scanned this working RAM drive for
chapters ending in P. and then used the S naming
method to copy the modifications on top of When all six transformations were complete, we'd
examine the chapters in the Editor. Some of our replacements were not dead
certain; for these we added a unique character, the <Del> character,
to the data we'd inserted. This made it easy to confirm the accuracy of
our guesses: we'd locate for the <Del> character on each BEX page.
Once all manual confirmation was complete, we copied the data from RAM
drive to floppy disk: this became our "original \\ chapters." It took
around forty hours to process the 16 disks comprising the BEX Dox.
Since this data needed to be manually reviewed,
working with RAM drives speeded up the process enormously. Once the \\
chapters were set to go, replacing with In your ClasX package, the disk labelled
We hope that, as you read and practice this part, you
gain confidence in the inherent malleability of data. The specific
Open-Apple sample is not important: the Replace characters techniques we
use are the things you should pay especial attention to. When you're
having thorny transformation chapter design problems, RDC is happy to
respond to written inquiries for assistance--please include sample data
chapters as well as all the transformations you've designed and why
they're not working.
Before we even have the textfiles in hand, we can
start by dissecting the format elements in the inkprint. Once the data is
in BEX chapters, this "prestructuring" helps impose meaning on what could
seem to be a random wilderness of control characters.
Now we know what formats we need to look
for--let's copy the ProDOS textfiles to BEX chapters. In the following
discussion, we demonstrate BEX options on an Apple with just two floppy
disk drives. When you have enough memory, you will of course configure BEX
with RAM drives so that everything moves more quickly: substitute your
virtual drive numbers for the 1 and 2 shown
below.
Insert the BEX chapters can't have periods in their names, so we
had to rename each textfile individually. You must supply different names
for the chapters; we just tacked on A and B at
random. Once we know what the chapters contain, we can give them better
names.
Now that the data is in BEX chapters, we can see what
we have to work with. Edit the Next, you notice a flurry of <Esc>
characters--they appear as an uppercase E nestled in to a
backwards L. All the markup begins with the <Esc>
character; this character is followed by a combination of letters and
numbers. Advance your cursor to the end of the BEX page and press
control-V to preview on the 80-column screen: the
<Esc> characters don't print. Writing transformation rules goes more
quickly when you can print the data to the screen or paper to check markup
patterns; one of the first tasks in the data massage will be replacing the
<Esc> character with printing characters.
But before we do that, let's get an overview of the
coding for paragraphs. Locate for <CR>s by pressing control-L
<CR> control-A. Aside from the four <CR>s at the start
of the page, every paragraph ends with exactly one <CR That's
great--you can confidently replace <CR> with ( $p ) in most cases.
Now a brief look at how changes in typestyle are
coded: The first The first bold text is the paragraph heading
"AppleWorks was introduced in ..."; locate for
Let's see what the other chapters hold in store. Print
the But when you get to the Print the final In isolation, this Open-Apple data is not the ideal
candidate. Some of the text is missing and you must type it in yourself;
you must check the To develop accurate transformations, we must do two
things:
Before we start researching formats, let's change
the <Esc> character to printing characters. We must choose
characters that are not already present in the data; this is a crucial
concern when you're transcribing an article like "Control-I"nterface",
which is talking about command sequences for computers! A quick visual
check shows no occurrences of Now that each <Esc> character is visible as
By pulling together all the format information in
this chart, we can see several potential trouble spots. The same markup
defines the end of displayed computer notation and the end of a major
heading. The generic paragraph markup The transformation chapter []B[]XOpen-Apple[]Y| Find the magazine name and its
font changes
Open-Apple| change to the plain name
``| Find left quote
"| change to straight quote
''| Find right quote
"| change to straight quote
[]Z07<CR>[]2<CR>[]M| Find end displayed
computer notation OR major heading
\\cfs$s | change to end CBC; quicker to manually
delete "cfs" later if not needed
[]Z05<CR>[]T<CR>[]M| Find end of minor
heading
\\rt$p | change to end of minor heading
[]H[]S24[]W19[]Z26<CR>| Find start one size
major heading
$s \\hd | change to start major heading
[]H[]S18[]W14[]Z18<CR>| Find start another size
major heading
$s \\hd | change to start major heading
[]H[]S14[]W11[]Z14<CR>| Find start minor heading
$s \\mh | change to start minor heading
[]Z05<CR>[]P<CR>| Find start small
monospaced type
$s \\cbs | change to start set-off CBC
<CR>[]M[]Y[]B| Find bold font at start of
paragraph
$p \\ib| change to start paragraph heading
[]Y[]X| Find begin italic font, which always appears
jammed to start of italics word
\\ib| change to begin italics, with one space after
command
[]B[]X| Find begin bold italic font
\\ib| change to begin italics, since need not
distinguish between bold and other italics
[]Y| Find end italics/bold/paragraph heading; jammed
next to last emphasized word
\\if| change to end italics, maintaining final
spacing, adding one space at start
$p | change to generic paragraph since all the
headings are already replaced
\\if,| Find end italic font when roman comma touches
italic text
,\\if| change to the correct order
\\if.| Ditto for periods
.\\if|
\\if"| Ditto for quotes
"\\if|
\\if:| Ditto for colons
:\\if|
\\if;| Ditto for semicolons
;\\if|
\\if?| Ditto for question marks
?\\if|
\\if!| Ditto for exclamation points
!\\if|
"\\ib| Find begin italic font when preceding quote is
roman
\\ib"| change to the correct order
| The end. \\endtranscom
The next step is finding some representative "test
data." To see the details of what's on the disk, use Whole disk catalog on
the Page Menu. The typefaces play a different role in the letters column
than in the rest of the magazine; it makes sense to develop
transformations for the rest of the magazine first, then modify them for
the "Letters" data.
Use the Check the end of the last BEX page. You'll see the
only This is an unusual combination of formats: the end of
displayed computer notation is immediately followed by a paragraph
heading. After the This happens because the When \\transcom []Z05[]R<CR>[]T[]Y[]X<CR>[]M|
Find end of letter, beginning of editorial reply
$s| change to skip-line to show change in context
[]R<CR>| Find flush right lines that end letter
writer's name and address
;| change to semicolon, fitting it all in one line to
save space
<CR>[]M[]Y[]B| Find paragraph beginning in bold
font
$p\\ib| change to paragraph heading
[]Y[]X| Find start italic font at END of word
\\if| change to end braille italics
\\ib| change to begin braille italics
[]B[]X| Find start bold italic font
\\ib| change to begin braille italics
[]Y| Find start roman font: ends
italics/bold/paragraph heading
\\if| change to end braille italics
<CR>[]M| Find start of paragraph
$p| change to generic paragraph, since all headings
are already found
<CR>$s| Find last line of letter writer's
address plus start of editorial reply
$s| change to plain skip-line
\\if,| Find end italic font when roman comma touches
italic text
,\\if| change to correct order
\\if.| Ditto for periods
.\\if|
\\if"| Ditto for quotes
"\\if|
\\if:| Ditto for colons
:\\if|
\\if;| Ditto for semicolons
;\\if|
\\if?| Ditto for question marks
?\\if|
\\if!| Ditto for exclamation points
!\\if|
"\\ib| Find where italic font begins inside roman
quotes
\\ib"| change to correct order
\\ib,| Find where start italic font markup appeared
before closing punctuation at END of word
,\\if| change to end braille italics and create
correct order
\\ib.| Ditto for period
.\\if|
"\\if|
\\ib:| Ditto for colon
:\\if|
\\ib;| Ditto for semicolon
;\\if|
\\ib?| Ditto for question mark
?\\if|
\\ib!| Ditto for exclamation point
!\\if|
|The end. \\endtranscom
The samples so far have illustrated the kinds of
analysis and processing you use to turn machine-readable text into
workable data entry for ClasX-CBC. To create true \\ chapters, the
remaining tasks are:
Before you process all the data, you
should clipboard the data from the Print the Make a hardcopy of the While the displayed computer notation uses a
distinctive font, a lot of the words that require CBC appear in the base
type. You can also enlist contextual Replace to assist you in this task.
The | second terminator means contextual
\\cfs| On string is end of set-off CBC
\\cbs| Off string is start of set-off CBC: don't want
to add embedded CBC commands INSIDE set-off CBC
"control-| Find majority of meaningful "control-X"
commands
^XIIIIIIIX| pattern ignores capitalization, inserts at
start
\\cb| change to inserts begin embedded CBC
"E"| Find single command letters in quotes
^XLX| pattern specifies ANY letter
\\cb| change to inserts begin embedded CBC
"CHR| Find start of BASIC function
^XXXX| pattern inserts
\\cb| change to inserts begin embedded CBC
"PR#| Find BASIC function
^QXXX| pattern allows initial punctuation, symbol, or
space
\\cb| change to inserts begin embedded CBC
"INPUT| Find BASIC function
^QXXX| pattern allows initial punctuation, symbol, or
space
\\cb| change to inserts begin embedded CBC
"INIT| Find BASIC function
^QXXXX| pattern allows initial punctuation, symbol, or
space
\\cb| change to inserts begin embedded CBC
"INPUT| Find BASIC function
^QXXXXX| pattern allows initial punctuation, symbol,
or space
\\cb| change to inserts begin embedded CBC
"PRINT| Find BASIC function
^QXXXXX| pattern allows initial punctuation, symbol,
or space
\\cb| change to inserts begin embedded CBC
| pattern string shortcut; exact match
\\cb| change to one space before command
\\cb| Find TWO spaces created by inserting before a
space
| pattern string shortcut; exact match
\\cb| change to one space after command
| End is in sight
| The end. \\endtranscom
We certainly don't want to add the (\\cb) and (\\cf)
commands inside set-off CBC, so we use the (\\cbs) and
(\\cfs) commands as off and on strings. After we run the data through this
transformation, we edit the data and locate for Many source textfiles don't use explicit "cancel the
current format" tags. Instead, the end of a heading, the end of a list,
the end of a typeface are all tagged with same generic "return to normal
format" markup. Most TranscriBEX and ClasX-CBC formats, on the other hand,
require an explicit "cancel that format" command: the end of a minor
heading needs (\\rt$p), the end of a list needs (\\enditems$p), the end of
italics needs (\\if), and so forth.
A particular contextual Replace technique lets you
identify exactly which format any "generic stop" markup is cancelling, and
then place the appropriate \\ command automatically. For reasons that soon
will become obvious, we call this contextual tool the "Galloping Gobble
Technique." This Part provides fundamental background on how the Galloping
Gobble Technique works and where it's useful. It assumes you're familiar
with contextual Replace.
SGML prefers that authors use complete and explicit
end-tags. Recognizing that authors may be reluctant to type long tags,
however, SGML also allows a generic stop: the "empty end-tag" or
<h1>Preparing New Disks for
Use</><CR>
When you buy blank disks, they have nothing recorded
on them--just like blank tape for a tape recorder. Before a disk can
receive information from DOS, you must prepare it using the
<e1>INIT</> command. This preparation process is called
<e2>initializing</> or <e2>formatting.</> Here's
how ...
If the author had typed full end-tags, then the first
Contextual Replace's on and off strings create smaller
contexts within a chapter, where the on string defines the start and the
off string defines the end of the context. The rules in your
transformation chapter are only executed inside this context. In this
sample, you only want to change Five transformations! Even when you're working
with RAM drives, that takes a lot of time. And this case only has three
different roles for the empty tags. A document where the empty tag ends 12
different formats would require 14 transformations!
The "Galloping Gobble Technique" comes to the rescue:
it enables just two transformations to expand any number of generic stop
tags to the appropriate explicit stop tags. To fully understand how the
Galloping Gobble Technique works, you must learn a little about how
Replace characters operates at the smallest level. Don't be discouraged by
this task--unlike humans, computer programs are truly stupid when it comes
to recognizing patterns.
Before we delve into bits and bytes, here's an
overview of the Galloping Gobble Technique: In the first transformation,
we place off strings all over the data--it's exactly like transformation 1
above. The second transformation has two functions. It uses the on and off
strings to expand the empty tag, and then gradually gobbles up these off
strings, doing the work of transformations 2 through 4 in the unacceptably
slow solution. Once the explicit end tags are in place, transformation 2
changes all the by-now explicit tags to the appropriate TranscriBEX and
ClasX commands.
In order to use the Galloping Gobble Technique
productively, you must understand exactly how BEX interprets on and off
strings in contextual Replace. In Master Level Section 6, we claim you
can't Replace your on and off string within the same chapter. That's
indeed what we thought when we wrote the manual. In the intervening time,
however, we've discovered that you can delete active off
strings from a chapter, as long as the off string character or characters
are not the first characters in your find string.
Computer software in general, and BEX in particular,
must ask literally thousands of yes/no questions to see the patterns that
we humans can recognize in a glance. "Fortunately, computers answer these
yes/no questions very quickly--BEX on an Apple IIgs can ask around 200,000
questions a second." During Replace characters, BEX builds up a picture of
the data just one character at a time. At any one moment, BEX focuses on
what we'll call its "current character." BEX compares this current
character with the off string and the find string. The results of these
comparisons influence what BEX does with the next character in the data.
During the active portions of a contextual transformation, BEX tests every
character at least twice for each transformation rule: once to check if
Replace should turn off, and then again to see if the character needs
replacing.
In Test 1, BEX compares the current character in the
chapter to the first character of the off string. When the current
character is different from the first character of the off string, the
current character fails Test 1, and BEX moves on to Test 2. "When the
current character passes Test 1, then BEX compares the next character in
the data with the next character in the off string. When a group of
characters in the data exactly match the off string, it means BEX has
encountered the complete off string. Replacement turns off until BEX
encounters the complete on string."
In Test 2, BEX asks if the current character is
identical to the first character of the find string. When the current
character fails this test, BEX advances one character and starts Test 1
all over again. When the current character passes Test 2, then BEX
compares the next character in the data with the next character in the
find string. The key fact is that BEX doesn't first apply
Test 1 to the next character. That "next character" could be part of the
off string, and BEX doesn't care.
The upshot is that a contextual transformation rule
can find and replace the off string for that transformation
chapter, as long as the off string is not the first character of the find
string. Consider this short contextual transformation chapter:
| second terminator means contextual Replace
+| On string is plus sign
-| Off string is hyphen
fox-| Find these four characters
| pattern string shortcut--exact match
dog| change to these three characters
| End in sight
| The end. \\endtranscom
The single rule finds the four characters
BEX makes the first character the current character,
and compares it with the first character of the on string: Since
A is not a hyphen, it fails Test 1. And since
A is not an f it also fails Test 2. BEX forgets
about A and moves on to the next character. <space>
becomes the current character, and <space> likewise fails both
tests. Now f is the current character. It fails Test 1, but
it passes Test 2. BEX makes a mental note of this, and proceeds to the
next character in the data. BEX doesn't compare o with
hyphen; it only performs Test 2, comparing o with the next
character of the find string.
Since o is the second character of the
find string, it also passes Test 2, and BEX makes another mental note. BEX
administers Test 2 to the next two characters, which both pass with flying
colors. BEX's mental notes now say: "Hey! We have a match!" BEX throws
away the Once the replacement is finished, BEX advances one:
the current character is now y. BEX administers Test 1 to
this character, and so it goes. BEX repeats this character-by-character
comparison for every transformation rule. When all the rules are done, BEX
writes the altered page to disk and moves to the next page.
Here's how you apply the Galloping Gobble Technique to
the short SGML sample shown above. The first transformation inserts an on
string of \\transcom | Terminator is vertical bar
| second terminator means contextual
| no on string
| no off string
</| Find the beginning of any start tag
^XO| pattern inserts, exactly left angle bracket,
anything other than slash of generic end tag
~~~| change by adding on string
/>| Find the ending of any start tag
OX^| pattern inserts, anything other than slash of
generic end tag, exactly right angle bracket
%%% | change by adding off string
| End is in sight
| The end. \\endtranscom
Pattern code O, the wild-card-minus-one,
comes in handy yet again! We find the begin and end of all tags by looking
for anything except the generic end-tag. After this transformation, our
sample data looks like:
When you buy blank disks, they have nothing recorded
on them--just like blank tape for a tape recorder. Before a disk can
receive information from DOS, you must prepare it using the
~~~<e1>%%%INIT</> command. This preparation process is called
~~~<e2>%%%initializing</> or
~~~<e2>%%%formatting.</> Here's how ...
Now the data is ready for the all-powerful second
transformation:
\\transcom | Terminator is vertical bar
| second terminator means contextual Replace
~~~| on string "placed by first transformation before
all start tags"
%%%| off string "placed by first transformation at end
of all start tags"
<h1>%%%| Find start tag for heading, plus its
attached off string
XXXXxxx| pattern makes off string depart
| change to nothing, deleting off string: Replace now
active for headings
</>| Find generic end tag between <h1> and
any other start tag
| pattern string shortcut means exact match
</h1>| change to explicit end heading tag
<e1>%%%| Find start tag for emphasis 1 plus its
attached off string
XXXXxxx| pattern makes off string depart: Replace now
active for emphasis 1
| change to nothing, deleting off string
</>| Find generic end tag between <e1> and
any other start tag
| pattern string shortcut means exact match
</e1>| change to explicit end emphasis 1 tag
XXXXxxx| pattern makes off string depart: Replace now
active for all data
| change to nothing, deleting off string
</>| Find remaining generic end tag, which is
after <e2>
| pattern string shortcut means exact match
</e2>| change to explicit end emphasis 2 tag;
all generic end tags have been expanded
<h1>| Find start heading
| pattern string shortcut means exact match
$s\\mh| change to TranscriBEX start minor heading
</h1><CR>| Find end heading
| pattern string shortcut means exact match
\\rt$p| change to TranscriBEX end minor heading
<e1>| Find start emphasis 1
| pattern string shortcut means exact match
\\cb| change to ClasX begin embedded CBC
</e1>| Find end emphasis 1
| pattern string shortcut means exact match
\\cf| change to ClasX finish embedded CBC
<e2>| Find start emphasis 2
| pattern string shortcut means exact match
\\ib| change to TranscriBEX begin braille italics
</e2>| Find end emphasis 2
| pattern string shortcut means exact match
\\if| change to TranscriBEX finish braille italics
@~~~| Find on strings, which have no more utility
Wxxx| pattern begins with boundary wild card, deletes
on string
| change to nothing, deleting on string
| End is in sight
| The end. \\endtranscom
When BEX starts to execute this transformation,
Replace always turns off immediately after all begin tags. The first rule
changes the context within the BEX page by gobbling up one of the off
strings: now Replace can operate after the Once all the generic end tags are expanded, there are
no more off strings in the data. The second half of this transformation
chapter merrily replaces all the begin and end tags with the appropriate
TranscriBEX and ClasX-CBC commands. Since Replace is on, you
can delete all but one of the on strings to get them out of your way. When
you edit the transformed data, you will have to manually delete the first
on string on the first BEX page.
While the Galloping Gobble Technique is incredible
powerful, there are several of its effects you must be aware of. First and
foremost, it operates one BEX page at a time. When a begin
tag appears on one BEX page, and its associated end tag shows up on the
next BEX page, the Galloping Gobble Technique won't work. Secondly, you
must plan carefully to prevent overflow errors. Our samples showed on and
off strings that were three characters each: if we tried to run the first
transformation on BEX pages with more than 3300 characters, we'd certainly
get the overflow shriek. In Part 4, we limit this problem by using
patterns already present in the data for on strings, and inserting a
one-character off string.
Finally, you can get unpredictable results when you
insert active on and off strings: that is, when a
transformation chapter both defines Inserting active off strings can be useful, however.
The Microsoft Corporation publishes many programs for the
Macintosh and IBM-PC, as well as scores of computer-related books. Their
word processor, simply called "Word," is available in both Mac and IBM
versions. Word gives you a variety of ways to save your data on disk: in
this Part, we focus on its Rich Text Format "RTF", also called
"Interchange format." "Don't confuse Microsoft's RTF with IBM's RFT, or
"Revisable Format Text." An explanation of RFT would require an entire
manual in itself!"
RTF text is indeed rich: it contains just about all
the information you need to create a braille version of an inkprint file.
To quote from the introduction to Microsoft's Rich Text Format
Specification, "The RTF standard provides a standard format for
text and graphics interchange that can be used with different output
devices. ... With RTF, documents composed under different operating
systems and with different software programs can be transferred between
those operating systems and applications." "If you have the opportunity to
base your TranscriBEX data entry on RTF data, you will save hours of
headscratching by obtaining a copy of the Rich Text Format
Specification. Call Microsoft at 206-882-8089, ask to speak with
"Developer Services," and be prepared to politely repeat your request for
the RTF until you hit on a sympathetic person."
Even though you create RTF data by saving to disk,
these files are "program specific plain ASCII input files." "When you
open an RTF file in Word, the program asks you if you'd like
to interpret the RTF commands. When you answer affirmatively, Word
recreate all the format present in the native file." In addition to the
content of the document, the RTF markup consists of a host of "control
words" "document format and structure commands", "control symbols" "coded
characters", and braces. The control words and symbols all begin with a
single backslash. For example, the RTF control word for a new paragraph is
The All RTF documents begin with a "header," which defines
the RTF version used in the file, the character set, the list of font
names and their corresponding numbers, the style sheet formats and their
corresponding labels, and the colors used. Take a look at the header
information in The header is pure markup, and it includes many
definitions that may not be relevant to a particular document. As you can
see from the inkprint, the Red Ryder documentation only uses three fonts:
Times Roman, Times Bold, and Courier. But just in case, the RTF header
defines a font number for all 18 fonts that were available on our
Macintosh system the day we created the RTF file. The most efficient way
to decode the header is to work backwards: find a font number or style
number in the data, then look it up in the header to see what it means. As
we developed transformation chapters, we used the clipboard to copy many
of our find strings from the header definitions.
On print page 56 of the Red Ryder excerpt, notice the
paragraph beginning with 3" Put the following .... The
set-off CBC that follows begins with one backslash. Since RTF uses
backslash as a command character, a data backslash must be coded as a
"control symbol." After a few hours' experimentation, we came up with
two transformation chapters that place the majority of ClasX and
TranscriBEX commands: they are The Red Ryder excerpt has two kinds of paragraphs:
text and set-off CBC. We place the appropriate TranscriBEX and ClasX
commands based on the RTF control words that appear at the start of the
paragraph. A quick review of the data showed that there were a lot of
minor control word variations for the transitions between text and CBC
paragraphs. While we could have carefully analyzed which control words
were common to all and deleted them, then written very specific rules that
found the distinctive commands, we took the lazy way out. We copied all
the variants to the clipboard, and wrote a total of five rules.
The excerpt uses bold type for both emphasis and some
computer notation. Instead of trying to distinguish between these
functions in the transformation chapter, we place a flag: (\\?b) and
(\\?f). Once both transformations are complete, we can locate for
\\transcom | Terminator is vertical bar
<CR>| Find hard Returns
| change to nothing, since they're meaningless
\-| Find discretionary hyphen
| change to nothing
\'d5| Find right single quote
'| change to single quote
\'d2| Find left double quote
"| change to straight quote
\'d3| Find right double quote
"| change to straight quote
\\| Find CODED single backslash
<>bs<>| change to UNIQUE character
combination, change to single backslash at end of RED2
\page| Find forced page break in inkprint
| change to space
\tab| Find tab character
| change to space
\par\pard\plain\s1\qj\sb120\sa120\f20| Find start of
"plain" non-CBC text
\\cfs$s| change to end set-off CBC
\par\pard\s1\qj\sb120\sa120| Find start of text
without "\plain"
$p| change to regular paragraph transition
$p| change to regular paragraph transition
\par\pard\plain\s3\fi-360\li720\f22| Find start of
monospaced font
$s\\cbs| change to begin set-off CBC
\par| Find any paragraph markers that may remain
$p| change to regular paragraph transition
| Find two spaces
| change to one
{\b| Find start of bold face type
{\\?b<LF>| change to "begin some sort of braille
emphasis" plus add the off string used by RED2
\\cbs| Find begin set-off CBC
{\\cbs<LF>| change by adding on string plus off
string used by RED2
\\cfs| Find finish set-off CBC
\\cfs<LF>| change by adding off string used by
RED2
| The end. \\endtranscom
This transformation uses the Galloping Gobble
Technique, introduced in Part 3. Remember that, when you use on and off
strings, Replace begins off. The transformation establishes
three contexts: First it operates only within set-off CBC, then it's let
loose on bold type, then finally, on the whole text. Remember that
\\transcom | Terminator is vertical bar
| second terminator means contextual
{\| on string is start of bold or CBC
<LF>| off string was strategically placed by
RED1
XXXXx| pattern deletes just the off string
| change to nothing: Replace now active for set-off
CBC
$p| Find paragraph indicators inside CBC
| pattern string shortcut means exact match
<CR>| change to <CR>
\?b<LF>| Find begin some sort of emphasis
XXXx| pattern deletes just the off string
| change to nothing: Replace now active for bold face
text
}| Find brace defining end of bold face
| pattern string shortcut means exact match
\\?f| change to end some sort of braille emphasis
Q{\| Find initial brace for begin emphasis and begin
CBC; notice that on string is NOT first character
WxX| pattern begins with a wild card paired with dummy
Q, just deletes brace
| change to nothing
Q<LF>| Find off string; notice that it's NOT
first character
Wx| pattern begins with a wild card paired with dummy
Q, just deletes off string
| change to nothing
<>bs<>| Find unique characters placed by
RED1 to signify one backslash
| pattern string shortcut means exact match
\| change to one backslash
| Find two spaces
| pattern string shortcut means exact match
| change to one
| End in sight
| The end. \\endtranscom
You can delete an active on string,
because Replace is on when you do it. Try running these two
transformations on the We hope that this adventure into RTF files has whetted
your appetite. Happy data jockeying!
Inkprint pages C5:46-49 are a facsimile of part of the
Red Ryder documentation. These pages have been omitted from the braille
edition.
INSTRUCTIONS on the Installer disk that explains what to do.
If you didn't enhance your BEX 3.0 disk, you would encounter Hardware and Documentation Requirements
TranscriBEX Background
MAKE$ and
ALL$ transformation chapters that change the mnemonic \\
commands to intricate strings of $$ commands. You understand that BEX's
Grade 2 translator changes inkprint data to contracted braille data.
Finally, you have experience proofreading your formatted, translated data
with a braille previewer, and creating paper braille copies with BEX's
Print option. The basics of these operations are explored in Sections 2
through 7 of the TranscriBEX Manual.
Some Background on Computer Braille and ASCII
chat it creates
the word *at in the grade 2 chapter. All U.S. braille devices
display dots 1-6 when they receive the asterisk. When a braille device is
displaying grade 2 material, then the braille reader knows that dots 1-6
stands for "ch." When a braille device is displaying inkprint material,
then the braille reader interprets dots 1-6 as asterisk.
] right bracket character. Therefore, the screen braille
representation of the grade 2 version of the word (reader) is
r1d].
Part 4: Background on the Computer Braille Code
Drawbacks of computer braille
CBC's format and translation tools
CBC Resources
Format issues for linear braille devices
LBF Resources
Identifying Computer Notation
TranscriBEX's Five Steps
MAKE$ or ALL$ transformation
chapter, changing all mnemonic \\ commands to intricate $$ format
commands. Optionally, print these chapter to any screen mode to check for
overall braille format.
FINETUNE transformation
chapter
MAKE$C or ALL$C transformation
chapter, changing all mnemonic TranscriBEX \\ commands to intricate $$
format commands; changing ClasX-CBC \\ commands to $$ commands plus more
Translator Controls. Not all the $$ commands are yet in place, so you
can't proofread to the screen.
FINETUNE-C
transformation chapter.
Machine-readable text
ClasX-CBC is a superset of TranscriBEX
MAKE$C and ALL$C. These transformation
chapters contain all the rules in MAKE$ and ALL$
plus the transformation rules for the ClasX-CBC commands. "To
remind you of this, we added the letter C for computer to the
chapter names." You would never transcribe an entire document in the
Computer Braille Code. For the literary portions of your document, you use
all the regular TranscriBEX commands. The MAKE$C and
ALL$C transformation chapters act just like TranscriBEX's
MAKE$ and ALL$ chapters in terms of handling all
the TranscriBEX commands. You never run your data through
both MAKE$ and MAKE$C
BEX 3.0 and ClasX-CBC
A Caution on
FINETUNENotation
Two ClasX command types
MAKE$C "or ALL$C" while other $$
commands are placed by the Grade 2 translator.
Part 1: The ASCII Characters in CBC
Representing Control Characters
<CR>. Some manuals show control characters in
brackets: [P] means "control-P." Other manuals precede a
control character with one caret: ^S means "control-S."
Part 2: Switching Between Literary and CBC
Braille Translation
Commands for set-off CBC
The ClasX data entry looks like:
/footerproc {pagenumber 1 eq<CR>
{footerproc1} {footerprocGT1} ifelse } def \\cfs $s
Of course, this depends on previous use of the ...
#[_$">_$]#,? frag;t illu/rates ! ,bool1n
op]ators3
/footerproc1 _[gsave showpage _&
grestore_] def
/footerproc _[pagenumber _1 eq
_[footerproc1_] _[footerproc_>gt1_] _&
ifelse _] def
#[_$">_$]#,( c\rse1 ? dep5ds on previ\s use (!
'''
Commands for Embedded CBC
Part 3: Showing Capitalization
Translator's Automatic Handling of
Capitalization
Reverse Capitalization
Duration of Reverse Caps
PART1 and PART2, and you want Reverse Caps for
the CBC in both of them. However, the (_rc) command only appears in
PART1. When you translate both chapters in one session, then
all the CBC in PART2 will use Reverse Caps. But if you find
an error in PART2, fix it, and then retranslate it on its
own, your CBC will use the default normal capitalization. "Extra" (_rc)
commands won't hurt: make sure you use them wherever you want Reverse
Capitalization.
Part 4: Format Situations that Add Characters
Automatic handling for isolated lower-cell signs
Continuation indicators
Continuation Indicators in Set-off CBC
#[style=Trans note]# The Code recommends that you break the
braille line at a space where possible. The Continuation Indicator does
not take the place of this space; the space appears immediately before the
_&. Take a close look at line 15 of the program sample
from Part 3: 256:DIR and the equals sign.
And the CBC transcription shows one space after the 256:DIR
and before the continuation indicator. Because set-off CBC always runs
over to cell 2, the equals sign appears in cell 2 of the next braille
line.
Continuation Indicators in Embedded CBC
Part 5: Emphasis Indicators
ClasX-CBC Data Entry for Emphasis
Part 6: Spacing and Indentation
Data Entry for Indented Material
Transcribing Significant Spaces
Data Entry for Significant Spaces
MAKE$ and ALL$ change two spaces to one. But
because multiple spaces can be meaningful in a CBC transcription,
MAKE$C and ALL$C leave multiple spaces alone.
MAKE$C and ALL$C
expand the (\\sp#) command to the appropriate number of blank spaces.
Here's the ClasX-CBC data entry for the embedded sample we just showed.
One way is to type the correct number of spaces:
Hints about the (\\sp#) command
MAKE$C and ALL$C
transformations expand this command to the number of spaces specified.
When your transcription includes a lot of (\\sp#) commands, you must take
this expansion into account! If you had ten (\\sp40) commands in a BEX
page containing 3500 characters, chances are good that you'd get an
overflow error when you use Replace characters and the MAKE$C
transformation chapter.
MAKE$C or ALL$C When you're
comfortable modifying transformation chapters, copy MAKE$C or
ALL$C to a MY MAKE$C chapter. Insert the five
characters |<space><space>|<space> right at
the start. But make sure that everyone using this MY MAKE$C
also faithfully types the (\\sp#) command.
Data Entry for "Short" Programs
Commands for "Long" Program Listings
Long program listing sample
161
1 208 ends with TranscriBEX's print page indicator command, (\\pp
93). BEX's translator knows that the print page indicator should be
translated into grade 2, not CBC, so the final formatted, translated
chapter shows the print page indicator as #id.
[number] text in the "line number zone" on the right edge of
the braille line. The translator recognizes the [number] is
not CBC, so it's translated into grade 2; following the
Code of Braille Textbook Formats and Techniques, ClasX-CBC
suppresses the number sign before the line number. Place (\\ln[number)
first on the program line, before any (\\#c) command and immediately after
the <CR> or ( $l ) that starts the line.
Part 8: Shape Indicators
Part 9: Half Line Shifts Up and Down
ClasX-CBC Data Entry for Half Line Shifts
ClasX-CBC Data Entry for Transcriber's Option
Symbols
MAKE$C and the translator unaltered, so your inkprint data
entry is your desired CBC result. Enter underbar, exclamation point (_!)
to get the Primary Transcriber's Option _! symbol. Enter
underbar, period (_.) to get the Secondary Transcriber's Option
_. symbol.
Part 11: Minimizing Switches in Braille Codes
since the braille result is:
muddles the meaning of the quotation marks:
Transcribing literary suffixes to CBC words
#[style=Trans note]# Some authors use programming tokens as if they were
English words, inflecting them with verbal and adjectival suffixes. There
are two important considerations for your data entry here. First off, you
don't want your ClasX-CBC commands to alter in meaning. When the inkprint
shows: MAKE$C sees the "finish
set-off CBC" command (\\cfs) with unsatisfactory results. To prevent this,
type one control-backslash <control-\> character after the (\\cf)
command. <Control-\> is detailed in Part 13; you enter it in your
text by holding down the Control key, pressing and releasing the backslash
key, then releasing the Control key. When your data entry is
then
MAKE$C recognizes the (\\cf)
command.
Literary suffixes also raise some translation issues.
Consider this inkprint:
\\is f4The REMarkable thing is how the
file is LOADed for PRINTing; these LOADs save a lot of time.
f15 \\xs
You may wish to suppress contraction of the
ar, able, ed, and
ing suffixes. We provide you with two techniques for
accomplishing this goal.
The first technique uses disappearing grade 1
translator controls "TCs", introduced on TranscriBEX page 17-2. Type ()
space, underbar, underbar, lowercase o, space to turn on
grade 1 translation immediately after the mid-word (\\cf) command. Return
to literary translation at the end of the word with (_l) space, underbar,
lowercase l, space. This technique works best when you're not
familiar with the braille translation rules. Data entry of the sample
above would be:
The second technique is one we recently discovered.
On TranscriBEX page 8-9, we describe the () command; you type it
before a single letter to suppress placement of the letter sign. When the
two characters less-than, semicolon appear in the middle of a word, then
the translator doesn't attempt to place the letter sign. And when the
() command interrupts a series of contractible letters, the
translator doesn't "see" the opportunity to contract. This approach
requires fewer keystrokes on your part; however, it depends on you knowing
what contraction the translator should be taking. Your data entry could
look like:
The \\cb REM \\cfarkable thing is how the
file is \\cb LOAD \\cfed for \\cb PRINT \\cfing; these \\cb
LOAD \\cf<control-\>s save a lot of processing time.
Notice where we put the () in "PRINTing." If
we'd placed it between the n and the g, we would
have ended up with an in sign: _>print_:9g2.
Whichever method you prefer, the translated result formatted to a 40-cell
line is:
\\bs
,! _>rem_:arkable ?+ is h[ ! file is
_>load_:ed = _>print_:ing2 ^! _>load_:s
save a lot ( process+ "t4
\\xs
Part 12: Manual Nemeth Code within CBC
Signalling the Switch
Format Variation between Nemeth and CBC
ClasX-CBC Commands for Manual Nemeth Code
Nemeth Sample Data Entry
YVAL and
XTRA are transcribed in CBC that's within set-off Nemeth.
Once you begin manual Nemeth, all translation is manual: you must type in
the Caps Lock _> symbols yourself. The translated,
formatted result on a 40-cell line looks like:
Part 13: Distinguishing Between Commands and
Computer Notation
The Special Role of Control-Backslash
ClasX-CBC uses one character to distinguish
between "real" BEX, TranscriBEX, or ClasX-CBC commands and "lifeless"
commands that are actually part of the computer text you're transcribing.
This character is control-backslash; to type it in your text, you depress
the Control key, press and release the backslash key, then release the
Control key. "Note that you don't have to press
control-C first, although you will get the right character
if you do." On the screen, this character appears as an uppercase
F nestled within a backwards uppercase L. When
you arrow over it, the voice pronounces <control-\> as "ASCII 28."
#[style=Trans note]# Place <control-\> in the middle of sequences
that would otherwise be interpreted as valid commands. To enter two
"lifeless" backslashes, type (\<control-\>\). To enter two
"lifeless" carets, type (^<control-\>^). To enter two "lifeless"
dollar signs, type ($<control-\>$). To enter a "lifeless" sequence
that's the same as a BEX format indicator, type space, dollar sign,
<control-\>, letter, space. Since you type two underbars for every
single underbar in your inkprint original, a Translator Control or
ClasX-CBC command that begins with underbar is no problem. As mentioned in
Part 11, when embedded CBC ends next to a literary s, type
(\\cf<control-\>s) to distinguish it from the (\\cfs) command. As
mentioned in Part 12, when you finish manual CBC entry within manual
Nemeth, type (_<control-\>:) to distinguish it from (_:). Here's a
truly horrible sample we cooked up. The inkprint original is:
Symptoms of missing control-backslash
MAKE$C and ALL$C place all the
valid \\ commands, they insert this message for any appearance of two
backslashes."
$$wellDone, then the translator won't
place the underbar that signals the uppercase D.
$$we. In the middle of proofreading,
all of a sudden the Part 14: Spacing for ClasX Commands
Samples of Spacing Options
But you get the same result when you type it this
way:
and has the identical result.
Space as a Shortcut for "Return to Baseline"
Summary of Command Combinations and Spacing
PS SAMPLE chapter on your ClasX-CBC
disk is the inkprint data entry for pages 92 and 93 from Adobe Systems,
Inc.'s PostScript Language Tutorial and Cookbook, reprinted
here through the kind permission of the publisher, Addison-Wesley. An
inkprint facsimile of these two pages appears on pages C3:13-14. To follow
along with this discussion, first use Copy chapters to copy the PS
SAMPLE chapter to an initialized data disk.
Step 1: Data Entry
Data Entry for PS SAMPLE
PS SAMPLE chapter on the
ClasX-CBC disk to demonstrate the ClasX-CBC procedure. While it's only two
inkprint pages, it happily contains the majority of the ClasX-CBC commands
you use as you transcribe computer materials. Since no one on the RDC
staff is a certified transcriber, we contacted one for structuring advice
on this material. We followed her recommendations with one exception: we
"cooked" the sample a little to include more ClasX-CBC commands. The
purpose of the PS SAMPLE is to demonstrate the use of
ClasX-CBC commands; don't use it as a model for making structuring
decisions!
PS SAMPLE chapter to the screen
to see what we did. The first command defines the transcription as
textbook format with print page indicators. The second command establishes
the print page indicator 92. We inserted the (\\setnumber99) command since
inkprint page 92 obviously won't be the first braille page, but the value
"99" came right out of thin air.
Formatting Program Listings
%
-------- Variables defines the left margin within the listing
itself. We code this with (\\0c); we don't need to enter another
hierarchical command until the inkprint indentation changes. Since the
inkprint program listing uses a proportionally spaced font, it's hard to
judge how many spaces appear at the start of the line or within a line--we
guessed.
char 0 is in the middle of the sentence. We code
the return to literary prose with (\\cfs$s\\left); the "left" command
ensures that the literary paragraph begins in cell 1. The last three
literary paragraphs Print page indicators within CBC
PS SAMPLE chapter, note that the
program line beginning with 161 1 251 {PrintCodeandChar} for
ends with TranscriBEX's (\\pp93) command. The Grade 2 translator
recognizes this command, and turns on grade 2 translation for the single
word following. This means your print page indicators appear as they
should--grade 2 numbers, not CBC numbers. If for some reason you need to
have a space in your print page indicator, then type this as a sticky
space with control-C S. Unlike a real space, the
<control-S> sticky space doesn't define a "word" as far as the
translator and formatter are concerned. ClasX-CBC similarly recognizes
that the word following the (\\ln[number]) line number command should be
translated as grade 2, not CBC.
BEX Page Size Guidelines
MAKE$C. The most dramatic
expansion occurs with large MAKE$C and ALL$C replace the command with the
specified number of spaces.
Step 2: Replace characters
MAKE$C transformation chapter. When your chapters do contain
line-for-line tables or (\\i#r#) commands, use the ALL$C
transformation chapter.
ALL$C
and MAKE$C chapters include all the rules in the plain
MAKE$ and ALL$ transformation chapters--you
never process your chapters through both MAKE$
and MAKE$C.
Replacing the PS SAMPLE
PS SAMPLE in drive 2, and proceed as follows:
Main Menu: f2Rf0
Replace
Drive or Chapter: f22
<CR>f0
There are 1 chapters:
1 PS SAMPLE
Use entire list? N f2Y
<CR>f0
Target chapter name: f22.A$
<CR>f0
Transformation chapter name: f21MAKE$C
<CR>f0
click click click
Replaced 126 times
Main Menu:
2PS SAMPLE$
<CR> at the Target chapter name: prompt, but the
shortcut does the same thing. The four characters 2.A$ tell
BEX four things: the 2 writes the target chapter on drive 2;
the . "period" uses a naming method even when there's only
one chapter; the A adds characters to the source chapter name
to create the target chapter name; and finally the $ defines
the dollar sign as the character to add. See BEX Master Level Section 4
for the full details.
Can't proofread ClasX-CBC $$ Chapters
PS SAMPLE chapter
to the Braille Previewer or any screen mode, many things would look
"wrong." You wouldn't see _& Continuation Indicators in
embedded CBC, and a few $$ commands would be printed instead of executed.
Wait until you have translated the data to preview it.
Step 3: Translation
MAKE$C or ALL$C
transformation chapter doesn't place all the $$ commands. The
Grade 2 translator places the commands which tell the formatter to allow
CBC Continuation Indicators. In addition, the translator places all the
CBC dots 4-5-6 signs and Countable Spaces indicators. Use option G - Grade
2 translator with the scratch $ chapters; your target chapters are the
translated and formatted $2 chapters.
Translating the PS SAMPLE
PS
SAMPLE data disk in drive 2, proceed as follows:
Main Menu: f2Gf0
Grade 2 translator
There are 1 chapters
Use entire list? N f2Y
<CR>f0
Target chapter name: f22.A2
<CR>f0
Starting to translate
dead silence
Chapter PS SAMPLE$ done
Main Menu:
2/$ <CR> at the
Drive or chapter: prompt. See User Level Section 4 for more
details on "Restrictive Scanning with the Slash."
Step 4: Proofread to Braille Previewer
PS SAMPLE$2 chapter to the
printer number you have configured as a Braille Previewer. Hardcopy
versions, as both screen braille and dot patterns, appear on pages \_/ of
this Manual. You may notice that printing CBC data requires more time than
printing literary data. This is normal: BEX is doing a lot of work behind
the scenes. It's noticeable when printing to the Braille Previewer, but it
won't delay your actual embossing.
%stack: comments on braille page 100. Braille page 101 ends
early because of the (\\endlisting) Proofreading the LOUSY PS chapter
LOUSY PS and LOUSY PS$2 on your ClasX-CBC disk.
Print the LOUSY PS$2 chapter to your Braille Previewer and
see how many data entry errors you can catch.
Part 5: Final Touches: Modifying the Translated,
Formatted Chapters
FINETUNE-CFINETUNE transformation chapter that fixes rare translator
errors. You should not use FINETUNE on CBC data, since
incorrect Grade 2 could be correct CBC. "See Section 1 for a sample of why
this is so." Instead, use the FINETUNE-C transformation
chapter supplied on the ClasX-CBC disk. Many of the rules from your
original FINETUNE are not needed in FINETUNE-C
since we have improved the quality of the braille translator.
FINETUNE-C is a contextual transformation chapter: its on and
off strings exempt all CBC braille from transformation.
FINETUNE-C that correct them. Because
FINETUNE-C is contextual, the procedure for adding rules is
different from regular FINETUNE. Each find string ends with
two <CR>s. Each change to string ends with one <CR The end of the
transformation chapter requires three <CR>s. As shipped to you, the
final rule uncontracts the "of" sign in the word "cofunction." It looks
like:
FINETUNE-C. Edit
the chapter and press control-A <space> to put your
cursor at the end of the page. We've added a note to the end of this
transformation chapter to remind you of the procedure when adding rules.
Enter control-Z control-L to zoom your cursor back to the
final <CR Left arrow twice then press control-I to begin
inserting. Type your find string, two <CR>s, your
change to string, then press control-N to finish the insert.
Preventing Program Lines from Straddling Braille
Page Boundaries
MAKE$C and ALL$C change
(\\nobreak#) to ( $$vl#), BEX's "variable discretionary page break
command." When BEX encounters the ( $$vl#) command, it compares the value
of # with the number of lines left on the current output page. When fewer
than # lines remain, BEX moves to a new braille page. When a program line
requires three braille lines, the # value is 3. As an
alternative to entering (\\nobreak3) in your original \\ chapter, you can
type ( $$vl3) in your final $2 chapter. Always place the (\\nobreak#) or (
$$vl#) command immediately after the <CR> that begins the line,
before any (\\ln[number]) line number command or (\\#c) indent command.
"Tweaking" Where Lines Break in Embedded CBC
Part 1: Prerequisites for Success
Replace characters and RAM Drives
BEX File Import Capabilities
Accuracy and Timeliness
Mitigating Factors
Standards for Machine-Readable Text: Background
on SGML
<h1>. In transcribing terms, the author is
structuring the manuscript, not formatting it. When the
author has found a MAKE$ is parallel to the
publisher's transformation of generic tags to machine-specific
instructions.
Two SGML Reference Works
Part 2: Varieties of Machine-Readable Text
Finding the Files
How Complete is the Content?
Is the Data "Plain" ASCII?
Handling "High Bit" ASCII
"tm";
change a lowercase o with a circumflex to the three
characters o<^. These changes can occur in the native word
processor "on a copy of the original data!" or you may be
able to obtain a utility program that does these sorts of replacements for
you. On the Macintosh, the "Apple File Exchange" utility can do this for
MacWrite files. Microsoft Word on both the Mac and the IBM-PC can save
data in "RTF" files that show all the original formats with plain ASCII
characters--more details in Section 5, Part 4.
Let Microsoft WORD" ^nish the jobQRbestS output in
seconds _at.
Handling Non-ASCII Data
Are You Working with an Input or an Output File?
<h1>, whose meaning is transparent. You must infer the
document's structure from the patterns of the device-specific commands. An
output file contains a <CR> at the end of every line. Deciding where
paragraphs and meaningful new lines occur in output files requires some
work on your part.
Understanding Input Files
Understanding Output Files
A Word of Warning on PostScript
WYSIWYG, Style Sheets, and "Tags"
Getting the Data into BEX Chapters
Starting with Apple Files
Starting with IBM or Macintosh Files
Part 3: Markup of Machine-Readable Text
<h1> becomes ($s\\hd). But when you're working
with a device-dependent input or output file, you end up replacing many
codes with just a few ClasX-CBC commands. The key skill is pattern
recognition. As you gain experience, you'll discover that certain types of
changes in format tend to signal certain functional divisions in the text.
Changes in Typestyle and Font
Explicit start and stop markup
<i> to start and </i> to finish
italics. Any other typestyle is coded without reference to the particular
typeface: instead of "begin computer type" the Chicago Guide recommends
<e1> and </e1> for "first
other-than-italics emphasis"; <e2> and
</e2> for "second other-than-italics emphasis"; and so
forth. In that system, computer notation could appear within
<e1> and </e1> tags. When your
textfile looks like: This is an <i>italic </i>word and this is
<e1>monospaced type</e1
then you know exactly where to put the ClasX
commands:
<i> becomes (\\ib); </i>
becomes (\\if); <e1> becomes (\\cb); and
</e1> becomes (\\cf). The explicit start and stop
technique is clearly the easiest one to transform automatically, but you
only encounter it in input files, and not all of them.
Explicit start and generic stop markup
</> "empty end-tag" generic stop for marking up font
changes and a host of other special formats. When you're working with a
device-specific output file, your data follows this pattern. Most printing
devices don't give a hoot what font you're leaving; they need to know what
font to use next. While this works fine in a typesetting environment,
TranscriBEX needs to know exactly which font you're leaving. Your textfile
could look like:
</> should be changed to (\\if) or (\\cf) is to
manually examine it in context. Contextual Replace comes to
the rescue: see Section 5, Part 3 for the trick to automatically handling
this "generic stop" system.
Typestyle changes next to punctuation
Headings
</> for headings. This presents you
with an explicit start, generic stop situation; you need to identify the
ends of major and minor headings to place the correct ($s) or (\\rt)
commands. Section 5, Part 3 gives samples of how you do it.
Breaking Text into Paragraphs and Lines
Paragraphs in Input Files
<p>. In
this situation, you replace every <p> with BEX's
paragraph ( $p ) indicator. An explicit tag may also appear for meaningful
new lines, or a <CR> may signify a new line. Microsoft's RTF uses
\par as a tag for paragraphs and \line as a tag for
meaningful new lines.
<nl> or
<l>, subsequent items are tagged with just a
<CR>, and the end of the list is tagged with the generic
</> end-tag. Whenever a format appears within an
explicit "begin" and "end" tags, it's time to write a contextual Replace
transformation using on and off strings: a sample appears in Section 5,
Part 4.
New lines in Input Files
Paragraphs in Output Files
Curling Quotation Marks
<bq> and </bq> tags: when "block
quotations" are generically coded, then the publisher can use the
enclosure symbols appropriate to the national style or language: single
quotes \\is
f4cc96thcc39f15 \\xs, double quotes \\is
f4cc170thcc186f1
5 \\xs, or guillemots \\is
f4cc171thcc187f1
5 \\xs. In the "Open-Apple" sample file in Section 5, beginning
quotes are shown with two accents `` while ending quotes are
shown with two apostrophes '': both are changed to the Apple
double quote (") before translation.
<l1>, and the end by </l1>.
Each item in the list may begin with simply one <CR> the "list item"
<li> tag, or a number sign . This is an easy task for
contextual Replace.
Horizontal and Vertical Spaces
Coded Command Characters
Part 1: Overview of the Task
Task 1: Locating Files
Task 2: Importing Data into BEX chapters
Task 3: Confirming workability
Task 4: Isolating Test Data
TEST DATA chapter by grabbing BEX
pages from various chapters having the qualities you desire.
Task 5: Analyzing the textfile format
TEST
DATA chapter. Always create modified copies during
testing, because you must compare the original with the altered
version to see if it worked correctly.
Final Processing
MAKE$C, translating,
and replacing with FINETUNE-C was all that remained. Since we
definitely wanted to make separate disks with the $2 chapters, our Sider
hard disk came in handy. We loaded the 16 floppy disks onto the Sider, and
designed an automatic procedure chapter that replaced, translated, and
replaced again. We set the auto chapter in motion at quitting time; when
we came in the next day, the data was ready to preview.
Part 2: The "Open-Apple" Sample
/Open.Apple contains the ProDOS textfiles for the November
1987 issue of the monthly "Open-Apple" magazine. Pages C5:22-29 of this
Manual are a facsimile of the inkprint original. RDC has been a subscriber
to Open-Apple from its first number, and we think it's neater than sliced
cheese. We wrote to them and asked how the magazine was prepared: they
told us they used ProDOS AppleWriter, embedding markup commands for their
outside typesetter.
Dissecting the Inkprint
Importing Data into BEX Chapters
/Open.Apple disk into drive 2
and press D at any BEX menu. Since it's a ProDOS, not DOS
3.3, disk, BEX beeps and reports Cannot read the disk. This
doesn't necessarily mean the disk is bad. The only BEX option that can
handle ProDOS disks is Read textfiles to chapters on the Second Menu.
Here's how you use it:
Second Menu: f2R
f0Read textfiles to chapters
Textfile:
At this point, replace your BEX disk in drive 1 with
an initialized data disk.
Textfile: f22 <CR>
f0There are 4 textfiles
1 NOV
2 CTRL.I.2
3 NOV.L1
4 ALTS
Use entire list? N f2Y <CR>
f0For textfile NOV
Target chapter: f2NOVA <CR>
f0For textfile CTRL.I.2
Target chapter: f2CTRL-I <CR>
f0For textfile NOV.L1
Target chapter: f2NOV-L1 <CR>
f0For textfile ALTS
Target chapter: f2ALTSB <CR>
f0extensive reading and writing between
disks 2 and 1
f0Second Menu:
Confirming Workability
NOVA chapter. First off, you
see the article title "Reality and Apple's vision"; at some point you can
change the cryptic chapter name NOVA to REALITY.
Visi and you see it begins with
<Esc>Y<Esc>X and ends with
<Esc>Y. The next italics word has the ending
<Esc>Y before the comma. We're going to
have to transpose this kind of punctuation in our transformation chapter.
was<space>i and you see
<Esc>M<Esc>Y<Esc>B. This bold type also
ends with <Esc>Y; the typestyle changes in Open-Apple
are coded with an explicit start, but a generic stop command.
If the distinctions between bold type and italic type were
important in the braille transcription, then the transformations would
have to discriminate between the end of italic type and the end of bold
type.
CTRL-I chapter to the screen--clearly it contains the
"Control-I"nterface" S"tandards" article. For the moment, ignore the
random-seeming letters and numbers that pop up--they are preceded by
<Esc> in the data, but that <Esc> doesn't appear when you
print to the screen. Don't worry about how type is coded here; at this
point, we want to see if the data is complete and correct. Two out of four
and everything seems to be in order.
Open-Apple Drawbacks
NOV-L1 chapter,
you hit a snag. The major heading "Ask "or Tell" Uncle DOS" is missing, as
well as the help wanted ad in italic type underneath it. The first letter
"Mopping up EMI," seems to be all there. But the start of the second BEX
page is quite mysterious: Instead of the "Patch instructions patchy"
heading, you see "aedi revelc", which doesn't appear anywhere in the
Open-Apple issue. When you advance by <CR>s with control-A
control-L, the next letter heading is "Frigid Flaw,"
which shows up on p. 3.80! As is common in periodicals typeset by outside
firms, the data in the letters column is not in final inkprint order, and
some of the material that was typeset never got pasted up for
the November issue.
ALTSB chapter, and you
see many short paragraphs at random--this a corrections file. "ALTS" is
probably short for ALTSB data against the inkprint to put it
where it belongs. The material requiring CBC transcription is not all
shown in a unique font, so you must place some ClasX-CBC commands
manually. On the other hand, Open-Apple is a monthly publication. The type
that didn't make it into the November issue probably shows up in the
December issue; the "missing" data from the November issue probably
appears on the October disk. When you have the opportunity to create
timely braille editions of a popular magazine, the combination of machine
input, a few transformations, and some manual effort can be an acceptable
price to pay.
Designing the Open-Apple Transformations
[]; if you want to make sure,
then use Replace characters to change [] to itself. When you
do this, BEX tells you it's replaced zero times, proving no
[] characters appear. Get back to the Main Menu, place an
initialized data disk in drive 1, and use this first transformation as an
opportunity to name the chapters more appropriately; the dialogue goes
like:
Main: f2R f0
Replace
Chapter: f22 <CR> f0
1 NOVA
2 CTRL-I
3 NOV-L1
4 ALTSB
Use entire list? Y f2<CR>
f0
Naming method: f21I <CR>
f0
For chapter NOVA
Target chapter: f2REALITY <CR>
f0
For chapter CTRL-I
Target chapter: f2INTERFACE <CR>
f0
For chapter NOV-L1
Target chapter: f2LETTERS <CR>
f0
For chapter ALTSB
Target chapter: f2CORRECTIONS <CR>
f0
Use transformation chapter: f2<CR>
f0
Enter terminator: f2# f0
Find: f2<Esc># f0
Change to: f2[]# f0
Find: f2# f0Continue? Y
f2<CR> f0
Chapter NOVA done
Chapter CTRL-I done
Chapter NOV-L1 done
Chapter ALTSB done
Replaced 719 times
Save transformation chapter: f2<CR>
f0
Main:
[], we can print data to the screen for our format research.
It's important to gather markup samples from a variety of contexts: note
down the escape codes that start bold type by locating for at least three
bold words. The following chart summarizes the markup patterns we found,
and how we decided to transcribe them. Again, don't base your
transcriptions on ours--contact a certified transcriber.
<CR>[]M
$p
[]B[]XOpen-Apple[]Y
Open-Apple
``
"
''
"
[]H[]S24[]W19[]Z26<CR>
$s\\hd
[]H[]S18[]W14[]Z18<CR>
$s\\hd
[]H[]S14[]W11[]Z14<CR>
$s\\mh
<CR>[]M[]Y[]B
$p\\ib
[]Z05<CR>[]P<CR>
$s\\cbs
[]Z07<CR>[]2<CR>[]M
$s
[]Z05<CR>[]T<CR>[]M
\\rt$p
[]Y
\\if
[]Z07<CR>[]2<CR>[]M
\\cfs$s
[]Y[]X
\\ib
[]B[]X
\\ib
[]Y
\\if
[]Y
\\if \\end3coltable
<CR>[]M also
appears at the end of major and minor headings. The "return to normal
font" markup []Y that defines the end of a paragraph heading
also appears within the "begin italic font" markup []Y[]X.
These kinds of partial overlaps are common; they force you to plan the
order of rules carefully.
OAT on your
ClasX-CBC disk is the result of several experiments on our part. We've
added comments about each rule in the following printable version:
Creating test data
Inkprint pages 3.75 and 3.76 contain italic,
bold, and bold italic type, as well as displayed computer notation--this
text should be contained in the first few BEX pages of the
INTERFACE chapter. Edit this chapter and locate for
Zap.[]Y, the minor heading towards the bottom of print page
3.76. You'll find it at the end of BEX page 5. Use Grab pages on the Page
Menu to copy the first five BEX pages of INTERFACE to a
TEST DATA chapter. OAT's
Effects
OAT transformation chapter on
your TEST DATA and take a look at the results. Since the
commands that end displayed computer notation and major headings are the
same, the first (\\cfs) on BEX page 1 is incorrect, and needs to be
manually deleted. Don't bother deleting it here, since this is just a
test. Instead, make a note to check the appropriateness of the (\\cfs)
command when you review all the transformed data.
[] command that OAT missed. In the
original, the data looked like:
program
selector[]Z07<CR>[]2<CR>[]M[]Y[]BZap.[]Y The Zap command
OAT transformation, it looks like:
program selector \\cfs$s\\if[]BZap.\\if The Zap
command
<CR>[]M is
included in the find string of both the "end displayed CBC" and "begin
paragraph heading" rules. The "end displayed CBC" rule comes first; after
it's executed, the data looks like:
program selector \\cfs$s[]Y[]BZap.[]Y The Zap command
The
<CR>[]M[]Y[]B pattern that
starts a paragraph heading no longer exists. A later rule changes
[]Y[]BZap.[]Y to \\if[]BZap.\\if. To prevent
this blurring of the end of displayed computer notation and a paragraph
heading, add another rule to OAT:
\\transcom []Z07<CR>[]2<CR>[]M[]Y[]B|Find
the COMBINATION of end CBC and start paragraph heading
\\cfs$s\\ib|change to the equivalent TranscriBEX
combination. \\endtranscom
As mentioned earlier, the Letters column, "Ask "or
Tell" Uncle DOS," uses type faces differently. The letters themselves have
the same pattern of roman, with italics marking software titles, etc. But
the editorial replies are entirely italic, and emphasized text here is
shown by bold italics. The
OAT transformation changes both
"begin italics" and "begin bold italics" to TranscriBEX's italics begin
command, (\\ib). The problem lies with the end bold italics
command: in the editorial replies, emphasized text ends with
[]Y[]X, because the type changes from bold
italics to regular italics. The OAT transformation would
create <text> \\ib <emphasized text> \\ib
<text>.
Careful study of the data shows that, when it's
signalling the return to the base italics text, the
[]Y[]X
markup appears three ways:
<emphasized
text>[]Y[]X<space><text>
<emphasized
text>[]Y[]X<punctuation><space><text>
<emphasized
text><punctuation>[]Y[]X<space><text>
[]Y[]X means the
start of a bold italics word, however, it appears as
<roman text><space>[]Y[]X<emphasized text>.
Notice how we handle all four situations in the following transformation
rules:
In practice, you'd copy
OAT and insert
the rules above to create a transformation chapter especially for the
letters data.
Beyond Testing
Coping with Corrections
CORRECTIONS chapter into
the appropriate spots. These corrections are designed to be "stripped in"
to the final paste-up, and they're at least two lines long. "Any smaller,
and they'd be too hard to physically handle!"
CORRECTIONS chapter to the
screen, and you see a []F markup appears in the middle of
several sentences. Chances are good this markup tells the typesetter to
"force justify" a line: []F with one space. Many of the corrections don't
start with <CR>[]M, since they don't happen to be
fixing the beginning of a paragraph.
CORRECTIONS
chapter and compare it with the inkprint. Then copy the first correction
to the Clipboard, edit its target chapter, and find the incorrect
original. Delete the wrong stuff and insert the right stuff from the
clipboard; repeat for all your corrections.
Charts Set in Monospaced Type
You'll frequently encounter charts set in
monospaced type, not because they're showing communications with a
computer, but because it's much easier for the author to format.
Typesetting tables and columnar material is even worse than
brailling them: with monospace type, the author can use spaces to line
things up. What they see on their word processor will be what they get in
type.
An excellent example of this appears halfway down
the first column of page 3.78. Transcribing this entire chart as set-off
CBC would drive a braille reader nuts: the Countable Spaces Indicators and
Continuation Indicators would only obscure the information. If you had
several pages of charts like this, it would be worthwhile to write a
contextual transformation chapter to reformat it. In this case, it's
faster to just type it in.
Adding Embedded CBC Commands
ADD CBC-T contextual transformation
chapter on your ClasX-CBC disk uses patterns of vocabulary to flag the
majority of words requiring CBC transcription. Here's a rule-by-rule
rundown on what it does:
\\cb. On the
first hit, we type in <space>\\cf where it belongs, and
then copy the end CBC command to the clipboard. We can continue locating
for the beginning of CBC and inserting the end command from the clipboard.
#[style=Trans note]# Inkprint pages C5:22-29 are a facsimile of the
November, 1987 issue of the magazine Open Apple. These pages have been
omitted from the braille edition.
#[Xstyle=Trans note]#
Scope of the Problem
</> symbol. The Chicago Guide refers to
this generic stop as "the exit code." Thankfully, SGML prohibits
nesting of empty end tags. In the following sample, the
</> tag serves three roles:
</> would have appeared as </h1>,
the second </> would have appeared </e1>, and the third </> would have
been </e2>. In terms of braille transcription, these
SGML tags should be transformed to the following TranscriBEX and ClasX-CBC
commands: \\2coltable
<h1>
</h1><CR>
<e1>
</e1>
<e2>
</e2>
An Unacceptably Slow Solution
</> to (\\rt$p) when
the </> is defining the end of a first level heading.
Here's a very slow way to accomplish this goal:
</> to a character
that's different than all the start tags, for example, %%%
three percent signs.
~~~, three tildes.
~~~ from one of the start tags, for
example, <h1>.
</h1>.
<h1> as your on string and
~~~ as your off string, change every %%% to
</h1>.
~~~ from another of the start tags, for
example, <e1>.
</e1>.
<e1> as your on string and
~~~ as your off string, change every %%% to
</e1>.
</e2>.
%%%s signal the end of the
second level of ~~~s
appear at the start of second level emphasis. Change %%% to
(\\if), ~~~<e2> to (\\ib), and do all the other
transformations set out in the chart above.
Efficiency with the Galloping Gobble Technique
fox- and changes them to dog, only between plus
signs and hyphens. Assume the following text appears after a plus sign in
the chapter; let's examine how BEX handles it:
A fox-y fellow
fox- characters and replaces them with the
dog characters.
Galloping Gobble Technique Sample
~~~ before each start tag, and inserts an off
string of %%% at the end of each start tag.
<h1> tag up
until any other </> end tag in this context is "end heading;" the
second rule therefore expands </> to
</h1>. You can use this technique to expand any number
of generic end tags to their explicit counterparts.
Cautions on the Galloping Gobble Technique
%%% as an off string and
has rules that insert %%% in the data. In our sample, the
first transformation didn't have on and off strings; it just placed them
for the benefit of the second transformation.
PRINT-TABLE and BRL-TABLE transformation
chapters for ClasX-LBF depend on inserting active off strings. Edit a copy
and see if you can figure out how they work! If you want to venture out to
the fringes of contextual Replace, here's a piece of advice: the find
string of a rule that inserts active on strings should be longer than the
change to string.
\par. The RTF control symbol for the closing double quote is
\'d3. The entire RTF file is a series of "groups," which
begin and end with braces. For example, the bold word ALERT
in a roman sentence appears as The two {\b .
RED SAMPLE chapter on your ClasX-CBC
disk is a portion of the "outmoded" documentation for the Macintosh
terminal program "Red Ryder." The inkprint version appears on pages
C5:46-49 of this Manual. This file started out as a native Microsoft Word
document: we opened it and then "Saved as..." RTF text. Our Mac sits next
to an Apple IIgs: we transferred the file over a cable between them,
saving the data to disk using BEX's Input through slot.
Analyzing the Header
RED SAMPLE; we've isolated it on the first BEX
page. Your initial impulse may be to run screaming from the room, because
it looks like a mad jumble of random characters. Use Grab pages to copy
the header page to a new chapter, then delete it from RED
SAMPLE. Make hardcopy versions of the header and the now-smaller
RED SAMPLE chapter to follow along with this discussion.
Coded Command Character Follies
\\ RTF data backslash and change it to something completely
different very early in the first transformation. When we're all done
placing TranscriBEX commands, we change that different something to a
single backslash.
Results of our Analysis
RED1 and RED2 on
your ClasX-CBC disk. RED1 expands the control symbols to the
characters the translator wants to see, and handles most of the
paragraphs. It also places on and off strings for the benefit of
RED2. RED2 uses the Galloping Gobble Technique
to expand the generic stop } to the "end emphasis" command
that TranscriBEX needs, as well as change paragraph indicators inside
set-off CBC to hard <CR>s.
Inside
RED1\\? and replace the question mark with a c when
it should be CBC, or an i when it should be braille italics.
RED1 places
on and off strings for the benefit of RED2. We chose these
carefully: the on string uses the control word pattern already present:
{\. We use a control character as an off string in
RED2 since it's less confusing. Between the single
backslashes and the double backslashes, it's hard enough to keep the plain
text characters straight. In the following samples, our single off string
character is shown with the four characters <LF>, "
also known as linefeed or <control-J".
Inside
RED2<LF> stands for a single <control-J>, so it's
paired with a single pattern code.
RED SAMPLE chapter and editing the
result. There's definitely room for Example #1:\\?b \\?fOn. Check the original and you see a bold
group that contained a single space--we have no idea why that's there, but
the transformation chapters rendered it faithfully. On the next BEX page,
the first set-off CBC command didn't appear where it should:
$p\\?f \pard\plain \s3\fi-360\li720 \f22 COMM
300-N-8-1-FULL
You can see traces of the culprit in that (\\?f)
command, which started out as a right brace. Check the original, and you
see that the bold group at the end of the previous paragraph ends
after the
\par control word.
RED1's rules assume just one space between the
\par and the next control word, \pard. Since a
brace intruded, the ($s\\cbs) wasn't placed. One could force every
paragraph to be an RTF group by placing (}$p{) instead of plain ( $p ).