

CTWM(1)								      CTWM(1)

***********************
VMS specific:
  This is an edited version of the man page.
  Compilation note: this window manager has been compiled to run on VMS.
  Hence file and directory specifications should be in that format.
  peterc@a3.ph.man.ac.uk 21/7/93 & 15/2/95
***********************


NAME
  ctwm - Tab Window Manager for the X Window System

SYNTAX

  ctwm [-display dpy] [-s] [-f initfile] [-v] [-n] [-k] [-w [win-id]]

DESCRIPTION

  Ctwm is a window manager for the X Window System.  It provides titlebars,
  shaped windows, virtual screens (workspaces), several forms of icon manage-
  ment, user-defined macro functions, click-to-type and pointer-driven key-
  board focus, and user-specified key and pointer button bindings.  It is
  actually twm (Tab Window Manager) from the MIT X11 distribution slightly
  modified to accomodate the use of several virtual screens (workspaces). It
  is heavily inspired from the Hewlett-Packard vuewm window manager. In addi-
  tion, ctwm can use coloured, shaped icons and background root pixmaps in
  XPM format [from Arnaud Le Hors],any format understood by the imconv pack-
  age [from the San Diego Supercomputer Center] and xwd files. Ctwm can be
  compiled to use both, either or none of the above icon/pixmap formats.

  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, ctwm
  is frequently executed in the foreground as the last client.	When run this
  way, exiting ctwm causes the session to be terminated (i.e. logged out).

  By default, application windows are surrounded by a ``frame'' with a
  titlebar at the top and a special border around the window.  The titlebar
  contains the window's name, a rectangle that is lit when the window is
  receiving keyboard input, and function boxes known as ``titlebuttons'' at
  the left and right edges of the titlebar.

  Pressing pointer Button1 (usually the left-most button unless it has been
  changed with xmodmap) on a titlebutton will invoke the function associated
  with the button.  In the default interface, windows are iconified by click-
  ing (pressing and then immediately releasing) the left titlebutton (which
  looks like a Dot).  Conversely, windows are deiconified by clicking in the
  associated icon or entry in the icon manager (see description of the vari-
  able ShowIconManager and of the function f.showiconmgr).

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

  When new windows are created, ctwm will honor any size and location infor-
  mation requested by the user (usually through -geometry command line argu-
  ment or resources for the individual applications). Otherwise, an outline
  of the window's default size, its titlebar, and lines dividing the window
  into a 3x3 grid that track the pointer are displayed.	 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 outline 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 posi-
  tion but attempt to make it long enough to touch the bottom the screen.

OPTIONS
  Ctwm accepts the following command line options:

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

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

***********************
VMS specific:
  filename.num -> filename_num
  and see note below for .ctwmrc
***********************

  -f filename
	  This option specifies the name of the startup file to use.  Ctwm
	  will first try to load filename.num, where num is the screen
	  number.  If it fails, it will try to load filename.  By default,
	  ctwm will look in the user's home directory for files named
	  .ctwmrc.num (where num is a screen number) or .ctwmrc.

  -v	  This option indicates that ctwm should print error messages when-
	  ever an unexpected X Error event is received.	 This can be useful
	  when debugging applications but can be distracting in regular use.

  -n	  This option indicates that ctwm should not filter the startup file
	  through m4. Available only if ctwm is compiled with the USEM4 flag.

  -k	  This option indicates that ctwm should keep the result of filtering
	  your startup file through m4 in /tmp. Available only if ctwm is
	  compiled with the USEM4 flag.

  -w [win-id]
	  If -w is specified without a win-id value, ctwm does not take over
	  the whole screen(s), instead it creates a new window that becomes
	  its root window. if the win-id value is given, it is considered to
	  be the id of an existing window, in which case, ctwm will try to
	  use this window as root window. You can run any number of instan-
	  tiation of ctwm at the same time. You can even have embedded ctwm
	  instantiations. This is totally useless, but I like. The
	  f.adoptwindow function can be used to capture an existing window
	  belonging to another ctwm. A possible use of such mode can be to
	  test new configuration file without restarting ctwm.

  -W	  This option tells ctwm not to display any welcome when starting.


CUSTOMIZATION

  Much of ctwm'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 ctwm begins):

***********************
VMS specific:
  Instead of $HOME/.[c]twmrc[.#] use DECW$USER_DEFAULTS:[C]TWM.RC[_#]
  -- where the logical DECW$USER_DEFAULTS usually points to
     SYS$LOGINROOT:[DECW$DEFAULTS], eg mphv2$user2:[bloggs.decw$defaults].
  and /usr/lib/X11/twm/system.ctwmrc => DECW$SYSTEM_DEFAULTS:SYSTEM.CTWMRC
***********************

  $HOME/.ctwmrc.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/.ctwmrc
	  This is the usual name for an individual user's startup file.

  $HOME/.twmrc
	  The users twm startup file.

  /usr/lib/X11/twm/system.ctwmrc
	  If none of the preceding files are found, ctwm will look in this
	  file for a default configuration.  This is often tailored by the
	  site administrator to provide convenient menus or familiar bindings
	  for novice users.

  If no startup files are found, ctwm will use the built-in defaults
  described above.  The only resource used by ctwm is bitmapFilePath for a
  colon-separated list of directories to search when looking for bitmap files
  (for more information, see the Athena Widgets manual and xrdb(1)).

  Ctwm startup files are logically broken up into three types of specifica-
  tions:  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, 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 sur-
  rounded by double quote characters (e.g. "blue") and are case-sensitive.  A
  pound sign (#) outside of a string causes the remainder of the line in
  which the character appears to be treated as a comment.

VARIABLES

  Many of the aspects of ctwm'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" "XTerm" "Xmh" }



  or

       AutoRaise
       {
	       "emacs"
	       "XTerm"
	       "Xmh"
       }

  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 an exact, case-sensitive match to the window's
  name name (given by the WM_NAME window property), resource name or class
  name (both given by the WM_CLASS window property).  The preceding example
  would enable autoraise on windows named ``emacs'' as well as any xterm
  (since they are of class ``XTerm'') or xmh windows (which are of class
  ``Xmh'').

***********************
VMS specific:
  The tilde (~) is taken as indicating that the file "~foo.bar"
  is looked for in HOME or SYS$LOGIN, e.g. SYS$LOGIN = DISK$USERS:[BLOGGS]
  implies "~foo.bar" will be DISK$USERS:[BLOGGS]FOO.BAR.
  Also a leading slash (/) implies an absolute filename,
  e.g. "/disk$users:[joe]foo.bar" means DISK$USERS:[JOE]FOO.BAR.
***********************

  String arguments that are interpreted as filenames (see the Pixmaps, Cur-
  sors, and IconDirectory 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 the default
  titlebars symbols:  :xlogo or :iconify (both refer to the X used for the
  iconify button), :resize (the nested squares used by the resize button),
  and :question (the question mark used for non-existent bitmap files).

  The following variables may be specified at the top of a ctwm startup file.
  Lists of Window name prefix strings are indicated by win-list.  Optional
  arguments are shown in square brackets:

  AlwaysOnTop { win-list }
	  This variable specifies a list of windows (all windows if the list
	  is defaulted) that ctwm will try its best to maintain on top of
	  others. This doesn't work in all case.

  AlwaysShowWindowWhenMovingFromWorkspaceManager
	  When ReallyMoveInWorkspaceManager is present and the user is moving
	  a window from the WorkSpaceMap, ctwm display the actual window only
	  if it crosses the current active workspace. If AlwaysShowWin-
	  dowWhenMovingFromWorkspaceManager is present, the actual window is
	  always visible during the move, regardless of whether it crosses
	  the current workspace or not. The Shift key toggles this behaviour.

  AnimationSpeed speed
	  The speed argument is a non-negative integer. It determines the
	  number of times a second animations (if any) are updated. If speed
	  is 0, animations are freezed. The default value is 0.

  AutoOccupy
	  This variable specifies that clients will automatically change
	  their occupation when their name or icon name changes. The new
	  occupation will be recalculated from the Occupy and OccupyAll
	  fields in the .ctwmrc file.

  AutoRaise { win-list }
	  This variable specifies a list of windows (all windows if the list
	  is defaulted) 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.

  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 of 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 titlebutton, ctwm will still wait for the pointer to
	  cross a window edge (to prevent accidents).  This option is partic-
	  ularly useful for people who like the press-drag-release method of
	  sweeping out window sizes.

  BeNiceToColormap
	  By defaults new colors are allocated for shadows when a 3D look is
	  used, but when you specify BeNiceToColormap ctwm uses stipling
	  instead of new colors, the effect is less beautiful, but accept-
	  able. In this case ClearShadowContrast and DarkShadowContrast have
	  no effects.

  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 par-
	  ticular border colors for different types of windows.	 For example:

	       BorderColor "gray50"
	       {
		       "XTerm" "red"
		       "xmh"   "green"
	       }

	  The default is "black".

  BorderResizeCursors
	  This variable specifies that ctwm should use resizing cursors when
	  the pointer is on the window border. To be used preferably when you
	  have bound a button to f.resize in the frame context.

  BorderShadowDepth pixels
	  This variable specifies the depth of the shadow ctwm uses for 3D
	  window borders, when UseThreeDBorders is selected.

  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 "white".

  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 "black".

  BorderWidth pixels
	  This variable specifies the width in pixels of the border surround-
	  ing all client window frames if ClientBorderWidth has not been
	  specified.  This value is also used to set the border size of win-
	  dows created by ctwm (such as the icon manager).  The default is 2.

  ButtonIndent pixels
	  This variable specifies the amount by which titlebuttons should be
	  indented on all sides.  Positive values cause the buttons to be
	  smaller than the window text and highlight area so that they stand
	  out.	Setting this and the TitleButtonBorderWidth variables to 0
	  makes titlebuttons be as tall and wide as possible.  The default is
	  1 if UseThreeDTitles is not set, 0 if it is set.

  ClearShadowContrast contrast
	  Indicates to ctwm how to calculate the clear shadow color for 3D
	  items.  The value is a comprised between 0 and 100. The formula
	  used is :

		   clear.{RGB} = (65535 - color.{RGB}) * (contrast / 100).

	  Has no effect if BeNiceToColormap is active.

  ClientBorderWidth
	  This variable indicates that border width of a window's frame
	  should be set to the initial border width of the window, rather
	  than to the value of BorderWidth.

  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 vari-
	  ables and their values: DefaultBackground, DefaultForeground, Menu-
	  Background, MenuForeground, MenuTitleBackground, MenuTitleFore-
	  ground, 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): Bor-
	  derColor, IconManagerHighlight, BorderTileBackground, Border-
	  TileForeground, TitleBackground, TitleForeground, IconBackground,
	  IconForeground, IconBorderColor, IconManagerBackground, and Icon-
	  ManagerForeground.  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 Mono-
	  chrome 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 win-
	  dow only 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 ctwm 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"

	  The image and mask strings 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"
	       }


  DarkShadowContrast contrast
	      Indicates to ctwm hos to calculate the dark shadow color for 3D
	  items.  The value is a comprised between 0 and 100. The formula
	  used is :

		   dark.{RGB}  = color.{RGB} * ((100 - contrast) / 100),

	  Has no effect if BeNiceToColormap is active.

  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 "white".

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

  DontIconifyByUnmapping { win-list }
	  This variable specifies a list of windows that should not be iconi-
	  fied by simply unmapping the window (as would be the case if Icon-
	  ifyByUnmapping 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.

  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.

  DontPaintRootWindow
	  This variable tells ctwm not to paint the root window, whatever you
	  told in the Workspaces specification. This is useful to have pix-
	  maps in the Workspace Map but not on the root window.

  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.

  DontWarpCursorInWMap
	  Tells ctwm not to warp the cursor to the corresponding actual win-
	  dow when you click in a small window in the workspace map.

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

  FramePadding pixels
	  This variable specifies the distance between the titlebar decora-
	  tions (the button and text) and the window frame.  The default is 2
	  pixels if UseThreeDTitles is not set, 0 if it is set.

  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 com-
	  plete description of the win-list.  The default is "white".

  IconBorderColor string [{ win-list }]
	  This variable specifies the color of the border used for icon win-
	  dows, 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
	  "black".

  IconBorderWidth pixels
	  This variable specifies the width in pixels of the border surround-
	  ing icon windows.  The default is 2.

  IconDirectory string
	  This variable specifies the directory that should be searched if if
	  a bitmap file cannot be found in any of the directories in the bit-
	  mapFilePath resource.

  IconFont string
	  This variable specifies the font to be used to display icon names
	  within icons.	 The default is "variable".

  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 "black".

  IconifyByUnmapping [{ win-list }]
	  This variable indicates that windows should be iconified by being
	  unmapped without trying to map any icons.  This assumes that the
	  user is will remap the window through the icon manager, the
	  f.warpto function, or the TwmWindows menu.  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 if no binding to the TwmWindows
	  menu is set in the user's startup file.

  IconJustification string
	  Where string is either "left", "center" or "right".  Tells ctwm how
	  to justify the icon image against the icon title (if any).

  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 "white".

  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.

  IconManagerFont string
	  This variable specifies the font to be used when displaying icon
	  manager entries.  The default is "variable".

  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 "black".

  IconManagerGeometry string [ columns ]
	  This variable specifies the geometry of the icon manager window.
	  The string argument is standard geometry specification that indi-
	  cates the initial full size of the icon manager.  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 number of columns is
	  1.

  IconManagerHighlight string [{ win-list }]
	  This variable specifies the border color to be used when highlight-
	  ing 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.  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.

  IconManagerShadowDepth pixels
	  This variable specifies the depth of the shadow ctwm uses for 3D
	  IconManager entries, when UseThreeDIconManagers is selected.

  IconManagerShow { win-list }
	  This variable specifies a list of windows that should appear in the
	  icon manager.	 When used in conjunction with the IconManager-
	  DontShow variable, only the windows in this list will be shown in
	  the icon manager.


  IconRegion geomstring vgrav hgrav gridwidth gridheight [{ win-list }]
	  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 geomstring is a quoted string containing a standard geometry
	  specification.  If more than one IconRegion lines are given, icons
	  will be put into the succeeding icon regions when the first is
	  full.	 The vgrav argument should be either North or South and con-
	  trol and is used to control whether icons are first filled in from
	  the top or bottom of the icon region.	 Similarly, the hgrav argu-
	  ment should be either East or West and is used to control whether
	  icons should be filled in from left from the right.  Icons are laid
	  out within the region in a grid with cells gridwidth pixels wide
	  and gridheight pixels high. The optional win-list argument tells
	  ctwm that if such a window is iconified, and there is enough room
	  in this icon region for its icon, then place it here.

  IconRegionAlignement string
	  Where string is either "top", "center" "bottom" or "border".	Tells
	  ctwm how to align icons inside their place in the IconRegion.	 This
	  keyword needs a string value. The acceptable values are : "top",
	  "center", "bottom" and "border". If "border" is given, the justifi-
	  cation will be "top" if the icon region gravity is "north" and
	  "bottom" if the icon region gravity is "south".

  IconRegionJustification string
	  Where string is either "left", "center" "right" or "border".	Tells
	  ctwm how to justify icons inside their place in the IconRegion.
	  This keyword needs a string value. The acceptable values are :
	  "left", "center", "right" and "border". If "border" is given, the
	  justification will be "left" if the icon region gravity is "west"
	  and "right" if the icon region gravity is "east".

  Icons { win-list }
	  This variable specifies a list of window names and the bitmap
	  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 bitmap in the file
	  ``xterm.icon''.  If ForceIcons is specified, this bitmap will be
	  used even if the client has requested its own icon pixmap.

  InterpolateMenuColors
	  This variable indicates that menu entry colors should be
	  interpolated between entry specified colors.	In the example below:

	       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 inter-
	  polated 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.

  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.

  MapWindowBackground color [{ win-list }]
	  This variable specifies the background colors to use for small win-
	  dows in the workspace map window 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.
	  If there is neither MapWindowBackground, nor MapWindowForeground
	  the window title colors are used.

  MapWindowCurrentWorkSpace { border_color background foreground bitmap }
	  Specify the appearence of the map window corresponding to the
	  current workspace.

  MapWindowDefaultWorkSpace { border_color background foreground bitmap }
	  Specify the appearence of the map window corresponding to the
	  workspaces other than the current workspace when no root background
	  information has been provided to ctwm in the WorkSpace command. Not
	  used in others cases.

  MapWindowForeground color [{ win-list }]
	  This variable specifies the foreground colors to use for small win-
	  dows in the workspace map window 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.
	  If there is neither MapWindowBackground, nor MapWindowForeground
	  the window title colors are used.

  MaxIconTitleWidth width
	  The integer argument tells ctwm the maximun width to use for an
	  icon title. If an icon title is larger than width, it is truncated.

  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 "white".

  MenuFont string
	  This variable specifies the font to use when displaying menus.  The
	  default is "variable".

  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 "black".

  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".

  MenuShadowDepth pixels
	  This variable specifies the depth of the shadow ctwm uses for 3D
	  menus, when UseThreeDMenus is selected.

  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 "white".

  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 "black".

  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 function starts working.  Also see the
	  f.deltastop function.	 The default is zero pixels.

  MovePackResistance pixels
	  This variable specifies the number of pixels of the movepack and
	  movepush resistance. See f.movepack and f.movepush.

  MoveOffResistance pixels
	  This variable specifies the number of pixels of the moveoff resis-
	  tance.  If pixels is positive, DontMoveOff will only prevent you
	  from going off the edge if you're within n pixels off the edge. If
	  you go further, DontMoveOff gives up and lets you go as far as you
	  wish. f.forcemove still allows you to totally ignore DontMoveOff.
	  A negative value puts you back into "never moveoff" mode (it's the
	  default).

  NoBackingStore
	  This variable indicates that ctwm's menus should not request back-
	  ing store to minimize repainting of menus.  This is typically used
	  with servers that can repaint faster than they can handle backing
	  store.

  NoBorder { win-list }
	  These windows won't have border. If you want no borders on all win-
	  dows, use the BorderWidth keyword.

  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.

  NoDefaults
	  This variable indicates that ctwm should not supply the default
	  titlebuttons and bindings.  This option should only be used if the
	  startup file contains a completely new set of bindings and defini-
	  tions.

  NoGrabServer
	  This variable indicates that ctwm should not grab the server when
	  popping up menus and moving opaque 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 Border-
	  Color.  When the border is not highlighted, it will be stippled
	  with an gray pattern using the current BorderTileForeground and
	  BorderTileBackground colors.

  NoIconTitle [{ win-list }]
	  This variable indicates that icons should not display the icon name
	  of the client.  If the optional win-list is given, only those
	  clients will not have icon titles.

  NoIconManagerFocus
	  This variable indicates that ctwm will not set the focus on the
	  corresponding window when the pointer is in an IconManager.

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

  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 { window-list }
	  The counterpart of OpaqueMove. See OpaqueMove.

  NoOpaqueResize { window-list }
	  The counterpart of OpaqueResize. See OpaqueResize.

  NoRaiseOnDeiconify
	  This variable indicates that windows that are deiconified should
	  not be raised.

  NoRaiseOnMove
	  This variable indicates that windows should not be raised when
	  moved.  This is typically used to allow windows to slide underneath
	  each other.

  NoRaiseOnResize
	  This variable indicates that windows should not be raised when
	  resized.  This is typically used to allow windows to be resized
	  underneath each other.

  NoRaiseOnWarp
	  This variable indicates that windows should not be raised when the
	  pointer is warped into them with the f.warpto function.  If this
	  option is set, warping to an occluded window may result in the
	  pointer ending up in the occluding window instead the desired
	  window (which causes unexpected behavior with f.warpring).

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

  NoShowOccupyAll
	  This variable specifies that OccupyAll windows won't be displayed
	  in the WorkSpaceMap window.

  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.

  NoTitleFocus
	  This variable indicates that ctwm should not set keyboard input
	  focus to each window as it is entered.  Normally, ctwm 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 ctwm 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 appli-
	  cations 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.

  Occupy { occupy-list }
	  This variable specifies which windows occupy which workspaces at
	  startup.

	  occupy-list consists of entries of the form :

		       [Window]	  win-name { wpsc1 wspc2 ... }
	       or      Workspace  wspc-name {win1 win2 ... }

	  Example :

	       Occupy {
			      "xload"	{"all"}
		   Window     "xterm"	{"here" "there" "elsewhere"}
			      "xv"	{"images"}
		   WorkSpace  "images"	{"xloadimage"}
	       }

	  Note : The Occupy declaration should come after the WorkSpaces
	  declaration.


  OccupyAll { window-list }

	  This variable specifies a list of windows that will occupy all
	  workspaces at startup.

	  window-list is a list of window names.

	  Example :

	       OccupyAll
	       {
		   "xload"
		   "xbiff"
		   "xconsole"
	       }

	  Note : The OccupyAll declaration should come after the WorkSpaces
	  declaration.


  OpaqueMove { window-list }
	  This variable indicates that the f.move function should actually
	  move the window instead of just an outline so that the user can
	  immediately see what the window will look like in the new position.
	  This option is typically used on fast displays (particularly if
	  NoGrabServer is set). The optional window list parameter indicates
	  that only windows in this list should actually be moved in opaque
	  mode. The NoOpaqueMove counterpart is also available.

  OpaqueMoveThreshold { threshold }
	  The integer parameter is a percentage and indicates that only win-
	  dows (elligible for opaque moving) with a surface smaller than this
	  percentage of the surface of the screen should actually be moved in
	  opaque mode.

  OpaqueResize { window-list }
	  The opaque version of resize. Extremely resource intensive, but
	  beautiful with fast server/client/network. See OpaqueMove. The
	  NoOpaqueResize counterpart is also available.

  OpaqueResizeThreshold { threshold }
	  The resize version of OpaqueMoveThreshold.

  Pixmaps { pixmaps }
	  This variable specifies a list of pixmaps that define the appear-
	  ance of various images.  Each entry is a keyword indicating the
	  pixmap to set, followed by a string giving the name of the bitmap
	  file.	 The following pixmaps may be specified:

	       Pixmaps
	       {
		       TitleHighlight  "gray1"
	       #    TitleHighlight "supman%.xbm"
	       }

	  The default for TitleHighlight is to use an even stipple pattern.

  PixmapDirectory path
	  This variable specifies the path where ctwm looks to find non-X11
	  bitmap files.	 Whenever you want to use a image file that is not an
	  X11 bitmap, specify : xpm:filename (for xpm files) or xwd:filename
	  for xwd files, or im:filename (for other files supported by the
	  imconv package), or |command for an on the file generated xwd file.

**************
VMS specific:
  PixmapDirectory	"mphv2$user2:[bloggs.xpm]"
**************

	  Use the % character to specify an animation.	Example :

	       PixmapDirectory	"/usr/lib/X11/twm"
	       Icons
	       {
		   "Axe"    "xpm:edit.xpm"
		   "xterm"  "xpm:ball%.xpm"
	       }

	  N.B This is only valid if your version of ctwm has been compiled
	  with the XPM and IMCONV options.

  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.

  RandomPlacement [ string ]
	  Where string is either "on", "off", "all" or "unmapped".  This
	  variable indicates that windows with no specified geometry should
	  be placed in a pseudo-random location instead of having the user
	  drag out an outline. The argument "on" or "all" tells ctwm do do
	  this for all such windows, "off", not to do this, and "unmapped",
	  only for unmapped windows, e.g.  iconified or not visible in the
	  current workspace.

  ReallyMoveInWorkspaceManager
	  This keyword tells ctwm to move the actual window when the user is
	  moving the small windows in the WorkSpaceMap window. If not present
	  the WorkSpaceMap can be used only to modify the occupation of a
	  window.

  ResizeFont string
	  This variable specifies the font to be used for in the dimensions
	  window when resizing windows.	 The default is "fixed".

  RestartPreviousState
	  This variable indicates that ctwm 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.

  ReverseCurrentWorkspace string
	  This variable specifies tells ctwm to reverse the background and
	  foreground colors in the small windows in the workspace map for the
	  current workspace.

  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.

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

  ShowWorkSpaceManager
	  This variable specifies that the WorkSpaceManager should be visi-
	  ble.

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

  SqueezeTitle [{ squeeze-list }]
	  This variable indicates that ctwm 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 loca-
	  tion of the squeezed titlebar along the top of the window.  It con-
	  tains 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 giving
	  the relative position about which the titlebar is justified.	The
	  ratio is measured from left to right if the numerator is positive,
	  and right to left if negative.  A denominator of 0 indicates that
	  the numerator should be measured in pixels.  For convenience, the
	  ratio 0/0 is the same as 1/2 for center and -1/1 for right.  For
	  example:

	       SqueezeTitle
	       {
		       "XTerm" left	       0       0
		       "xterm1"	       left	       1       3
		       "xterm2"	       left	       2       3
		       "oclock"	       center	       0       0
		       "emacs" right	       0       0
	       }

	  The DontSqueezeTitle list can be used to turn off squeezing on cer-
	  tain titles.

  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.

  StartInMapState
	  This variable specifies that the WorkSpaceManager should be started
	  in its map form when created.

  StayUpMenus
	  Tells ctwm to use stayup menus. These menus will stay on the screen
	  when ButtonUp, if either the menu has not yet been entered by the
	  pointer, or the current item is a f.title.

  SunkFocusWindowTitle
	  This variable specifies that the title of the focus window (if
	  exists) should be sunken instead of raised. Only valid if
	  UseThreeDTitles is set.

  ThreeDBorderWidth  pixels
	  The width of the 3D border in pixels, if any.

  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 "white".

  TitleButtonBorderWidth pixels
	  This variable specifies the width in pixels of the border surround-
	  ing titlebuttons.  This is typically set to 0 to allow titlebuttons
	  to take up as much space as possible and to not have a border.  The
	  default is 1 if UseThreeDTitles is not set, 0 if it is set.

  TitleButtonShadowDepth pixels
	  This variable specifies the depth of the shadow ctwm uses for 3D
	  title buttons, when UseThreeDTitles is selected.

  TitleFont string
	  This variable specifies the font to used for displaying window
	  names in titlebars.  The default is "variable".

  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 "black".

  TitleJustification string
	  This keyword needs a string value. The acceptable values are :
	  "left", "center" and "right". The window titles will be justified
	  according to this in the title window.

  TitlePadding pixels
	  This variable specifies the distance between the various buttons,
	  text, and highlight areas in the titlebar.  The default is 8 pixels
	  if UseThreeDTitles is not set, 0 if it is set.

  TitleShadowDepth pixels
	  This variable specifies the depth of the shadow ctwm uses for 3D
	  titles, when UseThreeDTitles is selected.

  TransientHasOccupation
	  This variable specifies that transient-for and non-group leader
	  windows can have their own occupation potentially different from
	  their leader window. The default case is that these windows follow
	  their leader, use this keyword if the default action doesn't please
	  you.

  TransientOnTop percentage
	  The parameter (required) is a percentage and tells ctwm to put
	  transient (and non-group leader) windows always on top of their
	  leader if and only if their surface is smaller than this fraction
	  of the surface of their leader. The surface of a window is its
	  width times its weight.

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

  UsePPosition string
	  This variable specifies whether or not ctwm should honor program-
	  requested locations (given by the PPosition flag in the
	  WM_NORMAL_HINTS property) in the absence of a user-specified posi-
	  tion.	 The argument string may have one of three values:  "off"
	  (the default) indicating that ctwm 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).	The latter option is for working around a bug
	  in older toolkits.

  UseThreeDBorders
	  Tells ctwm to use 3D-looking window borders. The width ot the 3D
	  borders is ThreeDBorderWidth. The color of the 3D border is Border-
	  TileBackground, and if NoHighlight is not selected, the border of
	  the Focus window is BorderColor.

  UseThreeDIconManagers
	  Tells ctwm to use 3D-looking IconManagers if any.

  UseThreeDMenus
	  Tells ctwm to use 3D-looking menus.

  UseThreeDTitles
	  Tells ctwm to use 3D-looking windows titles. In which case the
	  default values of TitleButtonBorderWidth, FramePadding, TitlePad-
	  ding and ButtonIndent are set to 0.  There are 5 built-in scalable
	  pixmaps for buttons, :xpm:menu, :xpm:dot, :xpm:resize, :xpm:zoomand
	  :xpm:bar. There is several built-in scalable animation for buttons
	  : %xpm:resize, %xpm:menu-up, %xpm:menu-down, %xpm:resize-out-top,
	  %xpm:resize-in-top, %xpm:resize-out-bot, %xpm:resize-in-bot,
	  %xpm:maze-out, %xpm:maze-in, %xpm:zoom-out, %xpm:zoom-in and
	  %xpm:zoom-inout. Try them to see what they look like.

  UseThreeDWMap
	  Tells ctwm to use 3D for the small windows in the workspace map.

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

  WindowRing [{ win-list }]
	  This variable specifies a list of windows along which the
	  f.warpring function cycles. If no argument is given, all the win-
	  dows are in the ring.

  WarpRingOnScreen
	  Tells ctwm that f.warpring warps pointer only to windows visible in
	  the current workspace.

  WarpUnmapped
	  This variable indicates that that the f.warpto function should
	  deiconify any iconified windows it encounters.  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 f.warpto to
	  ignore iconified windows.

  WMgrButtonShadowDepth depth
	  Control the depth of the shadow of the workspace manager buttons.

  WMgrHorizButtonIndent nb_pixels
	  Specifies the horizontal space, in pixel, between the buttons of
	  the workspace manager (in button mode).

  WMgrVertButtonIndent nb_pixels
	  Specifies the vertical space, in pixel, between the buttons of the
	  workspace manager (in button mode).

  WorkSpaceManagerGeometry string [ columns ]
	  This variable specifies the geometry of the workspace manager win-
	  dow. The string argument is standard geometry specification that
	  indicates the initial full size of the workspace manager. The
	  columns argument indicates the number of columns to use for the
	  workspace manager window.

	       WorkSpaceManagerGeometry	       "360x60+60-0" 8


  WorkSpaces { workspace-list }
	  This variable specifies a list of workspaces that are created at
	  startup, Where workspace-list is :

	       name [{bg-button [fg-button] [bg-root] [fg-root] [pixmap-root]}]


	  With :

	  bg-button:
		  background color of the corresponding button in the
		  workspace manager.

	  fg-button:
		  foreground color of the corresponding button in the
		  workspace manager.

	  bg-root:
		  background color of the corresponding root screen.

	  fg-root:
		  foreground color of the corresponding root screen.

	  pixmap-root:
		  pixmap to display on the corresponding root screen, either
		  the name of a bitmap, xpm:xpmfile, xwd:xwdfile, im:imfile
		  or |command_that generate_xwd.

	  Example :

	       WorkSpaces
	       {
		 "One"	 {"#686B9F" "white" "DeepSkyBlue3" "white" "xlogo16"}
		 "Two"	 {"#619AAE" "white" "firebrick"}
		 "Three" {"#727786" "white" "MidnightBlue" "white" "xpm:ball%.xpm"}
		 "Four"	 {"#727786" "white" "white" "white" "|(giftoppm | pnmtoxwd) < 2010.gif"}

		 "Five"	 {"#727786" "white" "DeepSkyBlue3" "white" "plaid"}
		 "Six"	 {"#619AAE" "white" "DeepSkyBlue3" "white" "xpm:background1"}
		 "Seven" {"#8C5b7A" "white" "chartreuse4"}
		 "Eight" {"#686B9F" "white" "MidnightBlue"}
	       }


	  The WorkSpaces declaration should come before the Occupy or Occupy-
	  All declarations. The maximum number of workspaces is 32.

  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 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, ctwm 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 win-
	  dow 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.

  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:


  ChangeWorkspaceFunction function
	  This variable specifies the function to be executed when the user
	  change the current workspace (zap).


  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.


  DeIconifyFunction function
	  This variable specifies the function to be executed when a window
	  is deiconified.


  IconifyFunction function
	  This variable specifies the function to be executed when a window
	  is iconified.


  WindowFunction function
	  This variable specifies the function to execute when a window is
	  selected from the TwmWindows menu.  If this variable is not set,
	  the window will be deiconified and raised.

BINDINGS

  After the desired variables have been set, functions may be attached
  titlebuttons and key and pointer buttons.  Titlebuttons 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 pixmap to use in
  the button box and the function to be invoked when a pointer button is
  pressed within them:

       LeftTitleButton "bitmapname"    = function

  or

       LeftTitleButton "bitmapname" {
	   Buttoni : function
	   ...
	   Buttonj : function
       }




  or

       RightTitleButton "bitmapname"   = function

  or

       RightTitleButton "bitmapname" {
	   Buttoni : function
	   ...
	   Buttonj : function
       }

  The bitmapname may refer to one of the  built-in bitmaps (which are scaled
  to match TitleFont) by using the appropriate colon-prefixed name described
  above.

  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 func-
  tion is to be invoked.  Keys are given as strings containing the appropri-
  ate 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, iconmgr, their first letters (iconmgr abbreviation is m), or all,
  separated by a vertical bar.	The function is any of the f. keywords
  described below.  For example, the default startup file contains the fol-
  lowing bindings:

       Button1 =       : root	       : f.menu "TwmWindows"
       Button1 = m     : window | icon : f.function "move-or-lower"
       Button2 = m     : window | icon : f.iconify
       Button3 = m     : window | icon : f.function "move-or-raise"
       Button1 =       : title	       : f.function "move-or-raise"
       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

  Ctwm provides many more window manipulation primitives than can be con-
  veniently stored in a titlebar, menu, or set of key bindings.	 Although a
  small set of defaults are supplied (unless the NoDefaults is specified),
  most users will want to have their most common operations bound to key and
  button strokes.  To do this, ctwm associates names with each of the primi-
  tives 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-raise"	       { f.move f.deltastop f.raise }
       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.

  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.

  f.addtoworkspace string
	  This function adds the selected window to the workspace whose name
	  is string.

  f.adoptwindow
	  This function ask for the user to select a window with the mouse,
	  and then adopt this window is it doesn't belong to the current
	  ctwm. Useful only with the -w flag.

  f.altcontext
	  Set the alternate context. The next key or button event ctwm
	  reveives will be interpreted using the alternate context. To define
	  bindings in the alternate context, use the keyword alter in the
	  context field of the binding command.	 For example:

	       "Return"= m     : all	       : f.altcontext
	       "n"     =       : alter	       : f.nextworkspace
	       "p"     =       : alter	       : f.prevworkspace

	  "" .nr )I "number"n

  f.altkeymap
	  Set the alternate keymap number, where number is an integer between
	  1 and 5 included. The next key or button event ctwm reveives will
	  be interpreted using this alternate keymap. To define bindings in
	  an alternate keymap, use the keyword a followed by number in the
	  modifier field of the binding command. For example:

	       "Return"= c     : all	       : f.altkeymap "1"
	       "i"     = a1    : window|icon|iconmgr   : f.iconify
	       "z"     = a1    : window	       : f.zoom
	       "d"     = a1    : window|icon   : f.delete
	       "o"     = a1    : window|icon   : f.occupy
	       "r"     = a1    : window|icon   : f.refresh


  When using an alternate keymaps, only the root, window, icon and iconmgr
  contexts are allowed.

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

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

  f.beep  This function sounds the keyboard bell.

  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 win-
	  dow.

  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 ctwm 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 mouse button on the tar-
	  get window.

  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 indicated window.  If the
	  window has not requested WM_DELETE_WINDOW messages, the keyboard
	  bell will be rung indicating that the user should choose an alter-
	  native method.  Note this is very different from f.destroy.  The
	  intent here is to delete a single window,  not necessarily the
	  entire application.

  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-raise" at the beginning of
	  the section.

  f.destroy
	  This function instructs the X server to close the display connec-
	  tion 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.

  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.downworkspace
	  Goto the workspace immediately underneath the current workspace in
	  the workspace manager. If the current workspace is the bottom one,
	  goto the top one in the same column. The result depends on the lay-
	  out of the workspace manager.

  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.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 func-
	  tion 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 neces-
	  sary.

  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.gotoworkspace workspace_name
	  This function warps you to the workspace whose name is
	  workspace_name.

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

  f.hideiconmgr
	  This function unmaps the current icon manager.

  f.hideworkspacemgr
	  Unmap the WorkSpace manager.

  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.

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

  f.leftworkspace
	  Goto the workspace immediately on the left of the current workspace
	  in the workspace manager. If the current workspace is the leftest
	  one, goto the rightest one in the same row. The result depends on
	  the layout of the workspace manager.

  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. When a menu
	  is popped up, you can use the arrow keys to move the cursor around
	  it. "Down" or space goes down, "Up" goes up, "Left" pops down the
	  menu, and "Right" activates the current entry. The first letter of
	  an entry name activates this entry (the first one if several
	  entries match). If the first letter is ~ then Meta-the-second-
	  letter activates it, if this first letter is ^ then Control-the-
	  second-letter activates it, and if this first letter is space, then
	  the second letter activates it.

  f.move  This function drags an outline of the selected window (or the win-
	  dow itself if the OpaqueMove variable is set) until the invoking
	  pointer button is released.  Double clicking within the number of
	  milliseconds given by ConstrainedMoveTime warps the pointer to the
	  center of the window and constrains the move to be either horizon-
	  tal or vertical depending on which grid line is crossed.  To abort
	  a move, press another button before releasing the first button.

  f.movepack
	  This function is like f.move except that it tries to avoid overlap-
	  ping of windows. When the moving window begin to overlap with
	  another window, the move is stopped. If you go too far over the
	  other window (more that MovePackResistance pixels), the move is
	  resumed and the moving window can overlap with the other window.
	  Useful to pack windows closely.

  f.movepush
	  This function is like f.move except that it tries to avoid overlap-
	  ping of windows. When the moving window begin to overlap with
	  another window, the other window is pushed. If you go too far over
	  the other window (more that MovePackResistance pixels), there is no
	  push and the moving window can overlap with the other window. Only
	  available if OpaqueMove is active.

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

  f.nextworkspace
	  Goto the next workspace in the list, using the order given in the
	  .ctwmrc file.

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

  f.occupy
	  This function pops up a window for the user to choose which
	  workspaces a window belongs to.

  f.occupyall
	  This function makes the specified window occupy all the workspaces.

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

  f.prevworkspace
	  Goto the previous workspace in the list, using the order given in
	  the .ctwmrc file.

  f.pin	  Valid only in a root menu. Make a menu permanent on the screen.
	  This is a toggle function, if you select it while the menu is
	  already permanent, it becomes non-permanent.

  f.quit  This function causes ctwm to restore the window's borders and exit.
	  If ctwm is the first client invoked from xdm, this will result in a
	  server reset.

  f.raiseicons
	  This function raises all the icons in the current workspace.

  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.removefromworkspace string
	  This function removes the selected window from the workspace whose
	  name is string.

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

  f.resize
	  This function displays an outline of the selected window.  Crossing
	  a border (or setting AutoRelativeResize) will cause the outline to
	  begin to rubber band until the invoking button is released.  To
	  abort a resize, press another button before releasing the first
	  button.

  f.restart

	  This function kills and restarts ctwm.

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

  f.rightworkspace
	  Goto the workspace immediately on the right of the current
	  workspace in the workspace manager. If the current workspace is the
	  rightest one, goto the leftest one in the same row. The result
	  depends on the layout of the workspace manager.

  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.saveyourself
	  This function sends a WM_SAVEYOURSELF message to the selected win-
	  dow if it has requested the message in its WM_PROTOCOLS window pro-
	  perty.  Clients that accept this message are supposed to checkpoint
	  all state associated with the window and update the WM_COMMAND pro-
	  perty as specified in the ICCCM.  If the selected window has not
	  selected for 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.setbuttonsstate
	  Set the WorkSpace manager in button state.

  f.setmapstate
	  Set the WorkSpace manager in map state.

  f.showiconmgr
	  This function maps the current icon manager.

  f.sorticonmgr
	  This function sorts the entries in the current icon manager alpha-
	  betically.  See the variable SortIconManager.

  f.showworkspacemgr
	  Map the WorkSpace manager.

  f.slowdownanimation
	  Decrease AnimationSpeed by 1.

  f.speedupanimation
	  Increase AnimationSpeed by 1.

  f.startanimation
	  Restart freezed animations (if any).

  f.stopanimation
	  Freeze animations (if any).

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

  f.toggleoccupation string
	  This function adds the selected window to the workspace whose name
	  is string if it doesn't already belongs to it, and removes it from
	  this workspace if not.

  f.togglestate
	  Toggle the state of the WorkSpace manager.

  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.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 neces-
	  sary.

  f.upworkspace
	  Goto the workspace immediately above the current workspace in the
	  workspace manager. If the current workspace is the top one, goto
	  the bottom one in the same column. The result depends on the layout
	  of the workspace manager.

  f.vanish
	  The specified window vanishes from the current workspace if it
	  occupies at least one other WorkSpace. Do nothing in the others
	  cases.

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

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

  f.warphere win_name
	  This function adds the window which has a name or class that
	  matches string to the current workspace and warps the pointer to
	  it. If the window is iconified, it will be deiconified if the vari-
	  able 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.

  f.warpto string
	  This function warps the pointer to the window which has a name or
	  class that matches string.  If the window is iconified, it will be
	  deiconified if the variable WarpUnmapped is set or else ignored.

  f.warptoiconmgr string
	  This function warps the pointer to the icon manager entry associ-
	  ated 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.

  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.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.

MENUS

  Functions may be grouped and interactively selected using pop-up (when
  bound to a pointer button) or pull-down (when associated with a titlebut-
  ton) 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":"backn")]    function1
	       string2 [ ("fore2":"backn")]    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 3 special menus. TwmWindows contains the names of all of the
  client and ctwm-supplied windows in the current workspace.  Selecting an
  entry will cause the WindowFunction to be executed on that window.  If Win-
  dowFunction hasn't been set, the window will be deiconified and raised.
  TwmWorkspaces contains the names of your workspaces, selecting an entry
  goto this workspace. In addition, these entries have submenus containing
  the names of all windows occupying this workspace, selecting such an entry
  executes f.warpto on this window. And finally, TwmAllWindows contains the
  names of all the windows ctwm manages. Selectting an entry executes
  f.warpto on this window.

  If an entry name begins with a '*' (star), this star won't be displayed and
  the corresponding entry will be the default entry for this menu. When a
  menu has a default entry and is used as a submenu of another menu, this
  default entry action will be executed automatically when this submenu is
  selected without beeing displayed. It's hard to explain, but easy to under-
  stand.

ICONS
  Ctwm supports several different ways of manipulating iconified windows.
  The common pixmap-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 the iconmgr context when specifying button and keyboard
  bindings.

  Moving the pointer into the icon manager also directs keyboard focus to the
  indicated window (setting the focus explicitly or else sending synthetic
  events 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.

BUGS
  The resource manager should have been used instead of all of the window
  lists.

  The IconRegion variable should take a list.

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

  If IconifyByUnmapping is on and windows are listed in IconManagerDontShow
  but not in DontIconifyByUnmapping, they may be lost if they are iconified
  and no bindings to f.menu "TwmWindows" or f.warpto are setup.


FILES

***********************
VMS specific:
  see notes above
***********************

   $HOME/.ctwmrc.<screen number>
   $HOME/.ctwmrc
   /usr/lib/X11/twm/system.ctwmrc
   $HOME/.twmrc

ENVIRONMENT VARIABLES

  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 ctwm startup file.

SEE ALSO

  X(1), Xserver(1), xdm(1), xrdb(1)

COPYRIGHT
  Portions copyright 1988 Evans & Sutherland Computer Corporation; portions
  copyright 1989 Hewlett-Packard Company and the Massachusetts Institute of
  Technology,  See X(1) for a full statement of rights and permissions.

AUTHORS
  Tom LaStrange, Solbourne Computer; Jim Fulton, MIT X Consortium; Steve
  Pitschke, Stardent Computer; Keith Packard, MIT X Consortium; Dave Stern-
  licht, MIT X Consortium; Dave Payne, Apple Computer.	Claude Lecommandeur,
  Swiss Polytechnical Institute of Lausanne (lecom@sic.epfl.ch).

