mca
 Help information about: Actions
 ^Editing
 
              E╔════════════════════════════════════════════════╗
              E║                    CActionsE                     ║
              E╚════════════════════════════════════════════════╝


 CUsing Action Lists

   When you're using InContext, you are always in a directory, and focussing
   on one or more objects.  You may have selected a single object, or your
   focus may be a group of objects selected by class or view, or even the
   entire set of objects in the directory.

   InContext always presents you with a list of CActionsB appropriate to the
   object or objects on which you're focussing.  Most users will find it
   convenient to have these actions shown on the main display, but this is
   under your control.  Actions shown on the main display look like this:

                        E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
                        E█A                         A  E█
                        E█A  B                       A  E█
                        E█A  EsB   EObjectsB   EActionsB  A  E█
                        E█A  B  admnnot.doc Edit     A  E█
                        E█A  B  afhsmin.doc ViewYB     A  E█
                        E█A  B C afhsnot.docB Archive  A  E█
                        E█A  B   bksale.doc Copy     A  E█
                        E█A  B bull8608.doc Delete   A  E█
                        E█A  B   edcord.doc Print    A  E█
                        E█A  B floodord.doc Rename   A  E█
                        E█A  B  lwvbylw.doc Take     A  E█
                        E█A  B  miscrep.doc Look-fmt A  E█
                        E█A  B  orchpiz.doc Spellchk A  E█
                        E█A  B ordattle.doc          A  E█
                        E█A                         A  E█
                        E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   Regardless of whether or not you choose to show the actions on the main
   display, they are available to you via the F ADction B Command.  Selecting
   it produces a display like the following:

        E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
        E█A                                                         A  E█
        E█A  B CDocumentB  EClass:B CALLB   EObject:B Cafhsnot.doc B   ETask:B CpaA  E█
        E█A  E──────────────────────────────G  Action    E─────────────A  E█
        E█A  B   G  All Actions of Class "doc"       FªEDdit  FªHDelpG  B   A  E█
        E█A  B   E│B                                               E│AbdEiA  E█
        E█A  E.B E │B EBrief NameB     EYour DescriptionB               E│ANCBIA  E█
        E█A  E.B  E│B  Edit         Edit using BRIEF editor         E│AADBSA  E█
        E█A  E.B  E│B  ViewYB         View using internal viewer      E│A  B A  E█
        E█A  E.B  E│B  Archive      Add object to an archive        E│A  B A  E█
        E█A  E.B  E│B  Copy         Make a copy of the object       E│A  B A  E█
        E█A  E.B  E│B  Delete       Delete object, after verif      E│A  B A  E█
        E█A  E.B  E│B  Print        Print using WORDIX formatter    E│A  B A  E█
        E█A  E.B  E│B  Rename       Rename the object               E│A  B A  E█
        E█A  E.B  E│B  Take         Take object along as you move   E│A  B A  E█
        E█A  E.B  E│B  Look-fmt     Preview formatted output        E│A  B A  E█
        E█A  E.B  E│B  Spellchk     Check spelling using SPELLIX    E│A  B A  E█
        E█A  E.B  E│B                                               E│A  B A  E█
        E█A                                                         A  E█
        E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   To perform one of these actions, simply select it with the mouse or
   keyboard.

   The action list varies, depending on the focus.  For example, the figure
   above shows a possible action list for a document (i.e., for an object
   of class "doc").  While the details will vary with your particular
   situation, this list assumes that documents are ASCII text files that are
   edited using the BRIEF editor, formatted and printed using the WORDIX
   formatter, and that the SPELLIX spelling checker can be used to check
   their spelling.

   A different set of actions would obviously apply if the object were not a
   document.  For example, if an executable program, such as the MS-DOS
   utility "chkdsk.com", is selected, the list might include such actions
   as these:

                        E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
                        E█A                         A  E█
                        E█A  B                       A  E█
                        E█A  EsB   EObjectsB   EActionsB  A  E█
                        E█A  B   backup.com view     A  E█
                        E█A  B C  chkdsk.comB copy     A  E█
                        E█A  B  command.com rename   A  E█
                        E█A  B     comp.com delete   A  E█
                        E█A  B diskcopy.com yank     A  E█
                        E█A  B    edlin.com rYBun      A  E█
                        E█A  B    fdisk.com          A  E█
                        E█A                         A  E█
                        E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   Obviously, it would be inappropriate to try to check the spelling of this
   executable program, or to try to print it, so those actions don't appear
   when an object of class "com" is selected.  The program CcanB be
   executed, though, so the action "run" is among those shown.

 CHow Do Action Definitions Work?

   A lot of power in InContext results from your ability to define the
   action lists yourself.  This is a somewhat more advanced topic than the
   CuseB of those action lists, and it is separately discussed.  For
   information on how to define your own actions, see
 ZmcaeB  CJ Editing the Action Definitions CB.

   Basically, each action definition consists of an action CnameB (e.g.,
   "edit"), an action CdescriptionB (e.g., "Edit spreadsheet with 1-2-3"), and
   a CprocedureB, that specifies what is to happen when the action is selected.
   You've seen the name and description on the main display and the Action
   display.  The procedure is visible only when you edit the action.

   Briefly, the CprocedureB is much like an MS-DOS Cbatch fileB, though it can
   contain commands in an InContext procedure language as well as MS-DOS
   commands.  The MS-DOS commands can execute other programs or perform
   MS-DOS-internal operations like file copying and renaming.  The additional
   InContext commands allow queries to the user, menus, etc.  This subject is
   discussed extensively in the "Editing the Action Definitions" section
   mentioned above.

 CWhat Actions Are Applicable to a Particular Object or Group?

   Behind the scenes, there are actually several different action lists that
   determine what actions are available under particular circumstances:

        CB The CgroupB action list determines what actions can be performed
          on a group of objects.

        CB The CcommonB action list applies to all single objects, regardless
          of class.  The common list includes actions like "copy", "delete",
          and "rename", which pretty much mean the same thing for all objects.

        CB The CclassB action list defines the actions that can be performed on
          a single object of a specified class.  These actions are in
          addition to the common actions, though they may also override or
          cancel those actions.

   The figure below illustrates graphically how these action lists apply to
   different situations.

                group
               E┌──────D group actions B
   if focus is E│B                                    known
   E────────────┤                                   ┌────────D class actions B
               E│B                      and class is E│
               E└──────D common actions E─────────────┤
                object                             E│ 
                                                   E└────────
                                                    unknown

   These action lists will now be discussed separately.

 CCommon Action List

   The CcommonB action list contains those actions that apply to single
   objects, regardless of class.  These actions can be overridden by the
   action list of an individual class, but for the most part, this list
   should contain those actions that apply uniformly to all objects.  Like
   all the action lists, this list is under CyourB control, and can be
   changed to suit your needs.  As issued by Rams' Island Software, though,
   this list contains the following actions:

        CeditB      In the common action list, this action asks the user to
                  verify that the object is an ASCII text file.  If the user
                  says "no", the procedure is aborted, while a "yes" answer
                  invokes the preferred text editor (possibly the internal
                  editor) on the object.  Whenever you create an action list
                  for a specific class, you will want to override this action
                  by defining an "edit" action there.  An action definition
                  there which lacks a procedure would cause "edit" not to
                  appear on the displayed action list at all.

        CviewB      This action allows any object to be viewed, without
                  possibility of modification.  As currently provided, this
                  action uses InContext's internal viewer.  If you prefer to
                  use another viewer, such as Vern Buerg's LIST program, you
                  can redefine this action.  In any event, this action should
                  be overridden in individual class definitions when
                  appropriate.  Thus, to "view" a graphical image, an
                  appropriate image viewer should be used, rather than a text
                  or hex viewer.

        CarchiveB   This action asks the user for the name of an LHARC
                  archive, and adds the selected object to that archive.
                  A pause occurs to allow the user to verify (by reading the
                  output of LHARC) that the operation was successful.  Then
                  the user is given an opportunity to delete the selected
                  object.

        CcopyB      This action invokes an internal file copy operation,
                  after asking the user for a destination.  You may also
                  copy or move objects with the "take" and "put-obj" actions
                  (see "take", below).

        CdeleteB    This action allows you to delete an object, after a
                  verification step to give you a chance to change your mind
                  or to avoid accidental deletion.

        CprintB     In the common action list, this action asks the user to
                  verify that the object is an ASCII text file.  If the user
                  says "no", the procedure is aborted, while a "yes" answer
                  invokes the normal DOS print command on the object.
                  Whenever you create an action list for a specific class,
                  you will want to override this action by defining a "print"
                  action there.

        CrenameB    This action allows you to rename a file.  In doing so,
                  you are free to change its filename prefix and/or its
                  class, if appropriate.

        CtakeB      This action allows you to pick up an object and carry it
                  with you as you move to another directory.  If you are
                  carrying an object, a "put-obj" action is added to the list
                  of actions available to you.  If you select the "put-obj"
                  action, you will be asked whether you want to move it there
                  or make a copy there, and the requested operation will be
                  performed.  If you "take" an object and never "put" it
                  anywhere, no damage is done; it remains in its original
                  place.

 CThe Action List for an Individual Class

   You may define whatever actions you like for an individual class.  In
   addition to adding actions not already defined in the common action list,
   a CclassB action list can undefine or redefine the actions that are on
   that list.  This gives you considerable flexibility.

   Many class action lists will define the "edit" and "view" operations in
   some special way, overriding whatever definition might have been
   inherited from the common action list.  For example, the Lotus 2.0
   spreadsheet class, "wk1", might be edited using Lotus 1-2-3, and might
   have no separate view operation.

 CThe Group Action List

   The CgroupB action list defines the actions that can be performed on a
   group of objects.  Such a group is always confined to the current
   directory, but may consist of all the objects in the directory, or only
   those in a particular view or class.  Initially, the actions defined in
   the group action list include:

        Cedit-allB  This action allows you to edit a group of objects.  It is
                  initially set up to use the internal InContext editor,
                  which does CnotB currently have a multiple-file
                  capability.  It therefore allows you to edit the objects
                  sequentially, one after another.  If you have a text
                  editor with multiple-file capability, you will undoubtedly
                  want to change this action's definition to make use of it.
  
        Cview-allB  This action allows you to view a group of objects, if your
                  initially set up to use the internal InContext viewer,
                  which does CnotB currently have a multiple-file
                  capability.  It therefore allows you to view the objects
                  sequentially, one after another.  If you have a text
                  viewer with multiple-file capability (such as LIST), you
                  will undoubtedly want to change this action's definition
                  to make use of it.

        Ccopy-allB  This action asks you where you want the objects copied,
                  and does an ordinary MS-DOS file copy operation.  At
                  present, no protection is offerred to insure that enough
                  space exists at the destination, so you should always check
                  after the operation to insure that all files were copied.

        Cdel-allB   This action deletes all the objects, either one at a
                  time (with individual verification) or as a group, if you
                  specify that.

        Carc-allB   This action adds the objects to a specified archive,
                  using the public-domain archive/compression program LHARC.
mcae
 Help information about: Editing the Action Definitions
 ^Language ^Macros
 
              E╔════════════════════════════════════════════════╗
              E║         CEditing the Action DefinitionsE         ║
              E╚════════════════════════════════════════════════╝


   To change the action definitions, select the Action display.  You will
   see the F EDdit B command on the command bar, as shown below.  Select that.
   (You may also select Edit by pressing function key F2.)

           E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
           E█A                                                   A  E█
           E█A  E───────────────────────────G  Action    E──────────A  E█
           E█A  G  All Actions of Class "txt"       FªEDdYDit  FªHDelpG  A  E█
           E█A  E│B                                               E│A  E█
           E█A  E│B EBrief NameB     EYour DescriptionB               E│A  E█
           E█A  E│B  Edit         Edit using preferred editor     E│A  E█
           E█A  E│B  View         View using internal viewer      E│A  E█
           E█A  E│B  Archive      Add object to an archive        E│A  E█
           E█A  E│B  Copy         Make a copy of the object       E│A  E█
           E█A  E│B  Delete       Delete object, after verif      E│A  E█
           E█A  E│B  Print        Print, standard size            E│A  E█
           E█A  E│B  Rename       Rename the object               E│A  E█
           E█A                                                   A  E█
           E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   This will cause a window to be popped up over the current action list,
   allowing you to specify which action list you want to edit.  The display
   you'll see looks like the following.

  E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
  E█A                                                                     A  E█
  E█A  E────────────────────────────────────────G  Action    E───────────────A  E█
  E█A  B             G  All Actions of Class "txt"       FªEDdit  FªHDelpG  B     A  E█
  E█A  B     EHoursB   E│B                                               E│AbdEirsA  E█
  E█A  JedcB E12a....B E │B EBrief NameB     EYour DescriptionB               E│ACEB   A  E█
  E█A  Bocs E 1 ....B  E│B  Edit         Edit using preferred editor     E│A  B   A  E█
  E█A  Brs  E 2 ....B  E│B  View         View using internal viewer      E│AEFB   A  E█
  E█A  Bst  E 3 ....B  E│B  Archive      Add object to an archive        E│AISB   A  E█
  E█A  B    E 4 ....B  E│B  Copy         Make a copy of the object       E│AS B   A  E█
  E█A  B    E 5 ....B  E│B  Delete       Delete object, after verif      E│A  B   A  E█
  E█A  B    E 6 ....B  E│B  Print        Print, standard size            E│A  B   A  E█
  E█A  B    E 7 ....B  E│B  Rename       Rename the object               E│ATSB   A  E█
  E█A  B G  Which action set do you want to edit?                        B   A  E█
  E█A  B E│ CAYBction definition for this class                           E │AICBSA  E█
  E█A  B E│ CCBommon actions applicable to all classes                   E │A  B A  E█
  E█A  B E│ CGBrouped-object actions applicable to whole views or classesE │A  B A  E█
  E█A  B E│ CMBacro action definitions useable in all of the above       E │AT B A  E█
  E█A  B E└─────────────────────────────────────────────────────────────┘A2 B A  E█
  E█A  B   A  2 ....A  │A                                               │ALUDEB A  E█
  E█A  B    E 3 C....B  E│B                                               E│AONBTXTA  E█
  E█A                                                                     A  E█
  E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   If you haven't yet read about the different action lists, you should do
 ZmcaB  so before continuing here.  See CJ Actions CB.

   For purposes of the following discussion, let's assume we want to add a
   simple "word count" command which will apply to objects of the "txt"
   (text) class.  Let's suppose, further, that you have available a program,
   called "wc", which takes a file name as an argument and writes to the
   screen a count of the number of words contained in the file.  This example
   is perhaps artificially simple, but it will allow us to discuss the basics
   of action definition editing before covering the details of the InContext
   procedure language that you might use in defining fancier procedures.

   Since we want the "word count" action to apply only to objects of the
   "txt" class, the correct choice above is "Action definition for this
   class".  Selecting that might produce a display like the following.

           E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
           E█A                                                   A  E█
           E█A  E───────────────────────────G  Action    E──────────A  E█
           E█A  G  Editing Actions for 'txt' Class         FªHDelpG  A  E█
           E█A  E│B                                               E│A  E█
           E█A  E│B EBrief NameB     EYour DescriptionB               E│A  E█
           E█A  E│B  YIDescriptB     I                              B  E│A  E█
           E█A  E│B                                               E│A  E█
           E█A                                                   A  E█
           E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   To get a little extra instructional value out of the example, we will
   assume that the "txt" class is currently undefined.  In that case, you
   would see a display like that above.

   The first thing you should do when editing the action list for a new class
   is to provide a meaningful text description of the class.  This is simply
   placed in the "Your Description" space corresponding to "Descrip".

           E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
           E█A                                                   A  E█
           E█A  E───────────────────────────G  Action    E──────────A  E█
           E█A  G  Editing Actions for 'txt' Class         FªHDelpG  A  E█
           E█A  E│B                                               E│A  E█
           E█A  E│B EBrief NameB     EYour DescriptionB               E│A  E█
           E█A  E│B  IDescriptB     IASCII Text FileYI               B  E│A  E█
           E█A  E│B                                               E│A  E█
           E█A                                                   A  E█
           E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   Now we're ready to add the "word count" action.  By placing the cursor on
   the line after which we want to add the new action, and pressing ENTER,
   we create space for the new action.  Filling in the resulting blanks, we
   we arrive at the following display:

           E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
           E█A                                                   A  E█
           E█A  E───────────────────────────G  Action    E──────────A  E█
           E█A  G  Editing Actions for 'txt' Class         FªHDelpG  A  E█
           E█A  E│B                                               E│A  E█
           E█A  E│B EBrief NameB     EYour DescriptionB               E│A  E█
           E█A  E│B  IDescriptB     IASCII Text File               B  E│A  E█
           E█A  E│B  IWord-cntB     IDisplay word count on screenYI  B  E│A  E█
           E█A  E│B                                               E│A  E█
           E█A                                                   A  E█
           E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   Now, with the cursor still on the "word count" line, we can edit the
   underlying CprocedureB by selecting F EDdit B again, or by simply pressing the
   left mouse button.  The result is the invocation of the text editor on
   an initially empty procedure definition:

     E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
     E█A                                                               A  E█
     E█A  E┌──────────────────────────────────────────────G  Action    E──A  E█
     E█A  E│B                   G  Editing Actions for 'txt' Class        A  E█
     E█A  G  Editing Definition of "Word-cnt"                FªSDearch/FªNDeA  E█
     E█A  E│YB                                                            A  E█
     E█A  E│B                                                            A  E█
     E█A  E│B                                                            A  E█
     E█A  E│B                                                            A  E█
     E█A  E│B                                                            A  E█
     E█A                                                               A  E█
     E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   Now all that's necessary is to enter the procedure.  For this simple
   example, an appropriate procedure definition is:

     E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
     E█A                                                               A  E█
     E█A  E┌──────────────────────────────────────────────G  Action    E──A  E█
     E█A  E│B                   G  Editing Actions for 'txt' Class        A  E█
     E█A  G  Editing Definition of "Word-cnt"                FªSDearch/FªNDeA  E█
     E█A  E│Bwc %f                                                       A  E█
     E█A  E│B!pauseYB                                                      A  E█
     E█A  E│B                                                            A  E█
     E█A  E│B                                                            A  E█
     E█A  E│B                                                            A  E█
     E█A                                                               A  E█
     E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   The first line of this procedure is an ordinary MS-DOS command, except
   that the characters "%f" will be replaced by the filename of the selected
   object.  The second line is an internal "!pause" command to allow us to
   view the result before returning to the InContext main display.  These
   commands are discussed in more detail in the help information for the
 ZmcaelB  CJ InContext Procedure Language CB.
mcaem
 Help information about: Action Editing: Macro Action Definitions

 
              E╔════════════════════════════════════════════════╗
              E║            CMacro Action DefinitionsE            ║
              E╚════════════════════════════════════════════════╝


   CMacrosB are really a very simple idea, but they can greatly increase the
   power of even a simple programming language.  Basically, a macro consists
   of a name and a definition.  Whenever the name appears in a procedure, the
   entire definition of the macro is substituted for the name.  This allows
   a rather complicated set of commands to be written once, stored in one
   place, and used as needed, perhaps in many procedures.  Since the set of
   commands exists only in one place, changing it will cause all of the using
   procedures to change in the same way.

   For example, it is likely that you will have many object classes whose
   underlying file is an ordinary text file, editable by an ordinary text
   editor.  By defining the macro "editText", and putting in the definition
   whatever it takes to set up and run your text editor the way you like,
   you can allow each of the classes to behave in exactly the same way, even
   if you later change editors or choose to invoke your editor differently.

   To do this, you would cause the action list of each of the text classes
   to have an "edit" action whose definition is simply an invocation of the
   macro:
        #editText

   To define the macro, you would select the F ADction B display, and
   select the F ªEDdit B command from that display's command bar.  The following
   menu would result.

    E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
    E█A                                                                 A  E█
    E█A  G  Which action set do you want to edit?                        A  E█
    E█A  E│ CABction definition for this class                           E │A  E█
    E█A  E│ CCBommon actions applicable to all classes                   E │A  E█
    E█A  E│ CGBrouped-object actions applicable to whole views or classesE │A  E█
    E█A  E│ CMYBacro action definitions useable in all of the above       E │A  E█
    E█A  E└─────────────────────────────────────────────────────────────┘A  E█
    E█A                                                                 A  E█
    E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   Selecting "CMacro action definitionsB" here produces an "action list" that
   actually serves only to hold the macros.

           E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
           E█A                                                   A  E█
           E█A  E───────────────────────────G  Action    E──────────A  E█
           E█A  G  Editing Action Definition Macros        FªHDelpG  A  E█
           E█A  E│B                                               E│A  E█
           E█A  E│B EBrief NameB     EYour DescriptionB               E│A  E█
           E█A  E│B  IDescriptB     IAction Macros                 B  E│A  E█
           E█A  E│B  IeditTextB     IEdit text fileYI                B  E│A  E█
           E█A  E│B  IprintTxtB     IPrint text file               B  E│A  E█
           E█A  E│B  IrunProg B     IExecute program               B  E│A  E█
           E█A  E│B  IviewTextB     IView text file                B  E│A  E█
           E█A  E│B                                               E│A  E█
           E█A                                                   A  E█
           E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   By placing an entry here called "editText", we create a macro that will
   be executed any time the "edit" action is selected for one of the text
   classes.  An example of a possible definition for this macro, using the
   BRIEF editor with a mouse menu driver, is shown below.  The actual
   definition of this macro will depend on what program you use for editing
   ordinary text files.  If you have no text editor, you may want to use the
   InContext internal editor.  To do so, simply replace the entire macro
   definition with the single line "!edit %f".

           E▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
           E█A                                                   A  E█
           E█A  E───────────────────────────G  Action    E──────────A  E█
           E█A  G  Editing Action Definition Macros        FªHDelpG  A  E█
           E█A  E│B                                               E│A  E█
           E█A  E│B EBrief NameB     EYour DescriptionB               E│A  E█
           E█A  E│B  IDescriptB     IAction Macros                 B  E│A  E█
           E█A  E│B  IeditTextB     IEdit text fileYI                B  E│A  E█
           E█A  E│B  IprintTxtB     IPrint text file               B  E│A  E█
           E█A  E│B  IrunProg B     IExecute program               B  E│A  E█
           E█A  E│B  IviewTextB     IView text file                B  E│A  E█
           E█A  E│B                                               E│A  E█
           E█A                                                   A  E█
           E▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

   At present, macros may not be nested.  That is, a macro may not itself
   invoke another macro.


 CSpecial InContext Macros

   Several special macros are used to control particular behaviors of
   InContext:

        C  incEditB    The InContext internal editor is intended for
                      handling only fairly small files, but it is relatively
                      fast for small files.  If you wish to substitute your
                      own preferred editor altogether, you should change the
                      "editText" macro.  If you would like to substitute your
                      own editor only for files over a certain size, however,
                      you can define this macro to invoke your preferred
                      editor.  This macro will be used only for editing a
                      file that exceeds either available memory or the
                      upper size limit defined in your configuration options.

        C  incPrintB   This macro can be used to specify a print
                      procedure for use when you select the F PDrint B
                      command.  In the absence of such a macro, printing
                      is done by writing directly to the "prn:" standard
                      printer output.  An example of such a procedure is
                      the following, which substitutes the 4PRINT laser
                      printer program:
                           downld c:\fonts\lp085r16.usl 2
                           4print %f -q -tab3 -h"%D  page $cn//%D  page $cn"

        C  incStartB   If this macro is present, it is executed during
                      InContext initialization.  This allows you to cause
                      the program to start out in the state you prefer.
                      A common example would define the following procedure
                      for incStart:
                           !keyStuff "\@T"
                      If this is done, InContext will automatically start
                      out with today's tasks in the Work-in-Progress list.
                      This is equivalent to your typing Alt-T, for the
                      "Today" command.  Without this startup macro, InContext
                      will start out with the same tasks active as at the end
                      of the last session.

        C  incViewB    This macro can be used to over-ride the use of
                      the InContext internal viewer for certain purposes,
                      such as viewing files in an LHARC archive.  For
                      example, to substitute Vern Buerg's LIST viewer for
                      the InContext internal viewer, define an "incView"
                      macro with the procedure
                           list %f


 COther Macros You May Want to Change

   These macros do not affect InContext in any special way, but they are
   used by some of the class definitions distributed with InContext:

        C  editTextB   In the action lists distributed with InContext,
                      this macro is used for all single-file editing
                      operations.  You can substitute your own editor for
                      the InContext internal editor by redefining this
                      macro.
 
        C  printTxtB   In the action lists distributed with InContext,
                      this macro is used for all ASCII-file printing
                      operations.  You can substitute your own print
                      program by redefining this macro.

        C  viewTextB   In the action lists distributed with InContext,
                      this macro is used for all single-file viewing
                      operations.  You can substitute your own viewer for
                      the InContext internal viewer by redefining this
                      macro.  This will not affect calendar viewing (which
                      must use the internal viewer), or viewing of files
                      inside an LHARC archive (see "incView", above).
