                     Scripit 1.20 Command Reference
                     ==============================



Introduction:
-------------

Scripit is a not a language in the normal sense of computer languages.
It is, instead, a script language that allows the user to automate
actions he/she would normally have to do manually.  (although Scripit
goes far beyond that)  Scripit can do anything the user can do manually
by either the mouse or keyboard by using a set of commands that instruct
Scripit to simulate specific mouse or keyboard actions.

The major concept in Scripit is that of a 'selected window.'  As you
know, the Amiga's user interface consists of windows (which reside on
one or more screens.)  These windows can be moved or resized, pushed to
the front or back, and are used to get user input via the keyboard or
mouse in the form of menu selections, boolean gadgets (clicks), string
gadgets (text input), proportional gadgets (slider moves), mouse movements,
mouse clicks, and keyboard actions.  Scripit can simulate all of those
in order to automate actions.

The first step in any Scripit script is to select the 'selected window'
which may or may not be the currently active window.  Once a window is
selected, all (well, actually most) Scripit commands will act upon that
window and will send simulated actions to it.  This allows Scripit to
'drive' programs that are in the background while you are working on
something else.

Next, commands are issued in the script to do things to the selected
window.  For example:

select window "MyProgram"
menu "MenuName" "MenuItem"

This script will select the window named "MyProgram" (this is the window
title displayed in its title bar) and will then simulate the user
selecting the menu "MenuName" item "MenuItem".  The select window
command will search for the window title specified in all of the screens
in the Amiga's system at the time the script was run.  There are several
select commands in Scripit that control how the window is selected.

Scripit will never allow the user to do something that the program
doesn't expect.  For example, if a menu item was disabled (ghosted)
Scripit will not send the simulated menu selection.  This is a safety
feature that makes it more reliable since the program that disabled
the menu item probably did it for a very good reason.

Menu selections are just a drop in the ocean of what Scripit can do,
but this should give you a taste of its power.  Scripit can also output
text and graphics onto the selected window (without the program owning
the window even knowing what is happening) or output text to a console
(a text-based window) that it was run from or it has opened using
special Scripit console control commands.

The easiest way of starting with Scripit is to use the provided
'Recorder' to record user actions as a script that can be executed
again to repeat those actions.  The generated script is a valid Scripit
script and can be edited and modified.  However, the Recorder does not
use any of the more powerful Scripit facilities such as variables,
graphics and text output, console control, or logic flow commands (such
as if/else, while, goto, etc.)

Scripit can also be driven from ARexx allowing ARexx control over programs
that do not have ARexx ports... but that is a different story entirely.


----------------------------------------------------------------------------
       The following is the full reference to all Scripit commands.
----------------------------------------------------------------------------

                        Scripit Select Commands
                        =======================

The SELECT commands are used to select the window Scripit will work with.
For example,  'SELECT WINDOW Test' will tell Scripit to select the
window titled 'Test' (actually the first window starting with 'Test')
for further control.

Normally, if no SELECT command was issued, the first command that
tries to do anything to a window will automatically select the currently
active window.  If you issued a SELECT command and it couldn't find
the window you requested, it will continue from there without
aborting.  So, the next command will select the active window automatically.

The SELECT WAIT command controls the operation of all the SELECT commands.
If you issue a 'SELECT WAIT 1000' command, all the SELECT commands
afterwards will wait for 1000 jiffies (i.e. 1000/50 = 20 seconds) before
failing and continuing with the script.  (Scripit will check for the window
once every 10 jiffies.)

Also, if you specify the 'ABORT' keyword in the SELECT WAIT command, e.g.
'SELECT WAIT 1000 ABORT' all the SELECT commands will wait for the specified
time, but will abort the script if the time runs out and Scripit couldn't
find the requested window yet.  So, the SELECT WAIT command actually
controls the operation of the 'SELECT WINDOW Test' command.

There are cases when the window you are trying to select has no title.  In
that case, you can use one of the other SELECT commands for that.  They are:
SELECT SCREEN, which selects the first window in the specified screen.
SELECT MENU, which selects the window by the name of one of its menus.
SELECT GADGET, which selects the window by the name of one of its gadgets.
SELECT ACTIVE, which selects the active window.


Command Summary:
----------------

SELECT      screenname windowname

            Select the Screen (and window) all the other commands will work
            on.  If no SELECT command was used, the currently active window
            will be selected.  (In all cases, the first match will be used.)

S SCREEN    screenname

            Select the first window in the specified screen.

S WINDOW    windowname

            Select the specified window.  (Searches through all the screens
            in the system.)

S ACTIVE    Select the currently active window.

S MENU      menuname

            This will force the screen/window search to look for the
            specified menu as the search criterion for the SELECT command.
            This should only be used with programs that have no screen or
            window name.  (e.g. to select DPaint: SELECT MENU Picture)
            Make sure you select a menu name that is unique to the program
            you're looking for.

S GADGET    gadgetname

            This will force the screen/window search to look for the
            specified gadget name as the search criterion for the SELECT
            command.  This should be used only when the program has no
            no screen or window name, or any menus.  Make sure you select
            a gadget name unique to the window you're looking for.

S WAIT      [MaxDelay] [ABORT]

            This sets the time all the SELECT commands will keep trying
            to find the requested screen, window, menu, or gadget.  The
            MaxDelay is specified in ticks, (50 per second).  The ABORT
            keyword, when specified, tells Scripit to abort the script if
            the requested window, etc. could not be found in the specified
            time, otherwise, if the ABORT keyword was not specified, the
            script will just continue.  Example:  SELECT WAIT 500 ABORT
            This means:  Wait for 10 seconds (500/50) and if nothing found
            then abort the script.  The S WAIT command doesn't do anything
            by itself, it only modifies the operation of the other SELECT
            commands (except for SELECT ACTIVE.)
            To turn the wait off, just type 'S WAIT' alone.

Return Codes:
-------------

            All select commands (except SELECT WAIT) will fill in #result
            with 1 for success or 0 for failure.  If #result is true, then
            #result2 will have the actual window's address, and #result3
            will have the actual screen's address.  $window will contain
            the window's title and $screen will contain the screen's title.


Note:       In all SELECT commands, SELECT can be replaced with an 'S'.
-----       e.g.  'S ACTIVE' is the same as 'SELECT ACTIVE'.

----------------------------------------------------------------------------

                               Main Commands
                               =============


The following commands mostly simulate user actions.  (i.e. menus, gadgets,
mousemoves, keyboard keys, etc.)


MENU        menu menuitem <subitem>

            Simulate a menu selection from the selected window's menu.  The
            input is 'menu' 'menuitem' and if needed 'subitem'.  This
            command needs at least the first two to work.  Note 1 explains
            naming conventions.  (If the window has the MENUVERIFY flag set
            Scripit will send a MENUVERIFY msg and wait for a reply to it
            before sending the actual menu select message.)

            Return Codes:

            #result  :  1 for success, 0 for failure.
            $result  :  Menu name
            $result2 :  Item name
            $result3 :  Subitem name (if exists)
            if #result == 0, then:
            #result2 :  0 for menu not found, 10 for menu disabled.


GADGET      gadgetname ID NUM X Y 

            This controls the gadgets of the selected window.  It needs a
            gadgetname (or number) to identify the gadget and, depending
            on the gadget type needs more arguments to modify that
            gadget's contents.  It will send both a GadgetUp and a
            GadgetDown message if the window's flags request that.
            (See Note 3 for more info.)

            Return Codes:
            -------------

            ALL gadget commands (GADGET, GADGETDOWN, GADGETUP & GETGADGET)
            fill in the following return codes:

            $result  : full text name of gadget (if exists)

            #result  : 0 = failure (gadget not found), 1 = bool gadget,
                       2 = prop gadget, 3 = string gadget

            if #result == 1 : (bool gadget)
                   #result2 : 0 = gadget not selected, 1 = gadget selected

            if #result == 2 : (prop gadget)
                   #result2 : prop gadget horizontal position (0-65536)
                   #result3 : prop gadget  vertical  position (0-65536)

            if #result == 3 : (string gadget)
                   $result2 : current contents of string gadget
                   $result3 : contents of string gadget undo buffer

GADGET      boolgadgetname ID NUM X Y

            Triggers a selected bool gadget from the selected window.

GADGET      stringgadgetname ID NUM X Y newstring

            Replaces the string in a string gadget with a new string and
            simulates a 'return' on the gadget.  [opt1] is the new string.
            
GADGET      propgadgetname ID NUM X Y horz,vert

            Changes the position of a proportional gadget.  The input values
            reflect the horizontal and vertical prop position of the gadget.
            (Values allowed: 0-65535)  [horz] is the horizontal position,
            and [vert] is the vertical position.

GADGETDOWN  Does the same job as 'GADGET' except that it will only send
            GadgetDown messages and not GadgetUp messages.
            (For use with Recorder scripts.)

GADGETUP    Does the same job as 'GADGET' except that it will only send
            GadgetUp messages and not GadgetDown messages.
            (For use with Recorder scripts.)

GETGADGET   gadgetname ID NUM
 
            This is identical to the GADGET command, except that it doesn't
            actually trigger or do anything to the gadget.  It will just
            check the gadget's status and fill in the corresponding result
            variables as per the GADGET command's return results.
            
WAIT        <delay>

            Suspends script execution for delay * 1/50th seconds.  Default
            delay time is 25, i.e. 1/2 second.
            
LMB         x,y
 
            Simulate clicking the left mouse button while the pointer
            is at position x,y.
            Related   : SELECTUP    Sends only LMBUp message.
            Commands  : SELECTDOWN  Sends only LMBDown message.

RMB         x,y
 
            Simulate clicking the right mouse button while the pointer
            is at position x,y.
            Related   : MENUUP      Sends only RMBUp message.
            Commands  : MENUDOWN    Sends only RMBDown message.

DOUBLECLICK Simulate a double click.  This can be one of the following:
 
            DOUBLECLICK GADGET boolgadget
            DOUBLECLICK RMB
            DOUBLECLICK LMB

            The delay between the two clicks is controlled by the double-
            click setting in Preferences.

VERBOSE     [ON] or [FULL] or [OFF]

            Turns on debug text printout to the console window.  Default
            mode is off.  VERBOSE ON will turn it on, any keyword other
            than 'ON' will turn it off except VERBOSE FULL which will turn
            on full debug display.

DRAG        x,y,x2,y2,[steps]

            This is intended for use with WorkBench.  It will click on an
            icon at x,y (if it exists) and will keep holding down the button
            while moving the icon to x2,y2 where it will release the button.
            It is the equivalent of:
                (RMBDOWN x,y + MOUSEMOVE x2,y2 + RMBUP x2,y2).
            Steps, if specified, will make the drag into an actual drag by
            inserting interim MOUSEMOVE commands between the RMBDOWN and
            RMBUP.  The number of interim moves is the number of steps
            specified.

MOUSEMOVE   x,y

            Simulates mouse movement to x,y.  (Sends a MOUSEMOVE message.)

DELTAMOVE   x,y

            Simulate mouse movement by x,y. (Sends a DELTAMOVE message.)

RAWKEY      code,qualifier

            Sends a RAWKEY event to the program owning the selected window.
            This command is only intended for script generated by the auto-
            script generator, Recorder.

ITICK       x,y

            Sends an INTUITICKS event to the program.  This is only intended
            for scripts generated by the Recorder.

POINTER     x,y [l] [L] [r] [R]

            Pointer will move the mouse pointer to position x,y on the
            current screen.  This will _really_ move the pointer not just
            simulate it. The qualifier (one of the following l,L,r,R)
            simulates left mouse button down, left mouse button up, right
            mouse button down, right mouse button up.


DRAW        x,y x2,y2 x3,y3 ..... xn,yn

            A specialized command used for drawing on DeluxePaint's screen.

            It simulates the following:
                POINTER x,y l
                POINTER x2,y2 L
                POINTER x2,y2 l
                POINTER x2,y2 L
                ....
                POINTER xn,yn l
                POINTER xn,yn L

WAITFOR     screen window <maxdelay> [ABORT]

            This command is obsolete.  You should use the SELECT WAIT
            command instead.  This was left in here for compatibility
            with older scripts only.

RUN         <program>

            Simply runs another program.  Control returns immediately to the
            script which continues executing.  If you want to include any
            command line switches, then RUN "programname switches.."
            Read note 4.

RUNBACK     <program>

            Simply runs another program.  Control returns immediately to the
            script which continues executing.  The program will not have any
            input or output streams.  Read note 4.

EXECUTE     <program>

            Executes another program.  Script processing will wait until the
            program exits.  You can also use the shorthand version of this
            command:  'X'.  (e.g. X list)  Read note 4.

REQUEST     [requester title] [default dir] [default file] [left edge]
            [top edge] [req width] [req height]

            This brings up the Scripit file requester and allows the user to
            select a file.  The return value of the requester is stored in
            system variable $request.  (see 'System Variables')  The
            arguments provided to REQUEST are not necessary, but they
            override the defaults.  The requester's title is "Please Select
            A File:" unless you supply one.  The default dir and default
            file are whatever was in the File Requester the last time it was
            run.  The left edge, top edge, width and height control the size
            and placement of the requester when it comes up.  (The requester
            itself is totally resizable and moveable by the user.)  If none
            of those was specified, the requester will come up where it was
            the last time it was used.
            NOTE:  The requester will always show up on the selected screen!
            (or on the Workbench screen if none was selected.)   
            Important:  This function is not available in 'Xit' only in
            the 'Scripit' program itself.

ABORT       [ON] or [PAUSE] or [OFF]

            ABORT controls whether the abort and pause/restart facilities
            work or not.  ABORT OFF disables both the abort and the pause/
            restart facilities.  ABORT PAUSE only allows the pause/restart
            but not the abort facility.  And ABORT ON, which is the default
            mode, allows both.

            Abort facility:  You can break out of a script that is currently
            executing by holding down both the left mouse button and the
            control key on the keyboard.

            Pause/restart facility:  You can stop the execution of a script
            at any time by pressing the left mouse button and the left shift
            key at the same time.  To resume the script press the left mouse
            button and then right shift key.  (you can also use the abort
            facility even when a script is paused.)

FORMAT      formatstring arg1 arg2 ... argn

            FORMAT is a text formatting function that does the same function
            that sprintf() does in the C language.  It uses the same format
            as sprintf().  The following is the full explanation of it:
            The formatting result string is stored in $result.

            The format string contains two types of items: normal text
            characters and 'coversion specifications', each of which causes
            the conversion and output of the next successive argument.
            The conversion specification always starts with a % and
            continues with some optional characters, then the conversion
            type characters, which can be any of the following: d, o, x,
            u, c, or s.

            For example:

            $name = "Khalid Aldoseri"
            #age  = 24
            FORMAT "Name : %s    Age : %d" $name #age
            
            After this, $result will contain:            

            "Name : Khalid Aldoseri    Age : 24"


            Conversion Characters:
            ----------------------

            d, o, or x      The integer in the corresponding argument is
                            converted to decimal, octal, or hexadecimal
                            notation, respectively, and output to the
                            result string.

            u               Converts an unsigned integer.

            c               Converts the integer to a single character
                            based on the standard ASCII tables.

            s               The characters in the corresponding argument
                            are output.


            Optional specifications:
            ------------------------

            These come in between the % and the conversion character.

            a.  An optional minus sign (-) which specifies left adjustment of
                the converted integer or string.

            b.  An optional digit string specifying the 'field width' for the
                conversion.  If the resulting string has fewer characters
                than this, enough blank characters are output to make the
                total number of characters output equal the field width.
                If the field width digits have a leading 0, 0 is used as a
                pad character rather than a blank.  The minus sign controls
                whether the blanks are output before or after the string.
            
            For example:
            
            FORMAT "Hex: %08x  Decimal: %8d" 10 10

            Then, $result will contain "Hex: 0000000a  Decimal:       10"
            
PRINTF      formatstring arg1 arg2 ... argn

            PRINTF does exactly the same job as FORMAT, except that it will
            print out the result string to the current console.  The result
            will still be available in $result.  PRINTF also allows for the
            special character codes as listed in the next command.

PRINT       arg1 arg2 ... argn

            Prints out the strings provided to the current console.  The
            is not terminated after each string.  You can also use any of
            the following special codes in the strings:

                \n  Return + Line feed
                \e  Return (no line feed)
                \r  Same as \e
                \t  Tab
                \b  Backspace

            E.g.:   PRINT "Test\n"

            These codes are only translated into actual returns, etc. when
            the string is about to be printed, so if you store such codes in
            a string variable, the code is stored, not the actual ASCII
            character.  These codes are also supported by the PRINTF,
            CON ECHO, and CON TEXT commands.


Note 1:     Argument format for Screen, Window, Menu and Gadget Selection:
-------
            The required item can be selected by specifying:

            a.  The item's name.  This is NOT case-sensitive.  Abbreviations
                are allowed.  (i.e. 'Pro' will match the first item that
                starts with 'Pro' e.g. 'Project'.)
                Leading spaces are ignored.

            b.  The item's number.  This is the sequential number of the
                item in its list.  This must always start with '^' and a
                number. (e.g.  'MENU ^1 ^4 ^3' will select the first menu,
                the fourth menuitem, and the 3rd subitem.)

Note 2:     Arguments can be separated by one or more spaces, tabs, or a
-------     comma.  Any string argument can be surrounded with double-quotes
            to include spaces in its text.  (e.g.  "Text string")  All
            numeric arguments are integer.  (i.e. no fractions allowed)  Any
            argument can be substituted by a string or integer variable.
            (Read section on 'Variables.')

Note 3:     Gadgets are selected by one of the following methods:
-------     
            a.  Gadget Name:
                This is the text that is normally attached to a gadget.  Few
                programs attach text to gadgets.  (Also use Lister for
                gadget names.)
            b.  Gadget ID:
                This is the gadget's ID number.  Most programs have unique
                ID numbers for each gadget.  You can find out a gadget's ID
                by using the 'Lister' program.
            c.  Serial Number:
                This is just a serial number of the gadget.  It is reliable
                in some programs, and unreliable in others.

            Scripit will search for the gadget based on the following logic:

            1.  Search for gadget name, first gadget that matches the name
                will be selected.  If no matching gadget found, or gadget
                name was a null (""), then:
            2.  Search for ID.  If found ID, then gadget found, unless more
                than more gadget with the same ID was found.
            3.  As a last resort, scan for the gadget by its serial number.

            Examples:

            a. Bool Gadget:
  
            GADGET "gadname" 323,6,10,34

            This will search for "gadname" first, then ID 323, then #6.  The
            X (10) and Y (34) settings are fed into the message sent to the
            program because some programs need to know where the pointer is
            when the gadget was clicked on.
 
            b. String Gadget:
  
            GADGET "gadname" 323,6,10,34 "newstring"
                
            c. Prop Gadget:
  
            GADGET "gadname" 323,6,10,34 horz,vert


Note 4:     The EXECUTE, RUN, and RUNBACK commands will interpret any
-------     arguments added after the command and these arguments are
            correctly passed to the command being executed/run.

            For example:

            RUN list df0:

            To give null arguments to a program, just use "".  e.g.:

            X Lister "" workbench

            Of course, any program name or argument that contains spaces or
            commas needs to be in double quotes.

Note 5:     The following commands return #result = 1 if successful, 0 if
-------     failed:  (success is if the message was delivered correctly to
            the program.)

            LMB, RMB, DOUBLECLICK, DRAG, MOUSEMOVE, DELTAMOVE, RAWKEY,
            ITICK, POINTER, DRAW.

----------------------------------------------------------------------------

                        Scripit Graphics Commands
                        =========================


These commands draw directly on the specified window (i.e. into its
RastPort,  if you understand what that means)  The program owning the window
will not know if you changed the contents of the window.
To use those, just SELECT the window you want, and start drawing!

    (Note:  To select DPaint's window, use SELECT MENU PICTURE)


GFX PEN         front_pen,back_pen,drawmode

                This sets the current front pen, back pen, and draw mode.
                The pen number can range from 0 to the number of colors on
                the screen.  The draw mode can be one of the following:
                JAM1 (the background color, 0, does not overwrite what is
                underneath it.)  JAM2 (color 0 clears whatever is underneath
                it.)  COMP (the complement mode reverse the color of the
                original pixel.)  and INVR (which is the same as JAM2, only
                with the front and back pen reversed.)

GFX MOVE        x,y

                Moves the windows 'cursor' to the specified x,y coords.
                This affects where drawing will start.
                
GFX TEXT        "string"

                Prints the specified string in the current font to the
                position selected by MOVE. (using the current front pen,
                back pen, and drawing mode.)

GFX LINE        x1,y1 x2,y2 .... xn,yn

                Draws connected straight lines.

GFX CIRCLE      x,y,radius

                Draws a circle at x,y using the specified radius

GFX ELLIPSE     x,y,x_radius,y_radius

                Draws an ellipse at x,y using the specified x_radius and
                y_radius.

GFX BOX         x,y,x2,y2

                Draws a rectangle.  x,y and x2,y2 are any two opposite
                corners.

GFX RECT        x,y,x2,y2

                Draws a filled-in rectangular.  x,y and x2,y2 are any two
                opposite corners.

GFX CLEAR       x,y

                Clears the current window.  The x,y are optional and select
                the start position for clearing.

GFX CLEARLINE   x,y

                Clear to the end of the current line starting at x,y.

GFX FILL        x,y,fillmode

                Does a flood-fill at the selected x,y using the current
                front pen.  Fillmode can be either 0 or 1.
                (Note:  This is currently not working very well, but I opted
                to keep it in here.)

GFX PIXEL       x,y

                Draws a single pixel at x,y using the current frontpen and
                drawmode.

GFX SAVEMODE    modenumber

                This saves the current settings (front pen, back pen, draw
                mode, and current x,y) to a temporary storage.  The
                modenumber selects the storage slot number.  (from 0 to 3)
                You should always use the GFX SAVEMODE command before
                changing anything in the window, and restore them using the
                next command as soon as possible.

GFX RESTOREMODE modenumber

                Restores the current settings to those stored in the
                selected location.  (0 to 3)


Example:
--------

select window "Workbench"
gfx savemode
gfx move 10,10
gfx pen 1,0,JAM2
gfx text "Some text on the Workbench Window!"
gfx restoremode

This script will select the Workbench window, save its current settings,
move the draw cursor to 10,10, set the front pen to 1, back pen to 0,
and draw mode to JAM2, then type some text there and finally restore the
window's settings to what they were.

----------------------------------------------------------------------------

                        Scripit Console Commands
                        ========================


Scripit can output text to any text console using its console commands.
These allow both output of text and ANSI console control commands.


            These Commands work with a CLI console only:
            --------------------------------------------

CON CLS     Clears all the text in the console and moves the cursor to the
            top left-hand corner.

CON ECHO    [string_1] [string_2] [string_3] ... [string_n] 

            Prints out the specified strings onto the console.  Each string
            is printed on its own line.

            Please refer to the description of the PRINT command for more
            details on print codes.


CON TEXT    [string_1] [string_2] [string_3] ... [string_n]

            Prints out the specified strings onto the console.  The line is
            not terminated after each string.
            Note: To terminate a line use \n code  E.g.
            CON TEXT "test " $test "\n"
            Please refer to the description of the PRINT command for more
            details on print codes.

CON MOVE    x,y

            Moves the cursor to position x,y.  If no x,y were given, the
            cursor will be moved to the top left of the screen.

CON UP      [n]
CON DOWN    [n]
CON LEFT    [n]
CON RIGHT   [n]

            Move the cursor up/down/left/right n times.  (default is 1)

CON SCROLLUP   [n]
CON SCROLLDOWN [n]

            Scroll the console lines up/down n lines.  (default is 1)

CON INSLINE
CON DELLINE

            Insert/Delete a line at the current cursor position.

CON INSCHAR [n]
CON DELCHAR [n]

            Insert/delete [n] chars at the current cursor position.

CON CURSORON
CON CURSOROFF

            Turn cursor display on/off.

CON CLREOL  Erase to end of line.
CON CLREOD  Erase to end of display.

CON STYLE   <style>;<frontpen>;<backpen>

            This sets the style (bold, underline, italic, inverse) of the
            text printed on the console as well as its front and back
            colors.  These match the same parameters used by ANSI for the
            'Select Graphic Rendition' command.

            The following is based on the Amiga RKM manual:

            Any number of parameters can be passed to the CON STYLE
            command in any order.  They are separated by semi-colons.

            These parameters are:

            <style>     0           Plain text
                        1           Bold
                        2           Italic
                        4           Underline
                        7           Inverse-video

            <frontpen>  30 to 37    Selects color 0 to 7 for foreground.

            <backpen>   40 to 47    Selects color 0 to 7 for background.

            For example:  CON STYLE 1;2;33;45
                          This will set the console text to bold + italic
                          with a front pen of 3 and a back pen of 5.
                          (note: spaces are not allowed here.)

            These parameters are cumulative.  If you set bold then later set
            italic, you will get bold/italic.  To make sure that you get
            only bold (or whatever) use a 0; to set plain text first.  e.g.
            CON STYLE 0;1  (clears previous modes, then sets bold.)

CON OPEN    consolespec

            This opens a new console that all the CON commands will use for
            output.  The format for the consolespec is the same as that for
            opening a NewCLI console.  i.e.  "CON:10/15/450/195/Setup".
            Note:  If you open a console _all_ text output by Scripit will
            be sent to that console, including debugging text.
            If Scripit needs to output any text and it was run from
            Workbench and you didn't open a console, then it will
            automatically open a default console for you.

            Results Codes:
            #result will contain 1 if the console was opened, 0 if not.

CON CLOSE   Closes the console opened by CON OPEN.
            (console is automatically closed when Scripit quits.)

CON CSI     <ANSI command>

            This sends an ANSI command to the console.  Scripit will insert
            the CSI (Control Sequence Introducer) before the string and will
            send the command untouched to the console.  These codes can be
            found in the Amiga RKM manuals or in the AmigaDOS manual.


Example:
--------

CON CLS
CON ECHO "This text is at the top of the screen."
CON MOVE 0,0
CON SCROLLDOWN 10

This will clear the console, type the text at the top of the console,
move the cursor back to the top, and scroll all lines down 10 times.


Note:       In all CON commands, CON can be replaced with a 'C'.
-----       e.g.  'C CLS' is the same as 'CON CLS'.

----------------------------------------------------------------------------

                    Controlling Workbench From Scripit
                    ----------------------------------

Scripit can control Workbench using a special set of commands.  To do this,
however, you must have 'XitLoadWB' running.  XitLoadWB comes before LoadWB
in your startup sequence.  It will watch over the loading of Workbench and
install hooks into Workbench that allow Scripit to find out the location
of icons on the Workbench screen.

(Note: XitLoadWB has only been tested with Workbench 1.3, I have no idea
whether it will continue to work as is with 1.4, or if it will need
modification.)


Installing 'XitLoadWB':

1.  Copy the 'XitLoadWB' file to your C: directory.

2.  Add a line 'XitLoadWB' in your s:startup-sequence right before the one
    that says 'LoadWB'.

    For example, this would be part of your startup-sequence:

    ....
    XitLoadWB
    LoadWB
    ....

Now, the next time you reboot, XitLoadWB will load and wait for LoadWB to
load Workbench.  It will then install itself while Workbench is loading
and display a small message confirming that it is loaded and working.

What this program does is to hook itself to Workbench while it is loading,
and becomes an interface between Scripit and WB, receiving commands from
Scripit and telling Workbench what to do.

XitLoadWB will wait a maximum of 60 seconds for WB to load, otherwise it
will complain and abort.

With the Scripit WB commands, you do not need to 'SELECT' the Workbench
window, all WB commands will automatically do that, and will restore
the previously selected window.


The following is a list of the Scripit WB Commands:



            Workbench Commands:  For use with Workbench only
            ------------------------------------------------

WB SELECT       <icon>

                Selects (single-clicks) a Workbench icon.
                (Will automatically deselect any icons previously selected.)

WB OPEN         <icon>

                Opens (double-clicks) a Workbench icon.  This will open a
                drawer's window, or invoke a tool or project.
                (Will automatically deselect any icons previously selected.)

WB CLOSE        <drawer>

                Closes a Workbench drawer.

WB DESELECT     Deselects all icons.

WB SHIFTSELECT  <icon_1> <icon_2> ..... <icon_N>

                Shift-selects a list of icons.

WB SHIFTOPEN    <icon_1> <icon_2> ..... <icon_N>

                Shift-selects a list of icons, and shift-double-clicks on
                the last icon in the list.

WB SNAPSHOT     This will 'Snapshot' the currently selected icons.  Use
                either the 'WB SELECT' command to select the icon, or the
                'WB SHIFTSELECT' command to select multiple icons, then
                issue this command.

WB CLEANUP      This will 'Clean Up' the currently selected drawer.

WB REDRAW       This will 'Redraw' the Workbench screen.

WB INFO         This will bring up the 'Info' window about the select icon.

WB MENU         <menu> <item>

                Simulates selecting the specified menu/menuitem.  e.g.
                WB MENU Disk "Empty Trash" will trigger the Empty Trash
                menu.

WB DRAG         <icon> <move_x> <move_y> <steps>

                Drags the WB icon by the specified x,y coordinates.
                (x & y can be either positive or negative)
                Specifying <steps> will make the drag smoother by showing
                the icon actually moving.  The number of steps is the number
                of times the icon will be display on route.  (I find that
                20 to 30 steps are good for long moves.)

WB DRAGTO       <icon> <destination_x> <destination_y> <steps>

                Drags the WB icon to the specified x,y coordinates.
                (x & y can only be positive.)

WB DRAGOVER     <icon1> <icon2> <steps>

                Drags icon1 and moves it on top of icon2.  This will achieve
                different results based on what icon1 and icon2 are.
                (e.g. copy disk or move icon into drawer)

WB FIND         <icon>

                This will look for the specified icon on the Workbench
                screen and fill in the appropriate result codes as specified
                below.


Result Codes:   All the WB commands will return a result code in #result.
-------------   1 if found icon, 0 if not.  If #result == 1, then #result2
                will contain the X position of the icon, and #result3 will
                contain the Y position.  (these are actually the center
                point of the icon, not its left/top edges.)  $result will
                contain the actual name of the icon.  Note: all those are of
                the last icon selected in any command that uses more than
                one icon.  If #result == 0, then if #result2 == 1, then the
                icon wasn't found, or if #result2 == 10, then XitLoadWB
                couldn't be found (either it wasn't loaded, or it didn't
                work correctly.)

                So, to test for XitLoadWB being loaded, just do a:

                WB DESELECT
                IF #result
                CON ECHO "XitLoadWB is running."
                ENDIF


Note:           No window select command is needed when using the WB
-----           commands.  These automatically operate on the Workbench
                window.  They will not change the currently selected window.

----------------------------------------------------------------------------

                        Scripit Window Commands
                        =======================

The window control commands consist of mostly commands that control the
window's size, placement, activation, etc.  The following is a list of those
commands:


W MOVE      x,y

            Moves the selected window by x (Horz) and y (Vert).  Full limit
            checking is implemented so that a window cannot be moved outside
            the screen it is on.  If the specified x & y are not possible,
            the window will move in the direction requested as much as
            possible.  E.G.  window move -20,10 will move the window 20
            pixels to the left and 10 pixels down.

W MOVETO    x,y

            Moves the selected window to position x (LeftEdge) and y
            (TopEdge) with full limit checking.  If the specified x,y are
            not possible, the window will be placed in as near a position to
            the requested position as possible.

W RESIZE    width,height

            Change the selected window's height and width by +/- the
            specified width and height.  The requested parameters will be
            checked against the actual screen limits as well as the window
            limits set by the program owning that window.  The window will
            be resized as much as possible.  (A SIZEVERIFY and/or a NEWSIZE
            message will be sent if the appropriate flags were set in the
            window's flags.)

W RESIZETO  width,height

            Resize the selected window to a new width and height.  The
            requested width/height will be checked against the actual
            screen limits as well as the window limits set by the program
            owning that window.  The window will be resized as much as
            possible.  (A SIZEVERIFY and/or a NEWSIZE message will be sent
            if the appropriate flags were set in the window's flags.)

W MAXSIZE   Expand the selected window to the maximum size possible.
            I.E. to either the screen limits or the window limits whichever
            is smaller.

W MINSIZE   Shrink the selected window to the minimum size possible.

W FRONT     Move the selected window to the front of all other windows.
            This simulates clicking on the window's 'to front' gadget.

W BACK      Move the selected window to the back of all other windows.
            This simulates clicking on the window's 'to back' gadget.

W CLOSE     Send a message to the program owning the selected window
            requesting that it closes the window.  This actually simulates
            clicking on the window's 'close' gadget.  If the program
            wants to close the window then, it will.  Scripit will not
            attempt to force-close the window.

W REFRESH   Send a REFRESHWINDOW message to the selected window.  This
            tells the program owning the window that it needs refreshing.
            It is up to that program to decide whether it wants to refresh
            it or not.

W REFRESHFRAME

            Manually refreshes the window's title bar and frame gadgets.

W ACTIVATE  Activate the selected window.  This simulates clicking anywhere
            in that window to make it receive all intuition input.
            (If the window requires an ACTIVEWINDOW message, one will be
            sent to it.)

W DEACTIVATE 

            Deactivate the selected window.  (If the window requires an
            INACTIVEWINDOW message, one will be sent to it.)

W LIMITS    min_x min_y max_x max_y

            Change the preset limits for resizing a window to new limits.
            (This might be dangerous if the program owning the window
            depends on the window not being smaller or larger than a
            specific size.)


Note 1:     In all WINDOW commands, WINDOW can be replaced with a 'W'.
-------     e.g.  'WINDOW LIMITS' is the same as 'W LIMITS'.

Note 2:     Always use 'WAIT' to introduce delays between functions that
-------     move, resize, open, close windows to allow enough time for
            Intuition and/or the program to respond to the previous command.
            (e.g.  If you do a MOVETO 0,0 and then a MAXSIZE without a delay
            between the two, Intuition will probably not have moved the
            window yet at the time Scripit is requesting a resize.  This
            will mess up the resize and can have serious effects.)

----------------------------------------------------------------------------

                        Scripit Screen Commands
                        =======================

These control the screen that the selected window belongs to.  You can use
the SELECT SCREEN command to select which screen these commands will act
upon.


SC FRONT    Move the selected screen to the front of all other screens.
            This simulates clicking on the screen's 'to front' gadget.

SC BACK     Move the selected screen to the back of all other screens.
            This simulates clicking on the screen's 'to back' gadget.

SC FLASH    <times> <delay>

            'Flash' the selected screen once.  The optional keyword <Times>
            controls how many times to flash the screen and the keyword
            <Delay> controls the delay between each flash (in 1/50 seconds.)

SC MOVE     x,y

            Moves the selected screen by x,y.  This simulates dragging the
            screen.  (The x drag does not work.  It is included for possible
            enhancements to Intuition in the future that might allow
            horizontal movements of a screen.)  Both x and y can be positive
            or negative.

SC MOVETO   x,y

            Moves the selected screen to x,y.  (read note in above command)
            x and y can only be positive.


Note:       In all SCREEN commands, SCREEN can be replaced with 'SC'.
-----       e.g.  'SCREEN FLASH' is the same as 'SC FLASH'.

----------------------------------------------------------------------------

                        The Scripit ARexx Interface
                        ---------------------------


Scripit can be loaded in 'resident' mode, in which case it will open a port
for ARexx and wait for commands and requests from ARexx.

To load Scripit in Resident mode:

    Scripit -x [portname]

    Where [portname] is the name of the port that Scripit will open.  If no
    portname is specified, 'XIT' will be used.


    After that, Scripit will just sit and wait for commands from ARexx.



    From ARexx:
    -----------
    
    To find Scripit's port:

        address 'XIT'

    To issue a command to Scripit:

    'commandname arg1 arg2 ... argN'

    For Example:

    address 'XIT'
    'select Screen Window'
    'closewindow'

    Or:

    address 'XIT' 'flash'

    Example ARexx Script:

    /* Test ARexx Scripit */

    address XIT
    'verbose off'
    'select wait 500 ABORT'
    'wb open dh2'
    'wb open access'
    'wb open Access!'
    'select Access ^5'
    'menu Phone Re-dial'

    This script will:
    1. Find Scripit's portname.
    2. Make sure that verbose mode is off.  (just in case it was turned
       on earlier by another script.)
    3. Set the select wait delay to 500 (10 seconds) and abort mode on.
       (read the select commands section for details.)
    4. Open the Workbench DH2 icon.
    5. Open the 'Access' drawer from DH2's window.
    6. Load Access!
    7. Wait for all of Access's five windows to come up.
    8. Send a 'Phone' 'Re-dial' command to Access.


    Getting Results from Scripit:
    -----------------------------

    The command sent from ARexx to Scripit can be any valid Scripit command.
    There are also a set of special 'Query' commands that only work with
    ARexx.

    The Query commands return a result string to ARexx from Scripit
    depending on what the Query command was.  You MUST, however, turn on the
    RESULTS option in ARexx before using any Query command, otherwise no
    result will be returned.

    The file 'Test.rexx' has an example rexx script that sets the RESULTS
    option on, loads Scripit, waits for Scripit to load, then sends the some
    query commands to Scripit.


    The following is the list of Query commands:



                    Query Commands:  For use with ARexx only
                    ----------------------------------------

QUERY WINDOW

            Returns the name currently selected window.

QUERY SCREEN

            Returns the name of the screen of the currently selected window.

QUERY WINDATA

            Returns data on the currently selected window in the following
            format:
            [LeftEdge] [TopEdge] [Width] [Height]

QUERY SCREENDATA

            Returns data on the currently selected screen in the following
            format:
            [LeftEdge] [TopEdge] [Width] [Height]

QUERY WINLIMITS

            Returns the window limits of the currently selected window in
            the following format:
            [MinWidth] [MinHeight] [MaxWidth] [MaxHeigth]

QUERY ACTIVEWINDOW

            Returns the name of the currently active window.

QUERY ACTIVESCREEN

            Returns the name of the currently active screen.

QUERY SCREENFLAGS

            Returns a string with the mode of the current screen.

QUERY WINDOWFLAGS

            Returns a string with the mode of the current window.

QUERY TEXTMODE

            Returns the current text mode of the selected window.
            Format: [Left] [Top] [FrontPen] [BackPen] [DrawMode]
            e.g.  10 10 1 0 JAM1

QUERY FONT

            Returns the current font of the selected window.
            Format: [Fontname] [Fontsize]
            e.g. topaz 11

QUERY MODE  <mode>

            Sets the current result returning method to ARexx.  Mode can be
            SHORT, LONG, or BOTH.

QUERY POINTERPOS

            Returns the current position of the pointer in the front screen.
            Format:  [pointer x] [pointer y]

QUERY MOUSEPOS

            Returns the current position of the mouse relative to the
            currently selected window.
            Format:  [mouse x] [mouse y]

QUERY PATH  <filename>

            Returns the full path to the file or directory specified.
            The returned string will contain the full pathname to the file.

QUIT        This will tell Scripit to leave the resident mode, close its
            ARexx port, and quit completely.  Only use this if you really
            want Scripit to unload itself.


Note:       In all QUERY commands, QUERY can be replaced with a question
-----       mark.  e.g.  'Q WINDOW' is the same as 'QUERY WINDOW'.

----------------------------------------------------------------------------

                          COMMAND ARGUMENTS
                          -----------------

The argument(s) to any command of the above can be either a string, an
integer, or a string variable, an integer variable, or even a forumla.

For example:

    con echo "Test"
    con echo 1234
    con echo $test
    con echo #test
    con echo #test/(10+2)

Since these are all fed into Scripit as strings, it has to decide what to do
with the argument based on the following logic:

    1. If the first character of the is a $, then this is a string variable.

    2. If the first character of the is a #, then this either an integer
       variable or an equation starting with an integer variable.

    3. If the first char of the string is neither, then it is a either a
       string or an integer, based on the command that interprets it.

Notes:

- The quotes make no difference when evaluating the argument, they just
  serve to seperate arguments.

- If you wish to use double quote character  as part of the argument string,
  you can use the alternate double quote character: (~).  

    For example:

    PRINT ~This is a "test" of using double quotes (").\n~

    You will get:

    This is a "test" of using double quotes (").


----------------------------------------------------------------------------
                          
                        LOGIC AND FLOW CONTROL
                        ======================

Scripit supports the following logic and flow control commands:

BEGIN:
------

BEGIN is the command that marks the beginning of a script.  This is
essential and MUST be included in every script.  Scripit currently scans for
the BEGIN statement and will start execution of the script at that point.
If it doesn't find the BEGIN statement, it will start execution at the first
line of the script.  However, future versions of Scripit will _not_ execute
any script that doesn't have the BEGIN statement, so make sure you use it
always.


LABEL/GOTO:
-----------

Labels define specific points in a script.  The GOTO command is then used
to continue execution of the script at the requested label.  Example:

    LABEL EndlessLoop
    con echo "aaaa"
    GOTO  EndlessLoop

Label names are not case-sensitive and are significant upto 24 characters.
Double-quotes are only needed for label names when you want to use spaces,
tabs, or commas in the label name.

You can also use the shorthand version of the LABEL command.  Just use the
label name and a colon.  e.g.:

    EndlessLoop:
    con echo "aaaa"
    GOTO  EndlessLoop


GOSUB/RETURN:
-------------

GOSUB and RETURN work exactly as in BASIC.  GOSUB transfers execution to
a subroutine while preserving a return pointer to the next line after
the GOSUB statement.  A RETURN statement picks up the last return pointer
stored on the return 'stack' and continues execution there.  For example:

    IF #a > 100
    CON ECHO "WARNING: Value is too high"
    GOSUB Complain
    END

    Complain:
    CON ECHO "A = " #a
    RETURN

You can nest upto 24 levels of GOSUBS.  Scripit will abort with an error
message if you pass that level.


IF/ELSE/ENDIF:
--------------

IF evaluates a statement and based on whether that statement is true
(non-zero) or false (zero) it will execute other statements.  The format
of the IF construct is like this:

    IF #a >= 10
    do something
    ELSE
    do something else
    ENDIF

    or:

    IF $test
    do something
    ENDIF

The ELSE part of the construct is optional, but the ENDIF statement is
essential.  You can nest IF constructs to as many levels as you like.
Indenting nested IFs is recommended for clarity.  The section 'Mathematical
Expressions' explains IF evaluation more.

Note:  Only a GOTO statement can break out of an IF construct.


WHILE/ENDWHILE:
---------------

The WHILE/ENDWHILE construct allows you to write loops more easily.  The
format of the while loop is:

    WHILE #a <= 10
    #a = #a + 1
    CON ECHO #a
    ENDWHILE

You can nest upto 24 levels of WHILE constructs.  GOTOs do _not_ break out
of the while construct.  For example:

    #a = 1000
    WHILE #a > 10
    IF #a > 100
    GOTO Test
    ENDIF
    CON ECHO #a
    LABEL Test
    #a = #a - 10
    ENDWHILE


END:
----

The END statement simply ends execution of the script.  For Example:

    IF #a > 1000
    CON ECHO "Value too big."
    END
    ENDIF


SCRIPT/SUBSCRIPT:
-----------------

The SCRIPT command allows you to execute another Scripit script from within
a script.  E.G.

    SCRIPT a_script_name

Script execution will stop at the current point in the old script and will
_not_ return.  Scripit will end when the new script ends.  The SUBSCRIPT
command is identical except that control returns to the calling script one
the called script ends.

All variables are preserved and will be shared between scripts!

----------------------------------------------------------------------------

                        Sending Text to a program
                        =========================


Scripit can send text to any program via the 'KEY' command.  This command
will translate the string text argument into a set of raw key events that
are sent to the currently selected window based on a set of rules:

Rule 1:  If the window selected is looking for raw key events, the raw
         keys will be sent its its message port.

Rule 2:  If the window selected is not looking for raw key events, the raw
         keys will be sent to the input device.  This will then be filtered
         by Intuition and sent to the currently active window.  So, you must
         make sure that the selected window is active by using the
         ACTIVATEWINDOW command.

Rule 3:  When translating the string argument, all characters will be
         converted to raw keys, except when a '\' (a backslash) is found.
         The backslash is a command that allows you to specify special keys.


         The following table summarizes the backslash commands:



                           Special "KEY" Format:
                           ---------------------

    \a      Alt Qualifier                   \o      (unused)                         
    \b      Backspace                       \p      Pad Qualifier            
    \c      Control Qualifier               \q      Double-Quote (")                   
    \d      Delete                          \r      Right Qualifier Modifier
    \e      Enter Key (on numeric pad)      \s      Shift Qualifier
    \f      Function Key:  F0 to F9         \t      Tab
    \g      (unused)                        \u      (unused)
    \h      Help                            \v      Mouse Button Qualifier
    \i      Turn on input device mode       \w      Mouse Button Click
    \j      Turn off input device mode      \x      Escape
    \k      (unused)                        \y      (unused)
    \l      Left Qualifier Modifier         \z      End Qualifier.
    \m      Amiga Qualifier                 \\      Backslash
    \n      Return Key                      \###    ASCII code. (000 to 255)
   
   
Notes:
        The \a, \s, \m and \v qualifier commands always default to using the
        left key.  e.g.  \a  will use the Left Alt key.  If you need to send
        a Right Alt key, use the qualifier modifier 'r' i.e. \ra (or \rs,
        \rm)  For the mouse buttons, you _must_ specify the left or right
        modifier: e.g.: \lv is the left mouse button, \rv is the right mouse
        button.  Using \v only will simulate the middle mouse button, which
        is currently supported by the Amiga's system software, but not by
        most programs.  The \w 'mouse button click' need to \z since it is
        considered as a key press itself, unlike the \v.

        All qualifier commands: \a, \s, \m, and \c are cumulative.  i.e.
        \a\s\ch  will send an  Alt-Shift-Control-h sequence.

        If you need to send only qualifier events without any actual keys,
        use the \z (end qualifier) command.  This will terminate the
        qualifier cumulating and send a qualifier rawkey event.  e.g.
        \c\lm\rm\z will send the infamous Control-LeftAmiga-RightAmiga
        sequence!  (This will not actually reboot the machine since the
        reset sequence is built into the keyboard, not the system.)

        If you need to send the rawkeys to the input device, use the \i
        command.  All text following this will be sent to the input device,
        until the string ends, or until the \j command is found.

        Important Note:

        Some programs prefer the 'enter' (\e) to 'return' (\n).  Use as
        appropriate.  If you get a reverse M instead of an actual return
        then you probably need to use the \e instead of \n.  The \e is
        mostly used when simulating entering text into a gadget via the KEY
        command.

Examples:

        KEY "Test.\n"       Sends 'Test.' then a Return.
        KEY "Test,\b.\n"    Sends 'Test,' a backspace, then '.' and Return.
        KEY "\h"            Simulates pressing the Help key.
        KEY "\a\rsk"        Sends a LeftAlt-RightShift-k.
        KEY "\032"          Sends the ASCII character # 32.
        KEY "\qA Quote.\q"  Sends "A Quote." (with the double-quotes.)
        KEY "\e"            Simulates pressing the Escape key.
        KEY "\f2"           Simulates pressing Function Key 2.  (F2)
        KEY "\a\s\f0"       Simulates pressing Alt-Shift-F10.

----------------------------------------------------------------------------

                                VARIABLES
                                ---------


Variables in Scripit are either integer or string variables.

Integer Variables:
------------------

These are all in the format:  #varname
e.g.  #a  #i  #test  #something .. or even #10 or #1010test

These can be used anywhere instead of any argument.  If the argument
for another function is expected to be a string, then the variable is
converted to a string before being passed that function.
e.g.  GFX TEXT #var

Variables names can consist of any combination of letters, numbers or
symbols.  The first character must always be a # sign.  The variable
names are significant upto the first 16 characters.  Variable names
are NOT case-sensitive.  i.e.  #test is the same as #TEST.

You can use any character in the name of variable as long as it is not
one of the following: + - / * = | & ^ % # space

To assign any value to an integer variable just use:

#a = 100

(The command is actually  LET #a = 100)

Integer variables can store numbers in the range of -2,147,483,648 to
+2,147,482,647  (i.e. a signed 32 bit integer).


String Variables:
-----------------

These are the same as integer variables, except they all start with a
$ sign.  e.g. $variable, $Test, etc.

To assign any string to a string variable use:

$a = "TEST STRING"   or even  $a = TEST

$a = $b   works as well.

To concatenate strings use:

$a = $b $c "TEST" $x #i  etc.

NOTE:  String and integer variables of the same name are actually the
same variable!  If you set a string variable then the value of its
contents are stored in the integer variable of the same name.


SHOWVARS:
---------

To view all current variables issue the command SHOWVARS and you will
get a list of the currently active variables.  (non system ones only)

For Example:

SHOWVARS

 Variable Name    Integer  Size       String
---------------  --------  ----  -----------------
a                       0    14  A Test String
ab                      0    20  Another Test String
abc                   100     0
Test                    0     8  Testing
Info                    0    12  Information
avar                  123     0
arg[1]                  0    14  first argument
arg[2]                  0    15  second argument
arg[3]                 10     2  10
arg[4]                 12     2  12
result                  0     0
result2                 0     0
result3                 0     0

SHOWVARS will also list out the user supplied arguments (arg[1] to arg[9])
at the end of this list, and after those, it will list out the contents
of the three integer and string result variables.

Note:  SHOWVARS has a shorthand version:  '?'.  (intended for use with the
interactive mode.)

You can also specify the variables to show using the SHOWVARS command. e.g.:

SHOWVARS abc Test avar


There is no limit on the number of variables in Scripit.  String variables
can store strings of any length.  (upto available memory)  All variables
are allocated memory and freed on the fly.


Arrays:
-------

Arrays in Scripit are a bit different from other languages.  The format for
using them is like C.  e.g.:  #test[10]  where the number between [] is the
element number.  The element number can be any valid math formula.  e.g.
#test[#a/2].

Arrays do not need to be predefined to be used.  They can be of any size.
You can also have negative elements.  (e.g.  #test[-10]).

Array elements are allocated and used as they are referenced, so if you
only used #test[32], #test[100] and #test[-32], only 3 elements will be
used and allocated memory.

Array elements are the same as normal variables in that you can reference
the same element as either a string or an integer.  i.e. #test[100] and
$test[100] are the same variable.  

----------------------------------------------------------------------------

                            SYSTEM VARIABLES
                            ----------------


All 'system variables' are read only variables maintained by Scripit.
They are either string or integer variables and follow the same notation
as normal variables.  (i.e. they start with either a $ sign or a # sign.)
System variables can be used in place of ANY argument to any command.


Strings:
--------

Variables:

$screen       The title of the currently selected screen.

$window       The title of the currently selected window.

$request      The returned string from the file requester.
              (this contains the full pathname of the selected file.)

$reqdir       The directory selected in the file requester.

$reqfile      The file name selected in the file requester.
              (not the full path)

$scriptname   This is the name of the script being executed.

$arg[n]       A user supplied argument that is taken from the CLI command:
              Scripit [options] [scriptname] [arg1] [arg2] ... [arg9]
              This can range from $arg[1] to $arg[9]
              (Note: you can access $arg[n] as an integer by using #arg[n])
              These args are guaranteed to contain either a valid argument
              or a null value, they will never contain garbage.

$time         The current time in the format  HH:MM:SS
              $hour $minute $second  contain the current hours, minutes,
              seconds.

$date         The current date in the format  MM.DD.YYYY
              $year $month $day   contain the current year,month,day.
              Note: $month contains a 3 character string with the name of
              the current month.  e.g. 'Jan'.

$version      The version number of Scripit.  (Current text # is "1.20")

$currentdir   The full pathname of the current directory.

Constants:

$lf           The line feed character.  (i.e. \n)


Integers:
---------

Variables:

#argcount     The number of user supplied arguments.  (can range between 0-9)
#time         The current time in the format  HHMMSS
              #hour #minute #second   contain the current hours, minutes,
              seconds.
#date         The current date in the format  YYYYMMDD
              #year #month #day   contain the current year,month,day.
#version      The version number of Scripit.  (Currently = 120)

The following all apply to the currently selected window and/or screen:

#win.width    The window's width.
#win.height   The window's height.
#win.top      The window's top edge.
#win.left     The window's left edge.
#scr.width    The screen's width.
#scr.height   The screen's height.
#scr.top      The screen's top edge.
#scr.left     The screen's left edge.
#win.pen0     The window's front pen color.
#win.pen1     The window's back pen color.
#win.mx       The x position of the mouse pointer relative to the window.
#win.my       The y position of the mouse pointer relative to the window.
$scr.fontname The name of the current font in the screen.
#scr.fontsize The point size of the current font in the screen.
#win.fontsize The point size of the current font in the window.
#win.x        The x position of the gfx write pointer in the window.
              (This is the one set with GFX MOVE)
#win.y        The y position of the gfx write pointer in the window.
#mousex       The pointer x position relative to the actual monitor.
#mousey       The pointer y position relative to the actual monitor.

The next variables are only for people that know what to do with them:

#win.flags    These are the window flags as per the Window structure.
#scr.flags    These are the screen flags as per the Screen structure.

Note:

System variables are predefined.  However, that doesn't mean that their
names are reserved.  You can use the name of a system variable for your
own variable, but after that you won't be able to access the system variable
anymore.  i.e. user variable names will override system variable names.
This applies to all system variables including $arg[1] to $arg[9].

----------------------------------------------------------------------------

                            Mathematical Expressions
                            ------------------------


Scripit can evaluate complex mathematical expressions that contain any
of the following math operators:

    ^   power

    *   multiply
    /   divide
    %   Modulo

    +   add
    -   subtract

    &   AND
    |   OR

    (   
    )   parentheses


The math expression evaluator is called into action ONLY in two commands:
The IF command and the LET (assign) command.  (next version will support
math expressions with any command.)

Examples:

LET #a = (100+3)/#b

(the LET keyword is not essential.)

IF #a+100 >= (100+3)^2+#b

The operators are evaluated on a priority basis.  The higher priority
operator gets evaluated first.  The above list lists them from the
highest to the lowest priority.  Parentheses change the priority by
assigning higher priority to expressions between parentheses.


The IF command can use any of the following comparison operators:

    >   Greater than
    <   Less than
    >=  Greater than or equals
    <=  Less than or equals
    ==  Equals
    =   Assign  (read below)
    <>  Not equals
        No operator

If no operator is provided then the expression is evaluated, and if
it is not 0 then it is true, otherwise it is false.  E.g.

    IF #a

If the assign '=' operator is used in an IF statement, then the
assignment is carried out and that value is used to determine
true/false.  e.g.

    IF #a = 100/12

    This does the same as:

    #a = 100/12
    IF #a



NOTE:  In both the LET and IF statement, the comparison operator
       MUST be separated by spaces.  All other arguments do not
       need spaces.

----------------------------------------------------------------------------

                         STRING ASSIGNMENT & COMPARISON
                         ------------------------------


    String variable assignment works like this:

    LET $a = "test"
    LET $beta = "test" $a $a $test

    You can only have on argument before the assign operator.  All
    arguments after it are concatenated into one string and stored
    in the string variable specified.


    String comparisons work the same way as integer comparisons.  E.G.

    IF $test

    This will be true is $test is defined and contains something, FALSE
    if not.

    IF $test == "hello"
    IF $test >= "hello"
    etc.

    This is a string comparison that is based on an alphanumeric sort.
    e.g. 'abc' is smaller than 'bbc' etc.  String length is only used
    when the all the letters match. e.g.  'abc' < 'abcd'

    With string comparisons, all arguments before the operator are
    concatenated into one string, and all arguments after it are
    concatenated into another.

    IF "abc" $test "bcd" >= $info $test $new


    Immediate resolve assignment:
    -----------------------------

    The ?= operator is the same as the = operator when using string
    variables except that the ?= operator resolves integer variable names in
    the string immediately.  For example:

    $test = #date
    Using this $test will contain "#date".

    $test ?= #date
    Using this $test will contain the current date "19890926".

    (Note: this only effect assigning integer variables to string variables.
    String variable to string variable assign is always immediately
    resolved.  i.e.  $t = $date  and  $t ?= $date  both result in $t
    containing "1989.09.26")

    Another note:  The ?= operator makes no difference when assigning to
    integer variables since such assignments are always immediately
    resolved.

    (I hope this made some sense to you! :-)

    For example:  The following will open a console window the size of
    the front screen:

        begin
        select active
        $console ?= "CON:0/0/" #scr.width "/" #scr.height "/ConsoleTitle"
        con open $console

    Note: you should always have the integer variable name as a separate
    argument.  This is because Scripit has no way of telling where the
    variable name ends and the rest of the text begins.

----------------------------------------------------------------------------

                                RESULT CODES
                                ------------

Many commands in Scripit return result codes via the system variables
#result, #result2, #result3, $result, $result2, and $result3.  As a rule,
#result will contain a 0 if the command failed, or 1 or above if the command
succeeded.

Each command uses these result codes to return different codes.  You can
find out what these codes are in the description of each command in this
file.

Most commands will set/clear the return results except for the following,
which are guaranteed not to modify the result variables:

IF, ELSE, ENDIF, WHILE, ENDWHILE, GOTO, LABEL, GOSUB, RETURN.

----------------------------------------------------------------------------

                                TIPS & HINTS
                                ------------

You can use the Scripit package (Scripit and Lister, specifically) in order
to remotely control another Amiga via the serial port (or modem)  Just issue
a 'newcli aux:' command on the Amiga to be controlled, and then use a
terminal program on the other Amiga.  Use Lister to find out what screens or
windows (and menus, gadgets) are on the remote Amiga, and use Scripit itself
to drive the programs on the remote Amiga.  If you need more details on how
to do this, leave me a message in Compuserve.

------------------------------------------------------------------------------
Copyright 1989  Khalid Aldoseri.                               7 October 1989.
------------------------------------------------------------------------------
