|
428
|
1 \input texinfo @c -*-texinfo-*-
|
|
|
2 @setfilename ../info/termcap.info
|
|
|
3 @settitle The Termcap Library
|
|
|
4 @ifinfo
|
|
|
5 @direntry
|
|
|
6 * Termcap: (termcap). Termcap library of the GNU system.
|
|
|
7 @end direntry
|
|
|
8
|
|
|
9 This file documents the termcap library of the GNU system.
|
|
|
10
|
|
|
11 Copyright (C) 1988 Free Software Foundation, Inc.
|
|
|
12
|
|
|
13 Permission is granted to make and distribute verbatim copies of
|
|
|
14 this manual provided the copyright notice and this permission notice
|
|
|
15 are preserved on all copies.
|
|
|
16
|
|
|
17 @ignore
|
|
|
18 Permission is granted to process this file through TeX and print the
|
|
|
19 results, provided the printed document carries copying permission
|
|
|
20 notice identical to this one except for the removal of this paragraph
|
|
|
21 (this paragraph not being relevant to the printed manual).
|
|
|
22
|
|
|
23 @end ignore
|
|
|
24 Permission is granted to copy and distribute modified versions of this
|
|
|
25 manual under the conditions for verbatim copying, provided that the entire
|
|
|
26 resulting derived work is distributed under the terms of a permission
|
|
|
27 notice identical to this one.
|
|
|
28
|
|
|
29 Permission is granted to copy and distribute translations of this manual
|
|
|
30 into another language, under the above conditions for modified versions,
|
|
|
31 except that this permission notice may be stated in a translation approved
|
|
|
32 by the Foundation.
|
|
|
33 @end ifinfo
|
|
|
34
|
|
|
35 @setchapternewpage odd
|
|
|
36 @titlepage
|
|
|
37 @sp 6
|
|
|
38 @center @titlefont{Termcap}
|
|
|
39 @sp 1
|
|
|
40 @center The Termcap Library and Data Base
|
|
|
41 @sp 4
|
|
|
42 @center First Edition
|
|
|
43 @sp 1
|
|
|
44 @center April 1988
|
|
|
45 @sp 5
|
|
|
46 @center Richard M. Stallman
|
|
|
47 @sp 1
|
|
|
48 @center Free Software Foundation
|
|
|
49 @page
|
|
|
50 @vskip 0pt plus 1filll
|
|
|
51 Copyright @copyright{} 1988 Free Software Foundation, Inc.
|
|
|
52
|
|
|
53 Published by the Free Software Foundation
|
|
|
54 (675 Mass Ave, Cambridge MA 02139).
|
|
|
55 Printed copies are available for $10 each.
|
|
|
56
|
|
|
57 Permission is granted to make and distribute verbatim copies of
|
|
|
58 this manual provided the copyright notice and this permission notice
|
|
|
59 are preserved on all copies.
|
|
|
60
|
|
|
61 Permission is granted to copy and distribute modified versions of this
|
|
|
62 manual under the conditions for verbatim copying, provided that the entire
|
|
|
63 resulting derived work is distributed under the terms of a permission
|
|
|
64 notice identical to this one.
|
|
|
65
|
|
|
66 Permission is granted to copy and distribute translations of this manual
|
|
|
67 into another language, under the above conditions for modified versions,
|
|
|
68 except that this permission notice may be stated in a translation approved
|
|
|
69 by the Foundation.
|
|
|
70 @end titlepage
|
|
|
71 @page
|
|
|
72
|
|
|
73 @synindex vr fn
|
|
|
74
|
|
|
75 @node Top, Introduction, (DIR), (DIR)
|
|
|
76
|
|
|
77 @menu
|
|
|
78 * Introduction::What is termcap? Why this manual?
|
|
|
79 * Library:: The termcap library functions.
|
|
|
80 * Data Base:: What terminal descriptions in @file{/etc/termcap} look like.
|
|
|
81 * Capabilities::Definitions of the individual terminal capabilities:
|
|
|
82 how to write them in descriptions, and how to use
|
|
|
83 their values to do display updating.
|
|
|
84 * Summary:: Brief table of capability names and their meanings.
|
|
|
85 * Var Index:: Index of C functions and variables.
|
|
|
86 * Cap Index:: Index of termcap capabilities.
|
|
|
87 * Index:: Concept index.
|
|
|
88 @end menu
|
|
|
89
|
|
|
90 @node Introduction, Library, Top, Top
|
|
|
91 @unnumbered Introduction
|
|
|
92
|
|
|
93 @cindex termcap
|
|
|
94 @dfn{Termcap} is a library and data base that enables programs to use
|
|
|
95 display terminals in a terminal-independent manner. It originated in
|
|
|
96 Berkeley Unix.
|
|
|
97
|
|
|
98 The termcap data base describes the capabilities of hundreds of different
|
|
|
99 display terminals in great detail. Some examples of the information
|
|
|
100 recorded for a terminal could include how many columns wide it is, what
|
|
|
101 string to send to move the cursor to an arbitrary position (including how
|
|
|
102 to encode the row and column numbers), how to scroll the screen up one or
|
|
|
103 several lines, and how much padding is needed for such a scrolling
|
|
|
104 operation.
|
|
|
105
|
|
|
106 The termcap library is provided for easy access this data base in programs
|
|
|
107 that want to do terminal-independent character-based display output.
|
|
|
108
|
|
|
109 This manual describes the GNU version of the termcap library, which has
|
|
|
110 some extensions over the Unix version. All the extensions are identified
|
|
|
111 as such, so this manual also tells you how to use the Unix termcap.
|
|
|
112
|
|
|
113 The GNU version of the termcap library is available free as source code,
|
|
|
114 for use in free programs, and runs on Unix and VMS systems (at least). You
|
|
|
115 can find it in the GNU Emacs distribution in the files @file{termcap.c} and
|
|
|
116 @file{tparam.c}.
|
|
|
117
|
|
|
118 This manual was written for the GNU project, whose goal is to develop a
|
|
|
119 complete free operating system upward-compatible with Unix for user
|
|
|
120 programs. The project is approximately two thirds complete. For more
|
|
|
121 information on the GNU project, including the GNU Emacs editor and the
|
|
|
122 mostly-portable optimizing C compiler, send one dollar to
|
|
|
123
|
|
|
124 @display
|
|
|
125 Free Software Foundation
|
|
|
126 675 Mass Ave
|
|
|
127 Cambridge, MA 02139
|
|
|
128 @end display
|
|
|
129
|
|
|
130 @node Library, Data Base, Introduction, Top
|
|
|
131 @chapter The Termcap Library
|
|
|
132
|
|
|
133 The termcap library is the application programmer's interface to the
|
|
|
134 termcap data base. It contains functions for the following purposes:
|
|
|
135
|
|
|
136 @itemize @bullet
|
|
|
137 @item
|
|
|
138 Finding the description of the user's terminal type (@code{tgetent}).
|
|
|
139
|
|
|
140 @item
|
|
|
141 Interrogating the description for information on various topics
|
|
|
142 (@code{tgetnum}, @code{tgetflag}, @code{tgetstr}).
|
|
|
143
|
|
|
144 @item
|
|
|
145 Computing and performing padding (@code{tputs}).
|
|
|
146
|
|
|
147 @item
|
|
|
148 Encoding numeric parameters such as cursor positions into the
|
|
|
149 terminal-specific form required for display commands (@code{tparam},
|
|
|
150 @code{tgoto}).
|
|
|
151 @end itemize
|
|
|
152
|
|
|
153 @menu
|
|
|
154 * Preparation:: Preparing to use the termcap library.
|
|
|
155 * Find:: Finding the description of the terminal being used.
|
|
|
156 * Interrogate:: Interrogating the description for particular capabilities.
|
|
|
157 * Initialize:: Initialization for output using termcap.
|
|
|
158 * Padding:: Outputting padding.
|
|
|
159 * Parameters:: Encoding parameters such as cursor positions.
|
|
|
160 @end menu
|
|
|
161
|
|
|
162 @node Preparation, Find, Library, Library
|
|
|
163 @section Preparing to Use the Termcap Library
|
|
|
164
|
|
|
165 To use the termcap library in a program, you need two kinds of preparation:
|
|
|
166
|
|
|
167 @itemize @bullet
|
|
|
168 @item
|
|
|
169 The compiler needs declarations of the functions and variables in the
|
|
|
170 library.
|
|
|
171
|
|
|
172 On GNU systems, it suffices to include the header file
|
|
|
173 @file{termcap.h} in each source file that uses these functions and
|
|
|
174 variables.@refill
|
|
|
175
|
|
|
176 On Unix systems, there is often no such header file. Then you must
|
|
|
177 explictly declare the variables as external. You can do likewise for
|
|
|
178 the functions, or let them be implicitly declared and cast their
|
|
|
179 values from type @code{int} to the appropriate type.
|
|
|
180
|
|
|
181 We illustrate the declarations of the individual termcap library
|
|
|
182 functions with ANSI C prototypes because they show how to pass the
|
|
|
183 arguments. If you are not using the GNU C compiler, you probably
|
|
|
184 cannot use function prototypes, so omit the argument types and names
|
|
|
185 from your declarations.
|
|
|
186
|
|
|
187 @item
|
|
|
188 The linker needs to search the library. Usually either
|
|
|
189 @samp{-ltermcap} or @samp{-ltermlib} as an argument when linking will
|
|
|
190 do this.@refill
|
|
|
191 @end itemize
|
|
|
192
|
|
|
193 @node Find, Interrogate, Preparation, Library
|
|
|
194 @section Finding a Terminal Description: @code{tgetent}
|
|
|
195
|
|
|
196 @findex tgetent
|
|
|
197 An application program that is going to use termcap must first look up the
|
|
|
198 description of the terminal type in use. This is done by calling
|
|
|
199 @code{tgetent}, whose declaration in ANSI Standard C looks like:
|
|
|
200
|
|
|
201 @example
|
|
|
202 int tgetent (char *@var{buffer}, char *@var{termtype});
|
|
|
203 @end example
|
|
|
204
|
|
|
205 @noindent
|
|
|
206 This function finds the description and remembers it internally so that
|
|
|
207 you can interrogate it about specific terminal capabilities
|
|
|
208 (@pxref{Interrogate}).
|
|
|
209
|
|
|
210 The argument @var{termtype} is a string which is the name for the type of
|
|
|
211 terminal to look up. Usually you would obtain this from the environment
|
|
|
212 variable @code{TERM} using @code{getenv ("TERM")}.
|
|
|
213
|
|
|
214 If you are using the GNU version of termcap, you can alternatively ask
|
|
|
215 @code{tgetent} to allocate enough space. Pass a null pointer for
|
|
|
216 @var{buffer}, and @code{tgetent} itself allocates the storage using
|
|
|
217 @code{malloc}. In this case the returned value on success is the address
|
|
|
218 of the storage, cast to @code{int}. But normally there is no need for you
|
|
|
219 to look at the address. Do not free the storage yourself.@refill
|
|
|
220
|
|
|
221 With the Unix version of termcap, you must allocate space for the
|
|
|
222 description yourself and pass the address of the space as the argument
|
|
|
223 @var{buffer}. There is no way you can tell how much space is needed, so
|
|
|
224 the convention is to allocate a buffer 2048 characters long and assume that
|
|
|
225 is enough. (Formerly the convention was to allocate 1024 characters and
|
|
|
226 assume that was enough. But one day, for one kind of terminal, that was
|
|
|
227 not enough.)
|
|
|
228
|
|
|
229 No matter how the space to store the description has been obtained,
|
|
|
230 termcap records its address internally for use when you later interrogate
|
|
|
231 the description with @code{tgetnum}, @code{tgetstr} or @code{tgetflag}. If
|
|
|
232 the buffer was allocated by termcap, it will be freed by termcap too if you
|
|
|
233 call @code{tgetent} again. If the buffer was provided by you, you must
|
|
|
234 make sure that its contents remain unchanged for as long as you still plan
|
|
|
235 to interrogate the description.@refill
|
|
|
236
|
|
|
237 The return value of @code{tgetent} is @minus{}1 if there is some difficulty
|
|
|
238 accessing the data base of terminal types, 0 if the data base is accessible
|
|
|
239 but the specified type is not defined in it, and some other value
|
|
|
240 otherwise.
|
|
|
241
|
|
|
242 Here is how you might use the function @code{tgetent}:
|
|
|
243
|
|
|
244 @example
|
|
|
245 #ifdef unix
|
|
|
246 static char term_buffer[2048];
|
|
|
247 #else
|
|
|
248 #define term_buffer 0
|
|
|
249 #endif
|
|
|
250
|
|
|
251 init_terminal_data ()
|
|
|
252 @{
|
|
|
253 char *termtype = getenv ("TERM");
|
|
|
254 int success;
|
|
|
255
|
|
|
256 if (termtype == 0)
|
|
|
257 fatal ("Specify a terminal type with `setenv TERM <yourtype>'.\n");
|
|
|
258
|
|
|
259 success = tgetent (term_buffer, termtype);
|
|
|
260 if (success < 0)
|
|
|
261 fatal ("Could not access the termcap data base.\n");
|
|
|
262 if (success == 0)
|
|
|
263 fatal ("Terminal type `%s' is not defined.\n", termtype);
|
|
|
264 @}
|
|
|
265 @end example
|
|
|
266
|
|
|
267 @noindent
|
|
|
268 Here we assume the function @code{fatal} prints an error message and exits.
|
|
|
269
|
|
|
270 If the environment variable @code{TERMCAP} is defined, its value is used to
|
|
|
271 override the terminal type data base. The function @code{tgetent} checks
|
|
|
272 the value of @code{TERMCAP} automatically. If the value starts with
|
|
|
273 @samp{/} then it is taken as a file name to use as the data base file,
|
|
|
274 instead of @file{/etc/termcap} which is the standard data base. If the
|
|
|
275 value does not start with @samp{/} then it is itself used as the terminal
|
|
|
276 description, provided that the terminal type @var{termtype} is among the
|
|
|
277 types it claims to apply to. @xref{Data Base}, for information on the
|
|
|
278 format of a terminal description.@refill
|
|
|
279
|
|
|
280 @node Interrogate, Initialize, Find, Library
|
|
|
281 @section Interrogating the Terminal Description
|
|
|
282
|
|
|
283 Each piece of information recorded in a terminal description is called a
|
|
|
284 @dfn{capability}. Each defined terminal capability has a two-letter code
|
|
|
285 name and a specific meaning. For example, the number of columns is named
|
|
|
286 @samp{co}. @xref{Capabilities}, for definitions of all the standard
|
|
|
287 capability names.
|
|
|
288
|
|
|
289 Once you have found the proper terminal description with @code{tgetent}
|
|
|
290 (@pxref{Find}), your application program must @dfn{interrogate} it for
|
|
|
291 various terminal capabilities. You must specify the two-letter code of
|
|
|
292 the capability whose value you seek.
|
|
|
293
|
|
|
294 Capability values can be numeric, boolean (capability is either present or
|
|
|
295 absent) or strings. Any particular capability always has the same value
|
|
|
296 type; for example, @samp{co} always has a numeric value, while @samp{am}
|
|
|
297 (automatic wrap at margin) is always a flag, and @samp{cm} (cursor motion
|
|
|
298 command) always has a string value. The documentation of each capability
|
|
|
299 says which type of value it has.@refill
|
|
|
300
|
|
|
301 There are three functions to use to get the value of a capability,
|
|
|
302 depending on the type of value the capability has. Here are their
|
|
|
303 declarations in ANSI C:
|
|
|
304
|
|
|
305 @findex tgetnum
|
|
|
306 @findex tgetflag
|
|
|
307 @findex tgetstr
|
|
|
308 @example
|
|
|
309 int tgetnum (char *@var{name});
|
|
|
310 int tgetflag (char *@var{name});
|
|
|
311 char *tgetstr (char *@var{name}, char **@var{area});
|
|
|
312 @end example
|
|
|
313
|
|
|
314 @table @code
|
|
|
315 @item tgetnum
|
|
|
316 Use @code{tgetnum} to get a capability value that is numeric. The
|
|
|
317 argument @var{name} is the two-letter code name of the capability. If
|
|
|
318 the capability is present, @code{tgetnum} returns the numeric value
|
|
|
319 (which is nonnegative). If the capability is not mentioned in the
|
|
|
320 terminal description, @code{tgetnum} returns @minus{}1.
|
|
|
321
|
|
|
322 @item tgetflag
|
|
|
323 Use @code{tgetflag} to get a boolean value. If the capability
|
|
|
324 @var{name} is present in the terminal description, @code{tgetflag}
|
|
|
325 returns 1; otherwise, it returns 0.
|
|
|
326
|
|
|
327 @item tgetstr
|
|
|
328 Use @code{tgetstr} to get a string value. It returns a pointer to a
|
|
|
329 string which is the capability value, or a null pointer if the
|
|
|
330 capability is not present in the terminal description.
|
|
|
331
|
|
|
332 There are two ways @code{tgetstr} can find space to store the string value:
|
|
|
333
|
|
|
334 @itemize @bullet
|
|
|
335 @item
|
|
|
336 You can ask @code{tgetstr} to allocate the space. Pass a null
|
|
|
337 pointer for the argument @var{area}, and @code{tgetstr} will use
|
|
|
338 @code{malloc} to allocate storage big enough for the value.
|
|
|
339 Termcap will never free this storage or refer to it again; you
|
|
|
340 should free it when you are finished with it.
|
|
|
341
|
|
|
342 This method is more robust, since there is no need to guess how
|
|
|
343 much space is needed. But it is supported only by the GNU
|
|
|
344 termcap library.
|
|
|
345
|
|
|
346 @item
|
|
|
347 You can provide the space. Provide for the argument @var{area} the
|
|
|
348 address of a pointer variable of type @code{char *}. Before calling
|
|
|
349 @code{tgetstr}, initialize the variable to point at available space.
|
|
|
350 Then @code{tgetstr} will store the string value in that space and will
|
|
|
351 increment the pointer variable to point after the space that has been
|
|
|
352 used. You can use the same pointer variable for many calls to
|
|
|
353 @code{tgetstr}.
|
|
|
354
|
|
|
355 There is no way to determine how much space is needed for a single
|
|
|
356 string, and no way for you to prevent or handle overflow of the area
|
|
|
357 you have provided. However, you can be sure that the total size of
|
|
|
358 all the string values you will obtain from the terminal description is
|
|
|
359 no greater than the size of the description (unless you get the same
|
|
|
360 capability twice). You can determine that size with @code{strlen} on
|
|
|
361 the buffer you provided to @code{tgetent}. See below for an example.
|
|
|
362
|
|
|
363 Providing the space yourself is the only method supported by the Unix
|
|
|
364 version of termcap.
|
|
|
365 @end itemize
|
|
|
366 @end table
|
|
|
367
|
|
|
368 Note that you do not have to specify a terminal type or terminal
|
|
|
369 description for the interrogation functions. They automatically use the
|
|
|
370 description found by the most recent call to @code{tgetent}.
|
|
|
371
|
|
|
372 Here is an example of interrogating a terminal description for various
|
|
|
373 capabilities, with conditionals to select between the Unix and GNU methods
|
|
|
374 of providing buffer space.
|
|
|
375
|
|
|
376 @example
|
|
|
377 char *tgetstr ();
|
|
|
378
|
|
|
379 char *cl_string, *cm_string;
|
|
|
380 int height;
|
|
|
381 int width;
|
|
|
382 int auto_wrap;
|
|
|
383
|
|
|
384 char PC; /* For tputs. */
|
|
|
385 char *BC; /* For tgoto. */
|
|
|
386 char *UP;
|
|
|
387
|
|
|
388 interrogate_terminal ()
|
|
|
389 @{
|
|
|
390 #ifdef UNIX
|
|
|
391 /* Here we assume that an explicit term_buffer
|
|
|
392 was provided to tgetent. */
|
|
|
393 char *buffer
|
|
|
394 = (char *) malloc (strlen (term_buffer));
|
|
|
395 #define BUFFADDR &buffer
|
|
|
396 #else
|
|
|
397 #define BUFFADDR 0
|
|
|
398 #endif
|
|
|
399
|
|
|
400 char *temp;
|
|
|
401
|
|
|
402 /* Extract information we will use. */
|
|
|
403 cl_string = tgetstr ("cl", BUFFADDR);
|
|
|
404 cm_string = tgetstr ("cm", BUFFADDR);
|
|
|
405 auto_wrap = tgetflag ("am");
|
|
|
406 height = tgetnum ("li");
|
|
|
407 width = tgetnum ("co");
|
|
|
408
|
|
|
409 /* Extract information that termcap functions use. */
|
|
|
410 temp = tgetstr ("pc", BUFFADDR);
|
|
|
411 PC = temp ? *temp : 0;
|
|
|
412 BC = tgetstr ("le", BUFFADDR);
|
|
|
413 UP = tgetstr ("up", BUFFADDR);
|
|
|
414 @}
|
|
|
415 @end example
|
|
|
416
|
|
|
417 @noindent
|
|
|
418 @xref{Padding}, for information on the variable @code{PC}. @xref{Using
|
|
|
419 Parameters}, for information on @code{UP} and @code{BC}.
|
|
|
420
|
|
|
421 @node Initialize, Padding, Interrogate, Library
|
|
|
422 @section Initialization for Use of Termcap
|
|
|
423 @cindex terminal flags (kernel)
|
|
|
424
|
|
|
425 Before starting to output commands to a terminal using termcap,
|
|
|
426 an application program should do two things:
|
|
|
427
|
|
|
428 @itemize @bullet
|
|
|
429 @item
|
|
|
430 Initialize various global variables which termcap library output
|
|
|
431 functions refer to. These include @code{PC} and @code{ospeed} for
|
|
|
432 padding (@pxref{Output Padding}) and @code{UP} and @code{BC} for
|
|
|
433 cursor motion (@pxref{tgoto}).@refill
|
|
|
434
|
|
|
435 @item
|
|
|
436 Tell the kernel to turn off alteration and padding of horizontal-tab
|
|
|
437 characters sent to the terminal.
|
|
|
438 @end itemize
|
|
|
439
|
|
|
440 To turn off output processing in Berkeley Unix you would use @code{ioctl}
|
|
|
441 with code @code{TIOCLSET} to set the bit named @code{LLITOUT}, and clear
|
|
|
442 the bits @code{ANYDELAY} using @code{TIOCSETN}. In POSIX or System V, you
|
|
|
443 must clear the bit named @code{OPOST}. Refer to the system documentation
|
|
|
444 for details.@refill
|
|
|
445
|
|
|
446 If you do not set the terminal flags properly, some older terminals will
|
|
|
447 not work. This is because their commands may contain the characters that
|
|
|
448 normally signify newline, carriage return and horizontal tab---characters
|
|
|
449 which the kernel thinks it ought to modify before output.
|
|
|
450
|
|
|
451 When you change the kernel's terminal flags, you must arrange to restore
|
|
|
452 them to their normal state when your program exits. This implies that the
|
|
|
453 program must catch fatal signals such as @code{SIGQUIT} and @code{SIGINT}
|
|
|
454 and restore the old terminal flags before actually terminating.
|
|
|
455
|
|
|
456 Modern terminals' commands do not use these special characters, so if you
|
|
|
457 do not care about problems with old terminals, you can leave the kernel's
|
|
|
458 terminal flags unaltered.
|
|
|
459
|
|
|
460 @node Padding, Parameters, Initialize, Library
|
|
|
461 @section Padding
|
|
|
462 @cindex padding
|
|
|
463
|
|
|
464 @dfn{Padding} means outputting null characters following a terminal display
|
|
|
465 command that takes a long time to execute. The terminal description says
|
|
|
466 which commands require padding and how much; the function @code{tputs},
|
|
|
467 described below, outputs a terminal command while extracting from it the
|
|
|
468 padding information, and then outputs the padding that is necessary.
|
|
|
469
|
|
|
470 @menu
|
|
|
471 * Why Pad:: Explanation of padding.
|
|
|
472 * Describe Padding:: The data base says how much padding a terminal needs.
|
|
|
473 * Output Padding:: Using @code{tputs} to output the needed padding.
|
|
|
474 @end menu
|
|
|
475
|
|
|
476 @node Why Pad, Describe Padding, Padding, Padding
|
|
|
477 @subsection Why Pad, and How
|
|
|
478
|
|
|
479 Most types of terminal have commands that take longer to execute than they
|
|
|
480 do to send over a high-speed line. For example, clearing the screen may
|
|
|
481 take 20msec once the entire command is received. During that time, on a
|
|
|
482 9600 bps line, the terminal could receive about 20 additional output
|
|
|
483 characters while still busy clearing the screen. Every terminal has a
|
|
|
484 certain amount of buffering capacity to remember output characters that
|
|
|
485 cannot be processed yet, but too many slow commands in a row can cause the
|
|
|
486 buffer to fill up. Then any additional output that cannot be processed
|
|
|
487 immediately will be lost.
|
|
|
488
|
|
|
489 To avoid this problem, we normally follow each display command with enough
|
|
|
490 useless charaters (usually null characters) to fill up the time that the
|
|
|
491 display command needs to execute. This does the job if the terminal throws
|
|
|
492 away null characters without using up space in the buffer (which most
|
|
|
493 terminals do). If enough padding is used, no output can ever be lost. The
|
|
|
494 right amount of padding avoids loss of output without slowing down
|
|
|
495 operation, since the time used to transmit padding is time that nothing
|
|
|
496 else could be done.
|
|
|
497
|
|
|
498 The number of padding characters needed for an operation depends on the
|
|
|
499 line speed. In fact, it is proportional to the line speed. A 9600 baud
|
|
|
500 line transmits about one character per msec, so the clear screen command in
|
|
|
501 the example above would need about 20 characters of padding. At 1200 baud,
|
|
|
502 however, only about 3 characters of padding are needed to fill up 20msec.
|
|
|
503
|
|
|
504 @node Describe Padding, Output Padding, Why Pad, Padding
|
|
|
505 @subsection Specifying Padding in a Terminal Description
|
|
|
506
|
|
|
507 In the terminal description, the amount of padding required by each display
|
|
|
508 command is recorded as a sequence of digits at the front of the command.
|
|
|
509 These digits specify the padding time in msec. They can be followed
|
|
|
510 optionally by a decimal point and one more digit, which is a number of
|
|
|
511 tenths of msec.
|
|
|
512
|
|
|
513 Sometimes the padding needed by a command depends on the cursor position.
|
|
|
514 For example, the time taken by an ``insert line'' command is usually
|
|
|
515 proportional to the number of lines that need to be moved down or cleared.
|
|
|
516 An asterisk (@samp{*}) following the padding time says that the time
|
|
|
517 should be multiplied by the number of screen lines affected by the command.
|
|
|
518
|
|
|
519 @example
|
|
|
520 :al=1.3*\E[L:
|
|
|
521 @end example
|
|
|
522
|
|
|
523 @noindent
|
|
|
524 is used to describe the ``insert line'' command for a certain terminal.
|
|
|
525 The padding required is 1.3 msec per line affected. The command itself is
|
|
|
526 @samp{@key{ESC} [ L}.
|
|
|
527
|
|
|
528 The padding time specified in this way tells @code{tputs} how many pad
|
|
|
529 characters to output. @xref{Output Padding}.
|
|
|
530
|
|
|
531 Two special capability values affect padding for all commands. These are
|
|
|
532 the @samp{pc} and @samp{pb}. The variable @samp{pc} specifies the
|
|
|
533 character to pad with, and @samp{pb} the speed below which no padding is
|
|
|
534 needed. The defaults for these variables, a null character and 0,
|
|
|
535 are correct for most terminals. @xref{Pad Specs}.
|
|
|
536
|
|
|
537 @node Output Padding,, Describe Padding, Padding
|
|
|
538 @subsection Performing Padding with @code{tputs}
|
|
|
539 @cindex line speed
|
|
|
540
|
|
|
541 @findex tputs
|
|
|
542 Use the termcap function @code{tputs} to output a string containing an
|
|
|
543 optional padding spec of the form described above (@pxref{Describe
|
|
|
544 Padding}). The function @code{tputs} strips off and decodes the padding
|
|
|
545 spec, outputs the rest of the string, and then outputs the appropriate
|
|
|
546 padding. Here is its declaration in ANSI C:
|
|
|
547
|
|
|
548 @example
|
|
|
549 char PC;
|
|
|
550 short ospeed;
|
|
|
551
|
|
|
552 int tputs (char *@var{string}, int @var{nlines}, int (*@var{outfun}) ());
|
|
|
553 @end example
|
|
|
554
|
|
|
555 Here @var{string} is the string (including padding spec) to be output;
|
|
|
556 @var{nlines} is the number of lines affected by the operation, which is
|
|
|
557 used to multiply the amount of padding if the padding spec ends with a
|
|
|
558 @samp{*}. Finally, @var{outfun} is a function (such as @code{fputchar})
|
|
|
559 that is called to output each character. When actually called,
|
|
|
560 @var{outfun} should expect one argument, a character.
|
|
|
561
|
|
|
562 @vindex ospeed
|
|
|
563 @vindex PC
|
|
|
564 The operation of @code{tputs} is controlled by two global variables,
|
|
|
565 @code{ospeed} and @code{PC}. The value of @code{ospeed} is supposed to be
|
|
|
566 the terminal output speed, encoded as in the @code{ioctl} system call which
|
|
|
567 gets the speed information. This is needed to compute the number of
|
|
|
568 padding characters. The value of @code{PC} is the character used for
|
|
|
569 padding.
|
|
|
570
|
|
|
571 You are responsible for storing suitable values into these variables before
|
|
|
572 using @code{tputs}. The value stored into the @code{PC} variable should be
|
|
|
573 taken from the @samp{pc} capability in the terminal description (@pxref{Pad
|
|
|
574 Specs}). Store zero in @code{PC} if there is no @samp{pc}
|
|
|
575 capability.@refill
|
|
|
576
|
|
|
577 The argument @var{nlines} requires some thought. Normally, it should be
|
|
|
578 the number of lines whose contents will be cleared or moved by the command.
|
|
|
579 For cursor motion commands, or commands that do editing within one line,
|
|
|
580 use the value 1. For most commands that affect multiple lines, such as
|
|
|
581 @samp{al} (insert a line) and @samp{cd} (clear from the cursor to the end
|
|
|
582 of the screen), @var{nlines} should be the screen height minus the current
|
|
|
583 vertical position (origin 0). For multiple insert and scroll commands such
|
|
|
584 as @samp{AL} (insert multiple lines), that same value for @var{nlines} is
|
|
|
585 correct; the number of lines being inserted is @i{not} correct.@refill
|
|
|
586
|
|
|
587 If a ``scroll window'' feature is used to reduce the number of lines
|
|
|
588 affected by a command, the value of @var{nlines} should take this into
|
|
|
589 account. This is because the delay time required depends on how much work
|
|
|
590 the terminal has to do, and the scroll window feature reduces the work.
|
|
|
591 @xref{Scrolling}.
|
|
|
592
|
|
|
593 Commands such as @samp{ic} and @samp{dc} (insert or delete characters) are
|
|
|
594 problematical because the padding needed by these commands is proportional
|
|
|
595 to the number of characters affected, which is the number of columns from
|
|
|
596 the cursor to the end of the line. It would be nice to have a way to
|
|
|
597 specify such a dependence, and there is no need for dependence on vertical
|
|
|
598 position in these commands, so it is an obvious idea to say that for these
|
|
|
599 commands @var{nlines} should really be the number of columns affected.
|
|
|
600 However, the definition of termcap clearly says that @var{nlines} is always
|
|
|
601 the number of lines affected, even in this case, where it is always 1. It
|
|
|
602 is not easy to change this rule now, because too many programs and terminal
|
|
|
603 descriptions have been written to follow it.
|
|
|
604
|
|
|
605 Because @var{nlines} is always 1 for the @samp{ic} and @samp{dc} strings,
|
|
|
606 there is no reason for them to use @samp{*}, but some of them do. These
|
|
|
607 should be corrected by deleting the @samp{*}. If, some day, such entries
|
|
|
608 have disappeared, it may be possible to change to a more useful convention
|
|
|
609 for the @var{nlines} argument for these operations without breaking any
|
|
|
610 programs.
|
|
|
611
|
|
|
612 @node Parameters,, Padding, Library
|
|
|
613 @section Filling In Parameters
|
|
|
614 @cindex parameters
|
|
|
615
|
|
|
616 Some terminal control strings require numeric @dfn{parameters}. For
|
|
|
617 example, when you move the cursor, you need to say what horizontal and
|
|
|
618 vertical positions to move it to. The value of the terminal's @samp{cm}
|
|
|
619 capability, which says how to move the cursor, cannot simply be a string of
|
|
|
620 characters; it must say how to express the cursor position numbers and
|
|
|
621 where to put them within the command.
|
|
|
622
|
|
|
623 The specifications of termcap include conventions as to which string-valued
|
|
|
624 capabilities require parameters, how many parameters, and what the
|
|
|
625 parameters mean; for example, it defines the @samp{cm} string to take
|
|
|
626 two parameters, the vertical and horizontal positions, with 0,0 being the
|
|
|
627 upper left corner. These conventions are described where the individual
|
|
|
628 commands are documented.
|
|
|
629
|
|
|
630 Termcap also defines a language used within the capability definition for
|
|
|
631 specifying how and where to encode the parameters for output. This language
|
|
|
632 uses character sequences starting with @samp{%}. (This is the same idea as
|
|
|
633 @code{printf}, but the details are different.) The language for parameter
|
|
|
634 encoding is described in this section.
|
|
|
635
|
|
|
636 A program that is doing display output calls the functions @code{tparam} or
|
|
|
637 @code{tgoto} to encode parameters according to the specifications. These
|
|
|
638 functions produce a string containing the actual commands to be output (as
|
|
|
639 well a padding spec which must be processed with @code{tputs};
|
|
|
640 @pxref{Padding}).
|
|
|
641
|
|
|
642 @menu
|
|
|
643 * Encode Parameters:: The language for encoding parameters.
|
|
|
644 * Using Parameters:: Outputting a string command with parameters.
|
|
|
645 @end menu
|
|
|
646
|
|
|
647 @node Encode Parameters, Using Parameters, Parameters, Parameters
|
|
|
648 @subsection Describing the Encoding
|
|
|
649 @cindex %
|
|
|
650
|
|
|
651 A terminal command string that requires parameters contains special
|
|
|
652 character sequences starting with @samp{%} to say how to encode the
|
|
|
653 parameters. These sequences control the actions of @code{tparam} and
|
|
|
654 @code{tgoto}.
|
|
|
655
|
|
|
656 The parameters values passed to @code{tparam} or @code{tgoto} are
|
|
|
657 considered to form a vector. A pointer into this vector determines
|
|
|
658 the next parameter to be processed. Some of the @samp{%}-sequences
|
|
|
659 encode one parameter and advance the pointer to the next parameter.
|
|
|
660 Other @samp{%}-sequences alter the pointer or alter the parameter
|
|
|
661 values without generating output.
|
|
|
662
|
|
|
663 For example, the @samp{cm} string for a standard ANSI terminal is written
|
|
|
664 as @samp{\E[%i%d;%dH}. (@samp{\E} stands for @key{ESC}.) @samp{cm} by
|
|
|
665 convention always requires two parameters, the vertical and horizontal goal
|
|
|
666 positions, so this string specifies the encoding of two parameters. Here
|
|
|
667 @samp{%i} increments the two values supplied, and each @samp{%d} encodes
|
|
|
668 one of the values in decimal. If the cursor position values 20,58 are
|
|
|
669 encoded with this string, the result is @samp{\E[21;59H}.
|
|
|
670
|
|
|
671 First, here are the @samp{%}-sequences that generate output. Except for
|
|
|
672 @samp{%%}, each of them encodes one parameter and advances the pointer
|
|
|
673 to the following parameter.
|
|
|
674
|
|
|
675 @table @samp
|
|
|
676 @item %%
|
|
|
677 Output a single @samp{%}. This is the only way to represent a literal
|
|
|
678 @samp{%} in a terminal command with parameters. @samp{%%} does not
|
|
|
679 use up a parameter.
|
|
|
680
|
|
|
681 @item %d
|
|
|
682 As in @code{printf}, output the next parameter in decimal.
|
|
|
683
|
|
|
684 @item %2
|
|
|
685 Like @samp{%02d} in @code{printf}: output the next parameter in
|
|
|
686 decimal, and always use at least two digits.
|
|
|
687
|
|
|
688 @item %3
|
|
|
689 Like @samp{%03d} in @code{printf}: output the next parameter in
|
|
|
690 decimal, and always use at least three digits. Note that @samp{%4}
|
|
|
691 and so on are @emph{not} defined.
|
|
|
692
|
|
|
693 @item %.
|
|
|
694 Output the next parameter as a single character whose ASCII code is
|
|
|
695 the parameter value. Like @samp{%c} in @code{printf}.
|
|
|
696
|
|
|
697 @item %+@var{char}
|
|
|
698 Add the next parameter to the character @var{char}, and output the
|
|
|
699 resulting character. For example, @samp{%+ } represents 0 as a space,
|
|
|
700 1 as @samp{!}, etc.
|
|
|
701 @end table
|
|
|
702
|
|
|
703 The following @samp{%}-sequences specify alteration of the parameters
|
|
|
704 (their values, or their order) rather than encoding a parameter for output.
|
|
|
705 They generate no output; they are used only for their side effects
|
|
|
706 on the parameters. Also, they do not advance the ``next parameter'' pointer
|
|
|
707 except as explicitly stated. Only @samp{%i}, @samp{%r} and @samp{%>} are
|
|
|
708 defined in standard Unix termcap. The others are GNU extensions.@refill
|
|
|
709
|
|
|
710 @table @samp
|
|
|
711 @item %i
|
|
|
712 Increment the next two parameters. This is used for terminals that
|
|
|
713 expect cursor positions in origin 1. For example, @samp{%i%d,%d} would
|
|
|
714 output two parameters with @samp{1} for 0, @samp{2} for 1, etc.
|
|
|
715
|
|
|
716 @item %r
|
|
|
717 Interchange the next two parameters. This is used for terminals whose
|
|
|
718 cursor positioning command expects the horizontal position first.
|
|
|
719
|
|
|
720 @item %s
|
|
|
721 Skip the next parameter. Do not output anything.
|
|
|
722
|
|
|
723 @item %b
|
|
|
724 Back up one parameter. The last parameter used will become once again
|
|
|
725 the next parameter to be output, and the next output command will use
|
|
|
726 it. Using @samp{%b} more than once, you can back up any number of
|
|
|
727 parameters, and you can refer to each parameter any number of times.
|
|
|
728
|
|
|
729 @item %>@var{c1}@var{c2}
|
|
|
730 Conditionally increment the next parameter. Here @var{c1} and
|
|
|
731 @var{c2} are characters which stand for their ASCII codes as numbers.
|
|
|
732 If the next parameter is greater than the ASCII code of @var{c1}, the
|
|
|
733 ASCII code of @var{c2} is added to it.@refill
|
|
|
734
|
|
|
735 @item %a @var{op} @var{type} @var{pos}
|
|
|
736 Perform arithmetic on the next parameter, do not use it up, and do not
|
|
|
737 output anything. Here @var{op} specifies the arithmetic operation,
|
|
|
738 while @var{type} and @var{pos} together specify the other operand.
|
|
|
739
|
|
|
740 Spaces are used above to separate the operands for clarity; the spaces
|
|
|
741 don't appear in the data base, where this sequence is exactly five
|
|
|
742 characters long.
|
|
|
743
|
|
|
744 The character @var{op} says what kind of arithmetic operation to
|
|
|
745 perform. It can be any of these characters:
|
|
|
746
|
|
|
747 @table @samp
|
|
|
748 @item =
|
|
|
749 assign a value to the next parameter, ignoring its old value.
|
|
|
750 The new value comes from the other operand.
|
|
|
751
|
|
|
752 @item +
|
|
|
753 add the other operand to the next parameter.
|
|
|
754
|
|
|
755 @item -
|
|
|
756 subtract the other operand from the next parameter.
|
|
|
757
|
|
|
758 @item *
|
|
|
759 multiply the next parameter by the other operand.
|
|
|
760
|
|
|
761 @item /
|
|
|
762 divide the next parameter by the other operand.
|
|
|
763 @end table
|
|
|
764
|
|
|
765 The ``other operand'' may be another parameter's value or a constant;
|
|
|
766 the character @var{type} says which. It can be:
|
|
|
767
|
|
|
768 @table @samp
|
|
|
769 @item p
|
|
|
770 Use another parameter. The character @var{pos} says which
|
|
|
771 parameter to use. Subtract 64 from its ASCII code to get the
|
|
|
772 position of the desired parameter relative to this one. Thus,
|
|
|
773 the character @samp{A} as @var{pos} means the parameter after the
|
|
|
774 next one; the character @samp{?} means the parameter before the
|
|
|
775 next one.
|
|
|
776
|
|
|
777 @item c
|
|
|
778 Use a constant value. The character @var{pos} specifies the
|
|
|
779 value of the constant. The 0200 bit is cleared out, so that 0200
|
|
|
780 can be used to represent zero.
|
|
|
781 @end table
|
|
|
782 @end table
|
|
|
783
|
|
|
784 The following @samp{%}-sequences are special purpose hacks to compensate
|
|
|
785 for the weird designs of obscure terminals. They modify the next parameter
|
|
|
786 or the next two parameters but do not generate output and do not use up any
|
|
|
787 parameters. @samp{%m} is a GNU extension; the others are defined in
|
|
|
788 standard Unix termcap.
|
|
|
789
|
|
|
790 @table @samp
|
|
|
791 @item %n
|
|
|
792 Exclusive-or the next parameter with 0140, and likewise the parameter
|
|
|
793 after next.
|
|
|
794
|
|
|
795 @item %m
|
|
|
796 Complement all the bits of the next parameter and the parameter after next.
|
|
|
797
|
|
|
798 @item %B
|
|
|
799 Encode the next parameter in BCD. It alters the value of the
|
|
|
800 parameter by adding six times the quotient of the parameter by ten.
|
|
|
801 Here is a C statement that shows how the new value is computed:
|
|
|
802
|
|
|
803 @example
|
|
|
804 @var{parm} = (@var{parm} / 10) * 16 + @var{parm} % 10;
|
|
|
805 @end example
|
|
|
806
|
|
|
807 @item %D
|
|
|
808 Transform the next parameter as needed by Delta Data terminals.
|
|
|
809 This involves subtracting twice the remainder of the parameter by 16.
|
|
|
810
|
|
|
811 @example
|
|
|
812 @var{parm} -= 2 * (@var{parm} % 16);
|
|
|
813 @end example
|
|
|
814 @end table
|
|
|
815
|
|
|
816 @node Using Parameters,, Encode Parameters, Parameters
|
|
|
817 @subsection Sending Display Commands with Parameters
|
|
|
818
|
|
|
819 The termcap library functions @code{tparam} and @code{tgoto} serve as the
|
|
|
820 analog of @code{printf} for terminal string parameters. The newer function
|
|
|
821 @code{tparam} is a GNU extension, more general but missing from Unix
|
|
|
822 termcap. The original parameter-encoding function is @code{tgoto}, which
|
|
|
823 is preferable for cursor motion.
|
|
|
824
|
|
|
825 @menu
|
|
|
826 * tparam:: The general case, for GNU termcap only.
|
|
|
827 * tgoto:: The special case of cursor motion.
|
|
|
828 @end menu
|
|
|
829
|
|
|
830 @node tparam, tgoto, Using Parameters, Using Parameters
|
|
|
831 @subsubsection @code{tparam}
|
|
|
832
|
|
|
833 @findex tparam
|
|
|
834 The function @code{tparam} can encode display commands with any number of
|
|
|
835 parameters and allows you to specify the buffer space. It is the preferred
|
|
|
836 function for encoding parameters for all but the @samp{cm} capability. Its
|
|
|
837 ANSI C declaration is as follows:
|
|
|
838
|
|
|
839 @example
|
|
|
840 char *tparam (char *@var{ctlstring}, char *@var{buffer}, int @var{size}, int @var{parm1},...)
|
|
|
841 @end example
|
|
|
842
|
|
|
843 The arguments are a control string @var{ctlstring} (the value of a terminal
|
|
|
844 capability, presumably), an output buffer @var{buffer} and @var{size}, and
|
|
|
845 any number of integer parameters to be encoded. The effect of
|
|
|
846 @code{tparam} is to copy the control string into the buffer, encoding
|
|
|
847 parameters according to the @samp{%} sequences in the control string.
|
|
|
848
|
|
|
849 You describe the output buffer by its address, @var{buffer}, and its size
|
|
|
850 in bytes, @var{size}. If the buffer is not big enough for the data to be
|
|
|
851 stored in it, @code{tparam} calls @code{malloc} to get a larger buffer. In
|
|
|
852 either case, @code{tparam} returns the address of the buffer it ultimately
|
|
|
853 uses. If the value equals @var{buffer}, your original buffer was used.
|
|
|
854 Otherwise, a new buffer was allocated, and you must free it after you are
|
|
|
855 done with printing the results. If you pass zero for @var{size} and
|
|
|
856 @var{buffer}, @code{tparam} always allocates the space with @code{malloc}.
|
|
|
857
|
|
|
858 All capabilities that require parameters also have the ability to specify
|
|
|
859 padding, so you should use @code{tputs} to output the string produced by
|
|
|
860 @code{tparam}. @xref{Padding}. Here is an example.
|
|
|
861
|
|
|
862 @example
|
|
|
863 @{
|
|
|
864 char *buf;
|
|
|
865 char buffer[40];
|
|
|
866
|
|
|
867 buf = tparam (command, buffer, 40, parm);
|
|
|
868 tputs (buf, 1, fputchar);
|
|
|
869 if (buf != buffer)
|
|
|
870 free (buf);
|
|
|
871 @}
|
|
|
872 @end example
|
|
|
873
|
|
|
874 If a parameter whose value is zero is encoded with @samp{%.}-style
|
|
|
875 encoding, the result is a null character, which will confuse @code{tputs}.
|
|
|
876 This would be a serious problem, but luckily @samp{%.} encoding is used
|
|
|
877 only by a few old models of terminal, and only for the @samp{cm}
|
|
|
878 capability. To solve the problem, use @code{tgoto} rather than
|
|
|
879 @code{tparam} to encode the @samp{cm} capability.@refill
|
|
|
880
|
|
|
881 @node tgoto,, tparam, Using Parameters
|
|
|
882 @subsubsection @code{tgoto}
|
|
|
883
|
|
|
884 @findex tgoto
|
|
|
885 The special case of cursor motion is handled by @code{tgoto}. There
|
|
|
886 are two reasons why you might choose to use @code{tgoto}:
|
|
|
887
|
|
|
888 @itemize @bullet
|
|
|
889 @item
|
|
|
890 For Unix compatibility, because Unix termcap does not have @code{tparam}.
|
|
|
891
|
|
|
892 @item
|
|
|
893 For the @samp{cm} capability, since @code{tgoto} has a special feature
|
|
|
894 to avoid problems with null characters, tabs and newlines on certain old
|
|
|
895 terminal types that use @samp{%.} encoding for that capability.
|
|
|
896 @end itemize
|
|
|
897
|
|
|
898 Here is how @code{tgoto} might be declared in ANSI C:
|
|
|
899
|
|
|
900 @example
|
|
|
901 char *tgoto (char *@var{cstring}, int @var{hpos}, int @var{vpos})
|
|
|
902 @end example
|
|
|
903
|
|
|
904 There are three arguments, the terminal description's @samp{cm} string and
|
|
|
905 the two cursor position numbers; @code{tgoto} computes the parametrized
|
|
|
906 string in an internal static buffer and returns the address of that buffer.
|
|
|
907 The next time you use @code{tgoto} the same buffer will be reused.
|
|
|
908
|
|
|
909 @vindex UP
|
|
|
910 @vindex BC
|
|
|
911 Parameters encoded with @samp{%.} encoding can generate null characters,
|
|
|
912 tabs or newlines. These might cause trouble: the null character because
|
|
|
913 @code{tputs} would think that was the end of the string, the tab because
|
|
|
914 the kernel or other software might expand it into spaces, and the newline
|
|
|
915 becaue the kernel might add a carriage-return, or padding characters
|
|
|
916 normally used for a newline. To prevent such problems, @code{tgoto} is
|
|
|
917 careful to avoid these characters. Here is how this works: if the target
|
|
|
918 cursor position value is such as to cause a problem (that is to say, zero,
|
|
|
919 nine or ten), @code{tgoto} increments it by one, then compensates by
|
|
|
920 appending a string to move the cursor back or up one position.
|
|
|
921
|
|
|
922 The compensation strings to use for moving back or up are found in global
|
|
|
923 variables named @code{BC} and @code{UP}. These are actual external C
|
|
|
924 variables with upper case names; they are declared @code{char *}. It is up
|
|
|
925 to you to store suitable values in them, normally obtained from the
|
|
|
926 @samp{le} and @samp{up} terminal capabilities in the terminal description
|
|
|
927 with @code{tgetstr}. Alternatively, if these two variables are both zero,
|
|
|
928 the feature of avoiding nulls, tabs and newlines is turned off.
|
|
|
929
|
|
|
930 It is safe to use @code{tgoto} for commands other than @samp{cm} only if
|
|
|
931 you have stored zero in @code{BC} and @code{UP}.
|
|
|
932
|
|
|
933 Note that @code{tgoto} reverses the order of its operands: the horizontal
|
|
|
934 position comes before the vertical position in the arguments to
|
|
|
935 @code{tgoto}, even though the vertical position comes before the horizontal
|
|
|
936 in the parameters of the @samp{cm} string. If you use @code{tgoto} with a
|
|
|
937 command such as @samp{AL} that takes one parameter, you must pass the
|
|
|
938 parameter to @code{tgoto} as the ``vertical position''.@refill
|
|
|
939
|
|
|
940 @node Data Base, Capabilities, Library, Top
|
|
|
941 @chapter The Format of the Data Base
|
|
|
942
|
|
|
943 The termcap data base of terminal descriptions is stored in the file
|
|
|
944 @file{/etc/termcap}. It contains terminal descriptions, blank lines, and
|
|
|
945 comments.
|
|
|
946
|
|
|
947 A terminal description starts with one or more names for the terminal type.
|
|
|
948 The information in the description is a series of @dfn{capability names}
|
|
|
949 and values. The capability names have standard meanings
|
|
|
950 (@pxref{Capabilities}) and their values describe the terminal.
|
|
|
951
|
|
|
952 @menu
|
|
|
953 * Format:: Overall format of a terminal description.
|
|
|
954 * Capability Format:: Format of capabilities within a description.
|
|
|
955 * Naming:: Naming conventions for terminal types.
|
|
|
956 * Inheriting:: Inheriting part of a description from
|
|
|
957 a related terminal type.
|
|
|
958 @end menu
|
|
|
959
|
|
|
960 @node Format, Capability Format, Data Base, Data Base
|
|
|
961 @section Terminal Description Format
|
|
|
962 @cindex description format
|
|
|
963
|
|
|
964 Aside from comments (lines starting with @samp{#}, which are ignored), each
|
|
|
965 nonblank line in the termcap data base is a terminal description.
|
|
|
966 A terminal description is nominally a single line, but it can be split
|
|
|
967 into multiple lines by inserting the two characters @samp{\ newline}.
|
|
|
968 This sequence is ignored wherever it appears in a description.
|
|
|
969
|
|
|
970 The preferred way to split the description is between capabilities: insert
|
|
|
971 the four characters @samp{: \ newline tab} immediately before any colon.
|
|
|
972 This allows each sub-line to start with some indentation. This works
|
|
|
973 because, after the @samp{\ newline} are ignored, the result is @samp{: tab
|
|
|
974 :}; the first colon ends the preceding capability and the second colon
|
|
|
975 starts the next capability. If you split with @samp{\ newline} alone, you
|
|
|
976 may not add any indentation after them.
|
|
|
977
|
|
|
978 Here is a real example of a terminal description:
|
|
|
979
|
|
|
980 @example
|
|
|
981 dw|vt52|DEC vt52:\
|
|
|
982 :cr=^M:do=^J:nl=^J:bl=^G:\
|
|
|
983 :le=^H:bs:cd=\EJ:ce=\EK:cl=\EH\EJ:cm=\EY%+ %+ :co#80:li#24:\
|
|
|
984 :nd=\EC:ta=^I:pt:sr=\EI:up=\EA:\
|
|
|
985 :ku=\EA:kd=\EB:kr=\EC:kl=\ED:kb=^H:
|
|
|
986 @end example
|
|
|
987
|
|
|
988 Each terminal description begins with several names for the terminal type.
|
|
|
989 The names are separated by @samp{|} characters, and a colon ends the last
|
|
|
990 name. The first name should be two characters long; it exists only for the
|
|
|
991 sake of very old Unix systems and is never used in modern systems. The
|
|
|
992 last name should be a fully verbose name such as ``DEC vt52'' or ``Ann
|
|
|
993 Arbor Ambassador with 48 lines''. The other names should include whatever
|
|
|
994 the user ought to be able to specify to get this terminal type, such as
|
|
|
995 @samp{vt52} or @samp{aaa-48}. @xref{Naming}, for information on how to
|
|
|
996 choose terminal type names.
|
|
|
997
|
|
|
998 After the terminal type names come the terminal capabilities, separated by
|
|
|
999 colons and with a colon after the last one. Each capability has a
|
|
|
1000 two-letter name, such as @samp{cm} for ``cursor motion string'' or @samp{li}
|
|
|
1001 for ``number of display lines''.
|
|
|
1002
|
|
|
1003 @node Capability Format, Naming, Format, Data Base
|
|
|
1004 @section Writing the Capabilities
|
|
|
1005
|
|
|
1006 There are three kinds of capabilities: flags, numbers, and strings. Each
|
|
|
1007 kind has its own way of being written in the description. Each defined
|
|
|
1008 capability has by convention a particular kind of value; for example,
|
|
|
1009 @samp{li} always has a numeric value and @samp{cm} always a string value.
|
|
|
1010
|
|
|
1011 A flag capability is thought of as having a boolean value: the value is
|
|
|
1012 true if the capability is present, false if not. When the capability is
|
|
|
1013 present, just write its name between two colons.
|
|
|
1014
|
|
|
1015 A numeric capability has a value which is a nonnegative number. Write the
|
|
|
1016 capability name, a @samp{#}, and the number, between two colons. For
|
|
|
1017 example, @samp{@dots{}:li#48:@dots{}} is how you specify the @samp{li}
|
|
|
1018 capability for 48 lines.@refill
|
|
|
1019
|
|
|
1020 A string-valued capability has a value which is a sequence of characters.
|
|
|
1021 Usually these are the characters used to perform some display operation.
|
|
|
1022 Write the capability name, a @samp{=}, and the characters of the value,
|
|
|
1023 between two colons. For example, @samp{@dots{}:cm=\E[%i%d;%dH:@dots{}} is
|
|
|
1024 how the cursor motion command for a standard ANSI terminal would be
|
|
|
1025 specified.@refill
|
|
|
1026
|
|
|
1027 Special characters in the string value can be expressed using
|
|
|
1028 @samp{\}-escape sequences as in C; in addition, @samp{\E} stands for
|
|
|
1029 @key{ESC}. @samp{^} is also a kind of escape character; @samp{^} followed
|
|
|
1030 by @var{char} stands for the control-equivalent of @var{char}. Thus,
|
|
|
1031 @samp{^a} stands for the character control-a, just like @samp{\001}.
|
|
|
1032 @samp{\} and @samp{^} themselves can be represented as @samp{\\} and
|
|
|
1033 @samp{\^}.@refill
|
|
|
1034
|
|
|
1035 To include a colon in the string, you must write @samp{\072}. You might
|
|
|
1036 ask, ``Why can't @samp{\:} be used to represent a colon?'' The reason is
|
|
|
1037 that the interrogation functions do not count slashes while looking for a
|
|
|
1038 capability. Even if @samp{:ce=ab\:cd:} were interpreted as giving the
|
|
|
1039 @samp{ce} capability the value @samp{ab:cd}, it would also appear to define
|
|
|
1040 @samp{cd} as a flag.
|
|
|
1041
|
|
|
1042 The string value will often contain digits at the front to specify padding
|
|
|
1043 (@pxref{Padding}) and/or @samp{%}-sequences within to specify how to encode
|
|
|
1044 parameters (@pxref{Parameters}). Although these things are not to be
|
|
|
1045 output literally to the terminal, they are considered part of the value of
|
|
|
1046 the capability. They are special only when the string value is processed
|
|
|
1047 by @code{tputs}, @code{tparam} or @code{tgoto}. By contrast, @samp{\} and
|
|
|
1048 @samp{^} are considered part of the syntax for specifying the characters
|
|
|
1049 in the string.
|
|
|
1050
|
|
|
1051 Let's look at the VT52 example again:
|
|
|
1052
|
|
|
1053 @example
|
|
|
1054 dw|vt52|DEC vt52:\
|
|
|
1055 :cr=^M:do=^J:nl=^J:bl=^G:\
|
|
|
1056 :le=^H:bs:cd=\EJ:ce=\EK:cl=\EH\EJ:cm=\EY%+ %+ :co#80:li#24:\
|
|
|
1057 :nd=\EC:ta=^I:pt:sr=\EI:up=\EA:\
|
|
|
1058 :ku=\EA:kd=\EB:kr=\EC:kl=\ED:kb=^H:
|
|
|
1059 @end example
|
|
|
1060
|
|
|
1061 Here we see the numeric-valued capabilities @samp{co} and @samp{li}, the
|
|
|
1062 flags @samp{bs} and @samp{pt}, and many string-valued capabilities. Most
|
|
|
1063 of the strings start with @key{ESC} represented as @samp{\E}. The rest
|
|
|
1064 contain control characters represented using @samp{^}. The meanings of the
|
|
|
1065 individual capabilities are defined elsewhere (@pxref{Capabilities}).
|
|
|
1066
|
|
|
1067 @node Naming, Inheriting, Capability Format, Data Base
|
|
|
1068 @section Terminal Type Name Conventions
|
|
|
1069 @cindex names of terminal types
|
|
|
1070
|
|
|
1071 There are conventions for choosing names of terminal types. For one thing,
|
|
|
1072 all letters should be in lower case. The terminal type for a terminal in
|
|
|
1073 its most usual or most fundamental mode of operation should not have a
|
|
|
1074 hyphen in it.
|
|
|
1075
|
|
|
1076 If the same terminal has other modes of operation which require
|
|
|
1077 different terminal descriptions, these variant descriptions are given
|
|
|
1078 names made by adding suffixes with hyphens. Such alternate descriptions
|
|
|
1079 are used for two reasons:
|
|
|
1080
|
|
|
1081 @itemize @bullet
|
|
|
1082 @item
|
|
|
1083 When the terminal has a switch that changes its behavior. Since the
|
|
|
1084 computer cannot tell how the switch is set, the user must tell the
|
|
|
1085 computer by choosing the appropriate terminal type name.
|
|
|
1086
|
|
|
1087 @cindex wrapping
|
|
|
1088 For example, the VT-100 has a setup flag that controls whether the
|
|
|
1089 cursor wraps at the right margin. If this flag is set to ``wrap'',
|
|
|
1090 you must use the terminal type @samp{vt100-am}. Otherwise you must
|
|
|
1091 use @samp{vt100-nam}. Plain @samp{vt100} is defined as a synonym for
|
|
|
1092 either @samp{vt100-am} or @samp{vt100-nam} depending on the
|
|
|
1093 preferences of the local site.@refill
|
|
|
1094
|
|
|
1095 The standard suffix @samp{-am} stands for ``automatic margins''.
|
|
|
1096
|
|
|
1097 @item
|
|
|
1098 To give the user a choice in how to use the terminal. This is done
|
|
|
1099 when the terminal has a switch that the computer normally controls.
|
|
|
1100
|
|
|
1101 @cindex screen size
|
|
|
1102 For example, the Ann Arbor Ambassador can be configured with many
|
|
|
1103 screen sizes ranging from 20 to 60 lines. Fewer lines make bigger
|
|
|
1104 characters but more lines let you see more of what you are editing.
|
|
|
1105 As a result, users have different preferences. Therefore, termcap
|
|
|
1106 provides terminal types for many screen sizes. If you choose type
|
|
|
1107 @samp{aaa-30}, the terminal will be configured to use 30 lines; if you
|
|
|
1108 choose @samp{aaa-48}, 48 lines will be used, and so on.
|
|
|
1109 @end itemize
|
|
|
1110
|
|
|
1111 Here is a list of standard suffixes and their conventional meanings:
|
|
|
1112
|
|
|
1113 @table @samp
|
|
|
1114 @item -w
|
|
|
1115 Short for ``wide''. This is a mode that gives the terminal more
|
|
|
1116 columns than usual. This is normally a user option.
|
|
|
1117
|
|
|
1118 @item -am
|
|
|
1119 ``Automatic margins''. This is an alternate description for use when
|
|
|
1120 the terminal's margin-wrap switch is on; it contains the @samp{am}
|
|
|
1121 flag. The implication is that normally the switch is off and the
|
|
|
1122 usual description for the terminal says that the switch is off.
|
|
|
1123
|
|
|
1124 @item -nam
|
|
|
1125 ``No automatic margins''. The opposite of @samp{-am}, this names an
|
|
|
1126 alternative description which lacks the @samp{am} flag. This implies
|
|
|
1127 that the terminal is normally operated with the margin-wrap switch
|
|
|
1128 turned on, and the normal description of the terminal says so.
|
|
|
1129
|
|
|
1130 @item -na
|
|
|
1131 ``No arrows''. This terminal description initializes the terminal to
|
|
|
1132 keep its arrow keys in local mode. This is a user option.
|
|
|
1133
|
|
|
1134 @item -rv
|
|
|
1135 ``Reverse video''. This terminal description causes text output for
|
|
|
1136 normal video to appear as reverse, and text output for reverse video
|
|
|
1137 to come out as normal. Often this description differs from the usual
|
|
|
1138 one by interchanging the two strings which turn reverse video on and
|
|
|
1139 off.@refill
|
|
|
1140
|
|
|
1141 This is a user option; you can choose either the ``reverse video''
|
|
|
1142 variant terminal type or the normal terminal type, and termcap will
|
|
|
1143 obey.
|
|
|
1144
|
|
|
1145 @item -s
|
|
|
1146 ``Status''. Says to enable use of a status line which ordinary output
|
|
|
1147 does not touch (@pxref{Status Line}).
|
|
|
1148
|
|
|
1149 Some terminals have a special line that is used only as a status line.
|
|
901
|
1150 For these terminals, there is no need for a @samp{-s} variant; the
|
|
428
|
1151 status line commands should be defined by default. On other
|
|
|
1152 terminals, enabling a status line means removing one screen line from
|
|
|
1153 ordinary use and reducing the effective screen height. For these
|
|
|
1154 terminals, the user can choose the @samp{-s} variant type to request
|
|
|
1155 use of a status line.
|
|
|
1156
|
|
|
1157 @item -@var{nlines}
|
|
|
1158 Says to operate with @var{nlines} lines on the screen, for terminals
|
|
|
1159 such as the Ambassador which provide this as an option. Normally this
|
|
|
1160 is a user option; by choosing the terminal type, you control how many
|
|
|
1161 lines termcap will use.
|
|
|
1162
|
|
|
1163 @item -@var{npages}p
|
|
|
1164 Says that the terminal has @var{npages} pages worth of screen memory,
|
|
|
1165 for terminals where this is a hardware option.
|
|
|
1166
|
|
|
1167 @item -unk
|
|
|
1168 Says that description is not for direct use, but only for reference in
|
|
|
1169 @samp{tc} capabilities. Such a description is a kind of subroutine,
|
|
|
1170 because it describes the common characteristics of several variant
|
|
|
1171 descriptions that would use other suffixes in place of @samp{-unk}.
|
|
|
1172 @end table
|
|
|
1173
|
|
|
1174 @node Inheriting,, Naming, Data Base
|
|
|
1175 @section Inheriting from Related Descriptions
|
|
|
1176
|
|
|
1177 @cindex inheritance
|
|
|
1178 When two terminal descriptions are similar, their identical parts do not
|
|
|
1179 need to be given twice. Instead, one of the two can be defined in terms of
|
|
|
1180 the other, using the @samp{tc} capability. We say that one description
|
|
|
1181 @dfn{refers to} the other, or @dfn{inherits from} the other.
|
|
|
1182
|
|
|
1183 The @samp{tc} capability must be the last one in the terminal description,
|
|
|
1184 and its value is a string which is the name of another terminal type which
|
|
|
1185 is referred to. For example,
|
|
|
1186
|
|
|
1187 @example
|
|
|
1188 N9|aaa|ambassador|aaa-30|ann arbor ambassador/30 lines:\
|
|
|
1189 :ti=\E[2J\E[30;0;0;30p:\
|
|
|
1190 :te=\E[60;0;0;30p\E[30;1H\E[J:\
|
|
|
1191 :li#30:tc=aaa-unk:
|
|
|
1192 @end example
|
|
|
1193
|
|
|
1194 @noindent
|
|
|
1195 defines the terminal type @samp{aaa-30} (also known as plain @samp{aaa}) in
|
|
|
1196 terms of @samp{aaa-unk}, which defines everything about the Ambassador that
|
|
|
1197 is independent of screen height. The types @samp{aaa-36}, @samp{aaa-48}
|
|
|
1198 and so on for other screen heights are likewise defined to inherit from
|
|
|
1199 @samp{aaa-unk}.
|
|
|
1200
|
|
|
1201 The capabilities overridden by @samp{aaa-30} include @samp{li}, which says
|
|
|
1202 how many lines there are, and @samp{ti} and @samp{te}, which configure the
|
|
|
1203 terminal to use that many lines.
|
|
|
1204
|
|
|
1205 The effective terminal description for type @samp{aaa} consists of the text
|
|
|
1206 shown above followed by the text of the description of @samp{aaa-unk}. The
|
|
|
1207 @samp{tc} capability is handled automatically by @code{tgetent}, which
|
|
|
1208 finds the description thus referenced and combines the two descriptions
|
|
|
1209 (@pxref{Find}). Therefore, only the implementor of the terminal
|
|
|
1210 descriptions needs to think about using @samp{tc}. Users and application
|
|
|
1211 programmers do not need to be concerned with it.
|
|
|
1212
|
|
|
1213 Since the reference terminal description is used last, capabilities
|
|
|
1214 specified in the referring description override any specifications of the
|
|
|
1215 same capabilities in the reference description.
|
|
|
1216
|
|
|
1217 The referring description can cancel out a capability without specifying
|
|
|
1218 any new value for it by means of a special trick. Write the capability in
|
|
|
1219 the referring description, with the character @samp{@@} after the capability
|
|
|
1220 name, as follows:
|
|
|
1221
|
|
|
1222 @example
|
|
|
1223 NZ|aaa-30-nam|ann arbor ambassador/30 lines/no automatic-margins:\
|
|
|
1224 :am@@:tc=aaa-30:
|
|
|
1225 @end example
|
|
|
1226
|
|
|
1227 @node Capabilities, Summary, Data Base, Top
|
|
|
1228 @chapter Definitions of the Terminal Capabilities
|
|
|
1229
|
|
|
1230 This section is divided into many subsections, each for one aspect of
|
|
|
1231 use of display terminals. For writing a display program, you usually need
|
|
|
1232 only check the subsections for the operations you want to use. For writing
|
|
|
1233 a terminal description, you must read each subsection and fill in the
|
|
|
1234 capabilities described there.
|
|
|
1235
|
|
|
1236 String capabilities that are display commands may require numeric
|
|
|
1237 parameters (@pxref{Parameters}). Most such capabilities do not use
|
|
|
1238 parameters. When a capability requires parameters, this is explicitly
|
|
|
1239 stated at the beginning of its definition. In simple cases, the first or
|
|
|
1240 second sentence of the definition mentions all the parameters, in the order
|
|
|
1241 they should be given, using a name
|
|
|
1242 @iftex
|
|
|
1243 in italics
|
|
|
1244 @end iftex
|
|
|
1245 @ifinfo
|
|
|
1246 in upper case
|
|
|
1247 @end ifinfo
|
|
|
1248 for each one. For example, the @samp{rp} capability is a command that
|
|
|
1249 requires two parameters; its definition begins as follows:
|
|
|
1250
|
|
|
1251 @quotation
|
|
|
1252 String of commands to output a graphic character @var{c}, repeated @var{n}
|
|
|
1253 times.
|
|
|
1254 @end quotation
|
|
|
1255
|
|
|
1256 In complex cases or when there are many parameters, they are described
|
|
|
1257 explicitly.
|
|
|
1258
|
|
|
1259 When a capability is described as obsolete, this means that programs should
|
|
|
1260 not be written to look for it, but terminal descriptions should still be
|
|
|
1261 written to provide it.
|
|
|
1262
|
|
|
1263 When a capability is described as very obsolete, this means that it should
|
|
|
1264 be omitted from terminal descriptions as well.
|
|
|
1265
|
|
|
1266 @menu
|
|
|
1267 * Basic:: Basic characteristics.
|
|
|
1268 * Screen Size:: Screen size, and what happens when it changes.
|
|
|
1269 * Cursor Motion:: Various ways to move the cursor.
|
|
|
1270 * Scrolling:: Pushing text up and down on the screen.
|
|
|
1271 * Wrapping:: What happens if you write a character in the last column.
|
|
|
1272 * Windows:: Limiting the part of the window that output affects.
|
|
|
1273 * Clearing:: Erasing one or many lines.
|
|
|
1274 * Insdel Line:: Making new blank lines in mid-screen; deleting lines.
|
|
|
1275 * Insdel Char:: Inserting and deleting characters within a line.
|
|
|
1276 * Standout:: Highlighting some of the text.
|
|
|
1277 * Underlining:: Underlining some of the text.
|
|
|
1278 * Cursor Visibility:: Making the cursor more or less easy to spot.
|
|
|
1279 * Bell:: Attracts user's attention; not localized on the screen.
|
|
|
1280 * Keypad:: Recognizing when function keys or arrows are typed.
|
|
|
1281 * Meta Key:: @key{META} acts like an extra shift key.
|
|
|
1282 * Initialization:: Commands used to initialize or reset the terminal.
|
|
|
1283 * Pad Specs:: Info for the kernel on how much padding is needed.
|
|
|
1284 * Status Line:: A status line displays ``background'' information.
|
|
|
1285 * Half-Line:: Moving by half-lines, for superscripts and subscripts.
|
|
|
1286 * Printer:: Controlling auxiliary printers of display terminals.
|
|
|
1287 @end menu
|
|
|
1288
|
|
|
1289 @node Basic, Screen Size, Capabilities, Capabilities
|
|
|
1290 @section Basic Characteristics
|
|
|
1291
|
|
|
1292 This section documents the capabilities that describe the basic and
|
|
|
1293 nature of the terminal, and also those that are relevant to the output
|
|
|
1294 of graphic characters.
|
|
|
1295
|
|
|
1296 @table @samp
|
|
|
1297 @item os
|
|
|
1298 @kindex os
|
|
|
1299 @cindex overstrike
|
|
|
1300 Flag whose presence means that the terminal can overstrike. This
|
|
|
1301 means that outputting a graphic character does not erase whatever was
|
|
|
1302 present in the same character position before. The terminals that can
|
|
|
1303 overstrike include printing terminals, storage tubes (all obsolete
|
|
|
1304 nowadays), and many bit-map displays.
|
|
|
1305
|
|
|
1306 @item eo
|
|
|
1307 @kindex eo
|
|
|
1308 Flag whose presence means that outputting a space can erase an
|
|
|
1309 overstrike. If this is not present and overstriking is supported,
|
|
|
1310 output of a space has no effect except to move the cursor.
|
|
|
1311
|
|
|
1312 @item gn
|
|
|
1313 @kindex gn
|
|
|
1314 @cindex generic terminal type
|
|
|
1315 Flag whose presence means that this terminal type is a generic type
|
|
|
1316 which does not really describe any particular terminal. Generic types
|
|
|
1317 are intended for use as the default type assigned when the user
|
|
|
1318 connects to the system, with the intention that the user should
|
|
|
1319 specify what type he really has. One example of a generic type
|
|
|
1320 is the type @samp{network}.
|
|
|
1321
|
|
|
1322 Since the generic type cannot say how to do anything interesting with
|
|
|
1323 the terminal, termcap-using programs will always find that the
|
|
|
1324 terminal is too weak to be supported if the user has failed to specify
|
|
|
1325 a real terminal type in place of the generic one. The @samp{gn} flag
|
|
|
1326 directs these programs to use a different error message: ``You have
|
|
|
1327 not specified your real terminal type'', rather than ``Your terminal
|
|
|
1328 is not powerful enough to be used''.
|
|
|
1329
|
|
|
1330 @item hc
|
|
|
1331 @kindex hc
|
|
|
1332 Flag whose presence means this is a hardcopy terminal.
|
|
|
1333
|
|
|
1334 @item rp
|
|
|
1335 @kindex rp
|
|
|
1336 @cindex repeat output
|
|
|
1337 String of commands to output a graphic character @var{c}, repeated @var{n}
|
|
|
1338 times. The first parameter value is the ASCII code for the desired
|
|
|
1339 character, and the second parameter is the number of times to repeat the
|
|
|
1340 character. Often this command requires padding proportional to the
|
|
|
1341 number of times the character is repeated. This effect can be had by
|
|
|
1342 using parameter arithmetic with @samp{%}-sequences to compute the
|
|
|
1343 amount of padding, then generating the result as a number at the front
|
|
|
1344 of the string so that @code{tputs} will treat it as padding.
|
|
|
1345
|
|
|
1346 @item hz
|
|
|
1347 @kindex hz
|
|
|
1348 Flag whose presence means that the ASCII character @samp{~} cannot be
|
|
|
1349 output on this terminal because it is used for display commands.
|
|
|
1350
|
|
|
1351 Programs handle this flag by checking all text to be output and
|
|
|
1352 replacing each @samp{~} with some other character(s). If this is not
|
|
|
1353 done, the screen will be thoroughly garbled.
|
|
|
1354
|
|
|
1355 The old Hazeltine terminals that required such treatment are probably
|
|
|
1356 very rare today, so you might as well not bother to support this flag.
|
|
|
1357
|
|
|
1358 @item CC
|
|
|
1359 @kindex CC
|
|
|
1360 @cindex command character
|
|
|
1361 String whose presence means the terminal has a settable command
|
|
|
1362 character. The value of the string is the default command character
|
|
|
1363 (which is usually @key{ESC}).
|
|
|
1364
|
|
|
1365 All the strings of commands in the terminal description should be
|
|
|
1366 written to use the default command character. If you are writing an
|
|
|
1367 application program that changes the command character, use the
|
|
|
1368 @samp{CC} capability to figure out how to translate all the display
|
|
|
1369 commands to work with the new command character.
|
|
|
1370
|
|
|
1371 Most programs have no reason to look at the @samp{CC} capability.
|
|
|
1372
|
|
|
1373 @item xb
|
|
|
1374 @kindex xb
|
|
|
1375 @cindex Superbee
|
|
|
1376 Flag whose presence identifies Superbee terminals which are unable to
|
|
|
1377 transmit the characters @key{ESC} and @kbd{Control-C}. Programs which
|
|
|
1378 support this flag are supposed to check the input for the code sequences
|
|
|
1379 sent by the @key{F1} and @key{F2} keys, and pretend that @key{ESC}
|
|
|
1380 or @kbd{Control-C} (respectively) had been read. But this flag is
|
|
|
1381 obsolete, and not worth supporting.
|
|
|
1382 @end table
|
|
|
1383
|
|
|
1384 @node Screen Size, Cursor Motion, Basic, Capabilities
|
|
|
1385 @section Screen Size
|
|
|
1386 @cindex screen size
|
|
|
1387
|
|
|
1388 A terminal description has two capabilities, @samp{co} and @samp{li},
|
|
|
1389 that describe the screen size in columns and lines. But there is more
|
|
|
1390 to the question of screen size than this.
|
|
|
1391
|
|
|
1392 On some operating systems the ``screen'' is really a window and the
|
|
|
1393 effective width can vary. On some of these systems, @code{tgetnum}
|
|
|
1394 uses the actual width of the window to decide what value to return for
|
|
|
1395 the @samp{co} capability, overriding what is actually written in the
|
|
|
1396 terminal description. On other systems, it is up to the application
|
|
|
1397 program to check the actual window width using a system call. For
|
|
|
1398 example, on BSD 4.3 systems, the system call @code{ioctl} with code
|
|
|
1399 @code{TIOCGWINSZ} will tell you the current screen size.
|
|
|
1400
|
|
|
1401 On all window systems, termcap is powerless to advise the application
|
|
|
1402 program if the user resizes the window. Application programs must
|
|
|
1403 deal with this possibility in a system-dependent fashion. On some
|
|
|
1404 systems the C shell handles part of the problem by detecting changes
|
|
|
1405 in window size and setting the @code{TERMCAP} environment variable
|
|
|
1406 appropriately. This takes care of application programs that are
|
|
|
1407 started subsequently. It does not help application programs already
|
|
|
1408 running.
|
|
|
1409
|
|
|
1410 On some systems, including BSD 4.3, all programs using a terminal get
|
|
|
1411 a signal named @code{SIGWINCH} whenever the screen size changes.
|
|
|
1412 Programs that use termcap should handle this signal by using
|
|
|
1413 @code{ioctl TIOCGWINSZ} to learn the new screen size.
|
|
|
1414
|
|
|
1415 @table @samp
|
|
|
1416 @item co
|
|
|
1417 @kindex co
|
|
|
1418 @cindex screen size
|
|
|
1419 Numeric value, the width of the screen in character positions. Even
|
|
|
1420 hardcopy terminals normally have a @samp{co} capability.
|
|
|
1421
|
|
|
1422 @item li
|
|
|
1423 @kindex li
|
|
|
1424 Numeric value, the height of the screen in lines.
|
|
|
1425 @end table
|
|
|
1426
|
|
|
1427 @node Cursor Motion, Wrapping, Screen Size, Capabilities
|
|
|
1428 @section Cursor Motion
|
|
|
1429 @cindex cursor motion
|
|
|
1430
|
|
|
1431 Termcap assumes that the terminal has a @dfn{cursor}, a spot on the screen
|
|
|
1432 where a visible mark is displayed, and that most display commands take
|
|
|
1433 effect at the position of the cursor. It follows that moving the cursor
|
|
|
1434 to a specified location is very important.
|
|
|
1435
|
|
|
1436 There are many terminal capabilities for different cursor motion
|
|
|
1437 operations. A terminal description should define as many as possible, but
|
|
|
1438 most programs do not need to use most of them. One capability, @samp{cm},
|
|
|
1439 moves the cursor to an arbitrary place on the screen; this by itself is
|
|
|
1440 sufficient for any application as long as there is no need to support
|
|
|
1441 hardcopy terminals or certain old, weak displays that have only relative
|
|
|
1442 motion commands. Use of other cursor motion capabilities is an
|
|
|
1443 optimization, enabling the program to output fewer characters in some
|
|
|
1444 common cases.
|
|
|
1445
|
|
|
1446 If you plan to use the relative cursor motion commands in an application
|
|
|
1447 program, you must know what the starting cursor position is. To do this,
|
|
|
1448 you must keep track of the cursor position and update the records each
|
|
|
1449 time anything is output to the terminal, including graphic characters.
|
|
|
1450 In addition, it is necessary to know whether the terminal wraps after
|
|
|
1451 writing in the rightmost column. @xref{Wrapping}.
|
|
|
1452
|
|
|
1453 One other motion capability needs special mention: @samp{nw} moves the
|
|
|
1454 cursor to the beginning of the following line, perhaps clearing all the
|
|
|
1455 starting line after the cursor, or perhaps not clearing at all. This
|
|
|
1456 capability is a least common denominator that is probably supported even by
|
|
|
1457 terminals that cannot do most other things such as @samp{cm} or @samp{do}.
|
|
|
1458 Even hardcopy terminals can support @samp{nw}.
|
|
|
1459
|
|
|
1460 @table @asis
|
|
|
1461 @item @samp{cm}
|
|
|
1462 @kindex cm
|
|
|
1463 String of commands to position the cursor at line @var{l}, column @var{c}.
|
|
|
1464 Both parameters are origin-zero, and are defined relative to the
|
|
|
1465 screen, not relative to display memory.
|
|
|
1466
|
|
|
1467 All display terminals except a few very obsolete ones support @samp{cm},
|
|
|
1468 so it is acceptable for an application program to refuse to operate on
|
|
|
1469 terminals lacking @samp{cm}.
|
|
|
1470
|
|
|
1471 @item @samp{ho}
|
|
|
1472 @kindex ho
|
|
|
1473 @cindex home position
|
|
|
1474 String of commands to move the cursor to the upper left corner of the
|
|
|
1475 screen (this position is called the @dfn{home position}). In
|
|
|
1476 terminals where the upper left corner of the screen is not the same as
|
|
|
1477 the beginning of display memory, this command must go to the upper
|
|
|
1478 left corner of the screen, not the beginning of display memory.
|
|
|
1479
|
|
|
1480 Every display terminal supports this capability, and many application
|
|
|
1481 programs refuse to operate if the @samp{ho} capability is missing.
|
|
|
1482
|
|
|
1483 @item @samp{ll}
|
|
|
1484 @kindex ll
|
|
|
1485 String of commands to move the cursor to the lower left corner of the
|
|
|
1486 screen. On some terminals, moving up from home position does this,
|
|
|
1487 but programs should never assume that will work. Just output the
|
|
|
1488 @samp{ll} string (if it is provided); if moving to home position and
|
|
|
1489 then moving up is the best way to get there, the @samp{ll} command
|
|
|
1490 will do that.
|
|
|
1491
|
|
|
1492 @item @samp{cr}
|
|
|
1493 @kindex cr
|
|
|
1494 String of commands to move the cursor to the beginning of the line it
|
|
|
1495 is on. If this capability is not specified, many programs assume
|
|
|
1496 they can use the ASCII carriage return character for this.
|
|
|
1497
|
|
|
1498 @item @samp{le}
|
|
|
1499 @kindex le
|
|
|
1500 String of commands to move the cursor left one column. Unless the
|
|
|
1501 @samp{bw} flag capability is specified, the effect is undefined if the
|
|
|
1502 cursor is at the left margin; do not use this command there. If
|
|
|
1503 @samp{bw} is present, this command may be used at the left margin, and
|
|
|
1504 it wraps the cursor to the last column of the preceding line.
|
|
|
1505
|
|
|
1506 @item @samp{nd}
|
|
|
1507 @kindex nd
|
|
|
1508 String of commands to move the cursor right one column. The effect is
|
|
|
1509 undefined if the cursor is at the right margin; do not use this
|
|
|
1510 command there, not even if @samp{am} is present.
|
|
|
1511
|
|
|
1512 @item @samp{up}
|
|
|
1513 @kindex up
|
|
|
1514 String of commands to move the cursor vertically up one line. The
|
|
|
1515 effect of sending this string when on the top line is undefined;
|
|
|
1516 programs should never use it that way.
|
|
|
1517
|
|
|
1518 @item @samp{do}
|
|
|
1519 @kindex do
|
|
|
1520 String of commands to move the cursor vertically down one line. The
|
|
|
1521 effect of sending this string when on the bottom line is undefined;
|
|
|
1522 programs should never use it that way.
|
|
|
1523
|
|
|
1524 The original idea was that this string would not contain a newline
|
|
|
1525 character and therefore could be used without disabling the kernel's usual
|
|
|
1526 habit of converting of newline into a carriage-return newline sequence.
|
|
|
1527 But many terminal descriptions do use newline in the @samp{do} string, so
|
|
|
1528 this is not possible; a program which sends the @samp{do} string must
|
|
|
1529 disable output conversion in the kernel (@pxref{Initialize}).
|
|
|
1530
|
|
|
1531 @item @samp{bw}
|
|
|
1532 @kindex bw
|
|
|
1533 Flag whose presence says that @samp{le} may be used in column zero
|
|
|
1534 to move to the last column of the preceding line. If this flag
|
|
|
1535 is not present, @samp{le} should not be used in column zero.
|
|
|
1536
|
|
|
1537 @item @samp{nw}
|
|
|
1538 @kindex nw
|
|
|
1539 String of commands to move the cursor to start of next line, possibly
|
|
|
1540 clearing rest of line (following the cursor) before moving.
|
|
|
1541
|
|
|
1542 @item @samp{DO}, @samp{UP}, @samp{LE}, @samp{RI}
|
|
|
1543 @kindex DO
|
|
|
1544 @kindex LE
|
|
|
1545 @kindex RI
|
|
|
1546 @kindex UP
|
|
|
1547 Strings of commands to move the cursor @var{n} lines down vertically,
|
|
|
1548 up vertically, or @var{n} columns left or right. Do not attempt to
|
|
|
1549 move past any edge of the screen with these commands; the effect of
|
|
|
1550 trying that is undefined. Only a few terminal descriptions provide
|
|
|
1551 these commands, and most programs do not use them.
|
|
|
1552
|
|
|
1553 @item @samp{CM}
|
|
|
1554 @kindex CM
|
|
|
1555 String of commands to position the cursor at line @var{l}, column
|
|
|
1556 @var{c}, relative to display memory. Both parameters are origin-zero.
|
|
|
1557 This capability is present only in terminals where there is a
|
|
|
1558 difference between screen-relative and memory-relative addressing, and
|
|
|
1559 not even in all such terminals.
|
|
|
1560
|
|
|
1561 @item @samp{ch}
|
|
|
1562 @kindex ch
|
|
|
1563 String of commands to position the cursor at column @var{c} in the
|
|
|
1564 same line it is on. This is a special case of @samp{cm} in which the
|
|
|
1565 vertical position is not changed. The @samp{ch} capability is
|
|
|
1566 provided only when it is faster to output than @samp{cm} would be in
|
|
|
1567 this special case. Programs should not assume most display terminals
|
|
|
1568 have @samp{ch}.
|
|
|
1569
|
|
|
1570 @item @samp{cv}
|
|
|
1571 @kindex cv
|
|
|
1572 String of commands to position the cursor at line @var{l} in the same
|
|
|
1573 column. This is a special case of @samp{cm} in which the horizontal
|
|
|
1574 position is not changed. The @samp{cv} capability is provided only
|
|
|
1575 when it is faster to output than @samp{cm} would be in this special
|
|
|
1576 case. Programs should not assume most display terminals have
|
|
|
1577 @samp{cv}.
|
|
|
1578
|
|
|
1579 @item @samp{sc}
|
|
|
1580 @kindex sc
|
|
|
1581 String of commands to make the terminal save the current cursor
|
|
|
1582 position. Only the last saved position can be used. If this
|
|
|
1583 capability is present, @samp{rc} should be provided also. Most
|
|
|
1584 terminals have neither.
|
|
|
1585
|
|
|
1586 @item @samp{rc}
|
|
|
1587 @kindex rc
|
|
|
1588 String of commands to make the terminal restore the last saved cursor
|
|
|
1589 position. If this capability is present, @samp{sc} should be provided
|
|
|
1590 also. Most terminals have neither.
|
|
|
1591
|
|
|
1592 @item @samp{ff}
|
|
|
1593 @kindex ff
|
|
|
1594 String of commands to advance to the next page, for a hardcopy
|
|
|
1595 terminal.
|
|
|
1596
|
|
|
1597 @item @samp{ta}
|
|
|
1598 @kindex ta
|
|
|
1599 String of commands to move the cursor right to the next hardware tab
|
|
|
1600 stop column. Missing if the terminal does not have any kind of
|
|
|
1601 hardware tabs. Do not send this command if the kernel's terminal
|
|
|
1602 modes say that the kernel is expanding tabs into spaces.
|
|
|
1603
|
|
|
1604 @item @samp{bt}
|
|
|
1605 @kindex bt
|
|
|
1606 String of commands to move the cursor left to the previous hardware
|
|
|
1607 tab stop column. Missing if the terminal has no such ability; many
|
|
|
1608 terminals do not. Do not send this command if the kernel's terminal
|
|
|
1609 modes say that the kernel is expanding tabs into spaces.
|
|
|
1610 @end table
|
|
|
1611
|
|
|
1612 The following obsolete capabilities should be included in terminal
|
|
|
1613 descriptions when appropriate, but should not be looked at by new programs.
|
|
|
1614
|
|
|
1615 @table @samp
|
|
|
1616 @item nc
|
|
|
1617 @kindex nc
|
|
|
1618 Flag whose presence means the terminal does not support the ASCII
|
|
|
1619 carriage return character as @samp{cr}. This flag is needed because
|
|
|
1620 old programs assume, when the @samp{cr} capability is missing, that
|
|
|
1621 ASCII carriage return can be used for the purpose. We use @samp{nc}
|
|
|
1622 to tell the old programs that carriage return may not be used.
|
|
|
1623
|
|
|
1624 New programs should not assume any default for @samp{cr}, so they need
|
|
|
1625 not look at @samp{nc}. However, descriptions should contain @samp{nc}
|
|
|
1626 whenever they do not contain @samp{cr}.
|
|
|
1627
|
|
|
1628 @item xt
|
|
|
1629 @kindex xt
|
|
|
1630 Flag whose presence means that the ASCII tab character may not be used
|
|
|
1631 for cursor motion. This flag exists because old programs assume, when
|
|
|
1632 the @samp{ta} capability is missing, that ASCII tab can be used for
|
|
|
1633 the purpose. We use @samp{xt} to tell the old programs not to use tab.
|
|
|
1634
|
|
|
1635 New programs should not assume any default for @samp{ta}, so they need
|
|
|
1636 not look at @samp{xt} in connection with cursor motion. Note that
|
|
|
1637 @samp{xt} also has implications for standout mode (@pxref{Standout}).
|
|
|
1638 It is obsolete in regard to cursor motion but not in regard to
|
|
|
1639 standout.
|
|
|
1640
|
|
|
1641 In fact, @samp{xt} means that the terminal is a Teleray 1061.
|
|
|
1642
|
|
|
1643 @item bc
|
|
|
1644 @kindex bc
|
|
|
1645 Very obsolete alternative name for the @samp{le} capability.
|
|
|
1646
|
|
|
1647 @item bs
|
|
|
1648 @kindex bs
|
|
|
1649 Flag whose presence means that the ASCII character backspace may be
|
|
|
1650 used to move the cursor left. Obsolete; look at @samp{le} instead.
|
|
|
1651
|
|
|
1652 @item nl
|
|
|
1653 @kindex nl
|
|
|
1654 Obsolete capability which is a string that can either be used to move
|
|
|
1655 the cursor down or to scroll. The same string must scroll when used
|
|
|
1656 on the bottom line and move the cursor when used on any other line.
|
|
|
1657 New programs should use @samp{do} or @samp{sf}, and ignore @samp{nl}.
|
|
|
1658
|
|
|
1659 If there is no @samp{nl} capability, some old programs assume they can
|
|
|
1660 use the newline character for this purpose. These programs follow a
|
|
|
1661 bad practice, but because they exist, it is still desirable to define
|
|
|
1662 the @samp{nl} capability in a terminal description if the best way to
|
|
|
1663 move down is @emph{not} a newline.
|
|
|
1664 @end table
|
|
|
1665
|
|
|
1666 @node Wrapping, Scrolling, Cursor Motion, Capabilities
|
|
|
1667 @section Wrapping
|
|
|
1668 @cindex wrapping
|
|
|
1669
|
|
|
1670 @dfn{Wrapping} means moving the cursor from the right margin to the left
|
|
|
1671 margin of the following line. Some terminals wrap automatically when a
|
|
|
1672 graphic character is output in the last column, while others do not. Most
|
|
|
1673 application programs that use termcap need to know whether the terminal
|
|
|
1674 wraps. There are two special flag capabilities to describe what the
|
|
|
1675 terminal does when a graphic character is output in the last column.
|
|
|
1676
|
|
|
1677 @table @samp
|
|
|
1678 @item am
|
|
|
1679 @kindex am
|
|
|
1680 Flag whose presence means that writing a character in the last column
|
|
|
1681 causes the cursor to wrap to the beginning of the next line.
|
|
|
1682
|
|
|
1683 If @samp{am} is not present, writing in the last column leaves the
|
|
|
1684 cursor at the place where the character was written.
|
|
|
1685
|
|
|
1686 Writing in the last column of the last line should be avoided on
|
|
|
1687 terminals with @samp{am}, as it may or may not cause scrolling to
|
|
|
1688 occur (@pxref{Scrolling}). Scrolling is surely not what you would
|
|
|
1689 intend.
|
|
|
1690
|
|
|
1691 If your program needs to check the @samp{am} flag, then it also needs
|
|
|
1692 to check the @samp{xn} flag which indicates that wrapping happens in a
|
|
|
1693 strange way. Many common terminals have the @samp{xn} flag.
|
|
|
1694
|
|
|
1695 @item xn
|
|
|
1696 @kindex xn
|
|
|
1697 Flag whose presence means that the cursor wraps in a strange way. At
|
|
|
1698 least two distinct kinds of strange behavior are known; the termcap
|
|
|
1699 data base does not contain anything to distinguish the two.
|
|
|
1700
|
|
|
1701 On Concept-100 terminals, output in the last column wraps the cursor
|
|
|
1702 almost like an ordinary @samp{am} terminal. But if the next thing
|
|
|
1703 output is a newline, it is ignored.
|
|
|
1704
|
|
|
1705 DEC VT-100 terminals (when the wrap switch is on) do a different
|
|
|
1706 strange thing: the cursor wraps only if the next thing output is
|
|
|
1707 another graphic character. In fact, the wrap occurs when the
|
|
|
1708 following graphic character is received by the terminal, before the
|
|
|
1709 character is placed on the screen.
|
|
|
1710
|
|
|
1711 On both of these terminals, after writing in the last column a
|
|
|
1712 following graphic character will be displayed in the first column of
|
|
|
1713 the following line. But the effect of relative cursor motion
|
|
|
1714 characters such as newline or backspace at such a time depends on the
|
|
|
1715 terminal. The effect of erase or scrolling commands also depends on
|
|
|
1716 the terminal. You can't assume anything about what they will do on a
|
|
|
1717 terminal that has @samp{xn}. So, to be safe, you should never do
|
|
|
1718 these things at such a time on such a terminal.
|
|
|
1719
|
|
|
1720 To be sure of reliable results on a terminal which has the @samp{xn}
|
|
|
1721 flag, output a @samp{cm} absolute positioning command after writing in
|
|
|
1722 the last column. Another safe thing to do is to output carriage-return
|
|
|
1723 newline, which will leave the cursor at the beginning of the following
|
|
|
1724 line.
|
|
|
1725 @end table
|
|
|
1726
|
|
|
1727 @node Scrolling, Windows, Wrapping, Capabilities
|
|
|
1728 @section Scrolling
|
|
|
1729 @cindex scrolling
|
|
|
1730
|
|
|
1731 @dfn{Scrolling} means moving the contents of the screen up or down one or
|
|
|
1732 more lines. Moving the contents up is @dfn{forward scrolling}; moving them
|
|
|
1733 down is @dfn{reverse scrolling}.
|
|
|
1734
|
|
|
1735 Scrolling happens after each line of output during ordinary output on most
|
|
|
1736 display terminals. But in an application program that uses termcap for
|
|
|
1737 random-access output, scrolling happens only when explicitly requested with
|
|
|
1738 the commands in this section.
|
|
|
1739
|
|
|
1740 Some terminals have a @dfn{scroll region} feature. This lets you limit
|
|
|
1741 the effect of scrolling to a specified range of lines. Lines outside the
|
|
|
1742 range are unaffected when scrolling happens. The scroll region feature
|
|
|
1743 is available if either @samp{cs} or @samp{cS} is present.
|
|
|
1744
|
|
|
1745 @table @samp
|
|
|
1746 @item sf
|
|
|
1747 @kindex sf
|
|
|
1748 String of commands to scroll the screen one line up, assuming it is
|
|
|
1749 output with the cursor at the beginning of the bottom line.
|
|
|
1750
|
|
|
1751 @item sr
|
|
|
1752 @kindex sr
|
|
|
1753 String of commands to scroll the screen one line down, assuming it is
|
|
|
1754 output with the cursor at the beginning of the top line.
|
|
|
1755
|
|
|
1756 @item SF
|
|
|
1757 @kindex SF
|
|
|
1758 String of commands to scroll the screen @var{n} lines up, assuming it
|
|
|
1759 is output with the cursor at the beginning of the bottom line.
|
|
|
1760
|
|
|
1761 @item SR
|
|
|
1762 @kindex SR
|
|
|
1763 String of commands to scroll the screen @var{n} line down, assuming it
|
|
|
1764 is output with the cursor at the beginning of the top line.
|
|
|
1765
|
|
|
1766 @item cs
|
|
|
1767 @kindex cs
|
|
|
1768 String of commands to set the scroll region. This command takes two
|
|
|
1769 parameters, @var{start} and @var{end}, which are the line numbers
|
|
|
1770 (origin-zero) of the first line to include in the scroll region and of
|
|
|
1771 the last line to include in it. When a scroll region is set,
|
|
|
1772 scrolling is limited to the specified range of lines; lines outside
|
|
|
1773 the range are not affected by scroll commands.
|
|
|
1774
|
|
|
1775 Do not try to move the cursor outside the scroll region. The region
|
|
|
1776 remains set until explicitly removed. To remove the scroll region,
|
|
|
1777 use another @samp{cs} command specifying the full height of the
|
|
|
1778 screen.
|
|
|
1779
|
|
|
1780 The cursor position is undefined after the @samp{cs} command is set,
|
|
|
1781 so position the cursor with @samp{cm} immediately afterward.
|
|
|
1782
|
|
|
1783 @item cS
|
|
|
1784 @kindex cS
|
|
|
1785 String of commands to set the scroll region using parameters in
|
|
|
1786 different form. The effect is the same as if @samp{cs} were used.
|
|
|
1787 Four parameters are required:
|
|
|
1788
|
|
|
1789 @enumerate
|
|
|
1790 @item
|
|
|
1791 Total number of lines on the screen.
|
|
|
1792 @item
|
|
|
1793 Number of lines above desired scroll region.
|
|
|
1794 @item
|
|
|
1795 Number of lines below (outside of) desired scroll region.
|
|
|
1796 @item
|
|
|
1797 Total number of lines on the screen, the same as the first parameter.
|
|
|
1798 @end enumerate
|
|
|
1799
|
|
|
1800 This capability is a GNU extension that was invented to allow the Ann
|
|
|
1801 Arbor Ambassador's scroll-region command to be described; it could
|
|
|
1802 also be done by putting non-Unix @samp{%}-sequences into a @samp{cs}
|
|
|
1803 string, but that would have confused Unix programs that used the
|
|
|
1804 @samp{cs} capability with the Unix termcap. Currently only GNU Emacs
|
|
|
1805 uses the @samp{cS} capability.
|
|
|
1806
|
|
|
1807 @item ns
|
|
|
1808 @kindex ns
|
|
|
1809 Flag which means that the terminal does not normally scroll for
|
|
|
1810 ordinary sequential output. For modern terminals, this means that
|
|
|
1811 outputting a newline in ordinary sequential output with the cursor on
|
|
|
1812 the bottom line wraps to the top line. For some obsolete terminals,
|
|
|
1813 other things may happen.
|
|
|
1814
|
|
|
1815 The terminal may be able to scroll even if it does not normally do so.
|
|
|
1816 If the @samp{sf} capability is provided, it can be used for scrolling
|
|
|
1817 regardless of @samp{ns}.
|
|
|
1818
|
|
|
1819 @item da
|
|
|
1820 @kindex da
|
|
|
1821 Flag whose presence means that lines scrolled up off the top of the
|
|
|
1822 screen may come back if scrolling down is done subsequently.
|
|
|
1823
|
|
|
1824 The @samp{da} and @samp{db} flags do not, strictly speaking, affect
|
|
|
1825 how to scroll. But programs that scroll usually need to clear the
|
|
|
1826 lines scrolled onto the screen, if these flags are present.
|
|
|
1827
|
|
|
1828 @item db
|
|
|
1829 @kindex db
|
|
|
1830 Flag whose presence means that lines scrolled down off the bottom of
|
|
|
1831 the screen may come back if scrolling up is done subsequently.
|
|
|
1832
|
|
|
1833 @item lm
|
|
|
1834 @kindex lm
|
|
|
1835 Numeric value, the number of lines of display memory that the terminal
|
|
|
1836 has. A value of zero means that the terminal has more display memory
|
|
|
1837 than can fit on the screen, but no fixed number of lines. (The number
|
|
|
1838 of lines may depend on the amount of text in each line.)
|
|
|
1839 @end table
|
|
|
1840
|
|
|
1841 Any terminal description that defines @samp{SF} should also define @samp{sf};
|
|
|
1842 likewise for @samp{SR} and @samp{sr}. However, many terminals can only
|
|
|
1843 scroll by one line at a time, so it is common to find @samp{sf} and not
|
|
|
1844 @samp{SF}, or @samp{sr} without @samp{SR}.@refill
|
|
|
1845
|
|
|
1846 Therefore, all programs that use the scrolling facilities should be
|
|
|
1847 prepared to work with @samp{sf} in the case that @samp{SF} is absent, and
|
|
|
1848 likewise with @samp{sr}. On the other hand, an application program that
|
|
|
1849 uses only @samp{sf} and not @samp{SF} is acceptable, though slow on some
|
|
|
1850 terminals.@refill
|
|
|
1851
|
|
|
1852 When outputting a scroll command with @code{tputs}, the @var{nlines}
|
|
|
1853 argument should be the total number of lines in the portion of the screen
|
|
|
1854 being scrolled. Very often these commands require padding proportional to
|
|
|
1855 this number of lines. @xref{Padding}.
|
|
|
1856
|
|
|
1857 @node Windows, Clearing, Scrolling, Capabilities
|
|
|
1858 @section Windows
|
|
|
1859 @cindex window
|
|
|
1860
|
|
|
1861 A @dfn{window}, in termcap, is a rectangular portion of the screen to which
|
|
|
1862 all display operations are restricted. Wrapping, clearing, scrolling,
|
|
|
1863 insertion and deletion all operate as if the specified window were all the
|
|
|
1864 screen there was.
|
|
|
1865
|
|
|
1866 @table @samp
|
|
|
1867 @item wi
|
|
|
1868 @kindex wi
|
|
|
1869 String of commands to set the terminal output screen window.
|
|
|
1870 This string requires four parameters, all origin-zero:
|
|
|
1871 @enumerate
|
|
|
1872 @item
|
|
|
1873 The first line to include in the window.
|
|
|
1874 @item
|
|
|
1875 The last line to include in the window.
|
|
|
1876 @item
|
|
|
1877 The first column to include in the window.
|
|
|
1878 @item
|
|
|
1879 The last column to include in the window.
|
|
|
1880 @end enumerate
|
|
|
1881 @end table
|
|
|
1882
|
|
|
1883 Most terminals do not support windows.
|
|
|
1884
|
|
|
1885 @node Clearing, Insdel Line, Windows, Capabilities
|
|
|
1886 @section Clearing Parts of the Screen
|
|
|
1887 @cindex erasing
|
|
|
1888 @cindex clearing the screen
|
|
|
1889
|
|
|
1890 There are several terminal capabilities for clearing parts of the screen
|
|
|
1891 to blank. All display terminals support the @samp{cl} string, and most
|
|
|
1892 display terminals support all of these capabilities.
|
|
|
1893
|
|
|
1894 @table @samp
|
|
|
1895 @item cl
|
|
|
1896 @kindex cl
|
|
|
1897 String of commands to clear the entire screen and position the cursor
|
|
|
1898 at the upper left corner.
|
|
|
1899
|
|
|
1900 @item cd
|
|
|
1901 @kindex cd
|
|
|
1902 String of commands to clear the line the cursor is on, and all the
|
|
|
1903 lines below it, down to the bottom of the screen. This command string
|
|
|
1904 should be used only with the cursor in column zero; their effect is
|
|
|
1905 undefined if the cursor is elsewhere.
|
|
|
1906
|
|
|
1907 @item ce
|
|
|
1908 @kindex ce
|
|
|
1909 String of commands to clear from the cursor to the end of the current
|
|
|
1910 line.
|
|
|
1911
|
|
|
1912 @item ec
|
|
|
1913 @kindex ec
|
|
|
1914 String of commands to clear @var{n} characters, starting with the
|
|
|
1915 character that the cursor is on. This command string is expected to
|
|
|
1916 leave the cursor position unchanged. The parameter @var{n} should never
|
|
|
1917 be large enough to reach past the right margin; the effect of such a
|
|
|
1918 large parameter would be undefined.
|
|
|
1919 @end table
|
|
|
1920
|
|
|
1921 Clear to end of line (@samp{ce}) is extremely important in programs that
|
|
|
1922 maintain an updating display. Nearly all display terminals support this
|
|
|
1923 operation, so it is acceptable for a an application program to refuse to
|
|
|
1924 work if @samp{ce} is not present. However, if you do not want this
|
|
|
1925 limitation, you can accomplish clearing to end of line by outputting spaces
|
|
|
1926 until you reach the right margin. In order to do this, you must know the
|
|
|
1927 current horizontal position. Also, this technique assumes that writing a
|
|
|
1928 space will erase. But this happens to be true on all the display terminals
|
|
|
1929 that fail to support @samp{ce}.
|
|
|
1930
|
|
|
1931 @node Insdel Line, Insdel Char, Clearing, Capabilities
|
|
|
1932 @section Insert/Delete Line
|
|
|
1933
|
|
|
1934 @cindex insert line
|
|
|
1935 @cindex delete line
|
|
|
1936 @dfn{Inserting a line} means creating a blank line in the middle
|
|
|
1937 of the screen, and pushing the existing lines of text apart. In fact,
|
|
|
1938 the lines above the insertion point do not change, while the lines below
|
|
|
1939 move down, and one is normally lost at the bottom of the screen.
|
|
|
1940
|
|
|
1941 @dfn{Deleting a line} means causing the line to disappear from the screen,
|
|
|
1942 closing up the gap by moving the lines below it upward. A new line
|
|
|
1943 appears at the bottom of the screen. Usually this line is blank, but
|
|
|
1944 on terminals with the @samp{db} flag it may be a line previously moved
|
|
|
1945 off the screen bottom by scrolling or line insertion.
|
|
|
1946
|
|
|
1947 Insertion and deletion of lines is useful in programs that maintain an
|
|
|
1948 updating display some parts of which may get longer or shorter. They are
|
|
|
1949 also useful in editors for scrolling parts of the screen, and for
|
|
|
1950 redisplaying after lines of text are killed or inserted.
|
|
|
1951
|
|
|
1952 Many terminals provide commands to insert or delete a single line at the
|
|
|
1953 cursor position. Some provide the ability to insert or delete several
|
|
|
1954 lines with one command, using the number of lines to insert or delete as a
|
|
|
1955 parameter. Always move the cursor to column zero before using any of
|
|
|
1956 these commands.
|
|
|
1957
|
|
|
1958 @table @samp
|
|
|
1959 @item al
|
|
|
1960 @kindex al
|
|
|
1961 String of commands to insert a blank line before the line the cursor
|
|
|
1962 is on. The existing line, and all lines below it, are moved down.
|
|
|
1963 The last line in the screen (or in the scroll region, if one is set)
|
|
|
1964 disappears and in most circumstances is discarded. It may not be
|
|
|
1965 discarded if the @samp{db} is present (@pxref{Scrolling}).
|
|
|
1966
|
|
|
1967 The cursor must be at the left margin before this command is used.
|
|
|
1968 This command does not move the cursor.
|
|
|
1969
|
|
|
1970 @item dl
|
|
|
1971 @kindex dl
|
|
|
1972 String of commands to delete the line the cursor is on. The following
|
|
|
1973 lines move up, and a blank line appears at the bottom of the screen
|
|
|
1974 (or bottom of the scroll region). If the terminal has the @samp{db}
|
|
|
1975 flag, a nonblank line previously pushed off the screen bottom may
|
|
|
1976 reappear at the bottom.
|
|
|
1977
|
|
|
1978 The cursor must be at the left margin before this command is used.
|
|
|
1979 This command does not move the cursor.
|
|
|
1980
|
|
|
1981 @item AL
|
|
|
1982 @kindex AL
|
|
|
1983 String of commands to insert @var{n} blank lines before the line that
|
|
|
1984 the cursor is on. It is like @samp{al} repeated @var{n} times, except
|
|
|
1985 that it is as fast as one @samp{al}.
|
|
|
1986
|
|
|
1987 @item DL
|
|
|
1988 @kindex DL
|
|
|
1989 String of commands to delete @var{n} lines starting with the line that
|
|
|
1990 the cursor is on. It is like @samp{dl} repeated @var{n} times, except
|
|
|
1991 that it is as fast as one @samp{dl}.
|
|
|
1992 @end table
|
|
|
1993
|
|
|
1994 Any terminal description that defines @samp{AL} should also define
|
|
|
1995 @samp{al}; likewise for @samp{DL} and @samp{dl}. However, many terminals
|
|
|
1996 can only insert or delete one line at a time, so it is common to find
|
|
|
1997 @samp{al} and not @samp{AL}, or @samp{dl} without @samp{DL}.@refill
|
|
|
1998
|
|
|
1999 Therefore, all programs that use the insert and delete facilities should be
|
|
|
2000 prepared to work with @samp{al} in the case that @samp{AL} is absent, and
|
|
|
2001 likewise with @samp{dl}. On the other hand, it is acceptable to write
|
|
|
2002 an application that uses only @samp{al} and @samp{dl} and does not look
|
|
|
2003 for @samp{AL} or @samp{DL} at all.@refill
|
|
|
2004
|
|
|
2005 If a terminal does not support line insertion and deletion directly,
|
|
|
2006 but does support a scroll region, the effect of insertion and deletion
|
|
|
2007 can be obtained with scrolling. However, it is up to the individual
|
|
|
2008 user program to check for this possibility and use the scrolling
|
|
|
2009 commands to get the desired result. It is fairly important to implement
|
|
|
2010 this alternate strategy, since it is the only way to get the effect of
|
|
|
2011 line insertion and deletion on the popular VT100 terminal.
|
|
|
2012
|
|
|
2013 Insertion and deletion of lines is affected by the scroll region on
|
|
|
2014 terminals that have a settable scroll region. This is useful when it is
|
|
|
2015 desirable to move any few consecutive lines up or down by a few lines.
|
|
|
2016 @xref{Scrolling}.
|
|
|
2017
|
|
|
2018 The line pushed off the bottom of the screen is not lost if the terminal
|
|
|
2019 has the @samp{db} flag capability; instead, it is pushed into display
|
|
|
2020 memory that does not appear on the screen. This is the same thing that
|
|
|
2021 happens when scrolling pushes a line off the bottom of the screen.
|
|
|
2022 Either reverse scrolling or deletion of a line can bring the apparently
|
|
|
2023 lost line back onto the bottom of the screen. If the terminal has the
|
|
|
2024 scroll region feature as well as @samp{db}, the pushed-out line really
|
|
|
2025 is lost if a scroll region is in effect.
|
|
|
2026
|
|
|
2027 When outputting an insert or delete command with @code{tputs}, the
|
|
|
2028 @var{nlines} argument should be the total number of lines from the cursor
|
|
|
2029 to the bottom of the screen (or scroll region). Very often these commands
|
|
|
2030 require padding proportional to this number of lines. @xref{Padding}.
|
|
|
2031
|
|
|
2032 For @samp{AL} and @samp{DL} the @var{nlines} argument should @emph{not}
|
|
|
2033 depend on the number of lines inserted or deleted; only the total number of
|
|
|
2034 lines affected. This is because it is just as fast to insert two or
|
|
|
2035 @var{n} lines with @samp{AL} as to insert one line with @samp{al}.
|
|
|
2036
|
|
|
2037 @node Insdel Char, Standout, Insdel Line, Capabilities
|
|
|
2038 @section Insert/Delete Character
|
|
|
2039 @cindex insert character
|
|
|
2040 @cindex delete character
|
|
|
2041
|
|
|
2042 @dfn{Inserting a character} means creating a blank space in the middle of a
|
|
|
2043 line, and pushing the rest of the line rightward. The character in the
|
|
|
2044 rightmost column is lost.
|
|
|
2045
|
|
|
2046 @dfn{Deleting a character} means causing the character to disappear from
|
|
|
2047 the screen, closing up the gap by moving the rest of the line leftward. A
|
|
|
2048 blank space appears in the rightmost column.
|
|
|
2049
|
|
|
2050 Insertion and deletion of characters is useful in programs that maintain an
|
|
|
2051 updating display some parts of which may get longer or shorter. It is also
|
|
|
2052 useful in editors for redisplaying the results of editing within a line.
|
|
|
2053
|
|
|
2054 Many terminals provide commands to insert or delete a single character at
|
|
|
2055 the cursor position. Some provide the ability to insert or delete several
|
|
|
2056 characters with one command, using the number of characters to insert or
|
|
|
2057 delete as a parameter.
|
|
|
2058
|
|
|
2059 @cindex insert mode
|
|
|
2060 Many terminals provide an insert mode in which outputting a graphic
|
|
|
2061 character has the added effect of inserting a position for that character.
|
|
|
2062 A special command string is used to enter insert mode and another is used
|
|
|
2063 to exit it. The reason for designing a terminal with an insert mode rather
|
|
|
2064 than an insert command is that inserting character positions is usually
|
|
|
2065 followed by writing characters into them. With insert mode, this is as
|
|
|
2066 fast as simply writing the characters, except for the fixed overhead of
|
|
|
2067 entering and leaving insert mode. However, when the line speed is great
|
|
|
2068 enough, padding may be required for the graphic characters output in insert
|
|
|
2069 mode.
|
|
|
2070
|
|
|
2071 Some terminals require you to enter insert mode and then output a special
|
|
|
2072 command for each position to be inserted. Or they may require special
|
|
|
2073 commands to be output before or after each graphic character to be
|
|
|
2074 inserted.
|
|
|
2075
|
|
|
2076 @cindex delete mode
|
|
|
2077 Deletion of characters is usually accomplished by a straightforward command
|
|
|
2078 to delete one or several positions; but on some terminals, it is necessary
|
|
|
2079 to enter a special delete mode before using the delete command, and leave
|
|
|
2080 delete mode afterward. Sometimes delete mode and insert mode are the same
|
|
|
2081 mode.
|
|
|
2082
|
|
|
2083 Some terminals make a distinction between character positions in which a
|
|
|
2084 space character has been output and positions which have been cleared. On
|
|
|
2085 these terminals, the effect of insert or delete character runs to the first
|
|
|
2086 cleared position rather than to the end of the line. In fact, the effect
|
|
|
2087 may run to more than one line if there is no cleared position to stop the
|
|
|
2088 shift on the first line. These terminals are identified by the @samp{in}
|
|
|
2089 flag capability.
|
|
|
2090
|
|
|
2091 On terminals with the @samp{in} flag, the technique of skipping over
|
|
|
2092 characters that you know were cleared, and then outputting text later on in
|
|
|
2093 the same line, causes later insert and delete character operations on that
|
|
|
2094 line to do nonstandard things. A program that has any chance of doing this
|
|
|
2095 must check for the @samp{in} flag and must be careful to write explicit
|
|
|
2096 space characters into the intermediate columns when @samp{in} is present.
|
|
|
2097
|
|
|
2098 A plethora of terminal capabilities are needed to describe all of this
|
|
|
2099 complexity. Here is a list of them all. Following the list, we present
|
|
|
2100 an algorithm for programs to use to take proper account of all of these
|
|
|
2101 capabilities.
|
|
|
2102
|
|
|
2103 @table @samp
|
|
|
2104 @item im
|
|
|
2105 @kindex im
|
|
|
2106 String of commands to enter insert mode.
|
|
|
2107
|
|
|
2108 If the terminal has no special insert mode, but it can insert
|
|
|
2109 characters with a special command, @samp{im} should be defined with a
|
|
|
2110 null value, because the @samp{vi} editor assumes that insertion of a
|
|
|
2111 character is impossible if @samp{im} is not provided.
|
|
|
2112
|
|
|
2113 New programs should not act like @samp{vi}. They should pay attention
|
|
|
2114 to @samp{im} only if it is defined.
|
|
|
2115
|
|
|
2116 @item ei
|
|
|
2117 @kindex ei
|
|
|
2118 String of commands to leave insert mode. This capability must be
|
|
|
2119 present if @samp{im} is.
|
|
|
2120
|
|
|
2121 On a few old terminals the same string is used to enter and exit
|
|
|
2122 insert mode. This string turns insert mode on if it was off, and off
|
|
|
2123 if it was on. You can tell these terminals because the @samp{ei}
|
|
|
2124 string equals the @samp{im} string. If you want to support these
|
|
|
2125 terminals, you must always remember accurately whether insert mode is
|
|
|
2126 in effect. However, these terminals are obsolete, and it is
|
|
|
2127 reasonable to refuse to support them. On all modern terminals, you
|
|
|
2128 can safely output @samp{ei} at any time to ensure that insert mode is
|
|
|
2129 turned off.
|
|
|
2130
|
|
|
2131 @item ic
|
|
|
2132 @kindex ic
|
|
|
2133 String of commands to insert one character position at the cursor.
|
|
|
2134 The cursor does not move.
|
|
|
2135
|
|
|
2136 If outputting a graphic character while in insert mode is sufficient
|
|
|
2137 to insert the character, then the @samp{ic} capability should be
|
|
|
2138 defined with a null value.
|
|
|
2139
|
|
|
2140 If your terminal offers a choice of ways to insert---either use insert
|
|
|
2141 mode or use a special command---then define @samp{im} and do not define
|
|
|
2142 @samp{ic}, since this gives the most efficient operation when several
|
|
|
2143 characters are to be inserted. @emph{Do not} define both strings, for
|
|
|
2144 that means that @emph{both} must be used each time insertion is done.
|
|
|
2145
|
|
|
2146 @item ip
|
|
|
2147 @kindex ip
|
|
|
2148 String of commands to output following an inserted graphic character
|
|
|
2149 in insert mode. Often it is used just for a padding spec, when padding
|
|
|
2150 is needed after an inserted character (@pxref{Padding}).
|
|
|
2151
|
|
|
2152 @item IC
|
|
|
2153 @kindex IC
|
|
|
2154 String of commands to insert @var{n} character positions at and after
|
|
|
2155 the cursor. It has the same effect as repeating the @samp{ic} string
|
|
|
2156 and a space, @var{n} times.
|
|
|
2157
|
|
|
2158 If @samp{IC} is provided, application programs may use it without first
|
|
|
2159 entering insert mode.
|
|
|
2160
|
|
|
2161 @item mi
|
|
|
2162 @kindex mi
|
|
|
2163 Flag whose presence means it is safe to move the cursor while in insert
|
|
|
2164 mode and assume the terminal remains in insert mode.
|
|
|
2165
|
|
|
2166 @item in
|
|
|
2167 @kindex in
|
|
|
2168 Flag whose presence means that the terminal distinguishes between
|
|
|
2169 character positions in which space characters have been output and
|
|
|
2170 positions which have been cleared.
|
|
|
2171 @end table
|
|
|
2172
|
|
|
2173 An application program can assume that the terminal can do character
|
|
|
2174 insertion if @emph{any one of} the capabilities @samp{IC}, @samp{im},
|
|
|
2175 @samp{ic} or @samp{ip} is provided.
|
|
|
2176
|
|
|
2177 To insert @var{n} blank character positions, move the cursor to the place
|
|
|
2178 to insert them and follow this algorithm:
|
|
|
2179
|
|
|
2180 @enumerate
|
|
|
2181 @item
|
|
|
2182 If an @samp{IC} string is provided, output it with parameter @var{n}
|
|
|
2183 and you are finished. Otherwise (or if you don't want to bother to
|
|
|
2184 look for an @samp{IC} string) follow the remaining steps.
|
|
|
2185
|
|
|
2186 @item
|
|
|
2187 Output the @samp{im} string, if there is one, unless the terminal is
|
|
|
2188 already in insert mode.
|
|
|
2189
|
|
|
2190 @item
|
|
|
2191 Repeat steps 4 through 6, @var{n} times.
|
|
|
2192
|
|
|
2193 @item
|
|
|
2194 Output the @samp{ic} string if any.
|
|
|
2195
|
|
|
2196 @item
|
|
|
2197 Output a space.
|
|
|
2198
|
|
|
2199 @item
|
|
|
2200 Output the @samp{ip} string if any.
|
|
|
2201
|
|
|
2202 @item
|
|
|
2203 Output the @samp{ei} string, eventually, to exit insert mode. There
|
|
|
2204 is no need to do this right away. If the @samp{mi} flag is present,
|
|
|
2205 you can move the cursor and the cursor will remain in insert mode;
|
|
|
2206 then you can do more insertion elsewhere without reentering insert
|
|
|
2207 mode.
|
|
|
2208 @end enumerate
|
|
|
2209
|
|
|
2210 To insert @var{n} graphic characters, position the cursor and follow this
|
|
|
2211 algorithm:
|
|
|
2212
|
|
|
2213 @enumerate
|
|
|
2214 @item
|
|
|
2215 If an @samp{IC} string is provided, output it with parameter @var{n},
|
|
|
2216 then output the graphic characters, and you are finished. Otherwise
|
|
|
2217 (or if you don't want to bother to look for an @samp{IC} string)
|
|
|
2218 follow the remaining steps.
|
|
|
2219
|
|
|
2220 @item
|
|
|
2221 Output the @samp{im} string, if there is one, unless the terminal is
|
|
|
2222 already in insert mode.
|
|
|
2223
|
|
|
2224 @item
|
|
|
2225 For each character to be output, repeat steps 4 through 6.
|
|
|
2226
|
|
|
2227 @item
|
|
|
2228 Output the @samp{ic} string if any.
|
|
|
2229
|
|
|
2230 @item
|
|
|
2231 Output the next graphic character.
|
|
|
2232
|
|
|
2233 @item
|
|
|
2234 Output the @samp{ip} string if any.
|
|
|
2235
|
|
|
2236 @item
|
|
|
2237 Output the @samp{ei} string, eventually, to exit insert mode. There
|
|
|
2238 is no need to do this right away. If the @samp{mi} flag is present,
|
|
|
2239 you can move the cursor and the cursor will remain in insert mode;
|
|
|
2240 then you can do more insertion elsewhere without reentering insert
|
|
|
2241 mode.
|
|
|
2242 @end enumerate
|
|
|
2243
|
|
|
2244 Note that this is not the same as the original Unix termcap specifications
|
|
|
2245 in one respect: it assumes that the @samp{IC} string can be used without
|
|
|
2246 entering insert mode. This is true as far as I know, and it allows you be
|
|
|
2247 able to avoid entering and leaving insert mode, and also to be able to
|
|
|
2248 avoid the inserted-character padding after the characters that go into the
|
|
|
2249 inserted positions.
|
|
|
2250
|
|
|
2251 Deletion of characters is less complicated; deleting one column is done by
|
|
|
2252 outputting the @samp{dc} string. However, there may be a delete mode that
|
|
|
2253 must be entered with @samp{dm} in order to make @samp{dc} work.
|
|
|
2254
|
|
|
2255 @table @samp
|
|
|
2256 @item dc
|
|
|
2257 @kindex dc
|
|
|
2258 String of commands to delete one character position at the cursor. If
|
|
|
2259 @samp{dc} is not present, the terminal cannot delete characters.
|
|
|
2260
|
|
|
2261 @item DC
|
|
|
2262 @kindex DC
|
|
|
2263 String of commands to delete @var{n} characters starting at the cursor.
|
|
|
2264 It has the same effect as repeating the @samp{dc} string @var{n} times.
|
|
|
2265 Any terminal description that has @samp{DC} also has @samp{dc}.
|
|
|
2266
|
|
|
2267 @item dm
|
|
|
2268 @kindex dm
|
|
|
2269 String of commands to enter delete mode. If not present, there is no
|
|
|
2270 delete mode, and @samp{dc} can be used at any time (assuming there is
|
|
|
2271 a @samp{dc}).
|
|
|
2272
|
|
|
2273 @item ed
|
|
|
2274 @kindex ed
|
|
|
2275 String of commands to exit delete mode. This must be present if
|
|
|
2276 @samp{dm} is.
|
|
|
2277 @end table
|
|
|
2278
|
|
|
2279 To delete @var{n} character positions, position the cursor and follow these
|
|
|
2280 steps:
|
|
|
2281
|
|
|
2282 @enumerate
|
|
|
2283 @item
|
|
|
2284 If the @samp{DC} string is present, output it with parameter @var{n}
|
|
|
2285 and you are finished. Otherwise, follow the remaining steps.
|
|
|
2286
|
|
|
2287 @item
|
|
|
2288 Output the @samp{dm} string, unless you know the terminal is already
|
|
|
2289 in delete mode.
|
|
|
2290
|
|
|
2291 @item
|
|
|
2292 Output the @samp{dc} string @var{n} times.
|
|
|
2293
|
|
|
2294 @item
|
|
|
2295 Output the @samp{ed} string eventually. If the flag capability
|
|
|
2296 @samp{mi} is present, you can move the cursor and do more deletion
|
|
|
2297 without leaving and reentering delete mode.
|
|
|
2298 @end enumerate
|
|
|
2299
|
|
|
2300 As with the @samp{IC} string, we have departed from the original termcap
|
|
|
2301 specifications by assuming that @samp{DC} works without entering delete
|
|
|
2302 mode even though @samp{dc} would not.
|
|
|
2303
|
|
|
2304 If the @samp{dm} and @samp{im} capabilities are both present and have the
|
|
|
2305 same value, it means that the terminal has one mode for both insertion and
|
|
|
2306 deletion. It is useful for a program to know this, because then it can do
|
|
|
2307 insertions after deletions, or vice versa, without leaving insert/delete
|
|
|
2308 mode and reentering it.
|
|
|
2309
|
|
|
2310 @node Standout, Underlining, Insdel Char, Capabilities
|
|
|
2311 @section Standout and Appearance Modes
|
|
|
2312 @cindex appearance modes
|
|
|
2313 @cindex standout
|
|
|
2314 @cindex magic cookie
|
|
|
2315
|
|
|
2316 @dfn{Appearance modes} are modifications to the ways characters are
|
|
|
2317 displayed. Typical appearance modes include reverse video, dim, bright,
|
|
|
2318 blinking, underlined, invisible, and alternate character set. Each kind of
|
|
|
2319 terminal supports various among these, or perhaps none.
|
|
|
2320
|
|
|
2321 For each type of terminal, one appearance mode or combination of them that
|
|
|
2322 looks good for highlighted text is chosen as the @dfn{standout mode}. The
|
|
|
2323 capabilities @samp{so} and @samp{se} say how to enter and leave standout
|
|
|
2324 mode. Programs that use appearance modes only to highlight some text
|
|
|
2325 generally use the standout mode so that they can work on as many terminals
|
|
|
2326 as possible. Use of specific appearance modes other than ``underlined''
|
|
|
2327 and ``alternate character set'' is rare.
|
|
|
2328
|
|
|
2329 Terminals that implement appearance modes fall into two general classes as
|
|
|
2330 to how they do it.
|
|
|
2331
|
|
|
2332 In some terminals, the presence or absence of any appearance mode is
|
|
|
2333 recorded separately for each character position. In these terminals, each
|
|
|
2334 graphic character written is given the appearance modes current at the time
|
|
|
2335 it is written, and keeps those modes until it is erased or overwritten.
|
|
|
2336 There are special commands to turn the appearance modes on or off for
|
|
|
2337 characters to be written in the future.
|
|
|
2338
|
|
|
2339 In other terminals, the change of appearance modes is represented by a
|
|
|
2340 marker that belongs to a certain screen position but affects all following
|
|
|
2341 screen positions until the next marker. These markers are traditionally
|
|
|
2342 called @dfn{magic cookies}.
|
|
|
2343
|
|
|
2344 The same capabilities (@samp{so}, @samp{se}, @samp{mb} and so on) for
|
|
|
2345 turning appearance modes on and off are used for both magic-cookie
|
|
|
2346 terminals and per-character terminals. On magic cookie terminals, these
|
|
|
2347 give the commands to write the magic cookies. On per-character terminals,
|
|
|
2348 they change the current modes that affect future output and erasure. Some
|
|
|
2349 simple applications can use these commands without knowing whether or not
|
|
|
2350 they work by means of cookies.
|
|
|
2351
|
|
|
2352 However, a program that maintains and updates a display needs to know
|
|
|
2353 whether the terminal uses magic cookies, and exactly what their effect is.
|
|
|
2354 This information comes from the @samp{sg} capability.
|
|
|
2355
|
|
|
2356 The @samp{sg} capability is a numeric capability whose presence indicates
|
|
|
2357 that the terminal uses magic cookies for appearance modes. Its value is
|
|
|
2358 the number of character positions that a magic cookie occupies. Usually
|
|
|
2359 the cookie occupies one or more character positions on the screen, and these
|
|
|
2360 character positions are displayed as blank, but in some terminals the
|
|
|
2361 cookie has zero width.
|
|
|
2362
|
|
|
2363 The @samp{sg} capability describes both the magic cookie to turn standout
|
|
|
2364 on and the cookie to turn it off. This makes the assumption that both
|
|
|
2365 kinds of cookie have the same width on the screen. If that is not true,
|
|
|
2366 the narrower cookie must be ``widened'' with spaces until it has the same
|
|
|
2367 width as the other.
|
|
|
2368
|
|
|
2369 On some magic cookie terminals, each line always starts with normal
|
|
|
2370 display; in other words, the scope of a magic cookie never extends over
|
|
|
2371 more than one line. But on other terminals, one magic cookie affects all
|
|
|
2372 the lines below it unless explicitly canceled. Termcap does not define any
|
|
|
2373 way to distinguish these two ways magic cookies can work. To be safe, it
|
|
|
2374 is best to put a cookie at the beginning of each line.
|
|
|
2375
|
|
|
2376 On some per-character terminals, standout mode or other appearance modes
|
|
|
2377 may be canceled by moving the cursor. On others, moving the cursor has no
|
|
|
2378 effect on the state of the appearance modes. The latter class of terminals
|
|
|
2379 are given the flag capability @samp{ms} (``can move in standout''). All
|
|
|
2380 programs that might have occasion to move the cursor while appearance modes
|
|
|
2381 are turned on must check for this flag; if it is not present, they should
|
|
|
2382 reset appearance modes to normal before doing cursor motion.
|
|
|
2383
|
|
|
2384 A program that has turned on only standout mode should use @samp{se} to
|
|
|
2385 reset the standout mode to normal. A program that has turned on only
|
|
|
2386 alternate character set mode should use @samp{ae} to return it to normal.
|
|
|
2387 If it is possible that any other appearance modes are turned on, use the
|
|
|
2388 @samp{me} capability to return them to normal.
|
|
|
2389
|
|
|
2390 Note that the commands to turn on one appearance mode, including @samp{so}
|
|
|
2391 and @samp{mb} @dots{} @samp{mr}, if used while some other appearance modes
|
|
|
2392 are turned on, may combine the two modes on some terminals but may turn off
|
|
|
2393 the mode previously enabled on other terminals. This is because some
|
|
|
2394 terminals do not have a command to set or clear one appearance mode without
|
|
|
2395 changing the others. Programs should not attempt to use appearance modes
|
|
|
2396 in combination except with @samp{sa}, and when switching from one single
|
|
|
2397 mode to another should always turn off the previously enabled mode and then
|
|
|
2398 turn on the new desired mode.
|
|
|
2399
|
|
|
2400 On some old terminals, the @samp{so} and @samp{se} commands may be the same
|
|
|
2401 command, which has the effect of turning standout on if it is off, or off
|
|
|
2402 it is on. It is therefore risky for a program to output extra @samp{se}
|
|
|
2403 commands for good measure. Fortunately, all these terminals are obsolete.
|
|
|
2404
|
|
|
2405 Programs that update displays in which standout-text may be replaced with
|
|
|
2406 non-standout text must check for the @samp{xs} flag. In a per-character
|
|
|
2407 terminal, this flag says that the only way to remove standout once written is
|
|
|
2408 to clear that portion of the line with the @samp{ce} string or something
|
|
|
2409 even more powerful (@pxref{Clearing}); just writing new characters at those
|
|
|
2410 screen positions will not change the modes in effect there. In a magic
|
|
|
2411 cookie terminal, @samp{xs} says that the only way to remove a cookie is to
|
|
|
2412 clear a portion of the line that includes the cookie; writing a different
|
|
|
2413 cookie at the same position does not work.
|
|
|
2414
|
|
|
2415 Such programs must also check for the @samp{xt} flag, which means that the
|
|
|
2416 terminal is a Teleray 1061. On this terminal it is impossible to position
|
|
|
2417 the cursor at the front of a magic cookie, so the only two ways to remove a
|
|
|
2418 cookie are (1) to delete the line it is on or (2) to position the cursor at
|
|
|
2419 least one character before it (possibly on a previous line) and output the
|
|
|
2420 @samp{se} string, which on these terminals finds and removes the next
|
|
|
2421 @samp{so} magic cookie on the screen. (It may also be possible to remove a
|
|
|
2422 cookie which is not at the beginning of a line by clearing that line.) The
|
|
|
2423 @samp{xt} capability also has implications for the use of tab characters,
|
|
|
2424 but in that regard it is obsolete (@pxref{Cursor Motion}).
|
|
|
2425
|
|
|
2426 @table @samp
|
|
|
2427 @item so
|
|
|
2428 @kindex so
|
|
|
2429 String of commands to enter standout mode.
|
|
|
2430
|
|
|
2431 @item se
|
|
|
2432 @kindex se
|
|
|
2433 String of commands to leave standout mode.
|
|
|
2434
|
|
|
2435 @item sg
|
|
|
2436 @kindex sg
|
|
|
2437 Numeric capability, the width on the screen of the magic cookie. This
|
|
|
2438 capability is absent in terminals that record appearance modes
|
|
|
2439 character by character.
|
|
|
2440
|
|
|
2441 @item ms
|
|
|
2442 @kindex ms
|
|
|
2443 Flag whose presence means that it is safe to move the cursor while the
|
|
|
2444 appearance modes are not in the normal state. If this flag is absent,
|
|
|
2445 programs should always reset the appearance modes to normal before
|
|
|
2446 moving the cursor.
|
|
|
2447
|
|
|
2448 @item xs
|
|
|
2449 @kindex xs
|
|
|
2450 Flag whose presence means that the only way to reset appearance modes
|
|
|
2451 already on the screen is to clear to end of line. On a per-character
|
|
|
2452 terminal, you must clear the area where the modes are set. On a magic
|
|
|
2453 cookie terminal, you must clear an area containing the cookie.
|
|
|
2454 See the discussion above.
|
|
|
2455
|
|
|
2456 @item xt
|
|
|
2457 @kindex xt
|
|
|
2458 Flag whose presence means that the cursor cannot be positioned right
|
|
|
2459 in front of a magic cookie, and that @samp{se} is a command to delete
|
|
|
2460 the next magic cookie following the cursor. See discussion above.
|
|
|
2461
|
|
|
2462 @item mb
|
|
|
2463 @kindex mb
|
|
|
2464 String of commands to enter blinking mode.
|
|
|
2465
|
|
|
2466 @item md
|
|
|
2467 @kindex md
|
|
|
2468 String of commands to enter double-bright mode.
|
|
|
2469
|
|
|
2470 @item mh
|
|
|
2471 @kindex mh
|
|
|
2472 String of commands to enter half-bright mode.
|
|
|
2473
|
|
|
2474 @item mk
|
|
|
2475 @kindex mk
|
|
|
2476 String of commands to enter invisible mode.
|
|
|
2477
|
|
|
2478 @item mp
|
|
|
2479 @kindex mp
|
|
|
2480 String of commands to enter protected mode.
|
|
|
2481
|
|
|
2482 @item mr
|
|
|
2483 @kindex mr
|
|
|
2484 String of commands to enter reverse-video mode.
|
|
|
2485
|
|
|
2486 @item me
|
|
|
2487 @kindex me
|
|
|
2488 String of commands to turn off all appearance modes, including
|
|
|
2489 standout mode and underline mode. On some terminals it also turns off
|
|
|
2490 alternate character set mode; on others, it may not. This capability
|
|
|
2491 must be present if any of @samp{mb} @dots{} @samp{mr} is present.
|
|
|
2492
|
|
|
2493 @item as
|
|
|
2494 @kindex as
|
|
|
2495 String of commands to turn on alternate character set mode. This mode
|
|
|
2496 assigns some or all graphic characters an alternate picture on the
|
|
|
2497 screen. There is no standard as to what the alternate pictures look
|
|
|
2498 like.
|
|
|
2499
|
|
|
2500 @item ae
|
|
|
2501 @kindex ae
|
|
|
2502 String of commands to turn off alternate character set mode.
|
|
|
2503
|
|
|
2504 @item sa
|
|
|
2505 @kindex sa
|
|
|
2506 String of commands to turn on an arbitrary combination of appearance
|
|
|
2507 modes. It accepts 9 parameters, each of which controls a particular
|
|
|
2508 kind of appearance mode. A parameter should be 1 to turn its appearance
|
|
|
2509 mode on, or zero to turn that mode off. Most terminals do not support
|
|
|
2510 the @samp{sa} capability, even among those that do have various
|
|
|
2511 appearance modes.
|
|
|
2512
|
|
|
2513 The nine parameters are, in order, @var{standout}, @var{underline},
|
|
|
2514 @var{reverse}, @var{blink}, @var{half-bright}, @var{double-bright},
|
|
|
2515 @var{blank}, @var{protect}, @var{alt char set}.
|
|
|
2516 @end table
|
|
|
2517
|
|
|
2518 @node Underlining, Cursor Visibility, Standout, Capabilities
|
|
|
2519 @section Underlining
|
|
|
2520 @cindex underlining
|
|
|
2521
|
|
|
2522 Underlining on most terminals is a kind of appearance mode, much like
|
|
|
2523 standout mode. Therefore, it may be implemented using magic cookies or as
|
|
|
2524 a flag in the terminal whose current state affects each character that is
|
|
|
2525 output. @xref{Standout}, for a full explanation.
|
|
|
2526
|
|
|
2527 The @samp{ug} capability is a numeric capability whose presence indicates
|
|
|
2528 that the terminal uses magic cookies for underlining. Its value is the
|
|
|
2529 number of character positions that a magic cookie for underlining occupies;
|
|
|
2530 it is used for underlining just as @samp{sg} is used for standout. Aside
|
|
|
2531 from the simplest applications, it is impossible to use underlining
|
|
|
2532 correctly without paying attention to the value of @samp{ug}.
|
|
|
2533
|
|
|
2534 @table @samp
|
|
|
2535 @item us
|
|
|
2536 @kindex us
|
|
|
2537 String of commands to turn on underline mode or to output a magic cookie
|
|
|
2538 to start underlining.
|
|
|
2539
|
|
|
2540 @item ue
|
|
|
2541 @kindex ue
|
|
|
2542 String of commands to turn off underline mode or to output a magic
|
|
|
2543 cookie to stop underlining.
|
|
|
2544
|
|
|
2545 @item ug
|
|
|
2546 @kindex ug
|
|
|
2547 Width of magic cookie that represents a change of underline mode;
|
|
|
2548 or missing, if the terminal does not use a magic cookie for this.
|
|
|
2549
|
|
|
2550 @item ms
|
|
|
2551 @kindex ms
|
|
|
2552 Flag whose presence means that it is safe to move the cursor while the
|
|
|
2553 appearance modes are not in the normal state. Underlining is an
|
|
|
2554 appearance mode. If this flag is absent, programs should always turn
|
|
|
2555 off underlining before moving the cursor.
|
|
|
2556 @end table
|
|
|
2557
|
|
|
2558 There are two other, older ways of doing underlining: there can be a
|
|
|
2559 command to underline a single character, or the output of @samp{_}, the
|
|
|
2560 ASCII underscore character, as an overstrike could cause a character to be
|
|
|
2561 underlined. New programs need not bother to handle these capabilities
|
|
|
2562 unless the author cares strongly about the obscure terminals which support
|
|
|
2563 them. However, terminal descriptions should provide these capabilities
|
|
|
2564 when appropriate.
|
|
|
2565
|
|
|
2566 @table @samp
|
|
|
2567 @item uc
|
|
|
2568 @kindex uc
|
|
|
2569 String of commands to underline the character under the cursor, and
|
|
|
2570 move the cursor right.
|
|
|
2571
|
|
|
2572 @item ul
|
|
|
2573 @kindex ul
|
|
|
2574 Flag whose presence means that the terminal can underline by
|
|
|
2575 overstriking an underscore character (@samp{_}); some terminals can do
|
|
|
2576 this even though they do not support overstriking in general. An
|
|
|
2577 implication of this flag is that when outputting new text to overwrite
|
|
|
2578 old text, underscore characters must be treated specially lest they
|
|
|
2579 underline the old text instead.
|
|
|
2580 @end table
|
|
|
2581
|
|
|
2582 @node Cursor Visibility, Bell, Underlining, Capabilities
|
|
|
2583 @section Cursor Visibility
|
|
|
2584 @cindex visibility
|
|
|
2585
|
|
|
2586 Some terminals have the ability to make the cursor invisible, or to enhance
|
|
|
2587 it. Enhancing the cursor is often done by programs that plan to use the
|
|
|
2588 cursor to indicate to the user a position of interest that may be anywhere
|
|
|
2589 on the screen---for example, the Emacs editor enhances the cursor on entry.
|
|
|
2590 Such programs should always restore the cursor to normal on exit.
|
|
|
2591
|
|
|
2592 @table @samp
|
|
|
2593 @item vs
|
|
|
2594 @kindex vs
|
|
|
2595 String of commands to enhance the cursor.
|
|
|
2596
|
|
|
2597 @item vi
|
|
|
2598 @kindex vi
|
|
|
2599 String of commands to make the cursor invisible.
|
|
|
2600
|
|
|
2601 @item ve
|
|
|
2602 @kindex ve
|
|
|
2603 String of commands to return the cursor to normal.
|
|
|
2604 @end table
|
|
|
2605
|
|
|
2606 If you define either @samp{vs} or @samp{vi}, you must also define @samp{ve}.
|
|
|
2607
|
|
|
2608 @node Bell, Keypad, Cursor Visibility, Capabilities
|
|
|
2609 @section Bell
|
|
|
2610 @cindex bell
|
|
|
2611 @cindex visible bell
|
|
|
2612
|
|
|
2613 Here we describe commands to make the terminal ask for the user to pay
|
|
|
2614 attention to it.
|
|
|
2615
|
|
|
2616 @table @samp
|
|
|
2617 @item bl
|
|
|
2618 @kindex bl
|
|
|
2619 String of commands to cause the terminal to make an audible sound. If
|
|
|
2620 this capability is absent, the terminal has no way to make a suitable
|
|
|
2621 sound.
|
|
|
2622
|
|
|
2623 @item vb
|
|
|
2624 @kindex vb
|
|
|
2625 String of commands to cause the screen to flash to attract attention
|
|
|
2626 (``visible bell''). If this capability is absent, the terminal has no
|
|
|
2627 way to do such a thing.
|
|
|
2628 @end table
|
|
|
2629
|
|
|
2630 @node Keypad, Meta Key, Bell, Capabilities
|
|
|
2631 @section Keypad and Function Keys
|
|
|
2632
|
|
|
2633 Many terminals have arrow and function keys that transmit specific
|
|
|
2634 character sequences to the computer. Since the precise sequences used
|
|
|
2635 depend on the terminal, termcap defines capabilities used to say what the
|
|
|
2636 sequences are. Unlike most termcap string-valued capabilities, these are
|
|
|
2637 not strings of commands to be sent to the terminal, rather strings that
|
|
|
2638 are received from the terminal.
|
|
|
2639
|
|
|
2640 Programs that expect to use keypad keys should check, initially, for a
|
|
|
2641 @samp{ks} capability and send it, to make the keypad actually transmit.
|
|
|
2642 Such programs should also send the @samp{ke} string when exiting.
|
|
|
2643
|
|
|
2644 @table @asis
|
|
|
2645 @item @samp{ks}
|
|
|
2646 @kindex ka@dots{}ku
|
|
|
2647 String of commands to make the function keys transmit. If this
|
|
|
2648 capability is not provided, but the others in this section are,
|
|
|
2649 programs may assume that the function keys always transmit.
|
|
|
2650
|
|
|
2651 @item @samp{ke}
|
|
|
2652 String of commands to make the function keys work locally. This
|
|
|
2653 capability is provided only if @samp{ks} is.
|
|
|
2654
|
|
|
2655 @item @samp{kl}
|
|
|
2656 String of input characters sent by typing the left-arrow key. If this
|
|
|
2657 capability is missing, you cannot expect the terminal to have a
|
|
|
2658 left-arrow key that transmits anything to the computer.
|
|
|
2659
|
|
|
2660 @item @samp{kr}
|
|
|
2661 String of input characters sent by typing the right-arrow key.
|
|
|
2662
|
|
|
2663 @item @samp{ku}
|
|
|
2664 String of input characters sent by typing the up-arrow key.
|
|
|
2665
|
|
|
2666 @item @samp{kd}
|
|
|
2667 String of input characters sent by typing the down-arrow key.
|
|
|
2668
|
|
|
2669 @item @samp{kh}
|
|
|
2670 String of input characters sent by typing the ``home-position'' key.
|
|
|
2671
|
|
|
2672 @item @samp{K1} @dots{} @samp{K5}
|
|
|
2673 @kindex K1@dots{}K5
|
|
|
2674 Strings of input characters sent by the five other keys in a 3-by-3
|
|
|
2675 array that includes the arrow keys, if the keyboard has such a 3-by-3
|
|
|
2676 array. Note that one of these keys may be the ``home-position'' key,
|
|
|
2677 in which case one of these capabilities will have the same value as
|
|
|
2678 the @samp{kh} key.
|
|
|
2679
|
|
|
2680 @item @samp{k0}
|
|
|
2681 String of input characters sent by function key 10 (or 0, if the terminal
|
|
|
2682 has one labeled 0).
|
|
|
2683
|
|
|
2684 @item @samp{k1} @dots{} @samp{k9}
|
|
|
2685 @kindex k1@dots{}k9
|
|
|
2686 Strings of input characters sent by function keys 1 through 9,
|
|
|
2687 provided for those function keys that exist.
|
|
|
2688
|
|
|
2689 @item @samp{kn}
|
|
|
2690 Number: the number of numbered function keys, if there are more than
|
|
|
2691 10.
|
|
|
2692
|
|
|
2693 @item @samp{l0} @dots{} @samp{l9}
|
|
|
2694 @kindex l0@dots{}l9
|
|
|
2695 Strings which are the labels appearing on the keyboard on the keys
|
|
|
2696 described by the capabilities @samp{k0} @dots{} @samp{l9}. These
|
|
|
2697 capabilities should be left undefined if the labels are @samp{f0} or
|
|
|
2698 @samp{f10} and @samp{f1} @dots{} @samp{f9}.@refill
|
|
|
2699
|
|
|
2700 @item @samp{kH}
|
|
|
2701 @kindex kA@dots{}kT
|
|
|
2702 String of input characters sent by the ``home down'' key, if there is
|
|
|
2703 one.
|
|
|
2704
|
|
|
2705 @item @samp{kb}
|
|
|
2706 String of input characters sent by the ``backspace'' key, if there is
|
|
|
2707 one.
|
|
|
2708
|
|
|
2709 @item @samp{ka}
|
|
|
2710 String of input characters sent by the ``clear all tabs'' key, if there
|
|
|
2711 is one.
|
|
|
2712
|
|
|
2713 @item @samp{kt}
|
|
|
2714 String of input characters sent by the ``clear tab stop this column''
|
|
|
2715 key, if there is one.
|
|
|
2716
|
|
|
2717 @item @samp{kC}
|
|
|
2718 String of input characters sent by the ``clear screen'' key, if there is
|
|
|
2719 one.
|
|
|
2720
|
|
|
2721 @item @samp{kD}
|
|
|
2722 String of input characters sent by the ``delete character'' key, if
|
|
|
2723 there is one.
|
|
|
2724
|
|
|
2725 @item @samp{kL}
|
|
|
2726 String of input characters sent by the ``delete line'' key, if there is
|
|
|
2727 one.
|
|
|
2728
|
|
|
2729 @item @samp{kM}
|
|
|
2730 String of input characters sent by the ``exit insert mode'' key, if
|
|
|
2731 there is one.
|
|
|
2732
|
|
|
2733 @item @samp{kE}
|
|
|
2734 String of input characters sent by the ``clear to end of line'' key, if
|
|
|
2735 there is one.
|
|
|
2736
|
|
|
2737 @item @samp{kS}
|
|
|
2738 String of input characters sent by the ``clear to end of screen'' key,
|
|
|
2739 if there is one.
|
|
|
2740
|
|
|
2741 @item @samp{kI}
|
|
|
2742 String of input characters sent by the ``insert character'' or ``enter
|
|
|
2743 insert mode'' key, if there is one.
|
|
|
2744
|
|
|
2745 @item @samp{kA}
|
|
|
2746 String of input characters sent by the ``insert line'' key, if there is
|
|
|
2747 one.
|
|
|
2748
|
|
|
2749 @item @samp{kN}
|
|
|
2750 String of input characters sent by the ``next page'' key, if there is
|
|
|
2751 one.
|
|
|
2752
|
|
|
2753 @item @samp{kP}
|
|
|
2754 String of input characters sent by the ``previous page'' key, if there is
|
|
|
2755 one.
|
|
|
2756
|
|
|
2757 @item @samp{kF}
|
|
|
2758 String of input characters sent by the ``scroll forward'' key, if there
|
|
|
2759 is one.
|
|
|
2760
|
|
|
2761 @item @samp{kR}
|
|
|
2762 String of input characters sent by the ``scroll reverse'' key, if there
|
|
|
2763 is one.
|
|
|
2764
|
|
|
2765 @item @samp{kT}
|
|
|
2766 String of input characters sent by the ``set tab stop in this column''
|
|
|
2767 key, if there is one.
|
|
|
2768
|
|
|
2769 @item @samp{ko}
|
|
|
2770 String listing the other function keys the terminal has. This is a
|
|
|
2771 very obsolete way of describing the same information found in the
|
|
|
2772 @samp{kH} @dots{} @samp{kT} keys. The string contains a list of
|
|
|
2773 two-character termcap capability names, separated by commas. The
|
|
|
2774 meaning is that for each capability name listed, the terminal has a
|
|
|
2775 key which sends the string which is the value of that capability. For
|
|
|
2776 example, the value @samp{:ko=cl,ll,sf,sr:} says that the terminal has
|
|
|
2777 four function keys which mean ``clear screen'', ``home down'',
|
|
|
2778 ``scroll forward'' and ``scroll reverse''.@refill
|
|
|
2779 @end table
|
|
|
2780
|
|
|
2781 @node Meta Key, Initialization, Keypad, Capabilities
|
|
|
2782 @section Meta Key
|
|
|
2783
|
|
|
2784 @cindex meta key
|
|
|
2785 A Meta key is a key on the keyboard that modifies each character you type
|
|
|
2786 by controlling the 0200 bit. This bit is on if and only if the Meta key is
|
|
|
2787 held down when the character is typed. Characters typed using the Meta key
|
|
|
2788 are called Meta characters. Emacs uses Meta characters as editing
|
|
|
2789 commands.
|
|
|
2790
|
|
|
2791 @table @samp
|
|
|
2792 @item km
|
|
|
2793 @kindex km
|
|
|
2794 Flag whose presence means that the terminal has a Meta key.
|
|
|
2795
|
|
|
2796 @item mm
|
|
|
2797 @kindex mm
|
|
|
2798 String of commands to enable the functioning of the Meta key.
|
|
|
2799
|
|
|
2800 @item mo
|
|
|
2801 @kindex mo
|
|
|
2802 String of commands to disable the functioning of the Meta key.
|
|
|
2803 @end table
|
|
|
2804
|
|
|
2805 If the terminal has @samp{km} but does not have @samp{mm} and @samp{mo}, it
|
|
|
2806 means that the Meta key always functions. If it has @samp{mm} and
|
|
|
2807 @samp{mo}, it means that the Meta key can be turned on or off. Send the
|
|
|
2808 @samp{mm} string to turn it on, and the @samp{mo} string to turn it off.
|
|
|
2809 I do not know why one would ever not want it to be on.
|
|
|
2810
|
|
|
2811 @node Initialization, Pad Specs, Meta Key, Capabilities
|
|
|
2812 @section Initialization
|
|
|
2813 @cindex reset
|
|
|
2814 @cindex initialization
|
|
|
2815 @cindex tab stops
|
|
|
2816
|
|
|
2817 @table @samp
|
|
|
2818 @item ti
|
|
|
2819 @kindex ti
|
|
|
2820 String of commands to put the terminal into whatever special modes are
|
|
|
2821 needed or appropriate for programs that move the cursor
|
|
|
2822 nonsequentially around the screen. Programs that use termcap to do
|
|
|
2823 full-screen display should output this string when they start up.
|
|
|
2824
|
|
|
2825 @item te
|
|
|
2826 @kindex te
|
|
|
2827 String of commands to undo what is done by the @samp{ti} string.
|
|
|
2828 Programs that output the @samp{ti} string on entry should output this
|
|
|
2829 string when they exit.
|
|
|
2830
|
|
|
2831 @item is
|
|
|
2832 @kindex is
|
|
|
2833 String of commands to initialize the terminal for each login session.
|
|
|
2834
|
|
|
2835 @item if
|
|
|
2836 @kindex if
|
|
|
2837 String which is the name of a file containing the string of commands
|
|
|
2838 to initialize the terminal for each session of use. Normally @samp{is}
|
|
|
2839 and @samp{if} are not both used.
|
|
|
2840
|
|
|
2841 @item i1
|
|
|
2842 @itemx i3
|
|
|
2843 @kindex i1
|
|
|
2844 @kindex i3
|
|
|
2845 Two more strings of commands to initialize the terminal for each login
|
|
|
2846 session. The @samp{i1} string (if defined) is output before @samp{is}
|
|
|
2847 or @samp{if}, and the @samp{i3} string (if defined) is output after.
|
|
|
2848
|
|
|
2849 The reason for having three separate initialization strings is to make
|
|
|
2850 it easier to define a group of related terminal types with slightly
|
|
|
2851 different initializations. Define two or three of the strings in the
|
|
|
2852 basic type; then the other types can override one or two of the
|
|
|
2853 strings.
|
|
|
2854
|
|
|
2855 @item rs
|
|
|
2856 @kindex rs
|
|
|
2857 String of commands to reset the terminal from any strange mode it may
|
|
|
2858 be in. Normally this includes the @samp{is} string (or other commands
|
|
|
2859 with the same effects) and more. What would go in the @samp{rs}
|
|
|
2860 string but not in the @samp{is} string are annoying or slow commands
|
|
|
2861 to bring the terminal back from strange modes that nobody would
|
|
|
2862 normally use.
|
|
|
2863
|
|
|
2864 @item it
|
|
|
2865 @kindex it
|
|
|
2866 Numeric value, the initial spacing between hardware tab stop columns
|
|
|
2867 when the terminal is powered up. Programs to initialize the terminal
|
|
|
2868 can use this to decide whether there is a need to set the tab stops.
|
|
|
2869 If the initial width is 8, well and good; if it is not 8, then the
|
|
|
2870 tab stops should be set; if they cannot be set, the kernel is told
|
|
|
2871 to convert tabs to spaces, and other programs will observe this and do
|
|
|
2872 likewise.
|
|
|
2873
|
|
|
2874 @item ct
|
|
|
2875 @kindex ct
|
|
|
2876 String of commands to clear all tab stops.
|
|
|
2877
|
|
|
2878 @item st
|
|
|
2879 @kindex st
|
|
|
2880 String of commands to set tab stop at current cursor column on all
|
|
|
2881 lines.
|
|
|
2882 @end table
|
|
|
2883
|
|
|
2884 @node Pad Specs, Status Line, Initialization, Capabilities
|
|
|
2885 @section Padding Capabilities
|
|
|
2886 @cindex padding
|
|
|
2887
|
|
|
2888 There are two terminal capabilities that exist just to explain the proper
|
|
|
2889 way to obey the padding specifications in all the command string
|
|
|
2890 capabilities. One, @samp{pc}, must be obeyed by all termcap-using
|
|
|
2891 programs.
|
|
|
2892
|
|
|
2893 @table @samp
|
|
|
2894 @item pb
|
|
|
2895 @kindex pb
|
|
|
2896 Numeric value, the lowest baud rate at which padding is actually
|
|
|
2897 needed. Programs may check this and refrain from doing any padding at
|
|
|
2898 lower speeds.
|
|
|
2899
|
|
|
2900 @item pc
|
|
|
2901 @kindex pc
|
|
|
2902 String of commands for padding. The first character of this string is
|
|
|
2903 to be used as the pad character, instead of using null characters for
|
|
|
2904 padding. If @samp{pc} is not provided, use null characters. Every
|
|
|
2905 program that uses termcap must look up this capability and use it to
|
|
|
2906 set the variable @code{PC} that is used by @code{tputs}.
|
|
|
2907 @xref{Padding}.
|
|
|
2908 @end table
|
|
|
2909
|
|
|
2910 Some termcap capabilities exist just to specify the amount of padding that
|
|
|
2911 the kernel should give to cursor motion commands used in ordinary
|
|
|
2912 sequential output.
|
|
|
2913
|
|
|
2914 @table @samp
|
|
|
2915 @item dC
|
|
|
2916 @kindex dC
|
|
|
2917 Numeric value, the number of msec of padding needed for the
|
|
|
2918 carriage-return character.
|
|
|
2919
|
|
|
2920 @item dN
|
|
|
2921 @kindex dN
|
|
|
2922 Numeric value, the number of msec of padding needed for the newline
|
|
|
2923 (linefeed) character.
|
|
|
2924
|
|
|
2925 @item dB
|
|
|
2926 @kindex dB
|
|
|
2927 Numeric value, the number of msec of padding needed for the backspace
|
|
|
2928 character.
|
|
|
2929
|
|
|
2930 @item dF
|
|
|
2931 @kindex dF
|
|
|
2932 Numeric value, the number of msec of padding needed for the formfeed
|
|
|
2933 character.
|
|
|
2934
|
|
|
2935 @item dT
|
|
|
2936 @kindex dT
|
|
|
2937 Numeric value, the number of msec of padding needed for the tab
|
|
|
2938 character.
|
|
|
2939 @end table
|
|
|
2940
|
|
|
2941 In some systems, the kernel uses the above capabilities; in other systems,
|
|
|
2942 the kernel uses the paddings specified in the string capabilities
|
|
|
2943 @samp{cr}, @samp{sf}, @samp{le}, @samp{ff} and @samp{ta}. Descriptions of
|
|
|
2944 terminals which require such padding should contain the @samp{dC} @dots{}
|
|
|
2945 @samp{dT} capabilities and also specify the appropriate padding in the
|
|
|
2946 corresponding string capabilities. Since no modern terminals require
|
|
|
2947 padding for ordinary sequential output, you probably won't need to do
|
|
|
2948 either of these things.
|
|
|
2949
|
|
|
2950 @node Status Line, Half-Line, Pad Specs, Capabilities
|
|
|
2951 @section Status Line
|
|
|
2952
|
|
|
2953 @cindex status line
|
|
|
2954 A @dfn{status line} is a line on the terminal that is not used for ordinary
|
|
|
2955 display output but instead used for a special message. The intended use is
|
|
|
2956 for a continuously updated description of what the user's program is doing,
|
|
|
2957 and that is where the name ``status line'' comes from, but in fact it could
|
|
|
2958 be used for anything. The distinguishing characteristic of a status line
|
|
|
2959 is that ordinary output to the terminal does not affect it; it changes only
|
|
|
2960 if the special status line commands of this section are used.
|
|
|
2961
|
|
|
2962 @table @samp
|
|
|
2963 @item hs
|
|
|
2964 @kindex hs
|
|
|
2965 Flag whose presence means that the terminal has a status line. If a
|
|
|
2966 terminal description specifies that there is a status line, it must
|
|
|
2967 provide the @samp{ts} and @samp{fs} capabilities.
|
|
|
2968
|
|
|
2969 @item ts
|
|
|
2970 @kindex ts
|
|
|
2971 String of commands to move the terminal cursor into the status line.
|
|
|
2972 Usually these commands must specifically record the old cursor
|
|
|
2973 position for the sake of the @samp{fs} string.
|
|
|
2974
|
|
|
2975 @item fs
|
|
|
2976 @kindex fs
|
|
|
2977 String of commands to move the cursor back from the status line to its
|
|
|
2978 previous position (outside the status line).
|
|
|
2979
|
|
|
2980 @item es
|
|
|
2981 @kindex es
|
|
|
2982 Flag whose presence means that other display commands work while
|
|
|
2983 writing the status line. In other words, one can clear parts of it,
|
|
|
2984 insert or delete characters, move the cursor within it using @samp{ch}
|
|
|
2985 if there is a @samp{ch} capability, enter and leave standout mode, and
|
|
|
2986 so on.
|
|
|
2987
|
|
|
2988 @item ds
|
|
|
2989 @kindex ds
|
|
|
2990 String of commands to disable the display of the status line. This
|
|
|
2991 may be absent, if there is no way to disable the status line display.
|
|
|
2992
|
|
|
2993 @item ws
|
|
|
2994 @kindex ws
|
|
|
2995 Numeric value, the width of the status line. If this capability is
|
|
|
2996 absent in a terminal that has a status line, it means the status line
|
|
|
2997 is the same width as the other lines.
|
|
|
2998
|
|
|
2999 Note that the value of @samp{ws} is sometimes as small as 8.
|
|
|
3000 @end table
|
|
|
3001
|
|
|
3002 @node Half-Line, Printer, Status Line, Capabilities
|
|
|
3003 @section Half-Line Motion
|
|
|
3004
|
|
|
3005 Some terminals have commands for moving the cursor vertically by half-lines,
|
|
|
3006 useful for outputting subscripts and superscripts. Mostly it is hardcopy
|
|
|
3007 terminals that have such features.
|
|
|
3008
|
|
|
3009 @table @samp
|
|
|
3010 @item hu
|
|
|
3011 @kindex hu
|
|
|
3012 String of commands to move the cursor up half a line. If the terminal
|
|
|
3013 is a display, it is your responsibility to avoid moving up past the
|
|
|
3014 top line; however, most likely the terminal that supports this is a
|
|
|
3015 hardcopy terminal and there is nothing to be concerned about.
|
|
|
3016
|
|
|
3017 @item hd
|
|
|
3018 @kindex hd
|
|
|
3019 String of commands to move the cursor down half a line. If the
|
|
|
3020 terminal is a display, it is your responsibility to avoid moving down
|
|
|
3021 past the bottom line, etc.
|
|
|
3022 @end table
|
|
|
3023
|
|
|
3024 @node Printer,, Half-Line, Capabilities
|
|
|
3025 @section Controlling Printers Attached to Terminals
|
|
|
3026 @cindex printer
|
|
|
3027
|
|
|
3028 Some terminals have attached hardcopy printer ports. They may be able to
|
|
|
3029 copy the screen contents to the printer; they may also be able to redirect
|
|
|
3030 output to the printer. Termcap does not have anything to tell the program
|
|
|
3031 whether the redirected output appears also on the screen; it does on some
|
|
|
3032 terminals but not all.
|
|
|
3033
|
|
|
3034 @table @samp
|
|
|
3035 @item ps
|
|
|
3036 @kindex ps
|
|
|
3037 String of commands to cause the contents of the screen to be printed.
|
|
|
3038 If it is absent, the screen contents cannot be printed.
|
|
|
3039
|
|
|
3040 @item po
|
|
|
3041 @kindex po
|
|
|
3042 String of commands to redirect further output to the printer.
|
|
|
3043
|
|
|
3044 @item pf
|
|
|
3045 @kindex pf
|
|
|
3046 String of commands to terminate redirection of output to the printer.
|
|
|
3047 This capability must be present in the description if @samp{po} is.
|
|
|
3048
|
|
|
3049 @item pO
|
|
|
3050 @kindex pO
|
|
|
3051 String of commands to redirect output to the printer for next @var{n}
|
|
|
3052 characters of output, regardless of what they are. Redirection will
|
|
|
3053 end automatically after @var{n} characters of further output. Until
|
|
|
3054 then, nothing that is output can end redirection, not even the
|
|
|
3055 @samp{pf} string if there is one. The number @var{n} should not be
|
|
|
3056 more than 255.
|
|
|
3057
|
|
|
3058 One use of this capability is to send non-text byte sequences (such as
|
|
|
3059 bit-maps) to the printer.
|
|
|
3060 @end table
|
|
|
3061
|
|
|
3062 Most terminals with printers do not support all of @samp{ps}, @samp{po} and
|
|
|
3063 @samp{pO}; any one or two of them may be supported. To make a program that
|
|
|
3064 can send output to all kinds of printers, it is necessary to check for all
|
|
|
3065 three of these capabilities, choose the most convenient of the ones that
|
|
|
3066 are provided, and use it in its own appropriate fashion.
|
|
|
3067
|
|
|
3068 @node Summary, Var Index, Capabilities, Top
|
|
|
3069 @chapter Summary of Capability Names
|
|
|
3070
|
|
|
3071 Here are all the terminal capability names in alphabetical order
|
|
|
3072 with a brief description of each. For cross references to their definitions,
|
|
|
3073 see the index of capability names (@pxref{Cap Index}).
|
|
|
3074
|
|
|
3075 @table @samp
|
|
|
3076 @item ae
|
|
|
3077 String to turn off alternate character set mode.
|
|
|
3078 @item al
|
|
|
3079 String to insert a blank line before the cursor.
|
|
|
3080 @item AL
|
|
|
3081 String to insert @var{n} blank lines before the cursor.
|
|
|
3082 @item am
|
|
|
3083 Flag: output to last column wraps cursor to next line.
|
|
|
3084 @item as
|
|
|
3085 String to turn on alternate character set mode.like.
|
|
|
3086 @item bc
|
|
|
3087 Very obsolete alternative name for the @samp{le} capability.
|
|
|
3088 @item bl
|
|
|
3089 String to sound the bell.
|
|
|
3090 @item bs
|
|
|
3091 Obsolete flag: ASCII backspace may be used for leftward motion.
|
|
|
3092 @item bt
|
|
|
3093 String to move the cursor left to the previous hardware tab stop column.
|
|
|
3094 @item bw
|
|
|
3095 Flag: @samp{le} at left margin wraps to end of previous line.
|
|
|
3096 @item CC
|
|
|
3097 String to change terminal's command character.
|
|
|
3098 @item cd
|
|
|
3099 String to clear the line the cursor is on, and following lines.
|
|
|
3100 @item ce
|
|
|
3101 String to clear from the cursor to the end of the line.
|
|
|
3102 @item ch
|
|
|
3103 String to position the cursor at column @var{c} in the same line.
|
|
|
3104 @item cl
|
|
|
3105 String to clear the entire screen and put cursor at upper left corner.
|
|
|
3106 @item cm
|
|
|
3107 String to position the cursor at line @var{l}, column @var{c}.
|
|
|
3108 @item CM
|
|
|
3109 String to position the cursor at line @var{l}, column
|
|
|
3110 @var{c}, relative to display memory.
|
|
|
3111 @item co
|
|
|
3112 Number: width of the screen.
|
|
|
3113 @item cr
|
|
|
3114 String to move cursor sideways to left margin.
|
|
|
3115 @item cs
|
|
|
3116 String to set the scroll region.
|
|
|
3117 @item cS
|
|
|
3118 Alternate form of string to set the scroll region.
|
|
|
3119 @item ct
|
|
|
3120 String to clear all tab stops.
|
|
|
3121 @item cv
|
|
|
3122 String to position the cursor at line @var{l} in the same column.
|
|
|
3123 @item da
|
|
|
3124 Flag: data scrolled off top of screen may be scrolled back.
|
|
|
3125 @item db
|
|
|
3126 Flag: data scrolled off bottom of screen may be scrolled back.
|
|
|
3127 @item dB
|
|
|
3128 Obsolete number: msec of padding needed for the backspace character.
|
|
|
3129 @item dc
|
|
|
3130 String to delete one character position at the cursor.
|
|
|
3131 @item dC
|
|
|
3132 Obsolete number: msec of padding needed for the carriage-return character.
|
|
|
3133 @item DC
|
|
|
3134 String to delete @var{n} characters starting at the cursor.
|
|
|
3135 @item dF
|
|
|
3136 Obsolete number: msec of padding needed for the formfeed character.
|
|
|
3137 @item dl
|
|
|
3138 String to delete the line the cursor is on.
|
|
|
3139 @item DL
|
|
|
3140 String to delete @var{n} lines starting with the cursor's line.
|
|
|
3141 @item dm
|
|
|
3142 String to enter delete mode.
|
|
|
3143 @item dN
|
|
|
3144 Obsolete number: msec of padding needed for the newline character.
|
|
|
3145 @item do
|
|
|
3146 String to move the cursor vertically down one line.
|
|
|
3147 @item DO
|
|
|
3148 String to move cursor vertically down @var{n} lines.
|
|
|
3149 @item ds
|
|
|
3150 String to disable the display of the status line.
|
|
|
3151 @item dT
|
|
|
3152 Obsolete number: msec of padding needed for the tab character.
|
|
|
3153 @item ec
|
|
|
3154 String of commands to clear @var{n} characters at cursor.
|
|
|
3155 @item ed
|
|
|
3156 String to exit delete mode.
|
|
|
3157 @item ei
|
|
|
3158 String to leave insert mode.
|
|
|
3159 @item eo
|
|
|
3160 Flag: output of a space can erase an overstrike.
|
|
|
3161 @item es
|
|
|
3162 Flag: other display commands work while writing the status line.
|
|
|
3163 @item ff
|
|
|
3164 String to advance to the next page, for a hardcopy terminal.
|
|
|
3165 @item fs
|
|
|
3166 String to move the cursor back from the status line to its
|
|
|
3167 previous position (outside the status line).
|
|
|
3168 @item gn
|
|
|
3169 Flag: this terminal type is generic, not real.
|
|
|
3170 @item hc
|
|
|
3171 Flag: hardcopy terminal.
|
|
|
3172 @item hd
|
|
|
3173 String to move the cursor down half a line.
|
|
|
3174 @item ho
|
|
|
3175 String to position cursor at upper left corner.
|
|
|
3176 @item hs
|
|
|
3177 Flag: the terminal has a status line.
|
|
|
3178 @item hu
|
|
|
3179 String to move the cursor up half a line.
|
|
|
3180 @item hz
|
|
|
3181 Flag: terminal cannot accept @samp{~} as output.
|
|
|
3182 @item i1
|
|
|
3183 String to initialize the terminal for each login session.
|
|
|
3184 @item i3
|
|
|
3185 String to initialize the terminal for each login session.
|
|
|
3186 @item ic
|
|
|
3187 String to insert one character position at the cursor.
|
|
|
3188 @item IC
|
|
|
3189 String to insert @var{n} character positions at the cursor.
|
|
|
3190 @item if
|
|
|
3191 String naming a file of commands to initialize the terminal.
|
|
|
3192 @item im
|
|
|
3193 String to enter insert mode.
|
|
|
3194 @item in
|
|
|
3195 Flag: outputting a space is different from moving over empty positions.
|
|
|
3196 @item ip
|
|
|
3197 String to output following an inserted character in insert mode.
|
|
|
3198 @item is
|
|
|
3199 String to initialize the terminal for each login session.
|
|
|
3200 @item it
|
|
|
3201 Number: initial spacing between hardware tab stop columns.
|
|
|
3202 @item k0
|
|
|
3203 String of input sent by function key 0 or 10.
|
|
|
3204 @item k1 @dots{} k9
|
|
|
3205 Strings of input sent by function keys 1 through 9.
|
|
|
3206 @item K1 @dots{} K5
|
|
|
3207 Strings sent by the five other keys in 3-by-3 array with arrows.
|
|
|
3208 @item ka
|
|
|
3209 String of input sent by the ``clear all tabs'' key.
|
|
|
3210 @item kA
|
|
|
3211 String of input sent by the ``insert line'' key.
|
|
|
3212 @item kb
|
|
|
3213 String of input sent by the ``backspace'' key.
|
|
|
3214 @item kC
|
|
|
3215 String of input sent by the ``clear screen'' key.
|
|
|
3216 @item kd
|
|
|
3217 String of input sent by typing the down-arrow key.
|
|
|
3218 @item kD
|
|
|
3219 String of input sent by the ``delete character'' key.
|
|
|
3220 @item ke
|
|
|
3221 String to make the function keys work locally.
|
|
|
3222 @item kE
|
|
|
3223 String of input sent by the ``clear to end of line'' key.
|
|
|
3224 @item kF
|
|
|
3225 String of input sent by the ``scroll forward'' key.
|
|
|
3226 @item kh
|
|
|
3227 String of input sent by typing the ``home-position'' key.
|
|
|
3228 @item kH
|
|
|
3229 String of input sent by the ``home down'' key.
|
|
|
3230 @item kI
|
|
|
3231 String of input sent by the ``insert character'' or ``enter
|
|
|
3232 insert mode'' key.
|
|
|
3233 @item kl
|
|
|
3234 String of input sent by typing the left-arrow key.
|
|
|
3235 @item kL
|
|
|
3236 String of input sent by the ``delete line'' key.
|
|
|
3237 @item km
|
|
|
3238 Flag: the terminal has a Meta key.
|
|
|
3239 @item kM
|
|
|
3240 String of input sent by the ``exit insert mode'' key.
|
|
|
3241 @item kn
|
|
|
3242 Numeric value, the number of numbered function keys.
|
|
|
3243 @item kN
|
|
|
3244 String of input sent by the ``next page'' key.
|
|
|
3245 @item ko
|
|
|
3246 Very obsolete string listing the terminal's named function keys.
|
|
|
3247 @item kP
|
|
|
3248 String of input sent by the ``previous page'' key.
|
|
|
3249 @item kr
|
|
|
3250 String of input sent by typing the right-arrow key.
|
|
|
3251 @item kR
|
|
|
3252 String of input sent by the ``scroll reverse'' key.
|
|
|
3253 @item ks
|
|
|
3254 String to make the function keys transmit.
|
|
|
3255 @item kS
|
|
|
3256 String of input sent by the ``clear to end of screen'' key.
|
|
|
3257 @item kt
|
|
|
3258 String of input sent by the ``clear tab stop this column'' key.
|
|
|
3259 @item kT
|
|
|
3260 String of input sent by the ``set tab stop in this column'' key.
|
|
|
3261 @item ku
|
|
|
3262 String of input sent by typing the up-arrow key.
|
|
|
3263 @item l0
|
|
|
3264 String on keyboard labelling function key 0 or 10.
|
|
|
3265 @item l1 @dots{} l9
|
|
|
3266 Strings on keyboard labelling function keys 1 through 9.
|
|
|
3267 @item le
|
|
|
3268 String to move the cursor left one column.
|
|
|
3269 @item LE
|
|
|
3270 String to move cursor left @var{n} columns.
|
|
|
3271 @item li
|
|
|
3272 Number: height of the screen.
|
|
|
3273 @item ll
|
|
|
3274 String to position cursor at lower left corner.
|
|
|
3275 @item lm
|
|
|
3276 Number: lines of display memory.
|
|
|
3277 @item mb
|
|
|
3278 String to enter blinking mode.
|
|
|
3279 @item md
|
|
|
3280 String to enter double-bright mode.
|
|
|
3281 @item me
|
|
|
3282 String to turn off all appearance modes
|
|
|
3283 @item mh
|
|
|
3284 String to enter half-bright mode.
|
|
|
3285 @item mi
|
|
|
3286 Flag: cursor motion in insert mode is safe.
|
|
|
3287 @item mk
|
|
|
3288 String to enter invisible mode.
|
|
|
3289 @item mm
|
|
|
3290 String to enable the functioning of the Meta key.
|
|
|
3291 @item mo
|
|
|
3292 String to disable the functioning of the Meta key.
|
|
|
3293 @item mp
|
|
|
3294 String to enter protected mode.
|
|
|
3295 @item mr
|
|
|
3296 String to enter reverse-video mode.
|
|
|
3297 @item ms
|
|
|
3298 Flag: cursor motion in standout mode is safe.
|
|
|
3299 @item nc
|
|
|
3300 Obsolete flag: do not use ASCII carriage-return on this terminal.
|
|
|
3301 @item nd
|
|
|
3302 String to move the cursor right one column.
|
|
|
3303 @item nl
|
|
|
3304 Obsolete alternative name for the @samp{do} and @samp{sf} capabilities.
|
|
|
3305 @item ns
|
|
|
3306 Flag: the terminal does not normally scroll for sequential output.
|
|
|
3307 @item nw
|
|
|
3308 String to move to start of next line, possibly clearing rest of old line.
|
|
|
3309 @item os
|
|
|
3310 Flag: terminal can overstrike.
|
|
|
3311 @item pb
|
|
|
3312 Number: the lowest baud rate at which padding is actually needed.
|
|
|
3313 @item pc
|
|
|
3314 String containing character for padding.
|
|
|
3315 @item pf
|
|
|
3316 String to terminate redirection of output to the printer.
|
|
|
3317 @item po
|
|
|
3318 String to redirect further output to the printer.
|
|
|
3319 @item pO
|
|
|
3320 String to redirect @var{n} characters ofoutput to the printer.
|
|
|
3321 @item ps
|
|
|
3322 String to print the screen on the attached printer.
|
|
|
3323 @item rc
|
|
|
3324 String to move to last saved cursor position.
|
|
|
3325 @item RI
|
|
|
3326 String to move cursor right @var{n} columns.
|
|
|
3327 @item rp
|
|
|
3328 String to output character @var{c} repeated @var{n} times.
|
|
|
3329 @item rs
|
|
|
3330 String to reset the terminal from any strange modes.
|
|
|
3331 @item sa
|
|
|
3332 String to turn on an arbitrary combination of appearance modes.
|
|
|
3333 @item sc
|
|
|
3334 String to save the current cursor position.
|
|
|
3335 @item se
|
|
|
3336 String to leave standout mode.
|
|
|
3337 @item sf
|
|
|
3338 String to scroll the screen one line up.
|
|
|
3339 @item SF
|
|
|
3340 String to scroll the screen @var{n} lines up.
|
|
|
3341 @item sg
|
|
|
3342 Number: width of magic standout cookie. Absent if magic cookies are
|
|
|
3343 not used.
|
|
|
3344 @item so
|
|
|
3345 String to enter standout mode.
|
|
|
3346 @item sr
|
|
|
3347 String to scroll the screen one line down.
|
|
|
3348 @item SR
|
|
|
3349 String to scroll the screen @var{n} line down.
|
|
|
3350 @item st
|
|
|
3351 String to set tab stop at current cursor column on all lines.
|
|
|
3352 programs.
|
|
|
3353 @item ta
|
|
|
3354 String to move the cursor right to the next hardware tab stop column.
|
|
|
3355 @item te
|
|
|
3356 String to return terminal to settings for sequential output.
|
|
|
3357 @item ti
|
|
|
3358 String to initialize terminal for random cursor motion.
|
|
|
3359 @item ts
|
|
|
3360 String to move the terminal cursor into the status line.
|
|
|
3361 @item uc
|
|
|
3362 String to underline one character and move cursor right.
|
|
|
3363 @item ue
|
|
|
3364 String to turn off underline mode
|
|
|
3365 @item ug
|
|
|
3366 Number: width of underlining magic cookie. Absent if underlining
|
|
|
3367 doesn't use magic cookies.
|
|
|
3368 @item ul
|
|
|
3369 Flag: underline by overstriking with an underscore.
|
|
|
3370 @item up
|
|
|
3371 String to move the cursor vertically up one line.
|
|
|
3372 @item UP
|
|
|
3373 String to move cursor vertically up @var{n} lines.
|
|
|
3374 @item us
|
|
|
3375 String to turn on underline mode
|
|
|
3376 @item vb
|
|
|
3377 String to make the screen flash.
|
|
|
3378 @item ve
|
|
|
3379 String to return the cursor to normal.
|
|
|
3380 @item vi
|
|
|
3381 String to make the cursor invisible.
|
|
|
3382 @item vs
|
|
|
3383 String to enhance the cursor.
|
|
|
3384 @item wi
|
|
|
3385 String to set the terminal output screen window.
|
|
|
3386 @item ws
|
|
|
3387 Number: the width of the status line.
|
|
|
3388 @item xb
|
|
|
3389 Flag: superbee terminal.
|
|
|
3390 @item xn
|
|
|
3391 Flag: cursor wraps in a strange way.
|
|
|
3392 @item xs
|
|
|
3393 Flag: clearing a line is the only way to clear the appearance modes of
|
|
|
3394 positions in that line (or, only way to remove magic cookies on that
|
|
|
3395 line).
|
|
|
3396 @item xt
|
|
|
3397 Flag: Teleray 1061; several strange characteristics.
|
|
|
3398 @end table
|
|
|
3399
|
|
|
3400 @node Var Index, Cap Index, Summary, Top
|
|
|
3401 @unnumbered Variable and Function Index
|
|
|
3402
|
|
|
3403 @printindex fn
|
|
|
3404
|
|
|
3405 @node Cap Index, Index, Var Index, Top
|
|
|
3406 @unnumbered Capability Index
|
|
|
3407
|
|
|
3408 @printindex ky
|
|
|
3409
|
|
|
3410 @node Index,, Cap Index, Top
|
|
|
3411 @unnumbered Concept Index
|
|
|
3412
|
|
|
3413 @printindex cp
|
|
|
3414
|
|
|
3415 @contents
|
|
|
3416 @bye
|
