Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
FVWM(1)			    FVWM 2.5.20	(from cvs)		       FVWM(1)

NAME
       fvwm - F? Virtual Window	Manager	InSitu for X11

SYNOPSIS
       fvwm  [-c  config-command]  [-d	displayname] [-f config-file] [-r] [-s
       [screen_num]] [-V] [-C visual-class | -I	 visual-id]  [-l  colors  [-L]
       [-A]  [-S]  [-P]]  [-D]	[-h]  [-i client-id] [-F state-file] [--debug-
       stack-ring] [-blackout]

DESCRIPTION
       Fvwm is a window	manager	for X11.  It is	designed  to  minimize	memory
       consumption, provide a 3D look to window	frames,	and a virtual desktop.

       Note  that there	are several window managers around that	have "fvwm" in
       their name.  In the past, version 2.x of	fvwm was commonly called fvwm2
       to  distinguish	it  from  the former version 1.x (fvwm or even fvwm1).
       Since version 1.x has been replaced by version 2.x a long time  ago  we
       simply call version 2.x and all versions	to come, fvwm, throughout this
       document, and the executable program is named fvwm.  There is  an  fvwm
       offspring called	fvwm95,	it is mostly a patched version of fvwm-2.0.43.
       The main	goal of	fvwm95 was to supply a Windows 95 like look and	 feel.
       Since  then,  fvwm has been greatly enhanced and	practically all	fvwm95
       features	can be achieved	by fvwm.

       Fvwm provides both, a large virtual desktop and multiple	disjoint desk-
       tops which can be used separately or together.  The virtual desktop al-
       lows you	to pretend that	your video screen is really quite  large,  and
       you  can	scroll around within the desktop.  The multiple	disjoint desk-
       tops allow you to pretend that you really have several screens to  work
       at, but each screen is completely unrelated to the others.

       Fvwm  provides  keyboard	 accelerators  which allow you to perform most
       window manager functions, including moving and  resizing	 windows,  and
       operating the menus, using keyboard shortcuts.

       Fvwm  has  also overcome	the distinction	between	configuration commands
       and action commands that	most window managers make. Configuration  com-
       mands  typically	 set fonts, colors, menu contents, key and mouse func-
       tion bindings, while action commands do things  like  raise  and	 lower
       windows.	  Fvwm	makes  no  such	distinction, and allows	anything to be
       changed at any time.

       Other noteworthy	differences between fvwm and other X11 window managers
       are  the	 introduction of the SloppyFocus and NeverFocus	focus methods.
       Focus policy can	be separately specified	for different  window  groups.
       Windows	using  SloppyFocus  acquire  focus when	the pointer moves into
       them and	retain focus until some	other window acquires it.   Such  win-
       dows  do	 not  lose  focus when the pointer moves into the root window.
       The NeverFocus policy is	provided for use with windows into  which  one
       never types (e.g. xclock, oclock, xbiff,	xeyes, tuxeyes)	- for example,
       if a SloppyFocus	terminal window	has focus, moving the pointer  over  a
       NeverFocus decoration window does not deprive the terminal of focus.

OPTIONS
       These are the command line options that are recognized by fvwm:

       -i | --clientid
	      id  This	option	is used	when fvwm is started by	a session man-
	      ager. Should not be used by a user.

       -c | --cmd
	      config-command Causes fvwm  to  use  config-command  instead  of
	      'Read  config'  (or  'Read .fvwm2rc') as its initialization com-
	      mand.  (Note that	up to 10 -f and	-c parameters  can  be	given,
	      and they are executed in the order specified.)

	      Any  module started by command line arguments is assumed to be a
	      module that sends	back config commands.  All command  line  mod-
	      ules  have  to quit before fvwm proceeds on to the StartFunction
	      and setting border decorations and styles.  There	is a potential
	      deadlock	if  you	start a	module other than FvwmCpp/FvwmM4/Fvwm-
	      Perl but there is	a timeout so fvwm will eventually get going.

	      As an example, starting the pager	this way hangs fvwm until  the
	      timeout, but the following should	work well:
	      fvwm -c "AddToFunc StartFunction I Module	FvwmPager"

       -d | --display
	      displayname Manage the display called displayname	instead	of the
	      name obtained from the environment variable $DISPLAY.

       -D | --debug
	      Puts X transactions  in  synchronous  mode,  which  dramatically
	      slows  things  down,  but	 guarantees that fvwm's	internal error
	      messages are correct. Also causes	fvwm to	output debug  messages
	      while running.

       -f config-file
	      Causes fvwm to read config-file instead of ~/.fvwm/config	as its
	      initialization file.  This is equivalent	to  -c	'Read  config-
	      file'.

       -h | --help
	      A	short usage description	is printed.

       -r | --replace
	      Try  to  take  over from a previously running wm.	 This does not
	      work unless the other wm is ICCCM	2.0 compliant.

       -F | --restore
	      state-file This option is	used when fvwm is started by a session
	      manager.	Should not be used by a	user.

       -s | --single-screen
	      [screen_num]  On	a  multi-screen	 display, run fvwm only	on the
	      screen named in the $DISPLAY environment	variable  or  provided
	      through  the  -d option. The optional argument screen_num	should
	      be positive or null and override the screen  number.   Normally,
	      fvwm  attempts to	start up on all	screens	of a multi-screen dis-
	      play.

       -V | --version
	      Prints the version of fvwm to stderr.  Also prints  an  informa-
	      tion  about the compiled in support for readline,	rplay, stroke,
	      xpm, png,	gnome hints, EWMH hints, session management,  bidirec-
	      tional text, multibyte characters, xinerama and Xft aa font ren-
	      dering.

       -C | --visual
	      visual-class Causes fvwm to use visual-class for the window bor-
	      ders  and	menus.	visual-class can be "StaticGray", "GrayScale",
	      "StaticColor", "PseudoColor", "TrueColor"	or "DirectColor".

       -I | --visualid
	      id Causes	fvwm to	use id as the visual id	for the	window borders
	      and  menus.   id	can  be	 specified as N	for decimal or 0xN for
	      hexadecimal. See man page	of xdpyinfo for	a  list	 of  supported
	      visuals.

       -l | --color-limit
	      limit  Specifies	a  limit on the	colors used in image, gradient
	      and possibly simple colors used by fvwm. In fact,	fvwm (and  all
	      the  modules) uses a palette with	at most	limit colors. This op-
	      tion is only useful with screens that  display  256  colors  (or
	      less)  with  a dynamic visual (PseudoColor, GrayScale or Direct-
	      Color). The default depends on your X server  and	 how  you  run
	      fvwm.  In	 most  case  this default is reasonable. The -l	option
	      should be	used only if you encounter problems with  colors.   By
	      default, fvwm tries to detect "large" pre-allocated palettes. If
	      such a palette is	detected fvwm uses it and a priori the -l must
	      not  be  used.  Moreover,	in this	case the -A and	-S options are
	      forced. Note that	XFree-4.2 pre-allocate 244 colors (if you  use
	      a	 driver	 with  Render support) leaving only a few free colors.
	      This may lead to some color problems (and	nothing	can be	done).
	      XFree-4.3	 or better pre-allocate	only 85	colors.	 If no pre-al-
	      located palette is auto detected the defaults are	as follow:
			  | depth 8 (256 colors)| depth	4 (16 colors)
	      ------------|---------------------|--------------------
	      PseudoColor | 68 (4 cc + 4 grey)	| 10 (2	cc + 2 grey)
	      ------------|---------------------|--------------------
	      GrayScale	  | 64 regular grey	|  8 regular grey
	      ----------- |---------------------|--------------------
	      DirectColor | 32 (3 cc + 5 grey)	| 10 (2	cc + 2 grey)
	      ------------|------------------------------------------
	      where "I cc" means a "IxIxI color	cube"
	      These defaults may change	before version 2.6. Note that  if  you
	      use  a  private  color map (i.e.,	fvwm is	started	with the -C or
	      the -I options), then others defaults are	used.

	      Now what to do if	you encounter problems with colors? The	 first
	      thing  to	 do is to check	if you really cannot run your X	server
	      with depth 15, 16	or better.  Check your X server	documentation.
	      Note  that some hardware can support two different depths	on the
	      same screen (typically depth 8 and depth 24). If depth 8 is  the
	      default,	you  can force fvwm to use the best depth by using the
	      -C option	with TrueColor as argument.  So	now we assume that you
	      are  forced to run in depth 8 with a dynamic visual because your
	      hardware/driver cannot do	better or because you need to  use  an
	      application  which  needs	 to run	under this mode	(e.g., because
	      this application needs read-write	colors). What it should	be un-
	      derstand	is  that you have only 256 colors and that all the ap-
	      plications which use the default color map must share these col-
	      ors. The main problem is that there are applications which use a
	      lot or even all the colors.  If you  use	such  application  you
	      will  have no more free colors and some applications (which used
	      only a few colors) may fail to start or are unusable. There  are
	      three  things  that can be done (and fvwm	does not really	play a
	      particular role, all applications	are concerned).	The  first  is
	      to  run  the  applications  which	waste your (default) color map
	      with a private color map.	For example,  run  netscape  with  the
	      -install option, run KDE/QT applications with the	--cmap option,
	      use the -C option	for fvwm. The disadvantage of this  method  is
	      that  it	is  visually disturbing	(see the ColormapFocus command
	      for a better control of the color	maps  switching).  The	second
	      method  is  to  limit the	number of colors that the applications
	      use. Again, some applications have options to  specify  a	 given
	      color limit. With	fvwm you may try various values, 61 (a special
	      "visual" palette), 56 (a 4x4x3 color cube	plus 6	grey),	29  (a
	      3x3x3 color cube plus 2 grey), 10	or 9. Also, you	may use	the -L
	      option.  However,	limiting the number of colors is not  the  de-
	      finitive	solution.  The definitive solution is to try cause ap-
	      plications which use a lot of colors use the same	 colors.  This
	      is  a  difficult	task as	there are no formal standards for this
	      goal. However, some toolkits as QT and GTK use  color  cubes  as
	      palettes.	 So,  the idea is to configure your applications/tool-
	      kits to all use the same color cube. Moreover, you can  use  the
	      colors  in  this	color  cube  in	your X resources configuration
	      files and/or as arguments	to colors options.  Fvwm can  use  any
	      color  cube  of the form RxGxB with 2 <= R <= 6, R = G, R-1 =< B
	      <= R and B >= 2. To get an RxGxB color cube give an argument  to
	      -l  an  integer  c  >=  R*G*B  and  < (R+1)*(G+1)*B if B=R and <
	      R*G*(B+1)	if B < R (and different	from 61). If c >  R*G*B,  then
	      some grey	may be added to	the color cube.	You can	use the	Print-
	      Info Colors [1] command to get information on your  fvwm	colors
	      setting.	In particular, this command prints the palette used by
	      fvwm in rgb format (the last integer gives the number  of	 times
	      fvwm has allocated the colors).

       -L | --strict-color-limit
	      If  the  screen  displays	256 colors (or less) and has a dynamic
	      visual, causes fvwm to use its palette for all  the  colors.  By
	      default, the palette is used only	for images and gradients.

       -P | --visual-palette
	      If  the  screen  displays	256 colors (or less) and has a dynamic
	      visual, this option causes fvwm to use a	palette	 designed  for
	      limiting	the  "visual" color distance between the points	of the
	      palette. Moreover, for better color sharing, if possible	colors
	      with  a  name  in	 the X rgb data	base are used for defining the
	      colors (with the hope that applications and images  will	prefer
	      to  use named colors). If	the -l option is not used this palette
	      has 61 colors. This palette is also  automatically  selected  if
	      61 or 9 is used as argument to the -l option.

       -A | --allocate-palette
	      If  the  screen  displays	256 colors (or less) and has a dynamic
	      visual this option causes	fvwm to	allocate all the colors	of its
	      palette  at  start up for	reserving these	colors for future use.
	      This option forces the -static-palette option. By	default,  fvwm
	      allocates	 (reserves)  a	color  in its palette only if it needs
	      this color.

       -S | --static-palette
	      If the screen displays 256 colors	(or less) and  has  a  dynamic
	      visual  this  option causes fvwm to never	free the colors	in its
	      palette. By default, when	fvwm does not need a color any more it
	      frees  this  color  so that a new	color can be used. This	option
	      may speed	up image loading and save a few	bits of	memory.

       -blackout
	      This option is provided for backward compatibility only.	Black-
	      ing  out the screen during startup is not	necessary (and doesn't
	      work) anymore. This option will be removed in the	future.

       --debug-stack-ring
	      Enables stack ring debugging.  This option is only intended  for
	      internal debugging and should only be used by developers.

ANATOMY	OF A WINDOW
       Fvwm  puts  a  decorative border	around most windows.  This border con-
       sists of	a bar on each side and a small L-shaped	section	on  each  cor-
       ner.  There is an additional top	bar called the title-bar which is used
       to display the name of the window.  In addition,	there are up to	10 ti-
       tle-bar buttons.	 The top, side,	and bottom bars	are collectively known
       as the side-bars.  The corner pieces are	called the frame.

       With the	built-in minimal configuration,	dragging mouse button 1	in the
       frame  or  side-bars begins a resize operation on the window.  Dragging
       mouse button 2 in the frame  or	side-bars  begins  a  move  operation.
       There are raise/lower operations	bound to a single clicking on borders.
       Similarly for the window	title.

       Up to ten title-bar buttons may exist.  Their use  is  completely  user
       definable.   One	popular	configuration uses one button on the left that
       is used to bring	up a list of window options and	 two  buttons  on  the
       right used to iconify and maximize the window.  Another popular config-
       uration adds a close button to the right.  The number of	title-bar but-
       tons  used depends on which ones	have mouse actions bound to them.  See
       the section on the Mouse	command	below.

THE VIRTUAL DESKTOP
       Fvwm provides multiple virtual desktops for users who wish to use them.
       The  screen  is	a viewport onto	a desktop which	may be larger than the
       screen.	Several	distinct desktops can be accessed (concept: one	 desk-
       top  for	 each  project,	or one desktop for each	application, when view
       applications are	distinct).  Since each desktop can be larger than  the
       physical	 screen,  divided into m by n pages which are each the size of
       the physical screen, windows which are larger than the screen or	 large
       groups of related windows can easily be viewed.

       The (m by n) size (i.e. number of pages)	of the virtual desktops	can be
       changed any time, by using the DeskTopSize command.  All	virtual	 desk-
       tops  must  be (are) the	same size.  The	total number of	distinct desk-
       tops does not need to be	specified, but is limited to  approximately  4
       billion	total. All windows on a	range of desktops can be viewed	in the
       FvwmPager, a miniature view of the desktops.  The pager is an accessory
       program,	called a module, which is not essential	for the	window manager
       to operate.  Windows may	also be	listed,	along with  their  geometries,
       in a window list, accessible as a pop-up	menu, or as a separate window,
       called the FvwmWinList (another module).

       Fvwm keeps the windows on the desktop in	a layered  stacking  order;  a
       window  in a lower layer	never obscures a window	in a higher layer. The
       layer of	a window can be	changed	by using the Layer command.  The  con-
       cept of layers is a generalization of the StaysOnTop flag of older fvwm
       versions. The StaysOnTop	and StaysPut Style options are now implemented
       by  putting  the	 windows in suitable layers and	the previously missing
       StaysOnBottom Style option has been added.

       Sticky windows are windows  which  transcend  the  virtual  desktop  by
       "Sticking  to the screen's glass".  They	always stay put	on the screen.
       This is convenient for things like clocks and xbiffs, so	you only  need
       to run one such gadget and it always stays with you.  Icons can also be
       made to stick to	the glass, if desired.

       Window geometries are specified relative	to the current viewport.  That
       is:
       xterm -geometry +0+0
       creates	a  window in the upper left hand corner	of the visible portion
       of the screen.  It is permissible to  specify  geometries  which	 place
       windows	on  the	 virtual desktop, but off the screen.  For example, if
       the visible screen is 1000 by 1000 pixels, and the desktop size is 3x3,
       and  the	current	viewport is at the upper left hand corner of the desk-
       top, invoking:
       xterm -geometry +1000+1000
       places a	window just off	of the lower right hand	corner of the  screen.
       It  can	be found by moving the mouse to	the lower right	hand corner of
       the screen and waiting for it to	scroll into view.  A  geometry	speci-
       fied as something like:
       xterm -geometry -5-5
       places  the  window's  lower  right hand	corner 5 pixels	from the lower
       right corner of the visible portion of the screen.   Not	 all  applica-
       tions  support  window geometries with negative offsets.	 Some applica-
       tions place the window's	upper right hand corner	5 pixels above and  to
       the  left  of  the  upper left hand corner of the screen; others	may do
       just plain bizarre things.

       There are several ways to cause a window	to map onto a desktop or  page
       other  than  the	currently active one. The geometry technique mentioned
       above (specifying x,y  coordinates  larger  than	 the  physical	screen
       size),  however,	suffers	from the limitation of being interpreted rela-
       tive to the current viewport: the window	may not	consistently appear on
       a specific page,	unless you always invoke the application from the same
       page.

       A better	way to place windows on	a different page, screen or desk  from
       the  currently  mapped viewport is to use the StartsOnPage or StartsOn-
       Screen style specification (the successors to  the  older  StartsOnDesk
       style)  in  your	config file.  The placement is consistent: it does not
       depend on your current location on the virtual desktop.

       Some applications that understand standard Xt  command  line  arguments
       and X resources,	like xterm and xfontsel, allow the user	to specify the
       start-up	desk or	page on	the command line:
       xterm -xrm "*Desk:1"
       starts an xterm on desk number 1;
       xterm -xrm "*Page:3 2 1"
       starts an xterm two pages to the	right and one down from	the upper left
       hand page of desk number	3.  Not	all applications understand the	use of
       these options, however.	You could achieve the same  results  with  the
       following lines in your .Xdefaults file:
       XTerm*Desk: 1
       or
       XTerm*Page: 3 2 1

USE ON MULTI-SCREEN DISPLAYS
       If the -s command line argument is not given, fvwm automatically	starts
       up on every screen on the specified display.  After  fvwm  starts  each
       screen is treated independently.	 Restarts of fvwm need to be performed
       separately on each screen.  The use of
	EdgeScroll 0 0
       is strongly recommended for multi-screen	displays.   You	 may  need  to
       quit on each screen to quit from	the X session completely.  This	is not
       to be confused with Xinerama support.

XINERAMA SUPPORT
       Fvwm supports the Xinerama extension of newer X servers which is	 simi-
       lar to multi head support (multiple screens) but	allows to move windows
       between screens.	 If Xinerama support has been compiled into  fvwm,  it
       is used whenever	fvwm runs on an	X server that supports and uses	multi-
       ple screens via Xinerama.  Without this option, the  whole  desktop  is
       treated	as  one	big screen.  For example, menus	might pop up right be-
       tween two screens.  The EdgeResistance command allows for specifying an
       explicit	 resistance  value for moving windows over the screen edge be-
       tween two Xinerama screens.  Xinerama support can be  enabled  or  dis-
       abled  on the fly or from the configuration file	with the Xinerama com-
       mand.  Many modules and commands	work nicely with Xinerama displays.

       Everywhere where	a geometry in the usual	 X  format  can	 be  supplied,
       fvwm's Xinerama extension allows	for specifying a screen	in addition to
       the geometry (or	even the screen	alone).	 To do this, a '@' is added to
       the  end	of the geometry	string followed	by either the screen number or
       a letter.  A number is taken as the number of the Xinerama screen to be
       used (as	configured in the X server).  The letter can be	one of 'g' for
       the global screen (the rectangle	that encloses all  Xinerama  screens),
       'p' for the primary screen (see below), 'c' for the current screen (the
       one that	currently contains the pointer).  If the  X  server  does  not
       support Xinerama	or only	one screen is used, the	screen bit is ignored.

       Style * IconBox 64x300-0-0@p

       Xinerama	 support  can be configured to use a primary screen.  Fvwm can
       be configured to	place new windows and icons on this screen.  The  pri-
       mary  screen  is	 screen	 0 by default but can be changed with the Xin-
       eramaPrimaryScreen command.

       Xinerama	support	was designed to	work out of the	box with the same con-
       figuration file that would work on a single screen.  It may not perform
       very well if the	involved screens use different screen resolutions.  In
       this situation, windows may get stuck in	the portion of the whole desk-
       top that	belongs	to neither screen.  When this happens, the windows  or
       icons can be retrieved with the command

       All MoveToScreen

       that can	be entered in an FvwmConsole window or with FvwmCommand.

       For  multi-screen  implementations  other than Xinerama,	such as	Single
       Logical Screen, it is possible to simulate a Xinerama configuration  if
       the  total  screen seen by fvwm is made up of equal sized monitors in a
       rectangular grid.  The commands XineramaSls, XineramaSlsSize  and  Xin-
       eramaSlsScreens are used	to configure this feature.

INITIALIZATION
       During initialization, fvwm searches for	a configuration	file which de-
       scribes key and button bindings,	and many other things. The  format  of
       these  files is described later.	 Fvwm first searches for configuration
       files using the command
       Read config
       This looks for file config in $FVWM_USERDIR and $FVWM_DATADIR  directo-
       ries, as	described in Read below.  If this fails	more files are queried
       for backward compatibility.  Here is the	complete list of all file  lo-
       cations	queried	in the default installation (only the first found file
       is used):
       $HOME/.fvwm/config
       /usr/local/share/fvwm/config

       $HOME/.fvwm/.fvwm2rc
       $HOME/.fvwm2rc
       /usr/local/share/fvwm/.fvwm2rc
       /usr/local/share/fvwm/system.fvwm2rc
       /etc/system.fvwm2rc
       Please note, the	last 5 locations are not guaranteed to be supported in
       the future.

       If a configuration file is not found, the left mouse button, or Help or
       F1 keys on the root window bring	up menus and forms that	can  create  a
       starting	configuration file.

       Fvwm  sets  two	environment variables which are	inherited by its chil-
       dren.  These are	$DISPLAY which describes the display on	which fvwm  is
       running.	 $DISPLAY may be unix:0.0 or :0.0, which doesn't work too well
       when passed through ssh to another machine, so $HOSTDISPLAY is set to a
       network-ready description of the	display.  $HOSTDISPLAY always uses the
       TCP/IP transport	protocol (even for a  local  connection)  so  $DISPLAY
       should  be  used	for local connections, as it may use Unix-domain sock-
       ets, which are faster.

       If you want to start some applications or modules with  fvwm,  you  can
       simply put
       Exec app
       or
       Module FvwmXxx
       into  your  config, but it is not recommended; do this only if you know
       what you	are doing. It is usually critical  to  start  applications  or
       modules	after the entire config	is read, because it contains styles or
       module configurations which can affect window appearance	and  function-
       ality.

       The standard way	to start applications or modules on fvwm's start up is
       to add them to an initialization	 function  (usually  StartFunction  or
       InitFunction).	This  way they are only	started	after fvwm finishes to
       read and	execute	config file.

       Fvwm has	three special  functions  for  initialization:	StartFunction,
       which  is  executed on startups and restarts; InitFunction and Restart-
       Function, which are executed during initialization  and	restarts  (re-
       spectively)  just  after	StartFunction.	These functions	may be custom-
       ized in a user's	config file using  the	AddToFunc  command  (described
       later)  to  start  up  modules,	xterms,	or whatever you'd like to have
       started by fvwm.

       Fvwm has	also a special exit function: ExitFunction, executed when  ex-
       iting  or restarting before actually quitting.  It could	be used	to ex-
       plicitly	kill modules, etc.

       If fvwm is run under a session manager,	functions  SessionInitFunction
       and  SessionRestartFunction  are	 executed  instead of InitFunction and
       RestartFunction.	 This helps to define the user's  config  file	to  be
       good  for  both running under a session manager and without it.	Gener-
       ally it is a bad	idea to	start xterms or	other  applications  in	 "Ses-
       sion*"  functions.   Also someone can decide to start different modules
       while running under a session manager or	not.  For the similar purposes
       SessionExitFunction is used instead of ExitFunction.
       DestroyFunc StartFunction
       AddToFunc StartFunction
	+ I Module FvwmPager * *
	+ I Module FvwmButtons

       DestroyFunc InitFunction
       AddToFunc InitFunction
	+ I Module FvwmBanner
	+ I Module FvwmTaskBar
	+ I xsetroot -solid cyan
	+ I Exec xterm
	+ I Exec netscape

       DestroyFunc RestartFunction
       AddToFunc RestartFunction
	+ I Module FvwmTaskBar

       DestroyFunc SessionInitFunction
       AddToFunc SessionInitFunction
	+ I Module FvwmBanner

       DestroyFunc SessionRestartFunction
       AddToFunc SessionRestartFunction
	+ I Nop
       You  do	not  need  to  define all special functions if some are	empty.
       Also note, all these special functions may be emulated now using	Start-
       Function	and ExitFunction, like this:
       DestroyFunc StartFunction
       AddToFunc StartFunction
       + I Test	(Init) Module FvwmBanner
       + I Module FvwmPager * *
       + I Test	(Restart) Beep

       DestroyFunc ExitFunction
       AddToFunc ExitFunction
       + I Test	(Quit) Echo Bye-bye
       + I KillModule MyBuggyModule
       + I Test	(ToRestart) Beep

COMPILATION OPTIONS
       Fvwm has	a number of compile-time options.  If you have trouble using a
       certain command or feature, check to see	if support for it was included
       at  compile time.  Optional features are	described in the config.h file
       that is generated during	compilation.

ICONS AND IMAGES
       Fvwm can	load .xbm, .xpm, and .png images.  XBM images are  monochrome.
       Fvwm  can  always display XBM files.  XPM and PNG formats are color im-
       ages.  Compile-time options determine whether fvwm can display  XPM  or
       PNG icons and images.  See the INSTALL.fvwm file	for more information.

       The  related  SHAPE  compile-time  option  can make fvwm	display	spiffy
       shaped icons.

MODULES
       A module	is a separate program which runs as a  separate	 Unix  process
       but  transmits  commands	to fvwm	to execute.  Users can write their own
       modules to do any weird or bizarre manipulations	 without  bloating  or
       affecting the integrity of fvwm itself.

       Modules	must  be  spawned  by fvwm so that it can set up two pipes for
       fvwm and	the module to communicate with.	 The pipes  are	 already  open
       for  the	 module	 when it starts	and the	file descriptors for the pipes
       are provided as command line arguments.

       Modules can be spawned by fvwm at any time during the X session by  use
       of  the	Module	command.   Modules can exist for the duration of the X
       session,	or can perform a single	task and exit.	If the module is still
       active  when  fvwm  is told to quit, then fvwm closes the communication
       pipes and waits to receive a SIGCHLD from the module,  indicating  that
       it  has	detected  the pipe closure and has exited.  If modules fail to
       detect the pipe closure fvwm exits after	approximately 30 seconds  any-
       way.   The number of simultaneously executing modules is	limited	by the
       operating system's maximum number of simultaneously open	files, usually
       between 60 and 256.

       Modules	simply transmit	commands to the	fvwm command engine.  Commands
       are formatted just as in	the case of a  mouse  binding  in  the	config
       setup  file.   Certain auxiliary	information is also transmitted, as in
       the sample module FvwmButtons.  The FvwmButtons module is documented in
       its own man page.

       Please refer to the MODULE COMMANDS section for details.

ICCCM COMPLIANCE
       Fvwm	attempts     to	    be	  ICCCM	   2.0	  compliant.	 Check
       http://tronche.com/gui/x/icccm/	for  more  info.  In  addition,	 ICCCM
       states  that it should be possible for applications to receive any key-
       stroke, which is	not consistent with  the  keyboard  shortcut  approach
       used  in	fvwm and most other window managers.  In particular you	cannot
       have the	same keyboard shortcuts	working	with  your  fvwm  and  another
       fvwm running within Xnest (a nested X server running in a window).  The
       same problem exists with	mouse bindings.

       The ICCCM states	that windows possessing	the property
       WM_HINTS(WM_HINTS):
	   Client accepts input	or input focus:	False
       should not be given the keyboard	input focus  by	 the  window  manager.
       These  windows can take the input focus by themselves, however.	A num-
       ber of applications set this property, and yet expect the  window  man-
       ager  to	give them the keyboard focus anyway, so	fvwm provides a	window
       style, Lenience,	which allows fvwm to overlook this ICCCM  rule.	  Even
       with  this  window  style it is not guaranteed that the application ac-
       cepts focus.

       The differences between ICCCM 1.1 and 2.0 include the ability  to  take
       over from a running ICCCM 2.0 compliant window manager; thus
       fvwm; vi	~/.fvwm/config;	fvwm -replace
       resembles  the  Restart	command.   It  is  not exactly the same, since
       killing the previously running wm may terminate your X session, if  the
       wm was started as the last client in your .Xclients or .Xsession	file.

       Further	additions  are	support	 for client-side colormap installation
       (see the	ICCCM for details) and the urgency hint. Clients can set  this
       hint  in	 the  WM_HINTS	property of their window and expect the	window
       manager to attract the user's attention to the window.	Fvwm  has  two
       re-definable  functions	for  this purpose, "UrgencyFunc" and "Urgency-
       DoneFunc", which	are executed when the flag is set/cleared.  Their  de-
       fault definitions are:
       AddToFunc UrgencyFunc
	+ I Iconify off
	+ I FlipFocus
	+ I Raise
	+ I WarpToWindow 5p 5p
       AddToFunc UrgencyDoneFunc
	+ I Nop

GNOME COMPLIANCE
       Fvwm   attempts	 to   be   GNOME   (version   1)   compliant.	 Check
       http://www.gnome.org for	what that may mean. To disable GNOME hints for
       some or all windows, the	GNOMEIgnoreHints style can be used.

EXTENDED WINDOW	MANAGER	HINTS
       Fvwm  attempts  to  respect  the	extended window	manager	hints (ewmh or
       EWMH for	 short)	 specification:	 http://www.freedesktop.org/wiki/Stan-
       dards_2fwm_2dspec  and some extensions of this specification.  This al-
       lows fvwm to work with KDE version >= 2,	GNOME version 2	and other  ap-
       plications  which  respect this specification (any application based on
       GTK+ version 2).	Applications  which  respect  this  specification  are
       called ewmh compliant applications.

       This  support  is  configurable with styles and commands.  These	styles
       and commands have EWMH as the prefix (so	you can	find  them  easily  in
       this man	page).

       There  is  a  new Context 'D' for the Key, PointerKey, Mouse and	Stroke
       commands. This context is for desktop applications  (such  as  kdesktop
       and Nautilus desktop).

       When a compliant	taskbar	asks fvwm to activate a	window (typically when
       you click on a button which represents a	window	in  such  a  taskbar),
       then  fvwm  calls  the complex function EWMHActivateWindowFunc which by
       default is Iconify Off, Focus and Raise.	You can	 redefine  this	 func-
       tion.  For example:
       DestroyFunc EWMHActivateWindowFunc
       AddToFunc EWMHActivateWindowFunc	I Iconify Off
       + I Focus
       + I Raise
       + I WarpToWindow	50 50
       additionally warps the pointer to the center of the window.

       The  EWMH specification introduces the notion of	Working	Area.  Without
       ewmh support the	Working	Area is	the full visible screen	(or  all  your
       screens if you have a multi head	setup and you use Xinerama).  However,
       compliant applications (such as a panel)	can ask	to  reserve  space  at
       the  edge of the	screen.	 If this is the	case, the Working Area is your
       full visible screen minus these reserved	spaces.	If a panel can be hid-
       den  by	clicking  on a button the Working Area does not	change (as you
       can unhide the panel at any time), but the Dynamic Working Area is  up-
       dated:  the  space reserved by the panel	is removed (and	added again if
       you pop up the panel). The Dynamic Working Area may be used  when  fvwm
       places or maximizes a window.  To know if an application	reserves space
       you can type "xprop | grep _NET_WM_STRUT" in a terminal and select  the
       application.   If four numbers appear then these	numbers	define the re-
       served space as explained in the	EwmhBaseStruts command.

MWM COMPATIBILITY
       Fvwm provides options to	emulate	Motif Window Manager (Mwm) as well  as
       possible.   Please  refer  to the Emulate command as well as to the Mwm
       specific	options	of the Style and MenuStyle commands for	details.

OPEN LOOK and XVIEW COMPATIBILITY
       Fvwm supports all the Open Look	decoration  hints  (except  pushpins).
       Should  you  use	any such application, please add the following line to
       your config:
       Style * OLDecor
       Most (perhaps all) Open Look applications have a	strange	notion of key-
       board  focus  handling.	 Although a lot	of work	went into fvwm to work
       well with these,	you may	still encounter	problems.  It  is  recommended
       to  use	the  NeverFocus	 focus policy and the NoLenience style for all
       such applications (the windows will still get the focus):
       Style <application name>	NeverFocus, NoLenience
       But in case you can not live with that focus policy, you	can try	 using
       one of the other	focus policies in combination with the Lenience	style:
       Style <application name>	MouseFocus, Lenience
       Style <application name>	SloppyFocus, Lenience
       Style <application name>	ClickToFocus, Lenience

M4 PREPROCESSING
       M4 pre-processing is handled by a module	in fvwm.  To get more details,
       try man FvwmM4.	In short, if you want fvwm to parse  your  files  with
       m4,  then  replace  the command Read with FvwmM4	in your	~/.fvwm/config
       file (if	it appears at all), and	start fvwm with	the command
       fvwm -cmd "FvwmM4 config"

CPP PREPROCESSING
       Cpp is the C-language pre-processor.  fvwm offers cpp processing	 which
       mirrors	the  m4	 pre-processing.  To find out about it,	re-read	the M4
       section above, but replace "m4" with "cpp".

AUTO-RAISE
       Windows can be automatically raised when	it  receives  focus,  or  some
       number of milliseconds after it receives	focus, by using	the auto-raise
       module, FvwmAuto.

CONFIGURATION FILES
       The configuration file is used to describe mouse	and  button  bindings,
       colors,	the  virtual display size, and related items.  The initializa-
       tion configuration file is typically called config (or  .fvwm2rc).   By
       using  the  Read	command, it is easy to read in new configuration files
       as you go.

       Lines beginning with '#'	are ignored by fvwm.  Lines starting with  '*'
       are expected to contain module configuration commands (rather than con-
       figuration commands for fvwm itself). Like in  shell  scripts  embedded
       newlines	 in  a configuration file line can be quoted by	preceding them
       with a backslash.  All lines linked in this fashion are	treated	 as  a
       single line.  The newline itself	is ignored.

       Fvwm  makes  no	distinction  between configuration commands and	action
       commands, so anything mentioned in the fvwm  commands  section  can  be
       placed on a line	by itself for fvwm to execute as it reads the configu-
       ration file, or it can be placed	as an executable command in a menu  or
       bound  to  a mouse button or a keyboard key.  It	is left	as an exercise
       for the user to decide which function make sense	for initialization and
       which ones make sense for run-time.

SUPPLIED CONFIGURATION
       A  sample configuration file, system.fvwm2rc, is	supplied with the fvwm
       distribution.  It is well commented and can be used as a	source of  ex-
       amples	for   fvwm  configuration.   It	 may  be  copied  to  /usr/lo-
       cal/share/fvwm/config file.

       Alternatively, the built-in menu	(accessible when no configuration file
       is found) has options to	create an initial config file for the user.

       If  you are new to fvwm,	try fvwm-themes	package	demonstrating the pow-
       erful fvwm functionality.

FONT NAMES AND FONT LOADING
       The fonts used for the text of a	window title, icon titles,  menus  and
       geometry	 window	can be specified by using the Font and IconFont	Style,
       the Font	MenuStyle and the DefaultFont commands.	Also, all the  Modules
       which  use  text	 have configuration command(s) to specify font(s). All
       these styles and	commands take a	font name as an	argument. This section
       explains	what is	a font name for	fvwm and which fonts fvwm loads.

       First, you can use what we can call a usual font	name, for example,
       -adobe-courier-bold-r-normal--10-100-75-75-m-60-ISO8859-1
       -adobe-courier-bold-r-normal--10-*
       -*-fixed-medium-o-normal--14-*-ISO8859-15
       That  is,  you  can use an X Logical Font Description (XLFD for short).
       Then the	"first"	font which matches the description is loaded and used.
       This  "first"  font  depends of your font path and also of your locale.
       Fonts which match the locale charset are	loaded in priority order.  For
       example with
       -adobe-courier-bold-r-normal--10-*
       if  the	locale	charset	 is  ISO8859-1,	then fvwm tries	to load	a font
       which matches
       -adobe-courier-bold-r-normal--10-*-ISO8859-1
       with the	locale charset ISO8859-15 fvwm tries to	load
       -adobe-courier-bold-r-normal--10-*-ISO8859-15.

       A font name can be given	as an extended XLFD. This is a comma separated
       list of (simple)	XLFD font names, for example:
       -adobe-courier-bold-r-normal--14-*,-*-courier-medium-r-normal--14-*
       Each  simple  font  name	is tried until a matching font with the	locale
       charset is found	and if this fails each simple font name	is tried with-
       out constraint on the charset.

       More details on the XLFD	can be found in	the X manual page, the X Logi-
       cal Font	Description Conventions	document (called xlfd) and the	XLoad-
       Font  and  XCreateFontSet manual	pages. Some useful font	utilities are:
       xlsfonts, xfontsel, xfd and xset.

       If you have Xft support you can specify an Xft font name	 (description)
       of a true type (or Type1) font prefixed by "xft:", for example:
       "xft:Luxi Mono"
       "xft:Luxi Mono:Medium:Roman:size=14:encoding=iso8859-1"
       The  "first"  font which	matches	the description	is loaded.  This first
       font depends on the XftConfig configuration file	with Xft1 and  on  the
       /etc/fonts/fonts.conf file with Xft2.  One may read the Xft manual page
       and the fontconfig man page with	Xft2. The first	string	which  follows
       "xft:" is always	considered as the family. With the second example Luxi
       Mono is the Family (Other  XFree	 TTF  families:	 "Luxi	Serif",	 "Luxi
       Sans"),	Medium is the Weight (other possible weights: Light, DemiBold,
       Bold, Black), Roman is the slant	or  the	 style	(other	possibilities:
       Regular,	 Oblique,  Italic)  size specifies the point size (for a pixel
       size use	pixelsize=), encoding allows for enforce a charset  (iso8859-1
       or  iso10646-1  only; if	no encoding is given the locale	charset	is as-
       sumed).	An important parameter is "minspace=bool" where	bool  is  True
       or  False.  If  bool  is	 False (the default?) Xft gives	a greater font
       height to fvwm than if bool is True. This may  modify  text  placement,
       icon and	window title height, line spacing in menus and FvwmIdent, but-
       ton height in some fvwm modules ...etc.	With a LCD monitor you may try
       to  add	"rgba=mode" where mode is either rgb, bgr, vrgb	or vbgr	to en-
       able subpixel rendering.	The best mode depends  on  the	way  your  LCD
       cells  are  arranged. You can pass other	specifications in between ":",
       as "foundry=foundry_name", "spacing=type" where type can	be  monospace,
       proportional  or	charcell, "charwidth=integer", "charheight=integer" or
       "antialias=bool"	where bool is True or False. It	seems that  these  pa-
       rameters	are not	always taken in	account.  To determine which Xft fonts
       are really loaded you can export	XFT_DEBUG=1 before starting  fvwm  and
       take a look to the error	log. With Xft2 you may use fc-list to list the
       available fonts.	Anyway,	Xft support is experimental (from  the	X  and
       the  fvwm  point	 of  view) and the quality of the rendering depends on
       number of parameters (the XFree and  the	 freetype  versions  and  your
       video card(s)).

       After  an Xft font name you can add after a ";" an XLFD font name (sim-
       ple or extended)	as:
       xft:Verdana:pixelsize=14;-adobe-courier-bold-r-normal--14-*
       then, if	either loading the Xft font fails or fvwm has no Xft  support,
       fvwm  loads  the	font "-adobe-courier-bold-r-normal--14-*". This	allows
       for writing portable configuration files.

FONT AND STRING	ENCODING
       Once a font is loaded, fvwm finds its encoding (or charset)  using  its
       name  (the  last	two fields of the name). fvwm assumes that the strings
       which are displayed with	this font use this encoding (an	 exception  is
       that  if	an iso10646-1 font is loaded, then UTF-8 is assumed for	string
       encoding).  In a	normal situation, (i) a	font is	 loaded	 by  giving  a
       font  name  without  specifying	the encoding, (ii) the encoding	of the
       loaded font is the locale encoding, and then (iii) the strings  in  the
       fvwm  configuration files should	use the	locale encoding	as well	as the
       window and icon name. With Xft the situation is bit  different  as  Xft
       supports	 only  iso10646-1  and iso8859-1. If you do not	specify	one of
       these encodings in the Xft font name, then fvwm does strings conversion
       using  (iii).  Note  that  with multibyte fonts (and in particular with
       "CJK" fonts) for	good text rendering, the locale	encoding should	be the
       charset of the font.

       To  override  the  previous rules, it is	possible to specify the	string
       encoding	in the beginning of a font description as follow:
       StringEncoding=enc:_full_font_name_
       where enc is an encoding	supported by fvwm (usually font	 name  charset
       plus some unicode encodings: UTF-8, USC-2, USC-4	and UTF-16).

       For  example, you may use an iso8859-1 locale charset and have an Fvwm-
       Form in Russian using koi8-r encoding. In this case, you	just  have  to
       ask  FvwmForm  to  load a koi8-r	font by	specifying the encoding	in the
       font name. With a multibyte language, (as  multibyte  font  works  well
       only if the locale encoding is the charset of the font),	you should use
       an iso10646-1 font:
       StringEncoding=jisx0208.1983-0:-*-fixed-medium-r-*-ja-*-iso10646-1
       or
       "StringEncoding=jisx0208.1983-0:xft:Bitstream Cyberbit"
       if your FvwmForm	configuration uses jisx0208.1983-0  encoding.  Another
       possibility  is	to  use	UTF-8 encoding for your	FvwmForm configuration
       and use an iso10646-1 font:
       -*-fixed-medium-r-*-ja-*-iso10646-1
       or
       "StringEncoding=UTF-8:xft:Bitstream Cyberbit"
       or equivalently
       "xft:Bitstream Cyberbit:encoding=iso10646-1"
       In general iso10646-1 fonts together with UTF-8 string encoding	allows
       the display of any characters in	a given	menu, FvwmForm

       More  and more, unicode is used and text	files use UTF-8	encoding. How-
       ever, in	practice the characters	used range over	 your  locale  charset
       (this  is the case when you generate a menu with	fvwm-menu-desktop with
       recent versions of KDE and GNOME). For  saving  memory  (an  iso10646-1
       font  may have a	very large number of characters) or because you	have a
       pretty font without an iso10646-1 charset, you can specify  the	string
       encoding	to be UTF-8 and	use a font in the locale charset:
       StringEncoding=UTF-8:-*-pretty_font-*-12-*

       In most cases, fvwm correctly determines	the encoding of	the font. How-
       ever, some fonts	do not end with	valid encoding names.  When  the  font
       name isn't normal, for example:
       -misc-fixed-*--20-*-my_utf8-36
       you need	to add the encoding after the font name	using a	slash as a de-
       limiter.	For example:
       MenuStyle * Font	-misc-fixed-*--20-*-my_utf8-36/iso10646-1
       If fvwm finds an	encoding, fvwm uses the	iconv system functions	to  do
       conversion  between  encodings.	Unfortunately, there are no standards.
       For  conversion	between	 iso8859-1  and	 UTF-8:	 a  GNU	 system	  uses
       "ISO-8859-1"  and  other	 systems use "iso881" to define	the converters
       (these two names	are supported by fvwm).	Moreover, in some cases	it may
       be  necessary to	use machine specific converters. So, if	you experience
       problems	you can	try to get information on  your	 iconv	implementation
       ("man iconv" may	help) and put the name which defines the converter be-
       tween the font encoding and UTF-8 at the	end of the font	name after the
       encoding	 hint  and  a /	(another possible solution is to use GNU libi-
       conv). For example use:
       Style * Font -misc-fixed-*--14-*-iso8859-1/*/latin1
       to use latin1 for defining the converter	for  the  iso8859-1  encoding.
       The  "*"	in between the "/" says	to fvwm	to determine the encoding from
       the end of the font name. Use:
       Style * Font -misc-fixed-*--14-*-local8859-6/iso8859-6/local_iso8859_6_iconv
       to force	fvwm to	use the	font with iso8859-6 as the encoding  (this  is
       useful  for  bi-directionality)	and  to	 use local_iso8859_6_iconv for
       defining	the converters.

FONT SHADOW EFFECTS
       Fonts can be given 3d effects. At the beginning of the  font  name  (or
       just after a possible StringEncoding specification) add
       Shadow=size [offset] [directions]:
       size  is	 a  positive  integer  which specifies the number of pixels of
       shadow.	offset is an optional positive integer which defines the  num-
       ber of pixels to	offset the shadow from the edge	of the character.  The
       default offset is zero.	directions is an optional  set	of  directions
       the  shadow  emanates  from  the	character.  The	directions are a space
       separated list of fvwm directions:

       N, North, Top, t, Up, u,	-

       E, East,	Right, r, Right, r, ]

       S, South, Bottom, b, Down, d, _

       W, West,	Left, l, Left, l, [

       NE, NorthEast, TopRight,	tr, UpRight, ur, ^

       SE, SouthEast, BottomRight, br, DownRight, dr, _

       SW, SouthWest, BottomLeft, bl, DownLeft,	dl, v

       NW, NorthWest, TopLeft, tl, UpLeft, ul, _

       C, Center, Centre, .

       A shadow	is displayed in	each given direction.  All  is	equivalent  to
       all  the	 directions.   The default direction is	BottomRight.  With the
       Center direction, the shadow surrounds the whole	string.	 Since this is
       a  super	 set of	all other directions, it is a waste of time to specify
       this along with any other directions.

       The shadow effect only works with colorsets.  The color of  the	shadow
       is  defined  by	using the fgsh option of the Colorset command.	Please
       refer to	the COLORSETS section for details about	colorsets.

       Note: It	can be difficult to find the font, fg, fgsh and	bg  colors  to
       make this effect	look good, but it can look quite good.

BI-DIRECTIONAL TEXT
       Arabic  and  Hebrew text	require	bi-directional text support to be dis-
       played correctly, this means that logical strings should	 be  converted
       before  their  visual  presentation, so left-to-right and right-to-left
       sub-strings are determined and reshuffled.  In fvwm this	is done	 auto-
       matically  in  window  titles, menus, module labels and other places if
       the fonts used for displaying the text are of one of the	charsets  that
       require	bidi  (bi-directional)	support.   For	example, this includes
       iso8859-6, iso8859-8 and	iso10646-1 (unicode), but not other  iso8859-*
       fonts.

       This bi-directional text	support	is done	using the fribidi library com-
       pile time option, see INSTALL.fvwm.

KEYBOARD SHORTCUTS
       Almost all window manager operations can	be performed from the keyboard
       so  mouse-less  operation should	be possible.  In addition to scrolling
       around the virtual desktop by binding the Scroll	command	to appropriate
       keys,  Popup, Move, Resize, and any other command can be	bound to keys.
       Once a command is started the pointer is	moved by using the  up,	 down,
       left,  and  right  arrows, and the action is terminated by pressing re-
       turn.  Holding down the Shift key causes	the pointer movement to	go  in
       larger  steps and holding down the control key causes the pointer move-
       ment to go in smaller steps. Standard emacs and vi cursor movement con-
       trols  (	 n, p, f, b, and j, k, h, l ) can be used instead of the arrow
       keys.

SESSION	MANAGEMENT
       Fvwm supports session management	according to the X Session  Management
       Protocol.  It saves and restores	window position, size, stacking	order,
       desk, stickiness, shadiness, maximizedness, iconifiedness for all  win-
       dows. Furthermore, some global state is saved.

       Fvwm  doesn't  save any information regarding styles, decors, functions
       or menus.  If you change	any of these resources during a	session	 (e.g.
       by  issuing  Style commands or by using various modules), these changes
       are lost	after saving and restarting the	session.  To become permanent,
       such changes have to be added to	the configuration file.

       Note  further that the current implementation has the following anomaly
       when used on a multi-screen display: Starting fvwm for the first	 time,
       fvwm  manages  all screens by forking a copy of itself for each screen.
       Every copy knows	its parent and issuing a Quit command to any  instance
       of  fvwm	 kills	the master and thus all	copies of fvwm.	 When you save
       and restart the session,	the session manager brings up a	copy  of  fvwm
       on  each	screen,	but this time they are started as individual instances
       managing	one screen only.  Thus a Quit kills only the copy it was  sent
       to.   This  is  probably	not a very serious problem, since with session
       management, you are supposed to quit a session through the session man-
       ager anyway. If it is really needed,
       Exec exec killall fvwm
       still kills all copies of fvwm.	Your system must have the killall com-
       mand though.

BOOLEAN	ARGUMENTS
       A number	of commands take one or	several	boolean	arguments.  These take
       a  few equivalent inputs: "yes",	"on", "true", "t" and "y" all evaluate
       to true while "no", "off", "false", "f"	and  "n"  evaluate  to	false.
       Some  commands  allow "toggle" too which	means that the feature is dis-
       abled if	it is currently	enabled	and vice versa.

CONDITIONAL COMMANDS AND RETURN	CODES
       Fvwm recognizes a number	of commands that are executed only if  certain
       conditions  are	met.   For a complete description, please refer	to the
       section CONDITIONAL COMMANDS below.

BUILT-IN KEY AND MOUSE BINDINGS
       The following commands are built-in to fvwm:
       Key Help	R A Popup MenuFvwmRoot
       Key F1 R	A Popup	MenuFvwmRoot
       Key Tab A M WindowList Root c c NoDeskSort
       Key Escape A MC EscapeFunc
       Mouse 1 R A Menu	MenuFvwmRoot
       Mouse 1 T   A FuncFvwmRaiseLowerX Move
       Mouse 1 FS  A FuncFvwmRaiseLowerX Resize
       Mouse 2 FST A FuncFvwmRaiseLowerX Move
       AddToFunc FuncFvwmRaiseLowerX
       + I Raise
       + M $0
       + D Lower
       The Help	and F1 keys invoke a built-in menu that	fvwm creates.  This is
       primarily  for  new users that have not created their own configuration
       file. Either key	on the root (background) window	pops  up  an  menu  to
       help you	get started.

       The  Tab	key pressed anywhere with the Meta key (same as	the Alt	key on
       PC keyboards) held down pop-ups a window	list.

       Mouse button 1 on the title-bar or side frame can move, raise or	 lower
       a window.

       Mouse  button 1 on the window corners can resize, raise or lower	a win-
       dow.

       You can override	or remove these	bindings. To remove  the  window  list
       binding,	use this:
       Key Tab A M -

MODULE AND FUNCTION COMMANDS
       If  fvwm	 encounters  a command that it doesn't recognize, it checks to
       see if the specified command should have	been
       Function	(rest of command)
       or
       Module (rest of command)
       This allows complex functions or	modules	to  be	invoked	 in  a	manner
       which is	fairly transparent to the configuration	file.

       Example:	the config file	contains the line
       HelpMe
       Fvwm  looks  for	 an  fvwm command called "HelpMe", and fails.  Next it
       looks for a user-defined	complex	function called	"HelpMe".  If no  such
       function	exists,	fvwm tries to execute a	module called "HelpMe".

DELAYED	EXECUTION OF COMMANDS
       Note:  There  are  many commands	that affect look and feel of specific,
       some or all windows, like Style,	Mouse, Colorset, TitleStyle  and  many
       others.	 For  performance reasons such changes are not applied immedi-
       ately but only when fvwm	is idle, i.e. no user  interaction  or	module
       input  is  pending.   Specifically, new Style options that are set in a
       function	are not	applied	until after the	function has completed.	  This
       can sometimes lead to unwanted effects.

       To  force that all pending changes are applied immediately, use the Up-
       dateStyles, Refresh or RefreshWindow commands.

QUOTING
       Quotes are required only	when needed to make fvwm consider two or  more
       words to	be a single argument.  Unnecessary quoting is allowed.	If you
       want a quote character in your text, you	must escape it	by  using  the
       backslash  character.   For  example,  if you have a pop-up menu	called
       "Window-Ops", then you do not need quotes:
       Popup Window-Ops
       but if you replace the dash with	a space, then you need quotes:
       Popup "Window Ops"
       The supported quoting characters	are double quotes, single  quotes  and
       reverse	single	quotes.	  All three kinds of quotes are	treated	in the
       same way.  Single characters can	be quoted with a preceding  backslash.
       Quoting single characters works even inside other kinds of quotes.

COMMAND	EXPANSION
       Whenever	 an fvwm command line is executed, fvwm	performs parameter ex-
       pansion.	 A parameter is	a '$' followed by a word enclosed in  brackets
       ($[...])	or a single special character.	If fvwm	encounters an unquoted
       parameter on the	command	line it	expands	it to a	 string	 indicated  by
       the  parameter name.  Unknown parameters	are left untouched.  Parameter
       expansion is performed before quoting.  To get a	literal	'$' use	"$$".

       The longer variables may	contain	additional variables inside the	 name,
       which are expanded before the outer variable.

       In  earlier  versions  of  fvwm,	some single letter variables were sup-
       ported.	It is deprecated now, since they cause a number	 of  problems.
       You should use the longer substitutes instead.

       Example:

       # Print the current desk	number,	horizontal page	number
       # and the window's class	(unexpanded here, no window).
       Echo $[desk.n] $[page.nx] $[w.class]

       Note:  If the command is	called outside a window	context, it will print
       "$[w.class]" instead of the class name.	It is usually  not  enough  to
       have  the pointer over a	window to have a context window.  To force us-
       ing the window with the focus, the Current command can be used:
       Current Echo $[desk.n] $[page.nx] $[w.class]

       The parameters known by fvwm are:

	    $$
	       A literal '$'.

	    $.
	       The absolute directory of the currently	Read  file.   Intended
	       for  creating relative and relocatable configuration trees.  If
	       used outside of any read	file, the returned value is '.'.

	    $0 to $9
	       The positional parameters given to a complex function (a	 func-
	       tion  that  has been defined with the AddToFunc command).  "$0"
	       is replaced with	the first parameter, "$1" with the second  pa-
	       rameter	and  so	 on.   If the corresponding parameter is unde-
	       fined, the "$..." is deleted from the command line.

	    $*
	       All positional parameters given to a  complex  function.	  This
	       includes	parameters that	follow after "$9".

	    $[n]
	       The  n:th  positional  parameter	 given	to a complex function,
	       counting	from 0.	 If the	corresponding parameter	is  undefined,
	       the "$[n]" is deleted from the command line. The	parameter will
	       be expanded unquoted.

	    $[n-m]
	       The positional parameters given to a complex function, starting
	       with  parameter n and ending with parameter m.  If all the cor-
	       responding parameters are undefined, the	 "$[...]"  is  deleted
	       from  the  command line.	If only	some of	the parameters are de-
	       fined, all defined parameters are expanded, and	the  remaining
	       silently	ignored. All parameters	will be	expanded unquoted.

	    $[n-]
	       All  the	 positional  parameters	 given	to a complex function,
	       starting	with parameter n.  If all the corresponding parameters
	       are  undefined,	the "$[...]" is	deleted	from the command line.
	       All parameters will be expanded unquoted.

	    $[*]
	       All the positional parameters given to a	complex	function. This
	       is equivalent of	$[0-].

	    $[version.num]
	       The version number, like	"2.6.0".

	    $[version.info]
	       The  version  info,  like " (from cvs)",	empty for the official
	       releases.

	    $[version.line]
	       The first line printed by the --version command line option.

	    $[vp.x] $[vp.y] $[vp.width]	$[vp.height]
	       Either coordinate or the	width or height	of the	current	 view-
	       port.

	    $[desk.n]
	       The current desk	number.

	    $[desk.name<n>]
	       These parameters	are replaced with the name of the desktop num-
	       ber <n> that is defined with the	 DesktopName  command.	If  no
	       name is defined,	then the default name is returned.

	    $[desk.width] $[desk.height]
	       The  width  or  height  of the whole desktop, i.e. the width or
	       height multiplied by the	number of pages	in x or	y direction.

	    $[desk.pagesx] $[desk.pagesy]
	       The number of total pages in a desk in x	or y direction.	  This
	       is the same as the values set by	DesktopSize.

	    $[page.nx] $[page.ny]
	       The  current  page  numbers,  by	X and Y	axes, starting from 0.
	       page is equivalent to area in the GNOME terminology.

	    $[w.id]
	       The window-id (expressed	in hex,	e.g. 0x10023c) of  the	window
	       the command was called for or "$[w.id]" if no window is associ-
	       ated with the command.

	    $[w.name]  $[w.iconname]  $[w.class]  $[w.resource]	 $[w.iconfile]
	    $[w.miniiconfile]
	       The window's name, icon name, resource class and	resource name,
	       file name of its	icon or	mini icon defined  with	 the  Icon  or
	       MiniIcon	 style	(including the full path if the	file was found
	       on disk), or unexpanded "$[w.<attribute>]" string if no	window
	       is associated with the command.

	       Note, the first 4 variables may include any kind	of characters,
	       so these	variables are quoted.  It means	that the value is sur-
	       rounded	by  single  quote  characters and any contained	single
	       quote is	prefixed with a	backslash.  This guarantees that  com-
	       mands like:

		 Style $[w.resource] Icon norm/network.png

	       work correctly, regardless of any special symbols the value may
	       contain,	like spaces and	different kinds	of quotes.

	    $[w.x] $[w.y] $[w.width] $[w.height]
	       Either coordinate or the	width or height	of the current	window
	       if  it  is  not iconified.  If no window	is associated with the
	       command or the window is	iconified, the string is left as is.

	    $[w.desk]
	       The number of the desk on which the window is  shown.   If  the
	       window is sticky	the current desk number	is used.

	    $[w.layer]
	       The layer of the	window.

	    $[cw.x] $[cw.y] $[cw.width]	$[cw.height]
	       These  work like	$[w....] but return the	geometry of the	client
	       part of the window.  In other words: the	border	and  title  of
	       the window is not taken into account.

	    $[i.x],  $[it.x],  $[ip.x]	$[i.y],	 $[it.y],  $[ip.y] $[i.width],
	    $[it.width], $[ip.width] $[i.height], $[it.height],	$[ip.height]
	       These work like $[w....]	but return the geometry	 of  the  icon
	       ($[i....]),  the	 icon  title  ($[it....])  or the icon picture
	       ($[ip....]).

	    $[pointer.x] $[pointer.y]
	       These return the	position of the	pointer	on the screen.	If the
	       pointer is not on the screen, these variables are not expanded.

	    $[pointer.wx] $[pointer.wy]
	       These  return  the position of the pointer in the selected win-
	       dow.  If	the pointer is not on the screen, the window is	iconi-
	       fied   or  no  window  is selected, these variables are not ex-
	       panded.

	    $[pointer.cx] $[pointer.cy]
	       These return the	position of the	pointer	in the client  portion
	       of  the	selected window.  If the pointer is not	on the screen,
	       the window is shaded or iconified or  no	 window	 is  selected,
	       these variables are not expanded.

	    $[screen]
	       The  screen  number fvwm	is running on.	Useful for setups with
	       multiple	screens.

	    $[fg.cs<n>]
	    $[bg.cs<n>]
	    $[hilight.cs<n>]
	    $[shadow.cs<n>]
	       These parameters	are replaced with the name of  the  foreground
	       (fg),  background  (bg),	 hilight  (hilight) or shadow (shadow)
	       color that is defined in	colorset <n> (replace <n> with zero or
	       a  positive  integer).	For example "$[fg.cs3]"	is expanded to
	       the  name  of  the  foreground  color   of   colorset   3   (in
	       rgb:rrrr/gggg/bbbb  form).   Please refer to the	COLORSETS sec-
	       tion for	details	about colorsets.

	    $[schedule.last]
	       This is replaced	by the id of the last command that was	sched-
	       uled  with  the	Schedule command, even if this command was al-
	       ready executed.

	    $[schedule.next]
	       This is replaced	by the id the next command used	with  Schedule
	       will get	(unless	a different id is specified explicitly).

	    $[cond.rc]
	       The return code of the last conditional command.	 This variable
	       is only valid inside a function and can not be used in a	condi-
	       tional  command.	  Please refer to the section CONDITIONAL COM-
	       MANDS in	the command list.

	    $[func.context]
	       The context character of	the running command  as	 used  in  the
	       command.	 This is useful	for example with:
	       Mouse 3 FS N WindowShade	$$[func.context]

	    $[gt.str]
	       return  the translation of str by looking in the	current	locale
	       catalogs. If no translation is found str	 is  returned  as  is.
	       See the LocalePath command.

	    $[...]
	       If  the	string within the braces is neither of the above, fvwm
	       tries to	find an	environment variable with this	name  and  re-
	       places  its value if one	is found (e.g. "$[PAGER]" could	be re-
	       placed by "more").  Otherwise the string	is left	as is.

       Some examples can be found in the description of	the AddToFunc command.

SCRIPTING AND COMPLEX FUNCTIONS
       To achieve the more complex effects, fvwm has a number of commands that
       improve	its scripting abilities.  Scripts can be read from a file with
       Read, from the output of	a command with PipeRead	or written as  a  com-
       plex  function  with the	AddToFunc command.  For	the curious, section 7
       of the fvwm FAQ shows some real life applications of scripting.	Please
       refer  to  the  sections	COMMANDS FOR USER FUNCTIONS AND	SHELL COMMANDS
       and CONDITIONAL COMMANDS	for details.  A	word of	warning:  during  exe-
       cution  of  complex  functions,	fvwm  needs to take all	input from the
       mouse pointer (the pointer is "grabbed" in the slang of X).   No	 other
       programs	 can  receive  any  input from the pointer while a function is
       run.  This can confuse some programs.  For example, the xwd program re-
       fuses  to  make	screen	shots  when  run  from a complex function.  To
       achieve the same	functionality you can use the Read or PipeRead command
       instead.

THE LIST OF FVWM COMMANDS
       The  command  descriptions  below are grouped together in the following
       sections.  The sections are hopefully sorted in order of	usefulness  to
       the newcomer.
       - Menu commands
       - Miscellaneous commands
       - Commands affecting window movement and	placement
       - Commands for focus and	mouse movement
       - Commands controlling window state
       - Commands for mouse, key and stroke bindings
       - The Style command (controlling	window styles)
       - Other commands	controlling window styles
       - Commands controlling the virtual desktop
       - Commands for user functions and shell commands
       - Conditional commands
       - Module	commands
       - Quit, restart and session management commands
       - Colorsets
       - Color gradients

   MENUS
       Before a	menu can be opened, it has to be populated with	menu items us-
       ing the AddToMenu command and bound to a	key or mouse button  with  the
       Key, PointerKey or Mouse	command	(there are many	other ways to invoke a
       menu too).  This	is usually done	in the configuration file.

       Fvwm menus are extremely	configurable  in  look	and  feel.   Even  the
       slightest  nuances  can	be changed to the user's liking, including the
       menu item fonts,	the background,	delays before popping  up  sub	menus,
       generating  menus dynamically and many other features.  Please refer to
       the MenuStyle command to	learn more.

       Types of	Menus

	      In fvwm there are	four slightly different	types of menus:

	      Popup menus can appear everywhere	on the screen on their own  or
	      attached	to  a part of a	window.	 The Popup command opens popup
	      menus.  If the popup menu	was invoked with a mouse  button  held
	      down,  it	is closed when the button is released.	The item under
	      the pointer is then activated and	the associated action is  exe-
	      cuted.

	      Menu  is	a  very	 similar  command,  but	the menus it opens are
	      slightly less transient.	When invoked by	clicking a mouse  but-
	      ton,  it	stays  open  and can be	navigated with no button held.
	      But if it	is invoked by a	button press followed by mouse motion,
	      it behaves exactly like a	popup menu.

	      Tear  off	 menus	or  Pin	 up menus are menus from either	of the
	      above two	commands that have been	"torn off" their original con-
	      text  and	 pinned	on the desktop like a normal window.  They are
	      created from other menus by certain key  presses	or  mouse  se-
	      quences or with the TearMenuOff command from inside a menu.

	      Sub menus	are menus inside menus.	 When a	menu item that has the
	      Popup command as its action  is  selected,  the  named  menu  is
	      opened  as an inferior menu to the parent.  Any type of menu can
	      have sub menus.

       Menu Anatomy

	      Menus consist of any number of titles which  are	inactive  menu
	      items  that  usually appear at the top of	the menu, normal items
	      triggering various actions when selected,	 separator  lines  be-
	      tween  the  items, tear off bars (a horizontal broken line) that
	      tear off the menu	when selected, and sub	menu  items  indicated
	      with  a triangle pointing	left or	right, depending on the	direc-
	      tion in which the	sub menu appears.  All the  above  menu	 items
	      are optional.

	      Additionally,  if	the menu is too	long to	fit on the screen, the
	      excess menu items	are put	in a continuation menu and a sub  menu
	      with  the	 string	"More..." is placed at the bottom of the menu.
	      Finally, there may be a picture running up either	 side  of  the
	      menu (a "side bar").

       Menu Navigation

	      Menus  can  be  navigated	 either	 with the keyboard or with the
	      mouse.  Many people prefer to use	 the  mouse,  but  it  can  be
	      rather  tedious.	 Once you get the hang of it, keyboard naviga-
	      tion can be much faster.	While fvwm displays a menu, it can  do
	      nothing else.  For example, new windows do not appear before the
	      menu is closed.  However,	this is	not exactly true for tear  off
	      menus.  See the Tear Off Menus section for details.

       Mouse Navigation

	      Moving  the pointer over a menu selects the item below it.  Nor-
	      mally this is indicated by a 3d border around the	item, but  not
	      all  parts of a menu can be selected.  Pressing any mouse	button
	      while a menu is open activates the item below it.	  Items	 of  a
	      popup  menu are also activated by	releasing a held mouse button.
	      In case of an item that hides a sub menu,	the sub	menu  is  dis-
	      played  if the pointer hovers over the item long enough or moves
	      close to the triangle indicating the sub menu.   This  behaviour
	      can be tuned with	menu styles.

	      Scrolling	 a  mouse  wheel  over a menu either wraps the pointer
	      along the	menu (default),	scrolls	the menu under the pointer  or
	      act  as if the menu was clicked depending	on the MouseWheel menu
	      style.

	      Clicking on a selected item activates it - what happens  exactly
	      depends on the type of the item.

	      Clicking	on  a title, a separator, the side bar,	or outside the
	      menu closes the menu (exception:	tear  off  menus  can  not  be
	      closed  this way).  Pressing mouse button	2 over a menu title or
	      activating a tear	off bar	creates	a tear off menu	from the  cur-
	      rent  menu.   Clicking on	a normal menu item invokes the command
	      that is bound to it, and clicking	on  a  sub  menu  item	either
	      closes  all  open	 menus	and replaces them with the sub menu or
	      posts the	menu (default).

	      Posting menus is meant to	ease mouse  navigation.	  Once	a  sub
	      menu  is	posted,	only items from	that sub menu can be selected.
	      This can be very useful to navigate  the	menu  if  the  pointer
	      tends to stray off the menu.  To unpost the menu and revert back
	      to normal	operation, either click	on the same sub	menu  item  or
	      press any	key.

       Keyboard	Navigation

	      Just  like  with mouse navigation, the item below	the pointer is
	      selected.	 This is achieved by warping the pointer to  the  menu
	      items when necessary.  While a menu is open, all key presses are
	      intercepted by the menu.	No other application can get  keyboard
	      input (although this is not the case for tear off	menus).

	      Items  can be selected directly by pressing a hotkey that	can be
	      configured individually for each menu item.  The hotkey is indi-
	      cated  by	underlining it in the menu item	label.	With the Auto-
	      maticHotkeys menu	style fvwm automatically  assigns  hotkeys  to
	      all menu items.

	      The  most	 basic	keys  to navigate through menus	are the	cursor
	      keys (move up or down one	item, enter  or	 leave	a  sub	menu),
	      Space  (activate	item) and Escape (close	menu).	Numerous other
	      keys can be used to navigate through menus:

	      Enter, Return, Space activate the	current	item.

	      Escape, Delete, Ctrl-G exit the current sequence of menus	or de-
	      stroy a tear off menu.

	      J, N, Cursor-Down, Tab, Meta-Tab,	Ctrl-F,	move to	the next item.

	      K,  P, Cursor-Up,	Shift-Tab, Shift-Meta-Tab, Ctrl-B, move	to the
	      prior item.

	      L, Cursor-Right, F enter a sub menu.

	      H, Cursor-Left, B	return to the prior menu.

	      Ctrl-Cursor-Up, Ctrl-K Ctrl-P, Shift-Ctrl-Meta-Tab, Page-Up move
	      up five items.

	      Ctrl-Cursor-Down,	 Ctrl-J	Ctrl-N,	Ctrl-Meta-TabP,	Page-Down move
	      down five	items.

	      Home, Shift-Cursor-Up, Ctrl-A move to the	first item.

	      End, Shift-Cursor-Down, Ctrl-E move to the last item.

	      Meta-Cursor-Up, Ctrl-Cursor-Left,	Shift-Ctrl-Tab	move  up  just
	      below the	next separator.

	      Meta-Cursor-Down,	Ctrl-Cursor-Right, Ctrl-Tab move down just be-
	      low the next separator.

	      Insert opens the "More..." sub menu if any.

	      Backspace	tears off the menu.

       Tear Off	Menus

	      A	tear off menu is any menu that has been	"torn off" the	window
	      it  was  attached	 to  and pinned	to the root window.  There are
	      three ways to tear off a menu:  click on	the  menu  title  with
	      mouse button 2, press Backspace in the menu or activate its tear
	      off bar (a horizontal bar	with a broken line).   Tear  off  bars
	      must  be	added  to the menu as any other	item by	assigning them
	      the command TearMenuOff.

	      The action taken with the	backspace key cannot be	overridden but
	      the  action  of  mouse button 2 on the title can.	 To remove the
	      builtin mouse button 2 binding, use:

	      Mouse 2 M	N -

	      ("M" is for "Menu" context)

	      To assign	some other button for tearoff, use:

	      Mouse 1 M	N TearOff

	      Note that	the Modifier, must be "N" (none) and that the notation
	      "Mouse 0"	(for any mouse button cannot be	used.)

	      The  window  containing  the  menu is placed as any other	window
	      would be.	 If you	find it	confusing to have your tear off	 menus
	      appear  at random	positions on the screen, put this line in your
	      configuration file:
	      Style fvwm_menu UsePPosition

	      To remove	borders	and buttons from a tear-off menu but keep  the
	      menu title, you can use

	      Style fvwm_menu !Button 0, !Button 1
	      Style fvwm_menu !Button 2, !Button 3
	      Style fvwm_menu !Button 4, !Button 5
	      Style fvwm_menu !Button 6, !Button 7
	      Style fvwm_menu !Button 8, !Button 9
	      Style fvwm_menu Title, HandleWidth 0

	      A	tear off menu is a cross breeding between a window and a menu.
	      The menu is swallowed by a window	and its	title is stripped  off
	      and  displayed  in the window title.  The	main advantage is that
	      the menu becomes permanent - activating an item does  not	 close
	      the  menu.  Therefore, it	can be used multiple times without re-
	      opening it.  To destroy such a menu, close its window  or	 press
	      the Escape key.

	      Tear off menus behave somewhat differently than normal menus and
	      windows.	They do	not take the keyboard  focus,  but  while  the
	      pointer  is  over	 one  of them, all key presses are sent	to the
	      menu.  Other fvwm	key bindings  are  disabled  as	 long  as  the
	      pointer  is  inside  the	tear off menu or one of	its sub	menus.
	      When the pointer leaves this area, all sub menus are closed  im-
	      mediately.   Note	 that the window containing a tear off menu is
	      never hilighted as if it had the focus.

	      A	tear off menu is an independent	copy of	the menu it originated
	      from.   As such, it is not affected by adding items to that menu
	      or changing its menu style.

	      To create	a tear off menu	without	opening	the normal menu	first,
	      the  option TearOffImmediately can be added to the Menu or Popup
	      command.

       AddToMenu menu-name [menu-label action]

	      Begins or	adds to	a menu definition.  Typically a	 menu  defini-
	      tion looks like this:
	      AddToMenu	Utilities Utilities Title
	       + Xterm		 Exec  exec xterm -e tcsh
	       + Rxvt		 Exec  exec rxvt
	       + "Remote Logins" Popup Remote-Logins
	       + Top		 Exec  exec rxvt -T Top	-n \
				 Top -e	top
	       + Calculator	 Exec  exec xcalc
	       + Xman		 Exec  exec xman
	       + Xmag		 Exec  exec xmag
	       + emacs		 Exec  exec xemacs
	       + Mail		 MailFunction \
				 xmh "-font fixed"
	       + ""		 Nop
	       + Modules	 Popup Module-Popup
	       + ""		 Nop
	       + Exit Fvwm	 Popup Quit-Verify
	      The menu could be	invoked	via
	      Mouse 1 R	A Menu Utilities Nop
	      or
	      Mouse 1 R	A Popup	Utilities
	      There is no end-of-menu symbol.  Menus do	not have to be defined
	      in a contiguous region of	the config file.  The quoted (or first
	      word) portion in the above examples is the menu label, which ap-
	      pears in the menu	when the user pops it up.  The remaining  por-
	      tion  is	an  fvwm command which is executed if the user selects
	      that menu	item.  An empty	menu-label ("")	and the	 Nop  function
	      are used to insert a separator into the menu.

	      The  keywords DynamicPopUpAction and DynamicPopDownAction	have a
	      special meaning when used	as the name of a menu item.   The  ac-
	      tion  following  the  keyword  is	 executed whenever the menu is
	      popped up	or down.  This way you can  implement  dynamic	menus.
	      It  is  even possible to destroy itself with DestroyMenu and the
	      rebuild from scratch.  When the menu has been destroyed  (unless
	      you  used	 the recreate option when destroying the menu),	do not
	      forget to	add the	dynamic	action again.

	      Note: Do not trigger actions that	require	user interaction. They
	      will  probably fail and may screw	up your	menus.	See the	Silent
	      command.

	      Warning: Do not issue MenuStyle commands	as  dynamic  menu  ac-
	      tions.  Chances are good that this will crash fvwm.

	      There  are  several configurable scripts installed together with
	      fvwm for automatic menu generation.  They	 have  their  own  man
	      pages.  Some of them, specifically fvwm-menu-directory and fvwm-
	      menu-desktop, may	be used	with DynamicPopupAction	 to  create  a
	      directory	listing	or GNOME/KDE application listing.

	      Example (File browser):
	      #	You can	find the shell script fvwm_make_browse_menu.sh
	      #	in the utils/ directory	of the distribution.
	      AddToMenu	BrowseMenu
	      +	DynamicPopupAction Piperead \
		'fvwm_make_browse_menu.sh BrowseMenu'
	      Example (Picture menu):
	      #	Build a	menu of	all .jpg files in
	      #	$HOME/Pictures
	      AddToMenu	JpgMenu	foo title
	      +	DynamicPopupAction Function MakeJpgMenu

	      AddToFunc	MakeJpgMenu
	      +	I DestroyMenu recreate JpgMenu
	      +	I AddToMenu JpgMenu Pictures Title
	      +	I PipeRead 'for	i in $HOME/Pictures/*.jpg; \
		do echo	AddToMenu JpgMenu "`basename $i`" Exec xv $i; done'
	      The keyword MissingSubmenuFunction has a similar meaning.	 It is
	      executed whenever	you try	to pop up a sub	menu that does not ex-
	      ist.  With this function you can define and destroy menus	on the
	      fly.  You	can use	any command after the keyword, but if the name
	      of  an  item  (that is a submenu)	defined	with AddToFunc follows
	      it, fvwm executes	this command:
	      Function <function-name> <submenu-name>
	      I.e. the name is passed to the function as  its  first  argument
	      and can be referred to with "$0".

	      The  fvwm-menu-directory script mentioned	above may be used with
	      MissingSubmenuFunction to	create an up to	date recursive	direc-
	      tory listing.

	      Example:
	      #	There is another shell script fvwm_make_directory_menu.sh
	      #	in the utils/ directory	of the distribution. To	use it,
	      #	define this function in	your configuration file:

	      DestroyFunc MakeMissingDirectoryMenu
	      AddToFunc	MakeMissingDirectoryMenu
	      +	I PipeRead fvwm_make_directory_menu.sh $0

	      DestroyMenu SomeMenu
	      AddToMenu	SomeMenu
	      +	MissingSubmenuFunction MakeMissingDirectoryMenu
	      +	"Root directory" Popup /
	      This is another implementation of	the file browser that uses sub
	      menus for	subdirectories.

	      Titles can be used within	the menu. If you add  the  option  top
	      behind  the  keyword Title, the title is added to	the top	of the
	      menu.  If	there was a title already, it is overwritten.
	      AddToMenu	Utilities Tools	Title top
	      All text up to the first Tab in the menu label is	aligned	to the
	      left  side  of  the  menu,  all  text  right of the first	Tab is
	      aligned to the left in a second column and all  text  thereafter
	      is placed	right aligned in the third column.  All	other Tabs are
	      replaced by spaces.  Note	that you can change this  format  with
	      the ItemFormat option of the MenuStyle command.

	      If  the menu-label contains an ampersand ('&'), the next charac-
	      ter is taken as a	hot-key	for the	menu item.  Hot-keys  are  un-
	      derlined	in  the	 label.	  To  get  a literal '&', insert "&&".
	      Pressing the hot-key moves through the list of menu  items  with
	      this  hot-key  or	selects	an item	that is	the only one with this
	      hot-key.

	      If the menu-label	contains a sub-string  which  is  set  off  by
	      stars,  then  the	 text  between the stars is expected to	be the
	      name of an image file to insert in the menu.  To get  a  literal
	      '*', insert "**".	 For example
	       + Calculator*xcalc.xpm* Exec exec xcalc
	      inserts  a  menu	item  labeled "Calculator" with	a picture of a
	      calculator above it.  The	following:
	       + *xcalc.xpm*	       Exec exec xcalc
	      Omits the	"Calculator" label, but	leaves the picture.

	      If the menu-label	contains a sub-string which is set off by per-
	      cent  signs, then	the text between the percent signs is expected
	      to be the	name of	image file (a so called	mini icon to insert to
	      the left of the menu label.  A second mini icon that is drawn at
	      the right	side of	the menu can be	given in the same way.	To get
	      a	literal	'%', insert "%%". For example

	       + Calculator%xcalc.xpm% Exec exec xcalc
	      inserts  a  menu	item  labeled "Calculator" with	a picture of a
	      calculator to the	left.  The following:
	       + %xcalc.xpm%	       Exec exec xcalc
	      Omits the	"Calculator" label, but	leaves the picture.  The  pic-
	      tures used with this feature should be small (perhaps 16x16).

	      If  the menu-name	(not the label)	contains a sub-string which is
	      set off by at signs ('@'), then the text	between	 them  is  ex-
	      pected to	be the name of an xpm or bitmap	file to	draw along the
	      left side	of the menu (a side pixmap).  You may want to use  the
	      SidePic  option of the MenuStyle command instead.	 To get	a lit-
	      eral '@',	insert "@@".  For example
	      AddToMenu	StartMenu@linux-menu.xpm@
	      creates a	menu with a picture in its bottom left corner.

	      If the menu-name also contains a sub-string surrounded by	 '^'s,
	      then  the	text between '^'s is expected to be the	name of	an X11
	      color and	the column containing the side picture is colored with
	      that  color.   You can set this color for	a menu style using the
	      SideColor	option of the MenuStyle	command.   To  get  a  literal
	      '^', insert "^^".	 Example:
	      AddToMenu	StartMenu@linux-menu.xpm@^blue^
	      creates a	menu with a picture in its bottom left corner and col-
	      ors with blue the	region of the menu containing the picture.

	      In all the above cases, the name of the resulting	menu  is  name
	      specified, stripped of the substrings between the	various	delim-
	      iters.

       ChangeMenuStyle menustyle menu ...
	      Changes the menu style of	menu to	menustyle.   You  may  specify
	      more than	one menu in each call of ChangeMenuStyle.
	      ChangeMenuStyle pixmap1 \
		ScreenSaverMenu	ScreenLockMenu

       CopyMenuStyle orig-menustyle dest-menustyle
	      Copy  orig-menustyle  to dest-menustyle, where orig-menustyle is
	      an existing menu style.  If the menu style  dest_menustyle  does
	      not exist, then it is created.

       DestroyMenu [recreate] menu
	      Deletes  a  menu,	 so  that  subsequent  references to it	are no
	      longer valid.  You can use this to change	the contents of	a menu
	      during  an  fvwm	session.   The	menu  can be rebuilt using Ad-
	      dToMenu.	The optional parameter	recreate  tells	 fvwm  not  to
	      throw  away  the	menu completely	but to throw away all the menu
	      items (including the title).
	      DestroyMenu Utilities

       DestroyMenuStyle	menustyle
	      Deletes the menu style named menustyle and changes all menus us-
	      ing  this	style to the default style, you	cannot destroy the de-
	      fault menu style.
	      DestroyMenuStyle pixmap1

       Menu menu-name [position] [double-click-action]
	      Causes a previously defined menu to be popped  up	 in  a	sticky
	      manner.	That is, if the	user invokes the menu with a click ac-
	      tion instead of a	drag action, the menu stays up.	  The  command
	      double-click-action  is invoked if the user double-clicks	a but-
	      ton (or hits the key rapidly twice if the	menu  is  bound	 to  a
	      key)  when  bringing up the menu.	 If the	double click action is
	      not specified, double clicking on	the menu does  nothing.	  How-
	      ever, if the menu	begins with a menu item	(i.e. not with a title
	      or a separator) and the double click action is not given,	double
	      clicking	invokes	 the  first  item of the menu (but only	if the
	      pointer really was over the item).

	      The pointer is warped to where it	was when the menu was  invoked
	      if it was	both invoked and closed	with a keystroke.

	      The  position arguments allow placement of the menu somewhere on
	      the screen, for example centered on the visible screen or	 above
	      a	 title	bar.  Basically	it works like this: you	specify	a con-
	      text-rectangle and an offset to this rectangle by	which the  up-
	      per  left	corner of the menu is moved from the upper left	corner
	      of the rectangle.	 The position  arguments  consist  of  several
	      parts:
	      [context-rectangle] x y [special-options]
	      The context-rectangle can	be one of:

		   Root
		      the root window of the current screen.
		   XineramaRoot
		      the  root	 window	of the whole Xinerama screen.  Equiva-
		      lent to "root" when Xinerama is not used.
		   Mouse
		      a	1x1 rectangle at the mouse position.
		   Window
		      the frame	of the context window.
		   Interior
		      the inside of the	context	window.
		   Title
		      the title	of the context window or icon.
		   Button<n>
		      button #n	of the context window.
		   Icon
		      the icon of the context window.
		   Menu
		      the current menu.
		   Item
		      the current menu item.
		   Context
		      the current window, menu or icon.
		   This
		      whatever widget the pointer is on	(e.g. a	 corner	 of  a
		      window or	the root window).
		   Rectangle <geometry>
		      the  rectangle  defined by <geometry> in X geometry for-
		      mat.  Width and height default to	1 if omitted.

	      If the context-rectangle is omitted or illegal (e.g. "item" on a
	      window),	"Mouse"	 is  the  default.  Note that not all of these
	      make sense under all circumstances (e.g. "Icon" if  the  pointer
	      is on a menu).

	      The offset values	x and y	specify	how far	the menu is moved from
	      it's default position.  By default, the numeric value  given  is
	      interpreted  as  a  percentage  of the context rectangle's width
	      (height),	but with a trailing 'm'	the menu's width  (height)  is
	      used  instead.  Furthermore a trailing 'p' changes the interpre-
	      tation to	mean pixels.

	      Instead of a single value	you can	use a list of values.  All ad-
	      ditional	numbers	 after	the first one are separated from their
	      predecessor by their sign.  Do not use any other separators.

	      If x or y	are prefixed with "o<number>" where <number> is	an in-
	      teger,  the  menu	 and the rectangle are moved to	overlap	at the
	      specified	position before	any other offsets  are	applied.   The
	      menu  and	the rectangle are placed so that the pixel at <number>
	      percent of the rectangle's width/height is right over the	 pixel
	      at  <number>  percent  of	the menu's width/height. So "o0" means
	      that the top/left	borders	of the menu and	the rectangle overlap,
	      with  "o100"  it's the bottom/right borders and if you use "o50"
	      they are centered	upon each other	(try it	and you	will see it is
	      much  simpler than this description).  The default is "o0".  The
	      prefix "o<number>" is an abbreviation for	"+<number>-<number>m".

	      A	prefix of 'c' is equivalent to "o50".  Examples:
	      #	window list in the middle of the screen
	      WindowList Root c	c

	      #	menu to	the left of a window
	      Menu name	window -100m c+0

	      #	popup menu 8 pixels above the mouse pointer
	      Popup name mouse c -100m-8p

	      #	somewhere on the screen
	      Menu name	rectangle 512x384+1+1 +0 +0

	      #	centered vertically around a menu item
	      AddToMenu	foobar-menu
	       + "first	item" Nop
	       + "special item"	Popup "another menu" item \
				+100 c
	       + "last item" Nop

	      #	above the first	menu item
	      AddToMenu	foobar-menu
	       + "first	item" Popup "another menu" item	\
			      +0 -100m
	      Note that	you can	put a sub menu far off the current menu	so you
	      could  not reach it with the mouse without leaving the menu.  If
	      the pointer leaves the current menu in the general direction  of
	      the sub menu the menu stays up.

	      The special-options:

		   To  create a	tear off menu without opening the normal menu,
		   add the option TearOffImmediately.  Normally	the menu opens
		   in  normal  state for a split second	before being torn off.
		   As tearing off places the menu like any other window, a po-
		   sition should be specified explicitly:
		   # Forbid fvwm to place the menu window
		   Style <name of menu>	UsePPosition
		   # Menu at top left corner of	screen
		   Menu	Root 0p	0p TearOffImmediately

		   The	animated  and  Mwm  or Win menu	styles may move	a menu
		   somewhere else on the screen.  If you do not	want this  you
		   can	add Fixed as an	option.	 This might happen for example
		   if you want the menu	always in the top right	corner of  the
		   screen.

		   Where  do  you want a menu to appear	when you click on it's
		   menu	item? The default is to	place the title	under the cur-
		   sor,	 but  if you want it where the position	arguments say,
		   use the SelectInPlace option.  If you want the  pointer  on
		   the title of	the menu, use SelectWarp too.  Note that these
		   options apply only if the PopupAsRootMenu MenuStyle	option
		   is used.

		   The	pointer	 is warped to the title	of a sub menu whenever
		   the pointer would be	on an item when	the sub	menu is	popped
		   up  (fvwm  menu  style) or never warped to the title	at all
		   (Mwm	or Win menu styles).  You can force  (forbid)  warping
		   whenever the	sub menu is opened with	the WarpTitle (NoWarp)
		   option.

		   Note	that the special-options do work with  a  normal  menu
		   that	has no other position arguments.

       MenuStyle stylename options
	      Sets  a  new  menu  style	or changes a previously	defined	style.
	      The stylename is the style name; if it contains spaces  or  tabs
	      it  has  to be quoted.  The name "*" is reserved for the default
	      menu style. The default menu style is used for  every  menu-like
	      object  (e.g. the	window created by the WindowList command) that
	      had not be assigned a style using	the ChangeMenuStyle.  See also
	      DestroyMenuStyle.	  When	using monochrome color options are ig-
	      nored.

	      options is a comma separated list	containing some	 of  the  key-
	      words  Fvwm  /  Mwm  / Win, BorderWidth, Foreground, Background,
	      Greyed, HilightBack / !HilightBack, HilightTitleBack, ActiveFore
	      /	!ActiveFore, MenuColorset, ActiveColorset, GreyedColorset, Ti-
	      tleColorset, Hilight3DThick / Hilight3DThin / Hilight3DOff,  Hi-
	      light3DThickness,	Animation / !Animation,	Font, TitleFont, Menu-
	      Face, PopupDelay,	PopupOffset, TitleWarp / !TitleWarp,  TitleUn-
	      derlines0	 / TitleUnderlines1 / TitleUnderlines2,	SeparatorsLong
	      /	SeparatorsShort, TrianglesSolid	/ TrianglesRelief,  PopupImme-
	      diately  /  PopupDelayed,	 PopdownImmediately  / PopdownDelayed,
	      PopupActiveArea, DoubleClickTime,	SidePic,  SideColor,  PopupAs-
	      RootMenu / PopupAsSubmenu	/ PopupIgnore /	PopupClose, RemoveSub-
	      menus / HoldSubmenus, SubmenusRight / SubmenusLeft,  SelectOnRe-
	      lease,  ItemFormat,  VerticalItemSpacing,	 VerticalTitleSpacing,
	      AutomaticHotkeys / !AutomaticHotkeys, MouseWheel,	 ScrollOffPage
	      /	!ScrollOffPage,	TrianglesUseFore / !TrianglesUseFore.

	      In  the  above  list  some options are listed as option pairs or
	      triples with a '/'  in  between.	 These	options	 exclude  each
	      other.   All paired options can be negated to have the effect of
	      the counterpart option by	prefixing ! to the option.

	      Some options are now negated by prefixing	! to the option.  This
	      will  soon be the	preferred form for all such options. The other
	      negative forms are now deprecated	and will be removed in the fu-
	      ture.

	      This is a	list of	MenuStyle deprecated negative options: Active-
	      ForeOff, AnimationOff, AutomaticHotkeysOff, HilightBackOff,  Ti-
	      tleWarpOff

	      Fvwm, Mwm, Win reset all options to the style with the same name
	      in former	versions of fvwm.  The default for new menu styles  is
	      Fvwm  style.   These  options  override  all others except Fore-
	      ground, Background, Greyed, HilightBack, ActiveFore and PopupDe-
	      lay,  so	they should be used only as the	first option specified
	      for a menu style or to reset the style to	defined	behavior.  The
	      same  effect can be created by setting all the other options one
	      by one.

	      Mwm and Win style	menus  popup  sub  menus  automatically.   Win
	      menus  indicate the current menu item by changing	the background
	      to dark.	Fvwm sub menus overlap the parent menu,	 Mwm  and  Win
	      style menus never	overlap	the parent menu.

	      Fvwm  style  is  equivalent to !HilightBack, Hilight3DThin, !Ac-
	      tiveFore,	!Animation, Font, MenuFace, PopupOffset	0  67,	Title-
	      Warp,  TitleUnderlines1,	SeparatorsShort, TrianglesRelief, Pop-
	      upDelayed, PopdownDelayed,  PopupDelay  150,  PopdownDelay  150,
	      PopupAsSubmenu, HoldSubmenus, SubmenusRight, BorderWidth 2, !Au-
	      tomaticHotkeys, PopupActiveArea 75.

	      Mwm style	is equivalent to  !HilightBack,	 Hilight3DThick,  !Ac-
	      tiveFore,	 !Animation,  Font, MenuFace, PopupOffset -3 100, !Ti-
	      tleWarp, TitleUnderlines2, SeparatorsLong, TrianglesRelief, Pop-
	      upImmediately, PopdownDelayed, PopdownDelay 150, PopupAsSubmenu,
	      HoldSubmenus, SubmenusRight, BorderWidth	2,  !AutomaticHotkeys,
	      PopupActiveArea 75.

	      Win  style  is  equivalent to HilightBack, Hilight3DOff, Active-
	      Fore, !Animation,	Font, MenuFace,	PopupOffset  -5	 100,  !Title-
	      Warp,  TitleUnderlines1,	SeparatorsShort,  TrianglesSolid, Pop-
	      upImmediately, PopdownDelayed, PopdownDelay 150, PopupAsSubmenu,
	      RemoveSubmenus, SubmenusRight, BorderWidth 2, !AutomaticHotkeys,
	      PopupActiveArea 75.

	      BorderWidth takes	the thickness of the border around  the	 menus
	      in  pixels. It may be zero to 50 pixels.	The default is 2.  Us-
	      ing an illegal value reverts the border width to the default.

	      Foreground and Background	may have a color name as an  argument.
	      This  color is used for menu text	or the menu's background.  You
	      can omit the color name to reset these colors  to	 the  built-in
	      default.

	      Greyed  may have a color name as an argument.  This color	is the
	      one used to draw a menu-selection	which is  prohibited  (or  not
	      recommended)  by	the  Mwm hints which an	application has	speci-
	      fied. If the color is omitted the	color of greyed	 menu  entries
	      is based on the background color of the menu.

	      HilightBack and !HilightBack switch hilighting the background of
	      the selected menu	item on	and off.  A specific background	 color
	      may  be  used  by	providing the color name as an argument	to Hi-
	      lightBack.  If you use this option without an argument the color
	      is based on the menu's background	color.	The ActiveColorset op-
	      tion overrides the specified color.

	      HilightTitleBack switches	hilighting the background of menu  ti-
	      tles  on.	 If a TitleColorset was	used, the background colour is
	      taken from there.	 Otherwise the color is	based  on  the	menu's
	      background color.

	      ActiveFore  and  !ActiveFore switch hilighting the foreground of
	      the selected menu	item on	and off.  A specific foreground	 color
	      may  be  used  by	providing the color name as an argument	to Ac-
	      tiveFore.	 Omitting the color turns hilighting on	 when  an  Ac-
	      tiveColorset is used.  ActiveFore	turns off hilighting the fore-
	      ground completely.   The	ActiveColorset	option	overrides  the
	      specified	color.

	      MenuColorset controls if a colorset is used instead of the Fore-
	      ground, Background and MenuFace menu styles.   If	 the  MenuCol-
	      orset  keyword is	followed by a number equal to zero or greater,
	      this number is taken as the number of the	colorset to  use.   If
	      the number is omitted, the colorset is switched off and the reg-
	      ular menu	styles are used	again.	The foreground and  background
	      colors  of  the  menu  items are replaced	by the colors from the
	      colorset.	If the colorset	has a pixmap defined, this  pixmap  is
	      used as the background of	the menu.  Note	that the MenuFace menu
	      style has	been optimized for memory consumption and may use less
	      memory than the background from a	colorset.  The shape mask from
	      the colorset is used to shape the	menu.	Please	refer  to  the
	      COLORSETS	section	for details about colorsets.

	      ActiveColorset  works  exactly  like MenuColorset, but the fore-
	      ground from the colorset replaces	the color given	with  the  Ac-
	      tiveFore menu style and the colorset's background	color replaces
	      the color	given with the HilightBack command (to turn  on	 back-
	      ground  hilighting  you  have  to	use the	HilightBack menu style
	      too).  If	specified, the hilight and shadow colors from the col-
	      orset are	used too.  The pixmap and shape	mask from the colorset
	      are not used.  Hilighting	the background or  foreground  can  be
	      turned  off  individually	 with  the !ActiveFore or !HilightBack
	      menu styles.

	      GreyedColorset works exactly like	MenuColorset,  but  the	 fore-
	      ground  from  the	 colorset  replaces  the  color	given with the
	      Greyed menu style.  No other parts of the	colorset are used.

	      TitleColorset works exactly like MenuColorset, but is used  only
	      for menu titles.

	      Hilight3DThick,  Hilight3DThin and Hilight3DOff determine	if the
	      selected menu item is hilighted with a 3D	relief.	Thick  reliefs
	      are two pixels wide, thin	reliefs	are one	pixel wide.

	      Hilight3DThickness  takes	 one  numeric argument that may	be be-
	      tween -50	and +50	pixels.	With negative  values  the  menu  item
	      gets a pressed in	look.  The above three commands	are equivalent
	      to a thickness of	2, 1 and 0.

	      Animation	and !Animation turn menu animation on  or  off.	  When
	      animation	 is  on, sub menus that	do not fit on the screen cause
	      the parent menu to be shifted to the left	so the sub menu	can be
	      seen.

	      Font  and	 TitleFont take	a font name as an argument.  If	a font
	      by this name exists it is	used for the text of all  menu	items.
	      If  it  does not exist or	if the name is left blank the built-in
	      default is used.	If a TitleFont is given, it is	used  for  all
	      menu titles instead of the normal	font.

	      MenuFace	enforces  a  fancy background upon the menus.  You can
	      use the same options for MenuFace	as for the  ButtonStyle.   See
	      description  of ButtonStyle command and the COLOR	GRADIENTS sec-
	      tions for	more information.  If you use MenuFace	without	 argu-
	      ments the	style is reverted back to normal.

	      Some examples of MenuFaces are:
	      MenuFace DGradient 128 2 lightgrey 50 blue 50 \
		white
	      MenuFace TiledPixmap texture10.xpm
	      MenuFace HGradient 128 2 Red 40 Maroon 60	\
		White
	      MenuFace Solid Maroon
	      Note:  The  gradient styles H, V,	B and D	are optimized for high
	      speed and	low memory consumption in menus.  This is not the case
	      for all the other	gradient styles.  They may be slow and consume
	      huge amounts of memory, so if you	encounter performance problems
	      with  them  you may be better off	by not using them.  To improve
	      performance you can try one or all of the	following:

	      Turn hilighting of the active menu item  other  than  foreground
	      color off:
	      MenuStyle	<style>	Hilight3DOff, !HilightBack
	      MenuStyle	<style>	ActiveFore <preferred color>
	      Make  sure  sub  menus  do not overlap the parent	menu. This can
	      prevent menus being redrawn every	time a sub  menu  pops	up  or
	      down.
	      MenuStyle	<style>	PopupOffset 1 100
	      Run  your	 X  server  with backing storage.  If your X Server is
	      started with the -bs option, turn	it off.	 If not	 try  the  -wm
	      and +bs options:
	      startx --	-wm +bs
	      You  may	have to	adapt this example to your system (e.g.	if you
	      use xinit	to start X).

	      PopupDelay requires one numeric argument.	 This value is the de-
	      lay  in  milliseconds  before  a	sub menu is popped up when the
	      pointer moves over a menu	item that has  a  sub  menu.   If  the
	      value  is	 zero no automatic pop up is done.  If the argument is
	      omitted the built-in default is used. Note that the popup	 delay
	      has  no  effect if the PopupImmediately option is	used since sub
	      menus pop	up immediately then.

	      PopupImmediately makes menu items	with sub menus pop up it up as
	      soon  as	the pointer enters the item.  The PopupDelay option is
	      ignored then.  If	PopupDelayed is	used fvwm looks	 at  the  Pop-
	      upDelay option if	or when	this automatic popup happens.

	      PopdownDelay  works  exactly  like PopupDelay but	determines the
	      timeout of the PopupDelayed style.

	      PopdownImmediately makes sub menus vanish	as soon	as the pointer
	      leaves  the  sub	menu  and the correspondent item in the	parent
	      menu.  With the opposite option PopdownDelayed the sub menu only
	      pops down	after the time specified with the PopdownDelay option.
	      This comes handy when the	pointer	often strays off the menu item
	      when trying to move into the sub menu.  Whenever there is	a con-
	      flict between  the  PopupImmediately,  PopupDelayed,  PopupDelay
	      styles  and the PopdownImmediately, PopdownDelayed, PopdownDelay
	      styles, the Popup...  styles win when using mouse	navigation and
	      the Popdown...  styles win when navigating with the keyboard.

	      PopupOffset  requires two	integer	arguments.  Both values	affect
	      where sub	menus are placed relative to the parent	menu.  If both
	      values are zero, the left	edge of	the sub	menu overlaps the left
	      edge of the parent menu.	If the first value is non-zero the sub
	      menu  is shifted that many pixels	to the right (or left if nega-
	      tive).  If the second value is non-zero the  menu	 is  moved  by
	      that  many  percent  of  the parent menu's width to the right or
	      left.

	      PopupActiveArea requires an integer value	between	 51  and  100.
	      Normally,	 when  the pointer is over a menu item with a sub menu
	      and the pointer enters the area that starts at 75% of  the  menu
	      width,  the  sub menu is shown immediately.  This	percentage can
	      be changed with PopupActiveArea.	Setting	this value to 100 dis-
	      ables  this  kind	 of  automatic popups altogether.  The default
	      value is restored	if no or an illegal value is given.

	      TitleWarp	and !TitleWarp affect if the pointer warps to the menu
	      title  when a sub	menu is	opened or not. Note that regardless of
	      this setting the pointer is not warped if	the menu does not  pop
	      up under the pointer.

	      TitleUnderlines0,	 TitleUnderlines1 and TitleUnderlines2 specify
	      how many lines are drawn below a menu title.

	      SeparatorsLong and SeparatorsShort set the length	of menu	 sepa-
	      rators.	Long  separators run from the left edge	all the	way to
	      the right	edge.  Short separators	leave  a  few  pixels  to  the
	      edges of the menu.

	      TrianglesSolid  and  TrianglesRelief affect how the small	trian-
	      gles for sub menus is drawn.  Solid triangles are	filled with  a
	      color while relief triangles are hollow.

	      DoubleClickTime  requires	 one  numeric argument.	 This value is
	      the time in milliseconds between two mouse clicks	in a  menu  to
	      be  considered  as a double click.  The default is 450 millisec-
	      onds.  If	the argument is	omitted	the double click time is reset
	      to this default.

	      SidePic takes the	name of	an image file as an argument. The pic-
	      ture is drawn along the left side	of the menu.  The SidePic  op-
	      tion  can	 be overridden by a menu specific side pixmap (see Ad-
	      dToMenu).	 If the	file name is omitted an	existing  side	pixmap
	      is removed from the menu style.

	      SideColor	 takes	the  name of an	X11 color as an	argument. This
	      color is used to color the column	containing  the	 side  picture
	      (see  above).  The  SideColor option can be overridden by	a menu
	      specific side color (see AddToMenu).  If the color name is omit-
	      ted the side color option	is switched off.

	      PopupAsRootMenu,	 PopupAsSubmenu,  PopupIgnore  and  PopupClose
	      change the behavior when you click on a menu item	that  opens  a
	      sub  menu.  With PopupAsRootMenu the original menu is closed be-
	      fore the sub menu	appears, with PopupAsSubmenu it	is not,	so you
	      can navigate back	into the parent	menu.  Furthermore, with Popu-
	      pAsSubmenu the sub menu is  held	open  (posted)	regardless  of
	      where you	move the mouse.	 Depending on your menu	style this may
	      simplify navigating through the menu.   Any  keystroke  while  a
	      menu  is	posted	reverts	 the menu back to the normal behavior.
	      With PopupClose the menu is closed when a	sub menu item is acti-
	      vated,  and  the menu stays open if PopupIgnore is used (even if
	      the menu was invoked with	the Popup command).  PopupAsSubmenu is
	      the default.

	      RemoveSubmenus  instructs	 fvwm to remove	sub menu when you move
	      back into	the parent menu.  With HoldSubmenus the	sub  menu  re-
	      mains visible.  You probably want	to use HoldSubmenus if you are
	      using the	PopupDelayed style.  RemoveSubmenus affects menu navi-
	      gation with the keyboard.

	      SelectOnRelease  takes  an optional key name as an argument.  If
	      the given	key is released	in a menu using	this style,  the  cur-
	      rent  menu  item is selected.  This is intended for Alt-Tab Win-
	      dowList navigation.  The key name	is a standard X11 key name  as
	      defined  in  /usr/include/X11/keysymdef.h, (without the XK_ pre-
	      fix), or the keysym database  /usr/X11R6/lib/X11/XKeysymDB.   To
	      disable this behavior, omit the key name.

	      Note:  Some  X servers do	not support KeyRelease events.	Selec-
	      tOnRelease does not work on such a machine.

	      ItemFormat takes a special string	as its	argument  that	deter-
	      mines  the layout	of the menu items.  Think of the format	string
	      as if it were a menu item.  All you have	to  do	is  tell  fvwm
	      where  to	 place	the different parts of the menu	item (i.e. the
	      labels, the triangle denoting a sub menu,	the mini icons and the
	      side pic)	in the blank area.  The	string consists	of spaces, Tab
	      characters and formatting	directives beginning with '%'. Any il-
	      legal characters and formatting directives are silently ignored:

		   %l, %c and %r
		      Insert  the  next	item label.  Up	to three labels	can be
		      used. The	item column  is	 left-aligned  (%l),  centered
		      (%c) or right-aligned (%r).
		   %i
		      Inserts the mini icon.
		   %> and %<
		      Insert  the  sub	menu  triangle	pointing either	to the
		      right (%>) or to the left	(%<)
		   %|
		      The first	%| denotes the beginning of the	area  that  is
		      highlighted  either  with	a background color or a	relief
		      (or both).  The second %|	marks the end  of  this	 area.
		      %| can be	used up	to twice in the	string.	 If you	do not
		      add one or both of them, fvwm sets the  margins  to  the
		      margins  of  the	whole item (not	counting the side pic-
		      ture).
		   %s
		      Places the side picture either at	the beginning  or  the
		      end  of  the  menu. This directive may be	used only once
		      and only as the first or last in the format  string.  If
		      the  %s is not at	the beginning of the string, menus are
		      not drawn	properly.
		   Space, Tab, %Space and %Tab
		      Add gap of one space, or a tab, using the	width  of  the
		      menu font.  When using a tab, the	size of	the gap	can be
		      one to 8 spaces since the	tab position is	a multiple  of
		      8	 from  the edge	of the menu.  The whole	string must be
		      quoted if	spaces or tabs are used.
		   %p
		      Like Space and Tab %p inserts an	empty  area  into  the
		      item, but	with better control of its size	(see below).

	      You  can define an additional space before and after each	of the
	      objects like this:
	      %left.rightp
	      This means: if the object	is defined in the menu (e.g. if	it  is
	      %s  and you use a	side picture, or it is %l for the third	column
	      and there	are items defined that actually	have a third  column),
	      then  add	 left  pixels before the object	and right pixels after
	      it.  You may leave out the left or the .right parts  if  you  do
	      not  need	 them.	All values up to the screen width are allowed.
	      Even negative values can be used with care.  The p  may  be  re-
	      placed with any other formatting directives described above.

	      Note: Only items defined in the format string are	visible	in the
	      menus. So	if you do not put a %s in there	you do not see a  side
	      picture, even if one is specified.

	      Note:  The  SubmenusLeft	style  changes	the default ItemFormat
	      string, but if it	was set	manually it is not modified.

	      Note: If any unformatted title of	the menu  is  wider  than  the
	      widest  menu item, the spaces between the	different parts	of the
	      menu items are enlarged to match the width of the	title.	 Lead-
	      ing left aligned objects in the format string (%l, %i, %<, first
	      %|) stick	to the left  edge  of  the  menu  and  trailing	 right
	      aligned objects (%r, %i, %>, second %|) stick to the right edge.
	      The gaps between the remaining items are enlarged	equally.

	      Examples:
	      MenuStyle	* ItemFormat \
		"%.4s%.1|%.5i%.5l%.5l%.5r%.5i%2.3>%1|"
	      Is the default string used by fvwm: (side	 picture  +  4	pixels
	      gap)  (beginning of the hilighted	area + 1 pixel gap) (mini icon
	      +	5p) (first column left	aligned	 +  5p)	 (second  column  left
	      aligned  +  5p)  (third  column right aligned + 5p) (second mini
	      icon + 5p) (2p + sub menu	triangle + 3p) (1p + end of  hilighted
	      area).
	      MenuStyle	* ItemFormat \
		"%.1|%3.2<%5i%5l%5l%5r%5i%1|%4s"
	      Is used by fvwm with the SubmenusLeft option below.

	      VerticalItemSpacing  and VerticalTitleSpacing control the	verti-
	      cal spacing of menu items	and titles  like  ItemFormat  controls
	      the  horizontal  spacing.	  Both take two	numeric	arguments that
	      may range	from -100 to +100.  The	first is  the  gap  in	pixels
	      above  a	normal	menu item (or a	menu title), the second	is the
	      gap in pixels below it.  Negative	numbers	do not make much sense
	      and may screw up the menu	completely.  If	no arguments are given
	      or the given arguments are invalid, the  built-in	 defaults  are
	      used: one	pixel above the	item or	title and two below.

	      SubmenusLeft  mirrors  the  menu layout and behavior.  Sub menus
	      pop up to	the left, the sub menu triangle	is drawn left and  the
	      mini  icon  and  side picture are	drawn at the right side	of the
	      menu.  The default is SubmenusRight.  The	position  hints	 of  a
	      menu  are	also affected by this setting, i.e. position hints us-
	      ing item or menu as context rectangle and	position hints using m
	      offsets.

	      AutomaticHotkeys	and !AutomaticHotkeys control the menu's abil-
	      ity to automatically provide hot-keys on the first character  of
	      each  menu  item's label.	 This behavior is always overridden if
	      an explicit hot-key is assigned in the AddToMenu command.

	      MouseWheel controls the ability to scroll	the menu using a mouse
	      wheel. It	takes one argument, that can be	one of ScrollsPointer,
	      ScrollsMenu, ScrollsMenuBackwards	 or  ActivatesItem.   Scrolls-
	      Pointer  makes  the  mouse wheel scroll the pointer over a menu.
	      This is the default. ScrollsMenu and ScrollsMenuBackwards	scroll
	      the  menu	 beneath the pointer. ActivatesItem disables scrolling
	      by mouse wheel and makes the use of a mouse wheel	act as if  the
	      menu  was	 clicked.  If no argument is supplied the default set-
	      ting is restored.

	      ScrollOffPage allows a menu to be	scrolled out  of  the  visible
	      area  if	MouseWheel  is	set to ScrollsMenu or ScrollsMenuBack-
	      wards. This is the default.  The opposite,  !ScrollOffPage  dis-
	      ables this behaviour.

	      TrianglesUseFore	draws  sub  menu triangles with	the foreground
	      color of the menu	colorset  (normally  drawn  with  the  hilight
	      color).  !TrianglesUseFore disables this behaviour.

	      Examples:
	      MenuStyle	* Mwm
	      MenuStyle	* Foreground Black, Background gray40
	      MenuStyle	* Greyed gray70, ActiveFore White
	      MenuStyle	* !HilightBack,	Hilight3DOff
	      MenuStyle	* Font lucidasanstypewriter-14
	      MenuStyle	* MenuFace DGradient 64	darkgray \
		MidnightBlue

	      MenuStyle	red Mwm
	      MenuStyle	red Foreground Yellow
	      MenuStyle	red Background Maroon
	      MenuStyle	red Greyed Red,	ActiveFore Red
	      MenuStyle	red !HilightBack, Hilight3DOff
	      MenuStyle	red Font lucidasanstypewriter-12
	      MenuStyle	red MenuFace DGradient 64 Red Black
	      Note that	all style options could	be placed on a single line for
	      each style name.

       MenuStyle forecolor backcolor shadecolor	font style [anim]
	      This is the old syntax of	the MenuStyle command.	It is obsolete
	      and  may be removed in the future.  Please use the new syntax as
	      described	above.

	      Sets the menu style.  When using monochrome the colors  are  ig-
	      nored.   The shadecolor is the one used to draw a	menu-selection
	      which is prohibited (or not recommended) by the Mwm hints	 which
	      an  application has specified.  The style	option is either Fvwm,
	      Mwm or Win, which	changes	the appearance and  operation  of  the
	      menus.

	      Mwm  and	Win  style  menus  popup sub menus automatically.  Win
	      menus indicate the current menu item by changing the  background
	      to  black.   Fvwm	sub menus overlap the parent menu, Mwm and Win
	      style menus never	overlap	the parent menu.

	      When the anim option is given, sub menus that do not fit on  the
	      screen  cause  the  parent menu to be shifted to the left	so the
	      sub menu can be seen. See	also SetAnimation command.

       Popup PopupName [position] [default-action]
	      This command has two purposes: to	bind a menu to a key or	 mouse
	      button, and to bind a sub	menu into a menu.  The formats for the
	      two purposes differ slightly.  The position  arguments  are  the
	      same  as for Menu.  The command default-action is	invoked	if the
	      user clicks a button to invoke the menu and releases it  immedi-
	      ately  again (or hits the	key rapidly twice if the menu is bound
	      to a key).  If the  default  action  is  not  specified,	double
	      clicking	on the menu does nothing.  However, if the menu	begins
	      with a menu item (i.e. not with a	title or a separator) and  the
	      default  action  is not given, double clicking invokes the first
	      item of the menu (but only if the	pointer	really	was  over  the
	      item).

	      To  bind a previously defined pop-up menu	to a key or mouse but-
	      ton:

		The following example binds mouse buttons 2 and	3 to a	pop-up
		called	"Window	 Ops".	The menu pops up if the	buttons	2 or 3
		are pressed in the window frame, side-bar, or title-bar,  with
		no modifiers (none of shift, control, or meta).
		Mouse 2	FST N Popup "Window Ops"
		Mouse 3	FST N Popup "Window Ops"
		Pop-ups	 can  be bound to keys through the use of the Key com-
		mand.  Pop-ups can be operated	without	 using	the  mouse  by
		binding	 to  keys  and operating via the up arrow, down	arrow,
		and enter keys.

	      To bind a	previously defined pop-up menu to  another  menu,  for
	      use as a sub menu:

		The  following	example	 defines  a sub	menu "Quit-Verify" and
		binds it into a	main menu, called "RootMenu":
		AddToMenu Quit-Verify
		 + "Really Quit	Fvwm?" Title
		 + "Yes, Really	Quit"  Quit
		 + "Restart Fvwm"      Restart
		 + "Restart Fvwm 1.xx" Restart fvwm1 -s
		 + ""		       Nop
		 + "No,	Don't Quit"    Nop

		AddToMenu RootMenu "Root Menu" Title
		 + "Open XTerm Window" Popup NewWindowMenu
		 + "Login as Root"     Exec exec xterm \
					 -fg green -T Root \
					 -n Root -e su -
		 + "Login as Anyone"   Popup AnyoneMenu
		 + "Remote Hosts"      Popup HostMenu
		 + ""		       Nop
		 + "X utilities"       Popup Xutils
		 + ""		       Nop
		 + "Fvwm Modules"      Popup Module-Popup
		 + "Fvwm Window	Ops"   Popup Window-Ops
		 + ""		       Nop
		 + "Previous Focus"    Prev (AcceptsFocus) Focus
		 + "Next Focus"	       Next (AcceptsFocus) Focus
		 + ""		       Nop
		 + "Refresh screen"    Refresh
		 + ""		       Nop
		 + "Reset X defaults"  Exec xrdb -load \
				       $HOME/.Xdefaults
		 + ""		       Nop
		 + ""		       Nop
		 + Quit		       Popup Quit-Verify

	      Popup differs from Menu in that pop-ups do not stay  up  if  the
	      user  simply  clicks.  These are popup-menus, which are a	little
	      hard on the wrist.  Menu menus stay up on	a click	 action.   See
	      the  Menu	command	for an explanation of the interactive behavior
	      of menus.	A menu can be open up to ten times at once, so a  menu
	      may even use itself or any of its	predecessors as	a sub menu.

       TearMenuOff
	      When assigned to a menu item, it inserts a tear off bar into the
	      menu (a horizontal broken	line).	Activating that	item tears off
	      the  menu.  If the menu item has a label,	it is shown instead of
	      the broken line.	If used	outside	menus, this command does noth-
	      ing.  Examples:
	      AddToMenu	WindowMenu
	      +	I "" TearMenuOff

	      AddToMenu	RootMenu
	      +	I "click here to tear me off" TearMenuOff

       Title  Does nothing.  This is used to insert a title line in a popup or
	      menu.

   MISCELLANEOUS COMMANDS
       BugOpts [option [bool]],	...
	      This command controls several  workarounds  for  bugs  in	 third
	      party programs.  The individual options are separated by commas.
	      The optional argument bool is a boolean argument and controls if
	      the  bug	workaround is enabled or not.  It can either be	"True"
	      or "False" to turn the option on or off, or "toggle"  to	switch
	      is  back	and forth.  If bool is omitted,	the default setting is
	      restored.

	      FlickeringMoveWorkaround disables	 ConfigureNotify  events  that
	      are  usually  sent to an application while it is moved.  If some
	      windows flicker annoyingly while being moved,  this  option  may
	      help  you.   Note	 that if this problem occurs it	is not an fvwm
	      bug, it is a problem of the application.

	      MixedVisualWorkaround makes fvwm install the root	 colormap  be-
	      fore  it	does  some  operations	using the root window visuals.
	      This is only useful when the -visual option  is  used  to	 start
	      fvwm  and	 then  only  with  some	configurations of some servers
	      (e.g. Exceed 6.0 with an 8 bit PseudoColor root and fvwm using a
	      24 bit TrueColor visual).

	      The  ModalityIsEvil  option  controls whether Motif applications
	      have the ability to have modal dialogs (dialogs that  force  you
	      to  close	 them first before you can do anything else).  The de-
	      fault is to not allow applications to have modal	dialogs.   Use
	      this  option  with care. Once this option	is turned on, you have
	      to restart fvwm to turn it off.

	      RaiseOverNativeWindows makes fvwm	try to raise  the  windows  it
	      manages over native windows of the X server's host system.  This
	      is needed	for some X servers running under  Windows  or  Windows
	      NT.   Fvwm  tries	 to  detect  if	 it is running under such an X
	      server and initializes the flag accordingly.

	      RaiseOverUnmanaged makes fvwm try	to raise the windows  it  man-
	      ages  over override_redirect windows.  This is used to cope with
	      ill-mannered applications	that use long-lived  windows  of  this
	      sort,  contrary to ICCCM conventions.  It	is useful with the Un-
	      managed style option too.

	      FlickeringQtDialogsWorkaround suppresses flickering of  the  fo-
	      cused  window  in	some modules when using	KDE or Qt applications
	      with application modal dialog windows.  By default  this	option
	      is  turned on.  This option may be visually disturbing for other
	      applications using windows not managed by	fvwm.  Since these ap-
	      plications  are rare it is most likely safe to leave this	option
	      at its default.

	      EWMHIconicStateWorkaround	is needed by EWMH compliant pagers  or
	      taskbars	which represent	windows	which are on a different desk-
	      tops as iconified. These pagers and taskbars use	a  version  of
	      the  EWMH	specification before version 1.2 (the current KDE2 & 3
	      versions).   These  pagers  and  taskbars	 use  the  IconicState
	      WM_STATE	state  to  determine  if  an application is iconified.
	      This state, according to the ICCCM , does	not imply that a  win-
	      dow  is  iconified (in the usual sense).	Turning	on this	option
	      forces fvwm to establish an equivalence between the  IconicState
	      WM_STATE	state  and  the	iconified window.  This	violates ICCCM
	      compliance but should not	cause big problems.  By	 default  this
	      option is	off.

	      With  the	 DisplayNewWindowNames	enabled, fvwm prints the name,
	      icon name	(if available),	resource and class of new  windows  to
	      the  console.   This  can	help in	finding	the correct strings to
	      use in the Style command.

	      When the ExplainWindowPlacement option is	enabled, fvwm prints a
	      message to the console whenever a	new window is placed or	one of
	      the commands PlaceAgain, Recapture or RecaptureWindow  is	 used.
	      The  message  explains  on which desk, page, Xinerama screen and
	      position it was placed and why.  This option can be used to fig-
	      ure out why a specific window does not appear where you think it
	      should.

	      The DebugCRMotionMethod option enables some  debugging  code  in
	      the ConfigureRequest handling routines of	fvwm.  It is not help-
	      ful for the user,	but if you report a bug	to the	fvwm  team  we
	      may ask you to enable this option.

       BusyCursor [Option bool], ...
	      This command controls the	cursor during the execution of certain
	      commands.	 Option	can be DynamicMenu,  ModuleSynchronous,	 Read,
	      Wait, *.	An option must be followed by a	boolean	argument bool.
	      You can use commas to separate individual	options.  If  you  set
	      an option	to "True", then	when the corresponding command is run,
	      fvwm displays the	cursor of the WAIT context of the  CursorStyle
	      command.	"False"	forces to not display the cursor.  The default
	      is:
	      BusyCursor DynamicMenu False, \
		ModuleSynchronous False, Read False, \
		Recapture True,	Wait False
	      The option * refers to all available options.

	      The Read option also controls the	PipeRead command.

	      The DynamicMenu option affects the DynamicPopupAction and	 Miss-
	      ingSubmenuFunction  options  of  the AddToMenu command.  If this
	      option is	set to "False",	then the busy cursor is	not  displayed
	      during  a	dynamic	menu command even if this command is a Read or
	      PipeRead command and the Read option is set to "True".

	      The Wait option affects only the root  cursor.   During  a  wait
	      pause the	root cursor is replaced	by the busy cursor and fvwm is
	      still fully functional (you can escape from the pause,  see  the
	      EscapeFunc  command).  If	you want to use	this option and	if you
	      do not use the default root cursor, you must set your root  cur-
	      sor with the CursorStyle command.

       ClickTime [delay]
	      Specifies	 the  maximum  delay  in milliseconds between a	button
	      press and	a button release for the Function command to  consider
	      the  action  a  mouse click.  The	default	delay is 150 millisec-
	      onds.  Omitting the delay	value resets the ClickTime to the  de-
	      fault.

       ColorLimit limit
	      This command is obsolete.	See the	--color-limit option to	fvwm.

       ColormapFocus FollowsMouse|FollowsFocus
	      By  default,  fvwm  installs the colormap	of the window that the
	      cursor is	in.  If	you use
	      ColormapFocus FollowsFocus
	      then the installed colormap is the one for the window that  cur-
	      rently has the keyboard focus.

       CursorStyle context [number| name | xpm | None |	Tiny [fore back]]
	      Defines  a new cursor for	the specified context.	Note that this
	      command can not control the shapes an applications uses, for ex-
	      ample, to	indicate that it is busy.  The various contexts	are:

		   POSITION (top_left_corner)
		      used when	initially placing windows

		   TITLE (top_left_arrow)
		      used in a	window title-bar

		   DEFAULT (top_left_arrow)
		      used in windows that do not set their cursor

		   SYS (hand2)
		      used in one of the title-bar buttons

		   MOVE	(fleur)
		      used when	moving or resizing windows

		   RESIZE (sizing)
		      used when	moving or resizing windows

		   WAIT	(watch)
		      used  during  certain  fvwm commands (see	BusyCursor for
		      details).

		   MENU	(top_left_arrow)
		      used in menus

		   SELECT (crosshair)
		      used when	the user is required to	select a window

		   DESTROY (pirate)
		      used for DESTROY,	CLOSE, and DELETE commands

		   TOP (top_side)
		      used in the top side-bar of a window

		   RIGHT (right_side)
		      used in the right	side-bar of a window

		   BOTTOM (bottom_side)
		      used in the bottom side-bar of a window

		   LEFT	(left_side)
		      used in the left side-bar	of a window

		   TOP_LEFT (top_left_corner)
		      used in the top left corner of a window

		   TOP_RIGHT (top_right_corner)
		      used in the top right corner of a	window

		   BOTTOM_LEFT (bottom_left_corner)
		      used in the bottom left corner of	a window

		   BOTTOM_RIGHT	(bottom_right_corner)
		      used in the bottom right corner of a window

		   TOP_EDGE (top_side)
		      used at the top edge of the screen.

		   RIGHT_EDGE (right_side)
		      used at the right	edge of	the screen.

		   BOTTOM_EDGE (bottom_side)
		      used at the bottom edge of the screen.

		   LEFT_EDGE (left_side)
		      used at the left edge of the screen.

		   ROOT	(left_ptr)
		      used as the root cursor.

		   STROKE (plus)
		      used during a StrokeFunc command.

	      The defaults are shown in	parentheses above.  If you  ever  want
	      to  restore  the	default	 cursor	for a specific context you can
	      omit the second argument.

	      The second is either the numeric value of	the cursor as  defined
	      in  the  include	file X11/cursorfont.h or its name (without the
	      XC_ prefix). Alternatively, the xpm file name may	be  specified.
	      This  xpm	 file  should  contain	a pixmap using 3 colors	(None,
	      black, white) and	an optional hot-spot.  If no hot-spot  is  de-
	      fined,  the hot-spot is placed in	the center of the image.  Fur-
	      thermore the name	can be None (no	 cursor)  or  Tiny  (a	single
	      pixel as the cursor).  For example:
	      #	make the kill cursor be	XC_gumby (both forms work):
	      CursorStyle DESTROY 56
	      CursorStyle DESTROY gumby

	      CursorStyle TOP_LEFT topl.xpm
	      CursorStyle ROOT nice_arrow.xpm yellow black
	      The  optional  fg	 and  bg  arguments specify the	foreground and
	      background colors	for the	cursor,	defaulting to black and	white.

	      Here is an example pixmap	file nice_arrow.xpm:
	      /* XPM */
	      static char *nice_arrow_xpm[] = {
	      /* width height num_colors chars_per_pixel hot-spot */
	      "	   14	 14	   3		1	   1 1",
	      /* colors	*/
	      "	 c None",
	      ". c black",
	      "# c white",
	      /* pixels	*/
	      "...	     ",
	      ".##..	     ",
	      ".####..	     ",
	      "	.#####..     ",
	      "	.#######..   ",
	      "	 .########.. ",
	      "	 .##########.",
	      "	  .#######.. ",
	      "	  .######.   ",
	      "	   .######.  ",
	      "	   .###.###. ",
	      "	    .#.	.###.",
	      "	    .#.	 .#. ",
	      "	     .	  .  ",
	      };
	      The hot-spot coordinates are relative to zero, in	the above  ex-
	      ample, the hot-spot is in	the second row,	and second column.

       DefaultColors [foreground background]
	      DefaultColors  sets the default foreground and background	colors
	      used in miscellaneous windows created by fvwm,  for  example  in
	      the geometry feedback windows during a move or resize operation.
	      If you do	not want to change one color or	the other,  use	 -  as
	      its  color  name.	 To revert to the built-in default colors omit
	      both color names.	Note that the default colors are not  used  in
	      menus, window titles or icon titles.

       DefaultColorset [num]
	      DefaultColorset sets the colorset	used by	the windows controlled
	      by the DefaultColors command.  To	revert back to the DefaultCol-
	      ors colors use
	      DefaultColorset -1
	      or any variant of	the DefaultColors command.

       DefaultFont [fontname]
	      DefaultFont sets the default font	to font	fontname.  The default
	      font is used by fvwm whenever no other font has been  specified.
	      To  reset	the default font to the	built-in default, omit the ar-
	      gument.  The default font	is used	for menus, window titles, icon
	      titles as	well as	the geometry feedback windows during a move or
	      resize operation.	 To override the default font  in  a  specific
	      context,	use  the  Style	* Font,	Style *	IconFont, or MenuStyle
	      commands.

       DefaultIcon filename
	      sets the default icon which is used if a window has  neither  an
	      client-supplied icon nor an icon supplied	via the	Icon option of
	      the Style	command.

       DefaultLayers bottom put	top
	      changes  the  layers  that  are  used  for  the	StaysOnBottom,
	      StaysPut,	 StaysOnTop Style options.  Initially, the layers 2, 4
	      and 6 are	used.

       Deschedule [command_id]
	      Removes all commands that	were scheduled with the	id  command_id
	      with  the	 Schedule command from the list	of commands to be exe-
	      cuted unless they	were already executed.	If the	command_id  is
	      omitted,	the  value of the variable $[schedule.last] is used as
	      the id.

       Emulate Fvwm|Mwm|Win
	      This command is a	catch all for  how  miscellaneous  things  are
	      done  by fvwm. Right now this command affects where the move/re-
	      size  feedback  window  appears  and  how	 window	 placement  is
	      aborted. To have more Mwm- or Win-like behavior you can call Em-
	      ulate with Mwm or	Win as its argument.  With Mwm resize and move
	      feedback windows are in the center of the	screen,	instead	of the
	      upper left corner.  This also affects how	 manual	 placement  is
	      aborted.	See the	ManualPlacement	description.

       EscapeFunc
	      By  default the key sequence Ctrl-Alt-Escape allows for escaping
	      from a Wait pause	and from a locked  ModuleSynchronous  command.
	      The EscapeFunc command used with the Key command allows for con-
	      figuring this key	sequence.  An example:
	      Key Escape A MC -
	      Key Escape A  S EscapeFunc
	      replaces the Ctrl-Alt-Escape key sequence	with Shift-Escape  for
	      aborting a Wait pause and	ModuleSynchronous command.  EscapeFunc
	      used outside the Key command does	nothing.

       FakeClick [command value] ...
	      This command is mainly intended for debugging fvwm and no	 guar-
	      antees  are  made	that it	works for you.	FakeClick can simulate
	      mouse button press and release events and	pass them to  fvwm  or
	      the  applications.   The parameters are a	list of	commands which
	      consist of pairs of command tokens and integer values, The press
	      and  release commands are	followed by the	appropriate mouse but-
	      ton number and generate a	button press or	release	event  on  the
	      window below the pointer.	 The wait commands pauses fvwm for the
	      given number of milliseconds.  The modifiers  command  simulates
	      pressing	or  releasing  modifier	 keys.	 The values 1 to 5 are
	      mapped to	Mod1 to	Mod5 while 6, 7	and 8  are  mapped  to	Shift,
	      Lock  and	 Control.   The	modifier is set	for any	further	button
	      events.  To release a modifier key, use the corresponding	 nega-
	      tive  number.   The depth	command	determines to which window the
	      button events are	sent. With a depth of 1, all events go to  the
	      root  window, regardless of the pointer's	position.  With	2, the
	      event is passed to the top level window under the	pointer	 which
	      is  usually  the	frame  window. With 3, events go to the	client
	      window. Higher numbers go	to successive sub windows.   Zero  (0)
	      goes  to	the  smallest  window that contains the	pointer.  Note
	      that events propagate upward.
	       FakeClick depth 2 press 1 wait 250 release 1
	      This simulates a click with button 1 in the parent window	(depth
	      2)  with	a  delay of 250	milliseconds between the press and the
	      release.	Note: all command names	can be abbreviated with	 their
	      first letter.

       FakeKeypress [command value] ...
	      This  command is mainly intended for debugging fvwm and no guar-
	      antees are made that it works for	you.  FakeKeypress  can	 simu-
	      late  key	 press and release events and pass them	to fvwm	or ap-
	      plications.  The parameters are a	list of	commands which consist
	      of  pairs	 of  command tokens and	values.	 The press and release
	      commands are followed by a key name.  The	key name is a standard
	      X11  key name as defined in /usr/include/X11/keysymdef.h,	(with-
	      out    the    XK_	   prefix),    or    the    keysym    database
	      /usr/X11R6/lib/X11/XKeysymDB.   The  wait,  modifiers  and depth
	      commands are the same as those used by FakeClick.

	      Save all GVim sessions with: "Esc:w\n"
	      All (gvim) FakeKeypress press Escape \
				      press colon \
				      press w \
				      press Return
	      Save & exit all GVim sessions with: "Esc:wq\n"
	      All (gvim) FakeKeypress press Escape \
				      press colon \
				      press w \
				      press q \
				      press Return
	      Send A to	a specific window:
	      WindowId 0x3800002 FakeKeypress press A
	      Note: all	command	names can be abbreviated with their first let-
	      ter.

       GlobalOpts [options]
	      As announced in the past,	this command has been removed.	Please
	      replace the global options in your configuration file  according
	      to the following table:
	      GlobalOpts WindowShadeShrinks
		-->
	      Style * WindowShadeShrinks

	      GlobalOpts WindowShadeScrolls
		-->
	      Style * WindowShadeScrolls

	      GlobalOpts SmartPlacementIsReallySmart
		-->
	      Style * MinOverlapPlacement

	      GlobalOpts SmartPlacementIsNormal
		-->
	      Style * TileCascadePlacement

	      GlobalOpts ClickToFocusDoesntPassClick
		-->
	      Style * ClickToFocusPassesClickOff

	      GlobalOpts ClickToFocusPassesClick
		-->
	      Style * ClickToFocusPassesClick

	      GlobalOpts ClickToFocusDoesntRaise
		-->
	      Style * ClickToFocusRaisesOff

	      GlobalOpts ClickToFocusRaises
		-->
	      Style * ClickToFocusRaises

	      GlobalOpts MouseFocusClickDoesntRaise
		-->
	      Style * MouseFocusClickRaisesOff

	      GlobalOpts MouseFocusClickRaises
		-->
	      Style * MouseFocusClickRaises

	      GlobalOpts NoStipledTitles
		-->
	      Style * !StippledTitle

	      GlobalOpts StipledTitles
		-->
	      Style * StippledTitle

	      GlobalOpts CaptureHonorsStartsOnPage
		-->
	      Style * CaptureHonorsStartsOnPage

	      GlobalOpts CaptureIgnoresStartsOnPage
		-->
	      Style * CaptureIgnoresStartsOnPage

	      GlobalOpts RecaptureHonorsStartsOnPage
		-->
	      Style * RecaptureHonorsStartsOnPage

	      GlobalOpts RecaptureIgnoresStartsOnPage
		-->
	      Style * RecaptureIgnoresStartsOnPage

	      GlobalOpts ActivePlacementHonorsStartsOnPage
		-->
	      Style * ManualPlacementHonorsStartsOnPage

	      GlobalOpts ActivePlacementIgnoresStartsOnPage
		-->
	      Style * ManualPlacementIgnoresStartsOnPage

	      GlobalOpts RaiseOverNativeWindows
		-->
	      BugOpts RaiseOverNativeWindows on

	      GlobalOpts IgnoreNativeWindows
		-->
	      BugOpts RaiseOverNativeWindows off

       HilightColor textcolor backgroundcolor
	      This  command  is	obsoleted by the Style options HilightFore and
	      HilightBack.  Please use
	      Style * HilightFore textcolor, \
		      HilightBack backgroundcolor
	      instead.

       HilightColorset [num]
	      This command is obsoleted	by the Style  option  HilightColorset.
	      Please use
	      Style * HilightColorset num
	      instead.

       IconFont	[fontname]
	      This  command is obsoleted by the	Style option IconFont.	Please
	      use
	      Style * IconFont fontname
	      instead.

       IconPath	path
	      This command is obsolete.	 Please	use ImagePath instead.

       ImagePath path
	      Specifies	a colon	separated list	of  directories	 in  which  to
	      search  for images (both monochrome and pixmap).	To find	an im-
	      age given	by a relative pathname,	fvwm looks into	each directory
	      listed in	turn, and uses the first file found.

	      If a directory is	given in the form "/some/dir;.ext", this means
	      all images in this directory  have  the  extension  ".ext"  that
	      should be	forced.	 The original image name (that may contain an-
	      other extension or no extension at all) is not  probed,  instead
	      ".ext"  is  added	 or  replaces the original extension.  This is
	      useful, for example, if a	user has some image  directories  with
	      ".xpm"  images  and other	image directories with the same	names,
	      but ".png" images.

	      The path may contain environment variables  such	as  $HOME  (or
	      ${HOME}).	  Further, a '+' in the	path is	expanded to the	previ-
	      ous value	of the path, allowing appending	or prepending  to  the
	      path easily.

	      For example:
	      ImagePath	$HOME/icons:+:/usr/include/X11/bitmaps
	      Note:  if	 the FvwmM4 module is used to parse your config	files,
	      then m4 may want to mangle the word "include"  which  frequently
	      shows up in the ImagePath	command.  To fix this one may add
	      undefine(`include')
	      prior  to	 the  ImagePath	command, or better: use	the -m4-prefix
	      option to	force all m4 directives	to have	a prefix of "m4_" (see
	      the FvwmM4 man page).

       LocalePath path
	      Specifies	 a  colon  separated list of "locale path" in which to
	      search for string	translations. A	locale path is constituted  by
	      a	 directory  path  and  a  text domain separated	by a semicolon
	      (';'). As	an example the default locale path is:
	      /install_prefix/share/locale;fvwm
	      where install_prefix is the fvwm	installation  directory.  With
	      such a locale path translations are searched for in
	      /install_prefix/share/locale/lang/LC_MESSAGES/fvwm.mo
	      where  lang  depends on the locale. If no	directory is given the
	      default directory	path is	assumed. If no text domain  is	given,
	      fvwm is assumed. Without argument	the default locale path	is re-
	      stored.

	      As for the ImagePath command, path may contain environment vari-
	      ables and	a '+' to append	or prepend the locale path easily.

	      For example, the fvwm-themes package uses
	      LocalePath ";fvwm-themes:+"
	      to add locale catalogs.

	      The default fvwm catalog contains	a few strings used by the fvwm
	      executable itself	(Desk and Geometry) and	strings	used  in  some
	      default  configuration files and FvwmForm	configuration. You can
	      take a look at the po/ subdirectory of the fvwm  source  to  get
	      the  list	 of the	strings	with a possible	translation in various
	      languages. At present, very few languages	are supported.

	      The main use of locale catalogs is via the "$[gt.string]"	param-
	      eter:
	      DestroyMenu MenuFvwmWindowOps
	      AddToMenu	  MenuFvwmWindowOps "$[gt.Window Ops]" Title
	      +	"$[gt.&Move]"		   Move
	      +	"$[gt.&Resize]"		   Resize
	      +	"$[gt.R&aise]"		   Raise
	      +	"$[gt.&Lower]"		   Lower
	      +	"$[gt.(De)&Iconify]"	   Iconify
	      +	"$[gt.(Un)&Stick]"	   Stick
	      +	"$[gt.(Un)Ma&ximize]"	   Maximize
	      +	"" Nop
	      +	"$[gt.&Close]"		   Close
	      +	"$[gt.&Destroy]"	   Destroy
	      gives  a menu in the locale languages if translations are	avail-
	      able.

	      Note that	the FvwmTaskBar	module has its own  catalog  and  that
	      the  FvwmScript  module  has  a  set of special instructions for
	      string translation. It is	out of the scope of this discussion to
	      explain  how  to	build locale catalogs. Please refer to the GNU
	      gettext documentation.

       PixmapPath path
	      This command is obsolete.	Please use ImagePath instead.

       PrintInfo subject [verbose]
	      Print information	on subject on stderr.  An optional integer ar-
	      gument  verbose defines the level	of information which is	given.
	      The current valid	subjects are:

	      Colors which prints information about the	colors used  by	 fvwm.
	      This useful on screens which can only display 256	(or less) col-
	      ors at once.  If verbose is one or greater the palette  used  by
	      fvwm  is	printed.  If you have a	limited	color palette, and you
	      run out of colors, this command might be helpful.

	      Locale which prints information on your  locale  and  the	 fonts
	      that fvwm	used.  verbose can be 1	or 2.

	      nls  which  prints  information on the locale catalogs that fvwm
	      used

	      style which prints information on	fvwm styles.  verbose  can  be
	      1.

       Repeat When  the	 Repeat	 command is invoked, the last command that was
	      executed by fvwm is executed again.  This	happens	regardless  of
	      whether  it was triggered	by user	interaction, a module or by an
	      X	event.	Commands that are executed  from  a  function  defined
	      with the Function	command, from the Read or PipeRead commands or
	      by a menu	are not	repeated.  Instead, the	function, menu	or the
	      Read  or	PipeRead command is executed again.

       Schedule	[Periodic] delay_ms [command_id] command
	      The command is executed after about delay_ms milliseconds.  This
	      may be useful in some tricky setups.  The	command	is executed in
	      the  same	 context  window as the	Schedule command.  An optional
	      integer argument command_id may be given in decimal, hexadecimal
	      or  octal	 format.  This id can be used with the Deschedule com-
	      mand to remove the scheduled command before it is	executed.   If
	      no  id is	given, fvwm uses negative id numbers, starting with -1
	      and decreasing by	one with each use  of  the  Schedule  command.
	      Note  that  the  Schedule	 command and its arguments undergo the
	      usual command line expansion, and, when command is finally  exe-
	      cuted,  it  is expanded again.  It may therefore be necessary to
	      quote the	parts of the command that must not be expanded twice.

	      Note:  A window's	id as it is returned with $[w.id] can be  used
	      as the command_id.  Example:
	      Current Schedule 1000 $[w.id] WindowShade

	      The Schedule command also	supports the optional keyword Periodic
	      which indicates that the command should be  executed  every  de-
	      lay_ms.  Example:
	      Schedule Periodic	10000 PipeRead '[ -N "$MAIL" ] && echo \
		   Echo	You have mail'
	      Use the Deschedule command to stop periodic commands.

       State state [bool]
	      Sets,  clears or toggles one of the 32 user defined states which
	      are associated with each window.	The state is a number  ranging
	      from  0 to 31.  The states have no meaning in fvwm, but they can
	      be checked in conditional	commands like Next with	the State con-
	      dition.	The  optional  argument	 bool  is  a boolean argument.
	      "True" sets the given state, while  "False"  clears  it.	 Using
	      "toggle"	switches  to the opposite state.  If the bool argument
	      is not given, the	state is toggled.

       WindowFont [fontname]
	      This command is obsoleted	by the Style option Font.  Please use
	      Style * Font fontname
	      instead.

       WindowList [(conditions)] [position] [options] [double-click-action]
	      Generates	a pop-up menu (and pops	it up) in which	the title  and
	      geometry	of  each  of  the windows currently on the desktop are
	      shown.

	      The format of the	 geometry  part	 is:  desk(layer):  x-geometry
	      sticky,  where  desk and layer are the corresponding numbers and
	      sticky is	empty or a capital S.  The geometry of iconified  win-
	      dows is shown in parentheses.  Selecting an item from the	window
	      list pop-up menu causes the  interpreted	function  "WindowList-
	      Func"  to	 be run	with the window	id of that window passed in as
	      $0. The default "WindowListFunc" looks like this:
	      AddToFunc	WindowListFunc
	      +	I Iconify off
	      +	I FlipFocus
	      +	I Raise
	      +	I WarpToWindow 5p 5p
	      You can destroy the built-in "WindowListFunc"  and  create  your
	      own if these defaults do not suit	you.

	      The  window  list	menu uses the "WindowList" menu	style if it is
	      defined (see MenuStyle command).	 Otherwise  the	 default  menu
	      style  is	used.  To switch back to the default menu style, issue
	      the command
	      DestroyMenuStyle WindowList
	      Example:
	      MenuStyle	WindowList SelectOnRelease Meta_L
	      The conditions can be used to exclude certain windows  from  the
	      window  list.  Please  refer to the Current command for details.
	      Only windows that	match the given	conditions  are	 displayed  in
	      the  window  list.   The	options	below work vice	versa: windows
	      that would otherwise not be included in the window list  can  be
	      selected with them.  The conditions always override the options.

	      The  position  arguments	are the	same as	for Menu.  The command
	      double-click-action is invoked if	 the  user  double-clicks  (or
	      hits  the	 key rapidly twice if the menu is bound	to a key) when
	      bringing the  window  list.   The	 double-click-action  must  be
	      quoted if	it consists of more than one word.

	      The  double-click-action is useful to define a default window if
	      you have bound the window	list to	a key (or button) like this:
	      #	Here we	call an	existing function, but
	      #	it may be different.  See the default
	      #	WindowListFunc definition earlier in this
	      #	man page.
	      AddToFunc	SwitchToWindow
	      +	I WindowListFunc

	      Key Tab A	M WindowList "Prev SwitchToWindow"
	      Hitting Alt-Tab once it brings up	the window list, if you	hit it
	      twice  the focus is flipped between the current and the last fo-
	      cused window.  With the proper SelectOnRelease menu  style  (see
	      example  above)  a window	is selected as soon as you release the
	      Alt key.

	      The options passed to WindowList are separated by	commas and can
	      be  Geometry  /  NoGeometry / NoGeometryWithInfo,	NoDeskNum, No-
	      Layer,   NoNumInDeskTitle,   NoCurrentDeskTitle,	 MaxLabelWidth
	      width,  TitleForAllDesks,	 Function funcname, Desk desknum, Cur-
	      rentDesk,	NoIcons	/ Icons	/ OnlyIcons, NoNormal /	Normal / Only-
	      Normal,  NoSticky	 /  Sticky / OnlySticky, NoStickyAcrossPages /
	      StickyAcrossPages	/ OnlyStickyAcrossPages, NoStickyAcrossDesks /
	      StickyAcrossDesks	/ OnlyStickyAcrossDesks, NoOnTop / OnTop / On-
	      lyOnTop, NoOnBottom / OnBottom  /	 OnlyOnBottom,	Layer  m  [n],
	      UseListSkip  / OnlyListSkip, NoDeskSort, ReverseOrder, CurrentA-
	      tEnd, IconifiedAtEnd, UseIconName, Alphabetic  /	NotAlphabetic,
	      SortByResource, SortByClass, NoHotkeys, SelectOnRelease.

	      (Note - normal means not iconic, sticky, or on top)

	      With the SortByResource option windows are alphabetically	sorted
	      first by resource	class, then by resource	name and then by  win-
	      dow  name	 (or icon name if UseIconName is specified).  Reverse-
	      Order also works in the expected manner.

	      With the SortByClass option windows are sorted  just  like  with
	      SortByResource, but the resource name is not taken into account,
	      only the resource	class.

	      The SelectOnRelease option works exactly like the	MenuStyle  op-
	      tion  with  the  same  name, but overrides the option given in a
	      menu style.  By default, this option is set to the left Alt key.
	      To switch	it off,	use SelectOnRelease without a key name.

	      If  you  pass  in	a function via Function	funcname, it is	called
	      within a window context of the selected window:
	      AddToFunc	IFunc I	Iconify	toggle
	      WindowList Function IFunc, NoSticky, \
		CurrentDesk, NoIcons
	      If you use the Layer m [n] option, only windows  in  layers  be-
	      tween m and n are	displayed. n defaults to m.  With the Reverse-
	      Order option the order of	the windows in the list	is reversed.

	      With the CurrentAtEnd option the currently  focused  window  (if
	      any)  is	shown  at  the bottom of the list.  This is mostly in-
	      tended for simulating the	Alt-Tab	behavior in another GUI.

	      IconifiedAtEnd makes iconified windows be	moved to  the  end  of
	      the list.	 This is also from another GUI.

	      The  NoGeometry option causes fvwm to not	display	the geometries
	      as well as the separators	which indicate the different desktops.
	      NoGeometryWithInfo  removes the geometries, but keep the desktop
	      information and indicates	iconic windows.	 NoDeskNum causes fvwm
	      to  not display the desktop number in the	geometry or before the
	      window title with	the NoGeometryWithInfo option.	NoNumInDeskTi-
	      tle  is  only useful if a	desktop	name is	defined	with the Desk-
	      topName command. It causes fvwm to not display the desktop  num-
	      ber  before  the	desktop	name.  By default, the WindowList menu
	      have a title which indicates the current desk  or	 the  selected
	      desktop  if  the	Desk condition is used.	The NoCurrentDeskTitle
	      option removes this title.  TitleForAllDesks causes fvwm to  add
	      a	 menu title with the desk name and/or number before each group
	      of windows on the	same desk.  With NoLayer,  the	layer  of  the
	      window  is  not  diplayed.   The options ShowPage, ShowPageX and
	      ShowPageY	enable displaying the page of the window rounded  mul-
	      tiples  of the display size.  With ShowScreen, the window's Xin-
	      erama screen number is displayed.

	      The MaxLabelWidth	option takes the number	of characters to print
	      as  its argument.	 No more than that many	characters of the win-
	      dow name are visible.

	      If you wanted to use the WindowList  as  an  icon	 manager,  you
	      could invoke the following:
	      WindowList OnlyIcons, Sticky, OnTop, Geometry
	      (Note  - the Only	options	essentially wipe out all other ones...
	      but the OnlyListSkip option which	just causes WindowList to only
	      consider the windows with	WindowListSkip style.)

       XSync  When  XSync is called, the X function with the same name is used
	      to send all pending X requests to	the server.  This  command  is
	      intended for debugging only.

       XSynchronize [bool]
	      The XSynchronize command controls	whether	X requests are sent to
	      the X server immediately or not.	Normally, requests are sent in
	      larger  batches  to save unnecessary communication.  To send re-
	      quests immediately, use "True" as	the argument, to disable  this
	      use  "False"  or	to toggle between both methods use "Toggle" or
	      omit the bool argument.  Fvwm defaults to	synchronized  requests
	      when  started with the --debug option.  This command is intended
	      for debugging only.

       +      Used to continue adding to the last specified decor, function or
	      menu.  See  the  discussion  for	AddToDecor, AddToFunc, and Ad-
	      dToMenu.

   COMMANDS AFFECTING WINDOW MOVEMENT AND PLACEMENT
       AnimatedMove x y	[Warp]
	      Move a window in an animated fashion.  Similar to	 Move  command
	      below. The options are the same, except they are required, since
	      it doesn't make sense to have a user move	 the  window  interac-
	      tively  and animatedly.  If the optional argument	Warp is	speci-
	      fied the pointer is warped with the window.

       HideGeometryWindow [Never | Move	| Resize]
	      Hides the	position or size window	that is	usually	shown  when  a
	      window is	moved or resized interactively.	 To switch it off only
	      for move or resize operations the	optional parameters  Move  and
	      Resize  can  be  used respectively.  To switch both on again use
	      the Never	option.

       Layer [arg1 arg2] | [default]
	      Puts the current window in a new layer.  If  arg1	 is  non  zero
	      then  the	 next layer is the current layer number	plus arg1.  If
	      arg1 is zero then	the new	layer is arg2.

	      As a special case, default puts the window in its	default	layer,
	      i.e.  the	 layer it was initially	in.  The same happens if no or
	      invalid arguments	are specified.

       Lower  Allows the user to lower a window.  Note that this lowers	a win-
	      dow  only	 in its	layer.	To bring a window to the absolute bot-
	      tom, use
	      AddToFunc	lower-to-bottom
	       + I Layer 0 0
	       + I Lower

       Move [[screen screen] [w|m]x[p] [w|m]y[p] [Warp]] | [pointer]
	      Allows the user to move a	window.	 If called from	somewhere in a
	      window or	its border, then that window is	moved.	If called from
	      the root window then the user is allowed to  select  the	target
	      window.

	      If  the  literal	option Screen followed by a screen argument is
	      specified, the coordinates are interpreted as  relative  to  the
	      given  screen.   The width and height of the screen are used for
	      the calculations instead of the display dimensions.  The	screen
	      as  interpreted as in the	MoveToScreen command.  If the optional
	      argument Warp is specified the pointer is	warped with  the  win-
	      dow.  If the single argument pointer is given, the top left cor-
	      ner of the window	is moved to the	pointer	position before	start-
	      ing  the	operation; this	is mainly intended for internal	use by
	      modules like FvwmPager.

	      The operation can	be aborted with	Escape or any mouse button not
	      set  to  place  the  window. By default mouse button 2 is	set to
	      cancel the move operation. To change this	you may	use the	 Mouse
	      command  with  special context 'P' for Placement (see Mouse com-
	      mand for details).

	      The window condition PlacedByButton can be used to  check	 if  a
	      specific	button	was  pressed  to place the window (see Current
	      command).

	      If the optional arguments	x and y	are provided, then the	window
	      is  moved	 immediately  without user interaction.	 Each argument
	      can specify an absolute or relative  position  from  either  the
	      left/top or right/bottom of the screen.  By default, the numeric
	      value given  is  interpreted  as	a  percentage  of  the	screen
	      width/height,  but  a trailing 'p' changes the interpretation to
	      mean pixels.  To move the	window relative	to its	current	 posi-
	      tion,  add  the  'w' (for	"window") prefix before	the x and/or y
	      value.  To move the window to a position relative	to the current
	      location	of  the	pointer, add the 'm' (for "mouse") prefix.  To
	      leave either coordinate unchanged, "keep"	can  be	 specified  in
	      place of x or y.

	      Simple Examples:
	      #	Interactive move
	      Mouse 1 T	A Move
	      #	Move window to top left	is at (10%,10%)
	      Mouse 2 T	A Move 10 10
	      #	Move top left to (10pixels,10pixels)
	      Mouse 3 T	A Move 10p 10p
	      More  complex  examples  (these  can be bound as actions to key-
	      strokes, etc.; only the command is shown,	though):
	      #	Move window so bottom right is at bottom
	      #	right of screen
	      Move -0 -0

	      #	Move window so top left	corner is 10 pixels
	      #	off the	top left screen	edge
	      Move +-10	+-10

	      #	Move window 5% to the right, and to the
	      #	middle vertically
	      Move w+5 50

	      #	Move window up 10 pixels, and so left edge
	      #	is at x=40 pixels
	      Move 40p w-10p

	      #	Move window to the mouse pointer location
	      Move m+0 m+0
	      See also the AnimatedMove	command	above.

       MoveToDesk [prev	| arg1 [arg2] [min max]]
	      Moves the	selected window	to another desktop.  The arguments are
	      the  same	 as  for the GotoDesk command.	Without	any arguments,
	      the window is moved to the current desk.	MoveToDesk  is	a  re-
	      placement	 for  the old WindowsDesk command, which can no	longer
	      be used.

       MoveThreshold [pixels]
	      When the user presses a mouse button upon	an object  fvwm	 waits
	      to  see  if the action is	a click	or a drag.  If the mouse moves
	      by more than pixels pixels it is assumed to be a drag.

	      Previous versions	of fvwm	hardwired pixels to 3,	which  is  now
	      the default value.  If pixels is negative	or omitted the default
	      value (which might be increased when 16000x9000  pixel  displays
	      become affordable) is restored.

       MoveToPage [options] [x[p|w] y[p|w]] | [prev]
	      Moves the	selected window	to another page	(x,y).	The upper left
	      page is (0,0), the upper right is	(M,0), where  M	 is  one  less
	      than  the	 current  number  of horizontal	pages specified	in the
	      DeskTopSize command.  Similarly the lower	left  page  is	(0,N),
	      and  the lower right page	is (M,N).  Negative page numbers refer
	      to pages from the	rightmost/lowest page.	If x  and  y  are  not
	      given,  the  window  is moved to the current page	(a window that
	      has the focus but	is off-screen can  be  retrieved  with	this).
	      Moving  windows  to  a  page relative to the current page	can be
	      achieved by adding a trailing 'p'	after any  or  both  numerical
	      arguments.  To move the window relative to its current location,
	      add a trailing 'w'.  To move a window to the previous  page  use
	      prev as the single argument.

	      Windows are usually not moved beyond desk	boundaries.

	      Possible	options	 are wrapx and wrapy to	wrap around the	x or y
	      coordinate when the window is moved beyond  the  border  of  the
	      desktop. For example, with wrapx,	when the window	moves past the
	      right edge of the	desktop, it reappears on the left  edge.   The
	      options  nodesklimitx  and nodesklimity allow moving windows be-
	      yond the desk boundaries in x and	 y  direction  (disabling  the
	      wrapx and	wrapy options).

	      Examples:
	      #	Move window to page (2,3)
	      MoveToPage 2 3

	      #	Move window to lowest and rightmost page
	      MoveToPage -1 -1

	      #	Move window to last page visited
	      MoveToPage prev

	      #	Move window two	pages to the right and one
	      #	page up, wrap at desk boundaries
	      MoveToPage wrapx wrapy +2p -1p

       MoveToScreen [screen]
	      Moves  the  selected  window  to	another	 Xinerama screen.  The
	      screen argument can be 'p' for the primary screen, 'c'  for  the
	      current  screen  (containing  the	 mouse	pointer),  'g' for the
	      global screen or the screen number itself	(counting from zero).

       OpaqueMoveSize [percentage]
	      Tells fvwm the maximum size  window  with	 which	opaque	window
	      movement should be used.	The percentage is percent of the total
	      screen area (may be greater than 100).  With
	      OpaqueMoveSize 0
	      all windows are moved using the traditional rubber-band outline.
	      With
	      OpaqueMoveSize unlimited
	      or  if  a	 negative percentage is	given all windows are moved as
	      solid windows.  The default is
	      OpaqueMoveSize 5
	      which allows small windows to be moved in	an opaque  manner  but
	      large windows are	moved as rubber-bands.	If percentage is omit-
	      ted or invalid the default value is set.	To resize  windows  in
	      an  opaque manner	you can	use the	ResizeOpaque style.  See Style
	      command.

       PlaceAgain [Anim] [Icon]
	      Causes the current window's position to be re-computed using the
	      initial window placement logic.  The window is moved to where it
	      would have been if it were a new window that had just  appeared.
	      Most  useful with	Smart or Clever	(ReallySmart) placement.  With
	      the optional argument Anim an animated move is used to place the
	      window  in  its  new position.  With the additional option Icon,
	      the icon is placed again instead.

       Raise  Allows the user to raise a window. Note that this	raises a  win-
	      dow  only	 in  its layer.	To bring a window to the absolute top,
	      use
	      AddToFunc	raise-to-top
	       + I Layer 0 ontop
	       + I Raise
	      where ontop is the highest layer used in your setup.

       RaiseLower
	      Alternately raises and lowers a window.  The window is raised if
	      it is obscured by	any window (except for its own transients when
	      RaiseTransient style is used; see	Style command) otherwise it is
	      lowered.

       Resize	[[frame]   [direction	dir  [warptoborder]]  [fixeddirection]
       [w]width[p|c] [w]height[p|c]] | [bottomright | br x y]
	      Allows for resizing a window.  If	called	from  somewhere	 in  a
	      window  or  its  border, then that window	is resized.  If	called
	      from the root window then	the user is allowed to select the tar-
	      get window.

	      The  operation  can  be  aborted	with Escape or by pressing any
	      mouse button (except button 1 which confirms it).

	      If the optional arguments	width and height  are  provided,  then
	      the  window  is  resized	so  that  its  dimensions are width by
	      height.  The units of width and  height  are  percent-of-screen,
	      unless  a	 letter	'p' is appended	to one or both coordinates, in
	      which case the location is specified in pixels.  With a 'c' suf-
	      fix  the unit defined by the client application (hence the c) is
	      used.  So	you can	say
	      Resize 80c 24c
	      to make a	terminal window	just big enough	for 80x24 characters.

	      If the width or height is	prefixed with the letter 'w' the  size
	      is  not taken as an absolute value but added to the current size
	      of the window.  Example:
	      #	Enlarge	window by one line
	      Resize keep w+1c
	      Both, width and height can be negative.  In this	case  the  new
	      size  is the screen size minus the given value.  If either value
	      is "keep", the corresponding dimension of	the window is left un-
	      touched.	The new	size is	the size of the	client window, thus
	      Resize 100 100
	      may  make	 the  window  bigger than the screen.  To base the new
	      size on the size of the whole fvwm window, add the frame	option
	      after  the  command.   The options fixeddirection, direction and
	      warptoborder are only used in interactive	move operations.  With
	      fixeddirection  the  same	 border	 is  moved even	if the pointer
	      moves past the opposite border.  The direction  option  must  be
	      followed	by  a  direction  name such as "NorthWest", "South" or
	      "East" (you get the idea).   Resizing  is	 started  immediately,
	      even if the pointer is not on a border.  The warptoborder	option
	      changes the behaviour  of	 the  direction	 option	 so  that  the
	      pointer  is  automatically warped	to the border in the given di-
	      rection before starting to resize.  Also,	if resizing is started
	      by  clicking  on the window border, the pointer is warped	to the
	      outer edge of the	border.
	      AddToFunc	ResizeSE I Resize Direction SE
	      Mouse 3 A	M ResizeSE

	      An alternate syntax is used if the  keyword  bottomright	or  in
	      short  br	follows	the command name.  In this case, the arguments
	      x	and y specify the desired position of the bottom right	corner
	      of  the  window.	 They are interpreted exactly like the x and y
	      arguments	of the Move command.  Actually,	any of the options ac-
	      cepted by	the Move command can be	used.

       ResizeMaximize [resize-arguments]
	      Combines the effects of Resize and Maximize in a single command.
	      When used	on a maximized window, the window is  resized  and  is
	      still in the maximized state afterwards.	When used on an	unmax-
	      imized window, the window	is resized and put into	the  maximized
	      state  afterwards.   This	 is useful if the user wants to	resize
	      the window temporarily and then return to	the original geometry.
	      The resize-arguments are the same	as for the Resize command.

       ResizeMove resize-arguments move-arguments
	      This  command does the same as the Resize	and Move commands, but
	      in a single call which is	less visually disturbing. The  resize-
	      arguments	 are exactly the same arguments	as for the Resize com-
	      mand and the move-arguments are exactly the  same	 arguments  as
	      for the Move command except the pointer option which is not sup-
	      ported by	the ResizeMove command.

	      Examples:
	      #	Move window to top left	corner and cover
	      #	most of	the screen
	      ResizeMove -10p -20p 0 0

	      #	Grow the focused window	towards	the top	of screen
	      Current Resize keep w+$[w.y]p keep 0

	      Note:  Fvwm may not be able to parse the command properly	if the
	      option bottomright of the	Resize command is used.

       ResizeMoveMaximize resize-arguments move-arguments
	      Combines the effects of ResizeMove and Maximize in a single com-
	      mand.  When used on a maximized window, the  window  is  resized
	      and  moved and is	still in the maximized state afterwards.  When
	      used on an unmaximized window, the window	 is  resized  and  put
	      into the maximized state afterwards.  This is useful if the user
	      wants to resize the window temporarily and then  return  to  the
	      original	geometry.  The resize-arguments	and move-arguments are
	      the same as for the ResizeMove command.

       RestackTransients
	      This command regroups the	transients of a	window close to	it  in
	      the  stacking  order  as if the window had just been lowered and
	      then raised.  The	position of the	window itself is not  altered.
	      Only  windows that use either the	RaiseTransient	or  LowerTran-
	      sient style are affected at all.	When RestackTransients is used
	      on  a  transient window with the StackTransientParent style set,
	      it is redirected to the parent window.

       SetAnimation milliseconds-delay [fractions-to-move-list]
	      Sets the time between frames and the list	of fractional  offsets
	      to  customize the	animated moves of the AnimatedMove command and
	      the animation of menus (if the menu style	is  set	 to  animated;
	      see  MenuStyle command).	If the fractions-to-move-list is omit-
	      ted, only	the time between frames	is altered.  The fractions-to-
	      move-list	 specifies how far the window should be	offset at each
	      successive frame as a fraction of	 the  difference  between  the
	      starting location	and the	ending location.  e.g.:
	      SetAnimation 10 -.01 0 .01 .03 .08 .18 .3	\
		.45 .6 .75 .85 .90 .94 .97 .99 1.0
	      Sets  the	 delay between frames to 10 milliseconds, and sets the
	      positions	of the 16 frames of the	 animation  motion.   Negative
	      values  are  allowed,  and in particular can be used to make the
	      motion appear more cartoonish, by	briefly	moving slightly	in the
	      opposite	direction  of the main motion.	The above settings are
	      the default.

       SnapAttraction [proximity [behavior] [Screen]]
	      If during	an interactive move the	window or  icon	 comes	within
	      proximity	 pixels	 of another the	window or icon,	it is moved to
	      make the borders adjoin.	The default of 0 means that  no	 snap-
	      ping  happens.  Calling this command without arguments turns off
	      snap attraction and restores the default behavior.  Please refer
	      also to the SnapGrid command.

	      The  behavior  argument is optional and may be set to one	of the
	      four following values:  With All both icons and windows snap  to
	      other  windows and other icons.  SameType	lets snap windows only
	      to other windows and icons only to  other	 icons.	 With  Windows
	      windows  snap  only  to other windows.  Icons do not snap. Simi-
	      larly with Icons icons snap to only other	icons and  windows  do
	      not snap.

	      If  the  behavior	 option	is not given, the snapping behavior is
	      not changed.  The	default	behavior is All.

	      If the Screen option is present windows and or icons are snapped
	      to the screen edges too.

       SnapGrid	[x-grid-size y-grid-size]
	      During  an  interactive move a window or icon is positioned such
	      that its location	(top left corner) is coincident	with the near-
	      est  grid	point. The default x-grid-size and y-grid-size setting
	      are both 1, which	is effectively no grid	all.   An  interactive
	      move with	both SnapGrid and SnapAttraction results in the	window
	      being moved to be	adjacent to  the  nearest  window  border  (if
	      within  snap  proximity)	or grid	position.  In other words, the
	      window moves the shortest	 distance  possible  to	 satisfy  both
	      SnapGrid	and SnapAttraction.  Note that the x and y coordinates
	      are not coupled.	For example, a window may snap to another win-
	      dow  on the x axis while snapping	to a grid point	on the y axis.
	      Calling this command without arguments  reinstates  the  default
	      settings.

       WindowsDesk arg1	[arg2]
	      Moves the	selected window	to another desktop.

	      This  command  has  been	removed	 and must be replaced by Move-
	      ToDesk, the arguments for	which are the same as for the GotoDesk
	      command.	 Important  note: You cannot simply change the name of
	      the command: the syntax has changed.  If you used
	      WindowsDesk n
	      to move a	window to desk n, you have to change it	to
	      MoveToDesk 0 n

       XorPixmap [pixmap]
	      Selects the pixmap with which bits are xor'ed when doing rubber-
	      band  window  moving  or	resizing.  This	has a better chance of
	      making the rubber-band visible if	XorValue does  not  give  good
	      results.	 An example pixmap resize.rainbow.xpm is provided with
	      the icon distribution.  To turn the XorPixmap off	again use  the
	      XorValue command or omit the pixmap argument.

       XorValue	[number]
	      Changes  the value with which bits are xor'ed when doing rubber-
	      band window moving or resizing.  Valid values range from zero to
	      the  maximum  value  of an unsigned long integer on your system.
	      Setting this value is a trial-and-error  process.	  The  default
	      value  0	tries  to  find	 a value that gives a good contrast to
	      black and	white.	The default value is used if the given	number
	      is omitted or invalid.

   COMMANDS FOR	FOCUS AND MOUSE	MOVEMENT
       CursorMove horizontal[p]	vertical[p]
	      Moves  the  mouse	pointer	by horizontal pages in the X direction
	      and vertical pages in the	Y direction.  Either or	 both  entries
	      may  be  negative.  Both	horizontal and vertical	values are ex-
	      pressed in percent of pages, so
	      CursorMove 100 100
	      means to move down and right by one full page.
	      CursorMove 50 25
	      means to move right half a page and down a quarter  of  a	 page.
	      Alternatively,  the  distance  can be specified in pixels	by ap-
	      pending a	'p' to the horizontal and/or  vertical	specification.
	      For example
	      CursorMove -10p -10p
	      means  move  ten	pixels up and ten pixels left.	The CursorMove
	      function should not be called from pop-up	menus.

       FlipFocus  [NoWarp]
	      Executes a Focus command as if the user had used the pointer  to
	      select  the  window.  This  command alters the order of the Win-
	      dowList in the same way as clicking in a window to  focus,  i.e.
	      the  target  window is removed from the WindowList and placed at
	      the start. This command is recommended for use with  the	Direc-
	      tion command and in the function invoked from WindowList.

       Focus  [NoWarp]
	      Sets  the	 keyboard focus	to the selected	window.	 If the	NoWarp
	      argument is given, this is all it	does.  Otherwise it also moves
	      the  viewport  or	 window	 as needed to make the selected	window
	      visible. This command does not automatically raise  the  window.
	      Does  not	 warp  the pointer into	the selected window (see Warp-
	      ToWindow function).  Does	not de-iconify.	 This command does not
	      alter  the  order	 of  the WindowList, it	rotates	the WindowList
	      around so	that the target	window is at the start.

	      When the NoWarp argument is given,  Focus	 cannot	 transfer  the
	      keyboard focus to	windows	on other desks.

	      To  raise	 and/or	warp a pointer to a window together with Focus
	      or FlipFocus, use	a function, like:
	      AddToFunc	SelectWindow
	      +	I Focus
	      +	I Iconify false
	      +	I Raise
	      +	I WarpToWindow 50 8p

       WarpToWindow x[p] y[p]
	      Warps the	cursor to the associated window.  The parameters x and
	      y	 default  to  percentage  of window down and in	from the upper
	      left hand	corner (or number of pixels down and in	if 'p' is  ap-
	      pended  to  the  numbers).  If a number is negative the opposite
	      edge is used and the direction  reversed.	  This	command	 works
	      also  with  windows  that	are not	managed	by fvwm.  In this case
	      fvwm does	not bring the window onto the screen if	it is not vis-
	      ible.   For  example  it	is possible to warp the	pointer	to the
	      center of	the root window	on screen 1:
	      WindowId root 1 WarpToWindow 50 50

   COMMANDS CONTROLLING	WINDOW STATE
       Close  If the window accepts the	delete window protocol	a  message  is
	      sent  to	the  window asking it to gracefully remove itself.  If
	      the window does not understand the delete	window	protocol  then
	      the  window  is destroyed	as with	the Destroy command.  Note: if
	      the window accepts the delete window protocol but	does not close
	      itself in	response, the window is	not deleted.

       Delete Sends  a	message	to a window asking that	it remove itself, fre-
	      quently causing the application to exit.

       Destroy
	      Destroys an application window, which usually causes the	appli-
	      cation to	crash and burn.

       Iconify [bool]
	      Iconifies	 a  window if it is not	already	iconified or de-iconi-
	      fies it if it is already iconified.  The optional	argument  bool
	      is  a  boolean argument.	"True" means only iconification	is al-
	      lowed, while "False" forces  de-iconification.   Using  "toggle"
	      switches between iconified and de-iconified states.

	      There  are a number of Style options which influence the appear-
	      ance and behavior	of icons (e.g.	StickyIcon, NoIcon).

	      For backward compatibility, the optional argument	may also be  a
	      positive	number instead of "True", or a negative	number instead
	      of "False".  Note	that this syntax is obsolete, and will be  re-
	      moved in the future.

       Maximize	[flags]	[bool] [horizontal[p]] [vertical [p]]
	      Without its optional arguments (or if the	bool bit has the value
	      "toggle")	Maximize causes	the window to alternately switch  from
	      a	 full-screen  size to its normal size.	To force a window into
	      maximized	(normal) state you can use a "True" or	"False"	 value
	      for the bool argument.

	      With  the	 optional arguments horizontal and vertical, which are
	      expressed	as percentage of a full	screen,	the user  can  control
	      the  new size of the window.  An optional	suffix 'p' can be used
	      to indicate pixels instead of percents of	the screen  size.   If
	      horizontal  is  greater  than 0 then the horizontal dimension of
	      the window is set	to horizontal*screen_width/100.	 If the	 value
	      is  smaller than 0 the size is subtracted	from the screen	width,
	      i.e. -25 is the same as 75.  If horizontal is "grow", it is max-
	      imized  to  current  available space until finding any obstacle.
	      The vertical resizing is similar.	 If both horizontal and	verti-
	      cal  values  are "grow", it expands vertically first, then hori-
	      zontally to find space.  Instead of the horizontal "grow"	 argu-
	      ment,   "growleft"  or  "growright"  can	be  used  respectively
	      "growup" and "growdown".	The optional flags argument is a space
	      separated	 list  containing  the	following  key words: ewmhiwa,
	      growonwindowlayer, growonlayers and screen.  ewmhiwa causes fvwm
	      to  ignore  the EWMH working area.  Growonwindowlayer causes the
	      various grow methods to ignore windows with a layer  other  than
	      the current layer	of the window which is maximized.  The growon-
	      layers option must have two integer arguments.  The first	one is
	      the  minimum  layer and the second one the maximum layer to use.
	      Windows that are outside of this range of	layers are ignored  by
	      the grow methods.	 A negative value as the first or second argu-
	      ment means to assume no minimum or maximum layer.	  Screen  must
	      have an argument which specifies the Xinerama screen on which to
	      operate.	It can be 'p' for the primary screen, 'c' for the cur-
	      rent  screen  (containing	the mouse pointer), 'g'	for the	global
	      screen or	the screen number itself (counting from	 zero).	  This
	      option is	only useful with multiple Xinerama screens.

	      Here  are	 some examples.	 The following adds a title-bar	button
	      to switch	a window to the	full vertical size of the screen:
	      Mouse 0 4	A Maximize 0 100
	      The following causes windows to be stretched to the full width:
	      Mouse 0 4	A Maximize 100 0
	      This makes a window that is half the screen size in each	direc-
	      tion:
	      Mouse 0 4	A Maximize 50 50
	      To expand	a window horizontally until any	other window is	found:
	      Mouse 0 4	A Maximize 0 grow
	      To  expand  a  window  until  any	 other window on the same or a
	      higher layer is hit.
	      Mouse 0 4	A Maximize growonlayers	$[w.layer] -1 grow grow
	      To expand	a window but leave the lower 60	pixels of  the	screen
	      unoccupied:
	      Mouse 0 4	A Maximize 100 -60p
	      Values larger than 100 can be used with caution.

       Recapture
	      This command is obsolete and should not be used anymore.	Should
	      you want to do something specific	that you cannot	do without it,
	      please  report this to the fvwm-workers mailing list (fvwm-work-
	      ers@fvwm.org).  This command will	be removed at  some  point  in
	      the  future.  Please read	the note at the	end of the section DE-
	      LAYED EXECUTION OF COMMANDS to learn about how to	avoid the  Re-
	      capture command.

	      Causes  fvwm to recapture	all of its windows.  This ensures that
	      the latest style parameters are used.  The  recapture  operation
	      is visually disturbing.

	      Since  fvwm version 2.4 only a very few Style options need a Re-
	      capture to take effect (e.g.  UseStyle).

       RecaptureWindow
	      This command is obsolete and should not be  used	anymore.   See
	      Recapture	For details.

	      Causes fvwm to recapture the chosen window.

       Refresh
	      Causes all windows on the	screen to redraw themselves. All pend-
	      ing updates of all windows' styles and looks are applied immedi-
	      ately.   E.g. if Style or	TitleStyle commands were issued	inside
	      a	fvwm function.

       RefreshWindow
	      Causes the chosen	window to redraw itself. All  pending  updates
	      of the window's style and	look are applied immediately.  E.g. if
	      Style or TitleStyle commands were	issued inside a	fvwm function.

       Stick [bool]
	      If the bool argument is empty or	"toggle",  the	Stick  command
	      makes a window sticky if it is not already sticky, or non-sticky
	      if it is already sticky.	To make	a window sticky	regardless  of
	      its  current state the bool argument must	be "True".  To make it
	      non-sticky use "False".

       StickAcrossPages	[bool]
	      Works like Stick but only	sticks	a  window  across  pages,  not
	      across desks.

       StickAcrossDesks	[bool]
	      Works  like  Stick  but  only  sticks a window across desks, not
	      across pages.

       WindowShade [bool] | [[ShadeAgain] direction]
	      Toggles the window shade feature for titled windows.  Windows in
	      the shaded state only display a title-bar.  If bool is not given
	      or "toggle", the window shade state  is  toggled.	  If  bool  is
	      "True",  the  window  is forced to the shaded state.  If bool is
	      "False", then the	window is forced to the	non-shaded state.   To
	      force shading in a certain direction, the	direction argument can
	      be used.	Any of the strings "North", "South",  "West",  "East",
	      "NorthWest", "NorthEast",	"SouthWest", "SouthEast" or "Last" can
	      be given.	The direction can be abbreviated with the usual	one or
	      two  letters "N",	"NW", etc.  Using a direction on a window that
	      was already shaded unshades the window.  To shade	it in  a  dif-
	      ferent  direction, use the ShadeAgain option. The	direction Last
	      will shade the window in the direction it	last  was  shaded.  If
	      the  window has never been shaded	before it will be shaded as if
	      no direction were	given. Windows without titles  can  be	shaded
	      too.  Please refer also to the options WindowShadeSteps, Window-
	      ShadeShrinks,   WindowShadeScrolls,   WindowShadeLazy,   Window-
	      ShadeAlwaysLazy  and  WindowShadeBusy.  option of	the Style com-
	      mand.  Examples:
	      Style * WindowShadeShrinks, \
	      WindowShadeSteps 20, WindowShadeLazy
	      Mouse 1 -	S WindowShade North
	      Mouse 1 [	S WindowShade West
	      Mouse 1 ]	S WindowShade E
	      Mouse 1 _	S WindowShade S

	      Note: When a window that has been	shaded with a direction	 argu-
	      ment  changes  the direction of the window title (see TitleAtTop
	      Style option), the shading direction does	not change.  This  may
	      look very	strange.  Windows that were shaded without a direction
	      argument stay shaded in the direction of the title bar.

	      For backward compatibility, the optional argument	may also be  1
	      to  signify  "on", and 2 to signify "off". Note that this	syntax
	      is obsolete, and will be removed in the future.

       WindowShadeAnimate  [steps[p]]
	      This command is obsolete.	 Please	use the	 WindowShadeSteps  op-
	      tion of the Style	command	instead.

   COMMANDS FOR	MOUSE, KEY AND STROKE BINDINGS
       IgnoreModifiers [Modifiers]
	      Tells  fvwm which	modifiers to ignore when matching Mouse	or Key
	      bindings.	 IgnoreModifiers affects the ClickToFocus  style  too.
	      This  command  belongs  into  your config.  If you issue it when
	      your fvwm	session	is already up and running the results are  un-
	      predictable.   The should	appear before any applications or mod-
	      ules are started in your config file (e.g. with  the  Exec  com-
	      mand).

	      Modifiers	 has  the same syntax as in the	Mouse or Key bindings,
	      with the addition	of 'L' meaning the caps	lock key.  The default
	      is  "L".	Modifiers can be omitted, meaning no modifiers are ig-
	      nored.  This command comes in handy if the num-lock and  scroll-
	      lock  keys interfere with	your shortcuts.	 With XFree86 '2' usu-
	      ally is the num-lock modifier and	'5' refers to the  scroll-lock
	      key. To turn all these pesky modifiers off you can use this com-
	      mand:
	      IgnoreModifiers L25
	      If the Modifiers argument	is the string "default", fvwm  reverts
	      back to the default value	"L".

	      Important	 Note:	This  command  creates	a lot of extra network
	      traffic, depending on your CPU, network connection,  the	number
	      of Key or	Mouse commands in your configuration file and the num-
	      ber of modifiers you want	to ignore.   If	 you  do  not  have  a
	      lightning	 fast  machine or very few bindings you	should not ig-
	      nore more	than two modifiers. I.e. do not	ignore scroll-lock  if
	      you  have	 no problem with it.  In the FAQ you can find a	better
	      solution of this problem.

       EdgeCommand [direction [Function]]
	      Binds a specified	fvwm  command  Function	 to  an	 edge  of  the
	      screen.  Direction may be	one of "North",	"Top", "West", "Left",
	      "South", "Bottom", "Right" and "East". If	 Function  is  omitted
	      the  binding  for	this edge is removed. If EdgeCommand is	called
	      without any arguments all	edge bindings are removed.

	      Function is executed when	the mouse pointer enters the invisible
	      pan  frames that surround	the visible screen.  The binding works
	      only if EdgeThickness is set to a	value greater than  0.	 If  a
	      function	is bound to an edge, scrolling specified by EdgeScroll
	      is disabled for this edge.  It is	possible to  bind  a  function
	      only  to some edges and use the other edges for scrolling.  This
	      command is intended to raise or lower certain windows  when  the
	      mouse  pointer enters an edge.  FvwmAuto can be used get a delay
	      when raising or lowering windows.	 The following example	raises
	      FvwmButtons  if  the  mouse  pointer  enters the top edge	of the
	      screen.
	      #	Disable	EdgeScrolling but make it possible
	      #	to move	windows	over the screen	edge
	      EdgeResistance 10000 20

	      #	Set thickness of the edge of the screen	to 1
	      EdgeThickness 1

	      #	Give focus to FvwmButtons if the mouse
	      #	hits top edge
	      EdgeCommand Top Next (FvwmButtons) Focus
	      #	Make sure the Next command matches the window
	      Style FvwmButtons	CirculateHit

	      Module FvwmButtons
	      Module FvwmAuto 100 \
		   "Silent AutoRaiseFunction" \
		   "Silent AutoLowerFunction"

	      #	If any window except FvwmButtons has
	      #	focus when calling this	function
	      #	FvwmButtons are	lowered
	      DestroyFunc AutoLowerFunction
	      AddToFunc	AutoLowerFunction
	      +	I Current (!FvwmButtons) \
		   All (FvwmButtons) Lower

	      #	If FvwmButtons has focus when calling \
	      #	this function raise it
	      DestroyFunc AutoRaiseFunction
	      AddToFunc	AutoRaiseFunction
	      +	I Current (FvwmButtons)	Raise
	      Normally,	the invisible pan frames are only on the screen	 edges
	      that border virtual pages.  If a screen edge has a command bound
	      to it, the pan frame is always created on	that edge.

       EdgeLeaveCommand	[direction [Function]]
	      Binds a specified	fvwm  command  Function	 to  an	 edge  of  the
	      screen.  Direction may be	one of "North",	"Top", "West", "Left",
	      "South", "Bottom", "Right" and "East". If	 Function  is  omitted
	      the  binding  for	 this  edge is removed.	If EdgeLeaveCommand is
	      called without any arguments all edge bindings are removed.

	      Function is executed when	the mouse pointer leaves the invisible
	      pan  frames that surround	the visible screen.  The binding works
	      only if EdgeThickness is set to a	value greater than  0.	 If  a
	      function	is bound to an edge, scrolling specified by EdgeScroll
	      is disabled for this edge.  It is	possible to  bind  a  function
	      only  to some edges and use the other edges for scrolling.  This
	      command is intended to raise or lower certain windows  when  the
	      mouse  pointer leaves an edge.  FvwmAuto can be used get a delay
	      when raising or lowering windows.	 See example for EdgeCommand
	      Normally,	the invisible pan frames are only on the screen	 edges
	      that border virtual pages.  If a screen edge has a command bound
	      to it, the pan frame is always created on	that edge.

       GnomeButton
	      Used in conjunction with Mouse to	pass mouse button  presses  on
	      the root window to a GNOME program (such as GMC).	 The following
	      example passes presses of	mouse buttons 1	and 3 to such  a  pro-
	      gram.
	      Mouse 1 R	A GnomeButton
	      Mouse 3 R	A GnomeButton

       Key [(window)] Keyname Context Modifiers	Function
	      Binds a keyboard key to a	specified fvwm command,	or removes the
	      binding if Function is '-'.  The syntax is the  same  as	for  a
	      Mouse  binding  except  that the mouse button number is replaced
	      with a Keyname.  Normally, the key binding is activated when the
	      key  is  pressed.	 Keyname is a standard X11 key name as defined
	      in /usr/include/X11/keysymdef.h, (without	the  XK_  prefix),  or
	      the  keysym  database  /usr/X11R6/lib/X11/XKeysymDB.   Only  key
	      names that are generated with no modifier	keys or	with just  the
	      Shift  key  held	are guaranteed to work.	 The Context and Modi-
	      fiers fields are defined as in the Mouse binding.	 However, when
	      you  press  a  key the context window is the window that has the
	      keyboard focus.  That is not necessarily the same	as the	window
	      the  pointer  is	over (with SloppyFocus or ClickToFocus).  Note
	      that key bindings	with the 'R' (root window) context do not work
	      properly	with  SloppyFocus  and ClickToFocus.  If you encounter
	      problems,	use the	PointerKey command instead.  If	 you  want  to
	      bind  keys to a window with SloppyFocus or ClickToFocus that are
	      supposed to work when the	pointer	is not over the	 window,  fvwm
	      assumes  the pointer is over the client window (i.e. you have to
	      use the 'W' context).

	      The following example binds the built-in window list to  pop  up
	      when  Alt-Ctrl-Shift-F11	is  hit,  no  matter  where  the mouse
	      pointer is:
	      Key F11 A	SCM WindowList
	      Binding a	key to a title-bar button causes that  button  to  ap-
	      pear.  Please refer to the Mouse command for details.

       Mouse [(window)]	Button Context Modifiers Function
	      Defines  a  mouse	binding, or removes the	binding	if Function is
	      '-'.  Button is the mouse	button number.	If Button is zero then
	      any  button  performs  the  specified  function.	Note that only
	      mouse buttons 1 to 5 are fully supported	by  X11.   Any	number
	      above  this  works only partially.  Complex functions can	not be
	      used with	these buttons and neither any operation	that  requires
	      dragging the pointer with	the button held.  This is due to limi-
	      tations of X11.  By default, the highest allowed	button	number
	      is 9.

	      Context describes	where the binding applies.  Valid contexts are
	      'R' for the root window, 'W' for an application window, 'D'  for
	      a	desktop	application (as	kdesktop or Nautilus desktop), 'T' for
	      a	window title-bar, 'S' for a window side, top, or  bottom  bar,
	      '[',  ']',  '-'  and '_' for the left, right, top	or bottom side
	      only, 'F'	for a window frame (the	corners), '<',	'^',  '>'  and
	      'v'  for	the  top  left,	top right, bottom right	or bottom left
	      corner, 'I' for an icon window, or '0' through '9' for title-bar
	      buttons,	or  any	 combination of	these letters.	'A' is for any
	      context.	For instance, a	context	 of  "FST"  applies  when  the
	      mouse is anywhere	in a window's border except the	title-bar but-
	      tons.  Only 'S' and 'W' are valid	for an undecorated window.

	      The special context 'M' for menus	can only be  used  to  control
	      which  mouse  button is used to tear off menus.  See the section
	      "Tear Off	Menus" for details.

	      The special context 'P' controls what buttons that can  be  used
	      to  place	a window. When using this context no modifiers are al-
	      lowed (Modifiers must be N), no window is	allowed, and the Func-
	      tion must	be one of PlaceWindow, PlaceWindowDrag,	PlaceWindowIn-
	      teractive	, CancelPlacement, CancelPlacementDrag ,  CancelPlace-
	      mentInteractive or -.

	      PlaceWindow  makes  Button usable	for window placement, both for
	      interactive and drag move.  CancelPlacement  does	 the  inverse.
	      That  is	makes  Button  to cancel move for both interactive and
	      drag move. It may	however	not override how new windows  are  re-
	      sized after being	placed.	This is	controlled by the Emulate com-
	      mand. Also a window being	dragged	can always be  placed  by  re-
	      leasing  the  button hold	while dragging,	regardless of if it is
	      set to PlaceWindow or not.

	      PlaceWindowDrag and PlaceWindowInteractive/CancelPlacementDrag
	      and  CancelPlacementInteractive work as PlaceWindow/CancelPlace-
	      ment with	the exception that they	 only  affect  either  windows
	      dragged /	placed interactively.

	      -	is equivalent to CancelPlacement.

	      The  following example makes all buttons but button 3 usable for
	      interactive placement and	makes drag moves started by other but-
	      tons than	one cancel if button 1 is pressed before finishing the
	      move:
	      Mouse 0 P	N PlaceWindow
	      Mouse 3 P	N CancelPlacement
	      Mouse 1 P	N CancelPlacementDrag

	      By default, the binding applies to all windows. You can  specify
	      that  a  binding	only applies to	specific windows by specifying
	      the window name in brackets. The window name is a	wildcard  pat-
	      tern  specifying	the  class, resource or	name of	the window you
	      want the binding to apply	to.

	      The following example shows how the same key-binding can be used
	      to  perform  different functions depending on the	window that is
	      focused:
	      Key (rxvt)  V A C	Echo ctrl-V-in-RXVT
	      Key (*term) V A C	Echo ctrl-V-in-Term
	      Key (*vim)  V A C	--
	      Key	  V A C	Echo ctrl-V-elsewhere

	      A	'--' action indicates that the event should be	propagated  to
	      the  specified window to handle. This is only a valid action for
	      window-specific bindings.

	      This example shows how to	display	the WindowList when  Button  3
	      is pressed on an rxvt window:
	      Mouse (rxvt) 3 A A WindowList

	      Note  that Fvwm actually intercepts all events for a window-spe-
	      cific binding and	(if the	focused	window doesn't	match  any  of
	      the bindings) sends a synthetic copy of the event	to the window.
	      This should be transparent to most  applications,	 however  (for
	      security reasons)	some programs ignore these synthetic events by
	      default -	xterm is one of	them.  To  enable  handling  of	 these
	      events, add the following	line to	your ~/.Xdefaults file:

	      XTerm*allowSendEvents:  true

	      Modifiers	 is  any  combination of 'N' for no modifiers, 'C' for
	      control, 'S' for shift, 'M' for Meta, 'L'	for Caps-Lock  or  'A'
	      for  any	modifier. For example, a modifier of "SM" applies when
	      both the Meta and	Shift  keys  are  down.	  X11  modifiers  mod1
	      through mod5 are represented as the digits '1' through '5'.  The
	      modifier 'L' is ignored by default.  To turn it on, use the  Ig-
	      noreModifiers command.

	      Function is one of fvwm's	commands.

	      The  title-bar buttons are numbered with odd numbered buttons on
	      the left side of the title-bar and even numbers  on  the	right.
	      Smaller-numbered buttons are displayed toward the	outside	of the
	      window while larger-numbered buttons appear toward the middle of
	      the  window  (0  is  short for 10).  In summary, the buttons are
	      numbered:
	      1	3 5 7 9	   0 8 6 4 2
	      The highest odd numbered button which has	an action bound	to  it
	      determines  the  number of buttons drawn on the left side	of the
	      title bar.  The highest even number  determines  the  number  of
	      right side buttons which are drawn.  Actions can be bound	to ei-
	      ther mouse buttons or keyboard keys.

       PointerKey [(window)] Keyname Context Modifiers Function
	      This command works exactly like the Key command.	The only  dif-
	      ference  is  that	 the  binding operates on the window under the
	      pointer.	Normal key bindings operate on the focused window  in-
	      stead.   The  PointerKey command can for example be used to bind
	      keys to the root window if you are using SloppyFocus or ClickTo-
	      Focus.   However,	 some  applications (xterm is one example) are
	      unable to	handle this key	anymore, even if the pointer  is  over
	      the  xterm window.  It is	recommended to use the PointerKey com-
	      mand only	for key	combinations that are not needed in any	appli-
	      cation window.

	      Example:
	      Style * SloppyFocus
	      PointerKey f1 a m	Menu MainMenu

       Stroke [(window)] Sequence Button Context Modifiers Function
	      Binds  a	mouse  stroke sequence to a specified fvwm command, or
	      removes the binding if Function is '-'.  The syntax is the  same
	      as for a Mouse binding except that Sequence is inserted in front
	      of the button number and a value of 0 for	 Button	 concerns  the
	      StrokeFunc  command.   The  Context and Modifiers	fields are de-
	      fined as in the Mouse binding.  However, only  the  'R'  Context
	      really  works (if	you want to use	other contexts you need	to use
	      the StrokeFunc below).

	      Strokes sequences	are defined in a telephone grid	like this:
	       1  2  3

	       4  5  6

	       7  8  9
	      or in a numeric pad grid like this:
	       7  8  9

	       4  5  6

	       1  2  3
	      The telephone grid is used by default, to	use  the  numeric  pad
	      grid you should begin the	sequence with a	'N'.  Note that	a com-
	      plex motion may produce several  different  sequences  (see  the
	      "netscape"  example below	to handle such motion).	 Moreover, se-
	      quences are limited to 20	elements (with the present version  of
	      libstroke),  however,  in	 practice  it is preferable to use se-
	      quence with less than 12 elements.

	      Because of the default button menu in fvwm, you may need to  re-
	      move a mouse button binding (using an empty action) before using
	      the stroke
	      Mouse 3 R	N
	      Also, you	can still use the stroke "sequence 0"  to  simulate  a
	      click:
	      Stroke 0 3 R N Menu WindowList Nop
	      The  following  example starts xterm when	the mouse drags	an 'I'
	      on the root window with button 3 pressed down:
	      Stroke 258  3  R	N  Exec	exec xterm
	      An example for Netscape:
	      Stroke 7415963	3  R  N	 Exec exec netscape
	      Stroke 74148963	3  R  N	 Exec exec netscape
	      Stroke 74158963	3  R  N	 Exec exec netscape
	      Stroke 7418963	3  R  N	 Exec exec netscape
	      Stroke 415963	3  R  N	 Exec exec netscape
	      You may prefer to	use the	numeric	pad grid since you have	such a
	      grid on your machine. Here an example:
	      Stroke N78963214	 3  R  N  FvwmForm FvwmForm-QuitVerify
	      Stroke N789632147	 3  R  N  FvwmForm FvwmForm-QuitVerify
	      This example starts the "QuitVerify" form	if you draw a box that
	      begins in	the top	left corner.

	      Note: You	need libstroke installed and fvwm compiled with	stroke
	      support.	libstroke can be obtained at
	      http://www.etla.net/~willey/projects/libstroke/

       StrokeFunc [Options]
	      Causes fvwm to record a mouse stroke sequence and	to execute the
	      corresponding action as defined in a Stroke command.  The	cursor
	      is  modified  to	the  STROKE context of the CursorStyle command
	      during recording.	 When the stroke is finished StrokeFunc	 looks
	      for a stroke binding of the form
	      Stroke sequence 0	Context	Modifiers action
	      and  executes the	corresponding action (Note the 0).  Normal use
	      of this function is via a	Mouse or Key command.  Examples:
	      Mouse 3 A	M StrokeFunc
	      Key x R N	StrokeFunc
	      If you press mouse button	 3  and	 Alt  anywhere	(respectively,
	      press  the  key  x  when the cursor is on	the root window), then
	      fvwm records the mouse motions until the mouse button 3 (respec-
	      tively,  the  x  key) is released	and then check if the recorded
	      sequence corresponds to a	stroke binding of the form
	      "Stroke sequence 0 A M action"
	      "Stroke sequence 0 R N action"
	      Note that	the Context and	Modifiers are taken at	the  beginning
	      of  the  execution of the	StrokeFunc command (so you can release
	      the modifiers before the end of the stroke recording in the case
	      of a mouse binding and if	you used, say, a title-bar context the
	      mouse motion can go through an application  window).   The  keys
	      Escape and Delete	allow you to abort the command.

	      The StrokeFunc command has five options: NotStayPressed, EchoSe-
	      quence, DrawMotion, FeedBack and StrokeWidth.  These options are
	      disabled	by  default.   EchoSequence  causes  fvwm  to Echo the
	      recorded stroke sequence.	 DrawMotion causes fvwm	 to  draw  the
	      mouse  motion  on	 the  screen.  FeedBack	causes fvwm to display
	      during a fraction	of second the cursor of	the  WAIT  context  of
	      the  CursorStyle	command	if the recorded	stroke sequence	corre-
	      sponds to	a stroke binding.  StrokeWidth takes an	integer	 argu-
	      ment,  which must	be >= 0	and <= 100 and which defines the width
	      of the line for the DrawMotion option.

	      NotStayPressed works only	if StrokeFunc is used via a Mouse or a
	      Key  command.   This option removes the need to have a button or
	      the key pressed during the stroke, but you have to  do  a	 mouse
	      click  or	 press the Return or Space key to finish the mouse mo-
	      tion recording (these keys also work without the	NotStayPressed
	      option).

	      You  can	use  the StrokeFunc "alone".  In this case it works as
	      above with the NotStayPressed option  enabled.   However,	 Modi-
	      fiers,  in general, may not work as expected (i.e., in this case
	      use 'A' or 'N' as	Modifiers in the stroke	bindings).

	      Note that	some computers do not support key release  events.  If
	      that  is the case	the StrokeFunc used via	a Key command works as
	      if the NotStayPressed option is enabled.

   THE STYLE COMMAND (CONTROLLING WINDOW STYLES)
       For readability,	the commands in	this section are not sorted alphabeti-
       cally.  The description of the Style command can	be found at the	end of
       this section.

       FocusStyle stylename options
	      works exactly like the Style command, but	accepts	only the focus
	      policy  related  styles  beginning with "FP".  The prefix	can be
	      removed, but at the cost of a little bit of time.	 FocusStyle is
	      meant to make the	configuration file more	readable.  Example:
	      FocusStyle * EnterToFocus, !LeaveToUnfocus
	      is equivalent to
	      Style * FPEnterToFocus, !FPLeaveToUnfocus

       DestroyStyle style
	      deletes  the style named style.  The changes take	effect immedi-
	      ately.  Note that	style is not a wild-carded search string,  but
	      rather  a	 case-sensitive	 string	 that should exactly match the
	      original Style command.

	      Destroying style "*" can be done,	but isn't really to be	recom-
	      mended. For example:
	      DestroyStyle Application*
	      This  removes  all  settings for the style named "Application*",
	      NOT all styles starting with "Application".

       DestroyWindowStyle
	      deletes the styles set by	the WindowStyle	 command  on  the  se-
	      lected window. The changes take effect immediately.

       UpdateStyles
	      All pending updates of all windows' styles and looks are applied
	      immediately.  E.g. if Style, WindowStyle or TitleStyle  commands
	      were issued inside a fvwm	function.

       Style stylename options ...
	      The  Style command is used to set	attributes of a	window to val-
	      ues other	than the default or to set the window manager  default
	      styles.

	      stylename	can be a window's name,	class, or resource string.  It
	      may contain the wildcards	'*' and	'?', which are matched in  the
	      usual  Unix filename manner.  Multiple style options in a	single
	      Style command are	read from left to right	as if they were	issued
	      one after	each other in separate commands.  A given style	always
	      overrides	all conflicting	styles that have been  issued  earlier
	      (or further left on the same style line).

	      Note:  windows  that  have no name (WM_NAME) are given a name of
	      "Untitled", and windows that do  not  have  a  class  (WM_CLASS,
	      res_class)  are given class "NoClass" and	those that do not have
	      a	resource (WM_CLASS, res_name) are given	resource "NoResource".

	      If a window has the resource "fvwmstyle" set, the	value of  that
	      resource	will  be used in addition to any window	names when se-
	      lecting the style.

	      options is a comma separated list	containing one or more of  the
	      following	 keywords.   Each group	of style names is separated by
	      slashes ('/').  The last style in	these groups is	 the  default.
	      BorderWidth,  HandleWidth,  NoIcon  /  Icon,  MiniIcon, IconBox,
	      IconGrid,	IconFill, IconSize, !Title /  Title,  TitleAtBottom  /
	      TitleAtLeft  /  TitleAtRight  / TitleAtTop, LeftTitleRotatedCW /
	      LeftTitleRotatedCCW, RightTitleRotatedCCW	/ RightTitleRotatedCW,
	      TopTitleRotated  / TopTitleNotRotated, BottomTitleRotated	/ Bot-
	      tomTitleNotRotated, !UseTitleDecorRotation /  UseTitleDecorRota-
	      tion, StippledTitle / !StippledTitle, StippledIconTitle /	!Stip-
	      pledIconTitle, IndexedWindowName / ExactWindowName, IndexedIcon-
	      Name  /  ExactIconName,  !Borders	/ Borders, !Handles / Handles,
	      WindowListSkip / WindowListHit,  CirculateSkip  /	 CirculateHit,
	      CirculateSkipShaded  /  CirculateHitShaded,  CirculateSkipIcon /
	      CirculateHitIcon,	Layer, StaysOnTop / StaysOnBottom /  StaysPut,
	      Sticky   /  Slippery,  StickyAcrossPages	/  !StickyAcrossPages,
	      StickyAcrossDesks	/ !StickyAcrossDesks,  !StickyStippledTitle  /
	      StickyStippledTitle, !StickyStippledIconTitle / StickyStippledI-
	      conTitle,	StartIconic /  StartNormal,  Color,  ForeColor,	 Back-
	      Color, Colorset, HilightFore, HilightBack, HilightColorset, Bor-
	      derColorset, HilightBorderColorset, IconTitleColorset, HilightI-
	      conTitleColorset,	IconBackgroundColorset,	IconTitleRelief, Icon-
	      BackgroundRelief,	IconBackgroundPadding, Font, IconFont,	Start-
	      sOnDesk  /  StartsOnPage / StartsAnyWhere, StartsOnScreen, Manu-
	      alPlacementHonorsStartsOnPage /  ManualPlacementIgnoresStartsOn-
	      Page,  CaptureHonorsStartsOnPage	/  CaptureIgnoresStartsOnPage,
	      RecaptureHonorsStartsOnPage   /	 RecaptureIgnoresStartsOnPage,
	      StartsOnPageIncludesTransients  /	StartsOnPageIgnoresTransients,
	      IconTitle	/ !IconTitle, MwmButtons /  FvwmButtons,  MwmBorder  /
	      FvwmBorder,  MwmDecor  / NoDecorHint, MwmFunctions / NoFuncHint,
	      HintOverride / NoOverride, !Button / Button,  ResizeHintOverride
	      /	  NoResizeOverride,   OLDecor  /  NoOLDecor,  GNOMEUseHints  /
	      GNOMEIgnoreHints,	StickyIcon / SlipperyIcon, StickyAcrossPagesI-
	      con  /  !StickyAcrossPagesIcon, StickyAcrossDesksIcon / !Sticky-
	      AcrossDesksIcon, ManualPlacement / CascadePlacement  /  MinOver-
	      lapPlacement  / MinOverlapPercentPlacement / TileManualPlacement
	      /	TileCascadePlacement / CenterPlacement /  UnderMousePlacement,
	      MinOverlapPlacementPenalties,   MinOverlapPercentPlacementPenal-
	      ties, DecorateTransient /	NakedTransient,	 DontRaiseTransient  /
	      RaiseTransient,  DontLowerTransient / LowerTransient, DontStack-
	      TransientParent /	StackTransientParent, SkipMapping  /  ShowMap-
	      ping,  ScatterWindowGroups  /  KeepWindowGroupsOnDesk, UseDecor,
	      UseStyle,	NoPPosition / UsePPosition, NoUSPosition /  UseUSPosi-
	      tion,  NoTransientPPosition / UseTransientPPosition, NoTransien-
	      tUSPosition / UseTransientUSPosition, NoIconPosition /  UseIcon-
	      Position,	 Lenience  /  NoLenience, ClickToFocus / SloppyFocus /
	      MouseFocus|FocusFollowsMouse  /  NeverFocus,   ClickToFocusPass-
	      esClickOff  /  ClickToFocusPassesClick,  ClickToFocusRaisesOff /
	      ClickToFocusRaises, MouseFocusClickRaises	/ MouseFocusClickRais-
	      esOff, GrabFocus / GrabFocusOff, GrabFocusTransientOff / GrabFo-
	      cusTransient, FPFocusClickButtons,  FPFocusClickModifiers,  !FP-
	      SortWindowlistByFocus  / FPSortWindowlistByFocus,	FPClickRaises-
	      Focused  /  !FPClickRaisesFocused,  FPClickDecorRaisesFocused  /
	      !FPClickDecorRaisesFocused, FPClickIconRaisesFocused / !FPClick-
	      IconRaisesFocused, !FPClickRaisesUnfocused /  FPClickRaisesUnfo-
	      cused,  FPClickDecorRaisesUnfocused  /  !FPClickDecorRaisesUnfo-
	      cused, FPClickIconRaisesUnfocused	/ !FPClickIconRaisesUnfocused,
	      FPClickToFocus	/   !FPClickToFocus,   FPClickDecorToFocus   /
	      !FPClickDecorToFocus, FPClickIconToFocus /  !FPClickIconToFocus,
	      !FPEnterToFocus  /  FPEnterToFocus, !FPLeaveToUnfocus / FPLeave-
	      ToUnfocus, !FPFocusByProgram / FPFocusByProgram, !FPFocusByFunc-
	      tion  / FPFocusByFunction, FPFocusByFunctionWarpPointer /	!FPFo-
	      cusByFunctionWarpPointer,	 FPLenient  /  !FPLenient,  !FPPassFo-
	      cusClick	 /   FPPassFocusClick,	 !FPPassRaiseClick  /  FPPass-
	      RaiseClick,  FPIgnoreFocusClickMotion  /	!FPIgnoreFocusClickMo-
	      tion,   FPIgnoreRaiseClickMotion	 /  !FPIgnoreRaiseClickMotion,
	      !FPAllowFocusClickFunction /  FPAllowFocusClickFunction,	!FPAl-
	      lowRaiseClickFunction / FPAllowRaiseClickFunction, FPGrabFocus /
	      !FPGrabFocus,  !FPGrabFocusTransient   /	 FPGrabFocusTransient,
	      FPOverrideGrabFocus  /  !FPOverrideGrabFocus,  FPReleaseFocus  /
	      !FPReleaseFocus, !FPReleaseFocusTransient	/  FPReleaseFocusTran-
	      sient,  FPOverrideReleaseFocus / !FPOverrideReleaseFocus,	Start-
	      sLowered / StartsRaised, IgnoreRestack / AllowRestack,  FixedPo-
	      sition / VariablePosition, FixedUSPosition / VariableUSPosition,
	      FixedPPosition / VariablePPosition,  FixedSize  /	 VariableSize,
	      FixedUSSize / VariableUSSize, FixedPSize / VariablePSize,	!Clos-
	      able / Closable, !Iconifiable / Iconifiable, !Maximizable	/ Max-
	      imizable,	  !AllowMaximizeFixedSize   /  AllowMaximizeFixedSize,
	      IconOverride / NoIconOverride /  NoActiveIconOverride,  Depress-
	      ableBorder  /  FirmBorder,  MaxWindowSize, IconifyWindowGroups /
	      IconifyWindowGroupsOff, ResizeOpaque /  ResizeOutline,  Backing-
	      Store  /	BackingStoreOff	/ BackingStoreWindowDefault, Opacity /
	      ParentalRelativity, SaveUnder / SaveUnderOff, WindowShadeShrinks
	      /	 WindowShadeScrolls, WindowShadeSteps, WindowShadeAlwaysLazy /
	      WindowShadeBusy /	WindowShadeLazy, EWMHDonateIcon	/  EWMHDontDo-
	      nateIcon,	EWMHDonateMiniIcon / EWMHDontDonateMiniIcon, EWMHMini-
	      IconOverride / EWMHNoMiniIconOverride, EWMHUseStackingOrderHints
	      /	EWMHIgnoreStackingOrderHints, EWMHIgnoreStateHints / EWMHUseS-
	      tateHints,  EWMHIgnoreStrutHints	/  EWMHUseStrutHints,  EWMHIg-
	      noreWindowType   /   !EWMHIgnoreWindowType,  EWMHMaximizeIgnore-
	      WorkingArea / EWMHMaximizeUseWorkingArea / EWMHMaximizeUseDynam-
	      icWorkingArea,  EWMHPlacementIgnoreWorkingArea  /	 EWMHPlacemen-
	      tUseWorkingArea /	EWMHPlacementUseDynamicWorkingArea, MoveByPro-
	      gramMethod, Unmanaged, State.

	      In  the above list some options are listed as style-option/oppo-
	      site-style-option.  The opposite-style-option for	 entries  that
	      have them	describes the fvwm default behavior and	can be used if
	      you want to change the fvwm default behavior.

       Focus policy
	      ClickToFocus instructs fvwm to give the focus to a  window  when
	      it  is  clicked in.  The default MouseFocus (or its alias	Focus-
	      FollowsMouse) tells fvwm to give a window	the focus as  soon  as
	      the pointer enters the window, and take it away when the pointer
	      leaves the window.  SloppyFocus is similar, but doesn't give  up
	      the focus	if the pointer leaves the window to pass over the root
	      window or	a ClickToFocus window (unless you click	 on  it,  that
	      is),  which  makes  it possible to move the mouse	out of the way
	      without losing focus.  A window with the style NeverFocus	 never
	      receives	the  focus.   This is useful for modules like FvwmBut-
	      tons, for	example.  Note:	 Once any of the  "FP..."  styles  has
	      been  used, the defaults that come with the basic	focus policies
	      are not restored when the	latter are used	again.	 For  example,
	      once !FPGrabFocus	has been used, using ClickToFocus does not re-
	      store FPGrabFocus.

	      The focus	model can be augmented	with  several  additional  op-
	      tions.  In fvwm-2.5.3 and	later, there are a large number	of ad-
	      vanced options beginning with  "FP"  or  "!FP".	These  options
	      shall replace the	older options one day and are described	first.
	      Using any	of these new  options  may  limit  compatibility  with
	      older  releases.	In general, options beginning with "FP"	turn a
	      feature on, while	those beginning	with "!FP" turn	it off.

	      Focusing the window

	      With FPEnterToFocus, when	the pointer enters  a  window  it  re-
	      ceives focus.

	      With  FPLeaveToUnfocus  a	 window	 loses	focus when the pointer
	      leaves it.

	      With FPClickToFocus, FPClickDecorToFocus or  FPClickIconToFocus,
	      a	 window	 receives  focus  when the inside of the window	or the
	      decorations or its icon is clicked.

	      The FPFocusByProgram style allows	 windows  to  take  the	 focus
	      themselves.

	      The  !FPFocusByFunction style forbids that a window receives the
	      focus via	the Focus and FlipFocus	commands.

	      The FPFocusByFunctionWarpPointer style controls if  the  pointer
	      is warped	to a selected window when the Focus command is used.

	      FPLenient	 allows	 focus	on  windows  that do not want it, like
	      FvwmPager	or xclock.

	      The FPFocusClickButtons style takes a list of mouse buttons that
	      can  be  clicked to focus	or raise a window when the appropriate
	      style is used.  The default is to	use the	 first	three  buttons
	      ("123").

	      The  FPFocusClickModifiers  style	 takes a list of modifier keys
	      just like	the Key	command.  The exact  combination  of  modifier
	      keys must	be pressed for the click to focus or raise a window to
	      work.  The default is to use no modifiers	("N").

	      With the FPPassFocusClick	style, the click that was used to  fo-
	      cus a window is passed to	the application.

	      With  the	 FPAllowFocusClickFunction  style,  the	click that was
	      used to focus a window can also trigger a	normal action that was
	      bound to the window with the Mouse command).

	      If  the  FPIgnoreFocusClickMotion	 style	is used, clicking in a
	      window and then dragging the pointer with	the button  held  down
	      does  not	 count as the click to focus the window.  Instead, the
	      application processes these events normally.  This is useful  to
	      select  text in a	terminal window	with the mouse without raising
	      the window.  However, mouse bindings on the  client  window  are
	      not  guaranteed to work anymore (see Mouse command).  This style
	      forces the initial click to be passed to the  application.   The
	      distance	that the pointer must be moved to trigger this is con-
	      trolled by the MoveThreshold command.

	      The FPSortWindowlistByFocus and !FPSortWindowlistByFocus	styles
	      control  whether the internal window list	is sorted in the order
	      the windows were focused or in the order they were created.  The
	      latter is	the default for	ClickToFocus and SloppyFocus.

	      Clicking the window to raise

	      The  styles  FPClickRaisesFocused, FPClickDecorRaisesFocused and
	      FPClickIconRaisesFocused allow to	raise the window when the  in-
	      terior  or  the decorations or the icon of the window is clicked
	      while the	window is already focused.

	      The styles  FPClickRaisesUnfocused,  FPClickDecorRaisesUnfocused
	      and  FPClickIconRaisesUnfocused  allow  to raise the window when
	      the interior or the decorations or the icon  of  the  window  is
	      clicked while the	window is not yet focused.

	      With  the	 FPPassRaiseClick  style,  the	click that was used to
	      raise the	window is passed to the	application.

	      With the FPAllowRaiseClickFunction style,	 the  click  that  was
	      used  to	raise the window can also trigger a normal action that
	      was bound	to the window with the Mouse command.

	      If the FPIgnoreRaiseClickMotion style is	used,  clicking	 in  a
	      window  and  then	dragging the pointer with the button held down
	      does not count as	the click to raise the window.	 Instead,  the
	      application  processes these events normally.  This is useful to
	      select text in a terminal	window with the	mouse without  raising
	      the  window.   However,  mouse bindings on the client window are
	      not guaranteed to	work anymore (see Mouse	 command.   Note  that
	      this style forces	that the initial click is passed to the	appli-
	      cation.  The distance that the pointer must be moved to  trigger
	      this is controlled by the	MoveThreshold command.

	      Grabbing the focus when a	new window is created

	      New  normal or transient windows with the	FPGrabFocus or FPGrab-
	      FocusTransient style automatically receive the focus  when  they
	      are  created.   FPGrabFocus  is the default for windows with the
	      ClickToFocus style.  Note	that even if  these  styles  are  dis-
	      abled,  the application may take the focus itself.  Fvwm can not
	      prevent this.

	      The OverrideGrabFocus style instructs fvwm to  never  take  away
	      the focus	from such a window via the GrabFocus or	GrabFocusTran-
	      sient styles.  This can be useful	if you like to have  transient
	      windows  receive	the  focus  immediately,  for example in a web
	      browser, but not while you are working in	a terminal window or a
	      text processor.

	      The  above three styles are accompanied by FPReleaseFocus, FPRe-
	      leaseFocusTransient and FPOverrideReleaseFocus.	These  control
	      if  the  focus  is returned to another window when the window is
	      closed.  Otherwise no window or the  window  under  the  pointer
	      will receive the focus.

	      ClickToFocusPassesClickOff  and ClickToFocusPassesClick controls
	      whether a	mouse click to focus a window is sent to the  applica-
	      tion  or not.  Similarly,	ClickToFocusRaisesOff/MouseFocusClick-
	      RaisesOff	and  ClickToFocusRaises/MouseFocusClickRaises  control
	      if the window is raised (but depending on	the focus model).

	      Note:  in	 fvwm  versions	prior to 2.5.3,	the "Click..." options
	      applied only to windows with ClickToFocus	while  the  "Mouse..."
	      options  applied to windows with a different focus policy.  This
	      is no longer the case.

	      The old GrabFocus	style is equivalent  to	 using	FPGrabFocus  +
	      FPReleaseFocus.

	      The  old GrabFocusTransient style	is equivalent to using FPGrab-
	      FocusTransient + FPReleaseFocusTransient.

	      Lenience is equivalent to	the new	style FPLenient.

       Window title
	      The Title	and !Title options determine if	the window has	a  ti-
	      tle-bar or not.  By default all windows have a title-bar.	 NoTi-
	      tle is equivalent	to !Title but is deprecated.

	      Windows with  the	 TitleAtBottom,	 TitleAtLeft  or  TitleAtRight
	      style have a title-bar below, to the left	or to the right	of the
	      window instead of	above as usual.	 The TitleAtTop	style restores
	      the  default placement.  Even if the window has the !Title style
	      set, this	affects	the WindowShade	 command.   Please  check  the
	      WindowShade  command  for	 interactions between that command and
	      these styles.  Titles on the left	or right side of  the  windows
	      are augmented by the following styles:

	      Normally,	the text in titles on the left side of a window	is ro-
	      tated counterclockwise by	90 degrees from	the normal upright po-
	      sition  and  90  degrees clockwise for titles on the right side.
	      It can also be rotated in	the opposite directions	 with  LeftTi-
	      tleRotatedCW if TitleAtLeft is used, and with RightTitleRotated-
	      CCW if TitleAtRight is used.  The	defaults can be	restored  with
	      LeftTitleRotatedCCW  and RightTitleRotatedCW.  A normal horizon-
	      tal text may be rotated as well with TopTitleRotated if TitleAt-
	      Top  is  used,  and  with	BottomTitleRotated if TitleAtBottom is
	      used.  The defaults can be restored with TopTitleNotRotated  and
	      BottomTitleNotRotated.

	      By default the title bar decoration defined using	the TitleStyle
	      command is rotated following the title text  rotation  (see  the
	      previous	paragraph).  This can be disabled by using the !UseTi-
	      tleDecorRotation style.  UseTitleDecorRotation reverts  back  to
	      the default.

	      With the StippledTitle style, titles are drawn with the same ef-
	      fect that	is usually  reserved  for  windows  with  the  Sticky,
	      StickyAcrossPages	 or  StickyAcrossDesks	style.	!StippledTitle
	      reverts back to normal titles.  StippledTitleOff	is  equivalent
	      to !StippledTitle	but is deprecated.

	      Color  takes  two	arguments.  The	first is the window-label text
	      color and	the second is the window decorations normal background
	      color. The two colors are	separated with a slash.	 If the	use of
	      a	slash causes problems then the separate	 ForeColor  and	 Back-
	      Color options can	be used.

	      Colorset	takes  the  colorset  number  as its sole argument and
	      overrides	the colors set by Color.  Instead,  the	 corresponding
	      colors  from  the	 given colorset	are used.  Note	that all other
	      features of a colorset are not used.  Use	the  Colorset  decora-
	      tion  style  in the TitleStyle and ButtonStyle command for that.
	      To stop using the	colorset, the colorset number is omitted.

	      The HilightFore, HilightBack and HilightColorset	style  options
	      work exactly like	ForeColor, BackColor and Colorset but are used
	      only if the window has the focus.	 These styles replace the  old
	      commands HilightColor and	HilightColorset.

	      BorderColorset  takes  the  colorset number as its sole argument
	      and overrides the	colors set by Color or Colorset.  for the win-
	      dow border.  To stop using a colorset, the argument is omitted.

	      The  HilightBorderColorset  style	option works similarly to Bor-
	      derColorset but is used when the window has the focus.

	      !IconTitle disables displaying icon labels  while	 the  opposite
	      style   IconTitle	  enables  icon	 labels	 (default  behaviour).
	      NoIconTitle is equivalent	to !IconTitle but is deprecated.

	      IconTitleColorset	takes the colorset number as its sole argument
	      and  overrides the colors	set by Color or	Colorset.  To stop us-
	      ing this colorset, the argument is omitted.

	      HilightIconTitleColorset takes the colorset number as  its  sole
	      argument	and  overrides	the  colors set	by HilightColor	or Hi-
	      lightColorset.  To stop using this  colorset,  the  argument  is
	      omitted.

	      IconBackgroundColorset takes the colorset	number as its sole ar-
	      gument and uses it to set	a background for the icon picture.  By
	      default  the  icon picture is not	drawn onto a background	image.
	      To restore the default, the argument is omitted.

	      IconTitleRelief takes one	numeric	argument that may  be  between
	      -50  and	+50  pixels and	defines	the thickness of the 3D	relief
	      drawn around the icon title. With	negative values	the icon title
	      gets  a  pressed in look.	The default is 2 and it	is restored if
	      the argument is omitted.

	      IconBackgroundRelief takes one numeric argument that may be  be-
	      tween -50	and +50	pixels and defines the thickness of the	3D re-
	      lief drawn around	the icon picture  background  (if  any).  With
	      negative values the icon background gets a pressed in look.  The
	      default is 2 and it is restored if the argument is omitted.

	      IconBackgroundPadding takes one numeric argument that may	be be-
	      tween  0	and 50 pixels and defines the amount of	free space be-
	      tween the	relief of the icon background picture (if any) and the
	      icon  picture.  The default is 2 and it is restored if the argu-
	      ment is omitted.

	      The Font and IconFont options take the name of a font  as	 their
	      sole  argument.  This  font is used in the window	or icon	title.
	      By default the font given	in the DefaultFont  command  is	 used.
	      To  revert  back	to the default,	use the	style without the name
	      argument.	 These styles replace the older	WindowFont  and	 Icon-
	      Font commands.

	      The  IndexedWindowName style causes fvwm to use window titles in
	      the form
	      name (i)
	      where name is the	exact window name and i	is  an	integer	 which
	      represents  the i	th window with name as window name.  ExactWin-
	      dowName restores the default which is to use  the	 exact	window
	      name.   IndexedIconName  and  ExactIconName work the same	as In-
	      dexedWindowName and ExactWindowName styles but for the icon  ti-
	      tles.

       Title buttons
	      Button  and  !Button take	a numeric argument which is the	number
	      of the title-bar button which is to be included/omitted.	NoBut-
	      ton is equivalent	to !Button but is deprecated.

	      MwmButtons  makes	 the  Maximize button look pressed-in when the
	      window is	maximized.  See	the MwmDecorMax	 flag  in  ButtonStyle
	      for  more	 information.  To switch this style off	again, use the
	      FvwmButtons style.

       Borders

	      !Borders suppresses the window border (but not the  title)  com-
	      pletely.	 The  Borders  style enables them again.  Without bor-
	      ders, all	other styles affecting window borders are meaningless.

	      MwmBorder	makes the 3D bevel more	closely	match Mwm's.  FvwmBor-
	      der turns	off the	previous option.

	      With  the	!Handles style,	the window does	not get	the handles in
	      the window corners that are commonly used	to  resize  it.	  With
	      !Handles,	 the width from	the BorderWidth	style is used.	By de-
	      fault, or	if Handles is  specified,  the	width  from  the  Han-
	      dleWidth style is	used.  NoHandles is equivalent to !Handles but
	      is deprecated.

	      HandleWidth takes	a numeric argument which is the	width  of  the
	      border to	place the window if it does have resize-handles.

	      BorderWidth  takes  a numeric argument which is the width	of the
	      border to	place the window if it does not	 have  resize-handles.
	      It is used only if the !Handles style is specified too.

	      DepressableBorder	 makes	the border parts of the	window decora-
	      tion look	sunken in when a button	is pressed  over  them.	  This
	      can be disabled again with the FirmBorder	style.

       Icons, shading, maximizing, movement, resizing
	      Icon  takes  an (optional) unquoted string argument which	is the
	      icon bitmap or pixmap to use. Icons specified this way  override
	      pixmap icons, but	not icon windows or the	ewmh icon, provided by
	      the client in the	application (with  the	WM_HINTS  property  or
	      with  the	 ewmh  _NET_WM_ICON property).	The IconOverride style
	      changes the behavior to override any client-provided icons;  the
	      NoIconOverride  style  changes  the behavior to not override any
	      client-provided icons; the default overriding  behavior  can  be
	      activated	with the NoActiveIconOverride style.  With this	style,
	      fvwm uses	application provided icons if the icon is changed  but
	      uses the icon provided in	the configuration file until then.

	      There is one exception to	these rules, namely
	      Style * Icon unknown.xpm
	      doesn't force the	unknown.xpm icon on every window, it just sets
	      the default icon like the	DefaultIcon  command.  If  you	really
	      want all windows to have the same	icon, you can use
	      Style ** Icon unknown.xpm
	      If  the NoIcon attribute is set then the specified window	simply
	      disappears when it is iconified.	The window  can	 be  recovered
	      through  the  window-list.   If  Icon is set without an argument
	      then the NoIcon attribute	is cleared but no icon	is  specified.
	      An example which allows only the FvwmPager module	icon to	exist:
	      Style * NoIcon
	      Style FvwmPager Icon

	      IconBox  takes no	argument, four numeric arguments (plus option-
	      ally a screen specification), an	X11  geometry  string  or  the
	      string "none":
	      IconBox [screen scr-spec]	l t r b
	      or
	      IconBox geometry
	      Where  l	is the left coordinate,	t is the top, r	is right and b
	      is bottom.  Negative  coordinates	 indicate  distance  from  the
	      right  or	 bottom	 of  the screen.  If the first argument	is the
	      word screen, the scr-spec	argument specifies the Xinerama	screen
	      on  which	 the  IconBox  is defined.  It can be the usual	screen
	      Xinerama specification, 'p', 'c',	'g', a screen  number  or  the
	      additional  'w'  for  the	 screen	where the window center	is lo-
	      cated.  This is only useful with multiple	Xinerama screens.  The
	      "l  t  r b" specification	is more	flexible than an X11 geometry.
	      For example:
	      IconBox -80 240 -1 -1
	      defines a	box that is 80 pixels wide from	the  right  edge,  240
	      pixels  down  from  the  top, and	continues to the bottom	of the
	      screen.

	      Perhaps it is easier to use is an	X11 geometry string though:
	      IconBox 1000x70-1-1
	      places an	1000 by	70 pixel icon box on the bottom	of the	screen
	      starting in the lower right  hand	corner of the screen.  One way
	      to figure	out a geometry like this is to use a window  that  re-
	      sizes  in	 pixel	increments,  for example, xv.  Then resize and
	      place the	xv window where	you want the iconbox.  Then use	FvwmI-
	      dent  to read the	windows	geometry.  The icon box	is a region of
	      the screen where fvwm attempts to	put  icons  for	 any  matching
	      window,  as  long	 as they do not	overlap	other icons.  Multiple
	      icon boxes can be	defined	as overflow  areas.   When  the	 first
	      icon  box	is full, the second one	is filled.  All	the icon boxes
	      for one style must be defined in one Style command.   For	 exam-
	      ple:
	      Style * IconBox -80 240 -1 -1, \
		      IconBox 1000x70-1-1
	      A	 Style	command	 with the IconBox option replaces any icon box
	      defined previously by another Style command for the same	style.
	      Thats why	the backslash in the previous example is required.

	      Note: The	geometry for the icon box command takes	the additional
	      screen specifier "@w" in case a Xinerama setup  is  used.	  This
	      designates  the  screen where the	window center is located.  The
	      additional screen	specifier is not allowed anywhere else.

	      If you never define an icon box, or you fill all the icon	boxes,
	      fvwm has a default icon box that covers the screen, it fills top
	      to bottom, then left to right, and has an	80x80 pixel grid.   To
	      disable all but the default icon box you can use IconBox without
	      arguments	in a separate Style  command.	To  disable  all  icon
	      boxes including the default icon box, the	argument "none"	can be
	      specified.

	      Hint: You	can auto arrange your icons in the  icon  box  with  a
	      simple  fvwm function.  Put the "DeiconifyAndRearrange" function
	      below in your configuration file:
	      AddToFunc	DeiconifyAndRearrange
	       + C Iconify off
	       + C All (CurrentPage, Iconic) PlaceAgain	Icon
	      And then replace all places where	you call the  Iconify  command
	      to  de-iconify an	icon with a call to the	new function.  For ex-
	      ample replace
	      AddToFunc	IconFunc
	       + C Iconify off
	       + M Raise
	       + M Move
	       + D Iconify off

	      Mouse 1 I	A Iconify off
	      with
	      AddToFunc	IconFunc
	       + C DeiconifyAndRearrange
	       + M Raise
	       + M Move
	       + D DeiconifyAndRearrange

	      Mouse 1 I	A DeiconifyAndRearrange
	      IconGrid takes 2 numeric arguments greater than zero.
	      IconGrid x y
	      Icons are	placed in an icon box by stepping through the icon box
	      using  the  x and	y values for the icon grid, looking for	a free
	      space. The default grid is 3 by 3	pixels which gives  a  tightly
	      packed  appearance.  To get a more regular appearance use	a grid
	      larger than your largest icon. Use the  IconSize	definition  to
	      clip an icon to a	maximum	size. An IconGrid definition must fol-
	      low the IconBox definition that it applies to:
	      Style * IconBox -80x240-1-1, IconGrid 90 90
	      IconFill takes 2 arguments.
	      IconFill Bottom Right
	      Icons are	placed in an icon box by stepping through the icon box
	      using these arguments to control the direction the box is	filled
	      in. By default the direction is left to right, then top to  bot-
	      tom.  This would be expressed as:
	      IconFill left top
	      To fill an icon box in columns instead of	rows, specify the ver-
	      tical direction (top or bottom) first. The directions can	be ab-
	      breviated	 or  spelled  out  as follows: "t", "top", "b",	"bot",
	      "bottom",	"l", "lft", "left", "r", "rgt",	"right".  An  IconFill
	      definition  must	follow	the IconBox definition that it applies
	      to:
	      Style * IconBox -80x240-1-1, IconFill b r
	      IconSize sets limits on the size of an icon image.   Both	 user-
	      provided and application-provided	icon images are	affected.
	      IconSize [ width height [	maxwidth maxheight ] ]
	      All  arguments  are measured in pixels.  When all	four arguments
	      are passed to IconSize, width and	height represent  the  minimum
	      size  of an icon,	and maxwidth and maxheight represent the maxi-
	      mum size of an icon.  Icon images	that are smaller than the min-
	      imum size	are padded.  Icon images that are bigger than the max-
	      imum size	are clipped.

	      If only two arguments are	passed to IconSize, width  and	height
	      represent	 the  absolute size of an icon.	 Icons covered by this
	      style will be padded or clipped to achieve the given size.

	      If no arguments are specified, the default values	are  used  for
	      each  dimension.	 This effectively places no limits on the size
	      of an icon.

	      The value	of "-1"	can be used in place of	any of	the  arguments
	      to specify the default value for that dimension.

	      Note that	application-provided icon windows are not affected.

	      MiniIcon specifies a pixmap to use as the	miniature icon for the
	      window. This miniature icon can be drawn in a  title-bar	button
	      (see  ButtonStyle),  and	can  be	 used  by various fvwm modules
	      (FvwmWinList, FvwmIconMan	and FvwmTaskBar).  It takes  the  name
	      of a pixmap as an	argument.

	      WindowShadeShrinks  and  WindowShadeScrolls  control if the con-
	      tents of a window	that is	being shaded with the WindowShade com-
	      mand  are	 scrolled  (default)  or  if  they stay	in place.  The
	      shrinking	mode is	a bit faster

	      The WindowShadeSteps option selects the number of	steps for ani-
	      mation  when  shading  a	window with WindowShade.  It takes one
	      number as	its argument.  If the number has  a  trailing  'p'  it
	      sets  the	 number	of pixels to use as the	step size instead of a
	      fixed number of steps.  0	disables the animation.	 This  happens
	      too if the argument is omitted or	invalid.

	      The  WindowShade	command	 has  two modes	of operation: busy and
	      lazy shading.  Busy shading can be 50% slower than lazy shading,
	      but the latter can look strange under some conditions, for exam-
	      ple, if the window borders, buttons or the title are filled with
	      a	 tiled pixmap.	Also, the window handles are not drawn in lazy
	      mode and the border relief may only be drawn partially right be-
	      fore  the	 window	reaches	the shaded state or tight after	leaves
	      the unshaded state. By default, fvwm uses	lazy mode if there are
	      no bad visual effects (not counting the window handles) and busy
	      mode otherwise.  Use the WindowShadeAlwaysLazy  or  WindowShade-
	      Busy  to force using the lazy or busy mode.  The default setting
	      is restored with WindowShadeLazy.

	      ResizeOpaque instructs fvwm to resize the	corresponding  windows
	      with  their contents visible instead of using an outline.	 Since
	      this causes the application to redraw frequently it can be quite
	      slow  and	 make the window flicker excessively, depending	on the
	      amount of	graphics the application redraws.   The	 ResizeOutline
	      style  (default)	negates	the ResizeOpaque style.	 Many applica-
	      tions do not like	 their	windows	 being	resized	 opaque,  e.g.
	      XEmacs,  Netscape	 or terminals with a pixmap background.	If you
	      do not like the result, do not use the  ResizeOpaque  style  for
	      these  windows.	To exempt certain windows from opaque resizing
	      you could	use these lines	in your	configuration file:
	      Style * ResizeOpaque
	      Style rxvt ResizeOutline
	      Style emacs ResizeOutline
	      Sticky makes the window sticky, i.e. it  is  always  visible  on
	      each  page  and each desk.  The opposite style, Slippery reverts
	      back to the default.

	      StickyAcrossPages	and StickyAcrossPagesIcon work like Sticky and
	      StickyIcon,  but	stick  the window only across pages, not desks
	      while StickyAcrossDesks  and   StickyAcrossDesksIcon  works  the
	      other way	round.

	      Windows  that have been marked as	Sticky or StickyAcrossDesks or
	      StickyAcrossPages	will have  stipples  drawn  on	the  titlebar.
	      This  can	 be  negated with the !StickyStippledTitle style.  The
	      style StickyStippledTitle	puts back the stipples where that win-
	      dow  has	also been marked as Sticky.  Note that this is the de-
	      fault style for Sticky windows.  Sticky icons will have stipples
	      drawn  on	 the  icon title. This can be disabled in the same way
	      with the !StickyStippledIconTitle	style.

	      Windows with the StartIconic style are shown as icons initially.
	      Note  that  some	applications  counteract  that by deiconifying
	      themselves.  The default is to not iconify windows  and  can  be
	      set with the StartNormal style.

	      StickyIcon  makes	 the window sticky when	its iconified.	It de-
	      iconifies	on top the active desktop.  SlipperyIcon reverts  back
	      to the default.

	      StickyIconPage  works  like StickyIcon, but sticks the icon only
	      across pages, not	desks while StickyIconDesk works the other way
	      round.

	      StippledIconTitle	 works	like  StippledTitle  in	 that it draws
	      stipples on the titles  of  icons	 but  doesn't  make  the  icon
	      sticky.

	      IgnoreRestack  makes fvwm	ignore attempts	of clients to raise or
	      lower their own windows.	By default, the	 opposite  style,  Al-
	      lowRestack is active.

	      FixedPosition  and  FixedUSPosition make fvwm ignore attempts of
	      the user to move the window.  It is still	possible to  move  the
	      window  by  resizing it.	To allow the user to move windows, use
	      the VariablePosition or VariableUSPosition style.

	      FixedSize	and FixedUSSize	make fvwm ignore attempts of the  user
	      to  resize the window.  To allow the user	to resize windows, use
	      the VariableSize or VariableUSSize style.

	      FixedPPosition and FixedPSize make fvwm ignore attempts  of  the
	      program  to  move	 or resize its windows.	 To allow this kind of
	      actions,	use  the  VariablePPosition  or	 VariablePSize	style.
	      These  styles may	sometimes affect the initial placement and di-
	      mensions of new windows (depending on the	application).  If win-
	      dows  are	created	at strange places, try either the VariablePPo-
	      sition or	NoPPosition styles.  The FixedPSize style may screw up
	      window  dimensions for some applications.	 Do Not	use this style
	      in this case.

	      MoveByProgramMethod affects how fvwm reacts to requests  by  the
	      application  to move its windows.	 By default, fvwm tries	to de-
	      tect which method	to use,	but it	sometimes  detects  the	 wrong
	      method.	You  may  come across a	window that travels across the
	      screen by	a few pixels when the application resizes it, moves to
	      a	 screen	border with the	frame decorations off screen, that re-
	      members its position for the next	time it	starts but appears  in
	      a	 slighly  shifted  position,  or  that attepmts	to become full
	      screen but has the.  Try out both	options,  UseGravity  and  Ig-
	      noreGravity on the window	(and that window only) and see if that
	      helps.  By default, fvwm uses the	AutoDetect method.   Once  the
	      method was detected, it is never changed again.  As long as fvwm
	      can not detect the proper	method,	 it  uses  IgnoreGravity.   To
	      force  fvwm to retry the detection, use one of the other two op-
	      tions first and then use AutoDetect again.

	      Note:  This option was introduced	to alleviate  a	 problem  with
	      the  ICCCM2  specification.   The	ICCCM2 clearly states that the
	      UseGravity option	should be used,	but traditionally applications
	      ignored this rule.

	      Closable	enables	 the functions Close, Delete and Destroy to be
	      performed	on the windows.	This is	on by default.	The  opposite,
	      !Closable, inhibits the window to	be closed.

	      Iconifiable  enables the function	Iconify	to be performed	on the
	      windows.	This is	on by default.	 The  opposite,	 !Iconifiable,
	      inhibits the window from being iconified.

	      Maximizable enables the function Maximize	to be performed	on the
	      windows.	This is	on by default.	 The  opposite,	 !Maximizable,
	      inhibits the window from being maximized.

	      AllowMaximizeFixedSize  enables the function Maximize to be per-
	      formed on	windows	that are not  resizable,  unless  maximization
	      has been disabled	either using the style !Maximizable or through
	      WM hints.	 This is on by default.	 The opposite, !AllowMaximize-
	      FixedSize,  inhibits all windows that are	not resizable from be-
	      ing maximized.

	      ResizeHintOverride instructs fvwm	to ignore the program supplied
	      minimum and maximum size.	 This can be handy for broken applica-
	      tions that refuse	to be resized.	Do not use it if  you  do  not
	      need it.	The default (opposite) style is	NoResizeOverride.

	      MaxWindowSize  [ width [ p ]  height [ p ] ] Tells fvwm the max-
	      imum width and height of a window.  The values are the  percent-
	      age  of the total	screen area.  If the letter 'p'	is appended to
	      either of	the values, the	numbers	 are  interpreted  as  pixels.
	      This  command is useful to force large application windows to be
	      fully visible.  Neither height nor width may be  less  than  100
	      pixels.  If you omit the parameters or their values are invalid,
	      both limits are set to 32767 pixels (which is the	default).

	      With IconifyWindowGroups all windows in the  same	 window	 group
	      are  iconified  at once when group leader	is iconified.  The de-
	      fault is IconifyWindowGroupsOff, which disables  this  behavior.
	      Although	a number of applications use the window	group hint, it
	      is rarely	used in	a proper way, so it is probably	 best  to  use
	      IconifyWindowGroups only for selected applications.

       Window Manager placement
	      Applications  can	 place	windows	 at  a	particular spot	on the
	      screen either by window manager hints or a  geometry  specifica-
	      tion.  When they do neither, then	the window manager steps in to
	      find a place for the window.  Fvwm knows several	ways  to  deal
	      with this	situation. The default is TileCascadePlacement.

	      CenterPlacement  automatically  places new windows in the	center
	      of the display.

	      CascadePlacement automatically place new windows in a  cascading
	      fashion.

	      TileCascadePlacement automatically places	new windows in a smart
	      location - a location in which they do  not  overlap  any	 other
	      windows  on  the	screen.	 If no such position can be found Cas-
	      cadePlacement is used as a fall-back method.

	      TileManualPlacement This is the  same  as	 TileCascadePlacement,
	      but uses ManualPlacement as the fall-back	method.

	      UnderMousePlacement automatically	places new windows centered at
	      the current cursor position.

	      MinOverlapPlacement automatically	places new windows in a	 loca-
	      tion in which the	overlapping area in pixels of other windows is
	      minimized.  By default this  placement  policy  tries  to	 avoid
	      overlapping  icons  and  windows	on higher layers.  This	can be
	      configured with the MinOverlapPlacementPenalties style.

	      MinOverlapPercentPlacement is similar to MinOverlapPlacement but
	      tries  to	 minimize  the overlapped percentages of other windows
	      instead of the overlapped	area in	pixels.	 This placement	policy
	      tries  to	avoid covering other windows completely	and tries even
	      harder not to cover small	windows.  This can be configured  with
	      the MinOverlapPlacementPenalties and MinOverlapPercentPlacement-
	      Penalties	styles.

	      MinOverlapPlacementPenalties takes at most 6  positive  or  null
	      decimal arguments:
	      normal ontop icon	sticky below strut
	      if trailing arguments are	missing	the default is used which is:
	      1	5 10 1 0.05 50
	      This style configures the	MinOverlapPlacement and	MinOverlapPer-
	      centPlacement placement policy.  The normal factor affects  nor-
	      mal  windows,  the  ontop	 factor	affects	windows	with a greater
	      layer than the window being  placed,  the	 icon  factor  affects
	      icons,  the sticky factor	affects	sticky windows,	the below fac-
	      tor affects windows with a smaller layer than the	 window	 being
	      placed,  the  strut  factor  affects  the	complement of the EWMH
	      working area if the window being placed  has  the	 EWMHPlacemen-
	      tUseWorkingArea style and	windows	with an	EWMH strut hint	(i.e.,
	      a	"please	do not cover me" hint) if the window being placed  has
	      the  EWMHPlacementUseDynamicWorkingArea  style.	These  factors
	      represent	the amount of area that	these  types  of  windows  (or
	      area) are	counted	as, when a new window is placed.  For example,
	      by default the area of ontop windows is counted 5	times as  much
	      as  normal  windows.   So	MinOverlapPlacement and	MinOverlapPer-
	      centPlacement will cover 5 times as much area of another	window
	      before  it  will	cover an ontop window.	To treat ontop windows
	      the same as other	windows, set this to  1.   To  really,	really
	      avoid  putting  windows  under ontop windows, set	this to	a high
	      value, say 1000. This style affects the  window  already	mapped
	      and  not	the window which is currently placed. There is one ex-
	      ception to this rule: in the case	of the window being placed has
	      the  EWMHPlacementUseWorkingArea	style the strut	factor affects
	      the placed window.

	      MinOverlapPercentPlacementPenalties takes	at most	4 positive  or
	      null integer arguments:
	      cover_100	cover_95 cover_85 cover_75
	      if  trailing  arguments  are missing the defaults	are used which
	      are:
	      12 6 4 1
	      This style affects the MinOverlapPercentPlacement	placement pol-
	      icy  and	is  similar to the MinOverlapPlacementPenalties	style.
	      The cover_xx factor is used when the window being	placed	covers
	      at  least	 xx percent of the window. This	factor is added	to the
	      factor determined	by the MinOverlapPlacementPenalties style.

	      ManualPlacement (aka active placement). The user is required  to
	      place  every  new	 window	 manually.  The	window only shows as a
	      rubber band until	a place	is selected manually.  The  window  is
	      placed  when a mouse button or any key except Escape is pressed.
	      Escape aborts manual placement which places the  window  in  the
	      top left corner of the screen. If	mouse button 2 is pressed dur-
	      ing the initial placement	of a window  (respectively  Shift  and
	      mouse  button  1 in case Mwm emulation has been enabled with the
	      Emulate command),	the user is asked to resize the	window too.

	      It is possible to	define buttons usable to  place	 windows  with
	      the  Move	command	and the	special	context	'P' for	placement (see
	      Move command). However, you can't	redefine the way to  also  re-
	      size the window other than the way it is affected	by the Emulate
	      command. The button used for placing the window can  be  checked
	      with the PlacedByButton condition	(see Current command).

	      Example:
	      Style * ManualPlacement

	      *FvwmEvent: PassID
	      *FvwmEvent: add_window GrowDownFunc
	      AddToFunc	StartFunction
	      +	I FvwmEvent

	      AddToFunc	GrowDownFunc
	      +	I windowid $0 (PlacedByButton 3) \
		Resize bottomright keep	-0p

	      Now,  whenever a window is created and the user presses button 3
	      to finish	initial	placement, the	window	is  automatically  en-
	      larged until it hits the bottom screen border.

	      Old  placement  styles  DumbPlacement  / SmartPlacement /	Smart-
	      PlacementOff, CleverPlacement / CleverPlacementOff, ActivePlace-
	      ment / RandomPlacement, ActivePlacementsHonorsStartsOnPage / Ac-
	      tivePlacementsHonorsStartsOnPageOff,  GlobalOpts	SmartPlacemen-
	      tIsReallySmart  /	 GlobalOpts  SmartPlacementIsNormal  are still
	      supported	but will be removed in the future.  The	 old  and  new
	      styles can be translated according to the	following table:
	      GlobalOpts SmartPlacementIsReallySmart
	      Style * SmartPlacement
		-->
	      Style * SmartPlacement, CleverPlacement

	      GlobalOpts SmartPlacementIsNormal
	      Style * SmartPlacement
		-->
	      Style * SmartPlacement, CleverPlacementOff

	      Style * DumbPlacement, RandomPlacement
		-->
	      Style * CascadePlacement

	      Style * DumbPlacement, ActivePlacement
		-->
	      Style * ManualPlacement

	      Style * SmartPlacement, \
	      RandomPlacement, CleverPlacementOff
		-->
	      Style * TileCascadePlacement

	      Style * SmartPlacement, \
	      ActivePlacement, CleverPlacementOff
		-->
	      Style * TileManualPlacement

	      Style * SmartPlacement, CleverPlacement
		-->
	      Style * MinOverlapPlacement

	      Style * SmartPlacement, \
	      ActivePlacement, CleverPlacement
		-->
	      Style * MinOverlapPercentPlacement

	      Style * ActivePlacementsHonorsStartsOnPage
		-->
	      Style * ManualPlacementsHonorsStartsOnPage

	      Style * ActivePlacementsHonorsStartsOnPageOff
		-->
	      Style * ManualPlacementsHonorsStartsOnPageOff

       Placement policy	options	and window stacking
	      NoPPosition instructs fvwm to ignore the program specified posi-
	      tion (PPosition hint) when adding	new windows.  Using  PPosition
	      is required for some applications, but if	you do not have	one of
	      those its	a real headache.  Many programs	set PPosition to some-
	      thing obnoxious like 0,0 (upper left corner).

	      NoUSPosition works like NoPPosition but applies suppresses using
	      the user specified position indicated by the program (USPosition
	      hint).   It  is  generally  a  bad  thing	to override the	user's
	      choice, but some applications  misuse  the  USPosition  hint  to
	      force  their windows to a	certain	spot on	the screen without the
	      user's consent.

	      NoTransientPPosition and UseTransientPPosition work like	NoPPo-
	      sition and UsePPosition but apply	only to	transient windows.

	      NoIconPosition  instructs	 fvwm  to ignore the program specified
	      icon position (IconPosition hint)	when iconifying	the window.

	      StartsOnDesk takes a numeric argument which is the desktop  num-
	      ber  on  which the window	should be initially placed.  Note that
	      standard Xt programs can also specify this via a resource	 (e.g.
	      "-xrm '*Desk: 1'").

	      StartsOnPage  takes  1,  2,  or  3 numeric arguments.  If	one or
	      three arguments are given, the first (or only) argument  is  the
	      desktop  number.	If  three arguments are	given, the 2nd and 3rd
	      arguments	identify the x,y page position on the virtual  window.
	      If  two arguments	are given, they	specify	the page position, and
	      indicate no desk preference.  If only  one  argument  is	given,
	      StartsOnPage  functions  exactly	like  StartsOnDesk.  For those
	      standard Xt programs which understand this usage,	 the  starting
	      desk/page	 can  also  be	specified  via a resource (e.g., "-xrm
	      '*page: 1	0 2'").	 StartsOnPage in conjunction with  SkipMapping
	      is  a  useful  technique	when  you want to start	an app on some
	      other page and continue with what	you were  doing,  rather  than
	      waiting for it to	appear.

	      StartsOnScreen  takes  one argument.  It can be 'p' for the pri-
	      mary screen, 'c' for the current screen  (containing  the	 mouse
	      pointer),	 'g' for the global screen or the screen number	itself
	      (counting	from zero).  A new window is placed on	the  specified
	      Xinerama	screen.	 The default is	to place windows on the	screen
	      that contains the	mouse pointer at the time the window  is  cre-
	      ated.   However,	those  windows	which  are  not	placed by fvwm
	      (i.e., those with	a USPosition hint from a user specified	geome-
	      try)  are	 normally  placed in a position	relative to the	global
	      screen.  The StartsOnScreen style	is also	useful to cause	 these
	      windows  to  be  placed  relative	to a specific Xinerama screen.
	      For example:
	      Style * StartsOnScreen c
	      Would cause all windows, including those with their own geometry
	      to be placed relative to the current Xinerama screen rather than
	      the global screen.  For those standard Xt	programs which	under-
	      stand  this  usage, the starting desk/page can also be specified
	      via a resource (e.g., "-xrm '*fvwmscreen:	 c'").	 ('fvwmscreen'
	      was  chosen  because some	applications already use '.screen' for
	      other purposes.)

	      StartsOnPageIncludesTransients causes the	StartsOnPage style  to
	      be applied even for transient windows.  This is not usually use-
	      ful, since transients are	usually	pop ups	that you want  to  ap-
	      pear  in	your visible viewport; but occasionally	an application
	      uses a transient for something like a startup window that	 needs
	      to be coerced into place.

	      ManualPlacementIgnoresStartsOnPage  suppresses  StartsOnPage  or
	      StartsOnDesk placement in	the event  that	 both  ManualPlacement
	      and  SkipMapping	are  in	effect when a window is	created.  This
	      prevents you from	interactively placing a	window and  then  won-
	      dering  where it disappeared to, because it got placed on	a dif-
	      ferent desk or page.   ManualPlacementHonorsStartsOnPage	allows
	      this  to happen anyway.  The option has no effect	if SkipMapping
	      is not in	effect,	because	fvwm switches to the proper  desk/page
	      to  perform  interactive placement.  The default is ManualPlace-
	      mentIgnoresStartsOnPage;	     ManualPlacementHonorsStartsOnPage
	      matches  the  way	 the old StartsOnDesk style used to handle the
	      situation.

	      CaptureHonorsStartsOnPage	causes the initial capture (of an  al-
	      ready  existing window) at startup to place the window according
	      to the StartsOnPage and StartsOnScreen desk, page	 and  Xinerama
	      screen specification.  CaptureIgnoresStartsOnPage	causes fvwm to
	      ignore these settings (including StartsOnDesk) on	 initial  cap-
	      ture.  The default is CaptureIgnoresStartsOnPage.

	      RecaptureHonorsStartsOnPage causes a window to be	placed accord-
	      ing to, or revert	to, the	StartsOnPage and StartsOnScreen	 desk,
	      page  and	Xinerama screen	specification on Restart or Recapture.
	      RecaptureIgnoresStartsOnPage causes fvwm to respect the  current
	      window  position on Restart or Recapture.	 The default is	Recap-
	      tureIgnoresStartsOnPage.

	      Layer accepts one	optional  argument:  a	non-negative  integer.
	      This  is	the  layer  the	 window	 is put	in.  If	no argument is
	      given, any previously set	value is deleted and the default layer
	      is implied.

	      StaysOnTop  puts the window in the top layer.  This layer	can be
	      changed by the command DefaultLayers; the	default	is 6.

	      StaysPut puts the	window in the put layer.  This	layer  can  be
	      changed by the command DefaultLayers; the	default	is 4.

	      StaysOnBottom  puts  the window in the bottom layer.  This layer
	      can be changed by	the command DefaultLayers; the default is 2.

	      StartsLowered instructs fvwm to put the window initially at  the
	      bottom of	its layer rather than the default StartsRaised.

	      SkipMapping  tells  fvwm not to switch to	the desk the window is
	      on when it gets mapped initially (useful	with  StartsOnDesk  or
	      StartsOnPage).

	      KeepWindowGroupsOnDesk  makes  new  windows that have the	window
	      group hint set appear on the same	desk as	the other  windows  of
	      the  same	 group.	 Since this behavior may be confusing, the de-
	      fault setting is ScatterWindowGroups.  The window	group hint  is
	      ignored when placing windows in this case.

       Transient windows
	      DecorateTransient	 causes	 transient windows, which are normally
	      left undecorated,	to be given the	usual fvwm decorations	(title
	      bar,  buttons, etc.). Note that some pop-up windows, such	as the
	      xterm menus, are not managed by the window manager and still  do
	      not  receive  decorations.   NakedTransient (the default)	causes
	      transient	windows	not to be given	the standard decorations.  You
	      can  only	bind keys or mouse buttons to the sides	and the	client
	      part of an undecorated window ('S' and 'W' contexts in bindings,
	      see Mouse	and Key	commands).

	      A	 window	 with the RaiseTransient style that has	transient win-
	      dows raises all its transients when  it  is  raised.   The  Don-
	      tRaiseTransient  style  disables this behavior.  All windows are
	      then treated as if they had no transients.

	      A	window with the	LowerTransient style that has  transient  win-
	      dows lowers all its transients when it is	lowered.  The DontLow-
	      erTransient style	disables this behavior.	 All windows are  then
	      treated as if they had no	transients.

	      The  StackTransientParent	style augments RaiseTransient and Low-
	      erTransient styles.  Raising a window with  StackTransientParent
	      style  transfers the raise action	to the main window if the win-
	      dow being	raised is a transient and its main window  has	Raise-
	      Transient	style; this effect makes raise on a transient act just
	      like raise on its	main - the whole group is raised.  Similar be-
	      havior  holds  for lowering a whole group	of transients when the
	      main has LowerTransient style.   DontStackTransientParent	 turns
	      this  behavior off.  (Dont)StackTransientParent has no effect if
	      RaiseTransient and LowerTransient	are not	used.

	      A	reasonable emulation of	Motif  raise/lower  on	transients  is
	      possible like this
	      Style * RaiseTransient
	      Style * LowerTransient
	      Style * StackTransientParent

       Extended	Window Manager Hints styles
	      To  understand  the used terminology in this sub section,	please
	      read the section EXTENDED	WINDOW MANAGER HINTS.

	      EWMHDonateIcon instructs fvwm to set the application  ewmh  icon
	      hint  with the icon that is used by fvwm if the application does
	      not provide such hint (and if the	icon used by fvwm  is  not  an
	      icon  window).   EWMHDonateMiniIcon does the same	thing for mini
	      icons. This allows compliant pager, taskbar, iconbox  ...etc  to
	      display  the  same (mini)	icons as fvwm. Note that on some hard-
	      ware (e.g., 8-bit	displays) these	styles can  slow  down	window
	      mapping  and  that in general only one of	these styles is	needed
	      by a compliant application.  EWMHDontDonateIcon and  EWMHDontDo-
	      nateMiniIcon  restore the	defaults which are to not set any ewmh
	      (mini) icons hints.

	      By default, if an	application provides  an  ewmh	icon  hint  of
	      small  size  (i.e.,  height and width less than or equal to 22),
	      then fvwm	uses this icon as its mini icon.  EWMHMiniIconOverride
	      instructs	 fvwm  to  ignore  ewmh	icons and to use the mini icon
	      provided by the MiniIcon style.  EWMHNoMiniIconOverride restores
	      the default.

	      EWMHUseStackingOrderHints	 causes	fvwm to	use EWMH hints and re-
	      spect  EWMH  hints  which	 change	 the  window  layer.   EWMHIg-
	      noreStackingOrderHints causes fvwm to ignore EWMH	layer hints.

	      An application can ask for some reserved space on	the desktop by
	      a	hint.  In the EWMH terminology such a hint is called  a	 strut
	      and  it  is used to compute the working area and may be used for
	      window placement	and  in	 the  maximize	command.   EWMHIgnore-
	      StrutHints  causes  fvwm	to  ignore  such  hints,  as EWMHUseS-
	      trutHints, causes	fvwm to	use it which is	the default.

	      EWMHIgnoreStateHints causes fvwm to ignore  initial  EWMH	 state
	      hints when a new window is mapped. The default EWMHUseStateHints
	      causes fvwm to accept such hints.

	      EWMHIgnoreWindowType causes fvwm	to  ignore  EWMH  window  type
	      specification.  The default !EWMHIgnoreWindowType	causes fvwm to
	      style windows of specified types as such.

	      EWMHMaximizeIgnoreWorkingArea causes fvwm	 to  ignore  the  EWMH
	      working area when	it executes a Maximize command.	With EWMHMaxi-
	      mizeUseWorkingArea the EWMH working area is used as  with	 EWMH-
	      MaximizeUseDynamicWorkingArea  the  EWMH dynamic working area is
	      used (the	default).

	      EWMHPlacementIgnoreWorkingArea causes fvwm to  ignore  the  EWMH
	      working  area  when  it  places (or places again)	a window. With
	      EWMHPlacementUseWorkingArea the EWMH working area	 is  taken  in
	      account  as with EWMHPlacementUseDynamicWorkingArea the EWMH dy-
	      namic working area is taken in account (the default).  Note that
	      with   the  MinOverlapPlacement  and  MinOverlapPercentPlacement
	      placement	policy,	the way	the EWMH  (dynamic)  working  area  is
	      taken  in	 account is configurable with the MinOverlapPlacement-
	      Penalties	style.

       Miscellaneous
	      The BackingStore,	BackingStoreOff	and  BackingStoreWindowDefault
	      determine	 if  the X server uses backing store for the window or
	      not.  BackingStore means that the	X server tries to keep the ob-
	      scured  parts  of	a window in memory.  This is usually slower if
	      the client runs on the same machine as the X server, but can  be
	      much  faster  if	the connection is slow (see also SaveUnder be-
	      low).  BackingStoreOff disables backing store  for  the  window.
	      By default, fvwm does not	enable or disable backing store	itself
	      but leaves is as the window requested it.	 To revert back	to the
	      application's choice, use	the BackingStoreWindowDefault style.

	      Note: This style is useless if the X server does not allow back-
	      ing store.

	      SaveUnder	enables	the corresponding window attribute  in	the  X
	      server.	For  a	window using this style, the X server tries to
	      store the	graphics below it in memory which is usually slower if
	      the  client runs on the same machine as the X server.  SaveUnder
	      may speed	up fvwm	if the connection to  the  X  server  is  slow
	      (e.g.  over a modem link).  To disable save under, use the Save-
	      UnderOff style.  This is	the  default.  See  also  BackingStore
	      above.

	      Note:  This style	is useless if the X server does	not allow save
	      under.

	      ParentalRelativity enables clients that use a background	pixmap
	      of  type	ParentRelative	to  achieve transparency. Fvwm modules
	      that support transparent colorsets require this setting.	 Opac-
	      ity  is  the  default and	should be used for all non-transparent
	      clients for better performance.

	      MwmDecor makes fvwm attempt to recognize	and  respect  the  mwm
	      decoration  hints	that applications occasionally use.  To	switch
	      this style off, use the NoDecorHint style.

	      MwmFunctions makes fvwm attempt to recognize and respect the mwm
	      prohibited  operations hints that	applications occasionally use.
	      HintOverride makes fvwm shade out	operations that	mwm would pro-
	      hibit, but it lets you perform the operation anyway.  NoFuncHint
	      allows turns off the mwm hints completely.

	      OLDecor makes fvwm attempt to recognize and respect the olwm and
	      olvwm  hints  that  many	older XView and	OLIT applications use.
	      Switch this option off with NoOLDecor.

	      With GNOMEIgnoreHints fvwm ignores all GNOME hints for the  win-
	      dow,  even  if  GNOME compliance is compiled in.	This is	useful
	      for those	pesky applications that	try to be more clever than the
	      user  and	 use GNOME hints to force the window manager to	ignore
	      the user's preferences.  The GNOMEUseHints style	switches  back
	      to the default behavior.

	      UseDecor This style is deprecated	and will be removed in the fu-
	      ture.  There are plans to	replace	it with	a more flexible	 solu-
	      tion in fvwm-3.0.

	      UseDecor	accepts	one argument: the name of a decor created with
	      AddToDecor.  If no decor name is specified, the "Default"	 decor
	      is  used.	Windows	do not actually	contain	decors,	but are	always
	      assigned to one.	If  the	 decor	is  later  modified  with  Ad-
	      dToDecor,	 the changes are visible for all windows which are as-
	      signed to	it.  The decor for a window  can  be  reassigned  with
	      ChangeDecor.

	      UseStyle This style is deprecated	and will be removed in the fu-
	      ture.  There are plans to	replace	it with	a more flexible	 solu-
	      tion in fvwm-3.0.

	      UseStyle	takes  one  arg,  which	 is the	name of	another	style.
	      That way you can have unrelated window names easily inherit sim-
	      ilar traits without retyping.  For example:
		Style rxvt UseStyle XTerm
	      Warning:	If a style is built from one or	more parent styles and
	      the parent styles	are changed, the derived style	is  not	 modi-
	      fied. To achieve this you	have to	issue the UseStyle line	again.

	      Unmanaged	Windows	with the Unmanaged style option	are ignored by
	      fvwm.  They are not decorated, can not be	moved or resized, etc.
	      You  probably  want to use Bugopts RaiseOverUnmanaged too.  This
	      option can be turned off with the	 !Unmanaged  style.   However,
	      windows  that are	already	ignored	at the time when the option is
	      set must be recaptured with the Recapture	command	 in  order  to
	      become managed.

	      State  sets  the	initial	 value	of  one	of the 32 user defined
	      states which are associated with each window.  The state	number
	      ranges  from  0  to  31  and  must be given as an	argument.  The
	      states have no meaning in	fvwm, but they can be checked in  con-
	      ditional commands	like Next with the State condition and manipu-
	      lated with the State command.
	      #	turn on	state 11 for xterms ...
	      Style xterm State	11
	      #	... but	not for	rxvts.
	      Style rxvt !State	11

	      Windows with the WindowListSkip styles do	not appear in the menu
	      that  is	created	with the WindowList command or the lists shown
	      in several modules like FvwmIconMan or FvwmWinList.  In the mod-
	      ules,  the  style	can usually be ignored with an option.	Please
	      refer to the man page of the module in question for further  in-
	      formation.   To disable this feature, use	the default style Win-
	      dowListHit.

	      The styles CirculateSkip and CirculateHit	 control  whether  the
	      window  is considered by conditional commands, for example Next,
	      Prev or All.  Windows with CirculateSkip,	are never selected  by
	      conditional commands.  However, the styles can be	overridden ex-
	      plicitly in the condition	with the CirculateHit,	CirculateHitI-
	      con  or CirculateHitShaded conditions, and some conditional com-
	      mands, e.g.  Current and All, do this by	default.   The	styles
	      CirculateSkipIcon,   CirculateHitIcon,  CirculateSkipShaded  and
	      CirculateHitShaded work like CirculateSkip and CirculateHit  but
	      apply  only  to  iconic  or  shaded  windows.  Note: if multiple
	      ...Skip... options are combined, windows are  only  selected  if
	      they match none of the given conditions.	So, with
	      Style * CirculateSkipIcon, CirculateSkipShaded
	      only  windows  that  are neither iconic nor shaded are selected.
	      Note:  For historical reasons, the conditional  commands	under-
	      stand  the  names	of these styles	as condition names.  Take care
	      not to confuse them.

       Examples
	      #	Change default fvwm behavior to	no title-
	      #	bars on	windows! Also define a default icon.
	      Style *		  !Title,		 \
				  Icon unknown1.xpm,	 \
				  BorderWidth 4,	 \
				  HandleWidth 5

	      #	now, window specific changes:
	      Style Fvwm*	!Handles, Sticky,	 \
				WindowListSkip,		 \
				BorderWidth 0
	      Style FvwmPager	StaysOnTop, BorderWidth	0
	      Style *lock	!Handles, Sticky,	 \
				StaysOnTop, WindowListSkip
	      Style xbiff	Sticky,	WindowListSkip
	      Style FvwmButtons	!Handles, Sticky,	 \
				WindowListSkip
	      Style sxpm	!Handles

	      #	Put title-bars back on xterms only!
	      Style xterm     Title, Color black/grey

	      Style rxvt	Icon term.xpm
	      Style xterm	Icon rterm.xpm
	      Style xcalc	Icon xcalc.xpm
	      Style xbiff	Icon mail1.xpm
	      Style xmh		Icon mail1.xpm,		\
				  StartsOnDesk 2
	      Style xman	Icon xman.xpm
	      Style matlab	Icon math4.xpm,		\
				  StartsOnDesk 3
	      Style xmag	Icon magnifying_glass2.xpm
	      Style xgraph	Icon graphs.xpm
	      Style FvwmButtons	Icon toolbox.xpm
	      Style Maker	StartsOnDesk 1
	      Style signal	StartsOnDesk 3

	      #	Fire up	Netscape on the	second desk, in	the
	      #	middle of my 3x3 virtual desktop, and do not
	      #	bother me with it...
	      Style Netscape* SkipMapping,		\
			      StartsOnPage 1 1 1
	      Note that	all properties for a window are	 or'ed	together.   In
	      the  above  example "FvwmPager" gets the property	StaysOnTop via
	      an exact window name match but also gets	!Handles,  Sticky  and
	      WindowListSkip  by a match to "Fvwm*".  It gets !Title by	virtue
	      of a match to "*".  If conflicting styles	are  specified	for  a
	      window, then the last style specified is used.

       WindowStyle options
	      sets attributes (styles) on the selected window. The options are
	      exactly the same as for the Style	command.

   OTHER COMMANDS CONTROLLING WINDOW STYLES
       AddButtonStyle button [state] [style] [-- [!] flag ...]

	      Adds a button style to button.  button can be a  button  number,
	      or  one  of  "All", "Left" or "Right".  state can	be "ActiveUp",
	      "ActiveDown", "InactiveUp" or "InactiveDown", or	"Active"  (the
	      same  as	both  "ActiveUp"  and "ActiveDown") or "Inactive" (the
	      same as both "InactiveUp"	and "InactiveDown") or any of these  6
	      with  "Toggled" prepended.  The "Active" states apply to the fo-
	      cused window, the	"Inactive" ones	apply to  all  other  windows.
	      The  "Up"	 states	 apply	to the non pressed buttons, the	"Down"
	      ones apply to pressed buttons.  The "Toggled" prefix  refers  to
	      maximized,  shaded or sticky windows that	have the corresponding
	      MwmDecor...  button  style  set.	 Additionally,	the  following
	      shortcuts	 may  be used: "AllNormal", "AllToggled", "AllActive",
	      "AllInactive", "AllUp", "AllDown".  They are actually  different
	      masks for	4 individual states from 8 total.  These are supported
	      too: "AllActiveUp", "AllActiveDown", "AllInactiveUp",  "AllInac-
	      tiveDown".

	      If state is omitted, then	the style is added to every state.  If
	      the style	and flags are enclosed in parentheses,	then  multiple
	      state definitions	can be placed on a single line.	 Flags for ad-
	      ditional button styles cannot be changed after definition.

	      Buttons are drawn	in the order of	definition, beginning with the
	      most  recent  button style, followed by those added with AddBut-
	      tonStyle.	 To clear the button style stack, change style	flags,
	      or  for descriptions of available	styles and flags, see the But-
	      tonStyle command.	 Examples:
	      ButtonStyle 1 Pixmap led.xpm -- Top Left
	      ButtonStyle 1 ActiveDown HGradient 8 grey	\
		black
	      ButtonStyle All --  UseTitleStyle
	      AddButtonStyle 1 ActiveUp	(Pixmap	a.xpm)	\
		ActiveDown (Pixmap b.xpm -- Top)
	      AddButtonStyle 1 Vector 4	50x30@1	70x70@0	\
		30x70@0	50x30@1
	      Initially	for this example  all  button  states  are  set	 to  a
	      pixmap.	The second line	replaces the "ActiveDown" state	with a
	      gradient (it overrides the pixmap	assigned to it in the line be-
	      fore,  which assigned the	same style to every state).  Then, the
	      UseTitleStyle flag is set	for all	buttons, which causes fvwm  to
	      draw  any	styles set with	TitleStyle before drawing the buttons.
	      Finally, AddButtonStyle is used to place additional pixmaps  for
	      both  "ActiveUp"	and  "ActiveDown"  states  and a vector	button
	      style is drawn on	top of all states.

       AddTitleStyle [state] [style] [-- [!] flag ...]
	      Adds a title style to the	title-bar.  state can  be  "ActiveUp",
	      "ActiveDown",  "InactiveUp"  or "InactiveDown", or "Active" (the
	      same as both "ActiveUp" and  "ActiveDown")  or  "Inactive"  (the
	      same  as both "InactiveUp" and "InactiveDown") or	any of these 6
	      with "Toggled" prepended.	 If state is omitted, then  the	 style
	      is added to every	state.	If the style and flags are enclosed in
	      parentheses, then	multiple state definitions can be placed on  a
	      single  line.   This  command is quite similar to	the AddButton-
	      Style command (see above).

	      Title-bars are drawn in the order	of definition, beginning  with
	      the  most	recent TitleStyle, followed by those added with	AddTi-
	      tleStyle.	 To clear the title style stack, change	 style	flags,
	      or  for  the descriptions	of available styles and	flags, see the
	      TitleStyle and ButtonStyle commands.

       AddToDecor decor
	      This command is deprecated and will be removed  in  the  future.
	      There  are  plans	to replace it with a more flexible solution in
	      fvwm-3.0.

	      Add or divert commands to	the decor named	decor.	A decor	 is  a
	      name  given  to  the set of commands which affect	button styles,
	      title-bar	styles and border styles.  If decor does not exist  it
	      is  created;  otherwise  the  existing decor is modified.	 Note:
	      Earlier versions allowed to use  the  HilightColor,  HilightCol-
	      orset and	WindowFont commands in decors.	This is	no longer pos-
	      sible.  Please use the Style command  with  the  Hilight...  and
	      Font options.

	      New  decors  start  out exactly like the "default" decor without
	      any style	definitions.  A	given decor may	be applied to a	set of
	      windows  with the	UseDecor option	of the Style command.  Modify-
	      ing an existing decor affects all	windows	 which	are  currently
	      assigned to it.

	      AddToDecor  is  similar  in usage	to the AddToMenu and AddToFunc
	      commands,	except that menus and functions	are replaced  by  But-
	      tonStyle,	 AddButtonStyle, TitleStyle, AddTitleStyle and Border-
	      Style commands.  Decors created with AddToDecor can  be  manipu-
	      lated   with  ChangeDecor,  DestroyDecor,	 UpdateDecor  and  the
	      UseDecor Style option.

	      The following example creates  a	decor  "FlatDecor"  and	 style
	      "FlatStyle".  They are distinct entities:
	      AddToDecor FlatDecor
	      +	ButtonStyle All	\
		  Active   (-- flat) \
		  Inactive (-- flat)
	      +	TitleStyle  -- flat
	      +	BorderStyle -- HiddenHandles NoInset

	      Style FlatStyle \
		  UseDecor FlatDecor, HandleWidth 4, \
		  ForeColor   white, BackColor	 grey40, \
		  HilightFore black, HilightBack grey70

	      Style xterm UseStyle FlatStyle
	      An  existing  window's decor may be reassigned with ChangeDecor.
	      A	decor can be destroyed with DestroyDecor.
	      DestroyDecor FlatDecor
	      AddToDecor FlatDecor ...

	      Style FlatStyle UseDecor FlatDecor
	      and now apply the	style again:
	      Style xterm UseStyle FlatStyle

       BorderStyle [state] [style] [-- [!] flag	...]
	      Defines a	border style for windows.  state can  be  either  "Ac-
	      tive" or "Inactive".  If state is	omitted, then the style	is set
	      for both states.	If the style and flags are enclosed in	paren-
	      theses,  then  multiple  state  definitions can be specified per
	      line.

	      style is a subset	of the available button	styles,	and  can  only
	      be  TiledPixmap  (uniform	 pixmaps  which	match the bevel	colors
	      work best	this way) or Colorset. If a '!'	 is  prefixed  to  any
	      flag,  the behavior is negated.  If style	is not specified, then
	      one can change flags without resetting the style.

	      The HiddenHandles	flag hides the corner handle dividing lines on
	      windows  with  handles  (this  option has	no effect for NoHandle
	      windows).	 By default, HiddenHandles is disabled.

	      The NoInset flag supplements HiddenHandles.  If given, the inner
	      bevel around the window frame is not drawn.  If HiddenHandles is
	      not specified, the frame looks a little strange.

	      Raised causes a raised relief pattern  to	 be  drawn  (default).
	      Sunk  causes a sunken relief pattern to be drawn.	 Flat inhibits
	      the relief pattern from being drawn.

	      To decorate the active and inactive window borders with  a  tex-
	      tured pixmap, one	might specify:
	      BorderStyle Active TiledPixmap marble.xpm
	      BorderStyle Inactive TiledPixmap granite.xpm
	      BorderStyle Active -- HiddenHandles NoInset
	      To clear the style for both states:
	      BorderStyle Simple
	      To clear for a single state:
	      BorderStyle Active Simple
	      To unset a flag for a given state:
	      BorderStyle Inactive -- !NoInset
	      title-bar	 buttons can inherit the border	style with the UseBor-
	      derStyle flag (see ButtonStyle).

       ButtonState [ActiveDown bool] [Inactive bool] [InactiveDown bool]
	      The ButtonState command controls which states of the window  ti-
	      tles and title buttons are used.	The default is to use all four
	      states: "ActiveUp", "ActiveDown",	 "InactiveUp"  and  "Inactive-
	      Down" (see ButtonStyle and TitleStyle commands).	The bool argu-
	      ment after the key word controls if the designated state is used
	      ("True") or not ("False").  The "ActiveUp" state cannot be deac-
	      tivated. If no arguments are provided or the given arguments are
	      illegal, the default is restored.

	      If ActiveDown argument is	"False", no different button style for
	      the pressed down buttons used, instead "ActiveUp"	state is  used
	      even when	button is pressed.

	      If  Inactive  argument is	"False", focused and unfocused windows
	      look similarly, the corresponding	 "Active"  states  are	always
	      used.

	      If  InactiveDown argument	is "False" (only applied when Inactive
	      is "True"), the pressed titles and title buttons in  non-focused
	      windows  are  drawn  using "InactiveUp" or "ActiveUp" states de-
	      pending on the values of the other key words.

       ButtonStyle button [state] [style] [-- [!] flag ...]
	      Sets the button style for	a title-bar button.  button is the ti-
	      tle-bar  button number between 0 and 9, or one of	"All", "Left",
	      "Right", or "Reset".  Button numbering is	described in the Mouse
	      command  section.	 If the	style and flags	are enclosed in	paren-
	      theses, then multiple state definitions  can  be	specified  per
	      line.

	      state refers to which button state should	be set.	 Button	states
	      are defined as follows: "ActiveUp" and "ActiveDown" refer	to the
	      un-pressed  and  pressed	states	for buttons on active windows;
	      while the	"InactiveUp" and "InactiveDown"	states denote  buttons
	      on  inactive  windows.   The shortcut "Active" denotes both "Ac-
	      tiveUp" and "ActiveDown" states.	 Shortcut  "Inactive"  denotes
	      both  "InactiveUp" and "InactiveDown" states.  The similar state
	      names like just described, but with  the	"Toggled"  prefix  are
	      used  instead  for title buttons which have one of the MwmDecor-
	      Max, MwmDecorShade, MwmDecorStick	or MwmDecorLayer hints,	if the
	      window is	maximized, shaded, sticky or placed on specific	layer,
	      respectively.
	      AddToDecor Default
	       + ButtonStyle 6			 \
		 Vector	4 50x25@1 85x75@0 15x75@0 50x25@1
	       + ButtonStyle 6 ToggledActiveUp	 \
		 Vector	4 50x75@0 85x25@1 15x25@0 50x75@0
	       + ButtonStyle 6 ToggledActiveDown \
		 Vector	4 50x75@0 85x25@1 15x25@0 50x75@0
	       + ButtonStyle 6 ToggledInactive	 \
		 Vector	4 50x75@0 85x25@1 15x25@0 50x75@0
	       + ButtonStyle 6 - MwmDecorShade
	      Mouse 0 6	N WindowShade
	      Additionally, the	following shortcuts may	be used:  "AllNormal",
	      "AllToggled",  "AllActive",  "AllInactive",  "AllUp", "AllDown".
	      They are actually	different masks	for 4 individual states	from 8
	      total.  These are	supported too: "AllActiveUp", "AllActiveDown",
	      "AllInactiveUp", "AllInactiveDown".

	      If state is specified, that particular button state is set.   If
	      state  is	 omitted,  every state is set.	Specifying a style de-
	      stroys the current style (use AddButtonStyle to avoid this).

	      If style is omitted, then	state-dependent	flags can be  set  for
	      the  primary  button style without destroying the	current	style.
	      Examples (each line should be considered independent):
	      ButtonStyle Left -- flat
	      ButtonStyle All ActiveUp (-- flat) \
		Inactive (-- flat)
	      The first	line sets every	state of the  left  buttons  to	 flat,
	      while  the second	sets only the "ActiveUp" and "Inactive"	states
	      of every button to flat (only flags are  changed;	 the  buttons'
	      individual styles	are not	changed).

	      If you want to reset all buttons to their	defaults:
	      ButtonStyle Reset
	      To reset the "ActiveUp" button state of button 1 to the default:
	      ButtonStyle 1 ActiveUp Default
	      To  reset	all button states of button 1 to the default of	button
	      number 2:
	      ButtonStyle 1 Default 2
	      For any button, multiple state definitions can be	given  on  one
	      line  by	enclosing the style and	flags in parentheses.  If only
	      one definition per line is given the parentheses can be omitted.

	      flags affect the specified state.	 If a '!'  is prefixed to  any
	      flag,  its  behavior  is negated.	 The available state-dependent
	      flags for	all styles are described here (the  ButtonStyle	 entry
	      deals with state-independent flags).

	      Raised causes a raised relief pattern to be drawn.

	      Sunk causes a sunken relief pattern to be	drawn.

	      Flat inhibits the	relief pattern from being drawn.

	      UseTitleStyle  causes  the given button state to render the cur-
	      rent title style before rendering	the buttons' own styles.   The
	      Raised,  Flat  and  Sunk TitleStyle flags	are ignored since they
	      are redundant in this context.

	      UseBorderStyle causes the	button to inherit the  decorated  Bor-
	      derStyle options.

	      Raised,  Sunk and	Flat are mutually exclusive, and can be	speci-
	      fied for the initial ButtonStyle only.  UseTitleStyle  and  Use-
	      BorderStyle  are	also  mutually exclusive (both can be off how-
	      ever).  The default is  Raised  with  both  UseBorderStyle   and
	      UseTitleStyle left unset.

	      Important	 note  for the "ActiveDown" and	"InactiveDown" states:
	      When a button is pressed,	the relief is  inverted.   Because  of
	      this,  to	 obtain	 the raised look in "ActiveDown" or "Inactive-
	      Down" states you must specify the	opposite of the	desired	relief
	      (i.e.   Sunk for "ActiveDown" or "InactiveDown").	 This behavior
	      is consistent, but may seem confusing at first.	The  same  ap-
	      plies to the "Toggled" states.

	      Button  styles  are classified as	non-destructive, partially de-
	      structive, or fully destructive.	Non-destructive	styles do  not
	      affect  the image. Partially destructive styles can obscure some
	      or all parts of the underlying image (i.e.  Pixmap).  Fully  de-
	      structive	 styles	 obscure  the  entire  underlying  image (i.e.
	      Solid or one of the gradient styles).  Thus, if stacking	styles
	      with  AddButtonStyle (or AddTitleStyle for title-bars), use care
	      in sequencing styles to minimize redraw.

	      The available styles are:

	      Simple, Default, Solid, Colorset,	Vector,	?Gradient, Pixmap, Ad-
	      justedPixmap,  ShrunkPixmap, StretchedPixmap, TiledPixmap, Mini-
	      Icon

	      The description of these styles and their	arguments follow:

	      The Simple style does nothing.  There are	no arguments, and this
	      style is an example of a non-destructive button style.

	      The  Default  style conditionally	accepts	one argument: a	number
	      which specifies the default button number	to load.  If the style
	      command  given is	ButtonStyle or AddButtonStyle, the argument is
	      optional (if given, it overrides the current button).  If	a com-
	      mand  other than ButtonStyle or AddButtonStyle is	used, the num-
	      ber must be specified.

	      The Solid	style fills the	button with a solid color.  The	relief
	      border  color is not affected.  The color	is specified as	a sin-
	      gle argument.  This style	is fully destructive.

	      The Colorset cs [alpha] style fills the button with the Colorset
	      cs.   The	 optional alpha	argument is a percentage between 0 and
	      100. It causes fvwm to merge the colorset	 background  onto  the
	      button  using  this  percentage. If the percentage is 0 the col-
	      orset background is hidden and if	it is 100 the  colorset	 back-
	      ground  is  fully	 applied. The default is 100. So, the destruc-
	      tiveness depends on the alpha argument.

	      The Vector num X[offsetp]xY[offsetp]@C ...  style	draws  a  line
	      pattern.	 Since	this  is  a standard button style, the keyword
	      Vector is	optional, num is a number of point  specifications  of
	      the  form	X[offsetp]xY[offsetp]@C	...  X and Y are point coordi-
	      nates inside the button, given in	percents (from 0 to 100).   An
	      optional absolute	offset in pixels, can be given as "+<offset>p"
	      for a positive or	"-<offset>p" for a negative offset.

	      C	specifies a line color (0 - the	shadow color, 1	 -  the	 high-
	      light color, 2 - the background color, 3 - the foreground	color,
	      4	- only move the	point, do not draw).  The first	point color is
	      not  used.   You	can  use up to 10000 points in a line pattern.
	      This style is partially destructive.

	      The specification	is a little cumbersome:
	      ButtonStyle 2 Vector 4 50x30@1 70x70@0 \
		30x70@0	50x30@1
	      then the button 2	decoration uses	a 4-point  pattern  consisting
	      of  a line from (x=50,y=30) to (70,70) in	the shadow color (@0),
	      and then to (30,70) in the shadow	color, and finally to  (50,30)
	      in  the  highlight  color	(@1).  Is that too confusing?  See the
	      fvwm web pages for some examples with screenshots.

	      A	more complex example of	Vector:
	      ButtonStyle 8 Vector 10 45x65@2 45x75@3 \
		20x75@3	20x50@3	35x50@3	35x65@1	35x25@1	\
		75x25@1	75x65@0	35x65@0
	      ButtonStyle 0 Vector 10 45x65@2 45x75@0 \
		20x75@0	20x50@1	45x50@1	45x65@0	75x65@3	\
		75x25@3	35x25@3	35x47@3
	      The ?Gradient styles denote color	gradients.  Fill in the	 ques-
	      tion  mark  with	any one	of the defined gradient	types.	Please
	      refer to the COLOR GRADIENTS section for a  description  of  the
	      gradient syntax.	The gradient styles are	fully destructive.

	      The  Pixmap  style displays a pixmap.  A pixmap should be	speci-
	      fied as an argument.  For	example, the following would give but-
	      ton  number  2  the same pixmap for all 4	states (2 active and 2
	      inactive), and button number 4 all different pixmaps.
	      ButtonStyle 2 Pixmap my_pixmap.xpm
	      ButtonStyle 4 \
		ActiveUp   (Pixmap activeup.xpm) \
		ActiveDown (Pixmap activedown.xpm) \
		Inactive   (Pixmap inactiveup.xpm)
	      ButtonStyle 4 \
		InactiveDown Pixmap inactivedown.xpm
	      The pixmap specification can be given as an absolute or relative
	      pathname	(see  ImagePath).   If the pixmap cannot be found, the
	      button style reverts to Simple.  Flags specific  to  the	Pixmap
	      style  are  Left,	 Right,	Top, and Bottom.  These	can be used to
	      justify the pixmap (default is centered  for  both  directions).
	      Pixmap transparency is used for the color	"None."	 This style is
	      partially	destructive.

	      The AdjustedPixmap style is similar to the Pixmap	style. But the
	      image is resized to exactly fit the button.

	      The  ShrunkPixmap	 style	is similar to the Pixmap style.	But if
	      the image	is bigger than the button the image is resized to  fit
	      into the button.

	      The StretchedPixmap style	is similar to the Pixmap style.	But if
	      the image	is smaller than	the button the	image  is  resized  to
	      cover the	button.

	      The TiledPixmap style accepts a pixmap to	be tiled as the	button
	      background. One pixmap is	 specified  as	an  argument.	Pixmap
	      transparency is not used.	 This style is fully destructive.

	      The MiniIcon style draws the window's miniature icon in the but-
	      ton, which is specified with the MiniIcon	option	of  the	 Style
	      command.	This button style accepts no arguments.	 Example:
	      Style *	  MiniIcon mini-bx2.xpm
	      Style xterm MiniIcon mini-term.xpm
	      Style Emacs MiniIcon mini-doc.xpm

	      ButtonStyle 1 MiniIcon

       ButtonStyle button - [!]flag ...
	      Sets  state-independent  flags for the specified button.	State-
	      independent flags	affect button behavior.	 Each  flag  is	 sepa-
	      rated  by	 a  space.  If a '!'  is prefixed to the flag then the
	      behavior is negated.  The	special	flag Clear clears any existing
	      flags.

	      The  following flags are usually used to tell fvwm which buttons
	      should be	affected by mwm	function hints (see  MwmFunctions  op-
	      tion of the Style	command.  This is not done automatically since
	      you might	have buttons bound to complex functions, for instance.

	      MwmDecorMenu should be assigned to title-bar buttons which  dis-
	      play  a  menu.   The  default assignment is the leftmost button.
	      When a window with the MwmFunctions Style	option requests	not to
	      show this	button,	it is hidden.

	      MwmDecorMin  should be assigned to title-bar buttons which mini-
	      mize or iconify the window.  The default assignment is the  sec-
	      ond  button  over	from the rightmost button.  When a window with
	      the MwmFunctions Style option requests not to show this  button,
	      it is hidden.

	      MwmDecorMax  should be assigned to title-bar buttons which maxi-
	      mize the window. The default assignment is the rightmost button.
	      When a window with the MwmFunctions Style	option requests	not to
	      show this	button,	it is hidden.  When the	window	is  maximized,
	      the vector pattern on the	button looks pressed in.

	      MwmDecorShade  should  be	 assigned  to  title-bar buttons which
	      shade the	window (see WindowShade	command).  When	the window  is
	      shaded, the vector pattern on the	button looks pressed in.

	      MwmDecorStick should be assigned to title-bar buttons which make
	      the window sticky. When the window is sticky, the	vector pattern
	      on the button looks pressed in.

	      The  flag	 MwmDecorLayer	layer  should be assigned to title-bar
	      buttons which place the window  in  the  layer  numbered	layer.
	      When the window is on that specific layer, the vector pattern on
	      the button looks pressed in.

       ChangeDecor decor
	      This command is deprecated and will be removed  in  the  future.
	      There  are  plans	to replace it with a more flexible solution in
	      fvwm-3.0.

	      Changes the decor	of a window to decor.  decor is	 "Default"  or
	      the  name	 of  a decor defined with AddToDecor.  If decor	is in-
	      valid, nothing occurs.  If called	from somewhere in a window  or
	      its  border,  then  that window is affected.  If called from the
	      root window the user is allowed to  select  the  target  window.
	      ChangeDecor  only	 affects attributes which can be set using the
	      AddToDecor command.
	      ChangeDecor CustomDecor1

       DestroyDecor [recreate] decor
	      This command is deprecated and will be removed  in  the  future.
	      There  are  plans	to replace it with a more flexible solution in
	      fvwm-3.0.

	      Deletes the decor	defined	with AddToDecor,  so  that  subsequent
	      references  to it	are no longer valid.  Windows using this decor
	      revert to	the "Default" decor. The optional  parameter  recreate
	      tells  fvwm  not to throw	away the decor completely but to throw
	      away only	its contents. If the decor  is	created	 again	later,
	      windows do not use it before the UseDecor	style is applied again
	      unless the decor was destroyed with the  recreate	 option.   The
	      decor named "Default" cannot be destroyed.
	      DestroyDecor CustomDecor1

       TitleStyle [justification] [Height [num]] [MinHeight [num]]
	      Sets  attributes	for the	title-bar.  Justifications can be Cen-
	      tered, RightJustified or LeftJustified.  Height sets  the	 title
	      bar's height to an amount	in pixels.  MinHeight sets the minimal
	      height in	pixels of the title bar.  Defaults are	Centered,  the
	      window's	font  height and no minimal height.  To	reset the font
	      height to	the default value, omit	the  num  argument  after  the
	      Height  keyword. The MinHeight height is reseted by Height or if
	      given with no argument.  Example:
	      TitleStyle LeftJustified Height 24

       TitleStyle [state] [style] [-- [!] flag ...]
	      Sets the style for the title-bar.	 See  also  AddTitleStyle  and
	      ButtonStyle.  state can be one of	"ActiveUp", "ActiveDown", "In-
	      activeUp", or "InactiveDown".  Shortcuts like "Active" and  "In-
	      active"  are  allowed.  The states with the "Toggled" prefix are
	      allowed too, the title itself does not use "Toggled" states, but
	      these  states  are  used for the buttons with ButtonStyle	UseTi-
	      tleStyle.	 If state is omitted, then the style is	added to every
	      state.   If  parentheses	are placed around the style and	flags,
	      then multiple state definitions can be given  per	 line.	 style
	      can be omitted so	that flags can be set while not	destroying the
	      current style.

	      If a '!'	is prefixed to any  flag,  its	behavior  is  negated.
	      Valid  flags for each state include Raised, Flat and Sunk	(these
	      are mutually exclusive).	The default is Raised.	See  the  note
	      in ButtonStyle regarding the "ActiveDown"	state.	Examples:
	      TitleStyle ActiveUp HGradient 16 navy black
	      TitleStyle ActiveDown (Solid red -- flat)	\
		  Inactive (TiledPixmap	wood.xpm)
	      TitleStyle ActiveUp (-- Flat) ActiveDown	\
		  (-- Raised) InactiveUp (-- Flat) \
		  InactiveDown (-- Sunk)
	      This  sets  the  "ActiveUp"  state to a horizontal gradient, the
	      "ActiveDown" state to solid red, and the "Inactive" states to  a
	      tiled  wood pixmap. Finally, "ActiveUp" and "InactiveUp" are set
	      to look flat, while "ActiveDown" set to be sunk (the Raised flag
	      for  the	"ActiveDown" state causes it to	appear sunk due	to re-
	      lief inversion), and "InactiveDown" is set to  look  raised.  An
	      example which sets flags for all states:
	      TitleStyle -- flat
	      For a flattened look:
	      TitleStyle -- flat
	      ButtonStyle All Active (-- flat) Inactive	(-- flat)

	      TitleStyle accepts all the ButtonStyle
	       styles and arguments:

	      Simple, Default, Solid, Colorset,	Vector,	?Gradient, Pixmap, Ad-
	      justedPixmap, ShrunkPixmap, StretchedPixmap, TiledPixmap,	 Mini-
	      Icon.

	      See  the	ButtonStyle  command  for  a  description of all these
	      styles and their arguments.

	      In addition to these styles TitleStyle accepts a powerful	Multi-
	      Pixmap  option.  This  allows  you to specify different pixmaps,
	      colorsets	or colors for different	parts of the titlebar. Some of
	      them  are	 tiled	or stretched to	fit a particular space;	others
	      are discrete "transition"	images.	The definable sections are:
	      Main
		The full titlebar
	      LeftMain
		Left of	title text
	      RightMain
		Right of title text
	      UnderText
		Underneath title text
	      LeftOfText
		just to	the left of the	title text
	      RightOfText
		just to	the right of the title text
	      LeftEnd
		at the far left	end of the titlebar
		(just after left buttons if any)
	      RightEnd
		at the far right end of	the titlebar
		(just before right buttons if any)
	      Buttons
		under buttons in case of UseTitleStyle
	      LeftButtons
		under left buttons in case of UseTitleStyle
	      RightButtons
		under right buttons in case of UseTitleStyle
	      None of these are	mandatory except for Main (or, if you  do  not
	      define  Main,  you must define both LeftMain and RightMain).  If
	      no Buttons pixmaps are defined and  UseTitleStyle	 is  specified
	      for  one	or more	buttons, Main, LeftMain, or RightMain are used
	      as appropriate.

	      The syntax for this style	type is:
	      MultiPixmap section style	arg, ...
	      continuing for whatever you want to define. The style can	be ei-
	      ther  TiledPixmap,  AdjustedPixmap,  Colorset or Solid.  See the
	      ButtonStyle command for the description of these styles.	In the
	      case  of	a transition section, LeftEnd, LeftOfText, RightOfText
	      or RightEnd, AdjustedPixmap only resize the pixmap  in  the  "y"
	      direction. For the Colorset and Solid styles a width of the half
	      of the title bar height is assumed for the transition sections.

	      An example:
	      MultiPixmap Main AdjustedPixmap foo.xpm, \
			  UnderText TiledPixmap	bar.xpm, \
			  Buttons Colorset 2
	      Note that	the old	syntax is still	supported:  if	the  style  is
	      omitted, TiledPixmap is assumed and adding "(stretched)" between
	      the section and the file name implies AdjustedPixmap.

       UpdateDecor [decor]
	      This command is deprecated and will be removed  in  the  future.
	      There  are  plans	to replace it with a more flexible solution in
	      fvwm-3.0.

	      This command is kept mainly for backward	compatibility.	 Since
	      all  elements  of	 a decor are updated immediately when they are
	      changed, this command is mostly useless.

	      Updates window decorations.  decor is an optional	argument which
	      specifies	the decor to update.  If given,	only windows which are
	      assigned to that particular decor	are updated.  This command  is
	      useful, for instance, after a ButtonStyle, TitleStyle or Border-
	      Style (possibly used in conjunction with AddToDecor).   Specify-
	      ing an invalid decor results in all windows being	updated.  This
	      command is less disturbing than Recapture, but does  not	affect
	      window style options as Recapture	does.

   COMMANDS CONTROLLING	THE VIRTUAL DESKTOP
       Desk arg1 [arg2]	[min max]
	      This command has been renamed.  Please see GotoDesk command.

       DesktopName desk	name
	      Defines  the name	of the desktop number desk to name.  This name
	      is used in the WindowList	command	and in the FvwmPager where  it
	      override	the  Label configuration option. Moreover, if consecu-
	      tive names starting from desktop 0 are defined, then these names
	      can be used by any EWMH compliant	application (as	a pager).

       DeskTopSize HorizontalxVertical
	      Defines the virtual desktop size in units	of the physical	screen
	      size.

       EdgeResistance scrolling	moving [xinerama-moving]
	      Tells how	hard it	should be to change the	 desktop  viewport  by
	      moving  the  mouse  over	the edge of the	screen and how hard it
	      should be	to move	a window over the edge of the screen.

	      The first	parameter tells	how many milliseconds the pointer must
	      spend  on	 the screen edge before	fvwm moves the viewport.  This
	      is intended for people who use
	      EdgeScroll 100 100
	      but find themselves accidentally flipping	pages when they	do not
	      want to.

	      The  second parameter tells how many pixels over the edge	of the
	      screen a window's	edge must move before it actually  moves  par-
	      tially  off the screen.  By default the viewport is moved	a full
	      page in the requested direction, but if you used EdgeScroll  and
	      set any values other than	zero they are used instead.

	      Note that, with
	      EdgeScroll 0 0
	      it  is  still possible to	move or	resize windows across the edge
	      of the current screen.  By making	the first parameter to EdgeRe-
	      sistance	10000 this type	of motion is impossible.  With EdgeRe-
	      sistance less than 10000 but greater than	0  moving  over	 pages
	      becomes difficult	but not	impossible.  See also EdgeThickness.

	      The  optional  third  parameter does the same as the second, but
	      for individual Xinerama screens.	 If  omitted,  xinerama-moving
	      will be set to the value of moving.  Set xinerama-moving to zero
	      to ignore	individual screen edges.  Note that the	center of  the
	      window  being  moved determines the xinerama screen on which the
	      window should be kept.

       EdgeScroll horizontal[p]	vertical[p] [wrap|wrapx|wrapy]
	      Specifies	the percentage of a page to  scroll  when  the	cursor
	      hits the edge of a page.	A trailing 'p' changes the interpreta-
	      tion to mean pixels.  If you do not want any paging or scrolling
	      when you hit the edge of a page include
	      EdgeScroll 0 0
	      in  your	config file, or	possibly better, set the EdgeThickness
	      to zero.	See the	 EdgeThickness	command.  If  you  want	 whole
	      pages, use
	      EdgeScroll 100 100
	      Both horizontal and vertical should be positive numbers.

	      If  the  horizontal  and	vertical percentages are multiplied by
	      1000 or one of the keywords wrap,	wrapx and wrapy	is given  then
	      scrolling	wraps around at	the edge of the	desktop.  If
	      EdgeScroll 100000	100000
	      is used fvwm scrolls by whole pages, wrapping around at the edge
	      of the desktop.

       EdgeThickness 0|1|2
	      This is the width	or height of the invisible  window  that  fvwm
	      creates  on  the	edges of the screen that are used for the edge
	      scrolling	feature.

	      In order to enable page scrolling	via the	 mouse,	 four  windows
	      called  the  "pan	 frames"  are  placed  at the very edge	of the
	      screen. This is how fvwm detects the  mouse's  presence  at  the
	      window  edge.  Because of	the way	this works, they need to be at
	      the top of the stack and eat mouse events, so if	you  have  any
	      kind  of	error along the	lines of: "mouse clicks	at the edge of
	      the screen do the	wrong thing" you're having  trouble  with  the
	      pan  frames  and	(assuming you do not use the mouse to flip be-
	      tween pages) should set the EdgeThickness	to 0.

	      A	value of 0 completely  disables	 mouse	edge  scrolling,  even
	      while dragging a window.	1 gives	the smallest pan frames, which
	      seem to work best	except on some servers.

	      2	is the default.

	      Pan frames of 1 or 2 pixels can sometimes	be confusing, for  ex-
	      ample, if	you drag a window over the edge	of the screen, so that
	      it straddles a pan frame,	clicks on the window, near the edge of
	      the screen are treated as	clicks on the root window.

       EwmhBaseStruts left right top bottom
	      Where  left, right, top and bottom are positive or null integers
	      which define bands at the	edge of	the screen.   left  defines  a
	      band  on	the left of your screen	of width left, right defines a
	      band on the right	of your	screen of width	right, top  defines  a
	      band  on the top of your screen of height	top and	bottom defines
	      a	band on	the bottom of your screen of height bottom.  The  unit
	      is the pixel and the default is 0	0 0 0.	These areas define ad-
	      ditional reserved	space to the reserved space  defined  by  some
	      ewmh compliant applications. This	is used	to compute the Working
	      Area. See	the EXTENDED WINDOW MANAGER HINTS section for a	 defi-
	      nition of	the Working Area.

       EWMHNumberOfDesktops num	 [max]
	      This  command  is	 useful	 only  for  an ewmh compliant pager or
	      taskbar (as kpager or kicker taskbar) and	not for	 fvwm  modules
	      (FvwmPager or FvwmIconMan). It causes a compliant	application to
	      consider at least	num desktops (desktop  0  to  desktop  num-1).
	      The  optional  argument  max  causes  a compliant	application to
	      never consider more than max desktops. If	max is 0 (the default)
	      there is no limitation.  The actual number of desktops is	deter-
	      mined dynamically.  It is	at least num, but it can be d if there
	      is a window on desktop d-1 (or if	the current desktop is desktop
	      d-1) and d is less or equal to max or max	is null.  Moreover,  a
	      compliant	 pager can ask to change num itself.  This is accepted
	      by fvwm only if this number is less than or equal	to max	or  if
	      max  is  null.  Note that	negative desktops are not supported by
	      the ewmh specification.  The default is 4	0.

       GotoDesk	prev | arg1 [arg2] [min	max]
	      Switches the current viewport  to	 another  desktop  (workspace,
	      room).

	      The command takes	1, 2, 3, or 4 arguments.  A single argument is
	      interpreted as a relative	desk number.  Two arguments are	under-
	      stood  as	 a  relative and an absolute desk number.  Three argu-
	      ments specify a relative desk and	the minimum and	maximum	of the
	      allowable	 range.	Four arguments specify the relative, absolute,
	      minimum and maximum values.  (Desktop numbers can	be  negative).
	      If a literal prev	is given as the	single argument, the last vis-
	      ited desk	number is used.

	      If arg1 is non zero then the next	desktop	number is the  current
	      desktop number plus arg1.

	      If  arg1	is zero	then the new desktop number is arg2.  (If arg2
	      is not present, then the command has no effect.)

	      If min and max are given,	the new	desktop	number is  no  smaller
	      than  min	 and no	bigger than max.  Values out of	this range are
	      truncated	(if you	gave  an  absolute  desk  number)  or  wrapped
	      around (if you gave a relative desk number).

	      The  syntax  is the same as for MoveToDesk, which	moves a	window
	      to a different desktop.

	      The number of active desktops is determined  dynamically.	  Only
	      desktops	which contain windows or are currently being displayed
	      are active.  Desktop numbers  must  be  between  2147483647  and
	      -2147483648 (is that enough?).

       GotoDeskAndPage prev | desk xpage ypage
	      Switches the current viewport to another desktop and page, simi-
	      lar to the GotoDesk and GotoPage commands.  The new desk is desk
	      and the new page is (xpage,ypage).

       GotoPage	prev | [options] x [p] y [p]
	      Moves  the  desktop viewport to page (x,y).  The upper left page
	      is (0,0),	the upper right	is (M,0), where	M is one less than the
	      current  number of horizontal pages specified in the DeskTopSize
	      command.	The lower left page is (0,N), and the lower right page
	      is (M,N),	where N	is the desktop's vertical size as specified in
	      the DeskTopSize command.	To switch to a page  relative  to  the
	      current one add a	trailing 'p' after any or both numerical argu-
	      ments.

	      Possible options are wrapx and wrapy to wrap around the x	 or  y
	      coordinate  when	the viewport is	moved beyond the border	of the
	      desktop.

	      To go to the last	visited	page use prev as the  first  argument.
	      The GotoPage function should not be used in a pop-up menu.

	      Examples:
	      #	Go to page (2,3)
	      GotoPage 2 3

	      #	Go to lowest and rightmost page
	      GotoPage -1 -1

	      #	Go to last page	visited
	      GotoPage prev

	      #	Go two pages to	the right and one page up
	      GotoPage +2p -1p

       Scroll horizonal	[p] vertical [p]
	      Scrolls  the  virtual  desktop's viewport	by horizontal pages in
	      the x-direction and vertical pages in the	 y-direction.	Either
	      or  both	entries	may be negative.  Both horizontal and vertical
	      values are expressed in percent of pages,	so
	      Scroll 100 100
	      means to scroll down and right by	one full page.
	      Scroll 50	25
	      means to scroll right half a page	and down a quarter of a	 page.
	      The  Scroll  function  should  not  be called from pop-up	menus.
	      Normally,	scrolling stops	at the edge of the desktop.

	      If the horizontal	and vertical percentages are 100 or  more  and
	      are  multiplied  by 1000 then scrolling wraps around at the edge
	      of the desktop.  If
	      Scroll 100000 0
	      is executed over and over	fvwm moves to the next desktop page on
	      each  execution  and wraps around	at the edge of the desktop, so
	      that every page is hit in	turn.

	      If the letter 'p'	is appended  to	 each  coordinate  (horizontal
	      and/or vertical),	then the scroll	amount is measured in pixels.

       Xinerama	bool
	      Enables  Xinerama	 support  if  the boolean argument is true and
	      disables it if the argument  is  false.	Calling	 this  command
	      without  arguments  turns	on Xinerama support if it was disabled
	      before and turns it off if it was	enabled.  For example:
	      #	Turn Xinerama support on, use primary screen 2
	      XineramaPrimaryScreen 2
	      Xinerama on
	      #Turn it off again
	      Xinerama off

       XineramaPrimaryScreen [primary-screen]
	      Takes an integer number or 'g' or	'c' as its argument.  A	number
	      is taken as the number of	the Xinerama screen that is to be used
	      as the primary screen.  The primary screen can be	 used  as  the
	      preferred	screen to place	windows	with
	      XineramaPrimaryScreen <screen number>
	      Style * StartsOnScreen p
	      The  primary  screen  is used in some of the modules and for the
	      default icon box too.  Any number	that is	zero or	more is	 taken
	      as  the  primary screen's	number.	 Instead, the letter 'c' indi-
	      cates to use the current screen (containing the  pointer)	 when-
	      ever the primary screen is used.	This may be very confusing un-
	      der some circumstances.  With 'g', the global screen is used  as
	      the  primary  screen,  effectively disabling the primary screen.
	      Calling this function with any other argument  (including	 none)
	      resets the primary screen	to 0.

       XineramaSls [bool]
	      For  multi-screen	 implementations  other	than Xinerama, such as
	      Single Logical Screen, it	is possible  to	 simulate  a  Xinerama
	      configuration  if	 the  total  screen seen by fvwm is made up of
	      equal sized monitors in a	 rectangular  grid.   The  XineramaSls
	      command  turns  SLS support on or	off or toggles it to the oppo-
	      site state, depending on if  the	boolean	 argument  is  "True",
	      "False"  or  "toggle".  If no argument is	given, this is treated
	      like "toggle".  The default layout uses one by one screens.   To
	      configure	 the  layout, use the XineramaSlsSize or XineramaSlsS-
	      creens command.

       XineramaSlsSize HorizontalxVertical
	      This command configures the layout of the	Single Logical	screen
	      feature.	 It takes two arguments, Horizontal and	Vertical which
	      must be an integer value dividing	evenly into the	total  desktop
	      width,  and  height.   For  an example with two monitors side by
	      side which appear	as one screen through the  X-Server  with  the
	      right screen as the primary screen, use:
	      XineramaSlsSize 2x1
	      XineramaSls On
	      XineramaPrimaryScreen 1
	      Xinerama On

       XineramaSlsScreens number-of-screens screen-spec	...
	      This  command configures the layout of the Single	Logical	screen
	      feature.	Its first argument is the number of  screens  to  use.
	      It  must be followed by exactly this number of screen-spec argu-
	      ments.  Each of these can	be written either in standard X	geome-
	      try  format:  "<width>x<height>+<x>+<y>" or as a space separated
	      list of numbers: "x y width height".  Both  ways	of  describing
	      screens can be mixed in a	single command.	 All four numbers must
	      be supplied.  The	x and y	 values	 specify  the  origin  of  the
	      screen in	relation to the	global screen's	origin while width and
	      height specify the size of the screen in pixels.	No checks  are
	      done  if	the geometries make sense, so it is possible to	define
	      overlapping screens (with	random results)	or  screens  that  are
	      not visible at all.
	      XineramaSlsScreens 3 \
		512x768+0+0 512x300+512+0 512 300 512 468
	      XineramaSls On
	      XineramaPrimaryScreen 1
	      Xinerama On

   COMMANDS FOR	USER FUNCTIONS AND SHELL COMMANDS
       AddToFunc [name [I | M |	C | H |	D action]]
	      Begins or	adds to	a function definition.	Here is	an example:
	      AddToFunc	Move-or-Raise I	Raise
	       + M Move
	       + D Lower
	      The  function  name  is "Move-or-Raise", and it could be invoked
	      from a menu or a mouse binding or	key binding:
	      Mouse 1 TS A Move-or-Raise
	      The name must not	contain	embedded  whitespace.	No  guarantees
	      are made whether function	names with embedded whitespace work or
	      not.  This behavior may also change in the future	 without  fur-
	      ther  notice.   The  letter before the action tells what kind of
	      action triggers the command which	follows	it.   'I'  stands  for
	      "Immediate", and is executed as soon as the function is invoked.
	      'M' stands for "Motion", i.e. if	the  user  starts  moving  the
	      mouse.   'C'  stands  for	"Click", i.e., if the user presses and
	      releases the mouse button.  'H' stands for "Hold", i.e.  if  the
	      user  presses  a	mouse  button  and holds it down for more than
	      ClickTime	milliseconds.  'D' stands for "Double-click". The  ac-
	      tion  'I'	 causes	an action to be	performed on the button-press,
	      if the function is invoked with prior knowledge of which	window
	      to act on.

	      There  is	 a  number  of predefined symbols that are replaced by
	      certain values if	they appear on the command line.  Please refer
	      to the COMMAND EXPANSION section for details.

	      Warning:	 Please	 read  the comments on executing complex func-
	      tions in the section SCRIPTING AND COMPLEX FUNCTIONS.

	      Examples:

	      If you call
	      Key F10 R	A Function MailFunction	\
		xmh "-font fixed"
	      and "MailFunction" is
	      AddToFunc	MailFunction
	       + I Next	($0) Iconify off
	       + I Next	(AcceptsFocus, $0) Focus
	       + I None	($0) Exec exec $0 $1
	      Then the last line of the	function becomes
	       + I None	(xmh) Exec exec	xmh -font fixed
	      The expansion is performed as the	function is executed,  so  you
	      can use the same function	with all sorts of different arguments.
	      You could	use
	      Key F11 R	A Function MailFunction	\
		zmail "-bg pink"
	      in the  same  config,  if	 you  wanted.	An  example  of	 using
	      "$[w.id]"	is:
	      AddToFunc	PrintFunction
	       + I Raise
	       + I Exec	xdpr -id $[w.id]
	      Note that	"$$" is	expanded to '$'.

	      Another  example:	bind right mouse button	within the window but-
	      ton number 6 (this is a minimize button for the win95 theme)  to
	      iconify all windows of the same resource:
	      AddToFunc	FuncIconifySameResource	"I" \
		All ($0) Iconify on
	      Mouse 3 6	A FuncIconifySameResource $[w.resource]

       Beep   As might be expected, this makes the terminal beep.

       DestroyFunc function
	      Deletes  a  function, so that subsequent references to it	are no
	      longer valid.  You can use this to  change  the  contents	 of  a
	      function during a	fvwm session.  The function can	be rebuilt us-
	      ing AddToFunc.
	      DestroyFunc PrintFunction

       Echo string
	      Prints a message to stderr.  Potentially	useful	for  debugging
	      things in	your config.
	      Echo Beginning style definitions...

       Exec command
	      Executes	command.   You	should not use an ampersand '&'	at the
	      end of the command. You  probably	 want  to  use	an  additional
	      "exec"  at  the  beginning  of command.  Without that, the shell
	      that fvwm	invokes	to run your command stays  until  the  command
	      exits.   In  effect, you'll have twice as	many processes running
	      as you need.  Note that some shells are smart  enough  to	 avoid
	      this, but	it never hurts to include the "exec" anyway.

	      The  following example binds function key	F1 in the root window,
	      with no modifiers, to the	exec function.	The  program  rxvt  is
	      started with an assortment of options.

	      Key F1 R N Exec exec rxvt	-fg yellow -bg blue \
		-e /bin/tcsh
	      Note that	this function doesn't wait for command to complete, so
	      things like:
	      Exec "echo AddToMenu ... > /tmp/file"
	      Read /tmp/file
	      do not work reliably (see	the PipeRead command).

       ExecUseShell [shell]
	      Makes the	Exec command use the specified shell, or the value  of
	      the  $SHELL  environment	variable if no shell is	specified, in-
	      stead of the default Bourne shell	(/bin/sh).
	      ExecUseShell
	      ExecUseShell /usr/local/bin/tcsh

       Function	FunctionName
	      Used to bind a previously	defined	function to  a	key  or	 mouse
	      button. The following example binds mouse	button 1 to a function
	      called "Move-or-Raise", whose definition was provided as an  ex-
	      ample  earlier  in this man page.	 After performing this binding
	      fvwm executes the	"move-or-raise"	function whenever button 1  is
	      pressed in a window's title-bar.
	      Mouse 1 T	A Function Move-or-Raise
	      The keyword Function may be omitted if FunctionName does not co-
	      incide with an fvwm command.

	      Warning:	Please read the	comments on  executing	complex	 func-
	      tions in the section SCRIPTING AND COMPLEX FUNCTIONS.

       Nop    Does  nothing.  This is used to insert a blank line or separator
	      in a menu.  If the menu item specification is
	      AddToMenu	MyMenu " " Nop
	      then a blank line	is inserted.  If it looks like
	      +	"" Nop
	      then a separator line is inserted.  Can also be used as the dou-
	      ble-click	action for Menu	or Popup.

       PipeRead	command	[quiet]
	      Causes  fvwm  to	read  commands from the	output of the command.
	      This command is executed by /bin/sh as if	you typed  it  on  the
	      command  line.  If the command consists of more than one word it
	      must be quoted.  Useful for building  up	dynamic	 menu  entries
	      based  on	 a  directories	 contents, for example.	If the keyword
	      Quiet follows the	command	no message is produced if the  command
	      is not found.

	      Example:
	      AddToMenu	HomeDirMenu
	      PipeRead 'for i in $HOME/*; \
		do echo	"+ $i Exec xterm -e vi $i"; done'

	      Note:  The PipeRead changes the pointer to a watch cursor	by de-
	      fault during execution.  However,	 some  commands,  for  example
	      xwd,  need  to take control of the pointer themselves and	do not
	      work.  To	disable	the watch cursor, use  the  command  prior  to
	      PipeRead
	      BusyCursor Read off

	      The  PipeRead  command  executes	synchronously.	If you want to
	      Exec something, but need the command to run  synchronously,  you
	      might do something like:
	      PipeRead 'command	1>&2'
	      The  redirection	causes	any  output  from the program to go to
	      stderr instead of	being read as a	sequence of commands by	 fvwm.
	      PipeRead	returns	1 if the given command could be	executed or -1
	      if not (see the section CONDITIONAL COMMANDS for the meaning  of
	      return codes).

       Read filename [quiet]
	      Causes  fvwm  to read commands from the file named filename.  If
	      the keyword Quiet	follows	the command no message is produced  if
	      the  file	 is not	found.	If the file name does not begin	with a
	      slash ('/'), fvwm	looks in the user's data directory,  then  the
	      system  data directory.  The user's data directory is by default
	      $HOME/.fvwm.  It can be overridden by exporting FVWM_USERDIR set
	      to any other directory.  The Read	command	returns	1 if the given
	      file could be read or -1 if not  (see  the  section  CONDITIONAL
	      COMMANDS for the meaning of return codes).

       SetEnv variable value
	      Set  an  environment  variable  to  a  new value,	similar	to the
	      shell's export or	setenv command.	 The variable  and  its	 value
	      are  inherited  by processes started directly by fvwm.  This can
	      be especially useful in conjunction with the FvwmM4 module.  For
	      example:
	      SetEnv height HEIGHT
	      makes the	FvwmM4 set variable HEIGHT usable by processes started
	      by fvwm as the environment variable $height.  If value  includes
	      whitespace,  you	should	enclose	 it in quotes.	If no value is
	      given, the variable is deleted.

       Silent command
	      A	number of commands require a window to operate on.  If no win-
	      dow  was	selected  when	such a function	is invoked the user is
	      asked to select a	window.	 Sometimes this	behavior is  unwanted,
	      for  example if the function was called by a module and the win-
	      dow that was selected at first does not exist anymore.  You  can
	      prevent this by putting Silent in	front of the fvwm command.  If
	      a	function that needs a window is	called with Silent  without  a
	      window  selected,	 it  simply returns without doing anything. If
	      Silent is	used on	a user defined function	it affects  all	 func-
	      tion and sub function calls until	the original function exits.

	      Another usage of Silent is with binding commands Key, PointerKey
	      and Mouse, this disables error messages.

	      Silent also disables the error  message  for  non-existent  com-
	      mands.   Note:  This  command is treated as a prefix to its com-
	      mand.  Expansion of the command line is done as  if  Silent  was
	      not there.

	      Examples:
	      Silent Move 0 0
	      Silent User_defined_function
	      #	do not complain	on keyboards without "Help" key
	      Silent Key Help R	A Popup	HelpMenu

       UnsetEnv	variable
	      Unset  an	environment variable, similar to shell's export	or un-
	      setenv command. The variable then	is removed from	 the  environ-
	      ment array inherited by processes	started	directly by fvwm.

       Wait window
	      This  command is intended	to be used in fvwm functions only.  It
	      causes execution of a function  to  pause	 until	a  new	window
	      matching window appears.	This can be a window's name, class, or
	      resource string.	It may contain	the  wildcards	'*'  and  '?',
	      which  are  matched  in the usual	Unix filename manner.  This is
	      particularly useful in the "InitFunction"	if you are  trying  to
	      start windows on specific	desktops:
	      AddToFunc	InitFunction
	       + I Exec	exec xterm -geometry 80x64+0+0
	       + I Wait	xterm
	       + I GotoDesk 0 2
	       + I Exec	exec xmh -font fixed -geometry \
		     507x750+0+0
	       + I Wait	xmh
	       + I GotoDesk 0 0
	      The  above  function  starts an xterm on the current desk, waits
	      for it to	map itself, then switches to desk 2 and	starts an xmh.
	      After the	xmh window appears control moves to desk 0.

	      Fvwm  remains  partially functional during a wait, but any input
	      from the modules is queued up and	processed only after the  win-
	      dow appears or the command is aborted.  For example, windows can
	      not be focused with FvwmTaskBar or FvwmWinList during a wait.

	      You can escape from a Wait  pause	 by  pressing  Ctrl-Alt-Escape
	      (where  Alt  is  the  first modifier).  To redefine this key se-
	      quence see the EscapeFunc	command.

   CONDITIONAL COMMANDS
       Conditional commands are	commands that are  only	 executed  if  certain
       conditions  are	met.   Most conditional	commands work on windows, like
       Next, ThisWindow	or All.	 There is one conditional  command  Test  that
       works  on  global  conditions  unrelated	to windows.  The syntax	of the
       conditions is described below.  For readability,	the list of conditions
       is located at the end of	this section.

   Return Codes
       All  commands  in this section (unless specifically stated for the com-
       mand) also have a return	code that can be 1 (if the condition was  met)
       or 0 (if	the condition was not met).  Some commands may return -1 which
       means that an error occurred and	the return code	is useless.  The Break
       command	returns	-2.  Additionally, the return codes of commands	run in
       a complex functions are passed to the invoking complex  function.   The
       return  code  is	 used by the TestRc command.  Please refer to the com-
       mands' description for examples.	 The return code can also be  accessed
       through	the variable $[cond.rc].  Non conditional commands do not mod-
       ify the return code of the last conditional command.   Important	 note:
       return  codes are only defined inside functions created with the	AddTo-
       Func command and	are not	inherited by sub functions.  To	run a  command
       without altering	the return code, the KeepRc command can	be used.

   The Ring of Windows
       Fvwm  stores windows in a ring internally.  Think of the	focused	window
       as a cursor on the current position in the ring.	 The Next command  and
       many  other  commands  search  forwards through the ring	for a matching
       window, and Prev	searches backwards.  The windows in the	ring  are  ei-
       ther  ordered by	creation time (if the !FPSortWindowlistByFocus respec-
       tively NeverFocus or MouseFocus styles are used)	or by  the  last  time
       they had	the focus.

   List	of Conditional Commands
       All [options] [(conditions)] command
	      Execute  command	on all windows meeting the conditions.	It re-
	      turns 1 if any window matches the	condition and 0	otherwise. The
	      execution	starts at the top of the window	ring and continues to-
	      wards the	bottom.	The options can	be any combination of  Reverse
	      and  UseStack.  If the option Reverse is given the execution or-
	      der is reversed. The option UseStack makes All use the  stacking
	      order  instead  of the window ring when walking through windows.
	      See Conditions section below for a list of conditions.

	      This command implies the conditions CirculateHit,	CirculateHitI-
	      con  and CirculateHitShaded.  They can be	turned off by specify-
	      ing !CirculateHit	etc. explicitly.

       Any [(conditions)] command
	      Performs command if any window which  satisfies  all  conditions
	      exists.	The  command is	run in the context of the root window.
	      See Conditions section below for a list of conditions.

       Break [levels]
	      If the break command is used in a	function,  function  execution
	      is terminated immediately.  Further commands of the function are
	      not processed.  Normally,	 all  nested  invocations  of  complex
	      functions	 are  left.   An optional integer number levels	may be
	      given to break out of the	given number of	nested	functions  and
	      continue	execution  of a	higher level function.	The Break com-
	      mand always has the return code -2.  Example:
	      AddToFunc	PickWindowRaiseAndDeiconify
	      +	I Pick
	      +	I TestRc (Error) Break
	      +	I Raise
	      +	I Iconify off

       Current [(conditions)] command
	      Performs command on the currently	focused	window if it satisfies
	      all conditions.  See Conditions section below for	a list of con-
	      ditions.

	      This command implies the conditions CirculateHit,	CirculateHitI-
	      con  and CirculateHitShaded.  They can be	turned off by specify-
	      ing !CirculateHit	etc. explicitly.

       Direction [FromPointer] direction [(conditions)]	command
	      Performs command (typically Focus) on a window in	the given  di-
	      rection which satisfies all conditions.  Normally, the center of
	      the currently focused window or the context window in which  the
	      command  was  invoked  is	 taken as the starting point.  Lacking
	      such a window, or	when the FromPointer option is given, the cur-
	      rent  position  of  the  pointer is taken	as the starting	point.
	      The direction  may  be  one  of  "North",	 "Northeast",  "East",
	      "Southeast", "South", "Southwest", "West", "Northwest" and "Cen-
	      ter".  Which window Direction selects depends on angle and  dis-
	      tance  between the center	points of the windows.	Closer windows
	      are considered a better match than those farther away.  The Cen-
	      ter  direction simply selects the	window closest to the starting
	      point.  Returns -1 if an invalid direction was given.  See  Con-
	      ditions section below for	a list of conditions.

       KeepRc command
	      Runs  the	command	but does not alter the return code of the pre-
	      vious command.  Note: KeepRc is treated as a prefix to its  com-
	      mand.   Expansion	 of  the command line is done as if KeepRc was
	      not there.

       Next [(conditions)] command
	      Performs command (typically Focus) on the	next window which sat-
	      isfies  all  conditions.	 If the	command	is running in a	window
	      context, it starts looking for a	matching  window  from	there.
	      Otherwise	 it starts at the focused window.  See Conditions sec-
	      tion below for a list of conditions.

       None [(conditions)] command
	      Performs command if no window which satisfies all	conditions ex-
	      ists.   The  command  is	run in the context of the root window.
	      Returns 1	if no window matches the conditions and	 0  otherwise.
	      See Conditions section below for a list of conditions.

	      This command implies the conditions CirculateHit,	CirculateHitI-
	      con and CirculateHitShaded.  They	can be turned off by  specify-
	      ing !CirculateHit	etc. explicitly.

       NoWindow	command
	      Performs	command,  but removes the window context if any.  This
	      is not really a conditional command, but a prefix	 that  may  be
	      useful  in  menu items that should operate without a window even
	      if such menu is bound to window decorations.

       Pick [(conditions)] command
	      Pick works like Function if invoked in the context of a  window.
	      If  invoked in the root window, it first asks the	user to	pick a
	      window and then executes the command in the context of that win-
	      dow.   This  avoids  annoying  multiple  selections with complex
	      functions.  The command is executed only if the given conditions
	      are  met.	 Returns -1 if no window was selected.	See Conditions
	      section below for	a list of conditions.

	      This command implies the conditions CirculateHit,	CirculateHitI-
	      con  and CirculateHitShaded.  They can be	turned off by specify-
	      ing !CirculateHit	etc. explicitly.

       PointerWindow [(conditions)] command
	      Performs command if the window under the pointer	satisfies  all
	      conditions.  Returns -1 if there is no window under the pointer.
	      See Conditions section below for a list of conditions.

	      This command implies the conditions CirculateHit,	CirculateHitI-
	      con  and CirculateHitShaded.  They can be	turned off by specify-
	      ing !CirculateHit	etc. explicitly.

       Prev [(conditions)] command
	      Performs command (typically Focus) on the	previous window	 which
	      satisfies	all conditions.	 If the	command	is running in a	window
	      context, it starts looking for a	matching  window  from	there.
	      Otherwise	 it starts at the focused window.  See Conditions sec-
	      tion below for a list of conditions.

       ScanForWindow [FromPointer] direction direction2	[(conditions)] command
	      Performs command (typically Focus) on a window in	the given  di-
	      rection which satisfies all conditions.  Normally, the center of
	      the currently focused window or the context window in which  the
	      command  was  invoked  is	 taken as the starting point.  Lacking
	      such a window, or	when the FromPointer option is given, the cur-
	      rent  position  of  the  pointer is taken	as the starting	point.
	      The direction  may  be  one  of  "North",	 "NorthEast",  "East",
	      "SouthEast",  "South",  "SouthWest",  "West",  and  "NorthWest".
	      Which window ScanForWindow selects depends first on the position
	      along  the primary axis given by direction.  If any windows have
	      the exact	same coordinate	along the primary axis,	the  secondary
	      direction	 is  used to order the windows.	 The direction2	may be
	      one of the same set of values as direction.   If	direction2  is
	      not perfectly perpendicular to direction,	ScanForWindow will re-
	      turn a failure.  When using ScanForWindow	 repeatedly  with  the
	      same  arguments,	it is guaranteed that all windows matching the
	      conditions will eventually be found.  If	the  focus  reaches  a
	      limit  along  the	primary	axis, it will wrap around to the oppo-
	      site side.  Returns -1 if	an invalid direction was  given.   See
	      Conditions section below for a list of conditions.

       Test [(test-conditions)]	command
	      Performs	command	 if  all  test-conditions  are satisfied.  The
	      test-conditions are keywords with	possible  arguments  from  the
	      list  below and are separated by commas or whitespace.  They in-
	      clude Version operator x.y.z, EnvIsSet varname, EnvMatch varname
	      pattern,	 EdgeHasPointer	  direction,  EdgeIsActive  direction,
	      Start, Init, Restart, Exit, Quit,	ToRestart, True, False,	F,  R,
	      W, X and I.  A test-condition prefixed with "!" is negated.

	      The  Version  operator  x.y.z test-condition is fulfilled	if the
	      logical condition	of the expression is true. Valid operator val-
	      ues are: _=, _, _=, _, ==	and !=.

	      Example:
	      Test (Version >= 2.5.11) Echo 2.5.11 or later.
	      The  EnvIsSet  varname test-condition is true if the given envi-
	      ronment variable is set.	The EnvMatch varname pattern test-con-
	      dition is	true if	pattern	matches	the given environment variable
	      value.  The pattern may contain special "*" and "?" chars.

	      The EdgeHasPointer [direction] test-condition  is	 true  if  the
	      edge in the given	direction currently contains the pointer.  The
	      EdgeIsActive [direction] test-condition is true if the  edge  in
	      the  given direction currently is	active.	An edge	is active, and
	      can contain a pointer if either a	command	is bound to it or edge
	      scroll  is available in that direction. The direction may	be one
	      of  Any, North, Top, Up, West, Left, South, Bottom,  Down, Right
	      and  East.  If no	direction is specified Any is assumed.

	      The  Start test-condition	is the same as either Init or Restart.
	      It is only true on startup or restart prior  and	during	Start-
	      Function	execution.  The	Exit test-condition is the same	as ei-
	      ther Quit	or ToRestart.  It is only valid	on shutdown during Ex-
	      itFunction function execution.

	      The  True	 and  False test-conditions are, well, unconditionally
	      true and false.

	      Additionally, if a test-condition	name is	 not  recognized,  the
	      Error return code	is set and the command is not executed.

	      The  F  file,  R file, W file, X file and	I file test-conditions
	      test  for	 existence  of	the  given   [F]ile   (possibly	  with
	      [R]ead/[W]rite  permissions),  e[X]ecutable  (in	$PATH),	or the
	      [I]mage (in ImagePath).

	      Example:
	      AddToFunc	StartFunction I	Test (Init) Exec exec xterm

	      AddToFunc	VerifyVersion
	      +	I Test (Version	2.5.*) Echo 2.5.x detected
	      +	I TestRc (NoMatch) Test	(!Version 2.6.*) Echo Future version
	      +	I TestRc (NoMatch) Echo	2.6.x is detected

	      Test (F $[FVWM_USERDIR]/local-config) Read local-config
	      Test (X xterm-utf16) Exec	exec xterm-utf16

       TestRc [([!]returncode)]	command
	      Performs command if the last conditional	command	 returned  the
	      value returncode.	 Instead of the	numeric	values 0 (no match), 1
	      (match), -1 (error), and -2  (break)  the	 symbolic  names  "No-
	      Match", "Match", "Error" and "Break" can be used.	 If no return-
	      code is given, the default 0 is assumed.	If the return code  is
	      prefixed	with  '!',  the	command	is executed if returncode does
	      not match	the value returned by the conditional command.	TestRc
	      command  can  only  be used inside functions.  If	the command is
	      another conditional command, the previous	 return	 code  is  re-
	      placed by	the new	one.  Example:
	      AddToFunc	ToggleXterm
	      +	I All (my_xtermwindow) Close
	      +	I TestRc (NoMatch) Exec	xterm -T my_xtermwindow

       ThisWindow [(conditions)] command
	      ThisWindow  executes the specified command in the	context	of the
	      current operand window.  If there	is no operand  window  (it  is
	      invoked in the root window), the command is ignored.  ThisWindow
	      is never interactive.  The command is executed only if the given
	      conditions are met.  It returns -1 if used outside a window con-
	      text.  See Conditions section below for a	list of	conditions.

	      This command implies the conditions CirculateHit,	CirculateHitI-
	      con  and CirculateHitShaded.  They can be	turned off by specify-
	      ing "!CirculateHit" etc. explicitly.

       WindowId	[id] [(conditions)] | [root [screen]] command
	      The WindowId command looks for a specific	window id and runs the
	      specified	 command  on  it.  The second form of syntax retrieves
	      the window id of the root	window of the  given  screen.	If  no
	      screen  is given,	the current screen is assumed.	The window in-
	      dicated by id may	belong to a window not managed by fvwm or even
	      a	 window	on a different screen.	Although most commands can not
	      operate on such windows, there are some exceptions, for  example
	      the  WarpToWindow	 command.   Returns  -1	 if no window with the
	      given id exists.	See Conditions section below  for  a  list  of
	      conditions.

	      This command implies the conditions CirculateHit,	CirculateHitI-
	      con and CirculateHitShaded.  They	can be turned off by  specify-
	      ing !CirculateHit	etc. explicitly.

	      Examples:
	      WindowId 0x34567890 Raise
	      WindowId root 1 WarpToWindow 50 50
	      WindowId $0 (Silly_Popup)	Delete
	      In  the  past  this command was mostly useful for	functions used
	      with the WindowList command,  or	for  selective	processing  of
	      FvwmEvent	 calls	(as  in	the last example), but currently these
	      handler functions	are called within a window  context,  so  this
	      command  is  not	really needed in these cases.  Still it	may be
	      useful if, for example, the window id should be  stored  in  the
	      environment variable for a further proceeding.
	      Pick SetEnv BOOKMARKED_WINDOW $[w.id]
	      WindowId $[BOOKMARKED_WINDOW] WarpToWindow

   Conditions
       The conditions that may be given	as an argument to any conditional com-
       mand are	a list of keywords separated by	commas or whitespace, enclosed
       in  parentheses.	  Unless stated	otherwise, conditional commands	accept
       all the conditions listed below.	 Note that earlier  versions  of  fvwm
       required	the conditions to be enclosed in brackets instead of parenthe-
       ses (this is still supported for	backward compatibility).

       In addition, the	conditions may include one or  more  window  names  to
       match  to.   If	more  than  one	window name is given, all of them must
       match.  The window name,	icon name, class, and resource are  considered
       when  attempting	 to  find a match. Each	name may include the wildcards
       separated by the	character '|', which acts as an	OR operator.   (If  OR
       operators  are  used,  they  must  not  be separated by spaces from the
       names.)	Each window name can begin with	'!', which prevents command if
       any  of	the window name, icon name, class or resource match.  However,
       '!' must	not be applied to individual names in a	group separated	by  OR
       operators;  it  may  only be applied to the beginning of	the group, and
       then it operates	on the whole group.

       Examples:
	Next ("Netscape|konqueror|Mozilla*") WarpToWindow 99 90
       This goes to the	next web browser window, no matter which of the	 three
       named web browsers is being used.
	Next ("Mozilla*", "Bookmark*") WarpToWindow 99 90
       This  goes to Mozilla's bookmark	manager	window,	ignoring other Mozilla
       windows and other browsers' bookmark windows.
	All ("XTerm|rxvt", !console) Iconify
       This iconifies all the xterm and	rxvt windows on	the current page,  ex-
       cept  that  the one named "console" (with the -name option to xterm) is
       excluded.
	Next (!"FvwmPager|FvwmForm*|FvwmButtons") Raise
	Next (!FvwmPager, !FvwmForm*, !FvwmButtons) Raise
       These two commands are equivalent; either one raises  the  next	window
       which is	not one	of the named fvwm modules.

       Any  condition can be negated by	using a	an exclamation mark ('!')  di-
       rectly in front of its name.

       AcceptsFocus, AnyScreen,	CirculateHit, CirculateHitIcon,	 CirculateHit-
       Shaded, Closable, CurrentDesk, CurrentGlobalPage, CurrentGlobalPageAny-
       Desk, CurrentPage,  CurrentPageAnyDesk,	CurrentScreen,	FixedPosition,
       FixedSize,  Focused, HasHandles,	HasPointer, Iconic, Iconifiable, Layer
       [n], Maximizable, Maximized, Overlapped,	PlacedByButton n, PlacedByBut-
       ton3, PlacedByFvwm, Raised, Shaded, State n, Sticky, StickyAcrossDesks,
       StickyAcrossPages, Transient, Visible.

       The AcceptsFocus	condition excludes all windows that do	not  want  the
       input  focus  (the application has set the "Input hints"	for the	window
       to False) and do	not use	the Lenience  option  of  the  Style  command.
       Also, all windows using the NeverFocus style are	ignored.

       With  the  AnyScreen condition used together with any of	the Current...
       conditions, windows that	do not intersect the Xinerama screen  contain-
       ing the mouse pointer are considered for	a match	too.  For example:
       # Focus next window on current page,
       # regardless of Xinerama	screen
       Next (CurrentPage, AnyScreen) Focus

       The  CirculateHit  and  CirculateHitIcon	 options  override  the	Circu-
       lateSkip	and CirculateSkipIcon Style attributes for  normal  or	iconic
       windows.	  The  CirculateHitShaded  option overrides the	CirculateSkip-
       Shaded Style.  All three	options	are turned on by default for the  Cur-
       rent  command.  They can	be turned off by specifying !CirculateHit etc.
       explicitly.  Note:  Do not confuse these	conditions with	the style  op-
       tions of	the same name.	Specifically,
       Style foo CirculateSkip
       Next (foo, CirculateHit)	...
       is not the same as
       Style foo CirculateHit ...
       Next (foo)
       The  prior  selects windows with	the name foo only in the Next command.
       In the second example, these windows are	always matched in  all	condi-
       tional commands.

       The  Closable  condition	 matches  only	windows	that are allowed to be
       closed.

       The CurrentDesk condition matches only windows that are on the  current
       desk.

       The  CurrentGlobalPage  condition  matches only windows that are	on the
       current page of the current desk, regardless of whether	Xinerama  sup-
       port  is	 enabled or not.  This condition implicitly activates the Cur-
       rentDesk	condition.

       The CurrentGlobalPageAnyDesk condition matches only windows that	are on
       the current page	of any desk, regardless	of whether Xinerama support is
       enabled or not.

       The CurrentPage condition matches only windows that are on the  current
       page  of	 the  current  desk.   If Xinerama support is enabled, it only
       matches windows that are	at least partially on the Xinerama screen con-
       taining	the  mouse  pointer.   This condition implicitly activates the
       CurrentDesk condition.

       The CurrentPageAnyDesk and CurrentScreen	conditions matches  only  win-
       dows  that are on the current page of any desk.	If Xinerama support is
       enabled,	they only match	windows	that are at  least  partially  on  the
       Xinerama	screen containing the mouse pointer.

       The  FixedPosition  condition  excludes	all windows that do not	have a
       fixed position, either set through WM hints or the Style	option	Fixed-
       Position.  Example:
       DestroyFunc ToggleFixedGeometry
       AddToFunc   ToggleFixedGeometry
       + I Pick	(FixedPosition)	WindowStyle VariablePosition, VariableSize
       + I TestRc (NoMatch) WindowStyle	FixedPosition, FixedSize

       The  FixedSize  condition excludes all windows that do not have a fixed
       size, either set	through	WM hints or the	Style option FixedSize.

       The Focused matches on the window that currently	has the	 keyboard  fo-
       cus.   This  is not useful for the Current command but can be used with
       the other conditional commands.

       The HasHandles condition	excludes all windows that do not  have	resize
       handles.

       The  HasPointer	condition excludes all windows that do not contain the
       pointer.

       The Iconic condition matches only iconic	windows.

       The Iconifiable condition matches only windows that are allowed	to  be
       iconified.

       The  Layer  [n]	condition matches only windows on the specified	layer.
       The optional argument of	the Layer condition defaults to	the  layer  of
       the  focused window.  The negation !Layer switches off the Layer	condi-
       tion.

       The Maximizable condition matches only windows that are allowed	to  be
       maximized.

       The Maximized condition matches only maximized windows.

       The  Overlapped	condition  matches only	windows	that are overlapped by
       other windows on	the same layer (or unmanaged  windows  if  the	option
       RaiseOverUnmanaged  of  the  BugOpts  command is	used).	Note that this
       condition can be	slow if	you have many windows or if RaiseOverUnmanaged
       is used and the connection to the X server is slow.

       The PlacedByButton n condition is fulfilled if the last interactive mo-
       tion of the window (with	the Move command or  as	 ManualPlacement)  was
       ended by	pressing mouse button n.  Example:
       Mouse   1 T     A       Function	MoveWindow

       DestroyFunc MoveWindow
       AddToFunc MoveWindow
       + C Move
       + C ThisWindow (PlacedByButton 5) WindowShade off
       + C TestRc (Match) Maximize on 0	100
       + C ThisWindow (PlacedByButton 4) WindowShade on

       The PlacedByButton3 condition has the same meaning as PlacedByButton 3.
       It remains only for backward compatibility.

       The PlacedByFvwm	condition excludes all windows that have  been	placed
       manually	or by using the	user or	program	position hint.

       The  Raised  conditions	matches	only windows that are fully visible on
       the current viewport and	not overlapped by any other window.

       The Shaded conditions matches only shaded windows (see WindowShade com-
       mand).

       The  State  n or	!State n conditions match only windows with the	speci-
       fied integer state set (or unset).  See the State command for  details.
       The argument may	range from 0 to	31.

       The  Sticky, StickyAcrossDesks and StickyAcrossPages match only windows
       that are	currently sticky, sticky across	all desks or sticky across all
       pages.	Please	refer  to the Style options with the same name and the
       commands	Stick, StickAcrossDesks	and StickAcrossPages for details.

       The Transient condition matches only windows that have the  "transient"
       property	set by the application.	 This it usually the case for applica-
       tion popup menus	and dialogs.  The FvwmIdent module can be used to find
       out whether a specific window is	transient.

       The  Visible condition matches only windows that	are at least partially
       visible on the current viewport and not completely overlapped by	 other
       windows.

   MODULE COMMANDS
       Fvwm maintains a	database of module configuration lines in a form
       *_ModuleName_: _Config-Resource_
       where _ModuleName_ is either a real module name or an alias.

       This  database  is initially filled from	config file (or	from output of
       -cmd config command), and can be	later modified	either	by  user  (via
       FvwmCommand) or by modules.

       When  modules are run, they read	appropriate portion of database.  (The
       concept of this database	is similar to one used	in  X  resource	 data-
       base).

       Commands	 for  manipulating module configuration	database are described
       below.

       *module_config_line
	      Defines a	module configuration.  module_config_line consists  of
	      a	 module	 name  (or a module alias) and a module	resource line.
	      The new syntax allows a delimiter, a colon and optional  spaces,
	      between the module name and the rest of the line,	this is	recom-
	      mended to	avoid conflicts.
	      *FvwmIconBox: MaxIconSize	48x48
	      *FvwmPager: WindowBorderWidth 1
	      *FvwmButtons-TopRight: Geometry 100x100-0+0
	      *FvwmButtons-Bottom: Geometry +0-0

       DestroyModuleConfig module_config
	      Deletes module configuration entries, so that new	 configuration
	      lines  may be entered instead.  This also	sometimes the only way
	      to turn back some	module	settings,  previously  defined.	  This
	      changes  the  way	 a  module  runs during	a fvwm session without
	      restarting.  Wildcards can be used for portions of the  name  as
	      well.

	      The  new	non-conflicting	syntax allows a	delimiter, a colon and
	      optional spaces between the module name  and  the	 rest  of  the
	      line.   In  this	case a module name (or alias) can't have wild-
	      cards.
	      DestroyModuleConfig FvwmButtons*
	      DestroyModuleConfig FvwmForm: Fore
	      DestroyModuleConfig FvwmIconBox: Max*

       KillModule modulename [modulealias]
	      Causes the module	which was invoked with name modulename	to  be
	      killed.	The  name  may	include	 wildcards.  If	modulealias is
	      given, only modules started with the given alias are killed.
	      KillModule FvwmPager  # kill all pagers

	      Module FvwmEvent SoundEvent
	      KillModule FvwmEvent SoundEvent

       Module modulename [moduleparams]
	      Specifies	a module with its optional parameters which should  be
	      spawned.	 Currently  several  modules,  including  FvwmButtons,
	      FvwmEvent,  FvwmForm,  FvwmGtk,  FvwmPager,  FvwmScript  support
	      aliases.	 Aliases  are  useful if more than one instance	of the
	      module should be spawned.	 Aliases may be	configured  separately
	      using  * syntax described	above.	To start a module FvwmForm us-
	      ing an alias MyForm, the following syntax	may be used:
	      Module FvwmForm MyForm

	      At the current time the available	modules	(included  with	 fvwm)
	      are  FvwmAnimate	(produces  animation  effects when a window is
	      iconified	or de-iconified), FvwmAuto  (an	 auto  raise  module),
	      FvwmBacker  (to change the background when you change desktops),
	      FvwmBanner (to display a spiffy XPM, XBM	or  PNG),  FvwmButtons
	      (brings  up  a  customizable  tool bar), FvwmCommandS (a command
	      server to	use with shell's FvwmCommand client), FvwmConsole  (to
	      execute  fvwm  commands  directly),  FvwmCpp (to preprocess your
	      config with cpp),	FvwmDebug (to help debug  fvwm),  FvwmDragWell
	      (the  place to drag&drop to), FvwmEvent (trigger various actions
	      by events), FvwmForm (to bring up	dialogs), FvwmGtk (to bring up
	      GTK  menus  and  dialogs),  FvwmIconBox  (like the mwm IconBox),
	      FvwmIconMan (a flexible icon manager), FvwmIdent (to get	window
	      info),  FvwmM4 (to preprocess your config	with m4), FvwmPager (a
	      mini version of the desktop), FvwmPerl (a	Perl  manipulator  and
	      preprocessor), FvwmProxy (to locate and control obscured windows
	      by using small proxy windows), FvwmRearrange (to rearrange  win-
	      dows),  FvwmSave	(saves	the  desktop state in .xinitrc style),
	      FvwmSaveDesk (saves the desktop state in fvwm  commands),	 Fvwm-
	      Script  (another	powerful  dialog  toolkit),  FvwmScroll	 (puts
	      scrollbars on any	window), FvwmTabs (a generic tabbing  module),
	      FvwmTaskBar  (a  Windows like task bar), FvwmTheme (managed col-
	      orsets, obsolete), FvwmWharf (an	AfterStep  like	 button	 bar),
	      FvwmWindowMenu  (a  configurable	fvwm menu listing current win-
	      dows), FvwmWinList (a window list).  These  modules  have	 their
	      own man pages.  There may	be other modules out on	there as well.

	      Modules  can be short lived transient programs or, like FvwmBut-
	      tons, can	remain for the duration	of the X session.  Modules are
	      terminated by the	window manager prior to	restarts and quits, if
	      possible.	 See the introductory section on modules.  The keyword
	      Module  may  be  omitted if modulename is	distinct from all fvwm
	      commands.

       ModuleListenOnly	modulename [moduleparams]
	      This command works like the Module command, but fvwm never sends
	      any  messages to the module. This	may be handy to	write a	module
	      as a shell script	that is	triggered by external  events  without
	      the burden to answer packets sent	by fvwm. For example, a	module
	      written as a shell script	may change labels of  the  FvwmButtons
	      module to	implement a simple clock.

       ModulePath path
	      Specifies	 a  colon  separated  list  of directories in which to
	      search for modules.  To find a module, fvwm searches each	direc-
	      tory  in turn and	uses the first file found.  Directory names on
	      the list do not need trailing slashes.

	      The ModulePath may contain environment variables such  as	 $HOME
	      (or  ${HOME}).   Further,	 a  '+'	in the path is expanded	to the
	      previous value of	the path, allowing easy	appending or  prepend-
	      ing to the path.

	      For example:
	      ModulePath ${HOME}/lib/fvwm/modules:+
	      The  directory  containing the standard modules is available via
	      the environment variable $FVWM_MODULEDIR.

       ModuleSynchronous  [Expect string] [Timeout secs] modulename
	      The ModuleSynchronous command is very similar to	Module.	  Fvwm
	      stops  processing	 any  commands and user	input until the	module
	      sends a string beginning with "NOP  FINISHED  STARTUP"  back  to
	      fvwm.   If  the  optional	 Timeout is given fvwm gives up	if the
	      module sent no input back	to fvwm	for secs seconds.  If the  Ex-
	      pect  option  is given, fvwm waits for the given string instead.
	      ModuleSynchronous	should only be used during fvwm	startup	to en-
	      force  the  order	in which modules are started.  This command is
	      intended for use with the	(currently hypothetical)  module  that
	      should be	in place before	other modules are started.

	      Warning:	It  is quite easy to hang fvwm with this command, even
	      if a timeout is given.  Be extra careful choosing	the string  to
	      wait  for.  Although  all	 modules in the	fvwm distribution send
	      back the "NOP FINISHED STARTUP" string once they	have  properly
	      started  up,  this  may not be the case for third	party modules.
	      Moreover,	you can	try to escape from a locked  ModuleSynchronous
	      command  by  using the key sequence Ctrl-Alt-Escape (see the Es-
	      capeFunc).

       ModuleTimeout timeout
	      Specifies	how many seconds fvwm waits for	a module  to  respond.
	      If  the  module does not respond within the time limit then fvwm
	      kills it.	 timeout must be greater than zero, or it is reset  to
	      the default value	of 30 seconds.

       SendToModule modulename string
	      Sends  an	 arbitrary string (no quotes required) to all modules,
	      whose alias or name matching modulename, which may contain wild-
	      cards.   This only makes sense if	the module is set up to	under-
	      stand and	deal with these	strings	though.	Can be used for	module
	      to  module communication,	or implementation of more complex com-
	      mands in modules.

   QUIT, RESTART AND SESSION MANAGEMENT	COMMANDS
       Quit   Exits fvwm, generally causing X to exit too.

       QuitScreen
	      Causes fvwm to stop managing the screen on which the command was
	      issued.

       QuitSession
	      Causes a session manager (if any)	to shutdown the	session.  This
	      command does not work for	xsm, it	seems that xsm does not	imple-
	      ment  this  functionality.   Use	Unix signals to	manage xsm re-
	      motely.

       Restart [window_manager [params]]
	      Causes fvwm to restart itself if window_manager is  left	blank,
	      or  to switch to an alternate window manager (or other fvwm ver-
	      sion) if window_manager is specified.  If	the window manager  is
	      not  in  your  default search path, then you should use the full
	      path name	for window_manager.

	      This command should not have a trailing ampersand.  The  command
	      can have optional	parameters with	simple shell-like syntax.  You
	      can use ~	(is expanded to	the user's home	directory)  and	 envi-
	      ronmental	variables $VAR or ${VAR}.  Here	are several examples:
	      Key F1 R N Restart
	      Key F1 R N Restart fvwm -s
	      Key F1 R N Restart ~/bin/fvwm -f $HOME/.fvwm/main
	      Key F1 R N Restart fvwm1 -s -f .fvwmrc
	      Key F1 R N Restart xterm -n '"X console"'	\
		-T \"X\	console\" -e fvwm1 -s
	      If  you  need  a	native restart,	we suggest only	to use Restart
	      command without parameters unless	there is a reason not to.   If
	      you still	use an old command 'Restart fvwm2' that	was correct in
	      2.2.x, all current  command  line	 arguments  are	 lost.	 On  a
	      restart  without	parameters  or with --pass-args, they are pre-
	      served.  Here are	some cases when	'Restart  fvwm2'  or  'Restart
	      fvwm' cause troubles:
	      *	running	fvwm under a session manager
	      *	running	fvwm with multi	headed displays
	      *	having command line arguments, like
		-f themes-rc or	-cmd
	      *	if the first fvwm2 in the $PATH	is a
		different one
	      This is why we are issuing a warning on an old usage. If you re-
	      ally want	to restart to fvwm with	no additional  arguments,  you
	      may  get	rid  of	 this  warning	by  using "Restart fvwm	-s" or
	      "Restart /full/path/fvwm".

	      Note, currently with multi headed	displays, restart of fvwms  on
	      different	screens	works independently.

       Restart --pass-args window_manager
	      The same as Restart without parameters but the name for the cur-
	      rent window manager is replaced with the	specified  window_man-
	      ager and original	arguments are preserved.

	      This command is useful if	you use	initial	arguments like
	      -cmd FvwmCpp
	      and  want	 to  switch to another fvwm version without losing the
	      initial arguments.

       Restart --dont-preserve-state [other-params]
	      The same as
	      Restart [other-params]
	      but it does not save any window states over the restart.

	      Without this option, Restart preserves most per-window state  by
	      writing  it  to  a  file	named  .fs-restart-$HOSTDISPLAY	in the
	      user's home directory.

       SaveSession
	      Causes a session manager (if any)	to  save  the  session.	  This
	      command does not work for	xsm, it	seems that xsm does not	imple-
	      ment this	functionality.	Use Unix signals  to  manage  xsm  re-
	      motely.

       SaveQuitSession
	      Causes  a	session	manager	(if any) to save and then shutdown the
	      session. This command does not work for xsm, it seems  that  xsm
	      does not implement this functionality.  Use Unix signals to man-
	      age xsm remotely.

   COLORSETS
       Colorsets are a powerful	method to control colors. Colorsets create ap-
       pearance	 resources  that  are  shared by fvwm and its modules.	When a
       colorset	is modified all	parts of fvwm react to that change. A colorset
       includes	 a  foreground	color,	background color, shadow and highlight
       color (often based on the background color), background face (this  in-
       cludes  images  and  all	kinds of gradients).  There is a way to	render
       background face and specify other color operations.

       In the 2.4.x versions a special module FvwmTheme	was introduced to man-
       age  colorsets.	 Starting  with	 the 2.5.x beta	version, the FvwmTheme
       functionality was moved to the core fvwm, so this module	 became	 obso-
       lete.

       The old syntax:
       DestroyModuleConfig FvwmTheme: *
       *FvwmTheme: Colorset 0 fg black,	bg rgb:b4/aa/94
       *FvwmTheme: Colorset 1 fg black,	bg rgb:a1/b2/c8
       corresponds to the new syntax:
       CleanupColorsets
       Colorset	0 fg black, bg rgb:b4/aa/94
       Colorset	1 fg black, bg rgb:a1/b2/c8

       Colorset	num [options]
	      Creates  or  modifies colorset num.  Colorsets are identified by
	      this number. The number can start	at zero	 and  can  be  a  very
	      large number.

	      Warning: The highest colorset number used	determines memory con-
	      sumption.	Thus, if you define 'Colorset 100000', the memory  for
	      100001  colorsets	 is used.  Keep	your colorset numbers as small
	      as possible.

	      By convention, colorsets are numbered like this:
	      #	0 = Default colors
	      #	1 = Inactive windows
	      #	2 = Active windows
	      #	3 = Inactive menu entry	and menu background
	      #	4 = Active menu	entry
	      #	5 = greyed out menu entry (only	bg used)
	      #	6 = module foreground and background
	      #	7 = hilight colors

	      If you need to have more colors and do not want to reinvent  the
	      wheel,  you  may	use the	convention used	in fvwm-themes,	it de-
	      fines the	meaning	of the first 40	colorsets for nearly all  pur-
	      poses:

	      http://fvwm-themes.sourceforge.net/doc/colorsets

	      Each  colorset  has  four	 colors, an optional pixmap and	an op-
	      tional shape mask.  The four colors are used by modules  as  the
	      foreground,  background,	highlight  and	shadow colors.	When a
	      colorset is created it defaults to a  foreground	of  black  and
	      background of gray.  The background and foreground are marked as
	      "average"	and "contrast" (see later) so that just	 specifying  a
	      pixmap or	gradient gives sensible	results.

	      options  is  a  comma separated list containing some of the key-
	      words: fg, Fore, Foreground, bg, Back, Background,  hi,  Hilite,
	      Hilight,	sh,  Shade, Shadow, fgsh, Pixmap, TiledPixmap, Aspect-
	      Pixmap, Transparent, RootTransparent, Shape, TiledShape, Aspect-
	      Shape, NoShape, ?Gradient, Tint, fgTint, bgTint, Alpha, fgAlpha,
	      Dither, NoDither,	IconTint, IconAlpha, Plain.

	      fg, Fore and Foreground take a color name	as an argument and set
	      the  foreground color.  The special name Contrast	may be used to
	      select a color that contrasts well with  the  background	color.
	      To  reset	the foreground color to	the default value you can sim-
	      ply omit the color name.

	      bg, Back and Background take a color name	as an argument and set
	      the  background  color.	It  also sets the highlight and	shadow
	      colors to	values that give a 3d effect unless  these  have  been
	      explicitly set with the options below.  The special name Average
	      may be used to select a color that is the	average	color  of  the
	      pixmap.	If the pixmap is tinted	with the Tint option, the tint
	      is not taken in account in the computation of the	average	color.
	      You  should  use	the  bgTint  option  to	get the	"real" average
	      color.  The background color is reset to the  default  value  if
	      the color	name is	omitted.

	      hi,  Hilite and Hilight take a color name	as an argument and set
	      the highlight color.  If the highlight color is  not  explicitly
	      set,  the	 default is to calculate it from the background	color.
	      To switch	back to	the default behavior the  color	 name  can  be
	      omitted.

	      sh,  Shade  and  Shadow take a color name	as an argument and set
	      the shadow color.	 If the	shadow color is	 not  explicitly  set,
	      the  default  is	to calculate it	from the background color.  To
	      switch back to the default behavior the color name can be	 omit-
	      ted.

	      fgsh  takes  a color name	as an argument and sets	the color used
	      by the shadowing font effect. See	the FONT SHADOW	 EFFECTS  sec-
	      tion  of	the  fvwm man page.  By	default	this color is computed
	      from the foreground and background colors.  To  switch  back  to
	      the default the color name can be	omitted.

	      Pixmap,  TiledPixmap and AspectPixmap take a file	name as	an ar-
	      gument, search the  ImagePath  and  use  it  as  the  background
	      pixmap.	Any  transparent  parts	are filled with	the background
	      color.  Not specifying a file name removes  any  existing	 image
	      from  the	colorset.  TiledPixmap produces	repeated copies	of the
	      image with no scaling, Pixmap causes the image to	 be  stretched
	      to  fit  whatever	 object	the colorset is	applied	to and Aspect-
	      Pixmap stretches to fit but retains the image aspect ratio.

	      Transparent creates a transparent	background pixmap.  The	pixmap
	      is  used	as  a  window background to achieve root transparency.
	      For this you should use the  ParentalRelativity  option  to  the
	      Style  command.	A subsequent root background change may	be de-
	      tected or	not, this depends on the program used to set the back-
	      ground.	If  you	 use  fvwm-root, xsetbg	(xli), FvwmBacker with
	      solid or colorset	colors or a recent  version  of	 Esetroot  (>=
	      9.2)  a background change	is detected. If	background changes are
	      not detected (e.g., if you use xv	or xsetroot) you can force de-
	      tection by using the -d option of	fvwm-root:
	      xv -root -quit mybg.png; fvwm-root -d
	      Due  to  the  way	X implements transparency no guarantees	can be
	      made that	the desired effect can be achieved.   The  application
	      may  even	 crash.	  If you experience any	problems with this op-
	      tion, do not use it.

	      Using outline move and resize (see  the  OpaqueMoveSize  command
	      and  the	ResizeOpaque Style option) as well as setting the Win-
	      dowShadeShrinks style may	help.  The transparency	achieved  with
	      Transparent  depends  on	whether	the colorset is	applied	to the
	      foreground or the	background of a	window.	In the second case the
	      transparency  is	relative to the	parent window of the window on
	      which the	colorset is defined.  For example:
	      Colorset 12 VGradient 200	grey30 grey60
	      Colorset 17 Transparent
	      *FvwmIconMan: Colorset 12
	      *FvwmIconMan: PlainColorset 17
	      gives an IconMan with a vertical grey  gradient  background  and
	      the  buttons  use	 the background	(by transparency). To obtain a
	      (root) transparent IconMan:
	      Colorset 12 Transparent
	      Colorset 17 Transparent
	      Colorset 18 Transparent
	      Colorset 19 Transparent
	      *FvwmIconMan: Colorset 12
	      *FvwmIconMan: PlainColorset 17
	      *FvwmIconMan: FocusColorset 18
	      *FvwmIconMan: IconColorset  19
	      The Colorset IconMan option defines  the	IconMan	 window	 back-
	      ground, but the PlainColorset and	the FocusColorset are drawn on
	      the foreground. So, the transparency of the IconMan  buttons  is
	      achieved	by  drawing nothing.  Now if this IconMan is swallowed
	      in an FvwmButtons	as:
	      FvwmButtons:(Colorset 10,	Swallow	\
		"FvwmIconMan" 'FvwmIconMan')
	      then, FvwmIconMan	becomes	a  child  of  FvwmButtons  and	it  is
	      transparent relative to FvwmButtons.  So,	in this	case FvwmIcon-
	      Man uses Colorset	10 as background. If you want  root  transpar-
	      ency  use	the RootTransparent option.  FvwmButtons, FvwmIconMan,
	      FvwmIdent, FvwmScroll and	 FvwmTaskBar  are  relatively  simple.
	      There  is	 one main colorset option which	defines	the background
	      of the window and	the other colorsets (if	any) are drawn on  the
	      foreground.  The	case of	FvwmWinList and	FvwmProxy are simpler.
	      With FvwmWinList all the colorsets are drawn on  the  foreground
	      and  with	 FvwmProxy the two colorsets refer to the window back-
	      grounds.	FvwmPager is more complicated as almost	everything  in
	      the  pager  are  windows	with some parental relations (the mini
	      windows are the child and	the desktops are the parents  and  all
	      this  is	complicated  by	the hilighted page). So, the colorsets
	      apply to the background of these windows.	You should experiment.
	      For FvwmForm and FvwmScript the situation	is similar. There is a
	      main window (a child of the root window)	which  corresponds  to
	      the  main	colorset and most of the widgets are windows which are
	      children of the main window.  Tint may  work  or	not  with  the
	      Transparent option. When the colorset is drawn on	the foreground
	      Tint should work.	In some	cases, tinting may be very slow. Tint-
	      ing  may	work  with  fvwm menu (without animation). Tinting may
	      work better if your X server has backing store enabled (try  xd-
	      pyinfo  to  see  if  this	 the case). There is a chance that the
	      backing store support of your X server does not work  well  with
	      the terrible hack	used to	Tint the ParentRelative	Pixmap.	So, to
	      get tinted root transparency it is more safe to  use  the	 Root-
	      Transparent option.

	      RootTransparent  [  buffer  ]  creates  a	root transparent back-
	      ground. To make this option work,	you must use an	Esetroot  com-
	      patible  program,	 fvwm-root  with the --retain-pixmap option or
	      FvwmBacker with the RetainPixmap option (and colorset  or	 solid
	      backgrounds).   The  buffer keyword is useful only when the Tint
	      option is	used too. This speeds up creation of windows which use
	      the  colorset  (useful for fvwm menus) at	the cost of memory us-
	      age. It also speeds up opaque move and resize which can be unac-
	      ceptably	slow  without  buffer.	However, this option may add a
	      lot of memory to your X server (depending	on the size of the im-
	      age  used	to set the background).	In summary, using outline move
	      and resize for modules which use such a colorset may be  a  good
	      idea.

	      Shape,  TiledShape  and AspectShape take a file name as an argu-
	      ment, search the ImagePath and  use  it  as  the	shape  bitmap.
	      TiledShape  produces repeated copies of the bitmap with no scal-
	      ing, Shape causes	the bitmap to be stretched to fit whatever ob-
	      ject the colorset	is applied to and AspectShape stretches	to fit
	      but retains the bitmap aspect ratio.  If the file	is a pixmap in
	      xpm format, the shape mask of the	pixmap is used.

	      Warning:	Due  to	 the way X11 implements	shapes you cannot take
	      back making windows shaped. You may have to restart fvwm or  the
	      shaped application.

	      ?Gradient	...  creates a pixmap and stretches it to fit the win-
	      dow.  ?Gradient may be one of HGradient,	VGradient,  DGradient,
	      BGradient,  SGradient,  CGradient,  RGradient or YGradient.  The
	      gradient types are as follows:  H	is horizontal; V is  vertical;
	      D	 is  diagonal  from top	left to	bottom right; B	is a backwards
	      diagonal from bottom left	to top right; S	is concentric squares;
	      C	 is  concentric	 circles; R is a radar like pattern and	Y is a
	      Yin Yang style (but without the  dots).	Please	refer  to  the
	      COLOR GRADIENTS section for the syntax of	gradients.

	      Tint  takes  2 arguments,	a color	and a percentage between 0 and
	      100. It causes the image defined using ?Pixmap or	 ?Gradient  to
	      be  tinted with the specified color using	the percentage.	If the
	      image is transparent Tint	tints only the	image  part.  Unfortu-
	      nately,  a  colorset  background specified using the Transparent
	      option can give strange results. See the Transparent option  for
	      details. With no arguments this option removes the tint.

	      fgTint takes 2 arguments,	a color	and a percentage between 0 and
	      100. It causes the color defined using fg	to be tinted with  the
	      specified	color using the	percentage. With no arguments this op-
	      tion removes the tint.

	      bgTint takes 2 arguments,	a color	and a percentage between 0 and
	      100.  It causes the color	defined	using bg to be tinted with the
	      specified	color using the	percentage. If the sh  and  hi	colors
	      are not specified, they are recomputed from the tinted bg	color.
	      With no arguments	this option removes the	tint.

	      Alpha takes a percentage between 0 and 100 as  an	 argument.  It
	      causes  fvwm to merge the	image defined using ?Pixmap or ?Gradi-
	      ent with the bg color using the percentage. If the percentage is
	      0	the image is hidden and	if it is 100 the image is displayed as
	      usual (no	merge).	The default is 100 and it is  restored	if  no
	      argument is given.

	      fgAlpha  takes a percentage between 0 and	100 as an argument. It
	      causes fvwm to merge the text and	the colorset background	 using
	      the percentage. If the percentage	is 0 the text is hidden	and if
	      it is 100	the text is displayed as usual (no merge). This	option
	      has  an effect only with fonts loaded by Xft, see	the FONT NAMES
	      AND FONT LOADING section.	The default is 100 and it is  restored
	      if no argument is	given.

	      Dither  causes fvwm to dither the	image defined using ?Pixmap or
	      ?Gradient.  This is useful only with displays  with  depth  less
	      than  or	equal  to 16 (i.e., on displays	which can only display
	      less than	65537 colors at	once). The dithering effect  lets  you
	      simulate	having	more  colors available that you	actually have.
	      NoDither causes fvwm to do not dither the	images.	 Dither	is the
	      default  if  the depth is	less than or equal to 8	(a screen with
	      256 colors or less). In depth 15 (32768 colors)  and  16	(65536
	      colors),	the  default  is  NoDither, however this effect	can be
	      useful with images which contain a lot of	close colors. For  ex-
	      ample a fine gradient will look more smooth.

	      IconTint	takes  2 arguments, a color and	a percentage between 0
	      and 100. It causes fvwm or a module to tint  the	"icons"	 which
	      are  rendered  into  the	colorset background with the specified
	      color using a percentage.	Here "icons" means, fvwm  Icons,  fvwm
	      menu  icons,  MiniIcons  which represent applications in various
	      modules, images loaded by	modules	(e.g., images specified	by the
	      Icon  FvwmButtons	 button	option)	...etc.	With no	arguments this
	      option removes the icon tint.

	      IconAlpha	takes a	percentage between 0 and 100 as	 an  argument.
	      It  causes fvwm to merge the "icons" which are rendered into the
	      colorset background using	this percentage. The  default  is  100
	      and it is	restored if no argument	is given.

	      Note:  It	is equivalent to use "Tint a_color rate" and "Alpha a"
	      if a = 100 and the bg color is a_color.  This  equivalence  does
	      not  hold	for IconAlpha and IconTint as the background can be an
	      image or a gradient (and not a uniform color background).	  How-
	      ever,  in	some cases you can achieve (almost) the	same effect by
	      using IconTint in	the place of IconAlpha.	This is	preferable as,
	      in general, IconAlpha generates more redrawing than IconTint.

	      NoShape removes the shape	mask from the colorset while Plain re-
	      moves the	background pixmap or gradient.

EXAMPLES
       Colorset	3 fg tan, bg navy

       If necessary this creates colorsets 0, 1, 2 and 3 and then changes col-
       orset 3 to have a foreground of tan, a background of navy.

       Colorset	3 bg "navy blue"

       changes the background color of colorset	3 to navy blue.	The foreground
       and pixmap are unchanged.

       Colorset	3 AspectPixmap large_murky_dungeon.xpm

       Causes depression.

       Colorset	3 bg Average

       Sets the	background color and the relief	colors to match	the background
       pixmap. This is the default setting but it must be used if a background
       color was specified and is now not required.
       Colorset	3 YGradient 200	3 blue 1000 navy 1 blue	1000 navy
       Adds a Yin Yang gradient	background pixmap to colorset 3.  If the back-
       ground  is set to average it is recomputed along	with the foreground if
       that is set to contrast.

       #!/bin/sh
       FvwmCommand "Colorset 7 fg navy,	bg gray"
       while true
       do
	 FvwmCommand "Colorset 7 fg gray"
	 sleep 1
	 FvwmCommand "Colorset 7 fg navy"
	 sleep 1
       done
       Makes colorset 7	blink.

       The color names used in colorsets are saved as fvwm variables which can
       be substituted in any fvwm command. For example:
       AddToFunc InitFunction
       + I Exec	exec xterm -fg $[fg.cs0] -bg $[bg.cs0]
       Where  $[fg.cs0]	is the foreground color	of colorset zero. Please refer
       to the COMMAND EXPANSION	section	for more information.

       CleanupColorsets
	      Resets a definition of all colorsets.

   COLOR GRADIENTS
       A color gradient	is a background	that changes its color gradually  from
       one  hue	 to  a	different one.	Color gradients	can be used by various
       commands	and modules of fvwm.  There  are  eight	 types	of  gradients:
       HGradient is a horizontal gradient, VGradient is	vertical, DGradient is
       diagonal	from top left to bottom	right, BGradient is backwards diagonal
       from bottom left	to top right, SGradient	is concentric squares, CGradi-
       ent is concentric circles, RGradient is a radar like pattern and	 YGra-
       dient is	a Yin Yang style (but without the dots).

       The color gradient syntax has two forms:

       ?Gradient colors	start-color end-color
	      This form	specifies a linear gradient.  The arguments denote the
	      total number of colors to	allocate (between  2  and  1000),  the
	      initial color and	the final color.

	      Example:
	      TitleStyle VGradient 20 \
	      rgb:b8/ce/bc rgb:5b/85/d0

       ?Gradient colors	segments color length color [length color] ...
	      The  second  form	specifies a nonlinear gradient.	 The arguments
	      are: the total number of	colors	to  allocate  (between	2  and
	      1000),  then  the	number of segments.  For each segment, specify
	      the starting color, a relative length, then  the	ending	color.
	      Each subsequent segment begins with the second color of the last
	      segment.	The lengths may	be  any	 non-negative  integers.   The
	      length of	one segment divided by the sum of all segments lengths
	      is the fraction of the colors that are used for the segment.

	    Examples:
	    MenuStyle *	MenuFace DGradient \
	      128 2 lightgrey 50 blue 50 white

	    # 20% gradient from	red to blue,
	    # 30% from blue to black,
	    # 50% from black to	grey
	    MenuStyle *	MenuFace DGradient 100 3 Red 20	Blue 30	\
	      Black 50 Grey

	    # 50% from blue to green, then
	    # 50% from yellow to red
	    Colorset 0 HGradient \
	      128 3 Blue 1000 Green 1 Yellow 1000 Red

ENVIRONMENT
       DISPLAY
	      Fvwm starts on this display unless the -display option is	given.

       FVWM_MODULEDIR
	      Set by fvwm to the directory containing the standard  fvwm  mod-
	      ules.

       FVWM_USERDIR
	      Used  to	determine  the	user's	data directory for reading and
	      sometimes	writing	personal files.	If this	variable  is  not  al-
	      ready  set,  it  is set by fvwm to $HOME/.fvwm, which is the de-
	      fault user's data	directory.

       SESSION_MANAGER
	      Fvwm tries to contact this session manager.

       SESSION_MANAGER_NAME
	      This is used mainly to determine xsm running to work around  its
	      bug.  If this variable is	set to "xsm", DiscardCommand is	set as
	      xsm expects it and not as	XSMP requires.	If you run fvwm	 under
	      xsm,  you	should set this	variable to "xsm", otherwise old state
	      files are	not removed.

       SM_SAVE_DIR
	      If this is set, fvwm saves its session data in  this  directory.
	      Otherwise	 it  uses  $HOME.   Note,  the	state  files are named
	      .fs-??????  and normally are removed automatically when not used
	      anymore.

AUTHORS
       Robert  Nation with help	from many people, based	on twm code, which was
       written by Tom LaStrange.  After	Robert Nation came Charles Hines, fol-
       lowed by	Brady Montz. Currently fvwm is developed by a number of	people
       on the fvwm-workers mailing list.

COPYRIGHT
       Fvwm and	all the	modules, scripts and other files coming	with the  dis-
       tribution  are  subject to the GNU General Public License (GPL).	Please
       refer to	the COPYING file that came with	fvwm for details.

BUGS
       As of fvwm version 2.4.0	there were  exactly  71.8  unidentified	 bugs.
       Since  then  22.825  bugs  have been fixed.  Assuming that there	are at
       least 10	unidentified bugs for every identified	one,  that  leaves  us
       with  71.8  -  22.825  +	10 * 22.825 = 277.225 unidentified bugs. If we
       follow this to its logical conclusion we	will have an  infinite	number
       of  unidentified	 bugs before the number	of bugs	can start to diminish,
       at which	point the program will be bug-free.  Since this	is a  computer
       program infinity	= 3.4028e+38 if	you do not insist on double-precision.
       At the current rate of bug discovery we should expect to	 achieve  this
       point  in 4.27e+27 years.  I guess we better plan on passing this thing
       on to our children...

       Known bugs can be found in the fvwm  bug	 tracking  system  (accessible
       from the	fvwm home page).

       Bug  reports can	be sent	to the fvwm-workers mailing list at fvwm-work-
       ers@fvwm.org (see the FAQ) or reported through the bug tracking system.

       The official fvwm homepage is http://fvwm.org/.

3rd Berkeley Distribution     (not released yet)		       FVWM(1)

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | ANATOMY OF A WINDOW | THE VIRTUAL DESKTOP | USE ON MULTI-SCREEN DISPLAYS | XINERAMA SUPPORT | INITIALIZATION | COMPILATION OPTIONS | ICONS AND IMAGES | MODULES | ICCCM COMPLIANCE | GNOME COMPLIANCE | EXTENDED WINDOW MANAGER HINTS | MWM COMPATIBILITY | OPEN LOOK and XVIEW COMPATIBILITY | M4 PREPROCESSING | CPP PREPROCESSING | AUTO-RAISE | CONFIGURATION FILES | SUPPLIED CONFIGURATION | FONT NAMES AND FONT LOADING | FONT AND STRING ENCODING | FONT SHADOW EFFECTS | BI-DIRECTIONAL TEXT | KEYBOARD SHORTCUTS | SESSION MANAGEMENT | BOOLEAN ARGUMENTS | CONDITIONAL COMMANDS AND RETURN CODES | BUILT-IN KEY AND MOUSE BINDINGS | MODULE AND FUNCTION COMMANDS | DELAYED EXECUTION OF COMMANDS | QUOTING | COMMAND EXPANSION | SCRIPTING AND COMPLEX FUNCTIONS | THE LIST OF FVWM COMMANDS | EXAMPLES | ENVIRONMENT | AUTHORS | COPYRIGHT | BUGS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=fvwm&sektion=1&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help