RISC DISC 1/RISC_DISC_1.iso/pd_share/code/appmaker/!AppMaker/!Help

Text File | 1994-05-25 | 7.9 KB | 166 lines

!Help file for AppMaker, version 0.99     (c) Ian Giblin, ALT-itude
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~     ~~~~~~~~~~~~~~~~~~~~~~~~~

This application will take either a file or a directory and put it in an
Application shell for you, adding sensible !Sprites, !Help, !Run and !Boot
files for you to edit.

You do, of course, have to actually write the body of the !Help file yourself,
and you still need to design a nice sprite, but some of the tedium of
app-making has been removed, and you can easily associate icons with
directories in a fairly straightforward and hopefully 'transparent' way.

For anyone new to this, the 'application shell' is really just a special type
of directory which has an icon sprite associated with it. If you want to look
inside a shell (e.g. to edit the !Sprites file yourself, or to edit your
program) you should hold down SHIFT and double-click the application, then
you can treat the open application shell as a normal directory for copying,
deleting, storing extra files, and so on.

Why bother? (1) You get to add icons to otherwise plain files; (2) You can
set the desktop up as you like in the !Run file before running the main
program, (3) You've got transparent path variable setting for storing your data
files if neccesary, (4) The help file is automatically created for you and you
can set it to auto-edit, then you only have to worry about the content;
To name but a few good reasons!

How To Use
~~~~~~~~~~

Drop any file (e.g. a BASIC program) or a directory onto the icon, then either
click 'OK' or drag the icon to where you want it. Your file will be renamed
to !RunImage (or without the '!' if it was a directory) and moved inside the
shell along with some other files:

   !Name.!Boot      ...initialises and sets up sprites;
   !Name.!Run       ...carries out the 'run' action;
   !Name.!Help      ...tells people about your program;
   !Name.!Sprites   ...defines an icon for the filer;

   (note that 'Name' represents the name of your original program)

The file doesn't have to be a conventional 'runnable' program; it can be a
sprite, a text file, a 'Replay' file, etc., as long as it has a 'run action'
associated with it, i.e. it does something when double-clicked. It can also be
a directory - see the 'Path Variable' section below for extra details.

Note that you cannot move the file or directory between file systems using
this (because a *ReName is used) - i.e. you can't drag from the 'Save As' box
to a RAM disc if your original was on floppy or hard disc. You should move the
file first using a normal drag (copy) or shift-drag (move).

There are some options on the icon bar, as follows:

   Edit !Sprites     ..'Runs' the !Sprites file (loading it into !Paint).
                        Use this sprite to remind you what the program does;
                        Default: ON

   Edit !Help        ..'Runs' the !Help file (loading it into !Edit or your
                        preferred text editor, for you to work on). If you
                        intend to distribute your program, it should have a
                        helpful !Help file;
                        Default: ON

   Protect Files     ...Sets the *ACCESS of the !RunImage, !Run and !Boot
                        files to LR, i.e. locked & read-only. Note this
                        will not apply to the !Sprites or !Help files, which
                        you'll usually need to change.
                        Default: OFF

   Set Directory     ...Adds a line to the !Run file which sets the CSD
                        (Currently Selected Dir.) to the one *containing*
                        your new application, when *run*, unless it was a
                        directory, in which case it will be the dir. itself;
                        Default: OFF

You can save the options as preferred if your file system allows this.

The Path Variable
~~~~~~~~~~~~~~~~~

The program also adds another line to '!Run' and '!Boot' - this one sets a
path (system) variable called 'Name$Path' (where 'Name' is just an
example again) and this allows you to refer to your path as a filer extension,
e.g. in your program you might need a data file which is in the *same*
directory as your new application, then you could specify the file name as
'Name:DataFile'. Note that this path will point to the directory containing
your application (if a normal file was used) or, if a directory was used,
the directory itself (which is now 'inside' the application shell).

A handy example is to create and use a 'scratch' directory. Try the following:

    1. Create a normal (empty) directory called 'Scratch'
    2. Drag it onto 'AppMaker' and click 'OK'
    3. Edit the sprite to look nice (this is optional!)

    4. Open a task window (CTRL-F12)
    5. Type the following commands (but not the bracketed bits):

            *Spool Scratch:StatFile            (...opens a 'spool' file)
            *Status                            (...creates some text)
            *Spool                             (...closes the file)
            *SetType Scratch:StatFile Text     (...filetypes the output)

    6. Close the task window (discard the contents)
    7. Double-click your '!Scratch' folder
    8. Double-click the file 'StatFile'

OK, the text is messy, but that's because we used 'Spool'. Don't worry, as
long as you can see it was the status text which was listed before. What
you've done is demonstrated how to output a file to a 'path', and refer to it
in filer commands. The actual content or type of the file doesn't really
matter; it can be anything you want - a program output file for example.

To continue the above example, you could 'Filer_Boot' your !Scratch folder in
the 'boot' sequence of your computer, then you need never remember where the
folder actually is - you can always refer to it by 'scratch:filename'. This
technique is standard practice for the Acorn !System folder.

If You Change Your Mind
~~~~~~~~~~~~~~~~~~~~~~~

The way to recover your original program or directory is to open the
application shell with a 'SHIFT double click' and then copy the file called
!RunImage (or just 'RunImage' without the '!') as the original file - you'll
have to type in the name yourself. The program itself (or directory) will not
have been changed.

Slight imperfection
~~~~~~~~~~~~~~~~~~~

This program uses the 'System' sprite area, and does a load of '*' commands
to set up the !Sprites file for the new application. This is not very elegant,
but gets the job done (I might put better sprite code into a later release).

The bad side is that it tries to set the sprite area to 32k before running,
and also does a *SNew (killing any sprites in this area). If this is a
problem, or if you always have some space there, you can change the lines
in the !Run file *IN YOUR PRIVATE COPY ONLY*.

Credits, feedback, etc
~~~~~~~~~~~~~~~~~~~~~~

I expect this has been done before, but maybe not in a FreeWare program, and
maybe not *exactly* the way I would have liked it...! I hope you find this
program useful. Please report any bugs or suggestions to me, via e-mail or
'normal' mail.

Ian Giblin

c/o Space Science Centre, MAPS, University of Sussex, Brighton BN1 9QH.

+---------------------------------------------------------------------------+

  This software is FREEWARE. It may be freely distributed so long as no
  money is exchanged, except to cover costs of distribution, i.e. post &
  packing or the cost of the disk and ALL the files are included in the
  distributed version.

+---------------------------------------------------------------------------+
|             AppMaker is and will remain © ALT-itude 1994                  |
+---------------------------------------------------------------------------+
|    ALT-itude is...   Ian Giblin,      e-mail:  [e-mail]      |
|                      Paddy Spencer,   e-mail:  [e-mail]        |
+---------------------------------------------------------------------------+