Provided by: vtwm_5.4.7-7_amd64 bug

NAME

       vtwm - Virtual Tab Window Manager for the X Window System

SYNOPSIS

       vtwm [ -d display ] [ -f initfile ] [ -m [ m4-options ] ] [ -p ] [ -s ] [ -v ]

DESCRIPTION

       vtwm  is a window manager for the X Window System.  It provides titlebars, shaped windows,
       several forms of icon management, user-defined macro functions, click-to-type and pointer-
       driven keyboard focus, and user-specified key and pointer button bindings.

       This  program  is  usually  started by the user's session manager or startup script.  When
       used from xdm(1) or xinit(1) without a session manager, vtwm is frequently executed in the
       foreground  as  the last client.  When run this way, exiting vtwm causes the session to be
       terminated (i.e., logged out).

       By default, application windows are surrounded by a border with a  titlebar  at  the  top.
       The titlebar contains the window's name, a rectangular area that indicates when the window
       is receiving keyboard input,  and  three  function  boxes  known  as  "titlebar  buttons".
       Pressing  pointer  Button1  (usually  the left-most button unless it has been changed with
       xmodmap(1)) on any of these titlebar features will invoke  the  function  associated  with
       them.

       With  the  default  interface,  windows  are  iconified  by  clicking  (pressing  and then
       immediately releasing) the titlebar button that looks like a dot.  Conversely, windows are
       deiconified  by  clicking  in  the  associated  icon or entry in the icon manager (see the
       descriptions of the  variable  ShowIconManager  and  the  function  f.showiconmgr  in  the
       BINDINGS section).

       Windows  are  resized  by  pressing  the  titlebar button that resembles a group of nested
       squares, dragging the pointer over the edge that is to be moved, and releasing the pointer
       when  the  window  is  the  desired size.  Similarly, windows are moved by pressing in the
       title or highlight area, dragging it to the new location,  and  then  releasing  when  the
       window  is  in  the desired position.  Just clicking in the title or highlight area raises
       the window without moving it.

       Pressing the titlebar button with the down arrow in it brings up a menu  with  many  other
       functions that may be applied to the window.

       When  new windows are created, vtwm will honor any size and location information requested
       by the user (usually through -geometry command line argument  or  X11  resources  for  the
       individual  applications).   With the default configuration, Clicking pointer Button1 will
       position the window at the current position  and  give  it  the  default  size.   Pressing
       pointer  Button2 (usually the middle pointer button) and dragging the window will give the
       window its current position but  allow  the  sides  to  be  resized  as  described  above.
       Clicking  pointer  Button3  (usually  the  right  pointer button) will give the window its
       current position but attempt to make it long enough to touch the bottom of the screen.

       The default behavior during these operations is to represent the window with an outline of
       the   client   window   and  its  titlebar,  lines  crossing  within  the  client  window.
       Alternatively, vtwm may be configured to  draw  the  window  completely,  but  it  is  not
       recommended unless yours is a fast system.

THE VIRTUAL DESKTOP

       vtwm  is based upon the twm(1) window manager, but adds extra functionality in the form of
       a virtual desktop.  The virtual desktop is an area larger than the  physical  screen.  The
       real  screen  is  considered  to  be a window onto portions of the virtual desktop showing
       whatever windows are present in that area of the desktop.   To help  navigate  around  the
       desktop,  vtwm  creates  a  new  window,  of the name VTWM Desktop, which shows the entire
       desktop using a small scale.  In the Virtual Desktop window, all windows  that  exist  are
       displayed  and  various  options  are  provided to recognize the identity of the different
       windows   (see   the   descriptions    of    the    variables    DesktopDisplayBackground,
       DesktopDisplayForeground, DesktopDisplayBorder and VirtualDesktopFont).

       To provide a consistent workspace, the option is provided of nailing windows onto the real
       screen.  When a window is nailed, it is considered stuck to the real screen no matter what
       part of the desktop is currently being displayed.

       Normally,  a few standard utilities are nailed down: the icon manager, the desktop view, a
       load average chart, a clock, and a mail notifier.  The  f.nail  (or  its  alias,  f.stick)
       function  can  be used to change the nailed status of any window; see the BINDINGS section
       for details.

       The root window of the display  is  unchanged  by  this  program  and  utilities  such  as
       xsetroot(1) will continue to work unmodified.

OPTIONS

       vtwm accepts the following command line options:

       -d display     This option specifies the X server to use.

       -f [initfile]  This  option  specifies  the  name of the startup file to use.  By default,
                      vtwm will look in the user's home  directory  for  files  named  .vtwmrc.N,
                      .vtwmrc, .twmrc.N, or .twmrc (where 'N' is a screen number).  It also looks
                      for system-wide default files; see  the  CUSTOMIZATION  section  below  for
                      details.  If  initfile  is  not  provided,  this specifies that vtwm should
                      disregard any startup files it finds, and use only the  defaults  that  are
                      compiled in (intended for testing compiled-in defaults).

       -m [options]   This  option  causes  vtwm  to  preprocess the startup file using the m4(1)
                      macro processor. The options will be passed verbatim to m4 along with those
                      symbols  that vtwm declares.  Note that options itself should be quoted, to
                      prevent unwanted processing that may occur by the shell, etc.

       -p             This option indicates that  vtwm  should  attempt  to  write  it's  PID  to
                      $HOME/vtwm.pid on startup, and delete that file on shutdown.  This file may
                      be useful as a lock file, or for determining the correct vtwm process for a
                      particular  user.   If  the  file cannot be written on startup, a bell will
                      sound, but vtwm will continue.

       -s             This option indicates that only the default screen (as specified by the  -d
                      option  or  by  the  DISPLAY  environment  variable) should be managed.  By
                      default, vtwm will attempt to manage all screens on the display.

       -v             This option indicates that vtwm should print messages to the stderr  device
                      when  an  unexpected  event  occurs.   This  can be be useful for debugging
                      applications, but may be distracting in regular use.

CUSTOMIZATION

       Much of vtwm's appearance and behavior can be controlled by providing a  startup  file  in
       one  of the following locations (searched in order for each screen being managed when vtwm
       begins):

       $HOME/.vtwmrc.screennumber
               The screennumber is a small positive number (e.g., 0, 1, etc.)   representing  the
               screen  number  (e.g.,  the  last  number  in  the  DISPLAY  environment  variable
               host:displaynum.screennum) that would be  used  to  contact  that  screen  of  the
               display.   This is intended for displays with multiple screens of differing visual
               types.

       $HOME/.vtwmrc
               This is the usual name for an individual user's startup file.

       $VTWMDIR/twm/system.vtwmrc
               If neither of the preceding files are found, vtwm will look in  this  file  for  a
               default  configuration.   Note  that the variable is defined only in the Makefile,
               and is often set and tailored by the  site  administrator  to  provide  convenient
               menus or familiar bindings for novice users.

       $HOME/.twmrc.screennumber

       $HOME/.twmrc

       $VTWMDIR/twm/system.twmrc
               When  none  of the .vtwmrc files can be found, vtwm reverts to acting like twm(1),
               and searches for these three .twmrc variants.  Note that the variable  is  defined
               only in the Makefile.

       This   search  algorithm  allows  both  twm(1)  and  vtwm  to  coexist  peacefully  at  an
       installation.  Since vtwm is a superset of twm(1), it can even used to replace the latter,
       and users who have only a .twmrc-style file should not notice much difference.

       If  no  startup files are found, or if vtwm is told to ignore them, vtwm will use built-in
       defaults as described in the DESCRIPTION section above, though the system.vtwmrc file,  if
       re-configured  before  the  build,  may  intervene.  The only X11 resource used by vtwm is
       bitmapFilePath for a colon-separated list of directories to search when looking for bitmap
       and pixmap files (for more information, see the Athena Widgets manual and xrdb(1)).

       vtwm startup files are logically broken up into three types of specifications:  Variables,
       Bindings, Menus.

       The Variables section must come first and is used to describe the fonts, colors,  cursors,
       border  widths,  icon  and  window placement, highlighting, autoraising, layout of titles,
       warping, and use of the icon manager.

       The Bindings section usually comes second and is used to specify the functions that should
       be  to be invoked when keyboard and pointer buttons are pressed in windows, icons, titles,
       and frames.

       The Menus section gives any user-defined menus (containing  functions  to  be  invoked  or
       commands to be executed).

       Variable  names  and  keywords are case-insensitive.  Strings must be surrounded by double
       quote characters (e.g., "blue") and are case-sensitive.  A sharp sign ('#') outside  of  a
       string  causes the remainder of the line in which the character appears to be treated as a
       comment.

M4 PREPROCESSING

       A powerful feature of vtwm as of version 5.4.6 is that it can  use  m4(1)  to  pre-process
       it's  startup  files.   When  vtwm  is  started  with -m, it will open a file for input as
       described above, but will process that file through m4 before parsing it.  So, you can use
       m4  macros to perform operations at runtime.  This makes it very easy to work when you use
       many different displays, etc.  For example, if you want to set the lower right section  of
       the  screen  to  be  your IconRegion, you can use m4 directives and pre-defined symbols to
       calculate the region you want:
           define(IRegion, translit(eval(WIDTH/3)*eval(HEIGHT/2)+eval(WIDTH-WIDTH/3)-0, *, x))
           IconRegion  "IRegion" SOUTH EAST 75 25
       will define the lower half, and right-hand third of the screen.   The  symbols  WIDTH  and
       HEIGHT  are  calculated  by  vtwm for m4 to use.  The following symbols are pre-defined by
       vtwm:

       SERVERHOST     This variable is set to the name of the  machine  that  is  running  the  X
                      server.

       CLIENTHOST     The machine that is running the X clients (i.e., "vtwm", "xterm", etc.).

       HOSTNAME       The canonical hostname running the clients (i.e., a fully-qualified version
                      of CLIENTHOST).

       USER           The name of the user running the program.  Gotten from the environment.

       HOME           The user's home directory.  Gotten from the environment.

       VERSION        The X major protocol version.  As seen by ProtocolVersion().

       REVISION       The X minor protocol revision.  As seen by ProtocolRevision().

       VENDOR         The vendor of your X server (i.e., "MIT X Consortium").

       RELEASE        The release number of your X server.  For MIT X11R5, this is "5".

       WIDTH          The width of your display in pixels.

       HEIGHT         The height of your display in pixels.

       X_RESOLUTION   The X resolution of your display in pixels per meter.

       Y_RESOLUTION   The Y resolution of your display in pixels per meter.

       PLANES         The number of bit planes your display supports in the default root window.

       BITS_PER_RGB   The number of significant bits in an RGB color.  (log base 2 of the  number
                      of  distinct  colors that can be created.  This is often different from the
                      number of colors that can be displayed at once.)

       TWM_TYPE       Tells which twm derivative is running.  It will always be set to "vtwm"  in
                      this  program.   This  is  useful for protecting parts of your startup file
                      that twm proper won't understand (like VirtualDesktop) so that it is  still
                      usable with other twm-based programs.

       CLASS          Your   visual   class.   Will  return  one  of  "StaticGray",  "GrayScale",
                      "StaticColor", "PseudoColor", "TrueColor", "DirectColor", or, if it  cannot
                      determine what you have, "NonStandard".

       COLOR          This will be either "Yes" or "No".  This is just a wrapper around the above
                      definition.  Returns "Yes"  on  "*Color",  and  "No"  on  "StaticGray"  and
                      "GrayScale".

       I18N           This  will  be  either  "Yes"  or  "No"  depending  on  whether support for
                      internationalization has been compiled in.

       XPM            This will be either "Yes" or "No" depending on whether support  for  pixmap
                      image files has been compiled in.

       SOUND          This  will  be  either "Yes" or "No" depending on whether support for sound
                      has been compiled in.

       REGEX          This will be either "Yes" or "No" depending on whether support for  regular
                      expressions ("RE"s) has been compiled in.

       Note  that  any symbols passed to m4 on the command line that conflict with these will not
       be anticipated or dealt with by vtwm; you will be at the mercy of your particular m4.

       Note also that if vtwm's preparation for executing m4 fails,  the  startup  file  will  be
       processed normally, and will choke on the first m4 macro encountered.

       Finally,  be  aware that m4 preprocessing can cause things often found in startup files to
       break.  For example, quotes and backquotes in shell commands will be badly  messed  up  by
       m4's  own  internal  quoting  mechanism.   This particular problem can be worked around by
       placing changequote(,) at the top of your startup file.

       Invoking vtwm with both the -m and -v options will print the m4 command with  all  symbols
       expanded.

VARIABLES

       Many  of  the aspects of vtwm's user interface are controlled by variables that may be set
       in the user's startup file.  Some of the options are enabled or  disabled  simply  by  the
       presence  of  a  particular keyword.  Other options require keywords, numbers, strings, or
       lists of all of these.

       Lists are surrounded by braces and are usually separated by whitespace or a newline.   For
       example:
           AutoRaise { "emacs" "VTWM*" "x*clock" "Xmh" "XTerm" }
       or
           AutoRaise
           {
               "emacs"
               "VTWM*"
               "x*clock"
               "Xmh"
               "XTerm"
           }

       When  a  variable  containing a list of strings representing windows is searched (e.g., to
       determine whether or not to enable autoraise as shown above), a string  must  be  a  case-
       sensitive  match to the window's name (given by the WM_NAME window property), or the class
       name or class class (both given by the WM_CLASS window property).  The  preceding  example
       would  enable  autoraise  on  windows named "emacs", all vtwm-specific windows, any clocks
       installed whose name starts with an 'x' (asclock will not  autoraise),  and  all  xmh  and
       xterm  windows  (which  are  of class "XTerm" and "Xmh", respectively).  See the WILDCARDS
       section for details on what the asterisks ('*') mean.

       String arguments that  are  interpreted  as  filenames  (see  the  Pixmaps,  Cursors,  and
       IconDirectory  variables  below)  will prepend the user's directory (specified by the HOME
       environment variable) if the first character is a tilde ('~').   If,  instead,  the  first
       character  is  a  colon (':'), the name is assumed to refer to one of the internal bitmaps
       that are used to create 2D titlebar buttons, the 2D icon manager button, and the  2D  menu
       pull-right  icon.   Finally, if the first five characters are ":xpm:", the name is assumed
       to refer to one of the built-in pixmaps that can used to create 3D titlebar  buttons,  the
       3D  icon manager button, and the 3D menu pull-right icon.  See the IMAGE AND AUDIO FORMATS
       section for further details.

       The following variables may be specified in the vtwm startup file.  Lists of window  names
       are  indicated  by  win-list,  and  optional  arguments  are shown in square brackets. Any
       default values are based on the distributed system.vtwmrc files, and if none is mentioned,
       the default setting is "off", "disabled", or "none".

       AppletRegion geomstr vgrav hgrav hgrid vgrid { win-list }
              This  variable  specifies an area on the root window in which the windows listed in
              win-list are placed.  The geomstr is a quoted string containing a standard geometry
              specification  for  the region size and location.  If more than one AppletRegion is
              specified, windows will be put into succeeding regions that have the window  listed
              when  the first is full.  The vgrav argument should be either North or South and is
              used to control whether windows are first filled in from the top or bottom  of  the
              region.  Similarly, the hgrav argument should be either East or West and is used to
              control whether windows should be filled in from the left or  right.   Windows  are
              laid  out  in a grid with cells hgrid pixels wide and vgrid pixels high.  Note that
              the smallest dimension of the region must be at  least  the  size  of  the  largest
              window  in  it, including frame and titlebar, in the same direction.  This variable
              is intended to simplify management of  all  those  little  tool  applications  like
              xcb(1), xbiff(1), xload(1), etc. that are used regularly.

       AutoPan N
               This  variable  allows the screen to automatically pan by N% of a real screen when
               the pointer approaches the edge of the screen. The pan will be in the direction of
               the  edge  approached. The default is 100, effectively "paging" across the virtual
               desktop.

       AutoPanBorderWidth pixels
               If AutoPan is turned on, when the pointer goes  within  the  specified  number  of
               pixels of the real screen's border, the screen is panned.  The default value is 5.

       AutoPanExtraWarp pixels
               If  AutoPan  is  turned  on  and  NaturalAutopanBehavior turned off, this variable
               specifies how far, in pixels, you want the pointer to move  away  from  the  inner
               edge of the autopan border when autopanning.  The default value is 2 pixels.

       AutoPanWarpWithRespectToRealScreen N
               With this option turned on, the pointer is warped by N% as many pixels on the real
               screen as the screen is scrolled, or by
                   (AutoPanBorderWidth + AutoPanExtraWarp)
               pixels, whichever is greater.  See  NaturalAutopanBehavior  for  a  more  thorough
               discussion of this and some recommended settings.

       AutoRaise [{ win-list }]
               This  variable specifies a list of windows (all windows if win-list is omitted) to
               be automatically raised whenever the pointer has come to rest in a window for  the
               amount  of  time  specified  by  the  RaiseDelay  variable.   This  action  can be
               interactively enabled  or  disabled  on  individual  windows  using  the  function
               f.autoraise.

       AutoRaiseDelay milliseconds
               A synonym for RaiseDelay.

       AutoRelativeResize
               This  variable  indicates  that  dragging out a window size (either when initially
               sizing the window with pointer Button2 or when resizing it) should not wait  until
               the   pointer   has  crossed  the  window  edges.   Instead,  moving  the  pointer
               automatically causes the nearest edge or edges to move by the same  amount.   This
               allows  the  resizing  windows  that  extend  off  the edge of the screen.  If the
               pointer is in the center of the window, or if the resize is begun  by  pressing  a
               titlebar  button,  vtwm will still wait for the pointer to cross a window edge (to
               prevent accidents).  This option is particularly useful for people  who  like  the
               press-drag-release method of sweeping out window sizes.

       BeNiceToColormap
               This  variable specifies that stippled lines be used for the bevel colors when any
               of the 3D variables are set, to conserve on colormap allocations.

       BorderBevelWidth pixels
               Tells vtwm to use 3D-looking window borders, and specifies the width in pixels  of
               the  bevel. The color of the 3D border is BorderTileBackground, and if NoHighlight
               is not selected, the border of the Focus window is BorderColor.  The default is  0
               if vtwm is built with 2D features, or 2 when vtwm is built with 3D features.

       BorderColor string [{ wincolorlist }]
               This  variable  specifies  the default color of the border to be placed around all
               non-iconified windows, and may only be given within a Color  or  Monochrome  list.
               The  optional  wincolorlist  specifies  a  list of window and color name pairs for
               specifying particular border colors for different types of windows.  For example:
                   BorderColor    "gray50"
                   {
                       "XTerm"    "red"
                       "xmh"      "green"
                   }

               The default is "gray70".

       BorderTileBackground string [{ wincolorlist }]
               This variable specifies the default background color in the gray pattern  used  in
               unhighlighted borders (only if NoHighlight hasn't been set), and may only be given
               within a Color or Monochrome list.  The optional  wincolorlist  allows  per-window
               colors to be specified.  The default is "gray60".

       BorderTileForeground string [{ wincolorlist }]
               This  variable  specifies the default foreground color in the gray pattern used in
               unhighlighted borders (only if NoHighlight hasn't been set), and may only be given
               within  a  Color  or Monochrome list.  The optional wincolorlist allows per-window
               colors to be specified.  The default is "gray60".

       BorderWidth pixels
               This variable specifies the width in pixels of the border surrounding  all  client
               window  frames  if  ClientBorderWidth  has not been specified.  This value is also
               used to set the border size of windows created by vtwm (such as the icon manager).
               The  default  is 2 if vtwm is built with 2D features, or 6 when vtwm is built with
               3D features.

       ButtonBevelWidth pixels
               Tells vtwm to use 3D-looking window buttons. It specifies the width in  pixels  of
               the  bevel.  The default is 0 if vtwm is built with 2D features, or 1 when vtwm is
               built with 3D features.

       ButtonIndent pixels
               This variable specifies the size of titlebar buttons, expressed  as  a  difference
               from  the  titlebar  font  height,  and  normally means that titlebar buttons will
               shrink (built-in images) or be cropped (external images) accordingly.  A  negative
               value is accepted, however, indicating that titlebar buttons should be larger than
               the  titlebar  font.  Setting  this  to  a  negated   FramePadding   value,   with
               TitleButtonBorderWidth  set  to  0,  makes  titlebar  buttons  as tall and wide as
               possible. The default is 0 if vtwm is built with with 2D features, or -2 when vtwm
               is built with 3D features.

       ButtonColorIsFrame
               This  variable  specifies  that the titlebar buttons will be the same color as the
               window frame. It is set by default if vtwm is built with 3D features.

       ClearBevelContrast contrast
               Indicates to vtwm how to calculate the clear bevel color for 3D items.  The  value
               is a compressed to the range 0 and 100. The formula used is:
                   clear.{RGB} = (65535 - color.{RGB}) * (contrast / 100)

               The default is 40 if vtwm is built with 3D features.

       ClientBorderWidth
               This variable indicates that width of a window's frame should be set to the border
               width as specified by the client, rather than to  the  value  of  BorderWidth.  If
               BorderBevelWidth is non-zero, however, this variable is ignored.

       Color { colors-list }
               This  variable  specifies  a  list  of color assignments to be made if the default
               display is capable of displaying more than simple black and  white.   The  colors-
               list   is   made   up   of   the  following  color  variables  and  their  values:
               DefaultBackground,     DefaultForeground,     MenuBackground,      MenuForeground,
               MenuTitleBackground,  MenuTitleForeground,  and  MenuShadowColor.   The  following
               color variables may also be given a list of window and color name pairs  to  allow
               per-window  colors  to  be  specified  (see BorderColor for details): BorderColor,
               DesktopDisplayForeground,     DesktopDisplayBackground,      RealScreenForeground,
               RealScreenBackground,  VirtualForeground, VirtualBackground, DekstopDisplayBorder,
               IconManagerHighlight,        BorderTitleBackground,         BorderTitleForeground,
               TitleBackground, TitleForeground, IconBackground, IconForeground, IconBorderColor,
               IconManagerBackground, and IconManagerForeground.  For example:
                   Color
                   {
                       MenuBackground     "gray50"
                       MenuForeground     "blue"
                       BorderColor        "red"
                       {
                           "XTerm"        "yellow"
                       }
                       TitleForeground    "yellow"
                       TitleBackground    "blue"
                   }

               All of these color variables may also be specified for  the  Monochrome  variable,
               allowing  the  same  initialization  file  to be used on both color and monochrome
               displays.

       ConstrainedMoveTime milliseconds
               This variable specifies the length of time between button clicks needed to begin a
               constrained  move  operation.  Double  clicking  within  this  amount of time when
               invoking f.move will cause the window only to be moved in a horizontal or vertical
               direction.   Setting  this value to 0 will disable constrained moves.  The default
               is 400 milliseconds.

       Cursors { cursor-list }
               This variable specifies the glyphs  that  vtwm  should  use  for  various  pointer
               cursors.   Each  cursor  may  be  defined  either from the cursor font or from two
               bitmap files.  Shapes from the cursor font may be specified directly as:
                   cursorname    "string"
               where cursorname is one of the cursor names listed below, and string is  the  name
               of  a  glyph as found in the file /usr/include/X11/cursorfont.h (without the "XC_"
               prefix).  If the cursor is to be defined from bitmap files, the  following  syntax
               is used instead:
                   cursorname    "image"    "mask"
               where  image  and  mask  specify the names of files containing the glyph image and
               mask in bitmap(1) form.  The bitmap files are located in the same manner  as  icon
               bitmap files.  The following example shows the default cursor definitions:
                   Cursors
                   {
                       Frame      "top_left_arrow"
                       Title      "top_left_arrow"
                       Icon       "top_left_arrow"
                       IconMgr    "top_left_arrow"
                       Move       "fleur"
                       Resize     "fleur"
                       Menu       "sb_left_arrow"
                       Button     "hand2"
                       Wait       "watch"
                       Select     "dot"
                       Destroy    "pirate"
                       Door       "exchange"
                       Virtual    "rtl_logo"
                       Desktop    "dotbox"
                   }

       DarkBevelContrast contrast
               Indicates  to  vtwm has to calculate the dark bevel color for 3D items.  The value
               is a comprised between 0 and 100. The formula used is:
                   dark.{RGB} = color.{RGB} * ((100 - contrast) / 100)

               The default is 40 if vtwm is built with 3D features.

       DecorateTransients
               This   variable   indicates   that   transient   windows   (those   containing   a
               WM_TRANSIENT_FOR  property) should have titlebars.  By default, transients are not
               reparented.

       DefaultBackground string
               This variable specifies the background color to be used for sizing and information
               windows.   The  default  is "maroon" for color displays or "gray50" for monochrome
               displays.

       DefaultForeground string
               This variable specifies the foreground color to be used for sizing and information
               windows.  The default is "gray85".

       DeiconifyToScreen
               When  deiconifying a window, by default, the window will be placed at its previous
               geometry in the virtual desktop. With this variable set,  vtwm  ensures  that  the
               window will be placed somewhere on the real screen.

       DesktopDisplayBackground color [{ win-list }]
               This  variable  sets  the  backgrounds  of  the  little windows inside the Virtual
               Desktop window, AND it sets the backgrounds of menu entries in  the  VTWM  Windows
               menu -- unless you specify OldFashionedVtwmWindowsMenu.  The default color is used
               for the default background of windows not named in the list.   The  optional  win-
               list is a list of window names and colors, for example:
                   DesktopDisplayBackground    "purple"
                   {
                       "zwgc"                  "green"
                   }

               The default is "gray60".

       DesktopDisplayBorder color [{ win-list }]
               This  variable  sets the border color in the virtual desktop representation window
               to color.  The win-list is in the same format as TitleForeground and other similar
               variables.
                   DesktopDisplayBorder    "black"
                   {
                       "zwgc"              "green"
                   }

               The default is "black".

       DesktopDisplayForeground color [{ win-list }]
               If  both  this  and the VirtualDesktopFont variable are set, then the names of the
               windows will be written in the window representations shown in the desktop.   This
               entry  also  sets  foreground  colors  for  entries in the VTWM Windows menu.  The
               format of this variable is the same as  that  used  for  DesktopDisplayBackground.
               The default is "gray85".

       DontDeiconifyTransients
               This  variable sees that iconified transient windows of an iconified parent window
               aren't deiconified when that parent is,  thus  preserving  their  state.   Default
               behavior  is  to deiconify all transient subwindows of the ancestor window when it
               is deiconified.

       DontIconifyByUnmapping { win-list }
               This variable specifies a list of windows that should not be iconified  by  simply
               unmapping  the  window  (as would be the case if IconifyByUnmapping had been set).
               This is frequently used to force some windows to be treated as icons  while  other
               windows are handled by the icon manager.

       DontInterpolateTitles
               This  variable specifies a modification to the InterpolateMenuColors behavior.  It
               will cause vtwm to not apply color interpolation to any titles in  the  middle  of
               the  menu.  So, f.title strings that appear in the middle of the menu (ie, without
               a specific color defined for them) will inherit the default  MenuTitle  foreground
               and background colors.

       DontMoveOff
               This  variable  indicates  that  windows should not be allowed to be moved off the
               screen.  It can be overridden by the f.forcemove function.

       DontShowInDisplay { list }
               This variable specifies a list of clients that should not appear  in  the  desktop
               display.  The default is:
                   DontShowInDisplay
                   {
                       "VTWM *"
                       "xclock"
                       "xload"
                   }

       DontShowInTwmWindows { list }

       DontShowInVtwmWindows { list }
               These  variables  specify  a  list  of  clients that should not appear in the VTWM
               Windows menu.

       DontSqueezeTitle [{ win-list }]
               This variable indicates that titlebars should not be  squeezed  to  their  minimum
               size  as  described  under  SqueezeTitle  below.   If  the optional window list is
               supplied, only those windows will be prevented from being squeezed.

       DoorBackground color [{ door-list }]
               Specifies background colors of doors. The default is "maroon" for  color  displays
               or "gray50" for monochrome displays.

       DoorBevelWidth pixels
               Tells  vtwm  to  use  3D-looking  doors,  and specifies the width in pixels of the
               bevel. The default is 0 if vtwm is built with 2D features, or 1 when vtwm is built
               with 3D features.

       DoorFont string
               This  variable  specifies the font to be used for text in doors.  This must be set
               in  order  to  see  the   doors.    The   default   is   "-adobe-helvetica-bold-r-
               normal--*-100-*-*-*-*-*-*".

       DoorForeground color [{ door-list }]
               Specifies foreground colors of doors. The default is "gray85".

       Doors { door-list }
               This  variable  is  used  to  create doors, which are teleports.  Each item in the
               door-list has the following format:
                   "winname"    "location"    "jumpTo"

               Windows with the name winname appear with geometry  and  position  as  defined  in
               location,  and  warp  the user to jumpTo when f.enterdoor is executed inside them.
               Doors have a class of "VTWM Door".

       EnhancedExecResources
               By default, f.exec variables behaved as they always did in vtwm.  You  would  have
               to  append " &" to all of your variables in order to execute them without blocking
               the window manager.  With this option turned on, you  don't  have  to;  vtwm  will
               automatically  append  "  &"  to  the  f.exec  variable  unless the last non-space
               character is either '&' or (in case you still want a command to block  the  window
               manager) ';'. For example, in a variable such as:
                   f.exec "foo; bar; baz"
               the  window manager will be blocked so that "foo" and "bar" can be executed; "baz"
               is the only command which will NOT block the window  manager.   If  you  want  all
               these commands to be backgrounded, try the following:
                   f.exec "{ foo; bar; baz }" # note that "{" and "}"
                                              # are shell keywords; they
                                              # MUST be separated by
                                              # spaces.

               If you still want a command to block the window manager, you would use:
                   f.exec "xset fp rehash;" # vtwm will not append " &"
                                            # because ';' is the last
                                            # non-space character.

               This  behavior  was  inspired  by  that  of  vuewm(1), Hewlett-Packard's workspace
               implementation of mwm(1).

       FixManagedVirtualGeometries

       FixTransientVirtualGeometries
               These are bug  workarounds  that  *should*  fix  the  way  most  windows'  virtual
               geometries  are  handled,  i.e.,  they  should be on the real screen if the parent
               windows are on the real screen, no matter where the virtual desktop is  (xv(1)  is
               one example of how these don't work).  They are both set by default.

       ForceIcons
               This  variable  indicates  that  icon  image files specified in the Icons variable
               should override any client-supplied images.

       FramePadding pixels
               This variable specifies the distance between the titlebar  font  or  the  titlebar
               button  height, whichever is greater, and the window frame, enlarging the titlebar
               as required. See also ButtonIndent,  for  how  it  influences  the  titlebar.  The
               default is 2 pixels.

       IconBackground string [{ win-list }]
               This  variable  specifies the background color of icons, and may only be specified
               inside of a Color or Monochrome list.  The optional win-list is a list  of  window
               names  and colors so that per-window colors may be specified.  See the BorderColor
               variable for a complete description of the win-list.  The default is "maroon"  for
               color displays or "gray50" for monochrome displays.

       IconBevelWidth pixels
               Tells  vtwm  to  use  3D-looking  icons,  and specifies the width in pixels of the
               bevel.  The default is 0 if vtwm is built with 2D features,  or  2  when  vtwm  is
               built with 3D features.

       IconBorderColor string [{ win-list }]
               This  variable  specifies  the  color of the border used for icon windows, and may
               only be specified inside of a Color or Monochrome list.  The optional win-list  is
               a list of window names and colors so that per-window colors may be specified.  See
               the BorderColor variable for a complete description of the win-list.  The  default
               is "gray85".

       IconBorderWidth pixels
               This  variable  specifies  the  width  in  pixels  of  the border surrounding icon
               windows.  The default is 2 if vtwm is built with 2D features, or 0  when  vtwm  is
               built with 3D features.

       IconDirectory string
               This  variable  specifies  the  directory that should be searched if an image file
               cannot be found in any of the directories in the bitmapFilePath variable.

       IconFont string
               This variable specifies the font to be used to display icon  names  within  icons.
               The default is "-adobe-helvetica-bold-r-normal--*-100-*-*-*-*-*-*".

       IconForeground string [{ win-list }]
               This variable specifies the foreground color to be used when displaying icons, and
               may only be specified inside of a Color or Monochrome list.  The optional win-list
               is  a  list of window names and colors so that per-window colors may be specified.
               See the BorderColor variable for a complete  description  of  the  win-list.   The
               default is "gray85".

       IconifyByUnmapping [{ win-list }]
               This variable indicates that windows should be iconified by being unmapped without
               trying to map any icons.  If the optional win-list is provided, only those windows
               will  be  iconified  by  simply  unmapping.   Windows  that have both this and the
               IconManagerDontShow options set may not be accessible unless the user has provided
               bindings to the warp functions (f.warp and the like) while WarpUnmapped is set, or
               by the VTWM Windows menu.  It is set by default.

       IconManagerBackground string [{ win-list }]
               This variable specifies the background color to use for icon manager entries,  and
               may only be specified inside of a Color or Monochrome list.  The optional win-list
               is a list of window names and colors so that per-window colors may  be  specified.
               See  the  BorderColor  variable  for  a complete description of the win-list.  The
               default is "maroon" for color displays or "gray50" for monochrome displays.

       IconManagerBevelWidth pixels
               Tells vtwm to use 3D-looking icon manager entries,  and  specifies  the  width  in
               pixels  of their bevels.  The default is 0 if vtwm is built with 2D features, or 1
               when vtwm is built with 3D features.

       IconManagerDontShow [{ win-list }]
               This variable indicates that the icon manager should not display any windows.   If
               the  optional  win-list  is given, only those windows will not be displayed.  This
               variable is used to prevent windows that are rarely iconified (such as  xclock  or
               xload) from taking up space in the icon manager.  The default is:
                   IconManagerDontShow
                   {
                       "VTWM *"
                       "xclock"
                       "xload"
                   }

       IconManagerFont string
               This  variable specifies the font to be used when displaying icon manager entries.
               The default is "-adobe-helvetica-bold-r-normal--*-100-*-*-*-*-*-*".

       IconManagerForeground string [{ win-list }]
               This variable specifies the foreground color  to  be  used  when  displaying  icon
               manager  entries,  and may only be specified inside of a Color or Monochrome list.
               The optional win-list is a list of window names  and  colors  so  that  per-window
               colors  may be specified.  See the BorderColor variable for a complete description
               of the win-list.  The default is "gray85".

       IconManagerGeometry string [ columns ]
               This variable indicates that a default icon manager is to  be  created,  with  the
               geometry  specified  with  string.  The  string  argument  should  be a standard X
               geometry specification, specifying the initial size  and/or  location.   The  icon
               manager  window  is  then  broken  into columns pieces and scaled according to the
               number of entries in  the  icon  manager.   Extra  entries  are  wrapped  to  form
               additional rows.  The default string is "+0+0", and the default columns is 1.

       IconManagerHighlight string [{ win-list }]
               This  variable  specifies  the  border color to be used when highlighting the icon
               manager entry that currently has the focus, and can only be specified inside of  a
               Color  or  Monochrome  list.   The optional win-list is a list of window names and
               colors so that per-window colors may be specified.  See the  BorderColor  variable
               for a complete description of the win-list.  The default is "black".

       IconManagers { iconmgr-list }
               This  variable  specifies  a  list  of icon managers to create, in addition to the
               default icon manager if IconManagerGeometry is used.  Each item  in  the  iconmgr-
               list has the following format:
                   "winname"    ["iconname"]    "geometry"    columns
               where  winname  is  the  name  of  the  windows  that should be put into this icon
               manager, iconname is the name of that icon manager window's icon,  geometry  is  a
               standard geometry specification, and columns is the number of columns in this icon
               manager as described in IconManagerGeometry.  For example:
                   IconManagers
                   {
                       "XTerm"     "300x5+800+5"    5
                       "myhost"    "400x5+100+5"    2
                   }

               Clients whose name or class is "XTerm" will have an entry created in  the  "XTerm"
               icon manager.  Clients whose name was "myhost" would be put into the "myhost" icon
               manager.

       IconManagerShow { win-list }
               This variable specifies a list of windows that should appear in the icon  manager.
               When  used  in conjunction with the IconManagerDontShow variable, only the windows
               in this list will be shown in the icon manager.  By default, all windows are shown
               except those in IconManagerDontShow.

       IconRegion geomstr vgrav hgrav hgrid vgrid
               This variable specifies an area on the root window in which icons are placed if no
               specific icon location is provided by the client.  The geomstr is a quoted  string
               containing a standard geometry specification for the region size and location.  If
               more than one IconRegion line is given, icons will  be  put  into  the  succeeding
               regions  when  the  first  is  full.  The vgrav argument should be either North or
               South and is used to control whether icons are first filled in  from  the  top  or
               bottom of the region.  Similarly, the hgrav argument should be either East or West
               and is used to control whether icons should be filled in from the left  or  right.
               Icons  are  laid out in a grid with cells hgrid pixels wide and vgrid pixels high.
               Note that the smallest dimension of the region must be at least the  size  of  the
               largest icon in it in the same direction.  Note also that many applications change
               their icon name as they run, and no provision is made to reformat the icon regions
               if any icon changes size accordingly.

       Icons { win-list }
               This variable specifies a list of window names and the image filenames that should
               be used as their icons.  For example:
                   Icons
                   {
                       "XTerm"    "xterm.icon"
                       "xfd"      "xfd_icon"
                   }

               Windows that match "XTerm" and would not be iconified by unmapping, and would  try
               to  use the icon image in the file "xterm.icon".  If ForceIcons is specified, this
               image will be used even if the client has requested its own icon image.

       IgnoreModifiers modlist
               This variable specifies the "shift states" to ignore when determining if an  event
               is bound by vtwm. In this example:
                   IgnoreModifiers    l | m2
               the  CapsLock  and  NumLock  states  will  be  ignored.  Note that the use of this
               variable can generate quite a bit of X protocol network traffic; modlist should be
               kept as small as possible. See also the BINDINGS section.

       InfoBevelWidth pixels
               Tells  vtwm to use 3D-looking identify, move and resize windows, and specifies the
               width in pixels of the bevel.  The default is 0 if vtwm is built with 2D features,
               or 2 when vtwm is built with 3D features.

       InfoFont string
               This  variable  specifies  the  font  to  be used for in the identify window.  The
               default is "-adobe-helvetica-bold-r-normal--*-100-*-*-*-*-*-*".

       InterpolateMenuColors
               This variable indicates that menu entry  colors  should  be  interpolated  between
               entry specified colors.  In this example:
                   Menu    "mymenu"
                   {
                       "Title"     ("black":"red")      f.title
                       "entry1"                         f.nop
                       "entry2"                         f.nop
                       "entry3"    ("white":"green")    f.nop
                       "entry4"                         f.nop
                       "entry5"    ("red":"white")      f.nop
                   }
               the foreground colors for "entry1" and "entry2" will be interpolated between black
               and white, and the background  colors  between  red  and  green.   Similarly,  the
               foreground for "entry4" will be half-way between white and red, and the background
               will be half-way between green and white.

       LessRandomZoomZoom
               With this option turned on, this makes random zooms a bit less "random" and a  bit
               more  visible.   This  might make a better visual bell, depending on your personal
               taste.

       MakeTitle { win-list }
               This variable specifies a list of windows on which a titlebar should be placed and
               is used to request titles on specific windows when NoTitle has been set.

       MaxWindowSize string
               This  variable specifies a geometry in which the width and height give the maximum
               size for a given window.  This is typically used to restrict windows to  the  size
               of the screen.  The default is "30000x30000".

       MenuBackground string
               This  variable  specifies  the  background  color  used for menus, and can only be
               specified inside of a Color or Monochrome list.  The default is "maroon" for color
               displays or "gray50" for monochrome displays.

       MenuBevelWidth pixels
               Tells  vtwm  to  use  3D-looking  menus,  and specifies the width in pixels of the
               bevel.  The default is 0 if vtwm is built with 2D features,  or  2  when  vtwm  is
               built with 3D features.

       MenuFont string
               This  variable  specifies  the  font to use when displaying menus.  The default is
               "-adobe-helvetica-bold-r-normal--*-120-*-*-*-*-*-*".

       MenuForeground string
               This variable specifies the foreground color used  for  menus,  and  can  only  be
               specified inside of a Color or Monochrome list.  The default is "gray85".

       MenuScrollBorderWidth pixels
               When  the  contents  of  a  menu would make it taller than the display, moving the
               pointer within pixels of the top or bottom of the menu causes  it  to  scroll  the
               entries.  The default value is 2.

       MenuScrollJump entries
               This  variable specifies the number of entries to scroll when the pointer is moved
               within the area defined by MenuScrollBorderWidth.  The default is 3 entries.

       MenuShadowColor string
               This variable specifies the color of the shadow behind  pull-down  menus  and  can
               only be specified inside of a Color or Monochrome list.  The default is "black".

       MenuTitleBackground string
               This variable specifies the background color for f.title entries in menus, and can
               only be specified inside of a Color or Monochrome list.  The default is "gray70".

       MenuTitleFont string
               This variable specifies the font to be  used  in  menu  titles.   The  default  is
               "-adobe-helvetica-bold-r-normal--*-120-*-*-*-*-*-*".

       MenuTitleForeground string
               This  variable specifies the foreground color for f.title entries in menus and can
               only be specified inside of a Color or Monochrome list.  The default  is  "maroon"
               for color displays or "gray50" for monochrome displays.

       Monochrome { colors }
               This  variable  specifies  a  list of color assignments that should be made if the
               screen has a depth of 1.  See the description of Colors.

       MoveDelta pixels
               This variable specifies the number of pixels the  pointer  must  move  before  the
               f.move  and  f.resize functions and initial menu highlighting starts working.  See
               also the f.deltastop function.  The default is 3 pixels.

       NailedAbove
               This variable causes nailed windows to be  physically  above  non-nailed  windows.
               The f.nailedabove function can be used to toggle this setting.

       NailedDown { list }
               This variable gives a list of clients that are nailed initially.  The default is:
                   NailedDown
                   {
                       "VTWM *"
                       "xclock"
                       "xload"
                   }

       NaturalAutopanBehavior
               By default, when autopanning, the pointer is warped by only
                   (AutoPanBorderWidth + AutoPanExtraWarp)
               pixels  on  the real screen.  With this option turned on, the pointer is warped on
               the real screen by as many pixels as the screen is scrolled, or the  above  value,
               whichever is greater.  Thus, the pointer does not normally move very much (only by
               AutoPanExtraWarp) in relation to the virtual desktop.

               This works really well on faster X terminals and workstations, although for slower
               ones, you may want to use the following:
                   AutoPanWarpWithRespectToRealScreen    50
               to  achieve  a  similar effect.  Setting NaturalAutopanBehavior has the exact same
               effect as using the variable
                   AutoPanWarpWithRespectToRealScreen    100

       NoBackingStore
               This variable indicates that vtwm's windows should not request  backing  store  to
               minimize  repainting.  This is typically used with servers that can repaint faster
               than they can handle backing store.

       NoBorder [{ win-list }]
               This variable indicates that windows should not have  borders.   If  the  optional
               win-list is given, only those windows will not have borders.

       NoBorderDecorations
               This  variable indicates that the 3D borders of titled windows should not have the
               little divots adorning the corners.

       NoCaseSensitive
               This variable indicates that case should be ignored when sorting icon names in  an
               icon manager.  This option is typically used with applications that capitalize the
               first letter of their icon name.

       NoDefaultMouseOrKeyboardBindings
               This variable indicates that vtwm  should  not  supply  the  default  pointer  and
               keyboard bindings.  This option should only be used if the startup file contains a
               completely new set of pointer and keyboard bindings  and  definitions.   See  also
               NoDefaults.

       NoDefaults
               This  variable  indicates that vtwm should not supply the default titlebar buttons
               and bindings.  This option should only be used if  the  startup  file  contains  a
               completely  new  set of bindings and definitions.  This function has the effect of
               setting both NoDefaultMouseOrKeyboardBindings and NoDefaultTitleButtons.

       NoDefaultTitleButtons
               This variable indicates that vtwm should not supply the default titlebar  buttons.
               This  option should only be used if the startup file contains a completely new set
               of titlebar button definitions.  See also NoDefaults.

       NoGrabServer
               This variable indicates that vtwm should minimize server  grabs  when  popping  up
               menus and moving or resizing windows.

       NoHighlight [{ win-list }]
               This  variable  indicates  that  borders  should  not  be highlighted to track the
               location of the pointer.  If the optional win-list  is  given,  highlighting  will
               only  be  disabled  for those windows.  When the border is highlighted, it will be
               drawn in the current BorderColor.  When the border is not highlighted, it will  be
               stippled   with  an  gray  pattern  using  the  current  BorderTileForeground  and
               BorderTileBackground colors.  It is set by  default  if  vtwm  is  built  with  3D
               features.

       NoIconManagerFocus
               This variable indicates that vtwm should not set focus to windows corresponding to
               their entries in an icon manager.  Normally, vtwm sets the focus  so  that  events
               from  an icon manager are delivered to the application.  Typically, this is set to
               facilitate icon  manager  bindings  that  would  otherwise  be  delivered  to  the
               application.

       NoIconManagerHighlight
               This variable indicates that icon manager entries will not be highlighted to track
               the location of the pointer. This is independant of the NoHighlight variable.

       NoIconManagers
               This variable indicates that no icon manager should be created.

       NoIconifyIconManagers
               This variable indicates that no icon manager should be iconified.

       NoMenuShadows
               This variable indicates that menus should not have drop shadows drawn behind them.
               This  is typically used with slower servers since it speeds up menu drawing at the
               expense of making the menu slightly harder to read.

       NoOpaqueMove [{ win-list }]

       NoOpaqueResize [{ win-list }]
               These variables indicate that the f.move and f.resize functions should change just
               a window's outline.  If the optional win-list is given, only those windows will be
               affected. These are usually used to narrow the scope of  "global"  OpaqueMove  and
               OpaqueResize variables.

       NoPrettyTitles
               If you don't mind long titles butting up against the right edge of short titlebars
               and icon managers. Disables the default behavior of using ellipses to  indicate  a
               truncated title.

       NoRaiseOnDeiconify

       NoRaiseOnMove

       NoRaiseOnResize

       NoRaiseOnWarp
               These  variables  indicate  that  windows  should not be raised after a deiconify,
               move, resize, or warp operation, and are typically used  to  preserve  the  window
               stacking order. Note that the pointer may end up in an occluding window when these
               variables are used.

       NoSaveUnders
               This variable indicates that menus should  not  request  save-unders  to  minimize
               window  repainting  following  menu selection.  It is typically used with displays
               that can repaint faster than they can handle save-unders.

       NoStackMode [{ win-list }]
               This variable indicates that client  window  requests  to  change  stacking  order
               should  be  ignored.   If  the  optional win-list is given, only requests on those
               windows will be ignored.  This is typically  used  to  prevent  applications  from
               relentlessly popping themselves to the front of the window stack.

       NoTitle [{ win-list }]
               This  variable  indicates that windows should not have titlebars.  If the optional
               win-list is given, only those windows will not have titlebars.  MakeTitle  may  be
               used  with  this  option  to  force  titlebars to be put on specific windows.  The
               default is:
                   NoTitle
                   {
                       "VTWM *"
                       "xclock"
                       "xload"
                   }

       NoTitleFocus
               This variable indicates that vtwm should not set  keyboard  input  focus  to  each
               window  as  it  is  entered.   Normally, vtwm sets the focus so that focus and key
               events from the titlebar and icon managers are delivered to the  application.   If
               the pointer is moved quickly and vtwm is slow to respond, input can be directed to
               the old window instead of the new.  This option is typically used to prevent  this
               "input  lag" and to work around bugs in older applications that have problems with
               focus events.

       NoTitleHighlight [{ win-list }]
               This variable indicates that the highlight area of the titlebar, which is used  to
               indicate  the  window that currently has the input focus, should not be displayed.
               If the optional win-list is given, only those  windows  will  not  have  highlight
               areas.   This  and the SqueezeTitle options can be set to substantially reduce the
               amount of screen space required by titlebars.

       NotVirtualGeometries
               This variable indicates that vtwm should assume that  user  geometries  should  be
               relative  to the current virtual window, as opposed to absolute.  If you set this,
               then "xterm -geometry +20+20" specifies a position in the current view; otherwise,
               it would specify a position in the top-left view.  It is set by default.

       NoWindowRing { win-list }
               This variable specifies a list of windows that will not be added to the list along
               which the f.warpring function cycles.  See also WindowRing.

       OldFashionedTwmWindowsMenu

       OldFashionedVtwmWindowsMenu
               By default, the VTWM Windows menu will use the same colors that  you  see  in  the
               panner. This variable disables that behavior.

       OpaqueMove [{ win-list }]

       OpaqueResize [{ win-list }]
               These  variables  indicate  that the f.move and f.resize functions should actually
               change the window instead of just an outline so that the user can immediately  see
               what  the  window  will  look like.  If the optional win-list is given, only those
               windows will be affected "opaquely".  These options are  typically  used  on  fast
               systems (particularly when NoGrabServer is set).

       PanDistanceX N

       PanDistanceY N
               These  variables define a grid of screens for the virtual desktop, expressed as N%
               of a real screen. When the f.snap function is called,  the  real  screen  will  be
               moved  to  the  closest  grid  location. The (mis)naming of these variables is for
               historical reasons. The default value is 100, effectively setting  up  "pages"  in
               the virtual desktop.

       PanResistance milliseconds
               This  variable  indicates  how  hard  it  should  be to pan to an adjacent virtual
               screen.  It specifies how long  the  pointer  must  be  within  AutoPanBorderWidth
               pixels  of  the  real  screen's  edge.   Values  equal  to 0 or greater than 10000
               disables this feature.  The default is 750 milliseconds.

       PauseOnExit N

       PauseOnQuit N
               These variables define a delay on exit, expressed in seconds. They allow the (vtwm
               stop) and f.quit sounds time to play before the connection to rplayd(8) is closed.

       Pixmaps { pixmaps }
               This  variable  specifies  a  list of images that define the appearance of various
               windows.  Each entry is a keyword indicating the window  to  set,  followed  by  a
               string  giving  the  name of the image. Built-in and external images may be freely
               mixed, given the constraints described in the IMAGE  AND  AUDIO  FORMATS  section.
               The following windows may be specified thus:
                   Pixmaps
                   {
                       TitleHighlight             ":xpm:sunkenbox"
                       RealScreenPixmap           "scaledbackground.xpm"
                       VirtualBackgroundPixmap    "gray1"
                       MenuIconPixmap             ":xpm:rarrow"
                       IconManagerPixmap          ":xpm:zoom"
                   }

               By  default, the TitleHighlight is an even, stippled pattern if vtwm is built with
               2D features,  or  "sunken"  lines  when  vtwm  is  built  with  3D  features.  The
               MenuIconPixmap  is  a right arrow by default (rendered 3D as appropriate), and the
               default IconManagerPixmap is either the X logo or a "raised" box,  for  2D  or  3D
               features, respectively.

       PointerPlacement
               This  variable  indicates that windows with no specified geometry should be placed
               with the window origin at the location of the mouse pointer  or,  if  WarpSnug  is
               specified,  as  close  as possible to that location such that the window fits onto
               the real screen. If RandomPlacement is also set then it takes precedence.

       PrettyZoom
               If Zoom is turned on, this makes the  associated  animation  look  just  a  little
               nicer,  depending on your personal taste.  This makes the zoom slower, however, so
               you may have to decrease the value of the Zoom variable.

       RaiseDelay milliseconds
               For windows that are to be automatically raised when the pointer enters  (see  the
               AutoRaise  variable  and  the  f.autoraise  function)  this variable specifies the
               length of time the pointer should rest in the window before  it  is  raised.   The
               default is 0 milliseconds.

       RaiseOnStart
               This  variable specifies that the raise which would normally occur at the end of a
               move   or   resize   operation   (subject   to   MoveDelta,   NoRaiseOnMove,   and
               NoRaiseOnResize) will occur at the start of the operation. This may be useful when
               OpaqueMove and/or OpaqueResize are specified.  Note  that  cancelling  a  move  or
               resize  operation  with  this  variable  set will not preserve the window stacking
               order.

       RandomPlacement
               This variable indicates that windows with no specified geometry should  be  placed
               in  a  pseudo-random  location  instead of having the user drag an outline (or the
               window itself if the OpaqueMove variable is set) to the preferred location.

       RealScreenBackground string
               See RealScreenForeground.

       RealScreenBorderWidth pixels
               This  value  specifies  the  border  width   of   the   RealScreen   window   (see
               RealScreenForeground). The default value is 0 pixels.

       RealScreenForeground string
               Inside  what  vtwm  calls  the virtual desktop window, but which we might call the
               "panner", is a little window that shows where the physical screen  is  located  in
               virtual  space.  The vtwm source code calls this little window the RealScreen.  By
               default, it has no border, and can be distinguished from the  normal  backdrop  of
               the panner only by its color or image.  Its foreground color has no meaning unless
               you give it an image.  (It can be given a border with RealScreenBorderWidth.)

       RealScreenPixmap string
               Names an image file used to decorate the RealScreen window.  A sample is provided,
               nestedsqu.xbm, but your mileage may vary as the size of your screen varies!  It is
               easy to find out the size of this window and to create  any  image  file  of  type
               bitmap(1) or pixmap(1) for it; that is the recommended procedure.

       ResizeFont string
               This  variable  specifies  the  font  to be used for in the dimensions window when
               resizing     windows.      The      default      is      "-adobe-helvetica-bold-r-
               normal--*-120-*-*-*-*-*-*".

       ResizeRegion location
               This  variable specifies the area on the screen to display the resize window.  The
               location should be one of NorthWest, NorthEast, SouthWest, SouthEast, or Centered.

       RestartPreviousState
               This variable indicates that vtwm should attempt to use the WM_STATE  property  on
               client  windows to tell which windows should be iconified and which should be left
               visible.  This is typically used to try to regenerate the state  that  the  screen
               was in before the previous window manager was shutdown. It is set by default.

       RightHandSidePulldownMenus
               Pull-down menus can appear when the pointer is to the right of the center of their
               parent menu, or they can appear when the pointer is closer to the  right  edge  of
               their parent menu.  This option enables the latter behavior, and is the default.

       SaveColor { colors-list }
               This  variable  indicates a list of color assignments to be stored as pixel values
               in the root window property _MIT_PRIORITY_COLORS.  Clients may elect  to  preserve
               these  values when installing their own colormap.  Note that use of this mechanism
               is a way an for application to avoid the  "technicolor"  problem,  whereby  useful
               screen  objects  such  as  window  borders and titlebars disappear when a programs
               custom colors are installed by the window manager.  For example:
                   SaveColor
                   {
                       BorderColor
                       TitleBackground
                       TitleForeground
                       "red"
                       "green"
                       "blue"
                   }

               This would place on the root window 3 pixel values for borders and  titlebars,  as
               well as the three color strings, all taken from the default colormap.

       ShallowReliefWindowButton
               This  indicates  that  the  features  of built-in 3D titlebar buttons, the 3D icon
               manager button the 3D menu pull-right icon, and the  3D  titlebar  highlight  area
               should  be  rendered  with a "flatter" appearance. It is set by default if vtwm is
               built with 3D features.

       ShowIconManager
               This variable indicates that the icon manager window should be displayed when vtwm
               is started.  It can always be brought up using the f.showiconmgr function.

       SnapRealScreen
               This variable causes the real screen to snap to a grid defined in PanDistanceX and
               PanDistanceY increments whenever the representation  moves.  The  f.snaprealscreen
               function can be used to toggle this setting.

       SortIconManager
               This  variable  indicates  that  entries  in  the  icon  manager  should be sorted
               alphabetically rather than by simply appending new windows to the end. It  is  set
               by default.

       SoundHost string
               This  variable  specifies  what  machine  (by  its TCP/IP hostname) is running the
               rplayd(8) daemon. If not specified, the  local  machine  is  tried.  If  rplayd(8)
               cannot be accessed, sound will be toggled off.

       Sounds { sound-list }
               This  variable  is  a  list of identifiers and associated sound files. It contains
               entries of the form:
                   "identifier"    "soundfile"    [volume]
               where identifier  is  any  function  described  in  the  BINDINGS  section  except
               f.playsound,  f.sounds, and f.separator, as well as these event identifiers: (vtwm
               start), (vtwm stop), (client map), (client unmap), (menu map), (menu unmap), (info
               unmap),  (autopan  event), and (bell event). The soundfile is the full pathname of
               the sound file to play for the associated identifier, and volume sets  the  volume
               for  which  to  play that sound (see also SoundVolume). Note that the list entries
               must be quoted:
                   Sounds
                   {
                       "(vtwm start)"    "/usr/share/sounds/wowee.wav"
                       "(vtwm stop)"     "/usr/share/sounds/seeya.wav"
                       "f.exec"          "/usr/share/sounds/click.au"   50
                       "(client map)"    "/usr/share/sounds/ping.au"    50
                       "f.delete"        "/usr/share/sounds/doh1.wav"
                       "f.deletedoor"    "/usr/share/sounds/doh2.wav"
                       "f.destroy"       "/usr/share/sounds/doh3.wav"
                       "(client unmap)"  "/usr/share/sounds/ping.au"
                   }

               This example points out that some identifiers "overlap":
                   f.beep > (bell event)            f.exec > (client map)
                   f.delete > (client unmap)        f.menu > (menu map)
                   f.deletedoor > (client unmap)    f.quit > (vtwm stop)
                   f.destroy > (client unmap)       f.version = f.identify

               In these cases, the function takes precedence  over  the  event  when  both  would
               otherwise play.

       SoundVolume N
               This variable sets the overall volume for which to play sounds, expressed as N% of
               maximum. Default is 25 (1/4 attenuation).

       SqueezeTitle [{ squeeze-list }]
               This variable indicates that vtwm should attempt to use  the  SHAPE  extension  to
               make  titlebars  occupy  only  as  much  screen  space  as  they need, rather than
               extending all the way across the top of the window.  The optional squeeze-list may
               be  used  to  control  the  location of the squeezed titlebar along the top of the
               window.  It contains entries of the form:
                   "name"    justification    num    denom
               where name is a window name, justification is either left, center, or  right,  and
               num and denom are numbers specifying a ratio for the relative position about which
               the titlebar is located, measured from left to right.  A ratio  of  0/0  indicates
               that  the  justification is absolute, A non-zero numerator with a zero denominator
               indicates a pixel count, and the justification is ignored entirely for  any  other
               ratio.  For example:
                   SqueezeTitle
                   {
                       "XTerm"     left      0    0
                       "xterm1"    left      1    3
                       "xterm2"    right     2    3
                       "oclock"    center    0    0
                       "emacs"     right     0    0
                   }

               The  DontSqueezeTitle list can be used to turn off squeezing on certain titles. It
               is set by default.

       StartIconified [{ win-list }]
               This variable indicates that client windows should  initially  be  left  as  icons
               until explicitly deiconified by the user.  If the optional win-list is given, only
               those windows will be started iconic.  This is useful for  programs  that  do  not
               support an -iconic command line option or resource.

       StaticIconPositions
               This  variable  alters icon placement such that they will maintain their positions
               on the virtual desktop when not nailed and DeiconifyToScreen is not used.  This is
               most  applicable  when  SnapRealScreen  and  AutoPan is used with PanDistanceX and
               PanDistanceY values to simulate ctwm(1) workspaces.

       StayUpMenus
               This variable alters menu interaction.  By default, a menu item is selected when a
               pointer  button  is  released  over  it.   This  variable  causes menu items to be
               selected on the next button press event.

       StayUpOptionalMenus
               This variable is similar to  StayUpMenus,  except  that  if  any  menu  items  are
               selected,  the menu interaction reverts to the old behavior.  For example, suppose
               you have the right pointer button bound to bring up  a  menu  with  a  title  bar.
               Clicking  the right button and releasing it (over the title bar) will bring up the
               menu and have it stay up until you click on  a  menu  item.   Clicking  the  right
               button,  moving  the  pointer  to a menu item, and releasing the right button will
               activate that menu item and dismiss the menu.

       Sticky { list }
               A synonym for NailedDown.

       StickyAbove
               A synonym for NailedAbove.

       StrictIconManager
               This variable causes icon managers to list only  those  windows  that  are  in  an
               iconified state.

       TitleBackground string [{ win-list }]
               This  variable  specifies  the background color used in titlebars, and may only be
               specified inside of a Color or Monochrome list.  The optional win-list is  a  list
               of window names and colors so that per-window colors may be specified. The default
               is "maroon" for color displays or "gray50" for monochrome displays.

       TitleBevelWidth pixels
               Tells vtwm to use 3D-looking titlebars, and specifies the width in pixels  of  the
               bevel  that  surrounds  the  titlebar.  If  the  value  of  ButtonIndent  added to
               FramePadding equals zero, the bevel will be bound to the text and highlight  area.
               The  default  is 0 if vtwm is built with 2D features, or 1 when vtwm is built with
               3D features..

       TitleButtonBorderWidth pixels
               This variable specifies the width in pixels of  the  border  surrounding  titlebar
               buttons,  drawn  in  the  TitleForeground color. The default is 1 if vtwm is built
               with 2D bitmaps, or 0 when vtwm is built with 3D pixmaps.

       TitleFont string
               This variable specifies the font to used for displaying window names in titlebars.
               The default is "-adobe-helvetica-bold-r-normal--*-120-*-*-*-*-*-*".

       TitleForeground string [{ win-list }]
               This  variable  specifies  the foreground color used in titlebars, and may only be
               specified inside of a Color or Monochrome list.  The optional win-list is  a  list
               of  window  names  and  colors  so  that  per-window colors may be specified.  The
               default is "maroon" for color displays or "gray50" for monochrome displays.

       TitlePadding pixels
               This variable specifies the distance between titlebar  buttons  in  the  titlebar.
               Note  that  distances  between  buttons and the title, the title and the highlight
               area, and the highlight area and buttons, are all set to a hard-coded value.   The
               default  is  5  if vtwm is built with 2D features, or 0 when vtwm is built with 3D
               features.

       UnknownIcon string
               This variable specifies the filename of an image  file to be used as  the  default
               icon.   This image will be used as the icon of all clients which do not provide an
               icon image and are not listed in the Icons list.

       UsePPosition string [{ win-list }]
               This variable  specifies  whether  or  not  vtwm  should  honor  program-requested
               locations  (given  by  the PPosition flag in the WM_NORMAL_HINTS property), in the
               absence of a user-specified position.  The argument string may have one  of  three
               values:   "off"  (the  default)  indicating  that  vtwm should ignore the program-
               supplied position, "on" indicating that the position should  be  used,  and  "non-
               zero"  indicating  that  the  position  should used if it is other than (0,0) (for
               working around a bug in older toolkits).  The  optional  win-list  is  a  list  of
               window  names  and  arguments  that  will override the global string argument. For
               example:
                   UsePPosition    "off"
                   {
                       "MPlayer"   "on"
                   }

       VirtualBackground string
               This is the background color for the panner, a.k.a. the  Virtual  Desktop  window.
               The default is "maroon" for color displays or "gray50" for monochrome displays.

       VirtualBackgroundPixmap string
               Names an image file to decorate the panner.

       VirtualForeground string
               Foreground  for  the  panner; has no use unless you specify a panner image of type
               bitmap(1).

       VirtualDesktop geometry scale
               This variable must be set to enable the virtual desktop features of vtwm. If  this
               variable  is  not  set,  vtwm will behave in the same manner as twm. This variable
               specifies where to place the virtual desktop window and its size. The geometry  is
               a  standard  X  geometry  specification  and  defines the size and location of the
               window containing the desktop representation.

               The scale parameter specifies the scaling of the virtual desktop  window  compared
               to  the  desktop.  The  size  specification can be given in three ways: If size is
               larger than the screen size, it represents the size of the whole desktop, and  the
               virtual  window  desktop  size will then be size divided by scale. When size times
               scale is smaller than the screen size, size represents the number of screens  that
               should  fit  in  the  desktop.  Otherwise  size represents the size of the virtual
               desktop window, and the currently accessible virtual desktop is then  scale  times
               the size of the desktop window. Using the default as an example:
                   VirtualDesktop    "5x2-0-0"    16
               With  scale set to 16, and a physical screen size of 1024x768, the desktop area is
               1/16 the size of the screen times the number of screens specified:
                   (5 * (1024 / 16)) x (2 * (768 / 16)) = 320 x 96

               The size of the desktop can be changed dynamically, by simply resizing the virtual
               desktop window.

       VirtualDesktopBevelWidth pixels
               Tells  vtwm to use a 3D-looking virtual desktop, and specifies the width in pixels
               of the bevel.  The default is 0 if vtwm is built with 2D features, or 1 when  vtwm
               is built with 3D features.

       VirtualDesktopFont font
               This  variable  causes font to be used when displaying the names of windows in the
               virtual desktop display.  If this variable is not set,  then  names  will  not  be
               displayed.  The DesktopDisplayForeground should also be set for this feature to be
               useful.  The default is "-adobe-helvetica-medium-r-normal--*-75-*-*-*-*-*-*".

       VirtualReceivesMotionEvents

       VirtualSendsMotionEvents
               These variables indicate that changes to the position and dimension of windows  on
               the  real screen will be reflected in the virtual desktop as they occur, and visa-
               versa.

       WarpCentered string
               By default, on warps to windows, the pointer goes to  either  the  center  of  the
               titlebar,  or  in  the  absence  of,  the  center  of the top border member.  This
               variable specifies that the pointer should  warp  to  the  center  of  the  window
               depending  on  the string argument: "on" indicates all windows, "titled" indicates
               titled windows only, "untitled" indicates untitled windows only,  and  "off"  (the
               default)  indicating  the  default  behavior. Note that warps to icon managers are
               exceptional: The pointer always goes to either the active entry, or in the absence
               of, the top entry.

       WarpCursor [{ win-list }]
               This  variable  indicates that the pointer should be warped into windows when they
               are deiconified.  If the optional win-list is given,  the  pointer  will  only  be
               warped when those windows are deiconified. It is set by default.

       WarpSnug
               With  this  variable  set,  the  warp functions (f.warp and the like) will fit the
               entire window on the screen, i.e., they'll be snugged on the real screen.

       WarpToTransients
               This variable indicates that the pointer should be warped into  transient  windows
               when they are created.

       WarpUnmapped
               This  variable  indicates  that  the  warp  functions (f.warp and the like) should
               deiconify any iconified windows they encounter.  This is typically used to make  a
               key  binding  that  will pop a particular window (such as xmh), no matter where it
               is.  The default is for the functions to ignore iconified windows.

       WarpVisible
               This variable indicates that the warp functions f.warpclassnext,  f.warpclassprev,
               f.warpring,  and  f.warpto  should  restrict themselves to windows that are on the
               screen.  The default is for the functions to traverse the entire virtual desktop.

       WarpWindows
               When warping to a window, by default the real screen will be  moved  to  find  the
               window  on the virtual desktop. With this set, the window itself will be warped to
               the real screen, moving the window in the virtual desktop.

       WindowRing [{ win-list }]
               This variable specifies that when windows are created, they should be added to the
               list  that the f.warpring function operates on. If the optional win-list is given,
               then only those windows will be included in the window ring. See also NoWindowRing
               and f.ring.

       XorValue number
               This  variable  specifies the value to use when drawing window outlines for moving
               and resizing.  This should be set to a value that will  result  in  a  variety  of
               distinguishable  colors  when  exclusive-or'ed  with  the  contents  of the user's
               typical screen.  Setting this variable to 1 often gives nice results  if  adjacent
               colors  in  the  default  colormap are distinct.  By default, vtwm will attempt to
               cause temporary lines to appear at the opposite  end  of  the  colormap  from  the
               graphics.

       Zoom [ count ]
               This  variable indicates that outlines suggesting movement of a window to and from
               its iconified state  should  be  displayed  whenever  a  window  is  iconified  or
               deiconified.   The  optional count argument specifies the number of outlines to be
               drawn.  The default count is 8.

       ZoomZoom
               This variable modifies zooms such that a random place will be used for the  source
               or destination when there isn't an appropriate window (e.g., an icon, icon manager
               entry, or client window).  Default  behavior  inhibits  zooms  when  there  aren't
               appropriate windows, except for the f.zoomzoom function.

SPECIAL VARIABLES

       The  following  variables must be set after the fonts have been assigned, so it is usually
       best to put them at the end of the variables or beginning of the bindings sections:

       DefaultFunction function
               This variable specifies the function to be executed when a key or button event  is
               received  for  which  no  binding  is provided.  This is typically bound to f.nop,
               f.beep, or a menu containing window operations.

       WindowFunction function
               This variable specifies the function to execute when a window is selected from the
               VTWM  Windows  menu.   If  this  variable is not set (default), the window will be
               deiconified and raised.  It is strongly recommended  that  if  this  is  set,  the
               function includes provision for deiconifying windows.

BINDINGS

       After  the desired variables have been set, functions may be attached titlebar buttons and
       key and pointer buttons.  Titlebar buttons may be added from the left or  right  side  and
       appear  in  the  titlebar  from  left-to-right  according  to  the order in which they are
       specified.  Key and pointer button bindings may be given in any order.

       Titlebuttons specifications must include the name of the image to use in  the  button  box
       and the function to be invoked when a pointer button is pressed within them:
           LeftTitleButton  "image" = function
       or
           RightTitleButton "image" = function

       See  the  ButtonIndent  and FramePadding variables and the IMAGE AND AUDIO FORMATS section
       for details on the image specification.

       Key and pointer button specifications must give the modifiers that must be  pressed,  over
       which  parts  of the screen the pointer must be, and what function is to be invoked.  Keys
       are given as strings containing the appropriate keysym name;  buttons  are  given  as  the
       keywords Button1-Button5:
           "FP1"   = modlist : context : function
           Button1 = modlist : context : function

       The  modlist  is  any  combination of the modifier names shift, control, lock, meta, mod1,
       mod2, mod3, mod4, or mod5 (which may be abbreviated as s, c, l, m, m1,  m2,  m3,  m4,  m5,
       respectively)  separated by a vertical bar (|).  Similarly, the context is any combination
       of window, title, icon, root, frame, virtual, desktop, door, iconmgr, their first  letters
       (iconmgr  abbreviation  is  m,  door has no abbreviation), or all, separated by a vertical
       bar.  It is rumored that window class names will also work.  The function is any of the f.
       keywords  described  below.   For example, the default startup file contains the following
       bindings:
           Button1 =   : root          : f.menu "VTWM Windows"
           Button1 = m : window | icon : f.function "move-or-lower"
           Button2 = m : window | icon : f.iconify
           Button3 = m : window | icon : f.move
           Button1 =   : title         : f.move
           Button2 =   : title         : f.raiselower
           Button1 =   : icon          : f.function "move-or-iconify"
           Button2 =   : icon          : f.iconify
           Button1 =   : iconmgr       : f.iconify
           Button2 =   : iconmgr       : f.iconify

       A user who wanted to be able to  manipulate  windows  from  the  keyboard  could  use  the
       following bindings:
           "F1"    =       : all : f.iconify
           "F2"    =       : all : f.raiselower
           "F3"    =       : all : f.warpring "next"
           "F4"    =       : all : f.warpto "xmh"
           "F5"    =       : all : f.warpto "emacs"
           "F6"    =       : all : f.colormap "next"
           "F7"    =       : all : f.colormap "default"
           "F20"   =       : all : f.warptoscreen "next"
           "Left"  = m     : all : f.backiconmgr
           "Right" = m | s : all : f.forwiconmgr
           "Up"    = m     : all : f.upiconmgr
           "Down"  = m | s : all : f.downiconmgr

       Note,  however,  that  using  all  for button or key bindings is almost always a bad idea,
       since it prevents all applications from receiving those events; this can cripple text  and
       graphics  editors  that  otherwise  expect  to  see  those  buttons  or keys (see also the
       IgnoreModifiers  variable,  and  the  f.bindbuttons,  f.bindkeys,   f.unbindbuttons,   and
       f.unbindkeys functions).

       vtwm  provides many more window manipulation primitives than can be conveniently stored in
       a titlebar, menu, or set of key bindings.  Although a small set of defaults  are  supplied
       (unless  either  NoDefaults, NoDefaultMouseOrKeyboardBindings, or NoDefaultTitleButtons is
       specified), most users will want to have their most common operations  bound  to  key  and
       button  strokes.   To  do  this,  vtwm  associates  names  with each of the primitives and
       provides user-defined functions  for  building  higher  level  primitives  and  menus  for
       interactively selecting among groups of functions.

       User-defined  functions  contain  the  name  by  which  they  are  referenced  in calls to
       f.function and a list of other functions to execute.  For example:
           Function "move-or-lower"    { f.move f.deltastop f.lower }
           Function "move-or-iconify"  { f.move f.deltastop f.iconify }
           Function "restore-colormap" { f.colormap "default" f.lower }

       The function name must be used in  f.function  exactly  as  it  appears  in  the  function
       specification.

       VTWM  PROFILE.   If  a  function called "VTWM Profile" is defined within the startup file,
       that function will be executed upon startup or restarting  of  the  window  manager.   For
       example:
           AutoPan    25
           Function   "VTWM Profile"
           {
               f.autopan
           }
       gives  AutoPan  a  value but turns autopanning off initially (it won't have a value unless
       AutoPan is set in the startup file; see f.autopan below), in case you want to turn  it  on
       sometime later.

       In  the descriptions below, if the function is said to operate on the selected window, but
       is invoked from a root menu, the cursor will be changed to the Select cursor and the  next
       window to receive a button press will be chosen:

       ! string
               This is an abbreviation for f.exec string.

       ^ string (OBSOLETE --- use a clipboard client)
               This is an abbreviation for f.cut string.

       f.autopan
               If autopan wasn't configured in your .vtwmrc file, this does nothing. If, however,
               it was configured, this toggles the current autopan state.  The  reason  for  this
               command  is  that  autopan is sometimes nice to have, but it interferes with using
               sticky windows that are near the edge of the screen. With this  command,  you  get
               the best of both worlds.

       f.autoraise
               This  function  toggles  whether  or  not  the  selected window is raised whenever
               entered by the pointer.  See the description of the variable AutoRaise.

       f.backiconmgr
               This function warps the pointer  to  the  previous  column  in  the  current  icon
               manager, wrapping back to the previous row if necessary.

       f.beep  This function sounds the keyboard bell.

       f.bindbuttons

       f.bindkeys
               These  functions  enable  vtwm's  pointer  or  keyboard  bindings for the selected
               window.  These are only needed  if  the  bindings  have  been  disabled  with  the
               f.unbindbuttons  or  f.unbindkeys  functions.   Be  careful  what  you  bind these
               functions to; f.bindkeys bound to a window context  key  will  not  be  accessable
               after f.unbindkeys is invoked for the window!

       f.bottomzoom
               This  function  is  similar  to the f.fullzoom function, but resizes the window to
               fill only the bottom half of the screen.

       f.circledown
               This function lowers the top-most window that occludes another window.

       f.circleup
               This function raises the bottom-most window that is occluded by another window.

       f.colormap string
               This  function  rotates  the  colormaps  (obtained  from  the  WM_COLORMAP_WINDOWS
               property on the window) that vtwm will display when the pointer is in this window.
               The argument string may have one of the  following  values:  "next",  "prev",  and
               "default".   It  should  be  noted here that in general, the installed colormap is
               determined by keyboard focus.  A pointer driven  keyboard  focus  will  install  a
               private colormap upon entry of the window owning the colormap.  Using the click to
               type model, private colormaps will not be  installed  until  the  user  presses  a
               pointer button on the target window.

       f.cut string (OBSOLETE --- use a clipboard client)
               This  function  places the specified string (followed by a newline character) into
               the root window property CUT_BUFFER0.

       f.cutfile (OBSOLETE --- use a clipboard client)
               This function reads the file indicated by the contents of the  CUT_BUFFER0  window
               property and replaces the cut buffer.

       f.deiconify
               This function deiconifies the selected window.  If the window is not an icon, this
               function does nothing.

       f.delete
               This function sends the WM_DELETE_WINDOW message to the  selected  window  if  the
               client application has requested it through the WM_PROTOCOLS window property.  The
               application is supposed to respond to the message by removing the window.  If  the
               window has not requested WM_DELETE_WINDOW messages, the keyboard bell will be rung
               indicating that the user should choose an alternative method.  Note this  is  very
               different  from  f.destroy.   The  intent  here is to delete a single window,  not
               necessarily the entire application.

       f.deletedoor
               This function deletes a door.

       f.deltastop
               This function allows a user-defined function to be aborted if the pointer has been
               moved  more  than MoveDelta pixels.  See the example definition given for Function
               "move-or-lower" at the beginning of the section.

       f.destroy
               This function instructs the X server to close the display connection of the client
               that  created  the selected window.  This should only be used as a last resort for
               shutting down runaway clients.  See also f.delete.

               This action sometimes leaves a runaway  process  that  consumes  CPU  cycles;  you
               should always try to use the applications own quit function, rather than this one.

       f.downiconmgr
               This  function  warps  the  pointer  to  the  next row in the current icon manger,
               wrapping to the beginning of the next column if necessary.

       f.enterdoor
               This function activates this door.  Typically one binds:
                   Button1 = : door : f.enterdoor
                   Button2 = : door : f.enterdoor
                   Button3 = : door : f.enterdoor

       f.exec string
               This function passes the argument string to /bin/sh for execution.  In multiscreen
               mode,  if  string  starts  a  new  X client without giving a display argument, the
               client will appear on the screen from which this function was invoked.

       f.file string (OBSOLETE --- use a clipboard client)
               This function assumes string is a file name.  This file is read  into  the  window
               server's cut buffer.

       f.focus This  function  toggles  the  keyboard focus of the server to the selected window,
               changing the focus rule from pointer-driven if necessary.  If the selected  window
               already was focused, this function executes an f.unfocus.

       f.forcemove
               This function is like f.move except that it ignores the DontMoveOff variable.

       f.forwiconmgr
               This  function  warps  the pointer to the next column in the current icon manager,
               wrapping to the beginning of the next row if necessary.

       f.fullzoom
               This function resizes the selected window to the full size of the display or  else
               restores the original size if the window was already zoomed.

       f.function string
               This  function  executes  the user-defined function whose name is specified by the
               argument string.

       f.hbzoom
               This function is a synonym for f.bottomzoom.

       f.hidedesktopdisplay
               This function unmaps the desktop display.

       f.hideiconmgr
               This function unmaps the current icon manager when selected from a client  window,
               and unmaps all icon managers when selected from the root window.

       f.horizoom
               This variable is similar to the f.zoom function except that the selected window is
               resized to the full width of the display.

       f.htzoom
               This function is a synonym for f.topzoom.

       f.hzoom This function is a synonym for f.horizoom.

       f.iconify
               This function iconifies or deiconifies the selected window or icon, respectively.

       f.identify
               This function displays a summary of the name and geometry of the selected  window.
               Clicking  the  pointer  or  pressing  a key in the window will dismiss it.  If the
               function is invoked on a desktop representation of a window, the real window which
               is represented will be identified.

       f.lefticonmgr
               This function similar to f.backiconmgr except that wrapping does not change rows.

       f.leftzoom
               This  variable  is  similar  to  the f.bottomzoom function but causes the selected
               window is only resized to the left half of the display.

       f.lower This function lowers the selected window.

       f.menu string
               This function invokes the menu specified by the argument string.   Cascaded  menus
               may be built by nesting calls to f.menu.

       f.move  This function drags an outline of the selected window (or the window itself if the
               OpaqueMove variable is set) until the invoking  pointer  button  is  released,  at
               which  time  the  window  is  raised  (subject  to  RaiseOnStart,  MoveDelta,  and
               NoRaiseOnMove). Double  clicking  within  the  number  of  milliseconds  given  by
               ConstrainedMoveTime  warps  the pointer to the center of the window and constrains
               the move horizontally or vertically, depending on pointer movement. To  abort  the
               move, press another button before releasing the invoking button.

       f.movescreen
               Moves  a window (or possibly the real screen) inside the desktop display. To abort
               the move, press another button before releasing the invoking button.  By  default,
               the bindings using the desktop context are defined as:
                   Button1 = : desktop : f.movescreen
                   Button2 = : desktop : f.movescreen

               This  is useful if you want to reset the default keyboard and pointer bindings via
               NoDefaultMouseOrKeyboardBindings and use some of your own for the virtual desktop,
               e.g.:
                   NoDefaultMouseOrKeyboardBindings
                   Button1 = : desktop : f.movescreen
                   Button2 = : desktop : f.warp
                   Button3 = : desktop : f.iconify

               This function is not useful under any context other than "desktop".

       f.nail  This  function  nails  or  unnails  the  selected window onto the real screen; the
               current value of this property is toggled on the window.

       f.nailedabove
               This function toggles the setting of the NailedAbove variable.

       f.namedoor
               This function, bound to the door context, pastes a name from CUT_BUFFER0 into  the
               selected door (see the BINDINGS section for details).

       f.newdoor
               This  function  creates  a new door with it's destination and name set to the real
               screen's current position in the virtual desktop.

       f.nexticonmgr
               This function warps the pointer to the next icon manager containing any windows on
               the current or any succeeding screen.

       f.nop   This  function  does  nothing  and  is  typically used with the DefaultFunction or
               WindowFunction variables or to introduce blank lines in menus.

       f.panup N

       f.pandown N

       f.panleft N

       f.panright N
               These functions move the real  screen  by  N%  of  the  screen  dimension  in  the
               indicated direction.  These are ideally bound to the cursor keys:
                   "Up"    = : root : f.panup    "100"
                   "Down"  = : root : f.pandown  "100"
                   "Left"  = : root : f.panleft  "100"
                   "Right" = : root : f.panright "100"

       f.playsound soundfile
               This  function plays the specified sound at SoundVolume volume. The soundfile must
               be the full pathname of the sound file. This  is  a  rather  "expensive"  function
               compared to that provided by the Sounds variable, and should be avoided.

       f.previconmgr
               This  function  warps  the  pointer  to  the  previous icon manager containing any
               windows on the current or preceding screens.

       f.quit  This function causes vtwm to restore the window's borders and exit.   If  vtwm  is
               the  last  client  invoked  from  xdm, this will result in a server reset, and the
               user's session will be logged out.

               Users who stay logged in for long periods (days or weeks), or who like  to  change
               window  managers,  or  experiment  with  them,  may  find  it  desirable  to use a
               relatively simple application, such as xbiff(1), as the last application in  their
               .xinitrc  or  .xsession file, letting the window manager start earlier, and run in
               the background.  This allows changing window managers  without  logging  out,  and
               also makes it much less likely that a session will be abruptly terminated by a bug
               in a complex program like a window manager.  The one drawback to this approach  is
               that  f.quit  then  no  longer terminates the session: you need to use f.delete or
               f.destroy on that last application to logout.

       f.raise This function raises the selected window.

       f.raiselower
               This function raises the selected window to the top of the stacking order if it is
               occluded by any windows, otherwise the window will be lowered.

       f.refresh
               This function causes all windows to be refreshed.

       f.resetdesktop
               This function moves the real display to (0,0)

       f.resize
               This function drags an outline of the selected window (or the window itself if the
               OpaqueResize  variable  is  set)  after  crossing  a   border   (or   by   setting
               AutoRelativeResize)  until  the invoking pointer button is released, at which time
               the window is raised (subject to RaiseOnStart, MoveDelta, and NoRaiseOnResize). To
               abort the resize, press another button before releasing the invoking button.

       f.restart
               This function kills and restarts vtwm. See also f.startwm.

       f.righticonmgr
               This  function  is  similar  to f.nexticonmgr except that wrapping does not change
               rows.

       f.rightzoom
               This variable is similar to the f.bottomzoom function  except  that  the  selected
               window is only resized to the right half of the display.

       f.ring  Selects  a  window  and  adds  it  to the WindowRing list, or removes it if it was
               already in the ring. This command makes f.warpring much more useful, by making its
               configuration dynamic.

       f.saveyourself
               This  function  sends  a  WM_SAVEYOURSELF message to the selected window if it has
               requested the message in its WM_PROTOCOLS window property.   Clients  that  accept
               this  message  are supposed to checkpoint all state associated with the window and
               update the WM_COMMAND property as specified in the ICCCM.  If the window  has  not
               requested this message, the keyboard bell will be rung.

       f.separator
               Valid  only  in  menus. The effect is to add a line separator between the previous
               and the following entry. The name selector part in the menu is not used (but  must
               be present).

       f.setrealscreen geomstr
               This  function  sets  the  real  screen to the virtual coordinates specified.  The
               geomstr is a quoted string containing a standard geometry specification.

       f.showdesktopdisplay
               This function maps the desktop display.

       f.showiconmgr
               This function maps the current icon manager when selected from  a  client  window,
               and maps all icon managers when selected from the root window.

       f.snap  This  function  snaps  the  real  screen  to  a grid defined on virtual space with
               PanDistanceX and PanDistanceY increments.

       f.snaprealscreen
               This function toggles the setting of SnapRealScreen.

       f.snugdesktop
               moves the display to try to fit all partially visible windows  completely  on  the
               screen.

       f.snugwindow
               moves the display to try to fit the selected window completely on the screen

       f.sorticonmgr
               This  function  sorts the entries in the current icon manager alphabetically.  See
               the variable SortIconManager.

       f.sounds
               This function toggles the playing of sounds. It's a "mute" function.

       f.squeezecenter

       f.squeezeleft

       f.squeezeright
               Selects a window and makes its title appear as though you had configured it as
                   SqueezeTitle    center    0    0
               or
                   SqueezeTitle    left      0    0
               or
                   SqueezeTitle    right     0    0
               respectively.  These  make  squeezed  titles  much  more  useful   because   their
               configuration is dynamic.

       f.startwm commandline
               This  function  kills  vtwm,  and  starts  up  the  window manager as specified by
               commandline. A trailing ampersand and/or environment variables should not be used.
               See also f.restart.

       f.staticiconpositions
               This function toggles the setting of StaticIconPositions.

       f.stick This function is a synonym for f.nail.

       f.stickyabove
               This function is synonymous with the f.nailedabove function.

       f.stricticonmgr
               This function toggles the setting of StrictIconManager.

       f.title This  function  provides  a  centered, unselectable item in a menu definition.  It
               should not be used in any other context.

       f.topzoom
               This variable is similar to the f.bottomzoom function  except  that  the  selected
               window is only resized to the top half of the display.

       f.twmrc Synonymous  with f.restart.  Historically, this function was intended to cause the
               startup customization file to be re-read.

       f.unbindbuttons

       f.unbindkeys
               These functions disable vtwm's pointer  or  keyboard  bindings  for  the  selected
               window,  allowing  events  to pass directly to the application.  These are useful,
               for example, when running another window manager within Xnest or Xvnc.

       f.unfocus
               This function resets the focus back to pointer-driven.  This should be used when a
               focused window is no longer desired.

       f.upiconmgr
               This  function  warps the pointer to the previous row in the current icon manager,
               wrapping to the last row in the same column if necessary.

       f.version
               This function causes the vtwm version window to be displayed.  This window will be
               displayed  until  a  pointer  button  is  pressed or the pointer is moved from one
               window to another.

       f.virtualgeometries
               This function toggles the setting of NotVirtualGeometries.

       f.vlzoom
               This function is a synonym for f.leftzoom.

       f.vrzoom
               This function is a synonym for f.rightzoom.

       f.warp  Warp the cursor to the selected window.  This is only  useful  if  the  window  is
               selected via the icon manager.

       f.warpclassnext string

       f.warpclassprev string
               These  functions  warp the pointer to the next or previous window in the specified
               class indicated by the argument string.  If string is "VTWM", only icon  managers,
               doors, and the Virtual Desktop window are considered.  If string empty (i.e., ""),
               the class of the window with focus is used.  If the window is iconified,  it  will
               be deiconified if the variable WarpUnmapped is set or else ignored.

       f.warpring string
               This  function  warps  the pointer to the next or previous window (as indicated by
               the argument string, which may be "next" or "prev") specified  in  the  WindowRing
               variable.   If  the  window  is  iconified, it will be deiconified if the variable
               WarpUnmapped is set or else ignored.

       f.warpsnug
               This function toggles the setting of WarpSnug.

       f.warpto string
               This function warps the pointer to the window which  has  a  name  or  class  that
               matches  string.  The  string  may  be  a  VTWM-style  wildcard, but not a regular
               expression (see the WILDCARDS section for details).  If the window  is  iconified,
               it will be deiconified if the WarpUnmapped variable is set, or else ignored.

       f.warptoiconmgr string
               This  function  warps  the  pointer  to the icon manager entry associated with the
               window containing the pointer in  the  icon  manager  specified  by  the  argument
               string.   If  string  is empty (i.e., ""), the current icon manager is chosen.  If
               the window is iconified, it will be deiconified if the  variable  WarpUnmapped  is
               set or else ignored.

       f.warptonewest
               This  function  warps  the  pointer  to  the most recently created window.  If the
               window is iconified, it will be deiconified if the variable WarpUnmapped is set or
               else ignored.

       f.warptoscreen string
               This  function  warps  the pointer to the screen specified by the argument string.
               String may be a number (e.g., "0" or "1"), the word "next" (indicating the current
               screen  plus  1, skipping over any unmanaged screens), the word "back" (indicating
               the current screen minus 1, skipping over any  unmanaged  screens),  or  the  word
               "prev" (indicating the last screen visited.

       f.warpvisible
               This function toggles the setting of WarpVisible.

       f.winrefresh
               This  function  is similar to the f.refresh function except that only the selected
               window is refreshed.

       f.zoom  This function is similar to the f.fullzoom function,  except  that  the  only  the
               height of the selected window is changed.

       f.zoomzoom
               This  function  makes  a  zoom outline from a random place to another random place
               (see the Zoom and ZoomZoom variables). It's silly, but can be  used  as  a  visual
               bell in place of f.beep.  See also the LessRandomZoomZoom variable.

MENUS

       Functions  may be grouped and interactively selected using pop-up (when bound to a pointer
       button)  or  pull-down  (when  associated  with  a  titlebar  button)  menus.   Each  menu
       specification  contains the name of the menu as it will be referred to by f.menu, optional
       default foreground and background colors, the list of item names and  the  functions  they
       should invoke, and optional foreground and background colors for individual items:
           Menu    "menuname"    [ ("deffore":"defback") ]
           {
               string1    [ ("fore1":"back1")]    function1
               string2    [ ("fore2":"back2")]    function2
                 ...
               stringN    [ ("foreN":"backN")]    functionN
           }

       The  menuname  is  case-sensitive.  The optional deffore and defback arguments specify the
       foreground and background colors used on a color display to highlight menu  entries.   The
       string  portion  of  each  menu entry will be the text which will appear in the menu.  The
       optional fore and back arguments specify the foreground and background colors of the  menu
       entry  when  the  pointer  is not in the entry.  These colors will only be used on a color
       display.   The  default  is  to  use  the  colors  specified  by  the  MenuForeground  and
       MenuBackground variables.  The function portion of the menu entry is one of the functions,
       including any user-defined functions, or additional menus.

       There is a special menu named VTWM Windows which contains the names of all of  the  client
       and  vtwm-supplied  windows.   Selecting  an  entry  will  cause  the WindowFunction to be
       executed on  that  window.   If  WindowFunction  hasn't  been  set,  the  window  will  be
       deiconified  and  raised.   This  menu  uses  the same colors as the little windows in the
       panner.  This feature still honors the traditional TwmWindows menu name of yore.

ICONS

       vtwm supports several different ways of manipulating iconified windows.  The common image-
       and-text  style  may  be  laid  out  by hand or automatically arranged as described by the
       IconRegion variable.  In addition, a terse grid of icon names,  called  an  icon  manager,
       provides  a  more  efficient  use of screen space as well as the ability to navigate among
       windows from the keyboard.

       An icon manager is a window that contains names of selected or all  windows  currently  on
       the  display.   In  addition  to the window name, a small button using the default iconify
       symbol will be displayed to the left of  the  name  when  the  window  is  iconified.   By
       default,  clicking  on  an  entry  in  the icon manager performs f.iconify.  To change the
       actions taken in the icon manager, use the iconmgr  context  when  specifying  button  and
       keyboard bindings.

       Moving  the  pointer  into  the  icon manager also directs keyboard focus to the indicated
       window when NoIconManagerFocus is not set (setting the focus explicitly  or  else  sending
       synthetic   events   if  NoTitleFocus  is  set).   Using  the  f.upiconmgr,  f.downiconmgr
       f.lefticonmgr, and f.righticonmgr functions,  the  input  focus  can  be  changed  between
       windows directly from the keyboard.

IMAGE AND AUDIO FORMATS

       vtwm  supports  many  images  on  its own (referred to as "internal" or "built-in" in this
       document), divided into two types, bitmaps and pixmaps. They are differentiated from  file
       images  by  either  a  colon  (':') or the string ":xpm:" as the first character(s) of the
       name, respectively:
           :darrow             scaled in any, n/a for highlight
           :delete / :xlogo    centered in any drawable
           :dot / :iconify     centered in any drawable
           :menu               scaled in any drawable
           :rarrow             scaled in any, n/a for highlight
           :resize             scaled in any drawable

           :xpm:bar            scaled in any drawable
           :xpm:box            scaled in any drawable
           :xpm:darrow         scaled in any, n/a for highlight
           :xpm:dot            centered in any drawable
           :xpm:lines          scaled in any drawable
           :xpm:menu           scaled in any drawable
           :xpm:raisedbox      scaled, for highlight only
           :xpm:raisedlines    scaled, for highlight only
           :xpm:rarrow         scaled in any, n/a for highlight
           :xpm:resize         scaled in any drawable
           :xpm:sunkenbox      scaled, for highlight only
           :xpm:sunkenlines    scaled, for highlight only
           :xpm:zoom           scaled in any drawable

       vtwm also supports a single image file format by  default,  the  X  Window  System  bitmap
       (files  typically  carrying  an  extension of ".xbm"), for two-color images. However, when
       built with the XPM library, vtwm will also support  the  X  Window  System  pixmap  (files
       typically carrying an extension of ".xpm"), for full-color images.

       All  image types and sources can be freely mixed within the variables that use them, given
       the behavior listed above, and with the following additional  exceptions:  The  Icons  and
       UnknownIcon   variables   don't  recognize  the  built-in  images,  the  RealScreenPixmap,
       TitleHighlight,  and  VirtualBackgroundPixmap  entries  of  the  Pixmaps  variable   don't
       recognize  the  built-in images, only titlebar buttons can accomodate external images that
       would be larger than the default space allocated for them (in any other  case,  the  image
       will   be   cropped   to   fit),   and  only  the  RealScreenPixmap,  TitleHighlight,  and
       VirtualBackgroundPixmap entries of the Pixmaps variable will tile small  images  into  the
       space allocated for them.

       The  icon  manager  drawable  is hard-coded to 11x11 pixels, the menu drawable is MenuFont
       pixels square, and titlebar buttons are
           (TitleFont - (2 * ButtonIndent))
       pixels square. The titlebar highlight area is
           (titlebar height - (2 * FramePadding) - 2)
       pixels high, where titlebar height is determined  by  TitleFont  or  the  titlebar  button
       height, whichever is greater, and FramePadding.

       The  root window can be decorated with whatever image files that are supported by X Window
       System utilities and applications (xloadimage(1), xsetroot(1), xv(1), etc.).

       If vtwm is built with sound support, several audio file formats are supported, not by vtwm
       per  se,  but  by the rplayd(8) daemon.  Currently, the AU, AIFF, WAV, and VOC formats are
       natively supported, but see also rplay.helpers(5).

WILDCARDS

       vtwm supports "wildcarding" when  matching  windows  against  a  variable's  win-list.  By
       default,  the  question  mark  ('?')  represents  any single character, the asterisk ('*')
       represents any zero  or  more  characters,  and  brackets  ('['  and  ']')  represent  any
       characters  listed  within them. The backslash ('\') "escapes" any one character, allowing
       these reserved characters to be used literally.

       vtwm can support a richer method of character substitution, called regular expressions, or
       "RE"s.  If  vtwm is built with REs, many more "wildcard" rules are added. A description of
       REs is beyond the scope of this document; see the re_format(7) or egrep(1) man pages.

       vtwm distinguishes REs from strings by enclosing them in forward slashes  ('/').  The  two
       may be freely mixed; changing the example in the VARIABLES section to:
           AutoRaise
           {
               "emacs"
               "VTWM*"
               /x.*clock/    # was "x*clock"
               "Xmh"
               "XTerm"
           }
       accomplishes the same thing. This is but a simple example of RE usage, and as such doesn't
       demonstrate or leverage their capabilities.

ASYNCHRONOUS EVENTS

       It is possible to issue an f.restart via a Unix signal, to ease debugging of vtwm resource
       files.   To  do  this,  send a SIGUSR1 to the vtwm process ID (written to $HOME/vtwm.pid).
       See kill(1) or slay(1).

BUGS

       There are precious few safeguards against binding functions  to  objects  inappropriately,
       especially where the virtual desktop is concerned.

       Double  clicking  very  fast to get the constrained move function will sometimes cause the
       window to move, even though the pointer is not moved.

       It is possible to ‘lose’ windows in the virtual desktop by placing them in a large desktop
       area, then shrinking the desktop so as to remove them from view.  They are still there, of
       course, but are unreachable until the

       See the BUGS file in the distribution for others.

FILES

       $HOME/.vtwmrc.screen-number
       $HOME/.vtwmrc
       $VTWMETCMDIR/vtwm/system.vtwmrc
       $HOME/.twmrc.screen-number
       $HOME/.twmrc
       $VTWMETCMDIR/twm/system.vtwmrc
              are files vtwm will search for  and  use  as  its  configuration  file.   They  are
              searched for in the order shown, and the first readable file found is used.

       $HOME/vtwm.pid
              contains  the  ID  of the user's vtwm process; see the description of the -p option
              above.

ENVIRONMENT

       DISPLAY
              This variable is used to determine which X server to use.  It is  also  set  during
              f.exec so that programs come up on the proper screen.

       HOME   This  variable  is  used  as  the  prefix for files that begin with a tilde and for
              locating the vtwm startup file.

AUTHORS AND CONTRIBUTORS

       Tom LaStrange, Solbourne Computer; Jim Fulton, MIT X Consortium; Steve Pitschke,  Stardent
       Computer;  Keith  Packard,  MIT  X  Consortium;  Dave Payne, Apple Computer; Nick Williams
       <njw@athena.mit.edu>; Dave Edmondson, Santa Cruz Operation, <davided@sco.com>; Dana  Chee,
       Bellcore  (R5  conversion),  <dana@thumper.bellcore.com>;  Warren  Jessop,  University  of
       Washington,  <whj@cs.washington.edu>;  Gilligan   <thoth@reef.cis.ufl.edu>;   Tim   Ramsey
       <tar@math.ksu.edu>;   Ralph   Betza   <gnohmon@ssiny.com>;   Michael  Kutzner  <futzi@uni-
       paderborn.de>; Stig Ostholm  <ostholm@ce.chalmers.se>;  M.  Eyckmans  <mce@ping.be>;  Tony
       Brannigan <tbrann@ox.ac.uk>; Alec Wolman <wolman@crl.dec.com>; <gdmr@dcs.edinburgh.ac.uk>;
       Marcel       Mol       <marcel@duteca.et.tudelft.nl>;        Darren        S.        Embry
       <dsembr01@starbase.spd.louisville.edu>;  Chris  P.  Ross <cross@eng.umd.edu>; Paul Falstad
       <pf@z-code.z-code.com>; D. J. Hawkey Jr., (version  5.4),  <hawkeyd@visi.com>,  with  Erik
       Agsjo <erik.agsjo@aktiedirekt.com>, Ugen Antsilevitch <ugen@xonix.com>, Nelson H. F. Beebe
       <beebe@math.utah.edu>,   Michael    Dales    <michael@dcs.gla.ac.uk>,    Jennifer    Elaan
       <jen@elaan.com>,  Michel  Eyckmans  <mce@ping.be>,  Callum  Gibson <callum.gibson@db.com>,
       Jason Gloudon <jdg@world.std.com>, Nicholas  Jacobs  <nicholas_jacobs@hotmail.com>,  Caveh
       Frank  Jalali  <caveh@eng.sun.com>  Takeharu  Kato  <magician@maekawa.is.uec.ac.jp>, Goran
       Larsson  <hoh@lorelei.approve.se>,  Rolf  Neugebauer  <neugebar@dcs.gla.ac.uk>,   Jonathan
       Paisley   <jp@dcs.gla.ac.uk>,  Steve  Ratcliffe  <sterat@dial.pipex.com>,  Seth  Robertson
       <seth@baka.org>,   Mehul   N.   Sanghvi    <mehul@kirsun.ne.mediaone.net>,    Tim    Wiess
       <tim@zetaflops.net>, acknowledging Claude Lecommandeur, (ctwm), <lecom@sic.epfl.ch>

COPYRIGHT

       Copyright 1988 Evans & Sutherland Computer Corporation
       Copyright 1989 Massachusetts Institute of Technology
       Copyright 1990 Dave Edmondson
       Copyright 1990 Imperial College of Science, Technology & Medicine
       Copyright 1990, 1991 Groupe Bull
       Copyright 2001 David J. Hawkey Jr.

       See  the  copyright  notices  in  the  vtwm  source  distribution  for  copyright  license
       statements.    On   Debian   systems,   these   may   also   be   found   in   the    file
       /usr/share/doc/vtwm/copyright.

SEE ALSO

       bitmap(1),  ctwm(1),  m4(1), mwm(1), pixmap(1), regex(7) or egrep(1), rplayd(8), tvtwm(1),
       twm(1), vuewm(1), X(1), xdm(1), xinit(1), xmodmap(1), xrdb(1), Xserver(1)