home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d7xx / d768 / uedit.lha / Uedit / Errata < prev    next >
Text File  |  1992-11-22  |  64KB  |  1,605 lines
  1.        ++++++++++++++++++++Uedit V3.0 Manual ERRATA++++++++++++++++++++
  2.  
  3. (((NOTE:  See Miscellaneous below:  Scratch buffers are buf50-59, and the
  4. scratch numbers are n0-n19.  Dedicated numbers were moved to n20-n30.)))
  5.  
  6.                              +++++Commands+++++
  7.  
  8. MANUAL UPDATE:  The normal-Esc command (set PM terminator) was modified as
  9. follows:  If atCursor==locB, it lets you set the PM terminator character as
  10. always.  If atCursor!=locB, it moves the cursor to locB.  locB is the
  11. location marking the last scratch delete(s); this is handy because you can
  12. move the cursor somewhere and long as you don't do a scratch delete there you
  13. can return quickly to your former position.
  14.  
  15. MANUAL UPDATE:  A new shftAlt-f Set Font command was created and added to the
  16. Display menu.
  17.  
  18. MANUAL UPDATE:  The bookmark commmands were modified so that they
  19. accept function keys F1-F8 as well as mouse-clicks.
  20.  
  21. MANUAL UPDATE:  A new apropos R-5 command was provided (written originally by
  22. Tony Sumrall).  It allows you to do an instant search that lists and
  23. describes all commands that pertain to "scroll", for instance, or "cursor",
  24. "undo", or "copy".  The apropos command uses a Help-Key file which is created
  25. from the Key-Help file by the MakeHelpKey program that is provided.  The
  26. source MakeHelpKey.c is also provided.
  27.  
  28. MANUAL UPDATE:  A new match-braces R-4 command was provided (originally by
  29. Tom Zartler).  It matches parens or curly braces.
  30.  
  31. MANUAL UPDATE:  An in-use command R-1 was provided (originally by Kurt
  32. Wessels).  It makes a table showing which keys are in use (a cmd is assigned
  33. to them) and which are available.  This is useful in deciding to which keys
  34. you would like to assign new commands in your config.
  35.  
  36. MANUAL UPDATE:  A new R-6 command swaps current file with next file.
  37.  
  38. MANUAL UPDATE:  A fake scroll gadget mouse command was created which uses the
  39. middle mouse button.  It draws and uses a scroll gadget in the msg line.
  40.  
  41. MANUAL UPDATE:  SC-f1 Restore Current File cmd was improved.  It restores the
  42. page, cursor, hilite, and invert locations.
  43.  
  44. MANUAL UPDATE:  The f7 and shft-f7 cmds can do an incremental search.
  45. Searching begins the instant you type an input and acts upon each new input.
  46. It auto-switches to case-sensitivity when you type a capital letter.  The up/
  47. down arrow keys cause it to switch to searching backward or forward.
  48.  
  49. MANUAL UPDATE:  An R-7 compare-buffers command put into the Buffers menu.  It
  50. compares curFile with buffer 41 from the cursor forward.  Use ctl-w to swap one
  51. of the buffers into the buf41 slot.  When disagreement is found, it puts the
  52. start-of-page of both buffers at the start of the cursor line and flash-
  53. displays the buffers alternately 2 times.  Note that when a disagreement is
  54. found and you wish to continue comparing the buffers, put each buffer's cursor
  55. at the beginning of text that is in agreement and resume the comparison.
  56.  
  57. MANUAL UPDATE:  Fold commands were added:  Set Fold (L-\), Fold (R-\), Goto
  58. Source (A-\).  Fold (R-\) includes line numbers optionally.  Goto Source
  59. takes you back to the source of any line in the fold-file.  (See Folds.)
  60.  
  61. MANUAL UPDATE:  Added a new Last Search (C-f9) key & menu item.  It lets you
  62. select from up to 10 previously used search strings.  If search strings
  63. aren't being stacked, it lets you turn on stacking for it.
  64.  
  65.                                       1 MANUAL UPDATE:  MOUSE-BUTTON COMMANDS:
  66.  
  67.     These have been modified as follows:
  68.         1)  scroll-hiliting, if you double-click the mouse button & move mouse.
  69.             (This cmd was originally written by Ken Perano.)
  70.         2)  auto-padding of lines with spaces if you click the mouse button
  71.             beyond end-of-line when the COLUMNAR FLAG is ON.
  72.  
  73.     normal-buttonDown:  This still deposits the cursor at the mouse as
  74.         always, and it scrolls the display up/down if you move the mouse
  75.         while holding down the button.  But if instead you double-click the
  76.         mouse-button while holding the mouse stationary and THEN move the
  77.         mouse while holding down the button, it marks a hilite region.  It
  78.         scrolls the display up/down, if you move the mouse to the bottom or
  79.         top of the window.
  80.  
  81.     shftAltCtl-buttonDown:  This command deposits the cursor at the mouse
  82.         arrow, but if you clicked beyond end-of-line it extends the line by
  83.         padding with spaces up to the mouse arrow.  This is useful when you
  84.         want to type text some distance to the right beyond the current end
  85.         of line.
  86.  
  87.     The following commands still set start/end of hilite or invert region as
  88.     before.  But in addition if the COLUMNAR flag is ON, they now pad with
  89.     spaces beyond end of line:
  90.  
  91.     shft-buttonDown:  Set start of hilite region at the mouse.  If COLUMNAR
  92.         flag is ON, pad beyond end of line with spaces, if mouse was clicked
  93.         to right of end of line.
  94.  
  95.     alt-buttonDown:  Set end of hilite region at the mouse.  If COLUMNAR flag
  96.         is ON, pad beyond end of line with spaces, if mouse was clicked to
  97.         right of end of line.
  98.  
  99.     shftCtl-buttonDown:  Set start of invert region at the mouse.  If
  100.         COLUMNAR flag is ON, pad beyond end of line with spaces, if mouse was
  101.         clicked to right of end of line.
  102.  
  103.     altCtl-buttonDown:  Set end of invert region at the mouse.  If COLUMNAR
  104.         flag is ON, pad beyond end of line with spaces, if mouse was clicked
  105.         to right of end of line.
  106.  
  107. MANUAL UPDATE:  userGlobalD is used as a flag to select incremental searching
  108. using a new SA-f7 cmd.  The SA-f7 cmd is also in the Settings menu.
  109.  
  110. MANUAL UPDATE:  New R-8 Save Key and R-9 Restore Key commands were created
  111. and added to the Keys menu.  When you want to create a command on a key (such
  112. as ESC) which already has a command on it, you can save the key temporarily
  113. and restore it when you are through using the temporary command.
  114.  
  115. MANUAL UPDATE:  A new friendly ctl-g Global Modes command was created and put
  116. into the menu.  It lets you set all of the global flag variables as well as
  117. the local ones which are inherited by new buffers.  Local flags already
  118. attached to buffers are not affected.  (Local buffer flags can be changed by
  119. clicking the appropriate letter in the title bar.  The new shft-f5 command
  120. presents help, if you need it.)
  121.  
  122.                                       2 MANUAL UPDATE:  A new R-0 Date-Time-Stamp command inserts a date-time stamp
  123. at the cursor.
  124.  
  125. MANUAL UPDATE:  A new ctl-gadget2 List Files cmd (submitted by Bob Jenkins)
  126. lists all files in Uedit and lets you click the file you want to see.
  127.  
  128. MANUAL UPDATE:  Two stack oriented commands were created, which allow you to
  129. keep and use up to 10 Search strings, Replace strings, Undo buffers, copied
  130. Columnar regions, or copied Hilite and Invert regions.  R-2 shows you how
  131. many buffers are on the stacks, how many bytes of memory are used, and lets
  132. you turn on/off stacking for each kind of buffer.  History (R-3) let you see
  133. the contents of buffers on the stacks, make them the current buffer (such as
  134. current search or replace string), delete individual buffers, or delete the
  135. whole stack.
  136.  
  137. MANUAL UPDATE:  A new alt-ESC Tune RGB command was written which uses the
  138. arrow keys to tune the colors.  The new alt-esc cmd is friendlier than the
  139. old one was.  You can restore the original colors before quitting, if you
  140. wish.  Also new L-esc, R-esc, and virtual-esc cmds were created, and an RGB
  141. Colors submenu was created.  The new cmds let you select from 3 sets of RGB
  142. colors.  Note that these keys can only be activated from the menu.
  143.  
  144. MANUAL UPDATE:  The alt-help command to toggle curFile's colors has been
  145. rewritten.  A new version allows you to set the color usage in a more
  146. friendly and thorough manner.
  147.  
  148. MANUAL UPDATE:  The hyper text commands and their keys and menu entry were
  149. changed considerably:
  150.  
  151.     1.  The Open HT (R-gadget3) and Close HT (R-gadget4) commands were
  152.     dropped.  The manual's discussion of these is now obsolete.  The Hyper
  153.     Text submenu was dropped.  Only the entry for Hyper Text (R-gadget1) is
  154.     now in the menu.
  155.  
  156.     2.  Hyper Text is now opened by R-clicking a word or by R-clicking
  157.     gadget1 (which solicits a word input).
  158.  
  159.     3.  Config!H's hyper text commands were modified extensively to make
  160.     hyper text friendlier and nicer.  Virtual keys are no longer used.
  161.     ("Unused" macronum slots are used instead.)
  162.  
  163.     4.  The hyper text commands now expect you to have the following
  164.     directory structure:
  165.         S:Hyper/Files/HyperSample
  166.         S:Hyper/Tables/HyperSample.tbl
  167.  
  168.     You can easily edit the DEFINE() near the top of Config!H to use U:
  169.     instead of S:.  Also you can have any number of hyper text files and
  170.     tables in the S:Hyper subdirectory.
  171.  
  172. MANUAL UPDATE:  A new Screen Size lAmiga-f2 was added to the Display menu.
  173. It asks for the new width & height dimensions and reopens the screen using
  174. the new dimensions.  NOTE:  The CL sWidth and sHeight variables don't change
  175. when you go to/from interlace; in interlace, the actual screen height is
  176. 2*sHeight.
  177.  
  178.  
  179.                                       3                           +++++Primitive Mode+++++
  180.  
  181. MANUAL UPDATE:  The discussion of Primitive Mode in the manual should be
  182. corrected as follows:
  183.  
  184. When in primitive mode, the title bar now says "ENTER" or "ESC" or "CTL-?"
  185. where '?' is any ctrl-character (a-z) used for pmEsc.  The present manual,
  186. now incorrectly, states that the title bar is one of the following:
  187.     "Primitive Mode string input (pmESC = done)"
  188.     "Primitive Mode number input (pmESC = done)"
  189.  
  190. The manual should be corrected to say that the title bar is one of the
  191. following:
  192.     "Primitive Mode string input (ENTER = done)"
  193.     "Primitive Mode string input (ESC   = done)"
  194.     "Primitive Mode string input (CTL-w = done)"  ('w' is any letter a-z)
  195.  
  196. This applies for both "string" and "number" primitive mode inputs.
  197.  
  198. MANUAL UPDATE:  A new lAmiga-q command and Files menu entry switches to the
  199. next file marked "Favorite".
  200.  
  201. MANUAL UPDATE:  A new shftAltCtl-z command loads files based on a filename-
  202. wildcard (*?) mask.  SAC-z is called in the startup cmd when Uedit first
  203. starts.
  204.  
  205. So if you run in CLI by typing "Run UE util*.?", the SAC-z command causes all
  206. files matching the mask "util*.?" to be auto-loaded.  During an edit session,
  207. you can press SAC-z to auto-load files using a wildcard mask also.
  208.  
  209. MANUAL UPDATE:  A new alt-f9 command does all-file (global) searches for the
  210. current search string.  It searches starting at the cursor in curFile and if
  211. not found in curFile it continues to the next file, and so on.  If it gets
  212. back to curFile without succeeding in the search, a False is returned.
  213.  
  214. A new ctl-f10 cmd does a replace of the current inverted "found" region and
  215. continues the all-file search forward as described above.  A new shftAlt-f10
  216. command does a total search-replace in ALL file buffers, starting at the
  217. cursor in curFile, continuing the all-file search & replace until curFile is
  218. returned to once again.
  219.  
  220. The all-file search and replace cmds were added to the Search & Replace menus.
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.                                       4                            +++++Miscellaneous+++++
  237.  
  238. MANUAL UPDATE:  The following buffer and number assignments supercede the
  239. ones elsewhere and in the manual:
  240.  
  241. (NOTE:  The max files setting can be as high as 36 without touching any
  242. buffers that are in use.)
  243.  
  244. buf65-99 = available for user commands
  245.     (the buf99 buffer stack is used for scratch stacking, but the variable
  246.     buf99 is not in use anywhere)
  247. buf50-59 = used for temporary purposes in commands
  248.  
  249. buf36 = holds REXXCOMM File for Rexx interface
  250. buf37 = copied columnar data
  251. buf38 = directory names
  252. buf39 = used for result of AmigaDOS commands (if result selected)
  253. buf40 = used for AmigaDOS commands
  254. buf41 = used in buffer swapping command, ctl-w
  255. buf42 = holds Help, if loaded
  256. buf43 = document names
  257. buf44 = make-command buffer
  258. buf45 = holds scratch deletes for Undo, keypad-0
  259. buf46 = copied invert
  260. buf47 = copied hilite
  261. buf48 = replace string
  262. buf49 = search or grep string
  263. buf60 = names of bookmarks (see Config!H) (n94 stores bookmark #)
  264. buf61 = Rexx msg/reply input buffer
  265. buf62 = Rexx msg/reply output buffer
  266. buf63 = hyper text filename
  267. buf64 = hyper text tablename
  268.  
  269. Number variable usage in the config files is as follows:
  270.  
  271. n31-n99 = available for use commands
  272.     (the n99 number stack is used for scratch stacking, but the variable n99
  273.     is not in use anywhere)
  274. n0-n19 = scratch variables, used everywhere for temporary purposes
  275.  
  276. n20 = delay time
  277. n21 = arithmetic total
  278. n22 = #cycles in cycle counter
  279. n23 = macroNum to be run in cycle counter
  280. n24 = split window size for hyper text
  281. n25 = hyper word index value
  282. n26 = used by rexx
  283. n27 = action/result
  284. n28 = rexx flag
  285. n29 = rexx return code
  286. n30 = bookmark number
  287.  
  288. MANUAL UPDATE:  Clicking to go to tiny window can now be included in learned
  289. sequences.  Also you can go to tiny window during startup compiles.
  290.  
  291.  
  292.  
  293.                                       5 MANUAL UPDATE:  When the screen is reopened after being in tiny window its
  294. vertical coordinate is the same as before.  I.e., you can slide the screen
  295. down, go to tiny window or switch to another screen type and the reopened
  296. screen keeps the original coordinates.  To reset the screen's coords to
  297. (0,0), move the tiny window before clicking in it.
  298.  
  299. MANUAL UPDATE:  There are only 3 Uedit programs now, UE, UES, and UEP.  UE
  300. contains the spell checking functions as well as the getAddress(), peek(),
  301. and poke() functions which used to be in UEK.  UES is identical to UE now,
  302. except it has a 4-file limit.  UEP is identical to UE except it has pixel-
  303. oriented word-wrapping.
  304.  
  305. MANUAL UPDATE:  Used to be Uedit wouldn't let you quit if a window rested on
  306. top of its screen.  Somebody presented an argument in favor of letting it
  307. quit regardless, so now it will.
  308.  
  309. MANUAL UPDATE:  The title bar now has a row of status flags = "tiokrwjmcabf".
  310. These correspond to all of the local buffer flag settings.  If the letter is
  311. capitalized, the flag is ON.  The flags can be toggled ON/OFF by clicking the
  312. appropriate letters in the title bar.  The flags are as follows:
  313.  
  314. t/T = trueTabs
  315. i/I = autoIndent
  316. o/O = Overstrike
  317. k/K = autobacKup
  318. r/R = Readonly
  319. w/W = wordWrap
  320. j/J = rightJustify
  321. m/M = Mapchars (map illegal characters)
  322. c/C = Changed
  323. a/A = userglobalA (in the std config this denotes Save On Idle)
  324. b/B = userglobalB
  325. f/F = Favorite
  326.  
  327. MANUAL UPDATE:  A new shft-f5 Local Modes command (in the menu) displays the
  328. description of the title bar local flags.
  329.  
  330. MANUAL UPDATE:  The LOCAL & GLOBAL flags were taken out of Show Vals.  All
  331. local and global flags commands and were eliminated and removed from the
  332. menus.
  333.  
  334. MANUAL UPDATE:  If you click the "X" in the title bar while in primitive
  335. mode, it switches the pmEsc character from "ESC" to "ENTER" or vice versa.
  336.  
  337. MANUAL UPDATE:  The CB (buffer header) structure has been changed, and the
  338. new CB structure is as follows; the new fields are marked:
  339.  
  340.  
  341.  
  342.  
  343.  
  344.  
  345.  
  346.  
  347.  
  348.  
  349.  
  350.                                       6 struct CB {
  351.     struct DB  *Block;
  352.     struct DB  *SHBlock;
  353.     struct DB  *EHBlock;
  354.     struct DB  *SIBlock;
  355.     struct DB  *EIBlock;
  356.     struct DB  *PBlock;
  357.     struct DB  *EBlock;
  358.     struct DB  *LABlock;
  359.     struct DB  *LBBlock;
  360.     struct DB  *LCBlock;
  361.     struct DB  *LDBlock;
  362.     struct DB  *LEBlock;
  363.     struct DB  *LFBlock;
  364.     struct DB  *LGBlock;
  365.     struct DB  *LHBlock;
  366.     struct DB  *LIBlock;
  367.     struct DB  *LJBlock;
  368.     struct DB  *LSPBlock;
  369.     struct DB  *LSCBlock;
  370.     struct DB  *MBlock;
  371.     UCHAR *Ptr;
  372.     UCHAR *SHPtr;
  373.     UCHAR *EHPtr;
  374.     UCHAR *SIPtr;
  375.     UCHAR *EIPtr;
  376.     UCHAR *PPtr;
  377.     UCHAR *EPtr;
  378.     UCHAR *LAPtr;
  379.     UCHAR *LBPtr;
  380.     UCHAR *LCPtr;
  381.     UCHAR *LDPtr;
  382.     UCHAR *LEPtr;
  383.     UCHAR *LFPtr;
  384.     UCHAR *LGPtr;
  385.     UCHAR *LHPtr;
  386.     UCHAR *LIPtr;
  387.     UCHAR *LJPtr;
  388.     UCHAR *LSPPtr;
  389.     UCHAR *LSCPtr;
  390.     UCHAR *MPtr;
  391.     
  392.     struct    DB    *NextBlock;
  393.     short  PageCol;
  394.     short  BufNum;
  395.     ULONG  Flags; /* used to be USHORT */
  396.     USHORT LineLength;
  397.     USHORT PageLines;
  398.     short  tabTable;
  399.     short  LeftMargin;
  400.     short  TopMargin;
  401.     short  BottomMargin;
  402.     ULONG  colors; /* used to be USHORT */
  403.     long   reserved1; /* new fields */
  404.     long   reserved2;
  405.     UCHAR  FileName[NAMELEN+3]; /* bumped upward */
  406. };
  407.  
  408.  
  409.  
  410.  
  411.  
  412.  
  413.  
  414.  
  415.  
  416.  
  417.  
  418.  
  419.  
  420.  
  421.  
  422.  
  423.  
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434.  
  435.  
  436.  
  437.  
  438.  
  439.  
  440.  
  441.  
  442.  
  443.  
  444.  
  445.  
  446.  
  447.  
  448.  
  449.  
  450.  
  451.  
  452.  
  453.  
  454.  
  455.  
  456.  
  457.  
  458.  
  459.  
  460.  
  461.  
  462.  
  463.  
  464.  
  465.                                       8                          +++++Config! defaults+++++
  466.  
  467. MANUAL UPDATE:  The following table appears in the Config! defaults in place
  468. of the old (<3> <1> <0> <2>) color defaults:
  469.  
  470.     Colors:  (values must be 0-3, corresponding to RGB color #s)
  471.                                fg       bg
  472.     0  normal text             <1>     <0>
  473.     1  cursor                   <1>     <2>
  474.     2  hilite                   <1>     <3>
  475.     3  cursor+hilite           <3>     <1>
  476.     4  inverse                 <0>     <1>
  477.     5  cursor+inverse           <2>     <3>
  478.     6  hilite+inverse           <3>     <1>
  479.     7  cursor+hilite+inverse   <0>     <3>
  480.     ((screen colors))
  481.     8  title bar               <1>     <3>
  482.     9  msg line                <2>     <0>
  483.     10 menus                   <1>     <3>
  484.     11 tab ruler               <1>     <2>
  485.     12 requester               <1>     <2>
  486.     13 formfeed                <1>     <2>
  487.     14 spare1                   <0>     <1>
  488.     15 spare2                   <0>     <1>
  489.  
  490. MANUAL UPDATE:  A new SHIFT+ALT keys array was added to the Config! defaults
  491. just beneath the ALT keys array.  Like the ALT keys array, it too can be used
  492. for foreign letters or other special characters.
  493.  
  494.                           +++++Command Language+++++
  495.  
  496. MANUAL UPDATE:  Startup Key and Menus (2.16) in the manual is now incorrect
  497. and should be updated as follows:
  498.  
  499.     The first time the startup cmd is run (when Uedit first starts up), EVERY
  500.     fct in startup is run.
  501.  
  502.     After that if startup is run (such as to rebuild the menus after changing
  503.     fonts), any runKey() fcts in the startup cmd are NOT run.  All other fcts
  504.     in startup are run, however.
  505.  
  506.     Thus if there's anything in the startup cmd that you want to run ONLY
  507.     when Uedit is starting up, put it into a separate routine and call it
  508.     with runKey() in the startup cmd.
  509.  
  510. MANUAL UPDATE:  The swapChar() discussion in manual Part3 should state that
  511. swapChar() does NOT advance cursor.
  512.  
  513. MANUAL UPDATE:  The discussion in manual Part 3 should be changed to reflect
  514. the fact that Compile() and CompileDefaults() now have a buffer argument.
  515.  
  516. You can now compile a command in ANY buffer now, not just in curFile.  You
  517. can also compile the config defaults in any buffer.  Modify your Config! and
  518. Config!M files to make the following change:
  519.     old:    compile & compileDefaults
  520.     new:    compile(curFile) & compileDefaults(curFile)
  521.  
  522.                                       9 MANUAL UPDATE:  A new getFont(name=list2,X=list10,Y=list10) CL function was
  523. created.
  524.  
  525. MANUAL UPDATE:  A new capsLock variable was added to list 10 and list 14 of
  526. the CL.  It is TRUE when CAPSLOCK is in effect on the keyboard.  The capsLock
  527. flag was added to the Show Vals list.
  528.  
  529. MANUAL UPDATE:  A fullRefresh CL function was created.  When a command writes
  530. all over the window with the text() function, it needs to cause a full
  531. refresh when it is finished.  refreshDisplay merely refreshes the currently
  532. active split window.  fullRefresh refreshes all split windows.
  533.  
  534. MANUAL UPDATE:  A new internal flag prevents the right mouse button from
  535. clearing the msg line after the text() and draw() functions have been used.
  536.  
  537. MANUAL UPDATE:  setFileName() now sets the CHANGED flag of the buffer.
  538.  
  539. MANUAL UPDATE:  gosub label(nn) was added to the CL.  It acts like a goto
  540. label(nn), except that when you do a goto it does not do a return.  With
  541. gosub, control resumes at the next statement after the gosub, when the
  542. subroutine returns.  Subroutines are normally put at the end of the command
  543. they are in.  Up to 100 subroutines are allowed (as many as there can be
  544. labels).  You can use a subroutine anytime the routine does not need to be
  545. callable from other commands.  Thus you need not use up virtual keys for such
  546. routines.
  547.  
  548. Example:  <normal-esc:
  549.     gosub label(50)
  550.     .. more stuff here
  551.     if (gosub label(50)) putMsg("TRUE")
  552.     else putMsg("false")
  553.     return  .. NEED A RETURN HERE unless you want control to fall into
  554.             .. the code below.
  555.  
  556.     label(50) .. subroutine, just a demo
  557.     alertUser("SUBROUTINE")
  558.     return  .. don't need this, return happens anyway at end of command
  559.     >
  560.  
  561. MANUAL UPDATE:  New compareBuf(buf1=list2,buf2=list2) CL function that
  562. compares two buffers starting from the cursor forward.  It stops and leaves
  563. the cursor at the first spot where the buffers disagree.  It sets sPage at
  564. the start of the cursor line in each buffer.  It returns FALSE when
  565. disagreement is found.  It returns TRUE when EOFILE is reached in both
  566. buffers simultaneously.
  567.  
  568. MANUAL UPDATE:  A new clickTime variable was added to list 10.  It contains
  569. the time (in hundredths of a second) since the last mouse-click.  The
  570. following tests for a mouse double-click by testing to see if the mouse was
  571. in the same spot for both clicks and the time between clicks was 0.40 sec or
  572. less:  if (eqLoc(curFile,atCursor,mouseLoc) & geNum(40,clickTime) ) ...etc
  573.  
  574. MANUAL UPDATE:  New userGlobalC and userGlobalD variables were added to the
  575. CL in lists 10 & 14.  These can be used for any purpose just like userGlobalA
  576. & userGlobalB.
  577.  
  578.  
  579.                                       10 MANUAL UPDATE:  The CL functions menu(), subMenu(), checkedMenu(), and
  580. checkedSubMenu() now have an added argument (which follows the first arg).
  581. It is ALTERNATE TEXT for the menu item when it is hilited.  If there is to be
  582. no alternate text, use "" for the argument.  The other menu function args are
  583. as before, except that the 2nd became the 3rd arg, the 3rd became the 4th,
  584. and so on.
  585.  
  586.     CONVERSION NOTE:  To convert your STARTUP command for the alternate menu
  587.     text, in the startup command
  588.           search for:  ",
  589.     replace with:  ","",
  590.  
  591. MANUAL UPDATE:  The maximum compiled command size was increased to 20480
  592. bytes, in order to accommodate the new alternate text argument in the menu()
  593. functions in the startup cmd.
  594.  
  595. MANUAL UPDATE:  A new clearBuf(buffer=list 2) CL function was created.  Its
  596. purpose is to improve performance.  FreeBuf() requires freeing the buffer and
  597. then it is reallocated later on when needed.  ClearRgn(buffer,all) is slow
  598. when the whole buffer is cleared.  Use clearBuf() when the buffer must be
  599. cleared and is to be used again.  Replace occurrences of clearRgn(buf,all) or
  600. freeBuf(buf) with clearBuf(buf) when performance matters.  (Internally,
  601. clearRgn(buf,all) calls clearBuf(buf) because it is faster.)  NOTE, however,
  602. that there's a sound reason for freeing rather than merely clearing buffers,
  603. at least now and then:  Freeing and reallocating reduces memory fragmentation.
  604.  
  605. MANUAL UPDATE:  A new define() CL function enables you to use either local or
  606. global "defines" in commands.  For local defines, which apply only to the
  607. current command, the define() functions MUST BE AT THE START OF THE COMMAND.
  608. You can define "scratch_buffer" to mean "buf54", by using
  609. define(scratch_buffer,buf54), then you can use "scratch_buffer" instead of
  610. "buf54".
  611.  
  612. To create global defines, use define() functions in a <defines:  ...>
  613. command.  The defines command is allowed to contain only define() functions.
  614. Global defines are stored in memory until you quit Uedit or compile a new
  615. defines command.  Global defines can be used in any command.  For instance,
  616.         <defines: define(scratch_buffer,buf54)
  617.                   define(search_buffer, buf49) >
  618. makes "scratch_buffer" a global substitute for "buf54" and "search_buffer" a
  619. global substitute for "buf49".
  620.  
  621. Compiling a blank <defines: > command wipes the stored global defines from
  622. memory.  For example, you can put a defines command at the start of a config
  623. module and a blank <defines:  > command at the end of the module.  Then when
  624. UE compiles the config module during a startup compile, the global defines
  625. created at the beginning are used only in compiling that module and are wiped
  626. from memory after the module has been compiled.
  627.  
  628. Arguments in define(arg1,arg2):
  629.     arg1 must be a contiguous "word" which may contain upper or lower case
  630.     alpha characters or the "_" underscore.
  631.  
  632.     arg2 has no restrictions.  arg2 continues until the closing ")" right
  633.     paren is encountered.  Matching and nested parens are allowed inside
  634.     arg2, however, as are quotes, spaces, linefeeds, comments, and so on.
  635.  
  636.                                       11 NOTES:
  637. 1.  The global defines are not stored in data files.  The the <defines:  ...>
  638. command once compiled simply stores the definitions in memory and it stays
  639. there until you quit Uedit or compile an empty <defines:> command.
  640.  
  641. 2.  Local defines are kept only while the command that contains them is being
  642. compiled, then they are wiped from memory.
  643.  
  644. 3.  Defines, whether used or not, have no effect on the size or content of
  645. compiled commands.
  646.  
  647. 4.  You can redefine a CL word like "char" and the compiler won't complain.
  648. But it will not use the illegal redefinition.
  649.  
  650.  
  651.     Below are a <defines:...> command and a command with some define()
  652.     functions in it.  Compile these, block out or add define()s to them,
  653.     and use them to figure out how to use defines in the CL:
  654.  
  655.     <defines:    .. these are obviously global define()s.
  656.         define(junk,inputNum)
  657.         define(stuff,setMaxfiles)       .. testing
  658.         define(stuffa, putMsg)
  659.         define(junkkey, altCtl-f1)
  660.     >
  661.  
  662.     <junkkey:    .. uncomment the define()s below to use them as locals
  663.     ..    define(junk,inputNum)
  664.     ..    define(stuff, setMaxfiles)       .. testing
  665.     ..    define(stuffa,putMsg)
  666.         stuffa("Input max # documents allowed (1-100)")
  667.         if (junk(n54)) stuff(n54) >
  668.  
  669.     <junkkey:    .. check this out!  It really works! (if junkkey is defined)
  670.         define(everything, putmsg("testing")>)
  671.         everything
  672.  
  673.  
  674. MANUAL UPDATE:  An empty literal "" is now permitted in the CL.  To clear the
  675. message line putMsg(" ") used to be used.  This can still be used, but
  676. putMsg("") is better.
  677.  
  678. MANUAL UPDATE:  loadState() now compares the date of the state file (being
  679. loaded in) with the dates of the (disk copies of the) files in the state
  680. file.  If a file on disk is NEWER than its counterpart in Uedit (which came
  681. from the state file), it is marked READONLY in Uedit and a warning is given.
  682. READONLY status prevents the file from being modified or saved inadvertently.
  683. To overwrite the NEWER file on disk, you must first turn OFF the READONLY
  684. flag by clicking the "R" status flag in the title bar.  But in most cases you
  685. will want to select Files/Open/Restore to load in the NEWER version of the
  686. file, replacing the out-of-date copy in memory.  For convenience, the Load
  687. State command was modified to load in the newer files from disk for you, if
  688. you wish it to.
  689.  
  690.  
  691.  
  692.  
  693.                                       12 MANUAL UPDATE:  loadState() and saveState() now can be aborted.  In both
  694. cases, when Amiga-ESC is pressed the function quits after completing the read
  695. or write of the current buffer.  Thus the validity of the state file is
  696. preserved.
  697.  
  698. MANUAL UPDATE:  fileRequest(outbuf,intext,flags) now requires a THIRD
  699. argument, which is the Flags value that the Arp (or substitute) requester is
  700. to use.
  701.  
  702. MANUAL UPDATE:  A new stackBuf(bufnum=list 10,flag=list 10) CL fct was
  703. created.  It optionally saves work buffers on a stack, rather than freeing
  704. them.  stackBuf() applies only to WORK buffers.
  705.  
  706. If flag=N where N>0 & N<=32768, it causes the bufnum buffer to be stored on
  707. the bufnum buffer stack, saving rather than freeing it, when you attempt to
  708. free the buffer in some command.  Up to N buffers can be stored on the stack.
  709. Once the stack is holding N buffers, the oldest (first in) is removed before
  710. another buffer is saved on the stack.
  711.  
  712. If flag=0, the bufnum buffer is no longer saved on the stack automatically
  713. when it is freed.
  714.  
  715. If flag=-1, the bufnum buffer stack is cleared (all buffers on it are freed).
  716.  
  717. If flag=-2, the flag status is returned; if flag=0 is returned, it means that
  718. buffers aren't being saved on the bufnum stack; if flag=N where N>0, it means
  719. buffers are being saved and up to N may be saved on the stack.  NOTE: use
  720. getStackSize() in order to get the number of buffers actually present on the
  721. bufnum stack.
  722.  
  723. NOTE:  For any work buffer, buffer-saving may or may not be in effect.  You
  724. can find out its status by using flag=-2.  Suppose you wish to free buf45
  725. (FOR REAL).  You don't know whether buf45 is being saved on the stack or not.
  726. Use this procedure:
  727.     equateNum(n54,-2)                    .. use flag=-2 to find out the status
  728.     if (stackBuf(buf45,n54))            .. if buffer-saving is in effect
  729.         stackBuf(buf45,0)                .. turn off buffer-saving temporarily
  730.     freeBuf(buf45)    .. now you can free it FOR REAL, not saving it on stack
  731.     stackBuf(buf45,n54)                       .. restore buffer-saving status
  732.  
  733.  
  734. MANUAL UPDATE:  The do-loop do(...) now accepts the following arguments for
  735. the loop variables:  do (list 13, list 10, list 10)
  736.  
  737. EXAMPLE  1:
  738.     define(do_loop, do(n54,20,n88))
  739.     do_loop { putMsg("this is a test") }
  740.  
  741. EXAMPLE 2:
  742.     do (cmdMultiplier, "A", 128) putMsg("testing")
  743.  
  744.  
  745.  
  746.  
  747.  
  748.  
  749.  
  750.                                       13 MANUAL UPDATE:  A new list 13 was created which has the following elements:
  751.  
  752.     n# n[n#] pmEsc userGlobalA userGlobalB userGlobalC userGlobalD spooks
  753.     busies icons searchCaps wildCard eitherOr multiWild allBut singleWhite
  754.     multiWhite menuOffset cmdMultiplier speakAlerts speakMsgs printTabs
  755.     smartTabs customScreen useKeys prefPrint idleTime hideDisplay scrollType
  756.     trapMenus sWidth sHeight tinyPriority capsLock clickTime trueTabs
  757.     autoIndent overStrike rightJustify wordWrap mapChars userLocalA
  758.     userLocalB tabTable lineLength splitSize leftMargin topMargin
  759.     bottomMargin pageLines autoBackup inputChar macroNum
  760.  
  761. MANUAL UPDATE:  tabsToSpaces(list 2) and spacesToTabs(list 2) now require a
  762. buffer argument.
  763.  
  764. MANUAL UPDATE:  An onAbort cmd can now be defined.  Its macronum is 1149.  It
  765. acts as follows:
  766.  
  767. When an abort occurs, either after you press Amiga-ESC or due to another
  768. cause such as running out of memory or loading a data file, the normal abort
  769. cleanup-work is done and then, if an onAbort command exists, it is executed.
  770. An onAbort cmd may free scratch buffers, reset buffer flags, and so on.
  771. Example:
  772.     <onAbort:    freeBuf(buf54)   .. free this scratch buffer
  773.                 downFlag(curFile,overStrike)  .. turn off overstrike mode
  774.     >
  775.  
  776. MANUAL UPDATE:  An onTitle cmd can now be defined.  Its macronum is 1150.
  777. When an onTitle cmd exists, clicking the title bar executes onTitle instead
  778. of switching you to tiny window.  Example:
  779.     <onTitle:  toggle(toTiny)     .. can still goto tiny window as always
  780.                freeBuf(buf54)     .. free scratch buffer
  781.                .. do lots of other stuff, like save file changes etc
  782.     >
  783.  
  784. Rather than compiling onTitle each time you want to use it, it is convenient
  785. simply to swap it to some unused key slot such as macroNum 1199.  Example:
  786. <normal-esc: swapKey(onTitle,1199) >
  787.  
  788. If the macroNum 1199 cmd does not exist, pressing ESC would restore the
  789. normal click-for-tiny-window action.  Pressing ESC again would reinstate the
  790. onTitle cmd.
  791.  
  792. MANUAL UPDATE:  The range of valid macroNums was extended to 1199.  The
  793. macroNums which aren't attached to key combinations (i.e., which lie above
  794. 1144) which are currently in use are:
  795.         rexxMacro     1145
  796.         idleMacro     1146
  797.         preKeyMacro  1147
  798.         startupMacro 1148
  799.         onAbort      1149
  800.         onTitle      1150
  801.  
  802. Currently macroNums 1151-1199 are available.
  803.  
  804.  
  805.  
  806.  
  807.                                       14 MANUAL UPDATE:  There is a new getRGB(reg0, reg1, reg2, reg3) CL function
  808. which gets the current RGB color register values.  All arguments are in list
  809. 10.  The RGB color values are stored in each color register argument in the
  810. rightmost 12 bits, 4 bits to each color.  Example:  reg0 = 0xf48, where
  811. Red=15 (0xf), Green=4, and Blue=8.
  812.  
  813. MANUAL UPDATE:  The laceColor CL function has been eliminated.  Its
  814. discussion in the manual is obsolete.
  815.  
  816. MANUAL UPDATE:  getLocal() & setLocal() now handle the color argument
  817. differently:
  818.  
  819.     When the color argument is used:  The buffer's local colors are now in 8
  820.     sets of 4 bits.  Each 4 bits is 2 pairs of 2 bits, each with values 0-3
  821.     corresponding to the Fg and Bg colors, respectively.  The sets of 4 bits
  822.     correspond (from left to right) to normal, cursor, hilite, cursor+hilite,
  823.     invert, invert+cursor, hilite+invert, and cursor+hilite+invert.
  824.  
  825.     NOTE:  There is an internal local-color variable that is used to set the
  826.     colors of newly created buffers.  setLocal() and getLocal() do not touch
  827.     this variable.  To access this color variable, you must use getColors()
  828.     or setColors() using a literal " " as the first argument.
  829.  
  830. MANUAL UPDATE:  getWBColors() has been eliminated.
  831.  
  832. MANUAL UPDATE:  Two new color CL functions were created:
  833.  
  834.     getColors(buffer,color#,fg,bg)
  835.     setColors(buffer,color#,fg,bg)
  836.     buffer: list 2
  837.     color#, fg, bg: list 10
  838.  
  839.     If a buffer argument is used and the buffer exists, the local colors
  840.     accessed will be those of the buffer.  If a literal argument is used or
  841.     the buffer referenced does not exist, the internal global color variable
  842.     (which is applied to newly created buffers) is used.
  843.  
  844.     fg & bg must be in the range 0-3.
  845.  
  846.     color# must be in the range 0-15 or equal -1.
  847.         If color# is in the range 0-7, the local fg & bg colors corresponding
  848.         to color# are accessed.
  849.  
  850.         If color# is in the range 8-15, the global fg/bg colors corresponding
  851.         to color# are accessed and the first argument (buffer or literal) is
  852.         ignored.  (Only colors 0 to 7 apply to buffers.)
  853.  
  854.         The fg/bg color pairs are as shown in the color table in the Config!
  855.         defaults.
  856.  
  857.         If color# is -1, fg and bg are long word (32-bit) bitmasks containing
  858.         all of the local (buffer) and global (screen) colors, respectively:
  859.  
  860.             The bit masks for the 3rd argument (fg), which applies to local
  861.             colors, are as follows:  Each 4 bits is 2 pairs of 2 bits, each
  862.             with values 0-3 corresponding to the Fg and Bg colors,
  863.  
  864.                                       15             respectively.  The sets of 4 bits correspond (from left to right)
  865.             to normal, cursor, hilite, cursor+hilite, invert, invert+cursor,
  866.             hilite+invert, and cursor+hilite+invert.
  867.  
  868.             The bit masks for the 4th argument (bg), which applies to the
  869.             global (screen) colors, are as follows:  Again, each 4 bits is 2
  870.             pairs of 2 bits, each with values 0-3 corresponding to Fg and Bg
  871.             colors, respectively.  The sets of 4 bits correspond (from left
  872.             to right) to title bar, msg line, menus, tab ruler, requester,
  873.             formfeed, spare1, and spare2.
  874.  
  875.             (WARNING:  If color# is -1 with setColors(), no check is made of
  876.             the bitmasks in either the 3rd or 4th arguments.  It is possible
  877.             to send invalid colors which render text invisible.
  878.  
  879. MANUAL UPDATE:  TEXT() and DRAW():
  880. The color values used with your existing text() and draw() function calls can
  881. now have values ranging from 0 to 15.  Also you may wish to take advantage of
  882. the increased flexibility available with the new color handling.  Note that
  883. there are 2 spare colors in the color table in the config defaults; colors 14
  884. & 15 can also be used with text() and draw().
  885.  
  886. MANUAL UPDATE:  There is a new xor(result=list10, A=list10, B=list10) CL
  887. function which computes result = A xor B.  xor() returns FALSE, if the result
  888. is 0; otherwise it returns TRUE.
  889.  
  890. MANUAL UPDATE:  MENUWIDTH:  The max menuwidth value is 17 as before, however
  891. the menus are drawn without the space for the check-box at the left.  This
  892. makes them narrower and better looking.  But if a menu item is CHECKABLE, in
  893. the checkedMenu() or checkedSUBMenu() function you should start its text TWO
  894. SPACES to the right, leaving room for its checkmark.
  895.  
  896. MANUAL UPDATE:  FOLDS:  A folding feature has been added.  To fold a file
  897. means to "hide" detail, creating a sort of outline consisting only of the
  898. desired text lines, such as headings (in documents) or function names (in
  899. program modules).
  900.  
  901. Three new CL functions were created for folding.  setFold() sets up the
  902. testing steps that control folding.  getFold() examines the current steps.
  903. fold() carries out the folding:  It reads an input buffer and puts the text
  904. lines that pass folding tests into an output buffer.
  905.  
  906. The testing steps are numbered 1 to 16.  Each step that exists specifies a
  907. test number in the range 1 to 15.  The test number indicates which test
  908. fold() is to use.  (See setFold().)  Each testing step also specifies an X
  909. value (string or indent or line length) and an SKA value.  The test number
  910. determines whether X must be an integer or string.  SKA means SKIP/KEEP/AND -
  911. SKA is used only if the current test succeeds.  SKIP means to skip the line.
  912. KEEP means to keep the line.  AND means to AND the current testing step with
  913. the next one.
  914.  
  915. OR:  The testing steps are performed starting with step 1.  The serial order
  916. is like ORing the sequence of tests.  If SKA=0 or 1 and the current test
  917. succeeds, the line is skipped or kept according to the SKA value.  No other
  918. tests are tried on that particular line of text.  If the current test fails,
  919. the next testing step is tried.  This is OR behavior.
  920.  
  921.                                       16 AND:  If SKA=2, the current step is ANDed with the next testing step.  If the
  922. current test fails, the next step and all subsequent ones that were ANDed
  923. with the current step are bypassed.  If the current test succeeds, the next
  924. test is performed; and if it also succeeds, then its own SKA value dictates
  925. that action to be taken (skip or keep the line, or AND with the next step).
  926.  
  927. Order of tests:  The order in which the tests are performed is critical.
  928. When the folded file does not look as you had hoped, press rAmiga-\ and look
  929. at the current testing steps.  Try these questions:
  930.  
  931.     1) Should test X come AFTER test Y instead of before it?
  932.  
  933.     2) Is a test KEEPing lines before a later test has a chance to SKIP them?
  934.  
  935.     3) Should a test be redefined to KEEP instead of SKIP or vice versa?
  936.  
  937.     4) Does at least one test use KEEP?  (If not, no lines are kept.)
  938.  
  939.     5) Is the last test a SKIP or AND?  (If so, it achieves nothing.)
  940.  
  941. Folding currently cannot look for multi-line regions enclosed in 2-character
  942. brackets, such as the comment brackets of the C ("/*" and "*/") or Pascal
  943. programming languages.  However, using parens "//" will work in C program
  944. modules, if "/" is not used anywhere except in comment brackets.  (See tests
  945. 14 and 15 in setFold().)
  946.  
  947.  
  948. fold(toBuf,fromBuf,R)
  949. toBuf: list 0 (buffer or literal)
  950. fromBuf: list 2 (buffer)
  951. R: list 12 (region)
  952.  
  953. fold() folds region R of buffer fromBuf into buffer toBuf using the (up to
  954. 16) line folding tests defined earlier with setFold().  If toBuf already
  955. exists, it is erased before being used.  If tobuf is a literal (such as ""),
  956. a new file buffer is created.  fromBuf's tab table is used in interpreting
  957. TABs in it, and toBuf is assigned the same tab table.  The lines of text in
  958. fromBuf's region R which pass the tests set up with setFold() are copied into
  959. toBuf; if a line's length exceeds 130 columns, only the first 130 columns are
  960. copied.  fold() returns FALSE, if no folding tests have been defined with
  961. setFold() or if fromBuf or region R doesn't exist.  (See setFold().)
  962.  
  963.  
  964. getFold(T,F,X,B,SKA)
  965. T,F,SKA:  list 10 (integer)
  966. X: list 10 (integer variable or buffer)
  967. B: list 2 (buffer)
  968.  
  969. Successive calls to getFold(), using T values from 1 to 16, fetch the testing
  970. steps that were set up with setFold() for the use of the fold() function.  If
  971. T=0, the maximum step number in use is returned in T, and the other arguments
  972. are ignored.  If T is between 1 and 16 (or the maximum step number in use),
  973. the values used in step T are put into F, X, B, and SKA.  The test number is
  974. put into F.  F is set to 0 and getFold() returns FALSE, if step T is not in
  975. use.  (See setFold() and the list of tests F.)  If F<=7, the integer value
  976. associated with test F (an indentation or line length) is put into X, and B
  977.  
  978.                                       17 is ignored (it can be a literal "").  If F>=8, the 1 to 4 character string
  979. associated with test F is put into buffer B; if F>=8, FALSE is returned if B
  980. is not a buffer.
  981.  
  982.  
  983. setFold(T,F,X,SKA)
  984. T,F,X,SKA:  list 10 (integer or text)
  985.  
  986. Successive calls to setFold() define the testing steps that will be used in
  987. folding a buffer or region using fold().  T is a step number in the range 1
  988. to 16.  The testing steps T are applied by fold() beginning with T=1.  Gaps
  989. are allowed in the T values; empty T slots are ignored by fold().  Any
  990. existing step T can be overwritten by calling setFold() again, using the same
  991. T.
  992.  
  993. If setFold() is called with T=0, all testing steps are deleted; and then two
  994. default steps (for T=1 and T=2) are defined, just as if you had called
  995. setFold() as follows:
  996.     setFold(1,1,0,1)    (keep blank lines - it keeps only 1 per series)
  997.     setFold(2,2,0,1)    (keep lines with no indentation)
  998.  
  999. F specifies the test to apply in step T.  (See the list of F tests below.)
  1000. If F=0, step T is deleted.  (To eliminate the above two default steps, call
  1001. setFold(1,0,0,0) and setFold(2,0,0,0).)
  1002.  
  1003. X and SKA (Skip/Keep/AND) are used with test F.  If F<=7, X is must be an
  1004. integer (indentation or line length) with a value between 1 and 130.  If F>=8
  1005. X must be a text string (of 1, 2, or 4 characters) in a buffer or literal
  1006. argument.  If X is to be used as a range of characters (such as "AZ" or "09")
  1007. or a set of brackets or quotes (such as "[]" or "\"\"") it must contain at
  1008. least 2 characters (only the first 2 are used).  If X is to be used as a text
  1009. string (not as a character range or set of brackets), it may contain 1 to 4
  1010. characters.  setFold() returns FALSE, if X is invalid.
  1011.  
  1012. fold() scans its input buffer line-by-line, applying to each line the tests
  1013. that were set up with setFold(), starting with test T=1.  fold() does not
  1014. keep a line (put it into the output buffer), unless a test succeeds on that
  1015. line of text.
  1016.  
  1017. When a test succeeds, SKA specifies the action to be taken:
  1018.     If SKA = 0, the line is skipped.
  1019.     If SKA = 1, the line is kept (put into the output buffer).
  1020.     If SKA = 2, the current test is ANDed with the next one; the SKA of the
  1021.     next test dictates what to do after that - assuming that the next test
  1022.     also succeeds; if any ANDed test fails, all tests ANDed with it are
  1023.     ignored.
  1024.  
  1025. NOTE:  Test F=15 may involve multi-lines of text.  If you want to AND a test
  1026. 15 with other test(s), make sure that test 15 is the last in ANDed the series.
  1027.  
  1028. Blank lines:  If F=1 and SKA=1, this specifies that blank lines be kept.  If
  1029. several blank lines are in series, fold() only keeps the first.
  1030.  
  1031.  
  1032.  
  1033.  
  1034.  
  1035.                                       18 Folding tests (F):
  1036.  
  1037. 0    erase test F, if it exists  (X and SKA ignored)
  1038. 1    blank line                  (X ignored)
  1039. 2    indentation = X
  1040. 3    indentation < X
  1041. 4    indentation > X
  1042. 5    line-length = X
  1043. 6    line-length < X
  1044. 7    line-length > X
  1045. 8    1-4 character string X (eg, "x" or "abcd") is in the line
  1046. 9    1-4 character string X is at start-of-line
  1047. 10  1-4 character string X is at end-of-line
  1048. 11  character in range X (eg, "AZ" or "09") is in the line
  1049. 12  character in range X is at start-of-line
  1050. 13  character in range X is at end-of-line
  1051. 14  rgn bounded by quotes or brackets in X (eg, "\"\"" or "[]") is in line
  1052. 15  rgn bounded by quotes or brackets in X may be in multi-lines
  1053.  
  1054.  
  1055. Example commands using setFold() and fold():
  1056.  
  1057. Set up folding tests
  1058. <lAmiga-\:
  1059.     setFold(0,0,0,0)
  1060.     setFold(1,1,0,1)    .. include blank lines (it keeps only 1 per series)
  1061.     setFold(2,15,"{}",0)  .. skip function code inside {}
  1062.     ..setFold(3,15,"//",1) .. keep comments bracketed by //
  1063.     ..setFold(4,9,"#",1) .. keep lines beginning with #
  1064.     setFold(5,2,0,1) .. keep lines with no indentation
  1065. >
  1066.  
  1067. Fold current file
  1068. <rAmiga-\:
  1069.     getFileName(buf54,curFile)
  1070.     insertRgn(buf54,eFile,".fold",all)
  1071.     if (fold("",curFile,all)) {
  1072.         setFileName(curFile,buf54)
  1073.         downFlag(curFile,changed)
  1074.     }
  1075. >
  1076.  
  1077.  
  1078.        ++++++++++++++++++++Uedit V2.6 Manual ERRATA++++++++++++++++++++
  1079.  
  1080.                              +++++Commands+++++
  1081.  
  1082. Certain keys could not be input and had to be moved because the Amiga uses
  1083. them.  The LEFT Amiga mouse & gadget keys for Hyper Text were moved to RIGHT
  1084. Amiga.  Set Left Margin was moved from lAmiga-m to lAmiga-k.  The keys
  1085. changed were:
  1086.  
  1087. lAmiga-gadget1  -->  rAmiga-gadget1
  1088. lAmiga-gadget3  -->  rAmiga-gadget3
  1089. lAmiga-gadget4  -->  rAmiga-gadget4
  1090. lAmiga-buttonDown --> rAmiga-buttonDown
  1091. lAmiga-m --> lAmiga-k
  1092.                                       19 Bookmarks:  The bookmark commands were improved.  Bookmarks are now named.
  1093. The alt-gadget3 Clear Marks command was moved to shft-gadget4 and put into
  1094. the Bookmarks submenu, and the 4th gadget name was changed to "Up/Init Marks".
  1095.  
  1096. Now the shift-gadgets let you click on a mark-name, goto next mark, set a
  1097. mark and name it, or reset the marks.  When you reset the marks they are set
  1098. by default to sFile, eFile, sHilite, eHilite, sInvert, eInvert, locA, and
  1099. locB, and they are named "S file", "E file", and so on accordingly.
  1100.  
  1101. buf60 is now used for storing bookmark names.
  1102.  
  1103.                            +++++Miscellaneous+++++
  1104.  
  1105. MANUAL UPDATE:  The manual says that the font is determined by Workbench.
  1106. This is no longer true.  The font is set initially by the Config! file
  1107. defaults.  It can be changed anytime by selecting Set Font.
  1108.  
  1109. MANUAL UPDATE:  In the manual page 8 where it says to slide the screen by
  1110. putting the mouse at the far right, this is no longer true.  Instead you
  1111. should put the mouse at the very top of the screen to slide the screen.
  1112.  
  1113. MANUAL UPDATE:  Uedit now processes work in tiny window.  Just start a
  1114. process, click the title bar and switch immediately to tiny window.  If a
  1115. requester requires an input, Uedit returns to its big screen.  If a primitive
  1116. mode input is required, Uedit waits until you return to big screen and give
  1117. the input.  Recall that you can set the priority of Uedit separately in big
  1118. screen and tiny window now also; thus you can start a big process and go to
  1119. tiny window and let Uedit finish the process using a lower (tiny window) task
  1120. priority, if you wish.
  1121.  
  1122.                          +++++Config! defaults+++++
  1123.  
  1124. MANUAL UPDATE:  Added:  New font name & height defaults in Config!
  1125.     <topaz>  Font name
  1126.     <8>      Font pixel height (8-32)
  1127.  
  1128.                          +++++Command Language+++++
  1129.  
  1130. MANUAL UPDATE:  Added:  Key names for middle mouse button:
  1131.                 middleDown  macnum = 73
  1132.                 middleUp    macnum = 75
  1133.  
  1134.     Example:  <normal-middleDown:
  1135.                     runKey(normal-buttonDown) .. deposit cursor
  1136.                     runKey(ctl-r) .. execute learned sequence
  1137.               >
  1138.  
  1139. MANUAL UPDATE:  Added:  New setFont(fontName,fontHeight) CL fct for selecting
  1140. font.
  1141.  
  1142. setFont(fontname,fontheight)
  1143. fontname:     list 0
  1144. fontheight:  list 10
  1145.     returns eRUE if fontname exists with font size equal to fontheight.  The
  1146.     font may be in memory or on disk; if font isn't in memory it is loaded
  1147.     from disk.  When a new font is selected or when Uedit quits, the current
  1148.     font is released.
  1149.                                       20
  1150.     setFont() does not change the font immediately or visibly.  It merely
  1151.     changes the stored font name and height.  Next time Uedit's screen is
  1152.     reopened - as when changing screens or returning from tiny window - the
  1153.     new font is used.  If the font cannot be found, topaz 8 is used by
  1154.     default.
  1155.  
  1156.     EXAMPLE command that switches Uedit's font.  Notice that it goes to/from
  1157.     tiny window in order to close/reopen the screen; and it runs startup cmd
  1158.     so that menu item spacings will be recomputed for the new font:
  1159.     <normal-esc:
  1160.     setfont("topaz",11) toggle(toTiny) toggle(toTiny) runkey(startup) >
  1161.  
  1162.     NOTE: Now you can use a proportional font in your Workbench 2.0 and a
  1163.     non-proportional font in Uedit.
  1164.  
  1165. MANUAL UPDATE:  tinyPriority CL argument and Config! default.  This sets the
  1166. task priority of Uedit while in tiny window.  Uedit does housekeeping in tiny
  1167. window and on large buffers this may consume resource, so you may wish to set
  1168. Uedit to a low priority in tiny window to keep it from hogging machine
  1169. resource during housekeeping or whatever work is being done in tiny window.
  1170.  
  1171. MANUAL UPDATE:  Added:  setTaskPri() CL function to set Uedit's task priority.
  1172.  
  1173. setTaskPri(pri)
  1174. pri:  list 10
  1175.  
  1176.     This sets Uedit's task priority when it is not in tiny window.  The
  1177.     tinyPriority CL variable and Config! default sets its priority when it is
  1178.     in tiny window.
  1179.  
  1180.  
  1181. MANUAL UPDATE:  Dynamic use of Dictionary Supplement during spell checking.
  1182. You now can have an optional UDSupplement in buf41 for the spell checking
  1183. cmds.  (See the rAmgia-c cmd in Config!S.)  When the word isn't found in the
  1184. main dictionary, spell() looks in the supplement.  The supplement must be in
  1185. alpha order; you can use SA-s to sort a stacked list of words to make a
  1186. dictionary supplement.
  1187.  
  1188. spell(B1,B2,B3)
  1189. B1,B3:  list 0 (buffer or " ")
  1190. B2:     list 2 (buffer)
  1191.  
  1192. The normal return for spell() is False; this indicates a bad word was found.
  1193. It also returns False if B2, the buffer being spell checked, does not exist
  1194. or if the speller is not up.  If spell() returns True, it has reached eof.
  1195. It checks from the cursor forward in B2, stopping when a bad word is found.
  1196. If B1 is a buffer, optional spellings are put into B1.  If B1 is " ", spell()
  1197. simply returns False when it finds a bad word.  (See the commands in
  1198. Config!S.)  When B1 is " " (no optional spellings), spell() may be aborted
  1199. with Amiga-ESC.  When B1 is a buffer (to collect optional spellings), the
  1200. lookup of spelling options may be stopped early on by giving an input; the
  1201. options accumulate in the message line as they are found, and thus when you
  1202. see the option you want you can click it with the mouse and no further
  1203. options are sought.  If B3 is a buffer, it is used as a supplemental
  1204. dictionary; the words in it should be on separate lines and in alphabetical
  1205.  
  1206.                                       21 order.  If B3 is " ", no supplement is used.  (See spellerUp, startSpell()
  1207. and stopSpell.)
  1208.  
  1209. Cursor Action:  Advances cursor until it finds a bad word or eof.
  1210.  
  1211. Display Action:  If B=curFile, refreshes cursor; if offscreen, centers cursor.
  1212.  
  1213. Example:
  1214.     if (not spellerUp) return
  1215.     while (not spell(buf54,curFile," ")) runKey(virtual-z) .. replace bad words
  1216.  
  1217. MANUAL UPDATE:   A draw() CL function.
  1218.  
  1219. draw(x,y,color,mode,flag)
  1220. x,y,color,mode,flag:  list 10
  1221.  
  1222. draws a line from the current position to x-y using the color, drawing mode,
  1223. and flag values specified.  Color = 0-7 specifies a color; color = -1 means
  1224. use the current (last) color.  mode values are: 0 = JAM1, 1 = JAM2, 2 = XOR,
  1225. 4 = INVERSE.  flag = 0 means do only a move(x,y) to set the current drawing
  1226. position to x-y; other arguments are ignored except the color is stored.
  1227. flag = 1 means draw a line to x-y using color, mode, and flag.  Example:  You
  1228. can draw (using XOR) a grating on top of the text in the window & erase it by
  1229. redrawing it again with XOR.  You can draw boxes and other figures with the
  1230. mouse.  draw() always returns True.
  1231.  
  1232. Compile BOTH of the cmds below to try this example.  Press shft & the mouse
  1233. button and move the mouse:
  1234.  
  1235. Note how xor erases old box on second execution.
  1236. <virtual-esc:
  1237.     draw(n0,n1,   0,2,0)
  1238.     add(n54,n0,20)
  1239.     draw(n54,n1, -1,2,1)
  1240.     add(n53,n1,20)
  1241.     draw(n54,n53,-1,2,1)
  1242.     draw(n0,n53, -1,2,1)
  1243.     draw(n0,n1,  -1,2,1)
  1244. >
  1245.  
  1246.  
  1247.  
  1248.  
  1249.  
  1250.  
  1251.  
  1252.  
  1253.  
  1254.  
  1255.  
  1256.  
  1257.  
  1258.  
  1259.  
  1260.  
  1261.  
  1262.  
  1263.                                       22 Place cursor or scroll if button held
  1264. <shft-buttonDown:
  1265. ..    moveCursor(curFile,mouseLoc)
  1266. ..    updateDisplay
  1267.     mouseXY(n0,n1)
  1268.     runkey(virtual-esc)
  1269.     if (not mousedown) return
  1270.     equateNum(n54,0)
  1271.     while (not inputwaiting) {
  1272.         trackmouse
  1273.         mouseXY(n2,n3)
  1274.         if (!eqNum(n2,n0) & !eqNum(n3,n1)) {
  1275.             runKey(virtual-esc)
  1276.             equateNum(n0,n2)
  1277.             equateNum(n1,n3)
  1278.             runKey(virtual-esc)
  1279.         }
  1280.     } >
  1281.  
  1282. Another example:  XOR a grating onto text.  Erase it on second execution.
  1283. <shft-esc:
  1284.     ..putmsg("  ") putmsg(" ")
  1285.     ..updateDisplay
  1286.     equateNum(n0,-8)
  1287.     while (add(n0,n0,8) & genum(sWidth,n0)) {
  1288.         draw(n0,16,0,2,0)
  1289.         draw(n0,sHeight,0,2,1)
  1290.     } >
  1291.  
  1292. ..equateNum(n0,50)
  1293. ..equateNum(n2,550)
  1294. ..equateNum(n1,25)
  1295. ..equateNum(n3,150)
  1296. ..runkey(virtual-b)
  1297.  
  1298. Draw a box of with corners (x-y) given by n0-n1 and n2-n3
  1299. ..<virtual-b:
  1300.     draw(n0,n1,2,2,0)
  1301.     draw(n2,n1,-1,2,1)
  1302.     draw(n2,n3,-1,2,1)
  1303.     draw(n0,n3,-1,2,1)
  1304.     draw(n0,n1,-1,2,1)
  1305. >
  1306.  
  1307. MANUAL UPDATE:  100 buffer & 100 number stacks.
  1308.  
  1309. getStackSize(B,N,S)
  1310. B,N,S:  list 10 (integer)
  1311.  
  1312. Reports the current buffer stack size in B, number stack size in N, and save-
  1313. file stack size in S.
  1314.  
  1315. Example:  .. get size of buffer stack 22 in n11 & number stack 99 in n12
  1316. equateNum(n11,22) equateNum(n12,99) getStackSize(n11,n12,n13)
  1317.  
  1318.  
  1319.  
  1320.                                       23 pop(S,BN)
  1321. S,BN:  list 10 (buffer or number)
  1322.  
  1323. pops the next item from stack S into buffer or number variable BN.  Returns
  1324. False if stack S is empty.  If S is a buffer variable such as buf10, buffer
  1325. stack 10 is used; if S is a number variable such as N22, number stack 22 is
  1326. used.  The stack is popped variable BN.  If a buffer is popped off a buffer
  1327. stack the current buffer BN is deleted and the stack is popped into buffer
  1328. variable BN.  Note that the stack is LIFO, last-in-first-out.  (See
  1329. getStackSize(), push(), and rollStack().)
  1330.  
  1331. Display Action:  Displays "home" buffer, if pop into curFile.
  1332.  
  1333. Example:  pop(n22, pageLines) .. pop number stack 22 into pageLines variable.
  1334. pop(buf99, buf3) .. pop buffer stack 99 into buf3 slot, killing old buf3.
  1335.  
  1336. push(S,BN)
  1337. S,BN:  list 10 (buffer or number)
  1338.  
  1339. pushes item BN, a buffer or number, onto the stack indicated by S.  If S is a
  1340. buffer variable such as b10, it means use buffer stack 10; if it is a number
  1341. variable such as n22, it means use number stack 22.  There are 100 buffer and
  1342. 100 number stacks.  False is returned if 8 bytes is not available for the
  1343. stack entry.  If BN is curFile, the "home" buffer becomes the new curFile; If
  1344. BN is the last file buffer, a new NoName buffer is opened.  (See rollStack(),
  1345. getStackSize(), and pop().)
  1346.  
  1347. Display Action:  If curFile pushed, displays new curFile.
  1348.  
  1349. Example:  push(buf10, curFile)   .. push curFile onto buffer stack 10.
  1350. push(n0,lineLength) .. push lineLength onto number stack 10.
  1351.  
  1352. rollStack(X,N)
  1353. X:  list 10 (buffer or integer)
  1354. N:  list 10 (integer)
  1355.  
  1356. Rolls the buffer stack by amount N, if X is a buffer argument; rolls the
  1357. number stack by amount N, if X is an integer argument.  X indicates which
  1358. buffer or number stack to roll.  rollStack() returns False, if the (buffer or
  1359. number) stack size is less than 2 or if N is 0.  N may be positive or
  1360. negative, and the stack is rolled forward or backward based on the sign and
  1361. amount of N.  The stacks are LIFO, last-in-first-out.  If N is 1, the first-
  1362. out stack entry is rolled to the last-out position, so that the second-out
  1363. becomes the first-out.  If N is -1, the last-out entry is rolled to the
  1364. first-out slot.  (See push(), pop(), and getStackSize().)
  1365.  
  1366. Example:  rollStack(buf10,1)   .. rolls buffer stack 10 forward by 1.
  1367. rollStack(n0,n54)    .. rolls number stack 0 by the amount in n54.
  1368.  
  1369. NEW:  Created new rexxKey command name.  Like startup, idle, and preKey,
  1370. rexxKey does not use shiftkeys.  rexxKey runs automatically in idle periods
  1371. ONLY if there is a rexx msg/reply waiting to be processed.  The special key
  1372. macroNums now are:
  1373.         rexxKey 1145
  1374.         idle    1146
  1375.         preKey  1147
  1376.         startup 1148
  1377.                                       24 NOTE:  The purpose of rexxKey is to reduce overhead.  When the idle cmd was
  1378. used to process rexx traffic with idleTime=0, there was high overhead because
  1379. idle constantly.  rexxKey runs (during idle periods) ONLY if there is an
  1380. incoming msg/reply to process.  And if you process the msg/reply in your
  1381. rexxKey cmd, rexxKey won't run again until there is another msg/reply to
  1382. process.  (In the std config, rexxKey runs ONLY if autoTraffic mode On.  See
  1383. Config!R.)
  1384.  
  1385. NOTE:  In order to keep rexxKey from running repeatedly in idle periods, you
  1386. MUST process the incoming msg/reply by calling rexxIn() in your rexxKey cmd.
  1387. In the std config turn on autoTraffic and this is taken care of
  1388. automatically.  (See Config!R.)
  1389.  
  1390. NOTE:  Config!R was modified to swap virtual-t with the rexxKey cmd instead
  1391. of with the idle cmd; the idle cmd is no longer used in Config!R.  Don't
  1392. forget to modify your custom Config!R, if you aren't going to use the one in
  1393. the std config on the Uedit disk.
  1394.  
  1395. NEW:  Created new sortLines(buffer=list 2,caseSensitive=list 10) CL fct.  It
  1396. sorts the lines in the buffer.  If caseSense is non-zero, case sensitivity is
  1397. used in the sort.  If caseSense is 0, case sensitivity is not used in the
  1398. sort.
  1399.  
  1400. NEW:  Created inTiny CL fct, returns TRUE if currently in tiny window.
  1401.  
  1402. NEW:  created new CL functions screenToBack and screenToFront.
  1403.  
  1404. NEW: When smartTabs is TRUE, spacesToTabs/tabsToSpaces warns when an eol is
  1405. encountered and a quote is not closed.
  1406.  
  1407.  
  1408.        ++++++++++++++++++++Uedit V2.5 Manual ERRATA++++++++++++++++++++
  1409.  
  1410.                              +++++Commands+++++
  1411.  
  1412. MANUAL UPDATE:  AREXX INTERFACE:  Uedit's old cryptic standard Rexx interface
  1413. (in the old Config!R) was replaced with Kerry Zimmerman's readable, verbose
  1414. interface, which users say is much easier to use.  The manual talks about the
  1415. old Config!R, not the new one which uses command words; so ignore the
  1416. irrelevant parts of the discussion in the manual, particularly the Examples.
  1417. See ReadMe.Demo for instructions on using the new interface.  The manual will
  1418. be updated on the next major upgrade.
  1419.  
  1420. Buffer usage:  (Buf 36 no longer used by Rexx interface)
  1421. buf36 = holds REXXCOMM File for Rexx interface
  1422. buf62 = Rexx msg/reply output buffer
  1423. buf61 = Rexx msg/reply input buffer
  1424.  
  1425. MANUAL UPDATE:  The following cmds are for the Editing Tricks in the manual:
  1426. Rather than setting MaxFiles to a high number, which requires customizing the
  1427. config files to change buffer numbers in its commands, you can store files on
  1428. the buffer stack and access them just as though they were in file buffers.
  1429.  
  1430. Load each file and use the cmd below to push the file onto the buffer stack.
  1431. You can load as many as memory will hold, and it doesn't use up file buffer
  1432. slots.
  1433.  
  1434.                                       25 Swap current buffer with stack & roll stack
  1435. <shft-gadget4:
  1436.     getStackSize(n51,n52,n53)
  1437.     if (eqNum(n51,0)) {
  1438.         putmsg("buffer stack is empty")
  1439.         returnFalse
  1440.     }
  1441.     equateNum(n54,curfile)
  1442.     ..if (getFlag(curfile,changed)
  1443.     ..    & askYesNo("Save this changed buffer?")) saveFile(curfile)
  1444.     push(buf99,curfile)
  1445.     rollstack(curfile,1)
  1446.     pop(buf99,buf[n54])
  1447. >
  1448.  
  1449. To save changes, use the cmd below repeatedly.  It examines the stack and
  1450. lets you save any buffers that have been changed.  Note that this cmd can be
  1451. customized to save changes on the stack automatically by deleting the
  1452. askYesNo() call.
  1453.  
  1454. Save changed files on buffer stack
  1455. <alt-gadget4:
  1456.     getStackSize(n51,n52,n53)
  1457.     if (eqNum(n51,0)) {
  1458.         putmsg("buffer stack is empty")
  1459.         returnFalse
  1460.     }
  1461.     equateNum(n54,curfile)
  1462.     do (n52,0,n51) {
  1463.         push(buf99,curfile)
  1464.         rollstack(curfile,1)
  1465.         pop(buf99,buf[n54])
  1466.         if (!eqNum(n52,n51)
  1467.             & getFlag(curfile,changed)
  1468.             & askYesNo("Save this changed file?")) saveFile(curfile)
  1469.     }
  1470. >
  1471.  
  1472. MANUAL UPDATE:  NEW: State (R-f5) and Load State (R-f6) menu commands.  These
  1473. save Uedit's state in the default state file "uestate".
  1474.  
  1475. MANUAL UPDATE:  NEW: saveState(filename) & loadState(filename) CL functions.
  1476. (The filename arguments are list 10.)  saveState() saves Uedit's state to
  1477. disk.  loadState() loads in a previously stored state.
  1478.  
  1479. A "state" is a snapshot.  Storing Uedit's state consists of storing file and
  1480. work buffers along with their local flags; also stored are many global
  1481. variables including colors and split window information.  When you load in a
  1482. state, everything is just as it was when the "snapshot" was taken; the split
  1483. windows are in the same order, the cursors are in the same spot, the colors
  1484. are the same, the currently active buffer is the same, colored regions are
  1485. the same, the search & grep strings are the same, even the Changed (or not)
  1486. status of files is the same.
  1487.  
  1488.  
  1489.  
  1490.  
  1491.                                       26 NOTE:  The state does not include keys or learned sequences.  As part of your
  1492. state command you can include saving or loading a data file and existing
  1493. learned sequence, if you wish.  The state also does not include buffers and
  1494. numbers on the stacks.
  1495.  
  1496.                            +++++Miscellaneous+++++
  1497.  
  1498. MANUAL UPDATE:  Section 1.30.3 in the manual which discusses leftMargin and
  1499. autoIndent needs correction.  A table needs to be provided to cover the
  1500. cases.  Note that when autoIndent is off and leftMargin>0, normal typing does
  1501. not use leftMargin.  But if you reformat the paragraph, it is indented to the
  1502. column specified by leftMargin.  So leftMargin is used in paragraph
  1503. reformatting if it is >0 even though during normal typing it is not used when
  1504. autoIndent is off.  Note also that the Left Margin (L-m).
  1505.  
  1506. MANUAL UPDATE:  Printed manual does not show the grep carat (^) symbol in the
  1507. symbol table at the top of page 68.  The carat symbol forces a match to start
  1508. of line.
  1509.  
  1510. MANUAL UPDATE:  The manual does not document the fact that spell() does not
  1511. present optional spellings for bad words if the big dictionary is not in
  1512. memory.  It does not bother looking up options on disk because it would be
  1513. too slow.  For the optional spellings to be presented in the message line,
  1514. you must have loaded the spelling dictionary into Uedit's memory.  Note that
  1515. using the Load Speller command in Config!s (unless you customize it) if Uedit
  1516. cannot find enough contiguous memory for the big dictionary, it will open the
  1517. speller using the dictionary on disk - in this case, optional spellings will
  1518. not be looked up and presented.
  1519.  
  1520. MANUAL UPDATE:  Hyper text was modified to allow partial words to be looked
  1521. up.  This is not documented in the manual.  When the word buffer argument has
  1522. something in it and the flag = 0 or 1, first the word buffer content is
  1523. treated as a whole word/phrase in the lookup; if not found, it is treated as
  1524. a partial word/phrase.  Thus you can type or click the first few letters of a
  1525. hyper word or phrase and the lookup should find the whole word/phrase if it
  1526. exists in the table.
  1527.  
  1528. MANUAL UPDATE:  Added:  -s CLI command line flag.  Examples:
  1529.     run UE -s         .. runs UE & loads in the default state file "uestate".
  1530.     run UE -sMyState .. runs UE & loads in state file MyState.
  1531.  
  1532. NOTE:  When a state is loaded, it uses the buffers that were in use when the
  1533. state was saved.  WARNING:  Files in Uedit may be erased so that the state
  1534. can use their buffers; you should save any changes before loading in a state.
  1535. Note also that if you type "Run UE -s file1 file2", file1 and file2 may be
  1536. erased from Uedit's memory so their buffers can be used by the state being
  1537. loaded in.
  1538.  
  1539. The -s flag is processed BEFORE the -k & -l CLI command line flags and AFTER
  1540. the named files (if any) are loaded in.  You can specify a key or learned
  1541. sequence (-k or -l) to act on the loaded state's files.  -s is processed
  1542. after the -c and -d flags, of course.  To summarize, the sequence is this:
  1543.     process -c and -d, if used
  1544.     load files, if any
  1545.     process -s, if used
  1546.     process -l and -k, if used
  1547.  
  1548.                                       27                          +++++Config! Defaults+++++
  1549.  
  1550. MANUAL UPDATE:  Added:  Alt-keys array in config defaults.  Below the 2
  1551. printable keys arrays in the config defaults is another array of the same
  1552. length (64 characters).  These keys can be typed in using the ALT shift-
  1553. modifier.  The purpose of the alt keys array is to enable foreign users to
  1554. type in foreign characters either in normal or especially in primitive mode.
  1555. (In normal mode they could use a command to input foreign letters, but they
  1556. couldn't type foreign letters in that way when in primitive mode.)
  1557.  
  1558. MANUAL UPDATE:  Added:  2 new Config! defaults for setting the screen's pixel
  1559. width & height.  The 2 reserved slots after "Trap menus" are replaced:
  1560.     old:
  1561.     <0>     Trap menus to use menu mouse button as a key
  1562.     <0>     Reserved.
  1563.     <0>     Reserved.
  1564.     new:
  1565.     <0>     Trap menus to use menu mouse button as a key
  1566.     <664>     Screen width in pixels (640-1064)
  1567.     <224>     Screen height in pixels (gets auto-doubled for LACE) (200-1064)
  1568.  
  1569. MANUAL UPDATE:  Added:  customScreen global CL variable and config default.
  1570. In the Config!  defaults it is the default just after smartTabs (which used
  1571. to be a RESERVED slot).  If customScreen is FALSE or 0, when the screen opens
  1572. it is a type WBENCHSCREEN; with a WBENCHSCREEN when you type Ctrl-y and "Run
  1573. NewCLI" in Uedit, the CLI window is on top of Uedit's window, but a side
  1574. effect is that rAmiga-n/m work strangely or incorrectly.  If customScreen is
  1575. TRUE or 1, when the screen opens it is a CUSTOMSCREEN; with a CUSTOMSCREEN
  1576. you cannot open a CLI or Performance Monitor window on top of Uedit's screen,
  1577. but the rAmiga-n/m keys work correctly.
  1578.  
  1579.                          +++++Command Language+++++
  1580.  
  1581. MANUAL UPDATE:  CL argument list 14 in Part3 of the manual should be the
  1582. following:
  1583.  
  1584. LIST 14:  autoBackup autoIndent busies changed columnar cram favorite
  1585.           hideDisplay icons lace learnMode mapChars markGadgets overStrike
  1586.           printTabs readOnly rightJustify rowCol scrollType searchCaps
  1587.           smartTabs speakAlerts speakMsgs spooks teachKeys trapMenus trueTabs
  1588.           useKeys userGlobalA userGlobalB userLocalA userLocalB wordWrap
  1589.  
  1590. The CL functions marked as using list 13 should be changed to use list 14.
  1591. No CL function uses list 13 which no longer exists.
  1592.  
  1593. MANUAL UPDATE:  Added:  CL variables sWidth and sHeight to set the pixel
  1594. width & height of Uedit's screen.  These belong in list 10 of the manual's
  1595. argument lists.  
  1596.  
  1597.  
  1598.  
  1599.  
  1600.  
  1601.  
  1602.  
  1603.  
  1604.  
  1605.                                       28