FVWM(1)

📦
version 2.7.0 · 4 versions
, in fedora 43, fedora 44, nixos 26.05, nixpkgs unstable

💅 FVWM — the manual, but make it cute

okay bestie, welcome to the Fvwm manual page, from the Fvwm 2.7.0 era, section 1 of the manual set. yes we're doing the whole thing. grab a snack. 🍓

✨ NAME ✨

Fvwm — F? Virtual Window Manager for X11 🪟👑

🌸 SYNOPSIS 🌸

so this is how you actually summon it:

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]

that's it that's the whole vibe check. every single one of those flags gets its own moment later, don't worry. 🫶

🦋 DESCRIPTION 🦋

Fvwm is a window manager for X11. its whole personality is: use as little memory as possible, give your window frames a 3D look, and hand you a virtual desktop. slay.

okay so important lore: there are, like, several window managers out there with "fvwm" somewhere in their name. messy. back in the day, version 2.x of fvwm was usually called fvwm2 just to keep it separate from the old 1.x (which was fvwm, or honestly fvwm1). but 1.x got replaced by 2.x literally ages ago, so now we just call 2.x — and every version that comes after it — fvwm for the whole document, and the actual executable program is named fvwm. periodt.

there's also an fvwm offspring called fvwm95 — it's basically a patched version of fvwm-2.0.43. its whole main character moment was trying to serve a Windows 95–ish look and feel. but since then fvwm got so much better, and practically every single fvwm95 feature can be achieved by fvwm now. ate. 💅

fvwm gives you both a big virtual desktop and multiple disjoint desktops, and you can use them separately or together. the way this works:

  • the virtual desktop lets you pretend your video screen is actually huge, and you can scroll around inside the desktop like it's a big map. 🔭
  • the multiple disjoint desktops let you pretend you genuinely have several screens to work at — but each screen is completely unrelated to the others. no crossover, no shared lore. 🙈

fvwm also has keyboard accelerators that let you do most window manager functions — moving and resizing windows, operating the menus, all of it — using keyboard shortcuts. keyboard girlies stay winning. ⌨️✨

fvwm has also completely overcome the distinction between configuration commands and action commands that most window managers are obsessed with. like, normally: configuration commands set fonts, colors, menu contents, and key and mouse function bindings, while action commands do stuff like raise and lower windows. fvwm makes no such distinction and lets you change anything at any time. no rules, just vibes. 🔥

other noteworthy differences between fvwm and other X11 window managers — and bestie, this is the good part:

  • it introduced the SloppyFocus and NeverFocus focus methods. iconic behavior.
  • focus policy can be specified separately for different window groups. yes, per group. flexible queen.
  • windows using SloppyFocus acquire focus when the pointer moves into them, and they retain focus until some other window acquires it. and here's the thing — such windows do not lose focus when the pointer moves into the root window. they simply don't. 😤
  • the NeverFocus policy exists for windows you never type into — like xclock, oclock, xbiff, xeyes, tuxeyes. so for example: if a SloppyFocus terminal window has focus, moving the pointer over a NeverFocus decoration window does not deprive the terminal of focus. it's giving considerate. 🎀
no cap, this is only part 1. more parts are coming, so stay tuned bestie 💖

✨ OPTIONS ✨

okay bestie, these are the command line options that fvwm actually recognizes. buckle up, there's a lot, and the color stuff goes hard 💅

  • -i | --clientid id — this one's for when fvwm gets started by a session manager. literally not for you, bestie. do not touch.
  • -c | --cmd config-command — tells fvwm to use config-command instead of Read config (or Read .fvwm2rc) as its initialization command. (heads up: you can pass up to 10 -f and -c parameters, and they get executed in the order you specified them.)

any module you start through command line arguments is assumed to be a module that sends back config commands. all command line modules have to quit before fvwm moves on to the StartFunction and setting border decorations and styles. there's a potential deadlock if you start a module other than FvwmCpp/FvwmM4/FvwmPerl, but there's a timeout so fvwm eventually gets going. 🫶

so like, starting the pager this way hangs fvwm until the timeout, but this should work well:

fvwm -c "AddToFunc StartFunction I Module FvwmPager"
  • -d | --display displayname — manage the display called displayname instead of whatever name it got 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 makes fvwm spit out debug messages while running. 🐛
  • -f config-file — makes fvwm read config-file instead of ~/.fvwm/config as its initialization file. this is equivalent to -c 'Read config-file'.
  • -h | --help — prints a short usage description.
  • -r | --replace — tries to take over from a previously running wm. ngl this does not work unless the other wm is ICCCM2 2.0 compliant.
  • -F | --restore state-file — also a session manager thing. 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 overrides the screen number. normally fvwm tries to start up on all screens of a multi-screen display.
  • -V | --version — prints the version of fvwm to stderr. also prints info 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 — makes fvwm use visual-class for the window borders and menus. visual-class can be "StaticGray", "GrayScale", "StaticColor", "PseudoColor", "TrueColor" or "DirectColor".
  • -I | --visualid id — makes fvwm use id as the visual id for the window borders and menus. id can be specified as N for decimal or 0xN for hexadecimal. peep the 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. fr fr, 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 cases 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 should be understood 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 an 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 to cause applications which use a lot of colors to 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, makes fvwm 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 makes fvwm 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 makes fvwm 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 makes fvwm 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.
lowkey important: a bunch of these are session-manager-only or dev-only, so if you're just vibing with your own config, the ones you'll actually reach for are the -c, -f, -d and maybe the color ones. don't go allocating palettes for fun, bestie 💖

💅 ANATOMY OF A WINDOW 💅

okay bestie, so fvwm puts a decorative border around most windows. This border is giving: a bar on each side + a small L-shaped section on each corner. Then there's an extra top bar called the title-bar — it's the one displaying the name of the window. And yes, there are up to 10 title-bar buttons. The top, side, and bottom bars are collectively known as the side-bars. The corner pieces? That's the frame. slay.

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

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 ✨

okay so the very first thing fvwm does when it wakes up is go looking for a configuration file 💅 that's the file where you describe all your key and button bindings, plus like a million other things. the format of those files? we'll get to that later bestie, patience.

fvwm's first move is to search for config files using this command:

Read config

that looks for a file called config in the $FVWM_USERDIR and $FVWM_DATADIR directories, exactly like the Read command describes. and if that fails? it goes digging through a bunch of other files for backward compatibility, because it loves you and wants your ancient dotfiles to work. here's the complete list of every location queried in the default installation — and heads up, only the first found file gets 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. so like... future-proof yourself, bestie.

and if no configuration file is found at all? don't panic 🫶 the left mouse button, or the Help or F1 keys on the root window, bring up menus and forms that can create a starting configuration file for you. iconic rescue behavior honestly.

fvwm also sets two environment variables that all its children inherit. these are $DISPLAY, which describes the display fvwm is running on — and $HOSTDISPLAY. here's the tea: $DISPLAY may be unix:0.0 or :0.0, which does not work too well when you pass it through ssh to another machine 😭 so $HOSTDISPLAY is set to a network-ready description of the display instead. $HOSTDISPLAY always uses the TCP/IP transport protocol (even for a local connection!), which means $DISPLAY is the one you want for local connections — it may use Unix-domain sockets, and those are faster. slay.

so you wanna start some applications or modules along with fvwm? you could just drop

Exec app

or

Module FvwmXxx

straight into your config. but ngl, that's not recommended — do it only if you know what you're doing 🙈 the thing is, it's usually important to start applications or modules after the entire config is read, because the config contains styles and module configurations that can affect window appearance and functionality. so like, order matters bestie.

the standard way to start applications or modules on fvwm's startup is to add them to an initialization function — usually StartFunction or InitFunction. this way they only start after fvwm finishes reading and executing the config file. chef's kiss 🌸

fvwm has three special functions for initialization:

  • StartFunction — executed on startups and restarts.
  • InitFunction — executed during initialization, just after StartFunction.
  • RestartFunction — executed during restarts, just after StartFunction.

these functions can be customized in a user's config file using the AddToFunc command (described later ✨) to start up modules, xterms, or literally whatever you'd like fvwm to start for you.

fvwm also has a special exit function: ExitFunction, executed when exiting or restarting, before actually quitting. it's giving "last chance to say goodbye" energy 💖 — you could use it to explicitly kill modules, etc.

and if fvwm is running under a session manager? then SessionInitFunction and SessionRestartFunction are executed instead of InitFunction and RestartFunction. this helps you write a config file that works great both under a session manager and without one. generally it is a bad idea to start xterms or other applications in "Session*" functions 🙅 and also, someone might want to start different modules depending on whether they're under a session manager or not. for 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 the special functions if some of them are empty. no cap. and also — note that all these special functions can be emulated now using just 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 whole bunch of compile-time options. so if you're having trouble using a certain command or feature, bestie, check whether support for it was even included at compile time 👀 optional features are described in the config.h file that gets generated during compilation. iykyk.

🎀 ICONS AND IMAGES 🎀

fvwm can load .xbm, .xpm, .png and .svg images. here's the breakdown:

  • XBM images are monochrome — and 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 info 🫶

and the related SHAPE compile-time option? it can make fvwm display spiffy shaped icons. obsessed. ✨

🌈 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 be. 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. main character energy for one little file 💅

the rendering options are specified as a string appended to the SVG filename, like this:

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 anyway — 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 specify 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 specify 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, bestie 😭

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

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 it 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. DIY queen behavior 💅

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

okay so bestie, fvwm is trying to be ICCCM 2.0 compliant, like it's doing the work. go check http://tronche.com/gui/x/icccm/ for the deets.

but here's the messy part: ICCCM says applications should be able to receive any keystroke, which lowkey does not vibe with the keyboard shortcut approach fvwm (and basically every other window manager) uses. specifically — you cannot have the same keyboard shortcuts working with your fvwm and another fvwm running inside Xnest (that's a nested X server running in a window, iykyk). same exact problem exists with mouse bindings. no cap.

ICCCM also says that windows carrying this property:

WM_HINTS(WM_HINTS):
    Client accepts input or input focus: False

should not be handed the keyboard input focus by the window manager. those windows can take the focus all by themselves tho. but a bunch of applications set this property and still expect the window manager to give them the keyboard focus anyway 🙈 so fvwm provides a window style, Lenience, which lets fvwm overlook this ICCCM rule. even with this window style it's not guaranteed that the application accepts focus. fr fr.

The differences between ICCCM 1.1 and 2.0 include the ability to take over from a running ICCCM 2.0 compliant window manager; so like:

fvwm; vi ~/.fvwm/config; fvwm -replace

that resembles the Restart command. it is not exactly the same tho, because 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). periodt.

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

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". yes bestie, that's literally the whole thing, iconic.

🌸 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. (yes that's the actual phrasing, they said "make sense", not "makes sense", we're keeping it, character for character 💜)

🍓 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

okay so, fonts bestie. The text on a window title, icon titles, menus, and the geometry window all gets its look from the Font and IconFont Style, the Font MenuStyle, and the DefaultFont command. And literally every Module that uses text has its own configuration command(s) for font(s). All of these take a font name as an argument. So this section is me explaining what a "font name" even is for fvwm, and which fonts fvwm actually loads. 🎀

First up, you can use what we'll call a usual font name, like:

-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's an X Logical Font Description — XLFD for short, iykyk. fvwm then loads and uses the "first" font that matches the description. And which one is "first" depends on your font path and also your locale. Fonts that match the locale charset get loaded in priority order. So with

-adobe-courier-bold-r-normal--10-*

if your locale charset is ISO8859-1, fvwm tries to load a font that matches

-adobe-courier-bold-r-normal--10-*-ISO8859-1

and if your locale charset is ISO8859-15, fvwm tries to load

-adobe-courier-bold-r-normal--10-*-ISO8859-15

A font name can also be given as an extended XLFD. That's a comma separated list of (simple) XLFD font names, like:

-adobe-courier-bold-r-normal--14-*,-*-courier-medium-r-normal--14-*

Each simple font name gets tried until a matching font with the locale charset is found, and if that fails, each simple font name gets tried again without any constraint on the charset. slay.

More XLFD details live in the X manual page, the X Logical Font Description Conventions document (it's called xlfd), and the XLoadFont and XCreateFontSet manual pages. Some useful font utilities you'll want: 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 that matches the description is the one loaded. Which one that is depends on the XftConfig configuration file with Xft1, and on the /etc/fonts/fonts.conf file with Xft2. You can read the Xft manual page and, with Xft2, the fontconfig man page. The first string after xft: is always the family. In 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=), and encoding lets you enforce a charset (iso8859-1 or iso10646-1 only; if no encoding is given the locale charset is assumed). A big one 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 an LCD monitor you might try adding 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 :, like 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 these parameters are not always taken in account, just saying. 💀

To figure out which Xft fonts are really loaded, you can export XFT_DEBUG=1 before starting fvwm and take a peek at the error log. With Xft2 you can 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 a 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), like:

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 is what lets you write portable configuration files, and we love that for us. 🫶

🦋 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 the strings displayed with this font use this encoding — one exception: if an iso10646-1 font is loaded, then UTF-8 is assumed for the string encoding. In a normal situation, (i) a font gets 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 a bit different, since Xft only supports iso10646-1 and iso8859-1. If you don't specify one of these encodings in the Xft font name, then fvwm does string 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 all those previous rules, you can specify the string encoding at the beginning of a font description, like this:

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 could use an iso8859-1 locale charset and have an FvwmForm in Russian using koi8-r encoding. In that 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 (since a 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. iconic honestly. ✨

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, bestie. 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. periodt.

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 ✨

okay so bestie, Arabic and Hebrew text? literally needs bi-directional text support to show up right, no cap. what that means is: logical strings have to get converted before they're visually presented, so the left-to-right and right-to-left sub-strings get figured out and reshuffled around. 💅 in fvwm this happens automatically in window titles, menus, module labels and other places — but only if the fonts you're using for that text are one of the charsets that require bidi (bi-directional) support. for example, that includes iso8859-6, iso8859-8 and iso10646-1 (unicode), but not the other iso8859-* fonts. 🫶

this whole bi-directional text situation is handled using the fribidi library compile time option, so go peek at INSTALL.fvwm. 📖

🌈 KEYBOARD SHORTCUTS 🌈

almost every single window manager operation can be done from the keyboard so mouse-less operation should totally be possible. 👑

on top of scrolling around the virtual desktop by binding the Scroll command to whatever keys you want, you can also bind Popup, Move, Resize, and literally any other command to keys. 🌸

once a command has started, you move the pointer with the up, down, left, and right arrows, and the action is terminated by pressing return. ✨ holding down the Shift key makes the pointer movement go in bigger steps, and holding down the control key makes the pointer movement go in smaller steps. and the standard emacs and vi cursor movement controls (n, p, f, b, and j, k, h, l) can be used instead of the arrow keys. iykyk. 🎀

🦋 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. 💾 and furthermore, some global state is saved too.

important tea 🫖 Fvwm does not save any information regarding styles, decors, functions or menus. if you change any of these resources during a session (like by issuing Style commands or by using various modules), those changes are lost after saving and restarting the session. to make them permanent, you have to add them to the configuration file. periodt.

also note further that the current implementation has the following anomaly when used on a multi-screen display: when you start 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. 😭 but when you save and restart the session, the session manager brings up a copy of fvwm on each screen, except this time they're started as individual instances managing one screen only. so now a Quit kills only the copy it was sent to. ngl this is probably not a very serious problem, since with session management you're supposed to quit a session through the session manager anyway. 🙈

but if it's really needed,

Exec exec killall fvwm

still kills all copies of fvwm. ⭐ your system must have the killall command though.

💖 BOOLEAN ARGUMENTS 💖

a bunch 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 the feature is disabled if it's 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 a 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". slay.

🎀 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. and get this — quoting single characters works even inside other kinds of quotes. iconic. 👑

✨ COMMAND EXPANSION ✨

okay bestie so every single time an fvwm command line gets run, fvwm does parameter expansion. A parameter is a '$' followed by a word in brackets ($[...]) or just one single special character. If fvwm bumps into an unquoted parameter on the command line, it expands it into the string that the parameter name points to. Unknown parameters? Left totally untouched, no notes. And the order matters: parameter expansion happens before quoting. Want a literal '$'? Use "$$". 🫶

If a command is prefixed with a '-', then parameter expansion isn't performed. This applies to the command immediately following the '-', the one where the expansion normally would have happened. And when you stack it with other prefix commands, it has to go before the other prefix. 💅

Example time:

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

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

The longer variables can have extra variables inside the name, and those inner ones get expanded before the outer variable. Nesting, but make it fashion. 🦋

So, in earlier versions of fvwm, some single letter variables were a thing. It's deprecated now, because they cause a whole pile of problems. Use the longer substitutes instead, fr fr.

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. And no, having the pointer hovering over a window is usually not enough to count as a context window. To force it to use the window with the focus, you whip out the Current command: Current Echo $[desk.n] $[page.nx] $[w.class]

🌸 The parameters fvwm knows about 🌸

  • $$ — a literal '$'. That's it, that's the whole vibe.
  • $. — the absolute directory of the currently Read file. Made for building relative and relocatable configuration trees. If you use it outside of any read file, you just get '.' back. 🎀
  • $0 to $9 — the positional parameters handed to a complex function (that's a function defined with the AddToFunc command). "$0" gets swapped for the first parameter, "$1" for the second, and so on down the line. If the matching parameter is undefined, the "$..." is deleted from the command line. poof. 💨
  • $* — all the positional parameters given to a complex function. Yes, including the ones that come after "$9". no cap.
  • $[n] — the n:th positional parameter given to a complex function, counting from 0. If that parameter is undefined, the "$[n]" gets deleted from the command line. And it's expanded unquoted.
  • $[n-m] — the positional parameters given to a complex function, starting at parameter n and ending at parameter m. If all of those parameters are undefined, the "$[...]" is deleted from the command line. If only some are defined, all the defined ones get expanded and the rest are silently ignored (rude but fine). All parameters expand unquoted.
  • $[n-] — all the positional parameters given to a complex function, starting at parameter n. If all of them are undefined, the "$[...]" is deleted from the command line. All parameters expand unquoted.
  • $[*] — all the positional parameters given to a complex function. This is the equivalent of $[0-]. same energy, different outfit.
  • $[version.num] — the version number, like "2.6.0".
  • $[version.info] — the version info, like " (from cvs)". It's 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 the coordinate or the width or height of the current viewport.
  • $[wa.x] $[wa.y] $[wa.width] $[wa.height] — either the coordinate or the width or height of the EWMH working area.
  • $[dwa.x] $[dwa.y] $[dwa.width] $[dwa.height] — either the coordinate or the width or height of the dynamic EWMH working area.
  • $[desk.n] — the current desk number.
  • $[desk.name<n>] — replaced with the name of desktop number <n> as defined by the DesktopName command. If no name is defined, you get the default name. 💖
  • $[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 the x or y direction.
  • $[desk.pagesx] $[desk.pagesy] — the number of total pages in a desk in the x or y direction. 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 GNOME terminology. iykyk.
  • $[w.id] — the window-id (written 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, the 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, if no window is associated with the command, you get the unexpanded "$[w.<attribute>]" string. 🙈
Note: the first 5 variables can contain literally any kind of characters, so these variables are quoted. Meaning the value is surrounded by single quote characters and any single quote inside it gets a backslash in front. This guarantees that commands like: Style $[w.resource] Icon norm/network.png work correctly, no matter what special symbols the value is carrying around, like spaces and all different kinds of quotes. slay.

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 that'll be the same as $[w.name] once expanded, although when you're using IndexedWindowName it's a way more useful distinction, and it lets you reference the specific window by its visible name for inclusion in things like Style commands. 👑

  • $[w.x] $[w.y] $[w.width] $[w.height] — either the coordinate or the width or height of the current window, if it's 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 the window is shown on. If the window is sticky, the current desk number gets used.
  • $[w.layer] — the layer of the window.
  • $[w.screen] — the screen number the window is on. If Xinerama isn't 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 are 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] — 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] — the position of the pointer in the selected window. If the pointer isn't on the screen, the window is iconified, or no window is selected, these variables are not expanded.
  • $[pointer.cx] $[pointer.cy] — the position of the pointer in the client portion of the selected window. If the pointer isn't 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 isn't enabled.
  • $[screen] — the screen number fvwm is running on. Super useful for setups with multiple screens. 🌈
  • $[fg.cs<n>] $[bg.cs<n>] $[hilight.cs<n>] $[shadow.cs<n>] — replaced with the name of the foreground (fg), background (bg), hilight (hilight) or shadow (shadow) color defined in colorset <n> (swap <n> for zero or a positive integer). For example "$[fg.cs3]" expands to the name of the foreground color of colorset 3 (in rgb:rrrr/gggg/bbbb form). Please refer to the Colorsets section for all the deets about colorsets. ✨
  • $[schedule.last] — replaced by the id of the last command that was scheduled with the Schedule command, even if that command was already executed.
  • $[schedule.next] — 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. Handy for stuff like:
Mouse 3 FS N WindowShade $$[func.context]
  • $[gt.str] — returns 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] — returns 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 inside the braces isn't any of the above, fvwm tries to find an environment variable with that name and replaces its value if one is found (e.g. "$[PAGER]" could get 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 🎀

okay so bestie, when you want the fancy effects — the ones that make people go "wait how did u do that" — fvwm has a whole lil toolbox of scripting powers. ✨

  • Scripts can be read from a file with Read
  • Scripts can come from the output of a command with PipeRead
  • Or you can write a complex function with the AddToFunc command

For the curious girlies, section 7 of the fvwm FAQ shows some real life applications of scripting. Go look, it's giving inspiration. 💅

Please refer to the sections User Functions and Shell Commands and Conditional Commands for details.

⚠️ a word of warning, and I mean it: 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. no cap, that's just how it is 😭

🌈 LIST OF FVWM COMMANDS 🌈

The command descriptions below are grouped together in the following sections. The sections are hopefully sorted in order of usefulness to the newcomer. 🫶

  • Menu commands
  • Miscellaneous commands
  • Commands affecting window movement and placement
  • Commands for focus and mouse movement
  • Commands controlling window state
  • Commands for mouse, key and stroke bindings
  • The Style command (controlling window styles)
  • Other commands controlling window styles
  • Commands controlling the virtual desktop
  • Commands for user functions and shell commands
  • Conditional commands
  • Module commands
  • Quit, restart and session management commands
  • Colorsets
  • Color gradients

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, iykyk). 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. 🪆

Menus consist of any number of:

  • titles — 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 tears off the menu when selected
  • 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"). 🌸

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.

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. periodt.
  • 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] — bestie this one moves the selection to another item 💅. If the first argument is zero, then the second argument is the one doing the work: it says which absolute item in the menu the pointer should move to. Negative items? Counted from the end of the menu, obviously. If the first argument is non-zero, then the second argument must be omitted, and that first argument is a relative change in the selected item instead. Either position may be suffixed with an 's', which means the items refer only to the first items after separators ✨.
  • MenuCursorLeft — enters a sub menu using the SubmenusLeft menu style, and comes back to the prior menu using the SubmenusRight menu style 🦋.
  • MenuCursorRight — enters a sub menu using the SubmenusRight menu style, and comes back to the prior menu using the SubmenusLeft menu style 🌸.
  • MenuSelectItem — triggers the action for the menu item. that's it, that's the whole job 👑
  • 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 the details 💀.

🎀 Tear Off Menus 🎀

Okay so a tear off menu is literally any menu that has been "torn off" the window it was attached to and then pinned to the root window 💖. There are three ways to tear one off:

  1. click on the menu title with mouse button 2 🖱️
  2. press Backspace in the menu ⌨️
  3. activate its tear off bar — that's a horizontal bar with a broken line ✨

Tear off bars have to be added to the menu like 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 a 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, fr fr 🌈. 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. So you can use it 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 then 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 💖.

Okay bestie, we're still deep in menu land and honestly? It's giving interior design show but for pixels. 💅

If the menu-label has a sub-string all wrapped in percent signs, then the text between those %s is expected to be the name of an image file — a lil mini icon, a "so-called" mini icon if you will — and it gets inserted to the left of the menu label. You can do the same thing for a second mini icon, which gets drawn on the right side of the menu. And if you want an actual literal '%', you insert "%%". For example:

    + Calculator%xcalc.xpm% Exec exec xcalc

That inserts a menu item labeled "Calculator" with a picture of a calculator chilling on the left. 🧮 And this one:

    + %xcalc.xpm%           Exec exec xcalc

omits the "Calculator" label entirely but leaves the picture. The pictures you use with this feature should be small (like, perhaps 16x16, keep it cute and tiny). 🎀

Now — if the menu-name (not the label, okay, pay attention bestie) contains a sub-string 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. That's a side pixmap. You might wanna use the SidePic option of the MenuStyle command instead, fyi. To get a literal '@', insert "@@". For example:

    AddToMenu StartMenu@linux-menu.xpm@

creates a menu with a picture in its bottom left corner. ✨

And if the menu-name also contains a sub-string surrounded by '^'s, then the text between the '^'s is expected to be the name of an X11 color, and the column containing the side picture gets 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 the region of the menu containing that picture blue. 💙

In all the above cases, the name of the resulting menu is the name you specified, stripped of the substrings between the various delimiters.

✨ ChangeMenuStyle ✨

ChangeMenuStyle menustyle menu ...

Changes the menu style of menu to menustyle. And you can specify more than one menu in each call of ChangeMenuStyle, because we're efficient like that. 👑

✨ CopyMenuStyle ✨

CopyMenuStyle orig-menustyle dest-menustyle

Copies orig-menustyle to dest-menustyle, where orig-menustyle is an existing menu style. If the menu style dest_menustyle doesn't exist yet, then boom, it gets created. 🪄

✨ DestroyMenu ✨

DestroyMenu [recreate] menu

Deletes a menu, so that any subsequent references to it are no longer valid. You can use this to change the contents of a menu mid-fvwm-session. The menu can be rebuilt using AddToMenu. The optional parameter recreate tells fvwm not to throw the menu away completely, but instead to throw away all the menu items (including the title). 💀

    DestroyMenu Utilities

✨ DestroyMenuStyle ✨

DestroyMenuStyle menustyle

Deletes the menu style named menustyle and changes all menus using this style back to the default style. And nope — you cannot destroy the default menu style, that one's forever. 🚫

    DestroyMenuStyle pixmap1
Menu menu-name [position] [double-click-action]

Causes a previously defined menu to be popped up in a sticky manner. Meaning: 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 isn't specified, double clicking on the menu does nothing. BUT — plot twist — if the menu begins with a menu item (i.e. not with a title or a separator) and the double click action isn't given, then double clicking invokes the first item of the menu (but only if the pointer really was over the item). 🙈

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

The position arguments let you place the menu somewhere on the screen — centered on the visible screen, above a title bar, whatever you're feeling. 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 isn't 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 you give 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, bestie, I'm serious.

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 the top/left borders of the menu and the rectangle overlap, "o100" gives you the bottom/right borders, and "o50" centers them upon each other (try it and you'll see it's much simpler than this description sounds, fr fr). 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 couldn't reach it with the mouse without leaving the menu. But 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. And since 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 don't want that, 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. And 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 (or 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 hadn't been assigned a style using ChangeMenuStyle. See also DestroyMenuStyle. And heads up: when using monochrome, color options are ignored. 🎨🚫

options is a comma separated list containing some of the keywords in this absolute iconic lineup:

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.

okay so some of these are option pairs or triples with a / between them, and bestie, that slash means they exclude each other. You pick one. All the paired options can also be negated — just slap a ! in front and boom, you get the counterpart option's effect. 💅

Some options are now negated by prefixing ! to the option. That's the preferred form for all of them, fr fr. The other negative forms? deprecated. They're getting removed in the future, so don't get attached. 😭

This is the list of MenuStyle deprecated negative options:

  • ActiveForeOff
  • AnimationOff
  • AutomaticHotkeysOff
  • HilightBackOff
  • TitleWarpOff

Fvwm, Mwm and 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 use them only as the first option you specify for a menu style, or to reset the style back to defined behavior. (Same effect can be achieved by setting all the other options one by one, if you're feeling extra. 🧚)

Mwm and Win style menus pop up 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. periodt.

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 can be anywhere from zero to 50 pixels. Default is 2. If you use an illegal value, the border width just reverts to the default. (no drama, it forgives you 💖)

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

Greyed may have a color name as an argument. This is the color used to draw a menu-selection that is prohibited (or at least not recommended) by the Mwm hints which an application has specified. If you omit the color, 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. You can use a specific background color by handing the color name to HilightBack as an argument. Use the option without an argument and the color is based on the menu's background color. The ActiveColorset option overrides the specified color. And if the colorset has a non solid background, that's what gets 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, that's 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, that 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, that 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 — so to turn on background hilighting you have to use the HilightBack menu style too, bestie. 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 it's 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 don't 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's used for the text of all menu items. If it doesn't exist, or if the name is left blank, the built-in default is used. If a TitleFont is given, it's 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 the description of the ButtonStyle command and the Color Gradients sections for more info. 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 — takes one numeric argument, bestie. That number is the delay in milliseconds before a sub menu pops up when the pointer wanders onto a menu item that has a sub menu. Set it to zero and no automatic pop up happens at all. Omit the argument entirely and the built-in default gets used. Lowkey important: the popup delay does nothing if you're using the PopupImmediately option, because then sub menus just appear instantly. ✨
  • PopupImmediately — makes menu items with sub menus pop up the second the pointer enters the item. PopupDelay is ignored when this is on. If PopupDelayed is used instead, fvwm checks the PopupDelay option if or when this automatic popup happens.
  • PopdownDelay — works exactly like PopupDelay but it sets the timeout of the PopupDelayed style.
  • PopdownImmediately — makes sub menus vanish the instant 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 by the PopdownDelay option. This is so handy when the pointer keeps straying off the menu item while you're trying to move into the sub menu. 🫶 Whenever there's 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. iykyk.
  • PopupOffset — takes 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 — takes 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. That 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 value or an illegal value is given.
  • TitleWarp and !TitleWarp — affect whether 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 are drawn. Solid triangles are filled with a color, while relief triangles are hollow.
  • DoubleClickTime — takes 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 do the vertical version of what ItemFormat does horizontally — they control the spacing of menu items and titles, but up-and-down instead of side-to-side. Both take two numeric arguments that can range from -100 to +100. The first one is the gap in pixels above a normal menu item (or a menu title), and the second is the gap in pixels below it. Negative numbers do not make much sense and may screw up the menu completely — like, do not. 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 is how you 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 control 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. 📝

So this right here 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. 🙈

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

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

BugOpts [option [bool]], ...

Okay so this one controls several workarounds for bugs in third party programs — not fvwm's fault, we're just being a good friend about it. 🫶 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). 🌈
  • ModalityIsEvil — okay so this one decides whether Motif applications are allowed to have modal dialogs</p> — and you know the ones, the 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, bestie, fr fr.
🚨 Once this option is turned on, you have to restart fvwm to turn it off. No take-backs, no undo, no nothing.
  • 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 — she's self-aware, your honor ✨.
  • 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 — 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.
  • DisplayNewWindowNames — with this 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. iykyk — debugging queen behavior.
  • ExplainWindowPlacement — when 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 way that this one just tells you the tea about your window placement… obsessed.
  • DebugCRMotionMethod — 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 🐛.
  • TransliterateUtf8 — 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 💫

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 ⏱️

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

ClickTime also specifies the delay between two clicks to be interpreted as a double-click.

🌈 ColorLimit 🌈

ColorLimit limit

This command is obsolete. See the --color-limit option to fvwm. she's retired, bestie, we don't do that anymore 💀.

🎨 ColormapFocus 🎨

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 🦋

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 takes [foreground] [background] and it's giving "let me set the mood lighting for fvwm's lil' helper windows" 💅 Like the geometry feedback windows that pop up while you're moving or resizing something. Only want to change one of the two colors? Pass - as the color name you don't care about, she'll leave that one alone. Want the factory settings back? Just omit both color names and boom, built-in defaults. Heads up bestie: these default colors do not apply to menus, window titles or icon titles. Different girls, different rules. ✨

  • DefaultColorset [num] — picks the colorset used by the windows that the DefaultColors command controls. Wanna go back to the DefaultColors colors? You say:
DefaultColorset -1

or literally any variant of the DefaultColors command. Either one. Pick your fighter. 🎀

  • DefaultFont [fontname] — sets the default font to fontname. This is the fallback font fvwm reaches for whenever nobody else specified one, so it's lowkey carrying the whole aesthetic. Leave the argument off and you're back to the built-in default. Where does it show up? Menus, window titles, icon titles, AND the geometry feedback windows during a move or resize. Iconic, honestly. 👑 Wanna override it in one specific context? That's Style * Font, Style * IconFont, or MenuStyle.
  • DefaultIcon filename — sets the default icon for windows that have neither a client-supplied icon nor one given via the Icon option of the Style command. The safety net icon. 🦋
  • DefaultLayers bottom put top — changes the layers used for the StaysOnBottom, StaysPut, StaysOnTop Style options. Initially it's layers 2, 4 and 6. That's the starting lineup. ⭐
  • Deschedule [command_id] — yeets every command that was scheduled with the id command_id via the Schedule command off the to-be-executed list — unless they already ran, obviously, you can't un-run a thing. Leave command_id out and fvwm uses the value of $[schedule.last] as the id. No cap. 💖
  • Emulate Fvwm | Mwm | Win — the catch-all command for how fvwm does miscellaneous things. Right now it affects where the move/resize feedback window shows up and how window placement gets aborted. Want more Mwm- or Win-like behavior? Call Emulate with Mwm or Win as the argument. With Mwm, the resize and move feedback windows sit in the center of the screen instead of the upper left corner. This also changes how manual placement is aborted — go read the ManualPlacement description, bestie. 🌸
  • EscapeFunc — by default, the key sequence Ctrl-Alt-Escape lets you escape from a Wait pause and from a locked ModuleSynchronous command. The EscapeFunc command, used together with the Key command, lets you configure that key sequence. Example time:
Key Escape A MC -
Key Escape A  S EscapeFunc

That swaps the Ctrl-Alt-Escape sequence for Shift-Escape when you're aborting a Wait pause and a ModuleSynchronous command. And EscapeFunc used outside the Key command? Does absolutely nothing. A whole lotta nothing. 💀

  • FakeClick [command value] ... — mainly a debugging tool for fvwm, and no guarantees are made that it works for you. FakeClick can simulate mouse button press and release events and pass them along to fvwm or to applications. The parameters are a list of commands made of pairs of command tokens and integer values.
    • 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.
    • wait pauses fvwm for the given number of milliseconds.
    • modifiers simulates pressing or releasing modifier keys. Values 1 to 5 map to Mod1 to Mod5, while 6, 7 and 8 map to Shift, Lock and Control. The modifier is set for any further button events. To release a modifier key, use the corresponding negative number.
    • depth decides which window the button events get sent to. Depth 1 means all events go to the root window, regardless of the pointer's position. Depth 2 passes the event to the top level window under the pointer, which is usually the frame window. Depth 3 sends events to the client window. Higher numbers go to successive sub windows. Zero (0) goes to the smallest window that contains the pointer.

And note that events propagate upward. 👀

FakeClick depth 2 press 1 wait 250 release 1

That 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] ... — again, mainly for debugging fvwm and no guarantees 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 made 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, bestie, it's over ✨

  • GlobalOpts [options] — this command is obsolete. Periodt. 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 — obsoleted by the Style options HilightFore and HilightBack. Please use
Style * HilightFore textcolor, HilightBack backgroundcolor

instead. 🫶

  • HilightColorset [num] — obsoleted by the Style option HilightColorset. Please use
Style * HilightColorset num

instead.

  • IconFont [fontname] — obsoleted by the Style option IconFont. Please use
Style * IconFont fontname

instead.

  • IconPath path — obsolete, bestie. Please use ImagePath instead. 💜
  • ImagePath path — specifies a colon separated list of directories to search for images (both monochrome and pixmap). When fvwm needs to find an image given by a relative pathname, it walks each directory in turn and uses the very first file it finds. First come, first served. 💅

Now if a directory is given in the form "/some/dir;.ext", that means every image in that directory has the extension ".ext" and it should be forced. The original image name (which might contain another extension, or no extension at all) is not probed — instead ".ext" gets added, or it replaces the original extension. Super useful, like, say, when a user has some image directories full of ".xpm" images and other image directories with the same names but ".png" images. 🌈

The path may contain environment variables such as $HOME (or ${HOME}). And a '+' in the path expands to the previous value of the path, which lets you append or prepend to the path easily. Chef's kiss. 😭

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

kay bestie so if you're dead set on undefine-ing include, you gotta do it before the ImagePath command runs:

undefine(`include')

...or, even better, just use the -m4-prefix option to force all m4 directives to have a prefix of "m4_" (go peep the FvwmM4 man page for that one 💅).

🌍 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. that's it that's the whole vibe 🙈

🔍 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 — prints information about the colors used by fvwm. This [is] 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 — 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 — prints information on your locale and the fonts that fvwm used. verbose can be 1 or 2.
  • nls — prints information on the locale catalogs that fvwm used.
  • style — prints information on fvwm styles. verbose can be 1.
  • bindings — prints information on all the bindings fvwm has: key, mouse and stroke bindings. verbose has no effect with this option.
  • infostore — 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. lowkey iconic behaviour, no notes 💖

⏰ 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. we love a glow-up 👑

🪟 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 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 get sorted just like with SortByResource, except the resource name isn't part of the vibe check — only the resource class matters. 💅

The SelectOnRelease option works exactly like the MenuStyle option of the same name, but it overrides whatever the menu style said. By default this one is set to the left Alt key. Want it gone? Use SelectOnRelease with no key name and it's out. 🫶

If you pass in a function via Function funcname, it gets called inside a window context of the selected window, like:

AddToFunc IFunc I Iconify toggle
WindowList Function IFunc, NoSticky, CurrentDesk, NoIcons

If you use the Layer m [n] option, only windows sitting in layers between m and n show up. n defaults to m. And with the ReverseOrder option the order of windows in the list is flipped. 🔄

With CurrentAtEnd, the currently focused window (if there is one) gets shown at the bottom of the list. This is mostly for simulating that Alt-Tab behavior from another GUI. IconifiedAtEnd makes iconified windows get moved to the end of the list — also borrowed from another GUI. 😌

The NoGeometry option makes fvwm not display the geometries, nor the separators that indicate the different desktops. NoGeometryWithInfo removes the geometries but keeps the desktop information and indicates iconic windows. NoDeskNum stops fvwm from displaying the desktop number in the geometry or before the window title when NoGeometryWithInfo is on. NoNumInDeskTitle is only useful if a desktop name is defined with the DesktopName command — it makes fvwm not display the desktop number before the desktop name. By default, the WindowList menu has a title indicating the current desk, or the selected desktop if the Desk condition is used. The NoCurrentDeskTitle option removes that title. TitleForAllDesks makes fvwm 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 isn't displayed. The options ShowPage, ShowPageX and ShowPageY enable displaying the page of the window rounded to multiples of the display size. With ShowScreen, the window's Xinerama screen number gets 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.

Wanna use the WindowList as an icon manager? Bestie, you could invoke this:

WindowList OnlyIcons, Sticky, OnTop, Geometry
Note — the Only options essentially wipe out all the other ones... except the OnlyListSkip option, which just causes WindowList to only consider the windows with the 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 ✨

  • XSynchronize [bool] — controls whether X requests are sent to the X server immediately or not. Normally requests are sent in bigger batches to save unnecessary communication. To send requests immediately, use "True" as the argument; to disable it, use "False"; to toggle between the two methods, use "Toggle" or just 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 ✨

  • AnimatedMove x y [Warp] — move a window in an animated fashion. Similar to the Move command. The options are the same, except they're 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 along with the window. 🎀

✨ HideGeometryWindow ✨

  • HideGeometryWindow [Never | Move | Resize] — hides the position or size window that's usually shown when a window is moved or resized interactively. To switch it off only for move or resize operations, use the optional parameters Move and Resize respectively. To switch both back on again, use the Never option. 🙈

✨ Layer ✨

  • 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 thing happens if no arguments or invalid arguments are specified. 🌈

✨ Lower ✨

  • Lower — allows the user to lower a window. Heads up: this lowers a window only within its layer. To bring a window to the absolute bottom, use:
AddToFunc lower-to-bottom
 + I Layer 0 0
 + I Lower

✨ Move ✨

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 gets 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 is 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 (like, 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 that, you may use the Mouse command with the 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 the Current command).

If the optional arguments x and y are provided, then the window is moved immediately without any user interaction. Each argument can specify an absolute or relative position from either the left/top or the 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 percent 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 the 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 the 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 ✨

  • 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 ✨

  • MoveThreshold [pixels] — when the user presses a mouse button on 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's 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 get increased once 16000x9000 pixel displays become affordable) is restored. 🍓

  • MoveToPage [options] [x[p | w] y[p | w]] | [prev] — okay bestie, this one yeets the selected window over to a different page, coords (x,y). The vibe check on the grid: top-left page is (0,0) 💖, top-right is (M,0) where M is literally one less than however many horizontal pages you told DesktopSize about. Same energy downstairs: bottom-left is (0,N), bottom-right is (M,N). Negative page numbers? Those count from the rightmost/lowest page, iykyk. No x and y given? Then the window just gets moved to the current page — which is the glow-up move for rescuing a window that has focus but is off-screen 🙈. Wanna go relative to the current page? Slap a trailing 'p' after either or both numbers. Wanna go relative to where the window already is? That's a trailing 'w'. And to hop to the previous page, just pass prev as the single argument, periodt.

Windows are usually not moved beyond desk boundaries. Noted. 👑

Possible options, bestie:

  • wrapx and wrapy — wrap around the x or y coordinate when the window gets moved past the border of the desktop. Like, with wrapx, when the window slides past the right edge of the desktop it pops back out on the left edge ✨.
  • nodesklimitx and nodesklimity — these let windows move beyond the desk boundaries in the x and y direction (which disables the wrapx and wrapy options, fyi).

Examples, served fresh:

# 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 (the one with the mouse pointer on it), 'w' for the screen containing the center of the context window, 'g' for the global screen, or just the screen number itself (counting from zero, no cap).
  • OpaqueMoveSize [percentage] — tells fvwm the maximum size window that should get opaque window movement 💅. The percentage is a percent of the total screen area (and yes, it can be greater than 100). With
OpaqueMoveSize 0

every window gets moved using the traditional rubber-band outline. With

OpaqueMoveSize unlimited

or if you hand it a negative percentage, all windows get moved as solid windows 🔥. The default is

OpaqueMoveSize 5

which lets the lil windows move opaquely while the big ones get the rubber-band treatment. If percentage is omitted or invalid, the default value gets set. And if you wanna resize windows opaquely, that's the ResizeOpaque style — see the Style command.

  • PlaceAgain [Anim] [Icon] — makes the current window's position get re-computed using the initial window placement logic ✨. Basically the window gets moved to where it would have been if it were a brand new window that just showed up. Most useful with Smart or Clever (ReallySmart) placement, ngl. With the optional argument Anim an animated move is used to put the window in its new position 🎀. With the additional option Icon, the icon is placed again instead.
  • Raise — lets the user raise a window 👑. Important caveat bestie: 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. Main character energy only.

  • RaiseLower — alternately raises and lowers a window. It gets raised if it's obscured by any window (except for its own transients when the RaiseTransient style is used — see the Style command), otherwise it gets lowered. It's giving indecisive but make it fashion 💅.
  • Resize [[frame] [direction dir] [warptoborder automatic] [fixeddirection] [w]width[p | c | wa | da] [w]height[p | c]] — allows for resizing a window 🦋. If it's called from somewhere in a window or its border, then that window is the one getting resized. If it's called from the root window, then the user gets to pick 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 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 that case the location is specified in pixels. With a 'c' suffix, the unit defined by the client application (hence the c, cute right?) 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's a percentage of the width or height of the EWMH dynamic working area. So you can literally say

Resize 80c 24c

to make a terminal window just big enough for 80x24 characters. Iconic.

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 that 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, so

Resize 100 100

may make the window bigger than the screen — no cap, it really will. 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 isn't 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] — alternate syntax alert 🚨! This one's 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, and they're 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. Slay.
  • ResizeMaximize [resize-arguments] — combines the effects of Resize and Maximize into a single command, bestie 🫶. When it's used on a maximized window, the window gets resized and is still in the maximized state</em> afterwards. When it's used on an unmaximized window, the window gets 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 — does the same thing 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. Noted.

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, fyi. 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 gets redirected to the parent window. Family reunion vibes 💜.
  • 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 the 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.:

So SetAnimation takes that delay + frame list, and here's what the default actually looks like:

SetAnimation 10 -.01 0 .01 .03 .08 .18 .3 \
  .45 .6 .75 .85 .90 .94 .97 .99 1.0

That 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 honestly they're the fun part — you can use them to make the motion appear more cartoonish by briefly moving slightly in the opposite direction of the main motion. The settings above are the default. 💖

  • SnapAttraction [proximity [behaviour] [Screen]] — bestie this command is obsolete. It's been replaced by the Style command option SnapAttraction. That's the whole vibe. 👋
  • SnapGrid [x-grid-size y-grid-size] — also obsolete, no cap. It's been replaced by the Style command option SnapGrid.
  • WindowsDesk arg1 [arg2] — moves the selected window to another desktop. But listen — 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, fr fr. 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. So like... it heard you, it just chose not to listen. 😭
  • 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. 💀 Yeah. That one's the nuclear option, bestie.
  • 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]] — okay this one's a whole meal, let's break it down 🍓

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

...it makes fvwm go and recapture all of its windows, bestie. Like, all of them. Why would you do that? So the freshest style parameters actually get used. Fair warning though — the recapture operation is visually disturbing, it's giving strobe light at a rave, so maybe don't do it mid-video-call. 😭

And since fvwm version 2.4, only a very few Style options actually need a Recapture to take effect (think UseStyle). So it's lowkey rarely the move. 💅

  • RecaptureWindow — bestie this one is obsolete, do not use it anymore, it's giving expired milk. ✨ See Recapture for details. It causes fvwm to recapture the chosen window.
  • Refresh — makes every window on the screen redraw itself. All pending updates to all windows' styles and looks get applied immediately. Like, e.g. if Style or TitleStyle commands were issued inside a fvwm function and you want them to show up right now. 🦋
  • RefreshWindow — same vibe but for just the chosen window: it redraws itself and all pending updates of that window's style and look are applied immediately. E.g. if Style or TitleStyle commands were issued inside a fvwm function. 🎀

✨ THE WINDOW-Y COMMANDS (sticky edition) ✨

  • Stick [bool] — the sticky-maker. If the bool argument is empty or "toggle", Stick makes a window sticky if it isn't already sticky, or non-sticky if it already is. Periodt, it just flips it. If you want it sticky no matter what its current state is, bool has to be "True". Want it non-sticky? Use "False". 💖
  • StickAcrossPages [bool] — works exactly like Stick, but it only sticks a window across pages, not across desks. Iykyk. 🧚
  • StickAcrossDesks [bool] — works exactly like Stick, but it only sticks a window across desks, not across pages. 🌸
  • WindowShade [bool] | [[ShadeAgain] direction] — toggles the window shade feature for titled windows. Shaded windows only show a title-bar, iconic behavior honestly. 👑

So: if bool is not given or is "toggle", the window shade state just gets toggled. If bool is "True", the window is forced into the shaded state. If bool is "False", the window is forced into the non-shaded state. To force shading in a specific direction, you use the direction argument. Any of the strings "North", "South", "West", "East", "NorthWest", "NorthEast", "SouthWest", "SouthEast" or "Last" can be given. And yes you can abbreviate with the usual one or two letters — "N", "NW", etc. 🦋

Heads up: using a direction on a window that was already shaded unshades the window. To shade it in a different direction instead, 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. 💅

Also please go read the 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 the 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". But note that this syntax is obsolete, and will be removed in the future. So like, don't. 🙈

  • WindowShadeAnimate [steps [p]] — this command is obsolete, bestie. 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. It affects the ClickToFocus style too. This command belongs in your config, fr fr — if you issue it when your fvwm session is already up and running, the results are unpredictable. 😭 It 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 to 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. But 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 to get a delay when raising or lowering windows. See the 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 can 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

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. no cap, X11 said "that's all you get bestie" 💅

Context describes where the binding applies. Valid contexts are:

  • 'R' — the root window
  • 'W' — an application window
  • 'D' — a desktop application (as kdesktop or Nautilus desktop)
  • 'T' — a window title-bar
  • 'S' — a window side, top, or bottom bar
  • '[', ']', '-' and '_' — the left, right, top or bottom side only
  • 'F' — a window frame (the corners)
  • '<', '^', '>' and 'v' — the top left, top right, bottom right or bottom left corner
  • 'I' — an icon window
  • '0' through '9' — title-bar buttons
  • or any combination of these letters
  • 'A' — 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. iykyk

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. the math is mathing 📐✨

⌨️ PointerKey

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. read the warning bestie, don't be messy 🙈

Example:

Style * SloppyFocus
PointerKey f1 a m Menu MainMenu

🖊️ Stroke

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. twelve max, keep it snappy girlie 💅

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. iconic behavior honestly 🌈

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

✍️ StrokeFunc

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"

Quick lil heads up bestie: the Context and Modifiers get locked in at the start of the StrokeFunc command running — so yeah, you can let go of those modifiers before the stroke recording even finishes (super handy with a mouse binding, and if you used, like, a title-bar context, your mouse motion can travel right on through an application window). And the Escape and Delete keys? They're your abort buttons. Mash either one to bail. 🙈

The StrokeFunc command has five options: NotStayPressed, EchoSequence, DrawMotion, FeedBack and StrokeWidth. All of them are disabled by default, no cap.

  • EchoSequence — makes fvwm Echo the recorded stroke sequence ✨
  • DrawMotion — makes fvwm draw your mouse motion on the screen 🖊️
  • FeedBack — makes fvwm flash the cursor of the WAIT context of the CursorStyle command for a fraction of a second, but only if the recorded stroke sequence matches a stroke binding 👀
  • StrokeWidth — takes an integer argument, which has to be >= 0 and <= 100, and it sets the width of the line for the DrawMotion option 📏

NotStayPressed only does its thing if StrokeFunc is used via a Mouse or a Key command. What it does is remove the need to hold a button (or the key) down during the whole stroke — but then you gotta do a mouse click, or hit the Return or Space key, to finish recording the mouse motion. (Fun fact: those keys work even without the NotStayPressed option too. 💅)

You can also run StrokeFunc "alone". In that case it behaves like the above with NotStayPressed enabled. But heads up — Modifiers, in general, may not work how you expect (so in this situation, use 'A' or 'N' as Modifiers in your stroke bindings).

Real talk: some computers just don't support key release events. If yours is one of them, StrokeFunc used via a Key command works as if the NotStayPressed option is enabled. Nothing you can do about it, it's giving hardware limitations. 💀

🎀 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. (Yes bestie, we're saving the big one for last. Main character energy. 👑)

FocusStyle stylename options

works exactly like the Style command, but it only accepts the focus policy related styles — the ones beginning with "FP". You can drop that prefix if you want, but it'll cost you a little bit of time. FocusStyle exists purely to make your config 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 — it's 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". Read that again, bestie, it's a trap. 😭

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

okay so bestie, we're still deep in the Style command tea and honestly? it's giving ✨ main character ✨ — here's the rest of it. 🫶

options is a comma separated list with one or more of the following keywords. Each group of style names gets separated by slashes (/). And the last style in each group? That's the default, periodt. 💅

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

ngl that list is a lot but you ate that, bestie. 🌈

Some of those options above are written as style-option/opposite-style-option. The opposite-style-option — for the ones that even have one — is describing the fvwm default behavior, and you can use it if you wanna flip the fvwm default behavior. 💫

🌸 Focus policy 🌸

ClickToFocus tells fvwm to hand a window the focus the moment you click inside it.

The default, MouseFocus (or its lil alias FocusFollowsMouse), tells fvwm to give a window the focus as soon as the pointer enters the window, and to take it away when the pointer leaves the window. 🦋

SloppyFocus is similar, except it doesn't give up the focus if the pointer leaves the window just to pass over the root window or a ClickToFocus window (unless you click on it, obviously) — which makes it possible to move the mouse out of the way without losing focus. Iconic behavior honestly. ✨

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

FPIgnoreFocusClickMotion — bestie okay so picture this: you click in a window and then you drag the pointer with the button still held down, and that drag does not count as the click that focuses the window 💅. Instead, the application processes those events normally, like nothing even happened. This is lowkey iconic for selecting text in a terminal window with the mouse without raising the window 🫶. BUT — and here's the catch — mouse bindings on the client window are not guaranteed to work anymore (see the Mouse command 😭). This style forces the initial click to be passed to the application. The distance the pointer has to move before this kicks in is controlled by the MoveThreshold command.

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

👑 Clicking the window to raise 👑

  • FPClickRaisesFocused, FPClickDecorRaisesFocused, FPClickIconRaisesFocused — these let you raise the window when the interior, the decorations, or the icon of the window gets clicked while the window is already focused ✨.
  • FPClickRaisesUnfocused, FPClickDecorRaisesUnfocused, FPClickIconRaisesUnfocused — same energy, but they raise the window when the interior, the decorations, or the icon gets clicked while the window is not yet focused 🌸.
  • FPPassRaiseClick — with this one, the click that was used to raise the window gets passed on to the application 💖.
  • FPAllowRaiseClickFunction — and with this one, that same raise-the-window click can also trigger a normal action that was bound to the window with the Mouse command 👑.
  • FPIgnoreRaiseClickMotion — if this style is on, 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, which is super useful for selecting text in a terminal window with the mouse without raising the window. However — same caveat as before, no cap — mouse bindings on the client window are not guaranteed to work anymore (see the Mouse command 😭). Note that this style forces that the initial click is passed to the application. The distance 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, fr fr 💀.

  • OverrideGrabFocus — this tells fvwm to never take away the focus from such a window via the GrabFocus or GrabFocusTransient styles 🫶. Super handy if you like having transient windows receive focus immediately, like in a web browser, but not while you're working in a terminal window or a text processor.

The above three styles are accompanied by FPReleaseFocus, FPReleaseFocusTransient and FPOverrideReleaseFocus 💜. These control whether 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 — these control whether a mouse click used to focus a window is sent to the application or not 💅.
  • ClickToFocusRaisesOff / MouseFocusClickRaisesOff and ClickToFocusRaises / MouseFocusClickRaises — these control whether the window is raised (but it depends 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. That is no longer the case, bestie — it's ancient history ⭐.

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 it is deprecated — so like, don't.

  • TitleAtBottom, TitleAtLeft, TitleAtRight — windows with these styles have a title-bar below, to the left, or to the right of the window instead of above like usual 🌸.
  • TitleAtTop — restores the default placement (back on top, where it belongs 💅).

Even if the window has the !Title style set, this affects the WindowShade command 👀. Please check the WindowShade command for the 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, bestie. 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 instead.
  • 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.
  • HilightFore, HilightBack and HilightColorset — these style options work exactly like ForeColor, BackColor and Colorset but they're 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.
  • HilightBorderColorset — works similarly to BorderColorset but it's used when the window has the focus ✨.
  • !IconTitle — disables displaying icon labels, while the opposite style IconTitle enables icon labels (that's the 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's 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's restored if the argument is omitted.

Okay so 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:

...and if you wanna de-iconify and tidy up all the other icons while you're at it, bestie, you build yourself a function. Like this:

AddToFunc DeiconifyAndRearrange
 + C Iconify off
 + C All (CurrentPage, Iconic) PlaceAgain Icon

Then go swap out every place you were calling Iconify to de-iconify an icon, and call your new function instead. So this:

AddToFunc IconFunc
 + C Iconify off
 + M Raise
 + M Move
 + D Iconify off

Mouse 1 I A Iconify off

becomes this:

AddToFunc IconFunc
 + C DeiconifyAndRearrange
 + M Raise
 + M Move
 + D DeiconifyAndRearrange

Mouse 1 I A DeiconifyAndRearrange
  • IconGrid — takes 2 numeric arguments, and both of them gotta be greater than zero. The syntax is:
IconGrid x y

So what it does: icons get placed in an icon box by stepping through the box using those x and y values as the icon grid, hunting for free space. The default grid is 3 by 3 pixels, which gives you that tightly packed look. Want something more regular and orderly? Use a grid bigger than your largest icon. And use the IconSize argument if you wanna clip or stretch an icon down to a max size. ✨ Heads up though: an IconGrid definition has to come after the IconBox definition it applies to:

Style * IconBox -80x240-1-1, IconGrid 90 90
  • IconFill — takes 2 arguments.
IconFill Bottom Right

Icons get placed in an icon box by stepping through it using these arguments to control which direction the box gets filled in. By default the direction is left to right, then top to bottom — which you'd write as:

IconFill left top

Wanna fill in columns instead of rows? Put the vertical direction (top or bottom) first. The directions can be abbreviated or spelled out all the way, like this: "t", "top", "b", "bot", "bottom", "l", "lft", "left", "r", "rgt", "right". Same rule as before, bestie: an IconFill definition has to follow the IconBox definition it applies to:

Style * IconBox -80x240-1-1, IconFill b r
  • IconSize — sets limits on how big an icon image can be. And it hits both user-provided and application-provided icon images, so no one escapes. 💅
IconSize [ width height [ maxwidth maxheight ] ]

Every argument is measured in pixels. When you pass all four arguments, width and height are the minimum size of an icon, and maxwidth and maxheight are the maximum size. Icons smaller than the minimum get padded, icons bigger than the maximum get clipped.

Pass only two arguments and width and height become the absolute size — icons covered by that style get padded or clipped to hit exactly that size.

Pass no arguments and the default values get used for each dimension, which basically means no limits at all on icon size. Slay.

You can drop a value of "-1" in place of any of the arguments to mean "use the default value for that dimension."

On top of the numeric args, you can throw in 1 more argument: "Stretched", "Adjusted", or "Shrunk".

Not me being the bearer of bad news: icon managers provided by modules are not affected by this style. 🙈
  • MiniIcon — specifies a pixmap to use as the miniature icon for the window. This lil mini icon can be drawn in a title-bar button (peep ButtonStyle), and various fvwm modules can use it too (FvwmIconMan and FvwmPager). It takes the name of a pixmap as its argument.
  • WindowShadeShrinks and WindowShadeScrolls — these control whether the contents of a window that's being shaded with the WindowShade command get scrolled (that's the default) or whether they stay put. The shrinking mode is a bit faster.
  • WindowShadeSteps — picks how many steps the animation takes when shading a window with WindowShade. Takes one number as its argument. If that 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 entirely — and that also happens if the argument is omitted or invalid.

The WindowShade command has two modes of operation: busy shading and lazy shading. Busy shading can be 50% slower than lazy shading, but lazy can look straight-up strange under some conditions — for example if the window borders, buttons, or the title are filled with a tiled pixmap. Also, the window handles aren't drawn in lazy mode, and the border relief may only be drawn partially right before the window hits the shaded state, or right after it 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 WindowShadeAlwaysLazy or WindowShadeBusy to force lazy or busy mode. And the default setting gets restored with WindowShadeLazy.

  • ResizeOpaque — tells fvwm to resize the corresponding windows with their contents visible instead of drawing an outline. Lowkey this makes the application redraw a whole bunch, so it can be pretty slow and make the window flicker excessively, depending on how much graphics the app redraws. The ResizeOutline style (the default) negates ResizeOpaque. A lot of applications do not like having their windows resized opaque — think XEmacs, Netscape, or terminals with a pixmap background. If you don't like the result, don't use ResizeOpaque on those windows. Wanna exempt certain windows from opaque resizing? Drop lines like these in your config file:
Style * ResizeOpaque
Style rxvt ResizeOutline
Style emacs ResizeOutline
  • Sticky — makes the window sticky, i.e. it's always visible on every page and every desk. The opposite style, Slippery, reverts back to the default.
  • StickyIcon — makes the window sticky when it's iconified. It de-iconifies on top of 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. Meanwhile StickyAcrossDesks and StickyAcrossDesksIcon work the other way round.

Windows that have been marked as Sticky, StickyAcrossDesks, or StickyAcrossPages get stipples drawn on the titlebar. You can negate that with the !StickyStippledTitle style. The StickyStippledTitle style puts the stipples back for windows marked as Sticky. Note that this is the default style for sticky windows. Sticky icons get stipples drawn on the icon title, and you can disable that the same way with the !StickyStippledIconTitle style.

  • StartIconic — windows with this style show up as icons right away. Just so you know, some applications counteract that by deiconifying themselves. 🙄 The default is to not iconify windows, and you can set that with the StartNormal style.
  • StickyIcon — yep, it's back: makes the window sticky when it's iconified, and it de-iconifies on top of the active desktop. SlipperyIcon reverts back to the default.
  • StickyIconPage — works like StickyIcon, but sticks the icon only across pages, not desks. StickyIconDesk works the other way round.
  • StippledIconTitle — works like StippledTitle in that it draws stipples on the titles of icons, but it does not make the icon sticky.
  • IgnoreRestack — makes fvwm ignore attempts by clients to raise or lower their own windows. By default, the opposite style, AllowRestack, is active.
  • FixedPosition and FixedUSPosition — make fvwm ignore attempts by the user to move the window. You can still move the window by resizing it though. Wanna let the user move windows? Use the VariablePosition or VariableUSPosition style.
  • FixedSize and FixedUSSize — make fvwm ignore attempts by the user to resize the window. To let the user resize windows, use the VariableSize or VariableUSSize style.
  • FixedPPosition and FixedPSize — make fvwm ignore attempts by the program to move or resize its windows. To allow that kind of action, use the VariablePPosition or VariablePSize style. These styles may sometimes affect the initial placement and dimensions of new windows (depends on the app). If windows are getting created at strange places, try either VariablePPosition or !UsePPosition. And the FixedPSize style may screw up window dimensions for some applications — in that case, Do Not use this style.
  • 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 sometimes it detects the wrong one. 😭 You might run into a window that travels across the screen by a few pixels when the application resizes it, or moves to a screen border with the frame decorations off screen, or remembers its position for the next time it starts but shows up slightly shifted, or that attempts 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 has been detected, it is never changed again. As long as fvwm can't 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 — bestie, this one lets the functions Close, Delete and Destroy be performed on the windows. It's on by default, periodt. The opposite, !Closable, inhibits the window to be closed. 💅
  • Iconifiable — enables the function Iconify to be performed on the windows. On by default, no cap. The opposite, !Iconifiable, inhibits the window from being iconified. 🎀
  • Maximizable — enables the function Maximize to be performed on the windows. 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 the 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). 👑
  • IconifyWindowGroups — with this, 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. 💀
  • SnapAttraction — this option affects interactive window movement: if during an interactive move the window or icon comes within proximity pixels of another 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 is optional and may be set to one of the five following values:

  • 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.
  • Windows — windows snap only to other windows.
  • Icons — icons snap only to other icons.
  • 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:

  • Screen — the already snapping icons or windows, which is controlled by the second argument, will snap now also to the screen edges.
  • ScreenWindows — snaps only windows to the screen edges.
  • ScreenIcons — snaps only icons to the screen edges.
  • ScreenAll — snaps windows and icons to the screen edges. ⭐
  • 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 at 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. 🧚

  • EdgeMoveDelay and EdgeResizeDelay — these styles tell 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. 💖

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

Reset vibes: to yeet this style back to its default settings, just slap a '!' in front of it. 💅

This style is the one calling the shots for the MinOverlapPlacement and MinOverlapPercentPlacement placement policy. Here's who's who in the factor squad:

  • normal — the factor for regular, everyday windows
  • ontop — the factor for windows sitting on a greater layer than the window currently being placed
  • icon — the factor for icons
  • sticky — the factor for sticky windows
  • below — the factor for windows on a smaller layer than the one being placed
  • strut — the factor for the complement of the EWMH working area, if the window being placed has the EWMHPlacementUseWorkingArea style — and for windows carrying an EWMH strut hint (aka the "please do not cover me 🥺" hint) if the window being placed has the EWMHPlacementUseDynamicWorkingArea style

These factors = how much area each of those window types (or that area) counts as when a new window shows up. So like, by default the area of ontop windows gets counted 5 times as much as normal windows. Meaning MinOverlapPlacement and MinOverlapPercentPlacement will cover 5x as much area of another window before it dares cover an ontop window. Want ontop windows treated like everybody else? Set it to 1. Want to really, really never put a window under an ontop window? Set it to a high value, say 1000. ✨

This style affects the window that's already mapped, not the window currently being placed. One exception though, bestie: if the window being placed has the EWMHPlacementUseWorkingArea style, then the strut factor does affect the placed window.

MinOverlapPercentPlacementPenalties takes at most 4 positive or null integer arguments:

cover_100 cover_95 cover_85 cover_75

If the trailing arguments are missing, the defaults get used, and those defaults are:

12 6 4 1

To reset this style to default values, prefix it with a '!'. This one affects the MinOverlapPercentPlacement placement policy and is basically the sibling of the MinOverlapPlacementPenalties style. The cover_xx factor kicks in when the window being placed covers at least xx percent of the window. This factor gets added to the factor determined by the MinOverlapPlacementPenalties style. 🧮

ManualPlacement (aka active placement). The user has to place every single new window manually, no auto-pilot. The window just shows up as a rubber band until you manually pick a spot. The window gets placed the moment a mouse button or any key except Escape is pressed. Escape aborts manual placement, which dumps the window in the top left corner of the screen. 🙈 And if mouse button 2 is pressed during the initial placement of a window (or Shift + mouse button 1 if Mwm emulation has been enabled with the Emulate command), the user is asked to resize the window too.

You can define buttons usable to place windows with the Move command and the special context 'P' for placement (see the Move command). But you can't redefine the way to also resize the window, other than how it's affected by the Emulate command. The button used for placing the window can be checked with the PlacedByButton condition (see the 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

So now, whenever a window is created and the user presses button 3 to finish initial placement, the window automatically enlarges until it hits the bottom screen border. Chef's kiss 👑

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. Not a drill. 🚨 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 — tells fvwm to ignore the program specified position (the PPosition hint) when adding new windows. Using PPosition is required for some applications, but if you don't have one of those it's a real headache. So 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 suppresses using the user specified position indicated by the program (USPosition hint). Overriding the user's choice is generally a bad thing, ngl, 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 — tells 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 where the window should be initially placed. Quick note: standard Xt programs can also specify this via a resource (like "-xrm '*Desk: 1'").
  • StartsOnPage — takes 1, 2, or 3 numeric arguments. With one or three arguments, the first (or only) argument is the desktop number. With three arguments, the 2nd and 3rd identify the x,y page position on the virtual window. With two arguments, they specify the page position and indicate no desk preference. With only one argument, StartsOnPage functions exactly like StartsOnDesk. For those standard Xt programs that understand this usage, the starting desk/page can also be specified via a resource (like "-xrm '*page: 1 0 2'"). And StartsOnPage + SkipMapping is a genuinely useful technique when you want to start an app on some other page and just keep doing what you were doing instead of waiting for it to appear. 🦋
  • StartsOnScreen — takes one argument. It can be 'p' for the primary screen, 'c' for the current screen (the one containing the mouse pointer), 'g' for the global screen, or the screen number itself (counting from zero). A new window gets placed on the specified Xinerama screen. The default is to place windows on the screen containing the mouse pointer at the time the window is created. However, those windows that aren't placed by fvwm (i.e. the ones 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 handy for making those windows place relative to a specific Xinerama screen. For example:
Style * StartsOnScreen c

would cause all windows, including the ones with their own geometry, to be placed relative to the current Xinerama screen rather than the global screen. For those standard Xt programs that understand this usage, the starting desk/page can also be specified via a resource (like "-xrm '*fvwmscreen: c'"). ('fvwmscreen' was chosen because some applications already use ´.screen' for other purposes.)

  • StartsOnPageIncludesTransients — makes the StartsOnPage style apply even for transient windows. Not usually useful, since transients are usually pop ups you want showing up 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 when both ManualPlacement and SkipMapping are in effect at window creation time. This saves you from interactively placing a window and then wondering where tf it disappeared to, because it got placed on a different desk or page. 💀
  • ManualPlacementHonorsStartsOnPage — allows that to happen anyway. This option has no effect if SkipMapping isn't 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 — bestie, this one makes the initial capture (like, when fvwm grabs a window that already existed) at startup place the window according to the StartsOnPage and StartsOnScreen desk, page and Xinerama screen spec. 💖
  • CaptureIgnoresStartsOnPage — the opposite vibe: fvwm straight up ignores those settings (yes, StartsOnDesk included) on initial capture. And the default? CaptureIgnoresStartsOnPage. periodt.
  • RecaptureHonorsStartsOnPage — makes a window get placed according to, or revert to, the StartsOnPage and StartsOnScreen desk, page and Xinerama screen spec whenever there's a Restart or Recapture. ✨
  • RecaptureIgnoresStartsOnPage — here fvwm respects the window's current position on Restart or Recapture. This is the default, no cap.
  • Layer — takes one optional argument: a non-negative integer. That's the layer the window gets put in. No argument given? Then any previously set value is deleted and the default layer is implied. 🫶
  • StaysOnTop — puts the window in the top layer. That layer can be changed with the DefaultLayers command; the default is 6. 👑
  • StaysPut — puts the window in the put layer. Changeable via DefaultLayers; the default is 4.
  • StaysOnBottom — puts the window in the bottom layer. Also DefaultLayers-able; the default is 2.
  • StartsLowered — tells fvwm to put the window initially at the bottom of its layer instead of the default StartsRaised. 💅
  • StartShaded — tells fvwm to shade the window. You can hand it an optional direction argument, and it can be one of "North", "South", "West", "East", "NorthWest", "NorthEast", "SouthWest", "SouthEast" — or, if you give no direction at all, the default is to shade north. 🧚
  • SkipMapping — tells fvwm not to switch to the desk the window is on when it gets mapped initially. Super 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 in the same group. Since this behavior may be confusing, the default setting is ScatterWindowGroups. Oh and heads up: the window group hint is ignored when placing windows in this case.

✨ Transient windows ✨

  • DecorateTransient — transient windows are normally left undecorated, but this gives them the usual fvwm decorations (title bar, buttons, all of it). Small note though: some pop-up windows, like the xterm menus, are not managed by the window manager and still don't get decorations. 😭
  • NakedTransient — this is the default, and it means transient windows don't get the standard decorations. Also, you can only bind keys or mouse buttons to the sides and the client part of an undecorated window (that's the 'S' and 'W' contexts in bindings, see the 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. 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. All windows are then treated as if they had no transients.

The StackTransientParent style augments the RaiseTransient and LowerTransient styles. Raising a window with the 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, so the whole group goes up together. 🌈 Similar behavior holds for lowering a whole group of transients when the main has LowerTransient style. DontStackTransientParent turns this behavior off. Also important: (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. iykyk.

  • EWMHDonateIcon — instructs fvwm to set the application ewmh icon hint with the icon that is used by fvwm, if the application doesn't provide such a hint (and if the icon used by fvwm isn't an icon window). 💖
  • EWMHDonateMiniIcon — same thing, but for mini icons. This lets compliant pagers, taskbars, iconboxes ...etc display the same (mini) icons as fvwm.
  • EWMHDontDonateIcon — restores the default, which is to not set any ewmh (mini) icons hints.
  • EWMHDontDonateMiniIcon — same, for mini icons.
Heads up bestie: on some hardware (e.g., 8-bit displays) these styles can slow down window mapping, and in general only one of these styles is needed by a compliant application. 😭

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.

  • EWHMMiniIconOverride — instructs fvwm to ignore ewmh icons and use the mini icon provided by the MiniIcon style. (Wait, it's EWHMMiniIconOverride, keep it exactly like that, bestie 💅)
  • 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 EWMH terminology such a hint is called a strut, and it's 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.
  • EWMHUseStrutHints — causes fvwm to use it. This is the default.
  • EWMHIgnoreStateHints — causes fvwm to ignore initial EWMH state hints when a new window is mapped.
  • EWMHUseStateHints — the default; causes fvwm to accept such hints.
  • EWMHIgnoreWindowType — causes fvwm to ignore EWMH window type specification.
  • !EWMHIgnoreWindowType — the default; 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.
  • EWMHMaximizeUseWorkingArea — the EWMH working area is used.
  • EWMHMaximizeUseDynamicWorkingArea — the EWMH dynamic working area is used. This one's the default. ✨
  • EWMHPlacementIgnoreWorkingArea — causes fvwm to ignore the EWMH working area when it places (or places again) a window.
  • EWMHPlacementUseWorkingArea — the EWMH working area is taken in account.
  • EWMHPlacementUseDynamicWorkingArea — the EWMH dynamic working area is taken in account. Default, babes. 🎀
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 💜

  • BackingStore, BackingStoreOff and BackingStoreWindowDefault — these determine if the X server uses backing store for the window or not. BackingStore means 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 it can be much faster if the connection is slow (see also SaveUnder below). BackingStoreOff disables backing store for the window. By default, fvwm doesn't enable or disable backing store itself but leaves it 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).
  • SaveUnderOff — to disable save under, use this. It's 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 — this is the default, and it 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.
  • 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. 💀
  • GNOMEUseHints — 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 takes literally one argument: the name of a decor you built with AddToDecor. No decor name? Cool, the "Default" decor steps in. Windows don't actually contain decors, they're just always assigned to one. And if you tweak that decor later with AddToDecor, the glow-up is visible on every window assigned to it. 🌸 Wanna move a window onto a different decor? That's ChangeDecor's whole gig.

UseStyle — okay bestie, this style is deprecated and it 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. Like, watch:

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. No shortcuts, sorry. 💀

Unmanaged — windows with the Unmanaged style option are straight up ignored by fvwm. They are not decorated, can not be moved or resized, etc. You probably want to use Bugopts RaiseOverUnmanaged too, iykyk. 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. So go do the recapture, bestie. 💅

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

# turn on state 11 for xterms ...
Style xterm State 11
# ... but not for rxvts.
Style rxvt !State 11

WindowListSkip — 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. 🫶

okay so AddToDecor works basically the same way as AddToMenu and AddToFunc do — same vibe, same energy — except instead of menus and functions you're stacking up ButtonStyle, AddButtonStyle, TitleStyle, AddTitleStyle and BorderStyle commands. 💅 And once you've made a decor with AddToDecor, you can mess with it using ChangeDecor, DestroyDecor, UpdateDecor and the Style option. Slay.

This next example builds a decor called FlatDecor and a style called FlatStyle, and heads up bestie — these are two whole separate entities, not the same thing:

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

If you wanna reassign the decor on a window that already exists, that's ChangeDecor's whole job. And a decor can get destroyed with DestroyDecor. ✨

DestroyDecor FlatDecor
AddToDecor FlatDecor ...

Style FlatStyle UseDecor FlatDecor

and then you apply the style all over again:

Style xterm UseStyle FlatStyle

BorderStyle 💖

BorderStyle state [style] [-- [!]flag ...]

This one defines a border style for your windows. state can be either "Active" or "Inactive". If you skip state, then the style gets set for both states at once. And if the style and flags are wrapped up in parentheses, you can stack multiple state definitions on a single line. Obsessed.

style is a lil subset of the available button styles — it can only be TiledPixmap (and ngl, uniform pixmaps that match the bevel colors work best this way) or Colorset. If you slap a '!' in front of any flag, the behavior gets negated. And if style isn't specified, you can still change flags without resetting the style. 🎀

The HiddenHandles flag hides the corner handle dividing lines on windows that have handles (note: this does nothing for !Handles windows). By default, HiddenHandles is disabled.

The NoInset flag is like a lil supplement to HiddenHandles. If you give it, the inner bevel around the window frame doesn't get drawn. But fr if HiddenHandles isn't specified too, the frame looks a little strange. 😭

Raised causes a raised relief pattern to be drawn (that's the default). Sunk causes a sunken relief pattern. Flat stops the relief pattern from being drawn at all.

To decorate the active and inactive window borders with a textured pixmap, you might go:

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 it for just a single state:

BorderStyle Active Simple

And to unset a flag for a given state:

BorderStyle Inactive -- !NoInset

Also, title-bar buttons can inherit the border style with the UseBorderStyle flag — go peek at ButtonStyle. 👑

ButtonState 🦋

ButtonState [ActiveDown bool] [Inactive bool] [InactiveDown bool]

The ButtonState command controls which states of the window titles and title buttons actually get used. The default is to use all four states: "ActiveUp", "ActiveDown", "InactiveUp" and "InactiveDown" (check ButtonStyle and TitleStyle for the deets). The bool argument after the keyword controls whether that designated state is used ("True") or not ("False"). And the bool flag works the same as it does for other commands — it's not limited to just "True" or "False", you can also say "Yes" and "No". But the "ActiveUp" state cannot be deactivated, periodt. If you give no arguments, or the arguments you gave are illegal, the default gets restored. 💅

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

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

If InactiveDown is "False" (and note this only applies when Inactive is "True"), then the pressed titles and title buttons in non-focused windows get drawn using "InactiveUp" or "ActiveUp" states, depending on the values of the other keywords.

ButtonStyle 🌸

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 over in the Mouse command section. If the style and flags are wrapped in parentheses, you can stack multiple state definitions per line. ✨

state is all about which button state should be set. Button states are defined like this: "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" means both "ActiveUp" and "ActiveDown" states. Shortcut "Inactive" means both "InactiveUp" and "InactiveDown" states. And the similar state names you just read, but with the "Toggled" prefix out front, get used instead for title buttons that have one of the MwmDecorMax, MwmDecorShade, MwmDecorStick or MwmDecorLayer hints — depending on whether the window is maximized, shaded, sticky or placed on a 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

On top of all that, these shortcuts exist too: "AllNormal", "AllToggled", "AllActive", "AllInactive", "AllUp", "AllDown". They're actually different masks for 4 individual states out of 8 total. And these are supported as well: "AllActiveUp", "AllActiveDown", "AllInactiveUp", "AllInactiveDown".

If state is specified, that particular button state gets set. If state is omitted, every state gets set. But careful — specifying a style destroys the current style (use AddButtonStyle if you wanna avoid that). 😭

If style is omitted, then state-dependent flags can be set for the primary button style without destroying the current style. Examples (and bestie, treat each line as 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 the flags change — the buttons' individual styles stay untouched).

If you wanna 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, you can give multiple state definitions on one line by wrapping the style and flags in parentheses. And if you're only giving one definition per line, you can skip the parentheses entirely. 🫶

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 right here (the ButtonStyle entry handles the state-independent flags):

  • Raised — causes a raised relief pattern to be drawn.
  • Sunk — causes a sunken relief pattern to be drawn.
  • Flat — stops 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're redundant in this context.
  • UseBorderStyle — causes the button to inherit the decorated BorderStyle options.

Raised, Sunk and Flat are mutually exclusive, and can only be specified for the initial ButtonStyle. UseTitleStyle and UseBorderStyle are mutually exclusive too (though both can be off, obviously). 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 gets inverted. Because of this, to get the raised look in "ActiveDown" or "InactiveDown" states you have to specify the opposite of the desired relief (i.e. Sunk for "ActiveDown" or "InactiveDown"). This behavior is consistent, but ngl it may seem confusing at first. Same thing applies to the "Toggled" states.

Button styles get classified as non-destructive, partially destructive, or fully destructive. Non-destructive styles don't affect the image at all. 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). So if you're stacking styles with AddButtonStyle (or AddTitleStyle for title-bars), be careful with how you sequence those 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 follows:

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 (and if given, it overrides the current button). But if a command other than ButtonStyle or AddButtonStyle is used, then the number must be specified. ⭐

The Solid style is giving fill-the-button-with-a-solid-color energy, periodt. The relief border color? Not affected bestie, she's untouched. The color comes in as a single argument. Heads up though — this style is fully destructive. 💅

The Colorset cs [alpha] style fills the button with the Colorset cs. That optional alpha argument is a percentage between 0 and 100, and it makes fvwm merge the colorset background onto the button using that percentage. If the percentage is 0, the colorset background is hidden; if it's 100, the colorset background is fully applied. Default is 100. So yeah, how destructive it is depends entirely on that 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 the 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). You can drop an optional absolute offset in pixels as "+<offset>p" for a positive or "-<offset>p" for a negative offset. ✨

C specifies a line color, and here's the lore:

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

Ngl the specification is a little cumbersome:

ButtonStyle 2 Vector 4 50x30@1 70x70@0 30x70@0 50x30@1

so button 2's 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, iykyk.

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 that 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, and 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.
  • 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, no cap.

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 is lowkey just ButtonStyle's twin — it accepts literally all the same styles and arguments, no cap:

Simple, Default, Solid, Colorset, Vector, ?Gradient, Pixmap, AdjustedPixmap, ShrunkPixmap, StretchedPixmap, TiledPixmap, MiniIcon.

Go peep the ButtonStyle command for the tea on what all of those actually do 💅

🎀 the MultiPixmap era 🎀

On top of all that, TitleStyle also serves a powerful MultiPixmap option. This one lets you set different pixmaps, colorsets or colors for different parts of the titlebar, like you're decorating a cake by section 🍰 Some of them get tiled or stretched to fit their little spot; others are discrete "transition" images. Here's every definable section, bestie:

  • Main — the full titlebar
  • LeftMain — left of the title text
  • RightMain — right of the title text
  • UnderText — underneath the 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 the left buttons, if there are any)
  • RightEnd — at the far right end of the titlebar (just before the right buttons, if there are 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 don't define Main, then you must define both LeftMain and RightMain. And if no Buttons pixmaps are defined while UseTitleStyle is specified for one or more buttons, then Main, LeftMain or RightMain get used as appropriate. Slay, it adapts ✨

The syntax for this style type is:

MultiPixmap section style arg, ...

...and you just keep going for whatever you wanna define. The style can be either TiledPixmap, AdjustedPixmap, Colorset or Solid — again, ButtonStyle has the full description of these styles. One lil caveat: for a transition section — LeftEnd, LeftOfText, RightOfText or RightEnd — AdjustedPixmap only resizes the pixmap in the "y" direction. And for the Colorset and Solid styles, a width of half the title bar height is assumed for the transition sections. Noted 📝

An example, because seeing it hit different:

MultiPixmap Main AdjustedPixmap foo.xpm, \
            UnderText TiledPixmap bar.xpm, \
            Buttons Colorset 2

And heads up — 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. Legacy queen behavior, we respect it 💖

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

It's kept mainly for backward compatibility, and since all elements of a decor are updated immediately when they're changed anyway, this command is mostly useless. Not me pointing out the uselessness 💀

So what does it do? It updates window decorations. decor is an optional argument specifying which decor to update. If you give it, only windows assigned to that particular decor get updated. This command comes in handy, for instance, after a ButtonStyle, TitleStyle or BorderStyle (possibly used in conjunction with AddToDecor). Specifying an invalid decor results in all windows being updated — surprise, everybody gets a glow-up 🙈

It's less disturbing than Recapture, but it does not affect window style options the way Recapture does. Pick your fighter, bestie 🥊

👑 Controlling the Virtual Desktop 👑

Desk arg1 [arg2] [min max]

This command has been renamed. Please go see the GotoDesk command instead, she's the main character now ✨

DesktopName desk name

Defines the name of the desktop number desk to name. This name gets used in the WindowList command and in the FvwmPager, where it overrides the Label configuration option. And plot twist — if consecutive names starting from desktop 0 are defined, then those names can be used by any EWMH compliant application (as a pager). The range, she is wide 💅

DesktopSize HorizontalxVertical

Defines the virtual desktop size in units of the physical screen size. Big desktop energy 📐

EdgeResistance delayEdgeResistance scrolling moving [xinerama-scrolling]

This one tells you 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. It's intended for the girlies who use

EdgeScroll 100 100

but keep finding themselves accidentally flipping pages when they do not want to 😭 If -1 is given as the delay, scrolling is disabled completely. No accidental page flips, periodt.

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. She's got your back 🫶

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.

Now for the wrapping lore: 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. And if

EdgeScroll 100000 100000

is used, fvwm scrolls by whole pages, wrapping around at the edge of the desktop. Circular queen behavior 🌈

EdgeThickness 0 | 1 | 2

This is the width or height of the invisible window that fvwm creates on the edges of the screen, used for the edge scrolling feature.

So here's the thing, bestie — in order to enable page scrolling via the mouse, four windows called the "pan frames" are placed at the very edge of the screen. That's 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 they 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) you 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 — then clicks on the window, near the edge of the screen, are treated as clicks on the root window. Awkward 💀

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 on top of 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. Boundaries but make it aesthetic ✨

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. Dynamic desktop math, we love to see it 📊

GotoDesk [prev | arg1 [arg2] [min max]]

Switches the current viewport to another desktop (workspace, room). Travel era ✈️

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. Take me back 🥺

Now the logic, step by step:

  • 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). Stay in your lane, numbers 💅

The syntax is the same as for MoveToDesk, which moves a window to a different desktop. Sibling commands, matching energy 🫶

The number of active desktops is determined dynamically. Like, fvwm doesn't keep a fixed roster, bestie — only desktops that actually contain windows or are currently being displayed count as active. Desktop numbers must be between 2147483647 and -2147483648 (is that enough? 😭 honestly queen, sure).

GotoDeskAndPage prev | desk xpage ypage

Switches the current viewport to another desktop and page at the same time — basically GotoDesk and GotoPage holding hands 🫶. 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 you specified in the DesktopSize command. Lower left is (0,N), lower right is (M,N), and N is the desktop's vertical size as specified in DesktopSize. To switch to a page relative to the current one, just add a trailing p after either or both numerical arguments. Sneaky and iconic 💅

Possible options are wrapx and wrapy, which wrap around the x or y coordinate when the viewport gets moved past the border of the desktop.

Wanna bounce back to the last page you visited? Use prev as the first argument. Heads up though:

The GotoPage function should not be used in a pop-up menu.

Examples, because we love a visual:

# 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, if you'd rather, kicks off interactive scrolling of the viewport. Either or both entries can be negative, no judgement 💖. Both the horizontal and vertical values are expressed in percent of pages, so:

Scroll 100 100

means scroll down and right by one full page. And:

Scroll 50 25

means scroll right half a page and down a quarter of a page. Also, real talk:

The Scroll function should not be called from pop-up menus.

Normally, scrolling stops at the edge of the desktop. But 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. So if

Scroll 100000 0

gets 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 gets hit in turn. Slay, honestly ✨

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 goes in the opposite direction of the mouse movement, and without it, scrolling goes in the same direction as the mouse.

So this binding:

Mouse 1 A CM Scroll reverse

gives you the effect of grabbing and dragging the viewport with button 1 if Control and Meta are pressed. Main character drag energy 👑

Xinerama [bool]

Enables Xinerama support if the boolean argument is true, and disables it if the argument is false. Calling this command with no arguments toggles: turns Xinerama support on if it was disabled before, and off if it was enabled. Like so:

# 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's gonna 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's zero or more is taken as the primary screen's number. Instead, the letter c says to use the current screen (the one containing the pointer) whenever the primary screen is used — which, ngl, 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 — like Single Logical Screen — it's 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 integer values dividing evenly into the total desktop width and height. For an example with two monitors side by side that 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 that number of screen-spec arguments. Each of those 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. Proceed with vibes at your own risk.
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's the vibe:

AddToFunc Move-or-Raise I Raise
 + M Move
 + D Lower

The function name is "Move-or-Raise", and you could invoke it from a menu, or a mouse binding, or a 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 — and, lowkey, this behavior may also change in the future without further notice. The letter before the action tells what kind of action triggers the command that 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's a whole bunch of predefined symbols that get replaced by certain values if they appear on the command line. Please refer to the Command Expansion section for the deets 📖

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

Examples time ✨ 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 the right mouse button within window button number 6 (that's 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. That's it, that's the command 🔔 iconic, no notes.

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 an fvwm session. The function can be rebuilt using AddToFunc. Glow-up via deletion, periodt.

DestroyFunc PrintFunction

Echo string

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

Echo Beginning style definitions...

okay bestie, we're deep in the command mines now — grab a snack, hydrate, and let's go 💖

  • EchoFuncDefinition function — it's giving Echo's cooler cousin. It prints the definition of the function you name, but it sends it to stderr instead of wherever Echo goes. Super handy when you wanna peek at how fvwm handles quoting, and honestly? Debugging functions with this is chef's kiss. 🎀
  • Exec command — runs command. Do NOT slap an ampersand & at the end of it, bestie, I'm begging. You probably want an extra "exec" at the front of command. Why? Because without it, the shell that fvwm spins up to run your command just... sits there until the command exits. Which means you end up with literally twice as many processes running as you actually need. 😭 Some shells are smart enough to dodge that, but honestly, adding the "exec" never hurts. So just add it. Periodt.

Here's the vibe: this binds function key F1 in the root window, no modifiers, to the exec function, and launches rxvt with a whole lil assortment of options.

    Key F1 R N Exec exec rxvt -fg yellow -bg blue \
      -e /bin/tcsh

Heads up though — this function does not wait for command to finish. So stuff like this:

    Exec "echo AddToMenu ... > /tmp/file"
    Read /tmp/file

does not work reliably. Not a vibe. Go look at the PipeRead command instead. ✨

  • ExecUseShell [shell] — makes Exec use the shell you specify, or the value of the $SHELL environment variable if you don't specify one, instead of the default Bourne shell (/bin/sh). Iconic customisation moment.
    ExecUseShell
    ExecUseShell /usr/local/bin/tcsh
  • Function FunctionName — this is how you bind a function you already defined earlier to a key or a mouse button. Look at this: it binds mouse button 1 to a function called "Move-or-Raise", whose definition was given as an example earlier in this man page. After you do this binding, fvwm runs the "move-or-raise" function every single time button 1 gets pressed in a window's title-bar. Slay.
    Mouse 1 T A Function Move-or-Raise

Fun lil shortcut: the keyword Function can be omitted entirely if FunctionName doesn't happen to coincide with an fvwm command. 🦋

Warning: please actually read the comments on executing complex functions in the section Scripting and Complex Functions. Like, for real. Don't skip it.
  • InfoStoreAdd key value — stores value at the given key. This is the move for storing generic info that lives for the lifetime of an fvwm config file — think, like, storing program preferences for opening video files. 🍓

The whole point of this command is to stash internal information inside fvwm that fvwm functions can use, or that can be used when opening programs of a certain type. Before this existed, the only way to do it was via SetEnv, but that's discouraged now because it shoves all that info into the environment — which pollutes it, makes the info global to other processes started by fvwm, and those processes might then go and modify them, which might not be what you wanted at all. So yeah: InfoStoreAdd still lets you store the info, but keeps it internal to fvwm. Main character behaviour. 👑

You can build up as many key/value pairs as you need. Getting the value back out of a given key happens through fvwm's usual expansion mechanism — go read the Command Expansion section for the deets. Example time:

        InfoStoreAdd teddybearprog xteddy

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

When you wanna remove an entry from the InfoStore, that's the InfoStoreRemove command's whole job.

  • InfoStoreRemove key — removes the entry at the given key from the InfoStore. Example:
    InfoStoreRemove teddybearprog
  • Nop — does absolutely nothing. An icon. A legend. A moment of rest. Its whole purpose in life is inserting a blank line or a separator into a menu. If the menu item specification looks like
    AddToMenu MyMenu " " Nop

then a blank line gets inserted. And if it looks like

    + "" Nop

then a separator line gets inserted. It can also be used as the double-click action for Menu or Popup. Versatile queen. 💅

  • PipeRead command [quiet] — makes fvwm read commands straight from the output of command. That command gets executed by /bin/sh, exactly as if you'd typed it on the command line. If command is more than one word, it must be quoted. This is the go-to for building dynamic menu entries based on a directory's contents, for example. And if the keyword Quiet follows the command, no message gets produced when the command isn't found. 🙈

Example:

    AddToMenu HomeDirMenu
    PipeRead 'for i in $HOME/*; \
      do echo "+ $i Exec xterm -e vi $i"; done'
Note: by default, PipeRead changes the pointer to a watch cursor while it's executing. But some commands — xwd, for instance — need to take control of the pointer themselves and just do not work with that. To disable the watch cursor, run this command before the PipeRead:
    BusyCursor Read off

PipeRead executes synchronously. So if you wanna Exec something but you need that command to run synchronously, you might do something like:

    PipeRead 'command 1>&2'

That redirection sends any output from the program off to stderr instead of letting fvwm read it as a sequence of commands. And for the record: PipeRead returns 1 if the given command could be executed, or -1 if it couldn't. (See the section Conditional Commands for what those return codes actually mean. 🌈)

  • Read filename [quiet] — makes fvwm read commands from the file named filename. If the keyword Quiet follows the command, no message is produced when the file isn't found. If the file name doesn't begin with a slash (/), fvwm goes looking in the user's data directory first, then the system data directory. The user's data directory is $HOME/.fvwm by default, but you can override it by exporting FVWM_USERDIR set to any other directory you like. Read returns 1 if the given file could be read, or -1 if not. (Again: Conditional Commands section for the return-code lore. 💜)
  • SetEnv variable value — sets an environment variable to a new value, just like the shell's export or setenv command. The variable and its value get inherited by processes started directly by fvwm. This is especially useful when you're pairing up 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 has whitespace in it, enclose it in quotes — no exceptions. And if you give no value at all, the variable gets deleted. 💀

  • Silent command — okay so a bunch of commands need a window to operate on. If no window was selected when one of those functions gets invoked, the user gets asked to pick a window. Sometimes that's just... not the vibe — say, the function was called by a module and the window that was selected at first doesn't exist anymore. You prevent all that by putting Silent in front of the fvwm command. If a function that needs a window is called with Silent and there's no window selected, it simply returns without doing anything. And 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: paired with the binding commands Key, PointerKey and Mouse, it disables error messages. 😌

Silent also disables the error message for non-existent commands. Note: this command is treated as a prefix to its command, and expansion of the command line is done as if Silent wasn't 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] — unsets an environment variable, just like the shell's export or unsetenv command. The variable then gets removed from the environment array that's inherited by processes started directly by fvwm. Gone. Poof. ✨
  • Wait window — this one is meant to be used in fvwm functions only, bestie, don't get any ideas. It pauses the execution of a function until a new window matching window shows up. That window can be a window's name, class, or resource string, and it may contain the wildcards '*' and '?', which get matched in the usual Unix filename manner. This is especially useful in the "InitFunction" when you're 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

So what's happening here: that function starts an xterm on the current desk, waits for it to map itself, then switches to desk 2 and starts an xmh. Once the xmh window appears, control moves to desk 0. 🎀

Fvwm stays partially functional during a wait — but any input from the modules gets queued up and only processed after the window appears or the command gets aborted. For example, windows cannot be focused with FvwmIconMan or FvwmPager during a wait. So like, don't try it.

If you need to escape from a Wait pause, press Ctrl-Alt-Escape (where Alt is the first modifier). Wanna redefine that key sequence? Go see the EscapeFunc command. 🦋

🌸 Conditional Commands 🌸

Conditional commands are commands that only get executed if certain conditions are met. Most of them work on windows — think Next, ThisWindow or All. There's exactly one conditional command, Test, that works on global conditions completely unrelated to windows. The syntax of the conditions is described below, and for readability's sake, the list of conditions lives at the end of this section. 🫶

and that's where we pause, bestie — more chaos incoming in the next part, don't go anywhere 💖

💖 Return Codes 💖

Okay bestie, this is the part where things get juicy — every command in this section has a vibe check it hands back, and that's the return code. Unless a command specifically says otherwise, it's 1 if the condition was met and 0 if it wasn't. Some commands might hit you with -1, which literally means an error happened and the return code is useless (rip). The Break command is special and returns -2. ✨

Also, the return codes of commands run in complex functions get passed up to the invoking complex function. The return code is what the TestRc command reads, so go check each command's description for examples. You can also grab it through the variable $[cond.rc]. 🎀

Non conditional commands do not modify the return code of the last conditional command. And important note, fr fr: return codes are only defined inside functions created with the AddToFunc command and are not inherited by sub functions. If you wanna run a command without messing up the return code, use the KeepRc command. 🫶

🌸 The Ring of Windows 🌸

Fvwm keeps windows in a ring internally, and like… think of the focused window as a cursor sitting on the current position in that ring. The Next command and a whole bunch of other commands search forwards through the ring looking for a matching window, and Prev searches backwards. 💅

The windows in the ring are either ordered by creation time (this happens if the !FPSortWindowlistByFocus, NeverFocus or MouseFocus styles are used) or by the last time they had the focus. That's it, that's the whole vibe. 🌈

🦋 List of Conditional Commands 🦋

All

All [options] [(conditions)] command

Runs command on every single window that meets 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 Reverse option is given, the execution order is reversed. The UseStack option 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

Any [(conditions)] command

Performs command if any window that satisfies all the conditions exists. The command is run in the context of the root window. See the Conditions section for a list of conditions. ✨

Break

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. You can hand it an optional integer number levels to break out of that 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

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

Direction [FromPointer] direction [(conditions)] command

Performs command (typically Focus) on a window in the given direction that 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. If there's no such window, or when the FromPointer option is given, the current position of the pointer is the starting point. 🧭

The direction may be one of "North", "Northeast", "East", "Southeast", "South", "Southwest", "West", "Northwest" and "Center". Which window Direction picks depends on angle and distance between the center points of the windows. Closer windows are considered a better match than ones 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

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

Next [(conditions)] command

Performs command (typically Focus) on the next window that 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

None [(conditions)] command

Performs command if no window that 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

NoWindow command

Performs command, but removes the window context if there is 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 a menu is bound to window decorations. 🪟

Pick

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

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

Prev [(conditions)] command

Performs command (typically Focus) on the previous window that 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

ScanForWindow [FromPointer] dir1 dir2 [(conditions)] command

Performs command (typically Focus) on a window in the given direction that 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. If there's no such window, or when the FromPointer option is given, the current position of the pointer is 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 [(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.

okay so continuing the test-condition lineup, bestie, we got a few more of these 💖

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.

Also, real talk — if a test-condition name is not recognized, the Error return code is set and the command is not executed. No silent vibes, just an error. 🙈

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

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

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. Heads up though — 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, no cap 🫶).

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. literally so convenient 🌈

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. iconic behaviour tbh 👑

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 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. 🫣 deprecated, so, yk.

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.

  • CurrentGlobalPage — only matches windows chillin' on the current page of the current desk. That's it, that's the whole vibe. Doesn't matter whether Xinerama support is on or off. Lowkey this condition auto-activates the CurrentDesk condition too, sneaky like that. ✨
  • CurrentGlobalPageAnyDesk — only matches windows on the current page of any desk, again regardless of whether Xinerama support is enabled or not. 🌈
  • CurrentPage — only matches windows 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 where your mouse pointer is hanging out. This one also implicitly activates the CurrentDesk condition. 💅
  • CurrentPageAnyDesk and CurrentScreen — both match only windows on the current page of any desk. If Xinerama support is enabled, they only match windows at least partially on the Xinerama screen containing the mouse pointer. 🖱️
  • Screen [n] — only matches windows that live on the specified Xinerama screen. 📺
  • Desk [n] — only matches windows that live on the specified desk. 🗂️
  • FixedPosition — excludes every window that doesn't have a fixed position, whether that got set through WM hints or via the Style option FixedPosition. Example, bestie:
    DestroyFunc ToggleFixedGeometry
    AddToFunc   ToggleFixedGeometry
    + I Pick (FixedPosition) \
         WindowStyle VariablePosition, VariableSize
    + I TestRc (NoMatch) WindowStyle FixedPosition, FixedSize
  • FixedSize — excludes every window that doesn't have a fixed size, again either set through WM hints or the Style option FixedSize. 📐
  • Focused — matches on the window that currently has the keyboard focus. ngl this one's not useful for the Current command, but you can use it with the other conditional commands. 👑
  • HasHandles — excludes all windows that don't have resize handles. 🎀
  • HasPointer — excludes all windows that don't contain the pointer. 🖱️
  • Iconic — matches only iconic windows. (Iconified = smol = iconic, literally.) 😌
  • Iconifiable — matches only windows that are allowed to be iconified. 🙈
  • Layer [n] — matches only windows on the specified layer. The optional argument defaults to the layer of the focused window. And the negation !Layer switches the Layer condition off. 🧅
  • Maximizable — matches only windows that are allowed to be maximized. 🔥
  • Maximized — matches only maximized windows. 📏
  • Fullscreen — matches only fullscreen windows. 🖥️
  • Overlapped — matches only windows that are overlapped by other windows on the same layer (or by unmanaged windows, if the RaiseOverUnmanaged option of the BugOpts command is in play). ⚠️ Heads up: this condition can be slow if you've got a ton of windows open, or if RaiseOverUnmanaged is used and the connection to the X server is slow. Like, she's doing her best but she's working hard for it. 💀
  • PlacedByButton n — this one's fulfilled if the last interactive motion of the window (via the Move command, or as ManualPlacement) was ended by pressing mouse button n. Example time:
    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
  • PlacedByButton3 — same meaning as PlacedByButton 3. It's only still here for backward compatibility, so don't get too attached. 🫶
  • PlacedByFvwm — excludes all windows that have been placed manually, or by using the user or program position hint. 🚫
  • Raised — matches only windows that are fully visible on the current viewport and not overlapped by any other window. 🌟
  • Shaded — matches only shaded windows (peep the WindowShade command). 🎏
  • State n or !State n — match only windows with the specified integer state set (or unset). Check the State command for the details. The argument may range from 0 to 31. 🔢
  • Sticky, StickyAcrossDesks and StickyAcrossPages — match only windows that are currently sticky, sticky across all desks, or sticky across all pages respectively. Go read the Style options with the same names, plus the Stick, StickAcrossDesks and StickAcrossPages commands for the full tea. 🍯
  • StickyIcon, StickyAcrossDesksIcon and StickyAcrossPagesIcon — match only windows that become sticky, sticky across all desks, or sticky across all pages when they're in the iconified state. 🧲
  • Transient — matches only windows that have the "transient" property set by the application. This is usually the case for application popup menus and dialogs. You can use the FvwmIdent module to find out whether a specific window is transient. 🔍
  • Visible — matches only windows that are at least partially visible on the current viewport and not completely overlapped by other windows. 👀

🧩 Module Commands

Fvwm keeps a whole database of module configuration lines, formatted like this:

*<ModuleName>: <Config-Resource>

where <ModuleName> is either a real module name or an alias. 💖

This database starts out filled from the config file (or from the output of the -cmd config command), and it can get modified later — either by the user (via FvwmCommand) or by modules themselves. ✨

When modules are run, they read the appropriate portion of the database. (The whole concept here is similar to the one used in the X resource database, iykyk.) 🗃️

The commands for manipulating this module configuration database are described below, bestie. 👇

  • * module_config_line — defines a module configuration. module_config_line consists of a module name (or a module alias) plus 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, and 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 is also sometimes the only way to turn back some module settings that were previously defined. It 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 that 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, that should be spawned. Currently several modules — including FvwmButtons, FvwmEvent, FvwmForm, FvwmPager and FvwmScript — support aliases. Aliases are useful if more than one instance of the module should be spawned. Aliases may be configured separately using the * 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 there as well. 🌈

Modules can be short lived transient programs, or — like FvwmButtons — they can stick around 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] — works like the Module command, but fvwm never sends any messages to the module. This may be handy for writing a module as a shell script that gets triggered by external events, without the burden of having 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, which lets you easily append or prepend to the path. 🎀

For example:

    ModulePath ${HOME}/lib/fvwm/modules:+

The directory holding the standard modules is available via the environment variable $FVWM_MODULEDIR. 🫶

  • ModuleSynchronous [Expect string] [Timeout secs] modulename — bestie this one is so similar to Module, but with a ✨plot twist✨: fvwm full-on stops processing any commands and user input until the module sends back a string that starts with "NOP FINISHED STARTUP". If you pass the optional Timeout, fvwm gives up when the module hasn't sent anything back for secs seconds. If you pass Expect, fvwm waits for that string instead. ModuleSynchronous should only ever be used during fvwm startup, to force the order modules start in. It's made for that (currently hypothetical 👀) module that has to be up before the other modules launch.
Warning: it is genuinely quite easy to hang fvwm with this command, even when you give a timeout. Be extra careful picking the string to wait for. All the modules in the fvwm distribution do send back the "NOP FINISHED STARTUP" string once they've properly started up, but third-party modules might not. Also, you can try to escape a locked ModuleSynchronous command with the key sequence Ctrl-Alt-Escape (check the EscapeFunc). 😭
  • ModuleTimeout timeout — tells fvwm how many seconds it waits for a module to respond. If the module doesn't respond in time, fvwm kills it. timeout must be greater than zero, otherwise it gets 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 matches modulename, which may contain wildcards. This only makes sense if the module is actually set up to understand and deal with those strings though. Great for module-to-module communication, or for building more complex commands inside modules. 💌

🛋️ Session Management Commands

  • Quit — exits fvwm, which generally makes X exit too. bye bestie 💅
  • QuitScreen — makes fvwm stop managing the screen where the command was issued.
  • Restart [window_manager [params]] — makes fvwm restart itself if window_manager is left blank, or switch to an alternate window manager (or another fvwm version) if window_manager is specified. If the window manager isn't in your default search path, use the full path name for window_manager.

This command should not have a trailing ampersand. It can take optional parameters with a simple shell-like syntax. You can use ~ (expanded to the user's home directory) and environment 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 using the Restart command without parameters unless there's a reason not to. If you still use the old command 'Restart fvwm2' that was correct back in 2.2.x, all current command line arguments are lost. On a restart without parameters, or with --pass-args, they're preserved. Here are some cases where '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 issue a warning on the old usage. If you really want to restart to fvwm with no additional arguments, you can get rid of the 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, except the name for the current window manager is replaced with the specified window_manager and the 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 those 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 there is one) to save the session. This command does not work for xsm; it seems xsm does not implement this functionality. Use Unix signals to manage xsm remotely. 😭
  • SaveQuitSession — causes a session manager (if there is any) to save and then shut down the session. This command does not work for xsm either; it seems xsm does not implement this functionality. Use Unix signals to manage xsm remotely.

🎨 Colorsets

Colorsets are a powerful method to control colors. They create appearance resources shared by fvwm and its modules. When a colorset is modified, every part of fvwm reacts to that change — it's giving main character energy fr fr. A colorset includes a foreground color, background color, shadow and highlight color (often based on the background color), and a background face (which includes images and all kinds of gradients). There's a way to render the 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 into the core of fvwm, so that module became obsolete. In 2.6.7 the FvwmTheme module was removed. 👑 (she's gone, bestie)

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

  • 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. So if you define 'Colorset 100000', the memory for 100001 colorsets gets 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 more colors and don't want to reinvent the wheel, you may use the convention from fvwm-themes — it defines the meaning of the first 40 colorsets for nearly all purposes:

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

Every colorset has four colors, an optional pixmap and an optional shape mask. The four colors get used by modules as the foreground, background, highlight and shadow colors. When a colorset is created it defaults to a foreground of black and a 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 pick a color that contrasts well with the background color. To reset the foreground color back 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 those have been explicitly set with the options below. The special name Average may be used to pick a color that's the average color of the pixmap. If the pixmap is tinted with the Tint option, the tint is not taken into account when computing the average color. You should use the bgTint option to get the "real" average color. The background color gets 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 isn't 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 isn't 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, AspectPixmap — these besties take a file name as their argument, go hunting through the ImagePath, and then use whatever they find as the background pixmap. 💖 Any transparent bits get filled in with the background color, no drama. If you don't give a file name at all, it just removes whatever image the colorset already had. Now the tea on how each one places the image: TiledPixmap makes repeated copies with no scaling whatsoever, Pixmap stretches that image to fit literally whatever object the colorset is applied to, and AspectPixmap stretches to fit too but keeps the image's aspect ratio intact (so nothing gets squished, thank u). ✨
  • Transparent — makes a transparent background pixmap. This pixmap is used as a window background to achieve root transparency. 🌈 For this you should use the ParentalRelativity option to the Style command. Now listen, a subsequent root background change may be detected or it may not — it fully depends on the program you 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) then a background change is detected. 🎀 But if background changes are not detected (like, say, 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
Okay so real talk: because of the way X implements transparency, no guarantees can be made that the desired effect can even be achieved. 😭 The application may even crash. If you experience any problems with this option — do not use it. Periodt.

Using outline move and resize (peep the OpaqueMoveSize command and the ResizeOpaque Style option) as well as setting the WindowShadeShrinks style may help. 💅 The transparency you get 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 the colorset is defined on. For example:

Colorset 12 VGradient 200 grey30 grey60
Colorset 17 Transparent
*FvwmIconMan: Colorset 12
*FvwmIconMan: PlainColorset 17

...gives you 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 literally drawing nothing. 🤯 Now if this IconMan gets swallowed into an FvwmButtons like:

FvwmButtons:(Colorset 10, Swallow "FvwmIconMan" 'FvwmIconMan')

...then FvwmIconMan becomes a child of FvwmButtons and it's transparent relative to FvwmButtons. So in this case FvwmIconMan uses Colorset 10 as its background. If you want root transparency, use the RootTransparent option instead. 🫶

FvwmButtons, FvwmIconMan, and FvwmIdent are relatively simple — there's one main colorset option that defines the background of the window, and the other colorsets (if there are any) are drawn on the foreground. 💜 The case of FvwmProxy is simpler still: the two colorsets refer to the window backgrounds. FvwmPager is more complicated, because almost everything in the pager is windows with some parental relations (the mini windows are the child, the desktops are the parents, and all of this is complicated by the highlighted page 🙈). So the colorsets apply to the background of these windows. You should experiment. For FvwmForm and FvwmScript the situation is similar: there's a main window (a child of the root window) which corresponds to the main colorset, and most of the widgets are windows that are children of the main window.

Tint may work or may not work 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 that's the case). There's 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. For this option to 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. It speeds up creation of windows which use the colorset (super 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, AspectShape — these take a file name as an argument, search the ImagePath, and use it as the shape bitmap. TiledShape makes repeated copies of the bitmap with no scaling, Shape stretches the bitmap to fit whatever object the colorset is applied to, and AspectShape stretches to fit but keeps the bitmap's 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 💀 Because of the way X11 implements shapes, you cannot take back making windows shaped. You may have to restart fvwm or the shaped application. No cap.
  • ?Gradient ... — creates a pixmap and stretches it to fit the window. The ?Gradient can be one of HGradient, VGradient, DGradient, BGradient, SGradient, CGradient, RGradient or YGradient. Here's the vibe check on each gradient type: 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's 100 the image is displayed as usual (no merge). The default is 100, and it's 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's 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's 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 than you actually have. 🤯
  • NoDither — causes fvwm to 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's restored if no argument is given. 🌸

Note: it's literally equivalent to use Tint a_color rate and Alpha a when a = 100 and the bg color is a_color. ✨ But heads up bestie — this equivalence does not hold for IconAlpha and IconTint, because the background there can be an image or a gradient (and not a uniform color background). That said, sometimes you can get (almost) the same effect by using IconTint in place of IconAlpha. Do that if you can, it's preferable — generally, IconAlpha generates way 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 it needs to, this creates colorsets 0, 1, 2 and 3, and then changes colorset 3 to have a foreground of tan and a background of navy. 🎀

Colorset 3 bg "navy blue"

Changes the background color of colorset 3 to navy blue. The foreground and pixmap stay untouched, no cap.

Colorset 3 AspectPixmap large_murky_dungeon.xpm

Causes depression. 💀 (fr fr, that's what it says.)

Colorset 3 bg Average

Sets the background color and the relief colors to match the background pixmap. This is the default setting, but you must use it 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 gets recomputed, along with the foreground if that's 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. 🦋 iconic.

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. 💖 (shoutout to the whole group chat, honestly.)

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

And that's a wrap on the whole thing, bestie — every last crumb of it. 🌸 This page was dated 19-Oct-2022, and it's the FVWM(1) man page, so that's the version and date energy we're closing out on. Go forth and configure your window manager, you absolute main character. 💅🎀✨

📦 where this page comes from