REF VEDTERMINALS Rob Duncan, December 1989
Updated John Gibson Jan 1997
COPYRIGHT University of Sussex 1997. All Rights Reserved.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
<<<<<<<<<<<<<<<<<<<<< >>>>>>>>>>>>>>>>>>>>>>
<<<<<<<<<<<<<<<<<<<<< VED TERMINAL TYPES >>>>>>>>>>>>>>>>>>>>>>
<<<<<<<<<<<<<<<<<<<<< >>>>>>>>>>>>>>>>>>>>>>
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
This file describes how Ved determines which terminal it is running on,
how it configures itself to make use of that terminal, and summarises
which terminal types are known.
More information about using and writing terminal libraries is given
in HELP * TERMINAL. Procedures which provide a higher-level interface to
the terminal screen are described in REF * VEDPROCS. Pointers to general
Ved documentation are in REF * VED. Logical names for Ved key sequences
are in HELP * LOGICAL_KEYS
CONTENTS - (Use <ENTER> g to access required sections)
1 Terminal Recognition and Initialisation
2 Terminal Descriptions
3 Terminal-Dependent Standard Screen Procedures
4 Mappings from Keyboard to Ved Functions
5 Known Terminal Types
6 LIB MKVEDIMAGE
------------------------------------------
1 Terminal Recognition and Initialisation
------------------------------------------
vedinitterm() [procedure variable]
Called by * vedsetup to determine the terminal type on which Ved
is running and to initialise Ved to use it (Ved will not run
until this procedure has terminated successfully). The procedure
is called by vedsetup immediately after any 'vedinit.p' files
have been compiled.
The XVed version of vedinitterm just calls * vedxvedinit,
followed by veduseterm('xved'). See REF * XVED for further
details.
For other versions of Ved, if a terminal library has already
been loaded, vedinitterm will merely check that all the features
which Ved needs have actually been defined. In the case where no
terminal library is loaded explicitly, vedinitterm will attempt
to determine the terminal type automatically, trying the
following strategies in order:
(1) the variable * vedterminalselect is consulted first, to
invoke any user-defined terminal recognition procedure;
(2) if this fails, and Poplog is running under UNIX, then
the value of the environment variable $TERM is taken as
the name of terminal and the procedure * veduseterm is
called with this name as argument to perform the
necessary initialisation;
(3) if this also fails, the user is prompted to enter a
terminal name interactively and veduseterm is called to
initialise from the given name.
At each stage, the variable vedterminalname is used as a flag to
indicate whether or not a terminal type has been successfully
selected, so you should never assign to this variable unless you
know what you're doing.
There is a minimum degree of functionality which a terminal must
provide in order for Ved to work at all (see the section on
``Terminal Descriptions'' below). If the terminal type selected
doesn't conform to this, then vedinitterm will repeatedly try
step (3) above until a usable type is found; the opportunity to
abort Ved is offered as an alternative at this stage.
Users may redefine vedinitterm for themselves (in a "vedinit.p"
file for example) to impose some alternative terminal selection
method. The standard method offers considerable flexibility
however, and a complete redefinition of vedinitterm should be
considered as very much a last resort. If you do redefine it,
you must still initialise for a particular terminal type with
veduseterm.
vedterminalselect -> list_or_false [variable]
list_or_false -> vedterminalselect
Used by vedinitterm for automatic terminal recognition: the
strategy is to an elicit an answer-back message from the
terminal and use that to identify the terminal type.
The value of vedterminalselect is normally a list. Each entry in
the list has one of three forms, interpreted as follows:
a string
assumed to be an escape sequence for eliciting an
answer-back message from the terminal. The string is
assigned to the variable vvedscreensendidseq and the
answer-back obtained by calling vedtermidseq;
a procedure
assumed to be a method for obtaining an answer-back
message. The procedure is called, and the result (which
must be a string or <false>) is taken as the current
answer-back;
a list of two elements
having the form:
[<string> <terminal-type>]
The <string> is compared against the current answer-back
message using
isstartstring(<string>, <answer-back>)
If this succeeds, then the corresponding <terminal-type>
is assumed. If the answer-back hasn't yet been set, the
procedure vedtermidseq is called first to obtain it.
The <terminal-type> may itself be either of two things:
a string
assumed to be a terminal name. The procedure veduseterm
is called with the name as argument;
a procedure or procedure variable name
assumed to be an initialisation procedure for a
particular terminal type. The procedure is simply
called; if it expects an argument, the answer-back
message is provided.
On Unix systems vedterminalselect is normally empty, since the
value of the TERM environment variable is taken as a more
reliable indicator of the terminal type. On VMS systems it has a
value something like:
[
'\^[Z'
['\^[[?63' vedvt220]
['\^[[?62' vedvt220]
['\^[[?' vedvt100]
['/K' vedvt52select]
]
This causes vedinitterm to prompt for an answer-back message
using the sequence <ESC> Z, and then use the reply to choose
between vt220, vt100 and vt52-type terminals. If the terminal
doesn't respond to <ESC> Z or sends an unrecognised reply, no
terminal type is selected.
If the value of vedterminalselect is anything other than a list,
it is simply ignored. Most terminal libraries set
vedterminalselect to <false> to suppress the automatic terminal
selection.
vedset [syntax]
This syntax word can be used to tailor Ved terminals to specify
screen handling and mappings from keyboard sequences to Ved
procedures. There are three formats, the first of which provides
a more readable alternative to using * vedsetkey.
vedset keys <commands> endvedset
vedset screen <commands> endvedset
vedset chars <commands> endvedset
For full details see HELP * VEDSET, * TERMINAL
vedtermidseq() -> string [procedure]
Reads an answer-back message from the terminal. The terminal is
prompted with the control sequence vvedscreensendidseq (default
value: '\^[Z') and the reply read using the procedure
vedinescapeseq. Returns <false> if no sensible reply is
forthcoming.
vedinescapeseq() -> string [procedure]
Reads an escape sequence from the terminal. Returns <false> if
the input is unrecognisable or doesn't complete within 3
seconds.
veduseterm(term) -> bool [procedure]
Initialises Ved to work on the terminal type term. term may be a
word or a string, e.g, "vt100", 'sun-cmd' etc. The result is a
flag indicating whether the initialisation was successful: it
will be <false> if the terminal type is unknown, or is in some
way unsuitable for Ved. Ved will not function correctly on
terminals for which this procedure returns <false>.
Initialisation is performed in two stages: screen initialisation
followed by keyboard initialisation. Screen initialisation
configures Ved's screen-control variables for driving the named
terminal screen; this must complete successfully if Ved is to
function correctly. Keyboard initialisation extends Ved's keymap
tables to recognise any function keys which the terminal
keyboard may provide: this step is optional.
Screen initialisation is normally performed by calling a library
procedure whose name is constructed from the argument term as
follows:
consword('ved' >< term >< 'screen')
Thus for a value of term of "vt100", the corresponding procedure
name would be "vedvt100screen". Any hyphens in term are first
translated to underscores, so that the name 'sun-cmd' would map
onto the procedure "vedsun_cmdscreen". The procedure is called
with no arguments. If no such procedure can be found, but the
operating system supports TERMCAP (UNIX only), then an entry
will be sought for term in the TERMCAP database and the screen
initialised from that instead. In either case there are a number
of screen-control variables which must be assigned before Ved
can proceed; if any of these are not properly set, veduseterm
will return <false>.
The default initialisation of the keyboard proceeds similarly,
calling a procedure whose name is constructed from term as
consword('ved' >< term >< 'keys')
This step can be suppressed or modified by appropriate setting
of the variable vedfunctionkeys described below.
vedfunctionkeys -> bool_or_word_or_p [variable]
bool_or_word_or_p -> vedfunctionkeys
Controls the keyboard initialisation performed by veduseterm. It
can take one of four values:
true (the default)
gives the default behaviour described above: the name of
the keyboard is taken to be the same as the name of the
terminal screen;
false
suppresses all the keyboard initialisation: in this
case, only the standard set of key bindings described in
HELP * VEDKEYS will be recognised, together with any
explicitly installed by the user;
a word
taken to be the name of the keyboard: veduseterm will
use this name as the root of the keyboard configuration
procedure regardless of the name of the terminal;
a procedure
to be applied to the terminal name before the keyboard
initialisation procedure is called; it may return any
value appropriate to vedfunctionkeys, typically a
(different) keyboard name.
------------------------
2 Terminal Descriptions
------------------------
The terminal and its screen-handling capabilities are described by the
values of the following global variables. Variables with the prefix
"vvedscreen" define the control sequences used to activate various
terminal functions: a control sequence may be a single character, a
string or a procedure, and will be sent to the terminal using the
procedure vedscreencontrol. A null string value implies that the
particular function is not supported by the terminal.
Note that keyboard facilities (e.g. interpretation of function keys or
key sequences, are set separately from screen manipulation.
Initialising Ved to work with a particular terminal type means assigning
to as many of these variables as possible. In order for Ved to work at
all, sensible values must be assigned to at least the following:
¤ vvedscreencharup
¤ vvedscreencharright
¤ vvedscreencleartail
as well as those procedures given under Terminal-Dependent Standard
Screen Procedures below.
For full details of how to build a terminal description from scratch,
see HELP * TERMINAL
vedterminalname -> word_or_false [variable]
word_or_false -> vedterminalname
The name of the terminal on which Ved is running (a word). Will
be <false> until Ved has been properly set up.
vedscreenlength -> int [variable]
int -> vedscreenlength
The number of usable lines on the terminal screen (an integer).
In windowed Ved (XVed), set to the number of lines in the window
whenever the current file is set.
vedscreenwidth -> int [variable]
int -> vedscreenwidth
The number of usable columns on the terminal screen (an
integer). In windowed Ved (XVed), set to the number of columns
in the window whenever the current file is set.
vedscreenwrap -> bool [variable]
bool -> vedscreenwrap
Indicates whether the terminal has automatic margins: <true>
means that whenever the cursor is moved beyond the last column
on a line, it will automatically wrap round to the first column
of the following line, possibly causing the screen to scroll;
<false> means that the cursor sticks at the end of a line.
veddumbvdu -> bool [variable]
bool -> veddumbvdu
A rough indicator of the intelligence of the terminal: a
non-false value means that the terminal doesn't support any kind
of insertion or deletion of lines and characters. This variable
is set by Ved on startup, but not subsequently used.
vednochardelete -> bool [variable]
bool -> vednochardelete
vednocharinsert -> bool [variable]
bool -> vednocharinsert
vednolinedelete -> bool [variable]
bool -> vednolinedelete
vednolineinsert -> bool [variable]
bool -> vednolineinsert
These variables indicate the level of support the terminal
provides for insertion and deletion of characters and complete
lines. A value of <false> means that the terminal DOES support
the feature; any other value means that it doesn't. Ved will
normally set these variables on startup depending on which
screen control sequences have been defined: thus vednochardelete
will be <false> if vvedscreendeletechar is not the null string.
Ved compensates for terminals without insertion and deletion by
redrawing appropriate parts of the screen.
vednokeypad -> bool [variable]
bool -> vednokeypad
Indicates whether the terminal has a separately programmable
keypad: the value <false> means that the terminal does have a
keypad, any other value means that it doesn't.
vedinserting -> bool [variable]
bool -> vedinserting
Indicates the current output mode of the terminal: the value
<false> means that the terminal is in normal (overstrike) mode;
<true> means that the terminal is in insert mode.
vednomoveinsert -> bool [variable]
bool -> vednomoveinsert
Indicates whether it is safe to move the cursor while in insert
mode.
vvedscreeninit -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreeninit
Control sequence to initialise the terminal for editing.
vvedscreenreset -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenreset
Control sequence to reset the terminal to normal (non-edit)
mode.
vvedscreensetpad -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreensetpad
Control sequence to enable the function keypad.
vvedscreenresetpad -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenresetpad
Control sequence to disable the function keypad.
vvedscreeninsertmode -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreeninsertmode
Control sequence to set the terminal into insert mode.
vvedscreenovermode -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenovermode
Control sequence to reset the terminal to normal (overstrike)
mode.
vvedscreengraphic -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreengraphic
vvedscreenalpha -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenalpha
These control sequences are sent out by the default
vedscreencharmode to set the terminal into or out of alternate
(graphic) character set mode (see vedscreencharmode below).
vvedscreengraphic sets graphic character set mode, and
vvedscreenalpha sets normal character set mode.
vvedscreencharnormal -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencharnormal
vvedscreencharhighlight -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencharhighlight
vvedscreencharbold -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencharbold
vvedscreencharunderline -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencharunderline
vvedscreencharaltfont -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencharaltfont
vvedscreencharblink -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencharblink
These control sequences are sent out by the default
vedscreencharmode to change the display attributes of characters
on the screen (see vedscreencharmode below). If the form of
these sequences is not suitable for a particular terminal, you
will need to redefine (nonactive) vedscreencharmode
appropriately.
The default vedscreencharmode procedure assumes that (as on the
vt100), attributes accumulate when their corresponding sequences
are sent out, and that the only way to turn one attribute off is
to turn them all off. This is achieved by sending
vvedscreencharnormal.
vvedscreencharhighlight should make characters highlighted (e.g.
in inverse video).
vvedscreencharbold should make characters display in a bold
version of the current font.
vvedscreencharunderline should cause characters to be
underlined.
vvedscreencharaltfont should make characters display in an
alternative font of the same size (preferably italic). If this
variable is nullstring, the default vedscreencharmode will
indicate alt font characters by using underlining instead, i.e.
vvedscreencharunderline.
vvedscreencharblink should cause characters to blink (i.e. flash
on and off), or some suitable substitute.
vvedscreencharup -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencharup
vvedscreenchardown -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenchardown
vvedscreencharleft -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencharleft
vvedscreencharright -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencharright
Control sequences to move the cursor one place up, down, left
and right. Not used at the boundaries of the screen.
vvedscreenscreenleft -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenscreenleft
Control sequence to move the cursor to the leftmost column of
the current line.
vvedscreenpoint -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenpoint
Control sequence to move the cursor to a given point on screen:
should be followed by the line and column to move to, suitably
encoded. Used by vedvt52screenxy only.
vvedscreenscrollup -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenscrollup
Control sequence to scroll the screen forwards. Used only on the
last line of the screen or scrolling region.
vvedscreenscrolldown -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenscrolldown
Control sequence to scroll the screen backwards. Used only on
the top line of the screen or scrolling region.
vvedscreencursorupscroll -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreensursorupscroll
Control sequence to move the cursor one place up, and to scroll
the screen if on the top line (no longer used by Ved).
vvedscreenclear -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenclear
Control sequence to clear the entire screen.
vvedscreencleartail -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreencleartail
Control sequence to clear from the cursor position to the end of
the current line.
vvedscreeninsertchar -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreeninsertchar
Control sequence to insert the next character; characters under
and to the right of the cursor on the current line are shifted
to the right.
vvedscreendeletechar -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreendeletechar
Control sequence to delete the character under the cursor;
characters to the right of the cursor on the current line move
one place left.
vvedscreeninsertline -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreeninsertline
Control sequence to open a new blank line on screen at the
current cursor position; the current and subsequent lines move
down.
vvedscreendeleteline -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreendeleteline
Control sequence to delete the current line on screen;
subsequent lines move up.
vvedscreenbell -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreenbell
Control sequence to ring the terminal bell or to give some
visible error indication.
vvedscreensendidseq -> char_or_string_or_p [variable]
char_or_string_or_p -> vvedscreensendidseq
Control sequence to elicit the terminal answer-back message.
vedansiscreenxy(col, line) [procedure]
One possible value for vedscreenxy. Positions the cursor using
an ansi-compatible escape sequence. The characters it sends
could be generated by the call:
printf('\^[[%p;%pH', [% line, col %]);
vedvt52screenxy(col, line) [procedure]
One possible value for vedscreenxy. Positions the cursor using a
vt52-compatible escape sequence. The characters it sends could
be generated by the call:
printf('%p%c%c', [% vvedscreenpoint, line+31, col+31 %])
vedvt52screengraphtrans(char) -> (outchar, graphic) [procedure]
vedvt100screengraphtrans(char) -> (outchar, graphic) [procedure]
Procedures that can be assigned to vedscreengraphtrans to
perform appropriate translations for Ved graphics characters
when output to the screen. vedvt52screengraphtrans does this for
vt52-type terminals, and vedvt100screengraphtrans for
vt100-type.
For example, vedvt100screengraphtrans is defined as
define vedvt100screengraphtrans(char);
lvars char, c;
;;; 123456789ABCDEF0123456789ABCD
lconstant trans = 'qqqxmjvxlkwxtunf`~___________';
subscrs(char-16:80, trans) -> c;
;;; 2nd result true means graphics mode
if c == `_` then char, false else c, true endif
enddefine;
See vedscreengraphtrans below for further information.
vedsetscrollregion(top, bottom) [procedure variable]
Sets the terminal scrolling region between line numbers top and
bottom inclusive. top and bottom are both integers. The first
usable line of the screen is numbered 1.
vedansisetscrollregion(top, bottom) [procedure]
One possible value of vedsetscrollregion. Sets the scrolling
region using an ansi-compatible escape sequence. The characters
it sends could be generated by the call:
printf('\^[[%p;%pr', [% top, bottom %]);
vedscreencontrol(seq) [procedure]
Sends the control sequence seq to the terminal. seq may be a
single character, a string or a procedure. Characters and
strings are used where a fixed sequence of characters is
sufficient to activate the desired terminal function; a
procedure is appropriate in cases where the actual sequence
needed may vary: it may, for example, depend on the current
position of the cursor on screen. A possible definition for
vedscreencontrol would be:
define vedscreencontrol(seq);
lvars seq;
if isprocedure(seq) then
seq();
else
vedoutascii(seq);
endif;
enddefine;
------------------------------------------------
3 Terminal-Dependent Standard Screen Procedures
------------------------------------------------
The following procedures present standard interfaces that all Ved
procedures can use, and must therefore always be defined. Except for
vedscreenxy, the others have default values which will work for any
terminal.
vedscreenxy(col, line) [procedure variable]
Moves the cursor to the given position on screen. line and col
are both integers. The north-west corner of the usable area of
the screen has (col, line) coordinates of (1, 1).
The default value of this procedure mishaps, so for a new
terminal you MUST give it a definition.
vedscreencharmode -> mode [(variable) active variable]
mode -> vedscreencharmode
This active variable returns or updates a set of mode bits
controlling how characters sent to the screen/window are
displayed. (It is usually called by vedscreenoutput, to set the
mode for the character being output.)
The mode argument is an integer, the bits in which are defined
in INCLUDE * VEDSCREENDEFS.PH. Currently, these are
VEDCMODE_GRAPHIC
- When set, characters will be interpreted in graphics char set.
(Note that this bit is NOT a character attribute like the
others.)
VEDCMODE_COLOURNUM
VEDCMODE_UNDERLINE
VEDCMODE_BOLD
VEDCMODE_ALTFONT
VEDCMODE_BLINK
- When set, characters will be displayed respectively
underlined, in a bold font, in an alternative font (e.g.
italic), or blinking on and off. VEDCMODE_COLOURNUM is a mask
for a 3-bit colour field starting at bit VEDCMODE_COLOUR_SHIFT,
i.e. the colour number is
(mode && VEDCMODE_COLOURNUM) >> VEDCMODE_COLOUR_SHIFT
Since most terminals will support only one highlight colour
(e.g. inverse video), the default vedscreencharmode uses the
least significant bit of the colour field (VEDCMODE_HIGHLIGHT)
to determine whether that should be set, i.e. odd colours will
set it and even colours clear it. (Note that XVed supports all 8
possible colours.)
These bits start at bit 16, and are used directly as the
attribute bits attached to characters in Ved buffer lines (and
stored in 'dstrings' - see REF * STRINGS). (They are also
representable as backslash sequences in Pop-11 character
constants see Backslash in Strings & Character Constants in
REF * ITEMISE.)
The default vedscreencharmode (used at least for vt100 and xterm
Ved), sends out the sequences
vvedscreengraphic
vvedscreenalpha
vvedscreencharnormal
vvedscreencharhighlight
vvedscreencharbold
vvedscreencharunderline
vvedscreencharaltfont
vvedscreencharblink
in response to the above bits being set and cleared (see the
description of these variables above). However, its behaviour
may not be appropriate for all terminals, so it may need
redefining for a particular terminal. (For example, the XVed
vedscreencharmode does not need the above sequences at all,
since it can control the modes by direct procedure calls to the
XpwScrollText widget.)
The default vedscreencharmode is defined as follows:
lvars current_charmode = 0;
define vars active vedscreencharmode;
current_charmode
enddefine;
;;;
define updaterof active vedscreencharmode mode;
lvars mode, diff, old = current_charmode;
returnif((mode ||/& old ->> diff) == 0);
mode -> current_charmode;
;;; deal with graphic first
if diff &&/=_0 VEDCMODE_GRAPHIC then
vedscreencontrol(if mode &&/=_0 VEDCMODE_GRAPHIC then
vvedscreengraphic
else
vvedscreenalpha
endif);
returnif((diff &&~~ VEDCMODE_GRAPHIC ->> diff) == 0)
endif;
mode &&~~ VEDCMODE_GRAPHIC -> mode;
;;; Assumes that the other modes accumulate when sent
;;; out, ie the only way to turn one off is to turn
;;; them all off (this is the vt100 behaviour).
if diff &&~~ mode /== 0 then
;;; clearing some modes -- must clear them all first
vedscreencontrol(vvedscreencharnormal);
returnif(mode == 0)
else
;;; only setting new ones
diff -> mode
endif;
if mode &&/=_0 VEDCMODE_BOLD then
vedscreencontrol(vvedscreencharbold)
endif;
if mode &&/=_0 VEDCMODE_ALTFONT then
if vvedscreencharaltfont == nullstring then
mode || VEDCMODE_UNDERLINE -> mode
else
vedscreencontrol(vvedscreencharaltfont)
endif
endif;
if mode &&/=_0 VEDCMODE_UNDERLINE then
vedscreencontrol(vvedscreencharunderline)
endif;
if mode &&/=_0 VEDCMODE_HIGHLIGHT then
vedscreencontrol(vvedscreencharhighlight)
endif;
if mode &&/=_0 VEDCMODE_BLINK then
vedscreencontrol(vvedscreencharblink)
endif;
enddefine;
vedscreengraphtrans(char) -> (outchar, graphic) [procedure variable]
This procedure is called by vedscreenoutput to perform an
appropriate translation for Ved standard graphics characters.
It takes a character char in the range 16:81 - 16:9D, and
returns two results: the character outchar to output, and a
boolean graphic saying whether graphics mode should be turned on
for outchar (i.e. whether VEDCMODE_GRAPHIC should be set in
vedscreencharmode).
See Ved Standard Graphics Characters in REF * VEDPROCS for a
description of the graphics characters, and Backslash in Strings
& Character Constants in REF * ITEMISE for a complete list of
their characters codes.
The default value of vedscreengraphtrans is a procedure which
translates all graphics characters to ordinary printing
characters (as described in REF * VEDPROCS); this default value
can also be assigned by calling vednographics.
There are two standard procedures for converting to vt52 and
vt100 graphics codes respectively: vedvt100screengraphtrans and
vedvt52screengraphtrans (see above). The default procedure is
defined
define vars vedscreengraphtrans(char);
lvars char, c;
;;; 123456789ABCDEF0123456789ABCD
lconstant trans = '---|---|---|||+o#.___________';
subscrs(char-16:80, trans) -> c;
;;; 2nd result false means not graphics mode
if c == `_` then char else c endif, false
enddefine;
If a new translation procedure needs to be written for a
particular terminal, note that currently, not all of the range
16:81 - 16:9D is actually used by the standard graphics
characters; the existing procedures simply do no translation for
the unused codes.
vedscreencursoron -> char_or_false [(variable) active variable]
char_or_false -> vedscreencursoron
Where possible, this active variable provides for turning the
text cursor on and off, and for displaying different cursors.
char_or_false may be a character-with-attributes (similar to
vedscreenoutput), or false. If a character, the updater sets the
cursor to correspond to that character; if false, the cursor is
turned off. The base procedure returns the current setting.
The ASCII characters Ved assumes may be available for different
cursors are as follows:
Char Description
---- -----------
`O` Rectangular block
`_` Underscore
`I` I-beam
`^` Carat
`\s` Invisible
The attributes part of the character is as for vedscreencharmode
above, except that Ved assumes only the colour and blink
attributes may actually have any effect.
The default vedscreencursoron just remembers the value assigned
to it and returns that when accessed, but otherwise does
nothing.
------------------------------------------
4 Mappings from Keyboard to Ved Functions
------------------------------------------
The initial mapping from key presses to editor functions is built in to
Ved, but corresponds to that set by the procedure veddefaultkeys:
running this procedure at any time will reset all key bindings back to
their initial state. The default key map is as described in
HELP * VEDKEYS. This mapping was introduced in Poplog Version 14.5;
anyone wishing to restore the mapping used prior to that version can do
so by placing at the start of their 'vedinit.p' file the two lines:
vedoldkeys();
vedoldkeys -> veddefaultkeys;
The first line restores the old key map immediately; the second line
ensures that any program which needs to re-set the keyboard will
continue to use the old map.
veddefaultkeys() [procedure variable]
Restores the key map to some initial state. User-assignable, it
defaults to vednewkeys.
vednewkeys() [procedure]
Sets the key map as described in HELP * VEDKEYS
vedoldkeys() [procedure]
Sets the key map as described in HELP * VEDOLDKEYS
vedkeymapname -> strword_or_false [variable]
A string describing the current mapping of keyboard keys to Ved
operations. Used by ved_hkeys to find and display a HELP file
that describes the current mapping. Its initial value is
<false>, indicating that only the default key mappings have been
set up. The procedure veduseterm assigns vedterminalname to
vedkeymapname (unless vedfunctionkeys is false). Individual
libraries that implement Ved key mappings may assign their own
values to vedkeymapname (e.g. LIB * VEDNCDXTERMKEYS)
-----------------------
5 Known Terminal Types
-----------------------
The following procedures configure Ved for use on particular terminal
types. Most of them, with the exception of the Visual 200 and vt100
procedures, are defined in autoloadable libraries. Where a terminal type
has "screen" and/or "keys" procedures defined for it, then it can be
initialised automatically with a call to veduseterm: this will autoload
any library files as necessary. For the remaining terminals, the
initialisation procedure must be called explicitly. For guidance on
selecting a terminal type see HELP * TERMINAL
vedansi() [procedure]
vedansikeys() [procedure]
vedansiscreen() [procedure]
Basic ANSI-compatible terminal. Defines minimal screen-control
facilities and no function keys. See HELP * ANSIKEYS
vedatari() [procedure]
Atari ST running UniTerm vt100 terminal emulator. Requires a
special UniTerm initialisation file to program the function keys
correctly. See HELP * VEDATARI
vedbbc() [procedure]
vedbbckeys() [procedure]
vedbbcscreen() [procedure]
BBC micro running vt52 terminal emulator.
vedbbcvt100() [procedure]
vedbbcvt100keys() [procedure]
vedbbcvt100screen() [procedure]
BBC micro running vt100 terminal emulator. HELP * BBCVT100
vedcifer() [procedure]
vedciferkeys() [procedure]
vedciferscreen() [procedure]
Cifer 2634 terminal. HELP * VEDCIFER
vedcmdtool() [procedure]
Sunview "cmdtool" window. HELP * VEDCMDTOOL
veddxterm() [procedure]
veddxtermkeys() [procedure]
veddxtermscreen() [procedure]
DECwindows terminal emulator. Similar to an XTERM, but with a
vt220-like keyboard. See HELP * VEDDXTERM
vedhpscreen() [procedure]
Generic Hewlett Packard terminal. See LIB * VEDHPSCREEN
vedsun() [procedure]
vedsunkeys() [procedure]
vedsunkeys_SUNVIEW() [procedure]
vedsunkeys_NOSUNVIEW() [procedure]
vedsunscreen() [procedure]
vednosunviewkeys [variable]
Sun console or Sunview "shelltool" window (if you know it's a
window, vedwinsun can be quicker to start up). vedsunkeys calls
vedsunkeys_SUNVIEW by default (which assumes that the SunView
accelerator keys are unavailable to Ved), but if the variable
vednosunviewkeys is declared and not <false>, it will call
vedsunkeys_NOSUNVIEW instead. See HELP * VEDSUN
vedsun_cmd() [procedure]
vedsun_cmdkeys() [procedure]
vedsun_cmdscreen() [procedure]
Sunview "cmdtool" window: same as vedcmdtool.
vedtvi() [procedure]
vedtvikeys() [procedure]
vedtviscreen() [procedure]
Televideo TVI 920C in vt52 emulation mode. See HELP * TVI
vedtvi925() [procedure]
vedtvi925keys() [procedure]
vedtvi925screen() [procedure]
Televideo 925. For key bindings see LIB * VEDTVI925KEYS.
vedvi200() [procedure]
vedvi200keys() [procedure]
vedvi200screen() [procedure]
Visual 200. See HELP * V200
vedvi500() [procedure]
vedvi500keys() [procedure]
vedvi500screen() [procedure]
Visual 500. See HELP * V500
vedvi55() [procedure]
vedvi55keys() [procedure]
vedvi55screen() [procedure]
Visual 55 in Visual 200 emulation mode. Basically the same as
the Visual 200, but with lots more function keys. LIB * AUTOV55
determines from the answerback whether the terminal is a Visual
200 or a 55 and configures Ved accordingly. See HELP * V55
vedvi550() [procedure]
vedvi550keys() [procedure]
vedvi550screen() [procedure]
Visual 550. See HELP * V550
vedvt100(id) [procedure]
vedvt100keys() [procedure]
vedvt100screen() [procedure]
vt100 series terminal. Makes minimal assumptions, so works with
many lookalikes and emulators, although the function keypad
escape sequences aren't always the same. The argument id is a
dummy, present for historical reasons, and usually passed as
<false>. See HELP * VT100KEYS, HELP * VT100
vedvt100screenextra() [procedure]
Can be used to inform Ved that a vt100-type terminal (including
vt220, xterm, etc.) is able to cope with inline character
insertion and deletion. These operations are then speeded up.
See LIB * VEDVT100SCREENEXTRA.
vedvt200() [procedure]
vedvt200keys() [procedure]
vedvt200screen() [procedure]
vedvt220() [procedure]
vedvt220keys() [procedure]
vedvt220screen() [procedure]
vt200 series terminal. Similar to a vt100 but with smarter
screen handling and extra function keys. See HELP * VT220KEYS
vedvt300() [procedure]
vedvt300keys() [procedure]
vedvt300screen() [procedure]
vedvt320() [procedure]
vedvt320keys() [procedure]
vedvt320screen() [procedure]
vt300 series terminal. Ved treats this the same as a vt200 (see
above).
vedvt52() [procedure]
vedvt52keys() [procedure]
vedvt52screen() [procedure]
vt52 terminal or emulator. See HELP * VT52
vedwinsun() [procedure]
Similar to vedsun, but assumes a Sunview "shelltool" window and
so can start up a little quicker. See HELP * VEDWINSUN
vedxterm() [procedure]
vedxtermkeys() [procedure]
vedxtermscreen() [procedure]
X windows "xterm" vt102 terminal emulator. Uses the same
screen-control sequences as the vt100, but offers a choice of
function key maps for different workstations and terminals. For
more detailed information, see HELP * VEDXTERM
vedtermcapscreen(term) [procedure]
(UNIX only) Reads the TERMCAP database entry for the named
terminal. term should be a word or string.
-----------------
6 LIB MKVEDIMAGE
-----------------
LIB * MKVEDIMAGE is a utility for building saved images that include
terminal configuration libraries of the type described above. Ved will
start up more quickly inside such a saved image, since the necessary
library files will already have been compiled. LIB MKVEDIMAGE is
described fully in HELP * MKVEDIMAGE
+-+ C.all/ref/vedterminals
+-+ Copyright University of Sussex 1997. All rights reserved.