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 Freedom Scientific Script Manager is a 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
Press INSERT+0 to run Script Manager. The Script Manager always opens the
script file associated with the active application. If the program does not
have any scripts, a new script file is created.

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.

Note: The Script Manager is compatible with both JAWS and MAGic.

JAWS scripts are saved to C:\Documents and Settings\user name\Application
Data\Freedom Scientific\JAWS\version number\Settings\enu.

MAGic scripts are saved to C:\Documents and Settings\user name\Application
Data\Freedom Scientific\MAGic\version number\Settings\enu.

If you want to create a MAGic script while running JAWS and MAGic together,
always close JAWS before starting Script Manager. JAWS scripts take precedence
over MAGic scripts. This means that if similar scripts are present, Script
Manager loads the JAWS scripts first. In addition, Script Manager will use the
JAWS default folder structure when saving scripts.

Opening Scripts

Freedom Scientific applications allow 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 users on the local computer or network.
If a user version of a script file is available, JAWS and MAGic use that file
instead of the shared version.
To open a shared script, choose Open Shared File from the File menu.

Saving Scripts

There are several ways to save scripts:

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, the
application 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 or the Explore MAGic
subment in the MAGic program group.

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


INSERT+0


Open Script Manager


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, the .jss files appear in either your shared or user folder. The shared
folder contains .jss files for every supported application. 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 Freedom Scientific applications 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 or MAGic running in the
background and press INSERT+0. 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 Freedom Scientific 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 or MAGic read 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
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 or MAGic to do and whether you want them 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+0. 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 and MAGic functionality comes from the default
script files in JAWS and MAGic.

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 or MAGic Version x.x
; Date
; Your Name

Notice the semicolon preceding each comment entry. In the 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+0). 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 and MAGic know 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 or MAGic. 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
Freedom Scientific 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 Freedom Scientific 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 Freedom Scientific 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 and MAGic can understand and use.

Confignames.ini - JAWS and MAGic use 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 or MAGic settings files for this application.
The Confignames.ini file can be found in your JAWS or MAGic 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 and MAGic how to behave
is contained in a default set of built-in files. The default script files
(Default.jss) are loaded when JAWS or MAGic 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 or MAGic 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 and MAGic constants.

Hjglobal.jsh - Contains the default JAWS and MAGic global variables.

Hook Functions - Sometimes it is necessary to put JAWS or MAGic 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 the JAWS and MAGic 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 or MAGic 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 or MAGic 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 Freedom Scientific 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 - Freedom Scientific script files are a collection of individual
scripts, functions, and variable declarations that are automatically loaded
whenever JAWS or MAGic is used with a particular Windows application.

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

Scripting Language - JAWS and MAGic provide 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
