CONTENTS

Characteristics of the Script Manager
Working with Script Files
Script and Function Overview
Calling a Function in a Script
Calling Another Script in a Script
Accessing Script and Function Information
Glossary of Scripting Terms
Inserting a Function within a Function
Script Manager's Compiler
What is Compiling?

----------
Characteristics of the Script Manager

The Script Manager is a JAWS script editing program with all the features
necessary for you to create scripts. These features include:
	* Hot keys for quick file navigation, text editing, and dialog access
	* Easy to follow dialogs that help you to find and assign scripts, functions,
and parameters
	* Seamless information transfer to other files
	* Commands for opening and saving both user and shared script files
	* A compiler that checks for syntax errors when compiling
	* A zoom feature for those of you with low vision

You can access the Script Manager from the Utilities Menu or from the Run JAWS
Manager dialog (INSERT+F2). The Script Manager always opens the script file
associated with the active application. If the program does not have any
scripts, JAWS creates a new script file.

While you can have multiple script files open at the same time, you can only
have one instance of the Script Manager running. To move between multiple
script files, press CTRL+TAB.

JAWS allows you to have both user and shared versions of the same script file.
User script files are only available when a particular user is logged in to
the computer. To open a user script, choose Open or Open User File from the
File menu. Shared script files are available to all JAWS users on the computer
or network. If a user version of a script file is available, JAWS uses that
file instead of the shared version. To open a shared script, choose Open
Shared File from the File menu.

You can save your changes and compile the script by using the Save command. If
you modify a shared script and then save your changes with this command, JAWS
saves the file in your user settings folder. To save the currently open script
as a shared file, choose Save As Shared from the File menu. To save the
currently open script as a user file, choose Save As User from the File menu.

Tip: You can view the contents of your shared and user settings folders by
using the Explore JAWS submenu in the JAWS program group.

If you are scripting for JAWS for Windows CE, then you will want to change
this directory to something other than the default. To do this, use the Save
As command, which can be found in the File menu, and specify a different
directory. The Script Manager will now save and compile your script files in
this directory until you open another instance of this program.

You can change the tab settings in Script Manager by selecting Tab Size in the
View menu. Using Tab indentation with complex scripts and functions helps in
understanding the logic and sequence of the script.

At times, you may be working with multiple files from multiple directories. To
always know what directory you are in, you can choose to display the full path
in the title bar. To do this, go to the View Menu and select Display Full
Path.

Also found in the View Menu is the zoom feature, which allows you to magnify
contents of a file from 100 to 500%.

If you are not finished writing your scripts, you can save the work you have
done without compiling by pressing CTRL+W.

The table below lists all the hot keys available in the Script Manager.


Hot Key

Command Description

CTRL+O

Open a Script File

CTRL+SHIFT+D

Open the User Specific Default Script Source File (Default.jss)

CTRL+N

Create a New File

CTRL+F4

Close Current File without Closing Script Manager

F2

Move to Next Script

SHIFT+F2

Move to Previous Script

CTRL+F

Find

F3

Find Next

SHIFT+F3

Find Previous

CTRL+H

Find and Replace

ALT+CTRL+I

Incremental Search

CTRL+G

Go to Line

CTRL+E

Create New Script

CTRL+S

Save and Compile

CTRL+W

Save without Compiling

CTRL+TAB

Move between Open Files

CTRL+I

Insert Function (works from within the Insert Function dialog if you need a
function inside another function.)

CTRL+R

Select Script or Function

CTRL+D

View/Edit Documentation for the Current Script or Function

CTRL+P

Print File

CTRL+DEL

Delete Script

CTRL+SHIFT+I

Insert Perform Script

CTRL+L

Script List

SHIFT+F1

Keyword Help


Back


Next

----------
Working with Script Files

When you use the Open Shared File and Open User File commands on the File
menu, JAWS lists the .jss files in either your shared or user folder. The
shared folder contains .jss files for every application JAWS supports. Your
user folder contains script files that you have created or modified. The file
Default.jss is especially important because it contains all the scripts and
functions used by JAWS to interface with Windows applications and because any
scripts added to this file cause global changes in the behavior of JAWS. While
you are working with Script Manager, you can quickly access this file at
anytime by pressing CTRL+SHIFT+D.

Similarly, you may find that you want scripts to affect only a specific
application. For this, you would need to open and add your scripts to the
application-specific .jss file. The easiest way to access an application's
.jss file is to open the application with JAWS running in the background and
press INSERT+F2, S, ENTER. To be sure you have the correct file open, press
INSERT+T.

Tip: You can use the Confignames.ini file to associate a more meaningful name
with the application. Your settings files can then use this alias instead of
the executable file's name. You can modify this file with any text editor
program, such as Notepad. For more information, see Naming JAWS Settings Files
in the Basics of Scripting manual.

After you open a .jss file that contains multiple scripts, use F2 or SHIFT+F2
to move among each script. If you are looking for specific text string, press
CTRL+F to open the Find dialog. Once you have found the text string, you must
close the dialog in order to edit. However, you can now press F3 or SHIFT+F3
to find another instance of the text string and immediately begin editing. If
you are making multiple and identical edits to the same text string, you may
want to use the Replace dialog instead. To open this dialog, press CTRL+H. The
Find and Replace dialogs allow you to make your searches case sensitive and/or
match whole words.

Another method of searching for text that you may find faster and less
obtrusive is the Incremental Search feature. This feature lets you skim your
script files and quickly edit as there is no dialog to open or close. In
addition, Incremental Search works well with F3 and SHIFT+F3. To use this
feature, press ALT+CTRL+I and then type the letter(s) or word(s) you are
searching for. As you type the letters, your cursor will move about the page,
while JAWS announces the text of the incremental search. The search displays
in the Status Bar, which you can read by pressing INSERT+PAGE DOWN on the Num
Pad. Move up or down in the search with F3 or SHIFT+F3. These keystrokes
remain available after exiting Incremental Search. Once you are on the line or
in the area you want to edit, you must press one of the arrow keys to exit
Incremental Search. You can then edit the script.

If you are familiar with a script file and you know the line that contains the
script you want to work with, use the Go To Line dialog (CTRL+G). Type the
number of the line and press ENTER. The cursor moves immediately to the
beginning of the line you specified. You can always find the number of line
you are working on by reading the Status Bar.


Back


Next

----------
Script and Function Overview

The JAWS Scripting Language is comprised of scripts and functions. Scripts can
be associated with keystrokes. For example, when you are in a word processor
and press the DOWN ARROW, JAWS reads a new line of text. A default script,
called SayNextLine, is associated or "bound" to the DOWN ARROW key.

Functions, on the other hand, are not bound to keystrokes and are always
called by a script or another function. Functions can use parameters to
complete a task and often return information or a specific value. The JAWS
scripting language has three different types of functions: event functions,
built-in functions, and user-defined functions.
	* Event functions execute automatically when a Windows operating system event
occurs. You cannot create new event functions. However, you can modify
existing event functions. You can also create application-specific versions of
the event functions found in the default script file.
	* User-defined functions can use existing built-in functions to create new or
modify existing user-defined functions
	* Built-in functions are the building blocks of scripts and functions. They
can not be modified or created.


Back


Next

----------
Calling a Function in a Script

This topic is a brief overview on writing scripts with the Script Manager. To
learn more about scripting, refer to the Basics of Scripting Manual. In
addition, the Freedom Scientific training department offers classes on
scripting. To see a schedule of classes offered, please visit our course
schedule.

Before you begin writing scripts, you need to have a good understanding of
what you want JAWS to do and whether you want JAWS to do it in a specific
application or in all applications on your computer. Once you have answered
these questions, you should then write out each step in order.

For example, you would like the command CTRL+1 to say, "Hello World!" in the
Notepad application. The easiest way to start this process is to open Notepad,
and then open Script Manager by pressing INSERT+F2, S, ENTER. Because there is
only one step, you do not need to write it out. Notice that the Script Manager
opens Notepad.jss, which is blank. This is because there are no scripts
written for this application and all JAWS functionality comes from the default
script files in JAWS.

As a matter of good scripting practice, you should begin a new script file
with the following information:

; Script File for Application Version x.x
; JAWS Version x.x
; Date
; Your Name

Notice the semicolon preceding each comment entry. In the JAWS scripting
language, semicolons are used to set off comments and always precede the
comment.

After you finish typing your name, press ENTER twice to put space between your
comments and your first script. Next, press CTRL+E to open the General page of
the New Script multi-page dialog. In the Script Name edit box, type the name
of the script you intend to write. Use initial caps and do not use spaces,
underscores, or punctuation. For this script type "HelloWorld". Since this
script will use a keystroke, check the Can be Attached to Key check box. In
the Synopsis edit box, type a brief sentence describing what your script will
do. For instance, you could write, "Speaks a hello world message." In the
Description edit box, you should provide more information about the function
of the script. In the case of this script, you could type, "Speaks a hello
world message in Notepad. Using this keystroke does not honor your Verbosity
Settings." These two edit boxes are important, particularly if you are
scripting an application for someone else, because keyboard help (INSERT+1)
uses this information.

The Category edit combo box is currently not used for scripting. The next
control is the Assign To edit box. In this edit box, press the actual
keystroke you want to use to activate the script, such as CTRL+1. Press ENTER
to close this dialog and return to the Notepad.jss file. Your .jss file should
look like this:

Script HelloWorld ()
EndScript

Notice that the New Script dialog automatically places your cursor in the
script's body area and inserts the appropriate beginning and ending keywords.

Now you are ready to insert the function that is called when the keystroke,
CTRL+1, is pressed. To do this press, CTRL+I. When the Insert Function dialog
opens, the Function Name edit box is active. Since the function in this script
is SayString, type "SayString" or just type "Say" and use the list box to find
the function SayString. If you are not familiar with a function, you can
listen to the description, as this gives good information about what the
function does. When you are done listening to the description, press ENTER.

When you choose a function that requires a parameter, the Insert Function
dialog asks you to enter the parameter. In addition, it describes the type of
parameter the function can accept.

Note: JAWS functions often require one or more parameters. A parameter in the
JAWS scripting language is defined as a value that is used by a function to
determine the characteristics or behavior of a script. For example, the
HelloWorld script tells JAWS to say, "Hello World" when you press the
keystroke CTRL+1. The parameter in this example is "Hello World" since this is
the value that the SayString function uses when the HelloWorld script is
activated with CTRL+1. If you change the parameter to "Have a nice day," then
the behavior of the script changes. There is much more to parameters than what
is given here. To learn more about parameters, please see Inserting Functions
in the Basics of Scripting Manual.

In the Parameter 1 edit box, type "Hello World!" and press ENTER. This takes
you back to the Notepad.jss file, which now has SayString ("Hello World!") in
the body area of your script. Your script should now look like this:

Script HelloWorld ()
SayString ("Hello World!")
EndScript

Press CTRL+S to compile and save your script. Then go to the Notepad
application and press the command CTRL+1.

To listen to the synopsis of the script, activate Keyboard Help and press
CTRL+1 once. To hear the description of the script, press CTRL+1 twice in
succession.

You have just written your first script. While this script is rudimentary, it
does illustrate the basic knowledge needed to write scripts. However, there is
much more to scripting and much more you can do with scripts.


Back


Next

----------
Calling Another Script in a Script

When writing scripts you may find it necessary to call another script within
the script your writing. For example, the following script uses the
SayAppVersion Script to read the Microsoft's version number of Word.

Script SayWordVersion ()
PerformScript SayAppVersion()
EndScript

To analyze this script, open HJPad and Script Manager (INSERT+F2, S, ENTER).
Next, open Default.jss (CTRL+SHIFT+D). Press CTRL+L to open the Script List
dialog and type SayAp. Once SayAppVersion is selected, press ENTER as this
takes you directly to the script in Default.jss. To avoid accidently altering
your Default.jss file, press CTRL+R to select the entire script and copy it
into your blank HJPad .txt file. Use your UP and DOWN ARROWS to read each line
of the script. (Notice the size of the SayAppVersion script.) In the
SayWordVersion script above, you could copy and paste this script in place of
PerformScript SayAppVersion without affecting the behavior of the
SayWordVersion script. But it is much easier to use PerformScript as this
calls the script directly from Default.jss. The Insert PerformScript dialog is
easy to use as this lists all the scripts contained within Default.jss. In
addition, this dialog can be activated within your .jss file with CTRL+SHIFT+I
so you can quickly insert scripts without selecting, copying, or pasting.

In your HJPad.jss file, press CTRL+END as you always write your next script at
the end of the file. Press CTRL+E and create a script called SayHJPadVersion
and assign it to CTRL+2. After you close this dialog, press CTRL+SHIFT+I, type
SayAp and press ENTER. Now, compile your script, move to your HJPad
application and press CTRL+2.

Congratulations! You've just completed your second script and scaled up many
levels in your scripting knowledge! The next topic shows you how to access
information about scripts and functions with Script Manager.


Back


Next

----------
Accessing Script and Function Information

With Script Manager, you can view documentation for any script or function as
well as information on any key word used in a script.

To view key word help, move the insertion point to a key word in a script or
function and press SHIFT+F1. The Script Manager displays the Key Word Help
dialog containing specific information on the script or function.

After you have reviewed the key word help information, press ESC to close the
Key Word Help dialog.

You can also view documentation for any script or function within the current
script file. First, move the insertion point to an individual script or
function. You can use the Next Script (F2), Prior Script (SHIFT+F2), or Script
List (CTRL+L) actions to move to the desired script or function. Any of the
three navigation methods will move the insertion point to the beginning line
of the script or function. Press DOWN ARROW twice to move into the body of the
script or function. This also removes the highlight from the name of the
script or function. To view the documentation, press CTRL+D. This displays the
Script Information multi-page dialog. The General page of this dialog displays
general information about the script or function. The information shown in the
Script Information dialog changes depending on whether you are viewing script
or function information. The Parameters page displays the parameters used by
the selected function. You can view a list of existing parameters on this page
along with their descriptions. After you are finished viewing the script
information, press ESC to close the dialog.

Back


Next

----------
Glossary of Scripting Terms

Application Script Files - These files are loaded on top of the default files
when an application runs. JAWS knows to load the application script files,
because the application script name (except for the extension) is the same as
the application program name. You can have both user and shared versions of
application script files. Shared scripts apply to all users on the computer or
network when they use the application with JAWS. User scripts are loaded only
by a specific user on a computer or network.

Arithmetic Operators -Arithmetic operators are used to perform classic
arithmetic operations within scripts. The four operators are a minus sign or
dash (-) for subtraction, a plus sign (+) for addition, a slash (/) for
division, and an asterisk (*) for multiplication.

Basics of Scripting Manual - This guide provides an introduction to the JAWS
scripting language. In it, you will find detailed information on scripting
terms, syntax, functionality, and more. There are also numerous exercises to
help you practice what you have learned. The Basics of Scripting manual is
available in HTML Help format. You can download this manual from the Freedom
Scientific Web site.

Bitwise Operators - You can use bitwise operators to compare two pieces of
information bit by bit instead of as a whole value. Computer information is
stored in digital form as a series of ones and zeros (bits). In a bitwise
comparison using the & operator, a value of true or 1 will be returned for
every pair of bit positions in the two pieces of information which are
identical.

Built-in Functions - The JAWS script language includes over 200 pre-defined
functions for use in scripts. Each function performs a specific series of
activities. These are the building blocks or instructions from which you
create your scripts.

Built-in Operators -The JAWS script language includes 3 types of operators you
can plug into functions when creating or editing. Operators come in several
varieties, each with a specific ability. The three types are; Arithmetic,
Logical, and Bitwise Operators

Comments - Comments are lines of text in your script file that are not
executable statements. They are used to inform those reading the source file
how the statements work. In the code, you can indicate that a line of text is
a comment by preceding it with a semicolon or pound sign. You can also
surround the comment text with /* and */.

Compile - When you save a script file using the Script Manager, your file is
saved and compiled into machine-readable language. When the Script Manager
saves a file, it creates an additional file that is converted from text into a
binary format, a form that JAWS can understand and use.

Confignames.ini - JAWS uses this file to associate more meaningful names with
the executable file names of Windows applications. You can then use this alias
when naming your JAWS settings files for this application. The Confignames.ini
file can be found in your JAWS settings folder.

Constants -Constants do not change their value. Once a value is assigned to a
constant, it stays that way. They can be used to represent a complex string of
letters or numbers.

Control IDs -The Control ID is an arbitrary number assigned by the programmer
to identify each window in his or her program. These Control IDs do not change
during program operation. The Control ID, unlike the Window Class, has no
special meaning other than the fact that it can be used to refer to a
particular window.

Default Script File - The information which tells JAWS how to behave is
contained in a default set of files, which are built into JAWS. The default
script files (Default.jss) are loaded when JAWS starts and are always active
during all application sessions. Default.jsm file contains messages useful
only to Default.jss. However, hjglobal.jsh and hjconst.jsh are used in any
script file that refers to JAWS global variables and constants.

Event Function - An event function runs automatically when certain system
events occur.

Functions - A block of code that is not called by a keystroke and activates
only when called by a script or another function.

Global - Variables can be local or global. Global variables can be used in any
script within the script file where they are defined. Global variables can be
declared at the beginning of a script file with the group heading, Globals.
Place this group right after the include statements.

Header Files - Header files are designated with the extension .jsh and contain
either variable or constant declarations.

Hjconst.jsh - Contains the default JAWS constants.

Hjglobal.jsh - Contains the default JAWS global variables.

Hook Functions - Sometimes it is necessary to put JAWS into an alternative
state where some or all of the keys on the keyboard perform different
functions when pressed than they normally would. Briefly, a hook is a special
user-defined function that you create, which is run instead of the code
normally run by JAWS scripts.

Includes -The purpose of an include statement is to tell the script source
file (.jss) that information from other named files is to be included as part
of the script. The syntax for an include statement requires that the file name
along with its extension be enclosed in quotation marks. It is assumed that
the file to be included is contained within the language (ENU) subdirectory of
the \SETTINGS subdirectory of your JAWS directory.

Integer- An integer variable is designed to hold an integer value. An integer
is a whole number without a decimal point.

.jkm File Extension - This is the JAWS key map file. This file contains the
keystrokes assigned to various scripts.

.jsb File Extension - This is the JAWS Script Binary (machine-readable
language) file that is created by the Script Manager when you save and compile
a .jss file. You do not directly create this file nor do you edit this file.

.jsd File Extension - This is the JAWS Script Documentation file. This file
contains all of the descriptive information about each script. This
information is entered into the .jsd file automatically when you create a
script using the New Script dialog. You can edit this file if desired.

.jsh File Extension - This is the JAWS Script Header file. This file contains
information relevant to the associated .jss file, such as definitions of
constants and global variables. See Constants and Variables for more details
about these script components. See also, Include Files.

.jsm File Extension - This is the JAWS Script Message file. It contains all of
the spoken messages used by SayString functions. Each message in the file is
numbered. Only the number is referenced when a script uses the SayString
function to read a message. In this way, when script files are distributed
internationally, translation of the messages into other languages is easier
when numbered messages are used. See Include Files.

.jss File Extension - This is the JAWS Script Source file that you create when
making application-specific script files. This file must be compiled before
JAWS can use it.

Local - Variables can be local or global. Local variables can only be used in
the script where they are declared. Local variables are declared within a
script in the first statement after the begin statement. They have the
heading, Var.

Logical Operators - Logical operators are used to make comparisons of
variables to other variables or constants. Sometimes several items or groups
of items must be compared with other items. The logical operators are usually
used within If-Then and While loops to check whether conditions required for
logical decisions are true or false.

Message Files - Message Files are designated with the extension .jsm and
contain message statements with their assigned numbers.

Object - An object variable is designed to hold an object. An object, for the
purposes of the JAWS script language, refers to the types of objects present
in certain Microsoft applications, such as the Office XP suite.

Parameters - A parameter is a piece of information that is passed to a script
or function. Parameters can be required or optional. If there is more than one
parameter, a comma is used to separate each parameter within the parentheses.

Returns - A return is information that is sent back from the function to the
calling script or function. The calling script or function then uses this
information. The type of returned information, such as string, Int, Object,
Handle, or Void, is declared before the function name.

Script - A script is like a mini computer program that combines a number of
steps or keystrokes into one operation,

Script Files - JAWS script files are a collection of individual scripts,
functions, and variable declarations that are automatically loaded whenever
JAWS is used with a particular Windows application.

Script Manager - The Script Manager is the JAWS script-editing program that
has all the features necessary for you to create scripts.

Scripting Language - JAWS provides a powerful scripting language you can use
to write or edit your own user-defined function. The only difference between a
built-in function and a user-defined function is that user-defined functions
can be modified, while built-in functions, which are hard-coded into JAWS,
cannot.

Scripts - Blocks of code that can be activated by a keystroke are called
scripts, and those that cannot are called functions.

String - A string variable holds a string of characters. A string is a group
of characters including letters, numbers, punctuation marks, and spaces.

User-Defined Functions - The difference between a user-defined function and a
script is that a script is attached to a keystroke and cannot provide a
return, while a user-defined function cannot be attached to a keystroke and
does provide a return. User-defined functions can be modified. User-defined
functions run whenever they are called from within a script or another
user-defined function.

Window Classes -The Window Class of a window provides some information about
what a window does. For example, a Window Class can be an edit field, a list
box, or a button.

Window Handle - A window handle is a unique window identifier that is assigned
by the system. Window handles are numbers that can change value whenever the
application is closed, but often only change when Windows is restarted.
Although the window handle changes during program operation, you can use this
information to identify the window whenever the window is active.

Window Subtype Code - Window Subtype Code also returns an integer. Window
Subtype Codes are translated into strings using the same constant definitions
as Window Type Code. The only difference is that the Window Subtype Code
provides more detailed information.

Window Type - Window Type returns a string or name that describes the window.
Window Class of a button, radio button, and check box is always "button";
however, the programmer could add the Window Types of these three windows. In
this case, the windows are reported as "button," "radio button," or "check
box."

Window Type Code - Asking for the Window Type Code returns a number instead of
a string. This number is translated into a recognizable string by constant
definitions located in the file called hjconst.jsh. Since the same numbers are
always returned for a given type of window, the numbers can be mapped to the
actual text of the Window Type in any language.

Windows Hierarchy - Window hierarchy can be defined as the relationship
between a parent and a child in a family.


Back


Next Section

----------
Inserting a Function within a Function

Type topic text here.

----------
Script Manager's Compiler

The script compiler in Script Manager is your best friend for debugging
scripts. It also makes sure that you complete each sequence correctly. When
you save your script with CTRL+S, the compiler automatically runs, checking
syntax and statement sequences. If there are errors, it displays them in the
Compile Error dialog. After you review the listed errors, press ENTER to close
the dialog. JAWS places the cursor at or near the error. If no error is
present, you can assume that at least the syntax of your script is correct.

Once you correct the error, choose Save from the File menu to recompile the
script.

The compiler cannot always find the exact location of the mistake. For
example, if you use several If-Then statements that are nested, and you forget
to use the correct number of EndIf statements, the compiler will display an
error, but the cursor may not be located exactly where the missing EndIf
statement should be. The cursor may actually be several lines away from that
location. The compiler can only tell you that your If-Then loops are not
formulated properly and that an If statement must be followed by an EndIf
statement. It is up to you to find out where you need to put the missing
statement.

Include files are examined as they are included. Always place the include
statement in your script file before you use anything in the included file.
For instance, you must include Hjconst.jsh before using any of the constants
it contains. If you layer your script file properly, all of your include
statements should be near the beginning of the script file.


Back

----------
What is Compiling?

When you save a script file using the Script Manager, your file is saved and
compiled into machine-readable language. When you write scripts for JAWS in
the Script Manager, you write them in plain text. JAWS, however, cannot use
them in text form. When the Script Manager saves your file, it creates an
additional file that is converted from text into a binary format that JAWS can
understand and use.

The original text file is saved with a .jss (JAWS Script Source) file
extension, and the compiled or binary version is saved with a .jsb (JAWS
Script Binary) file extension. The compiler checks the syntax (coding) of your
script to make sure that it conforms to the script language rules. If there is
an error, the compiler advises you what the error is and approximately where
in the script you can find the error. This is why it is important to always
create and save your script files using the Script Manager. If you edit and
save your files using some other text editor, they will not be compiled when
you save them, and JAWS will not be aware of the changes you have made.

The Script Manager generates several types of files. You can find these files
in C:\JAWSXXX\Settings\ENU folder. Listed below are the different file
extensions along with their descriptions.
	* .jss  This is the JAWS Script Source file that you create when making
application-specific script files. This file must be compiled before JAWS can
use it.
	* .jsb  This is the JAWS Script Binary (machine-readable language) file that
is created when you save and compile a .jss file. You do not directly create
this file nor do you edit this file.
	* .jsm  This is the JAWS Script Message file. It contains all spoken messages
used by SayFormattedMessage functions. Each message in the file is given a
unique name. Only the name is referenced when a script uses the
SayFormattedMessage function to read a message. This way, when script files
are distributed internationally the translation into other languages is easier
since all messages are stored in one file.
	* .jsh  This is the JAWS Script Header file. This file contains information
relevant to the associated .jss file, such as definitions of constants and
global variables.
	* .jsd  This is the JAWS Script Documentation file. This file contains all of
the descriptive information about each script. This information is entered
into the .jsd file automatically when you create a script using the New Script
dialog. You can edit this file if desired.

Back

----------
End of Document
