scoterm(XC)


scoterm -- terminal emulator for X

Command syntax

scoterm [Xt_options] [-option ...]

Desktop syntax

Double-click on the UNIX icon on the Desktop.

Description

scoterm, sometimes referred to by Desktop users as the ``UNIX window'', is an X client that emulates the SCO ANSI console; it produces a default window 80 columns wide by 25 lines in length. scoterm runs under the graphical operating environment.

Any application that runs on the SCO ANSI console can run under scoterm. There is one distinction, however: scoterm is a character-based terminal emulator and, therefore, does not support graphics mode or blinking characters.

scoterm offers features not available in the standard X terminal emulator, xterm, including:

These features are described below.

Command options

scoterm supports all Xt_options(XC), as well as:

-help
prints out a verbose message describing its options.

-ah
specifies that scoterm always highlights the text cursor, even when keyboard focus is lost or the pointer leaves the window.

+ah
specifies that scoterm displays a hollow text cursor whenever the keyboard focus is lost or the pointer leaves the window. This is the default behavior.

-b number
specifies the size of the inner border (the distance between the outer edge of the characters and the window border) in pixels. The default size is 2 pixels.

-blink
displays a blinking cursor.

+blink
displays a steady, non-blinking cursor. This mode is the default.

-cb
changes the effect of triple-clicking the mouse on a line of text. Usually, triple-clicking highlights the entire line. When this option is used, however, triple-clicking highlights only the word that the pointer is on and the portion of the line to the right of that word.

+cb
specifies that triple-clicking the mouse on a line highlights the entire line. This mode is the default.

-cc characterclassrange:value[,...]
reassigns specific characters to different character classes. This option is important when you select text with the mouse in one-word increments. For details, see the Character classes section in this manual page.

-charset charsetvalue
accepts any of the charset values specified in the language file, which is specified by the resource languageFile. By default, support is provided only for the IBM437 and ISO8859 character sets. Select the same character set as is used on the system on which scoterm is running. Note that scoterm can be configured to support any single-byte codeset. This means that scoterm can display data for any single byte codeset, and can generate keyboard output for any single byte character set. The resources that need to be configured to do so are: languageFile (class: LanguageFile), charset (class: Charset), keyboard (class: Keyboard), keysymMap (class: KeysymMap). For details, see the Resources section in this manual page.

-cmap
tells scoterm to use its own ANSI color map, if necessary.

+cmap
tells scoterm to use the X server's default color map. scoterm uses the server's color map by default.

-cn
specifies that new lines are not cut in line-mode selections.

+cn
specifies that new lines are cut in line-mode selections.

-e program [arguments ...]
specifies that the program (and its command line arguments) runs in the scoterm window. It also sets the window title and icon name to be the base name of the program being executed if neither -T (or -title) nor -n are given on the command line. -e must be the last option on the command line.

-fb font
specifies the font to use when displaying bold text. This font must be the same height and width as the non-bold font. If you do not specify both a non-bold font and a bold font, scoterm produces a bold font by overstriking the non-bold font. The default is to overstrike the normal font.

-j
specifies that scoterm jump-scrolls. Usually, text is scrolled one line at a time; this option allows scoterm to move multiple lines at a time so that it does not fall as far behind. This option makes scoterm much faster when scanning through large amounts of text.

+j
specifies that scoterm does not jump-scroll.

-keyboard name
identifies the keyboard type the X server uses. Keyboard styles vary in the layout of the keys on the keyboard. For example, -keyboard German specifies the German keyboard type. To see what languages are available, check the file specified by the resource languageFile. This option can be dynamically modified with the Keyboard submenu of the Options menu.

-l
specifies that scoterm send all terminal output to a log file as well as to the screen.

+l
specifies that scoterm does not log terminal output.

-lf filename
specifies the name of the file to which the output log (described above) is written. This option only works if the option -l is also specified. If filename begins with a pipe symbol, ``|'', the rest of the string is assumed to be a command to be used as the endpoint of a pipe. The default filename is ScotrmLognnnn, where nnnn is the process ID of scoterm, and is created in the directory from which scoterm was started (or the user's home directory in the case of a login window).

-ls
specifies that the shell started in the scoterm window is a login shell (that is, the first character of argv[0] is a dash, indicating to the shell that it should read the user's .login or .profile file).

+ls
specifies that the shell started in the scoterm window is not a login shell (that is, it is a ``normal'' subshell).

-mb
specifies that scoterm rings a margin bell when you type near the right end of a line.

+mb
specifies that a margin bell does not ring.

-menu
specifies that scoterm does not display a menu bar when it starts up.

+menu
displays a menu bar when scoterm starts up. If you start scoterm without the menu bar, you can activate the menu interface by pressing the <Ctrl> key and mouse button 1 simultaneously. scoterm displays the menu bar by default.

-mono
tells scoterm not to use color in its displays.

+mono
tells scoterm to use color in its windows. scoterm uses color by default.

-mptys
tells scoterm to use the merged pseudo-tty architecture used by SCO ® UNIX System ® V/386 Release 3.2 operating system, Version 4.0.

+mptys
tells scoterm to use the merged pseudo tty architecture used by UNIX systems prior to Release 3.2 Version 4.0

-n iconname
is the icon label when scoterm is iconified.

-nb number
specifies the number of characters from the right end of a line at which the margin bell, if enabled, rings. The default is 10 characters.

-rw
allows reverse-wraparound. This lets the cursor back up from the leftmost column of one line to the rightmost column of the previous line. It is very useful for editing long shell command lines.

+rw
disallows reverse-wraparound.

-s
specifies that scoterm scrolls asynchronously, meaning that the screen does not have to be kept completely up-to-date while scrolling. This allows scoterm to run faster when network latencies are very high and is typically useful when running across a very large internet or many gateways.

+s
specifies that scoterm scrolls synchronously.

-sb
displays a scroll bar.

+sb
specifies that a scroll bar is not displayed.

+scancodes
runs scoterm in scancode mode. The user must specify a keyboard file before using scancodes, because no default is provided. For details on specifying a keyboard file, see the descriptions of languageFile and keyboard in the Resources section later in this manual page.

-scancodes
specifies that scoterm does not run in scancode mode.

-si
specifies that output to a window does not automatically reposition the screen to the bottom of the scrolling region.

+si
specifies that output to a window causes the screen to scroll to the bottom.

-sk
specifies that pressing a key while using the scroll bar to review previous lines of text causes the window to be repositioned automatically in the normal position at the bottom of the scroll region.

+sk
specifies that pressing a key while using the scroll bar does not cause the window to be repositioned.

-sl number
specifies the number of lines scrolled to save from the top of the screen. The default is 64 lines.

-tm string
specifies a series of terminal setting keywords followed by the characters that should be bound to those functions, similar to the stty program. Allowable keywords include: intr, quit, erase, kill, eof, eol, swtch, start, stop, brk, susp, dsusp, rprnt, flush, weras, and lnext. You can specify control characters as ^char (for example, ^c or ^u), and you can use ^? to indicate delete.

-tn name
specifies the name of the terminal type to be set in the TERM environment variable. This terminal type must exist in the termcap(F) database and should have li# and co# entries. The default terminal type is scoansi.

-ut
specifies that scoterm does not write a record into the system log file /etc/utmp.

+ut
specifies that scoterm writes a record into the system log file /etc/utmp.

-vb
specifies a visual bell rather than an audible one. The window flashes, instead of a terminal bell ringing, whenever a <Ctrl>G is received.

+vb
specifies that a visual bell is not used.

-wf
waits for the window to be mapped the first time before starting the subprocess so that the initial terminal size settings and environment variables are correct. It is the application's responsibility to catch subsequent terminal size changes.

+wf
specifies that scoterm does not wait before starting the subprocess. -C specifies that this window receives console output. -Sccn specifies the last two letters of the name of a pseudoterminal to use in slave mode, plus the number of the inherited file descriptor. The option is parsed %c%c%d. This allows scoterm to be used as an input and output channel for an existing program and is sometimes used in specialized applications.

Desktop options

This section provides an overview of the scoterm menus. File menu items include:

Open logfile
for selecting a file to log screen activity.

Save logfile
for saving and closing the logfile.

Reset (soft)
for resetting scroll regions from partial scroll (a portion of the window) to full scroll. Use this command when a program has left the scroll region set incorrectly.

Reset (full)
for clearing the screen, resetting tabs to every eight columns, reinitializing the keyboard mapping data, restoring the sprite (for example, the mouse cursor) to its default shape, and resetting the terminal modes (such as wrap and jump scroll) to their initial states just after scoterm has finished processing the command line options.

The Edit menu item is:


Paste
for copying highlighted text strings to the right of the current text cursor position.

The Options menu provides three submenus:

The Display submenu items include:


Scrollbar
for adding a scrollbar to the scoterm window.

Auto linefeed
for generating a linefeed character at the end of each line.

Visual bell
for replacing the terminal bell with a visual signal.

Secure keyboard
for typing in passwords or other sensitive data when you are working in an unsecure environment.

The Font Size submenu items include:


Default
resets the size of the screen text to the font specified when scoterm is initialized.

6 by 13
specifies the smallest typesize available

17 by 28
specifies the largest typesize

You can change the font and size specified by each of the Font Size submenu items by editing your X resource file.

The Keyboard submenu allows you to select your keyboard type (such as German, French, or Italian) from a scrollable list.

Security

If your server is only using a host-based mechanism to control access to the server (see xhost(X)), security might be inadequate. When you enable access for a host and other users are also permitted to run clients on that same host, it is possible for someone to run an application that uses the basic services of the X protocol to monitor your activities, including everything you type at the keyboard. This is of particular concern when you want to type in a password or other sensitive data. The best solution to this problem is to use a better authorization mechanism than host-based control. However, a simple mechanism exists for protecting keyboard input in scoterm, as described here.

When enabled, the Secure keyboard item in the Options menu (see ``Desktop options'' earlier in this manual page) ensures that all keyboard input is directed only to scoterm (using the GrabKeyboard protocol request). When an application prompts you for a password (or other sensitive data), you can enable Secure keyboard using the menu, type in the data, then disable Secure keyboard using the menu again.

Only one X client at a time can secure the keyboard, so when you attempt to enable Secure keyboard, it might fail. In this case, the bell sounds. If the Secure keyboard succeeds, any characters that you type are displayed in reverse video. If this does not happen, then you should be aware of the possibility that your keyboard input is being monitored. If the application you are running displays a prompt before asking for the password, it is safest to enter secure mode before the prompt gets displayed. Then make sure that the text that you type is displayed in reverse video, to minimize the probability of having another user monitor your keyboard input. You can also bring up the menu again and make sure that a check mark appears next to the menu item.

Secure keyboard mode is disabled automatically if your scoterm window becomes unmapped, or if you start up a reparenting window manager (that places a title bar or other decoration around the window) while in Secure keyboard mode. (This is a feature of the X protocol that is not easily overcome.) When this happens, the foreground and background colors are switched back and the bell sounds in warning.

Font/display support

scoterm comes with four IBM Code Page 437 fonts for the SCO X server. They range in size from 6 by 13 to 17 by 28 pixels per character. All these fonts provide the same character set that is supported by the SCO ANSI console, including 8-bit character support for line-drawing characters, international characters, and Greek characters. You can change the scoterm font in the middle of a session by choosing another font from the Font Size submenu of the Options menu. (When a font name begins with the prefix ``ibm,'' scoterm assumes that the font is an IBM Code Page 437 font.)

You can also use non-IBM fonts under scoterm. scoterm can be configured to support any single byte codeset. This means that scoterm can display data for any single byte codeset, and can generate keyboard output for any single byte character set. The resources that need to be configured to do so are: languageFile (class: LanguageFile), charset (class: Charset), keyboard (class: Keyboard), keysymMap (class: KeysymMap). For details, see the Resources section in this manual page.

Eight-bit character support

scoterm supports 8-bit characters. The IBM fonts provided with scoterm include 8-bit characters. Eight-bit characters are also included in the CharClass for scoterm's cut-and-paste options, and can be remapped using the charClass resource.

SCO ANSI display control string compatibility

scoterm supports all SCO ANSI display control sequences. Any application that you subsequently run has the following ANSI console features: inverse video, line drawing, boldface, and underlining. scoterm does not support blinking characters or the double-wide and double-size character sets. Proportional fonts are not supported.

scoterm is configured to use 2 colors on graphics adapters that support 16 colors. If the server provides 256 colors, 16-color support is available.

If your server provides 256 colors, to configure scoterm for 16-color support, make a copy of /usr/lib/X11/sco/startup/ScoTerm and delete everything from the copy except the *Ansi color resources (for example, *Ansi.background, *Ansi.foreground, *Ansi.blue, *Ansi.lt_green, and *Ansi.lt_cyan). Remove the exclamation point (!) preceding those *Ansi color resources you want to configure and assign each a color value. Then add the ScoTerm* class name in front of the resources. Append the edited copy to .Xdefaults-hostname. This provides some additional colors for scoterm but may fail if the colormap is already nearly full.

Starting scoterm with the -cmap option gives scoterm its own private colormap, and changes the colors of the other clients when scoterm has mouse focus.

Environment variables

scoterm sets the environment variables TERM and TERMCAP properly for the size window you have created. It also uses and sets the environment variable DISPLAY to specify which bitmap display terminal to use. The environment variable WINDOWID is set to the X window ID number of the scoterm window.

When you start scoterm, it automatically sets the TERM type inside its window to scoansi and the TERMCAP environment variable to the contents of the SCO ANSI entry. If you use the -ls option to run a login shell in the scoterm (UNIX) window, enter scoansi at the TERM type prompt.

Resize support

scoterm windows, like xterm windows, can be resized and iconified. Applications running inside scoterm can automatically resize themselves to match the new window size, if they were designed to do so. However, most character-based applications are not designed this way. Refer to the resize(XC) manual page for more information on resizing scoterm windows.

Keyboard/mouse support

scoterm supports the SCO Event Manager API, which supports both mouse and keyboard events. Unlike xterm, scoterm uses mouse commands to call its menus and to cut and paste text in the scoterm window. Unlike xterm, scoterm also lets you use the mouse with character-based applications supporting the mouse.

By default, scoterm works with applications that rely on X to track the mouse. This mode allows the application to change the pointer to any of the cursor shapes included with X.

scoterm also lets you use the mouse to handle mouse movements and button events for applications that do their own mouse tracking and were not designed with X in mind.

Focusing the mouse within scoterm

scoterm supports all character-based applications, including those that are not compatible with the X Window system. If an application uses a mouse but does not recognize X, you can focus all mouse activity within the scoterm window by pressing <Ctrl><Alt><Bksp> at the same time.

When you do this, the X cursor disappears. The application in the scoterm window now controls the mouse, and the cursor stays within the confines of the window. To return mouse control to X, press <Ctrl><Alt><Bksp> again.

International keyboard support

scoterm provides international keyboard support. At startup, scoterm determines the keyboard language it is supposed to emulate as follows:

To inform scoterm what kind of keyboard the X server is using, you can select the keyboard type at any time after scoterm startup. This lets you dynamically switch between keyboards.

Console keyboard compatibility

scoterm supports all the keyboard configuration utilities provided by the SCO ANSI console, including setkey(C), mapchan(M), mapkey(M), and mapstr(M).

Scancode support

scoterm provides XT scancode support, allowing the kernel to receive values associated with both the depression and the release of each key on the keyboard.

Copying and pasting text with the mouse

From within the scoterm window, you can use the mouse to copy and paste text. You can select text, copy it into a temporary buffer, then paste the text from the buffer to the desired location. If you are running more than one scoterm window, you can easily cut and paste text between those windows. You can also cut and paste between scoterm and other applications.

The default mouse commands for selecting, copying, and pasting text are described below. These functions can be assigned to other buttons and keys through the resource database.


NOTE: Some applications that you run under scoterm might also use the mouse. When that is the case, the button commands for copying and pasting do not work. The mouse command goes to the application, which interprets it according to its own rules. To use the scoterm cut-and-paste commands under these circumstances, press the <Shift> key and the appropriate mouse button simultaneously. This sends the mouse command to scoterm instead of the application. You can then copy and paste text normally.

Selecting and copying text

To select text, move the cursor to the beginning of the text, drag with mouse button 1 to the end of the region that you want to copy, then release the button.

As you drag the mouse to select text, by default the highlighted area expands in increments of one character, so you can select just part of a line or part of a word. You can change this default setting as you select text, by clicking the mouse button.

You can change back and forth between these modes while selecting a piece of text.

The text that you select is highlighted, saved into a global cut buffer, and made the Primary selection when the button is released. If the key/button bindings specify that an X selection is to be made, scoterm leaves the selected text highlighted for as long as it is the selection owner.

Pasting text

To paste text that you have copied, press mouse button 2 (or select Paste from the Edit menu). This action pastes the text from the Primary selection, if any, or from the cut buffer. The text is inserted as keyboard input at the prompt in the window. You can paste the text back into the same window or switch to another scoterm window and paste it there instead. You can also paste between scoterm and other applications.

By cutting and pasting pieces of text without trailing new lines, you can take text from several places in different windows and form a command to the shell, for example, or take output from a program and insert it into an editor. Because the cut buffer is globally shared among different applications, you should regard it as a file whose contents you know. The terminal emulator and other text programs should treat the buffer as if it were a text file.

Character classes

Clicking the first mouse button twice in rapid succession causes all contiguous characters of the same class (for example, letters, white space, punctuation) to be selected. Because different people have different preferences for what should be selected (for example, whether should filenames be selected as a whole or only the separate subnames), the default mapping can be overridden through the use of the charClass (class: CharClass) resource.

This resource is simply a list of range:value pairs where the range is either a single number or low-high in the range of 0 to 255, corresponding to the ASCII code for the character or characters to be set. The value is arbitrary, although the default table uses the character number of the first character occurring in the set.

The default table is:

   static int charClass[256] = {
   /* NUL  SOH  STX  ETX  EOT  ENQ  ACK  BEL */
       32,   1,   1,   1,   1,   1,   1,   1,
   /*  BS   HT   NL   VT   NP   CR   SO   SI */
        1,  32,   1,   1,   1,   1,   1,   1,
   /* DLE  DC1  DC2  DC3  DC4  NAK  SYN  ETB */
        1,   1,   1,   1,   1,   1,   1,   1,
   /* CAN   EM  SUB  ESC   FS   GS   RS   US */
        1,   1,   1,   1,   1,   1,   1,   1,
   /*  SP    !    "    #    $    %    &    ' */
       32,  33,  34,  35,  36,  37,  38,  39,
   /*   (    )    *    +    ,    -    .    / */
       40,  41,  42,  43,  44,  45,  46,  47,
   /*   0    1    2    3    4    5    6    7 */
       48,  48,  48,  48,  48,  48,  48,  48,
   /*   8    9    :    ;    <    =    >    ? */
       48,  48,  58,  59,  60,  61,  62,  63,
   /*   @    A    B    C    D    E    F    G */
       64,  48,  48,  48,  48,  48,  48,  48,
   /*   H    I    J    K    L    M    N    O */
       48,  48,  48,  48,  48,  48,  48,  48,
   /*   P    Q    R    S    T    U    V    W */
       48,  48,  48,  48,  48,  48,  48,  48,
   /*   X    Y    Z    [    \    ]    ^    _ */
       48,  48,  48,  91,  92,  93,  94,  48,
   /*   `    a    b    c    d    e    f    g */
       96,  48,  48,  48,  48,  48,  48,  48,
   /*   h    i    j    k    l    m    n    o */
       48,  48,  48,  48,  48,  48,  48,  48,
   /*   p    q    r    s    t    u    v    w */
       48,  48,  48,  48,  48,  48,  48,  48,
   /*   x    y    z    {    |    }    ~  DEL */
       48,  48,  48, 123, 124, 125, 126,   1,
   /* 128  129  130  131  132  133  134  135 */
       48,  48,  48,  48,  48,  48,  48,  48,
   /* 136  137  138  139  140  141  142  143 */
       48,  48,  48,  48,  48,  48,  48,  48,
   /* 144  145  146  147  148  149  150  151 */
       48,  48,  48,  48,  48,  48,  48,  48,
   /* 152  153  154  155  156  157  158  159 */
       48,  48,  48, 155, 156, 157, 158, 159,
   /* 160  161  162  163  164  165  166  167 */
       48,  48,  48,  48,  48,  48,  48,  48,
   /*  168  169  170  171  172  173  174  175 */
       168, 169, 170, 171, 172, 173, 174, 175,
   /*  176  177  178  179  180  181  182  183 */
       176, 177, 178, 179, 179, 179, 179, 179,
   /*  184  185  186  187  188  189  190  191 */
       179, 179, 179, 179, 179, 179, 179, 179,
   /*  192  193  194  195  196  197  198  199 */
       179, 179, 179, 179, 179, 179, 179, 179,
   /*  200  201  202  203  204  205  206  207 */
       179, 179, 179, 179, 179, 179, 179, 179,
   /*  208  209  210  211  212  213  214  215 */
       179, 179, 179, 179, 179, 179, 179, 179,
   /*  216  217  218  219  220  221  222  223 */
       179, 179, 179, 219, 219, 219, 219, 219,
   /*  224  225  226  227  228  229  230  231 */
       224, 224, 224, 224, 224, 224, 224, 224,
   /*  232  233  234  235  236  237  238  239 */
       224, 224, 224, 224, 236, 224, 224, 239,
   /*  240  241  242  243  244  245  246  247 */
       240, 241, 242, 243, 244, 245, 246, 247,
   /*  248  249  250  251  252  253  254  255 */
       248, 249, 250, 251, 252, 253, 254, 255
   };
For example, the string ScoTerm*charClass: 33:48,37:48,45-47:48,64:48 specifies that the exclamation mark, percent sign, dash, period, slash, and at-sign characters should be treated the same way as characters and numbers. This is very useful for cutting and pasting electronic mailing addresses and filenames.

Resources

scoterm can be configured to support any single byte codeset, which means it can correctly display data for any single byte codeset and generate keyboard output for any single byte character set. The following resources need to be configured to enable this support:

languageFile
identifies scoterm's keyboard language file specifying the supported keyboard languages. The default file is /usr/lib/X11/sco/ScoTerm/LangIndex. The file contains entries of the format: mapkey_file:locale:charset:description, where each entry has the following meaning:

mapkey_file
is a full pathname to a console mapkey file on the system.

locale
is a locale that can be associated with the mapkey_file (optional).

charset
associates a character set name with the mapkey file. The resource *charset can accept any of the values specified in this field.

description
is a string that can be passed to the -keyboard command line option (or *keyboard resource) as a shorthand means of identifying the mapkey_file.


charset
is a resource that can take on any charset value specified in the charset field in the file identified by the *languageFile resource. The value of this resource limits the set of keyboards displayed in the keyboard selection dialog box to those keyboards that have an equivalent charset field associated with them. Similarly, the -keyboard command line option (or *keyboard resource) will only accept mapkey file names (or their associated descriptions) that are specified in the file identified by the *languageFile resource that have the same charset field value as specified by this resource.

keyboard
identifies the mapkey keyboard file that scoterm should use in order to emulate the console keyboard functionality. The possible values for this resource are constrained by the setting of the *charset resource (see above). If this resource is left blank, then scoterm can neither emulate the console keyboard functionality nor run in scancode mode. Instead, scoterm will use the X server keyboard mapping (i.e., characters from the iso8859-1 codeset).

keysymMap
identifies a file that maps codeset values to X keysyms. If this resource is left blank, then scoterm will use the defaults, which are for the codesets iso8859 and ibm437. The default used is determined by the value of the resource *charset. If you do not want to use one of the built-in defaults, then you should provide your own mapping. The format of the file specified by *keysymMap is as follows: lines beginning with a '#' character are ignored. On the remaining lines, fields are white-space separated. The first entry on a line is the codeset value, followed by a list of X keysyms that should be mapped to that codeset value. For an example, see the csxmaps used by the X server (/usr/lib/X11/csxmaps).

Thus, to correctly configure scoterm to support a specific coded character set (such as the ibm850 coded character set), the following steps should be performed:

  1. Obtain a list of console mapkey files that support the ibm850 coded character set. Use this list to add entries to the file specified by the resource *languageFile. For example, the entries could include:

    /usr/lib/keyboard/ps.850.can::ibm850:Canada,
    /usr/lib/keyboard/ps.850.dan::ibm850:Denmark
    /usr/lib/keyboard/ps.850.fin::ibm850:Finland
    /usr/lib/keyboard/ps.850.fra::ibm850:France
    /usr/lib/keyboard/ps.850.ger::ibm850:Germany
    /usr/lib/keyboard/ps.850.ita::ibm850:Italy
    /usr/lib/keyboard/ps.850.usa::ibm850:USA
    /usr/lib/keyboard/ps.850.usa::ibm850:Default

    Note that the locale field has been intentionally left blank, and the character set associated with these mapkey files is defined as ``ibm850''.

  2. Set the *charset resource value to be ``ibm850''.

  3. Set the *keyboard resource value to be ``Default'', to correspond to the ``mapkey'' file /usr/lib/keyboard/ps.850.usa. This assumes that the X server's keyboard is a USA keyboard by default.

  4. Set the *mapchan resource to point to a ``mapchan'' file that provides dead key support to the ibm850 coded character set. This is optional, but if you want dead key support then you need to set it.

  5. Configure the following font resources to point to ibm850 fonts: *Ansi*font:, *Ansi*boldFont:, *Ansi*font1:, *Ansi*boldFont1:, *Ansi*font2:, *Ansi*boldFont2:, *Ansi*font3:, *Ansi*boldFont3:, *Ansi*font4:, *Ansi*boldFont4:. Because ibm850 fonts are not provided by default on the system, you must install these for the X server.

  6. As an option, you can remap the *charClass resource to settings that are appropriate for the ibm850 coded character set.

  7. Set the resource *termName to a terminal type name that supports the ibm850 line drawing (graphics) characters. This may require you to supply new terminfo and termcap entries.

In addition, you can customize the characteristics of scoterm using your personal X resource file, $HOME/.Xdefaults-hostname, where hostname is the name of the machine on which the client is running. If this file does not exist in your home directory, you will need to create it. Changes made to this file take effect the next time you run scoterm.

The class name for scoterm is ScoTerm. scoterm understands all of the core resource names and classes. Some of the more useful resources are listed here. See /usr/lib/X11/rgb.txt for more information on color resources.


iconGeometry (class: IconGeometry)
specifies the preferred size and position of the application when iconified. The default behavior is specified by the window manager. This resource is not necessarily obeyed by all window managers.

monochrome (class: Monochrome)
is set to ``true'' or ``false''. If ``true'', the scoterm window emulates a monochrome monitor. If ``false'', the window allows color. The default is ``false''. See also the description of the resource useDefaultColormapOnly.

termName (class: TermName)
specifies the terminal type name to be set in the TERM environment variable. The default is scoansi.

title (class: Title)
specifies a string the window manager can use when displaying this application. The default is the name of the scoterm executable file, scoterm.

ttyModes (class: TtyModes)
specifies a string containing terminal setting keywords and the characters to which they may be bound. Allowable keywords include: intr, quit, erase, kill, eof, eol, swtch, start, stop, brk, susp, dsusp, rprnt, flush, weras, and lnext. Control characters may be specified as ^char (for example, ^c or ^u) and ^? can indicate delete. This is very useful for overriding the default terminal settings without having to do an stty every time scoterm is started. Here are examples:
   Scoterm*ttymodes: erase ^H

Scoterm*ttymodes: erase ^H kill ^U

useDefaultColormapOnly (class: UseDefaultColormapOnly)
is set to ``true'' or ``false''. When this resource has a value of ``true'', scoterm draws on the X default color map for colors that are the closest to the standard DOS colors. (If it cannot find a corresponding color in the default map, scoterm uses white.) If this resource is ``false'', scoterm uses the DOS colors. The useDefaultColormapOnly resource is active only when the monochrome resource is set to ``false''.

utmpInhibit (class: UtmpInhibit)
is set to ``true'' or ``false''. This resource specifies whether scoterm should try to record the user's terminal in /etc/utmp. The default is ``false'', and it is set in /usr/lib/X11/app-defaults/Scoterm.

The following resources are specified as part of the SCO ANSI widget (class: Ansi):


allowSendEvents (class AllowSendEvents)
is set to true or false. This resource specifies whether synthetic key and button events (generated using the X protocol SendEvent request) should be interpreted or discarded. The default is ``false'', meaning they are discarded. Note that allowing such events creates a very large security hole.

alwaysHighlight (class: AlwaysHighlight)
is set to ``true'' or ``false''. This resource specifies whether scoterm should always display a highlighted text cursor. The default is ``false'', which means that a hollow text cursor is displayed when the pointer moves out of the window or the window loses the input focus.

altPrefix (class: AltPrefix)
specifies that, when the user presses <Alt> while typing a character, a specified character should be sent as a prefix to the typed character. The value of altPrefix should be the ASCII decimal value of the character that you want to use as a prefix. This resource is active only when the eightBitInput resource is set to false. The default value of this resource is ``null''.

blink (class: Blink)
specifies whether the cursor blinks in the scoterm window. If this resource's value is ``true'', the cursor blinks. If the value is ``false'', the cursor does not blink. The default value is ``false''.

blinkRate (class: BlinkRate)
specifies how fast the cursor blinks in the scoterm window if the blink resource is set to ``true''. The default value is ``400'' (the cursor blinks once every 400 milliseconds).

blue (class: AnsiColors)
specifies a different color name or value that scoterm should use instead of the standard ANSI blue. The color can be any color that your server supports.

boldFont (class: Font)
specifies the name of the default bold font to use instead of overstriking. The default font is ``ibm6x13B''.

boldFont1 (class: Font1)
specifies the name of the bold font to use for the first alternate font instead of overstriking. The default font is ``ibm6x13B''.

boldFont2 (class: Font2)
specifies the name of the bold font to use for the second alternate font instead of overstriking. The default font is ``ibm8x13B''.

boldFont3 (class: Font3)
specifies the name of the bold font to use for the third alternate font instead of overstriking. The default font is ``ibm9x15B''.

boldFont4 (class: Font4)
specifies the name of the bold font to use for the fourth alternate font. The default font is overstriking ``ibm10x20''.

brown (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI brown. The color can be any color that your server supports.

charClass (class: CharClass)
specifies comma-separated lists of character class bindings of the form [low-]high:value. These are used in determining which sets of characters should be treated the same when doing cut and paste. See also ``Character classes'' in this manual page.

cyan (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI cyan. The color can be any color that your server supports.

background (class: Background)
specifies the color to use for the window background and the color name or value to use in place of the standard ANSI black. The default is ``black''. See scocolor(XC) for more information on setting background colors.

foreground (class: Foreground)
specifies the color to use for displaying text in the window. Setting the class name instead of the instance name is an easy way to have everything that would normally appear in the ``text'' color change color. This resource also specifies the color name or value to use in place of the standard ANSI white. The default color is ``white''. See scocolor(XC) for more information on setting foreground colors.

eightBitInput (class: EightBitInput)
specifies whether 8-bit characters are accepted. The default is ``false''. See also the description of the altPrefix resource.

font (class: Font)
specifies the name of the normal font. The default font is ``ibm6x13''.

font1 (class Font1)
specifies the name of the first alternate font. The default font is ``ibm6x13''.

font2 (class: Font2)
specifies the name of the second alternate font. The default font is ``ibm8x13''.

font3 (class: Font3)
specifies the name of the third alternate font. The default font is ``ibm9x15''.

font4 (class Font4)
specifies the name of the fourth alternate font. The default font is ``ibm10x20''.

geometry (class: Geometry)
specifies the preferred size and position of the window.

gray (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI gray. The color can be any color that your server supports.

green (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI green. The color can be any color that your server supports.

hi_white (class: AnsiColors):
specifies a different color name or value to use instead of the standard ANSI hi_white. The color can be any color that your server supports.

internalBorder (class: BorderWidth)
specifies the number of pixels between the characters and the window border. The default is ``2''.

jumpScroll (class: JumpScroll)
is set to ``true'' or ``false''. This resource specifies whether the jump scroll should be used. The default is ``true''. You can enable this feature by selecting Jump scroll from the Display submenu of the Options menu.

keyboard language name (class: Keyboard)
identifies the keyboard language that scoterm emulates. The values are described in the languageFile resource.

languageFile (class: LanguageFile)
identifies scoterm's keyboard language file specifying the supported keyboard languages. The default file is /usr/lib/X11/sco/ScoTerm/LangIndex. The file contains entries of the format: mapkey_file:locale:charset:description, where each entry has the following meaning:

mapkey_file
is a full pathname to a console mapkey file on the system.

locale
is a locale that can be associated with the mapkey_file (optional).

charset
associates a character set name with the mapkey file. The resource *charset can accept any of the values specified in this field.

description
is a string that can be passed to the -keyboard command line option (or *keyboard resource) as a shorthand means of identifying the mapkey_file.

logFile (class: Logfile)
specifies the name of the file to which a terminal session is logged. The default is ScotermLognnnn, where nnnn is the process ID of scoterm.

logging (class: Logging)
is set to ``true'' or ``false''. This resource specifies whether a terminal session should be logged. The default is ``false''.

logInhibit (class: LogInhibit)
is set to ``true'' or ``false''. This resource specifies whether or not terminal session logging should be inhibited from the scoterm. The default is ``false''.

loginShell (class: LoginShell)
specifies whether the shell to be run in the window should be started as a login shell. The default is ``false''.

lt_blue (class: AnsiColors)
specifies a different color name or value that scoterm should use instead of the standard ANSI lt_blue.

lt_cyan (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI lt_cyan.

lt_green (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI lt_green.

lt_magenta (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI lt_magenta.

lt_red (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI lt_red.

magenta (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI magenta.

mapchan (class: Mapchan
specifies the mapchan file automatically installed by scoterm. The following substitutions will be performed on the filename specified by *mapchan:

%L
is the current locale (for example, ``french_france.8859'').

%c
is the codeset part of current locale (for example, ``8859'').

%l
is the language part of current locale (for example, ``french'').

%t
is the territory part of the current locale (for example, ``france'').
The *mapchan resource can be left blank, in which case no mapchan settings are installed when scoterm starts up.

marginBell (class: MarginBell)
is set to ``true'' or ``false''. This resource specifies whether the bell should ring when the user types near the right margin. The default is ``false''.

mergedPTYS (class: MergedPTYS)
is set to ``true'' or ``false''. This resource tells scoterm to use the merged pseudo-tty architecture used by SCO UNIX System V/386 Release 3.2 operating system, Version 4.0. The default is ``true''.

multiClickTime (class: MultiClickTime)
specifies the maximum time in milliseconds between multi-click select events. The default is ``250''.

multiScroll (class: MultiScroll)
specifies whether scrolling should be done asynchronously. The default is ``false''.

MarginBell (class: Column)
specifies the number of characters from the right margin at which the margin bell should ring, when enabled. The default is ``10''.

pointerShape (class: Cursor)
specifies the name of the shape of the pointer. The default is xterm. Here is a list of the other pointer shapes: arrow, based_arrow_down, based_arrow_up, boat, bogosity, bottom_left_corner, bottom_right_corner, bottom_side, bottom_tee, box_spiral, center_ptr, circle, clock, coffee_mug, cross, cross_reverse, crosshair, diamond_cross, dot, dot_box_mask, double_arrow, draft_large, draft_small, draped_box, exchange, fleur, gobbler, gumby, hand, handl_mask, heart, icon, iron_cross, left_ptr, left_side, left_tee, leftbutton, ll_angle, lr_angle, man, middlebutton, mouse, pencil, pirate, plus, question_arrow, right_ptr, right_side, right_tee, rightbutton, trl_logo, sailboat, sb_down_arrow, sb_h_double_arrow, sb_left_arrow, sb_right_arrow, sb_up_arrow, sb_v_double_arrow, shuttle, sizing, spider, spraycan, star, target, tcross, top_left_arrow, top_left_corner, top_right_corner, top_side, top_tee, trek, ul_angle, umbrella, ur_angle, watch, and x_cursor.

reverseVideo (class: ReverseVideo)
is set to ``true'' or ``false''. This resource specifies whether reverse video is simulated. The default is ``false''.

red (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI red.

reverseWrap (class: ReverseWrap)
is set to ``true'' or ``false''. This resource specifies whether users can backspace from the left margin of a line directly to the right-most character on the previous line. The default is ``false''.

saveLines (class: SaveLines)
specifies the number of lines to save beyond the top of the screen when a scroll bar is turned on. The default is ``64''.

scancodesOn (class: scancodesOn)
is set to ``true'' or ``false''. This resource specifies whether scoterm runs in scancode mode. The default is ``true''.

scrollBar (class: ScrollBar)
specifies whether or not the scroll bar is displayed. The default is ``false''.

scrollInput (class: ScrollCond)
specifies whether output to the terminal automatically causes the scroll bar to go to the bottom of the scrolling region. The default is ``true''.

scrollKey (class: ScrollCond)
specifies whether pressing a key automatically causes the scrollbar to go to the bottom of the scrolling region. The default is ``true''.

scrollLines (class: ScrollLines)
specifies the number of lines that the scroll-back and scroll-forward actions use by default. If scrollLines is assigned a value, scroll-back and scroll-forward are set to the same value if they have no arguments of their own. The default value of scrollLines is one line.

titeInhibit (class: TiteInhibit)
is set to ``true'' or ``false''. This resource specifies whether scoterm removes the ti and te termcap entries (used to switch between alternate screens on startup of many screen-oriented programs) from the TERMCAP string. The default is ``false'', meaning that the entries should not be removed.

translations (class: Translations)
specifies the key and button bindings for menus, selections, programmed strings, and so on. See also ``Actions'' later in this manual page for valid resource settings for this resource.

useMenuBar (class: UseMenuBar)
is set to ``true'' or ``false''. If ``true'', the resource specifies that scoterm displays the menu bar when the client starts.

visualBell (class: VisualBell)
is set to ``true'' or ``false''. This resource specifies whether a visible bell that blinks should be used instead of an audible bell (the default) when <Ctrl>G is received. The default is ``false''.

waitForMap (class: WaitForMap)
specifies whether scoterm waits for the initial window map before starting the subprocess. The default is ``true''.

yellow (class: AnsiColors)
specifies a different color name or value to use instead of the standard ANSI yellow.

Actions

scoterm actions can be used within the ANSI translation sources. You can rebind keys (or sequences of keys) to arbitrary strings for input by changing the translations for the SCO ANSI widget. Changing the translations for events other than key and button events is not expected, and can cause unpredictable behavior. Example default bindings are listed at the end of this section. The following scoterm actions can be used within the ANSI translations resources:

bell([percent])
rings the keyboard bell at the specified percentage above or below the base volume.

focus-mouse()
focuses the mouse into the ANSI window.

ignore()
ignores the event but checks for special pointer position escape sequences.

insert()
synonymous for insert-seven-bit().

insert-seven-bit()
inserts the 7-bit USASCII character or string associated with the keysym that was pressed.

insert-eight-bit()
inserts the 8-bit IBM character or string associated with the keysym that was pressed.

insert-selection(sourcename [, ...])
inserts the string found in the selection or cut buffer indicated by sourcename. Sources are checked in the order given (case is significant) until one is found. Commonly used selections include: Primary, Secondary, and Clipboard. Cut buffers are typically named Cut_Buffer0 through Cut_Buffer7.

keymap(name)
dynamically defines a new translation table whose resource name is name with the suffix Keymap (case is significant). The name ``None'' restores the original translation table.

mouse-button-down()
generates an SCO event manager mouse button down event associated with the X Window mouse button that was pressed.

mouse-button-up()
generates an SCO event manager mouse button up event associated with the X Window mouse button that was released.

mouse-motion()
generates an SCO event manager mouse motion event associated with the X Window mouse motion.

popup-menu(menuname)
displays the specified popup menu.

select-start()
begins text selection at the current pointer location.

select-extend()
tracks the pointer and extends the selection. It should only be bound to motion events.

select-end(destname [, ...])
puts the currently selected text into all of the selections or cut buffers specified by destname.

select-cursor-start()
similar to select-start except that it begins the selection at the current text cursor position.

select-cursor-end(destname [, ...])
similar to select-end except that it should be used with select-cursor-start.

set-ansi-font(d/1/2/3/4/e/s [,normalfont,] boldfont]])
sets the font or fonts currently being used in the scoterm window. The first argument is a single character that specifies the font to be used: d or D specifies the default font (the font initially used when scoterm is started); 1 through 4 indicate the fonts specified by the font1 through font4 resources; e or E specifies the normal and bold fonts that can be set through escape codes (or specified as the second and third action arguments, respectively); and s or S specifies the font selection (as made by programs such as xfontsel(XC)) indicated by the second action argument.

start-extend()
similar to select-start except that the selection is extended to the current pointer location.

start-cursor-extend()
similar to select-extend except that the selection is extended to the current text cursor position.

string(string)
inserts the specified text string as if it had been typed. Quotation is necessary if the string contains white space or non-alphanumeric characters. If the string argument begins with the characters ``0x'', it is interpreted as a hex character constant.

scroll-back(count [,units])
scrolls the text window backward so that text that had previously scrolled off the top of the screen is now visible. The count argument specifies the number of units (by page, halfpage, pixel, or line) by which to scroll.

scroll-forw(count [,units])
scrolls similarly to scroll-back except that it scrolls forward.

allow-send-events(on/off/toggle)
sets or toggles the allowSendEvents resource.

set-logging(on/off/toggle)
toggles the logging resource and is invoked by the logging entry in the scoterm file menu.

redraw()
redraws the window and is invoked by the Redraw window item in the File menu

send-signal(signame)
sends the signal named by signame (which can also be a number) to the scoterm subprocess (the shell or program specified with the -e command line option). Allowable signal names are (case is not significant): suspend, tstp (if supported by the operating system), cont (if supported by the operating system), int, hup, term, and kill.

quit()
sends a SIGHUP to the subprogram and exits. It is also invoked by Exit in the File menu.

set-scrollbar(on/off/toggle)
sets or toggles the scroll bar resource.

set-jumpscroll(on/off/toggle)
sets or toggles the jumpscroll resource and is invoked by the Jump scroll item in the Display submenu of the Options menu

set-reverse-video(on/off/toggle)
sets or toggles the reverseVideo resource.

set-autowrap(on/off/toggle)
sets or toggles automatic wrapping of long lines and is invoked by the Auto wraparound item in the Display submenu of the Options menu.

set-reversewrap(on/off/toggle)
sets or toggles the reverseWrap resource and is invoked by the Reverse wraparound item in the Display submenu of the Options menu.

set-autolinefeed(on/off/toggle)
sets or toggles automatic insertion of linefeeds and is invoked by the Auto linefeed item in the Display submenu of the Options menu.

set-scroll-on-key(on/off/toggle)
sets or toggles the scrollKey resource.

set-scroll-on-tty-output(on/off/toggle)
sets or toggles the scrollTtyOutput resource and is invoked through the ``Jump to bottom when key pressed'' item in the Display submenu of the Options menu.

set-visual-bell(on/off/toggle)
sets or toggles the visualBell resource and is invoked from the Visual Bell item in the Display submenu of in the Options menu.

set-marginbell(on/off/toggle)
sets or toggles the marginBell resource and is invoked from the Margin bell item in the Display submenu of the Options menu.

set-altscreen(on/off/toggle)
sets or toggles between the alternative and current screens.

soft-reset()
resets the scrolling region and is invoked from the Reset (soft) item in the File menu.

hard-reset()
resets the scrolling region, tabs, window size, and cursor keys; reinitializes the keyboard; restores the default sprite (for example, the mouse cursor); and clears the screen. It is invoked from the Reset (full) item in the File menu.

The default bindings in the scoterm window are:

   ! Ctrl Alt <Key>BackSpace:focus-mouse()   \n\
   ! Ctrl <Btn1Down>:    popup-menu(mainMenu)    \n\
   ! Ctrl <Btn2Down>:    popup-menu(ansiMenu)    \n\
   ! Ctrl <Btn3Down>:    popup-menu(fontMenu)    \n\
   ! Shift Ctrl <Btn1Down>:  popup-menu(mainMenu)\n\
   ! Shift Ctrl <Btn2Down>:  popup-menu(ansiMenu)\n\
   ! Shift Ctrl <Btn3Down>:  popup-menu(fontMenu)\n\
   ! Shift <Key>Prior:   scroll-back(1,halfpage) \n\
   ! Shift <Key>Next:    scroll-forw(1,halfpage) \n\
   ! Shift <Key>Select:  select-cursor-start() \
                         select-cursor-end(PRIMARY, CUT_BUFFER0) \n\
   ! Shift <Key>Insert:  insert-selection(PRIMARY, CUT_BUFFER0)  \n\
   Alt <KeyPress>:       insert-eight-bit() \n\
   Meta <KeyPress>:      insert-eight-bit() \n\
   ~Alt <KeyPress>:      insert-seven-bit() \n\
   ~Meta <KeyPress>:     insert-seven-bit() \n\
   <KeyRelease>:         insert-seven-bit() \n\
   Shift <Btn2Up>:       insert-selection(PRIMARY, CUT_BUFFER0) \n\
   Shift <Btn1Down>:     select-start()	\n\
   Shift <Btn1Motion>:   select-extend() \n\
   Shift <Btn3Down>:     start-extend()	\n\
   Shift <Btn3Motion>:   select-extend()	\n\
   Shift <BtnUp>:        select-end(PRIMARY, CUT_BUFFER0) \n\
   ~Shift <Btn2Up>:      insert-selection(PRIMARY, CUT_BUFFER0) \n\
   ~Shift <Btn1Down>:    select-start()	\n\
   ~Shift <Btn1Motion>:  select-extend() \n\
   ~Shift <Btn3Down>:    start-extend()	\n\
   ~Shift <Btn3Motion>:  select-extend()	\n\
   ~Shift <BtnUp>:       select-end(PRIMARY, CUT_BUFFER0)

The following is an example of how the keymap() action adds special keys for entering commonly typed words:

   *Ansi.Translations: #override <Key>F5: keymap(dbx)
   *Ansi.dbxKeymap.translations: \
      <Key>F6:    keymap(None) \n\
      <Key>F9:    string("next") string("0x0d") \n\
      <Key>F10:   string("step") string("0x0d") \n\
      <Key>F11:   string("continue") string("0x0d") \n\
      <Key>F12:   string("print ") \
                      insert-selection(PRIMARY, CUT_BUFFER0)

Compatibility with earlier releases

In previous releases, on European keyboards the arrow keys moved the cursor on the screen. (Although it should be noted that the cursor movement did not support screen editing.) Arrow keys now echo control characters to the screen instead of moving the cursor. You can enter the following command to return the behavior to that expected in previous releases:
   stty cs6

See also

resize(1), showrgb(1), scocolor(XC), showrgb(X), termcap(F), tty(C), xlsfonts(XC), xlsfonts(1), X(X)
© 2007 The SCO Group, Inc. All rights reserved.
SCO OpenServer Release 6.0.0 -- 05 June 2007