window \- multiple window shell
\fIWindow\fP provides a window oriented working environment
on ordinary CRT terminals.
Windows are rectangular partitions on the physical terminal screen
that are indistinguishable from real terminals to processes running in
them. Their sizes are determined at creation
time. They are framed as necessary to mark the boundaries between
windows. Each window, like terminals, has a cursor and a set of
control functions. Most intelligent terminal functions such as line and
character deletion and insertion are supported. Display modes
such as underlining and reverse video are supported if the terminal
Each window has a text buffer which can be larger than the window.
Different parts of the buffer can be made visible through scrolling.
Windows are labeled with the digits ``1'' through ``9'',
thus a maximum of nine windows can exist at the same time.
One window, the current window, is treated specially.
This window is indicated by displaying its labels in reverse video.
Windows can overlap. Some can be completely obscured by others.
The current window is always on top of all others.
Windows need not be completely within the edges of the terminal screen.
Thus a large window (possibly larger than the physical screen)
can be placed to show only a portion of its full size. This
feature can in some situations replace the ability to change
window sizes which is not supported.
With each newly created window, a shell program is spawned with its
process environment tailored to that window. In particular,
a pseudo-terminal device (\fIpty (4)\fP) is allocated, and becomes
the standard input, output and diagnostic output of the shell. Its
special characters and modes (see \fIstty (1)\fP) are copied from
the user's real terminal. Also,
a \fItermcap (5)\fP entry for this window is created
and passed to the shell as \fIenviron (8)\fP
variable \fBTERMCAP\fP. This \fItermcap\fP entry contains the window's
size and characteristics as well as information about
the real terminal, such as the existence of underline, reverse
video and other display modes, and the codes produced by the terminal's
keypad (if any). The name of the shell program used is obtained from
the environment variable \fBSHELL\fP.
When \fIwindow\fP starts up, the file \fI.windowrc\fP in the
user's home directory is checked. If it exists, then the
commands contained in it are executed (see \fIsource\fP command below).
If \fI.windowrc\fP does not exist, then two
equal sized windows are created by default.
The command line arguments are
Turn on terse mode (see \fIterse\fP command below).
Don't perform any startup action.
Ignore \fI.windowrc\fP and create the two default
Set the escape character to \fIescape-char\fP.
The \fIwindow\fP program has two functional modes: command mode
In conversation mode, the terminal's
real cursor is placed at the cursor position of the current
window and all keyboard input is sent to the process in that
window. Output from windows is displayed at all times,
Typing \fIwindow\fP's escape character (normally ^P)
in conversation mode switches \fIwindow\fP into
command mode. In command mode, the top line of the
terminal screen becomes the command prompt window.
There are two types of commands. Short commands are
usually one or two key strokes. Long commands are
in the command window (see the ``:'' command below),
or read from a file (see \fIsource\fP below). They are parsed
much like conventional programming languages, with a syntax
similar to that of C. Numeric and string expressions and variables
are supported, as well as
conditional statements (if . . .). The grammar is described below.
The short commands. Below, \fI[1-9]\fP represents one of the
keys ``1'' through ``9,'' used to select the correponding window
Select window \fI[1-9]\fP as the current window
and return to conversation mode.
Select window \fI[1-9]\fP but stay in command mode.
List a short summary of commands.
Return to conversation mode.
Return to conversation mode and write ^P to the
current window. Thus, typing two ^P's in conversation
mode sends one to the current window. If the \fIwindow\fP
escape is changed to some other character, that
character takes the place of ^P here.
Select the previous current window and return to conversation
mode. This is useful for toggling between two windows.
Exit \fIwindow\fP. Confirmation is requested.
Create a new window. You are prompted for the positions
of the upper left and lower right corners of the window.
The cursor is placed on the screen and the keys ``h'', ``j'',
move the cursor left, down, up, and right, respectively.
The keys ``H'', ``J'', ``K'', and ``L'' move the cursor to the respective
limits of the screen. Typing a number before the movement keys
repeats the movement that number of times.
Return enters the cursor position
as the upper left corner of the window. The lower right corner
is entered in the same manner. During this process,
the position and size of the new window are indicated by a rectangular
box drawn on the screen. Typing escape (or ^[) at any point
This window becomes the current window,
and is given the first available label. The default buffer size
is used (see \fIbuffer\fP command below).
Only fully visible windows can be created this way.
Close window \fI[1-9]\fP. The process in the window is sent
the hangup signal (see \fIkill (1)\fP). \fICsh (1)\fP should
handle this signal correctly and cause no problems.
Move window \fI[1-9]\fP to another location. A box in the shape
of the window is drawn on
the screen to indicate the new position of the window, and the same keys as
those for the ``w'' command are used to position the box. The
window can be moved partially off-screen.
Move window \fI[1-9]\fP to its previous position.
Show all windows. Each window is brought to the top in sequence,
with the terminal cursor placed on its label. Typing escape
at this point will select the displayed window as the current window.
Return will display the next one. This command is sometimes confusing,
but useful when there are a large number of windows and some are completely
List all windows with their labels and the states of their shell processes.
Scroll the current window up by one line.
Scroll the current window down by one line.
Scroll the current window up by half the window size.
Scroll the current window down by half the window size.
Scroll the current window up by the full window size.
Scroll the current window down by the full window size.
Move the cursor of the current window left by one column.
Move the cursor of the current window down by one line.
Move the cursor of the current window up by one line.
Move the cursor of the current window right by one column.
List all variables. All currently defined variables are listed
Enter a line to be executed as long commands. Normal line
editing characters (erase character, erase word, erase line) are
Long commands. A long command is either a conditional statement
or a simple command. The simple long command consists of a
a list of arguments, terminated with newline or ``;''. A command can
be continued on the next line by ending the first line with ``\\''. The
arguments can be numeric or string expressions. Window supports both numeric
and string values. A string is any word beginning with a letter or
``_'', followed by letters, digits, or ``_''. Alternately, strings
can be quoted in ``"'' to include non-alphanumeric characters. Numeric
values are simple strings of digits. Boolean
values are represented by a numeric value not equal to zero. The supported operators in increasing
.B "boolean_expr ? expr1 : expr2"
if \fIboolean_expr\fP is true, \fIexpr2\fP otherwise.
.B boolean_expr1 || boolean_expr2
Logical or. Short circuit evaluation is supported.
.B boolean_expr1 && boolean_expr2
Logical and, with short circuit evaluation.
.B numeric_expr1 | numeric_expr2
.B numeric_expr1 ^ numeric_expr2
.B numeric_expr1 & numeric_expr2
.B expr1 == expr2, expr1 != expr2
Comparison (equal and not-equal, respectively). The boolean
result of the comparison is returned. The arguments can be numeric
.B expr1 < expr2, expr1 > expr2, expr1 <= expr2, expr1 >= expr2
Less than, greater than, less than or equal to, greater than or equal to.
.B numeric_expr1 << numeric_expr2, numeric_expr1 >> numeric_expr2,
\fINumeric_expr1\fP is bit shifted left (or right) by \fInumeric_expr2\fP
.B numeric_expr1 + numeric_expr2, numeric_expr1 - numeric_expr2
.B numeric_expr1 * numeric_expr2, numeric_expr1 / numeric_expr2, numeric_expr1 % numeric_expr2
Multiplication, division, modulo.
.B - numeric_expr, + numeric_expr, ~ numeric_expr, ! boolean_expr
Unary minus, unary plus, bitwise complement, logical complement.
Set the escape character to \fIC\fP.
Turn on (or off) terse mode. In terse mode, the command window
stays hidden even in command mode, and errors are reported by
sounding the terminal's bell.
.B window row col nrow ncol [nline]
Open a window with upper left corner at \fIrow\fP, \fIcol\fP
and size \fInrow\fP, \fIncol\fP. If \fInline\fP is specified,
then that many lines is allocated for the text buffer. Otherwise,
the default buffer size is used. Using a \fB``*''\fP in place of
\fIrow\fP, \fIcol\fP, \fInrow\fP, or \fIncol\fP gives, respectively,
the up, left, down, or right extremes of the screen.
Set the default buffer size to \fInline\fP. Initially, it is
48 lines. Using a very large buffer can slow the program down
Label window \fI[1-9]\fP with \fIstring\fP. This is in addition
to the numeric label that is always displayed.
Make window \fI[1-9]\fP the current window.
Write \fIstring\fP to window \fI[1-9]\fP.
Close window \fI[1-9]\fP. More than one window can be specified.
If no window is given, then all windows are closed.
Read and execute the long commands in \fIfile\fP. Recursive
\fIsource\fP is not allowed.
~/.windowrc startup command file.
/dev/ptyp? pseudo-terminal devices.
Should be self explanatory.
When a window is scrolled or the cursor moved, output from
the process in the window will be displayed at the new cursor
position. This is consistent with real terminals but
projects / unix-history / blob