AUTHOR AND VERSION.
P I E d i t o r f o r U n i x
by
G.B. Gustafson
Copyright 1985--2000
Version 20-April-2000
AUTHOR ADDRESS.
Regular and electronic mail can be used for communications. The GNU
Public License applies (see below). This software is not a product of
the University of Utah. There is NO WARRANTY.
Prof. Grant B. Gustafson
Math. Dept. Univ. Utah
155 South 1400 East
Salt Lake City, UT 84112-0090
gustafso@math.utah.edu [15-April-2000]
GNU PUBLIC LICENSE.
This editor is released as copyrighted material under the GNU PUBLIC
LICENSE:
NO WARRANTY
Because PI is licensed free of charge, absolutely no warranty is
provided, to the extent permitted by applicable state law. Except
when otherwise stated in writing, Grant B. Gustafson provides PI "as
is" without warranty of any kind, either expressed or implied,
including, but not limited to, the implied warranties of
merchantability and fitness for a particular purpose. The entire
risk as to the quality and performance of the program is with you.
Should the PI program prove defective, you assume the cost of all
necessary servicing, repair or correction.
In no event unless required by applicable law will Grant B. Gustafson
and/or any other party who may modify and redistribute PI be liable
to you for damages, including any lost profits, lost monies, or other
special, incidental or consequential damages arising out of the use
or inability to use (including but not limited to loss of data or
data being rendered inaccurate or losses sustained by third parties
or a failure of the program to operate with programs not distributed
by Grant B. Gustafson) the program, even if you have been advised of
the possibility of such damages, or for any claim by any other party.
NO COST?
This editor is provided free of charge to individuals and educational
institutions. Money is not requested.
WHY USE PI?
Unix editors are in abundance: ed, vi, emacs, jove. The complexity of
these Unix editors has increased over the years. Significantly, the
time required to learn each editor has also increased.
PI is made in the spirit of "simple" microcomputer editors. The
nucleus of keys required to run PI is very small: the arrow keys,
delete key, return and tab, menu key. Any editor function can be
selected from the pull-down menu. Memorization of keys is not
required.
There are some special features of PI that make it appealing:
MATRIX TEXT CURSOR. The text cursor moves independently of the
text to any row or column. Especially, the text cursor will move
beyond end of line and beyond end of file. This mode duplicates
what can be done by hand with paper and pencil.
LINE-BASED COPY, CUT and PASTE. To copy a collection of adjacent
lines, press F9 on each line, starting at the first and ending
with the last. This collects a copy of the block. Move the
cursor and press F10 to paste the block. It works like the
mouse, without dexterity problems.
VISUAL BLOCK. To de-mystify the mechanics of block operations, a
NotePad file collects all block text, where it can be viewed and
edited. An example for its use is to collect boilerplate text
from old letters, then finally paste the located snips into a
file.
MATRIX BLOCK. Solid rectangles of text with blank fill on the
right can be copied and pasted. No mouse work required.
LIVING CALCULATOR. An example: a TeX document has examples
labeled 1 to 45, but 4 have been deleted. With the integer
calculator, the examples are renumbered from 1 to 41. There are
three distinct calculators available: integer, floating-point
and scientific.
FOREIGN KEYBOARD. Entering text in foreign languages like
French, Slovak, Czech, German, Spanish, Finnish can use a
"foreign cycle table" in addition to native system keyboard
remaps. This system makes it possible to keep one keyboard
definition but still enter foreign text efficiently.
LINE NUMBERS. The cursor position on the screen and the current
line number are displayed (defeatable). There is a "GOTO LINE
NUMBER" on startup and also on menu "Edit".
CUSTOMIZATION. It is easy to add items on the menu and to bind
actions to keys or menu items.
DOCUMENTATION. There are three distinct kinds of online
documents which can be used during editing: plain text, html
browser and a quick reference.
LARGE FILES. Most MS-Windows and unix systems can read a 16mb
file successfully in about half a second.
FAST SEARCH. Modern systems can look through a 16mb file in
under one second.
ATOMIC JUSTIFICATION. Paragraphs or portions thereof are
justified left with ragged-right by an atomic command that acts
on the current line, borrowing from the next line to fill text.
This method is practical for everyday use.
BASIC KEYS.
Highest Frequency: Up, Down, Left, Right, Page Ahead, Page Back,
Scroll Ahead, Scroll Back, Return, Tab, Reverse Tab, Edge Left, Edge
Right, Edge Top, Edge Bottom, Top of File, End of File, Delete Right,
Delete Left.
The majority appear on menus, so it is not necessary to learn them
all at once. Function keys and keypad functions do all but a few of
these operations. See "Keymap editor" for a complete description of
each function and the keys mapped to it.
KEYMAP EDITOR
To display the key assignments for basic keys, press the MENU key
(see below or press ESC four times) and move with cursor keys to
"KEYS". Highlight the entry "Keymap editor" and press RETURN.
Move to the basic key with the arrow keys and read the key assignment
from the status line. A typical status line looks like this:
Keymap:^R:{PgUp}
The symbolc ^R means ctrl-R and {PgUp} is a second key on the
keyboard assigned to the same function. Multiple keys can be assigned
to a function. The keymap editor handles adds and deletes of keys.
In verbose mode, the status line will appear instead as
[PAGEBACK]{1020} Keymap:^R:{PgUp}
The [PAGEBACK] on the left is the source code symbol used by the
compiler and {1020} is the translation to an integer, which can be
used to assign a key to function "PAGEBACK". The information is only
useful for debugging the keymap.
To remove the key PgUp from "PAGEBACK" and add the key sequence ALT-p
in its place,
o Press MINUS (-) and then the key PgUp to delete the key.
o Press PLUS (+) and the the key Alt-p to add the key.
WARNING: key deletes apply to the current line in the keymap editor.
A log of the delete appears in PI.SET, in case you need to undo a
mistake.
The changes are inserted into the file PI.SET in the current
directory, or else in the system file PI.SET. You can edit that file
manually to inspect or delete automatically generated lines. To undo
a line in PI.SET, insert a comment character # or ; in column 1.
HOW TO DISPLAY KEY CODES. Start the "Keymap editor" and press "S".
The status line will show any key pressed in raw termcap codes. Use
RETURN to exit. Most function keys will emit codes that can be
inserted into the text by pressing ctrl-P first. The "escapes" in
termcap code are as follows:
Termcap C language Name
\e '\033' ESCAPE
\E '\033' ESCAPE
\b '\b' BACKSPACE
\f '\f' FORMFEED
\n '\n' LINEFEED
\r '\r' RETURN
\t '\t' TAB
^X 'X'-'@' Ctrl-X
TERMCAP KEY CODES RULES. The status line coding follows TERMCAP
rules: ^R means Ctrl-R, \E means ESCAPE. Function keys like F1 appear
on the status line as {F1}. The arrow keys are labeled {UP}, {LEFT},
{RIGHT}, {DOWN}. Other special key labels are {INS}, {DEL},
{BACKSPACE}, {HOME}, {END}, {PGUP}, {PGDN}, {ENTER}.
NAVIGATION. The keys available for navigation in the list are up and
down arrow keys. The SPACE key exits. A PERIOD key (.) executes the
command. Other keys are taken as a request to move the cursor to the
matching text. This includes function keys and multiple key
combinations like ctrl-K,ctrl-S (save file). Ordinary characters
match upper case letters and cause a search to begin, eg, "c" matches
"Cursor", "Center" and "Copy".
MOUSE USAGE.
On unix hosts with Xterm or Rxvt support there is positioning of the
cursor plus basic copy and paste.
Poorly documented in Xterm and Rxvt is how to make positioning and
copy/paste work together. Briefly, left mouse click will position the
cursor. The copy and paste functions require that SHIFT (also ALT for
rxvt) be pressed during these operations.
The best Xterm interface uses rxvt and a vga font. Most linux systems
support rxvt and a vga font. Other systems can import rxvt sources
and/or the vga font from a running linux system. The keymaps of RXVT
can be forced upon Xterm and NXterm by adding VT100 overrides to the
file $HOME/.Xdefaults or to the system XTerm application default.
Under MS-DOS with internal mouse support (a compile option; see
v14.c), mouse motion moves the cursor with scrolling in all four
directions. The left mouse button is RETURN and the right mouse
button is ESC (double-click right for the menu). If using MS-Windows,
then this option has limited use, because in order to use it and
windows copy/paste there has to be switching from full-screen to
windows mode. The compiled option can be disabled in PI.SET by
setting the mouse sensitivity variables equal to zero.
Under MS-DOS with external TSR xpcmouse.exe, there is copy and paste
relative to the visible screen plus cursor positioning. The clipboard
for this TSR is available in all DOS programs that don't capture the
mouse for their own use, even in MS-Windows. This interface works
with MS-Windows provided PI is primarily used in full-screen mode.
Then positioning, copy and paste appear to work normally. Under
certain setup conditions, namely EXCLUSIVE MOUSE MODE, it also works
in a DOS window, replacing for practical purposes the windows
copy/paste operations. The EXCULSIVE MODE interface is a lot of
trouble, since the expected Windows mouse copy/paste are disabled. It
is best to leave them enabled, then when positioning features are
required with the mouse, switch to full-screen mode, and back again
as needed. The combination SHIFT-ALT-BUTTON1 will copy the xpcmouse
buffer to the windows clipboard. It is possible to switch from
full-screen to window mode and bring data into windows applications.
Under MS-Windows 95/98/2000, the mouse interface for a DOS window is
easy to use and well-documented. To make PI easier to use in this
system, compile it without mouse support (the default). If later it
is decided to use mouse support, then xpcmouse can provide what is
required.
FILE FORMAT.
The basic file format is TEXT. Standard text files are used by
compilers, email programs, LaTeX and TeX programs, DOS or Unix
programs and utilities.
Foreign language text files can be created and edited, files that use
the extended ASCII codes 129-254 in addition to usual characters. All
of the MSDOS code pages are supported, so that a foreign language
keyboard and display can be matched. Unix support under X is limited
to available fonts. Favorite fonts are VGA for a DOS-style window and
some of the special code-page unix fonts that simulate what is
available under MS-windows. Lacking the exact code page font can be
problematic, the only cure being to substitute an available one and
live with it.
Text files from Apple MacIntosh, Microsoft MSDOS, Unix can be
imported or exported. Other file conversions are possible, for
example, WordStar to ASCII and other word processors that set the
eighth character bit.
Word processor formats are not supported.
KEY STANDARD.
This editor supports three major keyboard standards: Emacs, WordStar
and WordPerfect. Wordstar is the default, although a better keyword
might be "Borland" or "Microsoft NotePad".
As an emacs clone, PI places the majority of functions on menus and
implements only a critical mass of keyboard functions: cursor moves,
block marking, line and word deletes.
As a Wordstar-style editor, PI is similar to Microsoft Edit and
Borland International's Turbo products.
There is at present no VI support. It is possible to add it, but
there has been no demand for the feature.
PI used to run on these hosts: IBM PC, DEC-20/60, VAX 8600, SUN3,
SUN4, SUN386i, Stardent-Titan, DEC 3100, DEC 5000, DEC ALPHA, IBM AIX
(R6000 and 3790), SGI-Indigo. In the year 2000, the number of
different machines has been reduced to a small list: MSDOS, Win3.1
to Win2000, unix offered by IBM, DEC and SUN, and Linux on PC
hardware. There is no Apple Finder support.
TERMINAL.
Unix PI attempts to use system environment variables TERM and TERMCAP
to get terminal information. If these variables are unset, then PI
will assume terminal type VT100 and ask for confirmation, or ctrl-C
to abort. For a list of all supported unix terminals, execute the
unix shell command $PIE/tcapnames. Not finding a suitable terminal
from this list means that the file /etc/termcap has to be edited.
Under MSDOS the terminal type is not used. The assumed terminal is a
100% IBM compatible machine either monochrome or color. The editor
operates in high resolution text mode with direct screen writes to
segment address B000 or B800.
The only special MSDOS feature available is the video snow limiter
code which applies only to older CGA adaptors. The snow limiter
enable is set in resource file PI.SET. See SETUP below.
KEYBOARD.
The keyboard map is initially Wordstar keys plus function keys that
do not follow any special standard. The Keymap editor can change the
mapping based upon the installed keyboard itself, so expect to
customize PI to your system.
These remarks apply to Unix or VMS. Automatic default key set depends
upon the terminal. The only real support these days is vt100, so that
is what exists, although the code in PI will accept others which have
a termcap entry.
If the terminal does not match a known type, then a basic Wordstar
key assignment will be used and vt100 is assumed.
SETUP.
Under Unix, editor defaults like insert mode on/off can be set in the
resource file `~/.pirc' in your home directory. This file is supplied
automatically by PI: it copies `$PIE/SYSpi.rc' to the file
`$HOME/.pirc' to give you a private copy.
Under MS-DOS, the file name for editor defaults is PI.SET located in
the same directory as PI.EXE. The latter is expected to be in the
PATH set for MSDOS or the default connected directory. The location
can be changed from the default by using the environment variable
PIEINIT. See below.
Also expected in the same MSDOS directory as PI.EXE are PI.DAT and
PI.SET. The file PI.DAT is used to give key mapping reports. The file
PI.SET sets keys and serves as a way to load commonly used macros and
key definitions. If these files are not present, then the built-in
defaults apply. Notably, the keymap editor will not work.
Under Unix, the file names PI.SET and PI.DAT become ~/.pirc and
keymap.dat, respectively. Again, the setup files are expected to be
in the same directory as the executable.
LOCAL SETUP.
The file PI.SET under MSDOS can be copied to a local directory and
changed to effect changes that appropriate for that subdirectory. For
example, in one directory it may be appropriate to enable word wrap
but not in general. The local file PI.SET is read instead of the
global PI.SET.
The same advice applies under unix with the file ".pirc". If it is
present in a subdirectory, then it will be read on startup to reset
any global settings. In that system, it is impossible to get along
without the setup file ~/.pirc, because of read/write permissions on
the global setup files.
Macro keys and re-definitions of keys can be loaded automatically by
placing the file PI-MACRO.KEY in the subdirectory where the
automation is desired. Generally, this is a hack, and it is better to
place a copy of ~/.pirc in the subdirectory, then launch PI from that
location. The advantage is that macro definitions special to the
subdirectory are saved in ./.pirc instead of in ~/.pirc, a better
option for working on a project. The file pi-macro.key is a cheap
method for moving such macros to a new location, without copying the
entire setup file ./.pirc.
NORMAL START.
It is enough to type the name `pi'. If you want to edit an existing
file called MYFILE, then type `pi MYFILE' instead. See below for
other command line options.
COMMAND LINE OPTIONS.
The complete syntax is:
pi -dir:D -set:X -term:Y -key:Z -x -m FILE -gN
where each switch is described below.
-dir:D Use directory D for support files
Example: pi -dir:/usr/local/lib/pie/wdstar/
-set:X Use setup file X
Example: pi -set:/u/vi/peoples/.pirc
-term:Y Select terminal type Y
Example: pi -term:vt100
-key:Z Use key map file Z
Example: pi -key:$HOME/pi-dump.key
-x Special setup for PI running in an xterm window
Example: xterm -fn vga -geometry 80x25 -e pi -x &
Window properties can be set to customize colors,
fonts, scrollbars and borders.
-m Setup for unix workstation mouse under xterm window.
Normal xterm mouse clicks set the cursor. Cut and paste
require SHIFT to be depressed. See rxvt remarks below.
The X-windows mouse toggle "xmouse.toggle=1" in the
setup file .pirc does the same thing, but this command
line switch over-rides the setting in .pirc.
FILE A wildcard file list separated by spaces
Example: pi paper.tex p*.bib intro.???
-gN Go to line number N after file load
Example: pi paper.tex -g4872
The MS-DOS version ignores switches -x, -m and -term. There is a
version of PI for MS-DOS machines that need to set the terminal. To
that version please apply all remarks for the Unix version.
The -x switch applies to X-term windows that have no shell for exit.
It disables a shell exit (prudent if there is no shell). The -g
switch applies to the file name immediately preceding. One -g switch
can be given for each file.
Abbreviations are possible, e.g., "pi -s:X -t:Y -k:Z FILES".
More than one -set: and -key: may be supplied.
ENVIRONMENT VARIABLES.
The environment variable PIEINIT is used to shorten the command line
syntax or to provide a default. The statement
setenv PIEINIT '-set:X -term:Y -key:Z'
causes PI to reset its initial options. Subsequent command line
switches cause the defaults to be ignored.
Under MS-DOS the environment setup usually takes the form
set PIEINIT=-set:X -key:Z
SETTERM.
The preferred way to set TERM and TERMCAP under Unix for a vt100
terminal is by using the command
set noglob
eval `tset -Q -s vt100`
set term="$TERM"
unset noglob
XTERM and NXTERM.
A usual setup in $HOME/.Xdefaults for Xterm, NXterm and Rxvt is the
following. The last two iterms are likely ignored by Rxvt, but
important for Xterm, in order to keep a useful set of keymaps. If Sun
function keys are added, then the very last line will have almost no
effect on Xterm keymaps. Most attempts to add "xterm.geometry" have
failed, so it is left out (it has caused the Xterm menus to vanish,
without effecting any useful change to the geometry).
xterm*background: Yellow
xterm*foreground: Black
xterm*cursorColor: Red
xterm*charClass: 33:48,37:48,45-47:48,64:48
xterm*font: fixed
xterm*fullCursor: true
xterm*scrollBar: true
xterm*rightScrollBar: true
*eightBitInput: false
xterm*oldXtermFKeys: true
The useful keymap features of RXVT can be added to Xterm and Nxterm
once and for all by adding some text to $HOME/.Xdefaults, namely, the
Xterm.ad file distributed with RXVT. If you use both RXVT and XTERM,
then this is recommended, so that applications can have the same
keystrokes in both terminal programs. The text from a 1999 RXVT
distribution for Linux:
XTerm*vt100.translations: #override \
! [Key]BackSpace: string("\010") \n\
Shift[Key]Tab: string("\033[Z") \n\
Ctrl[Key]minus: string("\037") \n\
[Key]Home: string("\033[1~") \n\
[Key]End: string("\033[4~") \n\
[Key]Delete: string("\033[3~") \n\
Shift[Key]Delete: string("\177") \n\
Ctrl[Key]Delete: string("\010") \n\
Alt[Key]Return: string("\033\015") \n\
Alt[Key]space: string("\033\040") \n\
Alt[Key]a: string("\033a") \n\
Alt[Key]b: string("\033b") \n\
Alt[Key]c: string("\033c") \n\
Alt[Key]d: string("\033d") \n\
Alt[Key]e: string("\033e") \n\
Alt[Key]f: string("\033f") \n\
Alt[Key]g: string("\033g") \n\
Alt[Key]h: string("\033h") \n\
Alt[Key]i: string("\033i") \n\
Alt[Key]j: string("\033j") \n\
Alt[Key]k: string("\033k") \n\
Alt[Key]l: string("\033l") \n\
Alt[Key]m: string("\033m") \n\
Alt[Key]n: string("\033n") \n\
Alt[Key]o: string("\033o") \n\
Alt[Key]p: string("\033p") \n\
Alt[Key]q: string("\033q") \n\
Alt[Key]r: string("\033r") \n\
Alt[Key]s: string("\033s") \n\
Alt[Key]t: string("\033t") \n\
Alt[Key]u: string("\033u") \n\
Alt[Key]v: string("\033v") \n\
Alt[Key]w: string("\033w") \n\
Alt[Key]x: string("\033x") \n\
Alt[Key]y: string("\033y") \n\
Alt[Key]z: string("\033z") \n\
Ctrl[Key]Up: string("\033Oa") \n\
Ctrl[Key]Down: string("\033Ob") \n\
Ctrl[Key]Right: string("\033Oc") \n\
Ctrl[Key]Left: string("\033Od") \n\
Shift[Key]Up: string("\033[a") \n\
Shift[Key]Down: string("\033[b") \n\
Shift[Key]Right: string("\033[c") \n\
Shift[Key]Left: string("\033[d") \n
[The above code uses square brackets around "Key" instead of the
correct angle brackets, so it will display correctly in html
displays. For insertion into $HOME/.Xdefaults, change the square
brackets to angle brackets.]
It is possible to extend this list usefully, by adding codes for
ALT-1 to ALT-9. This gives a longer list of handy macro keys to
assign. It is unclear whether you will need to fool with the
backspace key, so it is commented out above. Generally speaking,
all comment lines should be removed from the Translations.
Additional keys needed for macros in Xterm can be designed from the
RXVT documentation for the keymaps. To wit:
Normal Shift Control Ctrl+Shift
Tab ^I ESC [ Z ^I ESC [ Z
BackSpace ^H ^? ^? ^?
Find ESC [ 1 ~ ESC [ 1 $ ESC [ 1 ^ ESC [ 1 @
Insert ESC [ 2 ~ paste ESC [ 2 ^ ESC [ 2 @
Execute ESC [ 3 ~ ESC [ 3 $ ESC [ 3 ^ ESC [ 3 @
Select ESC [ 4 ~ ESC [ 4 $ ESC [ 4 ^ ESC [ 4 @
Prior ESC [ 5 ~ scroll-up ESC [ 5 ^ ESC [ 5 @
Next ESC [ 6 ~ scroll-down ESC [ 6 ^ ESC [ 6 @
Home ESC [ 7 ~ ESC [ 7 $ ESC [ 7 ^ ESC [ 7 @
End ESC [ 8 ~ ESC [ 8 $ ESC [ 8 ^ ESC [ 8 @
Delete ESC [ 3 ~ ESC [ 3 $ ESC [ 3 ^ ESC [ 3 @
F1 ESC [ 11 ~ ESC [ 23 ~ ESC [ 11 ^ ESC [ 23 ^
F2 ESC [ 12 ~ ESC [ 24 ~ ESC [ 12 ^ ESC [ 24 ^
F3 ESC [ 13 ~ ESC [ 25 ~ ESC [ 13 ^ ESC [ 25 ^
F4 ESC [ 14 ~ ESC [ 26 ~ ESC [ 14 ^ ESC [ 26 ^
F5 ESC [ 15 ~ ESC [ 28 ~ ESC [ 15 ^ ESC [ 28 ^
F6 ESC [ 17 ~ ESC [ 29 ~ ESC [ 17 ^ ESC [ 29 ^
F7 ESC [ 18 ~ ESC [ 31 ~ ESC [ 18 ^ ESC [ 31 ^
F8 ESC [ 19 ~ ESC [ 32 ~ ESC [ 19 ^ ESC [ 32 ^
F9 ESC [ 20 ~ ESC [ 33 ~ ESC [ 20 ^ ESC [ 33 ^
F10 ESC [ 21 ~ ESC [ 34 ~ ESC [ 21 ^ ESC [ 34 ^
F11 ESC [ 23 ~ ESC [ 23 $ ESC [ 23 ^ ESC [ 23 @
F12 ESC [ 24 ~ ESC [ 24 $ ESC [ 24 ^ ESC [ 24 @
F13 ESC [ 25 ~ ESC [ 25 $ ESC [ 25 ^ ESC [ 25 @
F14 ESC [ 26 ~ ESC [ 26 $ ESC [ 26 ^ ESC [ 26 @
F15 (Help) ESC [ 28 ~ ESC [ 28 $ ESC [ 28 ^ ESC [ 28 @
F16 (Menu) ESC [ 29 ~ ESC [ 29 $ ESC [ 29 ^ ESC [ 29 @
F17 ESC [ 31 ~ ESC [ 31 $ ESC [ 31 ^ ESC [ 31 @
F18 ESC [ 32 ~ ESC [ 32 $ ESC [ 32 ^ ESC [ 32 @
F19 ESC [ 33 ~ ESC [ 33 $ ESC [ 33 ^ ESC [ 33 @
F20 ESC [ 34 ~ ESC [ 34 $ ESC [ 34 ^ ESC [ 34 @
Application
Up ESC [ A ESC [ a ESC O a ESC O A
Down ESC [ B ESC [ b ESC O b ESC O B
Right ESC [ C ESC [ c ESC O c ESC O C
Left ESC [ D ESC [ d ESC O d ESC O D
KP_Enter ^M ESC O M
KP_F1 ESC O P ESC O P
KP_F2 ESC O Q ESC O Q
KP_F3 ESC O R ESC O R
KP_F4 ESC O S ESC O S
XK_KP_Multiply * ESC O j
XK_KP_Add + ESC O k
XK_KP_Separator , ESC O l
XK_KP_Subtract - ESC O m
XK_KP_Decimal . ESC O n
XK_KP_Divide / ESC O o
XK_KP_0 0 ESC O p
XK_KP_1 1 ESC O q
XK_KP_2 2 ESC O r
XK_KP_3 3 ESC O s
XK_KP_4 4 ESC O t
XK_KP_5 5 ESC O u
XK_KP_6 6 ESC O v
XK_KP_7 7 ESC O w
XK_KP_8 8 ESC O x
XK_KP_9 9 ESC O y
An example: Add to the Translations the text
[Key]F16: string("\033[29~") \n\
to invoke the effect of RXVT's F16 onto the menu key (F16), which is
next to the Windows95 key on a Win95 keyboard. Then pressing F16 in
Xterm will generate the string "\033[29~" which can then be used to
produce some useful key in applications that can recognize it.
Please note that translations are not available in RXVT, the feature
is only found in Xterm. The translation feature in Rxvt exists, but
it is done differently than in Xterm. Execute "man rxvt" for details.
RXVT.
The international xterm called "rxvt" is available for unix. It
allows transparency of 8-bit characters and the mouse can be used in
a useful way. However, edits to Xterm also allow 8-bit transparency,
so try it first, before thinking that rxvt is needed.
The is also (1998) an edit of Rxvt called "xiterm" which tries to be
a replacement for the older MIT Ixterm. Probably all features worth
anything in xiterm have already been placed into Rxvt.
One known problem with Rxvt (1999) is pasting of text from other X
applications. Sometimes it fails, eg, Xmaple mouse-copying sometimes
cannot be pasted into Rxvt, but it will indeed paste into Xterm,
while text copied in an Xterm window always seems to paste into Rxvt.
The latter is an Rxvt workaround: paste application text into Xterm
and then copy it again for pasting into Rxvt. This problem does not
seem to exist for Netscape using its text-only message editor. Other
applications like Xfig and Gnuplot seem to be free of problems. One
could argue that the problem is Xmaple, except that regular Xterm
does not have a problem.
Other useful features of RXVT include a complete key mapping,
including ALT keys mapped as ESCAPE plus the character, e.g., ALT-x
maps to ESCAPE-x. The default for Xterm is the Meta key (Windows key
on 102 keyboards), different that the Alt key. See other references
herein to Xterm for a way to make Xterm and Rxvt have matching
keymaps, through $HOME/.Xdefaults.
The X-windows mouse can be used to position the cursor and/or copy
and paste text. To repeat, set "xmouse.toggle=1" in .pirc and press
the left mouse button to position the cursor, and press SHIFT plus
left mouse drag-and-release to copy text. To paste, press SHIFT and
then the right mouse button.
The advice given here for rxvt applies as well to xterm and nxterm.
It seems to always happen that some feature in one or more of these
terminal emulators is temporarily broken, so it is a good idea to
keep all of them running.
MENU.
The menu system in PI lists the majority of functions that the editor
can perform. To highlight an editor function apply cursor keys (or
press the letter displayed in upper case in its name). The
highlighted function is executed by pressing SPACE or RETURN.
The menu design parallels the MAC interface. The difference is that
the key assignment appears on the status line. It is recommended that
you learn key combinations for menu items used often.
To activate the MENU use one of these combinations:
DEC: ENTER key on the application pad
IBM 101: Dark Asterisk (*)
IBM 101: Two Dark Plus keys
IBM 101: ENTER key on the application pad
Ctrl-Underline
Two ESC keys
Four ESC keys
On a given keyboard, more than one combination might work. Choose the
one most convenient. The MENU key can be duplicated and changed - see
the section on keyboard reassignment below.
PURPOSE OF THE ENTER KEY.
The ENTER KEY is a special key that places the editor temporarily
into a command mode. The actual key varies among implementations. It
may be a single key or a sequence of keys. You will know that it
works because the cursor moves to the status line and the prompt
`ENTER: ' appears.
The idea behind the ENTER KEY is to reduce the number of keys
required by using postfix syntax. It is also useful for one-hand
typing of various commands.
In the command mode the expected input is:
NOTHING. The next key determines what happens as follows:
TERMINATING KEY RESULT
-----------------------------------------------------
Tab Reverse tab
Up Top of file
Down End of file
Paste line Paste notepad by line method
Kill to end of line Blank entire line.
Any search key Paste default search string
to status line.
Paste Paste last status line to
current status line.
A FILE NAME. The next key should be a file manipulation command
which can use the file name just entered. The possibilities
appear below:
TERMINATING KEY RESULT
-----------------------------------------------------
Open file Open file with supplied name
Save on disk Save as ... with supplied name
Close after save Save as ... with supplied name
Save as ... Save with supplied name
Exit after save Save with supplied name and exit
Inject file Inject file with supplied name
A SEARCH STRING. The next key should be a Forward search or
Backward search command. The action is the same as "New search"
without all the screen displays.
A NUMBER. The action taken on the next key is as follows:
TERMINATING KEY RESULT
-----------------------------------------------------
Page Up Cursor N pages forward
Page Down Cursor N pages back
Line ahead Cursor N lines forward
Line back Cursor N lines back
Copy line Add N lines to the notepad
Dup line onto notepad Add N lines to the notepad
Run macro Run macro N times
Kill line, add to notepad Delete N lines, add to notepad
Forward a window Forward N windows
GoTo line #. GoTo line number N
PASTE TEXT. The keys below copy text to the status line. They do
not terminate the status line input. The items are explained in
detail below.
KEY RESULT
----------------------------------------------------------
Any search key Paste default search string to status.
Note: Status must be empty.
Up arrow Paste a saved search string (50 saved).
Each uparrow recalls another search
string, until no more are left.
Dn arrow Back up in the saved search string list.
Stops at the default search string.
Paste directory Paste current buffer file name.
Tab Complete last token as a file name.
Backspace Paste token from screen to status.
BackTab Mung previous token as a unix file name.
Math key Replace status line by math result of the
line (considered a math problem) and
continue. There are several math keys.
See below, especially SciCalc.
EDITING THE STATUS LINE.
The status line prompts that accept search strings, file names and
words or phrases can be edited. Besides the left arrow and delete key
there are some other special functions available, all of which have
important uses.
a. A SEARCH key (AHEAD or BACK) pastes the default search string.
This only happens if the line is blank.
b. A PASTE DIRECTORY key yanks in the current buffer name (i.e.,
path name) in host format. Works anywhere on the line.
c. The TAB key completes a file name. To enter a TAB itself press the
QUOTE key (normally ctrl-V or ctrl-P) and then TAB. The match
proceeds from the last token before the cursor and therefore can
be applied anywhere along the line.
If an exact match occurs, then the file name appears on the status
line. Otherwise, the name entered has wildcards added.
Entering // (also \\ for MSDOS) will erase the current file name
and replace it by / (or \ for MSDOS). This feature eliminates the
need to erase long directory names. Shortcut: press // and TAB to
reduce a long directory name to /.
d. The REVERSE TAB key mungs the last token on the line to Unix
format. Useful under MSDOS for building command lines for GNU
utilities and TeX programs like sbtex and emtex.
e. The PgUp key hit on an empty status line causes a cursor move to
the top of the file. Similarly, ENTER plus PgDn moves the cursor
to the end of the file.
f. The Left Arrow key and the delete key remove one character left.
The Right Arrow key copies text at the buffer cursor position to
the status line, one character per key press, with blank fill if
beyond end of line.
g. The up arrow key recalls past search strings, which replace the
current status line text. After 50 up arrows the process ends. The
down arrow key reverses this process, until the default search
string again appears on the status line.
h. Other plain text can be typed in to change the phrase on the
status line. The QUOTE key can be used to enter ASCII control
characters. On an IBM keyboard, to enter ASCII codes 129-255, hold
down ALT and type the code on the numeric pad.
i. Ctrl-BACKSPACE (Backspace under Unix) injects a token from the
text buffer at the cursor. The END key is a duplicate key. It can
be repeated to quickly copy part of a line. It does nothing if the
cursor is at or beyond the end of line. Good for grabbing file
names, labels and search tokens from the screen without using a
mouse, especially for math computations.
j. The text on the status line can be interpreted as a math problem,
to which one of the math keys can be applied, to replace the
status with the answer to the math problem.
IntMath Replace status text with the integer math result.
Example: Status "4+5" becomes "9"
Extra trash on the line stops translation.
HexToBase10 Replace status text by its translation from hex
to decimal (base 10).
Example: "0x34fe" and "34Fe" translate to "13566"
OctToBase10 Replace status text by its translation from octal
to decimal (base 10).
Example: "0344" and "\344" translate to "228"
FloatMath Replace status text by the float math result.
Example: Status "34.5+6" becomes "40.5"
Extra trash on the line stops translation.
SciCalc Replace status text by its calculator result.
Supports scientific calculator functions like
ln(x), sin(x) and parentheses. Supports named
variables. Syntax is not forgiving.
Extra trash on the line is a syntax error.
Try them out yourself. The key maps are defined on the WORD menu.
If "Fill phrase buffer" is chosen from the "WORD" menu, then the
answer is saved in the phrase buffer, so it can be later injected
into the text or recalled. The calculations work on the status
line always, but it may be difficult to use it there.
k. The PASTE key copies the last status line onto the current status
line. All characters already typed are lost. If nothing is typed,
then the "last status line" text is unchanged. Generally, this key
is F10.
If you type something onto the status and accidently hit RETURN,
then press ENTER again followed by F10 to get back everything.
l. A number of editor function keys will cause immediate abort. The
most reliable abort is the menu key. The return key is accepted as
the end of input, meaning `go ahead, I did it right'. All abort
keys cause any typed text to be saved as "the last status line",
which is retrieved by F10 when the status line is active.
DELETING FILES FROM A PICK-LIST.
If a file list is presented in PI, then the DELETE LINE key (F4 or L4)
will mark a file for deletion. The INSERT LINE key (F3 or L3) will
unmark the file. Upon exit from the pick-list, a query appears on the
status line, for the actual deletion process. Each file is presented
and the following answers are expected:
Y Yes, delete the file
N No, don't delete it
Q Quit, forget about all marked files
A All, delete all the files without asking
? Other responses mean N: don't delete it.
In particular, SPACE and RETURN mean N.
ENTER KEYS FOR TERMINALS.
The ENTER KEY is chosen from these possibilities:
ENTER on the application pad
ESC,ESC key sequence
Dark+ on IBM 101 keyboards
The ENTER key is usually duplicated by many key combinations. For
example, on a Sun keyboard with any standard configuration, two ESC
keys or R1 invoke the ENTER key.
RETURN KEY AND LINEFEED KEY.
When INSERT is off, use RETURN to place the cursor on the left edge
of the next line. Repeat to adjust several lines.
When INSERT is on the function of RETURN changes depending upon the
method chosen in the initialization file PI.SET or ~/.pirc using the
setup value `return.insert.crlf'. The operation is as follows:
return.insert.crlf=0 No split line ever. Best typewriter emulator.
Same action as unix VI editor.
return.insert.crlf=1 Split line when INSERT is on. Emacs,
WordStar, WordPerfect.
The LINEFEED key ctrl-J can be used to replicate the function
described above for the return key in insert mode. It is a useful
combination to set `return.insert.crlf=0' in PI.SET and rely upon the
key ctrl-J (LINEFEED) to insert blank lines or split a line. About
half of the people using PI in Wordstar mode prefer this setup,
because unwanted RETURN keys are common.
In Emacs, Wordstar and WordPerfect emulation, the return key inserts
a new line.
In non-insert mode, the return key moves the cursor, but does not
insert text. The same is true of the TAB key in Wordstar and
Wordperfect modes.
Even in non-insert mode the action of the return key in insert mode
can be duplicated by ctrl-J (return is ctrl-M). This is used more
often at end of line than mid line. See below for how to set the
return key defaults.
TAB KEY AND REVERSE TAB KEY.
In non-insert mode the TAB key moves 8 columns at a time. An ENTER +
TAB moves in the reverse direction. The amount the TAB key moves can
be set: use the "VALUES" menu and apply "Tab and Margin". There are
also moves by word either left or right. These have been appended to
the table below because the functions provide a similar service.
The action of the TAB key is to insert spaces while reverse TAB
removes the spaces inserted by the TAB key. The state of insert mode
affects this rule: TAB and reverse TAB move the cursor when insert is
off, except for Emacs mode, where the state of insert does not affect
the action.
WordStar Emacs WordPerfect
-------------------------------------------------------------
ahead 8 columns Tab not used not used
back 8 columns shift-Tab not used not used
ahead one word ctrl-F ESC F ctrl-Right
back one word ctrl-A ESC B ctrl-Left
SHORT CURSOR MOVES.
Use the arrow keys for moves of a few characters. The normal
conventions are:
VT52/VT100 WordStar Emacs WordPerfect
---------------------------------------------------------
left arrow keypad 4 ctrl-S ctrl-B ctrl-X
right arrow keypad 6 ctrl-D ctrl-F ctrl-Y
up arrow keypad 8 ctrl-E ctrl-P
down arrow keypad 2 ctrl-X ctrl-N
On IBM-PC with compiled-in mouse the motions of the mouse move the
cursor.
DUPLICATE KEYS.
On an IBM-PC the arrow keys on the application pad duplicate the 101
keyboard arrow keys. On the MAC, use the keys on the application pad
and also any keys marked with arrows.
VERTICAL MOVES.
Vertical moves are done by cursor moves, page moves or the RETURN
key.
WordStar Emacs WordPerfect Duplicates
Page ahead ctrl-C ctrl-V PgDn R6:KP+:PageDn
Page back ctrl-R ESC v PgUp R3:KP-:PageUp
Return return return return none
Line ahead ctrl-Z ctrl-Z ctrl-Z none
Line back ctrl-W none ctrl-W none
Up ctrl-E ctrl-P UpArrow UpArrow
Down ctrl-X ctrl-N DnArrow DnArrow
The differences between the various ways of moving one line ahead or
back are subtle: in one case the cursor remains with the current line
and in the other the cursor moves. Page moves are by full screen with
no line of context. The cursor remains in the same screen location.
The commands of line ahead and back are used to change context
because they always cause lines to move on and off screen.
MOVE MANY PAGES.
To place the cursor ahead or back several pages:
Press the ENTER key.
Enter the number of pages NNN
Press the "Page ahead" or "Page back" key. See below for common key
assignments.
The action taken is to jump ahead or back NNN pages and refresh the
screen.
WordStar Emacs WordPerfect Duplicates
Page Back ctrl-R ESC V PgUp KeyPad-:R3
Page Ahead ctrl-C ctrl-V PgDn KeyPad+:R6:KeyPad,
MOVE MANY LINES.
To place the cursor ahead or back several lines:
Press the ENTER key.
Enter the number of lines NNN
Press the "Line ahead" or "Line back" key. See below for usual key
assignments.
WordStar Emacs WordPerfect Duplicates
Line Back ctrl-W ctrl-W ctrl-W none
Line Ahead ctrl-Z ctrl-Z ctrl-Z none
HORIZONTAL EDGE MOVES.
The cursor is placed at the start of the line or its very end, which
may imply a screen refresh, in case horizontal scrolling is needed to
display the targeted text. Usual key assignments:
WordStar Emacs WordPerfect Duplicates
Left edge ctrl-Q,ctrl-S ctrl-A Home+Left Home
Right edge ctrl-Q,ctrl-D ctrl-E End End
For horizontal edge moves the row remains the same and the column is
changed.
VERTICAL EDGE MOVES.
A vertical edge move places the cursor at the top or bottom screen
edge. No text scrolling will occur.
WordStar Emacs WordPerfect Duplicates
Top edge ctrl-Q,ctrl-E ESC , Home Up KeyPad5
Bottom edge ctrl-Q,ctrl-X ESC . Home Down
The precise result is to set column 1 for top and bottom moves.
END AND TOP OF FILE.
A move to top of file places the cursor on character 1 of the file. A
move to bottom of file places the cursor on the next character to be
entered at end of file. The refresh is therefore to the end of the
last line.
WordStar Emacs WordPerfect Duplicates
Top of file ctrl-Q,ctrl-R ESC < Home Home Up ENTER PgUp
End of file ctrl-Q,ctrl-C ESC > Home Home Down ENTER PgDn
GOTO A LINE NUMBER.
To goto a particular line number:
Press the MENU key and move to "EDIT". Choose "Goto line #" and
press RETURN.
Enter the digits for the line number.
Press RETURN.
SET BOOKMARK.
To set the current line and column: Ctrl-K,0
This is borrowed from Microsoft EDIT and Wordstar.
It's an experiment, to see if it is valuable.
GOTO BOOKMARK.
To goto the last marked line and column: Ctrl-Q,0
This is borrowed from Microsoft EDIT and Wordstar.
It's an experiment, to see if it is valuable.
CENTER TEXT IN MARGINS.
To center text on a line between the set margins choose "center Text"
on the "EDIT" menu. The left margin will always be 0. The right
margin is set by "Tab and margin" on the "VALUES" menu, default 72.
PARAGRAPH REFORM.
The principle use for this feature is to strip out unwanted blanks
and justify-left to a given right margin, default 72. The normal key
for reforms is ctrl--B for WordStar and WordPerfect keys, ESC-Q for
Emacs keys (Alt-Q on unix keyboards).
Reform can be executed from "Justify line" on the "EDIT" menu. It is
not especially convenient to do so. The reform key is a basic key.
Without the reform key, PI is fatally damaged.
SET REFORM MARGIN.
To set the right margin to 64:
Choose "Tab and margin" on the "VALUES" menu. Press RETURN to skip
the TAB set. Enter the number 64 at the margin prompt. Press
RETURN. If PERIOD is entered instead of 64, then the margin is set
at the cursor position.
REFORM SCOPE AND CONTEXT.
With auto indent ON, the reform scope for one reform key is one line
if the line is too long for the right margin, and two lines
otherwise. The reform context is from the cursor position forward.
With auto indent OFF, the reform scope is one line and the context is
again from the cursor position forward.
REFORM RULES.
Paragraphs are signaled by blank lines or leading white space. If
the cursor is at the front of the line, then all leading white space
is replaced by the number of spaces in a tab (which could be 0). All
other white space is truncated to one character per occurrence,
except at the end of a sentence, where one or two spaces are obeyed
and three or more are shrunk to two spaces.
Processing begins at the cursor, or the margin, so prior characters
are copied intact. Characters beyond the cursor and in particular the
set margin will be subject to reform.
One normal use for the reform key is to reform a hanging indent in
documentation. This requires auto indent, word wrap, insert mode and
hanging indent all ON. It will take a little practice to get it
right. Experiment!
HANGING INDENT.
When hanging indent is ON, blank fill occurs at the beginning of a
line to match the previous line. It is turned on and off by a toggle,
usually bound to ctrl-OU (auto-indent is bound to ctrl-OI, physically
next to it). Find it on the menu "Values" under "Hanging indent".
When this toggle is ON, paste from the mouse is problematic. It is
suggested to turn it off except when being used. It can be setup for
its default in PI.SET using the line
hang.indent.toggle=0; Toggle hanging indent mode (1=on,0=off)
hang.indent.toggle=1; Toggle hanging indent mode (1=on,0=off)
SPLIT LINE.
To split a line:
Position the cursor at the place to be split.
Select "Split line" on the "EDIT" menu. The cursor remains at its
original position. This is different than the action of RETURN in
insert mode because of the locked cursor position.
In the normal implementations of PI the LINEFEED key ctrl-J is
mapped to a more useful split line: ctrl-J splits the line and
moves the cursor to the next line.
JOIN LINES.
To join two lines:
Place the cursor at the start of the second line.
Insure that INSERT MODE is on.
Press DELETE to join the lines.
Lines may also be joined by deleting the word at end of line.
However, this method removes a portion of the line. Presently, lines
cannot be joined by pressing a delete key at end of line.
AUTO LINE SPLITTING.
Lines too long for the maximum line length are split on load and
separated by ctrl-B (`B' in inverse video at the start of the line).
To rejoin the lines, remove the ctrl-B at the front of the line. The
value for the maximum line length `line.max.chars' is set in the
resource file ~/.pirc or setup file PI.SET. Edit the file to increase
or decrease the maximum.
INSERT LINE.
To insert a line select "Insert line" from the "EDIT" menu.
WordStar Emacs WordPerfect Duplicates
ctrl-N ctrl-A,RETURN Home,Left,RETURN KP1:F3:L3:R13
The line is opened at the current position, which forces the old
current line down one. The cursor position remains unchanged,
pointing to the same location on the new blank line. When inserting a
line the cursor position along the line is irrelevant.
DELETE LINE.
To delete a line choose "Delete line" on the "EDIT" menu. The delete
line key is unique to WordStar and its clones. The duplicates are
implemented in Emacs and WordPerfect modes to make the operation a
single key.
WordStar Emacs WordPerfect
ctrl-Y ctrl-A,ctrl-K,ctrl-K Home,Left,ctrl-K,ctrl-K
Duplicates
KP3:F4:L4:R15
The position of the cursor along the line is irrelevant for the
delete line operation. After deletion, the line below becomes the
current line and the cursor position is unchanged.
ERASE LINE.
To erase to the end of the line, press the key below. To erase the
entire line, from column 1 to the end, press ENTER and then the key
below:
WordStar Emacs WordPerfect Duplicates
ctrl-Q,ctrl-T ctrl-K ctrl-K None
ctrl-Q,ctrl-Y none none None
On the "EDIT" menu the item is "Kill to end". The Wordstar
differences: ctrl-Q,ctrl-Y deletes to end of line but cannot join
lines. The other sequence acts like Emacs and Wordperfect.
DELETE MANY LINES NO SAVE.
To delete many lines select "Erase n lines" on the "EDIT" menu. A
prompt appears for the number of lines to delete from the cursor
position forward. The deleted lines are lost forever - very
dangerous! Very useful!
COPY LINE.
To copy the current line or a block of lines choose "Copy line" on
the "EDIT" menu. The menu system can be used to append the second and
further lines of a group or you can use the key shown on the status
line.
If multiple COPY LINE commands are given, then they start a new group
and append that group until another key is pressed. The first key
other than copy line ends the group. The menu key does not count as a
key for these purposes.
The DELETE LINE, KILL LINE and KILL WORD commands are used to form
groups also, in combination, but they cannot be mixed with COPY LINE,
since COPY LINE ends their group, and conversely.
The reason for the strange rule about mixing copy and delete is to
insure that the PASTE LINE operation will always paste a saved group
of consecutive lines.
The last ten previous groups are retained in an array. Also the last
group killed or copied is retained (until retired), making 11 groups
in memory at one time.
The last saved group can be pasted into the text by "Paste line" on
the "EDIT" menu. Other retired groups (10 max) can be pasted by
"Recover lines" on the EDIT menu. See PASTE LINE below for details
about how this works.
PASTE LINE.
To paste a line or block of lines at the cursor position, choose
"Paste line" from the "EDIT" menu. The paste applies only to the last
group saved. See COPY LINE above for more information on how the
lines are originally saved. See RECOVER LINES below for groups of
lines saved previously (not in the current group).
The reaction of the PASTE LINE key for a single line depends upon the
cursor position. If the cursor is at the front of the line, then a
new line is opened at the current cursor position and the text is
copied into the new blank line. The exception to this rule is when
the cursor is at the front of an empty line --- see below.
If the cursor is at the end of the line and only one line is in the
kill group, then PASTE LINE appends the current line (or a BELL if no
room to copy) but the cursor does not move. In particular, no extra
lines are opened.
If the cursor is mid line and only one line is in the kill group,
then PASTE LINE divides the line and appends the line from the group.
The cursor does not move, but the divided portion of the line appears
on a newly created line below the current line.
If the cursor position is beyond the end of line, then blanks are
added to fill to the current position and the copy proceeds as above
for end of line. No extra lines are opened to paste the first line of
the group. In particular, if the cursor is at the front of an empty
line, then the first group line is appended: no extra lines are
opened.
If the kill group has more than one line, then the first line gets
treated as above but remaining lines get copied into new lines below
the current line.
RECOVER SAVED LINES.
To recover one or more of the last 10 groups saved, choose "Recover
lines" from the "EDIT" menu.
The most recent saved group makes group 11. It is not in the list of
10 groups discussed here. For more information about the structure of
the 10 saved groups see MEMORY PURGE below.
The idea came from EMACS which allows previous kills to be recovered
(using bizarre rules). The PI implementation dumps the 10 arrays to
the screen one at a time from most recently used group to the oldest
group. Each dump is in inverse video. To keep or skip each one
respond to the status line prompt. The groups are unchanged by this
operation so that it can be repeated. However, future deletes WILL
change the array, so there is a transient nature to the saved groups:
they age and disappear automatically.
MEMORY USE OF SAVED STRINGS.
The array of saved groups contains 10 elements and the current group
recovered from the PASTE LINE key makes one more group. These groups
consume conventional memory. Under unix there is no lack of
conventional memory so the remarks below apply primarily to the PC
version of PI compiled in the medium memory model with large
pointers.
The catch is that files compete for the string space, so there has to
be space reserved in advance that files cannot use. The basic idea is
to reserve about 6 file buffers worth of space for strings. In even a
minimal installation that is about 24k of memory.
On a PC there is about 24k available total for the 11 groups,
although more is available if not used by files. This includes the
array size (500 lines normal) settable in PI.SET by variable
`killed.line.max'. An array size can be set so large that it consumes
excessive memory.
An array size of 100 and reserved space of just 24k can potentially
result in array allocations of 2200 bytes plus the line text involved
as the aged groups move down the array. About 300-400 full lines can
be saved before running out of memory whereas the setting of 100
lines might imply that 1100 lines can be saved.
Aging of groups moves a new first group and retires the last group
(10 groups total). All other groups are moved up one in the list. A
new group appears when a key change signals it or when the same key
is used repeatedly and the kill array becomes completely populated to
the array maximum size. An attempt to save a group of 200 lines will
result in two groups of 100 but no warning messages (the group size
of 100 is set in PI.SET).
Under normal use of the kill feature memory limits are never reached.
However, large kills of many lines, repeatedly, can cause the editor
to exhaust its 24k memory reserve. When this happens, all arrays are
dumped to the NotePad and memory gets recovered so the editor can
continue. A warning is sent to the status line.
MEMORY PURGE OF SAVED STRINGS.
The memory release of saved strings and their corresponding arrays
can be executed, without the NotePad dump, by pressing the key on
menu "EDIT" referenced as "Memory purge". See above for the exact
meaning of the memory release. Please note that this release is
permanent: it cannot be undone and all saved text is lost.
The NotePad dump can be simulated by "Paste lines" to dump the 11th
array into the NotePad followed by "Recover Lines". Both appear on
the "EDIT" menu. This manual dump must be executed while editing the
notepad to create the simulation. If done in another buffer, then it
adulterates the current text. Other than the location of the dumped
text, the result is the same.
ERASE CURSOR LINE.
To erase the line on which the cursor is placed, from front of line
to the end of the line, press ENTER followed by the key for "Kill to
end" on the "EDIT" menu.
This function is identical to "Cursor home" plus "Kill to end".
Consequently, the cursor is placed at the front of the line by this
function.
TRANSPOSE LINES.
To switch the current line with the previous line choose "Transpose
lines" on the "Keymap editor" in the "KEYS" menu. The key assignment
varies among implementations:
WordStar Emacs WordPerfect Duplicates
ALT-L ESC t ALT-L none
TRANSPOSE CHARACTERS.
To transpose the previous two characters before the cursor position
choose "Transpose characters" on the "Keymap editor" in the "KEYS"
menu. The key assignments:
WordStar Emacs WordPerfect Duplicates
ALT-T ctrl-T ALT-T ctrl-O,t
If there is only one character before the cursor, then nothing
happens. The transposition applies only to the current line, that is,
this operation does not affect the previous line.
DELETE CHARACTER RIGHT.
To delete the character right of the cursor press the following key:
WordStar Emacs WordPerfect Duplicates
ctrl-G ctrl-D Del Del:R9:KP9
QUOTE NEXT CHARACTER.
To enter a control code into the text choose "Quote next" on the
"Keymap editor" in the "KEYS" menu. The key assignments:
WordStar Emacs WordPerfect Duplicates
ctrl-P ctrl-Q ctrl-V none
ENTER EXTENDED CHARACTER.
Related to character quoting is the function which adds 128 to the
previous character, bound to ctrl-OE. See the keymap editor and
search for line
1050 Add 128 to previous character [EXTENDEDCHAR]
An ASCII code in the range 128 to 255 represents a character in
iso-8859 codes for common language extensions. Addin 128 is an
alternative and faster method for entering extended characters.
The entry of extended characters on an IBM keyboard is made from the
application pad using the decimal Ascii code. Here, the ALT key is
held down while a number is typed on the application pad. For
example, 225 results in greek beta. This convention makes the
extended character entry less likely to occur by accident.
See also the FOREIGN CHARACTER CYCLE TABLE for entry of foreign
characters by the cycling method.
REVEAL FUNCTION KEY CODES.
The quote key is used commonly in the inspection of function keys. On
most terminals you can press the quote key and then a function key to
reveal the exact sequence emitted by the function key. Naturally the
codes get inserted into the text, so it is useful to do this in the
notepad or a scratch buffer.
Example. Inject codes for F10 into the text.
Press ctrl-V for Emacs or Wordperfect mode, ctrl-P for Wordstar
mode. Press F10. The codes will appear at the cursor position. On
an IBM-PC you should see `C' with cedilla plus `D'. This stands for
ASCII codes 128 and 68 (decimal). The PI editor does not use code 0
for strings so all code 0 keys get mapped to 128.
SEARCH TOKEN FOR BEGIN/END LINE.
The character used in a search string to indicate the beginning or
end of a line has to be unusual so that it does not conflict with
ordinary text. This value is normally set to -128 in the PI.SET or
".pirc" source file using the resource line
search.token.lf=-128; Token in search string used for begin or end line
The value -128 is the sign extension to integer data type from the
character value '\200' (128 decimal). This is the editor's internal
idea of the NULL character which is entered by Ctrl-Shift-@.
Under unix, pressing the key Ctrl-Shift-@ produces the null
character, which the editor translates into 0+128 or '\200'. On an
IBM-PC, the sequence Ctrl-Shift-@ is not the null character, so we
define a key sequence to make it so, in agreement with unix usage.
This key sequence is compiled into the editor defaults, so you don't
need to set the key.
In addition, the control Ctrl-O,z is used as a second sequence to
insert this unusual character, in case Ctrl-Shift-@ does not work,
e.g., using Kermit remotely.
The action taken for this search character was described in the
section on searching. To reiterate, if the token is first in the
search string, then the search must match the beginning of the line.
If the token appears at the end of the line, then the search must
match the end of the line. For example, two successive tokens match a
line with empty contents, i.e., a blank line.
The bad thing is that you cannot search for this special character at
all, unless it happens to be in the middle of a search string. For
example, search string "XX " will search for zero token X followed
by a space at the beginning of a line. If zero token X is the only
character on the line, then search string "XXX" will find it.
EXAMPLE. Replace each adjacent pair of empty
lines by one empty line.
SOLUTION: Start a macro, searching for an empty line. The search
string is Ctrl-Shift-@ plus Ctrl-Shift-@. Search again for an
empty line (two searches total). Put the cursor on the previous line,
at the beginning. Search on this line only for the same search string
(Ctrl-O,F). Delete the line. End the macro.
Naturally, this macro won't be defined unless there **IS** a pair of
adjacent empty lines in the file. Assuming the macro was defined,
successfully, then press F7 or L7 enough times to search and replace
the whole file.
What about the **BEEP** on each failure?
The fix: save the current macro under key Alt-1 (for example). Make
the current macro give an argument of -1 and then invoke Alt-1. This
macro is silent. The macro key F7/L7 is normally a repeat key, so you
can hold down on it to accomplish the replacements.
UNIX FOREIGN CHARACTER SETS AND FONTS.
Since X displays Xterm windows with a default character set of 128
characters, the so-called fixed fonts, required foreign fonts are not
readily available for novices. Some unix setup is required to get the
foreign sets on screen. Most foreign sets can be displayed under X.
For Xterm or Rxvt, the command line syntax is
xterm -fn fontname &
to load the application with a different font "fontname". Therein is
the catch: you have to know the fontname. To find font names, use the
X applications "xlsfonts" and "xfontsel".
To some extent, changes can be automated by sending escape sequences
to Xterm, e.g.,
echo -e "\033]50;fixed\7"
echo -e "\033]50;vga\7"
will change to font "fixed" or "vga" respectively. A font change can
be executed from a macro using "Execute script" on the PI menu.
To make a macro to change to font "fixed", press these keys:
1. F8 (select "Recording" on the "Keys" menu)
2. ^O^Q (select "Execute script" on the "Tools" menu)
3. echo -e "\033]50;fixed\7"
4. RETURN
5. F7 (select "Replay keys" on the "Keys" menu)
The macro can be saved on the "Keys" menu, and finally added to the
"Tools" menu where it can be used. The key used to save it can be
deleted, because items on the "Tools" menu can be executed without a
key binding.
MS-DOS FOREIGN CHARACTER SETS AND FONTS.
If working under Windows 95/98/2000, then only the code page setup
applies. Hopefully, this is the default for most everyone, but other
information is recorded here to cover older machines with Windows 3.1
or earlier.
WINDOWS 3.1-2000.
Apply the ideas below to the batch file that replaces autoexec.bat in
the startup of a give DOS window. No config.sys are required. The
example is for code page 852, which corresponds to languages like
Slovak and Czech, using latin2 fonts. These commands do not affect
the keyboard in Windows; see Windows help for adding special
keyboards.
@echo off
mode con cp prepare=((852) c:\windows\command\ega.cpi)
mode con cp select=852
OLDER DOS SYSTEMS.
The font support situation with IBM-PC machines is completely
different since support for many foreign character sets has been
built into DOS 5.0. Assumed is a VGA or EGA display, extended
keyboard with F12 key and DOS 5.0 or later. It will work with the
Hercules or CGA video adaptors provided the language is supported by
the standard USA character set (in this case, no special setup is
required). Illustrated below is the method of setup for the Czech
character set. Similar remarks apply to the others supported by DOS
5.0. Choose **ONE** of the methods below. The first is the simplest.
DOS 5.0+ CODE PAGE METHOD.
In order to use this feature of DOS 5.0, the following lines are
required in CONFIG.SYS. The purpose here is to reserve space in main
computer memory for the Czech character set (see DOS 5.0 manual) and
also the USA character set. No character data gets loaded nor is
there a switch from the USA character set, until a mode command gets
issued at the DOS prompt --- see below.
country=042,,c:\dos\country.sys
device=c:\dos\display.sys con=(ega,852,1)
To load the Czech character set data into memory and switch from USA
set to Czech set, the following lines are required, typed at the DOS
prompt. See the DOS 5.0 manual for details about the mode command.
mode con codepage prepare=((852) c:\dos\ega.cpi)
mode con codepage select=852
The commands above are generally placed in a batch file in order to
automate the task. Names like czech.bat are common.
The DOS CODE PAGE method is far from ideal because it has a lot of
system overhead and it lacks portability across different versions of
DOS. Moreover, it is difficult to undo the effects.
GRIFFITH'S FONT EDITOR AND TSR.
An easy solution is to use the code page 852 fonts from "Font Editor
v3.0" by S Griffiths (1993). This shareware font editor is full-
featured and solves the problem of font creation and management
for most European languages. It is available at ftp://www.coast.net/.
His editor allows you to make a permanently installable TSR that
keeps the font in memory, or it can be a transient program loaded
with the editor itself. The best part of this is customization of the
font and the possibility to solve the same problem with other
languages.
The mechanics of loading different fonts is as follows. Make a batch
file that contains the commands need to load the font and then attach
the running of that file to a macro key. The "VGA Font" item on the
"QUIT" menu is such a link. The batch file contents that work with
Griffith's fonts:
Loadhigh c:\usr\CP852F16.COM
The COM file is made from the font editor by loading (F10) in a font
called CP852F16.FNT, then saving (F5) it as a COM file. Pretty easy?
Some laptops and portables have very complex problems related to
loading alternate character sets. Experiments are required to see if
it will work (at all). The main disadvantage of Griffith's TSR is
that there is no way to unload it from memory.
YOSSI GIL'S LOADFONT.
According to the doumentation, this program loads a user-defined font
to EGA/VGA. The version tested is 1.5, Jun 09 1993 Copyright (c)
1991-1993 by Yossi Gil, P.O.Box 3148, Jerusalem, ISRAEL, Email:
yogi@cs.technion.ac.il [available at ftp://www.coast.net/].
The operation with the font described above is
LOADFONT CP852F16.FNT
which stuffs the character set into the VGA adapter, while PI is
running, from a batch file like VGAFONT.BAT. The advantage of this
method is that the effect lasts only a short time and there is NO
SYSTEM OVERHEAD (no memory use).
The disadvantage is in forking tasks from PI, for example, a DVI
viewer will reset the text mode and therefore undo Yossi's font load
to the VGA adaptor. Of course, you can load it again, but that is one
more element of trouble.
FOREIGN CHARACTER CYCLE KEY.
This version of PI allows for extended character entry for foreign
character sets.
The basic key manipulation involves just one key on the keyboard
called the "Foreign cycle key". On an IBM-PC it is ctrl-\ or F12. See
the "Keymap editor" on the "KEYS" menu for the actual key assignment.
The idea for the use of the "Foreign cycle key" is to change the
character just left of the cursor by rules outlined below. In most
cases the possibilities for the change are among two or three
characters: a base character from the English set and one or two
foreign characters that look like it. For example, `?' and its upside
down Spanish version might occur as a pair and each press of the
cycle key produces the other member of the pair.
The basic ideas of operation for Czech characters are as follows:
Long vowels a, e, i, o, y (lower and upper case). Press F12 when
the cursor is just to the right of the vowel.
Long vowel u. Press F12 once or twice. The first press produces the
long u used at the front of a word, while the second press produces
the long u used inside a word.
Hooked vowel e. Press F12 twice. The first press produces long e,
the second hook e.
Hooked consonants c, d, n, r, s, t, z (upper and lower case). Press
F12 when the cursor is just to the right of the consonant.
Key F12 cycles among the choices. There is no danger in pressing
F12 too many times. No action occurs if F12 is pressed for a
non-Czech character.
OTHER FOREIGN CHARACTERS.
The macro keys can be used to insert new characters into the text
with a single key press. Function keys are best for this application.
A usual example: record a macro that inserts the character. Map it to
function key F11. To enter the special character press F11.
It is possible to directly enter extended characters 129-255 ASCII.
The procedure: hold down ALT and type the decimal ASCII code from the
application pad. When ALT is released the extended character will
appear on the screen at the cursor position. This procedure also
works for ASCII codes 0-127, which is important to know because of
the possibility of a typo.
FOREIGN CHARACTER CYCLE TABLE.
The Czech character set cycle table is below:
OLD NEW
------------------------------------------------
' ' 243 /* Hook on blank space */
'a' 160 /* long vowel, lower case */
'e' 130
'i' 161
'o' 162
'u' 163
'y' 236
'c' 159 /* hook consonant, lower case */
'd' 212
'n' 229
'r' 253
's' 231
't' 156
'z' 167
'A' 181 /* long vowel, upper case */
'E' 144
'I' 214
'O' 224
'U' 233
'Y' 237
'C' 172 /* hook consonant, upper case */
'D' 210
'N' 213
'R' 252
'S' 230
'T' 155
'Z' 166
163 133 /* long u to u-circle */
133 'u' /* u-circle to u */
130 216 /* long e to e-hook */
216 'e' /* e-hook to e */
144 183 /* long E to E-hook */
183 'E' /* E-hook to E */
The algorithm works as follows. The character X left of the current
cursor position is read. An attempt is made to match X against a
character in the "OLD" column. If it works, then X gets replaced by
the corresponding character in the "NEW" column. Otherwise, a second
attempt is made to match X from the "NEW" column. If successful, then
the corresponding character from the "OLD" column replaces X.
The basic idea works as long as the characters are based on accented
versions of some standard letter in the alphabet. It does not work on
Greek, Russian or Chinese because the alphabets are too far removed
from the Latin character set on the USA keyboard.
To load the foreign cycle table requires the same action as a keymap
load. In fact, the table can be kept in the same physical file
already used for private keymaps or macros, usually called PI.SET
(or ~/.pirc under unix).
A usual load for Czech keys would appear as below in the file PI.SET:
31000
foreign=
foreign=\325R\374S\346T\233Z\246\243\205\205u\202\330\330e\220\267\267E
foreign=\347t\234z\247A\265E\220I\326O\340U\351Y\355C\254D\322N
foreign=\40\363a\240e\202i\241o\242u\243y\354c\237d\324n\345r\375s
The internal loading occurs in the reverse order of the lines, but
left to right. Entries must be in pairs, as explained above. The
first line releases any memory already assigned to the foreign cycle
table. Each of the other lines appends the table (in reverse order of
lines). The maximum total length of the cycle table is 510 bytes.
This refers to the loaded size after decoding - the above table is 66
characters long in decoded form.
The number 31000 starts in column 1. It is used to alert the loading
program that the cycle table will be loaded next. It does not
correspond to a key assignment. Without the 31000, nothing happens,
which is by design.
The characters in the cycle table above are represented by octal
escape sequences. This is not required on an IBM-PC. Under unix it is
advisable because 8-bit characters are unreliable for display (font
support is possible in X11R5 and later).
CHARACTER TO LOWER CASE.
To change the character at the cursor to lower case use the key map
given by "Change character at cursor to lower" on the "Complete key
list" in the "KEYS" menu.
In Wordstar mode this is ctrl-O,l. It is not enabled in the other
modes. Used primarily in macros.
CHARACTER TO UPPER CASE.
To change the character at the cursor to upper case use the key map
given by "Change character at cursor to upper" on the "Complete key
list" in the "KEYS" menu.
In Wordstar mode this is ctrl-O,u. It is not enabled in the other
modes. Used primarily in macros.
NEW SEARCH.
To start a new search forward or reverse choose "New search" on the
"SEARCH" menu. A prompt appears for a new search string.
The search string can be replaced and edited on each invocation. It
responds to F5 or F6 as license to carry out the default search. To
recall and edit the default string press Up arrow on a blank status
line. Once text appears on the status line, the up arrow recalls the
50 past search strings in chronological order, cycling finally to the
default search string.
The other search commands simply seek out a match either forward or
reverse on the default search string. They are mapped to easy to
reach function keys like F5 and F6 (L5 and L6 on SUN keyboards) or
the PERIOD and ZERO application keys on a DEC or MAC keyboard.
The search matches are forced to the center line of the screen. It
seems to provide good context in the majority of cases. A search
failure rings the terminal bell and also stops any repeated operation
or macro.
Backward search performs as expected by any novice, seeking the next
match backwards, first on the current line, then on previous lines.
This search will not match the current position.
Searches can be made starting at the beginning of a line or matching
the end of a line, by including a special character in the search
string (called a token). The token is normally mapped to control -
shift-@, which is char 0, but the editor maps this again to ASCII
128. Nevertheless, we call this character token the ZERO token,
because it represents the null at the end of a line, which the editor
uses to replace the cr/lf combination at the end of lines. The ZERO
token is defined in the pi.set or .pirc source file on editor startup
as -128, because of sign extension of characters by most C compilers.
You can change the token character, but be careful of sign extension.
Searches for the beginning of line should have the ZERO TOKEN at the
front of the line. Matches for the end of the line should have the
ZERO TOKEN as the last character in the search string. A particular
case is an empty line, which is searched for by entering a search
string with two ZERO TOKENS.
Searches restrained to the current line will match forward from the
current cursor position, and backward from a position to the left of
the cursor position. With two exceptions: if the search string
contains one or two tokens for the end or beginning of line. In this
case, the logic is applied that an empty search string can still
match the end or beginning of the line. An interesting case is this
kind of search applied on an empty line with search string equal to
two ZERO tokens. Searching forward matches! Therefore, the search
succeeds, but does not move the cursor.
The line search is helpful in trying to delete successive blank
lines. A search forward is made for a blank line using two ZERO
tokens. Then press RETURN to go down one line and search that line
for the same string. It will fail if the line is not empty and
succeed otherwise. Therefore, if this logic is in a macro, then the
macro can proceed after the successful search to delete the extra
blank line!
The highlighting of search matches is done for all searches. On
certain X window displays this is annoying because of a non-blinking
cursor (may be cured by X some day).
SEARCH FORWARD.
To search forward for the default search string choose "Search
forward" on the "SEARCH" menu. This is usually mapped also to
function key F5 or L5 or PERIOD on the application pad.
The default search string is replaced, provided the search starts
with the ENTER key, a new string, and the string entry terminates
with Ctrl-O,f or its equivalent (F5, L5, PERIOD).
Pressing Ctrl-O,f (or F5, L5, PERIOD) directly after the ENTER key
will produce a copy of the last search string. Use UPARROW to cycle
through the last 50 search strings. End with Ctrl-O,f (or F5, L5,
PERIOD) to begin the search.
SEARCH BACKWARD.
To search backward for the default search string choose "Search
backward" on the "SEARCH" menu. This is usually mapped also to
function key F6 or L6 or ZERO on the application pad.
The default search string is replaced, provided the search starts
with the ENTER key, a new string, and the string entry terminates
with Ctrl-O,b or its equivalent (F6, L6, ZERO).
Pressing Ctrl-O,b (or F6, L6, ZERO) directly after the ENTER key will
produce a copy of the last search string. Use UPARROW to cycle
through the last 50 search strings. End with Ctrl-O,b (or F6, L6,
ZERO) to begin the search.
SEARCH LINE ONLY FORWARD.
To search the current line only forward for the default search string
choose "..within line" on the "SEARCH" menu. This is usually mapped
to key Ctrl-O,F. This function has a definite use in macros, to test
the existence of a string on the line. The search fails if the string
is not matched.
Unlike the F5 search, the search begins at the current cursor
position, rather than one character to the right. In particular, a
search for Ctrl-Shift-@ plus Ctrl-Shift-@ will succeed on a
completely empty line, provided the cursor is at the start of the
line.
The default search string is replaced, provided the search starts
with the ENTER key, a new string, and the string entry terminates
with Ctrl-O,F or its equivalent.
SEARCH LINE ONLY BACKWARD.
To search the current line only backward for the default search
string choose "..within line" on the "SEARCH" menu. This is usually
mapped to key Ctrl-O,B. The search begins one character to the left
of the current cursor position.
The default search string is replaced, provided the search starts
with the ENTER key, a new string, and the string entry terminates
with Ctrl-O,B or its equivalent.
QUERY REPLACE.
To search for a string and replace it, do these steps:
Press the MENU key and move to "SEARCH". Choose "Query/replace" and
press RETURN.
The string last searched will appear. Once text appears on the status
line, the up arrow recalls the 50 past search strings in
chronological order, cycling finally to the default search string.
Make changes and press RETURN. If the search fails, then so does
Query/Replace.
REPLACE: Y=Yes, A=All, Q=Quit, P=Prev, N=Next [N]: will appear on
the status line. The string match appears in inverse video. Press
one of the letters YAQPN or RETURN to take appropriate action.
The string replacement last used will appear the first time you
try to make a replacement of text. Make changes and press RETURN.
This string is used until you QUIT or a search fails. A blank
string is acceptable.
Listen for the bell as you proceed - it signals the end of the
Query/Replace (typing Q is a silent exit).
TOGGLE FOLD CASE FOR SEARCHING.
The switch is "Fold case on/off" on the "SEARCH" menu. For case fold,
the search string is mapped to upper case, and the target strings are
mapped to upper on compare. You can detect case fold by the uppercase
search string, displayed on the status line or by applying the toggle
twice.
SET REPEAT COUNT.
To set the repeat count for the next key choose "Set repeat count" on
the "Keymap editor" in the "KEYS" menu. The key map is usually
ctrl-Q,ctrl-Q (Wordstar) or ctrl-U (Emacs).
Repeat counts can be given to a saved macro. These will always run
verbose. The default macro is the only one that can run silent, but
it can call the saved macros, causing them to run silent also. The
default macro can also run off a repeat count, but this is again
verbose, never silent.
Silent running of the system macro begins by ENTER and then a
negative count, followed by the key for the default macro (F7 or L7
is a normal function key).
Repeat counts can be given to a number of other keys. Basically, it
must make sense. Examples: cursor keys, page and line moves, insert
and delete line, return key, tab key, delete word, word moves.
MEMORIZE STEPS.
To memorize a sequence of key strokes:
Press the MENU key and move to "Keys". Choose "Memorize keys" and
press RETURN. The status line should display the key to press
which ends the memorization process.
Key in the steps as usual. These steps may contain macro execution
keys (exceptions below).
Press the key displayed on the status line advertised to end
memorization.
A tactical error is to go back to the "Keys" menu and choose
"Memorize keys" again, which discards all steps to that point and
starts memorizing again! However, it is correct to choose "Replay
keys" to end the macro definition.
REUSE. The macro buffer gets erased each time a new recording is
started. To save the current macro text, press the MENU key, move to
"Keys". Choose "Save current macro" and press return. A prompt
appears for a key sequence on which to save the macro. See the text
below about saving macros.
EXECUTE MEMORIZED STEPS ONCE.
To execute memorized key strokes just once, press the key for "Replay
keys" on the "Keys" menu. This is always verbose.
STOP MEMORIZE.
The same key as used above stops the memorization of macro steps.
EXECUTE MEMORIZED STEPS MANY TIMES.
To execute memorized key strokes N times and view the progress
(verbose mode):
Press the MENU key and move to "Keys". Choose "Repeat replay #"
and press RETURN.
Type the digits of the number N. Press RETURN.
To abort, press any key (right arrow is a good choice). To stop
type--ahead macros, press the abort key, usually ctrl-U or ctrl-C or
ctrl-G.
SILENT EXECUTE MEMORIZED STEPS MANY TIMES.
To execute memorized key strokes N times, silent running:
Press the MENU key and move to "Keys". Choose "Repeat replay #" and
press RETURN.
Enter a minus sign `-' and the digits of the number N. Important:
the minus sign signals silent running!
Press RETURN.
To abort during the run, press RETURN.
To stop type--ahead macros, press the abort key (ctrl-U or ctrl-C
or ctrl-G depending on the setup file PI.SET or ~/.pirc). To be
absolutely correct, most any key will stop the macro.
SAVE CURRENT MACRO.
To save the current default macro choose "Save current macro" on the
"Keys" menu. A prompt appears for the key sequence to be assigned to
this macro. If successful, then the current macro and the newly saved
one are identical.
A new macro can be saved again with the same key used previously.
There is no complaint about re-using a previously assigned macro key.
Naturally, the contents of the previously assigned macro are lost,
but they are saved in PI.SET (or .pirc) as a comment.
The macros get saved in an array of default size 256, this size being
set up in PI.SET. A saved macro only uses the actual number of bytes
in its description, usually a lot less than 256 bytes. The array used
to save macros uses conventional memory so it should not be
artificially large. About 25 is a good number. See PI.SET.
These macros can be nested to 10 deep: macro 1 can call macro 3 and
it can call macro 7, etc. Deep recursion is detected. A key hit
during a macro aborts it.
RUN NON-DEFAULT MACRO.
To run a macro that has been saved you don't need to remember the
key to press which invokes the macro. Press the MENU key and move to
"Keys". Choose "Macro editor" and press RETURN. The editor will load
a buffer with the current state of the macro keys. The macro can be
run by pressing PERIOD.
ABORTS DURING RECORDING.
If you are recording and press the key for "Replay keys", then
macro recording will cease and the macro is defined. To make the
macro inactive, press "Record" and then "Replay" keys; see below.
EMPTY MACRO.
If a macro buffer contains no characters, then no action will
result from pressing the "Replay" key.
DYNAMIC RE-DEFINITION OF MACROS.
Any macro key can be re-defined at any time. This can be a
pleasant feature or an unexpected disaster. Fortunately, macro
text is documented in PI.SET. If there is a problem, then look
there for a way to recover the macro text.
RECURSION IN MACROS.
More than 10 levels of recursion will cause the recording to
abort. Macro 1 can call macro 2, and it can call macro 3, etc, up
to 10 deep. The common error is a cycle: 1 calls 2 and 2 calls 1.
Cycles occur by dynamic re-definition which in practise is
difficult to achieve but nonetheless possible.
DEFINE KEY AND DEFINE KEY DUPLICATE.
Keys are defined by a keymap source file upon load of PI, or by
adding definitions during editing. This section describes the
interactive definition of new keys and key duplicates.
To define a new key or a duplicate key in PI, press the MENU key and
move to "KEYS". Choose "Keymap editor" and press RETURN. Move to an
entry and press + to add a key or - to delete a key.
WRITE FILE PI-MACRO.KEY
To create the macro dump file "pi-macro.key" choose "Write
pi-macro.key" on the "Other" menu.
This function creates a disk file "pi-macro.key" in the current
directory with the macro keys listed in loadable format, with
descriptions. It is used to move just the macro keys into a new
directory.
The file PI-MACRO.KEY is loaded automatically from the directory in
which PI is started. The load takes place after the system loading
of key definitions and macros from PI.SET. The PIEINIT environment
variable and the command line switches for loading keys can be used
to automate the loading of unusual macro and key definitions.
WRITE FILE PI-DUMP.KEY
To save the keyboard mapping in a file, press the MENU key and move
to "Other". Choose "Write pi-dump.key" and press RETURN. The file
pi-dump.key will be saved. Load it into an edit buffer for
inspection. This file can be used to load your own private keys.
This function creates a disk file "pi-dump.key" in the current
directory with all keys including macro keys in loadable format, with
descriptions. It uses PI.DAT for the descriptions and it will not be
created unless that file is present. If the function fails to produce
a file, then you can expect that PI.DAT is not in the same directory
as PI.EXE. Under unix PI.DAT is called keymap.dat. The same location
rules apply.
KEY MAP FILE FORMAT.
The format is explained in each copy of "PI-DUMP.KEY" produced by
"Write pi-dump.key" on the "Other" menu. If you are interested in
customization, then print "PI-DUMP.KEY" for reference.
INSTALL KEY MAP FILE.
To install a properly made key map file choose "Read a keymap file"
on the "Other" menu.
This function uses conventional memory. It is best to load it at
startup via PI.SET, which is automatic (PI.SET is not loaded if
unavailable). The same advice applies under unix to the file ~/.pirc
or ./.pirc.
Previous strings used in the keymap are not freed, because they are a
mixture of static data in PI.EXE and possibly memory assigned by SBRK
or MALLOC memory managers. It is impossible to free static data,
hence the decision to not free anything at all.
The effect of the load is immediate. Sorting the table occurs
dynamically and automatically. Study PI.DAT and PI-DUMP.KEY carefully
before doing any hand editing --- it is best to create source by
using the Keymap editor until the combinations are obtained. In
unusual cases, this is impossible, and you will have to resort to
editing the key file by hand.
SET EMACS KEYS.
To set Emacs keys on a unix system choose "Set Emacs keys" on the
"Other" menu. The old key install is lost but any macro keys defined
manually or otherwise will still exist. The macro keys can be
redefined in the "macro editor" on the "keys" menu.
The key load is taken from "$PIE/emacs.keys" using the terminal type
determined by the TERM variable and TERMCAP information. If
select.emulation=1; appears in ~/.pirc, then no extra keys will be
loaded.
SET WORDSTAR KEYS.
To set Wordstar keys on a unix system choose "Set Wordstar keys" on
the "Other" menu. The old key install is lost but any macro
keys defined manually or otherwise will still exist.
The key load is similar to the emacs load discussed above, except
directory "$PIE/wdstar.keys" is used.
SET WORDPERFECT KEYS.
To set Wordperfect keys on a unix system choose "Set Wordperfect
keys" on the "Other" menu. The old key install is lost but any
macro keys defined manually or otherwise will stil exist.
The key load is similar to the emacs load discussed above, except
directory "$PIE/wdperf.keys" is used.
WORD AHEAD.
To move the cursor one word ahead choose "Next word" on the "WORD"
menu. The cursor moves to the first punctuation after the current
word. Try it a few times to see how it handles end of line.
The movement of the cursor parallels what is expected in emacs. It
does NOT replicate the cursor movement in Wordstar or Wordperfect.
WORD BACK.
To move the cursor one word back choose "Previous word" from the
"WORD" menu. The cursor moves to the beginning of the previous word.
The beginning of a line causes special processing. Try it to see how
it works.
The movement of the cursor parallels what is expected in emacs. It
does NOT replicate the cursor movement in Emacs, Wordstar or
Wordperfect.
ERASE WORD AT CURSOR.
To erase or kill the word in front of the cursor choose "Delete word"
on the "WORD" menu.
The action parallels the Emacs delete word key: each key erases
initial white space and punctuation after the cursor, then up to the
end of the word.
If at end of line, then the key removes the line separator. The word
on the next line is not killed because the line is joined to the
current line.
PASTE LINE brings back the group as one unit. The group is formed
from multiple mixed delete word, delete line and kill line commands.
CAPITALIZE WORD.
To capitalize a word choose "Capitalize word" on the "WORD" menu.
The capitalize function will cap the character at the cursor and
change to lower case the letters after the cursor. It breaks on the
first non-alphanumeric character.
Basically, the cursor ends up where WORD AHEAD would place the cursor.
Starting on non-alpha causes a skip to the first alpha character. But
it won't back up if you start on an alpha character.
LOWER CASE WORD.
To change a word to lower case choose "Lowercase word" on the "WORD"
menu. It works like CAPITALIZE WORD except it lowercases the first
letter.
UPPER CASE WORD.
To change a word to upper case choose "Uppercase word" on the "WORD"
menu. It works like CAPITALIZE WORD except it uppercases the following
letters.
FILL PHRASE BUFFER WITH TEXT.
To copy current characters to the phrase buffer:
Position the cursor.
Press the key for "Fill phrase string" on the "WORD" menu.
Press the right arrow key or backspace key or END key to copy
characters and then RETURN when finished. The characters are placed
in the phrase buffer, which is over--written on each use.
Uses of this feature include the transport of graphics characters
and efficient deletion or insertion of words and phrases from the
text. See below for methods.
This feature exists as a substitute for mouse cut and paste when
editing remotely or in non-mouse environments. It is also efficient
for use in macros, to do operations that are suggested by mouse
operations.
PASTE PHRASE.
To paste the phrase buffer at the current cursor position choose
"Paste phrase string" on the "WORD" menu.
Whatever was in the phrase buffer will be copied to the screen as
though typed. Undo the effect with "Kill phrase match" on the "WORD"
menu. The cursor must be on the first character of the proposed
match.
Special effects: If INSERT is on, then the characters are inserted,
otherwise over-write occurs.
KILL WORD OR PHRASE MATCH.
To delete the word or phrase matching the phrase buffer at the cursor
position:
The cursor position is important. Action is taken only in case the
phrase buffer matches the characters to the right of the current
cursor position!
Choose "Kill phrase match" on the "WORD" menu. The matching
characters are removed. To undo the effect, insure INSERT is on and
choose "Inject word/phrase" on the "WORD" menu.
optbuf [OPTMATH]>
IntMath ON PHRASE STRING
Calls function convert2int() to treat the current text in the phrase
buffer as an arithmetic problem. This function interprets the text as
an arithmetic problem involving **INTEGER** addition, subtraction,
multiplication and division. The conversion stops at the first
character that makes no sense. The integer computed by this operation
is converted to text and replaces the contents of the phrase buffer.
LIMITATIONS. Presently, the function cannot handle parentheses, due to
the basic nature of convert2int(). It can't handle floating point
decimal numbers either. This function is as endowed as a simple
4-function calculator, using only integer arithmetic.
CHAINING. Operation chains can work, for example, 2*6/2/2 converts to
3. Check this out by pressing Ctrl-OC, enter 2*6/2/2, then press
Ctrl-O,i to convert and view.
JUNK CHARACTERS. The problem text ((2*6)/2)/2 converts to 0, because
parentheses are not understood. However, this can be an advantage,
because "2*3{" converts to 6, the curly brace being a junk character.
In use, text like "2 +16{Extra Junk" converts like "2 +16".
USAGE. The principal service intended was to produce item numbering or
to add columns of integers. Always, this is done by a keyboard macro.
The basic idea is to load the phrase string with the text of an
arithmetic problem. Then apply this function to do the problem, with
the answer replacing the problem text in the phrase string.
FloatMath ON PHRASE STRING
Calls function convert2double() to treat the current text in the
phrase string as an arithmetic problem. This function interprets the
text as an arithmetic problem involving **FLOAT** addition,
subtraction, multiplication and division. The conversion stops at the
first character that makes no sense. The double computed by this
operation is converted to text and replaces the contents of the phrase
string.
LIMITATIONS. Presently, the function cannot handle parentheses, due to
the basic nature of convert2double(). This function is a simple
4-function calculator and no more.
CHAINING AND JUNK CHARACTERS. The operation is the same as the integer
version of this function.
USAGE. The principal service intended was to produce formatted numeric
output, especially for adding columns of financial or scientific data.
The strength of this simplistic package is the formatted output, which
uses sprintf() from C language. It has the advantage of working on
text strings containing garbage characters.
SET FORMAT STRING FOR FLOAT CONVERSION.
To invoke this function apply "Set math format" on the "WORD" menu.
You are expected to enter a string of characters that describes the
math output format.
The second prompt asks for DOUBLE (0) or INTEGER (1) data to be
applied to the format string. For example, if the format string
contains "%d" or "%c", then the expected data type is INTEGER.
The function accepts a new string for "sprintf", the C function used
to do the output conversion. The normal one is "%.08g". To replace it,
enter just the string itself, without double quotes, but with all
printf rules applied. Some useful formats:
1. "%.g" Prints numbers without decimal points, dropping
decimal digits.
2. "ans=%f" Prints "ans=" and then the answer in decimal
format.
3. "%-12.4f" Left justify the number in a field of width 12
with 4 decimal digits.
4. "%-012.4f" Left justify the number in a field of width 12
with 4 decimal digits, zero-filled.
5. "%6.2f" Normal right-justified financial format with two
digits for cents, aligned on the decimal point.
6. "%c" Converts integer value to character. For example,
65 converts to 'A'. Useful for converting decimal
data to character data (eg, assembly listings).
7. "%02x" Converts integer value to 2-digit hexadecimal. For
example, 65 converts to 45h.
EXAMPLE. Make an ASCII table from 33 to 46.
Method: Set up for this example by setting the "Set math format" on
the "WORD" menu to "%c" and choose integer (1) data. This example
explains why there are two expression evaluators, not just one.
32
Insert 32 on line 1 and move the cursor to the 33 !
start of line 2. Start a macro on line 2 that 34 "
does the following. First, go up one line. Start 35 #
"Fill phrase string" on the "WORD" menu. Press 36 $
key END to grab the token 32 off the screen, 37 %
then insert '+1' and press Ctrl-O,i to evaluate 38 &
the expression (it should be 32+1) to 33. Press 39 '
RETURN two times, once to exit the phrase fill 40 (
and once to go to the beginning of line 2. Then 41 )
press Ctrl-OV to insert the phrase. Press TAB, 42 *
Ctrl-O,k and Ctrl-OV to insert the converted 43 +
expression, which will be '!'. Press RETURN to 44 ,
get the cursor at the start of line 3. End the 45 -
macro. Each press of the macro key adds one 46 .
more line to the ASCII table.
SciCalc ON PHRASE STRING
Calls function calculator() to treat the current text in the
phrase string as a calculator problem. This special function must be
compiled into PI using the source vee.c (ee==expression evaluator).
USAGE. The principal service intended was to produce formatted numeric
output, especially for scientific problems involving math functions
like sine and cosine. Naturally, this one handles parentheses, but
also it supports the definition of variables on the fly and the use of
compiled functions like sine and cosine. That means answers can be
saved and recalled for a later computation.
The author of the basic evaluator is Mark Morley and the copyright for
vee.c dated 1992 belongs to Mark. The documentation is reproduced here
for convenience.
Examples:
1+1
10 * (x=5) <== Assigns 5 to X first!
((1/3) * sin(45))^2
X=50
Y=100
z=hypot(x,y)
[these are disabled in PI]
EXIT Exits the program.
VARS Shows a list a variables and their values.
CONS Shows a list of constants and their values.
CLR Erases all variables.
Constants
pi 3.14159265358979323846
e 2.71828182845904523536
Functions
sin(x) sine function, argument in radians
cos(x) cosine function, argument in radians
tan(x) tangent function, argument in radians
asin(y) inverse sine function
acos(y) inverse cosine function
atan(y) inverse tangent function
sinh(u) hyperbolic sine function
cosh(u) hyperbolic cosine function
tanh(u) hyperbolic tangent function
exp(u) exponential, base e
log(u) logarithm base e
ln(u) logarithm base e
log10(u) logarithm base 10
sqrt(u) square root
pow(x,y) raise x to power y
floor(u) round down to nearest integer
ceil(u) round up to next integer
fmod(x,y) float remainder of x/y
abs(u) absolute value
hypot(x,y) square root of x^2+y^2
deg(u) convert radians to degrees
rad(u) convert degrees to radians
oct(u) convert octal u to base ten
bin(u) convert binary u to base ten
ans last answer
This routines handle the following operators in
order of priority:
1) Anything enclosed in ()'s, variables and functions.
2) Unary + and - signs
3) To the power of symbol: ^
4) Times (*), divide (/), and modulus (%)
5) Plus (+) and minus (-)
6) Assignments (=)
Error messages
E_SYNTAX (1) Syntax error
E_UNBALAN (2) Unbalanced parenthesis
E_DIVZERO (3) Attempted division by zero
E_UNKNOWN (4) Reference to unknown variable
E_MAXVARS (5) Maximum variables exceeded
E_BADFUNC (6) Unrecognized function
E_NUMARGS (7) Wrong number of arguments to function
E_NOARG (8) Missing an argument to a function
E_EMPTY (9) Empty expression
EXAMPLE. Compute the monthly deposit required to have $25000.00
in the bank after 30 years, assuming 7.5 percent interest
compounded monthly.
Solution:
The expression calculator is applied to each equation below.
r=(7.5/100)/12 # 7.5% per annum compounded monthly
n=30*12 # 30-year loan
g=(1+r) # growth factor
v=25000 # value in 30 years
p=v*r/(g^(n+1)-1) # Payment
18.42 # Monthly payment
# Explanation of the formula.
# Each payment has a different term. We have to add a geometric
# series in order get a simple relation between the value (v) and
# the payment (p).
# v=p*g^n + p*g^(n-1)+ ... + p*g^0
# v=p*(g^(n+1)-1)/(g-1))
# p=v*r/(g^(n+1)-1)
EXAMPLE. An auto has sale price of $9000.00. It is to be financed at 9
percent interest compounded monthly for 7 years. Find the
monthly payment.
Solution.
Each month, interest is due on the unpaid balance, plus a payment to
reduce the balance, in such a way that the balance is paid off after 7
years.
n=12*7 # 12 months per year for 7 years
r=(9/100)/12 # Interest rate per month
p=9000 # Balance to pay off in 7 years
It is clear from the equal payment theory that p/n=107.14 is a minimum
payment. This is the figure for zero interest. Interest increases the
monthly payment.
UNEQUAL PAYMENTS.
One method for payment is to pay the amount 107.14 plus the actual
interest on the unpaid balance. The first month would be 107.14 plus
p*r=67.50 for a first payment amount of 174.64. However, the balance
is reduced by 107.14 only, and the next month the payment is 107.14
plus (p-107.14)*r=66.70 making second payment 173.84.
EQUAL PAYMENTS.
Nobody likes the weird payment scheme, so the banks enforce an equal
payment policy:
Equal payment c of principal plus interest
Unequal principal payments x1+ x2 + ... +xn = p
Unequal interest payments p*r, (p-x1)*r, (p-x1-x2)*r, ... , (xn)*r
x1=c-r*p
x2=c-r*(p-x1)=c-r*(p-c+p*r)
=c*(1+r) -r*p*(1+r)
=(c-r*p)*(1+r)
x3=c-r*(p-x1-x2)=c-r*(p-(c-r*p)-(c-r*p)*(1+r))
=(c-r*p)+r*(c-r*p)+r*(c-r*p)*(1+r)
=(c-r*p)+r*((1+r)^2-1)*(c-r*p)/r
=(c-r*p)*(1+r)^2
Add these up and set the result equal to p. Then sum the geometric
series again to give the compact relation
(c-r*p)((1+r)^(n+1)-1)/r) = p
To solve for c, let q=1-(1+r)^(-n-1), then
c=r*p/q=143.58
Payment k pays principal xk=(c-r*p)*(1+r)^k and interest c-xk.
Principal paid Interest paid Actual payment
x1=76.65 c-x1=66.93 c=143.58
x2=77.22 c-x2=66.35 c=143.58
x3=77.80 c-x3=65.78 c=143.58
HEXTOBASE10 on PHRASE STRING.
This function applies a hex to decimal conversion of the phrase
string, replacing the phrase string. It also works on the Enterkey
prompt. Leading characters like 0x or x are allowed. Any trailing
character causes a break and finally conversion, so extra junk can be
on the line.
OCTTOBASE10 on PHRASE STRING.
This function applies an octal to decimal conversion of the phrase
string, replacing the phrase string. It also works on the Enterkey
prompt. Leading characters like 0 or \ are allowed. Any trailing
character causes a break and finally conversion, so extra junk can be
on the line.
PUT WORD OR PHRASE IN NOTEPAD.
To append the phrase buffer onto the NotePad:
Cursor position is irrelevant. Ditto for INSERT mode.
Choose "Add phrase to notepad" on the "WORD" menu. The action is
immediate: the contents of the phrase buffer are appended to the
NotePad. All such appends add to the last group in the notepad
(numbered as group 1, physically the last group in the notepad).
Each append creates one new notepad line.
The phrase buffer is loaded on purpose (by you) and usually
contains short inter-line phrases or words. Appending phrases to
the notepad is a common method of collecting boilerplate text.
BLOCK MARK AND SETUP.
Position the cursor at the first line. The character position is
irrelevant for organization by lines. If a matrix is to be defined,
then position the cursor to the upper left corner of the matrix of
text. A `matrix' is a block of text consisting of rows and columns.
Incomplete rows of a matrix are by default padded with spaces.
Choose "Begin block set mark" on the "BLOCK" menu. Move the cursor to
the end of the block. For a line block the character position of the
line is irrelevant. However, for a matrix block, the cursor must be in
the lower right corner of the matrix.
To view the block defined in inverse video, select "Reveal block
setup" on the "BLOCK" menu. Alternatively, select "Swap mark with
cursor" to see the extreme ends of the block without inverse video.
A second application of "Swap mark with cursor" will invoke "Reveal
block setup". In practise, this is done with a key sequence: ctrl-KK
for Wordstar and ctrl-XX for emacs.
Some extreme cases. On a single line block markup doesn't make a whole
lot of sense. They are other editor operations that work better.
Investigate other items on the "BLOCK" and "WORD" menus. For example,
copying a line should never be done with block operations, because
there is a builtin feature for copying one or more lines.
SWAP BLOCK MARK.
To place the cursor at the other end of the marked block choose "Swap
mark with cursor" on the "BLOCK" menu.
The original mark becomes the cursor position and the current
position becomes the mark. Visually you will see the cursor move
which is enough to delimit the corners of the block. This feature is
present in Emacs and remains valuable for text editing on a slow
modem line.
A second application of "Swap mark with cursor" will invoke "Reveal
block setup". In practise, this is done by repeating the key sequence.
The two views of "Reveal block setup" are (1) By lines, (2) By matrix.
One of these is the default and the other is selected by pressing
SPACE at the prompt. The default remains until changed.
REVEAL BLOCK SETUP.
To see in inverse video the two possible block markups for the
current mark choose "Reveal block setup" on the "BLOCK" menu.
The first display is by lines and the second is the matrix or row and
column display. No action is taken from the displays other than to
show you what the current block is supposed to be.
The two views of "Reveal block setup" are (1) By lines, (2) By matrix.
One of these is the default and the other is selected by pressing
SPACE at the prompt. The default remains until changed.
BLOCK COPY
Assume the block has been defined (see above). Press the MENU key and
select "BLOCK". Choose "Copy block to notepad". The defined block
will be outlined in inverse video. The line block is presented first,
then the matrix block by pressing SPACE. Choose whichever one you want
copied to the notepad.
The block remains defined and no screen text is altered. The outlined
block is copied onto the end of the notepad as a new record. It will
be the first record presented by a paste operation. See below.
BLOCK MOVE
A block move is completed by doing first a block delete and then a
block paste. See below for block delete. This is normally called
"cut" and then "paste".
BLOCK DELETE
To delete the block into the notepad select "Move block to notepad" on
the "BLOCK" menu. The block will be outlined in inverse video.
Confirmation is required before the block vanishes from the screen.
The first display will be the line block, and if skipped, a second
display, the matrix block, will be presented.
The block is appended to the notepad as a new record. It will be the
first record presented for a paste operation.
The block can be either a group of adjacent lines or else a
rectangular matrix with blank-fill on the right. There is no provision
for other kinds of blocks. See the mouse operations for special cases
that can be done easily outside of the editor.
ERASE BLOCK NO SAVE
To delete a block of text without saving it in the notepad apply
"Erase n lines" on the "EDIT" menu. Sorry, no matrix erase unless
saved also to the notepad.
PASTE BLOCK
Move the cursor to the new location where you want to place the copy.
The copied text can be viewed as a matrix or as lines of text for
purposes of the copy.
The default (matrix or lines) is set by the last type used for a
copy. The initial default is lines, but this default is changed by
the first and subsequent copies. PI remembers what you did last and
uses that style as the default.
MATRIX: The lines in the notepad are all the same length. If not
true, then the paste will be aborted on the first line that
has unequal length. The editor will not offer a matrix
paste unless the line lengths match for the entire block.
If you need to fix a block in the NotePad, then add blanks
to the ends of lines until they all have the same length.
LINES: The lines in the notepad are of possibly unequal length.
This operation always succeeds.
When pasting lines the cursor position determines the line only.
Blank lines are opened at the cursor position to insert the lines
from the notepad.
When pasting a matrix, the cursor position determines the upper left
corner of the matrix. This operation never inserts lines. It inserts
columns. The operation never destroys screen text.
When pasting in over-write mode, the rules are the same as for a
matrix paste, except that any characters in the way get over-written.
This is perhaps dangerous but nevertheless useful.
A status query appears for the paste method: lines, matrix,
write-over matrix. If none is chosen then the paste fails and nothing
happens. Otherwise:
The last notepad record (most recent delete or copy) is presented
first, for approval (in write-over matrix mode the last record is
used and there is no option). If it is not the one you want, then
answer the status line query with either 'N' to Quit or 'P' for
previous record. All notepad records can be cycled onto the screen in
this fashion.
The writeover mode, supplied for convenience, should be used rarely.
It destroys screen text forever. It is generally acceptable to do
this operation when the paste will write over a blank portion of the
screen. Mistakes are unrecoverable if the screen text is not blank.
Uses: shifting columns, inserting diagrams into an outline block.
DISCARD NOTEPAD CONTENTS.
To clear the NotePad select "Erase the notepad" on the "BLOCK" menu.
There is no warning message nor confirmation. The notepad is a
scratch space.
The key mapped to this operation is useful to memorize, especially if
you expect to do a lot of boilerplate collection. It can be used from
any buffer including the notepad to wipe clean the notepad contents.
WRITE NOTEPAD TO DISK FILE.
To save the entire NotePad to a disk file:
Choose "Find window" on the "FILE" menu and edit the NotePad.
Decide if you want to remove the ctrl-A record separators (usually
yes). If so, then use Query-Replace to rid the buffer of these
unsavory characters.
Choose "Save to disk" on the "FILE" menu. Enter an appropriate file
name.
The main use of the NotePad as a file buffer is for editing
makefiles. The procedure is this: erase the notepad, inject the
makefile, edit, save. In this process no ctrl-A characters are
spuriously added.
MAKE EDIT WINDOW WITH NOTEPAD CONTENTS.
To make a new edit window with the notepad contents, for editing or
saving as a disk file:
Choose "New" on the "FILE" menu.
Choose "Paste block from notepad" on the "BLOCK" menu.
Copy in the notepad records desired. If YES is the answer to all
status prompts, then all records in the notepad are copied, in
proper order (no ctrl-A record separators are copied).
If the intent is to copy a large number of blocks from the notepad,
then it is advisable to edit the notepad and remove the undesirable
text and/or record separators.
DUPLICATE LINE ONTO NOTEPAD.
To duplicate the current line and append it to the last group in the
notepad choose "Dup line onto notepad" in the "BLOCK" menu.
The operation creates a new line in the notepad but does not alter
the current buffer contents or the cursor position. The last group in
the notepad is unchanged except for one more appended line.
DELETE LINE ONTO NOTEPAD.
To delete the current line and append it to the last group in the
notepad choose "Kill line, add to notepad" in the "BLOCK" menu.
The action is identical to "Delete line" on the "EDIT" menu except the
line is not added to the current save group. Instead, it is appended
to the notepad in a manner described above.
INITIAL TAB AND MARGIN SETTING.
To set the initial TAB amount (default 8 columns), choose "Tab and
margin" on the "VALUES" menu. To change the TAB amount enter a number
and press RETURN, or else enter '.' to choose the tab amount
determined by the cursor column.
The TAB setting is not to be confused with the DETAB setting of 8,
which is used to remove tabs (ascii value 9) from text as it scrolls
onto the screen.
To set the wrap, reform and centering margin, choose "Tab and margin"
on the "VALUES" menu. Skip the TAB prompt. Enter the amount for the
margin prompt or a period. The period implies the margin should be
set at the current cursor position.
The simplest use is to inspect the current settings: respond to each
prompt with RETURN.
TAB INSERTION.
To put tabs into the file, then turn off the DETAB toggle before
editing begins. See "Detab" on the "VALUES" menu.
Tabs are entered as the quoted entry key (ctrl-V or ctrl-P) followed
by ctrl--I the TAB key. They show up on the screen as the letter `I'
in inverse video. Some terminals do not display inverse video well:
adjust the terminal brightness control until properly displayed.
SET DETAB AMOUNT.
To set the tab stop for detab operations, press the MENU key and move
to "VALUES". Choose "Detab" and press RETURN. Enter the number for
the tab stop (2,4,8,16,32). Execute "Detab" again to turn on DETAB
(inspect the setting also!).
DETABBING FILES.
To fully detab a file, insure DETAB MODE is ON. The status of DETAB
is obtained by applying the toggle twice. To execute the toggle apply
"Detab" on the "VALUES" menu.
Physical detab occurs by a scroll from top to bottom. Holding down on
the "Page ahead" key ought to do it. Reverse scrolling also works.
Most persons want DETAB turned ON at all times, and do not wish to be
bothered with the details. That is why the default startup of PI has
DETAB turned ON. See the file $PIE/SYSpi.rc for startup changes.
TABS IN MAKEFILES.
It appears that the only common use of tabs in source files is the
Makefile. For such files the location of the tab is important:
changing it to spaces is not allowed. On the "VALUES" menu the item
"Detab" changes the way in which the editor handles tab characters.
Each use of the item toggles the state of the tab handling. In
addition, the conversion can be set to 2, 4, 8, 16, 32 spaces per
tab character.
A convenient way to edit makefiles is to clear the notepad, inject
the makefile, edit and save. The notepad does not process tabs and
it does not alter spaces at end of line.
SET IMPORT AND EXPORT FILE TYPE.
To set the file type used for importing and exporting text choose
"Export-import" on the "VALUES" menu. Choose 1=Ms-Dos, 2=MacIntosh,
3=Unix. Both the input and output file types can be set. Pressing
RETURN in the query causes the old value to be used (it appears in
closed brackets).
The line termination rules are as follows:
MS-DOS Carriage return and linefeed (13,10 decimal).
MAC Carriage return (13 decimal).
UNIX Linefeed (10 decimal).
BLOCK READS FROM DISK.
To set the disk input mode to special **BLOCK MODE**, choose
"Export-import" on the "VALUES" menu. Choose value 0 or 1 at the
prompt "Block read [0]:", where 0 is normal byte read and 1 is block
read.
Block read mode prompts for the starting block and the number of
blocks to read. See "Information" on the "BLOCK" menu for the
blocksize that is used for disk reads. Generally it is 8k or 16k
bytes. The actual number of bytes read is always less than the
blocksize.
The prompt for starting block assumes start=1. The prompt for number
of blocks assumes number=0, which means "read the whole file".
The special block mode is used on very large files to extract or
inject a chunk of the file.
PRINT SETUP
Choose "Printer" on the "VALUES" menu to set the defaults for print
formatting and the physical printer to be used. The options to be set
are:
Left spaces: Number of spaces inserted on the left edge.
Top blank lines: Number of blank lines inserted at the top of
each page.
Bottom blank lines: Number of blank lines added on the end of
each page.
Text lines per page: The number of lines of text used. The total
of the top and bottom blank lines plus the number of text lines
should equal 66 for a normal printer on 8.5x11 paper.
Use formfeeds: A value of 1 means yes, 0 means no. If yes, then
a line is added after each page containing a single formfeed
character ctrl-L. A formfeed normally ejects the page on a
printer. On some printers it produces an extra blank page.
Experiment to see how useful it might be.
Default printer: For MSDOS the default printer is PRN. For unix
it means the program lpr using the value of environment variable
PRINTER. In the case of MSDOS, the printer device can be used
like a file name, so there is no need to provide a switching
mechanism. The default printer is set by the mode command in
DOS. Printer switching is done by the PRINTER environment
variable in unix.
For unix, do not assume the print program is selected for you.
There is a print filter $PIE/printfilter used by default in
or PI uses the one in your home directory called `.printfilter'.
The print filter gets its file name argument from PI, which runs
the shell script.
BACKUP TOGGLE.
To toggle the state of the backup feature choose "Backup modes" on
the "VALUES" menu. There are three options:
0: Backups off
1: Backup in $HOME/PIbackups
2: Backup in ./PIbackups (current directory)
if that subdirectory already exists.
Otherwise, resort to $HOME/PIbackups.
The backup routine for unix and MSDOS munges the original file name
by replacing period by '\#' and using a hex sequence number for the
last 4 letters of the file name (3 of which are extension). In
practise this works well because the backups are numbered
consecutively from 0001.
The printer and all tty devices are not subject to the backup feature
(they are unplugged from backup rules as encountered).
BACKUP DISABLE.
Because editing on a floppy means disk space is at a premium, the
backup feature is disabled from the toggle "Backups" on the "VALUES"
menu.
PI handles tty backup toggles automatically. The tty backups are easy
to turn off automatically because the file name says it all.
This is almost true for floppies, but there are times when backups on
the floppy are appropriate. PI does not fool with floppy backups.
The file PI.SET can toggle the backups depending upon where PI is
started. If you start PI from a subdirectory where backups are OFF by
default (as set in PI.SET in that subdirectory), then the mode is
preserved for floppies that happen to be edited subsequently.
TOGGLE INSERT MODE.
To toggle insert mode choose "Insert mode" on the "VALUES" menu.
Usually this toggle is mapped to the INS key or KeyPad7. WordStar has
it mapped to ctrl-V also. Insert mode inserts characters in the line,
pushing old characters to the right. Press the toggle key again to
turn it off. Status of the insert toggle appears on the status line
as `[Insert]'.
TOGGLE HIGH STRIP.
To toggle high bit--stripping as is required for WordStar source
files, or files with extended characters choose "High strip" on the
"VALUES" menu. It works like detab, as lines pass across the screen,
and either forward or reverse scrolls will strip the 128--bit.
This mysterious feature is used to read under unix a file made under
MSDOS using IBM graphics characters such as the box-drawing set. Many
IBM vendors distribute documents that utilize the IBM graphics
characters.
INSERT EXTENDED CHARACTER.
To enter extended characters into the text, Ascii codes 128-255,
press ctrl-O,ctrl-E, just to the right of the character to be
converted.
On MSDOS machines, codes 129-255 can be entered directly via the ALT
key. The procedure: hold down ALT and type the ASCII code (in
decimal) on the application pad. When the ALT key is released the
extended code will appear on the screen at the cursor position.
TOGGLE AUTO INDENT.
To toggle auto--indent mode choose "Auto-indent" on the "VALUES"
menu.
This mode is not sophisticated so expect to use it with reform:
"Justify line" on the "EDIT" menu.
Auto indent is usually ON when the editor starts. Check defaults so
that you know the wakeup mode.
There is a collision between auto indent and X-windows: a copy of
more than one line of text will not paste as expected unless auto
indent is OFF!
TOGGLE STATUS LINE.
The four modes are set by choosing "Status line" on the "VALUES"
menu. Each such select changes to the next mode finally returning to
mode=1 (normal).
The status line toggle switches between these four modes:
1. File number, file name, insert mode display, line number,
cursor position.
2. The above but remove the line numbers and cursor position.
This is primarily made for modem use.
3. ASCII chart for the cursor character replaces the status of
item 2 above, unless beyond end of line, where it reverts
again to item 2. This can be invoked directly from "Ascii
reveal codes" on the "OTHER" menu.
4. Blank status line.
TOGGLE WORD WRAP MODE.
To toggle auto--wrap mode press the MENU key and move to "VALUES".
Choose "Wordwrap" and press RETURN.
This mode uses the right margin setting to determine when to spill
characters over to the next line. It is best used in combination with
Auto-indent mode and the Justify line command. With the modes set
properly it is possible to compose a paragraph without using the
RETURN key at all. Ditto for paragraphs with hanging indent.
TOGGLE HANGING INDENT MODE.
To toggle hanging--indent mode, turn on auto--wrap, auto--indent and
insert modes, and hanging-indent. In this mode, reform occurs at the
indent of the previous line rather than at the left margin. It mostly
affects typing, where hitting return results in the cursor moving to
the correct position on the next line, rather than just to the left
margin.
To set this special mode required three toggles or three setups in
the file PI.SET:
word.wrap.toggle=1; Toggle word wrap at right margin (1=on,0=off)
hang.indent.toggle=1; Toggle hanging indent mode (1=on,0=off)
auto.indent.toggle=1; Toggle auto-indent word wrap (1=on,0=off)
TOGGLE TRAILING SPACE STRIP.
There is a menu item "Trailing space" to set on/off and a
setup file PI.SET resource "trailing.space=0" to turn it on/off by
default. Trailing spaces are removed only as the text scrolls off the
screen. If the text never gets on screen, then it is not stripped.
trailing.space=0; Toggle stripping of trailing spaces (1=on,0=off)
INITIAL STARTUP WITH FILE LOAD.
To load in a file as PI is invoked:
At the system prompt, type PI and a space, but don't press RETURN.
Type the complete file name, which may include a path name, and
press RETURN. Wildcards may be used. More than one file is allowed.
Example: pi paper.tex chap*.bib intro.???
LOAD NEW FILE.
At least 40 files can be edited at once. The number is set in the
startup file PI.SET (or .pirc) on the line
info-max-size=40
To load another file while PI is running:
Press the MENU key and move with cursor keys to "Open".
Press space or return.
Two options exist:
1. Press the RETURN key to get a list of possible file name. To
choose one, move to it with the cursor keys and press RETURN.
The directory on the status line can be edited and wildcards
can be added to simplify the resulting list of file names.
2. At the prompt for a file name, enter the complete file name or
a partial file name and the TAB key to complete the file name
(if possible). Duplicates may exist. If not, then PI will
complete the file name. Otherwise, the name is completed with
wildcards and you may press return to get a subwindow of file
names that match the given wildcards.
Shortcut: To erase a long pathname, add // to the end and
press TAB. Only the root will remain.
The old file you are editing is not lost. The "FILE" menu commands
"Forward a window" and "Back a window" change the edit window to a
previous file. About 100 files can be kept in the editor at one time
under unix or MSDOS.
NEW UNTITLED WINDOW.
To create a new window called "UnTitled" choose "New" from the "FILE"
menu. The actual file name will be determined by prompt when exiting
PI or when an attempt is made to close the file.
RENAME FILE.
To rename or change the name of a file buffer choose "Rename" on the
"FILE" menu. A prompt will appear for the new name. The name is
checked against names on the disk to prevent accidental destruction
of existing files. See also the section on backups for recovery of
previous versions of files saved by PI.
SAVE FILE AND CONTINUE.
To save the current edit and continue editing the file, choose "Save
on disk" from the "FILE" menu. If backups are turned on, then the
previous version is saved as a backup with new name. The current
version carries the name on the status line. If anything goes wrong,
such as running out of disk space, then a warning appears on the
status line. In any case, the previous version on disk is not lost.
In the unix version, several failures at trying to save the file will
put a copy in the /tmp directory. Often this directory is on a
different physical disk. Incidents like this are common on systems
that have a large number of users and less than 10 percent free disk
space.
SAVE AS ....
If the edit window says `UnTitled' or `NotePad', then a file name
must be supplied during the save. This command also applies to save
an edit under a new file name. To use file name XXXXXXXX:
Press the MENU key and move to the "FILE" menu. Highlight "Save as ..."
and press return. The status line prompt will appear requesting a new
file name.
Enter XXXXXXXX on the status line. Sometimes the directory name needs
editing (backspace or delete will work). If XXXXXXXX already exists,
then the typing of the name can be avoided by pressing RETURN on the
status line to bring up a file list.
Press RETURN to save the file (ENTER key aborts). If unlucky and the
file name is already in use, then a prompt appears to allow or
disallow over-write.
DISCARD EDIT.
To discard the editing session (one window at a time), press the MENU
key and move to the "FILE" menu. Choose "Close" and press RETURN. If
the message "Discard edit?" appears, answer Y. If the edit was made
to a disk file that already has contents, then that file is unaltered
and only the current edit changes are lost. If the disk file did not
previously exist, then all changes are lost.
To discard all edits, quit PI from the menu and look carefully at the
list of changed buffers. If nothing dangerous is listed, then go
ahead and exit permanently (job ends). Each new copy of PI starts
with one buffer for the NotePad and one buffer for UnTitled.
SAVE FILE AND CLOSE
To save the file being edited and discard the edit window for that
file, press ctrl--KD. Compare this to save and exit, ctrl--KX, which
leaves the edit buffer intact, saves the file, and immediately
suspends PI (suspend leaves the editor resident so that fg and %n
commands resume editing) or else exits PI permanently (MSDOS).
In any case, ctrl-KD leaves the editor running.
SAVE FILE AND EXIT.
To save a file and exit PI (EXIT suspends PI, QUIT kills the job),
press the menu key(s) and move to the "FILE" menu with the cursor keys.
Highlight "Exit after save". Press RETURN or SPACE to make it happen.
UNIX. The editor is suspended and may be restarted with the `fg'
command. Don't restart PI with the INITIAL STARTUP (see above)! Use
the `jobs' command at the unix prompt to see which jobs are
suspended: these jobs can be resumed where you left off.
MS-DOS. Here, "EXIT" and "QUIT" mean the same. To get the equivalent
unix behavior, choose "Save to disk" from the "FILE" menu, then "Swap
pi and shell" from the "QUIT" menu. You can set this behavior in
PI.SET with the control string
suspend.on.exit=1; Suspend PI on SAVE THEN EXIT ctrl-KX. MSDOS (0)
READ FILE INTO TEXT.
To inject a file into the text:
Position the cursor to the line where the text is to be copied.
(Inject works like multiple insert line)
Press the MENU key and move to "FILE". Choose "Inject file" and
press RETURN.
Enter the name of the file to be inserted at the cursor and press
RETURN. A file lookup may be done here by using the file name
completion key TAB. A list of files appears if RETURN is used for
the file name.
NOTES: To insert part of a file, set up for "Block read" by choosing
"Export-import" on the "VALUES" menu, then select value 1 for block
read. You will be prompted for the start block and number of blocks
to read. The block size is determined by the block size used in the
editor, usually 4k or larger. See the "Information" display on the
"OTHER" menu.
Inject occurs by lines only, and the current line will be the
first line after the injected file.
Columnar injects may be done by pasting the notepad buffer. The
usual process is to inject a file into the NotePad, edit it, then
do a columnar inject into another edit buffer using "Paste block
from notepad" under the "BLOCK" menu.
FILE SIZE LIMITS.
The file size limit is determined by three variables in PI.SET:
xms.maximum.blocks=512; Largest number of xms blocks in use (512)
string.reserve.blocks=6; Mem blocks reserved for internal line copying (6)
block.buffer.size=4; Size in kilobytes [2..10] of low/xms memory buffer (4)
Each XMS block uses SIZEBLOCK bytes. A setting in PI.SET such as
block.buffer.size=4
results in BLOCKSIZE=4*1024 bytes. The total number of blocks is the
sum of blocks available in the transient program area (tpa,640kb max)
and the number MAXXMS set by default in PI.SET by the line
xms.maximum.blocks=512
This example sets MAXXMS=512. The MSDOS line (not used in unix)
string.reserve.blocks=6
loads a variable STASHmin=6. The object is to reserve tpa string
space of STASHmin*BLOCKSIZE=6*4096 (24kb) for strings. If the tpa is
480kb, then about 118 blocks are available there, reduced by 6 to
112, making a total of 512+112=624 blocks. Then the file size limit
is approximately 2,555,904 bytes (2.5mb).
ADJUSTMENTS. Changing the block size from 4 to 6 makes a big change
that affects little except the file size limit. MSDOS and unix have
different block size limits. A good working rule is to limit the
MSDOS block size to 8k. Unix should start with a block size of 8k
or 16k and not exceed 32k.
The number N of XMS blocks is used to create a large array in the
tpa of size 18N bytes. Assignments like N=2500 cause the
consumption of 45,000 bytes (44k) in the tpa. If N=65536, then
array consumption reaches 1,179,648 (1.1mb) which is larger than
the tpa itself (impossible). The MSDOS limit of about N=25,000
gives a file size limit of 267,960,320 bytes (255mb). This does not
apply to unix. Both systems will certainly use virtual memory to
reach the limits. In a practical sense, the file size is limited by
physical memory or RAM.
OLD MSDOS SYSTEMS. The version of HIMEM.SYS should be 2.0 or higher.
The best driver is dated 1988 (ver 2.04) or later and it is freely
available for downloading from
http://www.microsoft.com/
together with the Microsoft xms specs (xms20.txt, xms30.txt). The
driver shipped with windows 3.1 is version 3.xx and it has some
especially interesting setup features, such as a memory test and the
ability to increase the number of xms handles from the default 32 up
to 128 (not needed in PI).
HANDLING LARGE FILES.
The remarks below apply primarily to the PC version of the PI editor
which is in its minimum configuration limited to a capacity of about
500 kilobytes (see FILE SIZE LIMITS, above).
Block move functions can do this very well, if you have enough memory
to load the file. The method below is an alternative which makes it
easier to create files of about the same size. To use the block move
method on minimal hardware, set up MS Windows with a large disk swap
and run PI from a DOS window. If you have 1mb memory or less, then
the method below may be the only alternative.
LOAD BLOCKS.
To load blocks 2 through 10 of file SAMPLE.TXT:
Choose "Export-Import" on the "VALUES" menu.
Skip the first two prompts. Set "Block Read" to "1".
Choose "Open" on the "FILE" menu.
Enter: SAMPLE.TXT
Press RETURN.
The file name will be changed to UnTitled to avoid writing out a
short version of the file to the original file name. You will be
prompted for the following information:
Start block: [1] <== Enter 1 for the first block
Count: [0] <== "0" means the whole file, but "1"
means just one block will be read.
Enter 9, because that is how many
occupy blocks 2 through 10.
INJECT BLOCKS.
To read in blocks 5 through 10 of file SAMPLE.TXT at the cursor:
Position the cursor to the line where the text is to be inserted.
Choose "Export-Import" on the "VALUES" menu.
Skip the first two prompts. Set "Block Read" to "1".
Choose "Inject file" on the "FILE" menu.
Enter: SAMPLE.TXT
Press RETURN.
Repeat the previous example, answer the prompts as "5" and "6",
respectively.
BREAK A LARGE FILE INTO SMALL FILES.
To break up a large file of size 2400k (2.4mb) into multiple small
files. Assume the editor has 8k blocks. Then 300 blocks or more must
be read. Proceed as follows:
Read in blocks 1-50 by the method of the item above.
Write out the file to a new name, e.g., BIG.1, using "Save on
disk" on the "FILE" menu.
Repeat the above successively for pages 51-100, then pages
101-150, 151-200, etc.
The output files BIG.1, BIG.2, etc, from this procedure will be
about 400k bytes each. If you need to put them back together again,
the use the system copy command or inject the files inside PI into
a single file.
MAKING A UNIX BATCH FILE.
To make a shell file (batch file) that copies files to directory
/tmp:
Choose "New" on the "FILE" menu to get a new edit buffer. Insure
insert mode is ON. Then press choose "Paste directory" on the
"OTHER" menu.
Enter the wildcard file name.
Example: *.c
Press RETURN to inject the file names into the edit buffer.
Now that the file names are in the edit buffer, we write a short
macro to make the shell file.
Position the cursor to the top of the file list.
Choose "Memorize keys" on the "Keys" menu to start memorizing.
Type characters `c', `p', ` ', then go to the end of the line using
an editor key (END, R5, ctrl-RIGHT, ctrl-E are some of the usual
keys), then characters ` ', `/', `t', `m', `p' and finally a
carriage return.
Press the key suggested on the status line to end the memorizing
step. This completes one line of the set.
For each additional line, choose "Replay keys" on the "Keys" menu
(or the corresponding key).
Example: Enter wildcards `./*.c'
BEFORE MACRO AFTER MACRO
---------------------------------
where.c cp where.c /tmp
v1.c cp v1.c /tmp
make.c cp make.c /tmp
touch.c cp touch.c /tmp
fgrep.c cp fgrep.c /tmp
Save the file using "Save on disk" on the "FILE" menu with name
`test.sh'. At the Unix prompt, issue the command `chmod +x test.sh'.
Finally, type the name of the file at the unix prompt (test.sh). This
will execute the commands in the file `test.sh' as though you had
typed them yourself at the Unix prompt.
FORMAT FILE FOR PRINT.
To format a buffer it must be first saved to disk. The buffer is to
be replaced by one called "Untitled" in which all the format
operations described above have been performed.
To initiate formatting, choose "Print file" form the "FILE" menu. The
formatting and printing can be done separately.
PRINT FILE
To print the file in the current buffer choose "Print file" from the
"FILE" menu. The file can be printed even if it has not been saved on
disk (compare with the format rules above).
MSDOS. On a PC, a print job is a write to a device, normally PRN. If
you want to write to another device, then save the file with that
device name, e.g., com1 or lpt1.
UNIX. The printer name is set by the PRINTER environment variable
using the unix command "setenv". Lacking this setup, choose the
printer name "lpr". The unix action for print is to issue the
following background command:
$HOME/.printfilter filename
If the file $HOME/.printfilter does not exist, then PI uses the file
$PIE/printfilter instead.
PRINT FILTER INTERNALS
The local unix shell script $PIE/printfilter is
enscript -d lpr -B -f Courier12 $1
This print filter depends upon a system program ENSCRIPT of Markku
Rossi which paginates the text and converts it to postscript. To read
its documentation use the unix command "man enscript". The effort of
PI is to supply the command line argument $1 for the file name. The
print filter itself is to be written by the user. On many systems the
shell variable $PRINTER is defined, and that can be substituted in
the filter for the text "lpr". The advantage is that switches of
printer are automatic.
It is an advantage, when enscript is available, to do nothing to PI's
file; let enscript do everything. If this is not possible, then the
pagination and white space controls internal to PI can be applied.
PRINTING PROGRAM LISTINGS AND MAIL MESSAGES.
To print a mail message or program source code file called 'filename'
under unix , use the `lpr' command at the Unix prompt as follows:
lpr filename
The program `lpr' prints on a system printer, in this case, the
printer defined by environment variable PRINTER in the local shell
resource file '.cshrc' or '.bashrc'.
For more information on printing program source and mail messages see
the remarks above on print filter internals.
SUPERB PRINT OUTPUT.
PI is not a word processor like Word Perfect or Microsoft Word. If
you want superb printer output, then learn about LaTeX, NROFF and
TROFF, all of which have manual pages.
For programming purposes the combination of LPTOPS and LPR outlined
above will suffice. For reports and research papers, LaTeX is
indicated, especially if you expect to have mathematical equations,
foreign accented characters, tables and figures.
NEXT WINDOW
PREVIOUS WINDOW
FLIP WINDOWS.
To change edit windows:
FORWARD.
Press ctrl-L.
BACKWARD.
Press ctrl-QL
JUMP RELATIVE.
Press ENTER, enter a positive or negative number, then press
ctrl-L or ctrl-QL.
SELECT WINDOW.
Use the "FILE" menu item "Find window" which is mapped to ctrl-KA.
DISCARD WINDOW.
To discard an edit window, press the MENU key and move by cursor keys
to the "FILE" menu. Choose "Close" and press RETURN. If the edit
window has changes, then confirmation is requested: answer Y to scrap
it (other keys abort).
KILL UNIX PROCESS PI. QUIT EDITOR.
To exit pi permanently choose "Quit editor" on the "QUIT" menu. The
other exits will suspend the editor (fork kept).
To throw away a copy of PI at the shell level in unix:
Resume PI using `fg' or `%n' or `%pi', then exit pi with "Quit".
Alternate method: use the command `kill %pi' or `kill %n' to kill
the job without resuming the edit. If these commands are
unfamiliar, use `man csh' to get a tutorial.
FORKED JOBS.
UNIX. The pi editor will be kept as a forked job, by default. All
normal exits keep the fork. Only the PI 'QUIT' command will kill the
process (the `kill' command under csh will also get rid of pi). To
start unix PI once it is loaded, enter
fg (assuming pi was last job)
or
jobs (note number n for process `pi')
%n
MSDOS. The pi editor will be suspended only in case PI.SET has
variable set "suspend.on.exit=1" because the default (0) is to exit
the editor on "Save then exit" on the "FILE" menu. If the variable is
set, then to
start MSDOS PI after ctrl-KX exit, enter at the MSDOS prompt
EXIT (assuming pi was suspended)
Using the MSDOS key program wced, it is possible to define an alias
for the DOS exit command, making it match unix, for consistency. The
program wced adds some commonly used features of the BASH shell.
DISPLAY INTERNAL INFORMATION
To display the status of setup file options, press the MENU key and
move to "Help". Choose "Internal info" and press RETURN. A display
for Linux in May 2000 looks like this:
Max files : 40 How many files editable at once
Active Files : 2
Max file name: 256 Maximum size of a path name
Blocks in use: 11
Blocks total : 1024 There are 1024 blocks possible.
Block size : 16384 Each block has size 16kb.
Max columns : 384 A line can have 384 columns.
Max rows : 40 Window row maximum is 40 rows.
Columns 0 to : 74 Columns currently used are 0-74.
Rows 0 to : 23 Rows currently used are 0-23.
File size max = 16777216 bytes
Shared Text=172, Private Data=352, Stack=8
TERM=vt100
Keymap=Internal WS Keys
SrcDir=/var/lib/pie49/ Where to find all editor support files.
SetUp=./.pirc The initialization file.
The memory report lists the shareable text size of the application, an
amount that can be mostly swapped out to disk. Some portion of the
unshared data consists of static strings, e.g., menu text. The rest of
the non-variable unshared data comes from calls to malloc(). In the
example above, a file of size 207kb was being edited, which suggests
that 145kb of static strings and malloc() data were used at startup.
The entire 352kb is can be swapped to disk.
DIRECTORY INFO.
Unix path names look like /usr/include/sys/*.h. File names may
contain a path name or wildcard. MSDOS uses path names with
backslash. However, the unix path separator is acceptable as an
argument to an MSDOS program (but unacceptable to command.com as a
program name!).
WILDCARDS.
The wildcard character set is system dependent. Under Unix, `*' is a
multi-character wildcard. The character `?' is a single-character
wildcard. Directory names may not contain a wildcard. MS-DOS uses
the same wildcards as unix.
DIRECTORY PASTE.
A directory request "Paste directory" from the "OTHER" menu pastes
the information at the cursor. You may edit and use the directory
text as though you had typed it.
The directory normally gets emitted in 1-column format. To produce
4-column format add `,4' to the wildcard file name. Example: *.c,3
emits all C language files in 3-column format.
The principal use for a directory paste is to make a shell or batch
file. Another use is to simulate the "dired" feature of emacs for
loading files into the editor or running programs.
DIRECTORY INFORMATION.
To get directory information without pasting to the current cursor
position choose "Open" on the "FILE" menu and enter the starting
directory and wildcards. Press RETURN or SPACE) to get the file list
and end with escape (one or more) to abort the actual file load.
An alternate is to run the unix program `ls'. You may do so by the
following sequence or variant while the editor is running:
ENTER, `ls -al *.*', "Execute program"
LINE AND BOX DRAWING.
To draw lines and boxes choose "Box and line draw" on the "OTHER"
menu. The first prompt will be for the line drawing set. Normally
this prompt is skipped.
The first application of the mode sets line draw mode, in which the
cursor keys are used to draw lines. Other editing keys can also be
used, for example the return and delete key, space, normal text.
To turn off line and box drawing, apply the toggle again on the
"OTHER" menu.
The default line drawing set is determined by the value of variable
`drawing.style' in setup file PI.SET or $HOME/.pirc. A value of 1 is
normal. To see the effects of other values, choose one and experiment
with the cursor keys (the NotePad is a good place to experiment).
ASCII TABLE.
Select the menu OTHER and then "Ascii reveal codes" to display the
Ascii code of the character under the cursor. Selecting it twice
turns it off.
A number of text editors like to display the ASCII table instead.
If you really need an online ASCII chart, then please load the file
CHARS.TXT supplied with this editor package.
RESIZE SCREEN.
To resize the terminal screen or window:
Press the MENU key and move to the "OTHER" menu. Choose "Resize
Window" and press RETURN.
Enter the ROWS (22 normal).
Enter the COLS (78 normal).
A RETURN key keeps the old value. Use "Internal info" on the
"Help" menu to see the range of values possible.
On vt100 terminals, move the cursor off screen up and down afterwards
to reset the scrolling region to the new size.
In MS Windows 3.1, the unpredictability of the window size was a
constant trouble. There seemed to be no way to predict the ultimate
size of the window after launch. PI can react to new sizes manually,
but until it becomes a windows application, no automation is
possible. In Windows 95/98/2000 the window size problem has been
fixed and there is no reason to use resizing.
The main use for window resize is for remote modem connection. A good
size is 10 rows by 72 columns. Another application is a telnet
connection from an xterm window where the remote site does not
support X protocol, or where the trouble involved to set up X exceeds
the user's patience.
DEFINE COLORS IBM-PC.
To set the foreground and background colors choose "Color and menu
setup" on the "OTHER" menu.
The colors of everything can be permanently set in PI.SET. However,
experience showed that finding the right colors is a visual and
experimental process. Therefore, the color set is interactive, so
that experimentation is possible using the monitor and screen size
which will be in use. Other methods like color bar selection have
been tried but they proved to be confusing and not especially
experimental.
The drop-down menus have color assignments also which appear in
PI.SET. Setting these values interactively is clumsy. Instead, try
the color combinations as outlined above, then set the window
attributes accordingly in PI.SET. An exception is the box character
set used for menu edges. The 5 character sets can be selected
interactively from the "Color and menu setup" on the OTHER" menu.
See below for details.
COLOR RULES IBM-PC.
The rules for setting colors on IBM are simple. Choose a background
color using a number 0-7 and then a foreground color using 0-15. If
you choose the same number twice, then the text is invisible.
Otherwise, some contrasting pair of colors should appear. On a mono
monitor not many combinations will be visible.
The rules for obtaining a single integer ATTRIBUTE from the
foreground and background colors:
ATTRIBUTE = (foreground+(background)*16) - 128
dark colors: BLACK=0, BLUE=1, GREEN=2, CYAN=3, RED=4, MAGENTA=5,
BROWN=6, LIGHTGRAY=7
light colors: DARKGRAY=8, LIGHTBLUE=9, LIGHTGREEN=10, LIGHTCYAN=11,
LIGHTRED=12, LIGHTMAGENTA=13, YELLOW=14, WHITE=15
Example: BLACK on LIGHTCYAN uses attribute 48 because
(BLACK+(LIGHTCYAN)*16) - 128 = 48.
Warning: Attributes are in the range 0 to 127. Add 128 to an
attribute to make it blink.
COLORS SETUP PI.SET
The MSDOS file PI.SET contains the following setup lines with
suggestions for color assignments:
other.attributes=7; Screen attribute for edit screens
(7=mono,48=color)
title.attribute=15; Window title attribute flag
(31=boldface,15=mono).
window.attribute=19; Window text attribute
(19=blue /w yellow text,7=mono).
border.attribute=31; Window border attribute flag
(31=boldface,15=mono).
The line character set for the window border can also be set, as
follows:
box.characterset=2; Character set for box border
(0=Text,1=vga1,2=vga2,3=iso1,4=iso2)
The default for MSDOS is 2, double-line VGA characters.
DEFINE COLORS UNIX.
To set the foreground and background colors of menus under UNIX,
choose "Define colors" on the "OTHER" menu.
The colors of everything can be permanently set in ".pirc". However,
experience showed that finding the right colors is a visual and
experimental process. These color sets work only if the terminal is
ANSI, for example, remote connection to a unix host via Kermit.
COLOR RULES UNIX.
To set the foreground and background screen text color of PI under
unix requires a setup of the Xterm window in which PI operates. An
example:
xterm -bg yellow -fg blue -bd black -w 10 -geometry =80x34 &
Other xterm switches, commonly used, may be set in the ".Xdefaults"
source file:
+ah +cn +ls -s -sf -wf -j
Under Linux, with color_xterm, the menus may be set separately in the
file ".pirc". The colors:
30-37 foreground colors: 0=black, 1=red, 2=green, 3=brown,
4=blue, 5=magenta, 6=cyan, 7=white.
40-47 background colors: the same scheme.
0 Use the default colors set by the window system.
The setup lines in $HOME/.pirc are as follows:
ansi.mode.unix=1; Switch coloring mode 1=on, 0=off
tfg.text.fg.color=30;
tbg.text.bg.color=46; Use 0 for the X-windows bg color
mfg.menu.fg.color=37;
mbg.menu.bg.color=44;
box.characterset=0; Character set for box border
The line character set for the window border can be set, as follows:
box.characterset=4; Character set for box border
(0=Text,1=vga1,2=vga2,3=iso1,4=iso2)
The default for UNIX is 0, text characters. Use 3 or 4 if the font is
an iso-8859 font with line drawing characters. Use 1 or 2 for VGA
fonts, e.g.,
rxvt -fn vga -e pi -x &
launches PI in its own color window with vga font to simulate how the
program looks under Win98.
SUSPEND EDITOR.
To suspend PI, no file save:
For unix, use "Suspend editor" on the "QUIT" menu.
For MS-DOS, use "Swap pi and shell" on the "QUIT" menu. For many
years this has been mapped to F2, because it happens often. See
also PI.SET line "suspend.on.exit=1" which sets "File" menu item
"Save then exit" to a mode that emulates unix behavior.
This is the way to exit to the shell and do something else like run a
compiler, leaving your editing intact. Re-enter the editor with the
unix shell `fg' command or `%n' command (`man csh' for details).
The MS-DOS version uses Ralf Brown's (Thanks, Ralf!) SPAWN library to
release all memory used by PI and therefore make available for the
shell full memory. This method can be switched to a regular Turbo-C
library system call with reduced memory, if something goes wrong with
Ralf's SPAWN library. See menu "OTHER" and "Disk swap mode".
SUSPEND EDITOR AND EXIT TO SHELL.
A normal unix exit from PI will exit to the shell, where you can run
programs in a usual manner. The only exit that does not suspend the
editor is "Quit". The normal one for immediate suspend is "Suspend
editor". Both appear on the "Tools" menu.
The command named "Command shell" on the "TOOLS" menu exits the
editor and runs a private copy of the shell (bash under Linux). To
return to the editor, "exit" is required for the spawned shell. This
is sometimes confusing, because "jobs" will not show PI running and
it appears that PI has been trashed. However, some command like PS or
PSTREE will verify that indeed PI has been given a command to run the
shell, so "exit" will return to PI.
SHELL TO UNIX.
To exit to a new copy of Unix csh: press the MENU key and move to
"Tools". Choose "Command shell" and press RETURN.
To return to PI when done, type "exit" at the shell prompt. This
command executes so slowly that it is not recommended. Generally, it
is better and faster to choose "Suspend editor" on the "QUIT" menu,
then use the `fg' command to resume editing.
KEYMAP EDITING
To display all keys and their functions choose "Keymap editor" on the
"KEYS" menu. As you move the cursor through the list, the key
assignment appears on the status line.
To obtain a printed copy of the key list choose "Write pi-dump.key"
on the "Other" menu. Edit this file and choose "Print file" on the
"FILE" menu.
See also the MSDOS program PIHELPB.EXE, which displays common key
maps and keyboard layouts. Under Linux, the same program exists,
called pihelpbu. It can be displayed in an Xterm window or in a
console.
ONLINE HELP.
To get an online help file choose "Full manual" on the "Help" menu.
This runs the help program which displays the document pihelp.doc on
screen. Exit from the help routine restores the editing session.
MSDOS. There is a brief manual of key assignments that can be
displayed from the "Help" menu. This help program is normally bound
to Alt-F1. The full help display is bound to Shift-F1.
UNIX. There is a brief manual of key assignments that can be
displayed from the "Help" menu. This help program is normally bound
to ctrl-QH. The full help display is bound to ctrl-OH. The acronyms
for remembering the keys are "Quick Help" and "Ordinary Help".
PRINTED MANUALS.
The best help is a printed manual.
Print the manual yourself. Sources:
UNIX: $PIE/pihelp.htm
$PIE is /var/lib/pie/ or /usr/local/lib/pie/
MSDOS: c:\usr\PIHELP.HTM
To print the manual, load it into a browser like Netscape and use the
FILE menu "print" option. If a text-only version is wanted, then save
the file in Netscape as "text only" and edit away the top of the file.
RUN PROGRAM.
To run program XXXXXXXX:
Press the MENU key and move to "Tools". Choose "Execute program" and
press RETURN.
Enter XXXXXXXX and press RETURN. When the program exits, you will be
returned to PI.
It is common to run a compiler while in the editor. In this case, the
string XXXXXXXX is the command line "cc filename.c" or some variant.
Naturally, these key strokes can be memorized as a macro to reduce
the repetition.
MACRO IDEAS. A useful extension: Use "Paste directory" on the "File"
menu to put program names in the NotePad. Create a macro: begin with
"Execute program", grab the file name with backspace or Right-arrow,
then press RETURN. Each macro key will run the program at the cursor
position. Example: Run diff on selected pairs of files and collect
results to a single file.
GRABBING TEXT FROM THE SCREEN.
In each of the cases below, a key can be pressed after the string is
finished, which determines the action taken. Usually, the action is
to search for a string, load a file, inject a directory, copy a
substring, or some such task.
SEARCH STRINGS.
To use existing screen text for a search string:
Position the cursor at the desired text.
Press the ENTER key.
Press END for each token you want to capture. Use Right-Arrow to
grab single characters. Corrections are made with DELETE or
BACKSPACE or LEFTARROW.
Previous search strings can be recalled by pressing the SEARCH key
once again and then UPARROW and DOWNARROW to navigate through the
list of 51 saved search strings.
FILE NAMES.
To use existing screen text as a file name:
Position the cursor at the desired text.
Press the ENTER key.
Press END for each token you want to capture. Use Right-Arrow to
grab single characters. Corrections are made with DELETE.
DISABLE FUNCTION KEYS.
To disable a function key make it a duplicate for the NULL key
operation, which is do-nothing for this key. You will find it on the
"Keymap editor" on the "KEYS" menu. Key assignments are listed there.
To assign the duplicate function key, and hence disable that key,
choose "Keymap editor" on the "KEYS" menu.
SUN 3/50 KEYPAD CURSOR MOVES.
+----------------------+
| R1 | R2 | R3 | KEYPAD CURSOR MOVES
|Enter | Menu |PgUp | Press the key to execute
|-------+-------+------|
| R4 | R5 | R6 | ENTER-KEY KEYPAD MOVES
|Lt Edge|Rt Edge|PgDn | Press ENTER first, then the key
|-------+-------+------| +-------+
| R7 | R8 | R9 | | R8 |
|Insert | Up |Delete| |search |
|Toggle |Arrow |Char | |str up |
|-------+-------+------| +------+-------+------+
| R10 | R11 | R12 | | R10 | R11 | R12 |
| Left | Home |Right | | |Reverse| |
| Arrow | Cursor|Arrow | | | Home | |
|-------+-------+------| +------+-------+------+
| R13 | R14 | R15 | | R14 |
|Insert | Down |Delete| |search |
|Line |Arrow |Line | |str dn |
+----------------------+ +-------+
SUN 3/50 LEFT KEYPAD FUNCTIONS.
LEFT KEYPAD FUNCTIONS SUN 3/50
Press the key to execute
+-------------------------+
| L1 | L2 |
|Keymap edit |Run Program |
|------------+------------|
| L3 | L4 |
|Insert Line |Delete Line |
|------------+------------|
| L5 | L6 |
|Search Ahead|Search Back |
|------------+------------|
| L7 | L8 |
|Run Macro |Record Macro|
|------------+------------|
| L9 | L10 |
|Copy Line |Paste Line |
+-------------------------+
MAC PLUS KEYPAD CURSOR MOVES.
+-----------------------------+ MAC KEYPAD
| | = | / | * | EXTREME EDGE AND TOP OR
| Edit |Copy |Paste |Memori| BOTTOM OF FILE MOVES
| keymap| Line | Line |Steps | --PRESS ENTER FIRST--
|---------------+------+------| +----------------------+
| 7 | 8 | 9 | - | | 7 | 8 | 9 |
|Insert | Up |Delete| Page | | |Search | |
| Toggle| Arrow|Char | Up | | |str up | |
|-------+-------+------+------| |-------+-------+------|
| 4 | 5 | 6 | + | | 4 |Reverse| 6 |
|Left |Home |Right | Page | | | Home | |
| Arrow | Cursor| Arrow| Down | | | Cursor| |
|-------+-------+------+------| |-------+-------+------|
| 1 | 2 | 3 | | | 1 | 2 | 3 |
|Insert | Down |Delete| | | |Search | |
| Line | Arrow | Line | ENTER| | |str dn | |
|----------------------| KEY | +----------------------+
|Backward |Forward | | <=== MAC KEYPAD FUNCTIONS
|Search 0 |Search . | |
+-----------------------------+
MAC II/SE KEYPAD CURSOR MOVES.
+-----------------------------+ MAC II/SE KEYPAD
| Full | = | / | * | EXTREME EDGE AND TOP OR
| Key |Copy |Paste |Memori| BOTTOM OF FILE MOVES
| List | Line | Line |Steps | --PRESS ENTER FIRST--
|-------+-------+------+------| +----------------------+
| 7 | 8 | 9 | - | | 7 | 8 | 9 |
|Insert | Up |Delete| Page | | |Top of | |
| Toggle| Arrow|Char | Up | | | file | |
|-------+-------+------+------| |-------+-------+------|
| 4 | 5 | 6 | + | | 4 |Reverse| 6 |
|Left |Home |Right | Page | | | Home | |
| Arrow | Cursor| Arrow| Down | | | Cursor| |
|-------+-------+------+------| |-------+-------+------|
| 1 | 2 | 3 | | | 1 | 2 | 3 |
|Insert | Down |Delete| | | |Bottom | |
| Line | Arrow | Line | ENTER| | |of file| |
|----------------------| KEY | +----------------------+
|Backward |Forward | | <=== MAC KEYPAD FUNCTIONS
|Search 0 |Search . | |
+-----------------------------+
WORDSTAR LAYOUT FOR STANDARD QWERTY KEYBOARD.
+--------------------------------------------------------------------+
| Q | W | E | R | T | Y | U | I | O | P |
|quick |line |up |prev |erase |delete|abort |tab |option|ctrl |
|prefix|up |arrow |screen|right |line |key | key |prefix|insert|
+--------------------------------------------------------------------+
| A | S | D | F | G | K | L |
|left |left |right |right |delete|file |next | WORDSTAR KEYS ARE
|word |arrow |arrow |word |char |prefix|window| EXECUTED BY HOLDING
+------------------------------------------------+ DOWN THE CTRL KEY
| Z | X | C | V | B | N | AND PRESSING THE
|line |down |next |insert|reform|insert| INDICATED LETTER
|down |arrow |screen|toggle|lines |line |
+-----------------------------------------+
EMACS LAYOUT FOR STANDARD QWERTY KEYBOARD.
+--------------------------------------------------------------------+
| Q | W | E | R | T | Y | U | I | O | P |
|quote |kill |end of|search|transp|yank |repeat|tab |open |up |
|prefix|block |line | back |chars |killed|counts| key |line |arrow |
+--------------------------------------------------------------------+
| A | S | D | F | G | K | L |
|left |search|delete|right |abort |kill |center| EMACS KEYS ARE
|edge |ahead |char |arrow |all |to end|window| EXECUTED BY HOLDING
+------------------------------------------------+ DOWN THE CTRL KEY
| Z | X | C | V | B | N | AND PRESSING THE
|line |Emacs |exit |page |left |down | INDICATED LETTER
|down |prefix|editor|ahead |arrow |arrow |
+-----------------------------------------+
CUSTOMIZING PI.
The changes that can be made to the operation of PI are made through
resource files which are read by the editor. Many of the changes can
be done interactively as well. The files are:
Description Example file name
--------------------------------------------------
Defaults resource file ~/.pirc PI.SET
Key mapping resource file ~/.mykeys.key mykeys.key
Custom terminal file ~/.termcap NA
UNIX DEFAULT SETUP FILE.
It is possible to customize PI for your own use, so that it wakes up
in the modes and options that you wish to use. The mechanism for this
customization is a special file called `.pirc', which is to reside in
the home directory. PI will read this file by default.
To build your own SPECIAL COPY of .pirc, copy the file `SYSpi.rc'
from the directory $PIE to $HOME and edit its contents. The system
default file appears below.
MSDOS DEFAULT SETUP FILE.
The advice for unix applies with file name $PIE/SYSpi.rc. The setup
file PI.SET is located in the same directory as PI.EXE. Also located
there is setup files PI.DAT, needed for the keymap editor.
Local setup is done from the connected direcotry by copying PI.SET
there. Under unix, copy $HOME/.pirc to the connected directory. If
unix $HOME/.pirc does not exist, then copy the system file to the
unix directory arrived at by login.
INITIAL STARTUP OPTIONS.
The editor can be invoked with file names on the command line, in
which case the first file is displayed on startup. If no files were
specified, then the options are (1) Start with UnTitled, (2) Start
with menu. These two actions are toggled by the setting in PI.SET (or
file ".pirc" under unix):
action.on.startup=1; Menu on initial startup
action.on.startup=0; Start with file name "UnTitled"
Hint: Specify a file on th ecommand line to eliminate the creation of
the work file "UnTitled".
LOCAL SETUP.
The global setup file is "PI.SET" or ".pirc". A copy of it can
appear in a subdirectory to change defaults when PI is started from
that location. The items normally changed are backup, word wrap,
indent, margin, insert mode, colors, cursor.
UNIX TERMINAL TYPE.
The PI editor attempts to use system environment variables TERM and
TERMCAP to get terminal information. If these variables are unset,
then PI will assume vt100 and continue. For a list of all terminals
which are supported by PI, type the command $PIE/tcapnames.
Once the terminal type is known, you can either set the unix default
using the setterm command (see below), or else force PI to use the
terminal of your choice, via the command line switch "-term:" -- see
below.
The way to replace the system file /etc/termcap by your own is to use
features of environment variables which allow switching the system
default terminal database with another local one, over which you
have complete control. The basic mechanism the following:
setenv TERMCAP "tc=$HOME/.termcap"
where `.termcap' is a file in your home directory which contains the
termcap database record for your special terminal. Admittedly, this
is a fixup for missing entries in the termcap database, and you
should ask the system administrator to amend the database to
accommodate your equipment.
UNIX KEYBOARD.
The default keyboard function keys are set up by compiled defaults
that fit SUN and LINUX PC keyboards.
The editor has a keymap editor map function keys to ordinary tasks.
This is useful if you happen to have some extra function keys or if
the default maps are unsupported by the hardware.
IBM PC GREY KEYS.
Some of the keys on the IBM PC keyboard 101 are produced in
duplicate, notably the enter key and the arithmetic operators *+-/
which are near the numlock key.
The editor maps these keys to something useful when NUMLOCK is off.
When NUMLOCK is on the keypad becomes the classical "TEN KEY" for
data entry.
The defaults from compile time are (these settings may be put in
PI.SET):
plus.grey.keycode=33536; Grey plus mapped to "Alt =" (33536)
asterisk.grey.keycode=3103; Grey asterisk mapped to "Ctrl _" (3103)
enter.grey.keycode=33536; Grey enter mapped to "Alt =" (33536)
To restore all the keys to their original meaning use the following
lines in PI.SET:
plus.grey.keycode=20011; Grey plus mapped to itself (20011)
asterisk.grey.keycode=14122; Grey asterisk mapped to itself (14122)
enter.grey.keycode=57357; Grey enter mapped to itself (57357)
To decode the meaning of the keycodes requires translation from hex
numbers, usually printed in a reference manual for keys, into decimal
format. For the translations done above the codes work out as
follows:
Grey plus==0x4e2b==20011
Grey ast==0x372a==14122
Grey enter==0xe00d==57357
"Alt ="==0x8300==33536 (default is the ENTER key)
"Ctrl _"==0x0c1f==3103 (default is the MENU key)
A sample calculation (hex notation is a=10, b=11, c=12, d=13, e=14,
f=15):
0x4e2b == (4)16^3 + ( e)16^2 + ( 2)16^1 + ( b)16^0
== (4)16^3 + (14)16^2 + ( 2)16^1 + (11)16^0
== 20011
MOUSE.
Under unix the mouse setup is by X windows and not under the control
of PI (which uses X-term). All cut and paste operations are
controlled by X-term and the current X defaults for the window in
which PI is operating. The X-windows mouse is either on or off, as
set by the command line switch -m or the setup file toggle
"xmouse.toggle" (see .pirc).
MSDOS mouse control is by the mouse device driver supplied with the
mouse device. This software is installed during MSDOS boot before any
use of the mouse (the mouse won't work without it). If you are
running PI in a DOS window in Win95/98/2000, then Windows already has
assigned the mouse driver and nothing special is required, except to
allow that window to grab the mouse. Press the Win98 mouse on the "A"
icon to do that setup.
NOTE: These settings apply if PI was compiled with the mouse
routines. The default uses the TSR XPCMOUSE.EXE outside
PI or MS-Windows mouse.
In addition PI supplies two control variables in PI.SET. They are
horizontal.mouse.sens=8;
vertical.mouse.sens=16;
DEFAULTS. The defaults of 8 and 16 are recommended by most mouse
manufacturers. The effect of changing the numbers to a higher value
is to require more table space on which to move the mouse. Lower
numbers cause the mouse to react quickly to small motions on the
table.
DISABLE. Setting both values to 0 disables the mouse. It will not be
initialized or used. Use this setting if you are providing your own
mouse control program outside of PI, especially, MS-Windows.
MENU SLOWDOWN. The mouse action slows down on menus. It should be
approximately 8 times slower horizontally and twice as slow
vertically. The default is for the mouse to lock onto horizontal
lines. It will also lock onto columns but the bias is towards lines.
[With XPCMOUSE.EXE, menu access is by keyboard only. Ditto for
MS-Windows with the mouse properties disabled.]
CHANGES. In general the numbers 8 and 16 should be multiplied or
divided by powers of 2. You will find that changing 8,16 to 10,20
does no good at all: it just makes the mouse erratic.
BALLISTIC MOTION. Mouse driver software that provides ballistic
motion can be used to great advantage. Check out your mouse manual to
see if it is available and useful.
CURSOR STYLE.
The cursor under MSDOS can be set to a variety of styles. It is
easiest to set it experimentally from a pull-down menu inside the
editor. Then set it permanently in the setup file PI.SET. The
defaults of 1 and 13 apply to VGA. On some laptops and CGA machines
the defaults should be 6 and 7.
For unix under X-windows the cursor is set outside the editor by X
environment defaults. The basic customizations of the cursor in Xterm
are not very useful. The cursor color is settable by Xterm command
line arguments or in $HOME/.Xdefaults.
SETUP FILE .PIRC OR PI.SET.
; Default resource file "$HOME/.pirc" for the UNIX PI editor.
; Comment lines start with ';' or '#'.
; No leading white space on any line!
; The first three characters of a variable name are significant.
; Text can be edited.
;
; ====================== FAVORITE SETUP CHANGES =======================
;
select.emulation=2; None==0, Emacs==1, WordStar==2, WordPerfect==3. (2=default)
backup.toggle=2; Backup OFF (0) or ~/PIbackups (1) or ./PIbackups (2)
auto.indent.toggle=0; Toggle auto-indent word wrap (1=on,0=off). (1)
word.wrap.toggle=0; Toggle word wrap at right margin (1=on,0=off). (1)
hang.indent.toggle=0; Toggle hanging indent mode (1=on,0=off) (0)
xmouse.toggle=1; X-windows mouse for xterm. 0=off, 1=on.
; Press Left-mouse to set cursor, SHIFT-drag-mouse
; to copy and SHIFT-right-mouse to paste.
;
; ======================== STARTUP and EXIT =======================
;
action.on.startup=1; Menu on initial startup (1) or UnTitled (0).
suspend.on.exit=1; Suspend PI on SAVE THEN EXIT ctrl-KX. MSDOS (0)
;
; ========================= SETUP SIZE LIMITS =========================
;
xms.maximum.blocks=1024; Block maximum msdos xms (512) or unix (1024)
block.buffer.size=16; Block size msdos [2k->10k] (4) or unix [2k->32k] (16)
string.reserve.blocks=6; Blocks reserved msdos for internal line copying (6)
max.macro.size=256; Size in chars of a macro recording buffer (256=normal).
available.macros=25; Number of macro slots. See MACNUM in v10.c (25=normal).
info.max.size=40; Number of files editor will load at one time (40)
killed.line.max=1000; Maximum killed lines that will be saved (100=normal).
line.max.chars=384; Maximum allowed line length (160=normal).
most.lines.count=40; Most lines per screen >= 1+(row-max-index) (40=normal).
;
;
bit.strip.toggle=0; Toggle stripping of 128-bit on input file (1=on,0=off).
detab.toggle=1; Toggle auto-detab of input during scrolling (1=on,0=off).
fold.case.toggle=1; Toggle case-insensitive search mode (1=on,0=off).
insert.toggle=1; Toggle insert mode (1=on,0=off).
status.line.toggle=1; Print status line during edit (2=all,1=no numbers,0=off).
screen.tab.stop=8; Screen tab stop increment for TAB key (8=normal).
file.detab.stop=8; Tab stop increment for detabbing a file (8=default).
import.type=3; Import text line delimiter code (1=MSDOS,2=MAC,3=UNIX).
export.type=3; Export text line delimiter code (1=MSDOS,2=MAC,3=UNIX).
drawing.style=1; Default line/box drawing style (1 to 5,1=default).
tab.insert.mode=0; Tab key inserts spaces and/or TAB (1=on,0=off)
return.insert.crlf=0; EMACS-like split on RETURN (1=on,0=off)
right.margin=72; Right margin for word wrap and centering (72=normal).
; Don't change these....
search.token.lf=-128; Token in search string used for begin or end line
cga.noretrace.video=1; Set noretrace mode for CGA video (1=mono/ega/vga).
;
; ====================== COLOR INFO for IBM-PC =======================
;
; dark colors: BLACK=0, BLUE=1, GREEN=2, CYAN=3, RED=4, MAGENTA=5,
; BROWN=6, LIGHTGRAY=7
; light colors: DARKGRAY=8, LIGHTBLUE=9, LIGHTGREEN=10, LIGHTCYAN=11,
; LIGHTRED=12, LIGHTMAGENTA=13, YELLOW=14, WHITE=15
; Example: foreground=BLACK, background=LIGHTCYAN uses attribute 48
; because (foreground+(background)*16) - 128 = 48.
; Warning: Attributes are in the range 0 to 127.
; Add 128 to an attribute to make it blink.
; MSDOS uses special codes:
;other.attributes=(7=mono,48=color)
;title.attribute=(31=boldface,15=mono).
;window.attribute=(19=blue /w yellow text,7=mono).
;border.attribute=(31=boldface,15=mono).
;
; Unix variables are completely different:
other.attributes=7; Screen attribute for edit screens (7=normal)
title.attribute=128; Window title attribute flag (128=boldface).
window.attribute=7; Window text attribute flag (7=normal text).
border.attribute=128; Window border attribute flag (112=reverse video).
box.characterset=0; Box border char set (0=Text,1=vga1,2=vga2,3=iso1,4=iso2)
;
; =============== UNIX Color info for ANSI terminals ==================
;
; Colors are 0-7: 0=black, 1=red, 2=green, 3=brown, 4=blue, 5=magenta,
; 6=cyan, 7=white.
; Foreground: 30-37, background 40-47.
ansi-mode-unix=1; Set ANSI terminal mode (unix only, 0=off, 1=on)
tfg-text-fg-color=30; Foreground text color 30-37 ANSI mode (0=default)
tbg-text-bg-color=46; Background text color 40-47 ANSI mode (0=default)
mfg-menu-fg-color=37; Foreground menu color 30-37 ANSI mode
mbg-menu-bg-color=44; Background menu color 40-47 ANSI mode
;
; ========================== Printer Setup ==========================
;
printer.number=0; set printer 0-6:prn,com1,com2,com3,lpt1,lpt2,lpt3
lpp.printer=55; lines printed per page, 55 normal (printer)
left.spaces.printer=0; number of spaces printed before line (printer)
top.lines.printer=5; number of blank lines at top (printer)
bot.lines.printer=5; number of blank lines at bottom (printer)
formfeed.printer=1; use formfeed between pages, 1=on,0=off (printer)
;
; The abort key interrupts macros and stops type-aheads (editor halt).
abort.editor.char=21; Bailout/abort key is normally ctrl-U (21 decimal)
;
; Next two handled by TERMCAP - changes declare you an expert! (Win3)
row.max.index=23; Rows numbered 0..ROWMAX (ROWMAX=23 is normal).
col.max.index=79; Columns numbered 0..COLMAX (COLMAX=79 is normal).
;
; ==================== MSDOS MOUSE and CURSOR ===================
;
; Normal settings MSDOS: 0,0,1,13
;
horizontal.mouse.sens=0; Mouse sensitivity. Normal=8, Mouse Off=0.
vertical.mouse.sens=0; Mouse sensitivity. Normal=16, Mouse Off=0.
chigh.cursor.shape=1; Set IBM cursor to vga (1) or cga (6) or mono (12).
clow.cursor.shape=13; Set IBM cursor to vga (13) or cga (7) or mono (13)
;
; ======================= HTML Browser Default ======================
;
; Win95/98/2000: Unix:
; browser=netscape.exe browser=netscape
; browser=iexplorer.exe browser=netscape& [launch in background]
; browser=lynx
browser=netscape&
;
; ======================= MSDOS Bios KEY REMAP ======================
;
; MSDOS: Mapping of GREY keys on IBM 101 keyboard via bios keycode
; Grey plus==0x4e2b==20011, Grey ast==0x372a==14122, Grey ent==0xe00d==57357
; "Alt ="==0x8300==33536 (ENTER key), "Ctrl _"==0x0c1f==3103 (MENU key)
; To restore a key, use its keycode, e.g., uncomment one of these:
plus.grey.keycode=20011; Grey plus mapped to itself (20011)
asterisk.grey.keycode=14122; Grey asterisk mapped to itself (14122)
;enter.grey.keycode=57357; Grey enter mapped to itself (57357)
; The defaults from compile time are:
;plus.grey.keycode=33536; Grey plus mapped to "Alt =" (33536)
;asterisk.grey.keycode=3103; Grey asterisk mapped to "Ctrl _" (3103)
;enter.grey.keycode=33536; Grey enter mapped to "Alt =" (33536)
;
; ====================== Cycle Tables for accented chars =============
;
;czech keys. The array is 66 chars long. First is space \40.
; The 33 pairs are toggled by the F12 key or ctrl-\.
; To see the set correctly load MSDOS 5.0 code page 852!
;31000
; foreign=\40\363a\240e\202i\241o\242u\243y\354c\237d\324n
; foreign=\345r\375s\347t\234z\247A\265E\220I\326O\340U\351Y
; foreign=\355C\254D\322N\325R\374S\346T\233Z\246\243\205\205u
; foreign=\202\330\330e\220\267\267E
;
; ============================ KEY MAPS ===========================
;
; The keymap changes from the default plus macro keys are to be entered
; below. Global changes should be made in the system file PI.SET using
; the editor built-in "Keymap Editor" on the TOOLS menu.
;
; A local change comes from copying PI.SET to the connected directory.
; PI.SET is read during PI startup. Dynamic local changes in the keymap
; can be made from PI-MACRO.KEY, which is also read on startup, from the
; connected directory. Startup macros and key definitions can be in
; both files. PI.SET is read first, then PI-MACRO.KEY. Permanent
; local changes are made by manually moving text from PI-MACRO.KEY
; into the file PI.SET. All changes made in the KEYMAP EDITOR go directly
; into PI.SET. The file PI-MACRO.KEY is considered a temp file, but it
; is useful for temporarily loading some macros.
;
; All remarks here apply as well to unix, where the file names change to
; ".\PI.SET" <--> "./.pirc" and ".\PI-MACRO.KEY" <--> "./pi-macro.key".
;
15001 * Latex * [MACROKEY+1]
macro=^K^S\E\Elatex ^K^F^O^R
key=\E1
tool=Latex on current file
15002 * View dvi * [MACROKEY+2]
macro=\E\Exdvi ^K^F^H^H^H^H &^O^R
key=\E2
tool=Xdvi on current file
15003 * Print dvi * [MACROKEY+3]
macro=\E\Elpr ^K^F^H^H^H.dvi^O^R
key=\E3
15004 * ispell * [MACROKEY+4]
macro=\E\Eispell ^K^F^O^R
key=\E4
15005 Date line [MACROKEY+1]
key=\Ed
macro=^Q^Pdate^M
tool=Date insert
15006 Xterm font "fixed" [MACROKEY+1]
macro=^O^Qecho -e "\033]50;fixed\7"^M
tool=Xterm setfont "fixed"
; ========= End of original PI.SET source ======================