home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d5xx / d540 / parm.lha / ParM / ParM.docE < prev    next >
Text File  |  1991-08-27  |  27KB  |  634 lines

  1.  
  2.  
  3. Documentation for ParM
  4.  
  5.  
  6. ParM stands for Parametrable Menu.
  7.  
  8. ParM  allows  you to build your own menus in order to run all the programs
  9. you  can  have  on  one ore more disks.  This is very useful for hard disk
  10. owners  who  have  programs deeply enclosed in subdirectories.  With ParM,
  11. you  can run them without going through directories under either WorkBench
  12. or CLI.
  13. With  ParM,  you  can start programs in either WorkBench or CLI mode.  The
  14. advantage  of  WorkBench mode is that the default directory of the program
  15. you run is the one in which the program file is.  But not all programs can
  16. be run in this mode.
  17.  
  18.  
  19. Building:
  20.  
  21.     ParM  was  made using AztecC 5.0a, CygnusEd release 2, and ARexx 1.10.
  22.     File  headers  are done in such a way compilation can be launched from
  23.     Ced.  I use my own DevKit, completely rewritten since the original 1.2
  24.     version of the DevKit wasn't working at all.
  25.  
  26.     ParM  needs arp.library version 39 and req.library version 1.  I wrote
  27.     my  owns libraries for the Manx linker.  The ones used here are called
  28.     arps.lib  and req.lib.  The arps.lib provides a small startup code and
  29.     glues  for arp functions that cannot be prototyped, and the req.lib is
  30.     the reqglue.o given with CygnusEd rewriten as a library.
  31.  
  32.  
  33. Installation:
  34.  
  35.     Put  ParM  with  its  icon wherever you want, and just put the default
  36.     config  file  "ParM.cfg"  in  S:  if you use it.  If you don't, you'll
  37.     have  to  specify  the  config file in the command line or in the tool
  38.     types  of  the  icon, otherwise, you will have to cancel the requester
  39.     and  won't  have  any  menus.   Since  version 2.6r, you must also put
  40.     parm.library in your LIBS:  directory.  Make sure you have arp.library
  41.     39.1 or higher and req.library too.
  42.  
  43.  
  44. Running:
  45.  
  46.     It  is  recommended  to run ParM from CLI if you want your programs to
  47.     have  a default path other than the current directory and C:  which is
  48.     the case if you start it from WorkBench.
  49.  
  50. ParM can work in three ways.
  51. 1)  You  can  attach  ParM to the CLI you are using.  In this case, if you
  52.     don't specify any of the window options, the menus will be attached to
  53.     the  CLI  window  you  start  it  from.  You may then only "Run" it to
  54.     prevent you from closing the CLI.
  55.  
  56. 2)  ParM can have its own window.  This is allways the case when it is run
  57.     from  WorkBench, but you can also tell it to open it's own window when
  58.     run  from  CLI  using  "-w"  option or any of the window options.  You
  59.     should then "RunBack" it to be able to close the CLI later.  Don't use
  60.     arp ARun with NOIO because some programs don't like it, and those will
  61.     not run from ParM.
  62.     Warning: you shouldn't run ParM with "Run >NIL: ParM" because it would
  63.     be detached from the CLI but still keep the console for  it's  default 
  64.     input and output file handles and some commands in RUN mode may  crash
  65.     if you 'EndCLI' before. Or you can do it but use -o option then.
  66.     Note  that  RunBack use the C:Run command and you should place the arp
  67.     version  of  the  Run command of your C:  directory if you want to use
  68.     ParM as resident.
  69.  
  70. 3)  ParM can be attached to Workbench, ala MyMenu.
  71.  
  72.  
  73.     ParM  have  some  options  which  are  available  for most either from
  74.     WorkBench or from CLI.  Two of them are only available from CLI.  "-w"
  75.     since  ParM  allways  open  its own window when run from WorkBench and
  76.     '-o' because it is the default when run from WorkBench.
  77.  
  78.     Option list:
  79.  
  80.     CLI        WB
  81.  
  82.     -m      MYMENU       Attach menus to Workbench's. (Like MyMenu).
  83.     -w      (CLI only)   Open its own window rather than taking CLI's one.
  84.     -x      LEFTEDGE     Left edge of ParM Window (default 0)
  85.     -y      TOPEDGE      Top edge of ParM Window (default 0)
  86.     -d      DETAILPEN    Detail pen of ParM Window (default 3)
  87.     -b      BLOCKPEN     Block pen of ParM Window (default 2)
  88.     -c      MENUCOLOR    Color for ParM's main menu (default: Detail Pen)
  89.     -r      NODRAGBAR    No drag bar (You can't move ParM), =1 to activate
  90.     -g      DEPTHGADGETS Depth gadgets, =1 to activate
  91.     -s      STACKSIZE    Default stack size for commands (not parm's stack)
  92.     -f      CONFIGFILE   Configuration file.
  93.     -o                   Redirect output to NULL: for commands in RUN mode.
  94.  
  95.     -h or anything else to get help when run from CLI.
  96.  
  97.     To  use  workbench tool types, just use the keyword followed by an "="
  98.     and the value needed.  For example
  99.  
  100.         DETAILPEN=1
  101.  
  102.     this is equivalent to
  103.  
  104.         RunBack >NIL: ParM -d1    when run from CLI.
  105.  
  106.     if you specify any of the -x,-y,-d,-b,-g,-r options when run from cli,
  107.     a window will be open and -w option is useless.
  108.  
  109.  
  110. Configuration file:
  111.  
  112.     You  will  best  understand what follows if you have in front of you a
  113.     printout of the config file supplied.
  114.  
  115.     A  configuration  file  looks  like  a structured program.  You should
  116.     indent your lines to make the file as readable as possible.
  117.  
  118.     The  default  configuration file should be in the S:  directory and be
  119.     named ParM.cfg.
  120.  
  121.     The  configuration  file defines the menus you want, and what commands
  122.     they will run.  Comments begin with a #, and continue until the end of
  123.     the line.  Upper and lowercase do not make a difference.
  124.  
  125.  
  126.     Keywords:
  127.  
  128.     CMDWIN  console_name
  129.  
  130.         This  will  override  the  default console used for Command output
  131.         which is "CON:0/11/640/100/Command Window".  This should be placed
  132.         anywhere in the file but better be at top of it.
  133.  
  134.     SHELLWIN  console_name
  135.  
  136.         This  will  override  the  default console used for SHELL commands
  137.         which  is  "CON:0/11/640/100/ParM Shell".    This should be placed
  138.         anywhere in the file but better be at top of it.
  139.  
  140.     SHELLCMD  command
  141.  
  142.         This   will  override  the  default  command  used  to  create  an
  143.         interactive  shell,  which  is  AShell.   For  example, if you own
  144.         WShell,  you  can use NewWSH here.  This should be placed anywhere
  145.         in the file but better be at top of it.
  146.  
  147.     WAITCMD  command
  148.  
  149.         This  will  override  the  default command used to wait for a user
  150.         input  telling  to  close  the shell (default:  WaitReturn).  This
  151.         should be placed anywhere in the file but better be at top of it.
  152.  
  153.     TMPDIR  path
  154.  
  155.         This  will  override  the  default  temp  directory used for SHELL
  156.         scripts  which  is T:.  If your directory isn't in the root of the
  157.         device,  that is to say the dir name doesn't end with a colon (for
  158.         example  T:),  you  must  append a slash '/' to your dir name (for
  159.         example  RAM:T/).   This should be placed anywhere in the file but
  160.         better be at top of it.
  161.  
  162.     SHORTCUTQUAL qual
  163.  
  164.         This  can  be  used  to  add keys to access menus short-cuts.  For
  165.         example,  you can use Left-Amiga, ALT, SHIFT or Ctrl.  If you want
  166.         several keys, you just have to add qualifiers listed below:
  167.  
  168.             Left-Shift      1
  169.             Right-Shift     2
  170.             Ctrl            8
  171.             Left-Alt        16
  172.             Right-Alt       32
  173.             Left-Amiga      64
  174.  
  175.         If for example you want both left and right ALT keys to work for
  176.         menu shortcuts:     ( 16 + 32 = 48 ! )
  177.             SHORTCUTQUAL 48
  178.  
  179.         If  you  want shortcuts without a qualifier key, you can use 32768
  180.         (IEQUALIFIER_RELATIVEMOUSE),  which  is  allways present in RAWKEY
  181.         events. (Use with great care).
  182.         This  works  only when ParM has its own window or when attached to
  183.         Workbench.
  184.  
  185.  
  186.     ACTIVATEKEY [SCREENTOFRONT] [PASSTHROUGH] [NOCHECK] qualifier rawkey
  187.  
  188.         This  gives  you access to the simple but powerfull parm's library
  189.         input  handler.  Be carefull, rawkey is the keyboard key code, not
  190.         the ASCII code of the key.
  191.         This  gives  you the possibility to define one or more hot keys to
  192.         activate  parm's window, or any parm.library user, like "The Great
  193.         BrowserII".
  194.  
  195.         To  help  you experiment raw key code, there is a debug version of
  196.         the  library  given.   All  you have to do is put it in your LIBS:
  197.         directory.
  198.             Make parm.library is not already loaded.
  199.             Copy parm.library.debug libs:parm.library
  200.             Run ParM -w
  201.         Then, a window prints what follows:
  202.             Class  SubClass  Code  Qualifier.
  203.         These codes are in hex, and you must convert them to hex for ParM.
  204.         Only Code and Qualifier are usefull to the user.  Once you got the
  205.         codes you need, put back the normal parm.library in your LIBS:
  206.  
  207.         Options:
  208.             1. SCREENTOFRONT
  209.                 The screen which contains ParM's window comes to front.
  210.             2. PASSTHROUGH
  211.                 This may be hard to understand for non-programmers, but is
  212.                 powerfull  and  quite simple.  Let's say that if you don't
  213.                 use  this  option,  the  hot-key will just activate ParM's
  214.                 window, and that's all.  If you use it, the event will not
  215.                 be  removed  from list, and as ParM's window has just been
  216.                 activated,  it  will receive the raw key.  So, if this raw
  217.                 key is also a menu short cut, it will be executed without
  218.                 having to activate ParM's window with the mouse.
  219.  
  220.                 Example:
  221.  
  222.                     SHORTCUTQUAL 64                 (Amiga gauche)
  223.                     ACTIVATEKEY PASSTHROUGH 64 50   (Amiga gauche - X)
  224.  
  225.                     Menu System
  226.                         Item {X} Xoper RUN Xoper
  227.  
  228.                     This  allways  runs Xoper, without touching the mouse,
  229.                     even if ParM's window is not the active one.
  230.  
  231.                 Another example:
  232.  
  233.                     # Left ALT - Right Mouse Button
  234.                     ACTIVATEKEY PASSTHROUGH SCREENTOFRONT 8208 105
  235.  
  236.                     This activate ParM's menus, in a single click. No more
  237.                     need to search for little ParM's window.
  238.  
  239.             3. NOCHECK
  240.                 The  library keeps a list of hot-keys.  When you add a new
  241.                 hot-key  with  ACTIVATEKEY command, ParM controls if it is
  242.                 not already used.  If it is, you will be requested, and it
  243.                 will  be ignored.  If you specify NOCHECK, hot-key will be
  244.                 inserted  in  head  of  the list, and will take precedence
  245.                 over the old one.
  246.                 Here  is what I do with that:  I have a hot-key in ParM to
  247.                 load  BrowserII.  The same hot-key has the NOCHECK flag in
  248.                 BrowserII.menu.   So,  if BrowserII is already loaded, the
  249.                 hot-key   brings   BrowserII's   screen  to  front,  else,
  250.                 BrowserII is loaded by ParM.  Nice, isn't it ?
  251.  
  252.                 ParM.cfg :
  253.  
  254.                     SHORTCUTQUAL 64
  255.  
  256.                     # Left Amiga - Z   (Load BrowserII)
  257.                     ACTIVATEKEY PASSTHROUGH 64 49
  258.  
  259.                     menu Tools
  260.                         item {Z} BrowserII      RUN HD:Tools/BrowserII
  261.  
  262.                 BrowserII.menu :
  263.  
  264.                     SHORTCUTQUAL 64
  265.  
  266.                     # Left Amiga - Z
  267.                     ACTIVATEKEY SCREENTOFRONT NOCHECK 64 49
  268.  
  269.  
  270.     COLOR n
  271.  
  272.         This  will  set  the  foreground pen color for new items.  You can
  273.         change this as often as you want.  The arguments is the pen number
  274.         to  use.   The  default  is  window  detail pen.  If the color was
  275.         window  block pen, the item would be invisible, in this case, ParM
  276.         replaces the color with window detail pen.
  277.  
  278.     MENU menu_name
  279.  
  280.         Creates  a  new  menu.   Each  menu must have at least one item or
  281.         submenu.
  282.  
  283.     SUBMENU submenu_name
  284.  
  285.         Creates  a  new submenu.  Each submenu must have at least one item
  286.         and can't have submenus.
  287.         Each SUBMENU must end with an ENDSUBMENU
  288.  
  289.     ENDSUBMENU
  290.  
  291.         See SUBMENU.
  292.  
  293.     ITEM [{command-char}] item_name command_def
  294.  
  295.         Defines  a  new  menu  item.   Each  item  definition must have an
  296.         item_name  and  an associated command.  Each item is linked to the
  297.         current  menu  or  submenu.  An ENDSUBMENU statement tells ParM to
  298.         attach  next  items to the current menu rather than to the current
  299.         submenu.   If  any of the menu, submenu and item names may contain
  300.         whitespaces.   In this case, enclose the name in double quotes.  A
  301.         command  character may be defined for the menu item by putting the
  302.         character  after  the  ITEM  keyword  and  surround  it with {}'s.
  303.         Command syntax is decribed below.
  304.  
  305.         command_def
  306.  
  307.             Programs  can  be run in four ways:  ARUN, RUN, SHELL, and WB.
  308.             For  all modes, STACK and PRI are optionnal.  If STACK is less
  309.             than  4000  bytes, or if no stack is specified, the stack will
  310.             be  set to the ParM task Stack.  That is to say the stack size
  311.             at  time  ParM  was  run.   There's  an exception:  If ParM is
  312.             resident, ParM stack will allways be 4000 bytes.
  313.  
  314.  
  315.             1) ARUN syntax
  316.  
  317.             ARUN [WIN console_window] [STACK n] [PRI n] command [args]
  318.  
  319.             This  mode should be used for most of your needs.  The console
  320.             window  is  now optionnal.  This is a CreateProc() style mode.
  321.             Some  programs  don't  like  it,  but  there is not many.  For
  322.             example  scripts  cannot  be executed.  As a general rule, you
  323.             shouldn't  use  this  mode  for commands of the C:  directory.
  324.             Use  RUN  instead.   This mode has the same limitations as the
  325.             arp ARun command.  Actually, the console is immediately closed
  326.             after  the  program  ends.   We  hope  to fix this in a future
  327.             release.   For example, I use this mode to Format my floppies,
  328.             and  I  see  in  a little window the format process.  Commands
  329.             cannot be redirected in this mode.
  330.             Note: The ARUN mode with a console (ARUN WIN console)  is  the
  331.             same as the old CLI mode. So, you can do a search/replace with
  332.             your  favorite  editor to  update  your  old  config file to a
  333.             version >= 2.2 of ParM. ( CLI ==> ARUN WIN )
  334.  
  335.  
  336.             2) RUN syntax
  337.  
  338.             RUN [STACK n] [PRI n] command [args]
  339.  
  340.             This  mode  creates  a  background shell.  This mode should be
  341.             used for scripts.  If the bit s of your script file is set, it
  342.             is  automaticaly sourced (No need of the execute command).  In
  343.             this mode, commands won't be detached if ParM is attached to a
  344.             CLI,  this  is  why  you  should use the ARUN mode as often as
  345.             possible.  Redirection can be done in this mode.
  346.  
  347.  
  348.             2) SHELL syntax
  349.  
  350.             SHELL [WIN console_window] [STACK n] [PRI n] command [args][;command [args]]...
  351.  
  352.             This  mode  creates an interactive shell.  This mode should be
  353.             used for scripts that needs input from the user.  If the bit s
  354.             of  your  script  file  is set, it is automaticaly sourced (No
  355.             need  of  the execute command).  One more feature of this mode
  356.             is   that  you  can  specify  several  commands  separated  by
  357.             semicolons,  ie:  CD SYS:Utilities;Dir In fact, ParM creates a
  358.             script  file in a temporary directory which is T:  by default.
  359.             So  you  can  make  a  real script file.  Type it normaly, and
  360.             then,  put  a  semicolon at each end of line, and join all the
  361.             lines.   You  can  then submit this line to ParM as a command.
  362.             If  a  command  needs  a  semicolon,  you can put it after the
  363.             override  char  '\'.   Usualy, semicolons are taken as comment
  364.             delimiters.   If  no  console  is  specified,  a  parametrable
  365.             default console will be used for the shell.
  366.  
  367.  
  368.             4) WB syntax
  369.  
  370.             WB [STACK n] [PRI n] command
  371.  
  372.             Execute  command  in WorkBench mode.  No arguments are allowed
  373.             in  this  mode.  Warning:  If STACK is specified here, it will
  374.             override the stack specified in the icon of the command.  Your
  375.             command may crash if you ask a smaller stack than in the icon.
  376.             Do it at your own risk.
  377.  
  378.  
  379.             5) CFG action
  380.  
  381.             CFG ConfigFile
  382.  
  383.             ParM  loads  the  new  ConfigFile like ParM->Open in the Menu.
  384.             Very  usefull  to  use different cfg file on different disk to
  385.             choose programs on this disk.
  386.  
  387.  
  388.     For  all  modes but WB, your command is searched first in arp resident
  389.     list  and  then in CLI Path at time ParM was run.  To know the path in
  390.     which  ParM  search  its  commands, just issue the Path command in the
  391.     requester of ParM Command command, or open a newcli or shell from ParM
  392.     and issue the Path command.
  393.  
  394.     A config file is given with ParM as an example.
  395.  
  396.  
  397. ParM commands:
  398.  
  399.     Open:       Pops up a requester asking to select the new config file.
  400.     UpDate:     UpDate the menu reloading the config file.  Usefull if you
  401.                 modify the config file while ParM is running.
  402.     Std Cfg:    Load   the   standard   'S:ParM.cfg'  configuration  file.
  403.                 Usefull  to  return in your favorite cfg when you are lost
  404.                 in one disk cfg.
  405.     Cmd Mode:   Two  modes  are available.  Simple and Shell.  The current
  406.                 mode  is  checkmarked.   This  modes  are  for the Command
  407.                 command  (see below) In 'Simple' mode, ParM will stay busy
  408.                 while your command isn't finished, where as in Shell mode,
  409.                 Command is asynchronous.  To do that, an interactive shell
  410.                 is  created,  and  your(s)  command(s)  is  (are) put in a
  411.                 startup  file.   There is an (s) because in this mode, you
  412.                 can  put  several  commands  separated by semicolons. Same
  413.                 rules as SHELL mode in config file.
  414.                 If you own WShell and use PatchDOS, you will  have  access
  415.                 to all WShell facilities. (alias, residents commands...).
  416.     Command:    Allows you to execute a single CLI command.
  417.     Change Dir: Changes ParM current directory.  Commands run in all modes
  418.                 but WB will inherit ParM current directory.
  419.     Quit:       Why? You don't like it!
  420.  
  421.  
  422. Separated commands:
  423.  
  424.   End:
  425.  
  426.     The  End command can now close a CLI in which a ParM is attached.  End
  427.     needs  EndCLI  to  work.  If there is no ParM attached to the CLI, End
  428.     will  only  do  an  EndCLI.   End  and EndCLI can be made resident for
  429.     maximum  speed.   You  can for example put ParM in your CLI-Startup or
  430.     Shell-Startup  to  have  menus in all of your CLI/Shells and you'll be
  431.     able  to  leave them with the End command without worrying about ParM.
  432.     Don't use this command in a WShell since it loads EndCLI from disk and
  433.     WShell only accept its built in EndCLI command.
  434.  
  435.  
  436.   ParMCD:
  437.  
  438.     The  ParMCD  change  the  current directory of the ParM attched to the
  439.     current  cli window.  Without argument, ParM will take the cli current
  440.     dir.  Otherwise, you can specify a directory as an argument to ParMCD.
  441.  
  442.  
  443.   WaitReturn:
  444.  
  445.     The  WaitReturn is used by the Command command if in Shell mode.  This
  446.     one  can  also  be made resident.  You can use it in your scripts.  It
  447.     just wait for the user to hit return.
  448.  
  449.  
  450. Limitations:
  451.  
  452.     Scripts won't run in ARUN mode, use RUN or SHELL mode instead.
  453.  
  454.     If  a  command  in  RUN or SHELL mode can't be started, you will never
  455.     know, except you won't see it working.
  456.  
  457.     When  attached  to  a  CLI,  commands  executed  in  RUN mode won't be
  458.     detached,  which  means that you won't be able to close the cli before
  459.     those  commands  end.  This is the same problem as if you had run your
  460.     command in a CLI with
  461.             1> Run mycommand
  462.     By  the  way,  theses  commands will have their output file handles in
  463.     this  window, and advantages can be taken from that.  You can redirect
  464.     these  to  NIL: or use -o option to avoid trashing of your cli window.
  465.     In this case, commands will be detached.
  466.  
  467.     ParM  can  be  made  resident only with the arp ARes command.  Because
  468.     ParM is not really pure, when it is resident, ParM duplicates its data
  469.     and bss.  Only arp make it possible to know if we are resident or not,
  470.     and  then,  ParM  will never copy its data if it is made resident with
  471.     the  commodore  method.   So  I allways use the arp Run command to run
  472.     parm  since  the  arp  Run first searches commands in the arp resident
  473.     list.
  474.  
  475.     In  MyMenu  mode, if you use Command in Simple mode, Workbench will be
  476.     inactive until command is finished and window closed.
  477.  
  478.  
  479. Known bugs:
  480.  
  481.     Specified PRI in SHELL mode isn't used. Pri is allways 0.
  482.  
  483.  
  484. Future plans:
  485.  
  486. -   Decrease code size under 2 K !!!
  487. -   Make a  single  asynchronous  Command Mode  which doesn't use any disk
  488.     loaded command.
  489.  
  490.  
  491. Release notes:
  492.  
  493.     1.0:    Internal. Major MyMenu rework.
  494.  
  495.     1.1:    First official release. (Sent to Fred Fish)
  496.             Old CLI option changed to RB (stands for RunBack).
  497.             New CLI option added.
  498.             Config file syntax changed. (Old was MyMenu's one).
  499.  
  500.     1.4:    Internal. Option -l -d and WBRun enhanced.
  501.             Now you can run projects icons which have no file. For example
  502.             Serial, Pointer and Printer in the Prefs drawer.
  503.  
  504.     1.6:    Second official realease. 29/09/90
  505.             Code Cleanup
  506.             New CFG option added.
  507.             New 'Std cfg' menu added.
  508.  
  509.     1.7:    Internal
  510.             No more uses c16.lib, but use my owns instead.
  511.             Code size about 1.5K smaller.
  512.  
  513.     2.0:    Third Official release. 13/10/90.
  514.             ParM can now be made resident.
  515.             End command created.
  516.             Directory path string built in 'Change Dir'.
  517.  
  518.     2.1:    ParMCD command created.
  519.     2.1r:   This version uses the great req.library (r for req!)
  520.  
  521.     2.2r:   No more RB and CLI modes. New modes are ARUN, RUN, and SHELL.
  522.             STACK and PRI available in all modes but WB now.
  523.             No more need of the Run command in your C: directory.
  524.             Syntax errors in config file will now be reported with a line
  525.             and char number.
  526.  
  527.     2.3r:   You will never see again 'Workbench processes still active'.
  528.             ParM now creates a public MsgPort to handle workbench replies
  529.             and leave it if there's still messages to be replied.
  530.             Now, if your console has a close gadget, ParM will end if you
  531.             hit it. This is usefull for lucky owners of WShell.
  532.             Characters of ascii value over 127 now supported. (accents)
  533.             WAITCMD added.
  534.  
  535.     2.4r:   WB mode rewriten. STACK and PRI available in all modes now.
  536.             WB mode no more crashes if command not found. You can now run
  537.             tools that haven't an associated icon.
  538.             Memory for menus items is allocated by 1 K blocks to decrease
  539.             fragmentation.
  540.  
  541.     2.5r:   -s and -o option added.
  542.             -s (stack) is specially usefull when ParM is resident  because
  543.             in this case ParM stack is allways 4000 bytes whereas it takes
  544.             the default stack size of your cli when it is not resident. As
  545.             all commands run from ParM take as default the ParM stack size
  546.             you can specify a higher stack with this option.
  547.  
  548.     2.51r:  Minor update. Bug fixes.
  549.             ParM  no  more  crashes when run from workbench if arp.library
  550.             cannot be found.
  551.  
  552.     2.6r:   ParM now implemented as a shared library. This allow BrowserII
  553.             to take advantage of ParM's parsing and creating parametrables
  554.             menus. Put "parm.library" in LIBS:, and ParM at the same place
  555.             as before.
  556.             When  ParM  is used with it's own window, menus short-cuts can
  557.             be  accessed with  Left-Amiga  as well as standard Right-Amiga
  558.             key, except for M and N which are intuition private.
  559.             ParM window is now autofront. (user request).
  560.  
  561.     2.7:    -o  option  now  attempt to use NULL:  rather than NIL:, which
  562.             allow  to  really redirect output for RUN commands to NIL:  or
  563.             better  to  say  NULL: !  This prevent programs which open "*"
  564.             after the cli from which ParM was run to crash if cli has been
  565.             closed.  With NULL:, RUN mode is now perfectly safe and should
  566.             work in all cases.  If NULL:  isn't found, NIL:  will be used.
  567.             'r'  removed  from  version  number.   Making  a version which
  568.             doesn't use req.library is no more planned.
  569.  
  570.     2.8:    Bug fixes.
  571.             Qualifier for menu short-cuts now parametrable.
  572.  
  573.     2.9:    Implementation  of  an input handler in parm.library. It makes
  574.             possible to run a command with a hot-key, without touching the
  575.             mouse,  or  to activate ParM's menus without activating ParM's
  576.             window.
  577.  
  578.     3.0:    As a user request, ParM can now be attached to Workbench, just
  579.             like  MyMenu.  (Code stolen from MyMenu once again). Sorry and
  580.             thanks, Darin and John.
  581.             ParM now works with Console-Buffer. With some limitations. You
  582.             MUST run ParM AFTER CB, and leave ParM BEFORE CB.
  583.             You can now put several commands, separated by a ; in RUN mode
  584.             and in Command, like in SHELL mode.
  585.  
  586.  
  587. Acknowledgements:
  588.  
  589.     The  first  release (internal) of ParM was a major rework of MyMenu by
  590.     Darin Johnson.  The problem was that it wasn't possible to have MyMenu
  591.     without workbench, and program started from MyMenu didn't have a Path.
  592.  
  593.     So, lots of thanks to Darin Johnson for menu allocations and workbench
  594.     run.  The idea of attaching menus to the CLI and some other ideas came
  595.     from a friend who also made a menu but wasn't easy to configure.
  596.  
  597.     Great thanks to Olaf 'Olsen' Barthel for his update of arp startup for
  598.     manx 5.0, the code from which I made my own libs.
  599.  
  600.     Thanks  also  to  Colin  Fox  and  Bruce  Dawson  for  their fantastic
  601.     req.library.   We  encourage  every  programmers  to  use  it.   Every
  602.     professionnal  software  producers  should at least have a look at the
  603.     file requester.
  604.  
  605.     Thanks to S.R. and P.C. for ParM!
  606.     Thanks to Darin Johnson for MyMenu.
  607.     Thanks to William S. Hawes for ARexx and WShell.
  608.     Thanks to Pierre Ardichvili for his help to me and to Amiga.
  609.     Thanks to CygnusSoft and ASDG for their GREAT CygnusEd 2.
  610.  
  611.  
  612. Signature:
  613.  
  614.     S.R. & P.C.
  615.     This is not Status Register and Program Counter but
  616.     Sylvain Rougier & Pierre Carrette.
  617.     We are Frenchies so we hope the documentation is readable.  We put our
  618.     work  in  making english language comments, but it isn't allways easy,
  619.     so be fair with us.
  620.  
  621.  
  622. Donations:
  623.  
  624.     This  program is not public domain.  This program is ShearWare.  If you
  625.     use  it  or  if  you want the last revision, send donation and/or
  626.     bugs report to:
  627.  
  628.         Sylvain Rougier
  629.         Coiffure W
  630.         39 rue Carnot
  631.         86000 Poitiers
  632.         France.
  633.  
  634.