Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the stumpwm Reference Manual, version 1.0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Thu Mar 11 14:57:16 2021 GMT+0.
| • Introduction | What stumpwm is all about | |
| • Systems | The systems documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
StumpWM is a window manager written entirely in Common Lisp. It attempts to be highly customizable while relying entirely on the keyboard for input. You will not find buttons, icons, title bars, tool bars, or any of the other conventional GUI widgets.
These design decisions reflect the growing popularity of productive, customizable lisp based systems.
StumpWM is a "everything-and-the-kitchen-sink WM" or "the Emacs of WMs."
StumpWM:Windows::Emacs:Text
If you want a minimalist tiling window manager, then StumpWM is not what you're looking for. The code base is ~15k lines, the binaries produced are ~60mb.
StumpWM manages windows the way emacs manages buffers, or the way screen manages terminals. If you want a flexible, customizable, hackable desktop experience, look no further.
The recommended way to install the dependencies is using Quicklisp. Follow the instructions at http://www.quicklisp.org/ to install it. In short:
$ curl -O https://beta.quicklisp.org/quicklisp.lisp
$ sbcl --load quicklisp.lisp
Then at the REPL:
(quicklisp-quickstart:install)
Make sure you have added it to your lisp init file using:
(ql:add-to-init-file)
Then, in a repl:
(ql:quickload "clx")
(ql:quickload "cl-ppcre")
(ql:quickload "alexandria")
Note: The recommended way to install SBCL is by downloading one of their pre-built binaries available in their web page or build it from source. Please do not install SBCL using your distributions package manager, especially Ubuntu. If you do so it is likely that you'll run into problems when building StumpWM due to using obsolete versions of the dependencies.
Building stumpwm from git requires that you build the configure script:
./autogen.sh
Then run it:
./configure
Now build it:
make
If all goes well, you should have a stumpwm binary now. You can run the binary from where it is (starting it with X) or install it, along with the .info documentation, with:
make install
Now that you have a binary, call it from your ~/.xinitrc file:
# The default path is /usr/local/bin/stumpwm
echo /path/to/stumpwm >> ~/.xinitrc
startx
Hopefully that will put you in X running stumpwm! See StartUp on the wiki for more examples.
Pull requests are always welcome! Here are some guidelines to ensure that your contribution gets merged in a timely manner:
If you aren't a lisp hacker, you can contribute in the form of documenting and organizing the wiki. There's a lot of information floating around; if you find it where you didn't expect it, move or link to it in a more logical place.
Fancy yourself a lisp hacker? Here's a wishlist of features for the StumpWM universe (in no particular order):
There's a texinfo manual, stumpwm.texi. The build scripts generate an info file you can read in emacs or with the `info' program. The manual for the latest git version (may be slightly out of date) is available to read online at: The Manual
And, as in Emacs, you can always get documentation with:
| Key | Help | |--------------------|----------------------------------| | C-t h v | Variables | | C-t h f | Functions | | C-t h k | Key sequences | | C-t h c | Commands | | C-t h w | Find key sequences for a command |
For other stuff (tips tricks and examples) visit the stumpwm wiki
There's a #stumpwm channel on irc.freenode.net, too.
Finally, there's our mailing list (click to sign up) stumpwm-devel@nongnu.org.
Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The stumpwm system |
David Bjergaard <dbjergaard@gmail.com>
Shawn Betts <sabetts@vcn.bc.ca>
A tiling, keyboard driven window manager
1.0.1
stumpwm.asd (file)
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
Next: The stumpwm/package․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
stumpwm.asd
stumpwm (system)
Next: The stumpwm/debug․lisp file, Previous: The stumpwm․asd file, Up: Lisp files [Contents][Index]
stumpwm (system)
package.lisp
Next: The stumpwm/primitives․lisp file, Previous: The stumpwm/package․lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
stumpwm (system)
debug.lisp
Next: The stumpwm/wrappers․lisp file, Previous: The stumpwm/debug․lisp file, Up: Lisp files [Contents][Index]
debug.lisp (file)
stumpwm (system)
primitives.lisp
Next: The stumpwm/pathnames․lisp file, Previous: The stumpwm/primitives․lisp file, Up: Lisp files [Contents][Index]
primitives.lisp (file)
stumpwm (system)
wrappers.lisp
Next: The stumpwm/font-rendering․lisp file, Previous: The stumpwm/wrappers․lisp file, Up: Lisp files [Contents][Index]
wrappers.lisp (file)
stumpwm (system)
pathnames.lisp
Next: The stumpwm/keysyms․lisp file, Previous: The stumpwm/pathnames․lisp file, Up: Lisp files [Contents][Index]
pathnames.lisp (file)
stumpwm (system)
font-rendering.lisp
Next: The stumpwm/keytrans․lisp file, Previous: The stumpwm/font-rendering․lisp file, Up: Lisp files [Contents][Index]
font-rendering.lisp (file)
stumpwm (system)
keysyms.lisp
Next: The stumpwm/kmap․lisp file, Previous: The stumpwm/keysyms․lisp file, Up: Lisp files [Contents][Index]
keysyms.lisp (file)
stumpwm (system)
keytrans.lisp
Next: The stumpwm/input․lisp file, Previous: The stumpwm/keytrans․lisp file, Up: Lisp files [Contents][Index]
keytrans.lisp (file)
stumpwm (system)
kmap.lisp
Next: The stumpwm/core․lisp file, Previous: The stumpwm/kmap․lisp file, Up: Lisp files [Contents][Index]
kmap.lisp (file)
stumpwm (system)
input.lisp
Next: The stumpwm/command․lisp file, Previous: The stumpwm/input․lisp file, Up: Lisp files [Contents][Index]
input.lisp (file)
stumpwm (system)
core.lisp
Next: The stumpwm/menu-declarations․lisp file, Previous: The stumpwm/core․lisp file, Up: Lisp files [Contents][Index]
core.lisp (file)
stumpwm (system)
command.lisp
Next: The stumpwm/menu-definitions․lisp file, Previous: The stumpwm/command․lisp file, Up: Lisp files [Contents][Index]
command.lisp (file)
stumpwm (system)
menu-declarations.lisp
Next: The stumpwm/screen․lisp file, Previous: The stumpwm/menu-declarations․lisp file, Up: Lisp files [Contents][Index]
menu-declarations.lisp (file)
stumpwm (system)
menu-definitions.lisp
Next: The stumpwm/head․lisp file, Previous: The stumpwm/menu-definitions․lisp file, Up: Lisp files [Contents][Index]
menu-definitions.lisp (file)
stumpwm (system)
screen.lisp
Next: The stumpwm/group․lisp file, Previous: The stumpwm/screen․lisp file, Up: Lisp files [Contents][Index]
screen.lisp (file)
stumpwm (system)
head.lisp
Next: The stumpwm/bindings․lisp file, Previous: The stumpwm/head․lisp file, Up: Lisp files [Contents][Index]
head.lisp (file)
stumpwm (system)
group.lisp
Next: The stumpwm/events․lisp file, Previous: The stumpwm/group․lisp file, Up: Lisp files [Contents][Index]
group.lisp (file)
stumpwm (system)
bindings.lisp
Next: The stumpwm/window․lisp file, Previous: The stumpwm/bindings․lisp file, Up: Lisp files [Contents][Index]
bindings.lisp (file)
stumpwm (system)
events.lisp
Next: The stumpwm/floating-group․lisp file, Previous: The stumpwm/events․lisp file, Up: Lisp files [Contents][Index]
events.lisp (file)
stumpwm (system)
window.lisp
Next: The stumpwm/tile-window․lisp file, Previous: The stumpwm/window․lisp file, Up: Lisp files [Contents][Index]
window.lisp (file)
stumpwm (system)
floating-group.lisp
Next: The stumpwm/tile-group․lisp file, Previous: The stumpwm/floating-group․lisp file, Up: Lisp files [Contents][Index]
floating-group.lisp (file)
stumpwm (system)
tile-window.lisp
Next: The stumpwm/window-placement․lisp file, Previous: The stumpwm/tile-window․lisp file, Up: Lisp files [Contents][Index]
tile-window.lisp (file)
stumpwm (system)
tile-group.lisp
Next: The stumpwm/message-window․lisp file, Previous: The stumpwm/tile-group․lisp file, Up: Lisp files [Contents][Index]
tile-group.lisp (file)
stumpwm (system)
window-placement.lisp
Next: The stumpwm/selection․lisp file, Previous: The stumpwm/window-placement․lisp file, Up: Lisp files [Contents][Index]
window-placement.lisp (file)
stumpwm (system)
message-window.lisp
Next: The stumpwm/module․lisp file, Previous: The stumpwm/message-window․lisp file, Up: Lisp files [Contents][Index]
message-window.lisp (file)
stumpwm (system)
selection.lisp
Next: The stumpwm/ioloop․lisp file, Previous: The stumpwm/selection․lisp file, Up: Lisp files [Contents][Index]
selection.lisp (file)
stumpwm (system)
module.lisp
Next: The stumpwm/timers․lisp file, Previous: The stumpwm/module․lisp file, Up: Lisp files [Contents][Index]
module.lisp (file)
stumpwm (system)
ioloop.lisp
sbcl-io-loop (class)
Next: The stumpwm/stumpwm․lisp file, Previous: The stumpwm/ioloop․lisp file, Up: Lisp files [Contents][Index]
ioloop.lisp (file)
stumpwm (system)
timers.lisp
Next: The stumpwm/user․lisp file, Previous: The stumpwm/timers․lisp file, Up: Lisp files [Contents][Index]
timers.lisp (file)
stumpwm (system)
stumpwm.lisp
Next: The stumpwm/interactive-keymap․lisp file, Previous: The stumpwm/stumpwm․lisp file, Up: Lisp files [Contents][Index]
stumpwm.lisp (file)
stumpwm (system)
user.lisp
Next: The stumpwm/iresize․lisp file, Previous: The stumpwm/user․lisp file, Up: Lisp files [Contents][Index]
user.lisp (file)
stumpwm (system)
interactive-keymap.lisp
Next: The stumpwm/help․lisp file, Previous: The stumpwm/interactive-keymap․lisp file, Up: Lisp files [Contents][Index]
interactive-keymap.lisp (file)
stumpwm (system)
iresize.lisp
Next: The stumpwm/fdump․lisp file, Previous: The stumpwm/iresize․lisp file, Up: Lisp files [Contents][Index]
iresize.lisp (file)
stumpwm (system)
help.lisp
Next: The stumpwm/time․lisp file, Previous: The stumpwm/help․lisp file, Up: Lisp files [Contents][Index]
help.lisp (file)
stumpwm (system)
fdump.lisp
Next: The stumpwm/mode-line․lisp file, Previous: The stumpwm/fdump․lisp file, Up: Lisp files [Contents][Index]
fdump.lisp (file)
stumpwm (system)
time.lisp
Next: The stumpwm/mode-line-formatters․lisp file, Previous: The stumpwm/time․lisp file, Up: Lisp files [Contents][Index]
time.lisp (file)
stumpwm (system)
mode-line.lisp
Next: The stumpwm/color․lisp file, Previous: The stumpwm/mode-line․lisp file, Up: Lisp files [Contents][Index]
mode-line.lisp (file)
stumpwm (system)
mode-line-formatters.lisp
Next: The stumpwm/wse․lisp file, Previous: The stumpwm/mode-line-formatters․lisp file, Up: Lisp files [Contents][Index]
mode-line-formatters.lisp (file)
stumpwm (system)
color.lisp
Next: The stumpwm/dynamic-window․lisp file, Previous: The stumpwm/color․lisp file, Up: Lisp files [Contents][Index]
color.lisp (file)
stumpwm (system)
wse.lisp
Next: The stumpwm/remap-keys․lisp file, Previous: The stumpwm/wse․lisp file, Up: Lisp files [Contents][Index]
wse.lisp (file)
stumpwm (system)
dynamic-window.lisp
expose (function)
Next: The stumpwm/version․lisp file, Previous: The stumpwm/dynamic-window․lisp file, Up: Lisp files [Contents][Index]
dynamic-window.lisp (file)
stumpwm (system)
remap-keys.lisp
Previous: The stumpwm/remap-keys․lisp file, Up: Lisp files [Contents][Index]
remap-keys.lisp (file)
stumpwm (system)
version.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The stumpwm-system package | ||
| • The stumpwm package | ||
| • The stumpwm-user package |
Next: The stumpwm package, Previous: Packages, Up: Packages [Contents][Index]
stumpwm.asd
Next: The stumpwm-user package, Previous: The stumpwm-system package, Up: Packages [Contents][Index]
package.lisp (file)
Previous: The stumpwm package, Up: Packages [Contents][Index]
package.lisp (file)
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions | ||
| • Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported constants | ||
| • Exported special variables | ||
| • Exported macros | ||
| • Exported functions | ||
| • Exported generic functions | ||
| • Exported conditions | ||
| • Exported structures | ||
| • Exported classes |
Next: Exported special variables, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
primitives.lisp (file)
primitives.lisp (file)
primitives.lisp (file)
Next: Exported macros, Previous: Exported constants, Up: Exported definitions [Contents][Index]
A list of all keycodes that are considered modifiers
primitives.lisp (file)
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
primitives.lisp (file)
The keymap used by batch-menu menus in addition to *menu-map*
menu-declarations.lisp (file)
Eight colors by default. You can redefine these to whatever you like and then call (update-color-map).
color.lisp (file)
A hook called whenever command mode is ended
primitives.lisp (file)
A hook called whenever command mode is started
primitives.lisp (file)
While processing an I/O channel, this variable is dynamically bound to the channel in question. This is provided primarily for error-handling code.
ioloop.lisp (file)
Dynamically bound to the I/O loop currently running, providing an easy way for event callbacks to register new channels.
ioloop.lisp (file)
The directory used by stumpwm to store data between sessions.
primitives.lisp (file)
Set this variable for a visual indication of expose events on internal StumpWM windows.
debug.lisp (file)
Set this variable to a number > 0 to turn on debugging. The greater the number the more debugging output.
debug.lisp (file)
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.
debug.lisp (file)
Default color for the desktop background.
screen.lisp (file)
The name of the default group.
primitives.lisp (file)
The default I/O loop implementation. Should be generically optimal for the given LISP implementation and operating system.
ioloop.lisp (file)
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.
primitives.lisp (file)
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.
selection.lisp (file)
The name given to a window that does not supply its own name.
window.lisp (file)
A list of window properties that stumpwm should deny matching windows’ requests to become mapped for the first time.
primitives.lisp (file)
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.
primitives.lisp (file)
Called whenever the mode-line is destroyed. It is called with argument, the mode-line
primitives.lisp (file)
A hook called whenever a window is destroyed or withdrawn.
primitives.lisp (file)
The display for the X server
primitives.lisp (file)
A list of key-bindings for line editing.
primitives.lisp (file)
A hook called inside stumpwm’s inner loop, before the default event processing takes place. This hook is run inside (with-event-queue ...).
primitives.lisp (file)
True when executing external commands.
primitives.lisp (file)
A hook called when a frame is given focus. The hook functions are called with 2 arguments: the current frame and the last frame.
primitives.lisp (file)
A hook called whenever stumpwm switches groups. It is called with 2 arguments: the current group and the last group.
primitives.lisp (file)
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).
primitives.lisp (file)
What appears in the frame indicator window?
primitives.lisp (file)
Keep track of the timer that hides the frame indicator.
primitives.lisp (file)
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.
primitives.lisp (file)
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
primitives.lisp (file)
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}.
primitives.lisp (file)
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.
bindings.lisp (file)
The keymap that group related key bindings sit on. It is bound to @kbd{C-t g} by default.
bindings.lisp (file)
Help related bindings hang from this keymap
bindings.lisp (file)
Maximum number of lines for help to display.
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.
mode-line-formatters.lisp (file)
Allow windows to move between frames.
primitives.lisp (file)
Controls whether hooks will actually run or not
primitives.lisp (file)
Set this to T if you never want windows to resize based on incremental WM_HINTs, like xterm and emacs.
tile-window.lisp (file)
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.
primitives.lisp (file)
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
input.lisp (file)
Do not add a command to the input history if it’s already the first in the list.
input.lisp (file)
This is the keymap containing all input editing key bindings.
input.lisp (file)
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
primitives.lisp (file)
A hook called inside stumpwm’s inner loop.
primitives.lisp (file)
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.
primitives.lisp (file)
Set to the last interactive command run.
primitives.lisp (file)
Controls whether hidden groups are displayed by ’groups’ and ’vgroups’ commands
primitives.lisp (file)
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’
module.lisp (file)
how many previous messages to keep.
primitives.lisp (file)
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.
primitives.lisp (file)
The width in pixels given to the borders of windows with maxsize or ratio hints.
primitives.lisp (file)
primitives.lisp (file)
The keymap used by the interactive menu.
menu-declarations.lisp (file)
Called after an item is selected in the windows menu. It is called with 1 argument: the menu.
primitives.lisp (file)
A hook called whenever stumpwm displays a message. The hook function is passed any number of arguments. Each argument is a line of text.
primitives.lisp (file)
The maximum width of a message before it wraps.
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
primitives.lisp (file)
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
primitives.lisp (file)
The number of pixels that pad the text in the message window.
primitives.lisp (file)
Keep track of the timer that hides the message window.
primitives.lisp (file)
The number of pixels that pad the text in the message window vertically.
primitives.lisp (file)
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.
primitives.lisp (file)
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.
primitives.lisp (file)
The mode line background color.
mode-line.lisp (file)
The mode line border color.
mode-line.lisp (file)
Specifies how thick the mode line’s border will be. Integer value.
mode-line.lisp (file)
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.
primitives.lisp (file)
The mode line foreground color.
mode-line.lisp (file)
The string passed to FORMAT to highlight things in the mode line.
mode-line-formatters.lisp (file)
Specifies the number of padding pixels between the text and the side of the mode line. Integer value.
mode-line.lisp (file)
The number of padding pixels between the modeline text and the top/bottom of the modeline. Integer value.
mode-line.lisp (file)
Specifies where the mode line is displayed. Valid values are :top and :bottom.
mode-line.lisp (file)
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.
mode-line.lisp (file)
A mapping from modifier type to x11 modifier.
primitives.lisp (file)
The location of the contrib modules on your system.
module.lisp (file)
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.
primitives.lisp (file)
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
primitives.lisp (file)
A hook called when a new frame is created. The hook is called with the frame as an argument.
primitives.lisp (file)
A hook called whenever a head is added. It is called with 2 arguments: the new head and the current screen.
primitives.lisp (file)
Called whenever the mode-line is created. It is called with argument, the mode-line
primitives.lisp (file)
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.
primitives.lisp (file)
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.
primitives.lisp (file)
The width in pixels given to the borders of regular windows.
primitives.lisp (file)
primitives.lisp (file)
A keycode to keycode map to re-wire numpads when the numlock key is active
input.lisp (file)
A hook called whenever a window is placed by rule. Arguments are window group and frame
primitives.lisp (file)
Called after a command is called. It is called with 1 argument: the command as a symbol.
primitives.lisp (file)
Called before a command is called. It is called with 1 argument: the command as a symbol.
primitives.lisp (file)
A hook called before any threads are started. Useful if you need to fork.
primitives.lisp (file)
True when processing pre-existing windows at startup.
primitives.lisp (file)
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.
message-window.lisp (file)
A hook called when stumpwm quits.
primitives.lisp (file)
assign this to T and messages won’t be recorded. It is recommended this is assigned using LET.
primitives.lisp (file)
Bool to toggle remapped-keys on/off. Defaults to t
remap-keys.lisp (file)
A hook called when a split is removed. the hook is called with the current frame and removed frame as arguments.
primitives.lisp (file)
Set to T to hide windows during interactive resize
primitives.lisp (file)
Number of pixels to increment by when interactively resizing frames.
iresize.lisp (file)
The keymap used for resizing a window
primitives.lisp (file)
A hook called when stumpwm restarts.
primitives.lisp (file)
Set to NIL if you don’t want clicking the root window to focus the frame containing the pointer.
primitives.lisp (file)
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.
primitives.lisp (file)
This is the keymap by default bound to @kbd{C-t} (along with *group-root-map* and either *tile-group-root-map* or *float-group-root-map*). It is known as the @dfn{prefix map}.
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.
primitives.lisp (file)
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.
primitives.lisp (file)
The list of screens managed by stumpwm.
primitives.lisp (file)
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.
mode-line.lisp (file)
An alist containing format character format function pairs for formatting screen mode-lines. functions are passed the mode line.
mode-line.lisp (file)
Called after a :selection-notify event is processed. It is called with 1 argument: the selection as a string.
primitives.lisp (file)
The shell program used by @code{run-shell-command}.
primitives.lisp (file)
The keymap used by single selection menus in addition to *menu-map*
menu-declarations.lisp (file)
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.
primitives.lisp (file)
A hook called when stumpwm starts.
primitives.lisp (file)
This is the message StumpWM displays when it starts. Set it to NIL to suppress.
primitives.lisp (file)
Suppress abort message when non-nil.
primitives.lisp (file)
For complete focus on the task at hand, set this to @code{T} and no raise/map denial messages will be seen.
primitives.lisp (file)
Assign this T and messages will not time out. It is recommended to assign this using LET.
primitives.lisp (file)
Set this to T if you never want to see the frame indicator.
primitives.lisp (file)
Set to T if you never want to see messages that windows were placed according to rules.
primitives.lisp (file)
The color of message text.
primitives.lisp (file)
The default value for ‘echo-date’, (e.g, Thu Mar 3 2005 23:05:25).
The default time value to pass to the modeline.
The amount of time a frame indicator timeout takes.
primitives.lisp (file)
Specifies, in seconds, how long a message will appear for. This must be an integer.
primitives.lisp (file)
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.
primitives.lisp (file)
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*.
primitives.lisp (file)
The top level key map. This is where you’ll find the binding for the @dfn{prefix map}.
Top-level I/O loop
timers.lisp (file)
The width in pixels given to the borders of transient or pop-up windows.
primitives.lisp (file)
primitives.lisp (file)
A hook called whenever a window sets the property indicating that it demands the user’s attention
primitives.lisp (file)
version.lisp (file)
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.
primitives.lisp (file)
The events to listen for on managed windows.
primitives.lisp (file)
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.
primitives.lisp (file)
an alist containing format character format function pairs for formatting window lists.
primitives.lisp (file)
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
primitives.lisp (file)
The events to listen for on managed windows’ parents.
primitives.lisp (file)
List of rules governing window placement. Use define-frame-preference to add rules
primitives.lisp (file)
This is a plist of stumpwm’s current selections. The different properties are generally set when killing text in the input bar.
primitives.lisp (file)
Hash table for looking up windows quickly.
primitives.lisp (file)
Next: Exported functions, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
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.
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
primitives.lisp (file)
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 and floating-group are the two 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
@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.
command.lisp (file)
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.
command.lisp (file)
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.
@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.
@end table
primitives.lisp (file)
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.
interactive-keymap.lisp (file)
Deprecated. Use ‘defcommand’ instead.
command.lisp (file)
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.
command.lisp (file)
Create a new window attribute and corresponding get/set functions.
window.lisp (file)
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.
Move the specified element in in LIST to the head of the list.
primitives.lisp (file)
Remove all functions from a hook
primitives.lisp (file)
Remove the specified function from the hook.
primitives.lisp (file)
Execute body and then restore the current frame.
tile-group.lisp (file)
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.
primitives.lisp (file)
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.
message-window.lisp (file)
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.
primitives.lisp (file)
Next: Exported generic functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
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.
group.lisp (file)
Add a format function to a format character (or overwrite an existing one).
mode-line.lisp (file)
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
module.lisp (file)
window.lisp (file)
color.lisp (file)
Return T if we’re outta arguments from the input line.
command.lisp (file)
Pop the next argument off.
command.lisp (file)
command.lisp (file)
Return the remainder of the argument text.
command.lisp (file)
Make frames the same height or width in the current frame’s subtree.
tile-group.lisp (file)
Warp the mouse the lower right corner of the current head.
Return a progress bar string of WIDTH characters composed of characters FULL and EMPTY at PERCENT complete.
mode-line-formatters.lisp (file)
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.
mode-line-formatters.lisp (file)
Hang a key binding off the escape key.
bindings.lisp (file)
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.
interactive-keymap.lisp (file)
stumpwm.lisp (file)
Remove TIMER from the list of active timers.
timers.lisp (file)
Clear all marks in the current group.
window.lisp (file)
Clear all window placement rules.
primitives.lisp (file)
stumpwm.lisp (file)
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.
command.lisp (file)
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))
menu-definitions.lisp (file)
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}.
bindings.lisp (file)
primitives.lisp (file)
primitives.lisp (file)
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.
input.lisp (file)
primitives.lisp (file)
Copy the last message displayed into the X selection
selection.lisp (file)
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.
Display a window indicating which frame is focused.
tile-group.lisp (file)
Return the current group for the current screen, unless otherwise specified.
group.lisp (file)
Return the current screen.
screen.lisp (file)
Return the current window on the current screen
screen.lisp (file)
Return a pathname inside stumpwm’s data dir with the specified name and type
primitives.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
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
exising 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.
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.
remap-keys.lisp (file)
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.
window.lisp (file)
Print the online help associated with the specified command.
Print the online help associated with the specified function.
Either interactively type the key sequence or supply it as text. This command prints the command bound to the specified key sequence.
Print the online help associated with the specified variable.
debug.lisp (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.
fdump.lisp (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.
fdump.lisp (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.
fdump.lisp (file)
Dump *window-placement-rules* to FILE.
tile-window.lisp (file)
Display @var{string} in the message bar.
Display a list of all the windows in the current frame.
tile-window.lisp (file)
Display @var{string} in the message bar on @var{screen}. You almost always want to use @command{message}.
message-window.lisp (file)
Display a list of managed windows. The optional argument @var{fmt} can be used to override the default window formatting.
window.lisp (file)
Start emacs unless it is already running, in which case focus it.
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.
mode-line.lisp (file)
menu-definitions.lisp (file)
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.
message-window.lisp (file)
Evaluate the s-expression and display the result(s).
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
tile-window.lisp (file)
iresize.lisp (file)
Automagically tile all windows and let the user select one, make
that window the focus. Set the variable ‘*expose-auto-tile-fn*’ to another
tiling function if a different layout is desired. Set ‘*expose-n-max*’ to the
maximum number of windows to be displayed for choosing.
dynamic-window.lisp (file)
Clear the current frame.
tile-group.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
module.lisp (file)
window.lisp (file)
Transform all floating windows in this group to tiled windows. Puts all tiled windows in the first frame of the group.
tile-group.lisp (file)
Transforms a tile-window into a float-window
tile-group.lisp (file)
Cycle through the frame tree to the next frame.
tile-group.lisp (file)
Forget the window placement rule that matches the current window.
tile-window.lisp (file)
primitives.lisp (file)
Jump to the last frame that had focus.
tile-group.lisp (file)
Cycle through the frame tree to the previous frame.
tile-group.lisp (file)
primitives.lisp (file)
primitives.lisp (file)
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.
tile-window.lisp (file)
primitives.lisp (file)
primitives.lisp (file)
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.
tile-group.lisp (file)
Toggle the fullscreen mode of the current widnow. Use this for clients with broken (non-NETWM) fullscreen implementations, such as any program using SDL.
window.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
Return the x selection no matter what client own it.
selection.lisp (file)
Return the value of the environment variable.
wrappers.lisp (file)
(setf getenv) (function)
Set the value of the environment variable, @var{var} to @var{val}.
wrappers.lisp (file)
getenv (function)
Echo the X selection.
selection.lisp (file)
Kill the current group. All windows in the current group are migrated to the next group.
group.lisp (file)
Kill other groups. All windows in other groups are migrated to the current group.
group.lisp (file)
Merge @var{from} into the current group. @var{from} is not deleted.
group.lisp (file)
Move the current window to the specified group.
group.lisp (file)
Move the current window to the specified group, and switch to it.
group.lisp (file)
move the marked windows to the specified group.
group.lisp (file)
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.
group.lisp (file)
Create a floating window group with the specified name and switch to it.
floating-group.lisp (file)
Create a new group but do not switch to it.
group.lisp (file)
Create a floating window group with the specified name, but do not switch to it.
floating-group.lisp (file)
Cycle to the next group in the group list.
group.lisp (file)
Cycle to the next group in the group list, taking the current window along.
group.lisp (file)
Go back to the last group.
group.lisp (file)
Cycle to the previous group in the group list.
group.lisp (file)
Cycle to the previous group in the group list, taking the current window along.
group.lisp (file)
Grab the pointer and set the pointer shape.
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
tile-window.lisp (file)
Rename the current group.
group.lisp (file)
Allow the user to select a group from a list, like windowlist for groups.
group.lisp (file)
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.
group.lisp (file)
Accepts numbers to select a group, otherwise grouplist selects.
group.lisp (file)
Split the current frame into 2 side-by-side frames.
tile-group.lisp (file)
Split current frame in n rows of equal size.
tile-group.lisp (file)
Returns the time in seconds since idle according to the root window of the ‘screen’.
timers.lisp (file)
stumpwm.lisp (file)
Display information about the current window.
window.lisp (file)
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*’
module.lisp (file)
Delete the region between start and end in the input string
input.lisp (file)
Move the cursor to the specified point in the string
input.lisp (file)
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.
input.lisp (file)
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.
input.lisp (file)
Return the position of the cursor.
input.lisp (file)
Return a the substring in INPUT bounded by START and END.
input.lisp (file)
Return a value pair of numbers where the first number is < the second and neither excedes the bounds of the input string.
input.lisp (file)
Starts interactive command "IRESIZE"
iresize.lisp (file)
This compiles a key string into a key structure used by ‘define-key’, ‘undefine-key’, ‘set-prefix-key’ and others.
This way you can exit from command mode. Also aliased as abort.
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.
window.lisp (file)
Kill all windows in the current group.
window.lisp (file)
Kill all windows in current group except the current-window
window.lisp (file)
Display the last message. If the previous command was lastmsg, then continue cycling back through the message history.
message-window.lisp (file)
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.
pathnames.lisp (file)
Return a list of the available modules.
module.lisp (file)
List all the properties of the current window and their values, like xprop.
Loads the contributed module with the given NAME.
module.lisp (file)
color.lisp (file)
Return a list of keys that are bound to command
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
Toggle the current window’s mark.
window.lisp (file)
run FMT and ARGS through ‘format’ and echo the result to the current screen.
message-window.lisp (file)
Send a fake key to the current window. @var{key} is a typical StumpWM key, like @kbd{C-M-o}.
A command to toggle the mode line visibility.
mode-line.lisp (file)
List the modifiers stumpwm recognizes and what MOD-X it thinks they’re on.
primitives.lisp (file)
primitives.lisp (file)
primitives.lisp (file)
primitives.lisp (file)
primitives.lisp (file)
primitives.lisp (file)
primitives.lisp (file)
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
tile-group.lisp (file)
Just like move-focus except that the current is pulled along.
tile-group.lisp (file)
group.lisp (file)
Move all windows from the list to the group
Go to the next window in the window list.
window.lisp (file)
Go to the next window in the current frame.
tile-group.lisp (file)
Jump to the next urgent window
window.lisp (file)
don’t focus any window but still read keyboard events.
window.lisp (file)
Delete all the frames but the current one and grow it to take up the entire head.
tile-group.lisp (file)
Go to the last accessed window in the current frame.
tile-group.lisp (file)
Switch to the window last focused.
window.lisp (file)
Converts the non-wild pathname designator PATHSPEC to directory form.
pathnames.lisp (file)
Return T if the pathname describes an executable file.
wrappers.lisp (file)
Re-arrange current window according to placement rules.
fdump.lisp (file)
Re-arrange existing windows according to placement rules.
fdump.lisp (file)
Go to the previous window in the window list.
window.lisp (file)
Go to the previous window in the current frame.
tile-group.lisp (file)
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.
Pulls a window selected from the list of windows. This allows a behavior similar to Emacs’ switch-to-buffer when selecting another window.
tile-window.lisp (file)
Pull the next hidden window into the current frame.
tile-window.lisp (file)
Pull the last focused, hidden window into the current frame.
tile-window.lisp (file)
Pull the next hidden window into the current frame.
tile-window.lisp (file)
Pull all marked windows into the current frame and clear the marks.
tile-window.lisp (file)
Pull window N from another frame into the current frame and focus it.
tile-window.lisp (file)
stumpwm.lisp (file)
Stuff the string @var{string} into the x selection.
selection.lisp (file)
Prompt the user to confirm quitting StumpWM.
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.
Warp the mouse by the specified amount from its current position.
Warp the mouse to the specified location.
READ-LINE, but with a workaround for a known SBCL/Linux bug regarding files in sysfs. Data is read in chunks of BLOCKSIZE bytes.
wrappers.lisp (file)
Read a single character from the user.
input.lisp (file)
Read a line of input through stumpwm and return it. Returns nil if the user aborted.
input.lisp (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
debug.lisp (file)
Refresh current window by a pair of resizes, also make it occupy entire frame.
tile-window.lisp (file)
Refresh current window without changing its size.
window.lisp (file)
Refresh screens in case a monitor was connected, but a ConfigureNotify event was snarfed by another program.
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.
Make a generic placement rule for the current window. Might be too specific/not specific enough!
tile-window.lisp (file)
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.
tile-group.lisp (file)
window.lisp (file)
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.
window.lisp (file)
Ensure that used window numbers do not have gaps; ignore PRESERVED window numbers.
window.lisp (file)
Resize the current frame by @var{width} and @var{height} pixels
tile-group.lisp (file)
Resize frame to direction @var{d}
iresize.lisp (file)
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.
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.
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.
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.
fdump.lisp (file)
Restore *window-placement-rules* from FILE.
tile-window.lisp (file)
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
command.lisp (file)
Call each function in HOOK.
primitives.lisp (file)
Call each function in HOOK and pass args to it.
primitives.lisp (file)
Similar to run-or-raise, but move the matching window to the current frame instead of switching to the window.
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}.
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.
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.
timers.lisp (file)
Return the current window on the specified screen
screen.lisp (file)
screen.lisp (file)
screen.lisp (file)
screen.lisp (file)
screen.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
fdump.lisp (file)
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.
menu-definitions.lisp (file)
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.
menu-definitions.lisp (file)
Switch to the first window that starts with @var{query}.
window.lisp (file)
Switch to the first window whose name is exactly @var{name}.
window.lisp (file)
Find the window with the given number and focus it in its frame.
window.lisp (file)
Send the escape key to the current window.
bindings.lisp (file)
Prompts for a key and forwards it to the CURRENT-WINDOW.
remap-keys.lisp (file)
Set the background color for the message bar and input bar. @var{color} can be any color recognized by X.
screen.lisp (file)
Set the border color for the message bar and input bar. @var{color} can be any color recognized by X.
screen.lisp (file)
Deprecated, use ‘add-to-load-path’ instead
module.lisp (file)
Set the foreground color for the message bar and input bar. @var{color} can be any color recognized by X.
screen.lisp (file)
Set the border color for focused windows in a float group.
screen.lisp (file)
Set the border color for windows without focus in a float group.
screen.lisp (file)
Set the border color for focused windows. This is only used when there is more than one frame.
screen.lisp (file)
Set the font(s) for the message bar and input bar.
screen.lisp (file)
screen.lisp (file)
Set the default gravity for maxsize windows.
window.lisp (file)
Sets the location of the for StumpWM to find modules
module.lisp (file)
Set the border width for the message bar, input bar and frame indicator.
screen.lisp (file)
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}.
window.lisp (file)
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.
bindings.lisp (file)
Set the default gravity for transient/pop-up windows.
window.lisp (file)
Set the border color for windows without focus. This is only used when there is more than one frame.
screen.lisp (file)
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}.
screen.lisp (file)
window.lisp (file)
Set the X11 selection string to @var{string}.
selection.lisp (file)
Start the interactive resize mode.
iresize.lisp (file)
Shows the properties of the current window. These properties can be used for matching windows with run-or-raise or window placement rules.
Jump to the frame’s sibling. If a frame is split into two frames, these two frames are siblings.
tile-group.lisp (file)
Go to the next screen.
screen.lisp (file)
Go to the last screen.
screen.lisp (file)
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.
primitives.lisp (file)
Go to the previous screen.
screen.lisp (file)
Start the stump window manager.
stumpwm.lisp (file)
primitives.lisp (file)
Override the current window’s title.
window.lisp (file)
Toggle whether the current window always appears over other windows. The order windows are added to this list determines priority.
window.lisp (file)
Toggle whether the current window is shown in all groups.
group.lisp (file)
Toggle the state of the mode line for the specified screen
mode-line.lisp (file)
Remove a key binding from the escape key.
bindings.lisp (file)
Clear the key binding in the specified keybinding.
Transforms a float-window into a tile-window
tile-group.lisp (file)
Remove the grab on the cursor and restore the cursor shape.
Use the size the program requested for current window (if any) instead of maximizing it.
tile-window.lisp (file)
Read *colors* and cache their pixel colors for use when rendering colored text.
color.lisp (file)
window.lisp (file)
color.lisp (file)
Print version information and compilation date.
version.lisp (file)
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.
group.lisp (file)
Split the current frame into 2 frames, one on top of the other.
tile-group.lisp (file)
Split current frame in n columns of equal size.
tile-group.lisp (file)
Print the key sequences bound to the specified command.
window.lisp (file)
Send the string of characters to the current window as if they’d been typed.
window.lisp (file)
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).
window.lisp (file)
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}.
window.lisp (file)
Next: Exported conditions, Previous: Exported functions, Up: Exported definitions [Contents][Index]
automatically generated reader method
ioloop.lisp (file)
automatically generated writer method
ioloop.lisp (file)
ioloop.lisp (file)
automatically generated reader method
ioloop.lisp (file)
Give the specified window keyboard focus and (optionally) raise.
window.lisp (file)
Make the window visible and give it keyboard focus. If raise is t, raise the window.
Get the X and Y coordinates to place something of width WIDTH
and height HEIGHT within an area defined by MINX MINY MAXX and MAXY, guided by
GRAVITY.
message-window.lisp (file)
A head is being added to this group’s screen.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
Called when a window is added to the group. All
house keeping is already taken care of. Only the group’s specific
window managing housekeeping need be done. This function accepts keys
to inform the group on how to place the window.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
floating-group.lisp (file)
The user clicked somewhere in the group.
group.lisp (file)
tile-group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
floating-group.lisp (file)
The group is asked to return its current head.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
The group is asked to return its focused window.
group.lisp (file)
(setf group-current-window) (generic function)
automatically generated reader method
group-current-window (generic function)
automatically generated writer method
group.lisp (file)
Called when a window is removed from thegroup. All
house keeping is already taken care of. Only the group’s specific
window managing housekeeping need be done.
group.lisp (file)
tile-group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
The group is asked to focus the specified window wherever it is.
group.lisp (file)
tile-group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
The group is asked to in some way show the user where the keyboard focus is.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
The current window was hidden or destroyed or
something happened to it. So the group is asked to do something smart
about it.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
The window requested a position change.
group.lisp (file)
tile-group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
automatically generated reader method
group.lisp (file)
automatically generated writer method
group.lisp (file)
automatically generated reader method
group.lisp (file)
automatically generated writer method
group.lisp (file)
A request has been made to raise the window. TYPE
is the type of raise request being made. :MAP means the window has
made requested to be mapped. :above means the window has requested to
to be placed above its siblings.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
A head is being removed from this group’s screen.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
A head is being resized on this group’s screen.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
The window requested a width and/or height change.
group.lisp (file)
tile-group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
The root window got an exposure event. If the group
needs to redraw anything on it, this is where it should do it.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
automatically generated reader method
group.lisp (file)
automatically generated writer method
group.lisp (file)
Called on all groups while stumpwm is starting up.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
When the group is no longer the current group, this function is called.
group.lisp (file)
floating-group.lisp (file)
Called when the head configuration for the group changes.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
When a head or its usable area is resized, this is called. When the modeline size changes, this is called.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
When the group becomes the current group, this
function is called. This call is expected to set the focus.
group.lisp (file)
tile-group.lisp (file)
floating-group.lisp (file)
automatically generated reader method
group.lisp (file)
automatically generated writer method
group.lisp (file)
Returns a list of events that CHANNEL is interested in. An event
specification may be a simple symbol, or a list of a symbol and
additional data for the event. Specific I/O loop implementations may
implement additional events, but the following event specifications
should be supported by all I/O loops:
:READ – The channel will be notified when its I/O port can be
read from without blocking.
:WRITE – The channel will be notified when its I/O port can
be written to without blocking.
(:TIMEOUT TIME-SPEC) – TIME-SPEC is a point in time in the
same units as from (GET-INTERNAL-REAL-TIME), at which point
the channel will be notified. It is permissible for TIME-SPEC
to be a real number of any representation, but the system does
not guarantee any particular level of accuracy.
:LOOP – The channel will be notifed for each iteration of the
I/O loop, just before blocking for incoming events. This should
be considered a hack to be avoided, but may be useful for
certain libraries (such as XLIB).
If, at any time, an empty list is returned, the channel is
unregistered with the I/O loop.
The I/O loop will check what events a channel is interested in when it is first registered with the loop, and whenever the channel has been notified of an event. If the channel changes its mind at any other point in time, it should use the IO-LOOP-UPDATE function to notify the I/O loop of such changes. The I/O loop may also update spuriously at any time, but such updates are not guaranteed.
ioloop.lisp (file)
stumpwm.lisp (file)
stumpwm.lisp (file)
timers.lisp (file)
Called by the I/O loop to notify a channel that an event has occurred. EVENT is the symbol corresponding to the event specification from IO-CHANNEL-EVENTS (that is, :READ, :WRITE, :TIMEOUT or :LOOP). A number of keyword arguments with additional data specific to a certain event may also be passed, but no such arguments are currently defined.
ioloop.lisp (file)
stumpwm.lisp (file)
stumpwm.lisp (file)
stumpwm.lisp (file)
timers.lisp (file)
timers.lisp (file)
Returns the I/O facility operated on by CHANNEL, in a
representation understood by IO-LOOP. CHANNEL may be either an I/O
channel or an object representing an underlying I/O facility, such
as a stream object. An I/O loop implementation should implement
methods for any primitive I/O facilities that it can monitor for
events, and abstract channels should return whatever
IO-CHANNEL-IOPORT returns for the primitive facility that it
operates on.
An I/O channel may also return NIL to indicate that it is only interested in purely virtual events, such as :TIMEOUT or :LOOP.
ioloop.lisp (file)
stumpwm.lisp (file)
stumpwm.lisp (file)
timers.lisp (file)
Run the given I/O multiplexer, watching for events
on any channels registered with it. IO-LOOP will return when it has
no channels left registered with it.
ioloop.lisp (file)
Add a channel to the given I/O multiplexer to be monitored.
ioloop.lisp (file)
Unregister a channel from the I/O multiplexer.
ioloop.lisp (file)
Make the I/O loop update its knowledge of what
events CHANNEL is interested in. See the documentation for
IO-CHANNEL-EVENTS for more information.
ioloop.lisp (file)
What to do when exiting the menu without results. Must signal :menu-quit with the result.
menu-declarations.lisp (file)
menu-definitions.lisp (file)
What occurs when backspace is pressed in a menu
menu-declarations.lisp (file)
menu-definitions.lisp (file)
If the cursor is not at the top, move cursor up. Regardless, unmark the entry at the selected point.
menu-definitions.lisp (file)
menu-definitions.lisp (file)
Move menu cursor down
menu-declarations.lisp (file)
clear the search string if the cursor is moved
menu-definitions.lisp (file)
menu-definitions.lisp (file)
Apply FUNCTION to the data portion of the menu entry.
menu-declarations.lisp (file)
menu-definitions.lisp (file)
Generates a string suitable for displaying in a menu
menu-declarations.lisp (file)
menu-definitions.lisp (file)
What to do when exiting the menu with results. Must signal :menu-quit with the result.
menu-declarations.lisp (file)
Value returned with the signal is an alist, where the cdr of the value returned by assoc is a list items that were marked with that character. Example when entry1 and entry2 are marked with ’a’, and entry3 is not marked: ((a entry1 entry2) (NIL entry3))
menu-definitions.lisp (file)
menu-definitions.lisp (file)
Move a whole page up in the menu
menu-declarations.lisp (file)
menu-definitions.lisp (file)
menu-definitions.lisp (file)
Move a whole page down in the menu
menu-declarations.lisp (file)
menu-definitions.lisp (file)
menu-definitions.lisp (file)
Scroll the menu down
menu-declarations.lisp (file)
clear the search string if the cursor is moved
menu-definitions.lisp (file)
menu-definitions.lisp (file)
Scroll the menu up
menu-declarations.lisp (file)
clear the search string if the cursor is moved
menu-definitions.lisp (file)
menu-definitions.lisp (file)
Move menu cursor up
menu-declarations.lisp (file)
clear the search string if the cursor is moved
menu-definitions.lisp (file)
menu-definitions.lisp (file)
Bring the window to the top of the window stack.
window.lisp (file)
Map the window if needed and bring it to the top of the stack. Does not affect focus.
Really bring the window to the top of the window stack in group
window.lisp (file)
tile-window.lisp (file)
floating-group.lisp (file)
automatically generated reader method
primitives.lisp (file)
automatically generated writer method
primitives.lisp (file)
automatically generated reader method
primitives.lisp (file)
automatically generated writer method
primitives.lisp (file)
automatically generated reader method
primitives.lisp (file)
automatically generated writer method
primitives.lisp (file)
automatically generated reader method
primitives.lisp (file)
automatically generated writer method
primitives.lisp (file)
automatically generated reader method
primitives.lisp (file)
automatically generated writer method
primitives.lisp (file)
automatically generated reader method
primitives.lisp (file)
Update the window decoration.
window.lisp (file)
tile-window.lisp (file)
floating-group.lisp (file)
automatically generated reader method
window.lisp (file)
automatically generated writer method
window.lisp (file)
automatically generated reader method
window.lisp (file)
automatically generated writer method