home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Dream 49
/
Amiga_Dream_49.iso
/
atari
/
texte
/
oribin.zoo
/
readme.st
< prev
next >
Wrap
Text File
|
1991-07-26
|
37KB
|
754 lines
{{{ Introduction
-----------------
This file contains additional information about the ATARI ST version of
ORIGAMI. It contains both ST specific features/problems as well as
information necessary to compile ORIGAMI yourself. Please refer to the
ORIGAMI manuals for a general introduction to ORIGAMI and to the ORIGAMI man
page for a description of advanced command line options.
This file was created using ORIGAMI. The lines starting with 3 braces are
fold-comments created by ORIGAMI - just ignore the braces. They make sense if
the file is read into ORIGAMI (which I do for editing).
Origami is a folding editor similar to the TDS editor. (Some PC users call it
an outline editor.) ORIGAMI enables you to fold parts of your texts in order
to increase readability. The additional folding information is written to the
file, but it is hidden by embedding it in comments - the comment syntax can
be defined to meet nearly every existing language (C,Pascal,shell script,
Assembler, miranda, ...). Some of the highlights of ORIGAMI include:
- keyboard macros - record keyboard events and replay them when needed
- argument repeat - simply say 'repeat that command 17 times' ...
- a powerful macro language (OCL = Origami Command Language). OCL includes
if, while, ... structures, local variables, ..., and allows to write very
powerful macros (take a look at the towers-of-hanoi and the fill-paragraph
macros).
- freely definable keyboard layout - use the command syntax YOU like
- some powerful shell & pipe commands - send your text to/from an external
command, pipe your text through an external filter, ...
- TDS compatibility - ORIGAMI is able to read, write & edit the strange
binary file format used by the INMOS Transputer Development System - so
you do not need a transputer to edit these files anymore
- filed folds: you can enter and exit these folds just like other folds in
your text, but in fact they are in different files ... these files are
loaded / saved automatically if you enter/exit such folds.
- autosave: the current text is saved automatically after a selectable
period of time
If you fix bugs, please send a description or (even better) uuencoded
contexts diffs to:
mhaardt@ftp.thp.uni-koeln.de
You can get the beta-versions from the MINIX ftp archive in Cologne, Germany:
Server: ftp.thp.uni-koeln.de [134.95.64.1]
Path: minix/beta-test (this might change)
Files: origami.tar.Z
All files are 13-bit compressed tape archives.
Future versions of ORIGAMI are likely to appear on that FTP server, too
(sources). ST binaries will show up in the appropriate newsgroups, including
pre-compiled keybindings.
}}}
{{{ Installing ORIGAMI
-----------------------
To install ORIGAMI, simply copy the file ORIGAMI.PRG to your hard disk or to
your working disk. Origami then needs a keybinding-file called ORIGAMI.RC and
- optional - the files ORIGAMI.BIN (key binding description, displayed
through the 'describe-bindings' function) and ORIGAMI.HEL (help file,
displayed through the HELP function). If you are using the desktop, these
files can simply be copied to the same folder which contains ORIGAMI.
If you are using a shell like gulam, mupfel etc., you should set up an
environment variable HOME (the mupfel default installation does this
automatically). Then copy the above mentioned files to the folder which the
environment variable HOME points to. example:
SETENV HOME d:\gdist1_2\gemini
(this command should be placed in your shell startup file, eg the file
MUPFEL.MUP if you are using MUPFEL. Refer to your shell documentation for
details)
In this case, you should copy the files ORIGAMI.RC, ORIGAMI.BIN and
ORIGAMI.HEL to the folder d:\gdist1_2\gemini
Copy the file ORIGAMI.PRG to any place you wish to - but take care that your
shell can find ORIGAMI - see your shell manual for details about PATHs etc.
Although ORIGAMI is a GEM-based program, it WILL take command line arguments
as described in the docs. As far as I know, there is no possibility to pass
parameters to a GEM program when using the Desktop (who is really using the
Desktop ?)
If you do not set the environment variable HOME, ORIGAMI looks for these
files in the current working directory.
If you do not have a hard disk, simply copy the files ORIGAMI.PRG,
ORIGAMI.RC, ORIGAMI.BIN and ORIGAMI.HEL to a folder (or, maybe better, to the
root directory) of your working disk.
The files ORIGAMI.RC and ORIGAMI.BIN are created automatically by the KEYBIND
compiler which offers a complete redefinition of the keyboard as well as a
powerful macro programming language. For a start, you can simply copy these
files from your distribution disk (if they came with the binaries) and learn
about KEYBIND later. Note that KEYBIND overwrites these files when it is
executed, so be sure to have a copy of them - ORIGAMI will refuse to start
without a proper keybinding. If you have only the sources, you will have to
create these files using keybind as follows:
keybind -sv st.key
(when using a shell). If the 's' option is given, the 'sort.ttp' program must
be available in the shell's path. The current working directory must be set
to be the BINDINGS directory from the distribution, as KEYBIND will look for
include files.
If you are using the Desktop, copy the file KEYBIND.TTP to the BINDINGS
directory. Double-click on KEYBIND.TTP and enter '-v st.key' in the parameter
box. Keybind will then create the files ORIGAMI.RC and ORIGAMI.BIN which can
then be used as described above.
}}}
{{{ Starting ORIGAMI
---------------------
To start ORIGAMI, double-click on ORIGAMI.PRG from the desktop or type
'origami' from your shell. Origami then prompts for a file to edit. Simply
enter the name of a not-existing file, ORIGAMI will then come up with an
empty editing buffer.
You should now take the ORIGAMI manual (perhaps it would be a good idea to
print it out first) and try some functions. When using the default ORIGAMI.RC
and ORIGAMI.BIN from the ST folder of your ORIGAMI distribution, most keys
will behave like they do in many other ST programs. By pressing the HELP key,
a keybind-description is displayed which can be used to find out which keys
activate which functions. The functions not listed in the ORIGAMI manual (eg
towers-of-hanoi) are OCL macros. Refer to the ST keybinding source file
ST.KEY for details about using these macros. For a start, you might try the
following:
enter a blank line
type 6-10 characters
type ESC h a n o i
watch ...
load a text file (eg this file)
enter a paragraph with normal text
type ESC f p
watch ...
repeat this, but change the fill-paragraph mode by pressing ESC f m
}}}
{{{ Arguments
--------------
As mentioned above, ORIGAMI will take command line arguments. As it is not
possible to pass such arguments from the standard desktop, I implemented
another possibility:
When ORIGAMI is started without any arguments, the file ORIGAMI.OPT is read
and the first line of this file is used as the arguments to ORIGAMI, just as
if they had been typed that way. If the file ORIGAMI.OPT contains the
following:
-A ..\tos\readme.st
then ORIGAMI will load the file "..\tos\readme.st" and execute the
auto-macro. Of course it is not necessary to give a filename. The file
ORIGAMI.OPT is first searched in the current directory. If this fails, the
file is searched in the directory which is given by the environment variable
HOME. If this fails, too, then nothing is done. This means that you can have
several ORIGAMI.OPT files for different purposes if you invoke ORIGAMI from
within different current directories (on the desktop this means that ORIGAMI
is not in the current (=active) window, so you have to start it by
double-clicking ORIGAMI.PRG while pressing the right mouse button).
}}}
{{{ The ST keyboard and GEM menu bar
-------------------------------------
When generating own keybindings using the KEYBIND compiler, you will need
some additional knowledge about the ST specific keyboard routines used in
ORIGAMI. Nearly every ST key can be defined differently in combination with
the Shift, CTRL and ALT keys. Combinations of SHIFT, CTRL and ALT are not
allowed, the keys are checked in the order first ALT, then CTRL, then SHIFT.
Pressing CTRL-ALT-'A' achieves the same result as ALT-'A' as ALT is checked
first.
The ST keys generate two types of keyboard codes:
- normal ASCII and Control-Codes , e.g. the letters a..z and most of the
combinations of SHIFT / CTRL and a letter.
- some keys generate 'meta'-codesequences. These consist of a meta-code and
a keycode. There are four meta-codes depending on the state of the
Shift/CTRL/ALT keys. These meta codes are called 'meta' (none of the keys
Shift/CTRL/ALT pressed), 'smeta' (Shift pressed) ,'cmeta' (CTRL pressed)
and 'ameta' (ALT pressed). They can be accessed under these names in the
keybinding (see the ST sample keybinding file ST.KEY for examples). This
method is a bit unusual, but it enables you to define nearly every
keyboard layout you might want. The GEM menu bar creates sequences of
'mmeta' and a character. Although the menu bar itself is fixed, this
method enables it to redefine the menu function if desired. Keybindings
which contain 'mmeta'-codes are not listed in the describe-bindings list.
The GEM screen redraw message creates the sequence 'mmeta','@' and should
be bound to some function. This function does not have to do something
useful, it is just necessary to leave the inner line-editor loop in order
to recognize the redraw. In my keybinding, I use a macro which does
nothing but moving the cursor one position to the right and then back
left. The sequence should not be bound to the redraw-display function, as
this will yield a double screen redraw.
On the ST, the 'GENERAL ABORT KEY' can not be freely defined as described in
the ORIGAMI manuals. GENERAL ABORT is activated by pressing both SHIFT keys
together (you may have to press them for about 0.5 seconds).
The following aliases are pre-defined on the ST (this are all aliases which
MAY be available on UN*X via the termcap library if the terminal supports
them):
"backspace"
"rubout" (DEL key)
"home"
"left"
"right"
"up"
"down"
"next_page" (CTRL-down)
"prev_page" (CTRL-up)
"f1" - "f10" (function keys)
A list of ST keys which generate CTRL-codes or meta-sequences can be found
near the end of this file. Listed are the name of the ST key (on a german ST
keyboard) and the codesequence which is generated by this key. The
codesequences are given in keybind-syntax - look at the file ST.KEY for
examples on using these special ST keys.
WARNING: Since ORIGAMI 1.5, there have been some changes in the CTRL-TAB in
order to support the O_QUOTE function for CTRL-codes and in the MENU code tab
in order to implement the new functions.
After O_QUOTE, the next meta sequence is returned without the meta character.
This can be used to enter CTRL-characters into the text (except C-J) or to
check which character is returned after a META code (if the tables at the end
of this file should be wrong ...).
After O_QUOTE, it is also possible to enter the decimal number of the
character you want to get by typing the number on the numeric keypad while
pressing the ALT key. Pressing any other key ends this mode and enters the
choosen character into the text. code below 252 may be entered. For example,
by pressing O_QUOTE, ALT-1, ALT-8, ALT-9, ALT-ENTER, you get the copyright
sign (╜).
If something in the translation tables is wrong, changes can be made in the
file ST_KEYB.C. If you have problems because of a non-german keyboard layout,
please try to remap the keys by changing the keybinding before making changes
to the ORIGAMI C-code - I want to avoid several versions of ORIGAMI. I know
that some of the meta-sequences are not very logical - but please keep them
as they are in order to avoid confuzion with different ORIGAMI versions. It
should not bother too much as you get to see these sequences only once when
defining aliases for your the special keys used in your keybinding.
}}}
{{{ ST-specific extensions
{{{ GEM Fileselector
---------------------
You can invoke the GEM fileselector by pressing RETURN when ORIGAMI asks for
a filename. This enables macros to enter a fixed filename which would not be
possible if the fileselector would appear automatically.
}}}
{{{ backup files
-----------------
When saving a file, the ST version of ORIGAMI will preserve the previous
contents of that file in a file with the extension '.BAK'. This behaviour can
be disabled by using the additional '-B' option (via commandline or
ORIGAMI.OPT).
}}}
{{{ shell commands / sub shells
When calling a shell on the ST via the standard system() call, the shell in
memory which has started ORIGAMI is invoked. As a result of this, ORIGAMI
cannot simply set the environment variables ORIWORD, ORILINE and ORIFILE. As
a replacement, the shell is called with something like 'setenv "var=value"' -
this will set the shell's environment. The only problem is that the command
may not contain some special characters - eg '"' - and that the syntax for
the setenv command depends on the used shell. In order to make this work
with every shell without recompilation, this part of ORIGAMI can be
configures by setting two environment variables before starting ORIGAMI:
SHELL_SETENV and SHELL_SETCONV. If these are not set, a default will be used
which works with MUPFEL.
SHELL_SETENV contains the string which is passed to sprintf(). It may contain
2 ocurrences of %s - the first is the environment variable to set and the
second is the new value. "%s=%s" will produce something like "var=value",
which is the right command for SH/KSH and similar shells. "setenv %s=\"%s\""
will produce something like "setenv var=\"val\"" etc. which works with
MUPFEL.
SHELL_SETCONV controlls character substitution in 'val'. It may contain pairs
of characters - every ocurrence of the first character in a set is replaced
by the second one. If SHELL_SETCONV is "a_", then every 'a' in the value to
be set is replaced by a '_'. This can be used to avoid characters which would
otherwise confuse the shell, eg. '"', by replacing them with spaces.
If anyone has got an idea how this putenv/system stuff can be rewritten to
avoid this problems, please tell me !
}}}
}}}
{{{ The ST Screen implementation
---------------------------------
All output of ORIGAMI is printed via the VDI. This should work on nearly
every type of monitor. The VDI output is not as fast as TEMPUS etc., but it
should be compatible to the TT and some special ST graphic cards. It was
tested on a normal 1040ST and it also works well with Autoswitch-Overscan.
For speed reasons, the mouse and text cursor are only displayed when in edit
mode, not during the execution of a command. This is not ideal, but it was a
major speedup against the previous version which turned the mouse off before
every text output and on afterwards. If someone has a better method, tell me
(no Line-A or similar things please!)
The screen routines always do a full-screen redraw, no matter what the GEM
screen manager requests. ORIGAMI will suspend output while the ORIGAMI window
is not the top window on the screen, in order not to overwrite the top
window. At the moment when the ORIGAMI window becomes the top window again,
ORIGAMI will do a full-window redraw. Redraw is also held back while ORIGAMI
is in the read-prompt routine (eg. when 'set-language' was selected or when
ORIGAMI prompts for a filename). If ORIGAMI receives a redraw-message, the
part of the screen which should be redrawn is marked with a line pattern.
This avoids ugly effects when moving the window of an accessory.
(The ORIGAMI window is not vivible as a window. It is the white area covering
the whole screen except the menu bar. Maybe it will become a real, movable
window in a future version).
}}}
{{{ The ST version of KEYBIND
------------------------------
The ST version behaves much like the SUN/UN*X version described in the
ORIGAMI docs. However, as the ST OS (can we really call this thing an OS ?)
does not support pipes, a separate program called SORT.TTP is called
automatically if you start keybind with the '-s' option (which is highly
recommended). SORT is executed via a system()-call - this means it only works
if a shell like MUPFEL or GULAM is available.
If the environment variable HOME is not set, KEYBIND.TTP creates the files
ORIGAMI.BIN and ORIGAMI.RC in the current working directory.
Keybindings containing 'mmeta'-codes are not listed in the ORIGAMI.BIN-file,
as they only contain internal codes which would not be of any use.
}}}
{{{ Temporary files
--------------------
Temporary files are needed mainly to implement the pipe functions. ORIGAMI
first looks if an environment variable TMP exists. If it does, the temporary
files are put there. If this fails, the environment variable TEMP is used. If
this fails, too, the files are created in the current working directory.
The files are named XXXXXXXX.tmp, where XXXXXXXX is an 8-digit decimal
number, starting with 0. Existing files with that name will not be
overwritten, instead the next free number is used.
}}}
{{{ Known bugs
---------------
When you start TurboC from GEMINI, then use the 'TOS SHELL' function to
create a MUPFEL sub shell and then start ORIGAMI from that shell, the mouse
will not appear. This seems to be a bug in TurboC or in Mupfel, as other
programs have the same problems when started that way.
I was not able to test ORIGAMI on a color monitor (I do not have one) - so I
cannot tell if it works. Any comments are welcome.
I am quite sure that ORIGAMI will crash if it runs out of memory. Keep enough
memory free and save your file frequently (or use auto-save).
}}}
{{{ Compiling Origami/Keybind
------------------------------
If you want to compile ORIGAMI yourself, you will need TURBO-C 2.0. In order
to compile ORIGAMI you have to do the following:
- unpack the source archive
- convert LF at end of line to CR/LF (using UNX2ST or some other utility,
some text editors will work too - simply load and save the files). Maybe
you do not have to convert anything because it was done when downloading
the files in ASCII mode ...
- create a LOCAL subdirectory inside your TC 'include' directory and copy
the files from ORIGAMI\SRC\LOCAL there.
- copy the file SRC\TOS\ORIGAMI.PRJ to SRC\ORIGAMI\
- start the program UNIXNAME.PRG. This does a translation of unix-line '/'
to a tos-line '\' in filenames. If you haven't got UNIXNAME, you will have
to change all #include statements manually. UNIXNAME is a resident utility
that only needs to be executed once after booting your computer (maybe in
the AUTO folder). UNIXNAME should come with the ST specific parts of the
ORIGAMI sources.
- start TC, select the project file SRC\ORIGAMI\ORIGAMI.PRJ. Disable ALL
compiler and linker options (except debug info if required) - they are set
in the project file.
- select 'MAKE'. If TC complains about non-existent include files - that is
OK. Simply create an empty file with the required name. I remember the
files UNISTD.H, TERMCAP.H, SGTTY.H, PWD.H and SYS\TYPES.H (create SYS
subdirectory in INCLUDE directory). Maybe there are more files which I
forgot. TC should now compile ORIGAMI - this takes some time. Some
warnings are OK, but there should be no errors.
- The GEM ressource data is compiled directly into the program (module
ORI_RSC.C) in order to avoid loading extra RSC-files (bad when ORIGAMI is
called from a shell). This C-file is created by a special utility which I
will post soon (called RSH2RSI or RSCCONV).
WARNING: in the file SRC\ORIGAMI\OS.H, there is a recursive #define for
strlen(). If you want to use a different compiler than TC, this might cause
problems.
Now, you have to compile KEYBIND:
- again, make sure UNIXNAME is activated
- convert CR/LF as mentioned above
- copy the file SRC\TOS\KEYBIND.PRJ to SRC\KEYBIND\
- select project file SRC\KEYBIND\KEYBIND.PRJ
- disable all compiler and linker options
- select MAKE. There may be warnings, but no errors.
Now you are ready to compile the sample ST.KEY keybinding (or simply use the
provided, pre-compiled ORIGAMI.RC and ORIGAMI.BIN if they came with the
program) and make changes to the code.
AS MICHAEL HAARDT WHO MAINTAINS THE UN*X VERSION OF ORIGAMI DOES NOT LIKE
NON-POSIX STUFF IN THE SOURCES (EVEN IF I USE #IFDEF), YOU SHOULD RESTRICT
CHANGES TO THE ST-SPECIFIC FILES IN THE TOS FOLDER IF IT IS POSSIBLE - THIS
INCREASES THE CHANCE THAT THESE CHANGES CAN BE SUPPORTED IN THE NEXT VERSION
OF ORIGAMI. I do not want to apply the ST-specific changes in the ORIGAMI
main code every time a new ORIGAMI/UNIX version comes out (most improvements
are first made in the UN*X version and then ported to other systems).
}}}
{{{ Bugfixes
-------------
If you have discovered new bugs in ORIGAMI, please send me a note, if
possible with a clear description of a method by which the problem can be
reproduced. If you have a fix for that bug - even better, use 'diff -c' to
create a file that contains the differences between the original ORIGAMI code
and your code, then send me this file. DO NOT SEND THE COMPLETE SOURCE, ONLY
DIFFS!
}}}
{{{ Folder
-----------
In the ORIGAMI distribution, there is a little utility called FOLDER. This
utility takes a directory path or a list of files and creates a list of filed
folds for all given files. This list is written to standard output and should
be re-directed to a file. If a directory is passed as an argument to folder,
all sub-directories are folded recursively. For example, if E:\TC\SOURCE is
your C-source directory, you might type
folder e:\tc\source >c-source
at your shell prompt. FOLDER will then create a file called c-source which
contains filed folds for the whole source directory and everything within it.
If you start ORIGAMI and load this file, you can edit all your source files
by simply 'entering' the appropriate file folds in the list. FOLDER also has
some extra command line options, which are listed in the FOLDER man page
file.
}}}
If I forgot to document some special ST feature (which is not unlikely,
because I wrote this text after finishing the first ORIGAMI release and some
things do rapidly change) - please tell me so that I can incorporate these
thing into this file.
(email: send any comments to Michael Haardt, he will forward them to me.
Send mail to mhaardt@ftp.thp.uni-koeln.de. )
Michael Schwingen
Ahornstr. 36
W-5100 Aachen
Germany
{{{ ST Keyboard / menu code table
----------------------------------
{{{ normal:
------------
ESC ( = M-xxx in keybind) $esc
Backspace C-H
Delete $meta C-G
Return C-M
TAB C-I
HELP $meta C-V
UNDO $meta C-U
INSERT $meta C-F
Up $meta C-B
Clr/Home $meta C-A
arrow left $meta C-C
arrow down $meta C-E
arrow right $meta C-D
num. keypad ( $meta "(
num. keypad ) $meta ")
num. keypad / $meta "/
num. keypad * $meta "*
num. keypad 0 $meta "0
num. keypad 1 $meta "1
(...)
num. keypad 9 $meta "9
num. keypad - $meta "-
num. keypad + $meta "+
num. keypad ENTER $meta C-M
num. keypad . $meta ".
F1 $meta C-J
F2 $meta C-K
F3 $meta C-L
F4 $meta C-N
F5 $meta C-O
F6 $meta C-P
F7 $meta C-Q
F8 $meta C-R
F9 $meta C-S
F10 $meta C-T
}}}
{{{ with SHIFT pressed:
------------------------
ESC $smeta $esc
Backspace $smeta C-H
TAB $smeta C-I
Delete $smeta C-G
Return C-M
(same as RETURN without Shift)
HELP $smeta C-V
UNDO $smeta C-U
INSERT $smeta C-F
arrow up $smeta C-B
Clr/Home $smeta C-A
arrow left $smeta C-C
arrow down $smeta C-E
arrow right $smeta C-D
num. keypad ( $smeta "(
num. keypad ) $smeta ")
num. keypad / $smeta "/
num. keypad * $smeta "*
num. keypad 0 $smeta "0
(...)
num. keypad 9 $smeta "9
num. keypad - $smeta "-
num. keypad + $smeta "+
num. keypad ENTER $smeta C-M
num. keypad . $smeta ".
F1 $smeta C-J
F2 $smeta C-K
F3 $smeta C-L
F4 $smeta C-N
F5 $smeta C-O
F6 $smeta C-P
F7 $smeta C-Q
F8 $smeta C-R
F9 $smeta C-S
F10 $smeta C-T
}}}
{{{ with CTRL pressed:
-----------------------
ESC $cmeta $esc
1 $cmeta "1
2 $cmeta "2
(...)
9 $cmeta "9
0 $cmeta "0
₧ $cmeta "?
' $cmeta "`
# $cmeta "#
Backspace $cmeta "U
TAB $cmeta "T
Q C-Q
W C-W
E C-E
R C-R
T C-T
Z C-Z
U C-U
I $cmeta C-I
O C-O
P C-P
Ü $cmeta "@
+ $cmeta "+
RETURN $cmeta "M
DELETE $cmeta "q
A C-A
S C-S
D C-D
F C-F
G C-G
H $cmeta C-H
J $cmeta C-J
K C-K
L C-L
Ö $cmeta "[
Ä $cmeta "]
~ $cmeta "~
< $cmeta "<
Y C-Y
X C-X
C C-C
V C-V
B C-B
N C-N
M $cmeta C-M
, $cmeta ",
. $cmeta ".
- $cmeta "-
HELP $cmeta "s
UNDO $cmeta "r
INSERT $cmeta "p
arrow up $cmeta "l
Clr/Home $cmeta "k
arrow left $cmeta "m
arrow down $cmeta "o
arrow right $cmeta "n
num. keypad ( $cmeta "(
num. keypad ) $cmeta ")
num. keypad / $cmeta "/
num. keypad * $cmeta "*
num. keypad 0 $cmeta "A
num. keypad 1 $cmeta "B
num. keypad 2 $cmeta "C
num. keypad 3 $cmeta "D
num. keypad 4 $cmeta "E
num. keypad 5 $cmeta "F
num. keypad 6 $cmeta "G
num. keypad 7 $cmeta "H
num. keypad 8 $cmeta "I
num. keypad 9 $cmeta "J
num. keypad - $cmeta "_
num. keypad + $cmeta "=
num. keypad ENTER $cmeta ";
num. keypad . $cmeta ":
F1 $cmeta "a
F2 $cmeta "b
F3 $cmeta "c
F4 $cmeta "d
F5 $cmeta "e
F6 $cmeta "f
F7 $cmeta "g
F8 $cmeta "h
F9 $cmeta "i
F10 $cmeta "j
}}}
{{{ with ALT pressed:
----------------------
ESC $ameta $esc
1 $ameta "1
2 $ameta "2
(...)
9 $ameta "9
0 $ameta "0
₧ $ameta "?
' $ameta "`
# $ameta "#
Backspace $ameta C-H
TAB $ameta C-I
A $ameta "A
B $ameta "B
C $ameta "C
(...)
Z $ameta "Z
+ $ameta "+
RETURN $ameta C-M
DELETE $ameta "q
~ $ameta "~
< $ameta "<
, $ameta ",
. $ameta ".
- $ameta "-
HELP/Undo/cursor/Insert/ClrHome cannot be used together with ALT
num. keypad ( $ameta "(
num. keypad ) $ameta ")
num. keypad / $ameta "/
num. keypad * $ameta "*
num. keypad - $ameta "_
num. keypad + $ameta "=
num. keypad ENTER $ameta ";
num. keypad 0 $ameta C-A
num. keypad 1 $ameta C-B
num. keypad 2 $ameta C-C
num. keypad 3 $ameta C-D
num. keypad 4 $ameta C-E
num. keypad 5 $ameta C-F
num. keypad 6 $ameta C-G
num. keypad 7 $ameta C-J
num. keypad 8 $ameta C-K
num. keypad 9 $ameta C-L
F1 $ameta "a
F2 $ameta "b
F3 $ameta "c
F4 $ameta "d
F5 $ameta "e
F6 $ameta "f
F7 $ameta "g
F8 $ameta "h
F9 $ameta "i
F10 $ameta "j
}}}
{{{ GEM menu codes:
--------------------
FILE:
quit $mmeta,'b'
fast exit $mmeta,'c'
read file $mmeta,'d'
write file $mmeta,'e'
save current file $mmeta,'f'
insert file $mmeta,'g'
next file $mmeta,'h'
previous file $mmeta,'i'
SPECIAL:
help $mmeta,'j'
describe bindings $mmeta,'k'
set language $mmeta,'l'
TOS shell $mmeta,'m'
shell command $mmeta,'n'
PIPE from $mmeta,'o'
PIPE to $mmeta,'p'
Filter-Buffer $mmeta,'q'
PIPE KBD from $mmeta,'r'
MODES:
Insert-Mode $mmeta,'s'
Overwrite-Mode $mmeta,'t'
View-Only-Mode $mmeta,'u'
Read-Write-Mode $mmeta,'v'
Autosave $mmeta,'w'
no Autosave $mmeta,'x'
MACROS:
define macro $mmeta,'y'
execute macro $mmeta,'z'
define fix macro $mmeta,'A'
execute fix macro 1 $mmeta,'B'
execute fix macro 2 $mmeta,'C'
execute fix macro 3 $mmeta,'D'
execute fix macro 4 $mmeta,'E'
execute fix macro 5 $mmeta,'F'
GOTO:
goto line $mmeta,'G'
goto top of fold $mmeta,'H'
goto bottom of fold $mmeta,'I'
search $mmeta,'J'
search reverse $mmeta,'K'
replace string $mmeta,'L'
query-replace string $mmeta,'M'
FOLDING:
open fold $mmeta,'N'
close fold $mmeta,'O'
enter fold $mmeta,'P'
exit fold $mmeta,'Q'
unfold fold $mmeta,'R'
create fold $mmeta,'S'
auto-create fold $mmeta,'T'
auto-header $mmeta,'U'
toggle create file-fold $mmeta,'V'
toggle attach file to fold $mmeta,'W'
describe fold $mmeta,'X'
double line $mmeta,'Y'
move line $mmeta,'0'
pick line $mmeta,'1'
copy-pick line $mmeta,'2'
paste pick buffer $mmeta,'3'
GEM-Redraw-message: (not a menu function, created by screen manager)
$mmeta,'@'
}}}
}}}
