APDL Public Domain 1/APDL_PD1A.iso/textutil/jgpsuite/Docs/JGEdDoc

Text File | 1993-05-18 | 29.3 KB | 631 lines

.setu 10 :arc:          In/exclude Archimedes only features.
.// .setu 10 :msdos:    Ex/include msdos only features.
.setm 11 *.nost
\s1 \t*             Used for undentation in boast below; end of layout prologue.
.sp 0               Comment out if Pages wanted; default 66 lines (.sp 66)
.ft
/

.col
|Page \p
/
.hd
:.if \o
.col
Manual|Sat,30 Mar,1991|JGEd/JGSharEd
.else
.col
JGEd/JGShared|Sat,30 Mar,1991|Manual
.fi

:
.col
|JGEd

JGEd has been developed from a family of editors provided by John Richards of
RCP for CP/M, BBC and MSDOS. JGEd stands for Jolly Good Editor. The MSDOS
version is periodically updated to as large a subset of the Archimedes version
as MSDOS allows.

Upper case letters in the following command descriptions denote the command's
specification as an extended command.

Within the documentation for other machines, some bytes outside the common 7-bit
ASCII set may show as different and unexpected characters on the screen. Key
differences may be expressed as k1/k2 meaning k1 for Archimedes, k2 for MSDos.

.cp 6                   Conditional page throw ensures col & text on same page
.col
|Objectives

Any editor has to balance power - which conflicts directly with ease of
acquisition - and a desire to minimise the user's keystrokes - which conflicts
with both. JGEd puts power first, minimum keystrokes second. Ease of learning
has the lowest priority, but two aspects of JGEd help: regularity of syntax and
semantics; a distinction between immediate and extended commands.

A secondary objective was to put into JGEd facilities for making common
alterations to the machine's status. Many stand\-alone utilities to do so have
been produced, but it seems to me ergonomic to bundle them with the application
in which I, certainly, spend most of my time. Setting the Default Directory to
that of the file being edited, and setting the File Type of any subsequently
written files are two I find particularly useful; I should be glad to consider
any other candidates that might be suggested.

A tertiary objective was to keep as consistent as possible usages for various
machines and usages from a commandline or desktop.

A fourth objective was to provide flexible failsafe arrangements, both to
preserve the file being edited and to restore the status quo ante after editing
mistakes.

A fifth objective was to combine the largest possible editing window with the
availability of the desktop rescources; a final related objective was to be able
to use the mouse, and the function keys, in a regular and structured way to make
it unneccessary to use the keyboard when no ink characters were an intrinsic
part of the command to be effected.

.cp 6
.col
|Documentation

This manual, together with Help_JGEdI(nfo, Help_JGEdK(eys) and Help_JGEdL(ine),
and Help_JGEdM(ouse, documents the current version of !JGEd as at Wed,14 Apr
1993. The version, !JGSharEd, distributed as Shareware, may lag a little, and
not yet include all documented facilities. It is my practice to bring it
uptodate if a serious bug has been found and corrected in JGEd, or when a
substantial group of capabilities has been established to be working
satisfactorily. There is a deliberately tiresome but not wholly destructive
restriction kept in the Shareware Version, documented below.  Help_JGEdI etc.,
live in !jgp.info and are available online (type F1) within JGEd, as does
Help_JGPrn which provides on-line help if you are preparing text for JGPrint.

.if \u10 eq arc
.cp 6
.col
|Starting in the Desktop

Clicking on the application !jgp puts its icon on the iconbar. Thence, dragging
a file thereto will JGEd it, as will double clicking on a file of type JGEd.
More details follow.

!boot in the Application Directory !jgp sets <jgp$dir> to ...!jgp and provides
three filetypes, JGEd, JGPrint and JGPCopy. Double clicking on a file of type
JGEd applies !jgp.Tools.JGEd to it. Double clicking on !jgp registers a JGEd
icon (currently &203 but subject to change - see JGPDispute) on the icon bar.
Files of any type dragged to this icon will have JGEd applied to them; clicking
menu on the icon will reveal the options available, and a facility to define and
begin editing a new file.

Clicking select or adjust on the JGEd icon will swap it to and from a JGPrint
icon.

[Dragging a file to the JGPrint icon on the desktop will set its filetype to
JGPrint; double clicking on a JGPrint file will apply JGPrint/Doc to it. See
JGPrinDoc/Info for further details.]

If the desktop is active, JGEd starts in the mode selected via the options
submenu, in 'sharing' state; CTRL-F12 switches to and from 'non-sharing' state.
'sharing' implies that: other desktop tasks run concurrently; a red upright
caret rather than a winking cursor is used; JGEd's internal concurrent printing
is not available; while the red cursor is visible, the cpu is available for
switching to other tasks. In certain modes, 'sharing' state is not available.

Clicking Shift-menu when in the editing window, Adjust when in the macroline, or
executing dk in the macroline packs the edit away in a 'latent' window, clicking
from which reveals a menu to continue, save or quit, or use block reading and
writing capabilities described below. The title of the window is a right segment
of the name of the file being edited.

The latent windows from several instances of JGEd appear stacked below one
another on the desktop. Howver, if a window in the middle of the stack closes,
the next one opened will be in the same vertical position as the lowest one. Of
course the various window can be repositioned by the user for her convenience.

Note that it is permitted to have more than one process in which some file is
being edited, but that each operates on a copy read from the filing system.
Therefore, successive saves from two or more will overwrite the file
competitively. I therefore recommend that all but one are put into view mode
(CTRL-F11 or icon bar options), whence the edited text cannot be saved.

Restriction: JGEd does not work correctly in a mode with more than 128 rows; it
would be trivial to increase this if needed.
.fi
.if \u10 eq MsDos

.col
|Context of MSDos Implementation

JGEd, and indeed all the rest of the JGP suite, have principally been designed
for the Archimedes Desktop, a windows\-like environment. It is intended that
they shall themselves run under Windows 3, but as at summer 1992, they have
only been implemented to run from the command line.

A further restriction is that they have been conceived to run solely in a 80 by
25 black and white ANSI window; however, the colours described below for
various kinds of lines have been replaced by a suitable symbol, e.g. Í \ for the
home line. This is a successful alternative to the colours, and I should have
thought that screens which show a non\-standard symbol for the bytes involved
should convey the information just as clearly. Indeed, I may well
back\-implement these symbols for use on the appropriate modes in the
Archimedes.

On the Archimedes, the <--- is not used. Conventionally, DELETE deletes left
and END deletes under; this convention is used in JGEd. The MsDos user may well
find this needs some getting used to, and I regret the annoyance she may
suffer.

<---- is used to move the cursor to swap between the top and the bottom line
of the page. It was a deliberate choice to use it so that it was both
conspicuous in its effect, and in no way altered the text being edited.

Ideally, the user should find no difference between key usage on the two
machines. But the ANSI keyboard does not easily provide responses for F11 and
F12, and other key responses are different from those of the standard ARC.
Therefore the actual function keys used to provide the editor's immediate
capability, though similar, differ somewhat on the two systems. However, these
choices shown in JGEDK.HLP or its Arc analogue, and available online by
pressing f1 each have their own logic, and can each easily be acquired.
NB. Below, the Arc versions are more usually referred to than the MSDos, though
it is intended that both should be of equal status, eventually, in this
document.

Since MSDos has file-extensions in its filing systems, a number of auxiliary
files mentioned below are renamed in an obvious way for the MSDos
implementation; many are detailed in context below. For example, Autosave>
appears as Autosave.tmp.

As at Summer 1992, the following features have not been checked/found not to be
working:
.nofj
System Variables for remembering macros in Keys;
Automatic backup;
Insert (use Right-hand number pad with Alt); there remains the problem of the
bytes the ANSI keyboard listens for and gives a special response to.
.usel base

NB !S to stop the screen may be useful if some texts etc. rush by too fast.

.col
|Magic restart

!C or !Break returns to the BCPL Prompt line, from which system commands can be
executed without disturbing the system. Then:-\|
cont\|
followed by SHIFT-f10 will enable editing to continue.

The system normally stands alone, but the development version runs within
Shell.exe, the BCPL system. All CLI commands are available from within BCPL by
preceeding them with a *, and the f1-5 line editor applies.
.fi                  End of Msdos section

.cp 6
.col
|Starting in the Commandline

JEd and JSharEd, require jgp$dir to be set to the directory in which
Tools.JGEd/JGSharEd is to be found, i.e. <path>.!jgp. I keep these in the
library so that JEd <file> will edit <file>, where <file> is a path to the
required file from the currently selected directory. If <file> is not given, the
options available, the selected directory and a prompt to complete the
commandline are given.

If the Desktop is active, JGEd uses dark colours on a white background; if it is
not active JGEd uses bright colours on a dark background (which, personally, I
find easier on my eyes). The mode can be reset as required (md<n>). NB. 16
colour modes provide the best display, though JGEd works in any mode.

.cp 6
.col
|Files needed and Documentation Available

In the case that <jgp$dir>.Tools.JGEd/JGPrint are not available
<jgp$dir>.\_Tools.\_JGSharEd\/JGSharePr are used in their place.

Help_JGEdK etc, Halp_JGEDL and Halp_JGPrn should live in the directory
<jgp$dir>.info (set by !boot in the application !jgp). These files, which list,
with short descriptions, the immediate and extended commands available, get
typed when F1 followed by 1 to 4,0 are typed. After F1, you are prompted what to
type for what info. #(SH-3) and )(SH-0) get functionally rather than
alphaberically sorted help for the Macroline and JGPrint respectively.

To obtain a short description of the effect of any command, type it following
F1.

JGEd in non-wimp sharing mode can concurrently copy another file to the printer
while editing; see below for details.

Also see below for the use of the mouse within JGEd, and details about switches
and system variables. (Also described in Help_JGEdK/L.)

.cp 6
.col
|JGEd's Commands

Immediate commands are individual commands obtained from the non\-character
keys, with, if appropriate, SHIFT and CONTROL, or the three mouse buttons. Many
of these have an immediate effect on the cursor or the text, but 21 of them
initiate the macro\-line, where the user can set and execute a suitable
combination of extended commands. The beginner needs only one of these in the
first instance, but will probably rapidly move to the use of three or more. The
leftmost character in the commandline is either €(128) or ×(215) according to
whether JGEd's buffer is the same or different to the version in the filing
system. If this has disappeared, going to and from the macro\-line will recover
it. NB € changes to × at the action after an editing action.

In general, the red function keys unshifted and uncontrolled do the simplest and
commonest editing tasks, shifted keys more powerful tasks that redraw the
screen, controlled keys rarer tasks, and control-shifted keys very rare tasks.
There is slight duplication, both to keep consistent with earlier versions and
to suit differing keyboard practices.

.if \u10 eq arc
In the Editing Window:
.hln
Mouse-Select (single-click) places JGEd's cursor (the Wimp Caret) at the Wimp
Pointer.
.hln
Mouse-Select (Double-click)/type f9 quits editing; if the editing buffer has
been altered since the last save to the file being edited, the query "Edits will
be lost - Quit?(Y)? :" appears on the message line. Clicking Select/Typing Y
quits, setting jged$var to 1, others return to the editing window. A quit that
is not so intercepted sets jged$var to 0. See below for auto\-backup.
.hln
Mouse-Select (Drag) pushes any existing block (see below) and sets a block whose
start and end are the start and end of the drag (or Vice\-Versa). If the mouse
is held near the top line, the window moves up line by line; if the mouse is
held near the bottom line, the window moves down line by line. If held near the
top right-hand corner of the window, the window moves up by pages. If held near
the top left-hand corner the window goes to the beginning of the text. If held
near the bottom right-hand corner,the window goes to the end of the text, if
held near the bottom right hand corner the window moves down, slowly, by pages.
If the mouse is held near the right, but neither at the top or the bottom, the
text will be paged right, again slowly; if near the left, and the text has
already been paged right, it will be paged left. 3In this context a page is
always 10 columns. See Line and Page pacing below.
.hln
Mouse-Menu (single-click)/type PRINT(f0) installs an empty Macro\-line.
.hln
Mouse-Menu + Shift goes straight to the latent window.
.hln
Mouse-Adjust(single-click) modifies the behaviour of the next mouse click to
operate on blocks rather than define blocks; for details see below.
.hln
Mouse-Adjust (double-click)/type SHIFT-f9 saves the editing buffer to the file
and returns to the editing buffer.
.hln
Mouse-adjust(drag), if started within a block will adjust that block, keeping
the same start, if the first move is downwards, the same end if the first move
is upwards. The top and bottom, sides, and corners have the same effect as in the
select drag. A Drag beginning outside a block can be used to move the window. If
the drag outside a block begins and ends on the same line (in practice, hold the
button down without moving the mouse), the block is cancelled.

Note that Drags are based on the pointer, not the caret, which is hidden.
Marking effects may take a few moments to catch up the pointer.

Page Pace <n> and Line Pace <n> adjust the speeds of page and line pacing to
<n>/100 per second.

In the Macro Line:
.hln
Mouse-Select (single-click)/type RETURN executes the macro-line and
returns to the editing buffer. However, if JGEd is waiting a prompt, select is
construed as the response Y.
.hln
Mouse-Menu (single-click) leaves the macro-line for the editing buffer. However,
if JGEd is prompting Exchange? (Y/N), menu is construed as the response N.
.hln
Mouse-Adjust (single-click) returns to the desktop with a Latent Window for this
editing task; from this window, clicking opens a menu, and choosing Continue
closes the latent window and returns to the JGEd editing window.

After a single adjust-click in the editing window, a reminder of what the next
clicks do appears, after a short delay, on the bottom line. This will differ
according as the cursor is  in or out of the block. (If there is no block, JGEd
will complain):
.hln
A second single adjust-click will insert the block at the caret, or delete the
block and restores the preserved block if the caret is within it. The mouse
buttons revert to their original meanings.
.hln
a single select-click will move the block to the caret, or delete the
block if the caret is within it. The mouse buttons revert to their original
meanings.
.hln
a single menu-click will cause the mouse buttons to revert to their
original meanings, with the message Block transfers aborted.

In effect, if you click adjust without immediately doing a double click or drag,
you can then, if outside the block, use a second adjust or select click to
insert the block or move the block;
.hln
if the cursor is within the block, the second click will delete the block
(to scrap);
.hln
In either case a message on the bottom line will tell you what you may do and
how to do it. Clicking Menu aborts the block operation.

If the Wimp or some other task opens a window for some message or interrupt,
JGEd requires you to type SHIFT-PRINT to restore the editing window. (If you
need to.)

.fi
.if \u10 eq msdos
F10 installs an empty macro\-line.\|
SHIFT-f9 writes the edited text to the file being edited;\| f9 Quits; if the
text has been edited since last being saved, the user is prompted to confirm.

.fi
UNdo/SHIFT-f1 cancels all edits done since moving to the current line; if no
edits have been done it inserts the last DeLeted/SHIFT-f3 line. Two further uses
of SHIFT-F1/Undo will restore the updated version. The exchanges continue
indefinitely.

No further commands are explained in this document, except in the course of
exemplifying the editing capabilities available. If the descriptions in
Help_JGEdK/L/M need supplementing, my advice is to try the command out (on a
text you don't mind losing). Moreover, many users will not want to use some
groups (I have never used CTRL-SH-F1-9). I find, also, that one only gradually
acquires confidence and competence to use large combinations of extended
commands; however, the reader is warmly encouraged to experiment, and I would be
interested to hear of outcomes.

JGEd lines are restricted to 255 characters, which normally consist of bytes
33-126 + 128-255. See Start below, however, for variations.

.cp 6
.col
|The Macro-line

The macro\-line consists of a sequence of extended commands using semi\-colons
(;) as separators. A sub\-sequence, bracketed by ( ), and preceded by rp or <n> is
repeated indefinitely or <n> times; the brackets can be omitted for a single
repeated command.

Extended commands consist of one or two characters, possibly followed by one or
two parameters. F1 + (CTRL-)3 makes help available on the extended commands (and
the find/exchange qualifiers). Upper and lower case characters are treated as
equivalent. Parameters required may be numbers (use & to signify hexadecimal,
and other standard Archimedes conventions) or strings of characters, bracketed
at beginning and end by the same punctuation sign other than ';', '(', ')' - I
usually use'/'. An 'Invalid Syntax' report catches mistakes.

These command names are intended to be connotative, but potential clashes have
sometimes pre\-empted what would otherwise be the best choice. In Help_JGEdL
some commands are cited twice, so that groups of related commands can be seen
together. F1 followed by one or two letters provides a brief description of the
effects of individual commands.

There are simple editing facilities on the macro\-line; COPY and DEL delete
characters in the usual manner; <- and -> move the cursor left and right; SH-<-
and SH--> move the cursor to the beginning and end of the macro\-line; F11
empties the macro\-line. Any key without a defined effect will return the user
to immediate mode with the message "empty key"; F11, thence, restores the
macro\-line.

.if \u10 eq arc
However, F1 acts specially when on the macro-line; it  inserts into the
macro\-line the path that has specified the directory in which the file you are
editing was found. This makes inserting and saving to files in this or adjacent
directories very easy to specify; it is also useful if you want to use the
*/.../ command to execute some command at or near this directory.

Also, F2 acts specially when on the macro-line; it inserts the leaf name only of
the file being edited, i.e. the right part of the name after the last '.'. This
is useful, if you want to save, say, to the same or a related file name in this
or some other directory.
.fi

RET
.if \u10 eq arc
/Mouse-select
.fi
 hands the macro\-line over to be executed; the cursor need not be at the end of
the line when this is done.

.if \u10 eq arc
From the macroline, as mentioned above, clicking adjust restores the desktop
with a latent window representing this task; click on this window for a menu to
continue editing etc.
.fi

From the editing window,
.if \u10 eq arc
 F12 re-executes the current command line, F11
.fi
.if \u10 eq msdos
 Alt-F9 re-executes the current command line, Alt-F10
.fi
 reinstates it.

In extended editing: SH-F1-9 copies the macro\-line to the corresponding key;
CTRL-F1-9 copies the key string into the macro\-line at the cursor position;
.if \u10 eq arc
 CTRL-SH-F1-9 copies in the string after GSTransing.
.fi

In direct editing, these same control keys similarly install these strings on the
macro\-line. This completes the list of the 21 keys to enter the command line
promised above. (PRINT/F12/F11 are the only three that you will mostly use.)

These strings are held in the system variables Key$1-9, so can be set outside
this edit, and used in other edits. You can use Insert Variable/key$<n>/ to
insert them in the body of the text, so that you have them available next time.
Beware conflicts if you are concurrently doing more than one edit.
.if \u10 eq arc

SH-COPY splits the cursor so that Archimedes-style editing can be used. See
below for further details.
.fi

Any undefined key will return to direct editing, reporting line and column.
However, since f11 restores the last macro\-line, mistypes are harmless.

.cp 6
.col
|Blocks

Block Start and Block End define a group of lines to be a block; you can then
Insert a Block elsewhere above a cursor, Move a Block elsewhere above a cursor,
Write a Block to a file, Print a Block (only if no Wimp), or Delete a Block.
Attempting to Insert a block within itself produces the report "cursor inside
block". You can use the option l (see below) to Limit a search to within a
block. There is also Insert Under and Move Under. In the Wimp, via the latent
window,

Whenever you delete a block, it is held as a Scrap file (as
<wimp$scrapdir>.JGEdScrap); Scrap Read retrieves it below wherever your cursor
is. Scrap Write saves a block to Scrap without deleting it.

Finally pusH Block/SHIFT-F7 hides the block definition in an extra store, whence
pOp Block/SHIFT-F8 retrieves it; more importannt. using select-drag to define a
new block automatically pushes any existing block.

.cp 6
.col
|Insert File

You can Insert a File above the current line defined by the cursor; you give its
specification in the command line after the if command. Alternatively, you can
drag its file icon in the desktop from a filer to the latent window. Clicking
in the latent window opens a menu which allows access to save and writeblock
windows. Dragging on an icon for the filetype being edited in these windows to a
filer window writes the block or saves the whole file in that directory with the
filename set within that window. You can save or write a block directly from one
editing task to above the cursor in another another by dragging to the latent
window of the latter; in this case the filename in the former's window is
ignored. JGEd can exchange files with other applications that use the standard
interchange rules.

.cp 6
.col
|Find, Exchange, Insert and Count|

There are extended commands to Find, Exchange, Exchange with Query, Insert,
Insert Line above current, insert line After current and Count string
Occurrences. Strings may not include a new line; however the options s(plit)
must, and a(djacent) may, match strings on a pair of lines; option a allows
empty lines between the strings.

Count Words counts the number of words between the cursor position and the end
of the text (end of block for cw l). A word is deemed to be any number of
contiguous lower case letters, uppercase letters or digits.

If the letters of any of these commands are followed by a space, JGEd expects to
find one or more option letters as qualifiers before the opening bracket of
their string parameter(s). Qualifiers are listed at the end of JGEdL_help
(f1+3). i(nsert) applies only to Insert\/Exchange commands, which include il and
a; the rest apply only to Find\/Exchange\/Count Occurrence commands. Count Words
can only usefully be qualified by l(imited to the block. The qualifiers
s(plit) and a(djacent) use both Find and insert strings for finding.

rpeq/../../ will continue to suggest exchanges if y/n is tapped; any other key
ends the repeated exchange-query.
.if \u10 eq arc
Mouse-Select and Mouse-Menu are alternatives to y and n.
.fi

Qualifiers and the find\-string are case\-insensitive, except when the qualifier
c(ase) is used; the insert\-string, of course, is exact.

f be// will find an empty line; f l// within a repetition loop will limit it
to within a block; f o/.../ will continue the macro\-line rather than report an
error if ... is not found; note that the failure will not break the loop
immediately, but that the following commands until ')' will first be
executed. Of course, other commands, similarly qualified, behave similarly. (NB.
I may modify this later.)

.cp 6
.col
|Remembered Lines and Home

9 lines can be remembered at request by rl<n>; gl<n> will go to them. HOME/gh
takes you home. Home is, normally, the last line that you 'jumped' from, rather
than moved one line from. Jumping as a result of clicking Select does not reset
Home. The home line can be locked against alterations effected by later jumps,
or this lock can be released, by, immediate, CTRL-PG-UP/DOWN, and, extended,
Hold Home/release Home(X). Home is only set once in a macro\-line. (Therefore
you go back to the beginning of a repeated exchange.) Shades mark the Home and
remembered line if available in the current mode. gb and ge go to the
beginning/end of the current block. The Find line is set whenever you jump from
a line in a find or exchange. SHIFT-INSERT will take you back there
(resetting home). This is particularly useful if you have made a mistake by
going to far in an rpeq.

Whenever a find or a go command causes a new screen to be displayed, the
relevant line will be found about a quarter way down the screen.

.cp 6
.col
|Character Set Window

SHIFT-F7 switches on or off a dark green window in the bottom right of the
editing window which contains the Archimedes characters from byte 128 to 255 in
four lines of 32 characters each; it can also have an upper line for characters
0-31 (see below).

If the pointer is moved to one of the characters and Select is clicked, that
character will be inserted into the text at the caret.

Note that the text you are working with remains in existence below this window,
and, if you put the caret in this area, say by using the cursor keys, you will
insert or delete invisible characters. Briefly, don't.

.cp 6
.col
|Pixel Redefinition

You will also add the characters from 0 to 31 as an upper line if you have set
one of these from a file made from JGMkChar that includes one or more of these
characters. There is an Extended command Character Pixels /<string>/, which gets
the file pixelroot<string>, where pixelroot is initially <jgp$dir>.; Pixel Root
/<string>/ resets the root. Character pixels cancel (cq) restores the characters
in use to the standard Archimedes set.

These pixel redefinition facilities are intended principally to make the top-bit
set and vdu characters that appear on the screen accord with those used by your
printer, e.g. the standard PC-8 or PC-850 characterset used by many printers. If
you JGPrint to screen a text produced in this way, you will of course, see the
original Archimedes top-bit set unless you use JGSetChars (see JGCharDoc). The
VDU characters and 127 cannot be redesigned outside JGEd. A PC-8 file is
provided in !jgp for those whose printer (e.g.HP Deskjet) uses this character
set.

The redefinition of byte 127 will also extend left the 128-159 line of the
character set window to display 127.

Warning: if you redefine bytes 128 and/or 215, the tick and cross of the
macroline will be altered.

The pixel redefinition is cancelled when the edit is finished, and when leaving
for the latent window, restored on reentry to the own window.

Small Bug: it seems that bytes 128-144 are not restored in the !char window if
fx 25 0/4 is executed within JGEd, until a second redraw of the window, e.g.
after an f12.

.cp 6
.col
|Copying and the Selected String

.if \u10 eq arc
SHIFT-COPY enters Archimedes copy mode: the cursor keys and COPY take their
usual commandline meaning as opposed to their particular JGEd use; JGEd use is
restored by RETURN. Sharing state is temporarily rescinded. Warning: the
combination of JGEd and commandline rules may sometimes surprise. A report
appears, and after the first character has been written, the macro\-line is
displayed, so that useful macros can be copied to the text and preserved for
later use, by recopying them to the macroline.

.fi
The extended command Load String will copy characters from a single line into th
buffer 'selected string', using -¼> for insert and <- for delete; RETURN
completes the string. Qualified i i is equivalent to i/<selected string>/;
f f to f/<selected string>/; these qualifiers can be used with all find, insert
and exchange commands. Show String is also available.

.\ \+JGEdDoc1
.if 0
See Discussion at top of JGEdDoc1
.fi