                             Let 'em Fly!
                             ------------

                     (Flying Dials and more ...)

                             Version 1.30

                            15th July 1995

                     (c) 1991-93 by Oliver Scheel
                        Freaky Deaky Software

                     (c) 1994-95 by Darryl Piper

                           (it's Freeware)


1 Introduction
==============

Well,  actually I only wanted to see how fast the Atari ST's VDI could 
be, though it led on to rather more ...

With `Let 'em Fly!' in your AUTO-Folder, many normal GEM dialogs learn 
to fly like Julian Reschke's FlyDials (e.g.  in `Gemini'),  or in  the 
`Rufus' terminal program.  Furthermore these dialogs can be handled by 
using the keyboard shortcuts `Let 'em Fly!' offers,  so that there  is 
no  need to keep swapping between keyboard and mouse.  There are  many 
more features! The most important:

- Flying dials
    As already described,  many GEM dialogs learn to fly.  This  means 
    you  can drag them around by using the mouse.  This requires  that 
    programs  use the correct AES calls to handle dialogs.  The  alert 
    boxes too can now fly.

    Thanks to clever procedures the boxes can be moved with  tolerable 
    speed  even  without  a blitter,  and their  appearance  has  been 
    optimised.  Furthermore  memory usage has been optimised  for  the 
    whole  process,  i.e.  even when little memory is available it  is 
    possible in some cases to move the boxes around.

    Furthermore `Let 'em Fly!' memorises the position of dialog  boxes 
    inside a given program,  which means that after a box is moved  it 
    will appear in the new position the next time it is called.

    Virtual screens such as `BigScreen 2.0' are also  supported,  with 
    the  dialog  boxes  appearing centred  in  the  currently  visible 
    portion of the screen.

- Key dials
    Many dialogs can be operated by using keyboard shortcuts. `Let 'em 
    Fly!' scans the dialog for suitable keys.  For example, the button 
    `Cancel' may be activated by pressing [UNDO] and/or [ALT]+[C].

- New edit functions within editable fields
    If  a  dialog  contains  editable  input  fields  then  additional 
    editing  functions  become  available.   This  includes  Clipboard 
    support, a `history' of the last 20 inputs and a special character 
    box  to enter `ugly' characters.  Some of the edit  functions  can 
    also  operate  in programs using their own routines  for  handling 
    dialogs.

- New alert boxes with new icons
    The  appearance of the alert boxes have also been  re-implemented. 
    They are now only as large as they have to be, so look more `right 
    sized'. They also allow the loading of new icons.

- Grow and shrink boxes can be switched off
    To speed up screen re-draws,  `Let 'em Fly!' allows you to  switch 
    off the grow and shrink boxes.

- No pilot's licence needed
    You've  guessed it!  For using `Let 'em Fly!' you don't  need  any 
    flying lessons.  But you should gave basic experience in using the 
    mouse.


`Let  'em Fly!' works on all Atari ST/STe/TT/Falcon computers  in  all 
resolutions, including TruColor. MultiTOS is supported also.

`Let 'em Fly!' comes with no warranty. This means that the author will 
not  be liable for any damage which may caused by using or  not  using 
`Let 'em Fly!'.

`Let  'em  Fly!' is Freeware.  This means that this  programm  may  be 
freely  used and distributed for non commercial use.  All  rights  are 
reserved by the author!  Nearly all software and hardware titles  used 
in  these instructions are registered trademarks and are to be  viewed 
as such.


The `Let 'em Fly!' distribution package (English version):

     - LETEMFLY.PRG           The program itself
     - LET_CONF.CPX           The configuration CPX module

     - GEM1ICON.RSC           The original Atari icons for alert boxes
     - GEM2ICON.RSC           Icons from GEM/2 for the alert boxes

     - LETEMFLY.TXT           This manual

`Let 'em Fly!' may only be distributed complete with these files.

I  do  not expect that everyone will understand  everything  in  these 
instructions,  which is not really necessary for normal use.  This  is 
due to the fact that the program digs deeply into the operating system 
and to understand everything one has to know that inside out.


2 Installation
==============

It's very easy to install `Let 'em Fly!'. The LETEMFLY.PRG program can 
be  run from the desktop or copied into your AUTO-folder on  the  boot 
drive to load automatically when the computer is restarted.   You  can 
install the CPX file into your CPX folder,  this  will  allow  you  to
configure `Let 'em Fly!' as you wish.


3 Usage
=======

Not all dialog boxes are supported by `Let 'em Fly!' since some people 
have programmed their own dialog-handling routines.  In these `Let 'em 
Fly!'  can do nothing,  or only make some of its  features  available. 
`Let  'em  Fly!' requires that programs use the correct AES  calls  to 
handle dialogs.

Nor  are  dialogs on the desktop supported,  since  TOS  accesses  its 
routines directly here. That may change with MultiTOS.

If  at times something doesn't appear to be working,  then  I  suggest 
that you first check the settings with the configuration program  (see 
below).

Now, off we go ...


3.1 Flying Dials
----------------

Within  a GEM dialog there are selectable and non-selectable  objects. 
If  you  left-click  on  a non-selectable  object  and  keep  the  key 
depressed,  the mouse arrow changes into a flat hand and you can  drag 
the dialog around by moving the mouse. Depending on how `Let 'em Fly!' 
has  been configured (see below) one can move the dialog box  in  real 
time,  or  only as a frame (like normal windows are moved).  By  first 
pressing  and holding down one of the [SHIFT]-keys or the right  mouse 
button,  you  can make the dialog box disappear to leave just a  ghost 
outline,  i.e.  the dialog gets transparent and you can look `through' 
it  should some important information be hidden behind it.  The  ghost 
frame  can naturally also be moved.  On releasing the left button  the 
dialog will reappear on the screen. One can also reverse the operation 
of the right mouse button with the configuration program.

Note:  It may be that other programs that explicitly support `Let  'em 
Fly!' are only able to `fly' by using a special object (the Selectric 
file selector,  for instance,  supports `Let 'em Fly!' and in that one 
can  move  dialog  boxes  via an `asses ear' at  the  top  right  hand 
corner). But one can suppress the exclusitivity of the `flight object' 
by  additionally pressing the right mouse button,  i.e.  one can  then 
also use other objects for flying the dialog.

If  a  box can be moved normally but cannot be made  transparent  then 
there is not enough memory available to save the complete dialog  box. 
The first mode divides the flight path into a corresponding number  of 
individual  steps  when there is a memory shortage and  then  executes 
them, so offering more possibilities to complete the task.

If one clicks outside the dialog then normally this would only make  a 
`pling'  (sound  the  bell) but with `Let 'em Fly!'  the  dialog  also 
`flies'  to the mouse position.  This function is particularly  useful 
with large screens. In addition, a double-click on the `flight object' 
centres the dialog on the screen.

Furthermore  `Let 'em Fly!' remembers the last position of the  dialog 
boxes within a program, which means that if one moves the dialogs they 
will be displayed at their new position the next time they are called. 
By  pressing [ALT]+[CTRL] when calling (!) the dialog the box will  be 
correctly re-centred.  This function will also operate with  `foreign' 
flight routines.

It  is also possible to make dialog boxes appear at the current  mouse 
position.

With virtual screens such as `BigScreen 2.0' installed dialogs can  be 
centred  in  the currently visible portion.  Thus  one  saves  oneself 
having to hunt for the dialog. Alert boxes will always be displayed in 
the visible portion, irrespective of the settings in the configuration 
menu.  After  all  alert  boxes are there  to  impart  some  important 
information  to  the user and he should not have to  search  for  them 
first.

Summary:

    - Not  all dialog boxes can fly!  There must a) be  enough  memory 
      available  and  b) the corresponding operating  system  function 
      has to be called by the program.

    - Sometimes  it is possible to move the dialog box but it  can  no 
      longer  be made transparent.  In that case there is  not  enough 
      memory available for the buffering of the complete box.

    - Furthermore,  some programs that have not been designed to  make 
      their  dialog boxes fly can exhibit somewhat erratic  behaviour. 
      But  this only applies to the screen display and is more  of  an 
      irritation.  Normally  there  is  no  resultant  loss  of  data. 
      However I cannot guarantee this!


3.2 Key Dials
-------------
Many  dialogs  can be serviced directly from  the  keyboard.  One  can 
recognise when this is the case since `Let 'em Fly!' scans the current 
dialog  for  possible keyboard shortcuts and marks them by  drawing  a 
line  under  the corresponding letters or numbers in the  text  in  or 
beside  the buttons (with a colour screen another type of  display  is 
also available).  You can activate the button by holding the [ALT]-key 
and  pressing  the letter (or number).  This corresponds to  a  single 
mouse click on the object. Furthermore, a mouse click on an underlined 
text  outside  the  actual  button  will  act  like  a  click  on  the 
corresponding object.

If  there is no editable field you don't need to press  the  [ALT]-key 
(for instance in alert boxes).

When possible the functions keys [UNDO] and [HELP] are supported. 
`Let 'em Fly!' scans the following strings to define these F-keys:

[UNDO]:  `abbruch',  `abbrechen', `verlassen', `ende', `nein', `quit', 
         `cancel', `abort', `no', `exit'

[HELP]:  `help', `hilfe'

As  in  the whole of `Let 'em Fly!',  no distinction is  made  between 
capital and lower case letters. Pressing one of the F-keys selects the 
relevant object (carries out the action).

In total 38 keys [A-Z, 0-9, HELP, UNDO] are usable. The default object 
(button  with  a thick outline and selected by pressing  [RETURN])  as 
well  as  the UNDO object can (virtually) always be selected  via  the 
first letter of the corresponding object,  (e.g.  `OK' via  [ALT]+[O], 
`Cancel'  via [ALT]+[C] etc).  Furthermore one can shift  the  default 
button  around  (i.e.  change which one is the  default)  by  pressing 
[ALT]+[Tab]  or [ALT]+[SHIFT]+[Tab] (backwards),  which means that  in 
many cases one can `operate' a dialog just with this facility and  the 
[RETURN]-key.  If  there is no edit field in the dialog then  one  can 
also omit the [ALT].

[SHIFT]+[HELP] displays a copyright information, including the current 
version number.


3.3 Extended Editor
-------------------

If  editable  fields are present in a dialog box then `Let  'em  Fly!' 
makes additional edit functions available.

Besides the GEM functions built into the operating system:
[Cursor Up]         One field back
[Cursor Down]       One field forward
[Cursor Left]       One character left
[Cursor Right]      One character right
[TAB]               One field forward
[RETURN]            Terminate (apply) the dialog

... `Let 'em Fly!' gives you many many more functions ...

[RETURN]            If there is no default button,  the cursor   jumps 
                    to the next editable field
[SHIFT]+[RETURN]    Jumps to the next editable field, even if there is 
                    a default button
[SHIFT]+[TAB]       One field back
[SHIFT]+[Csr Left]  Jumps to the beginning of the field
[SHIFT]+[Csr Right] Jumps to the end of the field
[CTRL]+[Csr Left]   Jumps one word left
[CTRL]+[Csr Right]  Jumps one word right
[ClrHome]           Jumps to the first editable field
[SHIFT]+[ClrHome]   Jumps to the last editable field
[CTRL]+[Delete]     Deletes all charaters to right of the cursor

Furthermore  the  keys [Csr Up] and [Csr Down] include a  turn  around 
feature.  This means that if you are within the first field and  press 
[Csr Up] the cursor jumps to the last field,  and the other way around 
for [Csr Down].

Furthermore direct cursor positioning with the mouse inside(!) an edit 
field  is  supported.  When an edit field is  selected  the  operating 
system normally sets the cursor to the end of any string  present.  If 
direct  positioning  is possible the normal mouse cursor in  the  edit 
field changes to a text cursor, allowing this to be placed anywhere in 
a text string with the mouse.


All legal filename and path characters
--------------------------------------

...  can  now  be input in the editable fields  meant  for  this.  TOS 
behaves  VERY peculiarly in this respect:  On the one hand  it  simply 
will not permit several legal characters (e.g.  `$', `-') to be input, 
on the other one can input some of the `worst' signs (`',  `'  ...). 
`Let 'em Fly!' fixes this bug.


Special characters
------------------

In some cases one needs to input some characters which are not  easily 
(or at all) available from the keyboard. If you press [SHIFT]+[Insert] 
within  an editable field a character box appears where you can  click 
on  the character you want.  This function is only available when  the 
editable field template allows all characters to be used.


GEM-Clipboard
-------------

In  the  editable fields `Let 'em Fly!'  supports  the  GEM-Clipboard, 
which means that one can,  for instance,  cut out some text in another 
program and later insert it in the dialog.  In order to be able to use 
the Clipboard it has to be defined first,  i.e.  the operating  system 
has to know where the data are to be stored.  For this the environment 
variable  `CLIPBRD'  or `SCRAPDIR' must be set correctly.  If  one  is 
using  the  `Gemini'  replacement desktop this is done  more  or  less 
automatically.  Otherwise one can set this variable with special  DA's 
(such as `SETCLIPB.CPX') or programs (e.g.  with `JCNBOOT' by Jens  C. 
Neffe). The extra line needed is of the type:

CLIPBRD=Path
                     (Example: CLIPBRD=C:\CLIPBRD)

The following Clipboard functions are supported within editable fields:

[CTRL]-[X]     Cuts the current line to the Clipboard (i.e.  copies it 
               there  and  deletes  the  field).   If  you  press  the 
               [SHIFT]-key,  also,   the  contents  of  the  Clipboard 
               will  be  retained  and  the  line  will  be  appended, 
               preceded  by  a  line feed,  so  that  individual  text 
               portions in the Clipboard are separated by line feeds.
[CTRL]-[C]     Copies the current line into the Clipboard but  doesn't 
               delete  the  field.   The  [SHIFT]-key  will  react  as 
               described above.
[CTRL]-[V]      Inserts  the  first line of  the  Clipboard  into  the 
               current field.  The previous contents of the field will 
               be deleted,  but you can suppress this by pressing  the 
               [SHIFT]-key.


History (will teach us nothing...?)
-----------------------------------

Often  one  has to input strings that one had  already  input  earlier 
(like  in  a  command-line shell) and to save typing  `Let  'em  Fly!' 
supports  a  small  so-called  `History' (20 entries  with  up  to  40 
characters  for  each) of the strings you  typed  before.   Duplicated  
entries   are  suppressed  automatically  (for  our   `Gemini'-freaks: 
`nohistdouble = TRUE').

Pressing:
[CTRL]+[Csr Up/Down]  Scans the History to get back the previous typed 
                      strings.
[SHIFT]+[Csr Up/Down] Uses  the contents of the current field  as  the 
                      (beginning of a) search string so that `Let  'em 
                      Fly!'  will  only display inputs  starting  with 
                      this string.

People  who  haven't used a History before and  don't  understand  the 
above   should  make  their own experiments by  `playing'  with  these 
functions.  The History functions generally like that in the  `Mupfel' 
command-line shell (part of `Gemini').

Many  of the additional editing functions (except the  mouse  support) 
can  also be used in dialogs of other (`foreign') routines.  Here  the 
motto is:  Try it!   Incidentally, the `MagicDials' by Peter Hellinger 
are supported optimally by `Let 'em Fly!'.


3.4 New Alert Boxes
-------------------

Using `Let 'em Fly!' the alert boxes will look a little bit  different 
to the originals.  The size of the box is `best-fitted' to the  amount 
of text present and, apart from the method described above, any of the 
three   buttons   can  be  activated  also   by   pressing   [F1]-[F3] 
respectively,  making recourse to the mouse unnecessary. Equally there 
is no need to use the [ALT]-key for the keyboard shortcuts.  There are 
also  new icons that can be loaded at program start-up.  For this  the 
corresponding file must be called `LET_ICON.RSC' and be placed in  the 
same  directory  as  the program.  The construction  of  the  file  is 
described in `Programmer's Guide' (that used to be available from  the 
author,  but  following  his retirement from the  computer  scene  the  
current position is uncertain).

You  can  use  different icons,  which are included  on  the  disk  as 
`LTMFICON.RSC'  and `GEM1/2ICON.RSC' files,  by renaming  the  desired 
file  to  `LET_ICON.RSC' and copying it into the  AUTO  folder.  These 
resource  files can also be edited with an RCS (Resource  Construction 
Set) to change their colour or shape.

The  error boxes produced by TOS have also been replaced in  `Let  'em 
Fly!'  One can differentiate between two types here:  Critical  errors 
(e.g.  `The  data on disk X are damaged') and error messages from  the 
application (e.g. `Insufficient memory').

The  first variant is supported by `Let 'em Fly!' only  under  `Mag!x' 
(the   multi-tasking  AES  by  BELA)  since  this   fulfills   certain 
preconditions (re-entrance of the AES and the desktop is a stand-alone 
application).

Presumably  MultiTOS will also fulfill these preconditions and so  one 
can assume that these boxes will be available for modification.

The  event-critical  boxes differ from the TOS original in  two  ways: 
Firstly they have been furnished with meaningful icons,  and  secondly 
an `Ignore' button has been added,  which means that the error will be 
simply  ignored.   This  button  should,  however,  only  be  used  in 
emergencies, since some applications could produce peculiar errors.

The  second  variety runs under all conditions and  differs  from  the 
original  in  reporting  a more precise error  message  alongside  the 
number.


3.5 Have a nice time with Niceline
----------------------------------

Originally  `Niceline' was a stand-alone program,  which has now  been 
integrated into `Let 'em Fly!'  Have you looked at the dividing  lines 
in  the  `Gemini' drop-down menu entries?  It will be seen  that  this 
replaces  the  `---' (minus character) and  `==='  (equals  character) 
strings by  `nice lines'.  Unfortunately up to now that only  happened 
in `Gemini'. With Niceline this also applies to other menus.

But I must add,  that this is a small hack and doesn't work  correctly 
with all programs (e.g. GFA Basic). Hence Niceline has been configured 
so  that it is automatically de-activated with certain menu  patterns. 
Unfortunately some other programs have a similar pattern,  which  will 
not  allow installation of the nice lines.  If there are any  problems 
concerning menus, turn this feature off and try again.


4 The Configuration Program
===========================

There are two programs to configure `Let 'em Fly!':  A normal  program 
(LET_CONF.PRG,  which  can be run from the desktop or installed  as  a 
desk accessory by renaming the extension to `.ACC'), and a CPX for the 
extendable control panel.  When you call the program/CPX, you will get 
a small dialog box on the screen.

The  first line contains the `Let 'em Fly!' version that the user  has 
currently installed, and (for some early versions) whether this is the 
cut-down `Light' version. The second line contains the author's name.

In  the middle is a rectangular box containing a (scrollable) list  of 
configuration switches. Since this has grown to a large number, all of 
which  may  be  needed,  one can use the slider at the  right  to  run 
through  the list.  As the experienced `Let 'em Fly!' user  will  have 
noticed  there have been some changes in this program from  V1.12.  At 
first  sight the appearance may be rather obscure,  but  the  switches 
have  been sorted following new criteria:  Now the important  switches 
are on the first and second pages, with the rest following. That makes 
for faster operation.

If  one  uses  the PRG/ACC then one can use this  box  also  from  the 
keyboard,  pressing  the  underlined  letter to  change  the  relevant 
switch.  One  can also operate the Slider with [CsrUp] and  [CsrDown];  
by  also  pressing [SHIFT] one moves in page rather than  line  steps. 

Unfortunately,  for technical programming reasons,  keyboard operation  
is not possible with the CPX module.

Now to the switches and controllers:  The switches represent so-called 
Pop-Up  menus,  i.e.  a  click  on the switch field  produces  a  tiny 
selection  box in which one can either slide down to  the  alternative 
field  with  the button pressed,  or click on it again to  select  it. 
Alternatively you can toggle the selection by clicking on the  text(!) 
label for the relevant field.

- `Let 'em Fly!'    This  allows  you to  switch off  `Let  'em  Fly!' 
                    completely(!). The remaining settings then have no 
                    effect.

- Key Dials         Must be on  if you want to use keyboard  shortcuts 
                    within dialogs.

- Extended Editor   Enables  the new  edit functions  within  editable 
                    fields.

- Alert-Boxes       Here the new alert and error boxes can be switched 
                    on/off.

- Flying Dials      This switch activates the flight routines.

- Fly Type          There are two different types of flights:
                    Solid:  Boxes will be  moved  completely  in  real 
                            time,  i.e. they follow mouse movements. I 
                            recommend  use of a blitter or  a  graphic 
                            accelerator like NVDI or WARP9,  otherwise 
                            operation is somewhat slow.
                    Hollow: A  dragbox  will  be  used (as for  moving 
                            windows on the desktop).

- Ghost Flights     Normally,  the dialog  can be made transparent  by 
                    holding  the right mouse button at the start of  a 
                    flight.  This  switch  allows you to  invert  this 
                    feature.

- Dials to Mouse    Dialogs  will  not  appear at  the  screen  centre 
                    but at the current mouse position.

- Jumpin' Dials     Those who do not want  the dialogs  to fly  to the 
                    mouse position when you click outside a dialog, or 
                    re-centre  it  by a double-click in  the  dialog's 
                    `asses  ear',  can switch this function off  here. 
                    (Naturally it can be switched back on again).

- Save Position     This switch decides whether  `Let 'em Fly!'  is to 
                    remember the last position of the dialogs.

- Send Redraw       Some  programs  have problems  with  flying  dials 
                    after  the  dialog  box  is   closed,   i.e.   the 
                    background  will  not be restored  properly  (e.g. 
                    TC-Fileselector,  Adimens).  If  this function  is 
                    switched  on  then the currently  running  program 
                    will  be informed that after removing  the  dialog 
                    box the corresponding part of the screen is to  be 
                    re-drawn.

- VSCR-Support      The mega-gigantic abbreviation  `VSCR'  stands for 
                    Virtual SCReen  (used in cases where  the  visible 
                    part  of  the screen is not  the  complete  screen 
                    area - also comparable to the windows  technique); 
                    it  describes  a  process  that  can  tell   other 
                    programs which portion of the screen is  currently 
                    visible.  If this button is switched on then  this 
                    process  will  be supported.  An  absent  VSCR  is 
                    recognised automatically by `Let 'em Fly!'.
                    Some virtual screen drivers (like `BigScreen  2.0' 
                    by  Julian Reschke) use a cookie to  indicate  the 
                    coordinates  of  currently  visible  part  of  the 
                    complete (virtual) screen. `Let 'em Fly!' utilizes 
                    this  cookie when centering the dialogs,  so  that 
                    they  will appear within the visible part  of  the 
                    screen.  Alert  boxes,  however,  will  always  be 
                    displayed in the visible portion,  irrespective of 
                    the setting of this switch.

- Form Grow/Shrink  Switches the drawing  of (dialog-) grow and shrink 
                    boxes  on/off.  When off,  screen redraws will  be 
                    considerably speeded up,  though one loses some of 
                    the   intuitive  sensitivity.   Incidentally   the 
                    `KAOS-TOS' advertises this feature.
 
- Graf Grow/Shrink  Switches  on/off  the other  grow and shrink boxes 
                    (e.g.  windows,  or when a program is started from 
                    `Gemini').

- Niceline          Configures  the  Nicelines  (see   above).    Some 
                    programs  may  have  problems  (e.g.   GFA   Basic 
                    programs).
 
- Fly Delay         This allows one  to set the time between the click 
                    and  the  flight so that one can  reach  into  the 
                    buttons   without  the  dialog  starting  to   fly 
                    beforehand. `0' represents no delay.

- Shortcut Disp.    You've got the choice between  keyboard  shortcuts 
                    being   signalled  by  underscores   or   coloured 
                    characters.  Naturally this is only of interest in 
                    one of the colour resolutions;  in monochrome mode 
                    this switch has no effect and the underscore  will 
                    be used.

- Shortcut Col.     You want to have pink underscores?  No problem ... 
                    This  controller assigns a colour to the  keyboard 
                    shortcut;  in medium resolution, for instance, red 
                    is  easier  to see.  If the controller is  at  far 
                    left,  then  shortcuts  will be  assigned  but  no 
                    underscores will be drawn.

- Alert-Icon        Here one can assign a colour  to the icons  in the 
                    alert boxes (in colour resolution only of course).

- Alert-Border      Configures the thickness (not the sickness :-)) of 
                    the alert borders (even no border).


At the lower edge of the main box there are four buttons:

- Info      Shows a small information page

- Save      Makes  the  settings permanently resident  in  the  actual 
            program.  A  file selection box follows which  allows  the 
            path to be set;  it expects LETEMFLY.PRG (in some  earlier 
            versions  one  could also  choose  LET_LGHT.PRG,  but  the 
            cut-down `Light' version is no longer used).

- OK        The settings will be adopted but not saved,  i.e.  if  the 
            computer  is  rebooted  the settings  will  be  lost.  The 
            Closer at top left has the same effect.

- Cancel    All changes made will be cancelled  and the  configuration 
            program will be quit.


In  the  line above the main selection box,  the `Config  CPX'  button 
opens  up a sub-dialog allowing you to configure the CPX  itself.  You 
can  fade out rarely used switches to keep a  clearer  overview,  then 
click on `Save' to store these settings.  Back in the main dialog  you 
can swap between this `Selection' or `All' of the switches.


5 Well known problems with other programs
=========================================

- The  `Universal Item Selector (UIS III)' must be started after  `Let 
  'em   Fly!' within the AUTO folder,  since otherwise it will be  de-
  installed again. This may apply to all programs not using the   XBRA 
  protocol.

- The  `Little Green Selector' doesn't work well with `Let 'em  Fly!',   
  getting  a bit confused with the keyboard shortcuts and also  having    
  some  flight problems.  These problems must be searched for in  LGS!   
  For  some  (unexplained)  reason  LGS hooks  into  the  ikbdsys  and   
  apparently  `scrambles' the AES keycodes thoroughly,  so  that  only   
  LGS can do anything with them (how nice...).  Why does the LGS  only   
  use  XBRA in the GEMDOS-trap and nowhere else?   I don't  know  what   
  your friendly Atari dealer recommends,  but I recommend `Selectric'   
  as a file selector.

- Since  `MagicDials' by Peter Hellinger does not handle  user-defined   
  objects and buttons `conventionally', incorrect screen re-draws will   
  result  from  the use of [ALT]+[TAB] key combinations (and  also  by   
  reversal with [SHIFT]). However, the program will not crash.

- With  'MiNT'  versions  0.91 and lower `Let 'em  Fly!'  can  not  be 
  installed.   Other programs also have this problem.

- If  you  confirm a dialog in `NEODESK'  by  pressing  [RETURN],  the 
  dialog    won't vanish.  Remedy:  Use the desktop from TOS  2.06  or 
  `Gemini'.



6 Some internals
================

`Let  'em  Fly!' latches into the AES TRAP #2 (AES/VDI) and  TRAP  #13 
(BIOS)  and uses the XBRA-ID `LTMF'.   `Let 'em Fly!' also installs  a 
cookie  with  the same ID.  In some cases (see above)  the  etv_critic 
vector will also be bent.


7 Known bugs
============

If a dialog box is made transparent and memory is short,  then it  may 
happen that the box cannot be moved again at a further attempt.  Well, 
it  appears that GEMDOS is not always able to free a block of  size  X 
and later re-allocate a block with the same X.  Even `POOLFIX' doesn't 
correct matters.


8 Afterword
===========

As noted at the beginning,  I only wanted to see how fast the ST's VDI 
could be, and somehow this program resulted ...

The  flying routines were actually only intended for my own  programs, 
but  in `ST-Computer' magazine for June 1991 Robert  Tolksdorf  showed 
that  in  principle  one  can also  install  something  like  this  as 
resident; the two programs have nothing in common, except that we both 
made use of the form_do() sources by D.R.

The  rest  arose  only from need.  Dan Wilga  wrote  a  program  named 
`FormDoIt' which permits operating the dialogs from the  keyboard too,
and  also offers some editing functions.  Unfortunately his  form_do() 
routine  is not 100% compatible with the original and there were  some 
problems,  particularly  with TOUCHEXIT objects.  Furthermore he  uses 
Line-A  routines for graphic output,  which should no longer  be  used 
nowadays.  `FormDoIt' is connected with `Let 'em Fly!' only in so  far 
as  I  have implemented many functions and the principle in  `Let  'em 
Fly!',  but  my  program goes much further since  a) it  doesn't  just 
replace form_do(),  b) doesn't use Line-A routines and  c) is far more 
intelligent.

What should still be said is that so-called `rogue programs' are  only 
partly supported.  By `rogue programs' I mean,  among others, programs 
that do not keep to the rules of the AES. For example `UnLZH' does not 
recognise  appl_init/exit,  ALTHOUGH it uses AES  routines.  The  same 
applies to `PFX-PAK'.  Furthermore there are still programs about that 
do  not use an XBRA.  That applies particularly to programs  from  the 
USA.

XBRA has in the meantime been raised to a standard by Atari and should 
therefore be used by EVERY program that bends vectors. Though `Let 'em 
Fly!' contains quite a few safety queries,  it isn't possible to query 
everything ...


9 Credits
=========

Here  I would nevertheless like to thank the two people  named  above, 
since they showed that such things are possible.

`Interface'  by Olaf Meisiek was used for the design the dialog  boxes 
within and without (CPX) `Let 'em Fly!'


10 My address
=============

Versions upto 1.20 are direct from :

Oliver Scheel
Mundenheimer Strasse 254
D-67061 Ludwigshafen
Germany

Email: Oliver_Scheel@lu.maus.de


Newer versions ( ie, 1.30 onwards ) are from :

Darryl Piper
1 Parklands
Okehampton
Devon
EX 20 1 QE
England

Email: drpiper@cix.compulink.co.uk
