fvwm3-1.0.6a/0000755000175000017500000000000014361325136012253 5ustar jaimosjaimosfvwm3-1.0.6a/doc/0000755000175000017500000000000014361325136013020 5ustar jaimosjaimosfvwm3-1.0.6a/doc/FvwmAuto.adoc0000644000175000017500000001150114354105651015416 0ustar jaimosjaimos= FvwmAuto(1) :doctype: manpage :mantitle: FvwmAuto :manname: FvwmAuto :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmAuto - the fvwm auto-raise module == SYNOPSIS .... Module FvwmAuto Timeout [-passid] [-menter|-menterleave|-mfocus] [EnterCommand [LeaveCommand]] .... _FvwmAuto_ can only be invoked by fvwm. Command line invocation of the _FvwmAuto_ will not work. == DESCRIPTION The _FvwmAuto_ module is most often used to automatically raise focused windows. == INVOCATION The correct syntax is: .... Module FvwmAuto Timeout [-passid] [-menter|-menterleave|-mfocus] [EnterCommand [LeaveCommand]] AddToMenu Modules + "Auto Raise (300 ms)" Module FvwmAuto 300 + "Auto Raise/Lower" Module FvwmAuto 300 "Silent Raise" "Silent Lower" .... The _Timeout_ argument is required. It specifies how long a window must retain the keyboard input focus before the command is executed. The delay is measured in milliseconds, and any integer greater than zero is valid. If the literal option _-passid_ is given, the window id of the window just entered or left is appended to the command that is sent to fvwm. This can be used with the *WindowId* command of fvwm. The options _-menter_, _-menterleave_ and _-mfocus_ influence the actions FvwmAuto reacts to. No more than one of the options can be chosen. In _-mfocus_ mode, FvwmAuto raises the window that has the focus. In _-menter_ mode, FvwmAuto raises the window under the pointer when the pointer enters a window. The _LeaveCommand_ is executed on the window that was below the pointer before it entered the new window. When the pointer leaves a window and enters the root window, the _EnterCommand_ is executed too, but without a window to operate on. In _-menterleave_ mode, FvwmAuto works just like in _-menter_ mode, but the _LeaveCommand_ is also executed if the pointer moves out of a window but does not enter a new window. The latter two modes of operation are useful with windows that do not accept the focus. Note: -menterleave mode can interfere with popup windows of some applications. One example is the zoom menu of Ghostview. Please do not complain about this to us - it is a bug in Ghostview. _EnterCommand_ and _LeaveCommand_ are optional. _EnterCommand_ is executed _Timeout_ milliseconds after a window gets the input focus, _LeaveCommand_ is executed _Timeout_ milliseconds after the window has lost focus. Note that you always should use the 'Silent' keyword before the command itself. FvwmAuto prepends "Silent " to the command string on its own if yor forget this. Without this prefix fvwm would ask you for a window to act on if the window has died before the command sent by FvwmAuto has been processed by fvwm. This can for example happen with popup menus. "Silent Raise" is the default for _EnterCommand_, but any fvwm function is allowed. I would not use "Close" or "Destroy" with a low timeout, though. The _LeaveCommand_ can be handy for a tidy desktop. Experiment with: .... Module FvwmAuto 0 Nop "Silent Lower" Module FvwmAuto 0 Nop "Silent Iconify" .... An example for auto raising windows with ClickToFocus: .... Style * ClickToFocus FvwmAuto 0 -menter "Silent Raise" .... An example for auto raising and lowering only some windows: .... To start FvwmAuto: FvwmAuto 0 -passid -menter \ "Silent selective_raiselower raise" \ "Silent selective_raiselower lower" .... And put this in your .fvwm2rc: .... AddToFunc selective_raiselower + I WindowId $1 (FvwmIconMan) $0 + I WindowId $1 (FvwmButtons) $0 + IWindowId $1 (xclock) $0 ... .... More complex example (three FvwmAuto's are running): .... DestroyFunc RestoreIconified AddToFunc RestoreIconified + I Current (Iconic) Iconify false DestroyFunc RegisterFocus AddToFunc RegisterFocus + I Exec date +"%T $n focused" >>/tmp/focus-stats.txt DestroyFunc RegisterUnfocus AddToFunc RegisterUnfocus + I Exec date +"%T $n unfocused" >>/tmp/focus-stats.txt KillModule FvwmAuto Module FvwmAuto 250 Raise Nop Module FvwmAuto 800 RestoreIconified Nop Module FvwmAuto 0 RegisterFocus RegisterUnfocus .... == NOTES There is a special Raise/Lower support in FvwmAuto. It was added to improve Raise/Lower callbacks, since most of FvwmAuto usages is auto-raising or auto-lowering. This improvement includes locking on M_RAISE_WINDOW and M_LOWER_WINDOW packets and not raising/lowering explicitly raised windows. The special Raise/Lower support is enabled only when either _EnterCommand_ or _LeaveCommand_ contain substring "Raise" or "Lower". You can use this fact to enable/disable any special support by renaming these commands, if FvwmAuto does not automatically do want you expect it to do. Using _FvwmAuto_ in conjunction with _EdgeCommand_ can be even more powerful. There is a short example in the _fvwm_ man page. == AUTHOR .... FvwmAuto just appeared one day, nobody knows how. FvwmAuto was simply rewritten 09/96, nobody knows by whom. .... fvwm3-1.0.6a/doc/Makefile.am0000644000175000017500000000221214361324762015055 0ustar jaimosjaimosdocdir = @FVWM_DOCDIR@ MODULE_ADOC_SRCS = \ fvwm3.adoc \ fvwm3all.adoc \ fvwm3commands.adoc \ fvwm3_manpage_source.adoc \ fvwm3menus.adoc \ fvwm3styles.adoc \ $(wildcard Fvwm*.adoc) \ $(wildcard fvwm-*.adoc) # If building FvwmPrompt, don't generate the manpage for FvwmConsole as that # won't ever be installed. if FVWM_BUILD_GOLANG MODULE_ADOC = $(filter-out FvwmConsole.adoc, $(MODULE_ADOC_SRCS)) else MODULE_ADOC = $(MODULE_ADOC_SRCS) endif EXTRA_DIST = $(MODULE_ADOC_SRCS) nothing: clean: rm -f *.1 *.ad distclean-local: clean if FVWM_BUILD_MANDOC M1M = $(filter-out fvwm3_manpage_source.adoc, $(MODULE_ADOC)) man1_MANS = $(patsubst %.adoc,%.1, $(M1M)) EXTRACT_SECTIONS = \ commands \ menus \ styles SECTION_FILES = $(patsubst %,fvwm3_%.ad, $(EXTRACT_SECTIONS)) all: docs docs: $(man1_MANS) $(man1_MANS): $(SECTION_FILES) %.ad: fvwm3_manpage_source.adoc SECTION=$(patsubst fvwm3_%.ad,%,$@); \ cat "$<" | \ "$(GREP)" -A 1000000 -- "^// BEGIN '$$SECTION'" | \ "$(GREP)" -B 1000000 -- "^// END '$$SECTION'" | \ "$(GREP)" -v "^// .* '$$SECTION'" > "$@" %.1: %.adoc "$(ASCIIDOC)" -b manpage -a "$(patsubst %.1,%,$@)" "$<" -o "$@" endif fvwm3-1.0.6a/doc/FvwmPager.adoc0000644000175000017500000003633314354105651015556 0ustar jaimosjaimos= FvwmPager(1) == NAME FvwmPager - the Fvwm Pager module == SYNOPSIS *FvwmPager* [ _-transient_ ] [ _name_ ] [ _first desk_ [ _last desk_ ] ] FvwmPager is spawned by fvwm, so no command line invocation will work. All desks with desk numbers between _first desk_ and _last_ desk are displayed. If _last desk_ is omitted only the _first desk_ is shown. If both desk numbers are omitted, the current desk is used instead. If you use an asterisk '*' in place of _first desk_ the pager will always show the current desktop, even when you switch desks. FvwmPager will compute its initial window size based on your monitor(s) configuration. By default it makes a page 1/32 the size of your monitor(s) resolution (see _DeskTopScale_) and matches either the global aspect ratio or a single monitor if _Monitor_ is set. FvwmPager will preserve this aspect ratio when you resize it. See the _Geometry_ option for more info. Example lines to put in your .fvwm2rc: .... Module FvwmPager 0 3 .... or .... Module FvwmPager * .... or from within an fvwm pop-up menu: .... AddToMenu Module-Popup Modules Title + Audio Module FvwmAudio + Auto Module FvwmAuto 200 + Buttons Module FvwmButtons + Console Module FvwmConsole + Ident Module FvwmIdent + Banner Module FvwmBanner + Pager Module FvwmPager 0 3 .... or .... + Pager Module FvwmPager * .... If the pager is started with the _-transient_ option, the next time a button is released the pager is closed. Note that this option does only work if the window style of the pager window is 'sticky' (see the fvwm man page). You should use the 'StaysOnTop' style too. Example: .... Style FvwmPager Sticky, StaysOnTop *FvwmPager: Rows 1 *FvwmPager: Columns 1 Mouse 3 R C Module FvwmPager -transient .... With this in your .fvwm2rc, if you press control and button 3 in the root window the pager pops up under the mouse and while the viewport moves with the mouse. == DESCRIPTION The FvwmPager module shows a miniature view of the Fvwm desktops which are specified in the command line. This is a useful reminder of where your active windows are. Windows in the pager are shown in the same color as their fvwm decorations. The pager can be used to change your viewport into the current desktop, to change desktops, or to move windows around. Pressing mouse button 1 in the pager will cause you viewport to change to the selected page of the selected desk. If you click with button 1 in the desk-label area, you will switch desks but not pages within the desk. Dragging mouse button 2 on a miniature view of a window will cause that window to be move to the location where you release the mouse button, but your viewport will not change. If you drag the window out of the pager and onto your desktop, a full size image of the window will appear for you to place. There is no way to pick up a full size image of the window and move it into the pager, however. Since some mice do not have button 2, I have made provisions to drag windows in the pager by using pressing modifier-1 (usually Alt) and dragging with button 3. Clicking mouse button 3 on a location will cause the viewport to move to the selected location and switch desks if necessary, but will not align the viewport to a page boundary. Dragging button 3 will cause the viewport to move as you drag but not switch desktops, even if the pointer moves to another desktop. With the _*FvwmPager: SloppyFocus_ option the focus is transferred to the window pointed at with the mouse when the pointer is inside the pager. When iconified, the pager will work as a fully functional current desk only pager. Windows and viewports can be moved within the icon of the pager. Users will want to make sure that they have no lines similar to .... Icon "Fvwm Pager" whatever .... in their .fvwm2rc files. == INITIALIZATION During initialization, _FvwmPager_ gets config info from *fvwm*'s module configuration database (see _fvwm_(1), section *MODULE COMMANDS*). To use FvwmPager with several different configurations, you can invoke FvwmPager with an optional parameter, which it will use as its _name_ instead (e.g "Module FvwmPager OtherPager"). OtherPager will then read only the lines in the configuration file starting with "*OtherPager", and not the lines belonging to FvwmPager. This way multiple pager instances may be used. Note: the old way to use the FvwmPager with several different configurations is to link the executable to another name, i.e. .... ln -s FvwmPager OtherPager .... This may work, but this method is not supported. == KEYBOARD FOCUS CONTROL You can direct the keyboard focus to any window on the current desktop by clicking with button 2 on its image in the pager. The window does not need to be visible, but it does need to be on the current page. == INVOCATION The invocation method was shown in the synopsis section == CONFIGURATION OPTIONS *FvwmPager: Geometry geometry:: Completely or partially specifies the pager windows location and geometry, in standard X11 notation. If both width and height are set, FvwmPager will use that size and no longer preserve the aspect ratio when resized. If you wish to maintain an undistorted aspect ratio, you can set one dimension to zero. For example '400x0' will make a 400 pixel wide window whose height matches the aspect ratio and will also preserve aspect ratio when resized. + *Note*: FvwmPager's dimensions will be slightly adjusted to ensure every page shown has the exact same number of pixels. So the actual size may be slightly different than the specified size. *FvwmPager: Rows rows:: Tells fvwm how many rows of desks to use when laying out the pager window. *FvwmPager: Columns columns:: Tells fvwm how many columns of desks to use when laying out the pager window. *FvwmPager: IconGeometry geometry:: Specifies a size (optional) and location (optional) for the pager's icon window. Since there is no easy way for FvwmPager to determine the height of the icon's label, you will have to make an allowance for the icon label height when using negative y-coordinates in the icon location specification (used to specify a location relative to the bottom instead of the top of the screen). *FvwmPager: StartIconic:: Causes the pager to start iconified. *FvwmPager: NoStartIconic:: Causes the pager to start normally. Useful for canceling the effect of the _StartIconic_ option. *FvwmPager: LabelsBelow:: Causes the pager to draw desk labels below the corresponding desk. *FvwmPager: LabelsAbove:: Causes the pager to draw desk labels above the corresponding desk. Useful for canceling the effect of the _LabelsBelow_ option. *FvwmPager: ShapeLabels:: Causes the pager to hide the labels of all but the current desk. This turns off label hilighting. *FvwmPager: NoShapeLabels:: Causes the pager to show the labels of all visible desks. Useful for canceling the effect of the _ShapeLabels_ option. *FvwmPager: Font font-name:: Specified a font to use to label the desktops. If _font_name_ is "none" then no desktop labels will be displayed. *FvwmPager: SmallFont font-name:: Specified a font to use to label the window names in the pager. If not specified, the window labels will be omitted. Window labels seem to be fairly useless for desktop scales of 32 or greater. If _font_name_ is "none" then no window names will be displayed. *FvwmPager: Fore color:: Specifies the color to use to write the desktop labels, and to draw the page-grid lines. *FvwmPager: Back color:: Specifies the background color for the window. *FvwmPager: Hilight color:: The active page and desk label will be highlighted by using this background pattern instead of the normal background. *FvwmPager: HilightPixmap pixmap:: The active page will be highlighted by using this background pattern instead of the normal background. *FvwmPager: DeskHilight:: Hilight the active page with the current hilight color/pixmap. Useful for canceling the effect of the _NoDeskHilight_ option. *FvwmPager: NoDeskHilight:: Don't hilight the active page. *FvwmPager: WindowColors fore back hiFore hiBack:: Change the normal/highlight colors of the windows. _fore_ and _hiFore_ specify the colors as used for the font inside the windows. _back_ and _hiBack_ are used to fill the windows with. *FvwmPager: WindowLabelFormat format:: This specifies a printf() like format for the labels in the mini window. Possible flags are: %t, %i, %c, and %r for the window's title, icon title, class, or resource name, respectively. The default is "%i". *FvwmPager: DeskColor desk color:: Assigns the color _color_ to desk _desk_ (or the current desk if desk is "*") in the pager window. This replaces the background color for the particular _desk_. This only works when the pager is full sized. When Iconified, the pager uses the color specified by *FvwmPager: Back. + *TIP:* Try using *FvwmPager: DeskColor in conjunction with FvwmCpp (or FvwmM4) and FvwmBacker to assign identical colors to your various desktops and the pager representations. *FvwmPager: Pixmap pixmap:: Use _pixmap_ as background for the pager. *FvwmPager: DeskPixmap desk pixmap:: Assigns the pixmap _color_ to desk _desk_ (or the current desk if desk is "*") in the pager window. This replaces the background pixmap for the particular _desk_. + *TIP:* Try using *FvwmPager: DeskPixmap in conjunction with FvwmCpp (or FvwmM4) and FvwmBacker to assign identical pixmaps to your various desktops and the pager representations. *FvwmPager: DeskTopScale number:: If the geometry is not specified, then a desktop reduction factor is used to calculate the pager's size. Things in the pager window are shown at 1/_number_ of the actual size. *FvwmPager: MiniIcons:: Allow the pager to display a window's mini icon in the pager, if it has one, instead of showing the window's name. *FvwmPager: MoveThreshold pixels:: Defines the distance the pointer has to be moved before a window being dragged with button 2 is actually moved. The default value is three pixels. If the pointer moved less that this amount the window snaps back to its original position when the button is released. If _pixels_ is less than zero the default value is used. The value set with the _MoveThreshold_ command in fvwm is inherited by FvwmPager but can be overridden with this option. *FvwmPager: SloppyFocus:: If the SloppyFocus option is used, you do not need to click into the mini window in the pager to give the real window the focus. Simply putting the pointer over the window inside the pager is enough. + Note: This option interferes slightly with the MouseFocus and SloppyFocus styles of fvwm. Sometimes, if you click into the pager window to change pages or desks and then move the pointer to a place on the screen where a window of the new page will appear, this new window does not get the input focus. This may happen if you drag the pointer over one of the mini windows in the pager. There is nothing that can be done about this - except not using SloppyFocus in the pager. *FvwmPager: SolidSeparators:: By default the pages of the virtual desktop are separated by dashed lines in the pager window. This option causes FvwmPager to use solid lines instead. *FvwmPager: NoSeparators:: Turns off the lines separating the pages of the virtual desktop. *FvwmPager: Balloons [type]:: Show a balloon describing the window when the pointer is moved into a window in the pager. The default format (the window's icon name) can be changed using BalloonStringFormat. If _type_ is _Pager_ balloons are just shown for an un-iconified pager; if _type_ is _Icon_ balloons are just shown for an iconified pager. If _type_ is anything else (or null) balloons are always shown. *FvwmPager: BalloonFore color:: Specifies the color for text in the balloon window. If omitted it defaults to the foreground color for the window being described. *FvwmPager: BalloonBack color:: Specifies the background color for the balloon window. If omitted it defaults to the background color for the window being described. *FvwmPager: BalloonFont font-name:: Specifies a font to use for the balloon text. Defaults to _fixed_. *FvwmPager: BalloonBorderWidth number:: Sets the width of the balloon window's border. Defaults to 1. *FvwmPager: BalloonBorderColor color:: Sets the color of the balloon window's border. Defaults to black. *FvwmPager: BalloonYOffset number:: The balloon window is positioned to be horizontally centered against the pager window it is describing. The vertical position may be set as an offset. Negative offsets of _-n_ are placed _n_ pixels above the pager window, positive offsets of _+n_ are placed _n_ pixels below. Offsets of -1 and 1 represent the balloon window close to the original window without a gap. Offsets of 0 are not permitted, as this would permit direct transit from pager window to balloon window, causing an event loop. Defaults to +3. The offset will change sign automatically, as needed, to keep the balloon on the screen. *FvwmPager: BalloonStringFormat format:: The same as _*FvwmPager: WindowLabelFormat_, it just specifies the string to display in the balloons. The default is "%i". *FvwmPager: Colorset desk colorset:: Tells the module to use colorset _colorset_ for _desk_. If you use an asterisk '*' in place of _desk_, the colorset is used on all desks. *FvwmPager: BalloonColorset desk colorset:: Tells the module to use colorset _colorset_ for balloons on _desk_. If you use an asterisk '*' in place of _desk_, the colorset is used on all desks. *FvwmPager: HilightColorset desk colorset:: Tells the module to use colorset _colorset_ for hilighting on _desk_. If you use an asterisk '*' in place of _desk_, the colorset is used on all desks. *FvwmPager: WindowColorsets colorset activecolorset:: Uses colorsets in the same way as *FvwmPager: WindowColors. The shadow and hilight colors of the colorset are only used for the window borders if the *FvwmPager: Window3DBorders is specified too. *FvwmPager: WindowMinSize n:: Specifies the minimum size as _n_ pixels of the mini windows. This does not include the width of the border, so the actual minimum size is 2 * _WindowBorderWidth_ + _WindowMinSize_. The default is 3. *FvwmPager: WindowBorderWidth n:: Specifies the width of the border drawn around the mini windows. This also affects the minimum size of the mini windows, which will be 2 * _WindowBorderWidth_ + _WindowMinSize_. The default is 1. *FvwmPager: HideSmallWindows:: Tells FvwmPager to not show windows that are the minimum size. Useful for tiny pagers where small windows will appear out of place. *FvwmPager: Window3DBorders:: Specifies that the mini windows should have a 3d borders based on the mini window background. This option only works if *FvwmPager: WindowColorsets is specified. *FvwmPager: UseSkipList:: Tells FvwmPager to not show the windows that are using the WindowListSkip style. *FvwmPager: Monitor RandRName:: Tells FvwmPager to display windows only on _RandRName_ monitor. This is especially meaningful when the _DesktopConfiguration_ command is set to _per-monitor_. == AUTHOR Robert Nation + DeskColor patch contributed by Alan Wild + MiniIcons & WindowColors patch contributed by Rob Whapham + Balloons patch by Ric Lister + fvwm-workers: Dominik, Olivier, Hippo and others. fvwm3-1.0.6a/doc/FvwmPerl.adoc0000644000175000017500000003663314354105651015425 0ustar jaimosjaimos= FvwmPerl(1) == NAME FvwmPerl - the fvwm perl manipulator and preprocessor == SYNOPSIS FvwmPerl should be spawned by _fvwm_ (1) for normal functionality. To run this module, place this command somewhere in the configuration: Module FvwmPerl [params] or: ModuleSynchronize FvwmPerl [params] if you want to immediately start to send commands to FvwmPerl. == DESCRIPTION This module is intended to extend fvwm commands with the perl scripting power. It enables to embed perl expressions in the fvwm config files and construct fvwm commands. == INVOCATION If you want to invoke the unique and persistent instanse of FvwmPerl, it is suggested to do this from the _StartFunction_. Calling it from the top is also possible, but involves some issues not discussed here. AddToFunc StartFunction I Module FvwmPerl There are several command line switches: *FvwmPerl* [ *--eval* line ] [ *--load* file ] [ *--preprocess* [ *--quote* char ] [ *--winid* wid ] [ *--cmd* ] [ *--nosend* ] [ *--noremove* ] [ line | file ] ] [ *--export* [names] ] [ *--stay* ] [ *--nolock* ] [ alias ] Long switches may be abbreviated to short one-letter switches. **-e**|*--eval* line - evaluate the given perl code **-l**|*--load* file - evaluate perl code in the given file **-p**|*--preprocess* [ file ] - preprocess the given fvwm config file The following 5 options are only valid together with *--preprocess* option. **-c**|*--cmd* line - an fvwm command to be preprocessed instead of file **-q**|*--quote* char - change the default '%' quote **-w**|*--winid* wid - set explicit window context (should begin with digit, may be in oct or hex form; this window id overwrites implicit window context if any) *--nosend* - do not send the preprocessed file to _fvwm_ for **Read**ing, the default is send. Useful for preprocessing non fvwm config files. *--noremove* - do not remove the preprocessed file after sending it to _fvwm_ for **Read**ing, the default is remove. Useful for debugging. **-x**|*--export* [names] - define fvwm shortcut functions (by default, two functions named Eval and .). This option implies *--stay*. **-s**|*--stay* - continues an execution after *--eval*, *--load* or *--preprocess* are processed. By default, the module is not persistent in this case, i.e. *--nostay* is assumed. *--nolock* - when one of the 3 action options is given, this option causes unlocking _fvwm_ immediately. By default the requested action is executed synchronously; this only makes difference when invoked like: .... ModuleSynchronous FvwmPerl --preprocess someconfig.ppp .... If *--nolock* is added here, *ModuleSynchronous* returns immediately. Note that *Module* returns immediately regardless of this option. == USING ALIAS Aliases allow one to have several module invocations and work separately with all invocations, here is an example: .... ModuleSynchronous FvwmPerl FvwmPerl-JustTest SendToModule FvwmPerl-JustTest eval $a = 2 + 2; $b = $a SendToModule FvwmPerl-JustTest eval cmd("Echo 2 + 2 = $b") KillModule FvwmPerl FvwmPerl-JustTest .... == PREPROCESSING EXAMPLE One of the effective proprocessing solutions is to pass the whole fvwm configuration with embedded perl code to FvwmPerl --preprocess. An alternative approach is to write a perl script that produces fvwm commands and sends them for execution, this script may be loaded using FvwmPerl --load. There are however intermediate solutions that preprocess only separate configuration lines (or alternatively, execute separate perl commands that produce fvwm commands). The following code snippet adds ability of arithmetics and string scripting to certain lines that need this. To use this, you want to start FvwmPerl as your first command so that other commands may be asked to be preprosessed. .... ModuleSynchronize FvwmPerl AddToFunc . + I SendToModule FvwmPerl preprocess -c -- $* . Exec exec xterm -name xterm-%{++$i}% # use unique name . GotoDesk 0 %{ $[desk.n] + 1 }% # go to next desk . Exec exec %{ -x "/usr/bin/X11/aterm" ? "aterm" : "xterm" }% -sb # center a window Next (MyWindow) . Move \ %{($WIDTH - $[w.width]) / 2}%p %{($HEIGHT - $[w.height]) / 2}%p . Exec exec xmessage %{2 + 2}% # simple calculator . %{main::show_message(2 + 2, "Yet another Calculator"); ""}% .... == ACTIONS There are several actions that FvwmPerl may perform: eval perl-code:: Evaluate a line of perl code. A special function **cmd(**command*)* may be used in perl code to send commands back to fvwm. If perl code contains an error, it is printed to the standard error stream with the _[FvwmPerl][eval]:_ header prepended. load file-name:: Load a file of perl code. If the file is not fully qualified, it is searched in the user directory `+$FVWM_USERDIR+` (usually ~/.fvwm) and the system wide data directory `+$FVWM_DATADIR+`. A special function **cmd(**command*)* may be used in perl code to send commands back to fvwm. If perl code contains an error, it is printed to the standard error stream with the _[FvwmPerl][load]:_ header prepended. preprocess [-q|--quote char] [-c|--cmd] [line | file]:: Preprocess fvwm config _file_ or (if --cmd is given) _line_. This file contains lines that are not touched (usually fvwm commands) and specially preformatted perl code that is processed and replaced. Text enclosed in *%\{* ... *}%* delimiters, that may start anywhere on the line and end anywhere on the same or another line, is perl code. The _quote_ parameter changes perl code delimiters. If a single char is given, like '@', the delimiters are *@\{* ... *}@*. If the given quote is 2 chars, like *<>*, the quotes are *<\{* ... *}>* The perl code is substituted for the result of its evaluation. I.e. %\{$a = c; ++$a}% is replaced with d. The evaluation is unlike *eval* and *load* is done under the package PreprocessNamespace and without _use strict_, so you are free to use any variable names without fear of conflicts. Just don't use uninitialized variables to mean undef or empty list (they may be in fact initialized by the previous preprocess action), and do a clean-up if needed. The variables and function in the _main_ package are still available, like ::_cmd()_ or ::_skip()_, but it is just not a good idea to access them while preprocessing. There is a special function *include*(_file_) that loads a file, preprocesses it and returns the preprocessed result. Avoid recursion. If any embedded perl code contains an error, it is printed to the standard error stream and prepended with the _[FvwmPerl][preprocess]:_ header. The result of substitution is empty in this case. The following variables may be used in the perl code: `+$USER+`, `+$DISPLAY+`, `+$WIDTH+`, `+$HEIGHT+`, `+$FVWM_VERSION+`, `+$FVWM_MODULEDIR+`, `+$FVWM_DATADIR+`, `+$FVWM_USERDIR+` The following line based directives are recognized when preprocessing. They are processed after the perl code (if any) is substituted. %Repeat count:: Causes the following lines to be repeated _count_ times. %ModuleConfig module-name [ destroy ]:: Causes the following lines to be interpreted as the given module configuration. If destroy is specified the previous module configuration is destroyed first. %Prefix prefix:: Prefixes the following lines with the quoted _prefix_. %End any-optional-comment:: Ends any of the directives described above, may be nested. + .... %Prefix "AddToFunc SwitchToWindow I" Iconify off WindowShade off Raise WarpToWindow 50 50 %End %ModuleConfig FvwmPager destroy Colorset 0 Font lucidasans-10 DeskTopScale 28 MiniIcons %End ModuleConfig FvwmPager %Prefix "All (MyWindowToAnimate) ResizeMove " 100 100 %{($WIDTH - 100) / 2}% %{($HEIGHT - 100) / 2}% %Repeat %{$count}% br w+2c w+2c w-1c w-1c %End %Repeat %{$count}% br w-2c w-2c w+1c w+1c %End %End Prefix .... export [func-names]:: Send to _fvwm_ the definition of shortcut functions that help to activate different actions of the module (i.e. *eval*, *load* and *preprocess*). + Function names (_func-names_) may be separated by commas or/and whitespace. By default, two functions Eval and . are assumed. + The actual action defined in a function is guessed from the function name if possible, where function name . is reserved for *preprocess* action. + For example, any of these two fvwm commands + .... SendToModule MyPerl export PerlEval,PP FvwmPerl --export PerlEval,PPMyPerl .... + define the following two shortcut functions: + .... DestroyFunc PerlEval AddToFunc I SendToModule MyPerl eval $* DestroyFunc PP AddToFunc I SendToModule MyPerl preprocessc-c -- $* .... + These 4 actions may be requested in one of 3 ways: 1) in the command line when FvwmPerl is invoked (in this case FvwmPerl is short-lived unless *--stay* or *--export* is also given), 2) by sending the corresponding message in fvwm config using SendToModule, 3) by calling the corresponding perl function in perl code. == FUNCTIONS There are several functions that perl code may call: cmd($fvwm_command):: In case of *eval* or *load* - send back to fvwm a string `+$fvwm_command+`. In case of *preprocess* - append a string `+$fvwm_command+` to the output of the embedded perl code. do_eval($perl_code):: This function is equivalent to the *eval* functionality on the string _`+$perl_code+`_, described above. load($filename):: This function is equivalent to the *load* functionality on the file `+$filename+`, described above. preprocess(@params, ["-c $command"] [$filename]):: This function is equivalent to the *preprocess* functionality with the given parameters and the file `+$filename+` described above. export($func_names, [$do_unexport]):: This function is equivalent to the *export* functionality with the given `+$func_names+`, described above. May also *unexport* the function names if the second parameter is true. Function names should be separated by commas or/and whitespace. If _`+$func_names+`_ is empty then functions Eval and . are assumed. stop():: Terminates the module. skip():: Skips the rest of the event callback code, i.e. the module returns to listen to new module events. unlock():: Unsynchronizes the event callback from fvwm. This may be useful to prevent deadlocks, i.e. usually fvwm kills the non-responding module if the event callback is not finished in _ModuleTimeout_ seconds. This prevents it. This example causes FvwmPerl to suspend its execution for one minute: SendModule FvwmPerl eval unlock(); sleep(60); However, verify that there is no way a new message is sent by fvwm while the module is busy, and fvwm stays locked on this new message for too long. See also the *detach* solution if you need long lasting operations. detach():: Forks and detaches the rest of the event callback code from the main process. This may be useful to prevent killing the module if its event callback should take a long time to complete and it may be done in the detached child. The detached child may still send commands to fvwm (don't rely on this), but not receive the events of course, it exits immediately after the callback execution is finished. If you use _detach()_, better only send commands to fvwm in one process (the main one or the detached one), doing otherwise may often cause conflicts. show_message($msg, $title[, $use_stderr_too=1]):: Shows a dialog window with the given message, using whichever X tool is found in the system. See *FVWM::Module::Toolkit*::*show_message* for more information. == VARIABLES There are several global variables in the _main_ namespace that may be used in the perl code: .... $a, $b, ... $h @a, @b, ... @h %a, %b, ... %h .... They all are initialized to the empty value and may be used to store a state between different calls to FvwmPerl actions (*eval* and *load*). If you need more readable variable names, either write no strict 'vars'; at the start of every perl code or use a hash for this, like: .... $h{id} = $h{first_name} . " " . $h{second_name} .... or use a package name, like: .... @MyMenu::terminals = qw( xterm rxvt ); $MyMenu::item_num = @MyMenu::terminals; .... There may be a configuration option to turn strictness on and off. == MESSAGES FvwmPerl may receive messages using the fvwm command SendToModule. The names, meanings and parameters of the messages are the same as the corresponding actions, described above. Additionally, a message *stop* causes a module to quit. A message *unexport* [_func-names_] undoes the effect of *export*, described in the ACTIONS section. A message *dump* dumps the contents of the changed variables (not yet). == EXAMPLES A simple test: .... SendToModule FvwmPerl eval $h\{dir} = $ENV\{HOME} SendToModule FvwmPerl eval load($h\{dir} . "/test.fpl") SendToModule FvwmPerl load $[HOME]/test.fpl SendToModule FvwmPerl preprocess config.ppp SendToModule FvwmPerl export Eval,PerlEval,PerlLoad,PerlPP SendToModulecFvwmPerl unexport PerlEval,PerlLoad,PerlPP SendToModule FvwmPerl stop .... The following example handles root backgrounds in fvwmrc. All these commands may be added to StartFunction. .... Module FvwmPerl --export PerlEval # find all background pixmaps for a later use PerlEval $a = $ENV\{HOME} . "/bg"; \ opendir DIR, $a; @b = grep \{ /xpm$/ } readdir(DIR); closedir DIR # build a menu of background pixmaps AddToMenu MyBackgrounds "My Backgrounds" Title PerlEval foreach $b (@b) \ { cmd("AddToMenu MyBackgrounds $b Exec fvwm-root $a/$b") } # choose a random background to load on start-up PerlEval cmd("AddToFunc \ InitFunction + I Exec exec fvwm-root $a/" . $b[int(random(@b))]) .... == ESCAPING *SendToModule* just like any other fvwm commands expands several dollar prefixed variables. This may clash with the dollars perl uses. You may avoid this by prefixing SendToModule with a leading dash. The following 2 lines in each pair are equivalent: .... SendToModule FvwmPerl eval $$d = "$[DISPLAY]" -SendToModule FvwmPerl eval $d = "$ENV\{DISPLAY}" SendToModule FvwmPerl eval \ cmd("Echo desk=$d, display=$$d") SendToModule FvwmPerl preprocess -c \ Echo desk=%("$d")%, display=%\{$$d}% .... Another solution to avoid escaping of special symbols like dollars and backslashes is to create a perl file in ~/.fvwm and then load it: .... SendToModule FvwmPerl load build-menus.fpl .... If you need to preprocess one command starting with a dash, you should precede it using "-- 2. .... # this prints the current desk, i.e. "0" SendToModule FvwmPerl preprocess -c Echo "$%\{$a = "c"; ++$a}%" # this prints "$d" SendToModule FvwmPerl preprocess -c -- -Echo "$%\{"d"}%" # this prints "$d" (SendToModule expands $$ to $) SendToModule FvwmPerl preprocess -c -- -Echo "$$%\{"d"}%" # this prints "$$d" -SendToModule FvwmPerl preprocess -c -- -Echo "$$%\{"d"}%" .... Again, it is suggested to put your command(s) into file and preprocess the file instead. == CAVEATS FvwmPerl being written in perl and dealing with perl, follows the famous perl motto: There's more than one way to do it, so the choice is yours. Here are more pairs of equivalent lines: .... Module FvwmPerl --load "my.fpl" --stay Module FvwmPerl -e load("my.fpl") -s SendToModule FvwmPerl preprocess --quote @ my.pp SendToModule FvwmPerl eval preprocess(\{quote => @}, "my.ppp"); .... Warning, you may affect the way FvwmPerl works by evaluating appropriate perl code, this is considered a feature not a bug. But please don't do this, write your own fvwm module in perl instead. == SEE ALSO The _fvwm_ (1) man page describes all available commands. Basically, in your perl code you may use any function or class method from the perl library installed with fvwm, see the man pages of perl packages *General::FileSystem*, *General::Parse* and *FVWM::Module*. == AUTHOR Mikhael Goikhman . fvwm3-1.0.6a/doc/FvwmScript.adoc0000644000175000017500000006746114354105651015772 0ustar jaimosjaimos= FvwmScript(1) == NAME FvwmScript - module to build graphic user interface == SYNOPSIS FvwmScript must be spawned by Fvwm. It will not work from the command line. == DESCRIPTION FvwmScript is a module which allows you to build many graphical applications such as desktop accessories, button panel with pop up menus, modal dialogs... At the startup, FvwmScript reads the file which is specified on the command line. This file contains the script. This script is not included in the configuration file of Fvwm. An FvwmScript script is fully controllable by using the keyboard. (Shift)-Tab circulates around the widgets, Return simulates a mouse click, the arrows move the cursor or change the values of the widget and Escape "cancels" for Menu and PopupMenu. == INVOCATION FvwmScript can be invoked by inserting the line `Module FvwmScript name_of_script' in the .fvwm2rc file. The file "name_of_script" can start with a slash, in which case, it's a fully qualified path, and the file is read. If "name_of_script" does not start with a slash, FvwmScript will look in a few different places. If the .fvwm2rc contained the command line `*FvwmScript: Path path_of_the_script_directory', FvwmScript will try that directory. If that doesn't work, FvwmScript tries the system configuration directory and the user configuration directory as described under the "Read" command in the fvwm man page. The command to start FvwmScript can be placed on a line by itself, if FvwmScript is to be spawned during fvwm's initialization, or can be bound to a menu or mouse button or keystroke to invoke it later. == CONFIGURATION OPTIONS The following commands can be used in the config file (see _fvwm_(1), section *MODULE COMMANDS* for details). They are used only if the corresponding script commands are not used in the script. *FvwmScript: DefaultFont font:: Specifies the default font to be used. If not specified with this command or in the script with the Font command, fixed font is assumed. *FvwmScript: DefaultFore color:: Specifies the default foreground color to be used. If not specified with this command or in the script with the ForeColor command, black is used. *FvwmScript: DefaultBack color:: Specifies the default background color to be used. If not specified with this command or in the script with the BackColor command, grey85 is used. *FvwmScript: DefaultHilight color:: Specifies the default hilight color to be used. If not specified with this command or in the script with the HilightColor command, grey100 is used. *FvwmScript: DefaultShadow color:: Specifies the default shadow color to be used. If not specified with this command or in the script with the ShadowColor command, grey55 is used. *FvwmScript: DefaultColorset colorset:: Tells the module to use colorset _colorset_ as the default colorset. *FvwmScript: DefaultCursor cursor:: Tells the module to use X11 cursor _cursor_ as the default for all widgets. Cursor names are those defined in the include file X11/cursorfont.h but without XC_ prefix. == ANATOMY OF A SCRIPT FvwmScript uses a particular programming language. A script is composed of five parts. Heading contains general characteristics of the window and default properties for all widgets. The second part contains instructions whom are executed at the startup of the script. The third part contains periodic tasks which are executed every second. The fourth part contains instructions which are executed at exit. And the last part contains the description of widgets. A widget consists of eleven types of items: text labels, single-line text inputs, radio buttons, checkbox, push buttons, horizontal and vertical scrollbars, rectangles, pop up menus, swallowexecs and mini scrollbars. == HEADING OF A SCRIPT The syntax is as follows: WindowTitle string:: This option sets the window title. WindowSize width height:: This option sets window size. _width_ and _height_ are numerical value. WindowPosition x y:: This option sets window position. _x_ and _y_ are numerical value. ForeColor \{color}:: This option sets the default foreground color for all widgets. BackColor \{color}:: This option sets the default background color for all widgets. HilightColor \{color}:: This option sets the default hilight color for all widgets. ShadowColor \{color}:: This option sets the default shadow color for all widgets. Colorset \{n}:: This option sets the default colorset for all widgets. Font \{font}:: This option sets the default font for all widgets. UseGettext [locale_path]:: Enable the use of the gettext mechanism which is used by the WindowLocaleTitle, LocaleTitle, ChangeLocaleTitle instructions and the Gettext function. If no argument is given, the default FvwmScript locale catalog is used. This catalog is under the locale fvwm installation directory and the text domain is FvwmScript (+install_prefix/share/locale/*/LC_MESSAGES/FvwmScript.mo+). You can reset this catalog or add some catalogs exactly in the same way than with the *LocalePath* fvwm command (see the fvwm manual page). This instruction should be placed before the WindowLocaleTitle instruction. WindowLocaleTitle string:: This option sets the window title, but use the locale catalog(s) defined with UseGettext. == INITIALISATION This part contains instructions which will be executed at the startup. For example: Init Begin Do "Exec cat tada.voc > /dev/dsp" WarpPointer 1 Set $ToDo=Restart End These instructions are used to play a sound, move the pointer to widget 1 and to initialize $ToDo to "Restart" at every startup. == PERIODIC TASKS This part of the script contains instructions that are executed every second. For example: .... PeriodicTasks Begin If (RemainderOfDiv (GetTime) 10)==0 Then Do {Exec xcalc} End .... This example shows how to launch xcalc every 10 seconds. == THE QUIT FUNCTION This part of the script contains instructions that are executed when the script exits (after the Quit instruction or if you close the window with the Close, Delete or Destroy fvwm command). For Example .... QuitFunc Begin Do {Echo bye, bye} End .... Be aware that if you used the KillModule fvwm command to close the script, some instructions or functions which rely on the existence of a communication link between the script and fvwm will not be executed (for example the Do command). To smoothly kill a script with an fvwm command see the *COMMANDS* section. == MAIN OF A SCRIPT The second part of the script contains the description for every widget in the script. Each widget description has two parts. The first part describes initial properties, the second part contains instructions that are executed when the widget receives messages. All widgets can send and receive messages. All messages are identified by a number. The message "UserAction" is sent to a widget when the user operates the widget. The syntax for the first part is: .... Widget id # A number between 1 and 999 inclusive Property Type string Size width height Position x y Title { string } Value int MaxValue int MinValue int Font string ForeColor { color } BackColor { color } HilightColor { color } ShadowColor { color } Colorset int Flags flagsOpt .... The flagsOpt option to Flags is a space separated list containing one or more of the keywords _Hidden_, _NoReliefString_, _NoFocus_, _Left_ / _Center_ / _Right_. _Hidden_ is used to specify if the widget is hidden at startup. _NoReliefString_ specifies if strings are drawn with relief or not. _NoFocus_ specifies if the widget can get the keyboard focus or not. By default all widgets take focus, except Rectangle, HDipstick and VDipstick which cannot. Moreover, the NoFocus widgets are skipped when you circulate around the widgets with the (Shift-)Tab short cut. _Left_ / _Center_ / _Right_ specifies the text position. These apply only to ItemDraw, List, Menu, PopupMenu and PushButton. The default is _Center_ for ItemDraw and PushButton and _Left_ for the other widgets. LocaleTitle can be used in place of Title, for using the locale catalog(s) defined with UseGettext. The position of every widget must be specified. The syntax for the second part is: .... Main Case message of SingleClic: Begin # list of instructions which will be # executed when widget receives # message "SingleClic". This message is # generated by the user. End 1 : Begin # list of instructions which will be # executed when widget receives # message 1 End End .... == LIST OF WIDGETS There is fifteen types of widgets. *CheckBox*: Display check box with a string.:: *Title*: title of the check box. + *Value*: if Value is equal to 1, the box is checked else it is not. The *Size* property is ignored. *HDipstick*: Display a horizontal dipstick.:: This widget can be used to display disk usage. + *Value*: specify the current value of the dipstick. + *MinValue*: specify the minimum value of the dipstick. + *MaxValue*: specify the maximum value of the dipstick. A minimum size of 30x11 is imposed. *HScrollBar*: Display an horizontal scrollbar.:: *Value*: position of the thumb. + *MaxValue*: upper limit of Value. + *MinValue*: lower limit of Value. + The height property is ignored and a minimum width is imposed. The width should be at least the range plus 37 if all values are to be selectable e.g. a min of 0 and max of 10 has a range of 11 and therefore should have a minimum width of 48. *ItemDraw*: Display an icon and/or a string.:: *Title*: string to display. + *Icon*: icon to display. + *MaxValue*: x coordinate of the cursor. + *MinValue*: y coordinate of the cursor. + The size is made large enough to contain the title and/or the icon. *List*: Display a list.:: List lets user to choose between various options. + *Value*: specify which option is selected. + *MinValue*: First visible option. + *Title*: title contains options displayed in the list. The syntax is the following: +{Option 1|Option 2|...|Option N}+. All menus are displayed at the top of window. + A minimum height of three items is imposed and the width is made to be at least 108. *Menu*: Display a menu whom lets user to choose a option.:: Items of type Menu are layed out from left to right along the top of the window. The size and position properties are ignored. + *Value*: specify which option is selected. + *Title*: title contains options displayed in the menu. The syntax is the following: +{Option 1|Option 2|...|Option N}+. *MiniScroll*: Display a very small vertical scrollbar.:: *Value*: position of the thumb. + *MaxValue*: upper limit of Value. + *MinValue*: lower limit of Value. + The size is set to 19x34. *PopupMenu*: Display a pop up menu.:: *Value*: specify what option is selected. + *Title*: the title has the following syntax: {Option 1|Option 2|...|Option N}."Option 1|Option 2|...|Option N" is the pop up menu which is displayed when pressing mouse button. + The size property is ignored. *PushButton*: Display push button with an icon and/or a string.:: *Title*: this string has the following syntax {Title of the button|Option 1|Option 2|Option3|...|Option N}. "Option 1|Option 2|...|Option N" is the pop up menu which is displayed when pressing the right button. + *Icon*: icon to display. + The button is made large enough to fit the icon and or label. *RadioButton*: Display radio button with a string.:: *Title*: title of the radio button. + *Value*: if Value is equal to 1, the box is checked else it is not. + The size property is ignored *Rectangle*: Display a rectangle.:: This type of widget can be used to decorate window. *SwallowExec*:: This type of widget causes FvwmScript to spawn an process, and capture the first window whose name or resource is equal to Title, and display it in the script window. + *Title*: specify the window name which be captured and displayed in the script window. + *SwallowExec*: specify the command line to execute to spawn the process. Modules can also be swallowed. + *Value*: specify the looking of the border. Possible value: -1, 0, 1. + The size is made to be at least 30x30 *TextField*: Display a text input field.:: The text input field can be used to edit a single-line string. + *Title*: content of text field. + *Value*: position of the insert point. + *MinValue*: position of the end of the selection. + *MaxValue*: first visible character of the title + The height property is ignored, the width is made to be at least 40 pixels wider than the initial contents. *VDipstick*: Display a vertical dipstick.:: *Value*: specify the current value of the dipstick. + *MinValue*: specify the minimum value of the dipstick. + *MaxValue*: specify the maximum value of the dipstick. + The size is made to be at least 11x30. *VScrollBar*: Display a vertical scrollbar.:: *Value*: position of the thumb. + *MaxValue*: upper limit of Value. + *MinValue*: lower limit of Value. + The width property is ignored and a minimum height is imposed. The height should be at least the range plus 37 if all values are to be selectable e.g. a min of 0 and max of 10 has a range of 11 and therefore should have a minimum height of 48. == INSTRUCTIONS Here is the description of all instructions. HideWidget id : hide the widget numbered id.:: ShowWidget id: show the widget numbered id.:: ChangeValue id1 id2:: Set the value of the widget numbered _id1_ to _id2_. ChangeMaxValue id1 id2:: Set the maximum value of the widget numbered _id1_ to _id2_. ChangeMinValue id1 id2:: Set the minimum value of the widget numbered _id1_ to _id2_. ChangeTitle id1 id2:: Set the title of the widget numbered _id1_ to _id2_. ChangeWindowTitle string:: Set the title of the window to _string_. ChangeWindowTitleFromArg numarg:: Set the title of the window to the value of the _numarg_-th script argument. ChangeLocaleTitle id1 id2:: As ChangeTitle but use the locale catalog(s) defined with UseGettext. ChangeIcon id1 id2:: Set the icon of the widget numbered _id1_ to _id2_. ChangeForeColor id1 \{color}:: Set the foreground color of the widget numbered _id1_ to {_color_}. ChangeBackColor id1 \{color}:: Set the background color of the widget numbered _id1_ to {_color_}. ChangeColorSet id1 id2:: Set the colorset of the widget numbered _id1_ to _id2_. Specifying widget 0 sets the main window colorset. ChangePosition id1 x y:: Move the widget numbered _id1_ to position (_x_,_y_). ChangeSize id1 width height:: Set the size of the widget numbered _id1_ to (_width_,_height_). ChangeFont id1 newfont:: Set the font of the widget numbered _id1_ to _newfont_. WarpPointer id:: Warp the mouse pointer into the widget numbered _id_. WriteToFile filename \{str1} \{str2} etc:: Write to the file _filename_ the string which is the concatenation of all arguments _str1_, _str2_, etc. Do {command args}:: Execute the fvwm command inside the Do block. Any fvwm command as described in the fvwm man page can be used. Commands are sent from this module to the fvwm main program for processing. The length of the command and arguments can not exceed 988 characters. Set $var=\{str1} \{str2} etc:: Concatenate all arguments to a string and set the variable $__var__ to this string. Quit: quit the program.:: SendSignal id1 id2:: Send a message numbered _id2_ to widget _id1_. SendToScript id_script \{str11} \{str2} etc:: Send a message to the script identified by id_script. The message is the concatenation of str1, str2... Key _Keyname_ _Modifier_ _id_ _sig_ _str1_ _str2_ etc:: Binds a keyboard key to the instruction + SendSignal _id_ _sig_ + and sets the "last string" to the concatenation of str1, str2... (see the LastString function). The _Keyname_ and _Modifiers_ fields are defined as in the fvwm Key command. == ARGUMENTS Most of commands use arguments. There are two kinds of arguments: numbers and strings. A numerical argument is a value which is between -32000 and +32000. A string is always surrounded with braces. Variables always begin with the character "$" and can contain both numbers and strings. == FUNCTIONS All functions use arguments. Functions can return both a string and a number. The syntax is: (function argument1 argument2 etc) Here is the complete list of arguments: (GetTitle id):: Return the title of the widget numbered _id_. (GetValue id):: Return the current value of the widget numbered _id_. (GetMinValue id):: Return the current Min value of the widget numbered _id_. (GetMaxValue id):: Return the current Max value of the widget numbered _id_. (GetFore id):: Return the current RGB foreground value of the widget numbered _id_ in the hex format RRGGBB. (GetBack id):: Return the current RGB background value of the widget numbered _id_ in the hex format RRGGBB. (GetHilight id):: Return the current RGB hilight value of the widget numbered _id_ in the hex format RRGGBB. (GetShadow id):: Return the current RGB shadow value of the widget numbered _id_ in the hex format RRGGBB. (GetOutput \{str} int1 int2):: Executes the command _str_, gets the standard output and returns the word which is in the line _int1_ and in the position _int2_. If _int2_ is equal to -1, GetOutput returns the complete line. (NumToHex int):: Return the hexadecimal value of _int_. (HexToNum \{str}):: Return the decimal value of _str_, _str_ must be an hexadecimal value. (Add int1 int2):: Return the result of (__int1__+_int2_). (Mult int1 int2):: Return the result of (_int1_*_int2_). (Div int1 int2):: Return the result of (_int1_/_int2_). (StrCopy \{str} int1 int2):: Return the string whom is between position int1 and int2. For example, (StrCopy \{Hello} 1 2) returns \{He} (LaunchScript \{str}):: This function launches the script named str and returns an identification number. This number is necessary to use the functions SendToScript and ReceiveFromScript. The string str contains the script name and some arguments. (GetScriptArgument \{int}):: This function returns the argument script used in the function LaunchScript. If int is equal to zero, GetScriptArgument returns the name of the script. (GetScriptFather):: This function returns the identification number of the script father. (ReceivFromScript \{int}):: This function returns the message sent by the script numbered int. (RemainderOfDiv {int1 int2}): t:: This function returns the remainder of the division (_int1_/_int2_). (GetTime):: This function returns the time in seconds. (GetPid):: This function returns the process id of the script. (Gettext {_str_}):: This function return the translation of _str_ by using the locale catalog(s) defined with UseGettext. (SendMsgAndGet {_comId_} {_cmd_} _bool_):: Sends the command _cmd_ with identifier _comId_ to an external program ready to communicate with the script using a protocol specific to FvwmScript. If _bool_ is 0 FvwmScript does not wait for an answer from the external program. In this case the returned value is 1 if the message can be sent to the external program and 0 if this is not the case. If _bool_ is 1, then FvwmScript waits for an answer from the external program and the return value is this answer (a line of no more than 32000 characters). If the communication fails, the returned value is 0. See the section *A COMMUNICATION PROTOCOL* for a description of the communication protocol used. (Parse {_str_} _int_):: where _str_ must be a string of the form: X1S1X2S2X3S3...SnXn + where the Xn are numbers containing four decimal digits and where Sn are strings of length exactly Xn. The returned value is the string S__int__. If _int_ is out of range (e.g., >n) the returned value is the empty string. If _str_ is not of the specified form, the return value is unpredictable (but empty in the average). This function is useful to handle strings returned by the SendMsgAndGet function. (LastString):: This function returns the "current working string" for the Key instruction and the SendString command (see the *COMMANDS* section). At startup this string is empty, but when a Key binding is detected (respectively, a SendString command is received), then this string is set to the string associated to the instruction (respectively, to the command). == CONDITIONAL LOOPS There are three kinds of conditional loops. The instruction "If-Then-Else" has the following syntax: .... If $ToDo=={Open xcalc} Then Do {Exec xcalc &} # List of instructions Else Begin Do {Exec killall xcalc &} # List of instructions Do {Exec echo xcalc killed >/dev/console} End .... The second part "Else-Begin-End" is optional. If the loop contains only one instruction, Begin and End can be omitted. The instruction "While-Do" has the following syntax: .... While $i<5 Do Begin Set $i=(Add i 1) # List of instructions End .... Two strings can be compared with "==" and two numbers can be compared with "<", "<=", "==", ">=", ">". The loop "For-Do-Begin-End" has the following syntax: .... For $i=1 To 20 Do Begin Do {Exec xcalc &} # List of instructions End .... == COMMANDS The following fvwm command may be executed at any time ==== SendToModule _ScriptName_ SendString _id_ _sig_ _str_ ==== it sends to any module with alias or name which matches _ScriptName_ the string ==== SendString _id_ _sig_ _str_ ==== When an FvwmScript receives such a message it sends to the Widget _id_ the signal numbered _sig_ and the string _str_ can be obtained with the LastString function. Let us give an example. Say that you have a script MyScript with the widget: .... Widget 50 Property Type PushButton Title {Quit} ... Main Case message of SingleClic: Begin Quit End 1 : Begin Set $str = (LastString) If $str == {Quit} Then Quit Else ChangeTitle 33 $str End End .... Then the command .... SendToModule MyScript SendString 50 1 str .... forces MyScript to exit if str is equal to "Quit" and if not it changes the title of Widget 33 to str. This command can be used to change the window title ==== SendToModule _ScriptName_ ChangeWindowTitle _newTitle_ _[oldTitle]_ ==== it causes that any module with alias or name which matches _ScriptName_ changes its associated window title to _newTitle_. The optional argument _oldTitle_ makes sense when there are several instances of the same script. It permits one to avoid changing the name of all these instances by specifying the name of the window associated to the target script (see the example below). .... + I Module FvwmScript FvwmStorageSend "/dev/hda6" + I Wait FvwmStorageSend + I SendToModule FvwmStorageSend ChangeWindowTitle HDA6 + I Module FvwmScript FvwmStorageSend "/dev/hda1" + I Wait FvwmStorageSend + I SendToModule FvwmStorageSend ChangeWindowTitle HDA1 FvwmStorageSend .... Without the FvwmStorageSend argument in the last case, the SendToModule command would have changed to HDA1 the name of both instances of FvwmStorageSend. == EXAMPLES You will find examples of scripts in the fvwm configuration directory. FvwmScript-BellSetup, FvwmScript-KeyboardSetup, FvwmScript-PointerSetup and FvwmScript-ScreenSetup are a set of scripts that modify X settings. These scripts save preferences into a file named ~/.xinit-fvwmrc (If you want to use another file name, give it as the first argument of the script). If you want to load these preferences at every startup, you have to include the line ".xinit-fvwmrc" in your .xinitrc (or .xsession) file before starting fvwm. FvwmScript-BaseConfig modifies fvwm focus and paging mouse policy, window placement, opacity and other features of the move and resize commands, snap attraction and shading animation. This script saves preferences into a file named .FvwmBaseConfig in the user's data directory (i.e., $HOME/.fvwm or $FVWM_USERDIR if set). If you want to load these preferences at every startup you must add the line "Read .FvwmBaseConfig" in your fvwm configuration file. If you want to use another file name, give it as the first argument of the script. When you click on Ok or Apply an fvwm function that you may define named BaseConfigOkFunc or BaseConfigApplyFunc is called. This allows for reloading specific application styles that the script has destroyed (e.g., AddToFunc BaseConfigOkFunc I Read MyAppStyle). FvwmScript-Buttons is a buttons panel which can replace FvwmButtons (this script supports popup menus and requires xload, xclock, FvwmPager, TkDesk). FvwmScript-Colorset allows you to edit your colorset. FvwmScript-Date allows you to set date and time. FvwmScript-FileBrowser is a file browser used by the other scripts. FvwmScript-Find is an elementary front-end to find. FvwmScript-Quit allows one to quit fvwm, restart fvwm or some other window manager, or shut down and reboot the computer. FvwmScript-ScreenDump is a screen dumper. FvwmScript-WidgetDemo is a pure example script. See the next section for FvwmScript-ComExample. == A COMMUNICATION PROTOCOL FvwmScript is a weak (but simple) programming language. If you need to deal with a lot of data and/or you need to use complex algorithms you should use an external program (in perl for example) and "send" the desired information to your FvwmScript script. The first approach is to use the GetOutput function. This is simple but you should rerun your external program each time you need information from it (and this may cause performances problems). The second approach is to use the SendMsgAndGet function which extends FvwmScript by using any programming language which can deal with named pipes (fifos). We describe this solution in this section. (A third approach is to use fvwm-themes-com from the fvwm-themes package, but in fact the SendMsgAndGet method is an implementation of fvwm-themes-com inside FvwmScript and this gives better performance). Basically, you start an "external" program (the program for short) from your FvwmScript script (the script for short). This program runs in the background and you use the SendMsgAndGet function in your script to ask questions or to give instructions to the program. The program must strictly respect a certain communication protocol. First of all there is an identifier _comId_ for the communication, it should contain the process id of the script for a good implementation of the protocol (use the GetPid function and pass the _comId_ via an option to the program). The protocol uses two fifos, in the fvwm user directory, named: .tmp-com-in-_comId_ and .tmp-com-out-_comId_. The program should create and listen on the .tmp-com-in-_comId_ fifo. Then, when FvwmScript executes a function of the form: ==== Set $answer = (SendMsgAndGet {_comId_} {_cmd_} _bool_) ==== FvwmScript writes the _cmd_ on this fifo. This way the program can read the _cmd_ and can execute the appropriate action (it should remove the in fifo to support multi-communications). If _bool_ is 0, FvwmScript does not wait for an answer from the program and return 1 if the previous actions succeed and 0 if they failed (then the program should "go back" to the in fifo). If _bool_ is 1, then FvwmScript waits (20 sec) for an answer from the program and in turn returns the answer to the script (note that _bool_ is not passed to the program as it must know which commands need an answer). To answer, the program creates the .tmp-com-out-_comId_ fifo and writes the answer on it. The program should wait until FvwmScript reads the answer and then it should remove the out fifo and go back to the in fifo. The answer should consist of one line of no more than 32000 characters (take a look at the Parse function to handle multiple lines as one line). A simple way to understand this protocol and to write scripts and programs that use it is to take a look at the (not useful) example FvwmScript-ComExample and fvwm-script-ComExample.pl (that can found in the fvwm data directory). Moreover, this implementation of the protocol solves questions as: What to do if the script exits for a bad reason? What to do if the program exits for a bad reason? ...etc. == BUGS FvwmScript crashes if widgets are accessed that have not been defined. == AUTHOR Frederic Cordier (cordie97@cui.unige.ch or f-cord96@univ-lyon1.fr). == CONTRIBUTOR Eddy J. Gurney (eddy@gizmo.aa.ans.net). fvwm3-1.0.6a/doc/FvwmIdent.adoc0000644000175000017500000000577214354105651015566 0ustar jaimosjaimos= FvwmIdent(1) :doctype: manpage :mantitle: FvwmIdent :manname: FvwmIdent :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmIdent - the Fvwm identify-window module == SYNOPSIS FvwmIdent is spawned by fvwm, so no command line invocation will work. == DESCRIPTION The FvwmIdent module prompts the user to select a target window, if the module was not launched from within a window context in Fvwm. After that, it pops up a window with information about the window which was selected. == COPYRIGHTS The FvwmIdent program, and the concept for interfacing this module to the Window Manager, are all original work by Robert Nation and Nobutaka Suzuki. Copyright 1994, Robert Nation and Nobutaka Suzuki. No guarantees or warranties or anything are provided or implied in any way whatsoever. Use this program at your own risk. Permission to use this program for any purpose is given, as long as the copyright is kept intact. == INITIALIZATION During initialization, _FvwmIdent_ gets config info from *fvwm*'s module configuration database (see _fvwm_(1), section *MODULE COMMANDS*) to determine which colors and font to use. If the FvwmIdent executable is linked to another name, ie ln -s FvwmIdent MoreIdentify, then another module called MoreIdentify can be started, with a completely different configuration than FvwmIdent, simply by changing the keyword FvwmIdent to MoreIdentify. This way multiple clutter-reduction programs can be used. == INVOCATION FvwmIdent can be invoked by binding the action 'Module FvwmIdent' to a menu or key-stroke in the .fvwm2rc file. Fvwm will search directory specified in the ModulePath configuration option to attempt to locate FvwmIdent. Although nothing keeps you from launching FvwmIdent at start-up time, you probably don't want to. Clicking into the FvwmIdent window or pressing a key while it has focus closes FvwmIdent. Pressing mouse button 2 in the window restarts FvwmIdent and asks for a new window to select. == CONFIGURATION OPTIONS FvwmIdent reads the same .fvwm2rc file as fvwm reads when it starts up, and looks for lines as listed below: *FvwmIdent: Colorset n:: Tells the module to use colorset _n_. *FvwmIdent: Fore color:: Tells the module to use _color_ instead of black for text. Switches off the Colorset option. *FvwmIdent: Back color:: Tells the module to use _color_ instead of white for the window background. Switches off the Colorset option. *FvwmIdent: Font fontname:: Tells the module to use _fontname_ instead of fixed for text. *FvwmIdent: MinimalLayer layer:: FvwmIdent places its window on the layer of a target window. But not below the minimal layer. By default, the minimal layer is 4 just like the fvwm default layer. If _layer_ is 0, the layer of the target window is always used. If _layer_ is "default" or not specified, the default behavior is restored. If _layer_ is "none", FvwmIdent is placed as a normal window even if the target window is above it. == AUTHOR Robert Nation and Nobutaka Suzuki (nobuta-s@is.aist-nara.ac.jp). fvwm3-1.0.6a/doc/FvwmMFL.adoc0000644000175000017500000000635714354105651015141 0ustar jaimosjaimos= FvwmMFL(1) :doctype: manpage :mantitle: FvwmMFL :manname: FvwmMFL :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmMFL - the Fvwm3 front-loader module == SYNOPSIS _FvwmMFL_ can only be invoked by Fvwm3. Command line invocation of the _FvwmMFL_ will not work. This module has no command-line options. == DESCRIPTION The _FvwmMFL_ module provides access to Fvwm events over a unix-domain socket. This module is intended to provide externally-written programs (clients) the ability to receive information from Fvwm and to perform an action on that event. The information from Fvwm3 is in the form of JSON packets. Each JSON packet has different fields, depending on the type requested. == COMMUNICATION The default unix-domain socket for _FvwmMFL_ is _$TMPDIR/fvwm_mfl.sock_, although this can be overridden via an environment variable _FVWMMFL_SOCKET_. == REGISTERING INTEREST Commands can be sent to _FvwmMFL_ to control which information is sent the client. The _set_ command is used for this. The table below shows which events can be subscribed to. [cols="<,<",] |=== |_Event_ |_Description_ |new_window |Fired when a new window is mapped and visible. |map |Fired when a window is mapped. |configure_window |Fired when a window is moved or resized. |destroy_window |Fired when a window is closed. |new_page |Fired when a new page is switched to. |new_desk |Fired when a new desk is switched to. |raise_window |Fired when a window is raised (or changes layer). |lower_window |Fired when a window is lowered (or changed layer). |focus_change |Fired when a window loses/gains focus. |enter_window |Fired when a window has the pointer moved into it. |leave_Window |Fired when a window has pointer moved out of it. |window_shade |Fired when a window is shaded. |window_unshade |Fired when a window is unshaded. |window_name |Fired when the window name changes. |visible_name |Fired when the visible window name changes. |res_class |Fired when the class of the window is set. |res_name |Fired when the resource of the window is set. |iconify |Fired when a window is iconified. |deiconify |Fired when a window is deiconified. |icon_name |Fired when the icon name changes. |visible_icon_name |Fired when the icon's visible name changes. |icon_file |Fired when the path to the icon changes. |icon_location |Fired when the icon location changes. |restack |Fired when the window stacking order changes. |echo |Fired when Fvwm receives an Echo command. |=== For example, to register an interest in _new_window_ and _focus_change_, the following commands would be set via the socket: .... set new_window set focus_change .... To remove interest in an event, use the _unset_ command: .... unset focus_change .... == JSON FORMAT Each packet sent to a client is in plain JSON. The information contained in each packet varies depending on the event. TODO: document each JSON structure. == EXAMPLE The following example shows how to monitor for _focus_change_ events at the shell, printing the JSON returned: .... echo set focus_change | nc -U /tmp/fvwm_mfl.sock 2>&1 | jq --unbuffered .... Outputs: .... { "focus_change": { "window": "0x5400022", "type": 0, "hilight": { "text_colour": 16777215, "bg_colour": 32767 } } } .... == AUTHORS This module first appeared in 2020. fvwm3-1.0.6a/doc/FvwmForm.adoc0000644000175000017500000006773514354105651015435 0ustar jaimosjaimos= FvwmForm(1) :doctype: manpage :mantitle: FvwmForm :manname: FvwmForm :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmForm - input form module for Fvwm == SYNOPSIS *Module FvwmForm* [ _Alias_ ] FvwmForm must be spawned by Fvwm. If invoked from the command line, FvwmForm prints its version number and exits. == DESCRIPTION FvwmForm provides a mechanism to get user input and act accordingly. This is achieved by means of a form that the user can fill out, and from which the user can select actions he wants Fvwm to take. A form consists of five types of items: text labels, single-line text inputs, mutually-exclusive selections, multiple-choice selections, and action buttons. These items are arranged into several lines, with a very flexible layout. A text label only serves the purpose of explanation. It cannot accept any input. A timeout entry provides a mechanism for timing out the form and performing a certain action when the timeout occurs. The countdown is displayed similar to a text label except that it updates with the amount of time left. A text input field can be used to edit a single-line string. FvwmForm accepts Emacs-style cursor movement keys. See FvwmFormInput for details. Mouse copy is not supported, but you can paste. A selection consists of several choices. The selection itself is a logical entity that doesn't have any display feature. Each choice is displayed as a push-button followed by a explanatory text label. When selected, an exclusive choice shows a circle in the middle, while a multiple choice shows a check. An action button, when activated sends one or more commands to Fvwm or executes shell commands. The shell commands can contain the content of the input fields on the form and reflect the setting of choices on the form. The action buttons can be activated thru keyboard or mouse. == INITIALIZATION FvwmForm invoked without an alias uses configuration commands starting with "*FvwmForm". Normally you would invoke FvwmForm with an alias representing the name of a form, its configuration commands and configuration file. For example, the command "Module FvwmForm Rlogin" uses configuration commands starting with "*Rlogin", and reads the optional configuration file "Rlogin". All forms, regardless of alias, scan first for configuration commands that start with "*FvwmFormDefault". These commands normally come from the builtin form "FvwmForm-Form" which saves commands to the file ".FvwmForm". The physical reading of the optional input file, ".FvwmForm", is done only the first time FvwmForm is invoked, or after "FvwmForm-Form" updates the file. When the file ".FvwmForm" is read, it is done by sending the command "Read .FvwmForm Quiet" to fvwm. Because of the way the "read" command works, the file can reside in your personal fvwm user directory, or be in the fvwm data directory. See the description of the read command in the fvwm man page for more information about the environment variable $FVWM_USERDIR. Then FvwmForm reads the rest of the configuration fvwm has stored up. Fvwm stores configuration on an ongoing basis. The initial configuration comes from the .fvwm2rc file. Other sources, including "Read" commands can define a form. When letting FvwmForm and fvwm read files, remember that these files contain commands that can execute shell commands, so you should be careful about setting permissions on these files. When FvwmForm is invoked with a window context, e.g. from a window menu, all commands it sends to Fvwm will have that window context. This would allow FvwmForm to control the window it is invoked from. After all the configuration commands have been read, FvwmForm displays the form defined by the commands. == DEFAULTS FvwmForm creates a built-in form named "FvwmForm-Form" that creates a file called ".FvwmForm". This file contains saved default form colors and fonts. Other forms use these defaults unless they are overridden within the form. The default creating form would normally be invoked from a "module menu". For example, if you call your module menu "Module-Popup", you would add the line: AddToMenu "Module-Popup" "FvwmForm Defaults" FvwmForm FvwmForm-Form When you select "FvwmForm Defaults" from your module menu, a form is displayed that shows the current defaults and allows you to change them. If you activate the "Save Restart Me" button, the ".FvwmForm" file is written and "FvwmForm-Form" exits and restarts to show the new defaults. An example of what this file might contain after a save is: .... # This file last created by FvwmForm-Form on Sun Nov 28 11:18:26 EST 1999. *FvwmFormDefault: Font 10x20 *FvwmFormDefault: InputFont 8x13bold *FvwmFormDefault: ButtonFont 10x20 *FvwmFormDefault: TimeoutFont 10x20 *FvwmFormDefault: Fore white *FvwmFormDefault: Back cornflowerblue *FvwmFormDefault: Colorset -1 *FvwmFormDefault: ItemFore green *FvwmFormDefault: ItemBack gray40 *FvwmFormDefault: ItemColorset -1 *FvwmFormDefault: ButtonPointer hand2 *FvwmFormDefault: ButtonInPointer star *FvwmFormDefault: InputPointer gumby *FvwmFormDefault: ButtonPointerFore blue *FvwmFormDefault: ButtonPointerBack gray *FvwmFormDefault: ButtonInPointerFore gray *FvwmFormDefault: ButtonInPointerBack blue *FvwmFormDefault: InputPointerFore *FvwmFormDefault: InputPointerBack .... The commands in this file are just like any other FvwmForm command except that they start with "*FvwmFormDefault". FvwmForm only reads the file ".FvwmForm" the first time it is started or after the file is changed by "FvwmForm-Form". It does so by sending the command "*FvwmFormDefault: Read x". With "x" set to "y" or "n". "n" makes FvwmForm send a "read .FvwmForm quiet" command to fvwm. == VARIABLE SUBSTITUTION If you supply variables and values on the command line used to start FvwmForm (like this): Module FvwmForm MyForm ACTION=Browse "TITLE=Browse Form" Then all FvwmForm input commands undergo variable substitution. The variables from the command line are exported. Then every command gets expanded using the variables from the environment. For example, assuming the above invocation of "MyForm", commands would be changed like this: Before *MyForm: Text "$TITLE, Home $HOME, Going to $ACTION" After *MyForm: TEXT "Browse Form, Home /home/me, Going to Browse" Using this facility should make it possible for one form to be used for different sets of input data. == CONFIGURATION The following commands can be set in the .fvwm2rc file or thru any of the other ways that fvwm can accept commands. The simplest technique is to create a file in the read-only architecture-independent data directory, [PREFIX/share/fvwm] or your personal fvwm directory [$HOME/.fvwm], that matches the form alias. In the following paragraphs the string "FvwmForm" would normally be the form alias. FvwmForm reads commands before the form is ever displayed, and while the form is being displayed. The following commands are accepted before the form is displayed: Back Button ButtonFont ButtonInPointer ButtonInPointerFore ButtonInPointerBack ButtonPointer ButtonPointerFore ButtonPointerBack Choice Command Colorset Font Fore GrabServer Input InputFont InputPointer ItemBack ItemColorset ItemFore InputPointerFore InputPointerBack Line Message PadVText Position Selection Separator Text Timeout TimeoutFont Title UseData WarpPointer The following commands are accepted while the form is displayed: Map Stop UnMap The "Map", "UnMap" and "Stop" facility is under development and is currently not explained in this document, since it is likely to change. The order of the options DOES matter. The first background text color, "*FvwmFormBack", encountered before a displayable item sets the default background color for the entire form. Other than that, colors, fonts, text, choices and buttons can be intermixed in any order. The are no builtin limits on form size, number of items on a form, or number of fonts or colors used. **FvwmForm: GrabServer*:: This option makes FvwmForm grab the mouse pointer on startup. This feature is useful for things like logout verification. **FvwmForm: WarpPointer*:: This option makes FvwmForm warp the mouse pointer into its window on startup. It saves the user some mouse-travelling. **FvwmForm: Geometry ``_geometry_``*:: Specifies the FvwmForm window location. This is similar to what the Position option does but is more flexible. **FvwmForm: Position ``_x_ _y_``*:: Puts the FvwmForm window at location (_x_, _y_) on the screen. By convention, a negative _x_ (_y_) value measures distance from the right (bottom) of the screen. + If this option is omitted, FvwmForm starts at the center of the screen. **FvwmForm: Colorset ``_n_``*:: Tells the module to use colorset _n_. **FvwmForm: Back ``_color_``*:: Specifies the background color of the FvwmForm window and any text in the window. The first background color FvwmForm reads determines the overall screen background color. Switches off the Colorset option. See DEFAULTS. **FvwmForm: Fore ``_color_``*:: Specifies the foreground color for displaying text labels. Switches off the Colorset option. See DEFAULTS. **FvwmForm: ItemColorset ``_n_``*:: Tells the module to use colorset _n_ for items. **FvwmForm: ItemBack ``_color_``*:: Specifies the background color for the text input windows, and the buttons. Buttons are displayed as 3D depressable buttons. Inputs are displayed as 3D indented fields. Medium shade background colors work best. Switches off the ItemColorset option. See DEFAULTS. **FvwmForm: ItemFore ``_color_``*:: Specifies the foreground color for the text input strings and button text. Switches off the ItemColorset option. See DEFAULTS. **FvwmForm: Font ``_font_``*:: Specifies the font for displaying plain text. See DEFAULTS. **FvwmForm: ButtonFont ``_font_``*:: Specifies the font for text in the action buttons. See DEFAULTS. **FvwmForm: InputFont ``_font_``*:: Specifies the font for text input. See DEFAULTS. **FvwmForm: TimeoutFont ``_font_``*:: Specifies the font for display the timeout counter and related text. See DEFAULTS. **FvwmForm: Line ``_justification_``*:: Starts a new line. A line can contain any number of text, input, buttons and choice items. A FvwmForm window can have any number of lines. The width of the window is that of the longest line. + Justification of items in the line is specified by _justification_, which can be one of the following: + *``_left_``*::: Items are justified to the left of the window. *``_right_``*::: Items are justified to the right of the window. *``_center_``*::: Items are placed in the center of the window. *``_expand_``*::: If there is only one item in the line, the item is centered in the window. If two or more items are present, they are spread to fill the whole width of the window. **FvwmForm: Message*:: Defines a text area on the form that contains the last error message from fvwm. For purposes of determining form size, the message area is considered to be 80 bytes long. Its actual length is the same as the message received. If the message exceeds 80 bytes, you can see the rest of the message by resizing the form. + You should not attempt to put any text, buttons or input fields on the same line after a message field. Messages greater than 80 bytes will overlay the remainder of the line. **FvwmForm: PadVText ``_Pixels_``*:: The number of pixels used as vertical padding between text items, line to line. The default is 6 which looks good on lines containing text intermixed with input boxes, choices or buttons. + For straight text, such as might appear on a help form, padding of zero looks better. + (There are lots of other padding values used in form layout which can't currently be changed with commands.) **FvwmForm: Text ``_string_``*:: Displays _string_ as plain text. Line breaks must be achieved by multiple *FvwmForm: Line and *FvwmForm: Text options. Blanks may be used to provide extra padding between items. **FvwmForm: Title ``_string_``*:: Displays _string_ as the window's title. The string must be enclosed in double quotes. Using this command with anything other than a string enclosed in quotes creates a blank title. If this command is not used, the window title is the form alias. **FvwmForm: Input ``_name_ _size_ _init_string_``*:: Specifies a text input item with name _name_. A sub window of _size_ characters in width is used for editing. If _init_string_ is present, it is the initial string when FvwmForm starts or resets itself. The default initial string is "". + You can mouse paste into an input field using button 2. Buttons 1 and 3 move the cursor in an input field. + Input fields are always in insert mode, overtyping is not supported. + Emacs type keystrokes are supported. + Control-a, Home and Begin move to the front of an input field. Control-e and End move to the end of an input field. Control-b and Left move left in an input field. Control-f and Right move right in an input field. Control-p, Up, and Shift-Tab move to a previous input field if any, if the form has one input field, recall previous value. Control-n, Down, Return, Line-feed and Tab move to the next input field if any, if the form has one input field, for control-n and Down, restore previous input value. Control-h moves backward in an input field erasing a character. Control-d and Delete delete the next character in an input field. Control-k erases for the cursor to the end of an input field. Control-u erases the entire input field. + When a form executes a command, all the input values are saved in a ring of input history 50 items deep. + Meta(mod2)-"<" retrieves the previous value of an input field. Meta(mod2)-">" retrieves the next value of an input field. + (For forms with one input field, use the much easier arrow keys.) **FvwmForm: Selection ``_name_ _type_``*:: This option starts a selection item with name _name_. Its choices are specified in following configuration commands. The option _type_ is one of the following: + *``_single_``*::: The selections are mutually exclusive. + *``_multiple_``*::: This is a multiple-choice selection. **FvwmForm: Separator*:: Draws a 2 pixel shaded line across the form as a visual indication of a separate area. **FvwmForm: Choice ``_name_ _value_`` on | off ``_string_``*:: Specifies a choice for a proceeding selection. The choice item has a _name_ and a _value_ these are used in commands. See *FvwmForm: Command. The _string_ is displayed to the right of the choice button as a label. + The choice assumes the specified initial state ("on" means selected) when FvwmForm starts or resets. If the selections are mutually exclusive, FvwmForm does NOT detect inconsistencies in the initial states of the choices, i.e. two or none of the choices can be selected. However, once the user selects a choice, FvwmForm assures only one is selected. **FvwmForm: Button ``_type_ _string_`` [``_key_``]*:: This option specifies an action button. The button has _string_ as a label, and executes a set of Fvwm _command_ when it is activated. The commands are the following *FvwmForm: Commands. + The optional _key_ specifies a keyboard shortcut that activates the button. It is in either a control character, specified as ^@, ^A, ..., ^_, or a function key, specified as F1, F2, ..., F35. Control keys that are used for cursor movement in text input fields cannot activate any buttons, with the exception of TAB (^I), RETURN (^M), LINEFEED (^J), which can activate a button when the cursor is in the last text input field. + The behavior of the button is determined by _type_: + continue::: FvwmForm continues execution after sending the commands. restart::: After sending the commands, FvwmForm resets all the values to the initial ones, and then continues execution. quit::: FvwmForm quits after sending the commands. **FvwmForm: Command ``_command_``*:: This option specifies an Fvwm command associated with the current button. There can be more than one command attached to a button. Commands that appear before any *FvwmForm: Button option are executed at start-up time. This is usually a beep that gets the user's attention. + Commands starting with an exclamation mark (!) are executed by FvwmForm, all other commands are sent to Fvwm for execution. Before sending each command to Fvwm, FvwmForm recognizes variables of the following forms, and supply values to them. *$(``_name_``)*:: If _name_ corresponds to a text input field, the result is the user's input string. The special chars single-quote, double-quote and backslash are preceded by a backslash. + If _name_ corresponds to a choice, the result is the value of the choice (as specified in *FvwmForm: Choice) if the choice is selected. If the choice is not selected, the result is a blank string. + If _name_ corresponds to a selection, the result will be a list of the selected values of all its choices separated by spaces. *$(``_name_``?``_string_``)*:: If _name_ is a text input field and its value is not an empty string, the result is _string_, with recursive variable substitution applied. If the input value is empty, the result is empty. + If _name_ is a choice and it is selected, the result is _string_, with recursive variable substitution applied. If the choice is not selected, the result is empty. *$(``_name_``!``_string_``)*:: The same as the above, except that the converse conditions are taken. + When using the "?" and "!" forms to pass a string, the string is delimited by a right parenthesis. If you need to put a right parenthesis in a string, precede the right parenthesis with a backslash. **FvwmForm: UseData ``_datafile_ _leading_``*:: Tells FvwmForm to read a data file and extract data from module commands that match the "leading" argument and an input, choice, or selection variable in a form. + This lets a form display current fvwm module configuration data. For an example of how this works, examine the file "FvwmForm-Rlogin" which is installed in read-only architecture-independent data directory, [PREFIX/share/fvwm] and shown below. + For choices, the setting of the button is represented as the word "on", all other values for a setting are treated as off. + For selections, the setting of each choice button is determined by matching the current value of the selection against each choice. Currently, this only works correctly for selections that allow a single choice. **FvwmForm: ButtonPointer ``_pointername_``*:: Change the default mouse pointer (hand2) used when hovering over a button. The pointername must be one of the names defined in the include file X11/cursorfont.h (without the XC_ prefix). See DEFAULTS. **FvwmForm: ButtonInPointer ``_pointername_``*:: Change the default mouse pointer (hand1) used while a button is pressed in. The pointername must be one of the names defined in the include file X11/cursorfont.h (without the XC_ prefix). See DEFAULTS. **FvwmForm: InputPointer ``_pointername_``*:: Change the default mouse pointer (xterm) used while the pointer is over a text field. The pointername must be one of the names defined in the include file X11/cursorfont.h (without the XC_ prefix). See DEFAULTS. **FvwmForm: ButtonPointerFore|Back ``_color_``*:: Change the default mouse pointer foreground and background colors used when hovering over a button. See DEFAULTS. **FvwmForm: ButtonInPointerFore|Back ``_color_``*:: Change the default mouse pointer foreground and background colors used while a button is pressed in. See DEFAULTS. **FvwmForm: InputPointerFore|Back ``_color_``*:: Change the default mouse pointer foreground and background colors used while the pointer is over a text field. See DEFAULTS. **FvwmForm: Timeout ``_tenth_of_seconds_ _command_`` ``_"text"_``*:: Set up FvwmForm to time out after the amount of _tenth of seconds_ specified. When the timer hits zero, _command_ executes. The _text_ field is displayed much like a _Text_ field, except that a '%%' in the line is replaced automatically by the amount of time left on the timer. The value gets updated every tenth of second as the timer counts down. There can only be one timeout field per form. == EXAMPLES All of the following "examples" are installed in the read-only architecture-independent data directory, [PREFIX/share/fvwm], during fvwm installation. The following commands create a menu to invoke the examples: .... DestroyMenu Forms AddToMenu Forms "&Q. QuitVerify" Module FvwmForm FvwmForm-QuitVerify AddToMenu Forms "&C. Capture" Module FvwmForm FvwmForm-Capture AddToMenu Forms "&R. Rlogin" Module FvwmForm FvwmForm-Rlogin AddToMenu Forms "&T. Talk" Module FvwmForm FvwmForm-Talk .... == EXAMPLE 1 - Quit Verify This example simulates the mwm way of confirming logout. Return does the logout, Escape cancels logout. It times out after 20 seconds and performs the equivalent of the 'Logout' button. .... DestroyModuleConfig FvwmForm-QuitVerify: * *FvwmForm-QuitVerify: GrabServer *FvwmForm-QuitVerify: WarpPointer *FvwmForm-QuitVerify: Command Beep *FvwmForm-QuitVerify: Line center *FvwmForm-QuitVerify: Text "Do you really want to logout?" *FvwmForm-QuitVerify: Line expand *FvwmForm-QuitVerify: Button quit "Logout" ^M *FvwmForm-QuitVerify: Command Quit *FvwmForm-QuitVerify: Button restart "Restart" ^R *FvwmForm-QuitVerify: Command Restart *FvwmForm-QuitVerify: Button quit "Cancel" ^[ *FvwmForm-QuitVerify: Command Nop *FvwmForm-QuitVerify: Timeout 200 Quit "Automatic logout will occur in %% tenth of seconds." .... == EXAMPLE 2 - Remote Login This example lets the user type in a host name, an optional user name, and opens an xterm window from the remote host. .... DestroyModuleConfig FvwmForm-Rlogin: * *FvwmForm-Rlogin: WarpPointer *FvwmForm-Rlogin: Line center *FvwmForm-Rlogin: Text "Login to Remote Host" *FvwmForm-Rlogin: Line center *FvwmForm-Rlogin: Text "Host:" *FvwmForm-Rlogin: Input HostName 20 "" *FvwmForm-Rlogin: Line center *FvwmForm-Rlogin: Selection UserSel single *FvwmForm-Rlogin: Choice Default Default on "same user" *FvwmForm-Rlogin: Choice Custom Custom off "user:" *FvwmForm-Rlogin: Input UserName 10 "" *FvwmForm-Rlogin: Line expand *FvwmForm-Rlogin: Button quit "Login" ^M *FvwmForm-Rlogin: Command Exec exec ssh $(Custom?-l $(UserName)) $(HostName) xterm -T x term@$(HostName) -display $HOSTDISPLAY & # Before saving the data, remove any previously saved data: *FvwmForm-Rlogin: Command DestroyModuleConfig FvwmForm-RloginDefault: * # The "Login" button causes a login and a saving of the current data: *FvwmForm-Rlogin: Command !( /bin/echo \ "# Created by FvwmForm-Rlogin on: `/bin/date`."; /bin/echo \ '*FvwmForm-RloginDefault: HostName $(HostName)'; /bin/echo \ '*FvwmForm-RloginDefault: UserName $(UserName)'; /bin/echo \ '*FvwmForm-RloginDefault: Default $(Default?on)'; /bin/echo \ '*FvwmForm-RloginDefault: Custom $(Custom?on)' \ ) > ${FVWM_USERDIR}/.FvwmForm-Rlogin *FvwmForm-Rlogin: Button restart "Reset" *FvwmForm-Rlogin: Button quit "Cancel" ^[ *FvwmForm-Rlogin: Command Nop # Tell FvwmForm to read vars from the .FvwmForm-RloginDefault file: *FvwmForm-Rlogin: UseData .FvwmForm-Rlogin *FvwmForm-RloginDefault .... == EXAMPLE 3 - Capture Window This example provides a front-end to xwd, xwud, and xpr. .... DestroyModuleConfig FvwmForm-Capture: * *FvwmForm-Capture: Line center *FvwmForm-Capture: Text "Capture Window" *FvwmForm-Capture: Line left *FvwmForm-Capture: Text "File: " *FvwmForm-Capture: Input file 25 "/tmp/Capture" *FvwmForm-Capture: Line left *FvwmForm-Capture: Text "Printer: " *FvwmForm-Capture: Input printer 20 "$PRINTER" *FvwmForm-Capture: Line expand *FvwmForm-Capture: Selection PtrType single *FvwmForm-Capture: Choice PS ps on "PostScript" *FvwmForm-Capture: Choice Ljet ljet off "HP LaserJet" *FvwmForm-Capture: Line left *FvwmForm-Capture: Text "xwd options:" *FvwmForm-Capture: Line expand *FvwmForm-Capture: Selection Options multiple *FvwmForm-Capture: Choice Brd -nobdrs off "No border" *FvwmForm-Capture: Choice Frm -frame on "With frame" *FvwmForm-Capture: Choice XYZ -xy off "XY format" *FvwmForm-Capture: Line expand *FvwmForm-Capture: Button continue "Capture" ^M *FvwmForm-Capture: Command Exec exec xwd -out $(file) $(Options) & *FvwmForm-Capture: Button continue "Preview" *FvwmForm-Capture: Command Exec exec xwud -in $(file) & *FvwmForm-Capture: Button continue "Print" *FvwmForm-Capture: Command Exec exec xpr -device $(PtrType) $(file) | lpr -P $(printer) & *FvwmForm-Capture: Button quit "Quit" .... == EXAMPLE 4 - Talk Form This example provides a replacement for the module FvwmTalk. There are 2 forms, "FvwmForm-Talk." which executes commands, or sends commands to fvwm for execution, and "FvwmForm-TalkHelp." which is a help form. In the help form, notice how vertical line spacing is changed. Normal FvwmForm line spacing assumes text is intermixed with buttons, help forms require different spacing. .... # FvwmForm-Talk - Basic replacement for FvwmTalk DestroyModuleConfig FvwmForm-Talk: * *FvwmForm-Talk: WarpPointer # Layout *FvwmForm-Talk: Line center *FvwmForm-Talk: Text "Talk to Fvwm" *FvwmForm-Talk: Line left *FvwmForm-Talk: Text "Command:" *FvwmForm-Talk: Input Command 80 "" *FvwmForm-Talk: Line left *FvwmForm-Talk: Text "Msg:" *FvwmForm-Talk: Message *FvwmForm-Talk: Line center # Buttons *FvwmForm-Talk: Button restart "Return - Execute" ^M *FvwmForm-Talk: Command $(Command) *FvwmForm-Talk: Button continue "F1 - Help" F1 *FvwmForm-Talk: Command Module FvwmForm FvwmForm-TalkHelp *FvwmForm-Talk: Button restart "F3 - Reset input" F3 *FvwmForm-Talk: Command Nop *FvwmForm-Talk: Button quit "F4 - Dismiss" F4 *FvwmForm-Talk: Command Nop .... .... # FvwmForm-TalkHelp - Help Text for FvwmForm-Talk DestroyModuleConfig FvwmForm-TalkHelp: * *FvwmForm-TalkHelp: WarpPointer # Layout *FvwmForm-TalkHelp: Line center *FvwmForm-TalkHelp: Text "Talk to Fvwm - Help" *FvwmForm-TalkHelp: Line left *FvwmForm-TalkHelp: Text " " *FvwmForm-TalkHelp: Line left *FvwmForm-TalkHelp: PadVText 0 *FvwmForm-TalkHelp: Text "Enter commands in the *FvwmForm-TalkHelp: Line left *FvwmForm-TalkHelp: Text "Commands beginning with *FvwmForm-TalkHelp: Line left *FvwmForm-TalkHelp: Text "shell as a sub-process of the form." *FvwmForm-TalkHelp: Line left *FvwmForm-TalkHelp: Text "All other commands are sent to fvwm for execution." *FvwmForm-TalkHelp: Line left *FvwmForm-TalkHelp: Text "" *FvwmForm-TalkHelp: Line left *FvwmForm-TalkHelp: Text "Fvwm error messages are shown on the *FvwmForm-TalkHelp: Line left *FvwmForm-TalkHelp: Text "" # Buttons *FvwmForm-TalkHelp: Line center *FvwmForm-TalkHelp: Button quit "Return - Dismiss" ^M *FvwmForm-TalkHelp: Command Nop .... == BUGS AND LIMITATIONS FvwmForm is a fairly simple method of providing input. There is no input validation facility. FvwmForm has no way of dealing with lists. Report bugs to the fvwm-workers list. == COPYRIGHTS FvwmForm is original work of Thomas Zuwei Feng (ztfeng@math.princeton.edu). Copyright Feb 1995, Thomas Zuwei Feng. No guarantees or warranties are provided or implied in any way whatsoever. Use this program at your own risk. Permission to use, modify, and redistribute this program is hereby given, provided that this copyright is kept intact. == CHANGES During the fall of 1998, Dan Espen removed all form size limits, added unlimited font and color changing, form spacing control, configuration file reading, global control of appearance, synchronous command execution, Error message display, variable substitution, configurable pointers, and lots of other damage. No additional copyright is imposed. fvwm3-1.0.6a/doc/FvwmRearrange.adoc0000644000175000017500000001245214354105651016422 0ustar jaimosjaimos= FvwmRearrange(1) == NAME FvwmRearrange - rearrange fvwm windows == SYNOPSIS Module FvwmRearrange [-cascade | -tile] [options] [bounding box] FvwmRearrange is spawned by fvwm, so no command line invocation will work. == DESCRIPTION This module can be called to tile or cascade windows. When tiling the module attempts to tile windows on the current screen subject to certain constraints. Horizontal or vertical tiling is performed so that each window does not overlap another, and by default each window is resized to its nearest resize increment (note sometimes some space might appear between tiled windows -- this is why). When cascading the module attempts to cascade windows on the current screen subject to certain constraints. Layering is performed so consecutive windows will have their window titles visible underneath the previous. == INVOCATION FvwmRearrange is best invoked from a menu, pop up or button. There are a number of command line options which can be used to constrain the layering, these are described below. As an example case, one could call FvwmRearrange with the following arguments: .... FvwmRearrange -tile -h 10 10 90 90 .... or .... FvwmRearrange -cascade -resize 10 2 80 70 .... The first invocation will horizontally tile windows with a bounding box which starts at 10 by 10 percent into and down the screen and ends at 90 by 90 percent into and down the screen. The second invocation will cascade windows starting 10 by 2 percent into and down the screen. Windows will be constrained to 80 by 70 percent of the screen dimensions. Since the _resize_ is also specified, windows will be resized to the given constrained width and height. == OPTIONS -a:: Causes _all_ window types to be affected, even ones with the WindowListSkip style. -animate:: Attempt to do an animated move, this is ignored if _-resize_ or _-maximize_ are used. -cascade:: Cascade windows. This argument must be the first on the command line. This is the default. -desk:: Causes all windows on the desk to be cascaded/tiled instead of the current screen only. -flatx:: Inhibits border width increment. Only used when cascading. -flaty:: Inhibits border height increment. Only used when cascading. -h:: Tiles horizontally (default is to tile vertically). Used for tiling only. -incx arg:: Specifies a horizontal increment which is successively added to cascaded windows. _arg_ is a percentage of screen width, or pixel value if a _p_ is suffixed. Default is zero. Used only for cascading. -incy arg:: Specifies a vertical increment which is successively added to cascaded windows. _arg_ is a percentage of screen height, or pixel value if a _p_ is suffixed. Default is zero. Used only for cascading. -m:: Causes maximized windows to also be affected (implied by -a). -maximize:: When moving/resizing a window, put it also into maximized state. -mn arg:: Tiles up to _arg_ windows in tile direction. If more windows exist, a new direction row or column is created (in effect, a matrix is created). Used only when tiling windows. -noanimate:: Do not attempt to do an animated move. -nomaximize:: Do not put windows into maximized state. -noraise:: Inhibits window raising, leaving the depth ordering intact. -noresize:: Inhibits window resizing, leaving window sizes intact. This is the default when cascading windows. -nostretch:: If tiling: inhibits window growth to fit tile. Windows are shrunk to fit the tile but not expanded. If cascading: inhibits window expansion when using the -resize option. Windows will only shrink to fit the maximal width and height (if given). -r:: Reverses the window sequence. -resize:: Forces all windows to resize to the constrained width and height (if given). This is the default when tiling windows. -s:: Causes sticky windows to also be affected (implied by -a). -sp:: Causes windows sticky across pages to also be affected (implied by -a). -sd:: Causes windows sticky across desks to also be affected (implied by -a). -t:: Causes transient windows to also be affected (implied by -a). -tile:: Tile windows. This argument must be the first on the command line. -u:: Causes untitled windows to also be affected (implied by -a). -ewmhiwa:: When rearranging windows, make the calculation ignore the working area, such as EwmhBaseStruts; by default, FvwmRearrange will honour the working area. == BOUNDING BOX Up to four numbers can be placed on the command line that are not switches. The first pair specify an x and y offset to start the first window (default is 0, 0). The meaning of the second pair depends on operation mode: When tiling windows it specifies an absolute coordinate reference denoting the lower right bounding box for tiling. When cascading it specifies a maximal width and height for the layered windows. If an affected window exceeds either this width or height, it is resized to the maximal width or height. If any number is suffixed with the letter p, then it is taken to be a pixel value, otherwise it is interpreted as a screen percentage. Specifying zero for any parameter is equivalent to not specifying it. == BUGS It is probably not a good idea to delete windows while windows are being rearranged. == AUTHORS Andrew Veliath (original FvwmTile and FvwmCascade modules) Dominik Vogt (merged FvwmTile and FvwmCascade to FvwmRearrange) fvwm3-1.0.6a/doc/fvwm3styles.adoc0000644000175000017500000000013714354105651016157 0ustar jaimosjaimos= FVWM3STYLES(1) == NAME fvwm3styles - fvwm styles include::fvwm3_styles.ad[leveloffset=-1] fvwm3-1.0.6a/doc/fvwm-root.adoc0000644000175000017500000000654014354105651015615 0ustar jaimosjaimos= fvwm-root(1) == NAME fvwm-root - Sets the root window of the current X display to image == SYNOPSIS *fvwm-root* [**--retain-pixmap**|*-r*] [*--no-retain-pixmap*] [**--dummy**|*-d*] [*--no-dummy*] [*--dither*] [*--no-dither*] [*--color-limit* [_ncolors_] ] [*--no-color-limit*] [**--help**|**-h**|*-?*] [**--version**|*-V*] _image_file_ == DESCRIPTION _fvwm-root_ reads the image file specified in the command line and displays it in the root window. The supported image formats are _XBM_, _XPM_, _PNG_ and _SVG_ if appropriated libraries are compiled in. SVG rendering options (as described in the * ICONS AND IMAGES * section of the main fvwm documentation) can be utilized. == OPTIONS These command line options are recognized by fvwm-root: *--retain-pixmap* | *-r*:: Causes fvwm-root to retain and publish the Pixmap with which the background has been set (the ESETROOT_PMAP_ID and _XROOTPMAP_ID properties are used). This is useful for applications which want to use the root Pixmap on the background to simulate transparency (for example, Eterm and Aterm use this method). This option should also be used for the RootTransparent colorset option, refer to the COLORSETS section of fvwm(1). If this option is not used, fvwm-root sets the _XSETROOT_ID property to None, and some programs, like fvwm modules, may use this to update their background if the background is transparent (Transparent colorset). + Note, a well behaved program, like fvwm, should listen to both _XSETROOT_ID and _XROOTPMAP_ID property changes and update itself correspondingly. However some programs listen only to one of them, so you should either use this option or not depending on what part is implemented by these programs. You should also use this option to get fast root-transparent menus in fvwm. *--no-retain-pixmap*:: This is a default. May be useful to explicitly force the default even if "--retain-pixmap" is specified earlier. *--dummy* | *-d*:: Causes fvwm-root NOT to set the background, but to only free a memory associated with the ESETROOT_PMAP_ID property (if any). In any case the _XSETROOT_ID property is set to None. *--no-dummy*:: This is a default. May be useful to explicitly force the default even if "--dummy" is specified earlier. *--dither*:: Causes fvwm-root to dither images for "smoother" rendition on displays with color depth of 16 or lower. This the default with color depth less or equal to 8. *--no-dither*:: Causes fvwm-root NOT to dither images. This is the default with color depth greater than 8. **--color-limit **__ncolors__:: Causes fvwm-root to limit its color use to _ncolors_ (if specified). This option is taken in account only with color depth less or equal to 8 (and a TrueColor or GrayScale visual). The default is to use the same color limit as fvwm. So in normal situation this option is not useful. However, if fvwm use a private colors map, as fvwm-root always use the default colors map you should use this option for limiting colors correctly. If _ncolors_ is not specified a default is used. *--no-color-limit*:: Causes fvwm-root NOT to limit its color use. *--help*:: Shows a short usage. *--version*:: Shows a version number. == BUGS Repeated use of fvwm-root with different xpm pixmaps will use up slots in your color table pretty darn fast. == AUTHOR Rob Nation Rewritten and enhanced by fvwm-workers. fvwm3-1.0.6a/doc/FvwmCommand.adoc0000644000175000017500000000143214354105651016066 0ustar jaimosjaimos= FvwmConsole(1) :doctype: manpage :mantitle: FvwmCommand :manname: FvwmCommand :manvolnum: 1 :page-layout: base == NAME FvwmCommand - send commands to fvwm3. == SYNOPSIS FvwmCommand __command__ == DESCRIPTION FvwmCommand allows the user to send commands to fvwm3. This is useful for external use from shell-scripts or other languages. == INVOCATION FvwmCommand __command__ == CONFIGURATION OPTIONS FvwmCommand accepts the following command-line arguments: -c:: Read and send commands from stdin -f __filename__:: Use unix socket (__filename__) to connect to __FvwmMFL__ -i [infolevel]:: ---- 0 - default >0 - print output from FvwmMFL ---- -d:: Print detailed diagnostic messages -v:: Print version number. == AUTHOR FvwmCommand is the original work of Miroslav (NsCDE) fvwm3-1.0.6a/doc/fvwm-menu-desktop.adoc0000644000175000017500000003455614354105651017255 0ustar jaimosjaimos= fvwm-menu-desktop(1) == NAME fvwm-menu-desktop - Reads XDG menu files and creates Fvwm menus == SYNOPSIS fvwm-menu-desktop [ **--help**|*-h* ] [ *--version* ] [ *--install-prefix* _DIR_ ] [ *--desktop* _NAME_ ] [ *--menu-type* _NAME_ ] [ *--theme* _NAME_ ] [ **--with-titles**|*-w* ] [ *--without-titles* ] [ *--enable-mini-icons* ] [ **--size**|*-s* _NUM_ ] [ *--mini-icon-dir* _DIR_ ] [ *--app-icon* _NAME_ ] [ *--dir-icon* _NAME_ ] [ **--title**|*-t* _NAME_ ] [ *--insert-in-menu* _NAME_ ] [ *--get-menus* __all__|_desktop_ ] [ *--set-menus* _menu_paths_ ] [ *--all-menus* ] [ *--include-items* _NAME_ ] [ *--regen-cmd* _CMD_ ] [ *--term-cmd* _CMD_ ] [ *--dynamic* ] [ **--menu-error**|*-e* ] [ **--verbose**|*-v* ] == DESCRIPTION This is a python script which parses XDG menus definitions to build corresponding fvwm menus. This script depends on python-xdg to run. == OPTIONS Main Options:: --help:: Show the help and exit. --version:: Show the version and exit. --get-menus all|desktop:: Prints a space separated list of full menu paths found on the system. _all_ will print all menus found on the system except empty ones. _desktop_ will print the menu(s) that would be generated by the script. No menu generation is done. --desktop NAME:: Optional parameter to set the _NAME_ of the desktop XDG .menu file(s) to use. This option will override any default menus set via *FvwmForm-XDGMenu-Config* and cause the script to find menus in which _NAME_ is a part of the file name. Possible names are: _gnome_, _kde_, _xfce_, _lxde_, _debian_, etc. This option can be used in conjunction with *--menu-type* to control which .menu file(s) are used. --menu-type NAME:: Optional parameter to set the _NAME_ of the XDG menu type to use. This option will override any default menus set via *FvwmForm-XDGMenu-Config* and cause the script to find menus in which _NAME_ is a part of the file name. Possible _NAME_ types could be: _applications_, _settings_, _preferences_, etc. When used in conjunction with *--desktop*, only menus whose file name matches '*destkop*menutype*' are found. If no menus are found, the script exits with an error. --all-menus:: This option will build all menus found on the system. If used in conjunction with *--desktop* or *--menu-type* this will build all menus matching those settings. --install-prefix DIR:: Optional parameter to override the standard locations for XDG menu definitions. Tells *fvwm-menu-desktop* to look in _DIR_ for .menu files instead of the standard locations /etc/xdg/menus (and $HOME/.config/menus if it exists). --with-titles|-w:: If this option is set menus are generated with titles. This is the default. This option can be used to override the *FvwmForm-XDGMenu-Config* default setting. --without-titles:: If this option is set menus are generated without titles. The default is to generate with titles. --title|-t NAME :: Option to define the menu title _NAME_ of the top menu used by Fvwm's *Menu* or *Popup* commands. Default is "XDGMenu". --include-items NAME :: This option controls if the additional menu items 'Regenerate' and 'Configure' are included in the top level menu. _NAME_ can be one of _regenerate_, _config_, _both_, or _none_. The default is _both_. --regen-cmd CMD :: This option sets the fvwm command _CMD_ that is run when the menu item 'Regenerate' is selected. The default is "PipeRead `fvwm-menu-desktop`". --term-cmd CMD :: This option sets the terminal emulator command _CMD_ that is used to to run terminal applications in. _CMD_ needs to end with an execute option, such as xterm's -e option, which will run the command that is appended to _CMD_. The default is "xterm -e". --dynamic :: This option is to be used with creating dynamic menus using *DynamicPopUpAction* and *DynamicPopDownAction*. This adds a 'recreate' to the *DestroyMenu* command on the top level menu so those actions are not Destroyed when the menu is regenerated. --insert-in-menu NAME:: Option to insert generated menu(s) *IN* a menu _NAME_ (its top title). This option makes it so the top level menu is not Destroyed and the items are added to the end. Note menus regenerated with this option will append the menu items at the end of the existing menu. Each time the menu is regenerated new menu items appear giving a growing menu of duplicate items. You have to regenerate the whole menu via a function or restart fvwm. See *EXAMPLES* below for some solutions. --set-menus menu_paths:: Generates all menus listed in a space separated list of full menu paths. This option overrides any defaults and **--desktop**|*--menu-type* settings. --menu-error |-e:: If this option is present and python-xdg is not found, the script will print the error in the generated menu. Used in the default-config. --verbose:: Enables additional information printouts on STDERR. Icons Options:: By default, fvwm-menu-desktop builds menus without mini-icons. To enable mini-icons use the following options. If ImageMagick is installed on the system, the script will resize and copy the icons to $FVWM_USERDIR/.icons. This can take awhile. You should be prepared to wait the first time you generate the icons. Once the icons have been generated the script should run faster. If it is still to slow using icons, see *EXAMPLES* for ways to limit how often the menu is generated to speed things up. --enable-mini-icons:: This option enables mini-icons in the menus. If set, 24x24 mini-icons are used. If the specified icon isn't that size it will be converted if *ImageMagick* is installed and saved in $HOME/.fvwm/icons or to the directory specified with --mini-icon-dir option. Otherwise no icon appears in the menu for that entry. With most distributions, all the menu entries will have mini-icons appropriate to the application. --theme NAME:: Defines the used icon theme. Default is _gnome_ but all others found in /usr/share/icons could be used except the _hicolor_ theme because it's the default fallback theme if no icon is found. --size|-s NUM:: If --enable-mini-icons is used the _size_ of the icons can changed with this parameter. Default is 24. --mini-icon-dir DIR:: When the right size mini-icon isn't available, fvwm-menu-desktop creates icons with the right size in $HOME/.fvwm/icons. If you don't want to use the default directory, $HOME/.fvwm/icons, use this option to specify a different folder. --app-icon NAME:: Sets the default application icon if no others are found. Default is 'gnome-applications'. --dir-icon NAME:: Sets the default directory icon if no others are found. Default is 'gnome-fs-directory'. == USAGE *fvwm-menu-desktop* outputs XDG .menu files in the syntax of fvwm menus. When *fvwm-menu-desktop* is run with no options, it will load defaults from the *FvwmForm-XDGMenu-Config* file (see below) then search your system for suitable menu file(s). To see which menus are available on your system run: .... fvwm-menu-desktop --get-menus all .... If no menus are found you may not have any installed on your system. By default menus are stored as *.menu files in /etc/xdg/menus, $HOME/.config/menus or the location set in $XDG_MENU_PREFIX. You can use *--install-prefix* to specify another location search for menus. Though a combination of command line options and the *FvwmForm-XDGMenu-Config* settings, *fvwm-menu-desktop* can generate any combination of the menus found. To get a list of what menu(s) would be generated use the *--get-menus* _desktop_ option. The following will list all menus generated if *fvwm-menu-desktop* was run with no options. .... fvwm-menu-desktop --get-menus desktop .... *fvwm-menu-desktop* determines which menu(s) to generate as follows If no config file is found, all menus will be weighted and the script will generate the best (highest weight) menu found. If a config file is found (and override options are not used) the script will generate all menus selected in *FvwmForm-XDGMenu-Config*. *--desktop*, *--menu-type*, *--set-menus* and *--all-menus* will override any menus selected in *FvwmForm-XDGMenu-Config*. *--desktop* and *--menu-type* will only include menus whose name matches '*desktop*menutype*'. If used with *--all-menus*, all matching menus are generated. If used without *--all-menus*, only the highest weighted menu is generated. *--set-menus* generates menus from the list of full path menu file names. *--all-menus* by itself will generate all menus found. By default *fvwm-menu-desktop* will generate a menu whose top level name is "XDGMenu". To tell fvwm to read the output of *fvwm-menu-desktop* to create the menu XDGMenu add the following to your fvwm config file: .... PipeRead 'fvwm-menu-desktop' .... *Warning:* Depending on the options used this command may be slow and fvwm will pause until this command is complete. See *EXAMPLES* below for more details and possible workarounds. Once the menu is generated you can open the menu by using the command "Menu XDGMenu". You can also include this in the MenuFvwmRoot menu by: .... AddToMenu MenuFvwmRoot "XDG Menu" Popup XDGMenu .... *fvwm-menu-desktop* can be configured though both command line options and a *FvwmForm* GUI to customize the menu(s) that get generated. == GUI *FvwmForm-XDGMenu-Config* is a *FvwmForm* interface that can be used to configure the defaults for *fvwm-menu-desktop*. You can access this from the "Configure" item in the top level menu that is generated or run the following from within *FvwmConsole* .... Module FvwmPerl -l fvwm-menu-desktop-config.fpl .... This form can be used to select which menu(s) get generated by default along with setting many (but not all) of the available options. When you click "Save Settings" the form will write a config file located at $FVWM_USERDIR/.FvwmForm-XDGMenu-Config that *fvwm-menu-desktop* will parse for defaults when run. See the help inside of *FvwmForm-XDGMenu-Config* for more information. == EXAMPLES There are many ways to setup when fvwm runs *fvwm-menu-desktop* to generate the menu. One method is to just generate the menu when fvwm loads and then use the GUI config tool to change any options. To do this you only need to add the following to the fvwm config file: .... AddToMenu MenuFvwmRoot "XDG Menu" Popup XDGMenu PipeRead 'fvwm-menu-desktop' .... The menu is created once when fvwm loads. Since menu creation can sometimes be slow, this could cause fvwm to take longer to load than one wants. The menu is only generated when fvwm starts. If software is installed or removed you will have to select the 'Regenerate' option to rebuild the menu. One way to speed things up is to save the menu in a file and only generate the menu when 'Regenerate' is selected. To do this use *--regen-cmd* to call a custom function and write the menu to a file using a command like .... fvwm-menu-desktop --regen-cmd XDGRegen > $FVWM_USERDIR/.XDGMenu .... Then add the following to the fvwm config file to define the function XDGRegen. The second to last line will generate the menu if the menu file doesn't exist when fvwm starts. .... DestroyFunc XDGRegen AddToFunc XDGRegen + I PipeRead 'fvwm-menu-desktop --regen-cmd XDGRegen > \ $[FVWM_USERDIR]/.XDGMenu; echo "Nop"' + I Read $[FVWM_USERDIR]/.XDGMenu Test (!f $[FVWM_USERDIR]/.XDGMenu) XDGRegen Read $[FVWM_USERDIR]/.XDGMenu .... Besides creating a top level menu, *fvwm-menu-desktop* can insert the menu into an existing menu using the *--insert-in-menu* option. For example one could create the menu MenuFvwmRoot and include the XDG items at the end. .... DestroyMenu MenuFvwmRoot AddToMenu MenuFvwmRoot "Fvwm" Title + "Item1" Action1 ... + "ItemN" ActionN + "" Nop PipeRead 'fvwm-menu-desktop --insert-in-menu MenuFvwmRoot' .... In this case the menu items are inserted at the end of the MenuFvwmRoot menu. If no items are in the menu, this menu becomes MenuFvwmRoot. The problem here is, that you have to restart fvwm or rebuild the whole menu to Regenerate it because menu items cannot be removed. To do this you could use a function like .... DestroyFunc XDGRegen AddToFunc XDGRegen + I DestroyMenu MenuFvwmRoot + I AddToMenu MenuFvwmRoot "Fvwm" Title + I AddToMenu MenuFvwmRoot "Item1" Action1 ... + I AddToMenu MenuFvwmRoot "ItemN" ActionN + I AddToMenu MenuFvwmRoot "" Nop + I PipeRead 'fvwm-menu-desktop --insert-in-menu MenuFvwmRoot \ --regen-cmd XDGRegen' .... Fvwm can also create menus dynamically by using *DynamicPopUpAction* and/or *DynamicPopDownAction*. These commands when used with a Menu will run a Function when the menu is opened. For example one could create the menu XDGMenu when it is opened using .... AddToMenu XDGMenu "XDGMenu" Title + DynamicPopUpAction PipeRead 'fvwm-menu-desktop' .... This will create the menu when it is opened. One issue here is it will only create the menu the first time it is opened, and you still have to Regenerate the menu to see any changes. To create the menu each time it is open used the *--dynamic* option .... AddToMenu XDGMenu "XDGMenu" Title + DynamicPopUpAction PipeRead 'fvwm-menu-desktop \ --dynamic --include-items config' + DynamicPopDownAction DestroyMenu recreate XDGMenu .... This will now Destroy the menu when it closed so it can be rebuilt the next time it is opened. The recreate flag doesn't completely destroy the menu keeping the DynamicPopUpAction and DynamicPopDownAction actions. The *--dynamic* flag includes the recreate option in the generated menus. To insert a menu into MenuFvwmRoot and still be dynamic you need to use a function that generates the whole menu. For example .... DestroyFunc GenRootMenu AddToFunc GenRootMenu + I DestroyMenu recreate MenuFvwmRoot + I AddToMenu MenuFvwmRoot "Fvwm" Title + I AddToMenu MenuFvwmRoot "Item1" Action1 ... + I AddToMenu MenuFvwmRoot "ItemN" ActionN + I AddToMenu MenuFvwmRoot "" Nop + PipeRead `fvwm-menu-desktop --insert-in-menu MenuFvwmRoot \ --include-items config` AddToMenu MenuFvwmRoot "Fvwm" Title + DynamicPopUpAction GenRootMenu + DynamicPopDownAction DestroyMenu recreate MenuFvwmRoot .... == BUGS The whole process of creating menus from files is slow. Otherwise report bugs to the fvwm-workers mailing list . == AUTHORS This script is based on fvwm-xdg-menu.py written by Piotr Zielinski (http://www.cl.cam.ac.uk/~pz215/) who assigned Licence: GPL 2 Date: 03.12.2005. The script was reworked to replace the existing fvwm-menu-desktop perl script by the fvwm-workers. == COPYING The script is distributed by the same terms as fvwm itself. See GNU General Public License for details. fvwm3-1.0.6a/doc/fvwm-convert-2.6.adoc0000644000175000017500000000662714354105651016623 0ustar jaimosjaimos= fvwm-convert-2.6(1) == NAME fvwm-convert-2.6 - convert fvwm 2.4.x configuration file to fvwm 2.6 style == SYNOPSIS *fvwm-convert-2.6* [__--follow-read__|_-f_] [__--help__|_-h_] source [_dest_] == OPTIONS The following options are supported: --help | -h:: Prints a usage message to the screen. --follow-read | -f:: Follows files found along with the *Read* command. == DESCRIPTION *fvwm-convert-2.6* converts an fvwm 2.4.x configuration file into a fvwm 2.6 file with compatible syntax. It is not suitable to convert older 2.x configuration files. Please use *fvwm-convert-2.2* to convert these to the 2.2.x format first, and then if necessary *fvwm-convert-2.4* By default, *fvwm-convert-2.6* won't look for a given config file. This must be specified as the first parameter to *fvwm-convert-2.6.* Different source and destination files may be given. If the destination file already exists, this program exits. If no destination file is given, then the filename is the same name as the source file with the suffix ".converted" added. Without an absolute path given as the destination path to the destination file, the program will create the destination file in the CWD. *fvwm-convert-2.6* makes the following changes: *Style lines*:: In fvwm 2.4, most style options could be negated from their counterparts using NoFoo -- fvwm-convert-2.6 corrects this by now using !Foo. *ModulePath*:: In fvwm 2.4 and beyond, the ModulePath is compiled into fvwm. *fvwm-convert-2.6* comments out any ModulePath commands it finds. If you are using your own modules, (not the ones that come with fvwm), you will have to fix your configuration file after using *fvwm-convert-2.6*. *Conditional command syntax*:: In fvwm 2.4, the conditional command options were whitespace-separated -- they should now be comma-separated instead. In addition, the older syntax to Next and Prev of using [*] to denote all windows has been removed entirely. Both these checks and conversions are done on function commands, key/mouse bindings. *WindowShadeSteps*:: In fvwm 2.4, the WindowShadeSteps command is replaced by the WindowShadeSteps Style option. *fvwm-convert-2.6* makes this change. *FvwmTheme*:: In fvwm 2.6, the FvwmTheme module is replaced by a series of Colorset commands. Whilst *fvwm-convert-2.6* will try and make this change, it is still recommended that this is checked after conversion. *EdgeResistance*:: In fvwm 2.6, the EdgeResistance command is has been split to include an additional style option for EdgeMoveResistance. *fvwm-convert-2.6* makes any changes necessary. *StartFunction / RestartFunction / InitFunction*:: In fvwm 2.6, the need for using InitFunction and/or RestartFunction is redundant when StartFunction is read at both of these times. *fvwm-convert-2.6* attempts to convert this. *Read*:: If *-f* or *--follow-read* is given, any files *fvwm-convert-2.6* can detect and open will be converted automatically, else a list of files that can be followed are printed to the screen. == BUGS _InitFunction_ and _RestartFunction_ and hence _StartFunction_ are printed at the end of the files -- this slight reordering might put some comments before in an odd spot. When converting over FvwmTheme lines, the colorset definitions might well be broken, but these cannot easily be converted. Bug reports can be sent to the fvwm-workers mailing list (see the _FAQ_). == AUTHOR Thomas Adam fvwm3-1.0.6a/doc/fvwm3commands.adoc0000644000175000017500000000014214354105651016431 0ustar jaimosjaimos= FVWM3COMMANDS(1) == NAME fvwm3commands - fvwm built-in commands include::fvwm3_commands.ad[] fvwm3-1.0.6a/doc/FvwmConsole.adoc0000644000175000017500000000525014354105651016114 0ustar jaimosjaimos= FvwmConsole(1) :doctype: manpage :mantitle: FvwmConsole :manname: FvwmConsole :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmConsole - an fvwm command input interface == SYNOPSIS Module FvwmConsole [options] _FvwmConsole_ can only be invoked by fvwm. Command line invocation of the _FvwmConsole_ module will not work. == DESCRIPTION FvwmConsole allows the user to type fvwm configuration commands interactively, and have them executed immediately. This tool is particularly useful for testing new configuration ideas, or for implementing temporary changes to your environment. == INVOCATION FvwmConsole must be spawned as a module by fvwm. FvwmConsole takes all _xterm_(1) options. FvwmConsole can be invoked by inserting the line 'Module FvwmConsole' in the .fvwm2rc file. This can be placed on a line by itself, if FvwmConsole is to be spawned during fvwm's initialization, or can be bound to a menu or mouse button or keystroke to invoke it later. == CONFIGURATION OPTIONS FvwmConsole uses _xterm_(1). All resources set for xterm are inherited unless overridden by command line options. ____ Module FvwmConsole -g 40x10 -fg black -bg green3 ____ A different terminal emulator can be specified with the -terminal option. However, only terminal programs that understand the options -name, -title and -e can be used. ____ Module FvwmConsole -terminal rxvt ____ Previous versions of FvwmConsole supported a -e option to choose a different front-end. Although this option is still provided for backwards compatibility its use is discouraged unless you know exactly what you are doing. Also X resources can be set in your ~/.Xdefaults file: ____ FvwmConsole*VT100*geometry: 40x4 + FvwmConsole*font: 7x14 ____ == COMMAND EDITING If the GNU readline library is available, it can be used. Overwise a simple input reading function which doesn't have editing capabilities is used. For more details, refer GNU readline man and info pages. ____ Ctrl-A:: - beginning of line Ctrl-B:: - previous char Ctrl-D:: - delete char Ctrl-E:: - end of line Ctrl-F:: - next char Ctrl-H:: - backspace Ctrl-K:: - erase to the end of line Ctrl-N:: - next line Ctrl-P:: - previous line Ctrl-R:: - search reverse Ctrl-U:: - delete line Meta-B:: - previous word Meta-F:: - next word Esc <:: - beginning of history Esc >:: - end of history ____ == EXITING FvwmConsole can be stopped by entering the EOF character (usually CTRL-D). *Note!* Do not use the "quit" command, as this is an fvwm builtin: typing "quit" at the FvwmConsole command line will cause fvwm to exit. == SEE ALSO _xterm_(1), GNU Readline library == AUTHOR FvwmConsole is the original work of Toshi Isogai. fvwm3-1.0.6a/doc/FvwmIconMan.adoc0000644000175000017500000010542214354105651016040 0ustar jaimosjaimos= FvwmIconMan(1) :doctype: manpage :mantitle: FvwmIconMan :manname: FvwmIconMan :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmIconMan - an fvwm icon manager == SYNOPSIS FvwmIconMan is spawned by fvwm, so no command line invocation will work. == DESCRIPTION FvwmIconMan is an icon manager modeled after the TWM icon manager. The user may have multiple icon managers, each of which armed with a list of window types which it manages. For example, the user may have one manager which lists only emacs windows, and another which lists everything else. You may also specify what resolution each icon manager uses, for example, one icon manager may manage windows on all desks, and another may manage only those on the current desk, page or screen. FvwmIconMan can display the miniature icons provided by fvwm for its managed windows. The managers may have a maximum number of columns (and so grows vertically), a maximum number of rows (and then grows horizontally), or stay at a fixed size, and adjust the size of the window buttons to fit (think win95's Taskbar). And when support is compiled in for the X Shape extension, then the manager windows may be shaped. You can specify actions to be run when mouse, or key events are received. For example, you could bind the first mouse button to iconify the selected window, and make bindings for the arrow keys to navigate the manager window without the mouse. FvwmIconMan can be set to display which window currently has the keyboard focus, and by binding the select event (see below) to the fvwm Focus function, you can emulate the TWM icon manager's behavior. == INITIALIZATION During initialization, FvwmIconMan searches though the fvwm configuration file for the options which are described below. It is highly recommended that you make FvwmIconMan be a sticky window. And if you want to make use of the followfocus option, and/or binding an action to Focus, then you should make FvwmIconMan clicktofocus. Also, when using the Shape option, it's recommended that the FvwmIconMan window not be decorated at all by fvwm. == INVOCATION FvwmIconMan can be invoked by inserting the line 'Module FvwmIconMan' in the .fvwm2rc file. If FvwmIconMan is to be spawned during fvwm's initialization, then this line should be placed in the StartFunction declarations, or it can be bound to a menu, mouse button, or keystroke to invoke it later. If you wish to run FvwmIconMan in a transient mode, such as with the built in window list, then pass "-Transient" as an argument. The invocation "Module FvwmIconMan -Transient" will do nicely. In this mode, FvwmIconMan will pop up one manager window directly under the cursor. When the mouse button is released, it will execute the appropriate action, and then exit. Things are somewhat complicated by the fact that you can specify that FvwmIconMan creates multiple manager windows, behavior which is unsuitable when running transiently. So, when running transiently, FvwmIconMan will only create one manager window. Use the manager id 'transient' to specify options for this manager window. FvwmIconMan may accept an alias name as an argument. For example, "Module FvwmIconMan FvwmIconMan-Variant2". == CONFIGURATION OPTIONS REFERENCE CHART FvwmIconMan has acquired quite a few options. I assume others share my dislike of paging though a long man page, so here is a terse reference chart describing the available options. They are described in more detail in the next section. .... Name Description Default NumManagers number of managers 1 Action binds command to event Mouse 0 N sendcommand Iconify Background default background gray ButtonGeometry size of button in pixels Colorset default colorset DontShow list of windows to ignore DrawIcons use mini icons false FocusAndSelectButton flat grey black FocusAndSelectColorset FocusButton style for focused buttons up grey black FocusColorset FollowFocus show which win has focus false Font 8x13 Foreground default text color white Format describes button label "%c: %i" IconName manager icon name FvwmIconMan IconAndSelectButton up black grey IconAndSelectColorset IconButton style for icon buttons up black grey IconColorset ManagerGeometry size of manager in buttons 0x1 MaxButtonWidth max width of a button MaxButtonWidthByColumns NoIconAction animate iconification NOP PlainButton style for normal buttons up black grey PlainColorset ReliefThickness size of button relief 2 Resolution window filters desk page Reverse normal, icon or none none SelectButton style for selected buttons flat black grey SelectColorset Shape use shape extension false Show list of windows to show ShowOnlyIcons only icons visible false ShowNoIcons icons are not displayed false ShowTransient transient windows visible false ShowOnlyFocused only focused visible false Sort keep managers sorted name SortWeight weight for sorting Tips Tool Tips mode none TipsDelays Tool Tips mapping delays 1000 300 TipsFont Font for Tool Tips default fvwm font TipsColorset Tool Tips Colorset 0 TipsFormat describes Tips label the Format value TipsBorderWidth Tool Tips border size 1 TipsPlacement Tips placement vs button updown TipsJustification Tips Just vs button leftup TipsOffsets Tips placement Offsets 3 2 Title manager title FvwmIconMan TitleButton style for title button raisededge black grey TitleColorset UseWinList honor WinListSkip? true .... == CONFIGURATION OPTIONS With the exception of the nummanagers option, all of the options may be defined on a per-manager basis. So, for example, the user may have his emacs manager with a red foreground, and his xterm manager with a blue one. A configuration line may therefore have one of two forms: *FvwmIconMan: OptionName OptionValue:: To specify that the _OptionName_ takes the value _OptionValue_ for all managers. *FvwmIconMan: ManagerId OptionName OptionValue:: To specify that the option _OptionName_ takes the value _OptionValue_ for manager _ManagerId_. _ManagerId_ may either be a positive integer, or the string "transient". An integer id refers to managers which FvwmIconMan creates when running normally, and an id of "transient" refers to the single manager which FvwmIconMan creates when running transiently. The old syntax, that uses an asterisk instead of white spaces before _ManagerId_ and _OptionName_, is supported too, but it is obsolete now. The following options may be specified: *FvwmIconMan: NumManagers num:: _num_ is a positive integer specifying the total number of icon managers. Since FvwmIconMan would like to know how many managers there are before handling any manager specific options, this should come first. The default is 1. *FvwmIconMan: [id] Action type binding:: Binds an FvwmIconMan command to an event. _Type_ may be one of the values: Key, Mouse, or Select. Actions are described in the following section ACTIONS. *FvwmIconMan: [id] Background background:: Specifies the default background color. *FvwmIconMan: [id] ButtonGeometry geometry:: Specifies the initial geometry of an individual button in pixels. If the specified height is 0, then the button height is determined from the font size. X and Y coordinates are ignored. *FvwmIconMan: [id] Colorset colorset:: The default colorset used. Overrides background and foreground. *FvwmIconMan: [id] DrawIcons value:: If your version of fvwm is capable of using mini icons, then this option determines if FvwmIconMan displays the mini icons. Otherwise, it generates an error message. "true" means that mini icons are shown for iconified windows, "false" that mini icons are never shown, and "always" that mini icons are shown for all windows. *FvwmIconMan: [id] FocusAndSelectButton style [forecolor backcolor]:: Same as the plainbutton option, but specifies the look of buttons which are both selected, and have the keyboard focus. *FvwmIconMan: [id] FocusAndSelectColorset colorset:: Works like focusandselectbutton but uses colorsets instead. The style setting can still only be applied with focusandselectbutton. *FvwmIconMan: [id] FocusButton style [forecolor backcolor]:: Same as the plainbutton option, but specifies the look of buttons whose windows have the keyboard focus. *FvwmIconMan: [id] FocusColorset colorset:: Works like focusbutton but uses colorsets instead. The style setting can still only be applied with focusbutton. *FvwmIconMan: [id] FollowFocus boolean:: If _true_, then the button appearance reflects which window currently has focus. Default is false. *FvwmIconMan: [id] Font font:: Specifies the font to be used for labeling the buttons. The default is 8x13. *FvwmIconMan: [id] Foreground foreground:: Specifies the default foreground color. *FvwmIconMan: [id] Format formatstring:: A printf like format string which describes the string to be printed in the manager window for each managed window. Possible flags are: %t, %i, %c, and %r for the window's title, icon title, class, or resource name, respectively. The default is "%c: %i". *Warning*: m4 reserves the word _format_, so if you use m4, take appropriate action. *FvwmIconMan: [id] IconName iconstring:: Specifies the window icon name for that manager window. _Iconstring_ may either be a single word, or a string enclosed in quotes. The default is "FvwmIconMan". *FvwmIconMan: [id] IconAndSelectButton style [forecolor backcolor]:: Same as the plainbutton option, but specifies the look of buttons whose windows are iconified and the button is selected. *FvwmIconMan: [id] IconButton style [forecolor backcolor]:: Same as the plainbutton option, but specifies the look of buttons whose windows are iconified. *FvwmIconMan: [id] IconAndSelectColorset colorset:: Works like IconAndSelectButton but uses colorsets instead. The style setting can still only be applied with iconbutton. *FvwmIconMan: [id] IconColorset colorset:: Works like iconbutton but uses colorsets instead. The style setting can still only be applied with iconbutton. *FvwmIconMan: [id] ManagerGeometry geometry:: Specifies the initial geometry of the manager, in units of buttons. If _height_ is 0, then the manager will use _width_ columns, and will grow vertically once it has more than _width_ windows. Likewise, if _width_ is 0, it will use _height_ rows, and grow horizontally. If both are nonzero, then the manager window will be exactly that size, and stay that way. As columns are created, the buttons will narrow to accommodate. If the geometry is specified with a negative y coordinate, then the window manager will grow upwards. Otherwise, it will grow downwards. *FvwmIconMan: [id] MaxButtonWidth width:: Defines a maximum for the width of a button (in pixels). By default there is no maximum. A value of 0 resets the default. The maximum is only used with a non growing manager (the ManagerGeometry option specifies non zero width and height). *FvwmIconMan: [id] MaxButtonWidthByColumns col:: This is another way to set the button width. col is the number of columns of icons. The button width is determined by dividing the total width of FvwmIconMan by the number of columns. For example if the width of FvwmIconMan manager is 1024, MaxButtonWidthByColumns is 4 then MaxButtonWidth is 256. This is useful when you do not know, at config time, the width of the manager, for example, for a swallowed FvwmIconMan. *FvwmIconMan: [id] NoIconAction action:: Tells FvwmIconMan to do _action_ when a NoIcon style window is iconified or de-iconified. Relevant coordinates are appended to _action_ so that the icon can be traced to an FvwmIconMan button. An example action is "*FvwwmIconMan: NoIconAction SendToModule FvwmAnimate animate". A blank or null action turns this feature off. *FvwmIconMan: [id] PlainButton style [forecolor backcolor]:: Specifies how normal buttons look. _style_ may be one of _flat_, _up_, _down_, _raisededge_, or _sunkedge_, and describes how the button is drawn. The color options are both optional, and if not set, then the default colors are used. If on a monochrome screen, then the _style_ option is ignored, but must still be set. *FvwmIconMan: [id] PlainColorset colorset:: Works like plainbutton but uses colorsets instead. The style setting can still only be applied with plainbutton. *FvwmIconMan: [id] ReliefThickness num:: _num_ is an integer specifying the number of pixels thick that the relief at the edge of non-flat buttons should be. Setting this to 0 will produce flat buttons, as if the values for _FocusAndSelectButton_, _FocusButton_, _IconAndSelectButton_, _IconButton_, _PlainButton_, _SelectButton_, and _TitleButton_ were all set to _flat_. If _num_ is negative, the button will be inverted as if you had used _Reverse_ for all classes. *FvwmIconMan: [id] Resolution [_filter(s)_]:: Specifies a list of _filters_, separated by spaces, that configure which windows are displayed. If no filters are given, then all windows of the appropriate type are shown (see the show and dontshow options below). Each _filter_ then limits the windows that are displayed and may take one of the following values: desk, page, screen, !desk, !page, !screen, or invert. _desk_ only shows windows on the current desk, and _page_ only shows windows on the current page. _!desk_ and _!page_ only show windows not on the current desk or page respectively. _invert_ reverses the filter displaying the windows that did not match. + Notes: _page_ and _desk_ are independent. If the only filter is _page_, then you will see windows on the current page on all desks. To only see windows on the current page and desk (the default) you need both filters, 'desk page'. You can only have one of desk/!desk, page/!page, or screen/!screen, the last one issued take precedence. The invert filter reverses the whole filter so 'invert desk page' is not the same as '!desk !page'. Sticky windows are visible on all pages and desks, so they match all page and desk filters, but won't match the inverted filter. + The filters can take additional parameters to state which desk, page, or screen to show (or not show). _[!]desk [n]_ can take the desk number, which will only show windows (not) on the stated desk. _[!]page [x] [y]_ can take the horizontal, _x_, and vertical, _y_, page numbers, which will only show windows (not) on the stated page. + _[!]screen [S]_ shows windows (not) on monitor _S_, which can be: + > _NAME_: The "NAME" of the specific RandR monitor. + > _c_: The current RandR monitor (containing the pointer) + > _p_: The primary RandR monitor + > _g_: The global monitor + Since all windows are on the global monitor, _screen g_ effectively does nothing. _c_ is the current monitor at the time resolution is issued, and once set will not change. This filter is best used with a RandR _NAME_. + This configuration line is respected when FvwmIconMan is running as well, the resolution is changed dynamically when sent to fvwm. *FvwmIconMan: [id] Reverse class:: Causes certain classes of buttons to have their relief lines reversed so that up and down styles are reversed. This has no affect on flat buttons. The class can be icon, normal or none. The default is none. *FvwmIconMan: [id] SelectButton style [forecolor backcolor]:: Same as the plainbutton option, but specifies the look of buttons when the mouse is over them. *FvwmIconMan: [id] SelectColorset colorset:: Works like selectbutton but uses colorsets instead. The style setting can still only be applied with selectbutton. *FvwmIconMan: [id] Shape boolean:: If _True_, then use make the window shaped. Probably only useful if you have multiple columns or rows. If FvwmIconMan wasn't compiled to support the Shape extension, this generates an error message. When using shaped windows, it's recommended that a fvwm style is made for FvwmIconMan that has no borders. Otherwise, fvwm will get confused. *FvwmIconMan: [id] Sort value:: If _name_, then the manager list is sorted by name. If _namewithcase_, then it is sorted by name sensitive to case. If _id_, then the manager list is sorted by the window id, which never changes after the window is created. If _weighted_, then the manager list is sorted by weight (see the description of _sortweight_ below). Or it can be set to _none_, which results in no sorting. Default is _name_. *FvwmIconMan: [id] SortWeight weight pattern-list:: Assigns the specified _weight_ to windows that match _pattern-list_. The list is made up of patterns of the form _type=pattern_, where type is one of _class_, _resource_, _title_, or _icon_, and pattern is an expression of the same format used in the fvwm style command (minimalistic shell pattern matching). Multiple sort weights can be given. Each window is matched against the list of sort weights, in order, and is given the weight from the first match. Lower-weighted windows are placed first in the manager list. For example: + .... *FvwmIconMan: Sort weighted *FvwmIconMan: SortWeight 1 class=XTerm title=special* *FvwmIconMan: SortWeight 10 class=XTerm *FvwmIconMan: SortWeight 5 .... + In this example, xterm windows whose titles start with "special" (weight 1) are listed first, followed by everything but other xterms (weight 5), and the other xterms (weight 10) are listed last. If no default weight (empty pattern list) is given, the default weight is 0. Only relevant if the sort type is set to _weighted_. *FvwmIconMan: [id] Title title-string:: Specifies the window title string for that manager window. _Titlestring_ may either be a single word, or a string enclosed in quotes. The default is "FvwmIconMan". This will be drawn in the title bar of the manager window, if any, and in the title button, which is the button drawn when the manager is empty. *FvwmIconMan: [id] TitleButton style [forecolor backcolor]:: Same as the plainbutton option, but specifies the look of the title button (the button drawn when the manager is empty). The manager's title is drawn in the title button. *FvwmIconMan: [id] UseWinList boolean:: If _true_, then honor the WinListSkip style flag. Otherwise, all windows are subject to possible management according to the show and dontshow lists. The two following options control which windows get handled by which managers. A manager can get two lists, one of windows to show, and one of windows to ignore. If only the _show_ list is given, then that manager will show only the windows in the list. If only the _DontShow_ list is given, then the manager will show all windows except those in the list. If both lists are given, then a window will be shown if it is not in the _DontShow_ list, and in the _Show_ list. And finally, if neither list is given, then the manager will handle all windows. Each list is made up of patterns of the form _type=pattern_, where type is one of _class_, _resource_, _title_, or _icon_, and pattern is an expression of the same format used in the fvwm style command (minimalistic shell pattern matching). Quotes around the pattern will be taken as part of the expression. If a window could be handled by more than one manager, then the manager with the lowest id gets it. *FvwmIconMan: [id] Show pattern list:: If a window matches one of the patterns in the list, then it may be handled by this manager. *FvwmIconMan: [id] DontShow pattern list:: If a window matches one of the patterns in the list, then it may not be handled by this manager. *FvwmIconMan: [id] ShowTransient boolean:: Show transient windows in the list (default false). *FvwmIconMan: [id] ShowOnlyIcons boolean:: Only iconified windows are shown if _boolean_ is true. *FvwmIconMan: [id] ShowNoIcons boolean:: Only windows that are not iconified are shown if _boolean_ is true. *FvwmIconMan: [id] ShowOnlyFocused boolean:: Only window with the focus is shown if _boolean_ is true. The following two options control tips. *FvwmIconMan: [id] Tips value:: where _value_ can be always, needed or false. Default is false, no tips are displayed. With always, tips are enabled. With needed, a tip is displayed only if either the button string is truncated or the tip string is not equal to the button string. This configuration line is respected when FvwmIconMan is running as well. *FvwmIconMan: [id] TipsDelays delay [mappeddelay]:: where _delay_ and _mappeddelay_ are time out values in milliseconds. If no _mappeddelay_ is given _delay_ is assumed. Default is 1000 300. When the cursor is on a button, FvwmIconMan wait _delay_ milliseconds before displaying the tip. In the case where a tip is already mapped and the cursor goes to another button, FvwmIconMan waits _mappeddelay_ milliseconds before displaying the new tip. *FvwmIconMan: [id] TipsFont fontname:: Specifies the font to be used for tips. Default is the default fvwm font. *FvwmIconMan: [id] TipsColorset colorset:: Specifies the colors for tips window. Default is colorset 0. *FvwmIconMan: [id] TipsFormat formatstring:: Similar to the Format option but for the tips window. The default is the format string from the Format option. *FvwmIconMan: [id] TipsBorderWidth pixels:: Specifies the border width (in pixels) of the tips window. Default is 1. *FvwmIconMan: [id] TipsPlacement value:: where _value_ can be up, down, right, left, updown or leftright. This value specifies the position of the tips window relative to its button. Default is updown where buttons on the top half of the screen get tips below the button, otherwise the tips are above the button. *FvwmIconMan: [id] TipsJustification value:: where _value_ can be leftup, rightdown or center. Specifies the justification (direction) of the tips window relative to its button after the tips window has been placed. Default is leftup which means that if a tip is placed above or below its button, then the left border of the tip and of the button are aligned. If the tip is placed on the left or on the right of its button, leftup aligns the top borders. rightdown and center work like leftup but in different directions. The alignment is adjusted by the TipsOffset option. See next option. *FvwmIconMan: [id] TipsOffsets placementoffset justoffset:: where _placementoffset_ and _justoffset_ are offsets in pixels for the TipsPlacement and TipsJustification configuration option. Default is 3 2. == ACTIONS Actions are commands which may be bound to an event of the type: a key press, a mouse click, or the mouse entering a window manager button - denoted by the action types _Key_, _Mouse_, and _Select_. Normally, actions bound to a mouse click are executed when the button is pressed. In transient mode, the action is executed when the button is released, since it is assumed that FvwmIconMan was bound to some mouse event. A tip/warning: FvwmIconMan still keeps track of the mouse button and any modifier keys in this case, so if you bind FvwmIconMan to say, meta-button3, then it would be wise to ensure that the action you want to execute will be executed when the meta-button3 event occurs (which would be the button release, assuming you kept your finger on the meta key). The syntax for actions are: Key actions: Key Keysym Modifiers FunctionList:: _Keysym_ and _Modifiers_ are exactly the same as for the fvwm _Key_ command. Mouse actions: Mouse Button Modifiers FunctionList:: _Button_ and _Modifiers_ are exactly the same as for the fvwm _Mouse_ command. Select actions: Select FunctionList:: A _FunctionList_ is a sequence of commands separated by commas. They are executed in left to right order, in one shared context - which currently only contains a pointer to the "current" button. If a button is selected (typically by the mouse pointer sitting on it) when the action is executed, then the current button is initialized to that button. Otherwise, it points to nothing. Most of the available commands then modify this "current" button, either by moving it around, making it become the selected button, or sending commands to fvwm acting on the window represented by that button. Note that while this current button is initialized to be the selected button, the selected button does not implicitly follow it around. This way, the user can send commands to various windows, without changing which button is selected. Commands take five types of arguments: _Integer_, _Manager_, _Window_, _Button_, and _String_. A _String_ is a string specified exactly as for fvwm - either in quotes or as a single word not in quotes. Again, you may bind a sequence of commands to an event, by listing them separated by commas. _Window_ and _Button_ types look exactly the same in the .fvwm2rc file, but are interpreted as either specifying a managed window, or a FvwmIconMan button representing a window. They can either be an integer (which is interpreted module N where N is the number of buttons - so 0 is the first and -1 is the last), or one of the strings: _Select_, _Focus_, _Up_, _Down_, _Right_, _Left_, _Next_, _Prev_. _Select_ and _Focus_ refer to the currently selected or focused button or window. _Up_, _Down_, _Right_, and _Left_ refer to the button or window above, below, to the right of, or to the left of the current button in the manager window, allowing navigation around the manager window. _Next_ and _Prev_ designates the window, button, or manager after or before the current button, allowing navigation of the one dimensional list of windows which is drawn in the manager window. If the manager is sorted, _Next_ and _Prev_ move through the windows in the sorted order. The _Manager_ type can either be an integer, _Next_, or _Prev_. The meaning is analogous to that of the _Button_ type, but in terms of the integral index of the managers, restricted to managers which are nonempty. The following functions are currently defined: bif Button Integer/String:: A relative branch instruction. If _Button_ is _Select_ or _Focus_, then take the branch if there is a selected button or a focused button. If _Button_ is an integer, then branch if nonzero. If it is one of _Up_, _Down_, _Right_, _Left_, _Next_, _Prev_, then the branch is taken when the current button can move in that direction. If the branch is taken, then _Integer_ commands are skipped. No backwards branches are allowed. bifn Button Integer/String:: The complement of bif. The branch is taken if _Button_ evaluates to false, by the criteria listed for bif. gotobutton Button:: Sets current button to _Button_. If _Button_ is an integer, then the current button is set to _Button_ modulo the number of buttons, in the whichever manager contains the selected button, if any. gotomanager Manager:: Sets button to button 0 of _Manager_. This will only go to a visible, nonempty manager. So an integral argument is taken modulo the number of such managers. jmp Integer/String:: Executes a relative jump of _Integer_ instructions. Backwards jumps are not allowed. The jump is computed relative to the instruction following the jmp. label String:: Provides a label that previous instructions can jump to. It will not be visible to subsequent jump instructions, and the same label can be used multiple times in the same instruction list (though it would be perverse to do so.) print String:: Prints _String_ to the console. Useful for debugging actions. printdebug:: Prints defined actions to the console. Should only be used by developers. To enable this command, set CONFIG and FUNCTIONS variables to '1' in the modules/FvwmIconMan/debug.h and recompile this module. quit:: Quits FvwmIconMan. refresh:: Causes all manager windows to redraw themselves. ret:: Stop executing the entire action. searchback String:: Sets button to button before the current one whose printed string in the manager window matches specified _String_, which may contain wildcards. searchforward String:: Sets button to button after the current one whose printed string in the manager window matches specified _String_, which may contain wildcards. select:: Selects the current button, if any. If a select action has been specified, it will then be run. Therefore, it is considered unwise to set the select button in the select action. sendcommand Command:: Sends the fvwm command _Command_ to the window represented by the current button, if any. warp:: Warps cursor to current button, if any. *Examples:* gotobutton select, gotobutton Down, select Selects the button below the currently selected button. Since the current button is already initialized to the selected button, this may be shortened to "gotobutton Down, select". gotobutton Up, select Selects the button above the currently selected button. gotobutton 0, select Selects the first button of the current manager. If there is no current manager, which is the case when no button is selected, then this does nothing. gotobutton -1, select Selects the last button of the current manager. gotobutton focus, select Selects the button corresponding to the focused window. gotobutton focus, Iconify Sends the fvwm command Iconify to the focused window. Note that this does not change the selected button. bif Next 3, gotobutton 0, select, ret, gotobutton Next, select If a button is selected, and it's the last button, go to button 0. If it's not the last button, go to the next button. Otherwise, do nothing. Basically, this action cycles through all buttons in the current manager. bif select 7, bif focus 3, gotomanager 0, select, ret, gotobutton focus, \ select, ret, gotobutton down, select This is good for sending to FvwmIconMan with a SendToModule command. If there is a selected button, it moves down. Otherwise, if there is a focused button, it is selected. Otherwise, button 0 of manager 0 gets selected. bif select Select, bif focus Focus, gotomanager 0, select, ret, label Focus, \ gotobutton focus, select, ret, label Select, gotobutton down, select Same as previous, but using the label instruction. In addition to being bound to keys and mice, actions can be sent from fvwm to FvwmIconMan via the SendToModule command. Don't quote the command when using SendToModule. Also, due to a bug in the current version of fvwm, don't quote FvwmIconMan either. == SAMPLE CONFIGURATIONS This first example is of a the simplest invocation of FvwmIconMan, which only has one manager, and handles all windows: .... ############################################################## # Load any modules which should be started during # fvwm initialization ModulePath /usr/lib/X11/fvwm:/usr/bin/X11 Module FvwmIconMan # Make FvwmIconMan title-bar-less, sticky, and give it an icon Style "Fvwm*" Icon toolbox.xpm,NoTitle,NoHandles,Sticky Style "FvwmIconMan" HandleWidth 5, Handles, BorderWidth 5 ############################################################## ############################################################## #Definitions used by the modules *FvwmIconMan: NumManagers 1 *FvwmIconMan: Resolution global *FvwmIconMan: Background slategrey *FvwmIconMan: Foreground white *FvwmIconMan: Font 7x13 *FvwmIconMan: ButtonGeometry 100x0 *FvwmIconMan: ManagerGeometry 1x0-0+0 .... This example is the Reader's Digest version of my personal configuration. It has two managers, one for emacs and one for everything else, minus things with no icon title. Only windows on the current page are displayed. The use of the _drawicons_ and _shape_ options requires that fvwm and FvwmIconMan are compiled with the correct options. Note how the geometry and show options are specified per manager, and the others are common to all: .... Style "FvwmIconMan" NoTitle, Sticky, WindowListSkip, BorderWidth 0 Style "FvwmIconMan" HandleWidth 0 Key F8 A N SendToModule FvwmIconMan bif select Select, bif focus Focus, \ gotomanager 0, select, sendcommand WarpToWindow, ret, label Focus, \ gotobutton focus, select, sendcommand WarpToWindow, ret, label Select, \ gotobutton prev, select, sendcommand WarpToWindow Key F9 A N SendToModule FvwmIconMan bif select Select, bif focus Focus, \ gotomanager 0, select, sendcommand WarpToWindow, ret, label Focus, \ gotobutton focus, select, sendcommand WarpToWindow, ret, label Select, \ gotobutton next, select, sendcommand WarpToWindow *FvwmIconMan: NumManagers 2 *FvwmIconMan: Resolution page *FvwmIconMan: Background steelblue *FvwmIconMan: Foreground white *FvwmIconMan: Font 7x13 *FvwmIconMan: UseWinList true *FvwmIconMan: DrawIcons true *FvwmIconMan: Shape true *FvwmIconMan: FollowFocus true *FvwmIconMan: Sort name *FvwmIconMan: PlainButton up white steelblue *FvwmIconMan: SelectButton down white steelblue *FvwmIconMan: FocusButton up white brown *FvwmIconMan: FocusAndSelectButton down white brown *FvwmIconMan: TitleButton raisededge white steelblue *FvwmIconMan: NoIconAction "SendToModule FvwmAnimate animate" *FvwmIconMan: 1 Title "Emacs windows" *FvwmIconMan: 1 IconName "FvwmIconMan: Emacs" *FvwmIconMan: 1 Format "%i" *FvwmIconMan: 1 Show resource=emacs resource=gemacs *FvwmIconMan: 1 ManagerGeometry 1x0-400+0 *FvwmIconMan: 1 ButtonGeometry 200x0 *FvwmIconMan: 2 Title "All windows" *FvwmIconMan: 2 IconName "FvwmIconMan: all" *FvwmIconMan: 2 Format "%c: %i" *FvwmIconMan: 2 DontShow icon=Untitled *FvwmIconMan: 2 ManagerGeometry 2x4-0+0 *FvwmIconMan: 2 ButtonGeometry 200x0 *FvwmIconMan: transient Geometry 194x100 *FvwmIconMan: transient DontShow icon=Untitled *FvwmIconMan: transient Action Mouse 0 A sendcommand select select Iconify *FvwmIconMan: Action Mouse 1 N sendcommand Iconify *FvwmIconMan: Action Mouse 2 N sendcommand WarpToWindow *FvwmIconMan: Action Mouse 3 N sendcommand "Module FvwmIdent FvwmIdent" *FvwmIconMan: Action Key Left N gotobutton Left, select *FvwmIconMan: Action Key Right N gotobutton Right, select *FvwmIconMan: Action Key Up N gotobutton Up, select *FvwmIconMan: Action Key Down N gotobutton Down, select *FvwmIconMan: Action Key q N quit .... == UNFINISHED BUSINESS There is one bug that I know of. A honest to goodness solution to this would be appreciated. When an icon manager is set to grow upwards or leftwards, on some machines it may wander occasionally. It doesn't handle windows without resource names as gracefully as it should. == AUTHOR Brady Montz (bradym@cs.arizona.edu). == THANKS .... Thanks to: David Berson , Gren Klanderman , David Goldberg , Pete Forman , Neil Moore , Josh M. Osborne , Chris Siebenmann , Bjorn Victor . for contributing either code or truly keen ideas. .... fvwm3-1.0.6a/doc/fvwm3all.adoc0000644000175000017500000000077314354105651015412 0ustar jaimosjaimos= FVWM3ALL(1) == NAME fvwm3all - F? Virtual Window Manager for X11 - meta-man page == OVERVIEW fvwm3 contains many features. Because of this, the documentation is split into a number of different sections. This man page contains all those sections which can also be found in these separate manpages: *fvwm3commands* builtin fvwm3commands. + *fvwm3menus* commands/options relating to fvwm3menus. + *fvwm3styles* style options for handling windows, menus, etc. include::fvwm3_manpage_source.adoc[] fvwm3-1.0.6a/doc/FvwmBacker.adoc0000644000175000017500000001240014354105651015674 0ustar jaimosjaimos= FvwmBacker(1) :doctype: manpage :mantitle: FvwmBacker :manname: FvwmBacker :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmBacker - the fvwm background changer module == SYNOPSIS Module FvwmBacker _FvwmBacker_ can only be invoked by fvwm. Command line invocation of the _FvwmBacker_ module will not work. == DESCRIPTION The FvwmBacker module provides functionality to change the background when changing desktops. Any command can be executed to change the backgrounds. Actually, any arbitrary command can be sent to fvwm to execute, so you could also do things such as changing window border colors, etc. == COPYRIGHTS The FvwmBacker module is the original work of Mike Finger. Copyright 1994, Mike Finger. The author makes no guarantees or warranties of any kind about the use of this module. Use this module at your own risk. You may freely use this module or any portion of it for any purpose as long as the copyright is kept intact. == INITIALIZATION During initialization, _FvwmBacker_ gets config info from *fvwm*'s module configuration database (see _fvwm_(1), section *MODULE COMMANDS*). Available options are discussed in a later section. == INVOCATION FvwmBacker can be invoked by fvwm during initialization by inserting the line .... AddToFunc StartFunction I Module FvwmBacker .... in the .fvwm2rc file. FvwmBacker can be started using a 'Module FvwmBacker' command or stopped using a 'KillModule FvwmBacker' command at any time when fvwm is running. FvwmBacker must reside in a directory that is listed in the ModulePath option of fvwm for it to be executed by fvwm. == CONFIGURATION OPTIONS The following options can be placed in the .fvwm2rc file *FvwmBacker: Command (Desk d, Page x y) command:: Specifies the _command_ to execute when the viewport matches the arguments for the desk d, page x coordinate and y coordinate. Any or all of these three numeric arguments can be replaced with an asterisk (*) to indicate that any value matches, in this case Desk or Page parts can be skipped. + If either the _Desk_ or the _Page_ parts are omitted, the command is not executed if only the desk or the page is switched. If neither is given, the command is executed only once when the module is started. This is not the same as using asterisks for the numeric arguments: if asterisks are used, the command is always executed when only the desk or page changes, if the corresponding part is omitted, the command is never executed when only the desk or page changes. + If the _command_ is _-solid_ FvwmBacker uses the next argument as a color in the X database and sets the background to that color without generating a system call to xsetroot (only single word color names may be used). + If the _command_ is _colorset_ FvwmBacker uses the background specified in colorset _n_ for the given desk. Please refer to the fvwm man page for details about colorsets. + Otherwise the command is sent to fvwm to execute. *FvwmBacker: RetainPixmap:: Causes FvwmBacker to retain and publish the Pixmap with which the background has been set. This works only for the _-solid_ or _colorset_ commands. This is useful for applications which want to use the root Pixmap on the background to simulate transparency (for example, Eterm and Aterm use this method). This option should also be used for the RootTransparent colorset option. Note: with a colorset background this command may add a lot of memory to the X server. For example, this adds the pixmap width times height bytes with a TiledPixmap image, screen_width times screen_height bytes with a Pixmap image or a C,B,D,R,S or Y Gradient and screen_width bytes with a VGradient or screen height bytes with an HGradient. *FvwmBacker: DoNotRetainPixmap:: Cancels the effect of the previous option. This is the default. == RUN-TIME CONFIGURATION It it possible to replace FvwmBacker's configuration at run-time, although it is not yet possible to remove existing configuration lines. This is done by simply removing the old configuration from within fvwm and then read a new one. This can be done in many ways, for example by using an fvwm function or one of the modules *FvwmCommand* or *FvwmConsole*. Example: .... DestroyModuleConfig FvwmBacker* *FvwmBacker: Command (Desk 0) -solid black *FvwmBacker: Command (Desk 1) -solid blue .... == OLD-STYLE OPTIONS There is continued support for the now deprecated option: *FvwmBacker: Desk d command:: It is functionally equivalent to omitting the page coordinates with _*FvwmBacker: Command_: .... *FvwmBacker: Command (Desk Id) command .... == SAMPLE CONFIGURATION The following are excerpts from an .fvwm2rc file which describe FvwmBacker initialization commands: .... #### # Set Up Backgrounds for different desktop pages (2 desks, 3x2 pages). #### *FvwmBacker: Command (Page 2 *) -solid steelblue *FvwmBacker: Command (Desk 0, Page 0 0) Exec fvwm-root $[HOME]/bg2.xpm *FvwmBacker: Command (Desk 0, Page 0 1) -solid midnightblue *FvwmBacker: Command (Desk 0, Page 1 *) -solid yellow *FvwmBacker: Command (Desk 1, Page * 0) -solid navy *FvwmBacker: Command (Desk 1, Page * 1) Colorset 5 .... == AUTHOR Mike Finger (mfinger@mermaid.micro.umn.edu) == Modified by Andrew Davison (davison@cs.monash.edu.au) Michael Han (mikehan@best.com) Mikhael Goikhman (migo@homemail.com) fvwm3-1.0.6a/doc/fvwm3menus.adoc0000644000175000017500000000011514354105651015757 0ustar jaimosjaimos= FVWM3MENUS(1) == NAME fvwm3menus - fvwm menus include::fvwm3_menus.ad[] fvwm3-1.0.6a/doc/Makefile.in0000644000175000017500000004420314361325105015064 0ustar jaimosjaimos# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. @SET_MAKE@ VPATH = @srcdir@ am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ pkglibexecdir = $(libexecdir)/@PACKAGE@ am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ subdir = doc ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \ $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = AM_V_P = $(am__v_P_@AM_V@) am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) am__v_P_0 = false am__v_P_1 = : AM_V_GEN = $(am__v_GEN_@AM_V@) am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) am__v_GEN_0 = @echo " GEN " $@; am__v_GEN_1 = AM_V_at = $(am__v_at_@AM_V@) am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) am__v_at_0 = @ am__v_at_1 = SOURCES = DIST_SOURCES = am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; am__vpath_adj = case $$p in \ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ *) f=$$p;; \ esac; am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; am__install_max = 40 am__nobase_strip_setup = \ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` am__nobase_strip = \ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" am__nobase_list = $(am__nobase_strip_setup); \ for p in $$list; do echo "$$p $$p"; done | \ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ if (++n[$$2] == $(am__install_max)) \ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ END { for (dir in files) print dir, files[dir] }' am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' am__uninstall_files_from_dir = { \ test -z "$$files" \ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ $(am__cd) "$$dir" && rm -f $$files; }; \ } man1dir = $(mandir)/man1 am__installdirs = "$(DESTDIR)$(man1dir)" NROFF = nroff MANS = $(man1_MANS) am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) am__DIST_COMMON = $(srcdir)/Makefile.in README DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ ALL_DOMAINS = @ALL_DOMAINS@ ALL_LINGUAS = @ALL_LINGUAS@ AMTAR = @AMTAR@ AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AR_FLAGS = @AR_FLAGS@ ASCIIDOC = @ASCIIDOC@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ Bidi_CFLAGS = @Bidi_CFLAGS@ Bidi_LIBS = @Bidi_LIBS@ CATALOGS = @CATALOGS@ CATOBJEXT = @CATOBJEXT@ CC = @CC@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ CYGPATH_W = @CYGPATH_W@ DEFS = @DEFS@ DEPDIR = @DEPDIR@ DUMMYPOFILES = @DUMMYPOFILES@ ECHO_C = @ECHO_C@ ECHO_N = @ECHO_N@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ ETAGS = @ETAGS@ EXEEXT = @EXEEXT@ FC_CFLAGS = @FC_CFLAGS@ FC_CONFIG = @FC_CONFIG@ FC_LIBS = @FC_LIBS@ FRIBIDI_CONFIG = @FRIBIDI_CONFIG@ FVWMHOMEPAGE = @FVWMHOMEPAGE@ FVWMLIST = @FVWMLIST@ FVWMNAMELONG = @FVWMNAMELONG@ FVWMSCRIPT_DOMAIN = @FVWMSCRIPT_DOMAIN@ FVWMTASKBAR_DOMAIN = @FVWMTASKBAR_DOMAIN@ FVWMWORKERSLIST = @FVWMWORKERSLIST@ FVWMWORKERSLISTLONG = @FVWMWORKERSLISTLONG@ FVWM_CONFDIR = @FVWM_CONFDIR@ FVWM_DATADIR = @FVWM_DATADIR@ FVWM_DOCDIR = @FVWM_DOCDIR@ FVWM_DOMAIN = @FVWM_DOMAIN@ FVWM_IMAGEPATH = @FVWM_IMAGEPATH@ FVWM_MODULEDIR = @FVWM_MODULEDIR@ FVWM_PERLLIB = @FVWM_PERLLIB@ FVWM_PERLLIBDIR = @FVWM_PERLLIBDIR@ GMOFILES = @GMOFILES@ GMSGFMT = @GMSGFMT@ GO = @GO@ GREP = @GREP@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ INST_LINGUAS = @INST_LINGUAS@ ISRELEASED = @ISRELEASED@ LDFLAGS = @LDFLAGS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LN_S = @LN_S@ LOCALEDIR = @LOCALEDIR@ LTLIBOBJS = @LTLIBOBJS@ MAKEINFO = @MAKEINFO@ MANPAGE_PREAMBLE = @MANPAGE_PREAMBLE@ MKDIR_P = @MKDIR_P@ MKINSTALLDIRS = @MKINSTALLDIRS@ MSGFMT = @MSGFMT@ MSGMERGE = @MSGMERGE@ MSGUNIQ = @MSGUNIQ@ OBJEXT = @OBJEXT@ PACKAGE = @PACKAGE@ PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ PERL = @PERL@ PKG_CONFIG = @PKG_CONFIG@ PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ POFILES = @POFILES@ POSUB = @POSUB@ PYTHON = @PYTHON@ RANLIB = @RANLIB@ RELDATELONG = @RELDATELONG@ RELDATENUM = @RELDATENUM@ RELDATESHORT = @RELDATESHORT@ REQUIRED_PERL_VERSION = @REQUIRED_PERL_VERSION@ REQUIRED_PYTHON_VERSION = @REQUIRED_PYTHON_VERSION@ SED = @SED@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ UPDATEPOFILES = @UPDATEPOFILES@ USE_NLS = @USE_NLS@ VERSION = @VERSION@ VERSIONINFO = @VERSIONINFO@ XFT_CFLAGS = @XFT_CFLAGS@ XFT_CONFIG = @XFT_CONFIG@ XFT_LIBS = @XFT_LIBS@ XGETTEXT = @XGETTEXT@ XMKMF = @XMKMF@ XRandR_CFLAGS = @XRandR_CFLAGS@ XRandR_LIBS = @XRandR_LIBS@ X_CFLAGS = @X_CFLAGS@ X_EXTRA_LIBS = @X_EXTRA_LIBS@ X_LIBS = @X_LIBS@ X_PRE_LIBS = @X_PRE_LIBS@ Xcursor_CFLAGS = @Xcursor_CFLAGS@ Xcursor_LIBS = @Xcursor_LIBS@ Xft_CFLAGS = @Xft_CFLAGS@ Xft_LIBS = @Xft_LIBS@ Xrender_CFLAGS = @Xrender_CFLAGS@ Xrender_LIBS = @Xrender_LIBS@ abs_builddir = @abs_builddir@ abs_srcdir = @abs_srcdir@ abs_top_builddir = @abs_top_builddir@ abs_top_srcdir = @abs_top_srcdir@ ac_ct_CC = @ac_ct_CC@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ am__tar = @am__tar@ am__untar = @am__untar@ bindir = @bindir@ build = @build@ build_alias = @build_alias@ build_cpu = @build_cpu@ build_os = @build_os@ build_vendor = @build_vendor@ builddir = @builddir@ datadir = @datadir@ datarootdir = @datarootdir@ docdir = @FVWM_DOCDIR@ dvidir = @dvidir@ exec_prefix = @exec_prefix@ freetype_CFLAGS = @freetype_CFLAGS@ freetype_LIBS = @freetype_LIBS@ host = @host@ host_alias = @host_alias@ host_cpu = @host_cpu@ host_os = @host_os@ host_vendor = @host_vendor@ htmldir = @htmldir@ iconv_CFLAGS = @iconv_CFLAGS@ iconv_LIBS = @iconv_LIBS@ includedir = @includedir@ infodir = @infodir@ install_sh = @install_sh@ intl_CFLAGS = @intl_CFLAGS@ intl_LIBS = @intl_LIBS@ libdir = @libdir@ libevent_CFLAGS = @libevent_CFLAGS@ libevent_LIBS = @libevent_LIBS@ libexecdir = @libexecdir@ localedir = @localedir@ localstatedir = @localstatedir@ mandir = @mandir@ mkdir_p = @mkdir_p@ oldincludedir = @oldincludedir@ pdfdir = @pdfdir@ png_CFLAGS = @png_CFLAGS@ png_LIBS = @png_LIBS@ prefix = @prefix@ program_transform_name = @program_transform_name@ psdir = @psdir@ readline_CFLAGS = @readline_CFLAGS@ readline_LIBS = @readline_LIBS@ rsvg_CFLAGS = @rsvg_CFLAGS@ rsvg_LIBS = @rsvg_LIBS@ runstatedir = @runstatedir@ sbindir = @sbindir@ sharedstatedir = @sharedstatedir@ srcdir = @srcdir@ sysconfdir = @sysconfdir@ target_alias = @target_alias@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ xpm_CFLAGS = @xpm_CFLAGS@ xpm_LIBS = @xpm_LIBS@ xrandr_CFLAGS = @xrandr_CFLAGS@ xrandr_LIBS = @xrandr_LIBS@ xt_CFLAGS = @xt_CFLAGS@ xt_LIBS = @xt_LIBS@ MODULE_ADOC_SRCS = \ fvwm3.adoc \ fvwm3all.adoc \ fvwm3commands.adoc \ fvwm3_manpage_source.adoc \ fvwm3menus.adoc \ fvwm3styles.adoc \ $(wildcard Fvwm*.adoc) \ $(wildcard fvwm-*.adoc) @FVWM_BUILD_GOLANG_FALSE@MODULE_ADOC = $(MODULE_ADOC_SRCS) # If building FvwmPrompt, don't generate the manpage for FvwmConsole as that # won't ever be installed. @FVWM_BUILD_GOLANG_TRUE@MODULE_ADOC = $(filter-out FvwmConsole.adoc, $(MODULE_ADOC_SRCS)) EXTRA_DIST = $(MODULE_ADOC_SRCS) @FVWM_BUILD_MANDOC_TRUE@M1M = $(filter-out fvwm3_manpage_source.adoc, $(MODULE_ADOC)) @FVWM_BUILD_MANDOC_TRUE@man1_MANS = $(patsubst %.adoc,%.1, $(M1M)) @FVWM_BUILD_MANDOC_TRUE@EXTRACT_SECTIONS = \ @FVWM_BUILD_MANDOC_TRUE@ commands \ @FVWM_BUILD_MANDOC_TRUE@ menus \ @FVWM_BUILD_MANDOC_TRUE@ styles @FVWM_BUILD_MANDOC_TRUE@SECTION_FILES = $(patsubst %,fvwm3_%.ad, $(EXTRACT_SECTIONS)) all: all-am .SUFFIXES: $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ && { if test -f $@; then exit 0; else break; fi; }; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign doc/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign doc/Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(top_srcdir)/configure: $(am__configure_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(ACLOCAL_M4): $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): install-man1: $(man1_MANS) @$(NORMAL_INSTALL) @list1='$(man1_MANS)'; \ list2=''; \ test -n "$(man1dir)" \ && test -n "`echo $$list1$$list2`" \ || exit 0; \ echo " $(MKDIR_P) '$(DESTDIR)$(man1dir)'"; \ $(MKDIR_P) "$(DESTDIR)$(man1dir)" || exit 1; \ { for i in $$list1; do echo "$$i"; done; \ if test -n "$$list2"; then \ for i in $$list2; do echo "$$i"; done \ | sed -n '/\.1[a-z]*$$/p'; \ fi; \ } | while read p; do \ if test -f $$p; then d=; else d="$(srcdir)/"; fi; \ echo "$$d$$p"; echo "$$p"; \ done | \ sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \ sed 'N;N;s,\n, ,g' | { \ list=; while read file base inst; do \ if test "$$base" = "$$inst"; then list="$$list $$file"; else \ echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \ $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \ fi; \ done; \ for i in $$list; do echo "$$i"; done | $(am__base_list) | \ while read files; do \ test -z "$$files" || { \ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \ $(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \ done; } uninstall-man1: @$(NORMAL_UNINSTALL) @list='$(man1_MANS)'; test -n "$(man1dir)" || exit 0; \ files=`{ for i in $$list; do echo "$$i"; done; \ } | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \ dir='$(DESTDIR)$(man1dir)'; $(am__uninstall_files_from_dir) tags TAGS: ctags CTAGS: cscope cscopelist: distdir: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(DISTFILES) @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ list='$(DISTFILES)'; \ dist_files=`for file in $$list; do echo $$file; done | \ sed -e "s|^$$srcdirstrip/||;t" \ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ case $$dist_files in \ */*) $(MKDIR_P) `echo "$$dist_files" | \ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ sort -u` ;; \ esac; \ for file in $$dist_files; do \ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ if test -d $$d/$$file; then \ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ if test -d "$(distdir)/$$file"; then \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ else \ test -f "$(distdir)/$$file" \ || cp -p $$d/$$file "$(distdir)/$$file" \ || exit 1; \ fi; \ done check-am: all-am check: check-am all-am: Makefile $(MANS) installdirs: for dir in "$(DESTDIR)$(man1dir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: install-am install-exec: install-exec-am install-data: install-data-am uninstall: uninstall-am install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-am install-strip: if test -z '$(STRIP)'; then \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ install; \ else \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ fi mostlyclean-generic: clean-generic: distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." clean-am: clean-generic mostlyclean-am distclean: distclean-am -rm -f Makefile distclean-am: clean-am distclean-generic distclean-local dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-man install-dvi: install-dvi-am install-dvi-am: install-exec-am: install-html: install-html-am install-html-am: install-info: install-info-am install-info-am: install-man: install-man1 install-pdf: install-pdf-am install-pdf-am: install-ps: install-ps-am install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-am -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-generic pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: uninstall-man uninstall-man: uninstall-man1 .MAKE: install-am install-strip .PHONY: all all-am check check-am clean clean-generic cscopelist-am \ ctags-am distclean distclean-generic distclean-local distdir \ dvi dvi-am html html-am info info-am install install-am \ install-data install-data-am install-dvi install-dvi-am \ install-exec install-exec-am install-html install-html-am \ install-info install-info-am install-man install-man1 \ install-pdf install-pdf-am install-ps install-ps-am \ install-strip installcheck installcheck-am installdirs \ maintainer-clean maintainer-clean-generic mostlyclean \ mostlyclean-generic pdf pdf-am ps ps-am tags-am uninstall \ uninstall-am uninstall-man uninstall-man1 .PRECIOUS: Makefile nothing: clean: rm -f *.1 *.ad distclean-local: clean @FVWM_BUILD_MANDOC_TRUE@all: docs @FVWM_BUILD_MANDOC_TRUE@docs: $(man1_MANS) @FVWM_BUILD_MANDOC_TRUE@$(man1_MANS): $(SECTION_FILES) @FVWM_BUILD_MANDOC_TRUE@%.ad: fvwm3_manpage_source.adoc @FVWM_BUILD_MANDOC_TRUE@ SECTION=$(patsubst fvwm3_%.ad,%,$@); \ @FVWM_BUILD_MANDOC_TRUE@ cat "$<" | \ @FVWM_BUILD_MANDOC_TRUE@ "$(GREP)" -A 1000000 -- "^// BEGIN '$$SECTION'" | \ @FVWM_BUILD_MANDOC_TRUE@ "$(GREP)" -B 1000000 -- "^// END '$$SECTION'" | \ @FVWM_BUILD_MANDOC_TRUE@ "$(GREP)" -v "^// .* '$$SECTION'" > "$@" @FVWM_BUILD_MANDOC_TRUE@%.1: %.adoc @FVWM_BUILD_MANDOC_TRUE@ "$(ASCIIDOC)" -b manpage -a "$(patsubst %.1,%,$@)" "$<" -o "$@" # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: fvwm3-1.0.6a/doc/README0000644000175000017500000000067714354105651013712 0ustar jaimosjaimosFvwm3 Documentation =================== The old docbook formatted files have been replaced in favour of using `asciidoc` -- specifically via `asciidoctor` (https://asciidoctor.org). Unlike previous efforts, `asciidoctor` is now used to generate every man page -- including modules. For more information about the specific markup available, see: * https://asciidoctor.org/docs/asciidoc-writers-guide/ * https://asciidoctor.org/docs/user-manual/ fvwm3-1.0.6a/doc/FvwmAnimate.adoc0000644000175000017500000001376314354105651016100 0ustar jaimosjaimos= FvwmAnimate(1) :doctype: manpage :mantitle: FvwmAnimate :manname: FvwmAnimate :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmAnimate - the fvwm animate module == SYNOPSIS Module FvwmAnimate [ModuleAlias] *FvwmAnimate* can only be invoked by fvwm. Command line invocation of the FvwmAnimate module will not work. From within the .fvwm2rc file, *FvwmAnimate* is spawned as follows: .... Module FvwmAnimate .... or from within an fvwm pop-up menu: .... DestroyMenu Module-Popup AddToMenu Module-Popup "Modules" Title + "Fvwm Animate Icons" Module FvwmAnimate ModuleAlias .... == DESCRIPTION The *FvwmAnimate* module animates iconification and de-iconification or on command. There are currently 6 different animation effects. == INVOCATION *FvwmAnimate* must be invoked by the *fvwm* window manager. When invoked with the _OptionalName_ argument, the _ModuleAlias_ is used to find configuration commands, configuration files, and name the internally generated menus and forms instead of "FvwmAnimate". During startup, FvwmAnimate defines menus and forms for configuring and controlling FvwmAnimate. The default menu name is "MenuFvwmAnimate" and the form name is "FormFvwmAnimate". If the optional name is used, the menu would be "Menu" and the form would be "Form". Assuming you already had a builtin menu called "Module-Popup", you could use FvwmAnimate by configuring it like this: .... AddToFunc "StartFunction" "I" Module FvwmAnimate AddToMenu "Module-Popup" "Control Animation" Popup MenuFvwmAnimate .... == CONFIGURATION OPTIONS Since the pop up menu "MenuFvwmAnimate" allows complete control of the *FvwmAnimate* module, you don't really have to know what any of the configuration commands are. This section describes them anyway. *FvwmAnimate* gets configuration info from *fvwm*'s module configuration database (see _fvwm_(1), section *MODULE COMMANDS*). In addition, *FvwmAnimate* reads the file $HOME/.FvwmAnimate, and accepts commands from fvwm and its modules as it runs. If _ModuleAlias_ is used to start FvwmAnimate, the optional name is used in all commands, messages, menus and forms generated by FvwmAnimate and in the configuration file name. Unlike other fvwm modules, there is little reason to use the optional name. *FvwmAnimate: Color color:: Tells *FvwmAnimate* what color to draw with. The color is "XOR'ed" (exclusive ORed) onto the background. Depending on the display type you are using, the effect this causes will vary. Especially on 8-bit displays, it helps if the background is a solid color. You have to experiment with this to see how it works. + The default color is not really a color and can be entered as "Black^White", or more simply "None". This is the same as the default XOR mask used by fvwm for move and resize frames. + Other colors can be specified using standard X color notation. Ie. color names like "LightBlue", or RGB values like "#FFFFFF". *FvwmAnimate: Pixmap pixmap:: Tells *FvwmAnimate* to use *pixmap* to draw with. This can be useful if **FvwmAnimate: Color* gives poor results. *FvwmAnimate: Delay msecs:: Tells *FvwmAnimate* how many milliseconds to sleep between frames of animation. *FvwmAnimate: Iterations iterations:: Tells *FvwmAnimate* how many steps to break the animation into. *FvwmAnimate: Twist twist:: Tells *FvwmAnimate* how many revolutions to twist the iconification frame. *FvwmAnimate: Width width:: Tells *FvwmAnimate* how wide a line to draw with. The default width of 0 (zero) is a fast line of Width 1. *FvwmAnimate: Effect mode:: Tells *FvwmAnimate* which animation effect to use. Currently the effects are: _Frame_, _Lines_, _Flip_, _Turn_, _Zoom3D_, _Twist_ _Random_, and _None_. _None_ is normally set in the configuration file, in-case FvwmAnimate is started automatically, but an individual user doesn't want it running. *FvwmAnimate: Stop:: Tells *FvwmAnimate* to stop. *FvwmAnimate: Save:: Tells *FvwmAnimate* to save the current configuration in a file named ".FvwmAnimate" in the users home directory. This same file is read automatically by FvwmAnimate during startup. == COMMANDS *FvwmAnimate* can be asked to produce an animation thru the "SendToModule" command. The format of the command is: .... SendToModule FvwmAnimate animate sx sy sw sh dx dy dw dh .... The second word must match the name *FvwmAnimate* is started with. The 8 fields after _animate_ must be numbers. The first 4 are for the source (or starting) location of the animation. The last 4 are for the destination of the animation. The 2 pairs of 4 numbers, represent rectangles. The first 2 numbers are the x and y location of the upper right corner. The next 2 numbers are the width and height. One or more spaces can separate the fields in the command. Modules can use the "SendToModule" command to animate "NoIcon" windows, or you can think up your own ways to have all kinds of fun with this command. Additional available commands are: _pause_, _play_, _push_, _pop_ and _reset_. These may be space separated. _pause_ causes a module to not temporarily produce any animations. _play_ causes a module to produce an animation again. _push_ stores the current playing state for a future and _pop_ restores it. _reset_ removes all stored states and sets playing on. Suppose, we don't want to wait for all 40 xterms to be animated: .... SendToModule FvwmAnimate pause All (XTerm) Iconify on .... And if we don't want to damage the current playing state, then: .... SendToModule FvwmAnimate push pause All (XTerm) Iconify on SendToModule FvwmAnimate pop .... == ORIGIN *FvwmAnimate* is based on the *Animate* module from Afterstep 1.5pre6. Porting to *fvwm* and lots of other changes were done by _Dan Espen_ . Below are the original author and acknowledgments. == AUTHOR _Alfredo Kengi Kojima_ == ACKNOWLEDGMENTS These people have contributed to *FvwmAnimate*: Kaj Groner :: Twisty iconification, configuration file parsing, man page. Frank Scheelen :: fvwm3-1.0.6a/doc/fvwm3.adoc0000644000175000017500000000014514354105651014712 0ustar jaimosjaimos= FVWM3(1) == NAME fvwm3 - F? Virtual Window Manager for X11 include::fvwm3_manpage_source.adoc[] fvwm3-1.0.6a/doc/FvwmEvent.adoc0000644000175000017500000001663514354105651015604 0ustar jaimosjaimos= FvwmEvent(1) :doctype: manpage :mantitle: FvwmEvent :manname: FvwmEvent :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmEvent - the fvwm event module == SYNOPSIS _FvwmEvent_ is a more versatile replacement for _FvwmAudio_. It can in general be used to hook any _fvwm_ function or program to any window manager event. E.g: Delete unwanted Netscape Pop ups or application error pop ups as they appear, play sounds, log events to a file and the like. Be creative, you'll find a use for it. _FvwmEvent_ is spawned by _fvwm_, so no command line invocation will work. From within the _.fvwm2rc_ file, _FvwmEvent_ is spawned as follows: .... Module FvwmEvent .... or from within an _fvwm_ pop-up menu: .... DestroyMenu Module-Popup AddToMenu Module-Popup "Modules" Title + "Event" Module FvwmEvent + "Auto" Module FvwmAuto 200 + "Buttons" Module FvwmButtons + "Console" Module FvwmConsole + "Ident" Module FvwmIdent + "Banner" Module FvwmBanner + "Pager" Module FvwmPager 0 3 .... == DESCRIPTION The _FvwmEvent_ module communicates with the _fvwm_ window manager to bind _actions_ to window manager _events_. Different actions may be assigned to distinct window manager events. _FvwmEvent_ can be used to bind sound files to events like _FvwmAudio_ (RiP) did. It can be used for logging event traces to a log file, while debugging _fvwm_. == INVOCATION The invocation method was shown in the synopsis section. No command line invocation is possible. _FvwmEvent_ must be invoked by the _fvwm_ window manager. == CONFIGURATION OPTIONS _FvwmEvent_ gets config info from *fvwm*'s module configuration database (see _fvwm_(1), section *MODULE COMMANDS*), and looks for certain configuration options: *FvwmEvent: Cmd command:: This determines the _fvwm_ function that is to be called with the event parameters. You might want to do one of the following (details below): + .... # execute distinct fvwm functions *FvwmEvent: Cmd # execute distinct external programs *FvwmEvent: Cmd exec .... + _FvwmEvent_ has support for any other external program. e.g: the rsynth 'say' command: + .... *FvwmEvent: Cmd "Exec /rsynth/say" *FvwmEvent: destroy_window "window closed" .... + You can also use _fvwm_'s builtin _Echo_ command as _FvwmEvent: Cmd_ to obtain debug output for _fvwm_ events quietly. I used this setup to debug FvwmAuto: + .... *FvwmEvent: Cmd Echo *FvwmEvent: focus_change "focus change" *FvwmEvent: raise_window "raise window" .... + You can even call different shell commands for each event just by setting + .... *FvwmEvent: Cmd exec *FvwmEvent: add_window 'killname "APPL ERROR"' .... *FvwmEvent: PassId:: Specifies that the event action will have an ID parameter added to the end of the command line. Most events will have the windowID of the window that the event refers to, new_desk will have the new desk number. The windowID is a hexadecimal string preceded by 0x, desk numbers are decimal. *FvwmEvent: window-manager-event action-or-filename:: Binds particular actions to window manager events. + The following events are valid: + [cols="<,<",] |=== |_Event_ |_Description_ |add_window | Occurs when a new window is mapped and visible |config_info | Occurs when a module asks for configuration |configure_window | Occurs when a ConfigureNotify event happens |default_icon | Occurs when a window's DefaultIcon changes |deiconify | Occurs when a window id deiconified |destroy_window | Occurs when a window is destroyed |dewindowshade | Occurs when a window is unshaded |echo | Occurs when an Echo command is run |end_config_info | Occurs when there's no more module config to send |end_windowlist | Occurs when the windowlist has finished sending |enter_window | Occurs when a window receives a EnterNotify event |error | DEPRECATED |focus_change | Occurs when a window gains or loses focus |icon_file | DEPRECATED |icon_location | DEPRECATED |icon_name | DEPRECATED |iconify | Occurs when a window is iconified |leave_window | Occurs when a window receives a LeaveNotify event |lower_window | Occurs when a window is lowered |map | Occurs when a window is Mapped |mini_icon | Occurs when a window's mini icon changes |monitor_changed | Occurs when a monitor's resolution changes |monitor_disabled | Occurs when a monitor is disabled (via RandR) |monitor_enabled | Occurs when a monitor is enabled (via RandR) |monitor_focus | Occurs when a monitor gains focus |new_desk | Occurs when a new desk is switched to |new_page | Occurs when a new page is switched to |old_add_window | DEPRECATED |old_configure_window | DEPRECATED |property_change | Occurs when a window receives a PropertNotify event |raise_window | Occurs when a window is raised |res_class | Occurs when a window's Class is set |res_name | Occurs when a window's Resource is set |restack | Occurs when windows are restacked |sendconfig | Occurs when FvwmEvent asks for its config |shutdown | DEPRECATED |startup | DEPRECATED |string | Occurs when the SendToModule command is used |unknown | DEPRECATED |visible_icon_name | Occurs when a window's visible icon name changes |visible_name | Occurs when a window's visible name changes |window_name | Occurs when a window's name (WM_NAME) is set |windowshade | Occurs when a window is shaded |=== + The window related event handlers are executed within a window context. Previously PassId was used for this purpose, but now using PassId is not needed. + The monitor_* events do not operate in a window context (as there isn't one), but react to when a monitor is plugged in (enabled), unplugged (disabled), focused (focus) or changed (resized/rotated, etc., which will only be true if the monitor is already active). + The echo event is generated whenever Fvwm receives an Echo command. + Note: The enter_window event is generated when the pointer enters a window. With the -passid option, that window's id is passed to fvwm. An enter_window event is generated too when the pointer leaves a window and moves into the root window. In this case, the id passed is 0. + Note: When the shutdown event arrives, FvwmEvent may be killed before it can trigger the associated action. *FvwmEvent: Delay 5:: Specifies that an event-action will only be executed if it occurs at least 5 seconds after the previous event. Events that occur during the delay period are ignored. The default delay is 0 which disables the Event. *FvwmEvent: StartDelay delay:: Specifies that an event-action will only be executed if it occurs at least _delay_ seconds after the startup event. Events that occur during the delay period are ignored. This option is useful when _fvwm_ starts and restarts using an audio player. The default delay is 0. == HISTORY This module has evolved of _FvwmAudio_, which in term is heavily based on a similar Fvwm module called _FvwmSound_ by Mark Boyns. _FvwmAudio_ simply took Mark's original program and extended it to make it generic enough to work with any audio player. Due to different requests to do specific things on specific events, _FvwmEvent_ took this one step further and now calls any _fvwm_ function, or builtin-rplay. If _fvwm_'s Exec function is used, any external program can be called with any parameter. == AUTHORS .... 1994 FvwmSound Mark Boyns (boyns@sdsu.edu) 1994 FvwmAudio Mark Scott (mscott@mcd.mot.com) 1996 FvwmAudio Albrecht Kadlec 1998 FvwmEvent Albrecht Kadlec (albrecht@auto.tuwien.ac.at) .... fvwm3-1.0.6a/doc/FvwmPrompt.adoc0000644000175000017500000000173414354105651015776 0ustar jaimosjaimos= FvwmPrompt(1) == NAME FvwmPrompt - a command-shell for fvwm3 == SYNOPSIS [verse] _FvwmPrompt_ == DESCRIPTION _FvwmPrompt_ accepts the following command-line arguments: FvwmPrompt [-p ] _FvwmPrompt_ provides a minimal shell for sending commands to **fvwm3** -- with the history of previous commands remembered for easier repetition. The prompt can be changed, although by default the _FvwmPrompt_ interface looks like the following: .... *FvwmPrompt 1.0.1 (1.0.0-49-g845f28d85-dirty) Press ^D or type 'exit' to end this session >>> .... == Prerequisites _FvwmMFL_(1) must be spawned by **fvwm3** otherwise _FvwmPrompt_ will not start. For example: .... AddToFunc StartFunction I Module FvwmMFL .... == Comparisons to FvwmConsole Unlike _FvwmConsole_, _FvwmPrompt_ doesn't need to be spawned via a terminal (such as _xterm_) but acts as a standalone program, and can be run from any terminal the user choses. == Author Thomas Adam fvwm3-1.0.6a/doc/FvwmButtons.adoc0000644000175000017500000013421214354105651016151 0ustar jaimosjaimos= FvwmButtons(1) :doctype: manpage :mantitle: FvwmButtons :manname: FvwmButtons :manmanual: Fvwm Modules :manvolnum: 1 :page-layout: base == NAME FvwmButtons - the fvwm buttonbox module == SYNOPSIS .... Module FvwmButtons [-g geometry] [-transient | -transientpanel] [name[configfile]] .... _FvwmButtons_ can only be invoked by fvwm. Command line invocation of the _FvwmButtons_ module will not work. == DESCRIPTION The FvwmButtons module provides a window of buttons which sits on the X terminal's root window. The user can press the buttons at any time, and trigger invocation of a user-specified command by the window manager. FvwmButtons only works when fvwm is used as the window manager. The buttonbox can be of any configuration or geometry, and can have monochrome or color icons to represent the actions which would be invoked. Even other applications can be 'swallowed' by the button bar. Panels that are opened on a button press are available too. See _CREATING PANELS_ section for details. == OPTIONS The _-g_ option specifies the geometry of the main window. The command line option takes precedence over any other geometry settings in the configuration file. The _-transient_ option tells FvwmButtons to terminate itself after the first key or button press has been received (presses to open a sub panel do not count) or a sub panel has been closed or respawned. This is especially useful for sub panels where you want to select a single button and have it closed automatically. It could be used to create two-dimensional graphical menus. Since _-transient_ is an option, not a configuration setting you can use the same configuration for transient and non transient button bars. The _-transientpanel_ option does roughly the same as the _-transient_ option, but instead of closing the whole button bar, the window is merely hidden. This is very useful if the button bar is started as a subpanel of another button bar because it avoids that it must be started again when something is selected. == INVOCATION FvwmButtons is spawned by fvwm, so command line invocation will not work. FvwmButtons can be invoked by inserting the line 'Module FvwmButtons OptionalName' in the .fvwm2rc file. This should be placed in the StartFunction if FvwmButtons is to be spawned during fvwm's initialization. This can be bound to a menu or mouse button or keystroke to invoke it later. When invoked with the _OptionalName_ argument, the _OptionalName_ is used to find configuration commands. For example: .... AddToFunc StartFunction Module FvwmButtons MyButtonBox .... FvwmButtons will then use only the lines starting with "*MyButtonBox", instead of the default "*FvwmButtons". == CONFIGURATION OPTIONS The following commands are understood by FvwmButtons: *FvwmButtons: Back color:: Specifies the background color for the buttons. The relief and shadow color are calculated from the background color. *FvwmButtons: BoxSize algorithm:: This option specifies how serious FvwmButtons takes the Rows and Columns options (see below). It can be one of _dumb_, _fixed_ or _smart_. + If _fixed_ is used and both Rows and Columns are specified and non-zero, FvwmButtons uses exactly the number of rows and columns specified. If the box is too small to accommodate all buttons the module will fail. + If _smart_ is used FvwmButtons enlarges the box so all buttons have a chance to fit. The number of columns is increased to at least the width of the widest button and new rows are added until all buttons are placed. For the best tolerance of configuration errors use the smart option. + _dumb_ is neither _fixed_ nor _smart._ This is the default. *FvwmButtons: Colorset colorset:: Tells the module to use colorset _colorset_ for the window background. Refer to the fvwm man page for details about colorsets. *FvwmButtons: ActiveColorset colorset:: Tells the module to use colorset _colorset_ for the background color/image and/or title color of a button when the mouse is hovering above a button. *FvwmButtons: PressColorset colorset:: Tells the module to use colorset _colorset_ for the background color/image and/or title color of a button when it is pressed. *FvwmButtons: Columns columns:: Specifies the number of columns of buttons to be created. If unspecified, the number of columns is set to the number of buttons requested, divided by the number of rows. If both the rows and columns are specified, but the number of buttons is more than the rows and columns allow for, the columns specification is ignored unless the _BoxSize_ option is _fixed_. *FvwmButtons: File filename:: Specifies that the configuration for this button is found in the file _filename_. _Filename_ can be a full pathname, or is assumed to be in fvwm's startup directory. The configuration file is in the same format as fvwm's configuration file, but each line is read as if prefixed by "*FvwmButtons". Comments are given by starting a line with "#". Line continuation is done by ending a line with a "\". *FvwmButtons: Font font:: Specifies the font to be used for labeling the buttons, or _None_. *FvwmButtons: Fore color:: Specifies the color used for button label text and monochrome icons. *FvwmButtons: Frame width:: Specifies the width of the relief around each button. If this is a negative number, the relief is inverted. This makes the button sunken normally and raised when activated. *FvwmButtons: Geometry geometry:: Specifies the FvwmButtons window location and size. The geometry is a standard X11 window geometry specification. *FvwmButtons: ButtonGeometry geometry:: This option works like the _Geometry_ option except that the size is the size of a single button. The size of the whole FvwmButtons window is calculated by multiplying the button dimension by the number of rows and columns. *FvwmButtons: Padding width height:: This option specifies the default horizontal padding to be _width_ pixels, and the vertical padding to be _height_ pixels. The amount of free space between the relief of the button and its contents is normally 2 pixels on the sides and 4 pixels above and below, except for swallowed windows and containers, which are not padded at all, unless this option is used. *FvwmButtons: Pixmap pixmapfile:: Specifies a background pixmap to use. Specify "none" (without the double quotes) for a transparent background. *FvwmButtons: Rows rows:: Specifies the number of rows of buttons to be created. The default is 2 rows. *FvwmButtons: WindowName name:: If FvwmButtons has a titlebar enabled with Title style, (for example, some transient subpanel), this option can set it's Window name and Icon name to a string provided with this parameter. If omitted, default for Window and Icon name is the window resource name which itself is simply "FvwmButtons", or is derived from the alias by which FvwmButtons configuration is referenced. This enables setting a title with spaces and larger number of non-ASCII characters which is not allowed as an alias for FvwmButtons module instance otherwise. *FvwmButtons: (options) [title icon command]:: Specifies the contents of a button in the buttonbox. The following _options_, separated by commas or whitespace, can be given a button: + _geometry_::: Specifies the size and position of the button within the FvwmButtons window or container. The geometry is a standard X11 window geometry specification. The button is _width_ times the normal button width and _height_ times the normal button height. If values for _x_ and _y_ are given, the button is placed x (y) button units from the left (top) of the container if x (y) is positive and x (y) units from the right (bottom) if x (y) is negative. Buttons with position arguments (x and y) are placed before those without them. If two or more buttons are forced to overlap by this, FvwmButtons exits with an error message. + Action [(_options_)] _command_::: Specifies an fvwm command to be executed when the button is activated by pressing return or a mouse button. The _command_ needs to be quoted if it contains a comma or a closing parenthesis. + The current options of the _Action_ are: Mouse _n_ - this action is only executed for mouse button _n_. One action can be defined for each mouse button, in addition to the general action. + In the _command_ part, you can use a number of predefined variables: _$left_, _$right_, _$top_ and _$bottom_ are substituted by the left, right, top and bottom coordinates of the button pressed. _$-left_, _$-right_, _$-top_ and _$-bottom_ are substituted likewise, but the coordinates are calculated from the bottom or the right edge of the screen instead (for a button that is 5 pixels away from the right screen border, $-right will be 5). _$width_ and _$height_ are replaced by the width or height of the button. The variables _$fg_ and _$bg_ are replaced with the name of the foreground or background color set with the _Back_ or _Fore_ option (see below). All this is done regardless of any quoting characters. To get a literal '$' use the string '$$'. + Example: + .... *FvwmButtons: (Title xload, Action (Mouse 1) \ `Exec exec xload -fg $fg -bg $bg -geometry -3000-3000`) .... + Note: With fvwm versions prior to 2.5.0, actions could not be assigned to a button that swallowed an application window (see _Swallow_ option). Such actions worked only when the border around the button was clicked. This is now possible, but to get back the old behavior, the _ActionIgnoresClientWindow_ can be used on the button: + .... *FvwmButtons: (Action beep, ActionIgnoresClientWindow, \ Swallow xeyes "Exec exec xeyes") .... + In this example, the action is only executed when you click on the border of the button or the transparent part of the xeyes window, but not on the xeyes window itself. + ActionIgnoresClientWindow::: See the note in the description of _Action_ above. ActionOnPress::: Usually the action is executed on the button release except for the *Popup* action. This option changes this behavior, the action is executed on the button press. This may be good, for example, with *Menu* or *SendToModule* that generates popups, or when *Frame* is 0 and the button would look unresponsive otherwise. Back color::: Specifies the background color to be used drawing this box. A relief color and a shadow color are calculated from this. Center::: The contents of the button is centered on the button. This is the default but may be changed by _Left_ or _Right_. Top::: The contents of the button is vertically aligned at the top of the button. The default is to vertically center it. Colorset colorset::: The given colorset can be applied to a container, a swallowed application and a simple button. To apply it to a button or container, simply put the option in a line with a button or container description. Drawing backgrounds for individual buttons and containers with colorsets requires a lot of communication with the X server. So if you are not content with the drawing speed of dozens of buttons with colorset backgrounds, do not use colorsets here. Setting colorsets as the background of swallowed applications does not have this restriction but depends entirely on the swallowed application. It may work as you wish, but since it involves fiddling with other applications' windows there is no guarantee for anything. I have tested three applications: xosview works nicely with a colorset background, xload works only with a VGradient or solid background and an analog xclock leaves a trail painted in the background color after its hands. + If the swallowed window is an fvwm module (see the (No)FvwmModule option to Swallow), then the _colorset_ is not applied to the swallowed module. You should use the _colorset_ in the module configuration. If the swallowed module has a transparent colorset background, then the FvwmButtons background (and not the button colorset) is seen by transparency of the background of the swallowed module. Refer to the fvwm man page for details about colorsets. ActiveColorset colorset::: Use colorset _colorset_ for the background color/image and/or title color of the button when the mouse is hovering above it. PressColorset colorset::: Use colorset _colorset_ for the background color/image and/or title color of the button when it is pressed. Container [(options)]::: Specifies that this button will contain a miniature buttonbox, equivalent to swallowing another FvwmButtons module. The options are the same as can be given for a single button, but they affect all the contained buttons. Options available for this use are _Back, Font, Fore, Frame_ and _Padding_. Flags for Title and Swallow options can be set with _Title(flags)_ and _Swallow(flags)_. You should also specify either "Columns _width_" or "Rows _height_", or "Rows 2" will be assumed. For an example, see the _Sample configuration_ section. + The container button itself (separate from the contents) can take format options like _Frame_ and _Padding_, and commands can be bound to it. This means you can make a sensitive relief around a container, like + .... *FvwmButtons: (2x2, Frame 5, Padding 2 2, Action Beep,\ Container(Frame 1)) .... + Typically you will want to at least give the container a size setting __width__x_height_. End::: Specifies that no more buttons are defined for the current container, and further buttons will be put in the container's parent. This option should be given on a line by itself, i.e + .... *FvwmButtons: (End) .... + Font fontname::: Specifies that the font _fontname_ is to be used for labeling this button. Fore color::: Specifies the foregound color of the title and monochrome icons in this button. Frame width::: The relief of the button will be _width_ pixels wide. If _width_ is given as a negative number, the relief is inverted. This makes the button sunken normally and raised when activated. Icon filename::: The name of an image file, containing the icon to display on the button. FvwmButtons searches through the path specified in the fvwm ImagePath configuration item to find the icon file. ActiveIcon filename::: The name of an image file, containing an alternative icon to display on the button when the mouse is hovering above the button. If no ActiveIcon is specified, the image specified by Icon is displayed (if there is one). PressIcon filename::: The name of an image file, containing an alternative icon to display on the button when the button is pressed. If no PressIcon is specified, the image specified by Icon is displayed (if there is one). Id id::: The id to be used to identify this button. The first character of the id should be alphabetic. See also the "DYNAMICAL ACTIONS" section. Left::: The contents of the button are aligned to the left. The default is to center the contents on the button. NoSize::: This option specifies that this button will not be considered at all when making the initial calculations of button sizes. Useful for the odd button that gets just a couple of pixels too large to keep in line, and therefore blows up your whole buttonbox. "NoSize" is equivalent to "Size 0 0". Padding width height::: The amount of free space between the relief of the button and its contents is normally 2 pixels to the sides and 4 pixels above and below, except for swallowed windows and containers, which are by default not padded at all. This option sets the horizontal padding to _width_ and the vertical padding to _height_. Panel [ (options) ] hangon command::: Panels can be swallowed exactly like windows are swallowed by buttons with the _Swallow_ command below, but they are not displayed within the button. Instead they are hidden until the user presses the panel's button. Then the panel (the window of the swallowed application) opens with a sliding animation. The _options_ can be any of the _flags_ described for the Swallow command. In addition a direction 'left', 'right', 'up' or 'down' can be used to specify the sliding direction. + The _steps animation-steps_ option defines the number of animation steps. + The _delay ms_ option sets the delay between the steps of the animation in milliseconds. Use zero for no delay. The maximum delay is 10 seconds (10000). It doesn't make any sense to use the delay option unless you also use the smooth option. + The _smooth_ option causes the panel to redraw between the steps of the animation. The sliding animation may be smoother this way, it depends on the application, and display speed. The application may appear to grow instead of sliding out. The animation may be slower. + The _Hints_ option causes FvwmButtons to use the applications size hints to calculate the size of the animation steps. _Hints_ is the default. If the number of steps is not what you want, try using _NoHints._ + The _noborder_ option tells FvwmButtons to ignore the borders of the window when calculating positions for the animation (equivalent to set noplr and noptb in the position option). + With the _indicator_ option set, FvwmButtons will draw a small triangle in the button that will open a panel. The triangle points in the direction where the panel will pop up. The _indicator_ keyword may be followed by a positive integer that specifies the maximum width and height of the indicator. Without this size FvwmButtons will make the indicator fit the button. You will probably want to use the _Padding_ option to leave a few pixels between the indicator and the frame of the button. Second option to indicator may be given which enters the look of the triangle. If this keyword is _in_, triangle will appear pressed in, while _out_ will make triangle to appear depressed (3D raised). If this keyword is omitted, default will be _out_ or depressed. + The _position_ option allows one to place the panel. The syntax is: + .... position [context-window] [pos] [x y] [border-opts] .... + The argument _context-window_ can be one of: Button, Module or Root. The _context-window_ is the window from which panel percentage offsets are calculated. Button specifies the panel's button, Module specifies FvwmButtons itself, and Root specifies a virtual screen. The context-window together with the sliding direction define a line segment which is one of the borders of the context-window: the top/bottom/left/right border for sliding up/down/left/right. + The _pos_ argument can be one of: center, left or right (for sliding up or a down) or top or bottom (for sliding left or right). It defines the vertical (sliding up and down) or the horizontal (sliding left and right) position of the Panel on the line segment. For example, for a sliding up if you use a left pos, then the left borders of the panel and of the context-window will be aligned. + The offset values _x_ and _y_ specify how far the panel is moved from it's default position. By default, the numeric value given is interpreted as a percentage of the context window's width (height). A trailing "p" changes the interpretation to mean "pixels". All offset calculations are relative to the buttons location, even when using a root context. + The _border-opts_ are: mlr, mtb, noplr and noptb. They define which border widths are taken in account. By default, the borders of FvwmButtons are not taken in account. mlr reverses this default for the left and the right border and mtb reverses this default for the top and the bottom border. Conversely, by default the borders of the Panel are taken in account. noplr reverses this default for the left and the right border and noptb reverses this default for the top and the bottom border. + The defaults are sliding up with a delay of five milliseconds and twelve animation steps. To post the panel without any animation, set the number of steps to zero. The default position is 'Button center'. + Please refer to the _CREATING PANELS_ section for further information on panels. + Example: + .... # To include the panel in a button *FvwmButtons: (Panel(down, delay 0, steps 16) \ SubPanel "Module FvwmButtons SubPanel") # To define the panel as an instance of # FvwmButtons with a different name: *SubPanel: (Icon my_lock.xpm, Action Exec xlock) *SubPanel: (Icon my_move.xpm, Action Move) ... .... Right::: The contents of the button are aligned to the right. The default is to center the contents on the button. Size width height::: Specifies that the contents of this button require _width_ by _height_ pixels, regardless of what size FvwmButtons calculates from the icon and the title. A button bar with only swallowed windows will not get very large without this option specified, as FvwmButtons does not consider sizes for swallowing buttons. Note that this option gives the minimum space assured; other buttons might require the buttonbox to use larger sizes. Swallow [(flags)] hangon command::: Causes FvwmButtons to execute _command_, and when a window with a name, class or resource matching _hangon_ appears, it is captured and swallowed into this button. The _hangon_ string may contain wildcard characters ('*') that match any substring. Swallow replaces the variables _$fg_ and _$bg_ as described above for the _Action_ option (but if you use the UseOld and NoClose options the application is not be restarted when FvwmButtons is restarted and thus does not get the new colors - if you changed them). An example: + .... *FvwmButtons: (Swallow XClock 'Exec xclock -geometry -3000-3000 &') .... + takes the first window whose name, class, or resource is "XClock" and displays it in the button. If no matching window is found, the "Exec" command creates one. The argument "-geometry -3000-3000" is used so that the window is first drawn out of sight before its swallowed into FvwmButtons. + Modules can be swallowed by specifying the module instead of 'Exec whatever', like: + .... *FvwmButtons: (Swallow "FvwmPager" "FvwmPager 0 0") .... + The flags that can be given to swallow are: + NoClose / Close - Specifies whether the swallowed program in this button will be un-swallowed or closed when FvwmButtons exits cleanly. "NoClose" can be combined with "UseOld" to have windows survive a restart of the window manager. The default setting is "Close". + NoHints / Hints - Specifies whether hints from the swallowed program in this button will be ignored or not, useful in forcing a window to resize itself to fit its button. The default value is "Hints". + NoKill / Kill - Specifies whether the swallowed program will be closed by killing it or by sending a message to it. This can be useful in ending programs that doesn't accept window manager protocol. The default value is "NoKill". This has no effect if "NoClose" is specified. + NoRespawn / Respawn / SwallowNew - Specifies whether the swallowed program is to be respawned (restarted) if it dies. If "Respawn" is specified, the program is respawned using the original _command_. Use this option with care, the program might have a legitimate reason to die. If "SwallowNew" is given, the program is not respawned, but if a new window with the specified name appears, it is swallowed. + NoOld / UseOld - Specifies whether the button will try to swallow an existing window matching the _hangon_ name before spawning one itself with _command_. The _hangon_ string may contain wildcard characters ('*') that match any substring.The default value is "NoOld". "UseOld" can be combined with "NoKill" to have windows survive a restart of the window manager. If you want FvwmButtons to swallow an old window, and not spawn one itself if failing, let the _command_ be "Nop": + .... *FvwmButtons: (Swallow (UseOld) "Console" Nop) .... + If you want to be able to start it yourself, combine it with an action: + .... *FvwmButtons: (Swallow (UseOld) "Console" Nop, \ Action `Exec "Console" console &`) .... + NoTitle / UseTitle - Specifies whether the title of the button will be taken from the swallowed window's title or not. If "UseTitle" is given, the title on the button changes dynamically to reflect the window name. The default is "NoTitle". + NoFvwmModule / FvwmModule - By default, FvwmButtons treats the swallowed window as an fvwm module window if the 4 first letters of the _command_ is "Fvwm" or the 6 first letters of the _command_ is "Module". NoFvwmModule and FvwmModule override this logic. + Title [(options)] name::: Specifies the title to be written on the button. Whitespace can be included in the title by quoting it. If a title at any time is too long for its buttons, characters are chopped of one at a time until it fits. If _justify_ is "Right", the head is removed, otherwise its tail is removed. These _options_ can be given to Title: + Center - The title is centered horizontally. This is the default. + Left - The title is justified to the left side. + Right - The title is justified to the right side. + Side - Causes the title to appear on the right hand side of any icon or swallowed window, instead of below which is the default. If you use small icons, and combine this with the "Left" or "Right" option, you can get a look similar to fvwm's menus. + ActiveTitle name::: Specifies the title to be written on the button when the mouse is hovering above the button. If no ActiveTitle is specified, the text specified by Title is displayed (if there is any). PressTitle name::: Specifies the title to be written on the button when the button is pressed. If no PressTitle is specified, the text specified by Title is displayed (if there is any). Legacy fields [title icon command]::: These fields are kept for compatibility with previous versions of FvwmButtons, and their use is discouraged. The _title_ field is similar to the option Title _name_. If the title field is "-", no title is displayed. The _icon_ field is similar to the option Icon _filename_. If the icon field is "-" no icon is displayed. The _command_ field is similar to the option Action _command_ or alternatively Swallow "_hangon_" _command_. The command::: Any fvwm command is recognized by FvwmButtons. See fvwm(1) for more information. + The Exec command has a small extension when used in Actions, its syntax is: + .... Exec ["hangon"] command .... + Example: + .... *FvwmButtons: (Action Exec "xload" xload) .... + The hangon string must be enclosed in double quotes. When FvwmButtons finds such an Exec command, the button remains pushed in until a window whose name, class or resource matches the quoted portion of the command is encountered. This is intended to provide visual feedback to the user that the action he has requested will be performed. The hangon string may contain wildcard characters ('*') that match any substring. If the quoted portion contains no characters, then the button will pop out immediately. Note that users can continue pressing the button, and re-executing the command, even when it looks pressed in. + Quoting::: Any string which contains whitespace must be quoted. Contrary to earlier versions commands no longer need to be quoted. In this case any quoting character will be passed on to the application untouched. Only commas ',' and closing parentheses ')' have to be quoted inside a command. Quoting can be done with any of the three quotation characters; single quote: + 'This is a "quote"', + double quote: + "It's another `quote'", + and back quote: + `This is a strange quote`. + The back quoting is unusual but used on purpose, if you use a preprocessor like FvwmCpp and want it to get into your commands, like this: + .... #define BG gray60 *FvwmButtons: (Swallow "xload" `Exec xload -bg BG &`) .... + Any single character can be quoted with a preceding backslash '\'. == CREATING PANELS Former versions of FvwmButtons (fvwm 2.0.46 to 2.3.6) had a different way of handling panels. You can not use your old panel configuration with the new panel feature. Read "CONVERTING OLD PANEL CONFIGURATIONS" for more information. === HOW TO CREATE NEW PANELS Any program that can be launched from within fvwm and that has a window can be used as a panel. A terminal window could be your panel, or some application like xload or xosview or another fvwm module, including FvwmButtons itself. All you need to know is how to start your application from fvwm. The button that invokes the panel is as easily configured as any other button. Essentially you need nothing more than the _Panel_ option: .... *FvwmButtons: (Panel my_first_panel \ "Module FvwmButtons -g -30000-30000 my_first_panel") *FvwmButtons: (Panel my_second_panel \ "Exec exec xterm -g -30000-30000 -n my_second_panel") .... This works like the _Swallow_ option. The difference is that the application is not put into the button when it starts up but instead hidden from view. When you press the button for the panel the window slides into view. The '-g -30000-30000' option tells the application that it should be created somewhere very far to the top and left of your visible screen. Otherwise you would see it flashing for a moment when FvwmButtons starts up. Some applications do not work well with this kind of syntax so you may have to live with the short flashing of the window. If you want to make a panel from another instance of FvwmButtons you can do so, but you must give it a different name ('my_first_panel' in above example). If you run FvwmButtons under the same name, new panels are created recursively until your system runs out of resources and FvwmButtons crashes! To configure a second button bar with a different name, simply put '*new_name' in place of '*FvwmButtons' in your configuration file. If you are not familiar with the _Swallow_ option or if you want to learn more about how 'swallowing' panels works, refer to the description of the _Swallow_ option. Now that your panel basically works you will want to tune it a bit. You may not want a window title on the panel. To disable the title use the fvwm _Style_ command. If your button bar is 'sticky' you may want to make the panel sticky too. And probably the panel window should have no icon in case it is iconified. .... Style name_of_panel_window NoTitle, Sitcky, NoIcon .... You may want your panel to stay open only until you select something in it. You can give FvwmButtons the _-transientpanel_ option after the -g option in the command. FvwmPager has a similar option '-transient'. Last, but not least, you can now put an icon, a title or a small arrow in the button so that you can see what it is for. A title or icon can be specified as usual. To activate the arrow, just add '(indicator)' after the 'Panel' keyword in the example above and the _Padding_ option to leave a few pixels between the arrow and the border of the button. An optional direction in which the panel is opened can be given too: .... *FvwmButtons: (Padding 2, Panel(down, indicator) my_first_panel \ "Module FvwmButtons -g -30000-30000 -transientpanel my_first_panel") .... There are several more options to configure how your panel works, for example the speed and smoothness of the sliding animation. Please refer to the description of the _Panel_ option for further details. === CONVERTING OLD PANEL CONFIGURATIONS This section describes how to convert a pretty old syntax used in 2.2.x versions. You may skip it if your syntax is more recent. With the old panel feature you first had one or more lines defining panels in your main FvwmButtons configuration: .... ... *FvwmButtons(Title WinOps,Panel WinOps) *FvwmButtons(Title Tools ,Panel Tools) ... .... After the last configuration line for the main panel the configuration of the first panel followed, introduced with a line beginning with *FvwmButtonsPanel: .... *FvwmButtonsPanel WinOps *FvwmButtonsBack bisque2 ... *FvwmButtonsPanel Tools *FvwmButtonsBack bisque2 ... .... And perhaps you had style commands for you panels: .... Style FvwmButtonsPanel Title, NoHandles, BorderWidth 0 Style FvwmButtonsPanel NoButton 2, NoButton 4, Sticky .... The new configuration looks much the same, but now the configuration of the main panel is independent of the configuration of the sub panels. The lines invoking the panels use the same syntax as the Swallow option, so you simply add the name of the window to use as a panel and the command to execute instead of the panel name. Note that you give the new instance of FvwmButtons a different name. .... *FvwmButtons: (Title WinOps, Panel WinOps \ "Module FvwmButtons WinOps") *FvwmButtons: (Title Tools , Panel Tools \ "Module FvwmButtons Tools") .... If you used something like 'Panel-d' you now have to use 'Panel(down)' instead. To make the new panel vanish as soon as a button was selected start FvwmButtons with the '-transientpanel' option: .... *FvwmButtons: (Title Tools , Panel(down) Tools \ "Module FvwmButtons -transientpanel Tools") .... The rest of the configuration is very easy to change. Delete the lines '*FvwmButtonsPanel ' and add to all of the following configuration lines for the panel instead. Use the same name in your Style commands: .... *WinOps: Back bisque2 ... *Tools: Back bisque2 ... Style "WinOps" Title, NoHandles, BorderWidth 0 Style "WinOps" NoButton 2, NoButton 4, Sticky Style "Tools" Title, NoHandles, BorderWidth 0 Style "Tools" NoButton 2, NoButton 4, Sticky .... That's it. The new panels are much more flexible. Please refer to other parts of this documentation for details. === WHY WAS THE PANEL FEATURE REWRITTEN? There are several reasons. The most important one is that the program code implementing the panels was very disruptive and caused a lot of problems. At the same time it made writing new features for FvwmButtons difficult at best. The second reason is that most users were simply unable to make it work - it was way too complicated. Even I (the author of the new code) had to spend several hours before I got it working the first time. The third reason is that the new panels are more versatile. Any application can be a panel in FvwmButtons, not just other instances of FvwmButtons itself. So I sincerely hope that nobody is angry about the change. Yes - you have to change your configuration, but the new feature is much easier to configure, especially if you already know how the Swallow option works. == ARRANGEMENT ALGORITHM FvwmButtons tries to arrange its buttons as best it can, by using recursively, on each container including the buttonbox itself, the following algorithm. Getting the size right:: First it calculates the number of button unit areas it will need, by adding the width times the height in buttons of each button. Containers are for the moment considered a normal button. Then it considers the given _rows_ and _columns_ arguments. If the number of rows is given, it will calculate how many columns are needed, and stick to that, unless _columns_ is larger, in which case you will get some empty space at the bottom of the buttonbox. If the number of columns is given, it calculates how many rows it needs to fit all the buttons. If neither is given, it assumes you want two rows, and finds the number of columns from that. If the BoxSize option is set to _smart_ at least the height/width of the tallest/widest button is used while the _fixed_ value prevents the box from getting resized if both _rows_ and _columns_ have been set to non-zero. Shuffling buttons:: Now it has a large enough area to place the buttons in, all that is left is to place them right. There are two kinds of buttons: fixed and floating buttons. A fixed button is forced to a specific slot in the button box by a x/y geometry argument. All other buttons are considered floating. Fixed buttons are placed first. Should a fixed button overlap another one or shall be place outside the buttons window, FvwmButtons exits with an error message. After that the floating buttons are placed. The algorithm tries to place the buttons in a left to right, top to bottom western fashion. If a button fits at the suggested position it is placed there, if not the current slot stays empty and the slot to the right will be considered. After the button has been placed, the next button is tried to be placed in the next slot and so on until all buttons are placed. Additional rows are added below the bottom line of buttons until all buttons are placed if necessary if the BoxSize option _smart_ is used. Containers:: Containers are arranged by the same algorithm, in fact they are shuffled recursively as the algorithm finds them. Clarifying example:: An example might be useful here: Suppose you have 6 buttons, all unit sized except number two, which is 2x2. This makes for 5 times 1 plus 1 times 4 equals 9 unit buttons total area. Assume you have requested 3 columns. .... 1) +---+---+---+ 2) +---+---+---+ 3) +---+---+---+ | 1 | | | 1 | | | 1 | | +---+ + +---+ 2 + +---+ 2 + | | | | | | 3 | | + + + +---+---+ +---+---+---+ | | | | | | | | +-----------+ +---+-------+ +---+---+---+ 4) +---+---+---+ 5) +---+-------+ 6) +---+-------+ | 1 | | | 1 | | | 1 | | +---+ 2 + +---+ 2 | +---+ 2 | | 3 | | | 3 | | | 3 | | +---+---+---+ +---+---+---+ +---+-------+ | 4 | | | 4 | 5 | | | 4 | 5 | 6 | +---+---+---+ +---+---+---+ +---+---+---+ .... What size will the buttons be?:: When FvwmButtons has read the icons and fonts that are required by its configuration, it can find out which size is needed for every non-swallowing button. The unit button size of a container is set to be large enough to hold the largest button in it without squeezing it. Swallowed windows are simply expected to be comfortable with the button size they get from this scheme. If a particular configuration requires more space for a swallowed window, it can be set in that button's configuration line using the option "Size _width height_". This will tell FvwmButtons to give this button at least _width_ by _height_ pixels inside the relief and padding. == DYNAMICAL ACTIONS A running FvwmButtons instance may receive some commands at run time. This is achieved using the fvwm command .... SendToModule FvwmButtons-Alias .... Supported actions: ChangeButton button_id options:: can be used to change the title or icon of a button at run time. _button_id_ is the id of the button to change as specified using the *Id* button option. It may also be a number, in this case the button with the given number is assumed. And finally, _button_id_ may be in the form +x+y, where x and y are a column number and a row number of the button to be changed. It is possible to specify multiple option pairs (name with value) by delimiting them using comma. Currently options include *Title*, *ActiveTitle*, *PressTitle*, *Colorset*, *Icon*, *ActiveIcon* and *PressIcon*. These options work like the configuration options of the same name. ExpandButtonVars button_id command:: replaces variables present in the _command_ exactly like in the *Action* button option and then sends the command back to fvwm. _button_id_ has the same syntax as described in *ChangeButton* above. PressButton button_id [mouse_button]:: simulates a mouse click on a button. _button_id_ is the id of the button to press as specified using the *Id* button option and _mouse_button_ is the number of mouse button used to click on the button e.g "1" for the left mouse button etc. Quotes around the number are not necessary. If _mouse_button_ option is omitted, mouse button 1 is assumed. This command behaves exactly as if the mouse button was pressed and released on the button on in question. Silent:: This prefix may be specified before other actions. It disables all possible error and warning messages. Example::: .... *FvwmButtons: (Id note1, Title "13:30 - Dinner", Icon clock1.xpm) SendToModule FvwmButtons Silent \ ChangeButton note1 Icon clock2.xpm, Title "18:00 - Go Home" .... == SAMPLE CONFIGURATION The following are excerpts from a .fvwm2rc file which describe FvwmButtons initialization commands: .... ########################################################## # Load any modules which should be started during fvwm # initialization # Make sure FvwmButtons is always there. AddToFunc StartFunction "I" Module FvwmButtons # Make it titlebar-less, sticky, and give it an icon Style "FvwmButtons" Icon toolbox.xpm, NoTitle, Sticky # Make the menu/panel look like CDE Style "WinOps" Title, NoHandles, BorderWidth 0 Style "WinOps" NoButton 2, NoButton 4, Sticky Style "Tools" Title, NoHandles, BorderWidth 0 Style "Tools" NoButton 2, NoButton 4, Sticky ########################################################## DestroyModuleConfig FvwmButtons: * *FvwmButtons: Fore Black *FvwmButtons: Back rgb:90/80/90 *FvwmButtons: Geometry -135-5 *FvwmButtons: Rows 1 *FvwmButtons: BoxSize smart *FvwmButtons: Font -*-helvetica-medium-r-*-*-12-* *FvwmButtons: Padding 2 2 *FvwmButtons: (Title WinOps, Panel WinOps \ "Module FvwmButtons -transientpanel WinOps") *FvwmButtons: (Title Tools, Panel Tools \ "Module FvwmButtons -transientpanel Tools") *FvwmButtons: (Title Resize, Icon resize.xpm, Action Resize) *FvwmButtons: (Title Move, Icon arrows2.xpm, Action Move ) *FvwmButtons: (Title Lower, Icon Down, Action Lower ) *FvwmButtons: (Title Raise, Icon Up, Action Raise ) *FvwmButtons: (Title Kill, Icon bomb.xpm, Action Destroy) *FvwmButtons: (1x1,Container(Rows 3,Frame 1)) *FvwmButtons: (Title Dopey ,Action \ `Exec "big_win" xterm -T big_win -geometry 80x50 &`) *FvwmButtons: (Title Snoopy, Font fixed, Action \ `Exec "small_win" xterm -T small_win &`) *FvwmButtons: (Title Smokin') *FvwmButtons: (End) *FvwmButtons: (Title Xcalc, Icon rcalc.xpm, \ Action `Exec "Calculator" xcalc &`) *FvwmButtons: (Title XMag, Icon magnifying_glass2.xpm, \ Action `Exec "xmag" xmag &`) *FvwmButtons: (Title Mail, Icon mail2.xpm, \ Action `Exec "xmh" xmh &`) *FvwmButtons: (4x1, Swallow "FvwmPager" `FvwmPager 0 3` \ Frame 3) *FvwmButtons: (Swallow(UseOld,NoKill) "xload15" `Exec xload \ -title xload15 -nolabel -bg rgb:90/80/90 -update 15 \ -geometry -3000-3000 &`) .... The last lines are a little tricky - one spawns an FvwmPager module, and captures it to display in a quadruple width button. is used, the Pager will be as big as possible within the button's relief. The final line is even more magic. Note the combination of _UseOld_ and _NoKill_, which will try to swallow an existing window with the name "xload15" when starting up (if failing: starting one with the specified command), which is un-swallowed when ending FvwmButtons. The swallowed application is started with "-geometry -3000-3000" so that it will not be visible until its swallowed. The other panels are specified after the root panel: .... ########## PANEL WinOps DestroyModuleConfig WinOps: * *WinOps: Back bisque2 *WinOps: Geometry -3-3 *WinOps: Columns 1 *WinOps: (Title Resize, Icon resize.xpm, Action Resize) *WinOps: (Title Move, Icon arrows2.xpm, Action Move ) *WinOps: (Title Lower, Icon Down, Action Lower ) *WinOps: (Title Raise, Icon Up, Action Raise ) ########## PANEL Tools DestroyModuleConfig Tools: * *Tools: Back bisque2 *Tools: Geometry -1-1 *Tools: Columns 1 *Tools: (Title Kill, Icon bomb.xpm, Action Destroy) .... The color specification _rgb:90/80/90_ is actually the most correct way of specifying independent colors in X, and should be used instead of the older _#908090_. If the latter specification is used in your configuration file, you should be sure to escape the hash in any of the __command__s which will be executed, or fvwm will consider the rest of the line a comment. Note that with the x/y geometry specs you can easily build button windows with gaps. Here is another example. You can not accomplish this without geometry specs for the buttons: .... ########################################################## # Another example ########################################################## # Make it titlebar-less, sticky, and give it an icon Style "FvwmButtons" Icon toolbox.xpm, NoTitle, Sticky DestroyModuleConfig FvwmButtons: * *FvwmButtons: Font 5x7 *FvwmButtons: Back rgb:90/80/90 *FvwmButtons: Fore black *FvwmButtons: Frame 1 # 9x11 pixels per button, 4x4 pixels for the frame *FvwmButtons: Geometry 580x59+0-0 *FvwmButtons: Rows 5 *FvwmButtons: Columns 64 *FvwmButtons: BoxSize fixed *FvwmButtons: Padding 1 1 # Pop up a module menu directly above the button. *FvwmButtons: (9x1+3+0, Padding 0, Title "Modules", \ Action `Menu Modulepopup rectangle \ $widthx$height+$lleft+$top o+50 -100m`) # first row of buttons from left to right: *FvwmButtons: (3x2+0+1, Icon my_lock.xpm, Action `Exec xlock`) *FvwmButtons: (3x2+3+1, Icon my_recapture.xpm, Action Recapture) *FvwmButtons: (3x2+6+1, Icon my_resize.xpm, Action Resize) *FvwmButtons: (3x2+9+1, Icon my_move.xpm, Action Move) *FvwmButtons: (3x2+12+1, Icon my_fvwmconsole.xpm, \ Action 'Module FvwmConsole') # second row of buttons from left to right: *FvwmButtons: (3x2+0+3, Icon my_exit.xpm, Action QuitSave) *FvwmButtons: (3x2+3+3, Icon my_restart.xpm, Action Restart) *FvwmButtons: (3x2+6+3, Icon my_kill.xpm, Action Destroy) *FvwmButtons: (3x2+9+3, Icon my_shell.xpm, Action 'Exec rxvt') # big items *FvwmButtons: (10x5, Swallow (NoKill, NoCLose) \ "FvwmPager" 'FvwmPager * * -geometry 40x40-1024-1024') *FvwmButtons: (6x5, Swallow "FvwmXclock" `Exec xclock \ -name FvwmXclock -geometry 40x40+0-3000 -padding 1 \ -analog -chime -bg rgb:90/80/90`) *FvwmButtons: (13x5, Swallow (NoClose) \ "FvwmIconMan" 'Module FvwmIconMan') *FvwmButtons: (20x5, Padding 0, Swallow "xosview" \ `Exec /usr/X11R6/bin/xosview -cpu -int -page -net \ -geometry 100x50+0-3000 -font 5x7`) .... == BUGS The action part of the Swallow option must be quoted if it contains any whitespace character. == HISTORY The FvwmButtons program, and the concept for interfacing this module to the Window Manager, are all original work by Robert Nation. Originally, FvwmGoodStuff preceded FvwmButtons. == AUTHOR Robert Nation (1993). Somewhat enhanced by Jarl Totland (1996), Jui-Hsuan Joshua Feng, Scott Smedley. fvwm3-1.0.6a/doc/fvwm3_manpage_source.adoc0000644000175000017500000130466314354105651017777 0ustar jaimosjaimos== SYNOPSIS *fvwm3* [*-c* _config-command_] [*-d* _displayname_] [*-f* _config-file_] [*-o* _logfile_] [*-s* [_screen_num_]] [*-v*] [other options] == DESCRIPTION Fvwm is a window manager for X11 optimised for speed. Fvwm is intended to have a small memory footprint and is extremely customizable and extendible. A large _virtual desktop_ and _multiple disjoint desktops_ can be used separately or together. The virtual desktop pretends that the video screen is really quite large, and you can scroll around within the desktop. The multiple disjoint desktops pretend there are really several screens to work at, but each screen is completely unrelated to the others. Fvwm provides _keyboard accelerators_ that allow one to perform practically all window manager functions, including moving and resizing windows and operating the menus, using keyboard shortcuts. Fvwm does not distinguish between configuration and action commands. Configuration commands typically set fonts, colors, menu contents, and key and mouse function bindings, while action commands do things like raising and lowering windows. Fvwm makes no such distinction and allows anything to be changed at any time. == OPTIONS These are the command line options that are recognized by fvwm: *-i* | *--clientid* _id_:: This option is used when fvwm is started by a session manager. Should not be used by a user. *-c* | *--cmd* _config-command_:: Causes fvwm to use _config-command_ instead of '*Read* _config_' (or '*Read* _.fvwm2rc_') as its initialization command. (Note that up to 10 *-f* and *-c* parameters can be given, and they are executed in the order specified.) + Any module started by command line arguments is assumed to be a module that sends back config commands. All command line modules have to quit before fvwm proceeds on to the StartFunction and setting border decorations and styles. There is a potential deadlock if you start a module other than *FvwmCpp*/*FvwmM4*/*FvwmPerl* but there is a timeout so fvwm eventually gets going. + As an example, starting the pager this way hangs fvwm until the timeout, but the following should work well: .... fvwm -c "AddToFunc StartFunction I Module FvwmPager" .... *-d* | *--display* _displayname_:: Manage the display called _displayname_ instead of the name obtained from the environment variable _$DISPLAY_. *-f* _config-file_:: Causes fvwm to read _config-file_ instead of _~/.fvwm/config_ as its initialization file. _$FVWM_USERDIR_ can also be used to change location of default user directory _~/.fvwm_. *-o* _logfile_:: Write log messages to _logfile_. If _logfile_ is '-', log to the console. (Does not turn on logging, see the *-v* option.) *-h* | *--help*:: A short usage description is printed. *-r* | *--replace*:: Try to take over from a previously running wm. This does not work unless the other wm is ICCCM2 2.0 compliant. *-F* | *--restore* _state-file_:: This option is used when fvwm is started by a session manager. Should not be used by a user. *-s* | *--single-screen* [_screen_num_]:: On a multi-screen display, run fvwm only on the screen named in the _$DISPLAY_ environment variable or provided through the *-d* option. The optional argument _screen_num_ should be positive or null and override the screen number. Normally, fvwm attempts to start up on all screens of a multi-screen display. *-V* | *--version*:: Prints the version of fvwm to _stderr_. Also prints an information about the compiled in features as stated at compiletime. *-C* | *--visual* _visual-class_:: Causes fvwm to use _visual-class_ for the window borders and menus. _visual-class_ can be "StaticGray", "GrayScale", "StaticColor", "PseudoColor", "TrueColor" or "DirectColor". *-I* | *--visualid* _id_:: Causes fvwm to use _id_ as the visual id for the window borders and menus. _id_ can be specified as N for decimal or 0xN for hexadecimal. See man page of xdpyinfo for a list of supported visuals. *-l* | *--color-limit* _limit_:: Specifies a _limit_ on the colors used in image, gradient and possibly simple colors used by fvwm. In fact, fvwm (and all the modules) uses a palette with at most _limit_ colors. This option is only useful with screens that display 256 colors (or less) with a dynamic visual (PseudoColor, GrayScale or DirectColor). The default depends on your X server and how you run fvwm. In most case this default is reasonable. The *-l* option should be used only if you encounter problems with colors. By default, fvwm tries to detect large pre-allocated palettes. If such a palette is detected fvwm uses it and a priori the *-l* must not be used. Moreover, in this case the *-A* and *-S* options are forced. Note that XFree-4.2 pre-allocates 244 colors (if you use a driver with Render support) leaving only a few free colors. This may lead to some color problems (and nothing can be done). XFree-4.3 or better pre-allocate only 85 colors. If no pre-allocated palette is auto detected the defaults are as follow: + Display depth 8 (256 colors) + .... PseudoColor: 68 (4x4x4 color cube + 4 grey) GrayScale: 64 regular grey DirectColor: 32 (3x3x3 color cube + 5 grey) .... + Display depth 4 (16 colors) + .... PseudoColor: 10 (2x2x2 color cube + 2 grey) GrayScale: 8 regular grey DirectColor: 10 (2x2x2 color cube + 2 grey) .... + Note that if you use a private color map (i.e., fvwm is started with the *-C* or the *-I* options), then other defaults are used. + Now what to do if you encounter problems with colors? The first thing to do is to check if you really cannot run your X server with depth 15, 16 or better. Check your X server documentation. Note that some hardware can support two different depths on the same screen (typically depth 8 and depth 24). If depth 8 is the default, you can force fvwm to use the best depth by using the *-C* option with _TrueColor_ as argument. So now we assume that you are forced to run in depth 8 with a dynamic visual because your hardware/driver cannot do better or because you need to use an application which needs to run under this mode (e.g., because this application needs read-write colors). What it should be understand is that you have only 256 colors and that all the applications which use the default color map must share these colors. The main problem is that there are applications which use a lot or even all the colors. If you use such application you may have no more free colors and some applications (which used only a few colors) may fail to start or are unusable. There are three things that can be done (and fvwm does not really play a particular role, all applications are concerned). The first is to run the applications which waste your (default) color map with a private color map. For example, run netscape with the -install option, run KDE or QT applications with the --cmap option, use the *-C* option for fvwm. The disadvantage of this method is that it is visually disturbing (see the *ColormapFocus* command for a better control of the color maps switching). The second method is to limit the number of colors that the applications use. Again, some applications have options to specify a given color limit. With fvwm you may try various values, 61 (a special "visual" palette), 56 (a 4x4x3 color cube plus 6 grey), 29 (a 3x3x3 color cube plus 2 grey), 10 or 9. Also, you may use the *-L* option. However, limiting the number of colors is not the definitive solution. The definitive solution is to try cause applications which use a lot of colors use the same colors. This is a difficult task as there are no formal standards for this goal. However, some toolkits as QT and GTK use color cubes as palettes. So, the idea is to configure your applications/toolkits to all use the same color cube. Moreover, you can use the colors in this color cube in your X resources configuration files and/or as arguments to colors options. Fvwm can use any color cube of the form RxGxB with 2 <= R <= 6, R = G, R-1 =< B <= R and B >= 2. To get an RxGxB color cube give an argument to *-l* an integer c >= R*G*B and < (R+1)*(G+1)*B if B=R and < R*G*(B+1) if B < R (and different from 61). If c > R*G*B, then some grey may be added to the color cube. You can use the *PrintInfo* _Colors_ [_1_] command to get information on your fvwm colors setting. In particular, this command prints the palette used by fvwm in rgb format (the last integer gives the number of times fvwm has allocated the colors). *-L* | *--strict-color-limit*:: If the screen displays 256 colors (or less) and has a dynamic visual, causes fvwm to use its palette for all the colors. By default, the palette is used only for images and gradients. *-P* | *--visual-palette*:: If the screen displays 256 colors (or less) and has a dynamic visual, this option causes fvwm to use a palette designed for limiting the "visual" color distance between the points of the palette. Moreover, for better color sharing, if possible colors with a name in the X rgb data base are used for defining the colors (with the hope that applications and images prefer to use named colors). If the *-l* option is not used this palette has 61 colors. This palette is also automatically selected if 61 or 9 is used as argument to the *-l* option. *-A* | *--allocate-palette*:: If the screen displays 256 colors (or less) and has a dynamic visual this option causes fvwm to allocate all the colors of its palette at start up for reserving these colors for future use. This option forces the *-static-palette* option. By default, fvwm allocates (reserves) a color in its palette only if it needs this color. *-S* | *--static-palette*:: If the screen displays 256 colors (or less) and has a dynamic visual this option causes fvwm to never free the colors in its palette. By default, when fvwm does not need a color any more it frees this color so that a new color can be used. This option may speed up image loading and save a few bits of memory. *--debug-stack-ring*:: Enables stack ring debugging. This option is only intended for internal debugging and should only be used by developers. *-v* | *--verbose*:: Enables debug logging. Writes in append mode to fvwm log file, which is ~/.fvwm/fvwm3-output.log by default. See ENVIRONMENT section on how to override this location on fvwm3 startup using _$FVWM_USERDIR_ or _$FVWM3_LOGFILE_ . + Logging can also be dynamically toggled on and off using signals: + .... SIGUSR1 : used as a signal to restart Fvwm SIGUSR2 : used as a signal to toggle opening/closing debug log file .... == ANATOMY OF A WINDOW Fvwm puts a decorative border around most windows. This border consists of a bar on each side and a small L-shaped section on each corner. There is an additional top bar called the title-bar which is used to display the name of the window. In addition, there are up to 10 title-bar buttons. The top, side, and bottom bars are collectively known as the side-bars. The corner pieces are called the frame. With the built-in minimal configuration, dragging mouse button 1 in the frame or side-bars begins a resize operation on the window. Dragging mouse button 2 in the frame or side-bars begins a move operation. There are raise/lower operations bound to a single clicking on borders. Similarly for the window title. Up to ten title-bar buttons may exist. Their use is completely user definable. One popular configuration uses one button on the left that is used to bring up a list of window options and two buttons on the right used to iconify and maximize the window. Another popular configuration adds a close button to the right. The number of title-bar buttons used depends on which ones have mouse actions bound to them. See the *Mouse* command. == THE VIRTUAL DESKTOP Fvwm provides multiple virtual desktops for users who wish to use them. The screen is a viewport onto a _desktop_ which may be larger than the screen. Several distinct desktops can be accessed (concept: one desktop for each project, or one desktop for each application, when view applications are distinct). Since each desktop can be larger than the physical screen, divided into m by n _pages_ which are each the size of the physical screen, windows which are larger than the screen or large groups of related windows can easily be viewed. The (m by n) size (i.e. number of pages) of the virtual desktops can be changed any time, by using the *DesktopSize* command. All virtual desktops must be (are) the same size. The total number of distinct desktops does not need to be specified, but is limited to approximately 4 billion total. All windows on a range of desktops can be viewed in the *FvwmPager*, a miniature view of the desktops. The pager is an accessory program, called a module, which is not essential for the window manager to operate. Windows may also be listed using the *WindowList* command or the *FvwmIconMan* module. Fvwm keeps the windows on the desktop in a layered stacking order; a window in a lower layer never obscures a window in a higher layer. The layer of a window can be changed by using the *Layer* command. The concept of layers is a generalization of the _StaysOnTop_ flag of older fvwm versions. The _StaysOnTop_ and _StaysPut_ *Style* options are now implemented by putting the windows in suitable layers and the previously missing _StaysOnBottom_ *Style* option has been added. _Sticky_ windows are windows which transcend the virtual desktop by "Sticking to the screen's glass". They always stay put on the screen. This is convenient for things like clocks and xbiffs, so you only need to run one such gadget and it always stays with you. Icons can also be made to stick to the glass, if desired. Window geometries are specified relative to the current viewport. That is: .... xterm -geometry +0+0 .... creates a window in the upper left hand corner of the visible portion of the screen. It is permissible to specify geometries which place windows on the virtual desktop, but off the screen. For example, if the visible screen is 1000 by 1000 pixels, and the desktop size is 3x3, and the current viewport is at the upper left hand corner of the desktop, invoking: .... xterm -geometry +1000+1000 .... places a window just off of the lower right hand corner of the screen. It can be found by moving the mouse to the lower right hand corner of the screen and waiting for it to scroll into view. A geometry specified as something like: .... xterm -geometry -5-5 .... places the window's lower right hand corner 5 pixels from the lower right corner of the visible portion of the screen. Not all applications support window geometries with negative offsets. Some applications place the window's upper right hand corner 5 pixels above and to the left of the upper left hand corner of the screen; others may do just plain bizarre things. There are several ways to cause a window to map onto a desktop or page other than the currently active one. The geometry technique mentioned above (specifying x,y coordinates larger than the physical screen size), however, suffers from the limitation of being interpreted relative to the current viewport: the window may not consistently appear on a specific page, unless you always invoke the application from the same page. A better way to place windows on a different page, screen or desk from the currently mapped viewport is to use the _StartsOnPage_ or _StartsOnScreen_ style specification (the successors to the older _StartsOnDesk_ style) in your _config_ file. The placement is consistent: it does not depend on your current location on the virtual desktop. Some applications that understand standard Xt command line arguments and X resources, like xterm and xfontsel, allow the user to specify the start-up desk or page on the command line: .... xterm -xrm "*Desk:1" .... starts an xterm on desk number 1; .... xterm -xrm "*Page:3 2 1" .... starts an xterm two pages to the right and one down from the upper left hand page of desk number 3. Not all applications understand the use of these options, however. You could achieve the same results with the following lines in your _.Xdefaults_ file: .... XTerm*Desk: 1 .... or .... XTerm*Page: 3 2 1 .... == USE ON MULTI-SCREEN DISPLAYS If the *-s* command line argument is not given, fvwm automatically starts up on every screen on the specified display. After fvwm starts each screen is treated independently. Restarts of fvwm need to be performed separately on each screen. The use of .... EdgeScroll 0 0 .... is strongly recommended for multi-screen displays. You may need to quit on each screen to quit from the X session completely. This is not to be confused with RandR support. == RANDR SUPPORT Fvwm supports the RandR X11 protocol. If Fvwm has been compiled wiith RandR support then it tracks the outputs (displays) which it finds. These outputs are stored by name, which can be found by running using the xrand(1) command. In doing so, Fvwm tracks events from RandR, such as when a given output changes size, or has been removed. In such cases, Fvwm will react by moving windows. If an output is removed, those windows on that removed output will be moved to the next active output (the output which contains the mouse pointer). If the same output reappears, Fvwm will move those windows back again. In addition to specific *FvwmEvent* conditions which can be used to track a monitor's change, there is a function called _RandRFunc_ which the user can define to be run when a screen event occurs (such as enabling/disabling/resolution change): .... DestroyFunc RandRFunc AddToFunc RandRFunc + I Exec exec xmessage "A screen changed" .... == DESKTOP BEHAVIOUR Because Fvwm has the capability to track outputs, Fvwm can be told how to handle those. This is controlled via the *DesktopConfiguration* command. By default, Fvwm treats all outputs it finds as one large screen, although Fvwm can be told to treat screens indepedantly of each other. == INITIALIZATION During initialization, fvwm searches for a configuration file which describes key and button bindings, and many other things. The format of these files is described later. Fvwm first searches for configuration files using the command .... Read config .... This looks for file _config_ in _$FVWM_USERDIR_ and _$FVWM_DATADIR_ directories, as described in *Read*. If this fails more files are queried for backward compatibility. Here is the complete list of all file locations queried in the default installation (only the first found file is used): .... $HOME/.fvwm/config /usr/local/share/fvwm/config $HOME/.fvwm/.fvwm2rc $HOME/.fvwm2rc /usr/local/share/fvwm/.fvwm2rc /usr/local/share/fvwm/system.fvwm2rc /etc/system.fvwm2rc .... Please note, the last 5 locations are not guaranteed to be supported in the future. If a configuration file is not found, the left mouse button, or or keys on the root window bring up menus and forms that can create a starting configuration file. Fvwm sets two environment variables which are inherited by its children. These are _$DISPLAY_ which describes the display on which fvwm is running. _$DISPLAY_ may be _unix:0.0_ or _:0.0_, which doesn't work too well when passed through ssh to another machine, so _$HOSTDISPLAY_ is set to a network-ready description of the display. _$HOSTDISPLAY_ always uses the TCP/IP transport protocol (even for a local connection) so _$DISPLAY_ should be used for local connections, as it may use Unix-domain sockets, which are faster. If you want to start some applications or modules with fvwm, you can simply put .... Exec app .... or .... Module FvwmXxx .... into your _config_, but it is not recommended; do this only if you know what you are doing. It is usually important to start applications or modules after the entire config is read, because it contains styles or module configurations which can affect window appearance and functionality. The standard way to start applications or modules on fvwm's start up is to add them to an initialization function (usually *StartFunction* or *InitFunction*). This way they are only started after fvwm finishes to read and execute _config_ file. Fvwm has three special functions for initialization: *StartFunction*, which is executed on startups and restarts; *InitFunction* and *RestartFunction*, which are executed during initialization and restarts (respectively) just after StartFunction. These functions may be customized in a user's _config_ file using the *AddToFunc* command (described later) to start up modules, xterms, or whatever you'd like to have started by fvwm. Fvwm has also a special exit function: *ExitFunction*, executed when exiting or restarting before actually quitting. It could be used to explicitly kill modules, etc. If fvwm is run under a session manager, functions *SessionInitFunction* and *SessionRestartFunction* are executed instead of InitFunction and RestartFunction. This helps to define the user's _config_ file to be good for both running under a session manager and without it. Generally it is a bad idea to start xterms or other applications in "Session*" functions. Also someone can decide to start different modules while running under a session manager or not. For the similar purposes *SessionExitFunction* is used instead of ExitFunction. .... DestroyFunc StartFunction AddToFunc StartFunction + I Module FvwmPager * * + I Module FvwmButtons DestroyFunc InitFunction AddToFunc InitFunction + I Module FvwmBanner + I Module FvwmIconMan + I Exec xsetroot -solid cyan + I Exec xterm + I Exec netscape DestroyFunc RestartFunction AddToFunc RestartFunction + I Module FvwmIconMan DestroyFunc SessionInitFunction AddToFunc SessionInitFunction + I Module FvwmBanner DestroyFunc SessionRestartFunction AddToFunc SessionRestartFunction + I Nop .... You do not need to define all special functions if some are empty. Also note, all these special functions may be emulated now using *StartFunction* and *ExitFunction,* like this: .... DestroyFunc StartFunction AddToFunc StartFunction + I Test (Init) Module FvwmBanner + I Module FvwmPager * * + I Test (Restart) Beep DestroyFunc ExitFunction AddToFunc ExitFunction + I Test (Quit) Echo Bye-bye + I KillModule MyBuggyModule + I Test (ToRestart) Beep .... == COMPILATION OPTIONS Fvwm has a number of compile-time options. If you have trouble using a certain command or feature, check to see if support for it was included at compile time. Optional features are described in the _config.h_ file that is generated during compilation. == ICONS AND IMAGES Fvwm can load *.xbm,* *.xpm,* *.png* and *.svg* images. *XBM* images are monochrome. Fvwm can always display *XBM* files. *XPM* and *PNG* formats are color images. SVG is a vector graphics image format. Compile-time options determine whether fvwm can display *XPM*, *PNG* or *SVG* icons and images. See the _INSTALL.fvwm_ file for more information. The related *SHAPE* compile-time option can make fvwm display spiffy shaped icons. === SVG rendering options SVG images are generated from (XML) text files. A really simple SVG file might look something like this: .... .... By default, SVG images are rendered as the image creator intended them to. But since SVG is a vector graphics format, the images can be rendered at any chosen size and rotation, e.g. making it possible to use the same icon file rendered at different sizes for the _Icon_ and _MiniIcon_ styles. The rendering options are specified as a string appended to the SVG filename as follows: .... _image.svg_:[!] [(1) _size_] [(2) _position_] [(3) _rotation_] [(4) _scale_] ... {empty}(1) [-]_width_{x}[-]_height_ {empty}(2) {- | +}_xpos_{- | +}_ypos_ {empty}(3) @[-]_angle_ {empty}(4) {* | }[-]_factor_[x | y] .... The option string always starts with a colon (':') to separate it from the filename. An empty option string can skip this colon, but it might still be a good idea to include it to prevent ambiguity if the filename contains any colon. .... filename_without_colon.svg filename:with:colon.svg: .... An exclamation point ('!') transposes the entire final image (including the rendering area), i.e. all the horizontal and all the vertical coordinates are swapped with each other. .... image.svg:! .... _width_ and _height_ specifies the dimensions of the rendering area in pixels, i.e. the dimensions of the resulting image. The actual image is fitted to fill the entire rendering area. .... image.svg:60x60 .... Use a _width_ or _height_ value of 0 to keep the aspect ratio. .... image.svg:0x60 image.svg:60x0 .... A '-' before _width_ mirrors the rendering area horizontally. .... image.svg:-0x0 .... A '-' before _height_ mirrors the rendering area vertically. .... image.svg:0x-0 .... _xpos_ and _ypos_ specifies a translation of the image in pixels. A positive _xpos_ value moves the image to the right. A positive _ypos_ value moves it down. Moving it partially outside of the rendering area results in a cropped image. .... image.svg:-30-0 image.svg:-0+10 image.svg:-30+10 .... _angle_ specifies a rotation around the actual image center in degrees. This might result in a cropped image. A positive value rotates the image clockwise. Floating point values are recognized. .... image.svg:@180 image.svg:@-90 image.svg:@30 image.svg:@57.3 .... _factor_ specifes a scaling of the actual image (not the rendering area). Scaling it up results in a cropped image. Floating point values are recognized. Division by zero is ignored. If _factor_ is directly followed by a 'x' or a 'y', the scaling is horizontal or vertical respectively. Otherwise the scaling is uniform. .... image.svg:*2 image.svg:/2 image.svg:/3x image.svg:/2y .... Scaling down a translated or rotated image can prevent cropping. .... image.svg:@30*0.6 .... Repeated usage of translation, rotation, and scaling is allowed. Translation and rotation are additive. Scaling is multiplicative. .... image.svg:*2/3 image.svg:/3x/2y .... When combining affine transformations, the scaling is always done first, then the rotation, and finally the translation. .... image.svg:-30+10@30/3x/2y .... Use a negative scale _factor_ to mirror the actual image. .... image.svg:-30+10@30/-3x/2y .... Mirroring of the rendering area is done after any scaling, rotation or translation of the image. .... image.svg:-0x0-30+10@30/3x/2y .... Transposing is done last of all, after everything else. .... image.svg:!-0x0-30+10@30/3x/2y .... == MODULES A module is a separate program which runs as a separate Unix process but transmits commands to fvwm to execute. Users can write their own modules to do any weird or bizarre manipulations without bloating or affecting the integrity of fvwm itself. Modules must be spawned by fvwm so that it can set up two pipes for fvwm and the module to communicate with. The pipes are already open for the module when it starts and the file descriptors for the pipes are provided as command line arguments. Modules can be spawned by fvwm at any time during the X session by use of the *Module* command. Modules can exist for the duration of the X session, or can perform a single task and exit. If the module is still active when fvwm is told to quit, then fvwm closes the communication pipes and waits to receive a SIGCHLD from the module, indicating that it has detected the pipe closure and has exited. If modules fail to detect the pipe closure fvwm exits after approximately 30 seconds anyway. The number of simultaneously executing modules is limited by the operating system's maximum number of simultaneously open files, usually between 60 and 256. Modules simply transmit commands to the fvwm command engine. Commands are formatted just as in the case of a mouse binding in the _config_ setup file. Certain auxiliary information is also transmitted, as in the sample module *FvwmButtons*. Please refer to the *Module Commands* section for details. == ICCCM COMPLIANCE Fvwm attempts to be ICCCM 2.0 compliant. Check _http://tronche.com/gui/x/icccm/_ for more info. In addition, ICCCM states that it should be possible for applications to receive any keystroke, which is not consistent with the keyboard shortcut approach used in fvwm and most other window managers. In particular you cannot have the same keyboard shortcuts working with your fvwm and another fvwm running within Xnest (a nested X server running in a window). The same problem exists with mouse bindings. The ICCCM states that windows possessing the property .... WM_HINTS(WM_HINTS): Client accepts input or input focus: False .... should not be given the keyboard input focus by the window manager. These windows can take the input focus by themselves, however. A number of applications set this property, and yet expect the window manager to give them the keyboard focus anyway, so fvwm provides a window style, _Lenience_, which allows fvwm to overlook this ICCCM rule. Even with this window style it is not guaranteed that the application accepts focus. The differences between ICCCM 1.1 and 2.0 include the ability to take over from a running ICCCM 2.0 compliant window manager; thus .... fvwm; vi ~/.fvwm/config; fvwm -replace .... resembles the *Restart* command. It is not exactly the same, since killing the previously running wm may terminate your X session, if the wm was started as the last client in your _.Xclients_ or _.Xsession_ file. Further additions are support for client-side colormap installation (see the ICCCM for details) and the urgency hint. Clients can set this hint in the WM_HINTS property of their window and expect the window manager to attract the user's attention to the window. Fvwm has two re-definable functions for this purpose, "UrgencyFunc" and "UrgencyDoneFunc", which are executed when the flag is set/cleared. Their default definitions are: .... AddToFunc UrgencyFunc + I Iconify off + I FlipFocus + I Raise + I WarpToWindow !raise 5p 5p AddToFunc UrgencyDoneFunc + I Nop .... == EXTENDED WINDOW MANAGER HINTS Fvwm attempts to respect the extended window manager hints (ewmh or EWMH for short) specification: _https://specifications.freedesktop.org/wm-spec/wm-spec-1.3.html_ and some extensions of this specification. This support is configurable with styles and commands. These styles and commands have EWMH as the prefix (so you can find them easily in this man page). There is a new Context 'D' for the *Key*, *PointerKey*, *Mouse* commands. This context is for desktop applications (such as kdesktop and Nautilus desktop). When a compliant taskbar asks fvwm to activate a window (typically when you click on a button which represents a window in such a taskbar), then fvwm calls the complex function *EWMHActivateWindowFunc* which by default is Iconify Off, Focus and Raise. You can redefine this function. For example: .... DestroyFunc EWMHActivateWindowFunc AddToFunc EWMHActivateWindowFunc I Iconify Off + I Focus + I Raise + I WarpToWindow 50 50 .... additionally warps the pointer to the center of the window. The EWMH specification introduces the notion of Working Area. Without ewmh support the Working Area is the full visible screen (or all your screens if you have a multi head setup with RandR). 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. == CONFIGURATION === Configuration Files The configuration file is used to describe mouse and button bindings, colors, the virtual display size, and related items. The initialization configuration file is typically called _config_ (or _.fvwm2rc_). By using the *Read* command, it is easy to read in new configuration files as you go. Lines beginning with '#' are ignored by fvwm. Lines starting with '*' are expected to contain module configuration commands (rather than configuration commands for fvwm itself). Like in shell scripts embedded newlines in a configuration file line can be quoted by preceding them with a backslash. All lines linked in this fashion are treated as a single line. The newline itself is ignored. Fvwm makes no distinction between configuration commands and action commands, so anything mentioned in the fvwm commands section can be placed on a line by itself for fvwm to execute as it reads the configuration file, or it can be placed as an executable command in a menu or bound to a mouse button or a keyboard key. It is left as an exercise for the user to decide which function make sense for initialization and which ones make sense for run-time. === Supplied Configuration A sample configuration file, is supplied with the fvwm distribution. It is well commented and can be used as a source of examples for fvwm configuration. It may be copied from _/usr/local/share/fvwm/config_ file. Alternatively, the built-in menu (accessible when no configuration file is found) has options to create an initial config file for the user. == FONTS === Font names and font loading The fonts used for the text of a window title, icon titles, menus and geometry window can be specified by using the Font and IconFont *Style*, the Font *MenuStyle* and the *DefaultFont* commands. Also, all the Modules which use text have configuration command(s) to specify font(s). All these styles and commands take a font name as an argument. This section explains what is a font name for fvwm and which fonts fvwm loads. First, you can use what we can call a usual font name, for example, .... -adobe-courier-bold-r-normal--10-100-75-75-m-60-ISO8859-1 -adobe-courier-bold-r-normal--10-* -*-fixed-medium-o-normal--14-*-ISO8859-15 .... That is, you can use an X Logical Font Description (XLFD for short). Then the "first" font which matches the description is loaded and used. This "first" font depends of your font path and also of your locale. Fonts which match the locale charset are loaded in priority order. For example with .... -adobe-courier-bold-r-normal--10-* .... if the locale charset is ISO8859-1, then fvwm tries to load a font which matches .... -adobe-courier-bold-r-normal--10-*-ISO8859-1 .... with the locale charset ISO8859-15 fvwm tries to load .... -adobe-courier-bold-r-normal--10-*-ISO8859-15. .... A font name can be given as an extended XLFD. This is a comma separated list of (simple) XLFD font names, for example: .... -adobe-courier-bold-r-normal--14-*,-*-courier-medium-r-normal--14-* .... Each simple font name is tried until a matching font with the locale charset is found and if this fails each simple font name is tried without constraint on the charset. More details on the XLFD can be found in the X manual page, the X Logical Font Description Conventions document (called xlfd) and the XLoadFont and XCreateFontSet manual pages. Some useful font utilities are: xlsfonts, xfontsel, xfd and xset. If you have Xft support you can specify an Xft font name (description) of a true type (or Type1) font prefixed by "xft:", for example: .... "xft:Luxi Mono" "xft:Luxi Mono:Medium:Roman:size=14:encoding=iso8859-1" .... The "first" font which matches the description is loaded. This first font depends on the XftConfig configuration file with Xft1 and on the /etc/fonts/fonts.conf file with Xft2. One may read the Xft manual page and the fontconfig man page with Xft2. The first string which follows "xft:" is always considered as the family. With the second example Luxi Mono is the Family (Other XFree TTF families: "Luxi Serif", "Luxi Sans"), Medium is the Weight (other possible weights: Light, DemiBold, Bold, Black), Roman is the slant or the style (other possibilities: Regular, Oblique, Italic) size specifies the point size (for a pixel size use pixelsize=), encoding allows for enforce a charset (iso8859-1 or iso10646-1 only; if no encoding is given the locale charset is assumed). An important parameter is "minspace=bool" where bool is True or False. If bool is False (the default?) Xft gives a greater font height to fvwm than if bool is True. This may modify text placement, icon and window title height, line spacing in menus and *FvwmIdent*, button height in some fvwm modules ...etc. With a LCD monitor you may try to add "rgba=mode" where mode is either rgb, bgr, vrgb or vbgr to enable subpixel rendering. The best mode depends on the way your LCD cells are arranged. You can pass other specifications in between ":", as "foundry=foundry_name", "spacing=type" where type can be monospace, proportional or charcell, "charwidth=integer", "charheight=integer" or "antialias=bool" where bool is True or False. It seems that these parameters are not always taken in account. To determine which Xft fonts are really loaded you can export XFT_DEBUG=1 before starting fvwm and take a look to the error log. With Xft2 you may use fc-list to list the available fonts. Anyway, Xft support is experimental (from the X and the fvwm point of view) and the quality of the rendering depends on number of parameters (the XFree and the freetype versions and your video card(s)). After an Xft font name you can add after a ";" an XLFD font name (simple or extended) as: .... xft:Verdana:pixelsize=14;-adobe-courier-bold-r-normal--14-* .... then, if either loading the Xft font fails or fvwm has no Xft support, fvwm loads the font "-adobe-courier-bold-r-normal--14-*". This allows for writing portable configuration files. === Font and string encoding Once a font is loaded, fvwm finds its encoding (or charset) using its name (the last two fields of the name). fvwm assumes that the strings which are displayed with this font use this encoding (an exception is that if an iso10646-1 font is loaded, then UTF-8 is assumed for string encoding). In a normal situation, (i) a font is loaded by giving a font name without specifying the encoding, (ii) the encoding of the loaded font is the locale encoding, and then (iii) the strings in the fvwm configuration files should use the locale encoding as well as the window and icon name. With Xft the situation is bit different as Xft supports only iso10646-1 and iso8859-1. If you do not specify one of these encodings in the Xft font name, then fvwm does strings conversion using (iii). Note that with multibyte fonts (and in particular with "CJK" fonts) for good text rendering, the locale encoding should be the charset of the font. To override the previous rules, it is possible to specify the string encoding in the beginning of a font description as follow: .... StringEncoding=enc:_full_font_name_ .... where _enc_ is an encoding supported by fvwm (usually font name charset plus some unicode encodings: UTF-8, USC-2, USC-4 and UTF-16). For example, you may use an iso8859-1 locale charset and have an *FvwmForm* in Russian using koi8-r encoding. In this case, you just have to ask *FvwmForm* to load a koi8-r font by specifying the encoding in the font name. With a multibyte language, (as multibyte font works well only if the locale encoding is the charset of the font), you should use an iso10646-1 font: .... StringEncoding=jisx0208.1983-0:-*-fixed-medium-r-*-ja-*-iso10646-1 .... or .... "StringEncoding=jisx0208.1983-0:xft:Bitstream Cyberbit" .... if your *FvwmForm* configuration uses jisx0208.1983-0 encoding. Another possibility is to use UTF-8 encoding for your *FvwmForm* configuration and use an iso10646-1 font: .... -*-fixed-medium-r-*-ja-*-iso10646-1 .... or .... "StringEncoding=UTF-8:xft:Bitstream Cyberbit" .... or equivalently .... "xft:Bitstream Cyberbit:encoding=iso10646-1" .... In general iso10646-1 fonts together with UTF-8 string encoding allows the display of any characters in a given menu, *FvwmForm* etc. More and more, unicode is used and text files use UTF-8 encoding. However, in practice the characters used range over your locale charset. For saving memory (an iso10646-1 font may have a very large number of characters) or because you have a pretty font without an iso10646-1 charset, you can specify the string encoding to be UTF-8 and use a font in the locale charset: .... StringEncoding=UTF-8:-*-pretty_font-*-12-* .... In most cases, fvwm correctly determines the encoding of the font. However, some fonts do not end with valid encoding names. When the font name isn't normal, for example: .... -misc-fixed-*--20-*-my_utf8-36 .... you need to add the encoding after the font name using a slash as a delimiter. For example: .... MenuStyle * Font -misc-fixed-*--20-*-my_utf8-36/iso10646-1 .... If fvwm finds an encoding, fvwm uses the iconv system functions to do conversion between encodings. Unfortunately, there are no standards. For conversion between iso8859-1 and UTF-8: a GNU system uses "ISO-8859-1" and other systems use "iso881" to define the converters (these two names are supported by fvwm). Moreover, in some cases it may be necessary to use machine specific converters. So, if you experience problems you can try to get information on your iconv implementation ("man iconv" may help) and put the name which defines the converter between the font encoding and UTF-8 at the end of the font name after the encoding hint and a / (another possible solution is to use GNU libiconv). For example use: .... Style * Font -misc-fixed-*--14-*-iso8859-1/*/latin1 .... to use latin1 for defining the converter for the iso8859-1 encoding. The "*" in between the "/" says to fvwm to determine the encoding from the end of the font name. Use: .... Style * Font \ -misc-fixed-*--14-*-local8859-6/iso8859-6/local_iso8859_6_iconv .... to force fvwm to use the font with iso8859-6 as the encoding (this is useful for bi-directionality) and to use local_iso8859_6_iconv for defining the converters. === Font Shadow Effects Fonts can be given 3d effects. At the beginning of the font name (or just after a possible StringEncoding specification) add .... Shadow=size [offset] [directions]]: .... _size_ is a positive integer which specifies the number of pixels of shadow. _offset_ is an optional positive integer which defines the number of pixels to offset the shadow from the edge of the character. The default offset is zero. _directions_ is an optional set of directions the shadow emanates from the character. The _directions_ are a space separated list of fvwm directions: _N_, _North_, _Top_, _t_, _Up_, _u_, _-_ _E_, _East_, _Right_, _r_, _Right_, _r_, _]_ _S_, _South_, _Bottom_, _b_, _Down_, _d_, ___ _W_, _West_, _Left_, _l_, _Left_, _l_, _[_ _NE_, _NorthEast_, _TopRight_, _tr_, _UpRight_, _ur_, _^_ _SE_, _SouthEast_, _BottomRight_, _br_, _DownRight_, _dr_, _>_ _SW_, _SouthWest_, _BottomLeft_, _bl_, _DownLeft_, _dl_, _v_ _NW_, _NorthWest_, _TopLeft_, _tl_, _UpLeft_, _ul_, _<_ _C_, _Center_, _Centre_, _._ A shadow is displayed in each given direction. _All_ is equivalent to all the directions. The default _direction_ is _BottomRight_. With the _Center_ direction, the shadow surrounds the whole string. Since this is a super set of all other directions, it is a waste of time to specify this along with any other directions. The shadow effect only works with colorsets. The color of the shadow is defined by using the _fgsh_ option of the *Colorset* command. Please refer to the *Colorsets* section for details about colorsets. Note: It can be difficult to find the font, _fg_, _fgsh_ and _bg_ colors to make this effect look good, but it can look quite good. == BI-DIRECTIONAL TEXT Arabic and Hebrew text require bi-directional text support to be displayed correctly, this means that logical strings should be converted before their visual presentation, so left-to-right and right-to-left sub-strings are determined and reshuffled. In fvwm this is done automatically in window titles, menus, module labels and other places if the fonts used for displaying the text are of one of the charsets that require _bidi_ (bi-directional) support. For example, this includes iso8859-6, iso8859-8 and iso10646-1 (unicode), but not other iso8859-* fonts. This bi-directional text support is done using the _fribidi_ library compile time option, see _INSTALL.fvwm_. == KEYBOARD SHORTCUTS Almost all window manager operations can be performed from the keyboard so mouse-less operation should be possible. In addition to scrolling around the virtual desktop by binding the *Scroll* command to appropriate keys, *Popup*, *Move*, *Resize*, and any other command can be bound to keys. Once a command is started the pointer is moved by using the up, down, left, and right arrows, and the action is terminated by pressing return. Holding down the Shift key causes the pointer movement to go in larger steps and holding down the control key causes the pointer movement to go in smaller steps. Standard emacs and vi cursor movement controls can be used instead of the arrow keys. == SESSION MANAGEMENT Fvwm supports session management according to the X Session Management Protocol. It saves and restores window position, size, stacking order, desk, stickiness, shadiness, maximizedness, iconifiedness for all windows. Furthermore, some global state is saved. Fvwm doesn't save any information regarding styles, decors, functions or menus. If you change any of these resources during a session (e.g. by issuing *Style* commands or by using various modules), these changes are lost after saving and restarting the session. To become permanent, such changes have to be added to the configuration file. Note further that the current implementation has the following anomaly when used on a multi-screen display: Starting fvwm for the first time, fvwm manages all screens by forking a copy of itself for each screen. Every copy knows its parent and issuing a *Quit* command to any instance of fvwm kills the master and thus all copies of fvwm. When you save and restart the session, the session manager brings up a copy of fvwm on each screen, but this time they are started as individual instances managing one screen only. Thus a *Quit* kills only the copy it was sent to. This is probably not a very serious problem, since with session management, you are supposed to quit a session through the session manager anyway. If it is really needed, .... Exec exec killall fvwm .... still kills all copies of fvwm. Your system must have the *killall* command though. == BOOLEAN ARGUMENTS A number of commands take one or several boolean arguments. These take a few equivalent inputs: "yes", "on", "true", "t" and "y" all evaluate to true while "no", "off", "false", "f" and "n" evaluate to false. Some commands allow "toggle" too which means that the feature is disabled if it is currently enabled and vice versa. == BUILTIN KEY AND MOUSE BINDINGS The following commands are built-in to fvwm: .... Key Help R A Popup MenuFvwmRoot Key F1 R A Popup MenuFvwmRoot Key Tab A M WindowList Root c c NoDeskSort Key Escape A MC EscapeFunc Mouse 1 R A Menu MenuFvwmRoot Mouse 1 T A FuncFvwmRaiseLowerX Move Mouse 1 FS A FuncFvwmRaiseLowerX Resize Mouse 2 FST A FuncFvwmRaiseLowerX Move AddToFunc FuncFvwmRaiseLowerX + I Raise + M $0 + D Lower .... The Help and F1 keys invoke a built-in menu that fvwm creates. This is primarily for new users that have not created their own configuration file. Either key on the root (background) window pops up an menu to help you get started. The Tab key pressed anywhere with the Alt key (same as the key on PC keyboards) held down pop-ups a window list. Mouse button 1 on the title-bar or side frame can move, raise or lower a window. Mouse button 1 on the window corners can resize, raise or lower a window. You can override or remove these bindings. To remove the window list binding, use this: .... Key Tab A M - .... == COMMAND EXECUTION === Module and Function Commands If fvwm encounters a command that it doesn't recognize, it checks to see if the specified command should have been .... Function (rest of command) .... or .... Module (rest of command) .... This allows complex functions or modules to be invoked in a manner which is fairly transparent to the configuration file. Example: the _config_ file contains the line .... HelpMe .... Fvwm looks for an fvwm command called "HelpMe", and fails. Next it looks for a user-defined complex function called "HelpMe". If no such function exists, fvwm tries to execute a module called "HelpMe". === Delayed Execution of Commands **Note**: There are many commands that affect look and feel of specific, some or all windows, like *Style*, *Mouse*, *Colorset*, *TitleStyle* and many others. For performance reasons such changes are not applied immediately but only when fvwm is idle, i.e. no user interaction or module input is pending. Specifically, new *Style* options that are set in a function are not applied until after the function has completed. This can sometimes lead to unwanted effects. To force that all pending changes are applied immediately, use the *UpdateStyles*, *Refresh* or *RefreshWindow* commands. == QUOTING Quotes are required only when needed to make fvwm consider two or more words to be a single argument. Unnecessary quoting is allowed. If you want a quote character in your text, you must escape it by using the backslash character. For example, if you have a pop-up menu called "Window-Ops", then you do not need quotes: .... Popup Window-Ops .... but if you replace the dash with a space, then you need quotes: .... Popup "Window Ops" .... The supported quoting characters are double quotes, single quotes and reverse single quotes. All three kinds of quotes are treated in the same way. Single characters can be quoted with a preceding backslash. Quoting single characters works even inside other kinds of quotes. == COMMAND EXPANSION Whenever an fvwm command line is executed, fvwm performs parameter expansion. A parameter is a '$' followed by a word enclosed in brackets ($[...]) or a single special character. If fvwm encounters an unquoted parameter on the command line it expands it to a string indicated by the parameter name. Unknown parameters are left untouched. Parameter expansion is performed before quoting. To get a literal '$' use "$$". If a command is prefixed with a '-' parameter expansion isn't performed. This applies to the command immediately following the '-', in which the expansion normally would have taken place. When uesed together with other prefix commands it must be added before the other prefix. Example: .... Pick -Exec exec xmessage '$[w.name]' .... opens an xmessage dialog with "$[w.name]" unexpanded. The longer variables may contain additional variables inside the name, which are expanded before the outer variable. In earlier versions of fvwm, some single letter variables were supported. It is deprecated now, since they cause a number of problems. You should use the longer substitutes instead. Example: .... # Print the current desk number, horizontal page number # and the window's class (unexpanded here, no window). Echo $[desk.n] $[page.nx] $[w.class] .... Note: If the command is called outside a window context, it prints "$[w.class]" instead of the class name. It is usually not enough to have the pointer over a window to have a context window. To force using the window with the focus, the *Current* command can be used: .... Current Echo $[desk.n] $[page.nx] $[w.class] .... The parameters known by fvwm are: $$:: A literal '$'. $.:: The absolute directory of the currently Read file. Intended for creating relative and relocatable configuration trees. If used outside of any read file, the returned value is '.'. $0 to $9:: The positional parameters given to a complex function (a function that has been defined with the *AddToFunc* command). "$0" is replaced with the first parameter, "$1" with the second parameter and so on. If the corresponding parameter is undefined, the "$..." is deleted from the command line. $*:: All positional parameters given to a complex function. This includes parameters that follow after "$9". $[_n_]:: The _n_:th positional parameter given to a complex function, counting from 0. If the corresponding parameter is undefined, the "$[_n_]" is deleted from the command line. The parameter is expanded unquoted. $[_n_-_m_]:: The positional parameters given to a complex function, starting with parameter _n_ and ending with parameter _m_. If all the corresponding parameters are undefined, the "$[...]" is deleted from the command line. If only some of the parameters are defined, all defined parameters are expanded, and the remaining silently ignored. All parameters are expanded unquoted. $[_n_-]:: All the positional parameters given to a complex function, starting with parameter _n_. If all the corresponding parameters are undefined, the "$[...]" is deleted from the command line. All parameters are expanded unquoted. $[*]:: All the positional parameters given to a complex function. This is equivalent of $[0-]. $[version.num]:: The version number, like "2.6.0". $[version.info]:: The version info, which contains the SHA of the latest commit (if compiled from git), or "(relesaed)" if a compiled from a release tarball. $[version.line]:: The first line printed by the --version command line option. $[vp.x] $[vp.y] $[vp.width] $[vp.height]:: Either coordinate or the width or height of the current viewport. $[wa.x] $[wa.y] $[wa.width] $[wa.height]:: Either coordinate or the width or height of the EWMH working area. $[dwa.x] $[dwa.y] $[dwa.width] $[dwa.height]:: Either coordinate or the width or height of the dynamic EWMH working area. $[desk.n]:: The current desk number. $[desk.name]:: These parameters are replaced with the name of the desktop number that is defined with the *DesktopName* command. If no name is defined, then the default name is returned. $[desk.width] $[desk.height]:: The width or height of the whole desktop, i.e. the width or height multiplied by the number of pages in x or y direction. $[desk.pagesx] $[desk.pagesy]:: The number of total pages in a desk in x or y direction. This is the same as the values set by *DesktopSize*. $[page.nx] $[page.ny]:: The current page numbers, by X and Y axes, starting from 0. _page_ is equivalent to _area_ in the GNOME terminology. $[w.id]:: The window-id (expressed in hex, e.g. 0x10023c) of the window the command was called for or "$[w.id]" if no window is associated with the command. $[w.name] $[w.iconname] $[w.class] $[w.resource] $[w.visiblename] $[w.iconfile] $[w.miniiconfile] $[w.iconfile.svgopts] $[w.miniiconfile.svgopts]:: The window's name, icon name, resource class and resource name, visible name, file name of its icon or mini icon defined with the _Icon_ or _MiniIcon_ style (including the full path if the file was found on disk), and (if fvwm is compiled with SVG support) the icon or mini icon svg rendering options (including the leading colon), or unexpanded "$[w.]" string if no window is associated with the command. + Note, the first 5 variables may include any kind of characters, so these variables are quoted. It means that the value is surrounded by single quote characters and any contained single quote is prefixed with a backslash. This guarantees that commands like: + .... Style $[w.resource] Icon norm/network.png .... + work correctly, regardless of any special symbols the value may contain, like spaces and different kinds of quotes. + In the case of the window's visible name, this is the value returned from the literal title of the window shown in the titlebar. Typically this will be the same as $[w.name] once expanded, although in the case of using _IndexedWindowName_ then this is more useful a distinction, and allows for referencing the specific window by its visible name for inclusion in things like *Style* commands. $[w.x] $[w.y] $[w.width] $[w.height]:: Either coordinate or the width or height of the current window if it is not iconified. If no window is associated with the command or the window is iconified, the string is left as is. $[w.pagex] $[w.pagey]:: The X or Y page the window is on. $[w.desk]:: The number of the desk on which the window is shown. If the window is sticky the current desk number is used. $[w.layer]:: The layer of the window. $[w.screen]:: The screen name the window is on. If RandR is not present, this does not expand. $[cw.x] $[cw.y] $[cw.width] $[cw.height]:: These work like $[w.…] but return the geometry of the client part of the window. In other words: the border and title of the window is not taken into account. $[i.x], $[it.x], $[ip.x] $[i.y], $[it.y], $[ip.y] $[i.width], $[it.width], $[ip.width] $[i.height], $[it.height], $[ip.height]:: These work like $[w.…] but return the geometry of the icon ($[i.…]), the icon title ($[it.…]) or the icon picture ($[ip.…]). $[pointer.x] $[pointer.y]:: These return the position of the pointer on the screen. If the pointer is not on the screen, these variables are not expanded. $[pointer.wx] $[pointer.wy]:: These return the position of the pointer in the selected window. If the pointer is not on the screen, the window is iconified or no window is selected, these variables are not expanded. $[pointer.cx] $[pointer.cy]:: These return the position of the pointer in the client portion of the selected window. If the pointer is not on the screen, the window is shaded or iconified or no window is selected, these variables are not expanded. $[pointer.screen]:: The screen name the pointer is currently on. No expansion if RandR is not enabled. + This is deprecated; use $[monitor.current] instead. $[monitor..x], $[monitor..y], $[monitor..width], $[monitor..height], $[monitor..desk], $[monitor..pagex], $[monitor..pagey] $[monitor.primary], $[monitor.current], $[monitor.prev] $[monitor.output], $[monitor.count], $[monitor..prev_desk], $[monitor..prev_pagex], $[monitor..prev_pagey]:: Returns information about the selected monitor. These can be nested, for example: $[monitor.$[monitor.primary].width] + should be a valid xrandr(1) output name. + "x" returns the monitor's x position; "y" returns the monitor's y position; "width" returns the monitor's width (in pixels); "height" returns the monitor's height (in pixels) + "current" is the same as the deprecated $[screen.pointer] variable; the monitor which has the mouse pointer. + "prev" returns the previously focused monitor, or the empty string if there isn't one. + "count" returns the number of active monitors. + "desk" returns the current desk displayed on the referenced monitor. + "pagex" returns the X page on the referenced monitor. + "pagey" returns the Y page of the referenced monitor. + "primary" is the name of the output set as primary via xrandr(1). + "prev_desk" returns the previous desk on the referenced monitor. + "prev_pagex" returns the previous X page on the referenced monitor. + "prev_pagey" returns the previous Y page on the referenced monitor. $[screen]:: The screen number fvwm is running on. Useful for setups with multiple screens. $[screen.count]:: The total number of screens detected. Assumes RandR. + This is deprecated; use $[monitor.count] instead. $[fg.cs] $[bg.cs] $[hilight.cs] $[shadow.cs] $[fgsh.cs]:: These parameters are replaced with the name of the foreground (fg), background (bg), hilight (hilight), shadow (shadow), or the font shadow (fgsh) color that is defined in colorset (replace with zero or a positive integer). For example "$[fg.cs3]" is expanded to the name of the foreground color of colorset 3 (in rgb:rrrr/gggg/bbbb form). + If .lighten

or .darken

is appended to the parameters, they are instead replaced with a color that is lighter or darker than the one defined in colorset by a percentage value

(between 0 and 100). For example "$[bg.cs3.lighten15]" is expanded to the background color of colorset 3 and then lightened 15% (in rgb:rrrr/gggg/bbbb form). + If .hash is appened to the end the color output will use #rrggbb form (instead of rgb:rrrr/gggg/bbbb). For example, $[bg.cs3.hash] or $[bg.cs3.lighten15.hash]. + Please refer to the *Colorsets* section for details about colorsets. $[schedule.last]:: This is replaced by the id of the last command that was scheduled with the *Schedule* command, even if this command was already executed. $[schedule.next]:: This is replaced by the id the next command used with *Schedule* will get (unless a different id is specified explicitly). $[cond.rc]:: The return code of the last conditional command. This variable is only valid inside a function and can not be used in a conditional command. Please refer to the section *Conditional Commands* in the command list. $[func.context]:: The context character of the running command as used in the *Mouse*, *Key* or *PointerKey* command. This is useful for example with: + .... Mouse 3 FS N WindowShade $$[func.context] .... $[debuglog.state]:: Either _0_ (debug log closed) or _1_. Indicates the current state of debugging and logging facility. $[gt._str_]:: return the translation of _str_ by looking in the current locale catalogs. If no translation is found _str_ is returned as is. See the *LocalePath* command. $[infostore._key_]:: Return the value of the item stored in the InfoStore at the given _key_. If no key is present, the unexpanded string is returned. $[...]:: If the string within the braces is neither of the above, fvwm tries to find an environment variable with this name and replaces its value if one is found (e.g. "$[PAGER]" could be replaced by "more"). Otherwise the string is left as is. + Some examples can be found in the description of the *AddToFunc* command. == SCRIPTING AND COMPLEX FUNCTIONS To achieve the more complex effects, fvwm has a number of commands that improve its scripting abilities. Scripts can be read from a file with *Read*, from the output of a command with *PipeRead* or written as a complex function with the *AddToFunc* command. For the curious, section 7 of the fvwm FAQ shows some real life applications of scripting. Please refer to the sections *User Functions and Shell Commands* and *Conditional Commands* for details. A word of warning: during execution of complex functions, fvwm needs to take all input from the mouse pointer (the pointer is "grabbed" in the slang of X). No other programs can receive any input from the pointer while a function is run. This can confuse some programs. For example, the xwd program refuses to make screen shots when run from a complex function. To achieve the same functionality you can use the *Read* or *PipeRead* command instead. ifdef::fvwm3[] == MENU CONCEPTS AND COMMANDS Please refer to the fvwm3menus man page. endif::[] ifdef::fvwm3all[] // BEGIN 'menus' == MENUS Before a menu can be opened, it has to be populated with menu items using the *AddToMenu* command and bound to a key or mouse button with the *Key*, *PointerKey* or *Mouse* command (there are many other ways to invoke a menu too). This is usually done in the configuration file. Fvwm menus are extremely configurable in look and feel. Even the slightest nuances can be changed to the user's liking, including the menu item fonts, the background, delays before popping up sub menus, generating menus dynamically and many other features. Please refer to the *MenuStyle* command to learn more. *Types of Menus*:: 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. + Normal menus are very similar command, but slightly transient. When invoked by clicking a mouse button, they stay open and can be navigated with no button held. But if invoked by a button press followed by mouse motion, it behaves exactly like a popup menu. The *Menu* command creates normal menus. + "Sub menus" are menus inside other menus. When a menu item that has the *Popup* command as its action is selected, the named menu is opened as a sub menu to the parent. Any type of menu can have sub menus. + "Tear off menus" are menus that have been "torn off" their original context 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. *Menu Anatomy*:: Menus consist of any number of titles which are inactive menu items that usually appear at the top of the menu, normal items triggering various actions when selected, separator lines between the items, tear off bars (a horizontal broken line) that tear off the menu when selected, and sub menu items indicated with a triangle pointing left or right, depending on the direction in which the sub menu appears. All the above menu items are optional. + Additionally, if the menu is too long to fit on the screen, the excess menu items are put in a continuation menu and a sub menu with the string "More..." is placed at the bottom of the menu. The "More..." string honors the locale settings. + Finally, there may be a picture running up either side of the menu (a "side bar"). *Menu Navigation*:: Menus are navigated with the keyboard and the mouse. Many people prefer to use the mouse, but it can be tedious. 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), + (activate item) and + (close menu). Numerous other keys can be used to navigate through menus by default: + _Enter_, _Return_, _Space_ activate the current item. + _Escape_, _Delete_, _Ctrl-G_ exit the current sequence of menus or destroy a tear off menu. + _J_, _N_, _Cursor-Down_, _Tab_, _Meta-Tab_, _Ctrl-F_, move to the next item. + _K_, _P_, _Cursor-Up_, _Shift-Tab_, _Shift-Meta-Tab_, _Ctrl-B_, move to the prior item. + _L_, _Cursor-Right_, _F_ enter a sub menu. + _H_, _Cursor-Left_, _B_ return to the prior menu. + _Ctrl-Cursor-Up_, _Ctrl-K_ _Ctrl-P_, _Shift-Ctrl-Meta-Tab_, _Page-Up_ move up five items. + _Ctrl-Cursor-Down_, _Ctrl-J_ _Ctrl-N_, _Ctrl-Meta-Tab_ _Page-Down_ move down five items. + _Shift-P_, _Home_, _Shift-Cursor-Up_, _Ctrl-A_ move to the first item. + _Shift-N_, _End_, _Shift-Cursor-Down_, _Ctrl-E_ move to the last item. + _Meta-P_, _Meta-Cursor-Up_, _Ctrl-Cursor-Left_, _Shift-Ctrl-Tab_, move up just below the next separator. + _Meta-N_, _Meta-Cursor-Down_, _Ctrl-Cursor-Right_, _Ctrl-Tab_, move down just below the next separator. + _Insert_ opens the "More..." sub menu if any. + _Backspace_ tears off the menu. *Menu Bindings*:: The keys and mouse buttons used to navigate the menu can be configured using the *Key* and *Mouse* commands with the special context 'M', possible combined with 'T' for the menu title, 'I' for other menu items, 'S' for any border or sidepic, '[' for left border including a left sidepic, ']' for right border including a right sidepic, '-' for top border, '_' for bottom border. The menu context uses its own set of actions that can be bound to keys and mouse buttons. These are _MenuClose_, _MenuCloseAndExec_, _MenuEnterContinuation_, _MenuEnterSubmenu_, _MenuLeaveSubmenu_, _MenuMoveCursor_, _MenuCursorLeft_, _MenuCursorRight_, _MenuSelectItem_, _MenuScroll_ and _MenuTearOff_. + It is not possible to override the key Escape with no modifiers for closing the menu. Neither is it possible to undefine mouse button 1, the arrow keys or the enter key for minimal navigation. + *MenuClose* exits from the current sequence of menus or destroys a tear off menu. + *MenuCloseAndExec* exits from the current sequence of menus or destroys a tear off menu and executes the rest of the line as a command. + *MenuEnterContinuation* opens the "More..." sub menu if any. + *MenuEnterSubmenu* enters a sub menu. + *MenuLeaveSubmenu* returns to the prior menu. + *MenuMoveCursor* _n_ [_m_] moves the selection to another item. If the first argument is zero the second argument specifies an absolute item in the menu to move the pointer to. Negative items are counted from the end of the menu. If the first argument is non-zero, the second argument must be omitted, and the first argument specifies a relative change in the selected item. The positions may be suffixed with a 's' to indicate that the items should refer only to the first items after separators. + *MenuCursorLeft* enters a sub menu with the _SubmenusLeft_ menu style, and returns to the prior menu with the _SubmenusRight_ menu style. + *MenuCursorRight* enters a sub menu with the _SubmenusRight_ menu style, and returns to the prior menu with the _SubmenusLeft_ menu style. + *MenuSelectItem* triggers the action for the menu item. + **MenuScroll **__n__ performs menu scrolling according to the _MouseWheel_ menu style with _n_ items. The distance can be suffixed with an 's' to indicate the items should refer only to the first items after separators. + *MenuTearOff* turns a normal menu into a "torn off" menu. See *Tear Off Menus* for details. *Tear Off Menus*:: A tear off menu is any menu that has been "torn off" the window it was attached to and pinned to the root window. There are three ways to tear off a menu: click on the menu title with mouse button 2, press + in the menu or activate its tear off bar (a horizontal bar with a broken line). Tear off bars must be added to the menu as any other item by assigning them the command *TearMenuOff*. + The builtin tear off actions can be overridden by undefining the builtin menu actions bound to tear off. To remove the builtin mouse button 2 binding, use: + .... Mouse 2 MT A - .... + and to remove the builtin backspace binding, use: + .... Key Backspace M A - .... + See the section *Menu Bindings* for details on how to assign other bindings for tear off. + Note that prior to fvwm 2.5.20 the tear off mouse bindings were redefined in different way, which no longer work. + The window containing the menu is placed as any other window would be. If you find it confusing to have your tear off menus appear at random positions on the screen, put this line in your configuration file: + .... Style fvwm_menu UsePPosition .... + To remove borders and buttons from a tear-off menu but keep the menu title, you can use + .... Style fvwm_menu !Button 0, !Button 1 Style fvwm_menu !Button 2, !Button 3 Style fvwm_menu !Button 4, !Button 5 Style fvwm_menu !Button 6, !Button 7 Style fvwm_menu !Button 8, !Button 9 Style fvwm_menu Title, HandleWidth 0 .... + A tear off menu is a cross breeding between a window and a menu. The menu is swallowed by a window and its title is stripped off and displayed in the window title. The main advantage is that the menu becomes permanent - activating an item does not close the menu. Therefore, it can be used multiple times without reopening it. To destroy such a menu, close its window or press the Escape key. + Tear off menus behave somewhat differently than normal menus and windows. They do not take the keyboard focus, but while the pointer is over one of them, all key presses are sent to the menu. Other fvwm key bindings are disabled as long as the pointer is inside the tear off menu or one of its sub menus. When the pointer leaves this area, all sub menus are closed immediately. Note that the window containing a tear off menu is never hilighted as if it had the focus. + A tear off menu is an independent copy of the menu it originated from. As such, it is not affected by adding items to that menu or changing its menu style. + To create a tear off menu without opening the normal menu first, the option _TearOffImmediately_ can be added to the *Menu* or *Popup* command. === Building menu contents *AddToMenu* _menu-name_ [_menu-label_ _action_]:: Begins or adds to a menu definition. Typically a menu definition looks like this: + .... AddToMenu Utilities Utilities Title + Xterm Exec exec xterm -e tcsh + Rxvt Exec exec rxvt + "Remote Logins" Popup Remote-Logins + Top Exec exec rxvt -T Top -n Top -e top + Calculator Exec exec xcalc + Xman Exec exec xman + Xmag Exec exec xmag + emacs Exec exec xemacs + Mail MailFunction xmh "-font fixed" + "" Nop + Modules Popup Module-Popup + "" Nop + Exit Fvwm Popup Quit-Verify .... + The menu could be invoked via + .... Mouse 1 R A Menu Utilities Nop .... + or + .... Mouse 1 R A Popup Utilities .... + There is no end-of-menu symbol. Menus do not have to be defined in a contiguous region of the _config_ file. The quoted (or first word) portion in the above examples is the menu label, which appears in the menu when the user pops it up. The remaining portion is an fvwm command which is executed if the user selects that menu item. An empty menu-label ("") and the *Nop* function are used to insert a separator into the menu. + The keywords _DynamicPopUpAction_ and _DynamicPopDownAction_ have a special meaning when used as the name of a menu item. The action following the keyword is executed whenever the menu is popped up or down. This way you can implement dynamic menus. It is even possible to destroy itself with *DestroyMenu* and the rebuild from scratch. When the menu has been destroyed (unless you used the _recreate_ option when destroying the menu), do not forget to add the dynamic action again. + Note: Do not trigger actions that require user interaction. They may fail and may screw up your menus. See the *Silent* command. + *Warning* Do not issue *MenuStyle* commands as dynamic menu actions. Chances are good that this crashes fvwm. + The keyword _Greyed_ will still render the menu item, but will grey it out making the option unselectable. + 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 .... + 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 t the menu, all text right of the first is aligned to the left in a second column and all text thereafter is placed right aligned in the third column. All other s are replaced by spaces. Note that you can change this format with the _ItemFormat_ option of the *MenuStyle* command. + If the menu-label contains an ampersand ('&'), the next character is taken as a hot-key for the menu item. Hot-keys are underlined in the label. To get a literal '&', insert "&&". Pressing the hot-key moves through the list of menu items with this hot-key or selects an item that is the only one with this hot-key. + If the menu-label contains a sub-string which is set off by stars, then the text between the stars is expected to be the name of an image file to insert in the menu. To get a literal '*', insert "**". For example + .... + Calculator*xcalc.xpm* Exec exec xcalc .... + inserts a menu item labeled "Calculator" with a picture of a calculator above it. The following: + .... + *xcalc.xpm* Exec exec xcalc .... + Omits the "Calculator" label, but leaves the picture. + If the menu-label contains a sub-string which is set off by percent signs, then the text between the percent signs is expected to be the name of image file (a so called mini icon to insert to the left of the menu label. A second mini icon that is drawn at the right side of the menu can be given in the same way. To get a literal '%', insert "%%". For example + .... + Calculator%xcalc.xpm% Exec exec xcalc .... + inserts a menu item labeled "Calculator" with a picture of a calculator to the left. The following: + .... + %xcalc.xpm% Exec exec xcalc .... + Omits the "Calculator" label, but leaves the picture. The pictures used with this feature should be small (perhaps 16x16). + If the menu-name (not the label) contains a sub-string which is set off by at signs ('@'), then the text between them is expected to be the name of an image file to draw along the left side of the menu (a side pixmap). You may want to use the _SidePic_ option of the *MenuStyle* command instead. To get a literal '@', insert "@@". For example + .... AddToMenu StartMenu@linux-menu.xpm@ .... + creates a menu with a picture in its bottom left corner. + If the menu-name also contains a sub-string surrounded by '^'s, then the text between '^'s is expected to be the name of an X11 color and the column containing the side picture is colored with that color. You can set this color for a menu style using the _SideColor_ option of the *MenuStyle* command. To get a literal '^', insert "^^". Example: + .... AddToMenu StartMenu@linux-menu.xpm@^blue^ .... + creates a menu with a picture in its bottom left corner and colors with blue the region of the menu containing the picture. + In all the above cases, the name of the resulting menu is name specified, stripped of the substrings between the various delimiters. *DestroyMenu* [recreate] _menu_:: Deletes a menu, so that subsequent references to it are no longer valid. You can use this to change the contents of a menu during an fvwm session. The menu can be rebuilt using *AddToMenu*. The optional parameter _recreate_ tells fvwm not to throw away the menu completely but to throw away all the menu items (including the title). + .... DestroyMenu Utilities .... *Title*:: Does nothing. It is used to insert a title line in a popup or menu. === Commands that open menus *Menu* _menu-name_ [_position_] [_double-click-action_]:: Causes a previously defined menu to be popped up in a sticky manner. That is, if the user invokes the menu with a click action instead of a drag action, the menu stays up. The command _double-click-action_ is invoked if the user double-clicks a button (or hits the key rapidly twice if the menu is bound to a key) when bringing up the menu. If the double click action is not specified, double clicking on the menu does nothing. However, if the menu begins with a menu item (i.e. not with a title or a separator) and the double click action is not given, double clicking invokes the first item of the menu (but only if the pointer really was over the item). + The pointer is warped to where it was when the menu was invoked if it was both invoked and closed with a keystroke. + The _position_ arguments allow placement of the menu somewhere on the screen, for example centered on the visible screen or above a title bar. Basically it works like this: you specify a _context-rectangle_ and an offset to this rectangle by which the upper left corner of the menu is moved from the upper left corner of the rectangle. The _position_ arguments consist of several parts: + {empty}[_context-rectangle_] _x_ _y_ [_special options_] + The _context-rectangle_ can be one of: + _Root_::: the root window of the current screen. + _Monitor_::: the area of the current RandR screen. + _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_::: button 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 invalid (e.g. "item" on a window), "Mouse" is the default. Note that not all of these make sense under all circumstances (e.g. "Icon" if the pointer is on a menu). + The offset values _x_ and _y_ specify how far the menu is moved from its default position. By default, the numeric value given is interpreted as a percentage of the context rectangle's width (height), but with a trailing '_m_' the menu's width (height) is used instead. Furthermore a trailing '_p_' changes the interpretation to mean pixels. + Instead of a single value you can use a list of values. All additional numbers after the first one are separated from their predecessor by their sign. Do not use any other separators. + If _x_ or _y_ are prefixed with "'__o__" where 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 percent of the rectangle's width/height is right over the pixel at percent of the menu's width/height. So "o0" means that the top/left borders of the menu and the rectangle overlap, with "o100" it's the bottom/right borders and if you use "o50" they are centered upon each other (try it and you will see it is much simpler than this description). The default is "o0". The prefix "o" is an abbreviation for "+-m". + A prefix of '_c_' is equivalent to "o50". Examples: + .... # window list in the middle of the screen WindowList Root c c # menu to the left of a window Menu name window -100m c+0 # popup menu 8 pixels above the mouse pointer Popup name mouse c -100m-8p # somewhere on the screen Menu name rectangle 512x384+1+1 +0 +0 # centered vertically around a menu item AddToMenu foobar-menu + "first item" Nop + "special item" Popup "another menu" item +100 c + "last item" Nop # above the first menu item AddToMenu foobar-menu + "first item" Popup "another menu" item +0 -100m .... + Note that you can put a sub menu far off the current menu so you could not reach it with the mouse without leaving the menu. If the pointer leaves the current menu in the general direction of the sub menu the menu stays up. + _Special options_::: + To create a tear off menu without opening the normal menu, add the option _TearOffImmediately_. Normally the menu opens in normal state for a split second before being torn off. As tearing off places the menu like any other window, a position should be specified explicitly: + .... # Forbid fvwm to place the menu window Style UsePPosition # Menu at top left corner of screen Menu Root 0p 0p TearOffImmediately .... + The _Animated_ and _Mwm_ or _Win_ menu styles may move a menu somewhere else on the screen. If you do not want this you can add _Fixed_ as an option. This might happen for example if you want the menu always in the top right corner of the screen. + Where do you want a menu to appear when you click on its menu item? The default is to place the title under the cursor, but if you want it where the position arguments say, use the _SelectInPlace_ option. If you want the pointer on the title of the menu, use _SelectWarp_ too. Note that these options apply only if the _PopupAsRootMenu_ *MenuStyle* option is used. + The pointer is warped to the title of a sub menu whenever the pointer would be on an item when the sub menu is popped up (_fvwm_ menu style) or never warped to the title at all (_Mwm_ or _Win_ menu styles). You can force (forbid) warping whenever the sub menu is opened with the _WarpTitle_ (_NoWarp_) option. + Note that the _special-options_ do work with a normal menu that has no other position arguments. *Popup* _PopupName_ [_position_] [_default-action_]:: This command has two purposes: to bind a menu to a key or mouse button, and to bind a sub menu into a menu. The formats for the two purposes differ slightly. The _position_ arguments are the same as for *Menu*. The command _default-action_ is invoked if the user clicks a button to invoke the menu and releases it immediately again (or hits the key rapidly twice if the menu is bound to a key). If the default action is not specified, double clicking on the menu does nothing. However, if the menu begins with a menu item (i.e. not with a title or a separator) and the default action is not given, double clicking invokes the first item of the menu (but only if the pointer really was over the item). + To bind a previously defined pop-up menu to a key or mouse button: + The following example binds mouse buttons 2 and 3 to a pop-up called "Window Ops". The menu pops up if the buttons 2 or 3 are pressed in the window frame, side-bar, or title-bar, with no modifiers (none of shift, control, or meta). + .... Mouse 2 FST N Popup "Window Ops" Mouse 3 FST N Popup "Window Ops" .... + Pop-ups can be bound to keys through the use of the *Key* command. Pop-ups can be operated without using the mouse by binding to keys and operating via the up arrow, down arrow, and enter keys. + To bind a previously defined pop-up menu to another menu, for use as a sub menu: + The following example defines a sub menu "Quit-Verify" and binds it into a main menu, called "RootMenu": + .... AddToMenu Quit-Verify + "Really Quit Fvwm?" Title + "Yes, Really Quit" Quit + "Restart Fvwm" Restart + "Restart Fvwm 1.xx" Restart fvwm1 -s + "" Nop + "No, Don't Quit" Nop AddToMenu RootMenu "Root Menu" Title + "Open XTerm Window" Popup NewWindowMenu + "Login as Root" Exec exec xterm -T Root -n Root -e su - + "Login as Anyone" Popup AnyoneMenu + "Remote Hosts" Popup HostMenu + "" Nop + "X utilities" Popup Xutils + "" Nop + "Fvwm Modules" Popup Module-Popup + "Fvwm Window Ops" Popup Window-Ops + "" Nop + "Previous Focus" Prev (AcceptsFocus) Focus + "Next Focus" Next (AcceptsFocus) Focus + "" Nop + "Refresh screen" Refresh + "" Nop + "Reset X defaults" Exec xrdb -load \ $HOME/.Xdefaults + "" Nop + "" Nop + Quit Popup Quit-Verify .... + Popup differs from *Menu* in that pop-ups do not stay up if the user simply clicks. These are popup-menus, which are a little hard on the wrist. *Menu* menus stay up on a click action. See the *Menu* command for an explanation of the interactive behavior of menus. A menu can be open up to ten times at once, so a menu may even use itself or any of its predecessors as a sub menu. *TearMenuOff*:: When assigned to a menu item, it inserts a tear off bar into the menu (a horizontal broken line). Activating that item tears off the menu. If the menu item has a label, it is shown instead of the broken line. If used outside menus, this command does nothing. Examples: + .... AddToMenu WindowMenu + I "" TearMenuOff AddToMenu RootMenu + I "click here to tear me off" TearMenuOff .... === Menu style commands Menu styles describe the looks and behaviour like normal styles do for windows. Menu styles are assigned to individual or all menus, and changing the menu style immediately affects all menus that use it. (If a menu style is used from within a menu, the changes are applied the next time an affected menu is opened.) *ChangeMenuStyle* _menustyle_ _menu_ ...:: Changes the menu style of _menu_ to _menustyle_. You may specify more than one menu in each call of *ChangeMenuStyle*. *CopyMenuStyle* _orig-menustyle_ _dest-menustyle_:: Copy _orig-menustyle_ to _dest-menustyle_, where _orig-menustyle_ is an existing menu style. If the menu style _dest_menustyle_ does not exist, then it is created. *DestroyMenuStyle* _menustyle_:: Deletes the menu style named _menustyle_ and changes all menus using this style to the default style, you cannot destroy the default menu style. + .... DestroyMenuStyle pixmap1 .... *MenuStyle* _stylename_ [_options_]:: Sets a new menu style or changes a previously defined style. The _stylename_ is the style name; if it contains spaces or tabs it has to be quoted. The name "*" is reserved for the default menu style. The default menu style is used for every menu-like object (e.g. the window created by the *WindowList* command) that had not be assigned a style using the *ChangeMenuStyle*. See also *DestroyMenuStyle*. When using monochrome color options are ignored. + _options_ is a comma separated list containing some of the keywords Fvwm / Mwm / Win, BorderWidth, HilightBack / !HilightBack, HilightTitleBack, ActiveFore / !ActiveFore, MenuColorset, ActiveColorset, GreyedColorset, TitleColorset, Hilight3DThick / Hilight3DThin / Hilight3DOff, Hilight3DThickness, Animation / !Animation, Font, TitleFont, 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, Translucent / !Translucent. + In the above list some options are listed as option pairs or triples with a '/' in between. These options exclude each other. All paired options can be negated to have the effect of the counterpart option by prefixing ! to the option. + _Fvwm_, _Mwm_, _Win_ reset all options to the style with the same name in former versions of fvwm. The default for new menu styles is _Fvwm_ style. These options override all others except _HilightBack_, _ActiveFore_ and _PopupDelay_, so they should be used only as the first option specified for a menu style or to reset the style to defined behavior. The same effect can be created by setting all the other options one by one. + _Mwm_ and _Win_ style menus popup sub menus automatically. _Win_ menus indicate the current menu item by changing the background to dark. _Fvwm_ sub menus overlap the parent menu, _Mwm_ and _Win_ style menus never overlap the parent menu. + _Fvwm_ style is equivalent to !HilightBack, Hilight3DThin, !ActiveFore, !Animation, Font, 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, 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, PopupOffset -5 100, !TitleWarp, TitleUnderlines1, SeparatorsShort, TrianglesSolid, PopupImmediately, PopdownDelayed, PopdownDelay 150, PopupAsSubmenu, RemoveSubmenus, SubmenusRight, BorderWidth 2, UniqueHotkeyActivatesImmediate, !AutomaticHotkeys, PopupActiveArea 75. + _BorderWidth_ takes the thickness of the border around the menus in pixels. It may be zero to 50 pixels. The default is 2. Using an invalid value reverts the border width to the default. + _HilightBack_ and _!HilightBack_ switch hilighting the background of the selected menu item on and off. The _ActiveColorset_ background color is used for the hilighting. + _HilightTitleBack_ switches hilighting the background of menu titles on. The _TitleColorset_ background color is used for the hilighting. + _ActiveFore_ and _!ActiveFore_ switch hilighting the foreground of the selected menu item on and off. The _ActiveColorset_ foreground color is used for the hilighting. + _MenuColorset_ controls the colorset used to color the menu. If the colorset has a pixmap or gradient defined, this is used as the background of the menu. The shape mask from the colorset is used to shape the menu. Please refer to the *Colorsets* section for details about colorsets. + _ActiveColorset_ controls the color of the active menu item, provided the _HilightBack_ or _ActiveFore_ menu styles are used. If specified, the hilight and shadow colors from the colorset are used too. The pixmap and shape mask from the colorset are not used. Hilighting the background or foreground can be turned off individually with the _!ActiveFore_ or _!HilightBack_ menu styles. + _GreyedColorset_ works exactly like _MenuColorset_, but the foreground from the colorset replaces the color given with the _Greyed_ menu style. No other parts of the colorset are used. + _TitleColorset_ works exactly like _MenuColorset_, but is used only for menu titles. + _Translucent_ controls a pseudo transparent effect that uses a image of the desktop under the menu as its background image. This option takes one value that is a number between 0 (fully translucent) and 100 (not translucent), which is the percent of the translucency. Use _!Translucent_ (or no additional value) to turn the effect off. The translucent effect only applies to normal menus and does not apply to "torn off" menus. Note, only the menu background is translucent, the _HilightBack_ of the active item and _HilightTitleBack_ of the title are not. To have a fully translucent menu use the following. + .... MenuStyle * Translucent 60, !HilightBack, !HilightTitleBack, ActiveFore .... + _Hilight3DThick_, _Hilight3DThin_ and _Hilight3DOff_ determine if the selected menu item is hilighted with a 3D relief. Thick reliefs are two pixels wide, thin reliefs are one pixel wide. + _Hilight3DThickness_ takes one numeric argument that may be between -50 and +50 pixels. With negative values the menu item gets a pressed in look. The above three commands are equivalent to a thickness of 2, 1 and 0. + _Animation_ and _!Animation_ turn menu animation on or off. When animation is on, sub menus that do not fit on the screen cause the parent menu to be shifted to the left so the sub menu can be seen. + _Font_ and _TitleFont_ take a font name as an argument. If a font by this name exists it is used for the text of all menu items. If it does not exist or if the name is left blank the built-in default is used. If a _TitleFont_ is given, it is used for all menu titles instead of the normal font. + _PopupDelay_ requires one numeric argument. This value is the delay in milliseconds before a sub menu is popped up when the pointer moves over a menu item that has a sub menu. If the value is zero no automatic pop up is done. If the argument is omitted the built-in default is used. Note that the popup delay has no effect if the _PopupImmediately_ option is used since sub menus pop up immediately then. + _PopupImmediately_ makes menu items with sub menus pop up it up as soon as the pointer enters the item. The _PopupDelay option_ is ignored then. If _PopupDelayed_ is used fvwm looks at the _PopupDelay_ option if or when this automatic popup happens. + _PopdownDelay_ works exactly like _PopupDelay_ but determines the timeout of the _PopupDelayed_ style. + _PopdownImmediately_ makes sub menus vanish as soon as the pointer leaves the sub menu and the correspondent item in the parent menu. With the opposite option _PopdownDelayed_ the sub menu only pops down after the time specified with the _PopdownDelay_ option. This comes handy when the pointer often strays off the menu item when trying to move into the sub menu. Whenever there is a conflict between the _PopupImmediately_, _PopupDelayed_, _PopupDelay_ styles and the _PopdownImmediately_, _PopdownDelayed_, _PopdownDelay_ styles, the _Popup..._ styles win when using mouse navigation and the _Popdown..._ styles win when navigating with the keyboard. + _PopupOffset_ requires two integer arguments. Both values affect where sub menus are placed relative to the parent menu. If both values are zero, the left edge of the sub menu overlaps the left edge of the parent menu. If the first value is non-zero the sub menu is shifted that many pixels to the right (or left if negative). If the second value is non-zero the menu is moved by that many percent of the parent menu's width to the right or left. + _PopupActiveArea_ requires an integer value between 51 and 100. Normally, when the pointer is over a menu item with a sub menu and the pointer enters the area that starts at 75% of the menu width, the sub menu is shown immediately. This percentage can be changed with _PopupActiveArea_. Setting this value to 100 disables this kind of automatic popups altogether. The default value is restored if no or an invalid value is given. + _TitleWarp_ and _!TitleWarp_ affect if the pointer warps to the menu title when a sub menu is opened or not. Note that regardless of this setting the pointer is not warped if the menu does not pop up under the pointer. + _TitleUnderlines0_, _TitleUnderlines1_ and _TitleUnderlines2_ specify how many lines are drawn below a menu title. + _SeparatorsLong_ and _SeparatorsShort_ set the length of menu separators. Long separators run from the left edge all the way to the right edge. Short separators leave a few pixels to the edges of the menu. + _TrianglesSolid_ and _TrianglesRelief_ affect how the small triangles for sub menus is drawn. Solid triangles are filled with a color while relief triangles are hollow. + _DoubleClickTime_ requires one numeric argument. This value is the time in milliseconds between two mouse clicks in a menu to be considered as a double click. The default is 450 milliseconds. If the argument is omitted the double click time is reset to this default. + _SidePic_ takes the name of an image file as an argument. The picture is drawn along the left side of the menu. The _SidePic_ option can be overridden by a menu specific side pixmap (see *AddToMenu*). If the file name is omitted an existing side pixmap is removed from the menu style. + _SideColor_ takes the name of an X11 color as an argument. This color is used to color the column containing the side picture (see above). The SideColor option can be overridden by a menu specific side color (see *AddToMenu*). If the color name is omitted the side color option is switched off. + _PopupAsRootMenu_, _PopupAsSubmenu_, _PopupIgnore_ and _PopupClose_ change the behavior when you click on a menu item that opens a sub menu. With _PopupAsRootMenu_ the original menu is closed before the sub menu appears, with _PopupAsSubmenu_ it is not, so you can navigate back into the parent menu. Furthermore, with _PopupAsSubmenu_ the sub menu is held open (posted) regardless of where you move the mouse. Depending on your menu style this may simplify navigating through the menu. *Any* keystroke while a menu is posted reverts the menu back to the normal behavior. With _PopupClose_ the menu is closed when a sub menu item is activated, and the menu stays open if _PopupIgnore_ is used (even if the menu was invoked with the *Popup* command). _PopupAsSubmenu_ is the default. + _RemoveSubmenus_ instructs fvwm to remove sub menu when you move back into the parent menu. With _HoldSubmenus_ the sub menu remains visible. You probably want to use _HoldSubmenus_ if you are using the _PopupDelayed_ style. _RemoveSubmenus_ affects menu navigation with the keyboard. + _SelectOnRelease_ takes an optional key name as an argument. If the given key is released in a menu using this style, the current menu item is selected. This is intended for *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, + characters and formatting directives beginning with '%'. Any invalid characters and formatting directives are silently ignored: + -- *%l*, *%c* and *%r*::: Insert the next item label. Up to three labels can be used. The item column is left-aligned (*%l*), centered (*%c*) or right-aligned (*%r*). *%i*::: Inserts the mini icon. *%>* and *%<*::: Insert the sub menu triangle pointing either to the right (*%>*) or to the left (*%<*). *%|*::: The first *%|* denotes the beginning of the area that is highlighted either with a background color or a relief (or both). The second *%|* marks the end of this area. *%|* can be used up to twice in the string. If you do not add one or both of them, fvwm sets the margins to the margins of the whole item (not counting the side picture). *%s*::: Places the side picture either at the beginning or the end of the menu. This directive may be used only once and only as the first or last in the format string. If the *%s* is not at the beginning of the string, menus are not drawn properly. *Space*, *Tab*, *%Space* and *%Tab*::: Add gap of one space, or a tab, using the width of the menu font. When using a tab, the size of the gap can be one to 8 spaces since the tab position is a multiple of 8 from the edge of the menu. The whole string must be quoted if spaces or tabs are used. *%p*::: Like Space and Tab *%p* inserts an empty area into the item, but with better control of its size (see below). -- + You can define an additional space before and after each of the objects like this + .... %left.rightp .... + This means: if the object is defined in the menu (e.g. if it is *%s* and you use a side picture, or it is *%l* for the third column and there are items defined that actually have a third column), then add _left_ pixels before the object and _right_ pixels after it. You may leave out the _left_ or the _.right_ parts if you do not need them. All values up to the screen width are allowed. Even negative values can be used with care. The *p* may be replaced with any other formatting directives described above. + Note: Only items defined in the format string are visible in the menus. So if you do not put a *%s* in there you do not see a side picture, even if one is specified. + Note: The _SubmenusLeft_ style changes the default _ItemFormat_ string, but if it was set manually it is not modified. + Note: If any unformatted title of the menu is wider than the widest menu item, the spaces between the different parts of the menu items are enlarged to match the width of the title. Leading left aligned objects in the format string (*%l*, *%i*, *%<*, first *%|*) stick to the left edge of the menu and trailing right aligned objects (*%r*, *%i*, *%>*, second *%|*) stick to the right edge. The gaps between the remaining items are enlarged equally. + Examples: + .... MenuStyle * ItemFormat "%.4s%.1|%.5i%.5l%.5l%.5r%.5i%2.3>%1|" .... + Is the default string used by fvwm: (side picture + 4 pixels gap) (beginning of the hilighted area + 1 pixel gap) (mini icon + 5p) (first column left aligned + 5p) (second column left aligned + 5p) (third column right aligned + 5p) (second mini icon + 5p) (2p + sub menu triangle + 3p) (1p + end of hilighted area). + .... MenuStyle * ItemFormat "%.1|%3.2<%5i%5l%5l%5r%5i%1|%4s" .... + Is used by fvwm with the _SubmenusLeft_ option below. + _VerticalItemSpacing_ and _VerticalTitleSpacing_ control the vertical spacing of menu items and titles like _ItemFormat_ controls the horizontal spacing. Both take two numeric arguments that may range from -100 to +100. The first is the gap in pixels above a normal menu item (or a menu title), the second is the gap in pixels below it. Negative numbers do not make much sense and may screw up the menu completely. If no arguments are given or the given arguments are invalid, the built-in defaults are used: one pixel above the item or title and two below. + _VerticalMargins_ can be used to add some padding at the top and bottom of menus. It takes two numeric arguments that must be positive integers (or zero). If the number of arguments or its values are incorrect, fvwm defaults both to 0, which means no padding at all. If the values are correct, the first one is used for the top margin, and the second one is used for the bottom margin. + _SubmenusLeft_ mirrors the menu layout and behavior. Sub menus pop up to the left, the sub menu triangle is drawn left and the mini icon and side picture are drawn at the right side of the menu. The default is _SubmenusRight_. The position hints of a menu are also affected by this setting, i.e. position hints using _item_ or _menu_ as context rectangle and position hints using _m_ offsets. + _AutomaticHotkeys_ and _!AutomaticHotkeys_ control the menu's ability to automatically provide hot-keys on the first character of each menu item's label. This behavior is always overridden if an explicit hot-key is assigned in the *AddToMenu* command. + _UniqueHotkeyActivatesImmediate_ and _!UniqueHotkeyActivatesImmediate_ controls how menu items are invoked when used with hotkeys. By default, if a given menu entry only has one completeable match for a given hotkey, the action for that menu entry is invoked and the menu is closed. This is due to the _UniqueHotkeyActivatesImmediate_ option. However, the menu can be told to remain open, waiting for the user to invoke the selected item instead when there is only one matched item for a given hotkey, by using the _!UniqueHotkeyActivatesImmediate_ option. + _MouseWheel_ controls the ability to scroll the menu using a mouse wheel. It takes one argument, that can be one of ScrollsPointer, ScrollsMenu, ScrollsMenuBackwards or ActivatesItem. ScrollsPointer makes the mouse wheel scroll the pointer over a menu. This is the default. ScrollsMenu and ScrollsMenuBackwards scroll the menu beneath the pointer. ActivatesItem disables scrolling by mouse wheel and makes the use of a mouse wheel act as if the menu was clicked. If no argument is supplied the default setting is restored. + _ScrollOffPage_ allows a menu to be scrolled out of the visible area if _MouseWheel_ is set to ScrollsMenu or ScrollsMenuBackwards. This is the default. The opposite, _!ScrollOffPage_ disables this behaviour. + _TrianglesUseFore_ draws sub menu triangles with the foreground color of the menu colorset (normally drawn with the hilight color). _!TrianglesUseFore_ disables this behaviour. // END 'menus' endif::[] ifdef::fvwm3[] == LIST OF FVWM COMMANDS Please refer to the fvwm3commands and fvwm3styles man pages. endif::[] ifdef::fvwm3all[] // BEGIN 'commands' == 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 and key 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* === Miscellaneous Commands *BugOpts* [_option_ [_bool_]], ...:: This command controls several workarounds for bugs in third party programs. The individual options are separated by commas. The optional argument _bool_ is a boolean argument and controls if the bug workaround is enabled or not. It can either be "True" or "False" to turn the option on or off, or "toggle" to switch is back and forth. If _bool_ is omitted, the default setting is restored. + _DebugRandR_ activates monitor layout debug messages. + _FlickeringMoveWorkaround_ disables ConfigureNotify events that are usually sent to an application while it is moved. If some windows flicker annoyingly while being moved, this option may help you. Note that if this problem occurs it is not an fvwm bug, it is a problem of the application. + _MixedVisualWorkaround_ makes fvwm install the root colormap before it does some operations using the root window visuals. This is only useful when the *-visual* option is used to start fvwm and then only with some configurations of some servers (e.g. Exceed 6.0 with an 8 bit PseudoColor root and fvwm using a 24 bit TrueColor visual). + The _ModalityIsEvil_ option controls whether Motif applications have the ability to have modal dialogs (dialogs that force you to close them first before you can do anything else). The default is to not allow applications to have modal dialogs. Use this option with care. Once this option is turned on, you have to restart fvwm to turn it off. + _RaiseOverNativeWindows_ makes fvwm try to raise the windows it manages over native windows of the X server's host system. This is needed for some X servers running under Windows, Windows NT or Mac OS X. Fvwm tries to detect if it is running under such an X server and initializes the flag accordingly. + _RaiseOverUnmanaged_ makes fvwm try to raise the windows it manages over override_redirect windows. This is used to cope with ill-mannered applications that use long-lived windows of this sort, contrary to ICCCM conventions. It is useful with the _Unmanaged_ style option too. + _FlickeringQtDialogsWorkaround_ suppresses flickering of the focused window in some modules when using KDE or QT applications with application modal dialog windows. By default this option is turned on. This option may be visually disturbing for other applications using windows not managed by fvwm. Since these applications are rare it is most likely safe to leave this option at its default. + _QtDragnDropWorkaround_ suppresses the forwarding of unknown ClientEvent messages to windows -- usually this is harmless, but Qt has problems handling unrecognised ClientEvent messages. Enabling this option might therefore help for Qt applications using DragnDrop. This option is off by default. + _EWMHIconicStateWorkaround_ is needed by EWMH compliant pagers or taskbars which represent windows which are on a different desktops as iconified. These pagers and taskbars use a version of the EWMH specification before version 1.2 (the current KDE 2 & 3 versions). These pagers and taskbars use the IconicState WM_STATE state to determine if an application is iconified. This state, according to the ICCCM, does not imply that a window is iconified (in the usual sense). Turning on this option forces fvwm to establish an equivalence between the IconicState WM_STATE state and the iconified window. This violates ICCCM compliance but should not cause big problems. By default this option is off. + With the _DisplayNewWindowNames_ enabled, fvwm prints the name, icon name (if available), resource and class of new windows to the console. This can help in finding the correct strings to use in the *Style* command. + When the _ExplainWindowPlacement_ option is enabled, fvwm prints a message to the console whenever a new window is placed or *PlaceAgain*, is used. The message explains on which desk, page, screen and position it was placed and why. This option can be used to figure out why a specific window does not appear where you think it should. + The _DebugCRMotionMethod_ option enables some debugging code in the ConfigureRequest handling routines of fvwm. It is not helpful for the user, but if you report a bug to the fvwm team we may ask you to enable this option. + The _TransliterateUtf8_ option enables transliteration during conversions from utf-8 strings. By default fvwm will not transliterate during conversion, but will fall back to alternate strings provided by the clients if conversion from utf-8 fails due to characters which have no direct correspondence in the target charecter set. Some clients however neglect to set non utf-8 properties correctly in which case this option may help. *BusyCursor* [_Option_ _bool_], ...:: This command controls the cursor during the execution of certain commands. _Option_ can be _DynamicMenu_, _ModuleSynchronous_, _Read_, _Wait_ or _*_. An option must be followed by a boolean argument _bool_. You can use commas to separate individual options. If you set an option to "True", then when the corresponding command is run, fvwm displays the cursor of the _WAIT_ context of the *CursorStyle* command. "False" forces to not display the cursor. The default is: + .... BusyCursor DynamicMenu False, ModuleSynchronous False, \ Read False, Wait False .... + The _*_ option refers to all available options. + The _Read_ option controls the *PipeRead* command. + The _DynamicMenu_ option affects the _DynamicPopupAction_ and _MissingSubmenuFunction_ options of the *AddToMenu* command. If this option is set to "False", then the busy cursor is not displayed during a dynamic menu command even if this command is a *Read* or *PipeRead* command and the _Read_ option is set to "True". + The _ModuleSynchronous_ option affects the *ModuleSynchronous* command. If this option is set to "False", then the busy cursor is not displayed while fvwm waits for a module started by *ModuleSynchronous* to complete its startup. + The _Wait_ option affects only the root cursor. During a wait pause the root cursor is replaced by the busy cursor and fvwm is still fully functional (you can escape from the pause, see the *EscapeFunc* command). If you want to use this option and if you do not use the default root cursor, you must set your root cursor with the *CursorStyle* command. *ClickTime* [_delay_]:: Specifies the maximum delay in milliseconds between a button press and a button release for the *Function* command to consider the action a mouse click. The default delay is 150 milliseconds. Omitting the delay value resets the *ClickTime* to the default. + ClickTime also specifies the delay between two clicks to be interpreted as a double-click. *ColorLimit* _limit_:: This command is obsolete. See the *--color-limit* option to fvwm. *ColormapFocus* FollowsMouse | FollowsFocus:: By default, fvwm installs the colormap of the window that the cursor is in. If you use + .... ColormapFocus FollowsFocus .... + then the installed colormap is the one for the window that currently has the keyboard focus. *CursorStyle* _context_ [_num_ | _name_ | None | Tiny | _file_ [_x_ _y_] [_fg_ _bg_]]:: Defines a new cursor for the specified context. Note that this command can not control the shapes an applications uses, for example, to indicate that it is busy. The various contexts are: + _POSITION_ (top_left_corner)::: used when initially placing windows + _TITLE_ (top_left_arrow)::: used in a window title-bar + _DEFAULT_ (top_left_arrow)::: used in windows that do not set their cursor + _SYS_ (hand2)::: used in one of the title-bar buttons + _MOVE_ (fleur)::: used when moving or resizing windows + _RESIZE_ (sizing)::: used when moving or resizing windows + _WAIT_ (watch)::: used during certain fvwm commands (see *BusyCursor* for details) + _MENU_ (top_left_arrow)::: used in menus + _SELECT_ (crosshair)::: used when the user is required to select a window + _DESTROY_ (pirate)::: used for *Destroy*, *Close*, and *Delete* commands + _TOP_ (top_side)::: used in the top side-bar of a window + _RIGHT_ (right_side)::: used in the right side-bar of a window + _BOTTOM_ (bottom_side)::: used in the bottom side-bar of a window + _LEFT_ (left_side)::: used in the left side-bar of a window + _TOP_LEFT_ (top_left_corner)::: used in the top left corner of a window + _TOP_RIGHT_ (top_right_corner)::: used in the top right corner of a window + _BOTTOM_LEFT_ (bottom_left_corner)::: used in the bottom left corner of a window + _BOTTOM_RIGHT_ (bottom_right_corner)::: used in the bottom right corner of a window + _TOP_EDGE_ (top_side)::: used at the top edge of the screen + _RIGHT_EDGE_ (right_side)::: used at the right edge of the screen + _BOTTOM_EDGE_ (bottom_side)::: used at the bottom edge of the screen + _LEFT_EDGE_ (left_side)::: used at the left edge of the screen + _ROOT_ (left_ptr)::: used as the root cursor 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 .... *DefaultFont* [_fontname_]:: *DefaultFont* sets the default font to font _fontname_. The default font is used by fvwm whenever no other font has been specified. To reset the default font to the built-in default, omit the argument. The default font is used for menus, window titles, icon titles as well as the geometry feedback windows during a move or resize operation. To override the default font in a specific context, use the *Style* * _Font_, *Style* * _IconFont_, or *MenuStyle* commands. *DefaultIcon* _filename_:: Sets the default icon which is used if a window has neither an client-supplied icon nor an icon supplied via the _Icon_ option of the *Style* command. *DefaultLayers* _bottom_ _put_ _top_:: Changes the layers that are used for the _StaysOnBottom_, _StaysPut_, _StaysOnTop_ *Style* options. Initially, the layers 2, 4 and 6 are used. *Deschedule* [_command_id_]:: Removes all commands that were scheduled with the id _command_id_ with the *Schedule* command from the list of commands to be executed unless they were already executed. If the _command_id_ is omitted, the value of the variable $[schedule.last] is used as the id. *Emulate* Fvwm | Mwm | Win:: This command is a catch all for how miscellaneous things are done by fvwm. Right now this command affects where the move/resize feedback window appears and how window placement is aborted. To have more Mwm- or Win-like behavior you can call *Emulate* with _Mwm_ or _Win_ as its argument. With Mwm resize and move feedback windows are in the center of the screen, instead of the upper left corner. This also affects how manual placement is aborted. See the _ManualPlacement_ description. *EscapeFunc*:: By default the key sequence Ctrl-Alt-Escape allows for escaping from a *Wait* pause and from a locked *ModuleSynchronous* command. The *EscapeFunc* command used with the *Key* command allows for configuring this key sequence. An example: + .... Key Escape A MC - Key Escape A S EscapeFunc .... + replaces the Ctrl-Alt-Escape key sequence with Shift-Escape for aborting a *Wait* pause and *ModuleSynchronous* command. *EscapeFunc* used outside the *Key* command does nothing. *FakeClick* [_command_ _value_] ...:: This command is mainly intended for debugging fvwm and no guarantees are made that it works for you. _FakeClick_ can simulate mouse button press and release events and pass them to fvwm or the applications. The parameters are a list of commands which consist of pairs of _command_ tokens and integer _values_, The _press_ and _release_ commands are followed by the appropriate mouse button number and generate a button press or release event on the window below the pointer. The _wait_ commands pauses fvwm for the given number of milliseconds. The _modifiers_ command simulates pressing or releasing modifier keys. The values 1 to 5 are mapped to Mod1 to Mod5 while 6, 7 and 8 are mapped to Shift, Lock and Control. The modifier is set for any further button events. To release a modifier key, use the corresponding negative number. The _depth_ command determines to which window the button events are sent. With a depth of 1, all events go to the root window, regardless of the pointer's position. With 2, the event is passed to the top level window under the pointer which is usually the frame window. With 3, events go to the client window. Higher numbers go to successive sub windows. Zero (0) goes to the smallest window that contains the pointer. Note that events propagate upward. + .... FakeClick depth 2 press 1 wait 250 release 1 .... + This simulates a click with button 1 in the parent window (depth 2) with a delay of 250 milliseconds between the press and the release. Note: all command names can be abbreviated with their first letter. *FakeKeypress* [_command_ _value_] ...:: This command is mainly intended for debugging fvwm and no guarantees are made that it works for you. *FakeKeypress* can simulate key press and release events and pass them to fvwm or applications. The parameters are a list of commands which consist of pairs of command tokens and values. The _press_ and _release_ commands are followed by a key name. The key name is a standard X11 key name as defined in _/usr/include/X11/keysymdef.h_, (without the _XK__ prefix), or the keysym database _/usr/X11R6/lib/X11/XKeysymDB_. The _wait_, _modifiers_ and _depth_ commands are the same as those used by *FakeClick*. + Save all GVim sessions with: "Esc:w\n" + .... All (gvim) FakeKeypress press Escape \ press colon \ press w \ press Return .... + Save & exit all GVim sessions with: "Esc:wq\n" + .... All (gvim) FakeKeypress press Escape \ press colon \ press w \ press q \ press Return .... + Send A to a specific window: + .... WindowId 0x3800002 FakeKeypress press A .... + Note: all command names can be abbreviated with their first letter. *HilightColor* _textcolor_ _backgroundcolor_:: This command is obsoleted by the *Style* options _HilightFore_ and _HilightBack_. Please use + .... Style * HilightFore textcolor, HilightBack backgroundcolor .... + instead. *HilightColorset* [_num_]:: This command is obsoleted by the *Style* option _HilightColorset_. Please use + .... Style * HilightColorset num .... + instead. *IconFont* [_fontname_]:: This command is obsoleted by the *Style* option _IconFont_. Please use + .... Style * IconFont fontname .... + instead. *IconPath* _path_:: This command is obsolete. Please use *ImagePath* instead. *ImagePath* _path_:: Specifies a colon separated list of directories in which to search for images (both monochrome and pixmap). To find an image given by a relative pathname, fvwm looks into each directory listed in turn, and uses the first file found. + If a directory is given in the form "/some/dir;.ext", this means all images in this directory have the extension ".ext" that should be forced. The original image name (that may contain another extension or no extension at all) is not probed, instead ".ext" is added or replaces the original extension. This is useful, for example, if a user has some image directories with ".xpm" images and other image directories with the same names, but ".png" images. + The _path_ may contain environment variables such as _$HOME_ (or _$\{HOME}_). Further, a '+' in the _path_ is expanded to the previous value of the path, allowing appending or prepending to the path easily. + For example: + .... ImagePath $HOME/icons:+:/usr/include/X11/bitmaps .... + Note: if the *FvwmM4* module is used to parse your _config_ files, then m4 may want to mangle the word "include" which frequently shows up in the *ImagePath* command. To fix this one may add + .... undefine(`include') .... + prior to the *ImagePath* command, or better: use the *-m4-prefix* option to force all *m4* directives to have a prefix of "m4_" (see the *FvwmM4* man page). *LocalePath* _path_:: Specifies a colon separated list of "locale path" in which to search for string translations. A locale path is constituted by a directory path and a text domain separated by a semicolon (';'). As an example the default locale path is: + .... /install_prefix/share/locale;fvwm .... + where install_prefix is the fvwm installation directory. With such a locale path translations are searched for in + .... /install_prefix/share/locale/lang/LC_MESSAGES/fvwm.mo .... + where _lang_ depends on the locale. If no directory is given the default directory path is assumed. If no text domain is given, *fvwm* is assumed. Without argument the default locale path is restored. + As for the *ImagePath* command, _path_ may contain environment variables and a '+' to append or prepend the locale path easily. + For example, the fvwm-themes package uses + .... LocalePath ";fvwm-themes:+" .... + to add locale catalogs. + The default fvwm catalog contains a few strings used by the fvwm executable itself (Desk and Geometry) and strings used in some default configuration files and *FvwmForm* configuration. You can take a look at the po/ subdirectory of the fvwm source to get the list of the strings with a possible translation in various languages. At present, very few languages are supported. + The main use of locale catalogs is via the "$[gt.string]" parameter: + .... DestroyMenu MenuFvwmWindowOps AddToMenu MenuFvwmWindowOps "$[gt.Window Ops]" Title + "$[gt.&Move]" Move + "$[gt.&Resize]" Resize + "$[gt.R&aise]" Raise + "$[gt.&Lower]" Lower + "$[gt.(De)&Iconify]" Iconify + "$[gt.(Un)&Stick]" Stick + "$[gt.(Un)Ma&ximize]" Maximize + "" Nop + "$[gt.&Close]" Close + "$[gt.&Destroy]" Destroy .... + gives a menu in the locale languages if translations are available. + Note that the *FvwmScript* module has a set of special instructions for string translation. It is out of the scope of this discussion to explain how to build locale catalogs. Please refer to the GNU gettext documentation. *PixmapPath* _path_:: This command is obsolete. Please use *ImagePath* instead. *PrintInfo* _subject_ [_verbose_]:: Print information on _subject_ to debug log file, which defaults to _$HOME/.fvwm/fvwm3-output.log_ . Environment variables _$FVWM_USERDIR_ and _$FVWM3_LOGFILE_ can alter this default. For this logfile to be written, either fvwm3 has to be started with *-v* option or *SIGUSR2* signal can be used to toggle opening/closing debug log file. + An optional integer argument to debug log file, which defaults to _$HOME/.fvwm/fvwm3-output.log_ . Environment variables _$FVWM_USERDIR_ and _$FVWM3_LOGFILE_ can alter this default. For this logfile to be written, either fvwm3 has to be started with *-v* option or *SIGUSR2* signal can be used to toggle opening/closing debug log file. + An optional integer argument _verbose_ defines the level of information which is given. The current valid subjects are: + _Colors_ which prints information about the colors used by fvwm. This useful on screens which can only display 256 (or less) colors at once. If _verbose_ is one or greater the palette used by fvwm is printed. If you have a limited color palette, and you run out of colors, this command might be helpful. + _ImageCache_ which prints information about the images loaded by fvwm. If _verbose_ is one or greater all images in the cache will be listed together with their respective reuse. + _Locale_ which prints information on your locale and the fonts that fvwm used. _verbose_ can be 1 or 2. + _nls_ which prints information on the locale catalogs that fvwm used + _style_ which prints information on fvwm styles. _verbose_ can be 1. + _bindings_ which prints information on all the bindings fvwm has: key and mouse bindings. _verbose_ has no effect with this option. + _infostore_ which prints information on all entries in the infostore, listing the key and its value. _verbose_ has no effect with this option. *Schedule* [Periodic] _delay_ms_ [_command_id_] _command_:: The _command_ is executed after about _delay_ms_ milliseconds. This may be useful in some tricky setups. The _command_ is executed in the same context window as the *Schedule* command. An optional integer argument _command_id_ may be given in decimal, hexadecimal or octal format. This id can be used with the *Deschedule* command to remove the scheduled command before it is executed. If no id is given, fvwm uses negative id numbers, starting with -1 and decreasing by one with each use of the *Schedule* command. Note that the *Schedule* command and its arguments undergo the usual command line expansion, and, when _command_ is finally executed, it is expanded again. It may therefore be necessary to quote the parts of the command that must not be expanded twice. + Note: A window's id as it is returned with $[w.id] can be used as the _command_id_. Example: + .... Current Schedule 1000 $[w.id] WindowShade .... + The *Schedule* command also supports the optional keyword _Periodic_ which indicates that the _command_ should be executed every _delay_ms_. Example: + .... Schedule Periodic 10000 PipeRead '[ -N "$MAIL" ] && echo \ Echo You have mail' .... + Use the *Deschedule* command to stop periodic commands. *State* _state_ [_bool_]:: Sets, clears or toggles one of the 32 user defined states which are associated with each window. The _state_ is a number ranging from 0 to 31. The states have no meaning in fvwm, but they can be checked in conditional commands like *Next* with the _State_ condition. The optional argument _bool_ is a boolean argument. "True" sets the given state, while "False" clears it. Using "toggle" switches to the opposite state. If the _bool_ argument is not given, the state is toggled. *WindowFont* [_fontname_]:: This command is obsoleted by the *Style* option _Font_. Please use + .... Style * Font fontname .... + instead. *WindowList* [(_conditions_)] [_position_] [_options_] [_double-click-action_]:: Generates a pop-up menu (and pops it up) in which the title and geometry of each of the windows currently on the desktop are shown. + The format of the geometry part is: _desk_(_layer_): _x-geometry_ _sticky_, where _desk_ and _layer_ are the corresponding numbers and _sticky_ is empty or a capital S. The geometry of iconified windows is shown in parentheses. Selecting an item from the window list pop-up menu causes the interpreted function "WindowListFunc" to be run with the window id of that window passed in as $0. The default "WindowListFunc" looks like this: + .... AddToFunc WindowListFunc + I Iconify off + I FlipFocus + I Raise + I WarpToWindow 5p 5p .... + You can destroy the built-in "WindowListFunc" and create your own if these defaults do not suit you. + The window list menu uses the "WindowList" menu style if it is defined (see *MenuStyle* command). Otherwise the default menu style is used. To switch back to the default menu style, issue the command + .... DestroyMenuStyle WindowList .... + Example: + .... MenuStyle WindowList SelectOnRelease Meta_L .... + The _conditions_ can be used to exclude certain windows from the window list. Please refer to the *Current* command for details. Only windows that match the given conditions are displayed in the window list. The _options_ below work vice versa: windows that would otherwise not be included in the window list can be selected with them. The _conditions_ always override the _options_. + The _position_ arguments are the same as for *Menu*. The command _double-click-action_ is invoked if the user double-clicks (or hits the key rapidly twice if the menu is bound to a key) when bringing the window list. The _double-click-action_ must be quoted if it consists of more than one word. + The _double-click-action_ is useful to define a default window if you have bound the window list to a key (or button) like this: + .... # Here we call an existing function, but # it may be different. See the default # WindowListFunc definition earlier in this # man page. AddToFunc SwitchToWindow + I WindowListFunc Key Tab A M WindowList "Prev SwitchToWindow" .... + Hitting Alt-Tab once it brings up the window list, if you hit it twice the focus is flipped between the current and the last focused window. With the proper _SelectOnRelease_ menu style (see example above) a window is selected as soon as you release the Alt key. + The _options_ passed to WindowList are separated by commas and can be _Geometry_ / _NoGeometry_ / _NoGeometryWithInfo_, _NoDeskNum,_ _NoLayer,_ _NoNumInDeskTitle_, _NoCurrentDeskTitle_, _MaxLabelWidth width_, _TitleForAllDesks_, _Function funcname_, _Desk desknum_, _CurrentDesk_, _NoIcons_ / _Icons_ / _OnlyIcons_, _NoNormal_ / _Normal_ / _OnlyNormal_, _NoSticky_ / _Sticky_ / _OnlySticky_, _NoStickyAcrossPages_ / _StickyAcrossPages_ / _OnlyStickyAcrossPages_, _NoStickyAcrossDesks_ / _StickyAcrossDesks_ / _OnlyStickyAcrossDesks_, _NoOnTop_ / _OnTop_ / _OnlyOnTop_, _NoOnBottom_ / _OnBottom_ / _OnlyOnBottom_, _Layer m [n]_, _UseSkipList_ / _OnlySkipList_, _NoDeskSort_, _ReverseOrder_, _CurrentAtEnd_, _IconifiedAtEnd_, _UseIconName_, _Alphabetic_ / _NotAlphabetic_, _SortByResource_, _SortByClass_, _NoHotkeys_, _SelectOnRelease_. + (Note - normal means not iconic, sticky, or on top) + With the _SortByResource_ option windows are alphabetically sorted first by resource class, then by resource name and then by window name (or icon name if _UseIconName_ is specified). _ReverseOrder_ also works in the expected manner. + With the _SortByClass_ option windows are sorted just like with _SortByResource_, but the resource name is not taken into account, only the resource class. + The _SelectOnRelease_ option works exactly like the *MenuStyle* option with the same name, but overrides the option given in a menu style. By default, this option is set to the left + key. To switch it off, use _SelectOnRelease_ without a key name. + If you pass in a function via *Function* funcname, it is called within a window context of the selected window: + .... AddToFunc IFunc I Iconify toggle WindowList Function IFunc, NoSticky, CurrentDesk, NoIcons .... + If you use the _Layer_ _m_ [_n_] option, only windows in layers between m and n are displayed. n defaults to m. With the _ReverseOrder_ option the order of the windows in the list is reversed. + With the _CurrentAtEnd_ option the currently focused window (if any) is shown at the bottom of the list. This is mostly intended for simulating the Alt-Tab behavior in another GUI. + _IconifiedAtEnd_ makes iconified windows be moved to the end of the list. This is also from another GUI. + The _NoGeometry_ option causes fvwm to not display the geometries as well as the separators which indicate the different desktops. _NoGeometryWithInfo_ removes the geometries, but keep the desktop information and indicates iconic windows. _NoDeskNum_ causes fvwm to not display the desktop number in the geometry or before the window title with the _NoGeometryWithInfo_ option. _NoNumInDeskTitle_ is only useful if a desktop name is defined with the *DesktopName* command. It causes fvwm to not display the desktop number before the desktop name. By default, the WindowList menu have a title which indicates the current desk or the selected desktop if the _Desk_ condition is used. The _NoCurrentDeskTitle_ option removes this title. _TitleForAllDesks_ causes fvwm to add a menu title with the desk name and/or number before each group of windows on the same desk. With _NoLayer_, the layer of the window is not displayed. The options _ShowPage_, _ShowPageX_ and _ShowPageY_ enable displaying the page of the window rounded multiples of the display size. With _ShowScreen_, the window's screen name is displayed. + The _MaxLabelWidth_ option takes the number of characters to print as its argument. No more than that many characters of the window name are visible. + If you wanted to use the *WindowList* as an icon manager, you could invoke the following: + .... WindowList OnlyIcons, Sticky, OnTop, Geometry .... + (Note - the _Only_ options essentially wipe out all other ones... but the _OnlyListSkip_ option which just causes *WindowList* to only consider the windows with _WindowListSkip_ style.) *XSync*:: When *XSync* is called, the X function with the same name is used to send all pending X requests to the server. This command is intended for debugging only. *XSynchronize* [bool]:: The *XSynchronize* command controls whether X requests are sent to the X server immediately or not. Normally, requests are sent in larger batches to save unnecessary communication. To send requests immediately, use "True" as the argument, to disable this use "False" or to toggle between both methods use "Toggle" or omit the *bool* argument. Fvwm defaults to synchronized requests when started with the *--debug* option. This command is intended for debugging only. *+*:: Used to continue adding to the last specified decor, function or menu. See the discussion for *AddToDecor*, *AddToFunc*, and *AddToMenu*. === Window Movement and Placement *AnimatedMove* _x_ _y_ [Warp]:: Move a window in an animated fashion. Similar to *Move* command. The options are the same, except they are required, since it doesn't make sense to have a user move the window interactively and animatedly. If the optional argument _Warp_ is specified the pointer is warped with the window. *GeometryWindow* Hide | Show | Colorset _n_ | Position _x_ _y_ | Screen _S_:: Configures the position or size window that is usually shown when a window is moved or resized interactively. This can be used to hide, show, change the colorset, change the location, or change the screen of the geometry window. Multiple options can be set at once separated by spaces. Details of each option are described below. + > *GeometryWindow* Hide [Never | Move | Resize] + Hides or switches off the geometry window. If the optional parameters _Move_ or _Resize_ are given, it will only hide the geometry window during the respective operation. The parameter _Never_ will switch the geometry back on again (equivalent to _Show_). + > *GeometryWindow* Show [Never | Move | Resize] + Shows or switches on the geometry window (equivalent to _Hide Never_). If the optional parameters _Move_ or _Resize_ are given, it will only show the geometry window during the respective operation. The parameter _Never_ will switch the geometry window off (equivalent to _Hide_). + > *GeometryWindow* Colorset _cset_ + Sets colorset of the gometry window to _cset_. Use the literal option _default_ for _cset_ to use the default colorset. + > *GeometryWindow* Position \[\+|-]_x_[p] \[+|-]_y_[p] + Configures the position the geometry window appears. _x_ and _y_ are the relative coordinates as a percentage of the screen size. If a leading '-' is provided the coordinates are computed from the left/bottom of the screen respectively. If the coordinates are appended with a 'p', they are interpreted as the number of pixels from the respective screen edge. If no position arguments are given, the geometry window's position will return to its default state of the upper left corner or the center if emulating MWM. + > *GeometryWindow* Screen _RANDRNAME_ + Configure which screen the geometry window is shown on. By default the geometry window is shown on the current screen. If a valid _RANDRNAME_ is provided, the geometry window will always be shown on that screen. Use _current_ as the _RANDRNAME_ to return the default. + Examples: + .... # Position the geometry window in the center of the screen GeometryWindow Position 50 50 # Position the geometry window next to the RightPanel GeometryWindow Position -120p 0 # Use colorset 2 for the geometry window GeometryWindow Colorset 2 # Only show the geometry window on the primary monitor GeometryWindow Screen $[monitor.primary] # Hide the geometry window GeometryWindow Hide .... *HideGeometryWindow* [Never | Move | Resize]:: This command has been depreciated and is now obsolete. Use *GeometryWindow Hide* instead. *Layer* [_arg1_ _arg2_] | [default]:: Puts the current window in a new layer. If _arg1_ is non zero then the next layer is the current layer number plus _arg1_. If _arg1_ is zero then the new layer is _arg2_. + As a special case, _default_ puts the window in its default layer, i.e. the layer it was initially in. The same happens if no or invalid arguments are specified. *Lower*:: Allows the user to lower a window. Note that this lowers a window only in its layer. To bring a window to the absolute bottom, use + .... AddToFunc lower-to-bottom + I Layer 0 0 + I Lower .... *Move* [_options_]:: Allows the user to move a window. If called from somewhere in a window or its border, then that window is moved. If called from the root window, then the user is allowed to select the target window. Move can be called with various options to either start an interactive move, specify the position to move, or a direction. + *Move* without options starts an interactive move. The window may snap to other windows and screen boundaries, configurable with the *SnapAttraction* style. Moving a window to the edge of the screen can be used to drag the window to other pages. (See *EdgeScroll*, and the _EdgeMoveDelay_ style for more information.) + Holding down _Alt_ disables snapping and allows one to switch pages without any delay. Interactive movement can be aborted with the _Escape_ key or any mouse button not set to place the window. By default mouse button 2 is set to cancel the move operation. To change this you may use the *Mouse* command with special context 'P' for Placement. + The window condition _PlacedByButton_ can be used to check if a specific button was pressed to place the window (see *Current* command). + If the single argument _pointer_ is given, the top left corner of the window is moved to the pointer position before starting an interactive move; this is mainly intended for internal use by modules like *FvwmPager*. + > *Move* pointer + To move a window in a given direction until it hits another window, icon, or screen boundary use: + > *Move* shuffle [Warp] [ewmhiwa] [snap _type_] [layers _min_ _max_] _direction_(s) + The _direction_ can be _North_/_N_/_Up_/_U_, _East_/_E_/_Right_/_R_, _South_/_S_/_Down_/_D_, or _West_/_W_/_Left_/_L_. The window will move in the given direction until it hits another window or the *EwmhBaseStruts*/screen boundary. When a window is at the *EwmhBaseStruts*/screen boundary, it will move to the next monitor in the given direction, if it exists. If a window is outside of the current working area (partly off screen), it will move to the edge of the working area. Windows will honor the EWMH working area and stop at the *EwmhBaseStruts* unless the literal option _ewmhiwa_ is given. If multiple _direction_(s) are given, the window will move the directions in the order of the sequence stated. + The literal option _Warp_ will warp the mouse pointer to the window. If the literal option _snap_ followed by a snap _type_ of _windows_, _icons_, or _same_ is given, then the window will only stop if it hits another window, icon, or the same type. If the literal option _layers_ followed by a _min_ layer and _max_ layer is given, then only windows on the layers between _min_ and _max_ layers will stop the window. For example: + .... # Shuffle the window Right. Move shuffle Right # Shuffle Up, only consider windows on Layer 3. Move shuffle layers 3 3 Up # Shuffle Left then Up Move shuffle Left Up # Shuffle Up then Left (may not be same position as above) Move shuffle Up Left .... + *Move* can be used to moved a window to a specified position: + > *Move* [screen _S_] \[w | m]_x_[p | w] \[w | m]_y_[p | w] [Warp] [ewmhiwa] + This will move the window to the _x_ and _y_ position (see below). By default, the EWMH working area is honoured. If he trailing option _ewmhiwa_ is given, then the window position will ignore the working area (such as ignoring any values set via *EwmhBaseStruts*). If the option _Warp_ is given then the pointer is warped to the window. + If the literal option _screen_ followed by a RandR screen name _S_ 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. + The positional arguments _x_ and _y_ can specify an absolute or relative position from either the left/top or right/bottom of the screen. By default, the numeric value given is interpreted as a percentage of the screen width/height, but a trailing '_p_' changes the interpretation to mean pixels, while a trailing '_w_' means 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 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 # position minus 50% of widow size). Move 50-50w 50-50w .... + See also the *AnimatedMove* command. + *MoveToDesk* [prev | _arg1_ [_arg2_] [_min_ _max_]]:: Moves the selected window to another desktop. The arguments are the same as for the *GotoDesk* command. Without any arguments, the window is moved to the current desk. *MoveToDesk* is a replacement for the obsolete *WindowsDesk* command, which can no longer be used. *MoveThreshold* [_pixels_]:: When the user presses a mouse button upon an object fvwm waits to see if the action is a click or a drag. If the mouse moves by more than _pixels_ pixels it is assumed to be a drag. + Previous versions of fvwm hardwired _pixels_ to 3, which is now the default value. If _pixels_ is negative or omitted the default value (which might be increased when 16000x9000 pixel displays become affordable) is restored. *MoveToPage* [_options_] [_x_[p | w] _y_[p | w]] | [prev]:: Moves the selected window to another page (_x_,_y_). The upper left page is (0,0), the upper right is (M,0), where M is one less than the current number of horizontal pages specified in the *DesktopSize* command. Similarly the lower left page is (0,N), and the lower right page is (M,N). Negative page numbers refer to pages from the rightmost/lowest page. If _x_ and _y_ are not given, the window is moved to the current page (a window that has the focus but is off-screen can be retrieved with this). Moving windows to a page relative to the current page can be achieved by adding a trailing '_p_' after any or both numerical arguments. To move the window relative to its current location, add a trailing '_w_'. To move a window to the previous page use _prev_ as the single argument. + Windows are usually not moved beyond desk boundaries. + Possible _options_ are _wrapx_ and _wrapy_ to wrap around the x or y coordinate when the window is moved beyond the border of the desktop. For example, with _wrapx_, when the window moves past the right edge of the desktop, it reappears on the left edge. The options _nodesklimitx_ and _nodesklimity_ allow moving windows beyond the desk boundaries in x and y direction (disabling the _wrapx_ and _wrapy_ options). + Examples: + .... # Move window to page (2,3) MoveToPage 2 3 # Move window to lowest and rightmost page MoveToPage -1 -1 # Move window to last page visited MoveToPage prev # Move window two pages to the right and one # page up, wrap at desk boundaries MoveToPage wrapx wrapy +2p -1p .... *MoveToScreen* [_screen_]:: Moves the selected window to another screen. The _screen_ argument must be a valid RandR name. *OpaqueMoveSize* [_percentage_]:: Tells fvwm the maximum size window with which opaque window movement should be used. The percentage is percent of the total screen area (may be greater than 100). With + .... OpaqueMoveSize 0 .... + all windows are moved using the traditional rubber-band outline. With + .... OpaqueMoveSize unlimited .... + or if a negative percentage is given all windows are moved as solid windows. The default is + .... OpaqueMoveSize 5 .... + which allows small windows to be moved in an opaque manner but large windows are moved as rubber-bands. If _percentage_ is omitted or invalid the default value is set. To resize windows in an opaque manner you can use the _ResizeOpaque_ style. See the *Style* command. *PlaceAgain* [Anim] [Icon]:: Causes the current window's position to be re-computed using the initial window placement logic. The window is moved to where it would have been if it were a new window that had just appeared. Most useful with _Smart_ or _Clever_ (_ReallySmart_) placement. With the optional argument _Anim_ an animated move is used to place the window in its new position. With the additional option _Icon_, the icon is placed again instead. *Raise*:: Allows the user to raise a window. Note that this raises a window only in its layer. To bring a window to the absolute top, use + .... AddToFunc raise-to-top + I Layer 0 ontop + I Raise .... + where ontop is the highest layer used in your setup. *RaiseLower*:: Alternately raises and lowers a window. The window is raised if it is obscured by any window (except for its own transients when _RaiseTransient_ style is used; see the *Style* command) otherwise it is lowered. *Resize* [[frame] [direction _dir_] [warptoborder _automatic_] [fixeddirection] [w]_width_[p | c | wa | da] [w]_height_[p | c]]:: Allows for resizing a window. If called from somewhere in a window or its border, then that window is resized. If called from the root window then the user is allowed to select the target window. + *Resize* without options starts an interactive resize. + If the _EdgeResizeDelay_ style is set or the _Alt_ key is held down, the window can be resized across the edge of the screen. + The operation can be aborted with the _Escape_ key or by pressing any mouse button (except button 1 which confirms it). + If the optional arguments _width_ and _height_ are provided, then the window is resized so that its dimensions are _width_ by _height_. The units of _width_ and _height_ are percent-of-screen, unless a letter '_p_' is appended to one or both coordinates, in which case the location is specified in pixels. With a '_c_' suffix the unit defined by the client application (hence the c) is used. With the suffix '_wa_' the value is a percentage of the width or height size of the EWMH working area, and with the suffix '_da_' it is a percentage of the width or height of the EWMH dynamic working area. So you can say + .... Resize 80c 24c .... + to make a terminal window just big enough for 80x24 characters. + If the _width_ or _height_ is prefixed with the letter '_w_' the size is not taken as an absolute value but added to the current size of the window. Example: + .... # Enlarge window by one line Resize keep w+1c .... + Both, _width_ and _height_ can be negative. In this case the new size is the screen size minus the given value. If either value is "_keep_", the corresponding dimension of the window is left untouched. The new size is the size of the client window, thus + .... Resize 100 100 .... + may make the window bigger than the screen. To base the new size on the size of the whole fvwm window, add the _frame_ option after the command. The options _fixeddirection_, _direction_ and _warptoborder_ are only used in interactive move operations. With _fixeddirection_ the same border is moved even if the pointer moves past the opposite border. The _direction_ option must be followed by a direction name such as "NorthWest", "South" or "East" (you get the idea). Resizing is started immediately, even if the pointer is not on a border. If the special option _automatic_ is given as a direction argument, then the direction to resize is calculated based on the position of the pointer in the window. If the pointer is in the middle of the window, then no direction is calculated. The _warptoborder_ option can be used to warp the pointer to the direction indicated. As with the _automatic_ option for _direction_, the border to warp to is calculated based on the pointer's proximity to a given border. Also, if resizing is started by clicking on the window border, the pointer is warped to the outer edge of the border. + .... AddToFunc ResizeSE I Resize Direction SE Mouse 3 A M ResizeSE .... *Resize* [bottomright | br _x_ _y_]:: An alternate syntax is used if the keyword _bottomright_ or in short _br_ follows the command name. In this case, the arguments _x_ and _y_ specify the desired position of the bottom right corner of the window. They are interpreted exactly like the _x_ and _y_ arguments of the *Move* command. Actually, any of the options accepted by the *Move* command can be used. *ResizeMaximize* [_resize-arguments_]:: Combines the effects of *Resize* and *Maximize* in a single command. When used on a maximized window, the window is resized and is still in the maximized state afterwards. When used on an unmaximized window, the window is resized and put into the maximized state afterwards. This is useful if the user wants to resize the window temporarily and then return to the original geometry. The _resize-arguments_ are the same as for the *Resize* command. *ResizeMove* _resize-arguments_ _move-arguments_:: This command does the same as the *Resize* and *Move* commands, but in a single call which is less visually disturbing. The _resize-arguments_ are exactly the same arguments as for the *Resize* command and the _move-arguments_ are exactly the same arguments as for the *Move* command except the _pointer_ option which is not supported by the *ResizeMove* command. + Examples: + .... # Move window to top left corner and cover # most of the screen ResizeMove -10p -20p 0 0 # Grow the focused window towards the top of screen Current Resize keep w+$[w.y]p keep 0 .... + Note: Fvwm may not be able to parse the command properly if the option _bottomright_ of the *Resize* command is used. *ResizeMoveMaximize* _resize-arguments_ _move-arguments_:: Combines the effects of *ResizeMove* and *Maximize* in a single command. When used on a maximized window, the window is resized and moved and is still in the maximized state afterwards. When used on an unmaximized window, the window is resized and put into the maximized state afterwards. This is useful if the user wants to resize the window temporarily and then return to the original geometry. The _resize-arguments_ and _move-arguments_ are the same as for the *ResizeMove* command. *RestackTransients*:: This command regroups the transients of a window close to it in the stacking order as if the window had just been lowered and then raised. The position of the window itself is not altered. Only windows that use either the _RaiseTransient_ or _LowerTransient_ style are affected at all. When *RestackTransients* is used on a transient window with the _StackTransientParent_ style set, it is redirected to the parent window. *SetAnimation* _milliseconds-delay_ [_fractions-to-move-list_]:: Sets the time between frames and the list of fractional offsets to customize the animated moves of the *AnimatedMove* command and the animation of menus (if the menu style is set to animated; see *MenuStyle* command). If the _fractions-to-move-list_ is omitted, only the time between frames is altered. The _fractions-to-move-list_ specifies how far the window should be offset at each successive frame as a fraction of the difference between the starting location and the ending location. e.g.: + .... SetAnimation 10 -.01 0 .01 .03 .08 .18 .3 \ .45 .6 .75 .85 .90 .94 .97 .99 1.0 .... + Sets the delay between frames to 10 milliseconds, and sets the positions of the 16 frames of the animation motion. Negative values are allowed, and in particular can be used to make the motion appear more cartoonish, by briefly moving slightly in the opposite direction of the main motion. The above settings are the default. *SnapAttraction* [_proximity_ [_behaviour_] [Screen]]:: The *SnapAttraction* command is obsolete. It has been replaced by the *Style* command option _SnapAttraction_. *SnapGrid* [_x-grid-size_ _y-grid-size_]:: The *SnapGrid* command is obsolete. It has been replaced by the *Style* command option _SnapGrid_. *WindowsDesk* _arg1_ [_arg2_]:: Moves the selected window to another desktop. + This command has been removed and must be replaced by *MoveToDesk*, the arguments for which are the same as for the *GotoDesk* command. + + *Important* + You cannot simply change the name of the command: the syntax has changed. If you used: + .... WindowsDesk n .... + to move a window to desk n, you have to change it to: + .... MoveToDesk 0 n .... *XorPixmap* [_pixmap_]:: Selects the pixmap with which bits are xor'ed when doing rubber-band window moving or resizing. This has a better chance of making the rubber-band visible if *XorValue* does not give good results. An example pixmap _resize.rainbow.xpm_ is provided with the icon distribution. To turn the _XorPixmap_ off again use the *XorValue* command or omit the _pixmap_ argument. *XorValue* [_number_]:: Changes the value with which bits are xor'ed when doing rubber-band window moving or resizing. Valid values range from zero to the maximum value of an unsigned long integer on your system. Setting this value is a trial-and-error process. The default value 0 tries to find a value that gives a good contrast to black and white. The default value is used if the given _number_ is omitted or invalid. === Focus & Mouse Movement *CursorMove* _horizontal_[p] _vertical_[p]:: Moves the mouse pointer by _horizontal_ pages in the X direction and _vertical_ pages in the Y direction. Either or both entries may be negative. CursorMove can only move the mouse cursor to a relative position. To move the mouse cursor to an absolute position, see *WarpToWindow*. Both horizontal and vertical values are expressed in percent of pages, so + .... CursorMove 100 100 .... + means to move down and right by one full page. + .... CursorMove 50 25 .... + means to move right half a page and down a quarter of a page. Alternatively, the distance can be specified in pixels by appending a '_p_' to the horizontal and/or vertical specification. For example + .... CursorMove -10p -10p .... + means move ten pixels up and ten pixels left. The CursorMove function should not be called from pop-up menus. *FlipFocus* [NoWarp]:: Executes a *Focus* command as if the user had used the pointer to select the window. This command alters the order of the WindowList in the same way as clicking in a window to focus, i.e. the target window is removed from the *WindowList* and placed at the start. This command is recommended for use with the *Direction* command and in the function invoked from *WindowList*. *Focus* [NoWarp]:: Sets the keyboard focus to the selected window. If the _NoWarp_ argument is given, this is all it does. Otherwise it also moves the viewport or window as needed to make the selected window visible. This command does not automatically raise the window. Does not warp the pointer into the selected window (see *WarpToWindow* function). Does not de-iconify. This command does not alter the order of the *WindowList*, it rotates the *WindowList* around so that the target window is at the start. + When the _NoWarp_ argument is given, Focus cannot transfer the keyboard focus to windows on other desks. + To raise and/or warp a pointer to a window together with *Focus* or *FlipFocus*, use a function, like: + .... AddToFunc SelectWindow + I Focus + I Iconify false + I Raise + I WarpToWindow 50 8p .... *WarpToWindow* [!raise | raise] _x_[p] _y_[p]:: Warps the cursor to the associated window and raises it (unless the option _!raise_ is present). The parameters _x_ and _y_ default to percentage of window down and in from the upper left hand corner (or number of pixels down and in if '_p_' is appended to the numbers). If a number is negative the opposite edge is used and the direction reversed. This command works also with windows that are not managed by fvwm. In this case fvwm does not bring the window onto the screen if it is not visible. For example it is possible to warp the pointer to the center of the root window on screen 1: + .... WindowId root 1 WarpToWindow 50 50 .... === Window State *Close*:: If the window accepts the delete window protocol a message is sent to the window asking it to gracefully remove itself. If the window does not understand the delete window protocol then the window is destroyed as with the *Destroy* command. Note: if the window accepts the delete window protocol but does not close itself in response, the window is not deleted. *Delete*:: Sends a message to a window asking that it remove itself, frequently causing the application to exit. *Destroy*:: Destroys an application window, which usually causes the application to crash and burn. *Iconify* [_bool_]:: Iconifies a window if it is not already iconified or de-iconifies it if it is already iconified. The optional argument _bool_ is a boolean argument. "_True_" means only iconification is allowed, while "_False_" forces de-iconification. Using "_toggle_" switches between iconified and de-iconified states. + There are a number of *Style* options which influence the appearance and behavior of icons (e.g. _StickyIcon_, _NoIcon_). + For backward compatibility, the optional argument may also be a positive number instead of "True", or a negative number instead of "False". Note that this syntax is obsolete, and will be removed in the future. *Maximize* [_flags_] [_bool | forget_] [_horizontal_[p]] [_vertical_[p]]:: Without its optional arguments (or if the _bool_ bit has the value "_toggle_") *Maximize* causes the window to alternately switch from a full-screen size to its normal size. To force a window into maximized (normal) state you can use a "_True_" or "_False_" value for the _bool_ argument. + With just the parameter "forget" a maximized window reverts back into normal state but keeps its current maximized size. This can be useful in conjunction with the commands *ResizeMaximize* and *ResizeMoveMaximize*. If the window is not maximized, nothing happens. + With the optional arguments _horizontal_ and _vertical_, which are expressed as percentage of a full screen, the user can control the new size of the window. An optional suffix '_p_' can be used to indicate pixels instead of percents of the screen size. If horizontal is greater than 0 then the horizontal dimension of the window is set to _horizontal_*screen_width/100. If the value is smaller than 0 the size is subtracted from the screen width, i.e. -25 is the same as 75. If _horizontal_ is "_grow_", it is maximized to current 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 screen on which to operate. + 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. *Refresh*:: Causes all windows on the screen to redraw themselves. All pending updates of all windows' styles and looks are applied immediately. E.g. if *Style* or *TitleStyle* commands were issued inside a fvwm function. *RefreshWindow*:: Causes the chosen window to redraw itself. All pending updates of the window's style and look are applied immediately. E.g. if *Style* or *TitleStyle* commands were issued inside a fvwm function. *Stick* [_bool_]:: If the _bool_ argument is empty or "_toggle_", the *Stick* command makes a window sticky if it is not already sticky, or non-sticky if it is already sticky. To make a window sticky regardless of its current state the _bool_ argument must be "True". To make it non-sticky use "False". *StickAcrossPages* [_bool_]:: Works like *Stick* but only sticks a window across pages, not across desks. *StickAcrossDesks* [_bool_]:: Works like *Stick* but only sticks a window across desks, not across pages. *WindowShade* [bool] | [[ShadeAgain] _direction_]:: Toggles the window shade feature for titled windows. Windows in the shaded state only display a title-bar. If _bool_ is not given or "_toggle_", the window shade state is toggled. If _bool_ is "True", the window is forced to the shaded state. If _bool_ is "False", then the window is forced to the non-shaded state. To force shading in a certain direction, the _direction_ argument can be used. Any of the strings "_North_", "_South_", "_West_", "_East_", "_NorthWest_", "_NorthEast_", "_SouthWest_", "_SouthEast_" or "_Last_" can be given. The direction can be abbreviated with the usual one or two letters "_N_", "_NW_", etc. Using a direction on a window that was already shaded unshades the window. To shade it in a different direction, use the _ShadeAgain_ option. The direction _Last_ shades the window in the direction it last was shaded. If the window has never been shaded before it is shaded as if no direction had been given. Windows without titles can be shaded too. Please refer also to the options _WindowShadeSteps_, _WindowShadeShrinks_, _WindowShadeScrolls_, _WindowShadeLazy_, _WindowShadeAlwaysLazy_ and _WindowShadeBusy_ options of the *Style* command. Examples: + .... Style * WindowShadeShrinks, WindowShadeSteps 20, \ WindowShadeLazy Mouse 1 - S WindowShade North Mouse 1 [ S WindowShade West Mouse 1 ] S WindowShade E Mouse 1 _ S WindowShade S .... + Note: When a window that has been shaded with a _direction_ argument changes the direction of the window title (see _TitleAtTop_ *Style* option), the shading direction does not change. This may look very strange. Windows that were shaded without a _direction_ argument stay shaded in the direction of the title bar. + For backward compatibility, the optional argument may also be 1 to signify "on", and 2 to signify "off". Note that this syntax is obsolete, and will be removed in the future. *WindowShadeAnimate* [_steps_ [p]]:: This command is obsolete. Please use the _WindowShadeSteps_ option of the *Style* command instead. === Mouse & Key Bindings *IgnoreModifiers* [_Modifiers_]:: Tells fvwm which modifiers to ignore when matching Mouse or Key bindings. *IgnoreModifiers* affects the _ClickToFocus_ style too. This command belongs into your _config_. If you issue it when your fvwm session is already up and running the results are unpredictable. The should appear before any applications or modules are started in your _config_ file (e.g. with the *Exec* command). + _Modifiers_ has the same syntax as in the *Mouse* or *Key* bindings, with the addition of 'L' meaning the caps lock key. The default is "L". _Modifiers_ can be omitted, meaning no modifiers are ignored. This command comes in handy if the num-lock and scroll-lock keys interfere with your shortcuts. With XFree86 '2' usually is the num-lock modifier and '5' refers to the scroll-lock key. To turn all these pesky modifiers off you can use this command: + .... IgnoreModifiers L25 .... + If the _Modifiers_ argument is the string "_default_", fvwm reverts back to the default value "L". + *Important* This command creates a lot of extra network traffic, depending on your CPU, network connection, the number of *Key* or *Mouse* commands in your configuration file and the number of modifiers you want to ignore. If you do not have a lightning fast machine or very few bindings you should not ignore more than two modifiers. I.e. do not ignore + if you have no problem with it. In the _FAQ_ you can find a better solution of this problem. *EdgeCommand* [screen _RANDRNAME_] [_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. If the literal option _screen_ followed by a RandR screen name _RANDRNAME_ is given, the command is set only for the given monitor. + _Function_ is executed when the mouse pointer enters the invisible pan frames that surround the visible screen. The binding works only if *EdgeThickness* is set to a value greater than 0. If a function is bound to an edge, scrolling specified by *EdgeScroll* is disabled for this edge. It is possible to bind a function only to some edges and use the other edges for scrolling. This command is intended to raise or lower certain windows when the mouse pointer enters an edge. *FvwmAuto* can be used get a delay when raising or lowering windows. The following example raises *FvwmButtons* if the mouse pointer enters the top edge of the screen. + .... # Disable EdgeScrolling but make it possible # to move windows over the screen edge EdgeResistance -1 Style * EdgeMoveDelay 250 Style * EdgeMoveResistance 20 # Set thickness of the edge of the screen to 1 EdgeThickness 1 # Give focus to FvwmButtons if the mouse # hits top edge EdgeCommand Top Next (FvwmButtons) Focus # Make sure the Next command matches the window Style FvwmButtons CirculateHit Module FvwmButtons Module FvwmAuto 100 "Silent AutoRaiseFunction" \ "Silent AutoLowerFunction" # If any window except FvwmButtons has # focus when calling this function # FvwmButtons are lowered DestroyFunc AutoLowerFunction AddToFunc AutoLowerFunction + I Current (!FvwmButtons) All (FvwmButtons) Lower # If FvwmButtons has focus when calling this function raise it DestroyFunc AutoRaiseFunction AddToFunc AutoRaiseFunction + I Current (FvwmButtons) Raise .... + Normally, the invisible pan frames are only on the screen edges that border virtual pages. If a screen edge has a command bound to it, the pan frame is always created on that edge. *EdgeLeaveCommand* [screen _RANDRNAME_] [_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. If the literal option _screen_ followed by a RandR screen name _RANDRNAME_ is given, the command is set only for the given monitor. + _Function_ is executed when the mouse pointer leaves the invisible pan frames that surround the visible screen. The binding works only if *EdgeThickness* is set to a value greater than 0. If a function is bound to an edge, scrolling specified by *EdgeScroll* is disabled for this edge. It is possible to bind a function only to some edges and use the other edges for scrolling. This command is intended to raise or lower certain windows when the mouse pointer leaves an edge. *FvwmAuto* can be used get a delay when raising or lowering windows. See example for *EdgeCommand* + Normally, the invisible pan frames are only on the screen edges that border virtual pages. If a screen edge has a command bound to it, the pan frame is always created on that edge. *Key* [(_window_)] _Keyname_ _Context_ _Modifiers_ _Function_:: Binds a keyboard key to a specified fvwm command, or removes the binding if _Function_ is '-'. The syntax is the same as for a *Mouse* binding except that the mouse button number is replaced with a _Keyname_. Normally, the key binding is activated when the key is pressed. _Keyname_ is a standard X11 key name as defined in _/usr/include/X11/keysymdef.h_, (without the _XK__ prefix), or the keysym database _/usr/X11R6/lib/X11/XKeysymDB_. Only key names that are generated with no modifier keys or with just the + key held are guaranteed to work. The _Context_ and _Modifiers_ fields are defined as in the *Mouse* binding. However, when you press a key the context window is the window that has the keyboard focus. That is not necessarily the same as the window the pointer is over (with _SloppyFocus_ or _ClickToFocus_). Note that key bindings with the '_R_' (root window) context do not work properly with _SloppyFocus_ and _ClickToFocus_. If you encounter problems, use the *PointerKey* command instead. If you want to bind keys to a window with _SloppyFocus_ or _ClickToFocus_ that are supposed to work when the pointer is not over the window, fvwm assumes the pointer is over the client window (i.e. you have to use the 'W' context). + The special context '_M_' for menus can be used to (re)define the menu controls. It be used alone or together with 'T', 'S', 'I', '[', ']', '-' and '_'. See the *Menu Bindings* section for details. + The following example binds the built-in window list to pop up when + is hit, no matter where the mouse pointer is: + .... Key F11 A SCM WindowList .... + Binding a key to a title-bar button causes that button to appear. Please refer to the *Mouse* command for details. *Mouse* [(_window_)] _Button_ _Context_ _Modifiers_ _Function_:: Defines a mouse binding, or removes the binding if _Function_ is '-'. _Button_ is the mouse button number. If _Button_ is zero then any button performs the specified function. Note that only mouse buttons 1 to 5 are fully supported by X11. Any number above this works only partially. Complex functions can not be used with these buttons and neither any operation that requires dragging the pointer with the button held. This is due to limitations of X11. By default, the highest allowed button number is 9. + _Context_ describes where the binding applies. Valid contexts are '_R_' for the root window, '_W_' for an application window, '_D_' for a desktop application (as kdesktop or Nautilus desktop), '_T_' for a window title-bar, '_S_' for a window side, top, or bottom bar, '_[_', '_]_', '_-_' and '___' for the left, right, top or bottom side only, '_F_' for a window frame (the corners), '<', '^', '>' and '_v_' for the top left, top right, bottom right or bottom left corner, '_I_' for an icon window, or '_0_' through '_9_' for title-bar buttons, or any combination of these letters. '_A_' is for any context. For instance, a context of "FST" applies when the mouse is anywhere in a window's border except the title-bar buttons. Only 'S' and 'W' are valid for an undecorated window. + The special context '_M_' for menus can be used to (re)define the menu controls. It can be used alone or together with 'T', 'S', 'I', '[', ']', '-' and '_'. See the *Menu Bindings* section for details. + The special context '_P_' controls what buttons that can be used to place a window. When using this context no modifiers are allowed (_Modifiers_ must be N), no _window_ is allowed, and the _Function_ must be one of _PlaceWindow_, _PlaceWindowDrag_, _PlaceWindowInteractive_, _CancelPlacement_, _CancelPlacementDrag_, _CancelPlacementInteractive_ or _-_. + _PlaceWindow_ makes _Button_ usable for window placement, both for interactive and drag move. _CancelPlacement_ does the inverse. That is makes _Button_ to cancel move for both interactive and drag move. It may however not override how new windows are resized after being placed. This is controlled by the *Emulate* command. Also a window being dragged can always be placed by releasing the button hold while dragging, regardless of if it is set to _PlaceWindow_ or not. + _PlaceWindowDrag_ and _PlaceWindowInteractive_/_CancelPlacementDrag_ and _CancelPlacementInteractive_ work as _PlaceWindow_/_CancelPlacement_ with the exception that they only affect either windows dragged / placed interactively. + _-_ is equivalent to _CancelPlacement_. + The following example makes all buttons but button 3 usable for interactive placement and makes drag moves started by other buttons than one cancel if button 1 is pressed before finishing the move: + .... Mouse 0 P N PlaceWindow Mouse 3 P N CancelPlacement Mouse 1 P N CancelPlacementDrag .... + By default, the binding applies to all windows. You can specify that a binding only applies to specific windows by specifying the window name in brackets. The window name is a wildcard pattern specifying the class, resource or name of the window you want the binding to apply to. + The following example shows how the same key-binding can be used to perform different functions depending on the window that is focused: + .... Key (rxvt) V A C Echo ctrl-V-in-RXVT Key (*term) V A C Echo ctrl-V-in-Term Key (*vim) V A C -- Key V A C Echo ctrl-V-elsewhere .... + A '_--_' action indicates that the event should be propagated to the specified window to handle. This is only a valid action for window-specific bindings. + This example shows how to display the WindowList when Button 3 is pressed on an rxvt window: + .... Mouse (rxvt) 3 A A WindowList .... + Note that Fvwm actually intercepts all events for a window-specific binding and (if the focused window doesn't match any of the bindings) sends a synthetic copy of the event to the window. This should be transparent to most applications, however (for security reasons) some programs ignore these synthetic events by default - xterm is one of them. To enable handling of these events, add the following line to your _~/.Xdefaults_ file: + .... XTerm*allowSendEvents: true .... + _Modifiers_ is any combination of '_N_' for no modifiers, '_C_' for control, '_S_' for shift, '_M_' for Meta, '_L_' for Caps-Lock or '_A_' for any modifier. For example, a modifier of "SM" applies when both the + and + keys are down. X11 modifiers mod1 through mod5 are represented as the digits '1' through '5'. The modifier 'L' is ignored by default. To turn it on, use the *IgnoreModifiers* command. + _Function_ is one of fvwm's commands. + The title-bar buttons are numbered with odd numbered buttons on the left side of the title-bar and even numbers on the right. Smaller-numbered buttons are displayed toward the outside of the window while larger-numbered buttons appear toward the middle of the window (0 is short for 10). In summary, the buttons are numbered: + .... 1 3 5 7 9 0 8 6 4 2 .... + The highest odd numbered button which has an action bound to it determines the number of buttons drawn on the left side of the title bar. The highest even number determines the number of right side buttons which are drawn. Actions can be bound to either mouse buttons or keyboard keys. *PointerKey* [(_window_)] _Keyname_ _Context_ _Modifiers_ _Function_:: This command works exactly like the *Key* command. The only difference is that the binding operates on the window under the pointer. Normal key bindings operate on the focused window instead. The *PointerKey* command can for example be used to bind keys to the root window if you are using _SloppyFocus_ or _ClickToFocus_. However, some applications (xterm is one example) are unable to handle this key anymore, even if the pointer is over the xterm window. It is recommended to use the *PointerKey* command only for key combinations that are not needed in any application window. + Example: + .... Style * SloppyFocus PointerKey f1 a m Menu MainMenu .... ifdef::fvwm3[] == WINDOW STYLES Please refer to the fvwm3styles man page. endif::[] ifdef::fvwm3all[] // BEGIN 'styles' === Controlling Window Styles For readability, the commands in this section are not sorted alphabetically. The description of the *Style* command can be found at the end of this section. *FocusStyle* _stylename_ _options_:: works exactly like the *Style* command, but accepts only the focus policy related styles beginning with "FP". The prefix can be removed, but at the cost of a little bit of time. *FocusStyle* is meant to make the configuration file more readable. Example: + .... FocusStyle * EnterToFocus, !LeaveToUnfocus .... + is equivalent to + .... Style * FPEnterToFocus, !FPLeaveToUnfocus .... *DestroyStyle* _style_:: deletes the style named _style_. The changes take effect immediately. Note that _style_ is not a wild-carded search string, but rather a case-sensitive string that should exactly match the original *Style* command. + Destroying style "*" can be done, but isn't really to be recommended. For example: + .... DestroyStyle Application* .... + This removes all settings for the style named "Application*", NOT all styles starting with "Application". *DestroyWindowStyle*:: deletes the styles set by the *WindowStyle* command on the selected window. The changes take effect immediately. *UpdateStyles*:: All pending updates of all windows' styles and looks are applied immediately. E.g. if *Style*, _WindowStyle_ or _TitleStyle_ commands were issued inside a fvwm function. *Style* _stylename_ _options_ ...:: The *Style* command is used to set attributes of a window to values other than the default or to set the window manager default styles. + _stylename_ can be a window's name, class, visible name, or resource string. It may contain the wildcards '*' and '?', which are matched in the usual Unix filename manner. Multiple style options in a single *Style* command are read from left to right as if they were issued one after each other in separate commands. A given style always overrides all conflicting styles that have been issued earlier (or further left on the same style line). + Note: windows that have no name (WM_NAME) are given a name of "Untitled", and windows that do not have a class (WM_CLASS, res_class) are given class "NoClass" and those that do not have a resource (WM_CLASS, res_name) are given resource "NoResource". + If a window has the resource "fvwmstyle" set, the value of that resource is used in addition to any window names when selecting the style. + _options_ is a comma separated list containing one or more of the following keywords. Each group of style names is separated by slashes ('/'). The last style in these groups is the default. _BorderWidth_, _HandleWidth_, _!Icon_ / _Icon_, _MiniIcon_, _IconBox_, _IconGrid_, _IconFill_, _IconSize_, _!Title_ / _Title_, _TitleAtBottom_ / _TitleAtLeft_ / _TitleAtRight_ / _TitleAtTop_, _LeftTitleRotatedCW_ / _LeftTitleRotatedCCW_, _RightTitleRotatedCCW_ / _RightTitleRotatedCW_, _TopTitleRotated_ / _TopTitleNotRotated_, _BottomTitleRotated_ / _BottomTitleNotRotated_, _!UseTitleDecorRotation_ / _UseTitleDecorRotation_, _StippledTitle_ / _!StippledTitle_, _StippledIconTitle_ / _!StippledIconTitle_, _IndexedWindowName_ / _ExactWindowName_, _IndexedIconName_ / _ExactIconName_, _TitleFormat_ / _IconTitleFormat_ / _!Borders_ / _Borders_, _!Handles_ / _Handles_, _WindowListSkip_ / _WindowListHit_, _CirculateSkip_ / _CirculateHit_, _CirculateSkipShaded_ / _CirculateHitShaded_, _CirculateSkipIcon_ / _CirculateHitIcon_, _Layer_, _StaysOnTop_ / _StaysOnBottom_ / _StaysPut_, _Sticky_ / _Slippery_, _StickyAcrossPages_ / _!StickyAcrossPages_, _StickyAcrossDesks_ / _!StickyAcrossDesks_, _!StickyStippledTitle_ / _StickyStippledTitle_, _!StickyStippledIconTitle_ / _StickyStippledIconTitle_, _StartIconic_ / _StartNormal_, _Colorset_, _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_, _StickyIcon_ / _SlipperyIcon_, _StickyAcrossPagesIcon_ / _!StickyAcrossPagesIcon_, _StickyAcrossDesksIcon_ / _!StickyAcrossDesksIcon_, _ManualPlacement_ / _CascadePlacement_ / _MinOverlapPlacement_ / _MinOverlapPercentPlacement_ / _TileManualPlacement_ / _TileCascadePlacement_ / _PositionPlacement_, _MinOverlapPlacementPenalties_, _MinOverlapPercentPlacementPenalties_, _DecorateTransient_ / _NakedTransient_, _DontRaiseTransient_ / _RaiseTransient_, _DontLowerTransient_ / _LowerTransient_, _DontStackTransientParent_ / _StackTransientParent_, _SkipMapping_ / _ShowMapping_, _ScatterWindowGroups_ / _KeepWindowGroupsOnDesk_, _UseDecor_, _UseStyle_, _!UsePPosition_ / _NoPPosition_ / _UsePPosition_, _!UseUSPosition_, _NoUSPosition_ / _UseUSPosition_, _!UseTransientPPosition_, _NoTransientPPosition_ / _UseTransientPPosition_, _!UseTransientUSPosition_ / _NoTransientUSPosition_ / _UseTransientUSPosition_, _!UseIconPosition_ / _NoIconPosition_ / _UseIconPosition_, _Lenience_ / _!Lenience_, _ClickToFocus_ / _SloppyFocus_ / __MouseFocus__|_FocusFollowsMouse_ / _NeverFocus_, _ClickToFocusPassesClickOff_ / _ClickToFocusPassesClick_, _ClickToFocusRaisesOff_ / _ClickToFocusRaises_, _MouseFocusClickRaises_ / _MouseFocusClickRaisesOff_, _GrabFocus_ / _GrabFocusOff_, _GrabFocusTransientOff_ / _GrabFocusTransient_, _FPFocusClickButtons_, _FPFocusClickModifiers_, _!FPSortWindowlistByFocus_ / _FPSortWindowlistByFocus_, _FPClickRaisesFocused_ / _!FPClickRaisesFocused_, _FPClickDecorRaisesFocused_ / _!FPClickDecorRaisesFocused_, _FPClickIconRaisesFocused_ / _!FPClickIconRaisesFocused_, _!FPClickRaisesUnfocused_ / _FPClickRaisesUnfocused_, _FPClickDecorRaisesUnfocused_ / _!FPClickDecorRaisesUnfocused_, _FPClickIconRaisesUnfocused_ / _!FPClickIconRaisesUnfocused_, _FPClickToFocus_ / _!FPClickToFocus_, _FPClickDecorToFocus_ / _!FPClickDecorToFocus_, _FPClickIconToFocus_ / _!FPClickIconToFocus_, _!FPEnterToFocus_ / _FPEnterToFocus_, _!FPLeaveToUnfocus_ / _FPLeaveToUnfocus_, _!FPFocusByProgram_ / _FPFocusByProgram_, _!FPFocusByFunction_ / _FPFocusByFunction_, _FPFocusByFunctionWarpPointer_ / _!FPFocusByFunctionWarpPointer_, _FPLenient_ / _!FPLenient_, _!FPPassFocusClick_ / _FPPassFocusClick_, _!FPPassRaiseClick_ / _FPPassRaiseClick_, _FPIgnoreFocusClickMotion_ / _!FPIgnoreFocusClickMotion_, _FPIgnoreRaiseClickMotion_ / _!FPIgnoreRaiseClickMotion_, _!FPAllowFocusClickFunction_ / _FPAllowFocusClickFunction_, _!FPAllowRaiseClickFunction_ / _FPAllowRaiseClickFunction_, _FPGrabFocus_ / _!FPGrabFocus_, _!FPGrabFocusTransient_ / _FPGrabFocusTransient_, _FPOverrideGrabFocus_ / _!FPOverrideGrabFocus_, _FPReleaseFocus_ / _!FPReleaseFocus_, _!FPReleaseFocusTransient_ / _FPReleaseFocusTransient_, _FPOverrideReleaseFocus_ / _!FPOverrideReleaseFocus_, _StartsLowered_ / _StartsRaised_, _IgnoreRestack_ / _AllowRestack_, _FixedPosition_ / _VariablePosition_, _FixedUSPosition_ / _VariableUSPosition_, _FixedPPosition_ / _VariablePPosition_, _FixedSize_ / _VariableSize_, _FixedUSSize_ / _VariableUSSize_, _FixedPSize_ / _VariablePSize_, _!Closable_ / _Closable_, _!Iconifiable_ / _Iconifiable_, _!Maximizable_ / _Maximizable_, _!AllowMaximizeFixedSize_ / _AllowMaximizeFixedSize_, _IconOverride_ / _NoIconOverride_ / _NoActiveIconOverride_, _DepressableBorder_ / _FirmBorder_, _MinWindowSize_, _MaxWindowSize_, _IconifyWindowGroups_ / _IconifyWindowGroupsOff_, _ResizeOpaque_ / _ResizeOutline_, _BackingStore_ / _BackingStoreOff_ / _BackingStoreWindowDefault_, _Opacity_ / _ParentalRelativity_, _SaveUnder_ / _SaveUnderOff_, _WindowShadeShrinks_ / _WindowShadeScrolls_, _WindowShadeSteps_, _WindowShadeAlwaysLazy_ / _WindowShadeBusy_ / _WindowShadeLazy,_ _EWMHDonateIcon_ / _EWMHDontDonateIcon_, _EWMHDonateMiniIcon_ / _EWMHDontDonateMiniIcon_, _EWMHMiniIconOverride_ / _EWMHNoMiniIconOverride_, _EWMHUseStackingOrderHints_ / _EWMHIgnoreStackingOrderHints_, _EWMHIgnoreStateHints_ / _EWMHUseStateHints_, _EWMHIgnoreStrutHints_ / _EWMHUseStrutHints_, _EWMHIgnoreWindowType_ / _!EWMHIgnoreWindowType_, _EWMHMaximizeIgnoreWorkingArea_ / _EWMHMaximizeUseWorkingArea_ / _EWMHMaximizeUseDynamicWorkingArea_, _EWMHPlacementIgnoreWorkingArea_ / _EWMHPlacementUseWorkingArea_ / _EWMHPlacementUseDynamicWorkingArea_, _MoveByProgramMethod_, _Unmanaged_, _State_, _SnapGrid_, _SnapAttraction_, _EdgeMoveDelay_, _EdgeResizeDelay_. _EdgeMoveResistance_, _InitialMapCommand_ + In the above list some options are listed as style-option/opposite-style-option. The opposite-style-option for entries that have them describes the fvwm default behavior and can be used if you want to change the fvwm default behavior. + *Focus policy*;; _ClickToFocus_ instructs fvwm to give the focus to a window when it is clicked in. The default _MouseFocus_ (or its alias _FocusFollowsMouse_) tells fvwm to give a window the focus as soon as the pointer enters the window, and take it away when the pointer leaves the window. _SloppyFocus_ is similar, but doesn't give up the focus if the pointer leaves the window to pass over the root window or a ClickToFocus window (unless you click on it, that is), which makes it possible to move the mouse out of the way without losing focus. A window with the style _NeverFocus_ never receives the focus. This is useful for modules like *FvwmButtons*. for example. Note: Once any of the "FP..." styles has been used, the defaults that come with the basic focus policies are not restored when the latter are used again. For example, once !FPGrabFocus has been used, using ClickToFocus does not restore FPGrabFocus. + The focus model can be augmented with several additional options. In fvwm-2.5.3 and later, there are a large number of advanced options beginning with "FP" or "!FP". These options shall replace the older options one day and are described first. Using any of these new options may limit compatibility with older releases. In general, options beginning with "FP" turn a feature on, while those beginning with "!FP" turn it off. *Focusing the window*;; With _FPEnterToFocus_, when the pointer enters a window it receives focus. + With _FPLeaveToUnfocus_ a window loses focus when the pointer leaves it. + With _FPClickToFocus_, _FPClickDecorToFocus_ or _FPClickIconToFocus_, a window receives focus when the inside of the window or the decorations or its icon is clicked. + The _FPFocusByProgram_ style allows windows to take the focus themselves. + The !_FPFocusByFunction_ style forbids that a window receives the focus via the *Focus* and *FlipFocus* commands. + The _FPFocusByFunctionWarpPointer_ style controls if the pointer is warped to a selected window when the *Focus* command is used. + _FPLenient_ allows focus on windows that do not want it, like *FvwmPager* or xclock. + The _FPFocusClickButtons_ style takes a list of mouse buttons that can be clicked to focus or raise a window when the appropriate style is used. The default is to use the first three buttons ("123"). + The _FPFocusClickModifiers_ style takes a list of modifier keys just like the *Key* command. The exact combination of modifier keys must be pressed for the click to focus or raise a window to work. The default is to use no modifiers ("N"). + With the _FPPassFocusClick_ style, the click that was used to focus a window is passed to the application. + With the _FPAllowFocusClickFunction_ style, the click that was used to focus a window can also trigger a normal action that was bound to the window with the *Mouse* command). + If the _FPIgnoreFocusClickMotion_ style is used, clicking in a window and then dragging the pointer with the button held down does not count as the click to focus the window. Instead, the application processes these events normally. This is useful to select text in a terminal window with the mouse without raising the window. However, mouse bindings on the client window are not guaranteed to work anymore (see *Mouse* command). This style forces the initial click to be passed to the application. The distance that the pointer must be moved to trigger this is controlled by the *MoveThreshold* command. + The _FPSortWindowlistByFocus_ and !_FPSortWindowlistByFocus_ styles control whether the internal window list is sorted in the order the windows were focused or in the order they were created. The latter is the default for _ClickToFocus_ and _SloppyFocus_. + *Clicking the window to raise* + The styles _FPClickRaisesFocused_, _FPClickDecorRaisesFocused_ and _FPClickIconRaisesFocused_ allow one to raise the window when the interior or the decorations or the icon of the window is clicked while the window is already focused. + The styles _FPClickRaisesUnfocused_, _FPClickDecorRaisesUnfocused_ and _FPClickIconRaisesUnfocused_ allow one to raise the window when the interior or the decorations or the icon of the window is clicked while the window is not yet focused. + With the _FPPassRaiseClick_ style, the click that was used to raise the window is passed to the application. + With the _FPAllowRaiseClickFunction_ style, the click that was used to raise the window can also trigger a normal action that was bound to the window with the *Mouse* command. + If the _FPIgnoreRaiseClickMotion_ style is used, clicking in a window and then dragging the pointer with the button held down does not count as the click to raise the window. Instead, the application processes these events normally. This is useful to select text in a terminal window with the mouse without raising the window. However, mouse bindings on the client window are not guaranteed to work anymore (see *Mouse* command. Note that this style forces that the initial click is passed to the application. The distance that the pointer must be moved to trigger this is controlled by the *MoveThreshold* command. + *Grabbing the focus when a new window is created* + New normal or transient windows with the _FPGrabFocus_ or _FPGrabFocusTransient_ style automatically receive the focus when they are created. _FPGrabFocus_ is the default for windows with the _ClickToFocus_ style. Note that even if these styles are disabled, the application may take the focus itself. Fvwm can not prevent this. + The _OverrideGrabFocus_ style instructs fvwm to never take away the focus from such a window via the _GrabFocus_ or _GrabFocusTransient_ styles. This can be useful if you like to have transient windows receive the focus immediately, for example in a web browser, but not while you are working in a terminal window or a text processor. + The above three styles are accompanied by _FPReleaseFocus_, _FPReleaseFocusTransient_ and _FPOverrideReleaseFocus_. These control if the focus is returned to another window when the window is closed. Otherwise no window or the window under the pointer receives the focus. + _ClickToFocusPassesClickOff_ and _ClickToFocusPassesClick_ controls whether a mouse click to focus a window is sent to the application or not. Similarly, _ClickToFocusRaisesOff_/_MouseFocusClickRaisesOff_ and _ClickToFocusRaises_/_MouseFocusClickRaises_ control if the window is raised (but depending on the focus model). + Note: in fvwm versions prior to 2.5.3, the "Click..." options applied only to windows with _ClickToFocus_ while the "Mouse..." options applied to windows with a different focus policy. This is no longer the case. + The old _GrabFocus_ style is equivalent to using _FPGrabFocus_ + _FPReleaseFocus_. + The old _GrabFocusTransient_ style is equivalent to using _FPGrabFocusTransient_ + _FPReleaseFocusTransient_. + _Lenience_ is equivalent to the new style _FPLenient_. *Window title*:: The _Title_ and !Title options determine whether the window is decorated with a title-bar. By default all windows have a title-bar. _NoTitle_ is equivalent to _!Title_ but is deprecated. + Windows with the _TitleAtBottom_, _TitleAtLeft_ or _TitleAtRight_ style have a title-bar below, to the left or to the right of the window instead of above as usual. The _TitleAtTop_ style restores the default placement. Even if the window has the _!Title_ style set, this affects the *WindowShade* command. Please check the *WindowShade* command for interactions between that command and these styles. Titles on the left or right side of the windows are augmented by the following styles: + Normally, the text in titles on the left side of a window is rotated counterclockwise by 90 degrees from the normal upright position and 90 degrees clockwise for titles on the right side. It can also be rotated in the opposite directions with _LeftTitleRotatedCW_ if _TitleAtLeft_ is used, and with _RightTitleRotatedCCW_ if _TitleAtRight_ is used. The defaults can be restored with _LeftTitleRotatedCCW_ and _RightTitleRotatedCW_. A normal horizontal text may be rotated as well with _TopTitleRotated_ if _TitleAtTop_ is used, and with _BottomTitleRotated_ if _TitleAtBottom_ is used. The defaults can be restored with _TopTitleNotRotated_ and _BottomTitleNotRotated_. + By default the title bar decoration defined using the *TitleStyle* command is rotated following the title text rotation (see the previous paragraph). This can be disabled by using the !_UseTitleDecorRotation_ style. _UseTitleDecorRotation_ reverts back to the default. + With the _StippledTitle_ style, titles are drawn with the same effect that is usually reserved for windows with the _Sticky_, _StickyAcrossPages_ or _StickyAcrossDesks_ style. _!StippledTitle_ reverts back to normal titles. _StippledTitleOff_ is equivalent to _!StippledTitle_ but is deprecated. + *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. + _BorderColorset_ takes eight positive integers as its arguments and will apply the given colorsets to the eight individual components of the window border. + For backwards compatibility, if one integer is supplied, that is applied to all window border components. + The border is split up into the following definitions, and is the same order as the colorsets which will be applied to the border. + .... North, North East, East, South East, South, South West, West, North West .... + _North_, _East_, _South_, and _West_ refer to the top, left, bottom, and right sides of the window border. + _NE_, _SE_, _SW_, and _NW_ refer to the window handles. + *NOTE*: due to how window handles are rendered, there is no way to make one complete edge of a window the same color as defined by either _North_, _South_, _East_, or _West_. + The _HilightBorderColorset_ style option works the same as _BorderColorset_ but is used when the window has the focus. + !_IconTitle_ disables displaying icon labels while the opposite style _IconTitle_ enables icon labels (default behaviour). _NoIconTitle_ is equivalent to _!IconTitle_ but is deprecated. + _IconTitleColorset_ takes the colorset number as its sole argument and overrides the colors set by _Color_ or _Colorset_. To stop using this colorset, the argument is omitted. + _HilightIconTitleColorset_ takes the colorset number as its sole argument and overrides the colors set by *HilightColor* or _HilightColorset_. To stop using this colorset, the argument is omitted. + _IconBackgroundColorset_ takes the colorset number as its sole argument and uses it to set a background for the icon picture. By default the icon picture is not drawn onto a background image. To restore the default, the argument is omitted. + _IconTitleRelief_ takes one numeric argument that may be between -50 and +50 pixels and defines the thickness of the 3D relief drawn around the icon title. With negative values the icon title gets a pressed in look. The default is 2 and it is restored if the argument is omitted. + _IconBackgroundRelief_ takes one numeric argument that may be between -50 and +50 pixels and defines the thickness of the 3D relief drawn around the icon picture background (if any). With negative values the icon background gets a pressed in look. The default is 2 and it is restored if the argument is omitted. + _IconBackgroundPadding_ takes one numeric argument that may be between 0 and 50 pixels and defines the amount of free space between the relief of the icon background picture (if any) and the icon picture. The default is 2 and it is restored if the argument is omitted. + The _Font_ and _IconFont_ options take the name of a font as their sole argument. This font is used in the window or icon title. By default the font given in the *DefaultFont* command is used. To revert back to the default, use the style without the name argument. These styles replace the older *WindowFont* and _IconFont_ commands. + The deprecated _IndexedWindowName_ style causes fvwm to use window titles in the form + .... name (i) .... + where _name_ is the exact window name and _i_ is an integer which represents the _i th_ window with _name_ as window name. This has been replaced with: + .... TitleFormat %n (%t) .... + _ExactWindowName_ restores the default which is to use the exact window name. Deprecated in favour of: + .... TitleFormat %n .... + _IndexedIconName_ and _ExactIconName_ work the same as _IndexedWindowName_ and _ExactWindowName_ styles but for the icon titles. Both are deprecated in favour of: + .... IconTitleFormat %n (%t) IconTitleFormat %n .... + _TitleFormat_ describes what the visible name of a window should look like, with the following placeholders being valid: + *%n*::: Insert the window's name. *%i*::: Insert the window's icon name. *%c*::: Insert the window's class name. *%r*::: Insert the window's resource name. *%t*::: Insert the window count. *%I*::: Insert the window ID. *%%*::: Insert a literal '%' character. + Any amount of whitespace may be used, along with other characters to make up the string -- but a valid _TitleFormat_ string must contain at least one of the placeholders mentioned. No quote stripping is performed on the string, so for example the following is printed verbatim: + .... TitleFormat " %n " -> [%t] -> [%c] .... + Note: It's perfectly possible to use a _TitleFormat_ which can result in wiping out the visible title altogether. For example: + .... TitleFormat %z .... + Simply because the placeholder '%z' isn't supported. This is not a bug but rather a facet of how the formatting parser works. + _IconTitleFormat_ describes what the visible icon name of a window should look like, with the options being the same as _TitleFormat_. *Title buttons*:: _Button_ and !_Button_ take a numeric argument which is the number of the title-bar button which is to be shown or omitted. _NoButton_ is equivalent to _!Button_ but is deprecated. + _MwmButtons_ makes the *Maximize* button look pressed-in when the window is maximized. See the _MwmDecorMax_ flag in *ButtonStyle* for more information. To switch this style off again, use the *FvwmButtons* style. *Borders*:: !_Borders_ suppresses the window border (but not the title) completely. The _Borders_ style enables them again. Without borders, all other styles affecting window borders are meaningless. + _MwmBorder_ makes the 3D bevel more closely match Mwm's. _FvwmBorder_ turns off the previous option. + With the !_Handles_ style, the window does not get the handles in the window corners that are commonly used to resize it. With _!Handles_, the width from the _BorderWidth_ style is used. By default, or if _Handles_ is specified, the width from the _HandleWidth_ style is used. _NoHandles_ is equivalent to _!Handles_ but is deprecated. + _HandleWidth_ takes a numeric argument which is the width of the border to place the window if it does have resize-handles. Using HandleWidth without an argument restores the default. + _BorderWidth_ takes a numeric argument which is the width of the border to place the window if it does not have resize-handles. It is used only if the _!Handles_ style is specified too. Using BorderWidth without an argument restores the default. + _DepressableBorder_ makes the border parts of the window decoration look sunken in when a button is pressed over them. This can be disabled again with the _FirmBorder_ style. *Icons, shading, maximizing, movement, resizing*:: _Icon_ takes an (optional) unquoted string argument which is the icon bitmap or pixmap to use. Icons specified this way override pixmap icons, but not icon windows or the ewmh icon, provided by the client in the application (with the WM_HINTS property or with the ewmh _NET_WM_ICON property). The _IconOverride_ style changes the behavior to override any client-provided icons; the _NoIconOverride_ style changes the behavior to not override any client-provided icons; the default overriding behavior can be activated with the _NoActiveIconOverride_ style. With this style, fvwm uses application provided icons if the icon is changed but uses the icon provided in the configuration file until then. + There is one exception to these rules, namely + .... Style * Icon unknown.xpm .... + doesn't force the unknown.xpm icon on every window, it just sets the default icon like the DefaultIcon command. If you really want all windows to have the same icon, you can use + .... Style ** Icon unknown.xpm .... + If the _NoIcon_ attribute is set then the specified window simply disappears when it is iconified. The window can be recovered through the window-list. If _Icon_ is set without an argument then the _NoIcon_ attribute is cleared but no icon is specified. An example which allows only the *FvwmPager* module icon to exist: + .... Style * NoIcon Style FvwmPager Icon .... + _IconBox_ takes no argument, four numeric arguments (plus optionally a screen specification), an X11 geometry string or the string "none": + .... IconBox [screen scr-spec] l t r b .... + or + .... IconBox geometry .... + Where _l_ is the left coordinate, _t_ is the top, _r_ is right and _b_ is bottom. Negative coordinates indicate distance from the right or bottom of the screen. If the first argument is the word _screen_, the _scr-spec_ argument specifies the RandR screen on which the IconBox is defined ´or the additional 'w' for the screen where the window center is located. This is only useful with multiple 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 RandR isused. This designates the screen where the window center is located. The additional screen specifier is not allowed anywhere else. + If you never define an icon box, or you fill all the icon boxes, fvwm has a default icon box that covers the screen, it fills top to bottom, then left to right, and has an 80x80 pixel grid. To disable all but the default icon box you can use IconBox without arguments in a separate *Style* command. To disable all icon boxes including the default icon box, the argument "none" can be specified. + Hint: You can auto arrange your icons in the icon box with a simple fvwm function. Put the "DeiconifyAndRearrange" function below in your configuration file: + .... AddToFunc DeiconifyAndRearrange + C Iconify off + C All (CurrentPage, Iconic) PlaceAgain Icon .... + And then replace all places where you call the *Iconify* command to de-iconify an icon with a call to the new function. For example replace + .... AddToFunc IconFunc + C Iconify off + M Raise + M Move + D Iconify off Mouse 1 I A Iconify off .... + with + .... AddToFunc IconFunc + C DeiconifyAndRearrange + M Raise + M Move + D DeiconifyAndRearrange Mouse 1 I A DeiconifyAndRearrange .... + _IconGrid_ takes 2 numeric arguments greater than zero. + .... IconGrid x y .... + Icons are placed in an icon box by stepping through the icon box using the _x_ and _y_ values for the icon grid, looking for a free space. The default grid is 3 by 3 pixels which gives a tightly packed appearance. To get a more regular appearance use a grid larger than your largest icon. Use the _IconSize_ argument to clip or stretch an icon to a maximum size. An _IconGrid_ definition must follow the *IconBox* definition that it applies to: + .... Style * IconBox -80x240-1-1, IconGrid 90 90 .... + _IconFill_ takes 2 arguments. + .... IconFill Bottom Right .... + Icons are placed in an icon box by stepping through the icon box using these arguments to control the direction the box is filled in. By default the direction is left to right, then top to bottom. This would be expressed as: + .... IconFill left top .... + To fill an icon box in columns instead of rows, specify the vertical direction (top or bottom) first. The directions can be abbreviated or spelled out as follows: "t", "top", "b", "bot", "bottom", "l", "lft", "left", "r", "rgt", "right". An *IconFill* definition must follow the *IconBox* definition that it applies to: + .... Style * IconBox -80x240-1-1, IconFill b r .... + _IconSize_ sets limits on the size of an icon image. Both user-provided and application-provided icon images are affected. + .... IconSize [ width height [ maxwidth maxheight ] ] .... + All arguments are measured in pixels. When all four arguments are passed to _IconSize,_ _width_ and _height_ represent the minimum size of an icon, and _maxwidth_ and _maxheight_ represent the maximum size of an icon. Icon images that are smaller than the minimum size are padded. Icon images that are bigger than the maximum size are clipped. + If only two arguments are passed to _IconSize,_ _width_ and _height_ represent the absolute size of an icon. Icons covered by this style are padded or clipped to achieve the given size. + If no arguments are specified, the default values are used for each dimension. This effectively places no limits on the size of an icon. + The value of "-1" can be used in place of any of the arguments to specify the default value for that dimension. + In addition to the numeric arguments, 1 additional argument can be "Stretched", "Adjusted", or "Shrunk". + Note that module provided icon managers are not affected by this style. + _MiniIcon_ specifies a pixmap to use as the miniature icon for the window. This miniature icon can be drawn in a title-bar button (see *ButtonStyle*), and can be used by various fvwm modules (*FvwmIconMan* and *FvwmPager*). It takes the name of a pixmap as an argument. + _WindowShadeShrinks_ and _WindowShadeScrolls_ control if the contents of a window that is being shaded with the *WindowShade* command are scrolled (default) or if they stay in place. The shrinking mode is a bit faster + The _WindowShadeSteps_ option selects the number of steps for animation when shading a window with *WindowShade*. It takes one number as its argument. If the number has a trailing '_p_' it sets the number of pixels to use as the step size instead of a fixed number of steps. 0 disables the animation. This happens too if the argument is omitted or invalid. + The *WindowShade* command has two modes of operation: busy and lazy shading. Busy shading can be 50% slower than lazy shading, but the latter can look strange under some conditions, for example, if the window borders, buttons or the title are filled with a tiled pixmap. Also, the window handles are not drawn in lazy mode and the border relief may only be drawn partially right before the window reaches the shaded state or tight after leaves the unshaded state. By default, fvwm uses lazy mode if there are no bad visual effects (not counting the window handles) and busy mode otherwise. Use the _WindowShadeAlwaysLazy or WindowShadeBusy_ to force using the lazy or busy mode. The default setting is restored with _WindowShadeLazy_. + _ResizeOpaque_ instructs fvwm to resize the corresponding windows with their contents visible instead of using an outline. Since this causes the application to redraw frequently it can be quite slow and make the window flicker excessively, depending on the amount of graphics the application redraws. The _ResizeOutline_ style (default) negates the _ResizeOpaque_ style. Many applications do not like their windows being resized opaque, e.g. XEmacs, Netscape or terminals with a pixmap background. If you do not like the result, do not use the _ResizeOpaque_ style for these windows. To exempt certain windows from opaque resizing you could use these lines in your configuration file: + .... Style * ResizeOpaque Style rxvt ResizeOutline Style emacs ResizeOutline .... + _Sticky_ makes the window sticky, i.e. it is always visible on each page and each desk. The opposite style, _Slippery_ reverts back to the default. + _StickyIcon_ makes the window sticky when it's iconified. It de-iconifies on top the active desktop. _SlipperyIcon_ reverts back to the default. + _StickyAcrossPages_ and _StickyAcrossPagesIcon_ work like _Sticky_ and _StickyIcon_, but stick the window only across pages, not desks while _StickyAcrossDesks and StickyAcrossDesksIcon_ works the other way round. + Windows that have been marked as _Sticky_ or _StickyAcrossDesks_ or _StickyAcrossPages_ will have stipples drawn on the titlebar. This can be negated with the !_StickyStippledTitle_ style. The style _StickyStippledTitle_ puts back the stipples where that window has also been marked as _Sticky_. Note that this is the default style for _Sticky_ windows. Sticky icons will have stipples drawn on the icon title. This can be disabled in the same way with the !_StickyStippledIconTitle_ style. + Windows with the _StartIconic_ style are shown as icons initially. Note that some applications counteract that by deiconifying themselves. The default is to not iconify windows and can be set with the _StartNormal_ style. + _StickyIcon_ makes the window sticky when it's iconified. It de-iconifies on top the active desktop. _SlipperyIcon_ reverts back to the default. + _StickyIconPage_ works like _StickyIcon_, but sticks the icon only across pages, not desks while _StickyIconDesk_ works the other way round. + _StippledIconTitle_ works like _StippledTitle_ in that it draws stipples on the titles of icons but doesn't make the icon sticky. + _IgnoreRestack_ makes fvwm ignore attempts of clients to raise or lower their own windows. By default, the opposite style, _AllowRestack_ is active. + _FixedPosition_ and _FixedUSPosition_ make fvwm ignore attempts of the user to move the window. It is still possible to move the window by resizing it. To allow the user to move windows, use the _VariablePosition_ or _VariableUSPosition_ style. + _FixedSize_ and _FixedUSSize_ make fvwm ignore attempts of the user to resize the window. To allow the user to resize windows, use the _VariableSize_ or _VariableUSSize_ style. + _FixedPPosition_ and _FixedPSize_ make fvwm ignore attempts of the program to move or resize its windows. To allow this kind of actions, use the _VariablePPosition_ or _VariablePSize_ style. These styles may sometimes affect the initial placement and dimensions of new windows (depending on the application). If windows are created at strange places, try either the _VariablePPosition_ or _!UsePPosition_ styles. The _FixedPSize_ style may screw up window dimensions for some applications. Do Not use this style in this case. + _MoveByProgramMethod_ affects how fvwm reacts to requests by the application to move its windows. By default, fvwm tries to detect which method to use, but it sometimes detects the wrong method. You may come across a window that travels across the screen by a few pixels when the application resizes it, moves to a screen border with the frame decorations off screen, that remembers its position for the next time it starts but appears in a slighly shifted position, or that attepmts to become full screen but has the. Try out both options, _UseGravity_ and _IgnoreGravity_ on the window (and that window only) and see if that helps. By default, fvwm uses the _AutoDetect_ method. Once the method was detected, it is never changed again. As long as fvwm can not detect the proper method, it uses _IgnoreGravity_. To force fvwm to retry the detection, use one of the other two options first and then use _AutoDetect_ again. + Note: This option was introduced to alleviate a problem with the ICCCM specification. The ICCCM clearly states that the _UseGravity_ option should be used, but traditionally applications ignored this rule. + _Closable_ enables the functions *Close*, *Delete* and *Destroy* to be performed on the windows. This is on by default. The opposite, _!Closable_, inhibits the window to be closed. + _Iconifiable_ enables the function *Iconify* to be performed on the windows. This is on by default. The opposite, _!Iconifiable_, inhibits the window from being iconified. + _Maximizable_ enables the function *Maximize* to be performed on the windows. This is on by default. The opposite, _!Maximizable_, inhibits the window from being maximized. + _AllowMaximizeFixedSize_ enables the function *Maximize* to be performed on windows that are not resizable, unless maximization has been disabled either using the style _!Maximizable_ or through WM hints. This is on by default. The opposite, _!AllowMaximizeFixedSize_, inhibits all windows that are not resizable from being maximized. + _ResizeHintOverride_ instructs fvwm to ignore the program supplied minimum and maximum size as well as the resize step size (the character size in many applications). This can be handy for broken applications that refuse to be resized. Do not use it if you do not need it. The default (opposite) style is _NoResizeOverride_. + _MinWindowSize [ width [ p | c ] height [ p | c ] ]_ 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. If the letter '_c_' is appended to either of the values, the numbers are in terms of the client window's size hints, which can be useful for windows such as terminals to specify the number of rows or columns. This command is useful to deal with windows that freak out if their window becomes 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 | c ] height [ p | c ] ]_ 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. If the letter '_c_' is appended to either of the values, the numbers are in terms of the client window's size hints, which can be useful for windows such as terminals to specify the number of rows or columns. This command is useful to force large application windows to be fully visible. Neither _height_ nor _width_ may be less than 100 pixels. If you omit the parameters or their values are invalid, both limits are set to 32767 pixels (which is the default). + With _IconifyWindowGroups_ all windows in the same window group are iconified and deiconified at once when any window in the group is (de)iconified. The default is _IconifyWindowGroupsOff_, which disables this behavior. Although a number of applications use the window group hint, it is rarely used in a proper way, so it is probably best to use _IconifyWindowGroups_ only for selected applications. + The option _SnapAttraction_ affects interactive window movement: If during an interactive move the window or icon comes within _proximity_ pixels of another the window or icon, it is moved to make the borders adjoin. The default of 0 means that no snapping happens. Calling this command without arguments turns off snap attraction and restores the default behavior. Please refer also to the _SnapGrid_ option. + The second argument optional and may be set to one of the five following values: With _All_ both icons and windows snap to other windows and other icons. _SameType_ lets windows snap only to windows, and icons snap only to icons. With _Windows_ windows snap only to other windows. Similarly with _Icons_ icons snap only to other icons. With _None_ no snapping takes place. This option can be useful in conjunction with the thirs 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: + * With _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. The option _SnapGrid_ defines an invisible grid on the screen. During an interactive move a window or icon is positioned such that its location (top left corner) is coincident with the nearest grid point. The default _x-grid-size_ and _y-grid-size_ setting are both 1, which is effectively no grid all. An interactive move with both _SnapGrid_ and _SnapAttraction_ results in the window being moved to be adjacent to the nearest window border (if within snap proximity) or grid position. The window moves the shortest distance possible to satisfy both _SnapGrid_ and _SnapAttraction_. Note that the x and y coordinates are not coupled. For example, a window may snap to another window on the x axis while snapping to a grid point on the y axis. Using this style without arguments reinstates the default settings. The styles _EdgeMoveDelay_ and _EdgeResizeDelay_ define how hard it is to change the desktop viewport by moving or resizing a window over the edge of the screen. The parameter tells how many milliseconds the pointer must spend on the screen edge before fvwm moves the viewport. The command *EdgeScroll* determines how far the viewport is scrolled. If -1 is given as the delay, page flipping is disabled completely. The defaults are no delay for moving (0) and no flipping for resizing (-1). Using these styles without any argument restores the default settings. Note that, with .... EdgeScroll 0 0 .... it is still possible to move or resize windows across the edge of the current screen. See also *EdgeThickness*. The option _EdgeMoveResistance_ makes it easier to place a window directly adjacent to a RandR screen's edge. It takes one or two parameters. The first parameter tells how many pixels over an outside 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 inside edges (shared edge between two RandR monitors). If omitted, there is no resistance between inside edges. Note that the center of the window being moved determines the screen on which the window should be kept. Both values are 0 (no resistance) by default. To restore the defaults, the option _EdgeMoveResistance_ can be used without any parameters. The option _InitialMapCommand_ allows for any valid fvwm command or function to run when the window is initially mapped by fvwm. Example: .... Style MyWindow StartsOnPage 0 0, InitialMapCommand Iconify .... This would hence place the window called _MyWindow_ on page 0 0 for the current desk, and immediately run the *Iconify* command on that window. Note that should _InitialMapCommand_ be used as a global option for all windows, but there is a need that some windows should not have this command applied, then an action of *Nop* can be used on those windows, as in the following example: .... Style * InitialMapCommand Iconify Style XTeddy InitialMapCommand Nop .... *Window Manager placement*:: Applications can place windows at a particular spot on the screen either by window manager hints or a geometry specification. When they do neither, then the window manager steps in to find a place for the window. Fvwm knows several ways to deal with this situation. The default is _TileCascadePlacement_. + _PositionPlacement_ [__Center__|__UnderMouse__|_move-arguments_] When used without an argument, new windows are placed in the top left corner of the display. With the argument _Center_, all new window appear at the center of the screen, and with _UnderMouse_, windows are centered under the mouse pointer where possible. If the window is unable to fit on the screen because the pointer is at the edge of the screen, then the window is forced on-screen using this option. If any other _move-arguments_ are given, they are interpreted exactly as the *Move* command does (with the exception that references to the current window position do not work as the window has not been placed yet). + _CascadePlacement_ automatically place new windows in a cascading fashion. + _TileCascadePlacement_ automatically places new windows in a smart location - a location in which they do not overlap any other windows on the screen. If no such position can be found _CascadePlacement_ is used as a fall-back method. + _TileManualPlacement_ This is the same as _TileCascadePlacement_, but uses _ManualPlacement_ as the fall-back method. + _MinOverlapPlacement_ automatically places new windows in a location in which the overlapping area in pixels of other windows is minimized. By default this placement policy tries to avoid overlapping icons and windows on higher layers. This can be configured with the _MinOverlapPlacementPenalties_ style. + _MinOverlapPercentPlacement_ is similar to _MinOverlapPlacement_ but tries to minimize the overlapped percentages of other windows instead of the overlapped area in pixels. This placement policy tries to avoid covering other windows completely and tries even harder not to cover small windows. This can be configured with the _MinOverlapPlacementPenalties_ and _MinOverlapPercentPlacementPenalties_ styles. + _MinOverlapPlacementPenalties_ takes at most 6 positive or null decimal arguments: + .... normal ontop icon sticky below strut .... + if trailing arguments are missing the default is used which is: + .... 1 5 10 1 0.05 50 .... + To reset this style to the default values, prefix it with a '!'. This style configures the _MinOverlapPlacement_ and _MinOverlapPercentPlacement_ placement policy. The _normal_ factor affects normal windows, the _ontop_ factor affects windows with a greater layer than the window being placed, the _icon_ factor affects icons, the _sticky_ factor affects sticky windows, the _below_ factor affects windows with a smaller layer than the window being placed, the _strut_ factor affects the complement of the EWMH working area if the window being placed has the _EWMHPlacementUseWorkingArea_ style and windows with an EWMH strut hint (i.e., a "please do not cover me" hint) if the window being placed has the _EWMHPlacementUseDynamicWorkingArea_ style. These factors represent the amount of area that these types of windows (or area) are counted as, when a new window is placed. For example, by default the area of ontop windows is counted 5 times as much as normal windows. So _MinOverlapPlacement_ and _MinOverlapPercentPlacement_ covers 5 times as much area of another window before it will cover an ontop window. To treat ontop windows the same as other windows, set this to 1. To really, really avoid putting windows under ontop windows, set this to a high value, say 1000. This style affects the window already mapped and not the window which is currently placed. There is one exception to this rule: in the case of the window being placed has the _EWMHPlacementUseWorkingArea_ style the _strut_ factor affects the placed window. + _MinOverlapPercentPlacementPenalties_ takes at most 4 positive or null integer arguments: + .... cover_100 cover_95 cover_85 cover_75 .... + if trailing arguments are missing the defaults are used which are: + .... 12 6 4 1 .... + To reset this style to the default values, prefix it with a '!'. This style affects the _MinOverlapPercentPlacement_ placement policy and is similar to the _MinOverlapPlacementPenalties_ style. The _cover_xx_ factor is used when the window being placed covers at least _xx_ percent of the window. This factor is added to the factor determined by the _MinOverlapPlacementPenalties_ style. + _ManualPlacement_ (aka active placement). The user is required to place every new window manually. The window only shows as a rubber band until a place is selected manually. The window is placed when a mouse button or any key except _Escape_ is pressed. Escape aborts manual placement which places the window in the top left corner of the screen. If mouse button 2 is pressed during the initial placement of a window (respectively _Shift_ and mouse button 1 in case Mwm emulation has been enabled with the *Emulate* command), the user is asked to resize the window too. + It is possible to define buttons usable to place windows with the *Move* command and the special context 'P' for placement (see *Move* command). However, you can't redefine the way to also resize the window other than the way it is affected by the *Emulate* command. The button used for placing the window can be checked with the _PlacedByButton_ condition (see *Current* command). + Example: + .... Style * ManualPlacement *FvwmEvent: PassID *FvwmEvent: add_window GrowDownFunc AddToFunc StartFunction + I FvwmEvent AddToFunc GrowDownFunc + I windowid $0 (PlacedByButton 3) \ Resize bottomright keep -0p .... + Now, whenever a window is created and the user presses button 3 to finish initial placement, the window is automatically enlarged until it hits the bottom screen border. + _Old placement styles_ DumbPlacement / SmartPlacement / SmartPlacementOff, CleverPlacement / CleverPlacementOff, ActivePlacement / RandomPlacement, ActivePlacementsHonorsStartsOnPage / ActivePlacementsHonorsStartsOnPageOff are still supported but will be removed in the future. The old and new styles can be translated according to the following table: + .... Style * DumbPlacement, RandomPlacement --> Style * CascadePlacement Style * DumbPlacement, ActivePlacement --> Style * ManualPlacement Style * SmartPlacement, \ RandomPlacement, CleverPlacementOff --> Style * TileCascadePlacement Style * SmartPlacement, \ ActivePlacement, CleverPlacementOff --> Style * TileManualPlacement Style * SmartPlacement, CleverPlacement --> Style * MinOverlapPlacement Style * SmartPlacement, \ ActivePlacement, CleverPlacement --> Style * MinOverlapPercentPlacement Style * ActivePlacementsHonorsStartsOnPage --> Style * ManualPlacementsHonorsStartsOnPage Style * ActivePlacementsHonorsStartsOnPageOff --> Style * ManualPlacementsHonorsStartsOnPageOff .... *Placement policy options and window stacking*:: _!UsePPosition_ instructs fvwm to ignore the program specified position (PPosition hint) when adding new windows. Using PPosition is required for some applications, but if you do not have one of those it's a real headache. Many programs set PPosition to something obnoxious like 0,0 (upper left corner). Note: _!UsePPosition_ is equivalent to the deprecated option _!UsePPosition_ + _!UseUSPosition_ works like _!UsePPosition_ but applies suppresses using the user specified position indicated by the program (USPosition hint). It is generally a bad thing to override the user's choice, but some applications misuse the USPosition hint to force their windows to a certain spot on the screen without the user's consent. Note: _!UseUSPosition_ is equivalent to the deprecated option _!USPosition_ + _NoUseTransientPPosition_ and _UseTransientPPosition_ work like _!UsePPosition_ and _UsePPosition_ but apply only to transient windows. Note: _!UseTransientPPosition_ is equivalent to the deprecated option _!TransientPPosition_ + _NoUseIconPosition_ instructs fvwm to ignore the program specified icon position (IconPosition hint) when iconifying the window. Note: _!UseIconPosition_ is equivalent to the deprecated option _!IconPosition_ + _StartsOnDesk_ takes a numeric argument which is the desktop number on which the window should be initially placed. Note that standard Xt programs can also specify this via a resource (e.g. "-xrm '*Desk: 1'"). + _StartsOnPage_ takes 1, 2, or 3 numeric arguments. If one or three arguments are given, the first (or only) argument is the desktop number. If three arguments are given, the 2nd and 3rd arguments identify the x,y page position on the virtual window. If two arguments are given, they specify the page position, and indicate no desk preference. If only one argument is given, _StartsOnPage_ functions exactly like _StartsOnDesk_. For those standard Xt programs which understand this usage, the starting desk/page can also be specified via a resource (e.g., "-xrm '*page: 1 0 2'"). _StartsOnPage_ in conjunction with _SkipMapping_ is a useful technique when you want to start an app on some other page and continue with what you were doing, rather than waiting for it to appear. + _StartsOnScreen_ takes one argument. It must be a valid RandR name. A new window is placed on the specified screen. The default is to place windows on the screen that contains the mouse pointer at the time the window is created. However, those windows which are not placed by fvwm (i.e., those with a USPosition hint from a user specified geometry) are normally placed in a position relative to all identified screens. + _StartsOnPageIncludesTransients_ causes the _StartsOnPage_ style to be applied even for transient windows. This is not usually useful, since transients are usually pop ups that you want to appear in your visible viewport; but occasionally an application uses a transient for something like a startup window that needs to be coerced into place. + _ManualPlacementIgnoresStartsOnPage_ suppresses _StartsOnPage_ or _StartsOnDesk_ placement in the event that both _ManualPlacement_ and _SkipMapping_ are in effect when a window is created. This prevents you from interactively placing a window and then wondering where it disappeared to, because it got placed on a different desk or page. _ManualPlacementHonorsStartsOnPage_ allows this to happen anyway. The option has no effect if _SkipMapping_ is not in effect, because fvwm switches to the proper desk/page to perform interactive placement. The default is _ManualPlacementIgnoresStartsOnPage_; _ManualPlacementHonorsStartsOnPage_ matches the way the old _StartsOnDesk_ style used to handle the situation. + _CaptureHonorsStartsOnPage_ causes the initial capture (of an already existing window) at startup to place the window according to the _StartsOnPage_ and _StartsOnScreen_ desk, page and screen specification. _CaptureIgnoresStartsOnPage_ causes fvwm to ignore these settings (including _StartsOnDesk_) on initial capture. The default is _CaptureIgnoresStartsOnPage_. + _RecaptureHonorsStartsOnPage_ causes a window to be placed according to, or revert to, the _StartsOnPage_ and _StartsOnScreen_ desk, page and screen specification on *Restart*. _RecaptureIgnoresStartsOnPage_ causes fvwm to respect the current window position on *Restart*. The default is _RecaptureIgnoresStartsOnPage_. + _Layer_ accepts one optional argument: a non-negative integer. This is the layer the window is put in. If no argument is given, any previously set value is deleted and the default layer is implied. + _StaysOnTop_ puts the window in the top layer. This layer can be changed by the command *DefaultLayers*; the default is 6. + _StaysPut_ puts the window in the put layer. This layer can be changed by the command *DefaultLayers*; the default is 4. + _StaysOnBottom_ puts the window in the bottom layer. This layer can be changed by the command *DefaultLayers*; the default is 2. + _StartsLowered_ instructs fvwm to put the window initially at the bottom of its layer rather than the default _StartsRaised_. + _StartShaded_ tells fvwm to shade the window. An optional direction argument may be given, which can be one of "_North_", "_South_", "_West_", "_East_", "_NorthWest_", "_NorthEast_", "_SouthWest_", "_SouthEast_" or if no direction is given, the default is to shade north. + _SkipMapping_ tells fvwm not to switch to the desk the window is on when it gets mapped initially (useful with _StartsOnDesk_ or _StartsOnPage_). + _KeepWindowGroupsOnDesk_ makes new windows that have the window group hint set appear on the same desk as the other windows of the same group. Since this behavior may be confusing, the default setting is _ScatterWindowGroups_. The window group hint is ignored when placing windows in this case. *Transient windows*:: _DecorateTransient_ causes transient windows, which are normally left undecorated, to be given the usual fvwm decorations (title bar, buttons, etc.). Note that some pop-up windows, such as the xterm menus, are not managed by the window manager and still do not receive decorations. _NakedTransient_ (the default) causes transient windows not to be given the standard decorations. You can only bind keys or mouse buttons to the sides and the client part of an undecorated window ('S' and ´W' contexts in bindings, see *Mouse* and _Key_ commands). + A window with the _RaiseTransient_ style that has transient windows raises all its transients when it is raised. The _DontRaiseTransient_ style disables this behavior. All windows are then treated as if they had no transients. + A window with the _LowerTransient_ style that has transient windows lowers all its transients when it is lowered. The _DontLowerTransient_ style disables this behavior. All windows are then treated as if they had no transients. + The _StackTransientParent_ style augments _RaiseTransient_ and _LowerTransient_ styles. Raising a window with _StackTransientParent_ style transfers the raise action to the main window if the window being raised is a transient and its main window has _RaiseTransient_ style; this effect makes raise on a transient act just like raise on its main - the whole group is raised. Similar behavior holds for lowering a whole group of transients when the main has _LowerTransient_ style. _DontStackTransientParent_ turns this behavior off. _(Dont)StackTransientParent_ has no effect if _RaiseTransient_ and _LowerTransient_ are not used. + A reasonable emulation of Motif raise/lower on transients is possible like this + .... Style * RaiseTransient Style * LowerTransient Style * StackTransientParent .... *Extended Window Manager Hints styles*:: To understand the used terminology in this sub section, please read the *Extended Window Manager Hints* section. + _EWMHDonateIcon_ instructs fvwm to set the application ewmh icon hint with the icon that is used by fvwm if the application does not provide such hint (and if the icon used by fvwm is not an icon window). _EWMHDonateMiniIcon_ does the same thing for mini icons. This allows compliant pager, taskbar, iconbox ...etc to display the same (mini) icons as fvwm. Note that on some hardware (e.g., 8-bit displays) these styles can slow down window mapping and that in general only one of these styles is needed by a compliant application. _EWMHDontDonateIcon_ and _EWMHDontDonateMiniIcon_ restore the defaults which are to not set any ewmh (mini) icons hints. + By default, if an application provides an ewmh icon hint of small size (i.e., height and width less than or equal to 22), then fvwm uses this icon as its mini icon. _EWMHMiniIconOverride_ instructs fvwm to ignore ewmh icons and to use the mini icon provided by the _MiniIcon_ style. _EWMHNoMiniIconOverride_ restores the default. + _EWMHUseStackingOrderHints_ causes fvwm to use EWMH hints and respect EWMH hints which change the window layer. _EWMHIgnoreStackingOrderHints_ causes fvwm to ignore EWMH layer hints. + An application can ask for some reserved space on the desktop by a hint. In the EWMH terminology such a hint is called a strut and it is used to compute the working area and may be used for window placement and in the maximize command. _EWMHIgnoreStrutHints_ causes fvwm to ignore such hints, as _EWMHUseStrutHints_, causes fvwm to use it which is the default. + _EWMHIgnoreStateHints_ causes fvwm to ignore initial EWMH state hints when a new window is mapped. The default _EWMHUseStateHints_ causes fvwm to accept such hints. + _EWMHIgnoreWindowType_ causes fvwm to ignore EWMH window type specification. The default _!EWMHIgnoreWindowType_ causes fvwm to style windows of specified types as such. + _EWMHMaximizeIgnoreWorkingArea_ causes fvwm to ignore the EWMH working area when it executes a *Maximize* command. With _EWMHMaximizeUseWorkingArea_ the EWMH working area is used as with _EWMHMaximizeUseDynamicWorkingArea_ the EWMH dynamic working area is used (the default). + _EWMHPlacementIgnoreWorkingArea_ causes fvwm to ignore the EWMH working area when it places (or places again) a window. With _EWMHPlacementUseWorkingArea_ the EWMH working area is taken in account as with _EWMHPlacementUseDynamicWorkingArea_ the EWMH dynamic working area is taken in account (the default). Note that with the _MinOverlapPlacement_ and _MinOverlapPercentPlacement_ placement policy, the way the EWMH (dynamic) working area is taken in account is configurable with the _MinOverlapPlacementPenalties_ style. *Miscellaneous*:: The _BackingStore_, _BackingStoreOff_ and _BackingStoreWindowDefault_ determine if the X server uses backing store for the window or not. _BackingStore_ means that the X server tries to keep the obscured parts of a window in memory. This is usually slower if the client runs on the same machine as the X server, but can be much faster if the connection is slow (see also _SaveUnder_ below). _BackingStoreOff_ disables backing store for the window. By default, fvwm does not enable or disable backing store itself but leaves is as the window requested it. To revert back to the application's choice, use the _BackingStoreWindowDefault_ style. + Note: This style is useless if the X server does not allow backing store. + _SaveUnder_ enables the corresponding window attribute in the X server. For a window using this style, the X server tries to store the graphics below it in memory which is usually slower if the client runs on the same machine as the X server. _SaveUnder_ may speed up fvwm if the connection to the X server is slow (e.g. over a modem link). To disable save under, use the _SaveUnderOff_ style. This is the default. See also _BackingStore_ above. + Note: This style is useless if the X server does not allow save under. + _ParentalRelativity_ enables clients that use a background pixmap of type _ParentRelative_ to achieve transparency. Fvwm modules that support transparent colorsets require this setting. _Opacity_ is the default and should be used for all non-transparent clients for better performance. + _MwmDecor_ makes fvwm attempt to recognize and respect the mwm decoration hints that applications occasionally use. To switch this style off, use the _NoDecorHint_ style. + _MwmFunctions_ makes fvwm attempt to recognize and respect the mwm prohibited operations hints that applications occasionally use. _HintOverride_ makes fvwm shade out operations that mwm would prohibit, but it lets you perform the operation anyway. _NoFuncHint_ allows turns off the mwm hints completely. + _OLDecor_ makes fvwm attempt to recognize and respect the olwm and olvwm hints that many older XView and OLIT applications use. Switch this option off with _NoOLDecor_. + _UseDecor_ This style is deprecated and will be removed in the future. There are plans to replace it with a more flexible solution in fvwm-3.0. + _UseDecor_ accepts one argument: the name of a decor created with *AddToDecor*. If no decor name is specified, the "Default" decor is used. Windows do not actually contain decors, but are always assigned to one. If the decor is later modified with *AddToDecor*, the changes are visible for all windows which are assigned to it. The decor for a window can be reassigned with *ChangeDecor*. + _UseStyle_ This style is deprecated and will be removed in the future. There are plans to replace it with a more flexible solution in fvwm-3.0. + _UseStyle_ takes one arg, which is the name of another style. That way you can have unrelated window names easily inherit similar traits without retyping. For example: + .... Style rxvt UseStyle XTerm .... + Warning: If a style is built from one or more parent styles and the parent styles are changed, the derived style is not modified. To achieve this you have to issue the _UseStyle_ line again. + _Unmanaged_ Windows with the _Unmanaged_ style option are ignored by fvwm. They are not decorated, can not be moved or resized, etc. You probably want to use *Bugopts RaiseOverUnmanaged* too. This option can be turned off with the _!Unmanaged_ style. + _State_ sets the initial value of one of the 32 user defined states which are associated with each window. The state number ranges from 0 to 31 and must be given as an argument. The states have no meaning in fvwm, but they can be checked in conditional commands like *Next* with the _State_ condition and manipulated with the *State* command. + .... # turn on state 11 for xterms ... Style xterm State 11 # ... but not for rxvts. Style rxvt !State 11 .... + Windows with the _WindowListSkip_ styles do not appear in the menu that is created with the *WindowList* command or the lists shown in modules like *FvwmIconMan*. In the modules, the style can usually be ignored with an option. Please refer to the man page of the module in question for further information. To disable this feature, use the default style _WindowListHit_. + The styles _CirculateSkip_ and _CirculateHit_ control whether the window is considered by conditional commands, for example *Next*, _Prev_ or _All_. Windows with _CirculateSkip_, are never selected by conditional commands. However, the styles can be overridden explicitly in the condition with the _CirculateHit_, _CirculateHitIcon_ or _CirculateHitShaded_ conditions, and some conditional commands, e.g. *Current* and _All_, do this by default. The styles _CirculateSkipIcon_, _CirculateHitIcon_, _CirculateSkipShaded_ and _CirculateHitShaded_ work like _CirculateSkip_ and _CirculateHit_ but apply only to iconic or shaded windows. Note: if multiple ...Skip... options are combined, windows are only selected if they match none of the given conditions. So, with + .... Style * CirculateSkipIcon, CirculateSkipShaded .... + only windows that are neither iconic nor shaded are selected. Note: For historical reasons, the conditional commands understand the names of these styles as condition names. Take care not to confuse them. *Examples*:: .... # Change default fvwm behavior to no title- # bars on windows! Also define a default icon. Style * !Title, \ Icon unknown1.xpm, \ BorderWidth 4, \ HandleWidth 5 # now, window specific changes: Style Fvwm* !Handles, Sticky, \ WindowListSkip, \ BorderWidth 0 Style FvwmPager StaysOnTop, BorderWidth 0 Style *lock !Handles, Sticky, \ StaysOnTop, WindowListSkip Style xbiff Sticky, WindowListSkip Style FvwmButtons !Handles, Sticky, \ WindowListSkip Style sxpm !Handles # Put title-bars back on xterms only! Style xterm Title, Color black/grey Style rxvt Icon term.xpm Style xterm Icon rterm.xpm Style xcalc Icon xcalc.xpm Style xbiff Icon mail1.xpm Style xmh Icon mail1.xpm, \ StartsOnDesk 2 Style xman Icon xman.xpm Style matlab Icon math4.xpm, \ StartsOnDesk 3 Style xmag Icon magnifying_glass2.xpm Style xgraph Icon graphs.xpm Style FvwmButtons Icon toolbox.xpm Style Maker StartsOnDesk 1 Style signal StartsOnDesk 3 # Fire up Netscape on the second desk, in the # middle of my 3x3 virtual desktop, and do not # bother me with it... Style Netscape* SkipMapping, \ StartsOnPage 1 1 1 .... Note that all properties for a window are or'ed together. In the above example "FvwmPager" gets the property _StaysOnTop_ via an exact window name match but also gets _!Handles_, _Sticky_ and _WindowListSkip_ by a match to "Fvwm*". It gets _!Title_ by virtue of a match to "*". If conflicting styles are specified for a window, then the last style specified is used. *WindowStyle* _options_:: sets attributes (styles) on the selected window. The _options_ are exactly the same as for the *Style* command. === Window Styles *AddButtonStyle* button [_state_] [_style_] [-- +++[!]+++_flag_ ...]:: Adds a button style to _button_. _button_ can be a button number, or one of "_All_", "_Left_" or "_Right_". _state_ can be "_ActiveUp_", "_ActiveDown_", "_InactiveUp_" or "_InactiveDown_", or "_Active_" (the same as both "ActiveUp" and "ActiveDown") or "_Inactive_" (the same as both "InactiveUp" and "InactiveDown") or any of these 6 with "_Toggled_" prepended. The "Active" states apply to the focused window, the "Inactive" ones apply to all other windows. The "Up" states apply to the non pressed buttons, the "Down" ones apply to pressed buttons. The "Toggled" prefix refers to maximized, shaded or sticky windows that have the corresponding _MwmDecor..._ button style set. Additionally, the following shortcuts may be used: "_AllNormal_", "_AllToggled_", "_AllActive_", "_AllInactive_", "_AllUp_", "_AllDown_". They are actually different masks for 4 individual states from 8 total. These are supported too: "_AllActiveUp_", "_AllActiveDown_", "_AllInactiveUp_", "_AllInactiveDown_". + If _state_ is omitted, then the style is added to every state. If the _style_ and _flags_ are enclosed in parentheses, then multiple _state_ definitions can be placed on a single line. _Flags_ for additional button styles cannot be changed after definition. + Buttons are drawn in the order of definition, beginning with the most recent button style, followed by those added with *AddButtonStyle*. To clear the button style stack, change style flags, or for descriptions of available styles and flags, see the *ButtonStyle* command. + Examples: + .... **ButtonStyle** 1 Pixmap led.xpm -- Top Left **ButtonStyle** 1 ActiveDown HGradient 8 grey black **ButtonStyle All** -- UseTitleStyle AddButtonStyle 1 \ ActiveUp (Pixmap a.xpm) \ ActiveDown (Pixmap b.xpm -- Top) AddButtonStyle 1 Vector 4 50x30@1 70x70@0 30x70@0 50x30@1 .... + Initially for this example all button states are set to a pixmap. The second line replaces the "ActiveDown" state with a gradient (it overrides the pixmap assigned to it in the line before, which assigned the same style to every state). Then, the _UseTitleStyle_ flag is set for all buttons, which causes fvwm to draw any styles set with *TitleStyle* before drawing the buttons. Finally, *AddButtonStyle* is used to place additional pixmaps for both "ActiveUp" and "ActiveDown" states and a vector button style is drawn on top of all states. *AddTitleStyle* [_state_] [_style_] [-- +++[!]+++_flag_ ...]:: Adds a title style to the title-bar. _state_ can be "_ActiveUp_", "_ActiveDown_", "_InactiveUp_" or "_InactiveDown_", or "_Active_" (the same as both "ActiveUp" and "ActiveDown") or "_Inactive_" (the same as both "InactiveUp" and "InactiveDown") or any of these 6 with "Toggled" prepended. If _state_ is omitted, then the style is added to every state. If the _style_ and _flags_ are enclosed in parentheses, then multiple _state_ definitions can be placed on a single line. This command is quite similar to the *AddButtonStyle* command. + Title-bars are drawn in the order of definition, beginning with the most recent *TitleStyle*, followed by those added with *AddTitleStyle*. To clear the title style stack, change style flags, or for the descriptions of available styles and flags, see the *TitleStyle* and *ButtonStyle* commands. *AddToDecor* _decor_:: This command is deprecated and will be removed in the future. There are plans to replace it with a more flexible solution in fvwm-3.0. + Add or divert commands to the decor named _decor_. A decor is a name given to the set of commands which affect button styles, title-bar styles and border styles. If _decor_ does not exist it is created; otherwise the existing _decor_ is modified. Note: Earlier versions allowed to use the *HilightColor*, *HilightColorset* and *WindowFont* commands in decors. This is no longer possible. Please use the *Style* command with the _Hilight..._ and _Font_ options. + New decors start out exactly like the "default" decor without any style definitions. A given decor may be applied to a set of windows with the _UseDecor_ option of the *Style* command. Modifying an existing decor affects all windows which are currently assigned to it. + *AddToDecor* is similar in usage to the *AddToMenu* and *AddToFunc* commands, except that menus and functions are replaced by *ButtonStyle*, *AddButtonStyle*, *TitleStyle*, *AddTitleStyle* and *BorderStyle* commands. Decors created with *AddToDecor* can be manipulated with *ChangeDecor*, *DestroyDecor*, *UpdateDecor* and the *Style* option. + The following example creates a decor "FlatDecor" and style "FlatStyle". They are distinct entities: + .... AddToDecor FlatDecor + ButtonStyle All Active (-- flat) Inactive (-- flat) + TitleStyle -- flat + BorderStyle -- HiddenHandles NoInset Style FlatStyle \ UseDecor FlatDecor, HandleWidth 4, Colorset 0, HilightColorset 1 Style xterm UseStyle FlatStyle .... + An existing window's decor may be reassigned with *ChangeDecor*. A decor can be destroyed with *DestroyDecor*. + .... DestroyDecor FlatDecor AddToDecor FlatDecor ... Style FlatStyle UseDecor FlatDecor .... + and now apply the style again: + .... Style xterm UseStyle FlatStyle .... *BorderStyle* _state_ [_style_] [-- +++[!]+++_flag_ ...]:: Defines a border style for windows. _state_ can be either "_Active_" or "_Inactive_". If _state_ is omitted, then the style is set for both states. If the _style_ and _flags_ are enclosed in parentheses, then multiple _state_ definitions can be specified per line. + _style_ is a subset of the available button styles, and can only be _TiledPixmap_ (uniform pixmaps which match the bevel colors work best this way) or _Colorset_. If a '!' is prefixed to any _flag_, the behavior is negated. If _style_ is not specified, then one can change flags without resetting the style. + The _HiddenHandles_ flag hides the corner handle dividing lines on windows with handles (this option has no effect for !_Handles_ windows). By default, _HiddenHandles_ is disabled. + The _NoInset_ flag supplements _HiddenHandles_. If given, the inner bevel around the window frame is not drawn. If _HiddenHandles_ is not specified, the frame looks a little strange. + _Raised_ causes a raised relief pattern to be drawn (default). _Sunk_ causes a sunken relief pattern to be drawn. _Flat_ inhibits the relief pattern from being drawn. + To decorate the active and inactive window borders with a textured pixmap, one might specify: + .... BorderStyle Active TiledPixmap marble.xpm BorderStyle Inactive TiledPixmap granite.xpm BorderStyle Active -- HiddenHandles NoInset .... + To clear the style for both states: + .... BorderStyle Simple .... + To clear for a single state: + .... BorderStyle Active Simple .... + To unset a flag for a given state: + .... BorderStyle Inactive -- !NoInset .... + title-bar buttons can inherit the border style with the _UseBorderStyle_ flag (see *ButtonStyle*). *ButtonState* [ActiveDown _bool_] [Inactive _bool_] [InactiveDown _bool_]:: The *ButtonState* command controls which states of the window titles and title buttons are used. The default is to use all four states: "ActiveUp", "ActiveDown", "InactiveUp" and "InactiveDown" (see *ButtonStyle* and *TitleStyle* commands). The _bool_ argument after the key word controls if the designated state is used ("True") or not ("False"). The _bool_ flag is the same as other commands, and not limited to just "True" or "False"; "Yes" and "No" may also be used. The "ActiveUp" state cannot be deactivated. If no arguments are provided or the given arguments are invalid, the default is restored. + If _ActiveDown_ argument is "False", no different button style for the pressed down buttons used, instead "ActiveUp" state is used even when button is pressed. + If _Inactive_ argument is "False", focused and unfocused windows look similarly, the corresponding "Active" states are always used. + If _InactiveDown_ argument is "False" (only applied when _Inactive_ is "True"), the pressed titles and title buttons in non-focused windows are drawn using "InactiveUp" or "ActiveUp" states depending on the values of the other key words. *ButtonStyle* button [_state_] [_style_] [-- +++[!]+++_flag_ ...]:: Sets the button style for a title-bar button. _button_ is the title-bar button number between 0 and 9, or one of "_All_", "_Left_", "_Right_", or "_Reset_". Button numbering is described in the *Mouse* command section. If the _style_ and _flags_ are enclosed in parentheses, then multiple _state_ definitions can be specified per line. + _state_ refers to which button state should be set. Button states are defined as follows: "_ActiveUp_" and "_ActiveDown_" refer to the un-pressed and pressed states for buttons on active windows; while the "_InactiveUp_" and "_InactiveDown_" states denote buttons on inactive windows. The shortcut "_Active_" denotes both "ActiveUp" and "ActiveDown" states. Shortcut "_Inactive_" denotes both "InactiveUp" and "InactiveDown" states. The similar state names like just described, but with the "Toggled" prefix are used instead for title buttons which have one of the _MwmDecorMax_, _MwmDecorShade_, _MwmDecorStick_ or _MwmDecorLayer_ hints, if the window is maximized, shaded, sticky or placed on specific layer, respectively. + .... AddToDecor Default + ButtonStyle 6 \ Vector 4 50x25@1 85x75@0 15x75@0 50x25@1 + ButtonStyle 6 ToggledActiveUp \ Vector 4 50x75@0 85x25@1 15x25@0 50x75@0 + ButtonStyle 6 ToggledActiveDown \ Vector 4 50x75@0 85x25@1 15x25@0 50x75@0 + ButtonStyle 6 ToggledInactive \ Vector 4 50x75@0 85x25@1 15x25@0 50x75@0 + ButtonStyle 6 - MwmDecorShade Mouse 0 6 N WindowShade .... + Additionally, the following shortcuts may be used: "_AllNormal_", "_AllToggled_", "_AllActive_", "_AllInactive_", "_AllUp_", "_AllDown_". They are actually different masks for 4 individual states from 8 total. These are supported too: "_AllActiveUp_", "_AllActiveDown_", "_AllInactiveUp_", "_AllInactiveDown_". + If _state_ is specified, that particular button state is set. If _state_ is omitted, every state is set. Specifying a style destroys the current style (use *AddButtonStyle* to avoid this). + If _style_ is omitted, then state-dependent flags can be set for the primary button style without destroying the current style. Examples (each line should be considered independent): + .... ButtonStyle Left -- flat ButtonStyle All ActiveUp (-- flat) Inactive (-- flat) .... + The first line sets every state of the left buttons to flat, while the second sets only the "ActiveUp" and "Inactive" states of every button to flat (only flags are changed; the buttons' individual styles are not changed). + If you want to reset all buttons to their defaults: + .... ButtonStyle Reset .... + To reset the "ActiveUp" button state of button 1 to the default: + .... ButtonStyle 1 ActiveUp Default .... + To reset all button states of button 1 to the default of button number 2: + .... ButtonStyle 1 Default 2 .... + For any button, multiple _state_ definitions can be given on one line by enclosing the _style_ and _flags_ in parentheses. If only one definition per line is given the parentheses can be omitted. + _flags_ affect the specified _state_. If a '!' is prefixed to any _flag_, its behavior is negated. The available state-dependent flags for all styles are described here (the *ButtonStyle* entry deals with state-independent flags). + _Raised_ causes a raised relief pattern to be drawn. + _Sunk_ causes a sunken relief pattern to be drawn. + _Flat_ inhibits the relief pattern from being drawn. + _UseTitleStyle_ causes the given button state to render the current title style before rendering the buttons' own styles. The _Raised_, _Flat_ and _Sunk_ *TitleStyle* flags are ignored since they are redundant in this context. + _UseBorderStyle_ causes the button to inherit the decorated *BorderStyle* options. + _Raised_, _Sunk_ and _Flat_ are mutually exclusive, and can be specified for the initial *ButtonStyle* only. _UseTitleStyle_ and _UseBorderStyle_ are also mutually exclusive (both can be off however). The default is _Raised_ with both _UseBorderStyle and UseTitleStyle_ left unset. + *Important* + for the "ActiveDown" and "InactiveDown" states: When a button is pressed, the relief is inverted. Because of this, to obtain the raised look in "ActiveDown" or "InactiveDown" states you must specify the opposite of the desired relief (i.e. _Sunk_ for "ActiveDown" or "InactiveDown"). This behavior is consistent, but may seem confusing at first. The same applies to the "Toggled" states. + Button styles are classified as non-destructive, partially destructive, or fully destructive. Non-destructive styles do not affect the image. Partially destructive styles can obscure some or all parts of the underlying image (i.e. _Pixmap_). Fully destructive styles obscure the entire underlying image (i.e. _Solid_ or one of the _gradient_ styles). Thus, if stacking styles with *AddButtonStyle* (or *AddTitleStyle* for title-bars), use care in sequencing styles to minimize redraw. + The available styles are: + _Simple_, _Default_, _Solid_, _Colorset_, _Vector_, _?Gradient_, _Pixmap_, _AdjustedPixmap_, _ShrunkPixmap_, _StretchedPixmap_, _TiledPixmap_, _MiniIcon_ + The description of these styles and their arguments follow: + The _Simple_ style does nothing. There are no arguments, and this style is an example of a non-destructive button style. + The _Default_ style conditionally accepts one argument: a number which specifies the default button number to load. If the style command given is *ButtonStyle* or *AddButtonStyle*, the argument is optional (if given, it overrides the current button). If a command other than *ButtonStyle* or *AddButtonStyle* is used, the number must be specified. + The _Solid_ style fills the button with a solid color. The relief border color is not affected. The color is specified as a single argument. This style is fully destructive. + The _Colorset_ _cs_ [_alpha_] style fills the button with the Colorset _cs_. The optional _alpha_ argument is a percentage between 0 and 100. It causes fvwm to merge the colorset background onto the button using this percentage. If the percentage is 0 the colorset background is hidden and if it is 100 the colorset background is fully applied. The default is 100. So, the destructiveness depends on the _alpha_ argument. + The _Vector_ _num_ __X__**[**__offset__**p]x**__Y__**[**__offset__**p]@C ...** style draws a line pattern. Since this is a standard button style, the keyword _Vector_ is optional, _num_ is a number of point specifications of the form __X__**[**__offset__**p]x**__Y__**[**__offset__**p]@C ...** _X_ and _Y_ are point coordinates inside the button, given in percents (from 0 to 100). An optional absolute _offset_ in pixels, can be given as "+p" for a positive or "-p" for a negative offset. + _C_ specifies a line color (0 - the shadow color, 1 - the highlight color, 2 - the background color, 3 - the foreground color, 4 - only move the point, do not draw). The first point color is not used. You can use up to 10000 points in a line pattern. This style is partially destructive. + The specification is a little cumbersome: + .... ButtonStyle 2 Vector 4 50x30@1 70x70@0 30x70@0 50x30@1 .... + then the button 2 decoration uses a 4-point pattern consisting of a line from (x=50,y=30) to (70,70) in the shadow color (@0), and then to (30,70) in the shadow color, and finally to (50,30) in the highlight color (@1). Is that too confusing? See the fvwm web pages for some examples with screenshots. + A more complex example of _Vector_: + .... ButtonStyle 8 Vector 10 45x65@2 45x75@3 \ 20x75@3 20x50@3 35x50@3 35x65@1 35x25@1 \ 75x25@1 75x65@0 35x65@0 ButtonStyle 0 Vector 10 45x65@2 45x75@0 \ 20x75@0 20x50@1 45x50@1 45x65@0 75x65@3 \ 75x25@3 35x25@3 35x47@3 .... + The _Gradient_ styles denote color gradients. Fill in the question mark with any one of the defined gradient types. Please refer to the *Color Gradients* section for a description of the gradient syntax. The gradient styles are fully destructive. + The _Pixmap_ style displays a pixmap. A pixmap should be specified as an argument. For example, the following would give button number 2 the same pixmap for all 4 states (2 active and 2 inactive), and button number 4 all different pixmaps. + .... ButtonStyle 2 Pixmap my_pixmap.xpm ButtonStyle 4 \ ActiveUp (Pixmap activeup.xpm) \ ActiveDown (Pixmap activedown.xpm) \ Inactive (Pixmap inactiveup.xpm) ButtonStyle 4 \ InactiveDown Pixmap inactivedown.xpm .... + The pixmap specification can be given as an absolute or relative pathname (see *ImagePath*). If the pixmap cannot be found, the button style reverts to _Simple_. Flags specific to the _Pixmap_ style are _Left_, _Right_, _Top_, and _Bottom_. These can be used to justify the pixmap (default is centered for both directions). Pixmap transparency is used for the color "None." This style is partially destructive. + The _AdjustedPixmap_ style is similar to the _Pixmap_ style. But the image is resized to exactly fit the button. + The _ShrunkPixmap_ style is similar to the _Pixmap_ style. But if the image is bigger than the button the image is resized to fit into the button. + The _StretchedPixmap_ style is similar to the _Pixmap_ style. But if the image is smaller than the button the image is resized to cover the button. + The _TiledPixmap_ style accepts a pixmap to be tiled as the button background. One pixmap is specified as an argument. Pixmap transparency is not used. This style is fully destructive. + The _MiniIcon_ style draws the window's miniature icon in the button, which is specified with the _MiniIcon_ option of the *Style* command. This button style accepts no arguments. Example: + .... Style * MiniIcon mini-bx2.xpm Style xterm MiniIcon mini-term.xpm Style Emacs MiniIcon mini-doc.xpm ButtonStyle 1 MiniIcon .... *ButtonStyle* _button_ - +++[!]+++_flag_ ...:: Sets state-independent flags for the specified _button_. State-independent flags affect button behavior. Each _flag_ is separated by a space. If a '!' is prefixed to the flag then the behavior is negated. The special flag _Clear_ clears any existing flags. + The following flags are usually used to tell fvwm which buttons should be affected by mwm function hints (see _MwmFunctions_ option of the *Style* command. This is not done automatically since you might have buttons bound to complex functions, for instance. + _MwmDecorMenu_ should be assigned to title-bar buttons which display a menu. The default assignment is the leftmost button. When a window with the _MwmFunctions_ *Style* option requests not to show this button, it is hidden. + _MwmDecorMin_ should be assigned to title-bar buttons which minimize or iconify the window. The default assignment is the second button over from the rightmost button. When a window with the _MwmFunctions_ *Style* option requests not to show this button, it is hidden. + _MwmDecorMax_ should be assigned to title-bar buttons which maximize the window. The default assignment is the rightmost button. When a window with the _MwmFunctions_ *Style* option requests not to show this button, it is hidden. When the window is maximized, the vector pattern on the button looks pressed in. + _MwmDecorShade_ should be assigned to title-bar buttons which shade the window (see *WindowShade* command). When the window is shaded, the vector pattern on the button looks pressed in. + _MwmDecorStick_ should be assigned to title-bar buttons which make the window sticky. When the window is sticky, the vector pattern on the button looks pressed in. + The flag _MwmDecorLayer_ _layer_ should be assigned to title-bar buttons which place the window in the layer numbered _layer_. When the window is on that specific layer, the vector pattern on the button looks pressed in. *ChangeDecor* _decor_:: This command is deprecated and will be removed in the future. There are plans to replace it with a more flexible solution in fvwm-3.0. + Changes the decor of a window to _decor_. _decor_ is "Default" or the name of a decor defined with *AddToDecor*. If _decor_ is invalid, nothing occurs. If called from somewhere in a window or its border, then that window is affected. If called from the root window the user is allowed to select the target window. *ChangeDecor* only affects attributes which can be set using the *AddToDecor* command. + .... ChangeDecor CustomDecor1 .... *DestroyDecor* [recreate] _decor_:: This command is deprecated and will be removed in the future. There are plans to replace it with a more flexible solution in fvwm-3.0. + Deletes the _decor_ defined with *AddToDecor*, so that subsequent references to it are no longer valid. Windows using this _decor_ revert to the "Default" decor. The optional parameter _recreate_ tells fvwm not to throw away the decor completely but to throw away only its contents. If the decor is created again later, windows do not use it before the _UseDecor_ style is applied again unless the decor was destroyed with the _recreate_ option. The decor named "Default" cannot be destroyed. + .... DestroyDecor CustomDecor1 .... *TitleStyle* [_justification_] [Height [_num_]] [MinHeight [_num_]]:: Sets attributes for the title-bar. Justifications can be _Centered_, _RightJustified_ or _LeftJustified_. _Height_ sets the title bar's height to an amount in pixels. _MinHeight_ sets the minimal height in pixels of the title bar. Defaults are _Centered_, the window's font height and no minimal height. To reset the font height to the default value, omit the _num_ argument after the _Height_ keyword. The _MinHeight_ height is reset by _Height_ or if given with no argument. Example: + .... TitleStyle LeftJustified Height 24 .... *TitleStyle* [_state_] [_style_] [-- +++[!]+++_flag_ ...]:: Sets the style for the title-bar. See also *AddTitleStyle* and *ButtonStyle* _state_ can be one of "_ActiveUp_", "_ActiveDown_", "_InactiveUp_", or "_InactiveDown_". Shortcuts like "_Active_" and "_Inactive_" are allowed. The states with the "Toggled" prefix are allowed too, the title itself does not use "Toggled" states, but these states are used for the buttons with *ButtonStyle* _UseTitleStyle_. If _state_ is omitted, then the _style_ is added to every state. If parentheses are placed around the _style_ and _flags_, then multiple state definitions can be given per line. _style_ can be omitted so that flags can be set while not destroying the current style. + If a '!' is prefixed to any _flag_, its behavior is negated. Valid flags for each state include _Raised_, _Flat_ and _Sunk_ (these are mutually exclusive). The default is _Raised_. See the note in *ButtonStyle* regarding the "_ActiveDown_" state. Examples: + .... TitleStyle ActiveUp HGradient 16 navy black TitleStyle \ ActiveDown (Solid red -- flat) \ Inactive (TiledPixmap wood.xpm) TitleStyle \ ActiveUp (-- Flat) \ ActiveDown (-- Raised) \ InactiveUp (-- Flat) \ InactiveDown (-- Sunk) .... + This sets the "ActiveUp" state to a horizontal gradient, the "ActiveDown" state to solid red, and the "Inactive" states to a tiled wood pixmap. Finally, "ActiveUp" and "InactiveUp" are set to look flat, while "ActiveDown" set to be sunk (the _Raised_ flag for the "ActiveDown" state causes it to appear sunk due to relief inversion), and "InactiveDown" is set to look raised. An example which sets flags for all states: + .... TitleStyle -- flat .... + For a flattened look: + .... TitleStyle -- flat ButtonStyle All Active (-- flat) Inactive (-- flat) .... + *TitleStyle* accepts all the *ButtonStyle* styles and arguments: + _Simple_, _Default_, _Solid_, _Colorset_, _Vector_, _?Gradient_, _Pixmap_, _AdjustedPixmap_, _ShrunkPixmap_, _StretchedPixmap_, _TiledPixmap_, _MiniIcon_. + See the *ButtonStyle* command for a description of all these styles and their arguments. + In addition to these styles *TitleStyle* accepts a powerful _MultiPixmap_ option. This allows you to specify different pixmaps, colorsets or colors for different parts of the titlebar. Some of them are tiled or stretched to fit a particular space; others are discrete "transition" images. The definable _sections_ are: + _Main_::: The full titlebar + _LeftMain_::: Left of title text + _RightMain_::: Right of title text + _UnderText_::: Underneath title text + _LeftOfText_::: just to the left of the title text + _RightOfText_::: just to the right of the title text + _LeftEnd_::: at the far left end of the titlebar (just after left buttons if any) + _RightEnd_::: at the far right end of the titlebar (just before right buttons if any) + _Buttons_::: under buttons in case of _UseTitleStyle_ + _LeftButtons_::: under left buttons in case of _UseTitleStyle_ + _RightButtons_::: under right buttons in case of _UseTitleStyle_ None of these are mandatory except for _Main_ (or, if you do not define _Main_ you must define both _LeftMain_ and _RightMain_). If no _Buttons_ pixmaps are defined and _UseTitleStyle_ is specified for one or more buttons, _Main_, _LeftMain_ or _RightMain_ are used as appropriate. The syntax for this style type is: .... MultiPixmap section style arg, ... .... continuing for whatever you want to define. The _style_ can be either _TiledPixmap_, _AdjustedPixmap_, _Colorset_ or _Solid_. See the *ButtonStyle* command for the description of these styles. In the case of a transition section, _LeftEnd_, _LeftOfText_, _RightOfText_ or _RightEnd_, _AdjustedPixmap_ only resize the pixmap in the "y" direction. For the _Colorset_ and _Solid_ styles a width of the half of the title bar height is assumed for the transition sections. An example: .... MultiPixmap Main AdjustedPixmap foo.xpm, \ UnderText TiledPixmap bar.xpm, \ Buttons Colorset 2 .... Note that the old syntax is still supported: if the style is omitted, _TiledPixmap_ is assumed and adding "(stretched)" between the section and the file name implies _AdjustedPixmap_. *UpdateDecor* [_decor_]:: This command is deprecated and will be removed in the future. There are plans to replace it with a more flexible solution in fvwm-3.0. This command is kept mainly for backward compatibility. Since all elements of a decor are updated immediately when they are changed, this command is mostly useless. Updates window decorations. _decor_ is an optional argument which specifies the _decor_ to update. If given, only windows which are assigned to that particular _decor_ are updated. This command is useful, for instance, after a *ButtonStyle*, *TitleStyle* or *BorderStyle* (possibly used in conjunction with *AddToDecor*). Specifying an invalid decor results in all windows being updated. // END 'styles' endif::[] === Controlling the Virtual Desktop *Desk* _arg1_ [_arg2_] [_min_ _max_]:: This command has been renamed. Please see *GotoDesk* command. *DesktopName* _desk_ _name_:: Defines the name of the desktop number _desk_ to _name_. This name is used in the *WindowList* command and in the *FvwmPager* where it override the _Label_ configuration option. Moreover, if consecutive names starting from desktop 0 are defined, then these names can be used by any EWMH compliant application (as a pager). *DesktopConfiguration* global | per-monitor | shared:: This command controls the behaviour of how desktops should be managed by FVWM. By default, for all screens detected by FVWM through RandR support, the option of global means that all windows on the same desk across monitors is treated as one -- hence, when a change of desktop/page happens, the same change occurs across all monitors. + With per-monitor , each RandR monitor has a separate copy of desktops, and hence function independently of one another when switching desks/pages. + When __shared__ is set, the desktops are shared amongst all monitors. So for example, with the following number of desktops defined with two monitors (__[]__ is monitor1, and __<>__ is monitor2): + .... [0] 1 2 <3> 4 .... + Moving between desktops would still honor the monitor the desktop is being requested on. If __monitor1__ wanted to switch to desktop 3, then that desktop is exchanged with __monitor2__ such that the following showed the active desktop on both monitors: + .... <0> 1 2 [3] 4 .... + This concept is similar to how spectrwm or xmonad handles desktops. + **Note:** these each *DesktopConfiguration* mode can be changed on-the-fly. *DesktopSize* __Horizontal__x_Vertical_:: Defines the virtual desktop size in units of the physical screen size. *EdgeResistance* __delay__**EdgeResistance** _scrolling_ _moving_ [_screen-scrolling_]:: Tells how hard it should be to change the desktop viewport by moving the mouse over the edge of the screen. The parameter tells how many milliseconds the pointer must spend on the screen edge before fvwm moves the viewport. This is intended for people who use + .... EdgeScroll 100 100 .... + but find themselves accidentally flipping pages when they do not want to. If -1 is given as the delay, scrolling is disabled completely. + The second form of invocation with two or three arguments is obsolete and should be replaced with the following three commands as needed: + .... EdgeResistance scrolling Style * EdgeMoveDelay scrolling Style * EdgeMoveResistance moving or Style * EdgeMoveResistance moving screen-scrolling .... + Fvwm does this substitution automatically and prints a warning. *EdgeScroll* _horizontal_[p] _vertical_[p] [wrap | wrapx | wrapy]:: Specifies the percentage of a page to scroll when the cursor hits the edge of a page. A trailing '_p_' changes the interpretation to mean pixels. If you do not want any paging or scrolling when you hit the edge of a page include + .... EdgeScroll 0 0 .... + in your _config_ file, or possibly better, set the *EdgeThickness* to zero. See the *EdgeThickness* command. If you want whole pages, use + .... EdgeScroll 100 100 .... + Both _horizontal_ and _vertical_ should be positive numbers. + If the _horizontal_ and _vertical_ percentages are multiplied by 1000 or one of the keywords _wrap_, _wrapx_ and _wrapy_ is given then scrolling wraps around at the edge of the desktop. If + .... EdgeScroll 100000 100000 .... + is used fvwm scrolls by whole pages, wrapping around at the edge of the desktop. *EdgeThickness* 0 | 1 | 2:: This is the width or height of the invisible window that fvwm creates on the edges of the screen that are used for the edge scrolling feature. + In order to enable page scrolling via the mouse, four windows called the "pan frames" are placed at the very edge of the screen. This is how fvwm detects the mouse's presence at the window edge. Because of the way this works, they need to be at the top of the stack and eat mouse events, so if you have any kind of error along the lines of: "mouse clicks at the edge of the screen do the wrong thing" you're having trouble with the pan frames and (assuming you do not use the mouse to flip between pages) should set the EdgeThickness to 0. + A value of 0 completely disables mouse edge scrolling, even while dragging a window. 1 gives the smallest pan frames, which seem to work best except on some servers. + 2 is the default. + Pan frames of 1 or 2 pixels can sometimes be confusing, for example, if you drag a window over the edge of the screen, so that it straddles a pan frame, clicks on the window, near the edge of the screen are treated as clicks on the root window. *EwmhBaseStruts* _screen RANDRNAME_ _left_ _right_ _top_ _bottom_:: Where left, right, top and bottom are positive or null integers which define bands at the edge of the screen. If _screen_ is given, followed by the RANDRNAME of a given display, then the EwmhBaseStruts are defined for just RANDRNAME. _left_ defines a band on the left of your screen of width _left_, _right_ defines a band on the right of your screen of width _right_, _top_ defines a band on the top of your screen of height _top_ and _bottom_ defines a band on the bottom of your screen of height _bottom_. The unit is the pixel and the default is 0 0 0 0. These areas define additional reserved space to the reserved space defined by some ewmh compliant applications. This is used to compute the Working Area. See the *Extended Window Manager Hints* section for a definition of the Working Area. *EwmhNumberOfDesktops* _num_ [_max_]:: This command is useful only for an ewmh compliant pager or taskbar (as kpager or kicker taskbar) and not for fvwm modules ( *FvwmPager* or *FvwmIconMan*). It causes a compliant application to consider at least _num_ desktops (desktop 0 to desktop _num_-1). The optional argument _max_ causes a compliant application to never consider more than _max_ desktops. If _max_ is 0 (the default) there is no limitation. The actual number of desktops is determined dynamically. It is at least _num_, but it can be d if there is a window on desktop d-1 (or if the current desktop is desktop d-1) and d is less or equal to _max_ or _max_ is null. Moreover, a compliant pager can ask to change _num_ itself. This is accepted by fvwm only if this number is less than or equal to _max_ or if _max_ is null. Note that negative desktops are not supported by the ewmh specification. The default is 4 0. *GotoDesk* [prev | _arg1_ [_arg2_] [_min_ _max_]]:: Switches the current viewport to another desktop (workspace, room). + The command takes 1, 2, 3, or 4 arguments. A single argument is interpreted as a relative desk number. Two arguments are understood as a relative and an absolute desk number. Three arguments specify a relative desk and the minimum and maximum of the allowable range. Four arguments specify the relative, absolute, minimum and maximum values. (Desktop numbers can be negative). If a literal _prev_ is given as the single argument, the last visited desk number is used. + If _arg1_ is non zero then the next desktop number is the current desktop number plus _arg1_. + If _arg1_ is zero then the new desktop number is _arg2_. (If _arg2_ is not present, then the command has no effect.) + If _min_ and _max_ are given, the new desktop number is no smaller than _min_ and no bigger than _max_. Values out of this range are truncated (if you gave an absolute desk number) or wrapped around (if you gave a relative desk number). + The syntax is the same as for *MoveToDesk*, which moves a window to a different desktop. + The number of active desktops is determined dynamically. Only desktops which contain windows or are currently being displayed are active. Desktop numbers must be between 2147483647 and -2147483648 (is that enough?). *GotoDeskAndPage* screen | prev | _desk_ _xpage_ _ypage_:: Switches the current viewport to another desktop and page, similar to the *GotoDesk* and *GotoPage* commands. The new desk is _desk_ and the new page is (_xpage_,_ypage_). *GotoPage* screen | prev | [_options_] _x_[p] _y_[p]:: Moves the desktop viewport to page (x,y). The upper left page is (0,0), the upper right is (M,0), where M is one less than the current number of horizontal pages specified in the *DesktopSize* command. The lower left page is (0,N), and the lower right page is (M,N), where N is the desktop's vertical size as specified in the *DesktopSize* command. To switch to a page relative to the current one add a trailing '_p_' after any or both numerical arguments. + Possible _options_ are _wrapx_ and _wrapy_ to wrap around the x or y coordinate when the viewport is moved beyond the border of the desktop. + The name of the RandR screen. + To go to the last visited page use _prev_ as the first argument. The *GotoPage* function should not be used in a pop-up menu. + Examples: + .... # Go to page (2,3) GotoPage 2 3 # Go to lowest and rightmost page GotoPage -1 -1 # Go to last page visited GotoPage prev # Go two pages to the right and one page up GotoPage +2p -1p .... *Scroll* [screen RANDRNAME] [_horizonal_[p] _vertical_[p] | reverse]:: Scrolls the virtual desktop's viewport by _horizontal_ pages in the x-direction and _vertical_ pages in the y-direction or starts interactive scrolling of the viewport. Either or both entries may be negative. Both _horizontal_ and _vertical_ values are expressed in percent of pages, so + .... Scroll 100 100 .... + means to scroll down and right by one full page. + .... Scroll 50 25 .... + means to scroll right half a page and down a quarter of a page. The *Scroll* function should not be called from pop-up menus. Normally, scrolling stops at the edge of the desktop. + If the _horizontal_ and _vertical_ percentages are 100 or more and are multiplied by 1000 then scrolling wraps around at the edge of the desktop. If + .... Scroll 100000 0 .... + is executed over and over fvwm moves to the next desktop page on each execution and wraps around at the edge of the desktop, so that every page is hit in turn. + If the letter '_p_' is appended to each coordinate (_horizontal_ and/or _vertical_), then the scroll amount is measured in pixels. + Without arguments or if the option _reverse_ is given interactive scrolling takes place. The viewport scrolls as the mouse is moved. With the _reverse_ option scrolling is done in opposite direction of the mouse movement, and without it scrolling in the same direction as the mouse. + The binding + .... Mouse 1 A CM Scroll reverse .... + gives an effect of grabbing and dragging the viewport with button 1 if Control and Meta is pressed. + If _screen_ is given, followed by the RANDRNAME of a given display, then the specified screen is scrolled. This is only useful if using per-monitor or shared _DesktopConfiguration_ and wanting to scroll a monitor other than the current monitor. Interactive scrolling always scrolls the current monitor. === User Functions and Shell Commands *AddToFunc* [_name_ [I | J | M | C | H | D _action_]]:: Begins or adds to a function definition. Here is an example: + .... AddToFunc Move-or-Raise I Raise + M Move + D Lower .... + The function name is "Move-or-Raise", and it could be invoked from a menu or a mouse binding or key binding: + .... Mouse 1 TS A Move-or-Raise .... + The _name_ must not contain embedded whitespace. No guarantees are made whether function names with embedded whitespace work or not. This behavior may also change in the future without further notice. The letter before the _action_ tells what kind of action triggers the command which follows it. '_I_' stands for "Immediate", and is executed as soon as the function is invoked. '_J_' is similar to "Immediate" but is delayed until a button is pressed or released or the pointer is moved, or the function completes. It is always executed before the other function actions. '_M_' stands for "Motion", i.e. if the user starts moving the mouse. '_C_' stands for "Click", i.e., if the user presses and releases the mouse button. '_H_' stands for "Hold", i.e. if the user presses a mouse button and holds it down for more than *ClickTime* milliseconds. '_D_' stands for "Double-click". The action '_I_' causes an action to be performed on the button-press, if the function is invoked with prior knowledge of which window to act on. + There is a number of predefined symbols that are replaced by certain values if they appear on the command line. Please refer to the *Command Expansion* section for details. + *Warning* Please read the comments on executing complex functions in the section *Scripting and Complex Functions*. + Examples: + If you call + .... Key F10 R A Function MailFunction xmh "-font fixed" .... + and "MailFunction" is + .... AddToFunc MailFunction + I Next ($0) Iconify off + I Next (AcceptsFocus, $0) Focus + I None ($0) Exec exec $0 $1 .... + Then the last line of the function becomes + .... + I None (xmh) Exec exec xmh -font fixed .... + The expansion is performed as the function is executed, so you can use the same function with all sorts of different arguments. You could use + .... Key F11 R A Function MailFunction zmail "-bg pink" .... + in the same _config_, if you wanted. An example of using "$[w.id]" is: + .... AddToFunc PrintFunction + I Raise + I Exec xdpr -id $[w.id] .... + Note that "$$" is expanded to '$'. + Another example: bind right mouse button within the window button number 6 (this is a minimize button for the win95 theme) to iconify all windows of the same resource: + .... AddToFunc FuncIconifySameResource "I" All ($0) Iconify on Mouse 3 6 A FuncIconifySameResource $[w.resource] .... *Beep*:: As might be expected, this makes the terminal beep. *DestroyFunc* _function_:: Deletes a function, so that subsequent references to it are no longer valid. You can use this to change the contents of a function during a fvwm session. The function can be rebuilt using *AddToFunc*. + .... DestroyFunc PrintFunction .... *Echo* _string_:: Prints a message to the debug log file, which requires logging to be enabled. See the *-v* option or *PrintInfo* for more information on both enabling debug logging and the log file location. Potentially useful for debugging things in your _config_ or getting the value of variables. + .... Echo Beginning style definitions... Echo Current desk $[desk.n]. .... *EchoFuncDefinition* _function_:: The *EchoFuncDefinition* is similar to the *Echo* command but prints the definition for the given _function_ to the debug log file. It is useful to find out how fvwm handles quoting and for debugging functions. *Exec* _command_:: Executes _command_. You should not use an ampersand '&' at the end of the command. You probably want to use an additional "exec" at the beginning of _command_. Without that, the shell that fvwm invokes to run your command stays until the command exits. In effect, you'll have twice as many processes running as you need. Note that some shells are smart enough to avoid this, but it never hurts to include the "exec" anyway. + The following example binds function key + in the root window, with no modifiers, to the exec function. The program rxvt is started with an assortment of options. + .... Key F1 R N Exec exec rxvt -fg yellow -bg blue \ -e /bin/tcsh .... + Note that this function doesn't wait for _command_ to complete, so things like: + .... Exec "echo AddToMenu ... > /tmp/file" Read /tmp/file .... + do not work reliably (see the *PipeRead* command). *ExecUseShell* [_shell_]:: Makes the *Exec* command use the specified shell, or the value of the _$SHELL_ environment variable if no shell is specified, instead of the default Bourne shell (_/bin/sh_). + .... ExecUseShell ExecUseShell /usr/local/bin/tcsh .... *Function* _FunctionName_:: Used to bind a previously defined function to a key or mouse button. The following example binds mouse button 1 to a function called "Move-or-Raise", whose definition was provided as an example earlier in this man page. After performing this binding fvwm executes the "move-or-raise" function whenever button 1 is pressed in a window's title-bar. + .... Mouse 1 T A Function Move-or-Raise .... + The keyword *Function* may be omitted if _FunctionName_ does not coincide with an fvwm command. + Warning: Please read the comments on executing complex functions in the section *Scripting and Complex Functions*. *InfoStoreAdd* _key_ _value_:: Stores the _value_ at the given _key_. This is useful to store generic information used in the lifetime of an fvwm config file. For example storing program preferences for opening video files. + The purpose of this command is to store internal information to fvwm which can be used bu fvwm functions, or when opening programs of a certain type. Previous to this command the only way to do this was via *SetEnv* but this is discouraged because it places such information in the environment, which pollutes it and makes the information global to other processes started by fvwm which may then modify them which might not be what's wanted. Hence the point of *InfoStoreAdd* is to still allow for such information to be stored, but kept internal to fvwm. + In this way, one can build up as many key/value pairs as needed. Recalling the value of a given key happens through fvwm's usual expansion mechanism. See the *Command Expansion* section for more details. For example: + .... InfoStoreAdd teddybearprog xteddy # Echo the value of teddybearprog Echo $[infostore.teddybearprog] .... + Removing an entry from the InfoStore is done with the *InfoStoreRemove* command. *InfoStoreRemove* _key_:: Removes an entry at the given _key_ from the InfoStore. Example: + .... InfoStoreRemove teddybearprog .... *Nop*:: Does nothing. This is used to insert a blank line or separator in a menu. If the menu item specification is + .... AddToMenu MyMenu " " Nop .... + then a blank line is inserted. If it looks like + .... + "" Nop .... + then a separator line is inserted. Can also be used as the double-click action for *Menu* or *Popup*. *PipeRead* _command_ [quiet]:: Causes fvwm to read commands from the output of the _command_. This _command_ is executed by _/bin/sh_ as if you typed it on the command line. If the command consists of more than one word it must be quoted. Useful for building up dynamic menu entries based on a directories contents, for example. If the keyword _Quiet_ follows the command no message is produced if the _command_ is not found. + Example: + .... AddToMenu HomeDirMenu PipeRead 'for i in $HOME/*; \ do echo "+ $i Exec xterm -e vi $i"; done' .... + Note: The *PipeRead* changes the pointer to a watch cursor by default during execution. However, some commands, for example xwd, need to take control of the pointer themselves and do not work. To disable the watch cursor, use the command prior to *PipeRead* + .... BusyCursor Read off .... + The *PipeRead* command executes synchronously. If you want to *Exec* something, but need the command to run synchronously, you might do something like: + .... PipeRead 'command 1>&2' .... + The redirection causes any output from the program to go to stderr instead of being read as a sequence of commands by fvwm. *PipeRead* returns 1 if the given command could be executed or -1 if not (see the section *Conditional Commands* for the meaning of return codes). *Read* _filename_ [quiet]:: Causes fvwm to read commands from the file named _filename_. If the keyword _Quiet_ follows the command no message is produced if the file is not found. If the file name does not begin with a slash ('/'), fvwm looks in the user's data directory, then the system data directory. The user's data directory is by default _$HOME/.fvwm_. It can be overridden by exporting _FVWM_USERDIR_ set to any other directory. The *Read* command returns 1 if the given file could be read or -1 if not (see the section *Conditional Commands* for the meaning of return codes). *SetEnv* _variable_ _value_:: Set an environment variable to a new value, similar to the shell's export or setenv command. The _variable_ and its _value_ are inherited by processes started directly by fvwm. This can be especially useful in conjunction with the *FvwmM4* module. For example: + .... SetEnv height HEIGHT .... + makes the *FvwmM4* set variable _HEIGHT_ usable by processes started by fvwm as the environment variable _$height_. If _value_ includes whitespace, you should enclose it in quotes. If no _value_ is given, the variable is deleted. *Silent* _command_:: A number of commands require a window to operate on. If no window was selected when such a function is invoked the user is asked to select a window. Sometimes this behavior is unwanted, for example if the function was called by a module and the window that was selected at first does not exist anymore. You can prevent this by putting *Silent* in front of the fvwm _command_. If a function that needs a window is called with *Silent* without a window selected, it simply returns without doing anything. If *Silent* is used on a user defined function it affects all function and sub function calls until the original function exits. + Another usage of *Silent* is with binding commands *Key*, *PointerKey* and *Mouse*, this disables error messages. + *Silent* also disables the error message for non-existent commands. Note: This command is treated as a prefix to its _command_. Expansion of the command line is done as if *Silent* was not there. + Examples: + .... Silent Move 0 0 Silent User_defined_function # do not complain on keyboards without "Help" key Silent Key Help R A Popup HelpMenu .... *UnsetEnv* [_variable_]:: Unset an environment variable, similar to shell's export or unsetenv command. The _variable_ then is removed from the environment array inherited by processes started directly by fvwm. *Wait* _window_:: This command is intended to be used in fvwm functions only. It causes execution of a function to pause until a new window matching _window_ appears. This can be a window's name, class, or resource string. It may contain the wildcards '*' and '?', which are matched in the usual Unix filename manner. This is particularly useful in the "InitFunction" if you are trying to start windows on specific desktops: + .... AddToFunc InitFunction + I Exec exec xterm -geometry 80x64+0+0 + I Wait xterm + I GotoDesk 0 2 + I Exec exec xmh -font fixed -geometry \ 507x750+0+0 + I Wait xmh + I GotoDesk 0 0 .... + The above function starts an xterm on the current desk, waits for it to map itself, then switches to desk 2 and starts an xmh. After the xmh window appears control moves to desk 0. + Fvwm remains partially functional during a wait, but any input from the modules is queued up and processed only after the window appears or the command is aborted. For example, windows can not be focused with *FvwmIconMan* or *FvwmPager* during a wait. + You can escape from a *Wait* pause by pressing Ctrl-Alt-Escape (where Alt is the first modifier). To redefine this key sequence see the *EscapeFunc* command. *Status* _On | Off_:: Turns status either On or Off. This sends information in JSON format down a named pipe (set via FVWM_STATUS_PIPE env var) about the current desks and number of windows, etc. This is meant to provide a fast means of supplying third-party tools information about what's happening in Fvwm. For example, the JSON could be manipulated and sent to tools such as _lemonbar_, _polybar_, etc. + The format of the JSON blob looks like this: + .... { "version": 1, "current_screen": "HDMI2", "screens": { "HDMI2": { "current_client": "n6tadam@shuttle: ~", "desktops": { "0": { "number": 0, "is_urgent": false, "is_current": true, "number_of_clients": 5 }, }, }, }, } .... + These sections repeat for all screens/groups/etc, depending on how many there are of each. === Conditional Commands Conditional commands are commands that are only executed if certain conditions are met. Most conditional commands work on windows, like *Next*, *ThisWindow* or *All*. There is one conditional command, *Test*, that works on global conditions unrelated to windows. The syntax of the conditions is described below. For readability, the list of conditions is located at the end of this section. *Return Codes*:: All commands in this section (unless specifically stated for the command) also have a return code that can be 1 (if the condition was met) or 0 (if the condition was not met). Some commands may return -1 which means that an error occurred and the return code is useless. The *Break* command returns -2. Additionally, the return codes of commands run in a complex functions are passed to the invoking complex function. The return code is used by the *TestRc* command. Please refer to the commands' description for examples. The return code can also be accessed through the variable _$[cond.rc]_. Non conditional commands do not modify the return code of the last conditional command. Important note: return codes are only defined inside functions created with the *AddToFunc* command and are not inherited by sub functions. To run a command without altering the return code, the *KeepRc* command can be used. *The Ring of Windows*:: Fvwm stores windows in a ring internally. Think of the focused window as a cursor on the current position in the ring. The *Next* command and many other commands search forwards through the ring for a matching window, and *Prev* searches backwards. The windows in the ring are either ordered by creation time (if the _!FPSortWindowlistByFocus_, _NeverFocus_ or _MouseFocus_ styles are used) or by the last time they had the focus. *List of Conditional Commands*:: *All* [_options_] [(_conditions_)] _command_::: Execute _command_ on all windows meeting the conditions. It returns 1 if any window matches the condition and 0 otherwise. The execution starts at the top of the window ring and continues towards the bottom. The _options_ can be any combination of _Reverse_ and _UseStack_. If the option _Reverse_ is given the execution order is reversed. The option _UseStack_ makes All use the stacking order instead of the window ring when walking through windows. See the *Conditions* section for a list of conditions. + This command implies the conditions _CirculateHit_, _CirculateHitIcon_ and _CirculateHitShaded_. They can be turned off by specifying _!CirculateHit_ etc. explicitly. + *Any* [(_conditions_)] _command_::: Performs _command_ if any window which satisfies all _conditions_ exists. The command is run in the context of the root window. See the *Conditions* section for a list of conditions. + *Break* [_levels_]::: If the break command is used in a function, function execution is terminated immediately. Further commands of the function are not processed. Normally, all nested invocations of complex functions are left. An optional integer number _levels_ may be given to break out of the given number of nested functions and continue execution of a higher level function. The *Break* command always has the return code -2. Example: + .... AddToFunc PickWindowRaiseAndDeiconify + I Pick + I TestRc (Error) Break + I Raise + I Iconify off .... + *Current* [(_conditions_)] _command_::: Performs _command_ on the currently focused window if it satisfies all _conditions_. See the *Conditions* section for a list of conditions. + This command implies the conditions _CirculateHit_, _CirculateHitIcon_ and _CirculateHitShaded_. They can be turned off by specifying _!CirculateHit_ etc. explicitly. + *Direction* [FromPointer] _direction_ [(_conditions_)] _command_::: Performs _command_ (typically *Focus*) on a window in the given direction which satisfies all _conditions_. Normally, the center of the currently focused window or the context window in which the command was invoked is taken as the starting point. Lacking such a window, or when the _FromPointer_ option is given, the current position of the pointer is taken as the starting point. The _direction_ may be one of "North", "Northeast", "East", "Southeast", "South", "Southwest", "West", "Northwest" and "Center". Which window *Direction* selects depends on angle and distance between the center points of the windows. Closer windows are considered a better match than those farther away. The _Center_ direction simply selects the window closest to the starting point. Returns -1 if an invalid direction was given. See the *Conditions* section for a list of conditions. + *KeepRc* _command_::: Runs the _command_ but does not alter the return code of the previous command. Note: *KeepRc* is treated as a prefix to its _command_. Expansion of the command line is done as if *KeepRc* was not there. + *Next* [(_conditions_)] _command_::: Performs _command_ (typically *Focus*) on the next window which satisfies all _conditions_. If the command is running in a window context, it starts looking for a matching window from there. Otherwise it starts at the focused window. See *Conditions* section for a list of conditions. + *None* [(_conditions_)] _command_::: Performs _command_ if no window which satisfies all _conditions_ exists. The command is run in the context of the root window. Returns 1 if no window matches the conditions and 0 otherwise. See *Conditions* section for a list of conditions. + This command implies the conditions _CirculateHit_, _CirculateHitIcon_ and _CirculateHitShaded_. They can be turned off by specifying _!CirculateHit_ etc. explicitly. + *NoWindow* _command_::: Performs _command_, but removes the window context if any. This is not really a conditional command, but a prefix that may be useful in menu items that should operate without a window even if such menu is bound to window decorations. + *Pick* [(_conditions_)] _command_::: *Pick* works like *Function* if invoked in the context of a window. If invoked in the root window, it first asks the user to pick a window and then executes the _command_ in the context of that window. This avoids annoying multiple selections with complex functions. The command is executed only if the given _conditions_ are met. Returns -1 if no window was selected. See *Conditions* section for a list of conditions. + This command implies the conditions _CirculateHit_, _CirculateHitIcon_ and _CirculateHitShaded_. They can be turned off by specifying _!CirculateHit_ etc. explicitly. + *PointerWindow* [(_conditions_)] _command_::: Performs _command_ if the window under the pointer satisfies all _conditions_. Returns -1 if there is no window under the pointer. See *Conditions* section for a list of conditions. + This command implies the conditions _CirculateHit_, _CirculateHitIcon_ and _CirculateHitShaded_. They can be turned off by specifying _!CirculateHit_ etc. explicitly. + *Prev* [(_conditions_)] _command_::: Performs _command_ (typically *Focus*) on the previous window which satisfies all _conditions_. If the command is running in a window context, it starts looking for a matching window from there. Otherwise it starts at the focused window. See *Conditions* section for a list of conditions. + *ScanForWindow* [FromPointer] _dir1_ _dir2_ [(_conditions_)] _command_::: Performs _command_ (typically *Focus*) on a window in the given direction which satisfies all _conditions_. Normally, the center of the currently focused window or the context window in which the command was invoked is taken as the starting point. Lacking such a window, or when the _FromPointer_ option is given, the current position of the pointer is taken as the starting point. The direction _dir1_ may be one of "North", "NorthEast", "East", "SouthEast", "South", "SouthWest", "West", and "NorthWest". Which window *ScanForWindow* selects depends first on the position along the primary axis given by _dir1_. If any windows have the exact same coordinate along the primary axis, the secondary direction is used to order the windows. The direction _dir2_ may be one of the same set of values as _dir1_. If _dir2_ is not perfectly perpendicular to _dir1_, ScanForWindow returns a failure. When using ScanForWindow repeatedly with the same arguments, it is guaranteed that all windows matching the conditions will eventually be found. If the focus reaches a limit along the primary axis, it will wrap around to the opposite side. Returns -1 if an invalid direction was given. See *Conditions* section for a list of conditions. + *Test* [(_test-conditions_)] _command_::: Performs _command_ if all _test-conditions_ are satisfied. The _test-conditions_ are keywords with possible arguments from the list below and are separated by commas or whitespace. They include: _Version operator x.y.z_, _EnvIsSet varname_, _EnvMatch varname pattern_, _EdgeHasPointer direction_, _EdgeIsActive direction_, _Start_, _Init_, _Restart_, _Exit_, _Quit_, _ToRestart_, _True_, _False_, _F_, _R_, _W_, _X_ and _I_. A test-condition prefixed with "!" is negated. + The _Version_ _operator x.y.z_ test-condition is fulfilled if the logical condition of the expression is true. Valid _operator_ values are: _>=_, _>_, _<=_, _<_, _==_ and _!=_. + Example: + .... Test (Version >= 2.5.11) Echo 2.5.11 or later. .... + The _EnvIsSet_ _varname_ test-condition is true if the given environment variable is set. The _EnvMatch_ _varname pattern_ test-condition is true if _pattern_ matches the given environment or infostore variable value. (See *InfoStoreAdd*). The pattern may contain special "*" and "?" chars. The "varname" is coded without the leading dollar sign ($). + The _EdgeHasPointer_ [_direction_] test-condition is true if the edge in the given direction currently contains the pointer. The _EdgeIsActive_ [_direction_] test-condition is true if the edge in the given direction currently is active. An edge is active, and can contain a pointer if either a command is bound to it or edge scroll is available in that direction. The direction may be one of * Any__,__ North__,__ Top__,__ Up__,__ West__,__ Left__,__ South__,__ Bottom__, __ Down__,__ Right* and * East__. If no direction is specified __Any* is assumed. + The _Start_ test-condition is the same as either _Init_ or _Restart_. It is only true on startup or restart prior and during *StartFunction* execution. The _Exit_ test-condition is the same as either _Quit_ or _ToRestart_. It is only valid on shutdown during *ExitFunction* function execution. + The _True_ and _False_ test-conditions are unconditionally true and false. + Additionally, if a test-condition name is not recognized, the Error return code is set and the command is not executed. + The _F_ _file_, _R_ _file_, _W_ _file_, _X_ _file_ and _I_ _file_ test-conditions test for existence of the given [F]ile (possibly with [R]ead/[W]rite permissions), e[X]ecutable (in _$PATH_), or the [I]mage (in ImagePath). + Example: + .... AddToFunc StartFunction I Test (Init) Exec exec xterm AddToFunc VerifyVersion + I Test (Version 2.5.*) Echo 2.5.x detected + I TestRc (NoMatch) \ Test (!Version 2.6.*) Echo Future version + I TestRc (NoMatch) \ Echo 2.6.x is detected Test (F $[FVWM_USERDIR]/local-config) Read local-config Test (X xterm-utf16) Exec exec xterm-utf16 .... + *TestRc* [(+++[!]+++_returncode_)] _command_::: Performs _command_ if the last conditional command returned the value _returncode_. Instead of the numeric values 0 (no match), 1 (match), -1 (error), and -2 (break) the symbolic names "_NoMatch_", "_Match_", "_Error_" and "_Break_" can be used. If no _returncode_ is given, the default 0 is assumed. If the return code is prefixed with '!', the command is executed if _returncode_ does not match the value returned by the conditional command. The *TestRc* command can only be used inside functions. If the _command_ is another conditional command, the previous return code is replaced by the new one. Example: + .... AddToFunc ToggleXterm + I All (my_xtermwindow) Close + I TestRc (NoMatch) Exec xterm -T my_xtermwindow .... + *ThisWindow* [(_conditions_)] command::: *ThisWindow* executes the specified _command_ in the context of the current operand window. If there is no operand window (it is invoked in the root window), the command is ignored. *ThisWindow* is never interactive. The command is executed only if the given _conditions_ are met. It returns -1 if used outside a window context. See *Conditions* section for a list of conditions. + This command implies the conditions _CirculateHit_, _CirculateHitIcon_ and _CirculateHitShaded_. They can be turned off by specifying "!CirculateHit" etc. explicitly. + *WindowId* [_id_] [(_conditions_)] | [root [_screen_]] _command_::: The *WindowId* command looks for a specific window _id_ and runs the specified _command_ on it. The second form of syntax retrieves the window id of the root window of the given _screen_. If no _screen_ is given, the current screen is assumed. The window indicated by _id_ may belong to a window not managed by fvwm or even a window on a different screen. Although most commands can not operate on such windows, there are some exceptions, for example the *WarpToWindow* command. Returns -1 if no window with the given id exists. See *Conditions* section for a list of conditions. + This command implies the conditions _CirculateHit_, _CirculateHitIcon_ and _CirculateHitShaded_. They can be turned off by specifying _!CirculateHit_ etc. explicitly. + Examples: + .... WindowId 0x34567890 Raise WindowId root 1 WarpToWindow 50 50 WindowId $0 (Silly_Popup) Delete .... + In the past this command was mostly useful for functions used with the *WindowList* command, or for selective processing of *FvwmEvent* calls (as in the last example), but currently these handler functions are called within a window context, so this command is not really needed in these cases. Still it may be useful if, for example, the window id should be stored in the environment variable for a further proceeding. + .... Pick SetEnv BOOKMARKED_WINDOW $[w.id] WindowId $[BOOKMARKED_WINDOW] WarpToWindow .... *Conditions*:: The _conditions_ that may be given as an argument to any conditional command are a list of keywords separated by commas, enclosed in parentheses. Unless stated otherwise, conditional commands accept all the conditions listed below. Note that earlier versions of fvwm required the conditions to be separated by whitespace instead of commas and enclosed in brackets instead of parentheses (this is still supported for backward compatibility). + In addition, the _conditions_ may include one or more window names to match to. If more than one window name is given, all of them must match. The window name, icon name, class, and resource are considered when attempting to find a match. Each name may include the wildcards '*' and '?', and may consist of two or more alternatives, separated by the character '|', which acts as an OR operator. (If OR operators are used, they must not be separated by spaces from the names.) Each window name can begin with '!', which prevents _command_ if any of the window name, icon name, class or resource match. However, '!' must not be applied to individual names in a group separated by OR operators; it may only be applied to the beginning of the group, and then it operates on the whole group. + Examples: + .... Next ("Netscape|konqueror|Mozilla*") WarpToWindow 99 90 .... + This goes to the next web browser window, no matter which of the three named web browsers is being used. + .... Next ("Mozilla*", "Bookmark*") WarpToWindow 99 90 .... + This goes to Mozilla's bookmark manager window, ignoring other Mozilla windows and other browsers' bookmark windows. + .... All ("XTerm|rxvt", !console) Iconify .... + This iconifies all the xterm and rxvt windows on the current page, except that the one named "console" (with the -name option to xterm) is excluded. + .... Next (!"FvwmPager|FvwmForm*|FvwmButtons") Raise Next (!FvwmPager, !FvwmForm*, !FvwmButtons) Raise .... + These two commands are equivalent; either one raises the next window which is not one of the named fvwm modules. + Any condition can be negated by using a an exclamation mark ('!') directly in front of its name. + _AcceptsFocus_, _AnyScreen_, _CirculateHit_, _CirculateHitIcon_, _CirculateHitShaded_, _Closable_, _CurrentDesk_, _CurrentGlobalPage_, _CurrentGlobalPageAnyDesk_, _CurrentPage_, _CurrentPageAnyDesk_, _CurrentScreen_, _Desk_, _FixedPosition_, _FixedSize_, _Focused_, _HasBorders_, _HasHandles_, _HasPointer_, _HasTitle_, _TitleAtTop_, _TitleAtBottom_, _TitleAtLeft_, _TitleAtRight_, _Iconic_, _Iconifiable_, _Layer [n]_, _Maximizable_, _Maximized_, _Overlapped_, _PlacedByButton n_, _PlacedByButton3_, _PlacedByFvwm_, _Raised_, _Shaded_, _State n_, _Sticky_, _StickyAcrossDesks_, _StickyAcrossPages_, _StickyIcon_, _StickyAcrossDesksIcon_, _StickyAcrossPagesIcon_, _Transient_, _Visible_. + The _AcceptsFocus_ condition excludes all windows that do not want the input focus (the application has set the "Input hints" for the window to False) and do not use the _Lenience_ option of the *Style* command. Also, all windows using the _NeverFocus_ style are ignored. Note: _!Lenience_ is equivalent to the deprecated option _NoLenience_. + With the _AnyScreen_ condition used together with any of the _Current..._ conditions, windows that do not intersect the screen containing the mouse pointer are considered for a match too. For example: + .... # Focus next window on current page, # regardless of screen Next (CurrentPage, AnyScreen) Focus .... + The _CirculateHit_ and _CirculateHitIcon_ options override the _CirculateSkip_ and _CirculateSkipIcon_ *Style* attributes for normal or iconic windows. The _CirculateHitShaded_ option overrides the _CirculateSkipShaded_ *Style.* All three options are turned on by default for the *Current* command. They can be turned off by specifying _!CirculateHit_ etc. explicitly. Note: Do not confuse these conditions with the style options of the same name. Specifically, + .... Style foo CirculateSkip Next (foo, CirculateHit) ... .... + is not the same as + .... Style foo CirculateHit ... Next (foo) .... + The prior selects windows with the name foo only in the Next command. In the second example, these windows are always matched in all conditional commands. + The _Closable_ condition matches only windows that are allowed to be closed. + The _CurrentDesk_ condition matches only windows that are on the current desk. + The _CurrentGlobalPage_ condition matches only windows that are on the current page of the current desk, regardless of which screen the window is on. This condition implicitly activates the _CurrentDesk_ condition. + The _CurrentGlobalPageAnyDesk_ condition matches only windows that are on the current page of any desk, regardless of RandR screen . + The _CurrentPage_ condition matches only windows that are on the current page of the current desk. This condition implicitly activates the _CurrentDesk_ condition. + The _CurrentPageAnyDesk_ and _CurrentScreen_ conditions matches only windows that are on the current page of any desk. + The _Screen [name]_ condition matches only windows which are on the specified screen. + The _Desk [n]_ condition matches only windows which are on the specified desk. + The _FixedPosition_ condition excludes all windows that do not have a fixed position, either set through WM hints or the *Style* option _FixedPosition_. Example: + .... DestroyFunc ToggleFixedGeometry AddToFunc ToggleFixedGeometry + I Pick (FixedPosition) \ WindowStyle VariablePosition, VariableSize + I TestRc (NoMatch) WindowStyle FixedPosition, FixedSize .... + The _FixedSize_ condition excludes all windows that do not have a fixed size, either set through WM hints or the *Style* option _FixedSize_. + The _Focused_ matches on the window that currently has the keyboard focus. This is not useful for the *Current* command but can be used with the other conditional commands. + The _HasBorders_ condition excludes all windows that do not have borders. + The _HasHandles_ condition excludes all windows that do not have resize handles. + The _HasPointer_ condition excludes all windows that do not contain the pointer. + The _HasTitle_ condition excludes all windows that do not have a titlebar. + The _TitleAtTop_, _TitleAtBottom_, _TitleAtLeft_, _TitleAtRight_ conditions test for the titlebar at that window location. + The _Iconic_ condition matches only iconic windows. + The _Iconifiable_ condition matches only windows that are allowed to be iconified. + The _Layer [n]_ condition matches only windows on the specified layer. The optional argument of the _Layer_ condition defaults to the layer of the focused window. The negation _!Layer_ switches off the _Layer_ condition. + The _Maximizable_ condition matches only windows that are allowed to be maximized. + The _Maximized_ condition matches only maximized windows. + The _Overlapped_ condition matches only windows that are overlapped by other windows on the same layer (or unmanaged windows if the option _RaiseOverUnmanaged_ of the *BugOpts* command is used). Note that this condition can be slow if you have many windows or if RaiseOverUnmanaged is used and the connection to the X server is slow. + The _PlacedByButton n_ condition is fulfilled if the last interactive motion of the window (with the *Move* command or as _ManualPlacement_) was ended by pressing mouse button _n_. Example: + .... Mouse 1 T A Function MoveWindow DestroyFunc MoveWindow AddToFunc MoveWindow + C Move + C ThisWindow (PlacedByButton 5) WindowShade off + C TestRc (Match) Maximize on 0 100 + C ThisWindow (PlacedByButton 4) WindowShade on .... + The _PlacedByButton3_ condition has the same meaning as _PlacedByButton_ 3. It remains only for backward compatibility. + The _PlacedByFvwm_ condition excludes all windows that have been placed manually or by using the user or program position hint. + The _Raised_ conditions matches only windows that are fully visible on the current viewport and not overlapped by any other window. + The _Shaded_ conditions matches only shaded windows (see *WindowShade* command). + The _State n_ or _!State n_ conditions match only windows with the specified integer state set (or unset). See the *State* command for details. The argument may range from 0 to 31. + The _Sticky_, _StickyAcrossDesks_ and _StickyAcrossPages_ match only windows that are currently sticky, sticky across all desks or sticky across all pages. Please refer to the *Style* options with the same name and the commands *Stick*, *StickAcrossDesks* and *StickAcrossPages* for details. + The _StickyIcon_, _StickyAcrossDesksIcon_ and _StickyAcrossPagesIcon_ match only windows that become sticky, sticky across all desks or sticky across all pages when they are in iconified state. + The _Transient_ condition matches only windows that have the "transient" property set by the application. This it usually the case for application popup menus and dialogs. The *FvwmIdent* module can be used to find out whether a specific window is transient. + The _Visible_ condition matches only windows that are at least partially visible on the current viewport and not completely overlapped by other windows. === Module Commands Fvwm maintains a database of module configuration lines in a form .... *: .... where __ is either a real module name or an alias. This database is initially filled from config file (or from output of *-cmd* config command), and can be later modified either by user (via *FvwmCommand*) or by modules. When modules are run, they read appropriate portion of database. (The concept of this database is similar to one used in X resource database). Commands for manipulating module configuration database are described below. **+*+** _module_config_line_:: Defines a module configuration. _module_config_line_ consists of a module name (or a module alias) and a module resource line. The new syntax allows a delimiter, a colon and optional spaces, between the module name and the rest of the line, this is recommended to avoid conflicts. + .... *FvwmPager: WindowBorderWidth 1 *FvwmButtons-TopRight: Geometry 100x100-0+0 *FvwmButtons-Bottom: Geometry +0-0 .... *DestroyModuleConfig* _module_config_:: Deletes module configuration entries, so that new configuration lines may be entered instead. This also sometimes the only way to turn back some module settings, previously defined. This changes the way a module runs during a fvwm session without restarting. Wildcards can be used for portions of the name as well. + The new non-conflicting syntax allows a delimiter, a colon and optional spaces between the module name and the rest of the line. In this case a module name (or alias) can't have wildcards. + .... DestroyModuleConfig FvwmButtons* DestroyModuleConfig FvwmForm: Fore DestroyModuleConfig FvwmIconMan: Tips* .... *KillModule* _modulename_ [_modulealias_]:: Causes the module which was invoked with name _modulename_ to be killed. The name may include wildcards. If _modulealias_ is given, only modules started with the given alias are killed. + .... # kill all pagers KillModule FvwmPager Module FvwmEvent SoundEvent KillModule FvwmEvent SoundEvent .... *Module* _modulename_ [_moduleparams_]:: Specifies a module with its optional parameters which should be spawned. Currently several modules, including *FvwmButtons*, *FvwmEvent*, *FvwmForm*, *FvwmPager*, *FvwmScript* support aliases. Aliases are useful if more than one instance of the module should be spawned. Aliases may be configured separately using *** syntax. To start a module *FvwmForm* using an alias _MyForm_, the following syntax may be used: + .... Module FvwmForm MyForm .... + At the current time the available modules (included with fvwm) are *FvwmAnimate* (produces animation effects when a window is iconified or de-iconified), *FvwmAuto* (an auto raise module), *FvwmBacker* (to change the background when you change desktops), *FvwmBanner* (to display a spiffy XBM, XPM, PNG or SVG), *FvwmButtons* (brings up a customizable tool bar), *FvwmCommandS* (a command server to use with shell's FvwmCommand client), *FvwmConsole* (to execute fvwm commands directly), *FvwmCpp* (to preprocess your _config_ with cpp), *FvwmEvent* (trigger various actions by events), *FvwmForm* (to bring up dialogs), *FvwmIconMan* (a flexible icon manager), *FvwmIdent* (to get window info), *FvwmM4* (to preprocess your _config_ with m4), *FvwmPager* (a mini version of the desktop), *FvwmPerl* (a Perl manipulator and preprocessor), *FvwmProxy* (to locate and control obscured windows by using small proxy windows), *FvwmRearrange* (to rearrange windows), *FvwmScript* (another powerful dialog toolkit), These modules have their own man pages. There may be other modules out on there as well. + Modules can be short lived transient programs or, like *FvwmButtons* , can remain for the duration of the X session. Modules are terminated by the window manager prior to restarts and quits, if possible. See the introductory section on modules. The keyword *Module* may be omitted if _modulename_ is distinct from all fvwm commands. *ModuleListenOnly* _modulename_ [_moduleparams_]:: This command works like the *Module* command, but fvwm never sends any messages to the module. This may be handy to write a module as a shell script that is triggered by external events without the burden to answer packets sent by fvwm. For example, a module written as a shell script may change labels of the *FvwmButtons* module to implement a simple clock. *ModulePath* _path_:: Specifies a colon separated list of directories in which to search for modules. To find a module, fvwm searches each directory in turn and uses the first file found. Directory names on the list do not need trailing slashes. + The *ModulePath* may contain environment variables such as _$HOME_ (or _$\{HOME}_). Further, a '+' in the _path_ is expanded to the previous value of the _path_, allowing easy appending or prepending to the _path_. + For example: + .... ModulePath ${HOME}/lib/fvwm/modules:+ .... + The directory containing the standard modules is available via the environment variable _$FVWM_MODULEDIR_. *ModuleSynchronous* [Expect _string_] [Timeout _secs_] _modulename_:: The *ModuleSynchronous* command is very similar to *Module*. Fvwm stops processing any commands and user input until the module sends a string beginning with "NOP FINISHED STARTUP" back to fvwm. If the optional _Timeout_ is given fvwm gives up if the module sent no input back to fvwm for _secs_ seconds. If the _Expect_ option is given, fvwm waits for the given _string_ instead. *ModuleSynchronous* should only be used during fvwm startup to enforce the order in which modules are started. This command is intended for use with the (currently hypothetical) module that should be in place before other modules are started. + **Warning**: It is quite easy to hang fvwm with this command, even if a timeout is given. Be extra careful choosing the string to wait for. Although all modules in the fvwm distribution send back the "NOP FINISHED STARTUP" string once they have properly started up, this may not be the case for third party modules. Moreover, you can try to escape from a locked *ModuleSynchronous* command by using the key sequence + (see the *EscapeFunc*). *ModuleTimeout* _timeout_:: Specifies how many seconds fvwm waits for a module to respond. If the module does not respond within the time limit then fvwm kills it. _timeout_ must be greater than zero, or it is reset to the default value of 30 seconds. *SendToModule* _modulename_ _string_:: Sends an arbitrary string (no quotes required) to all modules, whose alias or name matching _modulename_, which may contain wildcards. This only makes sense if the module is set up to understand and deal with these strings though. Can be used for module to module communication, or implementation of more complex commands in modules. === Session Management Commands *Quit*:: Exits fvwm, generally causing X to exit too. *QuitScreen*:: Causes fvwm to stop managing the screen on which the command was issued. *Restart* [_window_manager_ [_params_]]:: Causes fvwm to restart itself if _window_manager_ is left blank, or to switch to an alternate window manager (or other fvwm version) if _window_manager_ is specified. If the window manager is not in your default search path, then you should use the full path name for _window_manager_. + This command should not have a trailing ampersand. The command can have optional parameters with simple shell-like syntax. You can use _~_ (is expanded to the user's home directory) and environmental variables _$VAR_ or _$\{VAR}_. Here are several examples: + .... Key F1 R N Restart Key F1 R N Restart fvwm -s Key F1 R N Restart fvwm1 -s -f .fvwmrc Key F1 R N Restart xterm -n '"X console"' -T \"X\ console\" -e fvwm -s .... + Note, currently with multi headed displays, restart of fvwms on different screens works independently. + *Restart* *--pass-args* _window_manager_:: The same as *Restart* without parameters but the name for the current window manager is replaced with the specified _window_manager_ and original arguments are preserved. + *Restart* *--dont-preserve-state* [_other-params_]:: The same as + .... Restart [other-params] .... + but it does not save any window states over the restart. + Without this option, *Restart* preserves most per-window state by writing it to a file named _.fs-restart-$HOSTDISPLAY_ in the user's home directory. *SaveSession*:: Causes a session manager (if any) to save the session. This command does not work for xsm, it seems that xsm does not implement this functionality. Use Unix signals to manage xsm remotely. *SaveQuitSession*:: Causes a session manager (if any) to save and then shutdown the session. This command does not work for xsm, it seems that xsm does not implement this functionality. Use Unix signals to manage xsm remotely. === Colorsets Colorsets are a powerful method to control colors. Colorsets create appearance resources that are shared by fvwm and its modules. When a colorset is modified all parts of fvwm react to that change. A colorset includes a foreground color, background color, shadow and highlight color (often based on the background color), background face (this includes images and all kinds of gradients). There is a way to render background face and specify other color operations. *Colorset* _num_ [_options_]:: Creates or modifies colorset _num_. Colorsets are identified by this number. The number can start at zero and can be a very large number. + Warning: The highest colorset number used determines memory consumption. Thus, if you define 'Colorset 100000', the memory for 100001 colorsets is used. Keep your colorset numbers as small as possible. + By convention, colorsets are numbered like this: + .... # 0 = Default colors # 1 = Inactive windows # 2 = Active windows # 3 = Inactive menu entry and menu background # 4 = Active menu entry # 5 = greyed out menu entry (only bg used) # 6 = module foreground and background # 7 = hilight colors .... + If you need to have more colors and do not want to reinvent the wheel, you may use the convention used in fvwm-themes, it defines the meaning of the first 40 colorsets for nearly all purposes: + _http://fvwm-themes.sourceforge.net/doc/colorsets_ + Each colorset has four colors, an optional pixmap and an optional shape mask. The four colors are used by modules as the foreground, background, highlight and shadow colors. When a colorset is created it defaults to a foreground of black and background of gray. The background and foreground are marked as "average" and "contrast" (see later) so that just specifying a pixmap or gradient gives sensible results. + _options_ is a comma separated list containing some of the keywords: fg, Fore, Foreground, bg, Back, Background, hi, Hilite, Hilight, sh, Shade, Shadow, fgsh, Pixmap, TiledPixmap, AspectPixmap, Transparent, RootTransparent, Shape, TiledShape, AspectShape, NoShape, ?Gradient, Tint, fgTint, bgTint, Alpha, fgAlpha, Dither, NoDither, IconTint, IconAlpha, Plain. + _fg_, _Fore_ and _Foreground_ take a color name as an argument and set the foreground color. The special name _Contrast_ may be used to select a color that contrasts well with the background color. To reset the foreground color to the default value you can simply omit the color name. + _bg_, _Back_ and _Background_ take a color name as an argument and set the background color. It also sets the highlight and shadow colors to values that give a 3d effect unless these have been explicitly set with the options below. The special name _Average_ may be used to select a color that is the average color of the pixmap. If the pixmap is tinted with the _Tint_ option, the tint is not taken in account in the computation of the average color. You should use the _bgTint_ option to get the "real" average color. The background color is reset to the default value if the color name is omitted. + _hi_, _Hilite_ and _Hilight_ take a color name as an argument and set the highlight color. If the highlight color is not explicitly set, the default is to calculate it from the background color. To switch back to the default behavior the color name can be omitted. + _sh_, _Shade_ and _Shadow_ take a color name as an argument and set the shadow color. If the shadow color is not explicitly set, the default is to calculate it from the background color. To switch back to the default behavior the color name can be omitted. + _fgsh_ takes a color name as an argument and sets the color used by the shadowing font effect. See the *Font Shadow Effects* section of the fvwm man page. By default this color is computed from the foreground and background colors. To switch back to the default the color name can be omitted. + _Pixmap_, _TiledPixmap_ and _AspectPixmap_ take a file name as an argument, search the *ImagePath* and use it as the background pixmap. Any transparent parts are filled with the background color. Not specifying a file name removes any existing image from the colorset. _TiledPixmap_ produces repeated copies of the image with no scaling, _Pixmap_ causes the image to be stretched to fit whatever object the colorset is applied to and _AspectPixmap_ stretches to fit but retains the image aspect ratio. + _Transparent_ creates a transparent background pixmap. The pixmap is used as a window background to achieve root transparency. For this you should use the _ParentalRelativity_ option to the *Style* command. A subsequent root background change may be detected or not, this depends on the program used to set the background. If you use *fvwm-root*, *xsetbg* (xli), *FvwmBacker* with solid or colorset colors or a recent version of *Esetroot* (>= 9.2) a background change is detected. If background changes are not detected (e.g., if you use *xv* or *xsetroot*) you can force detection by using the *-d* option of fvwm-root: + .... xv -root -quit mybg.png; fvwm-root -d .... + Due to the way X implements transparency no guarantees can be made that the desired effect can be achieved. The application may even crash. If you experience any problems with this option, do not use it. + Using outline move and resize (see the *OpaqueMoveSize* command and the _ResizeOpaque_ *Style* option) as well as setting the _WindowShadeShrinks_ style may help. The transparency achieved with _Transparent_ depends on whether the colorset is applied to the foreground or the background of a window. In the second case the transparency is relative to the parent window of the window on which the colorset is defined. For example: + .... Colorset 12 VGradient 200 grey30 grey60 Colorset 17 Transparent *FvwmIconMan: Colorset 12 *FvwmIconMan: PlainColorset 17 .... + gives an IconMan with a vertical grey gradient background and the buttons use the background (by transparency). To obtain a (root) transparent IconMan: + .... Colorset 12 Transparent Colorset 17 Transparent Colorset 18 Transparent Colorset 19 Transparent *FvwmIconMan: Colorset 12 *FvwmIconMan: PlainColorset 17 *FvwmIconMan: FocusColorset 18 *FvwmIconMan: IconColorset 19 .... + The Colorset IconMan option defines the IconMan window background, but the PlainColorset and the FocusColorset are drawn on the foreground. So, the transparency of the IconMan buttons is achieved by drawing nothing. Now if this IconMan is swallowed in an FvwmButtons as: + .... FvwmButtons:(Colorset 10, Swallow "FvwmIconMan" 'FvwmIconMan') .... + then, *FvwmIconMan* becomes a child of *FvwmButtons* and it is transparent relative to *FvwmButtons*. So, in this case *FvwmIconMan* uses Colorset 10 as background. If you want root transparency use the _RootTransparent_ option. *FvwmButtons* *FvwmIconMan*, and *FvwmIdent*, are relatively simple. There is one main colorset option which defines the background of the window and the other colorsets (if any) are drawn on the foreground. The case of *FvwmProxy* is simpler, the two colorsets refer to the window backgrounds. *FvwmPager* is more complicated as almost everything in the pager are windows with some parental relations (the mini windows are the child and the desktops are the parents and all this is complicated by the hilighted page). So, the colorsets apply to the background of these windows. You should experiment. For *FvwmForm* and *FvwmScript* the situation is similar. There is a main window (a child of the root window) which corresponds to the main colorset and most of the widgets are windows which are children of the main window. _Tint_ may work or not with the _Transparent_ option. When the colorset is drawn on the foreground _Tint_ should work. In some cases, tinting may be very slow. Tinting may work with fvwm menu (without animation). Tinting may work better if your X server has backing store enabled (try xdpyinfo to see if this the case). There is a chance that the backing store support of your X server does not work well with the terrible hack used to Tint the ParentRelative Pixmap. So, to get tinted root transparency it is more safe to use the _RootTransparent_ option. + _RootTransparent_ [ _buffer_ ] creates a root transparent background. To make this option work, you must use an *Esetroot* compatible program, fvwm-root with the --retain-pixmap option or *FvwmBacker* with the RetainPixmap option (and colorset or solid backgrounds). The _buffer_ keyword is useful only when the _Tint_ option is used too. This speeds up creation of windows which use the colorset (useful for fvwm menus) at the cost of memory usage. It also speeds up opaque move and resize which can be unacceptably slow without _buffer_. However, this option may add a lot of memory to your X server (depending on the size of the image used to set the background). In summary, using outline move and resize for modules which use such a colorset may be a good idea. + _Shape_, _TiledShape_ and _AspectShape_ take a file name as an argument, search the *ImagePath* and use it as the shape bitmap. _TiledShape_ produces repeated copies of the bitmap with no scaling, _Shape_ causes the bitmap to be stretched to fit whatever object the colorset is applied to and _AspectShape_ stretches to fit but retains the bitmap aspect ratio. If the file is a pixmap in xpm format the shape mask (all opaque pixels) of the pixmap is used. For png and svg images, the shape mask is equivalent to all not completely transparent pixels (alpha > 0). + *Warning* Due to the way X11 implements shapes you cannot take back making windows shaped. You may have to restart fvwm or the shaped application. + _?Gradient ..._ creates a pixmap and stretches it to fit the window. _?Gradient_ may be one of _HGradient_, _VGradient_, _DGradient_, _BGradient_, _SGradient_, _CGradient_, _RGradient_ or _YGradient_. The gradient types are as follows: H is horizontal; V is vertical; D is diagonal from top left to bottom right; B is a backwards diagonal from bottom left to top right; S is concentric squares; C is concentric circles; R is a radar like pattern and Y is a Yin Yang style (but without the dots). Please refer to the *Color Gradients* section for the syntax of gradients. + _Tint_ takes 2 arguments, a color and a percentage between 0 and 100. It causes the image defined using _?Pixmap_ or _?Gradient_ to be tinted with the specified color using the percentage. If the image is transparent _Tint_ tints only the image part. Unfortunately, a colorset background specified using the _Transparent_ option can give strange results. See the _Transparent_ option for details. With no arguments this option removes the tint. + _fgTint_ takes 2 arguments, a color and a percentage between 0 and 100. It causes the color defined using _fg_ to be tinted with the specified color using the percentage. With no arguments this option removes the tint. + _bgTint_ takes 2 arguments, a color and a percentage between 0 and 100. It causes the color defined using _bg_ to be tinted with the specified color using the percentage. If the _sh_ and _hi_ colors are not specified, they are recomputed from the tinted bg color. With no arguments this option removes the tint. + _Alpha_ takes a percentage between 0 and 100 as an argument. It causes fvwm to merge the image defined using _?Pixmap_ or _?Gradient_ with the _bg_ color using the percentage. If the percentage is 0 the image is hidden and if it is 100 the image is displayed as usual (no merge). The default is 100 and it is restored if no argument is given. + _fgAlpha_ takes a percentage between 0 and 100 as an argument. It causes fvwm to merge the text and the colorset background using the percentage. If the percentage is 0 the text is hidden and if it is 100 the text is displayed as usual (no merge). This option has an effect only with fonts loaded by Xft, see the *Font Names and Font Loading* section. The default is 100 and it is restored if no argument is given. + _Dither_ causes fvwm to dither the image defined using _?Pixmap_ or _?Gradient._ This is useful only with displays with depth less than or equal to 16 (i.e., on displays which can only display less than 65537 colors at once). The dithering effect lets you simulate having more colors available that you actually have. _NoDither_ causes fvwm to do not dither the images. _Dither_ is the default if the depth is less than or equal to 8 (a screen with 256 colors or less). In depth 15 (32768 colors) and 16 (65536 colors), the default is _NoDither_, however this effect can be useful with images which contain a lot of close colors. For example a fine gradient looks more smooth. + _IconTint_ takes 2 arguments, a color and a percentage between 0 and 100. It causes fvwm or a module to tint the "icons" which are rendered into the colorset background with the specified color using a percentage. Here "icons" means, fvwm Icons, fvwm menu icons, MiniIcons which represent applications in various modules, images loaded by modules (e.g., images specified by the _Icon_ *FvwmButtons* button option) ...etc. With no arguments this option removes the icon tint. _IconAlpha_ takes a percentage between 0 and 100 as an argument. It causes fvwm to merge the "icons" which are rendered into the colorset background using this percentage. The default is 100 and it is restored if no argument is given. _Note_: It is equivalent to use "Tint a_color rate" and "Alpha a" if a = 100 and the bg color is a_color. This equivalence does not hold for IconAlpha and IconTint as the background can be an image or a gradient (and not a uniform color background). However, in some cases you can achieve (almost) the same effect by using IconTint in the place of IconAlpha. This is preferable as, in general, IconAlpha generates more redrawing than IconTint. _NoShape_ removes the shape mask from the colorset while _Plain_ removes the background pixmap or gradient. Examples .... Colorset 3 fg tan, bg navy .... If necessary this creates colorsets 0, 1, 2 and 3 and then changes colorset 3 to have a foreground of tan, a background of navy. .... Colorset 3 bg "navy blue" .... changes the background color of colorset 3 to navy blue. The foreground and pixmap are unchanged. .... Colorset 3 AspectPixmap large_murky_dungeon.xpm .... causes depression. .... Colorset 3 bg Average .... Sets the background color and the relief colors to match the background pixmap. This is the default setting but it must be used if a background color was specified and is now not required. .... Colorset 3 YGradient 200 3 blue 1000 navy 1 blue 1000 navy .... Adds a Yin Yang gradient background pixmap to colorset 3. If the background is set to average it is recomputed along with the foreground if that is set to contrast. .... #!/bin/sh FvwmCommand "Colorset 7 fg navy, bg gray" while true do FvwmCommand "Colorset 7 fg gray" sleep 1 FvwmCommand "Colorset 7 fg navy" sleep 1 done .... Makes colorset 7 blink. The color names used in colorsets are saved as fvwm variables which can be substituted in any fvwm command. For example: .... AddToFunc InitFunction + I Exec exec xterm -fg $[fg.cs0] -bg $[bg.cs0] .... Where $[fg.cs0] is the foreground color of colorset zero. Please refer to the *Command Expansion* section for more information. *CleanupColorsets*:: Resets a definition of all colorsets. *Color Gradients*:: A color gradient is a background that changes its color gradually from one hue to a different one. Color gradients can be used by various commands and modules of fvwm. There are eight types of gradients: *HGradient* is a horizontal gradient, *VGradient* is vertical, *DGradient* is diagonal from top left to bottom right, *BGradient* is backwards diagonal from bottom left to top right, *SGradient* is concentric squares, *CGradient* is concentric circles, *RGradient* is a radar like pattern and *YGradient* is a Yin Yang style (but without the dots). + The color gradient syntax has two forms: + *?Gradient* _colors_ _start-color_ _end-color_ + This form specifies a linear gradient. The arguments denote the total number of _colors_ to allocate (between 2 and 1000), the initial color and the final color. + Example: + .... TitleStyle VGradient 20 rgb:b8/ce/bc rgb:5b/85/d0 .... + *?Gradient* _colors_ _segments_ _color_ _length_ _color_ [_length_ _color_] ... + The second form specifies a nonlinear gradient. The arguments are: the total number of _colors_ to allocate (between 2 and 1000), then the number of _segments_. For each segment, specify the starting _color_, a relative _length_, then the ending color. Each subsequent segment begins with the second color of the last segment. The lengths may be any non-negative integers. The length of one segment divided by the sum of all segments lengths is the fraction of the colors that are used for the segment. + Examples: + .... Colorset 0 DGradient 128 2 lightgrey 50 blue 50 white # 20% gradient from red to blue, # 30% from blue to black, # 50% from black to grey Colorset 0 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 .... Note: Some gradient styles 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