The stumpwm Reference Manual

This is the stumpwm Reference Manual, version 1.0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 17:58:55 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 stumpwm

A tiling, keyboard driven window manager

Maintainer

David Bjergaard <>

Author

Shawn Betts <>

Version

1.0.1

Dependencies
  • alexandria (system).
  • cl-ppcre (system).
  • clx (system).
  • sb-posix (system).
  • sb-introspect (system).
  • dynamic-mixins-swm (system).
Source

stumpwm.asd.

Child Components

2.2 dynamic-mixins-swm

Simple dynamic class mixing without manual permutations

Author

Ryan Pavlik

License

BSD-2-Clause

Version

0.0

Dependency

alexandria (system).

Source

dynamic-mixins-swm.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


3.1.1 stumpwm/stumpwm.asd

Source

stumpwm.asd.

Parent Component

stumpwm (system).

ASDF Systems

stumpwm.

Packages

stumpwm-system.


3.1.2 dynamic-mixins-swm/dynamic-mixins-swm.asd

Source

dynamic-mixins-swm.asd.

Parent Component

dynamic-mixins-swm (system).

ASDF Systems

dynamic-mixins-swm.

Packages

dynamic-mixins-swm.asdf.


3.1.3 stumpwm/package.lisp

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Packages

3.1.4 stumpwm/debug.lisp

Dependency

package.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.5 stumpwm/primitives.lisp

Dependency

debug.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.6 stumpwm/wrappers.lisp

Dependency

primitives.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.7 stumpwm/pathnames.lisp

Dependency

wrappers.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.8 stumpwm/font-rendering.lisp

Dependency

pathnames.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Internals

3.1.9 stumpwm/keysyms.lisp

Dependency

font-rendering.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Internals

3.1.10 stumpwm/keytrans.lisp

Dependency

keysyms.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Internals

3.1.11 stumpwm/kmap.lisp

Dependency

keytrans.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.12 stumpwm/input.lisp

Dependency

kmap.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.13 stumpwm/core.lisp

Dependency

input.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.14 stumpwm/command.lisp

Dependency

core.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.15 stumpwm/menu-declarations.lisp

Dependency

command.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.16 stumpwm/menu-definitions.lisp

Dependency

menu-declarations.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.17 stumpwm/screen.lisp

Dependency

menu-definitions.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.18 stumpwm/head.lisp

Dependency

screen.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.19 stumpwm/group.lisp

Dependency

head.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.20 stumpwm/bindings.lisp

Dependency

group.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.21 stumpwm/events.lisp

Dependency

bindings.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface

*button-state* (special variable).

Internals

3.1.22 stumpwm/window.lisp

Dependency

events.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.23 stumpwm/floating-group.lisp

Dependency

window.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.24 stumpwm/tile-window.lisp

Dependency

floating-group.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.25 stumpwm/tile-group.lisp

Dependency

tile-window.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.26 stumpwm/window-placement.lisp

Dependency

tile-group.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Internals

3.1.27 stumpwm/message-window.lisp

Dependency

window-placement.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.28 stumpwm/selection.lisp

Dependency

message-window.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.29 stumpwm/module.lisp

Dependency

selection.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.30 stumpwm/ioloop.lisp

Dependency

module.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

sbcl-io-loop (class).


3.1.31 stumpwm/timers.lisp

Dependency

ioloop.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.32 stumpwm/stumpwm.lisp

Dependency

timers.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.33 stumpwm/user.lisp

Dependency

stumpwm.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.34 stumpwm/interactive-keymap.lisp

Dependency

user.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.35 stumpwm/iresize.lisp

Dependency

interactive-keymap.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.36 stumpwm/help.lisp

Dependency

iresize.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.37 stumpwm/fdump.lisp

Dependency

help.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.38 stumpwm/time.lisp

Dependency

fdump.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.39 stumpwm/mode-line.lisp

Dependency

time.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.40 stumpwm/mode-line-formatters.lisp

Dependency

mode-line.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.41 stumpwm/color.lisp

Dependency

mode-line-formatters.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.42 stumpwm/wse.lisp

Dependency

color.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.43 stumpwm/dynamic-window.lisp

Dependency

wse.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface

expose (function).

Internals

3.1.44 stumpwm/dynamic-group.lisp

Dependency

dynamic-window.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.45 stumpwm/remap-keys.lisp

Dependency

dynamic-group.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.46 stumpwm/manual.lisp

Dependency

remap-keys.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Internals

3.1.47 stumpwm/minor-modes.lisp

Dependency

manual.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface
Internals

3.1.48 stumpwm/replace-class.lisp

Dependency

minor-modes.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface

3.1.49 stumpwm/version.lisp

Dependency

replace-class.lisp (file).

Source

stumpwm.asd.

Parent Component

stumpwm (system).

Public Interface

3.1.50 dynamic-mixins-swm/package.lisp

Source

dynamic-mixins-swm.asd.

Parent Component

dynamic-mixins-swm (system).

Packages

dynamic-mixins-swm.


3.1.51 dynamic-mixins-swm/sorting.lisp

Dependency

package.lisp (file).

Source

dynamic-mixins-swm.asd.

Parent Component

dynamic-mixins-swm (system).

Public Interface
Internals

3.1.52 dynamic-mixins-swm/dynamic-mixins.lisp

Dependency

sorting.lisp (file).

Source

dynamic-mixins-swm.asd.

Parent Component

dynamic-mixins-swm (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 stumpwm

Source

package.lisp.

Use List
  • alexandria.
  • common-lisp.
Used By List

stumpwm-user.

Public Interface
Internals

4.2 dynamic-mixins-swm

Source

package.lisp.

Use List
  • alexandria.
  • common-lisp.
Public Interface
Internals

4.3 stumpwm-user

Source

package.lisp.

Use List

4.4 stumpwm-system

Source

stumpwm.asd.

Use List
  • asdf/interface.
  • common-lisp.

4.5 dynamic-mixins-swm.asdf

Source

dynamic-mixins-swm.asd.

Use List
  • asdf/interface.
  • common-lisp.

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


5.1.1 Constants

Constant: +iconic-state+
Package

stumpwm.

Source

primitives.lisp.

Constant: +normal-state+
Package

stumpwm.

Source

primitives.lisp.

Constant: +withdrawn-state+
Package

stumpwm.

Source

primitives.lisp.


5.1.2 Special variables

Special Variable: *all-modifiers*

A list of all keycodes that are considered modifiers

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *altgr-offset*

The offset of altgr keysyms. Often 2 or 4, but always an even number.

Package

stumpwm.

Source

kmap.lisp.

Special Variable: *banish-pointer-to*

Where to put the pointer when no argument is given to (banish-pointer) or the banish command. May be one of :screen :head :frame or :window

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *batch-menu-map*

The keymap used by batch-menu menus in addition to *menu-map*

Package

stumpwm.

Source

menu-declarations.lisp.

Special Variable: *button-state*

Modifier state keys for button presses.

Package

stumpwm.

Source

events.lisp.

Special Variable: *class-ordering-rules*

A plist of rules for how to order classes for mixing. Keys are the class names. Rules have the following shape:

(:before ((string-1 . package-designator-1)
(string-2 . package-designator-2)
...
(string-n . package-designator-n))
:after ((string-1 . package-designator-1)
(string-2 . package-designator-2)
...
(string-n . package-designator-n)))

Package

dynamic-mixins-swm.

Source

sorting.lisp.

Special Variable: *colors*

Eight colors by default. You can redefine these to whatever you like and then call (update-color-map).

Package

stumpwm.

Source

color.lisp.

Special Variable: *command-mode-end-hook*

A hook called whenever command mode is ended

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *command-mode-start-hook*

A hook called whenever command mode is started

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *current-io-channel*

While processing an I/O channel, this variable is dynamically bound to the channel in question. This is provided primarily for error-handling code.

Package

stumpwm.

Source

ioloop.lisp.

Special Variable: *current-io-loop*

Dynamically bound to the I/O loop currently running, providing an easy way for event callbacks to register new channels.

Package

stumpwm.

Source

ioloop.lisp.

Special Variable: *data-dir*

The directory used by stumpwm to store data between sessions.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *debug-expose-events*

Set this variable for a visual indication of expose events on internal StumpWM windows.

Package

stumpwm.

Source

debug.lisp.

Special Variable: *debug-level*

Set this variable to a number > 0 to turn on debugging. The greater the number the more debugging output.

Package

stumpwm.

Source

debug.lisp.

Special Variable: *debug-stream*

This is the stream debugging output is sent to. It defaults to *error-output*. It may be more convenient for you to pipe debugging output directly to a file.

Package

stumpwm.

Source

debug.lisp.

Special Variable: *default-bg-color*

Default color for the desktop background.

Package

stumpwm.

Source

screen.lisp.

Special Variable: *default-group-name*

The name of the default group.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *default-io-loop*

The default I/O loop implementation. Should be generically optimal for the given LISP implementation and operating system.

Package

stumpwm.

Source

ioloop.lisp.

Special Variable: *default-package*

This is the package eval reads and executes in. You might want to set this to @code{:stumpwm} if you find yourself using a lot of internal stumpwm symbols. Setting this variable anywhere but in your rc file will have no effect.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *default-selections*

A keyword or list, one of:
:primary or ’(:primary) uses only the "primary" selection
:clipboard or ’(:clipboard) uses only the "clipboard" selection
Both can be specified in a list like ’(:primary :clipboard). In this case, set-x-selection will clobber both, and get-x-selection will default to the first item.

Package

stumpwm.

Source

selection.lisp.

Special Variable: *default-window-name*

The name given to a window that does not supply its own name.

Package

stumpwm.

Source

window.lisp.

Special Variable: *deny-map-request*

A list of window properties that stumpwm should deny matching windows’ requests to become mapped for the first time.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *deny-raise-request*

Exactly the same as @var{*deny-map-request*} but for raise requests.

Note that no denial message is displayed if the window is already visible.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *destroy-mode-line-hook*

Called whenever the mode-line is destroyed. It is called with argument, the mode-line

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *destroy-window-hook*

A hook called whenever a window is destroyed or withdrawn.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *display*

The display for the X server

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *editor-bindings*

A list of key-bindings for line editing.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *event-processing-hook*

A hook called inside stumpwm’s inner loop, before the default event processing takes place. This hook is run inside (with-event-queue ...).

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *executing-stumpwm-command*

True when executing external commands.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *focus-frame-hook*

A hook called when a frame is given focus. The hook functions are called with 2 arguments: the current frame and the last frame.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *focus-group-hook*

A hook called whenever stumpwm switches groups. It is called with 2 arguments: the current group and the last group.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *focus-window-hook*

A hook called when a window is given focus. It is called with 2 arguments: the current window and the last window (could be nil).

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *frame-indicator-text*

What appears in the frame indicator window?

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *frame-indicator-timer*

Keep track of the timer that hides the frame indicator.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *frame-number-map*

Set this to a string to remap the frame numbers to more convenient keys. For instance,

"hutenosa"

would map frame 0 to 7 to be selectable by hitting the appropriate homerow key on a dvorak keyboard. Currently, only single char keys are supported. By default, the frame labels are the 36 (lower-case) alphanumeric characters, starting with numbers 0-9.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *group-format*

The format string that decides what information will show up in the group listing. The following format options are available:

@table @asis
@item %n
Substitutes the group number translated via *group-number-map*, if there are more windows than *group-number-map* then will use the group-number.

@item %s
The group’s status. Similar to a window’s status.

@item %t
The group’s name.
@end table

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *group-formatters*

An alist of characters and formatter functions. The character can be used as a format character in @var{*group-format*}. When the character is encountered in the string, the corresponding function is called with a group as an argument. The functions return value is inserted into the string. If the return value isn’t a string it is converted to one using @code{prin1-to-string}.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *group-top-maps*

An alist of the top level maps for each group type. For a given group, all maps whose type matches the given group are active. So for a tile-group, both the group map and tile-group map are active.

Order is important. Each map is seached in the order they appear in the list (inactive maps being skipped). In general the order should go from most specific groups to most general groups.

Package

stumpwm.

Source

bindings.lisp.

Special Variable: *groups-map*

The keymap that group related key bindings sit on. It is bound to @kbd{C-t g} by default.

Package

stumpwm.

Source

bindings.lisp.

Special Variable: *help-keys*

The list of keys used to invoke the help command.

Package

stumpwm.

Source

bindings.lisp.

Special Variable: *help-map*

Help related bindings hang from this keymap

Package

stumpwm.

Source

bindings.lisp.

Special Variable: *help-max-height*

Maximum number of lines for help to display.

Package

stumpwm.

Source

help.lisp.

Special Variable: *hidden-window-color*

Color command for hidden windows when using the fmt-head-window-list-hidden-windows formatter. To disable coloring hidden windows, set this to an empty string.

Package

stumpwm.

Source

mode-line-formatters.lisp.

Special Variable: *honor-window-moves*

Allow windows to move between frames.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *hooks-enabled-p*

Controls whether hooks will actually run or not

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *ignore-wm-inc-hints*

Set this to T if you never want windows to resize based on incremental WM_HINTs, like xterm and emacs.

Package

stumpwm.

Source

tile-window.lisp.

Special Variable: *initializing*

True when starting stumpwm. Use this variable in your rc file to run code that should only be executed once, when stumpwm starts up and loads the rc file.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *input-candidate-selected-hook*
Package

stumpwm.

Source

input.lisp.

Special Variable: *input-completion-style*

The completion style to use.
A completion style has to implement input-completion-reset and input-completion-complete.
Available completion styles include
@table @asis
@item make-input-completion-style-cyclic
@item make-input-completion-style-unambiguous
@end table

Package

stumpwm.

Source

input.lisp.

Special Variable: *input-history-ignore-duplicates*

Do not add a command to the input history if it’s already the first in the list.

Package

stumpwm.

Source

input.lisp.

Special Variable: *input-map*

This is the keymap containing all input editing key bindings.

Package

stumpwm.

Source

input.lisp.

Special Variable: *input-window-gravity*

This variable controls where the input window appears. The following are valid values.
@table @asis
@item :top-left
@item :top-right
@item :bottom-left
@item :bottom-right
@item :center
@item :top
@item :left
@item :right
@item :bottom
@end table

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *internal-loop-hook*

A hook called inside stumpwm’s inner loop.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *key-press-hook*

A hook called whenever a key under *top-map* is pressed.
It is called with 3 argument: the key, the (possibly incomplete) key sequence it is a part of, and command value bound to the key.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *key-seq-color*

Color of a keybinding when displayed in windows such as the prefix keybinding in the which-key window.

Package

stumpwm.

Source

kmap.lisp.

Special Variable: *last-command*

Set to the last interactive command run.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *list-hidden-groups*

Controls whether hidden groups are displayed by ’groups’ and ’vgroups’ commands

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *load-path*

A list of paths in which modules can be found, by default it is populated by any asdf systems found in ‘*module-dir*’ set from the configure script when StumpWM was built, or later by the user using ‘add-to-load-path’

Package

stumpwm.

Source

module.lisp.

Special Variable: *max-last-message-size*

how many previous messages to keep.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *maximum-completions*

Maximum number of completions to show in interactive prompts. Setting this too high can crash the completion process due to drawing too far off screen.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *maxsize-border-width*

The width in pixels given to the borders of windows with maxsize or ratio hints.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *maxsize-gravity*
Package

stumpwm.

Source

primitives.lisp.

Special Variable: *menu-map*

The keymap used by the interactive menu.

Package

stumpwm.

Source

menu-declarations.lisp.

Special Variable: *menu-selection-hook*

Called after an item is selected in the windows menu. It is called with 1 argument: the menu.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *message-hook*

A hook called whenever stumpwm displays a message. The hook function is passed any number of arguments. Each argument is a line of text.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *message-max-width*

The maximum width of a message before it wraps.

Package

stumpwm.

Source

help.lisp.

Special Variable: *message-window-gravity*

This variable controls where the message window appears. The following are valid values.
@table @asis
@item :top-left
@item :top-right
@item :bottom-left
@item :bottom-right
@item :center
@item :top
@item :left
@item :right
@item :bottom
@end table

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *message-window-input-gravity*

This variable controls where the message window appears
when the input window is being displayed. The following are valid values. @table @asis
@item :top-left
@item :top-right
@item :bottom-left
@item :bottom-right
@item :center
@item :top
@item :left
@item :right
@item :bottom
@end table

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *message-window-padding*

The number of pixels that pad the text in the message window.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *message-window-timer*

Keep track of the timer that hides the message window.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *message-window-y-padding*

The number of pixels that pad the text in the message window vertically.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *min-frame-height*

The minimum height a frame can be. A frame will not shrink below this height. Splitting will not affect frames if the new frame heights are less than this value.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *min-frame-width*

The minimum width a frame can be. A frame will not shrink below this width. Splitting will not affect frames if the new frame widths are less than this value.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *minor-mode*

A dynamic variable bound to the minor mode object when executing a minor mode command.

Package

stumpwm.

Source

minor-modes.lisp.

Special Variable: *minor-mode-disable-hook*

A hook run whenever a minor mode is disabled. Functions are called with the minor mode symbol and the scope object. This is run when a minor mode is explicitly disabled via disable-minor-mode. This is run AFTER the minor mode has been disabled, and is called with the minor mode and the first object it was disabled in.

Package

stumpwm.

Source

minor-modes.lisp.

Special Variable: *minor-mode-enable-hook*

A hook run whenever a minor mode is enabled. Functions are called with the minor mode symbol and the object they have been added to. This is run when a minor mode is explicitly enabled via enable-minor-mode.

Package

stumpwm.

Source

minor-modes.lisp.

Special Variable: *minor-mode-maps*

A list of minor mode keymaps. An element of the list may be a single keymap or a function. If an element is a function it must take a group instance and return a list of keymaps.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *mode-line-background-color*

The mode line background color.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *mode-line-border-color*

The mode line border color.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *mode-line-border-width*

Specifies how thick the mode line’s border will be. Integer value.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *mode-line-click-hook*

Called whenever the mode-line is clicked. It is called with 4 arguments, the mode-line, the button clicked, and the x and y of the pointer.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *mode-line-foreground-color*

The mode line foreground color.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *mode-line-highlight-template*

The string passed to FORMAT to highlight things in the mode line.

Package

stumpwm.

Source

mode-line-formatters.lisp.

Special Variable: *mode-line-pad-x*

Specifies the number of padding pixels between the text and the side of the mode line. Integer value.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *mode-line-pad-y*

The number of padding pixels between the modeline text and the top/bottom of the modeline. Integer value.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *mode-line-position*

Specifies where the mode line is displayed. Valid values are :top and :bottom.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *mode-line-timeout*

The modeline updates after each command, when a new window appears or an existing one disappears, and on a timer. This variable controls how many seconds elapse between each update. If this variable is changed while the modeline is visible, you must toggle the modeline to update timer.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *modifiers*

A mapping from modifier type to x11 modifier.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *module-dir*

The location of the contrib modules on your system.

Package

stumpwm.

Source

module.lisp.

Special Variable: *mouse-focus-policy*

The mouse focus policy decides how the mouse affects input
focus. Possible values are :ignore, :sloppy, and :click. :ignore means stumpwm ignores the mouse. :sloppy means input focus follows the mouse; the window that the mouse is in gets the focus. :click means input focus is transfered to the window you click on.

If *MOUSE-FOCUS-POLICY* holds any value other than those listed above, mouse focus will behave as though it contains :IGNORE

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *new-frame-action*

When a new frame is created, this variable controls what is put in the new frame. Valid values are

@table @code
@item :empty
The frame is left empty

@item :last-window
The last focused window that is not currently visible is placed in the frame. This is the default.
@end table

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *new-frame-hook*

A hook called when a new frame is created. The hook is called with the frame as an argument.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *new-head-hook*

A hook called whenever a head is added. It is called with 2 arguments: the new head and the current screen.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *new-mode-line-hook*

Called whenever the mode-line is created. It is called with argument, the mode-line

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *new-window-hook*

A hook called whenever a window is added to the window list. This includes a genuinely new window as well as bringing a withdrawn window back into the window list.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *new-window-preferred-frame*

This variable controls what frame a new window appears in. It is a
list of preferences. The first preference that is satisfied is
used. Valid list elements are as follows:

@table @code
@item :focused
Choose the focused frame.

@item :last
Choose the last focused frame.

@item :empty
Choose any empty frame.

@item :unfocused
Choose any unfocused frame.
@end table

Alternatively, it can be set to a function that takes one argument, the new window, and returns the preferred frame or a list of the above preferences.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *normal-border-width*

The width in pixels given to the borders of regular windows.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *normal-gravity*
Package

stumpwm.

Source

primitives.lisp.

Special Variable: *numpad-map*

A keycode to keycode map to re-wire numpads when the numlock key is active

Package

stumpwm.

Source

input.lisp.

Special Variable: *place-window-hook*

A hook called whenever a window is placed by rule. Arguments are window group and frame

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *post-command-hook*

Called after a command is called. It is called with 1 argument: the command as a symbol.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *pre-command-hook*

Called before a command is called. It is called with 1 argument: the command as a symbol.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *pre-thread-hook*

A hook called before any threads are started. Useful if you need to fork.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *processing-existing-windows*

True when processing pre-existing windows at startup.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *queue-messages-p*

When non-nil, ECHO-STRING-LIST will retain old messages in addition to new ones. When the value is :new-on-bottom, new messages are added to the bottom as in a log file. See also WITH-MESSAGE-QUEUING.

Package

stumpwm.

Source

message-window.lisp.

Special Variable: *quit-hook*

A hook called when stumpwm quits.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *record-last-msg-override*

assign this to T and messages won’t be recorded. It is recommended this is assigned using LET.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *remapped-keys-enabled-p*

Bool to toggle remapped-keys on/off. Defaults to t

Package

stumpwm.

Source

remap-keys.lisp.

Special Variable: *remove-split-hook*

A hook called when a split is removed. the hook is called with the current frame and removed frame as arguments.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *resize-hides-windows*

Set to T to hide windows during interactive resize

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *resize-increment*

Number of pixels to increment by when interactively resizing frames.

Package

stumpwm.

Source

iresize.lisp.

Special Variable: *resize-map*

The keymap used for resizing a window

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *restart-hook*

A hook called when stumpwm restarts.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *root-click-focuses-frame*

Set to NIL if you don’t want clicking the root window to focus the frame containing the pointer.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *root-click-hook*

A hook called whenever there is a mouse click on the root window. Called with 4 arguments, the screen containing the root window, the button clicked, and the x and y of the pointer.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *root-map*

This is the keymap by default bound to @kbd{C-t} (along with *group-root-map* and either *tile-group-root-map*, *float-group-root-map*, or *dynamic-group-map*). It is known as the @dfn{prefix map}.

Package

stumpwm.

Source

kmap.lisp.

Special Variable: *rotation-focus-policy*

A keyword determining what frame to focus after rotating the windows in a dynamic group. Valid values are:
:PRESERVE, meaning to stay on the same frame
:FOLLOW, meaning to follow the current window as it rotates
:MASTER, meaning to always stay to the master
:MASTER-OR-FOLLOW, meaning to stay on the master, or if initiating the rotation while focused on a stack window to follow that window.

Package

stumpwm.

Source

dynamic-group.lisp.

Special Variable: *run-or-raise-all-groups*

When this is @code{T} the @code{run-or-raise} function searches all groups for a running instance. Set it to NIL to search only the current group.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *run-or-raise-all-screens*

When this is @code{T} the @code{run-or-raise} function searches all screens for a running instance. Set it to @code{NIL} to search only the current screen. If @var{*run-or-raise-all-groups*} is @code{NIL} this variable has no effect.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *screen-list*

The list of screens managed by stumpwm.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *screen-mode-line-format*

This variable describes what will be displayed on the modeline for each screen.
Turn it on with the function TOGGLE-MODE-LINE or the mode-line command.

It is a list where each element may be a string, a symbol, or a list.

For a symbol its value is used.

For a list of the form (:eval FORM) FORM is evaluated and the
result is used as a mode line element.

If it is a string the string is printed with the following formatting
options:

@table @asis
@item %h
List the number of the head the mode-line belongs to

@item %w
List all windows in the current group windows using @var{*window-format*}

@item %W
List all windows on the current head of the current group using
@var{*window-format*}

@item %g
List the groups using @var{*group-format*}

@item %n
The current group’s name

@item %u
Using @var{*window-format*}, return a 1 line list of the urgent windows, space seperated.

@item %v
Using @var{*window-format*}, return a 1 line list of the windows, space
separated. The currently focused window is highlighted with
fmt-highlight. Any non-visible windows are colored the
*hidden-window-color*.

@item %d
Using @var{*time-modeline-string*}, print the time.

@end table

A number of modules have been written that extends the possible
formatting strings. See their documentation for details.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *screen-mode-line-formatters*

An alist containing format character format function pairs for formatting screen mode-lines. functions are passed the mode line.

Package

stumpwm.

Source

mode-line.lisp.

Special Variable: *selection-notify-hook*

Called after a :selection-notify event is processed. It is called with 1 argument: the selection as a string.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *shell-program*

The shell program used by @code{run-shell-command}.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *single-menu-map*

The keymap used by single selection menus in addition to *menu-map*

Package

stumpwm.

Source

menu-declarations.lisp.

Special Variable: *split-frame-hook*

A hook called when a frame is split. the hook is called with the old frame (window is removed), and two new frames as arguments.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *start-hook*

A hook called when stumpwm starts.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *startup-message*

This is the message StumpWM displays when it starts. Set it to NIL to suppress.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *suppress-abort-messages*

Suppress abort message when non-nil.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *suppress-deny-messages*

For complete focus on the task at hand, set this to @code{T} and no raise/map denial messages will be seen.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *suppress-echo-timeout*

Assign this T and messages will not time out. It is recommended to assign this using LET.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *suppress-frame-indicator*

Set this to T if you never want to see the frame indicator.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *suppress-window-placement-indicator*

Set to T if you never want to see messages that windows were placed according to rules.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *text-color*

The color of message text.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *time-format-string-default*

The default value for ‘echo-date’, (e.g, Thu Mar 3 2005 23:05:25).

Package

stumpwm.

Source

time.lisp.

Special Variable: *time-modeline-string*

The default time value to pass to the modeline.

Package

stumpwm.

Source

time.lisp.

Special Variable: *timeout-frame-indicator-wait*

The amount of time a frame indicator timeout takes.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *timeout-wait*

Specifies, in seconds, how long a message will appear for. This must be an integer.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *timeout-wait-multiline*

Specifies, in seconds, how long a message will more than one line will appear for. This must be an integer. If falsy, default to *timeout-wait*.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *top-level-error-action*

If an error is encountered at the top level, in STUMPWM-INTERNAL-LOOP, then this variable decides what action shall be taken. By default it will print a message to the screen and to *standard-output*.

Valid values are :message, :break, :abort. :break will break to the debugger. This can be problematic because if the user hit’s a mapped key the ENTIRE keyboard will be frozen and you will have to login remotely to regain control. :abort quits stumpwm.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *top-level-error-hook*

Called when a top level error occurs. Note that this hook is run before the error is dealt with according to *top-level-error-action*.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *top-map*

The top level key map. This is where you’ll find the binding for the @dfn{prefix map}.

Package

stumpwm.

Source

kmap.lisp.

Special Variable: *toplevel-io*

Top-level I/O loop

Package

stumpwm.

Source

timers.lisp.

Special Variable: *transient-border-width*

The width in pixels given to the borders of transient or pop-up windows.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *transient-gravity*
Package

stumpwm.

Source

primitives.lisp.

Special Variable: *unscoped-minor-modes*

A dynamic variable holding all unscoped minor modes as mixed into the same object.

Package

stumpwm.

Source

minor-modes.lisp.

Special Variable: *urgent-window-hook*

A hook called whenever a window sets the property indicating that it demands the user’s attention

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *version*
Package

stumpwm.

Source

version.lisp.

Special Variable: *which-key-format*

The format string that decides how keybindings will show up in the which-key window. Two arguments will be passed to this formatter:

@table @asis
@item the keybind itself
@item the associated command
@end table

Package

stumpwm.

Source

help.lisp.

Special Variable: *window-border-style*

This controls the appearance of the border around windows. valid values are:
@table @var
@item :thick
All space within the frame not used by the window is dedicated to the border.

@item :thin
Only the border width as controlled by *maxsize-border-width* *normal-border-width* and *transient-border-width* is used as the border. The rest is filled with the unfocus color.

@item :tight
The same as :thin but the border surrounds the window and the wasted space within the frame is not obscured, revealing the background.

@item :none
Like :tight but no border is ever visible.
@end table

After changing this variable you may need to call sync-all-frame-windows to see the change.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *window-events*

The events to listen for on managed windows.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *window-format*

This variable decides how the window list is formatted. It is a string with the following formatting options:

@table @asis
@item %n
Substitutes the window’s number translated via *window-number-map*, if there are more windows than *window-number-map* then will use the window-number. @item %s
Substitute the window’s status. * means current window, + means last window, and - means any other window.
@item %t
Substitute the window’s name.
@item %c
Substitute the window’s class.
@item %i
Substitute the window’s resource ID.
@item %m
Draw a # if the window is marked.
@end table

Note, a prefix number can be used to crop the argument to a specified size. For instance, @samp{%20t} crops the window’s title to 20 characters.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *window-formatters*

an alist containing format character format function pairs for formatting window lists.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *window-name-source*

This variable controls what is used for the window’s name. The default is @code{:title}.

@table @code
@item :title
Use the window’s title given to it by its owner.

@item :class
Use the window’s resource class.

@item :resource-name
Use the window’s resource name.
@end table

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *window-parent-events*

The events to listen for on managed windows’ parents.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *window-placement-rules*

List of rules governing window placement. Use define-frame-preference to add rules

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *x-selection*

This is a plist of stumpwm’s current selections. The different properties are generally set when killing text in the input bar.

Package

stumpwm.

Source

primitives.lisp.

Special Variable: *xwin-to-window*

Hash table for looking up windows quickly.

Package

stumpwm.

Source

primitives.lisp.


5.1.3 Macros

Macro: act-on-matching-windows ((var &optional range) condition &rest code)

Run code on all windows matching condition; var is the shared lambda variable. Range can be any screen/group/frame or :screen/:group/:frame for the current instance. Condition is just the code to evaluate.

Package

stumpwm.

Source

wse.lisp.

Macro: add-hook (hook fn)

Add @var{function} to the @var{hook-variable}. For example, to display a message whenever you switch frames:

@example
(defun my-rad-fn (to-frame from-frame)
(stumpwm:message "Mustard!"))

(stumpwm:add-hook stumpwm:*focus-frame-hook* ’my-rad-fn) @end example

Package

stumpwm.

Source

primitives.lisp.

Macro: defcommand (name (&rest args) (&rest interactive-args) &body body)

Create a command function and store its interactive hints in
*command-hash*. The local variable %interactivep% can be used to check
if the command was called interactively. If it is non-NIL then it was
called from a keybinding or from the colon command.

The NAME argument can be a string, or a list of two symbols. If the
latter, the first symbol names the command, and the second indicates
the type of group under which this command will be usable. Currently,
tile-group, floating-group and dynamic-group are the possible values.

INTERACTIVE-ARGS is a list of the following form: ((TYPE PROMPT) (TYPE PROMPT) ...)

each element in INTERACTIVE-ARGS declares the type and prompt for the
command’s arguments.

TYPE can be one of the following:

@table @var
@item :y-or-n
A yes or no question returning T or NIL.
@item :variable
A lisp variable
@item :function
A lisp function
@item :command
A stumpwm command as a string.
@item :key-seq
A key sequence starting from *TOP-MAP*
@item :window-number
An existing window number
@item :number
An integer number
@item :string
A string
@item :key
A single key chord
@item :window-name
An existing window’s name
@item :direction
A direction symbol. One of :UP :DOWN :LEFT :RIGHT
@item :gravity
A gravity symbol. One of :center :top :right :bottom :left :top-right :top-left :bottom-right :bottom-left @item :group
An existing group
@item :frame
A frame
@item :shell
A shell command
@item :rest
The rest of the input yet to be parsed.
@item :module
An existing stumpwm module
@item :rotation
A rotation symbol. One of :CL, :CLOCKWISE, :CCL, OR :COUNTERCLOCKWISE
@end table

Note that new argument types can be created with DEFINE-STUMPWM-TYPE.

PROMPT can be string. In this case, if the corresponding argument is
missing from an interactive call, stumpwm will use prompt for its
value using PROMPT. If PROMPT is missing or nil, then the argument is
considered an optional interactive argument and is not prompted for
when missing.

Alternatively, instead of specifying nil for PROMPT or leaving it
out, an element can just be the argument type.

Package

stumpwm.

Source

command.lisp.

Macro: defcommand-alias (alias original)

Since interactive commands are functions and can conflict with package symbols. But for backwards compatibility this macro creates an alias name for the command that is only accessible interactively.

Package

stumpwm.

Source

command.lisp.

Macro: define-descended-minor-mode-scope (designator parent &key class filter-type retrieve-current-object)

Define a descended scope which inherits the parents type and functions unless provided.

Package

stumpwm.

Source

minor-modes.lisp.

Macro: define-frame-preference (target-group &body frame-rules)

Create a rule that matches windows and automatically places them in
a specified group and frame. Each frame rule is a lambda list:
@example
(frame-number raise lock &key from-group create restore dump-name class class-not instance instance-not type type-not role role-not title title-not match-properties-and-function match-properties-or-function)
@end example

@table @var
@item target-group
When nil, rule applies in the current group. When non nil, @var{lock} determines applicability of rule

@item frame-number
The frame number to send matching windows to

@item raise
When non-nil, raise and focus the window in its frame

@item lock
When this is nil, this rule will only match when @var{target-group}
matches the group designated by @var{from-group}.
When non-nil, this rule matches regardless
of the group and the window is sent to @var{target-group}. If
@var{lock} and @var{raise} are both non-nil, then stumpwm will jump to
the specified group and focus the matched window.

@item from-group
When @var{lock} is NIL, and this is non-NIL, this rule will only match
when @var{target-group} matches @var{from-group}. This should be set
to either a group name(a string), or an expression that returns a group(e.g (current-group)). When this is NIL, the rule matches if @var{target-group} matches
the group the window is in, or the current group if the window has no group.
@item create
When non-NIL the group is created and eventually restored when the value of
create is a group dump filename in *DATA-DIR*. Defaults to NIL.

@item restore
When non-NIL the group is restored even if it already exists. This arg should
be set to the dump filename to use for forced restore. Defaults to NIL

@item class
The windows class must match @var{class}.

@item class-not
The windows class must not match @var{class-not}

@item instance
The windows instance/resource name must match @var{instance}.

@item instance-not
The windows instance/resource name must not match @var{instance-not}.

@item type
The windows type must match @var{type}.

@item type-not
The windows type must not match @var{type-not}.

@item role
The windows role must match @var{role}.

@item role-not
The windows role must not match @var{role-not}.

@item title
The windows title must match @var{title}.

@item title-not
The windows title must not match @var{title-not}.

@item match-properties-and-function
A function that, if provided, must return true alongside the provided properties
in order for the rule to match. This function takes one argument, the window.
Must be an unquoted symbol to be looked up at runtime.

@item match-properties-or-function
A function that, if provided and returning true, will cause the rule to match
regardless of whether the window properties match. Takes one argument, the window.
Must be an unquoted symbol to be looked up at runtime.
@end table

Package

stumpwm.

Source

primitives.lisp.

Macro: define-interactive-keymap (name (&key on-enter on-exit abort-if exit-on) &body key-bindings)

Declare an interactive keymap mode. This can be used for developing interactive modes or command trees, such as @command{iresize}.

The NAME argument follows the same convention as in @command{defcommand}.

ON-ENTER and ON-EXIT are optional functions to run before and after the interactive keymap mode, respectively. If ABORT-IF is defined, the interactive keymap will only be activated if calling ABORT-IF returns true.

KEY-BINDINGS is a list of the following form: ((KEY COMMAND) (KEY COMMAND) ...) If one appends t to the end of a binding like so: ((kbd "n") "cmd" t) then the keymap is immediately exited after running the command.

Each element in KEY-BINDINGS declares a command inside the interactive keymap. Be aware that these commands won’t require a prefix to run.

Package

stumpwm.

Source

interactive-keymap.lisp.

Macro: define-minor-mode (mode superclasses slots &rest options)

Define a minor mode as a class to be instantiated when the minor mode is activated. Minor modes are dynamically mixed in to and out of the appropriate object when they are enabled or disabled.

If @var{SUPERCLASSES} is not provided a default superclass of MINOR-MODE will be provided. @var{OPTIONS} may include all normal options when defining a class, with the addition of the following options:

@itemize
@item
(:SCOPE SCOPE-DESIGNATOR)@*
The :SCOPE option determines what object(s) the minor mode can be mixed in with. New scopes can be defined with the macro DEFINE-MINOR-MODE-SCOPE.

@item
(:GLOBAL (OR T NIL))@*
When true the :GLOBAL option changes the way enable methods are defined to track the minor mode and autoenable it in all existing scope objects, as well as autoenabled when new scope objects are instantiated. If the :SCOPE option is :UNSCOPED then this option does not need to be provided.

@item
(:TOP-MAP spec)@*
The minor modes top map is created based upon the provided spec, which must be a list of cons cells whose car is a key sequence and whose cdr is a binding. For example: @code{(list (cons "C-m x" "echo"))}. This would bind the key sequence @kbd{C-m x} to the echo command. A reference to this keymap is stored as a slot in the minor mode object and can be accessed via the reader @code{MODE-KEYMAP} where @code{MODE} is the minor mode name.

@item
(:ROOT-MAP spec)@*
The minor modes root map is created based upon the provided spec. The spec is as described in the :TOP-MAP option.

@item
(:EXPOSE-KEYMAPS (OR T NIL))@*
This value is used at macroexpansion time to determine whether or not to generate keymap variables or store the keymap within the object. When T the variables *MODE-TOP-MAP* and *MODE-ROOT-MAP* will be generated.

@item
(:REBIND (MEMBER :TOP-MAP :ROOT-MAP :ALL-MAPS))@*

This option controls rebinding of the top and root maps. When it is :TOP-MAP the top map is rebound, when it is :ROOT-MAP the root map is rebound, and when it is :ALL-MAPS both the top and root map are rebound. Any rebound map will be rebound to the provided keymap specification. This only has an effect if the minor mode has previously been defined.

@item
(:LIGHTER T)@*
The :LIGHTER option will be used to generate a function returning a string to display in the mode line. When :LIGHTER is NULL a string is generated based upon the mode name. When it is a string that string is used as is. Otherwise :LIGHTER will assumed to be funcallable and used as is. When it is a symbol or a list that doesn’t begin with LAMBDA or FUNCTION a warning is issued that DEFINE-MINOR-MODE is assuming it is funcallable. When assumed to be funcallable, it is called with the mode object as its only argument.

@item
(:LIGHTER-MAKE-CLICKABLE (OR T NIL))@*
When :LIGHTER-MAKE-CLICKABLE is T then the :LIGHTER is wrapped in a call to FORMAT-WITH-ON-CLICK-ID, called with the id :ML-ON-CLICK-MINOR-MODE and the mode as a quoted symbol.

@item
(:LIGHTER-ON-CLICK FUNCTION)@*
When :LIGHTER-ON-CLICK is provided it must be a function of arity one, which will be called whenever the minor modes lighter is clicked, with the button code of the click as its only argument. If this is provided then :LIGHTER-MAKE-CLICKABLE is implied to be T.

@item
(:INTERACTIVE (OR SYMBOL T NIL))@*
The :INTERACTIVE option determines whether a command to toggle the minor mode on and off is generated. If it is T then a command with the same name as the minor mode is generated. If it is a symbol then that symbol will be used when defining the command.

@item
(:ENABLE-WHEN (MODE OBJECT) &BODY BODY)@*
When provided, the :ENABLE-WHEN option generates a method for the enable-when generic function. MODE is bound to the mode symbol, and OBJECT is bound to the scope object. If this is not provided, a method is generated which returns T for the minor mode and its scope. If it is provided and is nil, then no method is generated and a method for ENABLE-WHEN which dispatches upon the mode as a symbol and the scope type for the minor mode must be manually defined.

@item
(:MAKE-HOOKS (OR T NIL))@*
When :MAKE-HOOKS is T a set of hook variables are generated. These variables are fourfold: *MODE-HOOK* is run after explicitly enabling the minor
mode. *MODE-ENABLE-HOOK* is run when the minor mode is
autoenabled. *MODE-DISABLE-HOOK* is run when the minor mode is
autodisabled. Finally *MODE-DESTROY-HOOK* is run when the minor mode is explicitly disabled.

@item
(:DEFINE-COMMAND-DEFINER (OR T NIL))@*
When :DEFINE-COMMAND-DEFINER is T a macro is defined for defining commands that are active only when the minor mode is active. Commands defined with this macro have the special variable *MINOR-MODE* bound to the minor mode object in their body. The generated macro is called DEFINE-MODE-COMMAND. This option defaults to T.

@item
(:MIX-BEFORE &REST RULES)@*
The :MIX-BEFORE option defines rules on the order this class should be mixed in relative to other minor modes. This allows the implementer of a minor mode to make the mixing process aware of dependencies that dont otherwise make sense as a class hierarchy; If minor modes FOO and BAR both define around methods for the same method, but FOO’s method must be called first, FOO can add a rule stating that it must come before BAR in the mixin list. RULES must be a set of conses which have the form (SYMBOL-DESIGNATOR . PACKAGE-DESIGNATOR). SYMBOL-DESIGNATOR must be a valid argument to #’STRING, and PACKAGE-DESIGNATOR must be a valid argument to #’FIND-PACKAGE. Together these shall form a single symbol which should be the class name of the minor mode being referred to by the rule.

@item
(:MIX-AFTER &REST RULES)@*
The :MIX-AFTER option is similar to the :MIX-BEFORE option, except it specifies classes that this minor mode should occur after in the mixin list.
@end itemize

Example:
@verbatim
(define-minor-mode evil-mode () ()
(:scope :unscoped)
(:top-map ’(("j" . "move-focus down")
("k" . "move-focus up")
("h" . "move-focus left")
("l" . "move-focus right")
("x" . *exchange-window-map*)
("C-m b" . "evil-echo")))
(:lighter "EVIL")
(:lighter-make-clickable nil))

(define-evil-mode-command evil-echo () ()
(run-commands "echo"))
@end verbatim

Package

stumpwm.

Source

minor-modes.lisp.

Macro: define-minor-mode-scope ((designator class &optional filter-type) &body retrieve-current-object)

Define a minor mode scope for use with DEFINE-MINOR-MODE. This generates a call to ADD-MINOR-MODE-SCOPE which is evaluated when compiled, loaded, or executed. DESIGNATOR should be a keyword and TYPE should denote a class, while FILTER-TYPE should denote a general type. RETRIEVE-CURRENT-OBJECT should be a thunk body which returns the current object for this scope.

Package

stumpwm.

Source

minor-modes.lisp.

Macro: define-stumpwm-command (name (&rest args) &body body)

Deprecated. Use ‘defcommand’ instead.

Package

stumpwm.

Source

command.lisp.

Macro: define-stumpwm-type (type (input prompt) &body body)

Create a new type that can be used for command arguments. @var{type} can be any symbol.

When @var{body} is evaluated @var{input} is bound to the
argument-line. It is passed to @code{argument-pop},
@code{argument-pop-rest}, etc. @var{prompt} is the prompt that should
be used when prompting the user for the argument.

@example
(define-stumpwm-type :symbol (input prompt)
(or (find-symbol
(string-upcase
(or (argument-pop input)
;; Whitespace messes up find-symbol.
(string-trim " "
(completing-read (current-screen) prompt
;; find all symbols in the
;; stumpwm package.
(let (acc)
(do-symbols (s (find-package "STUMPWM")) (push (string-downcase (symbol-name s)) acc)) acc)))
(throw ’error "Abort.")))
"STUMPWM")
(throw ’error "Symbol not in STUMPWM package")))

(defcommand "symbol" (sym) ((:symbol "Pick a symbol: "))
(message "~a" (with-output-to-string (s)
(describe sym s))))
@end example

This code creates a new type called @code{:symbol} which finds the
symbol in the stumpwm package. The command @code{symbol} uses it and
then describes the symbol.

Package

stumpwm.

Source

command.lisp.

Macro: define-window-slot (attr)

Create a new window attribute and corresponding get/set functions.

Package

stumpwm.

Source

window.lisp.

Macro: defprogram-shortcut (name &key command props map key pullp pull-name pull-key)

Define a command and key binding to run or raise a program. If @var{pullp} is set, also define a command and key binding to run or pull the program.

Package

stumpwm.

Source

user.lisp.

Macro: move-to-head (list elt)

Move the specified element in in LIST to the head of the list.

Package

stumpwm.

Source

primitives.lisp.

Macro: remove-all-hooks (hook)

Remove all functions from a hook

Package

stumpwm.

Source

primitives.lisp.

Macro: remove-hook (hook fn)

Remove the specified function from the hook.

Package

stumpwm.

Source

primitives.lisp.

Macro: save-frame-excursion (&body body)

Execute body and then restore the current frame.

Package

stumpwm.

Source

tile-group.lisp.

Macro: with-data-file ((s file &rest keys &key if-exists &allow-other-keys) &body body)

Open a file in StumpWM’s data directory. keyword arguments are sent directly to OPEN. Note that IF-EXISTS defaults to :supersede, instead of :error.

Package

stumpwm.

Source

primitives.lisp.

Macro: with-message-queuing (new-on-bottom-p &body body)

Queue all messages sent by (MESSAGE ...), (ECHO-STRING ...), (ECHO-STRING-LIST ...) forms within BODY without clobbering earlier messages.
When NEW-ON-BOTTOM-P is non-nil, new messages are queued at the bottom.

Package

stumpwm.

Source

message-window.lisp.

Macro: with-restarts-menu (&body body)

Execute BODY. If an error occurs allow the user to pick a restart from a menu of possible restarts. If a restart is not chosen, resignal the error.

Package

stumpwm.

Source

primitives.lisp.


5.1.4 Ordinary functions

Function: add-group (screen name &key background type)

Create a new group in SCREEN with the supplied name. group names starting with a . are considered hidden groups. Hidden groups are skipped by gprev and gnext and do not show up in the group listings (unless *list-hidden-groups* is T). They also use negative numbers.

Package

stumpwm.

Source

group.lisp.

Function: add-minor-mode-scope (designator type current-object-thunk &optional filter-type)

Add a list of the TYPE, CURRENT-OBJECT-THUNK, and ALL-OBJECTS-THUNK, under DESIGNATOR in the minor mode scope hash table.

Package

stumpwm.

Source

minor-modes.lisp.

Function: add-screen-mode-line-formatter (character fmt-fun)

Add a format function to a format character (or overwrite an existing one).

Package

stumpwm.

Source

mode-line.lisp.

Function: add-to-load-path (path)

If ‘PATH’ is not in ‘*LOAD-PATH*’ add it, check if ‘PATH’ contains an asdf system, and if so add it to the central registry

Package

stumpwm.

Source

module.lisp.

Function: add-wm-state (xwin state)
Package

stumpwm.

Source

window.lisp.

Function: adjust-color (color amt)
Package

stumpwm.

Source

color.lisp.

Function: argument-line-end-p (input)

Return T if we’re outta arguments from the input line.

Package

stumpwm.

Source

command.lisp.

Function: argument-pop (input)

Pop the next argument off.

Package

stumpwm.

Source

command.lisp.

Function: argument-pop-or-read (input prompt &optional completions)
Package

stumpwm.

Source

command.lisp.

Function: argument-pop-rest (input)

Return the remainder of the argument text.

Package

stumpwm.

Source

command.lisp.

Function: balance-frames ()

Make frames the same height or width in the current frame’s subtree.

Package

stumpwm.

Source

tile-group.lisp.

Function: banish (&optional where)

Warp the mouse the lower right corner of the current head.

Package

stumpwm.

Source

user.lisp.

Function: bar (percent width full empty)

Return a progress bar string of WIDTH characters composed of characters FULL and EMPTY at PERCENT complete.

Package

stumpwm.

Source

mode-line-formatters.lisp.

Function: bar-zone-color (amount &optional med hi crit reverse)

Return a color command based on the magnitude of the argument. If the limits for the levels aren’t specified, they default to sensible values for a percentage. With reverse, lower numbers are more critical.

Package

stumpwm.

Source

mode-line-formatters.lisp.

Function: bind (key command)

Hang a key binding off the escape key.

Package

stumpwm.

Source

bindings.lisp.

Function: call-and-exit-kmap (command exit-command)

This command effectively calls two other commands in succession, via run-commands. it is designed for use in the define-interactive-keymap macro, to implement exiting the keymap on keypress.

Package

stumpwm.

Source

interactive-keymap.lisp.

Function: call-in-main-thread (fn)
Package

stumpwm.

Source

stumpwm.lisp.

Function: cancel-timer (timer)

Remove TIMER from the list of active timers.

Package

stumpwm.

Source

timers.lisp.

Function: change-default-layout (layout &optional update-heads)

Change the default layout for dynamic groups.

Package

stumpwm.

Source

dynamic-group.lisp.

Function: change-default-split-ratio (ratio &optional update-heads)

Change the default size of the master window for dynamic groups.

Package

stumpwm.

Source

dynamic-group.lisp.

Function: change-layout (layout)

Change the layout of the current head and group.

Package

stumpwm.

Source

dynamic-group.lisp.

Function: change-split-ratio (ratio)

Change the size of the master window of the current head and group.

Package

stumpwm.

Source

dynamic-group.lisp.

Function: clear-window-marks (&optional group windows)

Clear all marks in the current group.

Package

stumpwm.

Source

window.lisp.

Function: clear-window-placement-rules ()

Clear all window placement rules.

Package

stumpwm.

Source

primitives.lisp.

Function: close-resources ()
Package

stumpwm.

Source

stumpwm.lisp.

Function: colon (&optional initial-input)

Read a command from the user. @var{initial-text} is optional. When supplied, the text will appear in the prompt.

String arguments with spaces may be passed to the command by delimiting them with double quotes. A backslash can be used to escape double quotes or backslashes inside the string. This does not apply to commands taking :REST or :SHELL type arguments.

Package

stumpwm.

Source

command.lisp.

Function: command-menu (screen items command-list &key prompt initial-selection extra-keymap)

Use batch-menu to make selections and run commands specified in command-list.

SCREEN: The screen to display the menu on.

ITEMS: The items to be shown in the list. This is expected to be a list of @code{menu-item}s.

COMMAND-LIST: A list of entries defining the commands associated with each mark.
Only marks that are defined are allowed in the menu. The format
for these entries is (mark-character function calling-options).

Available calling-options:
:single (Default) Each value is passed separately to the supplied function. :all all values selected with this mark are passed to the function in a list.

Example:
’((#d ’delete-window) (#m ’move-multiple-windows :all))

Package

stumpwm.

Source

menu-definitions.lisp.

Function: command-mode ()

Command mode allows you to type StumpWM commands without needing the @key{C-t} prefix. Keys not bound in StumpWM will still get sent to the current window. To exit command mode, type @key{C-g}.

Package

stumpwm.

Source

bindings.lisp.

Function: command-mode-end-message ()
Package

stumpwm.

Source

primitives.lisp.

Function: command-mode-start-message ()
Package

stumpwm.

Source

primitives.lisp.

Function: commands ()

List all available commands.

Package

stumpwm.

Source

help.lisp.

Function: completing-read (screen prompt completions &key initial-input require-match)

Read a line of input through stumpwm and return it with TAB completion. Completions can be a list, an fbound symbol, or a function. If its an fbound symbol or a function then that function is passed the substring to complete on and is expected to return a list of matches. If require-match argument is non-nil then the input must match with an element of the completions.

Package

stumpwm.

Source

input.lisp.

Function: concat (&rest strings)
Package

stumpwm.

Source

primitives.lisp.

Function: copy-last-message ()

Copy the last message displayed into the X selection

Package

stumpwm.

Source

selection.lisp.

Function: copy-unhandled-error ()

When an unhandled error occurs, StumpWM restarts and attempts to continue. Unhandled errors should be reported to the mailing list so they can be fixed. Use this command to copy the unhandled error and backtrace to the X11 selection so you can paste in your email when submitting the bug report.

Package

stumpwm.

Source

user.lisp.

Function: curframe ()

Display a window indicating which frame is focused.

Package

stumpwm.

Source

tile-group.lisp.

Function: current-group (&optional screen)

Return the current group for the current screen, unless otherwise specified.

Package

stumpwm.

Source

group.lisp.

Function: current-head (&optional group)
Package

stumpwm.

Source

head.lisp.

Function: current-minor-modes (&optional screen)

Return all currently active minor modes.

Package

stumpwm.

Source

minor-modes.lisp.

Function: current-screen ()

Return the current screen.

Package

stumpwm.

Source

screen.lisp.

Function: current-window ()

Return the current window on the current screen

Package

stumpwm.

Source

screen.lisp.

Function: data-dir-file (name &optional type)

Return a pathname inside stumpwm’s data dir with the specified name and type

Package

stumpwm.

Source

primitives.lisp.

Reader: ddump-current (instance)
Writer: (setf ddump-current) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

current.

Reader: ddump-screens (instance)
Writer: (setf ddump-screens) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

screens.

Function: define-key (map key command)

Add a keybinding mapping for the key, @var{key}, to the command, @var{command}, in the specified keymap. If @var{command} is nil, remove an existing binding. For example,

@example
(stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "C-z") "echo Zzzzz...") @end example

Now when you type C-t C-z, you’ll see the text “Zzzzz...” pop up.

Package

stumpwm.

Source

kmap.lisp.

Function: define-remapped-keys (specs)

Define the keys to be remapped and their mappings. The SPECS argument needs to be of the following structure:

(regexp-or-function . (("key-to-remap" . <new-keycodes>) ...))

EXAMPLE:
(define-remapped-keys
’(("Firefox"
("C-n" . "Down")
("C-p" . "Up")
("C-k" . ("C-S-End" "C-x")))))

The above form remaps Ctrl-n to Down arrow, and Ctrl-p to Up arrow keys. The Ctrl-k key is remapped to the sequence of keys Ctrl-Shift-End followed by Ctrl-x.

Package

stumpwm.

Source

remap-keys.lisp.

Function: delete-from-mix (object &rest classes)
Package

dynamic-mixins-swm.

Source

dynamic-mixins.lisp.

Function: delete-window (&optional window)

Delete a window. By default delete the current window. This is a request sent to the window. The window’s client may decide not to grant the request or may not be able to if it is unresponsive.

Package

stumpwm.

Source

window.lisp.

Function: describe-command (com)

Print the online help associated with the specified command.

Package

stumpwm.

Source

help.lisp.

Function: describe-function (fn)

Print the online help associated with the specified function.

Package

stumpwm.

Source

help.lisp.

Function: describe-key (keys)

Either interactively type the key sequence or supply it as text. This command prints the command bound to the specified key sequence.

Package

stumpwm.

Source

help.lisp.

Function: describe-variable (var)

Print the online help associated with the specified variable.

Package

stumpwm.

Source

help.lisp.

Function: dformat (level fmt &rest args)
Package

stumpwm.

Source

debug.lisp.

Function: disable-minor-mode (minor-mode &optional scope-object)

Disable MINOR-MODE in the relevant objects.

Package

stumpwm.

Source

minor-modes.lisp.

Function: dump-desktop-to-file (file)

Dumps the frames of all groups of all screens to the named file.
If FILE is an absolute path, then the dump will be read written there. Otherwise, defaults to writing to "FILE.dump" in the XDG_DATA_HOME location.

Package

stumpwm.

Source

fdump.lisp.

Function: dump-group-to-file (file)

Dumps the frames of the current group of the current screen to the named file. If FILE is an absolute path, then the dump will be read written there. Otherwise, defaults to writing to "FILE.dump" in the XDG_DATA_HOME location.

Package

stumpwm.

Source

fdump.lisp.

Function: dump-screen-to-file (file)

Dumps the frames of all groups of the current screen to the named file. If FILE is an absolute path, then the dump will be read written there. Otherwise, defaults to writing to "FILE.dump" in the XDG_DATA_HOME location.

Package

stumpwm.

Source

fdump.lisp.

Function: dump-window-placement-rules (file)

Dump *window-placement-rules* to FILE.

Package

stumpwm.

Source

tile-window.lisp.

Function: dyn-blacklist-command (cmd)

Add CMD to the command blacklist for dynamic groups

Package

stumpwm.

Source

dynamic-group.lisp.

Function: dyn-unblacklist-command (cmd)

Remove CMD to the command blacklist for dynamic groups

Package

stumpwm.

Source

dynamic-group.lisp.

Function: dynamic-group-p (thing)
Package

stumpwm.

Source

dynamic-group.lisp.

Function: echo (string)

Display @var{string} in the message bar.

Package

stumpwm.

Source

user.lisp.

Function: echo-date ()

Display the date and time.

Package

stumpwm.

Source

time.lisp.

Function: echo-frame-windows (&optional fmt)

Display a list of all the windows in the current frame.

Package

stumpwm.

Source

tile-window.lisp.

Function: echo-string (screen msg)

Display @var{string} in the message bar on @var{screen}. You almost always want to use @command{message}.

Package

stumpwm.

Source

message-window.lisp.

Function: echo-windows (&optional fmt group windows)

Display a list of managed windows. The optional argument @var{fmt} can be used to override the default window formatting.

Package

stumpwm.

Source

window.lisp.

Function: emacs ()

Start emacs unless it is already running, in which case focus it.

Package

stumpwm.

Source

user.lisp.

Function: enable-minor-mode (minor-mode &optional scope-object)

Enable MINOR-MODE. If MINOR-MODE is global, then enable it in all relevant objects. Otherwise enable it in the current object. If SCOPE-OBJECT is provided, use SCOPE-OBJECT instead of the current object, or include it in the list of current objects if MINOR-MODE is global

Package

stumpwm.

Source

minor-modes.lisp.

Function: enable-mode-line (screen head state &optional format)

Set the state of SCREEN’s HEAD’s mode-line. If STATE is T and FORMAT is specified, then the mode-line’s format is updated.

Package

stumpwm.

Source

mode-line.lisp.

Function: enabled-minor-modes ()

Return all enabled minor modes, with duplicates removed.

Package

stumpwm.

Source

minor-modes.lisp.

Function: ensure-mix (object &rest classes)
Package

dynamic-mixins-swm.

Source

dynamic-mixins.lisp.

Function: entries-from-nested-list (lst)
Package

stumpwm.

Source

menu-definitions.lisp.

Function: err (fmt &rest args)

run FMT and ARGS through format and echo the result to the current screen along with a backtrace. For careful study, the message does not time out.

Package

stumpwm.

Source

message-window.lisp.

Function: eval-line (cmd)

Evaluate the s-expression and display the result(s).

Package

stumpwm.

Source

user.lisp.

Function: exchange-direction (dir &optional win)

Exchange the current window (by default) with the top window of the frame in specified direction. (bound to @kbd{C-t x} by default) @table @asis
@item up
@item down
@item left
@item right
@end table

Package

stumpwm.

Source

tile-window.lisp.

Function: exchange-with-master ()
Package

stumpwm.

Source

dynamic-group.lisp.

Function: exit-iresize ()
Package

stumpwm.

Source

iresize.lisp.

Function: expose ()

Automagically lay out all windows in a grid and let the user select one, making that window the focused window. Set the variable ‘*expose-auto-tile-fn*’ to another tiling function if a different layout is desired for tile groups. Set ‘*expose-n-max*’ to the maximum number of windows to be displayed for choosing when in a tile group.

Package

stumpwm.

Source

dynamic-window.lisp.

Function: fclear ()

Clear the current frame.

Package

stumpwm.

Source

tile-group.lisp.

Reader: fdump-current (instance)
Writer: (setf fdump-current) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

current.

Reader: fdump-height (instance)
Writer: (setf fdump-height) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

height.

Reader: fdump-number (instance)
Writer: (setf fdump-number) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

number.

Reader: fdump-width (instance)
Writer: (setf fdump-width) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

width.

Reader: fdump-windows (instance)
Writer: (setf fdump-windows) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

windows.

Reader: fdump-x (instance)
Writer: (setf fdump-x) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

x.

Reader: fdump-y (instance)
Writer: (setf fdump-y) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

y.

Function: find-minor-mode (minor-mode &optional screen)

Return the minor mode object associated with MINOR-MODE.

Package

stumpwm.

Source

minor-modes.lisp.

Function: find-module (name)
Package

stumpwm.

Source

module.lisp.

Function: find-wm-state (xwin state)
Package

stumpwm.

Source

window.lisp.

Function: flatten-floats ()

Transform all floating windows in this group to tiled windows. Puts all tiled windows in the first frame of the group.

Package

stumpwm.

Source

tile-group.lisp.

Function: float-this ()

Transforms a tile-window into a float-window

Package

stumpwm.

Source

tile-group.lisp.

Function: fnext ()

Cycle through the frame tree to the next frame.

Package

stumpwm.

Source

tile-group.lisp.

Function: fnext-in-head ()

Focus the next frame in the current head

Package

stumpwm.

Source

dynamic-group.lisp.

Function: forget ()

Forget the window placement rule that matches the current window.

Package

stumpwm.

Source

tile-window.lisp.

Function: format-expand (fmt-alist str &rest args)
Package

stumpwm.

Source

primitives.lisp.

Function: format-with-on-click-id (string id &rest arguments)

Wrap STRING in :on-click and :on-click-end color formatters, using ID as the id to call when clicked and ARGUMENTS as the arguments to pass to the ID’s function. STRING may not contain the :> color formatter, but may contain any other color formatters.

Package

stumpwm.

Source

mode-line-formatters.lisp.

Function: fother ()

Jump to the last frame that had focus.

Package

stumpwm.

Source

tile-group.lisp.

Function: fprev ()

Cycle through the frame tree to the previous frame.

Package

stumpwm.

Source

tile-group.lisp.

Function: fprev-in-head ()

Focus the previous frame in the current head

Package

stumpwm.

Source

dynamic-group.lisp.

Function: frame-windowlist (&optional fmt)

Allow the user to select a window from the list of windows in the current frame and focus the selected window. The optional argument @var{fmt} can be specified to override the default window formatting.

Package

stumpwm.

Source

tile-window.lisp.

Function: fselect (frame-number)

Display a number in the corner of each frame and let the user to select a frame by number or click. If @var{frame-number} is specified, just jump to that frame.

Package

stumpwm.

Source

tile-group.lisp.

Function: fullscreen ()

Toggle the fullscreen mode of the current widnow. Use this for clients with broken (non-NETWM) fullscreen implementations, such as any program using SDL.

Package

stumpwm.

Source

window.lisp.

Reader: gdump-current (instance)
Writer: (setf gdump-current) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

current.

Reader: gdump-name (instance)
Writer: (setf gdump-name) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

name.

Reader: gdump-number (instance)
Writer: (setf gdump-number) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

number.

Reader: gdump-tree (instance)
Writer: (setf gdump-tree) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

tree.

Function: generate-keymap (keymap-spec &optional top-map filter-bindings)

Generate a (potentially nested) keymap based on KEYMAP. KEYMAP is a list of keymap specs, where each spec is a cons cell containing an input sequence and something to bind it to. The input sequence is a string representing an arbitrary sequence of keys, eg "C-x C-s". The thing to bind it to is an arbitrary thing which will be passed to FILTER-BINDINGS, which defaults to #’identity. TOP-MAP is the keymap to bind everything in, and defaults to an empty keymap.

Package

stumpwm.

Source

minor-modes.lisp.

Function: get-x-selection (&optional timeout selection)

Return the x selection no matter which client owns it.

Package

stumpwm.

Source

selection.lisp.

Function: getenv (var)

Return the value of the environment variable.

Package

stumpwm.

Source

wrappers.lisp.

Function: (setf getenv) (var)

Set the value of the environment variable, @var{var} to @var{val}.

Package

stumpwm.

Source

wrappers.lisp.

Function: getsel ()

Echo the X selection.

Package

stumpwm.

Source

selection.lisp.

Function: gkill ()

Kill the current group. All windows in the current group are migrated to the next group.

Package

stumpwm.

Source

group.lisp.

Function: gkill-other ()

Kill other groups. All windows in other groups are migrated to the current group.

Package

stumpwm.

Source

group.lisp.

Function: gmerge (from)

Merge @var{from} into the current group. @var{from} is not deleted.

Package

stumpwm.

Source

group.lisp.

Function: gmove (to-group)

Move the current window to the specified group.

Package

stumpwm.

Source

group.lisp.

Function: gmove-and-follow (to-group)

Move the current window to the specified group, and switch to it.

Package

stumpwm.

Source

group.lisp.

Function: gmove-marked (to-group)

move the marked windows to the specified group.

Package

stumpwm.

Source

group.lisp.

Function: gnew (name)

Create a new group with the specified name. The new group becomes the current group. If @var{name} begins with a dot (“.”) the group new
group will be created in the hidden state. Hidden groups have group numbers less than one and are invisible to from gprev, gnext, and, optionally, groups and vgroups commands.

Package

stumpwm.

Source

group.lisp.

Function: gnew-dynamic (name)

Create a new dynamic group named NAME.

Package

stumpwm.

Source

dynamic-group.lisp.

Function: gnew-float (name)

Create a floating window group with the specified name and switch to it.

Package

stumpwm.

Source

floating-group.lisp.

Function: gnewbg (name)

Create a new group but do not switch to it.

Package

stumpwm.

Source

group.lisp.

Function: gnewbg-dynamic (name)

Create a new dynamic group named NAME in the background.

Package

stumpwm.

Source

dynamic-group.lisp.

Function: gnewbg-float (name)

Create a floating window group with the specified name, but do not switch to it.

Package

stumpwm.

Source

floating-group.lisp.

Function: gnext ()

Cycle to the next group in the group list.

Package

stumpwm.

Source

group.lisp.

Function: gnext-with-window ()

Cycle to the next group in the group list, taking the current window along.

Package

stumpwm.

Source

group.lisp.

Function: gother ()

Go back to the last group.

Package

stumpwm.

Source

group.lisp.

Function: gprev ()

Cycle to the previous group in the group list.

Package

stumpwm.

Source

group.lisp.

Function: gprev-with-window ()

Cycle to the previous group in the group list, taking the current window along.

Package

stumpwm.

Source

group.lisp.

Function: grab-pointer (screen)

Grab the pointer and set the pointer shape.

Package

stumpwm.

Source

core.lisp.

Function: gravity (gravity)

Set a window’s gravity within its frame. Gravity controls where the window will appear in a frame if it is smaller that the
frame. Possible values are:

@table @var
@item center
@item top
@item right
@item bottom
@item left
@item top-right
@item top-left
@item bottom-right
@item bottom-left
@end table

Package

stumpwm.

Source

tile-window.lisp.

Function: grename (name)

Rename the current group.

Package

stumpwm.

Source

group.lisp.

Function: grouplist (&optional fmt)

Allow the user to select a group from a list, like windowlist for groups.

Package

stumpwm.

Source

group.lisp.

Function: groups (&optional fmt)

Display the list of groups with their number and
name. @var{*group-format*} controls the formatting. The optional argument @var{fmt} can be used to override the default group formatting.

Package

stumpwm.

Source

group.lisp.

Function: gselect (&optional to-group)

Accepts numbers to select a group, otherwise grouplist selects.

Package

stumpwm.

Source

group.lisp.

Function: hnext ()

Move focus to the next head in a dynamic group

Package

stumpwm.

Source

dynamic-group.lisp.

Function: hprev ()

Move focus to the previous head in a dynamic group

Package

stumpwm.

Source

dynamic-group.lisp.

Function: hsplit (&optional ratio)

Split the current frame into 2 side-by-side frames.

Package

stumpwm.

Source

tile-group.lisp.

Function: hsplit-equally (amt)

Deprecated. Use ‘vsplit-uniformly’ instead.

Package

stumpwm.

Source

tile-group.lisp.

Function: hsplit-uniformly (amt)

Split current frame in n columns of equal size.

Package

stumpwm.

Source

tile-group.lisp.

Function: idle-time (screen)

Returns the time in seconds since idle according to the root window of the ‘screen’.

Package

stumpwm.

Source

timers.lisp.

Function: in-main-thread-p ()
Package

stumpwm.

Source

stumpwm.lisp.

Function: info (&optional fmt)

Display information about the current window.

Package

stumpwm.

Source

window.lisp.

Function: init-load-path (path)

Recursively builds a list of paths that contain modules, then add them to the load path. This is called each time StumpWM starts with the argument ‘*module-dir*’

Package

stumpwm.

Source

module.lisp.

Function: input-delete-region (input start end)

Delete the region between start and end in the input string

Package

stumpwm.

Source

input.lisp.

Function: input-goto-char (input point)

Move the cursor to the specified point in the string

Package

stumpwm.

Source

input.lisp.

Function: input-insert-char (input char)

Insert @var{char} into the input at the current
position. @var{input} must be of type @var{input-line}. Input functions are passed this structure as their first argument.

Package

stumpwm.

Source

input.lisp.

Function: input-insert-string (input string)

Insert @var{string} into the input at the current position. @var{input} must be of type @var{input-line}. Input functions are passed this structure as their first argument.

Package

stumpwm.

Source

input.lisp.

Function: input-point (input)

Return the position of the cursor.

Package

stumpwm.

Source

input.lisp.

Function: input-refine-prefix (str candidates)
Package

stumpwm.

Source

input.lisp.

Function: input-refine-regexp (str candidates)
Package

stumpwm.

Source

input.lisp.

Function: input-substring (input start end)

Return a the substring in INPUT bounded by START and END.

Package

stumpwm.

Source

input.lisp.

Function: input-validate-region (input start end)

Return a value pair of numbers where the first number is < the second and neither excedes the bounds of the input string.

Package

stumpwm.

Source

input.lisp.

Function: iresize ()

Starts interactive command "IRESIZE"

Package

stumpwm.

Source

iresize.lisp.

Function: kbd (keys)

This compiles a key string into a key structure used by ‘define-key’, ‘undefine-key’, ‘set-prefix-key’ and others.

Package

stumpwm.

Source

kmap.lisp.

Function: keyboard-quit ()

This way you can exit from command mode. Also aliased as abort.

Package

stumpwm.

Source

user.lisp.

Function: kill-window (&optional window)

Tell X to disconnect the client that owns the specified window. Default to the current window. if @command{delete-window} didn’t work, try this.

Package

stumpwm.

Source

window.lisp.

Function: kill-windows-current-group ()

Kill all windows in the current group.

Package

stumpwm.

Source

window.lisp.

Function: kill-windows-other ()

Kill all windows in current group except the current-window

Package

stumpwm.

Source

window.lisp.

Function: lastmsg ()

Display the last message. If the previous command was lastmsg, then continue cycling back through the message history.

Package

stumpwm.

Source

message-window.lisp.

Function: list-current-mode-objects (&key screen)
Package

stumpwm.

Source

minor-modes.lisp.

Function: list-directory (dirname)

Returns a fresh list of pathnames corresponding to the truenames of all files within the directory named by the non-wild pathname designator DIRNAME. The pathnames of sub-directories are returned in directory form - see PATHNAME-AS-DIRECTORY.

Package

stumpwm.

Source

pathnames.lisp.

Function: list-minor-modes (object)

List all minor modes active in OBJECT

Package

stumpwm.

Source

minor-modes.lisp.

Function: list-mode-objects (&optional sync)
Package

stumpwm.

Source

minor-modes.lisp.

Function: list-modes (object)

List all minor modes followed by the major mode for OBJECT.

Package

stumpwm.

Source

minor-modes.lisp.

Function: list-modules ()

Return a list of the available modules.

Package

stumpwm.

Source

module.lisp.

Function: list-window-properties ()

List all the properties of the current window and their values, like xprop.

Package

stumpwm.

Source

user.lisp.

Function: load-module (name)

Loads the contributed module with the given NAME.

Package

stumpwm.

Source

module.lisp.

Function: loadrc ()

Reload the @file{~/.stumpwmrc} file.

Package

stumpwm.

Source

user.lisp.

Function: lookup-color (screen color)
Package

stumpwm.

Source

color.lisp.

Function: lookup-command (keymap command)

Return a list of keys that are bound to command

Package

stumpwm.

Source

kmap.lisp.

Function: lookup-key (keymap key &optional accept-default)
Package

stumpwm.

Source

kmap.lisp.

Function: make-sparse-keymap ()

Create an empty keymap. If you want to create a new list of bindings
in the key binding tree, this is where you start. To hang frame
related bindings off @kbd{C-t C-f} one might use the following code:

@example
(defvar *my-frame-bindings*
(let ((m (stumpwm:make-sparse-keymap)))
(stumpwm:define-key m (stumpwm:kbd "f") "curframe")
(stumpwm:define-key m (stumpwm:kbd "M-b") "move-focus left")
m ; NOTE: this is important
))

(stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "C-f") ’*my-frame-bindings*) @end example

Package

stumpwm.

Source

kmap.lisp.

Function: mark ()

Toggle the current window’s mark.

Package

stumpwm.

Source

window.lisp.

Function: message (fmt &rest args)

run FMT and ARGS through ‘format’ and echo the result to the current screen.

Package

stumpwm.

Source

message-window.lisp.

Function: meta (key)

Send a fake key to the current window. @var{key} is a typical StumpWM key, like @kbd{C-M-o}.

Package

stumpwm.

Source

user.lisp.

Function: minor-mode-enabled-p (minor-mode &optional screen)

Return T if MINOR-MODE is active

Package

stumpwm.

Source

minor-modes.lisp.

Function: mix (&rest classes)
Package

dynamic-mixins-swm.

Source

dynamic-mixins.lisp.

Function: mode-line ()

A command to toggle the mode line visibility.

Package

stumpwm.

Source

mode-line.lisp.

Function: modifiers ()

List the modifiers stumpwm recognizes and what MOD-X it thinks they’re on.

Package

stumpwm.

Source

help.lisp.

Reader: modifiers-alt (instance)
Writer: (setf modifiers-alt) (instance)
Package

stumpwm.

Source

primitives.lisp.

Target Slot

alt.

Reader: modifiers-altgr (instance)
Writer: (setf modifiers-altgr) (instance)
Package

stumpwm.

Source

primitives.lisp.

Target Slot

altgr.

Reader: modifiers-hyper (instance)
Writer: (setf modifiers-hyper) (instance)
Package

stumpwm.

Source

primitives.lisp.

Target Slot

hyper.

Reader: modifiers-meta (instance)
Writer: (setf modifiers-meta) (instance)
Package

stumpwm.

Source

primitives.lisp.

Target Slot

meta.

Reader: modifiers-numlock (instance)
Writer: (setf modifiers-numlock) (instance)
Package

stumpwm.

Source

primitives.lisp.

Target Slot

numlock.

Function: modifiers-p (object)
Package

stumpwm.

Source

primitives.lisp.

Reader: modifiers-super (instance)
Writer: (setf modifiers-super) (instance)
Package

stumpwm.

Source

primitives.lisp.

Target Slot

super.

Function: move-focus (dir)

Focus the frame adjacent to the current one in the specified direction. The following are valid directions:
@table @asis
@item up
@item down
@item left
@item right
@end table

Package

stumpwm.

Source

tile-group.lisp.

Function: move-window (dir)

Just like move-focus except that the current is pulled along.

Package

stumpwm.

Source

tile-group.lisp.

Function: move-window-to-group (window to-group)
Package

stumpwm.

Source

group.lisp.

Function: move-windows-to-group (windows &optional arggroup)

Move all windows from the list to the group

Package

stumpwm.

Source

wse.lisp.

Function: next ()

Go to the next window in the window list.

Package

stumpwm.

Source

window.lisp.

Function: next-in-frame ()

Go to the next window in the current frame.

Package

stumpwm.

Source

tile-group.lisp.

Function: next-urgent ()

Jump to the next urgent window

Package

stumpwm.

Source

window.lisp.

Function: no-focus (group last-win)

don’t focus any window but still read keyboard events.

Package

stumpwm.

Source

window.lisp.

Function: only ()

Delete all the frames but the current one and grow it to take up the entire head.

Package

stumpwm.

Source

tile-group.lisp.

Function: only-one-frame-p ()

T if there is only one maximized frame in the current head.
This can be used around a the "only" command to avoid the warning message.

Package

stumpwm.

Source

tile-group.lisp.

Function: other-in-frame ()

Go to the last accessed window in the current frame.

Package

stumpwm.

Source

tile-group.lisp.

Function: other-window (&optional group)

Switch to the window last focused.

Package

stumpwm.

Source

window.lisp.

Function: pathname-as-directory (pathspec)

Converts the non-wild pathname designator PATHSPEC to directory form.

Package

stumpwm.

Source

pathnames.lisp.

Function: pathname-is-executable-p (pathname)

Return T if the pathname describes an executable file.

Package

stumpwm.

Source

wrappers.lisp.

Function: place-current-window ()

Re-arrange current window according to placement rules.

Package

stumpwm.

Source

fdump.lisp.

Function: place-existing-windows ()

Re-arrange existing windows according to placement rules.

Package

stumpwm.

Source

fdump.lisp.

Function: prev ()

Go to the previous window in the window list.

Package

stumpwm.

Source

window.lisp.

Function: prev-in-frame ()

Go to the previous window in the current frame.

Package

stumpwm.

Source

tile-group.lisp.

Function: programs-in-path (&optional full-path path)

Return a list of programs in the path. If @var{full-path} is @var{t} then return the full path, otherwise just return the filename. @var{path} is by default the @env{PATH} evironment variable but can be specified. It should be a string containing each directory seperated by a colon.

Package

stumpwm.

Source

user.lisp.

Function: pull-from-windowlist (&optional fmt)

Pulls a window selected from the list of windows. This allows a behavior similar to Emacs’ switch-to-buffer when selecting another window.

Package

stumpwm.

Source

tile-window.lisp.

Function: pull-hidden-next ()

Pull the next hidden window into the current frame.

Package

stumpwm.

Source

tile-window.lisp.

Function: pull-hidden-other ()

Pull the last focused, hidden window into the current frame.

Package

stumpwm.

Source

tile-window.lisp.

Function: pull-hidden-previous ()

Pull the next hidden window into the current frame.

Package

stumpwm.

Source

tile-window.lisp.

Function: pull-marked ()

Pull all marked windows into the current frame and clear the marks.

Package

stumpwm.

Source

tile-window.lisp.

Function: pull-window-by-number (n &optional group)

Pull window N from another frame into the current frame and focus it.

Package

stumpwm.

Source

tile-window.lisp.

Function: push-event (fn)
Package

stumpwm.

Source

stumpwm.lisp.

Function: putsel (string)

Stuff the string @var{string} into the x selection.

Package

stumpwm.

Source

selection.lisp.

Function: quit ()

Quit StumpWM.

Package

stumpwm.

Source

user.lisp.

Function: quit-confirm ()

Prompt the user to confirm quitting StumpWM.

Package

stumpwm.

Source

user.lisp.

Function: ratclick (&optional button)

Simulate a pointer button event at the current pointer location. Note: this function is unlikely to work unless your X server and CLX implementation support XTEST.

Package

stumpwm.

Source

user.lisp.

Function: ratrelwarp (dx dy)

Warp the mouse by the specified amount from its current position.

Package

stumpwm.

Source

user.lisp.

Function: ratwarp (x y)

Warp the mouse to the specified location.

Package

stumpwm.

Source

user.lisp.

Function: read-line-from-sysfs (stream &optional blocksize)

READ-LINE, but with a workaround for a known SBCL/Linux bug regarding files in sysfs. Data is read in chunks of BLOCKSIZE bytes.

Package

stumpwm.

Source

wrappers.lisp.

Function: read-one-char (screen)

Read a single character from the user.

Package

stumpwm.

Source

input.lisp.

Function: read-one-line (screen prompt &key completions initial-input require-match password)

Read a line of input through stumpwm and return it. Returns nil if the user aborted.

Package

stumpwm.

Source

input.lisp.

Function: redirect-all-output (file)

Elect to redirect all output to the specified file. For instance, if you want everything to go to ~/.stumpwm.d/debug-output.txt you would do:

@example
(redirect-all-output (data-dir-file "debug-output" "txt"))
@end example

Package

stumpwm.

Source

debug.lisp.

Function: redisplay ()

Refresh current window by a pair of resizes, also make it occupy entire frame.

Package

stumpwm.

Source

tile-window.lisp.

Function: refresh ()

Refresh current window without changing its size.

Package

stumpwm.

Source

window.lisp.

Function: refresh-heads (&optional screen)

Refresh screens in case a monitor was connected, but a ConfigureNotify event was snarfed by another program.

Package

stumpwm.

Source

head.lisp.

Function: refresh-time-zone ()

Refresh the time zone information from the system.

If you change the system time zone while StumpWM is running you can run this command to make StumpWM notice the change.

Package

stumpwm.

Source

time.lisp.

Function: register-altgr-as-modifier ()

Register the keysym(s) for ISO_Level3_Shift as modifiers.

Package

stumpwm.

Source

input.lisp.

Function: register-ml-on-click-id (id fn)

Register FN with ID, to be used by the :on-click mode line color formatter.

Package

stumpwm.

Source

mode-line.lisp.

Function: reload ()

Reload StumpWM using @code{asdf}.

Package

stumpwm.

Source

user.lisp.

Function: remember (lock title)

Make a generic placement rule for the current window. Might be too specific/not specific enough!

Package

stumpwm.

Source

tile-window.lisp.

Function: remove-split (&optional group frame)

Remove the specified frame in the specified group (defaults to current group, current frame). Windows in the frame are migrated to the frame taking up its space.

Package

stumpwm.

Source

tile-group.lisp.

Function: remove-wm-state (xwin state)
Package

stumpwm.

Source

window.lisp.

Function: renumber (nt &optional group)

Change the current window’s number to the specified number. If another window is using the number, then the windows swap numbers. Defaults to current group.

Package

stumpwm.

Source

window.lisp.

Function: repack-window-numbers (&optional preserved)

Ensure that used window numbers do not have gaps; ignore PRESERVED window numbers.

Package

stumpwm.

Source

window.lisp.

Function: resize (width height)

Move the frame split directly to the right of the current frame as much as possible up to @var{width} pixels, or if impossible try the split directly to the left instead. Similarly, also move the frame split directly below the current frame as much as possible up to @var{height} pixels, or if impossible try the split directly above instead.

Package

stumpwm.

Source

tile-group.lisp.

Function: resize-direction (d)

Resize frame to direction @var{d}

Package

stumpwm.

Source

iresize.lisp.

Function: restart-hard ()

Restart stumpwm. This is handy if a new stumpwm executable has been made and you wish to replace the existing process with it.

Any run-time customizations will be lost after the restart.

Package

stumpwm.

Source

user.lisp.

Function: restart-soft ()

Soft restart StumpWM. The lisp process isn’t restarted. Instead, control jumps to the very beginning of the stumpwm program. This differs from RESTART, which restarts the unix process.

Since the process isn’t restarted, existing customizations remain after the restart.

Package

stumpwm.

Source

user.lisp.

Function: restarts-menu (err)

Display a menu with the active restarts and let the user pick one. Error is the error being recovered from. If the user aborts the menu, the error is re-signalled.

Package

stumpwm.

Source

user.lisp.

Function: restore-from-file (file)

Restores screen, groups, or frames from named file, depending on file’s contents. If FILE is an absolute path, then the dump will be read from there. Otherwise, defaults to reading from "FILE.dump" in the XDG_DATA_HOME location.

Package

stumpwm.

Source

fdump.lisp.

Function: restore-window-placement-rules (file)

Restore *window-placement-rules* from FILE.

Package

stumpwm.

Source

tile-window.lisp.

Function: retile (&optional retile-floats)

Force a retile of all windows.

Package

stumpwm.

Source

dynamic-group.lisp.

Function: rotate-stack (direction)

Rotate the stack windows in current group and head forward (clockwise) or backward (counterclockwise)

Package

stumpwm.

Source

dynamic-group.lisp.

Function: rotate-windows (direction)

Rotate all windows in the current group and head forward (clockwise) or backward (counterclockwise)

Package

stumpwm.

Source

dynamic-group.lisp.

Function: run-commands (&rest commands)

Run each stumpwm command in sequence. This could be used if you’re used to ratpoison’s rc file and you just want to run commands or don’t know lisp very well. One might put the following in one’s rc file:

@example
(stumpwm:run-commands
"escape C-z"
"exec firefox"
"split")
@end example

Package

stumpwm.

Source

command.lisp.

Function: run-hook (hook)

Call each function in HOOK.

Package

stumpwm.

Source

primitives.lisp.

Function: run-hook-with-args (hook &rest args)

Call each function in HOOK and pass args to it.

Package

stumpwm.

Source

primitives.lisp.

Function: run-or-pull (cmd props &optional all-groups all-screens)

Similar to run-or-raise, but move the matching window to the current frame instead of switching to the window.

Package

stumpwm.

Source

user.lisp.

Function: run-or-raise (cmd props &optional all-groups all-screens)

Run the shell command, @var{cmd}, unless an existing window
matches @var{props}. @var{props} is a property list with the following keys:

@table @code
@item :class
Match the window’s class.
@item :instance
Match the window’s instance or resource-name.
@item :role
Match the window’s @code{WM_WINDOW_ROLE}.
@item :title
Match the window’s title.
@end table

By default, the global @var{*run-or-raise-all-groups*} decides whether to search all groups or the current one for a running
instance. @var{all-groups} overrides this default. Similarily for @var{*run-or-raise-all-screens*} and @var{all-screens}.

Package

stumpwm.

Source

user.lisp.

Function: run-shell-command (cmd &optional collect-output-p)

Run the specified shell command. If @var{collect-output-p} is @code{T} then run the command synchonously and collect the output. Be careful. If the shell command doesn’t return, it will hang StumpWM. In such a case, kill the shell command to resume StumpWM.

Package

stumpwm.

Source

user.lisp.

Function: run-with-timer (secs repeat function &rest args)

Perform an action after a delay of SECS seconds.
Repeat the action every REPEAT seconds, if repeat is non-nil. SECS and REPEAT may be reals.
The action is to call FUNCTION with arguments ARGS.

Package

stumpwm.

Source

timers.lisp.

Function: screen-current-window (screen)

Return the current window on the specified screen

Package

stumpwm.

Source

screen.lisp.

Function: screen-height (screen)
Package

stumpwm.

Source

screen.lisp.

Function: screen-root (screen)
Package

stumpwm.

Source

screen.lisp.

Function: screen-width (screen)
Package

stumpwm.

Source

screen.lisp.

Function: screen-windows (screen)
Package

stumpwm.

Source

screen.lisp.

Reader: sdump-current (instance)
Writer: (setf sdump-current) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

current.

Reader: sdump-groups (instance)
Writer: (setf sdump-groups) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

groups.

Reader: sdump-number (instance)
Writer: (setf sdump-number) (instance)
Package

stumpwm.

Source

fdump.lisp.

Target Slot

number.

Function: select-floating-window (&optional fmt window-list)

Select a floating window from a menu.

Package

stumpwm.

Source

dynamic-group.lisp.

Function: select-from-batch-menu (screen table &key prompt allowed-markers initial-selection extra-keymap)

Prompt the user with a menu that allows them to mark each item
with a character. They can exit the menu by pressing enter, or
whatever key is mapped to ’menu-finish’ in *menu-map*. Value returned
is an alist, where the cdr of each entry is a list of
items that were marked with that character. Note that the lisp printer cannot distinguish between ’(a . (b c d)) and ’(a b c d).

Example when "foo" and "bar" are marked with ’#d’, and "baz" is not marked: ((#d "foo" "bar") (NIL "baz"))
ALLOWED-MARKERS is a list of characters. If this parameter is specified, no other markers are allowed.
EXTRA-KEYMAP can be a keymap whose bindings will take precedence
over the default bindings.

Package

stumpwm.

Source

menu-definitions.lisp.

Function: select-from-menu (screen table &optional prompt initial-selection extra-keymap filter-pred)

Prompt the user to select from a menu on SCREEN. TABLE can be
a list of values or a nested list. If it’s a nested list, the first element in the sublist is displayed in the menu. What is displayed as menu items must be strings.

EXTRA-KEYMAP can be a keymap whose bindings will take precedence over the default bindings.

FILTER-PRED should be a a function returning T when a certain menu item should be visible to the user. It should accept arguments

ITEM-STRING (the string shown to the user), ITEM-OBJECT (the object corresponding to the menu item), and USER-INPUT (the current user input). The default is MENU-ITEM-MATCHES-REGEXP.
Returns the selected element in TABLE or nil if aborted.

Package

stumpwm.

Source

menu-definitions.lisp.

Function: select-window (query)

Switch to the first window that starts with @var{query}.

Package

stumpwm.

Source

window.lisp.

Function: select-window-by-name (name)

Switch to the first window whose name is exactly @var{name}.

Package

stumpwm.

Source

window.lisp.

Function: select-window-by-number (num &optional group)

Find the window with the given number and focus it in its frame.

Package

stumpwm.

Source

window.lisp.

Function: send-escape ()

Send the escape key to the current window.

Package

stumpwm.

Source

bindings.lisp.

Function: send-raw-key ()

Prompts for a key and forwards it to the CURRENT-WINDOW.

Package

stumpwm.

Source

remap-keys.lisp.

Function: set-bg-color (color)

Set the background color for the message bar and input bar. @var{color} can be any color recognized by X.

Package

stumpwm.

Source

screen.lisp.

Function: set-border-color (color)

Set the border color for the message bar and input bar. @var{color} can be any color recognized by X.

Package

stumpwm.

Source

screen.lisp.

Function: set-contrib-dir ()

Deprecated, use ‘add-to-load-path’ instead

Package

stumpwm.

Source

module.lisp.

Function: set-dynamic-group-initial-values (&key head-placement-policy overflow-policy master-layout default-split-ratio)

Set the default initial values for the class allocated slots of dynamic groups. These values are used only upon the first instantiation of a dynamic group.

Package

stumpwm.

Source

dynamic-group.lisp.

Function: set-fg-color (color)

Set the foreground color for the message bar and input bar. @var{color} can be any color recognized by X.

Package

stumpwm.

Source

screen.lisp.

Function: set-float-focus-color (color)

Set the border color for focused windows in a float group.

Package

stumpwm.

Source

screen.lisp.

Function: set-float-unfocus-color (color)

Set the border color for windows without focus in a float group.

Package

stumpwm.

Source

screen.lisp.

Function: set-focus-color (color)

Set the border color for focused windows. This is only used when there is more than one frame.

Package

stumpwm.

Source

screen.lisp.

Function: set-font (font)

Set the font(s) for the message bar and input bar.

Package

stumpwm.

Source

screen.lisp.

Function: set-frame-outline-width (width)
Package

stumpwm.

Source

screen.lisp.

Function: set-maxsize-gravity (gravity)

Set the default gravity for maxsize windows.

Package

stumpwm.

Source

window.lisp.

Function: set-module-dir (dir)

Sets the location of the for StumpWM to find modules

Package

stumpwm.

Source

module.lisp.

Function: set-msg-border-width (width)

Set the border width for the message bar, input bar and frame indicator.

Package

stumpwm.

Source

screen.lisp.

Function: set-normal-gravity (gravity)

Set the default gravity for normal windows. Possible values are @code{:center} @code{:top} @code{:left} @code{:right} @code{:bottom} @code{:top-left} @code{:top-right} @code{:bottom-left} and @code{:bottom-right}.

Package

stumpwm.

Source

window.lisp.

Function: set-prefix-key (key)

Change the stumpwm prefix key to KEY.
@example
(stumpwm:set-prefix-key (stumpwm:kbd "C-M-H-s-z"))
@end example

This will change the prefix key to @key{Control} + @key{Meta} + @key{Hyper} + @key{Super} + the @key{z} key. By most standards, a terrible prefix key but it makes a
great example.

Package

stumpwm.

Source

bindings.lisp.

Function: set-rule (symbol before after)

Add or replace a class ordering rule for SYMBOL.

Package

dynamic-mixins-swm.

Source

sorting.lisp.

Function: set-transient-gravity (gravity)

Set the default gravity for transient/pop-up windows.

Package

stumpwm.

Source

window.lisp.

Function: set-unfocus-color (color)

Set the border color for windows without focus. This is only used when there is more than one frame.

Package

stumpwm.

Source

screen.lisp.

Function: set-win-bg-color (color)

Set the background color of the window. The background color will only be visible for windows with size increment hints such as @samp{emacs} and @samp{xterm}.

Package

stumpwm.

Source

screen.lisp.

Function: set-window-geometry (win &key x y width height border-width)
Package

stumpwm.

Source

window.lisp.

Function: set-x-selection (text &optional selection)

Set the X11 selection string to @var{string}.

Package

stumpwm.

Source

selection.lisp.

Function: setup-iresize ()

Start the interactive resize mode.

Package

stumpwm.

Source

iresize.lisp.

Function: show-window-properties ()

Shows the properties of the current window. These properties can be used for matching windows with run-or-raise or window placement rules.

Package

stumpwm.

Source

user.lisp.

Function: sibling ()

Jump to the frame’s sibling. If a frame is split into two frames, these two frames are siblings.

Package

stumpwm.

Source

tile-group.lisp.

Function: snext ()

Go to the next screen.

Package

stumpwm.

Source

screen.lisp.

Function: sother ()

Go to the last screen.

Package

stumpwm.

Source

screen.lisp.

Function: split-string (string &optional separators)

Splits STRING into substrings where there are matches for SEPARATORS. Each match for SEPARATORS is a splitting point.
The substrings between the splitting points are made into a list which is returned.
***If SEPARATORS is absent, it defaults to "[ ftnrv]+".

If there is match for SEPARATORS at the beginning of STRING, we do not include a null substring for that. Likewise, if there is a match at the end of STRING, we don’t include a null substring for that.

Modifies the match data; use ‘save-match-data’ if necessary.

Package

stumpwm.

Source

primitives.lisp.

Function: sprev ()

Go to the previous screen.

Package

stumpwm.

Source

screen.lisp.

Function: stumpwm (&optional display-str)

Start the stump window manager.

Package

stumpwm.

Source

stumpwm.lisp.

Function: swap-windows ()

Exchange two windows

Package

stumpwm.

Source

dynamic-group.lisp.

Function: sync-all-minor-modes ()

Loop through all recently created objects and ensure that the appropriate minor modes are enabled in them, then nullify the list of objects.

Package

stumpwm.

Source

minor-modes.lisp.

Function: time-format (str)
Package

stumpwm.

Source

time.lisp.

Function: timer-p (object)
Package

stumpwm.

Source

primitives.lisp.

Function: title (title)

Override the current window’s title.

Package

stumpwm.

Source

window.lisp.

Function: toggle-always-on-top ()

Toggle whether the current window always appears over other windows. The order windows are added to this list determines priority.

Package

stumpwm.

Source

window.lisp.

Function: toggle-always-show ()

Toggle whether the current window is shown in all groups.

Package

stumpwm.

Source

group.lisp.

Function: toggle-mode-line (screen head &optional format)

Toggle the state of the mode line for the specified screen

Package

stumpwm.

Source

mode-line.lisp.

Function: unbind (key)

Remove a key binding from the escape key.

Package

stumpwm.

Source

bindings.lisp.

Function: undefine-key (map key)

Clear the key binding in the specified keybinding.

Package

stumpwm.

Source

kmap.lisp.

Function: unfloat-this ()

Transforms a float-window into a tile-window

Package

stumpwm.

Source

tile-group.lisp.

Function: ungrab-pointer ()

Remove the grab on the cursor and restore the cursor shape.

Package

stumpwm.

Source

core.lisp.

Function: unmaximize (&optional window)

Use the size the program requested for current window (if any) instead of maximizing it.

Package

stumpwm.

Source

tile-window.lisp.

Function: update-color-map (screen)

Read *colors* and cache their pixel colors for use when rendering colored text.

Package

stumpwm.

Source

color.lisp.

Function: update-configuration (win)
Package

stumpwm.

Source

window.lisp.

Function: update-screen-color-context (screen)
Package

stumpwm.

Source

color.lisp.

Function: validate-scope (scope superclasses &key errorp)

Validate a scope for a set of superclasses. SCOPE must be a designator as defined with define-minor-mode-scope, and superclasses should be the list of superclasses for a minor mode being defined with a scope of SCOPE. When ERRORP is T then an error is signalled when an invalid superscope is encountered. If it is NIL the NIL is returned instead. Upon success a list of conses is returned where the car is the scope designator and the cdr is the class with that scope.

Package

stumpwm.

Source

minor-modes.lisp.

Function: version ()

Print version information and compilation date.

Package

stumpwm.

Source

version.lisp.

Function: vgroups (&optional gfmt wfmt)

Like @command{groups} but also display the windows in each group. The optional arguments @var{gfmt} and @var{wfmt} can be used to override the default group formatting and window formatting, respectively.

Package

stumpwm.

Source

group.lisp.

Function: vsplit (&optional ratio)

Split the current frame into 2 frames, one on top of the other.

Package

stumpwm.

Source

tile-group.lisp.

Function: vsplit-equally (amt)

Deprecated. Use ‘hsplit-uniformly’ instead.

Package

stumpwm.

Source

tile-group.lisp.

Function: vsplit-uniformly (amt)

Split current frame in n rows of equal size.

Package

stumpwm.

Source

tile-group.lisp.

Function: where-is (cmd)

Print the key sequences bound to the specified command.

Package

stumpwm.

Source

help.lisp.

Function: which-key-mode ()

Toggle which-key-mode

Package

stumpwm.

Source

help.lisp.

Function: window-screen (window)
Package

stumpwm.

Source

window.lisp.

Function: window-send-string (string &optional window)

Send the string of characters to the current window as if they’d been typed.

Package

stumpwm.

Source

window.lisp.

Function: windowlist (&optional fmt window-list)

Allow the user to select a window from the list of windows and focus the selected window. For information of menu bindings see @ref{Menus}. The optional argument @var{fmt} can be specified to override the default window formatting. The optional argument @var{window-list} can be provided to show a custom window list (see @command{windowlist-by-class}). The default window list is the list of all window in the current group. Also note that the default window list is sorted by number and if the @var{windows-list} is provided, it is shown unsorted (as-is).

Package

stumpwm.

Source

window.lisp.

Function: windowlist-by-class (&optional fmt)

Allow the user to select a window from the list of windows (sorted by class) and focus the selected window. For information of menu bindings see @ref{Menus}. The optional argument @var{fmt} can be specified to override the default window formatting. This is a simple wrapper around the command @command{windowlist}.

Package

stumpwm.

Source

window.lisp.


5.1.5 Generic functions

Generic Function: autodisable-minor-mode (mode object)

The core of disabling minor modes within an object. Calls the minor modes on-disable function.

Package

stumpwm.

Source

minor-modes.lisp.

Generic Function: autoenable-minor-mode (mode object)

The core of enabling minor modes within an object. Mixes the minor mode in to the object

Package

stumpwm.

Source

minor-modes.lisp.

Generic Reader: callback-channel-events (object)
Package

stumpwm.

Methods
Reader Method: callback-channel-events ((callback-channel callback-channel))

automatically generated reader method

Source

ioloop.lisp.

Target Slot

events.

Generic Function: (setf callback-channel-events) (object)
Package

stumpwm.

Methods
Method: (setf callback-channel-events) (channel)
Source

ioloop.lisp.

Writer Method: (setf callback-channel-events) ((callback-channel callback-channel))

automatically generated writer method

Source

ioloop.lisp.

Target Slot

events.

Generic Reader: callback-channel-stream (object)
Package

stumpwm.

Methods
Reader Method: callback-channel-stream ((callback-channel callback-channel))

automatically generated reader method

Source

ioloop.lisp.

Target Slot

stream.

Generic Reader: dynamic-group-default-split-ratio (object)
Package

stumpwm.

Methods
Reader Method: dynamic-group-default-split-ratio ((dynamic-group dynamic-group))

The default ratio for the split between the master window
and the window stack. Valid values are any number between zero and one exclusive.

Source

dynamic-group.lisp.

Target Slot

split-ratio.

Generic Function: (setf dynamic-group-default-split-ratio) (group &optional update-heads)
Package

stumpwm.

Methods
Method: (setf dynamic-group-default-split-ratio) ((group dynamic-group) &optional update-heads)
Source

dynamic-group.lisp.

Generic Function: (setf dynamic-group-head-layout) (group head)
Package

stumpwm.

Methods
Method: (setf dynamic-group-head-layout) ((group dynamic-group) head)
Source

dynamic-group.lisp.

Generic Reader: dynamic-group-head-placement-policy (object)
Package

stumpwm.

Methods
Reader Method: dynamic-group-head-placement-policy ((dynamic-group dynamic-group))

Control which head new windows are placed upon. Valid values are :current-frame :first :second :third :fourth and :fifth

Source

dynamic-group.lisp.

Target Slot

head-placement-policy.

Generic Function: (setf dynamic-group-head-placement-policy) (group)
Package

stumpwm.

Methods
Method: (setf dynamic-group-head-placement-policy) ((group dynamic-group))
Source

dynamic-group.lisp.

Generic Function: (setf dynamic-group-head-split-ratio) (group head)
Package

stumpwm.

Methods
Method: (setf dynamic-group-head-split-ratio) ((group dynamic-group) head)
Source

dynamic-group.lisp.

Generic Reader: dynamic-group-master-layout (object)
Package

stumpwm.

Methods
Reader Method: dynamic-group-master-layout ((dynamic-group dynamic-group))

The default layout of the master window and window stack. Valid values are :left :right :top and :bottom

Source

dynamic-group.lisp.

Target Slot

master-layout.

Generic Function: (setf dynamic-group-master-layout) (group &optional update-heads)
Package

stumpwm.

Methods
Method: (setf dynamic-group-master-layout) ((group dynamic-group) &optional update-heads)
Source

dynamic-group.lisp.

Generic Reader: dynamic-group-overflow-policy (object)
Package

stumpwm.

Methods
Reader Method: dynamic-group-overflow-policy ((dynamic-group dynamic-group))

Control which window goes where when a head/group cannot
hold more windows.

The CAR is which window to remove from the group. Possible values are :new-window :master-window :stack-end and :stack-beg

The CADR is which head to move the window being removed to. Possible values are :any :ordered :first :second :third :fourth and :fifth.

The CADDR is what group to move the window being removed to in the event that it cannot be placed on a head in the group. Possible values are any and all strings.

Source

dynamic-group.lisp.

Target Slot

overflow-policy.

Generic Function: (setf dynamic-group-overflow-policy) (group)
Package

stumpwm.

Methods
Method: (setf dynamic-group-overflow-policy) ((group dynamic-group))
Source

dynamic-group.lisp.

Generic Function: focus-window (window &optional raise)

Give the specified window keyboard focus and (optionally) raise.

Package

stumpwm.

Source

window.lisp.

Methods
Method: focus-window (window &optional raise)

Make the window visible and give it keyboard focus. If raise is t, raise the window.

Generic Reader: frame-height (object)
Package

stumpwm.

Methods
Reader Method: frame-height ((frame frame))

automatically generated reader method

Source

primitives.lisp.

Target Slot

height.

Generic Writer: (setf frame-height) (object)
Package

stumpwm.

Methods
Writer Method: (setf frame-height) ((frame frame))

automatically generated writer method

Source

primitives.lisp.

Target Slot