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

FreeBSD Manual Pages

  
 
  

home | help
FVWM(1)				  Fvwm 2.6.9			       FVWM(1)

NAME
       Fvwm - F? Virtual Window	Manager	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
       desktops	which can be used separately or	together.  The virtual desktop
       allows you to pretend that your video screen is really quite large, and
       you can scroll around within the	desktop.  The multiple disjoint
       desktops	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 that	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
       commands	typically set fonts, colors, menu contents, and	key and	mouse
       function	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
       windows 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 manager.
	   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 command.  (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 modules
	   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/FvwmPerl
	   but there is	a timeout so fvwm eventually gets 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 ICCCM2 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 display.

       -V | --version
	   Prints the version of fvwm to stderr.  Also prints an information
	   about the compiled in support for readline, rplay, stroke, xpm,
	   png,	svg, GNOME hints, EWMH hints, session management,
	   bidirectional text, multibyte characters, xinerama and Xft aa font
	   rendering.

       -C | --visual visual-class
	   Causes fvwm to use visual-class for the window borders 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 option is
	   only	useful with screens that display 256 colors (or	less) with a
	   dynamic visual (PseudoColor,	GrayScale or DirectColor).  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-allocates 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-allocated palette is	auto
	   detected the	defaults are as	follow:

	   Display depth 8 (256	colors)

		   PseudoColor:	68 (4x4x4 color	cube + 4 grey)
		   GrayScale: 64 regular grey
		   DirectColor:	32 (3x3x3 color	cube + 5 grey)

	   Display depth 4 (16 colors)

		   PseudoColor:	10 (2x2x2 color	cube + 2 grey)
		   GrayScale: 8	regular	grey
		   DirectColor:	10 (2x2x2 color	cube + 2 grey)

	   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 other	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 understand
	   is that you have only 256 colors and	that all the applications
	   which use the default color map must	share these colors.  The main
	   problem is that there are applications which	use a lot or even all
	   the colors.	If you use such	application you	may 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 or 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 definitive	solution.  The definitive solution is
	   to try cause	applications 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/toolkits 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
	   PrintInfo 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 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.  Blacking
	   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
       consists	of a bar on each side and a small L-shaped section on each
       corner.	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 title-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
       configuration adds a close button to the	right.	The number of
       title-bar buttons used depends on which ones have mouse actions bound
       to them.	 See the Mouse command.

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
       desktop 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
       desktops	must be	(are) the same size.  The total	number of distinct
       desktops	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 using the
       WindowList command or the FvwmIconMan 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
       concept 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
       desktop,	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
       specified 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
       applications support window geometries with negative offsets.  Some
       applications 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
       relative	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
       StartsOnScreen 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
       similar to multi	head support (multiple screens)	but allows one 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 multiple screens via Xinerama.  Without this option, the whole
       desktop is treated as one big screen.  For example, menus might pop up
       right between two screens.  The EdgeResistance option of	the Style
       command command allows for specifying an	explicit resistance value for
       moving windows over the screen edge between two Xinerama	screens.
       Xinerama	support	can be enabled or disabled on the fly or from the
       configuration file with the Xinerama command.  Many modules and
       commands	work nicely with Xinerama displays.

       Whenever	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
       primary screen is screen	0 by default but can be	changed	with the
       XineramaPrimaryScreen command.

       Xinerama	support	was designed to	work out of the	box with the same
       configuration 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 desktop 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
       XineramaSlsScreens are used to configure	this feature.

INITIALIZATION
       During initialization, fvwm searches for	a configuration	file which
       describes 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
       directories, as described in Read.  If this fails more files are
       queried for backward compatibility.  Here is the	complete list of all
       file locations 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
       children.  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 sockets, 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 important to start applications or
       modules after the entire	config is read,	because	it contains styles or
       module configurations which can affect window appearance	and
       functionality.

       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
       RestartFunction,	which are executed during initialization and restarts
       (respectively) just after StartFunction.	 These functions may be
       customized 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
       exiting or restarting before actually quitting.	It could be used to
       explicitly 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.
       Generally it is a bad idea to start xterms or other applications	in
       "Session*" 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 FvwmIconMan
	    + I	Exec xsetroot -solid cyan
	    + I	Exec xterm
	    + I	Exec netscape

	   DestroyFunc RestartFunction
	   AddToFunc RestartFunction
	    + I	Module FvwmIconMan

	   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
       StartFunction 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, .png and .svg images.	XBM images are
       monochrome.  Fvwm can always display XBM	files.	XPM and	PNG formats
       are color images.  SVG is a vector graphics image format.  Compile-time
       options determine whether fvwm can display XPM, PNG or SVG icons	and
       images.	See the	INSTALL.fvwm file for more information.

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

   SVG rendering options
       SVG images are generated	from (XML) text	files.	A really simple	SVG
       file might look something like this:

	   <svg	width="120" height="80">
		<rect fill="red"     width="40"	height="40"  x="0"   y="0"  />
		<rect fill="lime"    width="40"	height="40"  x="40"  y="0"  />
		<rect fill="blue"    width="40"	height="40"  x="80"  y="0"  />
		<rect fill="cyan"    width="40"	height="40"  x="0"   y="40" />
		<rect fill="magenta" width="40"	height="40"  x="40"  y="40" />
		<rect fill="yellow"  width="40"	height="40"  x="80"  y="40" />
	   </svg>

       By default, SVG images are rendered as the image	creator	intended them
       to.  But	since SVG is a vector graphics format, the images can be
       rendered	at any chosen size and rotation, e.g. making it	possible to
       use the same icon file rendered at different sizes for the Icon and
       MiniIcon	styles.

       The rendering options are specified as a	string appended	to the SVG
       filename	as follows:

       image.svg:[!] [(1) size]	[(2) position] [(3) rotation] [(4) scale] ...

       (1) [-]width{x}[-]height
       (2) {- |	+}xpos{- | +}ypos
       (3) @[-]angle
       (4) {* |	/}[-]factor[x |	y]

       The option string always	starts with a colon (':') to separate it from
       the filename.  An empty option string can skip this colon, but it might
       still be	a good idea to include it to prevent ambiguity if the filename
       contains	any colon.

	   filename_without_colon.svg
	   filename:with:colon.svg:

       An exclamation point ('!') transposes the entire	final image (including
       the rendering area), i.e. all the horizontal and	all the	vertical
       coordinates are swapped with each other.

	   image.svg:!

       width and height	specifies the dimensions of the	rendering area in
       pixels, i.e. the	dimensions of the resulting image.  The	actual image
       is fitted to fill the entire rendering area.

	   image.svg:60x60

       Use a width or height value of 0	to keep	the aspect ratio.

	   image.svg:0x60
	   image.svg:60x0

       A '-' before width mirrors the rendering	area horizontally.

	   image.svg:-0x0

       A '-' before height mirrors the rendering area vertically.

	   image.svg:0x-0

       xpos and	ypos specifies a translation of	the image in pixels.  A
       positive	xpos value moves the image to the right.  A positive ypos
       value moves it down.  Moving it partially outside of the	rendering area
       results in a cropped image.

	   image.svg:-30-0
	   image.svg:-0+10
	   image.svg:-30+10

       angle specifies a rotation around the actual image center in degrees.
       This might result in a cropped image.  A	positive value rotates the
       image clockwise.	 Floating point	values are recognized.

	   image.svg:@180
	   image.svg:@-90
	   image.svg:@30
	   image.svg:@57.3

       factor specifes a scaling of the	actual image (not the rendering	area).
       Scaling it up results in	a cropped image.  Floating point values	are
       recognized.  Division by	zero is	ignored.  If factor is directly
       followed	by a 'x' or a 'y', the scaling is horizontal or	vertical
       respectively.  Otherwise	the scaling is uniform.

	   image.svg:*2
	   image.svg:/2
	   image.svg:/3x
	   image.svg:/2y

       Scaling down a translated or rotated image can prevent cropping.

	   image.svg:@30*0.6

       Repeated	usage of translation, rotation,	and scaling is allowed.
       Translation and rotation	are additive.  Scaling is multiplicative.

	   image.svg:*2/3
	   image.svg:/3x/2y

       When combining affine transformations, the scaling is always done
       first, then the rotation, and finally the translation.

	   image.svg:-30+10@30/3x/2y

       Use a negative scale factor to mirror the actual	image.

	   image.svg:-30+10@30/-3x/2y

       Mirroring of the	rendering area is done after any scaling, rotation or
       translation of the image.

	   image.svg:-0x0-30+10@30/3x/2y

       Transposing is done last	of all,	after everything else.

	   image.svg:!-0x0-30+10@30/3x/2y

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

       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
       keystroke, 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
       number of applications set this property, and yet expect	the window
       manager 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
       accepts 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
       "UrgencyDoneFunc", which	are executed when the flag is set/cleared.
       Their default definitions are:

	   AddToFunc UrgencyFunc
	    + I	Iconify	off
	    + I	FlipFocus
	    + I	Raise
	    + I	WarpToWindow !raise 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/Standards_2fwm_2dspec and some
       extensions of this specification.  This allows fvwm to work with	KDE
       version >= 2, GNOME version 2 and other applications 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
       function.  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
       hidden 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
       updated:	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
       reserved	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
       keyboard	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 Lenience style for all such
       applications (the windows still get the focus):

	   Style <application name> NeverFocus,	Lenience

       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,	but replace "m4" with "cpp".

CONFIGURATION
   Configuration Files
       The configuration file is used to describe mouse	and button bindings,
       colors, the virtual display size, and related items.  The
       initialization 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
       configuration 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
       configuration 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, is supplied	with the fvwm distribution.
       It is well commented and	can be used as a source	of examples for	fvwm
       configuration.  It may be copied	from /usr/local/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.

FONTS
   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
       without constraint on the charset.

       More details on the XLFD	can be found in	the X manual page, the X
       Logical Font Description	Conventions document (called xlfd) and the
       XLoadFont 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
       assumed).  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,
       button 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
       enable 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
       parameters 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
       (simple 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
       FvwmForm	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 etc.

       More and	more, unicode is used and text files use UTF-8 encoding.
       However,	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.
       However,	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
       delimiter.  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 between 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 libiconv).  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
       number 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
       displayed 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 automatically 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
       compile 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
       return.	Holding	down the Shift key causes the pointer movement to go
       in larger steps and holding down	the control key	causes the pointer
       movement	to go in smaller steps.	 Standard emacs	and vi cursor movement
       controls	( 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
       windows.	 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
       manager anyway.	If it is really	needed,

	   Exec	exec killall fvwm

       still kills all copies of fvwm.	Your system must have the killall
       command 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
       disabled	if it is currently enabled and vice versa.

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

       You can override	or remove these	bindings.  To remove the window	list
       binding,	use this:

	   Key Tab A M -

COMMAND	EXECUTION
   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
       immediately 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
       UpdateStyles, 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
       expansion.  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 "$$".

       If a command is prefixed	with a '-' parameter expansion isn't
       performed.  This	applies	to the command immediately following the '-',
       in which	the expansion normally would have taken	place.	When uesed
       together	with other prefix commands it must be added before the other
       prefix.

       Example:

	   Pick	-Exec exec xmessage '$[w.name]'

       opens an	xmessage dialog	with "$[w.name]" unexpanded.

       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
       supported.  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 prints
       "$[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
       using 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 function
	   that	has been defined with the AddToFunc command).  "$0" is
	   replaced with the first parameter, "$1" with	the second parameter
	   and so on.  If the corresponding parameter is undefined, 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 is expanded unquoted.

       $[n-m]
	   The positional parameters given to a	complex	function, starting
	   with	parameter n and	ending with parameter m.  If all the
	   corresponding parameters are	undefined, the "$[...]"	is deleted
	   from	the command line.  If only some	of the parameters are defined,
	   all defined parameters are expanded,	and the	remaining silently
	   ignored.  All parameters are	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 are 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 viewport.

       $[wa.x] $[wa.y] $[wa.width] $[wa.height]
	   Either coordinate or	the width or height of the EWMH	working	area.

       $[dwa.x]	$[dwa.y] $[dwa.width] $[dwa.height]
	   Either coordinate or	the width or height of the dynamic EWMH
	   working area.

       $[desk.n]
	   The current desk number.

       $[desk.name<n>]
	   These parameters are	replaced with the name of the desktop number
	   <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 associated with
	   the command.

       $[w.name] $[w.iconname] $[w.class] $[w.resource]	$[w.visiblename]
       $[w.iconfile] $[w.miniiconfile] $[w.iconfile.svgopts]
       $[w.miniiconfile.svgopts]
	   The window's	name, icon name, resource class	and resource name,
	   visible 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), and (if fvwm	is compiled with SVG support) the icon
	   or mini icon	svg rendering options (including the leading colon),
	   or unexpanded "$[w.<attribute>]" string if no window	is associated
	   with	the command.

	   Note, the first 5 variables may include any kind of characters, so
	   these variables are quoted.	It means that the value	is surrounded
	   by single quote characters and any contained	single quote is
	   prefixed with a backslash.  This guarantees that commands 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.

	   In the case of the window's visible name, this is the value
	   returned from the literal title of the window shown in the
	   titlebar.  Typically	this will be the same as $[w.name] once
	   expanded, although in the case of using IndexedWindowName then this
	   is more useful a distinction, and allows for	referencing the
	   specific window by its visible name for inclusion in	things like
	   Style commands.

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

       $[w.screen]
	   The screen number the window	is on.	If Xinerama is not present,
	   this	returns	the number 0.

       $[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 window.
	   If the pointer is not on the	screen,	the window is iconified	or no
	   window is selected, these variables are not expanded.

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

       $[pointer.screen]
	   The screen number the pointer is currently on.  Returns 0 if
	   Xinerama is not enabled.

       $[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 section for details about colorsets.

       $[schedule.last]
	   This	is replaced by the id of the last command that was scheduled
	   with	the Schedule command, even if this command was already
	   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 conditional
	   command.  Please refer to the section Conditional Commands in the
	   command list.

       $[func.context]
	   The context character of the	running	command	as used	in the Mouse,
	   Key or PointerKey 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.

       $[infostore.key]
	   Return the value of the item	stored in the InfoStore	at the given
	   key.	 If no key is present, the unexpanded string is	returned.

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

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

SCRIPTING & 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
       complex 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 User Functions and Shell Commands and
       Conditional Commands for	details.  A word of warning: during execution
       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
       refuses to make screen shots when run from a complex function.  To
       achieve the same	functionality you can use the Read or PipeRead command
       instead.

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.

       o   Menu	commands

       o   Miscellaneous commands

       o   Commands affecting window movement and placement

       o   Commands for	focus and mouse	movement

       o   Commands controlling	window state

       o   Commands for	mouse, key and stroke bindings

       o   The Style command (controlling window styles)

       o   Other commands controlling window styles

       o   Commands controlling	the virtual desktop

       o   Commands for	user functions and shell commands

       o   Conditional commands

       o   Module commands

       o   Quit, restart and session management	commands

       o   Colorsets

       o   Color gradients

   Menus
       Before a	menu can be opened, it has to be populated with	menu items
       using 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
	      executed.

	      Menu is a	very similar command, but the menus it opens are
	      slightly less transient.	When invoked by	clicking a mouse
	      button, 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
	      context and pinned on the	desktop	like a normal window.  They
	      are created from other menus by certain key presses or mouse
	      sequences	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
	      between 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
	      direction	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.
	      The "More..." string honors the locale settings.

	      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
	      navigation 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.
	      Normally 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 by default 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 displayed	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
	      current 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
	      indicated	by underlining it in the menu item label.  With	the
	      AutomaticHotkeys 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 by default:

	      Enter, Return, Space activate the	current	item.

	      Escape, Delete, Ctrl-G exit the current sequence of menus	or
	      destroy 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-Tab Page-Down move
	      down five	items.

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

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

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

	      Meta-N, Meta-Cursor-Down,	Ctrl-Cursor-Right, Ctrl-Tab, move down
	      just below the next separator.

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

	      Backspace	tears off the menu.

       Menu Bindings
	      The keys and mouse buttons used to navigate the menu can be
	      configured using the Key and Mouse commands with the special
	      context 'M', possible combined with 'T' for the menu title, 'I'
	      for other	menu items, 'S'	for any	border or sidepic, '[' for
	      left border including a left sidepic, ']'	for right border
	      including	a right	sidepic, '-' for top border, '_' for bottom
	      border.  The menu	context	uses its own set of actions that can
	      be bound to keys and mouse buttons.  These are MenuClose,
	      MenuCloseAndExec,	MenuEnterContinuation, MenuEnterSubmenu,
	      MenuLeaveSubmenu,	MenuMoveCursor,	MenuCursorLeft,
	      MenuCursorRight, MenuSelectItem, MenuScroll and MenuTearOff.

	      It is not	possible to override the key Escape with no modifiers
	      for closing the menu.  Neither is	it possible to undefine	mouse
	      button 1,	the arrow keys or the enter key	for minimal
	      navigation.

	      MenuClose	exits from the current sequence	of menus or destroys a
	      tear off menu.

	      MenuCloseAndExec exits from the current sequence of menus	or
	      destroys a tear off menu and executes the	rest of	the line as a
	      command.

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

	      MenuEnterSubmenu enters a	sub menu.

	      MenuLeaveSubmenu returns to the prior menu.

	      MenuMoveCursor n [m] moves the selection to another item.	 If
	      the first	argument is zero the second argument specifies an
	      absolute item in the menu	to move	the pointer to.	 Negative
	      items are	counted	from the end of	the menu.  If the first
	      argument is non-zero, the	second argument	must be	omitted, and
	      the first	argument specifies a relative change in	the selected
	      item.  The positions may be suffixed with	a 's' to indicate that
	      the items	should refer only to the first items after separators.

	      MenuCursorLeft enters a sub menu with the	SubmenusLeft menu
	      style, and returns to the	prior menu with	the SubmenusRight menu
	      style.

	      MenuCursorRight enters a sub menu	with the SubmenusRight menu
	      style, and returns to the	prior menu with	the SubmenusLeft menu
	      style.

	      MenuSelectItem triggers the action for the menu item.

	      MenuScroll n performs menu scrolling according to	the MouseWheel
	      menu style with n	items.	The distance can be suffixed with an
	      's' to indicate the items	should refer only to the first items
	      after separators.

	      MenuTearOff turns	a normal menu into a "torn off"	menu.  See
	      Tear Off Menus for details.

       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 builtin tear off actions can be overridden by	undefining the
	      builtin menu actions bound to tear off.  To remove the builtin
	      mouse button 2 binding, use:

		  Mouse	2 MT A -

	      and to remove the	builtin	backspace binding, use:

		  Key Backspace	M A -

	      See the section Menu Bindings for	details	on how to assign other
	      bindings for tear	off.

	      Note that	prior to fvwm 2.5.20 the tear off mouse	bindings were
	      redefined	in different way, which	no longer work.

	      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
	      reopening	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
	      immediately.  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
	      definition 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
	      appears in the menu when the user	pops it	up.  The remaining
	      portion 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
	      action 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 may fail and	may screw up your menus.  See the Silent
	      command.

	      Warning
	      Do not issue MenuStyle commands as dynamic menu actions.
	      Chances are good that this crashes 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
	      exist.  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
	      directory	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 Tab s
	      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
	      character	is taken as a hot-key for the menu item.  Hot-keys are
	      underlined 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
	      percent 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
	      pictures 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
	      expected to be the name of an image 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
	      literal '@', 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
	      colors 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
	      delimiters.

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

       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
	      AddToMenu.  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
	      using this style to the default style, you cannot	destroy	the
	      default 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
	      action instead of	a drag action, the menu	stays up.  The command
	      double-click-action is invoked if	the user double-clicks a
	      button (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.
	      However, 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
	      context-rectangle	and an offset to this rectangle	by which the
	      upper 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.	 Equivalent 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 format.
		  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
	      its 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
	      interpretation to	mean pixels.

	      Instead of a single value	you can	use a list of values.  All
	      additional 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
	      integer, 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 position
	      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 its menu
	      item? The	default	is to place the	title under the	cursor,	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
	      ignored.

	      options is a comma separated list	containing some	of the
	      keywords Fvwm / Mwm / Win, BorderWidth, Foreground, Background,
	      Greyed, HilightBack / !HilightBack, HilightTitleBack, ActiveFore
	      /	!ActiveFore, MenuColorset, ActiveColorset, GreyedColorset,
	      TitleColorset, Hilight3DThick / Hilight3DThin / Hilight3DOff,
	      Hilight3DThickness, Animation / !Animation, Font,	TitleFont,
	      MenuFace,	PopupDelay, PopupOffset, TitleWarp / !TitleWarp,
	      TitleUnderlines0 / TitleUnderlines1 / TitleUnderlines2,
	      SeparatorsLong / SeparatorsShort,	TrianglesSolid /
	      TrianglesRelief, PopupImmediately	/ PopupDelayed,
	      PopdownImmediately / PopdownDelayed, PopupActiveArea,
	      DoubleClickTime, SidePic,	SideColor, PopupAsRootMenu /
	      PopupAsSubmenu / PopupIgnore / PopupClose, RemoveSubmenus	/
	      HoldSubmenus, SubmenusRight / SubmenusLeft, SelectOnRelease,
	      ItemFormat, VerticalItemSpacing, VerticalMargins,
	      VerticalTitleSpacing, AutomaticHotkeys / !AutomaticHotkeys,
	      UniqueHotkeyActivatesImmediate /
	      !UniqueHotkeyActivatesImmediate, 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
	      is the preferred form for	all such options.  The other negative
	      forms are	now deprecated and will	be removed in the future.

	      This is a	list of	MenuStyle deprecated negative options:
	      ActiveForeOff, AnimationOff, AutomaticHotkeysOff,
	      HilightBackOff, TitleWarpOff

	      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
	      Foreground, Background, Greyed, HilightBack, ActiveFore and
	      PopupDelay, 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,
	      !ActiveFore, !Animation, Font, MenuFace, PopupOffset 0 67,
	      TitleWarp, TitleUnderlines1, SeparatorsShort, TrianglesRelief,
	      PopupDelayed, PopdownDelayed, PopupDelay 150, PopdownDelay 150,
	      PopupAsSubmenu, HoldSubmenus, SubmenusRight, BorderWidth 2,
	      !AutomaticHotkeys, UniqueHotkeyActivatesImmediate,
	      PopupActiveArea 75.

	      Mwm style	is equivalent to !HilightBack, Hilight3DThick,
	      !ActiveFore, !Animation, Font, MenuFace, PopupOffset -3 100,
	      !TitleWarp, TitleUnderlines2, SeparatorsLong, TrianglesRelief,
	      PopupImmediately,	PopdownDelayed,	PopdownDelay 150,
	      PopupAsSubmenu, HoldSubmenus, SubmenusRight, BorderWidth 2,
	      UniqueHotkeyActivatesImmediate, !AutomaticHotkeys,
	      PopupActiveArea 75.

	      Win style	is equivalent to HilightBack, Hilight3DOff,
	      ActiveFore, !Animation, Font, MenuFace, PopupOffset -5 100,
	      !TitleWarp, TitleUnderlines1, SeparatorsShort, TrianglesSolid,
	      PopupImmediately,	PopdownDelayed,	PopdownDelay 150,
	      PopupAsSubmenu, RemoveSubmenus, SubmenusRight, BorderWidth 2,
	      UniqueHotkeyActivatesImmediate, !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.
	      Using 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
	      specified.  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
	      HilightBack.  If you use this option without an argument the
	      color is based on	the menu's background color.  The
	      ActiveColorset option overrides the specified color.  If the
	      colorset has a non solid background it is	used for the
	      hilighting.

	      HilightTitleBack switches	hilighting the background of menu
	      titles on.  If a TitleColorset was used, the background colour
	      is taken from there.  Otherwise the color	is based on the	menu's
	      background color.	 If the	colorset has a non solid background it
	      is used for the hilighting.

	      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
	      ActiveFore.  Omitting the	color turns hilighting on when an
	      ActiveColorset is	used.  ActiveFore turns	off hilighting the
	      foreground completely.  The ActiveColorset option	overrides the
	      specified	color.

	      MenuColorset controls if a colorset is used instead of the
	      Foreground, Background and MenuFace menu styles.	If the
	      MenuColorset 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 regular 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
	      foreground from the colorset replaces the	color given with the
	      ActiveFore menu style and	the colorset's background color
	      replaces the color given with the	HilightBack command (to	turn
	      on background hilighting you have	to use the HilightBack menu
	      style too).  If specified, the hilight and shadow	colors from
	      the colorset 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
	      foreground 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
	      between -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
	      sections for more	information.  If you use MenuFace without
	      arguments	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
	      delay 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
	      PopupDelay 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
	      conflict 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
	      negative).  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
	      disables 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
	      separators.  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
	      triangles	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
	      milliseconds.  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
	      picture is drawn along the left side of the menu.	 The SidePic
	      option can be overridden by a menu specific side pixmap (see
	      AddToMenu).  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
	      omitted 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
	      before the sub menu appears, with	PopupAsSubmenu it is not, so
	      you can navigate back into the parent menu.  Furthermore,	with
	      PopupAsSubmenu 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
	      activated, 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
	      remains visible.	You probably want to use HoldSubmenus if you
	      are using	the PopupDelayed style.	 RemoveSubmenus	affects	menu
	      navigation 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
	      current menu item	is selected.  This is intended for Alt-Tab
	      WindowList navigation.  The key name 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.
	      To disable this behavior,	omit the key name.

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

	      ItemFormat takes a special string	as its argument	that
	      determines 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 illegal 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 picture).

	      %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
	      replaced 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.
	      Leading 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
	      vertical 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.

	      VerticalMargins can be used to add some padding at the top and
	      bottom of	menus.	It takes two numeric arguments that must be
	      positive integers	(or zero).  If the number of arguments or its
	      values are incorrect, fvwm defaults both to 0, which means no
	      padding at all.  If the values are correct, the first one	is
	      used for the top margin, and the second one is used for the
	      bottom margin.

	      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
	      using item or menu as context rectangle and position hints using
	      m	offsets.

	      AutomaticHotkeys and !AutomaticHotkeys control the menu's
	      ability 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.

	      UniqueHotkeyActivatesImmediate and
	      !UniqueHotkeyActivatesImmediate controls how menu	items are
	      invoked when used	with hotkeys.  By default, if a	given menu
	      entry only has one completeable match for	a given	hotkey,	the
	      action for that menu entry is invoked and	the menu is closed.
	      This is due to the UniqueHotkeyActivatesImmediate	option.
	      However, the menu	can be told to remain open, waiting for	the
	      user to invoke the selected item instead when there is only one
	      matched item for a given hotkey, by using	the
	      !UniqueHotkeyActivatesImmediate option.

	      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.  ScrollsPointer 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 setting is restored.

	      ScrollOffPage allows a menu to be	scrolled out of	the visible
	      area if MouseWheel is set	to ScrollsMenu or
	      ScrollsMenuBackwards.  This is the default.  The opposite,
	      !ScrollOffPage disables 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
	      ignored.	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
	      immediately 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
	      button:

	      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 command.
	      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 -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
	      nothing.	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
	      before 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
	      default 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, Windows NT
	      or Mac OS	X.  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
	      manages 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
	      Unmanaged	style option too.

	      FlickeringQtDialogsWorkaround suppresses flickering of the
	      focused 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
	      applications are rare it is most likely safe to leave this
	      option at	its default.

	      QtDragnDropWorkaround suppresses the forwarding of unknown
	      ClientEvent messages to windows -- usually this is harmless, but
	      Qt has problems handling unrecognised ClientEvent	messages.
	      Enabling this option might therefore help	for Qt applications
	      using DragnDrop.	This option is off by default.

	      EWMHIconicStateWorkaround	is needed by EWMH compliant pagers or
	      taskbars which represent windows which are on a different
	      desktops as iconified.  These pagers and taskbars	use a version
	      of the EWMH specification	before version 1.2 (the	current	KDE 2
	      &	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	window
	      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
	      figure 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
	      helpful for the user, but	if you report a	bug to the fvwm	team
	      we may ask you to	enable this option.

	      The TransliterateUtf8 option enables transliteration during
	      conversions from utf-8 strings.  By default fvwm will not
	      transliterate during conversion, but will	fall back to alternate
	      strings provided by the clients if conversion from utf-8 fails
	      due to characters	which have no direct correspondence in the
	      target charecter set.  Some clients however neglect to set non
	      utf-8 properties correctly in which case this option may help.

       BusyCursor [Option bool], ...
	      This command controls the	cursor during the execution of certain
	      commands.	 Option	can be DynamicMenu, ModuleSynchronous, Read,
	      Wait or *.  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,	Wait False

	      The * option refers to all available options.

	      The Read option controls the PipeRead command.

	      The DynamicMenu option affects the DynamicPopupAction and
	      MissingSubmenuFunction 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 ModuleSynchronous option affects the ModuleSynchronous
	      command.	If this	option is set to "False", then the busy	cursor
	      is not displayed while fvwm waits	for a module started by
	      ModuleSynchronous	to complete its	startup.

	      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
	      cursor 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
	      milliseconds.  Omitting the delay	value resets the ClickTime to
	      the default.

       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
	      currently	has the	keyboard focus.

       CursorStyle context [num	| name | None |	Tiny | file [x y] [fg bg]]
	      Defines a	new cursor for the specified context.  Note that this
	      command can not control the shapes an applications uses, for
	      example, 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 argument 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.  The name can also be None (no cursor) or Tiny (a
	      single pixel as the cursor).

		  # make the kill cursor be XC_gumby (both forms work):
		  CursorStyle DESTROY 56
		  CursorStyle DESTROY gumby

	      Alternatively, the cursor	can be loaded from an (XPM, PNG	or
	      SVG) image file.	If fvwm	is compiled with Xcursor support, full
	      ARGB is used, and	(possibly animated) cursor files made with the
	      xcursorgen program can be	loaded.	 Otherwise the cursor is
	      converted	to monochrome.

	      The optional x and y arguments (following	a file argument)
	      specifies	the hot-spot coordinate	with 0 0 as the	top left
	      corner of	the image.  Coordinates	within the image boundary are
	      valid and	overrides any hot-spot defined in the (XPM/Xcursor)
	      image file.  An invalid or undefined hot-spot is placed in the
	      center of	the image.

		  CursorStyle ROOT cursor_image.png 0 0

	      The optional fg and bg arguments specify the foreground and
	      background colors	for the	cursor,	defaulting to black and	white
	      (reverse video compared to the actual bitmap).  These colors are
	      only used	with monochrome	cursors.  Otherwise they are silently
	      ignored.

		  CursorStyle ROOT nice_arrow.xpm yellow black

       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
	      DefaultColors 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
	      argument.	 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
	      executed 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/resize feedback window appears and how window placement is
	      aborted.	To have	more Mwm- or Win-like behavior you can call
	      Emulate 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
	      configuring 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
	      guarantees 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
	      button 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
	      negative 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
	      guarantees are made that it works	for you.  FakeKeypress can
	      simulate key press and release events and	pass them to fvwm or
	      applications.  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, (without 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
	      letter.

       GlobalOpts [options]
	      This command is obsolete.	 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
	      image 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
	      another 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
	      previous 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
	      restored.

	      As for the ImagePath command, path may contain environment
	      variables	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]"
	      parameter:

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

	      Note 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
	      argument 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)
	      colors 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.

	      ImageCache which prints information about	the images loaded by
	      fvwm.  If	verbose	is one or greater all images in	the cache will
	      be listed	together with their respective reuse.

	      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.

	      bindings which prints information	on all the bindings fvwm has:
	      key, mouse and stroke bindings.  verbose has no effect with this
	      option.

	      infostore	which prints information on all	entries	in the
	      infostore, listing the key and its value.	 verbose has no	effect
	      with this	option.

       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
	      command 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
	      executed,	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
	      delay_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
	      condition.  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
	      windows is shown in parentheses.	Selecting an item from the
	      window list pop-up menu causes the interpreted function
	      "WindowListFunc" 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
	      focused 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,
	      NoLayer, NoNumInDeskTitle, NoCurrentDeskTitle, MaxLabelWidth
	      width, TitleForAllDesks, Function	funcname, Desk desknum,
	      CurrentDesk, NoIcons / Icons / OnlyIcons,	NoNormal / Normal /
	      OnlyNormal, NoSticky / Sticky / OnlySticky, NoStickyAcrossPages
	      /	StickyAcrossPages / OnlyStickyAcrossPages, NoStickyAcrossDesks
	      /	StickyAcrossDesks / OnlyStickyAcrossDesks, NoOnTop / OnTop /
	      OnlyOnTop, NoOnBottom / OnBottom / OnlyOnBottom, Layer m [n],
	      UseSkipList / OnlySkipList, NoDeskSort, ReverseOrder,
	      CurrentAtEnd, 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
	      window name (or icon name	if UseIconName is specified).
	      ReverseOrder 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
	      option 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
	      between m	and n are displayed.  n	defaults to m.	With the
	      ReverseOrder 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
	      intended 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.
	      NoNumInDeskTitle is only useful if a desktop name	is defined
	      with the DesktopName command.  It	causes fvwm to not display the
	      desktop number 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 multiples	of the display size.  With ShowScreen, the
	      window's Xinerama	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
	      window 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
	      requests 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
	      AddToMenu.

   Window Movement and Placement
       AnimatedMove x y	[Warp]
	      Move a window in an animated fashion.  Similar to	Move command.
	      The options are the same,	except they are	required, since	it
	      doesn't make sense to have a user	move the window	interactively
	      and animatedly.  If the optional argument	Warp is	specified 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
	      window only in its layer.	 To bring a window to the absolute
	      bottom, use

		  AddToFunc lower-to-bottom
		   + I Layer 0 0
		   + I Lower

       Move [[screen screen] [w	| m]x[p	| w] ... [w | m]y[p | w] ... [Warp]] |
       [pointer] | [ewmhiwa]
	      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.  By default, the EWMH working area is honoured.

	      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
	      window.  If the single argument pointer is given,	the top	left
	      corner of	the window is moved to the pointer position before
	      starting the operation; this is mainly intended for internal use
	      by modules like FvwmPager.  If the optional argument ewmhiwa is
	      given, then the window position will ignore the working area
	      (such as ignoring	any values set via EwmhBaseStruts).

	      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.

	      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, while a trailing 'w'	means precent of the window
	      width/height.  To	move the window	relative to its	current
	      position,	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.

	      For advanced uses, the arguments x and y can be used multiple
	      times, but without the prefix 'm'	or 'w'.	 (See complex examples
	      below).

	      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
	      keystrokes, 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

		  # Move window	to center of screen (50% of screen
		  # poition minus 50% of widow size).
		  Move 50-50w 50-50w

	      Note: In order to	obtain moving windows which do not snap	to
	      screen, with interactive move, hold down Alt whilst moving the
	      window to	disable	snap attraction	if it's	defined.

	      See also the AnimatedMove	command.

       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
	      replacement for the obsolete 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
	      beyond 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), 'w' for the
	      screen containing	the center of +the context window, '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
	      omitted or invalid the default value is set.  To resize windows
	      in an opaque manner you can use the ResizeOpaque style.  See the
	      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
	      window 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	the Style command) otherwise
	      it is lowered.

       Resize [[frame] [direction dir] [warptoborder automatic]
       [fixeddirection]	[w]width[p | c | wa | da] [w]height[p |	c]]
	      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
	      target 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'
	      suffix the unit defined by the client application	(hence the c)
	      is used.	With the suffix	'wa' the value is a percentage of the
	      width or height size of the EWMH working area, and with the
	      suffix 'da' it is	a percentage of	the width or height of the
	      EWMH dynamic working area.  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
	      untouched.  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.  If the special option
	      automatic	is given as a direction	argument, then the direction
	      to resize	is calculated based on the position of the pointer in
	      the window.  If the pointer is in	the middle of the window, then
	      no direction is calculated.  The warptoborder option can be used
	      to warp the pointer to the direction indicated.  As with the
	      automatic	option for direction, the border to warp to is
	      calculated based on the pointer's	proximity to a given border.
	      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

       Resize [bottomright | br	x y]
	      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
	      accepted 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
	      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 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 command and the move-arguments are	exactly	the same
	      arguments	as for the Move	command	except the pointer option
	      which is not supported 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
	      command.	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
	      LowerTransient 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
	      omitted, 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 [behaviour] [Screen]]
	      The SnapAttraction command is obsolete.  It has been replaced by
	      the Style	command	option SnapAttraction.

       SnapGrid	[x-grid-size y-grid-size]
	      The SnapGrid command is obsolete.	 It has	been replaced by the
	      Style command option SnapGrid.

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

	      This command has been removed and	must be	replaced by
	      MoveToDesk, the arguments	for which are the same as for the
	      GotoDesk command.

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

   Focus & 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
	      expressed	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
	      appending	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
	      WindowList 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
	      Direction	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
	      WarpToWindow 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 [!raise | raise] x[p] y[p]
	      Warps the	cursor to the associated window	and raises it (unless
	      the option !raise	is present).  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	appended 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	visible.  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

   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,
	      frequently causing the application to exit.

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

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

	      There are	a number of Style options which	influence the
	      appearance 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
	      removed in the future.

       Maximize	[flags]	[bool |	forget]	[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 just	the parameter "forget" a maximized window reverts back
	      into normal state	but keeps its current maximized	size.  This
	      can be useful in conjunction with	the commands ResizeMaximize
	      and ResizeMoveMaximize.  If the window is	not maximized, nothing
	      happens.

	      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
	      maximized	to curren available space until	finding	any obstacle.
	      The vertical resizing is similar.	 If both horizontal and
	      vertical values are "grow", it expands vertically	first, then
	      horizontally to find space.  Instead of the horizontal "grow"
	      argument,	"growleft" or "growright" can be used respectively
	      "growup" and "growdown".	The optional flags argument is a space
	      separated	list containing	the following key words: fullscreen,
	      ewmhiwa, growonwindowlayer, growonlayers and screen.  fullscreen
	      causes the window	to become fullscreened if the appropriate EWMH
	      hint is set.  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 growonlayers 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 argument 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 current 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
	      direction:

		  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-workers@fvwm.org>.	This command may be removed at some
	      point in the future.  Please read	the note at the	end of the
	      section Delayed Execution	of Commands to learn about how to
	      avoid the	Recapture 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
	      Recapture	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
	      pending updates of all windows' styles and looks are applied
	      immediately.  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
	      different	direction, use the ShadeAgain option.  The direction
	      Last shades the window in	the direction it last was shaded.  If
	      the window has never been	shaded before it is shaded as if no
	      direction	had been given.	 Windows without titles	can be shaded
	      too.  Please refer also to the options WindowShadeSteps,
	      WindowShadeShrinks, WindowShadeScrolls, WindowShadeLazy,
	      WindowShadeAlwaysLazy and	WindowShadeBusy	options	of the Style
	      command.	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
	      argument 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
	      option of	the Style command instead.

   Mouse, Key &	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
	      unpredictable.  The should appear	before any applications	or
	      modules are started in your config file (e.g. with the Exec
	      command).

	      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
	      ignored.	This command comes in handy if the num-lock and
	      scroll-lock keys interfere with your shortcuts.  With XFree86
	      '2' usually is the num-lock modifier and '5' refers to the
	      scroll-lock key.	To turn	all these pesky	modifiers off you can
	      use this command:

		  IgnoreModifiers L25

	      If the Modifiers argument	is the string "default", fvwm reverts
	      back to the default value	"L".

	      Important
	      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 number of modifiers
	      you want to ignore.  If you do not have a	lightning fast machine
	      or very few bindings you should not ignore 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 -1
		  Style	* EdgeMoveDelay	250
		  Style	* EdgeMoveResistance 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.

       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
	      Modifiers	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 special context 'M' for menus	can be used to (re)define the
	      menu controls.  It be used alone or together with	'T', 'S', 'I',
	      '[', ']',	'-' and	'_'.  See the Menu Bindings section for
	      details.

	      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
	      appear.  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
	      limitations 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
	      buttons.	Only 'S' and 'W' are valid for an undecorated window.

	      The special context 'M' for menus	can be used to (re)define the
	      menu controls.  It can be	used alone or together with 'T', 'S',
	      'I', '[',	']', '-' and '_'.  See the Menu	Bindings section for
	      details.

	      The special context 'P' controls what buttons that can be	used
	      to place a window.  When using this context no modifiers are
	      allowed (Modifiers must be N), no	window is allowed, and the
	      Function must be one of PlaceWindow, PlaceWindowDrag,
	      PlaceWindowInteractive, CancelPlacement, CancelPlacementDrag,
	      CancelPlacementInteractive 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
	      resized after being placed.  This	is controlled by the Emulate
	      command.	Also a window being dragged can	always be placed by
	      releasing	the button hold	while dragging,	regardless of if it is
	      set to PlaceWindow or not.

	      PlaceWindowDrag and PlaceWindowInteractive/CancelPlacementDrag
	      and CancelPlacementInteractive work as
	      PlaceWindow/CancelPlacement 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
	      buttons 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
	      pattern 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-specific 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
	      IgnoreModifiers 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
	      either mouse buttons or keyboard keys.

       PointerKey [(window)] Keyname Context Modifiers Function
	      This command works exactly like the Key command.	The only
	      difference is that the binding operates on the window under the
	      pointer.	Normal key bindings operate on the focused window
	      instead.	The PointerKey command can for example be used to bind
	      keys to the root window if you are using SloppyFocus or
	      ClickToFocus.  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
	      command only for key combinations	that are not needed in any
	      application 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
	      defined 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
	      complex motion may produce several different sequences (see the
	      "netscape" example below to handle such motion).	Moreover,
	      sequences	are limited to 20 elements (with the present version
	      of libstroke), however, in practice it is	preferable to use
	      sequence with less than 12 elements.

	      Because of the default button menu in fvwm, you may need to
	      remove 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
	      (respectively, 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,
	      EchoSequence, 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 corresponds to a	stroke binding.	 StrokeWidth takes an
	      integer argument,	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
	      motion 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,
	      Modifiers, 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.

   Controlling Window Styles
       For readability,	the commands in	this section are not sorted
       alphabetically.	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
	      immediately.  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
	      recommended.  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
	      selected 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
	      values other than	the default or to set the window manager
	      default styles.

	      stylename	can be a window's name,	class, visible name, 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 is used in addition to any window names when selecting
	      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,	!Icon /	Icon, MiniIcon,	IconBox,
	      IconGrid,	IconFill, IconSize, !Title / Title, TitleAtBottom /
	      TitleAtLeft / TitleAtRight / TitleAtTop, LeftTitleRotatedCW /
	      LeftTitleRotatedCCW, RightTitleRotatedCCW	/ RightTitleRotatedCW,
	      TopTitleRotated /	TopTitleNotRotated, BottomTitleRotated /
	      BottomTitleNotRotated, !UseTitleDecorRotation /
	      UseTitleDecorRotation, StippledTitle / !StippledTitle,
	      StippledIconTitle	/ !StippledIconTitle, IndexedWindowName	/
	      ExactWindowName, IndexedIconName / ExactIconName,	TitleFormat /
	      IconTitleFormat /	!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 /
	      StickyStippledIconTitle, StartIconic / StartNormal, Color,
	      ForeColor, BackColor, Colorset, HilightFore, HilightBack,
	      HilightColorset, BorderColorset, HilightBorderColorset,
	      IconTitleColorset, HilightIconTitleColorset,
	      IconBackgroundColorset, IconTitleRelief, IconBackgroundRelief,
	      IconBackgroundPadding, Font, IconFont, StartsOnDesk /
	      StartsOnPage / StartsAnyWhere, StartsOnScreen, StartShaded /
	      !StartShaded, ManualPlacementHonorsStartsOnPage /
	      ManualPlacementIgnoresStartsOnPage, CaptureHonorsStartsOnPage /
	      CaptureIgnoresStartsOnPage, RecaptureHonorsStartsOnPage /
	      RecaptureIgnoresStartsOnPage, StartsOnPageIncludesTransients /
	      StartsOnPageIgnoresTransients, IconTitle / !IconTitle,
	      MwmButtons / FvwmButtons,	MwmBorder / FvwmBorder,	MwmDecor /
	      !MwmDecor, MwmFunctions /	!MwmFunctions, HintOverride /
	      !HintOverride, !Button / Button, ResizeHintOverride /
	      !ResizeHintOverride, OLDecor / !OLDecor, GNOMEUseHints /
	      GNOMEIgnoreHints,	StickyIcon / SlipperyIcon,
	      StickyAcrossPagesIcon / !StickyAcrossPagesIcon,
	      StickyAcrossDesksIcon / !StickyAcrossDesksIcon, ManualPlacement
	      /	CascadePlacement / MinOverlapPlacement /
	      MinOverlapPercentPlacement / TileManualPlacement /
	      TileCascadePlacement / PositionPlacement,
	      MinOverlapPlacementPenalties,
	      MinOverlapPercentPlacementPenalties, DecorateTransient /
	      NakedTransient, DontRaiseTransient / RaiseTransient,
	      DontLowerTransient / LowerTransient, DontStackTransientParent /
	      StackTransientParent, SkipMapping	/ ShowMapping,
	      ScatterWindowGroups / KeepWindowGroupsOnDesk, UseDecor,
	      UseStyle,	!UsePPosition /	NoPPosition / UsePPosition,
	      !UseUSPosition, NoUSPosition / UseUSPosition,
	      !UseTransientPPosition, NoTransientPPosition /
	      UseTransientPPosition, !UseTransientUSPosition /
	      NoTransientUSPosition / UseTransientUSPosition, !UseIconPosition
	      /	NoIconPosition / UseIconPosition, Lenience / !Lenience,
	      ClickToFocus / SloppyFocus / MouseFocus|FocusFollowsMouse	/
	      NeverFocus, ClickToFocusPassesClickOff /
	      ClickToFocusPassesClick, ClickToFocusRaisesOff /
	      ClickToFocusRaises, MouseFocusClickRaises	/
	      MouseFocusClickRaisesOff,	GrabFocus / GrabFocusOff,
	      GrabFocusTransientOff / GrabFocusTransient, FPFocusClickButtons,
	      FPFocusClickModifiers, !FPSortWindowlistByFocus /
	      FPSortWindowlistByFocus, FPClickRaisesFocused /
	      !FPClickRaisesFocused, FPClickDecorRaisesFocused /
	      !FPClickDecorRaisesFocused, FPClickIconRaisesFocused /
	      !FPClickIconRaisesFocused, !FPClickRaisesUnfocused /
	      FPClickRaisesUnfocused, FPClickDecorRaisesUnfocused /
	      !FPClickDecorRaisesUnfocused, FPClickIconRaisesUnfocused /
	      !FPClickIconRaisesUnfocused, FPClickToFocus / !FPClickToFocus,
	      FPClickDecorToFocus / !FPClickDecorToFocus, FPClickIconToFocus /
	      !FPClickIconToFocus, !FPEnterToFocus / FPEnterToFocus,
	      !FPLeaveToUnfocus	/ FPLeaveToUnfocus, !FPFocusByProgram /
	      FPFocusByProgram,	!FPFocusByFunction / FPFocusByFunction,
	      FPFocusByFunctionWarpPointer / !FPFocusByFunctionWarpPointer,
	      FPLenient	/ !FPLenient, !FPPassFocusClick	/ FPPassFocusClick,
	      !FPPassRaiseClick	/ FPPassRaiseClick, FPIgnoreFocusClickMotion /
	      !FPIgnoreFocusClickMotion, FPIgnoreRaiseClickMotion /
	      !FPIgnoreRaiseClickMotion, !FPAllowFocusClickFunction /
	      FPAllowFocusClickFunction, !FPAllowRaiseClickFunction /
	      FPAllowRaiseClickFunction, FPGrabFocus / !FPGrabFocus,
	      !FPGrabFocusTransient / FPGrabFocusTransient,
	      FPOverrideGrabFocus / !FPOverrideGrabFocus, FPReleaseFocus /
	      !FPReleaseFocus, !FPReleaseFocusTransient	/
	      FPReleaseFocusTransient, FPOverrideReleaseFocus /
	      !FPOverrideReleaseFocus, StartsLowered / StartsRaised,
	      IgnoreRestack / AllowRestack, FixedPosition / VariablePosition,
	      FixedUSPosition /	VariableUSPosition, FixedPPosition /
	      VariablePPosition, FixedSize / VariableSize, FixedUSSize /
	      VariableUSSize, FixedPSize / VariablePSize, !Closable /
	      Closable,	!Iconifiable / Iconifiable, !Maximizable /
	      Maximizable, !AllowMaximizeFixedSize / AllowMaximizeFixedSize,
	      IconOverride / NoIconOverride / NoActiveIconOverride,
	      DepressableBorder	/ FirmBorder, MinWindowSize, MaxWindowSize,
	      IconifyWindowGroups / IconifyWindowGroupsOff, ResizeOpaque /
	      ResizeOutline, BackingStore / BackingStoreOff /
	      BackingStoreWindowDefault, Opacity / ParentalRelativity,
	      SaveUnder	/ SaveUnderOff,	WindowShadeShrinks /
	      WindowShadeScrolls, WindowShadeSteps, WindowShadeAlwaysLazy /
	      WindowShadeBusy /	WindowShadeLazy, EWMHDonateIcon	/
	      EWMHDontDonateIcon, EWMHDonateMiniIcon / EWMHDontDonateMiniIcon,
	      EWMHMiniIconOverride / EWMHNoMiniIconOverride,
	      EWMHUseStackingOrderHints	/ EWMHIgnoreStackingOrderHints,
	      EWMHIgnoreStateHints / EWMHUseStateHints,	EWMHIgnoreStrutHints /
	      EWMHUseStrutHints, EWMHIgnoreWindowType /	!EWMHIgnoreWindowType,
	      EWMHMaximizeIgnoreWorkingArea / EWMHMaximizeUseWorkingArea /
	      EWMHMaximizeUseDynamicWorkingArea,
	      EWMHPlacementIgnoreWorkingArea / EWMHPlacementUseWorkingArea /
	      EWMHPlacementUseDynamicWorkingArea, MoveByProgramMethod,
	      Unmanaged, State,	SnapGrid, SnapAttraction, EdgeMoveDelay,
	      EdgeResizeDelay.	EdgeMoveResistance, InitialMapCommand

	      In the above list	some options are listed	as
	      style-option/opposite-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 FocusFollowsMouse) 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 FvwmButtons.	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 restore FPGrabFocus.

		     The focus model can be augmented with several additional
		     options.  In fvwm-2.5.3 and later,	there are a large
		     number of advanced	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
		     receives 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	focus 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	controlled 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 one to raise	the window when	the interior or	the
		     decorations or the	icon of	the window is clicked while
		     the window	is already focused.

		     The styles	FPClickRaisesUnfocused,
		     FPClickDecorRaisesUnfocused and
		     FPClickIconRaisesUnfocused	allow one 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
		     application.  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
		     FPGrabFocusTransient 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 disabled, 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
		     GrabFocusTransient	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,
		     FPReleaseFocusTransient 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 receives the focus.

		     ClickToFocusPassesClickOff	and ClickToFocusPassesClick
		     controls whether a	mouse click to focus a window is sent
		     to	the application	or not.	 Similarly,
		     ClickToFocusRaisesOff/MouseFocusClickRaisesOff 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
		     FPGrabFocusTransient + FPReleaseFocusTransient.

		     Lenience is equivalent to the new style FPLenient.

	      Window title
		     The Title and !Title options determine if the window has
		     a title-bar or not.  By default all windows have a
		     title-bar.	 NoTitle 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	rotated	counterclockwise by 90 degrees from the	normal
		     upright position and 90 degrees clockwise for titles on
		     the right side.  It can also be rotated in	the opposite
		     directions	with LeftTitleRotatedCW	if TitleAtLeft is
		     used, and with RightTitleRotatedCCW if TitleAtRight is
		     used.  The	defaults can be	restored with
		     LeftTitleRotatedCCW and RightTitleRotatedCW.  A normal
		     horizontal	text may be rotated as well with
		     TopTitleRotated if	TitleAtTop 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 !UseTitleDecorRotation style.
		     UseTitleDecorRotation reverts back	to the default.

		     With the StippledTitle style, titles are drawn with the
		     same effect 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	BackColor 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 decoration 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	window border.	To stop	using a
		     colorset, the argument is omitted.

		     The HilightBorderColorset style option works similarly to
		     BorderColorset 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	using this colorset, the argument is
		     omitted.

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

		     IconBackgroundColorset takes the colorset number as its
		     sole argument 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	between	-50 and	+50 pixels and defines the thickness
		     of	the 3D relief 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	between	0 and 50 pixels	and defines the	amount of free
		     space between the relief of the icon background picture
		     (if any) and the icon picture.  The default is 2 and it
		     is	restored if the	argument 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 IconFont commands.

		     The deprecated 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.  This has been replaced with:

			 TitleFormat %n	(%t)

		     ExactWindowName restores the default which	is to use the
		     exact window name.	 Deprecated in favour of:

			     TitleFormat %n

		     IndexedIconName and ExactIconName work the	same as
		     IndexedWindowName and ExactWindowName styles but for the
		     icon titles.  Both	are deprecated in favour of:

			 IconTitleFormat %n (%t)
			 IconTitleFormat %n

		     TitleFormat describes what	the visible name of a window
		     should look like, with the	following placeholders being
		     valid:

		     %n
			 Insert	the window's name.

		     %i
			 Insert	the window's icon name.

		     %c
			 Insert	the window's class name.

		     %r
			 Insert	the window's resource name.

		     %t
			 Insert	the window count.

		     %I
			 Insert	the window ID.

		     %%
			 Insert	a literal '%' character.

		     Any amount	of whitespace may be used, along with other
		     characters	to make	up the string -- but a valid
		     TitleFormat string	must contain at	least one of the
		     placeholders mentioned.  No quote stripping is performed
		     on	the string, so for example the following is printed
		     verbatim:

			     TitleFormat " %n "	-> [%t]	->	[%c]

		     Note: It's	perfectly possible to use a TitleFormat	which
		     can result	in wiping out the visible title	altogether.
		     For example:

			     TitleFormat %z

		     Simply because the	placeholder '%z' isn't supported.
		     This is not a bug but rather a facet of how the
		     formatting	parser works.

		     IconTitleFormat describes what the	visible	icon name of a
		     window should look	like, with the options being the same
		     as	TitleFormat.

	      Title buttons
		     Button and	!Button	take a numeric argument	which is the
		     number of the title-bar button which is to	be shown or
		     omitted.  NoButton	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)
		     completely.  The Borders style enables them again.
		     Without borders, all other	styles affecting window
		     borders are meaningless.

		     MwmBorder makes the 3D bevel more closely match Mwm's.
		     FvwmBorder	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	default, or if Handles is specified,
		     the width from the	HandleWidth 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.  Using HandleWidth	without	an argument
		     restores the default.

		     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.  Using BorderWidth without an argument
		     restores the default.

		     DepressableBorder makes the border	parts of the window
		     decoration	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
		     optionally	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
		     located.  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 resizes in pixel	increments, for
		     example, xv.  Then	resize and place the xv	window where
		     you want the iconbox.  Then use FvwmIdent 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 example:

			 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.  That's 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 example 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 argument to clip or
		     stretch an	icon to	a maximum size.	 An IconGrid
		     definition	must follow 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 bottom.  This would be expressed
		     as:

			 IconFill left top

		     To	fill an	icon box in columns instead of rows, specify
		     the vertical direction (top or bottom) first.  The
		     directions	can be abbreviated 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 maximum size of an	icon.  Icon
		     images that are smaller than the minimum size are padded.
		     Icon images that are bigger than the maximum 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 are 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.

		     In	addition to the	numeric	arguments, 1 additional
		     argument can be "Stretched", "Adjusted", or "Shrunk".

		     Note that module provided icon managers are not affected
		     by	this style.

	      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
	      (FvwmIconMan and FvwmPager).  It takes the name of a pixmap as
	      an argument.

	      WindowShadeShrinks and WindowShadeScrolls	control	if the
	      contents of a window that	is being shaded	with the WindowShade
	      command 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
	      animation	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
	      example, 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 before 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 WindowShadeBusy 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
	      applications 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.

	      StickyIcon makes the window sticky when it's iconified.  It
	      de-iconifies on top the active desktop.  SlipperyIcon 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
	      window has also been marked as Sticky.  Note that	this is	the
	      default 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 it's 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,
	      AllowRestack 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
	      dimensions of new	windows	(depending on the application).	 If
	      windows are created at strange places, try either	the
	      VariablePPosition	or !UsePPosition 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
	      detect 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
	      remembers	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
	      IgnoreGravity 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
	      options first and	then use AutoDetect again.

	      Note: This option	was introduced to alleviate a problem with the
	      ICCCM specification.  The	ICCCM 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
	      performed	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,
	      !AllowMaximizeFixedSize, inhibits	all windows that are not
	      resizable	from being maximized.

	      ResizeHintOverride instructs fvwm	to ignore the program supplied
	      minimum and maximum size as well as the resize step size (the
	      character	size in	many applications).  This can be handy for
	      broken applications that refuse to be resized.  Do not use it if
	      you do not need it.  The default (opposite) style	is
	      NoResizeOverride.

	      MinWindowSize [ width [ p	] height [ p ] ] Tells fvwm the
	      minimum width and	height of a window.  The values	are the
	      percentage 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 for certain versions of xemacs
	      which freak out if their windows become too small.  If you omit
	      he parameters or their values are	invalid, both limits are set
	      to 0 pixels (which is the	default	value).

	      MaxWindowSize [ width [ p	] height [ p ] ] Tells fvwm the
	      maximum width and	height of a window.  The values	are the
	      percentage 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 and	deiconified at once when any window in the
	      group is (de)iconified.  The default 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.

	      The option SnapAttraction	affects	interactive window movement:
	      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
	      snapping happens.	 Calling this command without arguments	turns
	      off snap attraction and restores the default behavior.  Please
	      refer also to the	SnapGrid command.

	      The second argument determined is	optional and may be set	to one
	      of the five following values: With All both icons	and windows
	      snap to other windows and	other icons.  SameType lets windows
	      snap only	to windows, and	icons snap only	to icons.  With
	      Windows windows snap only	to other windows.  Similarly with
	      Icons icons snap only to other icons.  With None no snapping
	      takes place.  This option	can be useful in conjunction with the
	      following	argument if you	only want to snap against the screen
	      edges.  The default behavior is All.

	      The third	and last optional argument may be set to one of	the
	      four following values:

	      o	  With Screen the already snapping icons or windows, which is
		  controlled by	the second argument, will snap now also	to the
		  screen edges.

	      o	  ScreenWindows	snaps only windows to the screen edges.

	      o	  ScreenIcons snaps only icons to the screen edges.

	      o	  ScreenAll snaps windows and icons to the screen edges.

	      The option SnapGrid defines an invisible grid on the screen.
	      During an	interactive move a window or icon is positioned	such
	      that its location	(top left corner) is coincident	with the
	      nearest 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.  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
	      window on	the x axis while snapping to a grid point on the y
	      axis.  Using this	style without arguments	reinstates the default
	      settings.

	      The styles EdgeMoveDelay and EdgeResizeDelay tells how hard it
	      should be	to change the desktop viewport by moving or resizing a
	      window over the edge of the screen.  The parameter tells how
	      many milliseconds	the pointer must spend on the screen edge
	      before fvwm moves	the viewport.  The command EdgeScroll
	      determines how far the viewport is scrolled.  If -1 is given as
	      the delay, page flipping is disabled completely.	The defaults
	      are no delay for moving (0) and no flipping for resizing (-1).
	      Using these styles without any argument restores the default
	      settings.	 Note that, with

		  EdgeScroll 0 0

	      it is still possible to move or resize windows across the	edge
	      of the current screen.  See also EdgeThickness.

	      The option EdgeMoveResistance makes it easier to place a window
	      directly adjacent	to the screen's	or xinerama screen's border.
	      It takes one or two parameters.  The first parameter tells how
	      many pixels over the edge	of the screen a	window's edge must
	      move before it actually moves partially off the screen.  The
	      optional second parameter	does the same as the first, but	for
	      individual Xinerama screens.  If omitted,	the value of the first
	      parameter	is assumed for this type of movement.  Set the second
	      parameter	to 0 to	zero to	ignore individual xinerama screen
	      edges.  Note that	the center of the window being moved
	      determines the xinerama screen on	which the window should	be
	      kept.  Both values are 0 by default.  To restore the defaults,
	      the option EdgeMoveResistance can	be used	without	any
	      parameters.

	      The option InitialMapCommand allows for any valid	fvwm command
	      or function to run when the window is initially mapped by	fvwm.
	      Example:

		  Style	MyWindow StartsOnPage 0	0, InitialMapCommand Iconify

	      This would hence place the window	called MyWindow	on page	0 0
	      for the current desk, and	immediately run	the Iconify command on
	      that window.

	      Note that	should InitialMapCommand be used as a global option
	      for all windows, but there is a need that	some windows should
	      not have this command applied, then an action of Nop can be used
	      on those windows,	as in the following example:

		  Style	* InitialMapCommand Iconify
		  Style	XTeddy InitialMapCommand Nop

       Window Manager placement
	      Applications can place windows at	a particular spot on the
	      screen either by window manager hints or a geometry
	      specification.  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.

	      PositionPlacement	[Center|UnderMouse|move-arguments] When	used
	      without an argument, new windows are placed in the top left
	      corner of	the display.  With the argument	Center,	all new	window
	      appear at	the center of the screen, and with UnderMouse, windows
	      are centered under the mouse pointer where possible.  If the
	      window is	unable to fit on the screen because the	pointer	is at
	      the edge of the screen, then the window is forced	on-screen
	      using this option.  If any other move-arguments are given, they
	      are interpreted exactly as the Move command does (with the
	      exception	that references	to the current window position do not
	      work as the window has not been placed yet).

	      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
	      CascadePlacement is used as a fall-back method.

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

	      MinOverlapPlacement automatically	places new windows in a
	      location 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
	      MinOverlapPercentPlacementPenalties 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

	      To reset this style to the default values, prefix	it with	a '!'.
	      This style configures the	MinOverlapPlacement and
	      MinOverlapPercentPlacement placement policy.  The	normal factor
	      affects normal 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 factor 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
	      EWMHPlacementUseWorkingArea 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
	      MinOverlapPercentPlacement covers	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 exception 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

	      To reset this style to the default values, prefix	it with	a '!'.
	      This style affects the MinOverlapPercentPlacement	placement
	      policy 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
	      during 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
	      resize 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
	      enlarged until it	hits the bottom	screen border.

	      Old placement styles DumbPlacement / SmartPlacement /
	      SmartPlacementOff, CleverPlacement / CleverPlacementOff,
	      ActivePlacement /	RandomPlacement,
	      ActivePlacementsHonorsStartsOnPage /
	      ActivePlacementsHonorsStartsOnPageOff, GlobalOpts
	      SmartPlacementIsReallySmart / 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
	      !UsePPosition instructs fvwm to ignore the program specified
	      position (PPosition hint)	when adding new	windows.  Using
	      PPosition	is required for	some applications, but if you do not
	      have one of those	it's a real headache.  Many programs set
	      PPosition	to something obnoxious like 0,0	(upper left corner).
	      Note: !UsePPosition is equivalent	to the deprecated option
	      !UsePPosition

	      !UseUSPosition works like	!UsePPosition 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.  Note: !UseUSPosition	is equivalent to the
	      deprecated option	!USPosition

	      NoUseTransientPPosition and UseTransientPPosition	work like
	      !UsePPosition and	UsePPosition but apply only to transient
	      windows.	Note: !UseTransientPPosition is	equivalent to the
	      deprecated option	!TransientPPosition

	      NoUseIconPosition	instructs fvwm to ignore the program specified
	      icon position (IconPosition hint)	when iconifying	the window.
	      Note: !UseIconPosition is	equivalent to the deprecated option
	      !IconPosition

	      StartsOnDesk takes a numeric argument which is the desktop
	      number 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
	      primary 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
	      created.	However, those windows which are not placed by fvwm
	      (i.e., those with	a USPosition hint from a user specified
	      geometry)	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
	      understand 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
	      useful, since transients are usually pop ups that	you want to
	      appear 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
	      wondering	where it disappeared to, because it got	placed on a
	      different	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 ManualPlacementIgnoresStartsOnPage;
	      ManualPlacementHonorsStartsOnPage	matches	the way	the old
	      StartsOnDesk style used to handle	the situation.

	      CaptureHonorsStartsOnPage	causes the initial capture (of an
	      already 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 capture.	The default is CaptureIgnoresStartsOnPage.

	      RecaptureHonorsStartsOnPage causes a window to be	placed
	      according	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 RecaptureIgnoresStartsOnPage.

	      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.

	      StartShaded tells	fvwm to	shade the window.  An optional
	      direction	argument may be	given, which can be one	of "North",
	      "South", "West", "East", "NorthWest", "NorthEast", "SouthWest",
	      "SouthEast" or if	no direction is	given, the default is to shade
	      north.

	      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
	      default 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
	      windows raises all its transients	when it	is raised.  The
	      DontRaiseTransient style disables	this behavior.	All windows
	      are then treated as if they had no transients.

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

	      The StackTransientParent style augments RaiseTransient and
	      LowerTransient styles.  Raising a	window with
	      StackTransientParent style transfers the raise action to the
	      main window if the window	being raised is	a transient and	its
	      main window has RaiseTransient style; this effect	makes raise on
	      a	transient act just like	raise on its main - the	whole group is
	      raised.  Similar behavior	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 Extended	Window Manager Hints section.

	      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
	      hardware (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
	      EWMHDontDonateMiniIcon 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
	      respect EWMH hints which change the window layer.
	      EWMHIgnoreStackingOrderHints 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.
	      EWMHIgnoreStrutHints causes fvwm to ignore such hints, as
	      EWMHUseStrutHints, 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
	      EWMHMaximizeUseWorkingArea the EWMH working area is used as with
	      EWMHMaximizeUseDynamicWorkingArea	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
	      dynamic 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
	      MinOverlapPlacementPenalties 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
	      obscured 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
	      below).  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
	      backing 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
	      SaveUnderOff 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.
	      Opacity 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
	      prohibit,	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
	      window, 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
	      future.  There are plans to replace it with a more flexible
	      solution 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
	      AddToDecor, the changes are visible for all windows which	are
	      assigned to it.  The decor for a window can be reassigned	with
	      ChangeDecor.

	      UseStyle This style is deprecated	and will be removed in the
	      future.  There are plans to replace it with a more flexible
	      solution 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
	      similar 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
	      modified.	 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
	      conditional commands like	Next with the State condition and
	      manipulated 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 modules like FvwmIconMan.  In the modules, the	style can
	      usually be ignored with an option.  Please refer to the man page
	      of the module in question	for further information.  To disable
	      this feature, use	the default style WindowListHit.

	      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
	      explicitly in the	condition with the CirculateHit,
	      CirculateHitIcon or CirculateHitShaded conditions, and some
	      conditional commands, 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
	      understand 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.

   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
	      focused 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",
	      "AllInactiveDown".

	      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
	      additional 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
	      AddButtonStyle.  To clear	the button style stack,	change style
	      flags, or	for descriptions of available styles and flags,	see
	      the ButtonStyle 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
	      before, 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
	      AddButtonStyle command.

	      Title-bars are drawn in the order	of definition, beginning with
	      the most recent TitleStyle, followed by those added with
	      AddTitleStyle.  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,
	      HilightColorset and WindowFont commands in decors.  This is no
	      longer possible.	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.
	      Modifying	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
	      ButtonStyle, AddButtonStyle, TitleStyle, AddTitleStyle and
	      BorderStyle commands.  Decors created with AddToDecor can	be
	      manipulated with ChangeDecor, DestroyDecor, UpdateDecor and the
	      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
	      "Active" or "Inactive".  If state	is omitted, then the style is
	      set for both states.  If the style and flags are enclosed	in
	      parentheses, 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 !Handles
	      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
	      textured 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
	      UseBorderStyle flag (see ButtonStyle).

       ButtonState [ActiveDown bool] [Inactive bool] [InactiveDown bool]
	      The ButtonState command controls which states of the window
	      titles and title buttons are used.  The default is to use	all
	      four states: "ActiveUp", "ActiveDown", "InactiveUp" and
	      "InactiveDown" (see ButtonStyle and TitleStyle commands).	 The
	      bool argument after the key word controls	if the designated
	      state is used ("True") or	not ("False").	The bool flag is the
	      same as other commands, and not limited to just "True" or
	      "False"; "Yes" and "No" may also be used.	 The "ActiveUp"	state
	      cannot be	deactivated.  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
	      depending	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
	      title-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 parentheses, 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
	      "ActiveUp" 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
	      MwmDecorMax, 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
	      destroys 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
	      current 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
	      BorderStyle options.

	      Raised, Sunk and Flat are	mutually exclusive, and	can be
	      specified	for the	initial	ButtonStyle only.  UseTitleStyle and
	      UseBorderStyle are also mutually exclusive (both can be off
	      however).	 The default is	Raised with both UseBorderStyle	and
	      UseTitleStyle left unset.

	      Important
	      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 "InactiveDown"	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 applies to the
	      "Toggled"	states.

	      Button styles are	classified as non-destructive, partially
	      destructive, 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
	      destructive 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,
	      AdjustedPixmap, ShrunkPixmap, StretchedPixmap, TiledPixmap,
	      MiniIcon

	      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
	      command other than ButtonStyle or	AddButtonStyle is used,	the
	      number 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
	      single 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
	      colorset background is hidden and	if it is 100 the colorset
	      background is fully applied.  The	default	is 100.	 So, the
	      destructiveness 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
	      coordinates 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
	      highlight	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
	      question 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
	      specified	as an argument.	 For example, the following would give
	      button 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
	      button, 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
	      separated	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
	      option 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
	      display 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
	      minimize or iconify the window.  The default assignment is the
	      second 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
	      maximize 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
	      invalid, 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
	      Centered,	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
	      reset 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",
	      "InactiveUp", or "InactiveDown".	Shortcuts like "Active"	and
	      "Inactive" 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
	      UseTitleStyle.  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
	      relief 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,
	      AdjustedPixmap, ShrunkPixmap, StretchedPixmap, TiledPixmap,
	      MiniIcon.

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

	      In addition to these styles TitleStyle accepts a powerful
	      MultiPixmap 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
	      either 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
	      BorderStyle (possibly used in conjunction	with AddToDecor).
	      Specifying 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.

   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
	      consecutive 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 delayEdgeResistance scrolling moving
       [xinerama-scrolling]
	      Tells how	hard it	should be to change the	desktop	viewport by
	      moving the mouse over the	edge of	the screen.  The 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.	If -1 is given as the delay, scrolling is disabled
	      completely.

	      The second form of invocation with two or	three arguments	is
	      obsolete and should be replaced with the following three
	      commands as needed:

		  EdgeResistance scrolling
		  Style	* EdgeMoveDelay	scrolling
		  Style	* EdgeMoveResistance moving
		  or
		  Style	* EdgeMoveResistance moving xinerama-scrolling

	      Fvwm does	this substitution automatically	and prints a warning.

       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
	      interpretation 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
	      between 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
	      example, 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
	      additional 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	definition 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 determined 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
	      understood as a relative and an absolute desk number.  Three
	      arguments	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 visited 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,
	      similar 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
	      arguments.

	      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]	| reverse]
	      Scrolls the virtual desktop's viewport by	horizontal pages in
	      the x-direction and vertical pages in the	y-direction or starts
	      interactive scrolling of the viewport.  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.

	      Without arguments	or if the option reverse is given interactive
	      scrolling	takes place.  The viewport scrolls as the mouse	is
	      moved.  With the reverse option scrolling	is done	in opposite
	      direction	of the mouse movement, and without it scrolling	in the
	      same direction as	the mouse.

	      The binding

		  Mouse	1 A CM Scroll reverse

	      gives an effect of grabbing and dragging the viewport with
	      button 1 if Control and Meta is pressed.

       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'
	      indicates	to use the current screen (containing the pointer)
	      whenever the primary screen is used.  This may be	very confusing
	      under 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
	      opposite 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
	      XineramaSlsScreens command.

       XineramaSlsSize Horizontal Vertical
	      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
	      arguments.  Each of these	can be written either in standard X
	      geometry 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

   User	Functions and Shell Commands
       AddToFunc [name [I | J |	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
	      further 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.
	      'J' is similar to	"Immediate" but	is delayed until a button is
	      pressed or released or the pointer is moved, or the function
	      completes.  It is	always executed	before the other function
	      actions.	'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 action '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 functions 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
	      button 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
	      using AddToFunc.

		  DestroyFunc PrintFunction

       Echo string
	      Prints a message to stderr.  Potentially useful for debugging
	      things in	your config.

		  Echo Beginning style definitions...

       EchoFuncDefinition function
	      The EchoFuncDefinition is	similar	to the Echo command but	prints
	      the definition for the given function to stderr.	It is useful
	      to find out how fvwm handles quoting and for debugging functions

       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,
	      instead 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 example 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
	      coincide with an fvwm command.

	      Warning: Please read the comments	on executing complex functions
	      in the section Scripting and Complex Functions.

       InfoStoreAdd key	value
	      Stores the value at the given key.  This is useful to store
	      generic information used in the lifetime of an fvwm config file.
	      For example storing program preferences for opening video	files.

	      The purpose of this command is to	store internal information to
	      fvwm which can be	used bu	fvwm functions,	or when	opening
	      programs of a certain type.  Previous to this command the	only
	      way to do	this was via SetEnv but	this is	discouraged because it
	      places such information in the environment, which	pollutes it
	      and makes	the information	global to other	processes started by
	      fvwm which may then modify them which might not be what's
	      wanted.  Hence the point of InfoStoreAdd is to still allow for
	      such information to be stored, but kept internal to fvwm.

	      In this way, one can build up as many key/value pairs as needed.
	      Recalling	the value of a given key happens through fvwm's	usual
	      expansion	mechanism.  See	the Command Expansion section for more
	      details.	For example:

		      InfoStoreAdd teddybearprog xteddy

		      #	Echo the value of teddybearprog
		      Echo $[infostore.teddybearprog]

	      Removing an entry	from the InfoStore is done with	the
	      InfoStoreRemove command.

       InfoStoreRemove key
	      Removes an entry at the given key	from the InfoStore.  Example:

		  InfoStoreRemove teddybearprog

       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
	      double-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
	      default 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
	      window 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
	      window 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
	      function 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
	      commands.	 Note: This command is treated as a prefix to its
	      command.	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
	      unsetenv command.	 The variable then is removed from the
	      environment 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
	      window appears or	the command is aborted.	 For example, windows
	      can not be focused with FvwmIconMan or FvwmPager 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
	      sequence 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
	      command) 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 commands' description
	      for examples.  The return	code can also be accessed through the
	      variable $[cond.rc].  Non	conditional commands do	not modify the
	      return code of the last conditional command.  Important note:
	      return codes are only defined inside functions created with the
	      AddToFunc	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 either ordered by	creation time (if the
	      !FPSortWindowlistByFocus,	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	returns	1 if any window	matches	the condition and 0
		     otherwise.	 The execution starts at the top of the	window
		     ring and continues	towards	the bottom.  The options can
		     be	any combination	of Reverse and UseStack.  If the
		     option Reverse is given the execution order is reversed.
		     The option	UseStack makes All use the stacking order
		     instead of	the window ring	when walking through windows.
		     See the Conditions	section	for a list of conditions.

		     This command implies the conditions CirculateHit,
		     CirculateHitIcon and CirculateHitShaded.  They can	be
		     turned off	by specifying !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 the Conditions section 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 command 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 the	Conditions section for
		     a list of conditions.

		     This command implies the conditions CirculateHit,
		     CirculateHitIcon and CirculateHitShaded.  They can	be
		     turned off	by specifying !CirculateHit etc.  explicitly.

	      Direction	[FromPointer] direction	[(conditions)] command
		     Performs command (typically Focus)	on a window in the
		     given direction 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 current
		     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 "Center".  Which window Direction selects depends on
		     angle and distance	between	the center points of the
		     windows.  Closer windows are considered a better match
		     than those	farther	away.  The Center direction simply
		     selects the window	closest	to the starting	point.
		     Returns -1	if an invalid direction	was given.  See	the
		     Conditions	section	for a list of conditions.

	      KeepRc command
		     Runs the command but does not alter the return code of
		     the previous command.  Note: KeepRc is treated as a
		     prefix to its command.  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 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 section for a list	of
		     conditions.

	      None [(conditions)] command
		     Performs command if no window which satisfies all
		     conditions	exists.	 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 for a
		     list of conditions.

		     This command implies the conditions CirculateHit,
		     CirculateHitIcon and CirculateHitShaded.  They can	be
		     turned off	by specifying !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 window.  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 for a list	of conditions.

		     This command implies the conditions CirculateHit,
		     CirculateHitIcon and CirculateHitShaded.  They can	be
		     turned off	by specifying !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 for a
		     list of conditions.

		     This command implies the conditions CirculateHit,
		     CirculateHitIcon and CirculateHitShaded.  They can	be
		     turned off	by specifying !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 section for a list	of
		     conditions.

	      ScanForWindow [FromPointer] dir1 dir2 [(conditions)] command
		     Performs command (typically Focus)	on a window in the
		     given direction 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 current
		     position of the pointer is	taken as the starting point.
		     The direction dir1	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
		     dir1.  If any windows have	the exact same coordinate
		     along the primary axis, the secondary direction is	used
		     to	order the windows.  The	direction dir2 may be one of
		     the same set of values as dir1.  If dir2 is not perfectly
		     perpendicular to dir1, ScanForWindow returns 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 opposite side.  Returns -1 if an invalid
		     direction was given.  See Conditions section 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 include:	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 values are: _=, _, _=, _,	== and !=.

		     Example:

			 Test (Version >= 2.5.11) Echo 2.5.11 or later.

		     The EnvIsSet varname test-condition is true if the	given
		     environment variable is set.  The EnvMatch	varname
		     pattern test-condition is true if pattern matches the
		     given environment or infostore variable value.  (See
		     InfoStoreAdd).  The pattern may contain special "*" and
		     "?" chars.	 The "varname" is coded	without	the leading
		     dollar sign ($).

		     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 StartFunction execution.  The Exit test-condition
		     is	the same as either Quit	or ToRestart.  It is only
		     valid on shutdown during ExitFunction function execution.

		     The True and False	test-conditions	are 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 "NoMatch", "Match",	"Error"	and "Break"
		     can be used.  If no returncode 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.	 The TestRc
		     command can only be used inside functions.	 If the
		     command is	another	conditional command, the previous
		     return code is replaced 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 context.  See
		     Conditions	section	for a list of conditions.

		     This command implies the conditions CirculateHit,
		     CirculateHitIcon and CirculateHitShaded.  They can	be
		     turned off	by specifying "!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 indicated 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 for a	list
		     of	conditions.

		     This command implies the conditions CirculateHit,
		     CirculateHitIcon and CirculateHitShaded.  They can	be
		     turned off	by specifying !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 command are a	list of	keywords separated by commas,
	      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 separated
	      by whitespace instead of commas and enclosed in brackets instead
	      of parentheses (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 '*'	and '?', and may consist of two	or
	      more alternatives, 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, except 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
	      ('!')  directly in front of its name.

	      AcceptsFocus, AnyScreen, CirculateHit, CirculateHitIcon,
	      CirculateHitShaded, Closable, CurrentDesk, CurrentGlobalPage,
	      CurrentGlobalPageAnyDesk,	CurrentPage, CurrentPageAnyDesk,
	      CurrentScreen, Desk, FixedPosition, FixedSize, Focused,
	      HasHandles, HasPointer, Iconic, Iconifiable, Layer [n],
	      Maximizable, Maximized, Overlapped, PlacedByButton n,
	      PlacedByButton3, PlacedByFvwm, Raised, Shaded, State n, Sticky,
	      StickyAcrossDesks, StickyAcrossPages, StickyIcon,
	      StickyAcrossDesksIcon, StickyAcrossPagesIcon, 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.	Note: !Lenience	is equivalent to the deprecated	option
	      NoLenience.

	      With the AnyScreen condition used	together with any of the
	      Current...  conditions, windows that do not intersect the
	      Xinerama screen containing 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
	      CirculateSkip and	CirculateSkipIcon Style	attributes for normal
	      or iconic	windows.  The CirculateHitShaded option	overrides the
	      CirculateSkipShaded Style.  All three options are	turned on by
	      default for the Current command.	They can be turned off by
	      specifying !CirculateHit etc.  explicitly.  Note:	Do not confuse
	      these conditions with the	style options 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 conditional 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 support is enabled or not.  This	condition implicitly
	      activates	the CurrentDesk	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 containing the mouse pointer.	 This
	      condition	implicitly activates the CurrentDesk condition.

	      The CurrentPageAnyDesk and CurrentScreen conditions matches only
	      windows 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 Screen [n] condition matches only windows which are on the
	      specified	Xinerama screen.

	      The Desk [n] condition matches only windows which	are on the
	      specified	desk.

	      The FixedPosition	condition excludes all windows that do not
	      have a fixed position, either set	through	WM hints or the	Style
	      option FixedPosition.  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 focus.  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 condition.

	      The Maximizable condition	matches	only windows that are allowed
	      to be maximized.

	      The Maximized condition matches only maximized windows.

	      The Fullscreen condition matches only fullscreen 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 motion 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 command).

	      The State	n or !State n conditions match only windows with the
	      specified	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 StickyIcon, StickyAcrossDesksIcon and	StickyAcrossPagesIcon
	      match only windows that become sticky, sticky across all desks
	      or sticky	across all pages when they are in iconified state.

	      The Transient condition matches only windows that	have the
	      "transient" property set by the application.  This it usually
	      the case for application 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
       database).

       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
	      recommended to avoid conflicts.

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

		  DestroyModuleConfig FvwmButtons*
		  DestroyModuleConfig FvwmForm:	Fore
		  DestroyModuleConfig FvwmIconMan: Tips*

       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.

		  # kill all pagers
		  KillModule FvwmPager

		  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, 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.  To start	a module FvwmForm using	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 XBM, XPM,	PNG or SVG),
	      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),	FvwmEvent (trigger various
	      actions by events), FvwmForm (to bring up	dialogs), 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
	      windows),	FvwmScript (another powerful dialog toolkit), 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
	      FvwmButtons , 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
	      directory	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
	      prepending 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
	      Expect option is given, fvwm waits for the given string instead.
	      ModuleSynchronous	should only be used during fvwm	startup	to
	      enforce 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
	      EscapeFunc).

       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
	      wildcards.  This only makes sense	if the module is set up	to
	      understand and deal with these strings though.  Can be used for
	      module to	module communication, or implementation	of more
	      complex commands in modules.

   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.

       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
	      version) 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
	      environmental 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
	      preserved.  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
	      really 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
	      current window manager is	replaced with the specified
	      window_manager 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
	      implement	this functionality.  Use Unix signals to manage	xsm
	      remotely.

       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
	      manage xsm remotely.

   Colorsets
       Colorsets are a powerful	method to control colors.  Colorsets create
       appearance 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 includes 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
       manage colorsets.  Starting with	the 2.5.x beta version,	the FvwmTheme
       functionality was moved to the core fvwm, so this module	became
       obsolete.  In 2.6.7 the FvwmTheme module	was removed.

       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
	      consumption.  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
	      defines the meaning of the first 40 colorsets for	nearly all
	      purposes:

	      http://fvwm-themes.sourceforge.net/doc/colorsets

	      Each colorset has	four colors, an	optional pixmap	and an
	      optional 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
	      keywords:	fg, Fore, Foreground, bg, Back,	Background, hi,
	      Hilite, Hilight, sh, Shade, Shadow, fgsh,	Pixmap,	TiledPixmap,
	      AspectPixmap, Transparent, RootTransparent, Shape, TiledShape,
	      AspectShape, 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
	      simply 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
	      omitted.

	      fgsh takes a color name as an argument and sets the color	used
	      by the shadowing font effect.  See the Font Shadow Effects
	      section 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
	      argument,	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
	      AspectPixmap 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
	      detected or not, this depends on the program used	to set the
	      background.  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
	      detection	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
	      option, do not use it.

	      Using outline move and resize (see the OpaqueMoveSize command
	      and the ResizeOpaque Style option) as well as setting the
	      WindowShadeShrinks 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
	      background, 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
	      FvwmIconMan uses Colorset	10 as background.  If you want root
	      transparency use the RootTransparent option.  FvwmButtons
	      FvwmIconMan, and FvwmIdent, 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 FvwmProxy is simpler,	the two	colorsets refer	to the
	      window backgrounds.  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.	 Tinting may work with fvwm menu
	      (without animation).  Tinting may	work better if your X server
	      has backing store	enabled	(try xdpyinfo 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 RootTransparent option.

	      RootTransparent [	buffer ] creates a root	transparent
	      background.  To make this	option work, you must use an Esetroot
	      compatible 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
	      usage.  It also speeds up	opaque move and	resize which can be
	      unacceptably slow	without	buffer.	 However, this option may add
	      a	lot of memory to your X	server (depending on the size of the
	      image 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
	      argument,	search the ImagePath and use it	as the shape bitmap.
	      TiledShape produces repeated copies of the bitmap	with no
	      scaling, Shape causes the	bitmap to be stretched to fit whatever
	      object 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 (all opaque pixels) of the
	      pixmap is	used.  For png and svg images, the shape mask is
	      equivalent to all	not completely transparent pixels (alpha > 0).

	      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
	      window.  ?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.
	      Unfortunately, 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
	      option 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
	      ?Gradient	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
	      example a	fine gradient looks 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).
	      However, 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
	      removes 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 colorset 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 background 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, CGradient is
	      concentric circles, RGradient is a radar like pattern and
	      YGradient	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
       The environment variables that have an effect on	how fvwm operates are
       the following:

       DISPLAY
	   Fvwm	starts on this display unless the -display option is given.

       FVWM_MODULEDIR
	   Set by fvwm to the directory	containing the standard	fvwm modules.

       FVWM_USERDIR
	   Used	to determine the user's	data directory for reading and
	   sometimes writing personal files.  If this variable is not already
	   set,	it is set by fvwm to $HOME/.fvwm, which	is the default 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,
       followed	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
       distribution are	subject	to the GNU General Public License (GPL).
       Please refer to the COPYING file	that came with fvwm for	details.

BUGS
       Bug reports can be sent to the fvwm-workers mailing list	at
       <fvwm-workers@fvwm.org>

       The official fvwm homepage is http://fvwm.org/.

				  05-Sep-2019			       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 | CONFIGURATION | FONTS | BI-DIRECTIONAL TEXT | KEYBOARD SHORTCUTS | SESSION MANAGEMENT | BOOLEAN ARGUMENTS | BUILTIN KEY AND MOUSE BINDINGS | COMMAND EXECUTION | QUOTING | COMMAND EXPANSION | SCRIPTING & COMPLEX FUNCTIONS | LIST OF FVWM COMMANDS | 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