Common Lisp Package: STUMPWM

README:

FUNCTION

Public

ABORT-IRESIZE

Exit from the interactive resize mode.

ADD-SCREEN-MODE-LINE-FORMATTER (CHARACTER FMT-FUN)

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

ARGUMENT-LINE-END-P (INPUT)

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

ARGUMENT-POP (INPUT)

Pop the next argument off.

ARGUMENT-POP-REST (INPUT)

Return the remainder of the argument text.

BAR-ZONE-COLOR (AMOUNT &OPTIONAL (MED 20) (HI 50) (CRIT 90) 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.

CANCEL-TIMER (TIMER)

Remove TIMER from the list of active timers.

CLEAR-WINDOW-PLACEMENT-RULES

Clear all window placement rules.

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.

CURRENT-GROUP (&OPTIONAL (SCREEN (CURRENT-SCREEN)))

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

CURRENT-SCREEN

Return the current screen.

CURRENT-WINDOW

Return the current window on the current screen

DATA-DIR-FILE (NAME &OPTIONAL TYPE)

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

DDUMP-CURRENT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DDUMP-SCREENS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

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

DUMP-DESKTOP-TO-FILE (FILE)

Dumps the frames of all groups of all screens to the named file

DUMP-GROUP-TO-FILE (FILE)

Dumps the frames of the current group of the current screen to the named file.

DUMP-SCREEN-TO-FILE (FILE)

Dumps the frames of all groups of the current screen to the named file

ECHO-DATE

Display the date and time.

ECHO-STRING (SCREEN MSG)

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

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.

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.

EXIT-IRESIZE

Exit from the interactive resize mode.

FDUMP-CURRENT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FDUMP-HEIGHT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FDUMP-NUMBER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FDUMP-WIDTH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FDUMP-WINDOWS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FDUMP-X (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FDUMP-Y (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

GDUMP-CURRENT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

GDUMP-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

GDUMP-NUMBER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

GDUMP-TREE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

GET-X-SELECTION (&OPTIONAL TIMEOUT)

Return the x selection no matter what client own it.

GETENV (VAR)

Return the value of the environment variable.

SETFGETENV (VAL VAR)

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

INPUT-DELETE-REGION (INPUT START END)

Delete the region between start and end in the input string

INPUT-GOTO-CHAR (INPUT POINT)

Move the cursor to the specified point in the string

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.

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.

INPUT-POINT (INPUT)

Return the position of the cursor.

INPUT-SUBSTRING (INPUT START END)

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

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.

IRESIZE

Start the interactive resize mode. A new keymap specific to resizing the current frame is loaded. Hit @key{C-g}, @key{RET}, or @key{ESC} to exit.

KBD (KEYS)

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

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.

LIST-MODULES

Return a list of the available modules.

LOAD-MODULE (NAME)

Loads the contributed module with the given NAME.

LOOKUP-COMMAND (KEYMAP COMMAND)

Return a list of keys that are bound to command

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

MESSAGE (FMT &REST ARGS)

run FMT and ARGS through `format' and echo the result to the current screen.

PATHNAME-IS-EXECUTABLE-P (PATHNAME)

Return T if the pathname describes an executable file.

PLACE-EXISTING-WINDOWS

Re-arrange existing windows according to placement rules.

PROGRAMS-IN-PATH (&OPTIONAL FULL-PATH (PATH (SPLIT-STRING (GETENV 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.

READ-LINE-FROM-SYSFS (STREAM &OPTIONAL (BLOCKSIZE 80))

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

READ-ONE-CHAR (SCREEN)

Read a single character from the user.

READ-ONE-LINE (SCREEN PROMPT &KEY (INITIAL-INPUT ) REQUIRE-MATCH PASSWORD)

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

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

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.

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

RUN-HOOK (HOOK)

Call each function in HOOK.

RUN-HOOK-WITH-ARGS (HOOK &REST ARGS)

Call each function in HOOK and pass args to it.

RUN-OR-RAISE (CMD PROPS &OPTIONAL (ALL-GROUPS *RUN-OR-RAISE-ALL-GROUPS*) (ALL-SCREENS *RUN-OR-RAISE-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}.

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.

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.

SCREEN-CURRENT-WINDOW (SCREEN)

Return the current window on the specified screen

SDUMP-CURRENT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SDUMP-GROUPS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SDUMP-NUMBER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SET-BG-COLOR (COLOR)

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

SET-BORDER-COLOR (COLOR)

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

SET-CONTRIB-DIR (DIR)

Sets the location of the contrib modules

SET-FG-COLOR (COLOR)

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

SET-FLOAT-FOCUS-COLOR (COLOR)

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

SET-FLOAT-UNFOCUS-COLOR (COLOR)

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

SET-FOCUS-COLOR (COLOR)

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

SET-FONT (FONT)

Set the font for the message bar and input bar.

SET-MAXSIZE-GRAVITY (GRAVITY)

Set the default gravity for maxsize windows.

SET-MSG-BORDER-WIDTH (WIDTH)

Set the border width for the message bar and input bar.

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

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.

SET-TRANSIENT-GRAVITY (GRAVITY)

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

SET-UNFOCUS-COLOR (COLOR)

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

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

SET-X-SELECTION (TEXT)

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

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.

STUMPWM (&OPTIONAL (DISPLAY-STR (OR (GETENV DISPLAY) :0)))

Start the stump window manager.

TOGGLE-MODE-LINE (SCREEN HEAD &OPTIONAL (FORMAT '*SCREEN-MODE-LINE-FORMAT*))

Toggle the state of the mode line for the specified screen

UNDEFINE-KEY (MAP KEY)

Clear the key binding in the specified keybinding.

UPDATE-COLOR-MAP (SCREEN)

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

VERSION

Print version information and compilation date.

WINDOW-SEND-STRING (STRING &OPTIONAL (WINDOW (CURRENT-WINDOW)))

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

Undocumented

ADJUST-COLOR (COLOR AMT)

ARGUMENT-POP-OR-READ (INPUT PROMPT &OPTIONAL COMPLETIONS)

COMMAND-MODE-END-MESSAGE

COMMAND-MODE-START-MESSAGE

CONCAT (&REST STRINGS)

CURRENT-HEAD (&OPTIONAL (GROUP (CURRENT-GROUP)))

SETFDDUMP-CURRENT (NEW-VALUE INSTANCE)

SETFDDUMP-SCREENS (NEW-VALUE INSTANCE)

DFORMAT (LEVEL FMT &REST ARGS)

SETFFDUMP-CURRENT (NEW-VALUE INSTANCE)

SETFFDUMP-HEIGHT (NEW-VALUE INSTANCE)

SETFFDUMP-NUMBER (NEW-VALUE INSTANCE)

SETFFDUMP-WIDTH (NEW-VALUE INSTANCE)

SETFFDUMP-WINDOWS (NEW-VALUE INSTANCE)

SETFFDUMP-X (NEW-VALUE INSTANCE)

SETFFDUMP-Y (NEW-VALUE INSTANCE)

FIND-MODULE (NAME)

SETFGDUMP-CURRENT (NEW-VALUE INSTANCE)

SETFGDUMP-NAME (NEW-VALUE INSTANCE)

SETFGDUMP-NUMBER (NEW-VALUE INSTANCE)

SETFGDUMP-TREE (NEW-VALUE INSTANCE)

LOOKUP-KEY (KEYMAP KEY &OPTIONAL ACCEPT-DEFAULT)

SETFSDUMP-CURRENT (NEW-VALUE INSTANCE)

SETFSDUMP-GROUPS (NEW-VALUE INSTANCE)

SETFSDUMP-NUMBER (NEW-VALUE INSTANCE)

SET-FRAME-OUTLINE-WIDTH (WIDTH)

SET-WINDOW-GEOMETRY (WIN &KEY X Y WIDTH HEIGHT BORDER-WIDTH)

TIME-FORMAT (STR)

TIMER-P (OBJECT)

UPDATE-SCREEN-COLOR-CONTEXT (SCREEN)

Private

ADD-GROUP (SCREEN NAME &KEY BACKGROUND (TYPE *DEFAULT-GROUP-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.

ALL-COMMANDS (&OPTIONAL (ONLY-ACTIVE T))

Return a list of all interactive commands as strings. By default only return active commands.

ALL-HEADS

Return all heads on all screens.

ALTERNATE (STRINGS PERIOD)

Show each of STRINGS, alternating at most once every PERIOD seconds.

ARGUMENT-LINE-START (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ARGUMENT-LINE-STRING (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ASSIGN-WINDOW (WINDOW GROUP &OPTIONAL (WHERE TAIL))

Assign the window to the specified group and perform the necessary housekeeping.

BACKTRACE-STRING

Similar to print-backtrace, but return the backtrace as a string.

BALANCE-FRAMES

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

BALANCE-FRAMES-INTERNAL (GROUP TREE)

Resize all the children of tree to be of equal width or height depending on the tree's split direction.

BANISH (&OPTIONAL WHERE)

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

BANISH-POINTER (&OPTIONAL (WHERE *BANISH-POINTER-TO*))

Move the pointer to the lower right corner of the head, or WHEREever (one of :screen :head :frame or :window)

BAR (PERCENT WIDTH FULL EMPTY)

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

BIND (KEY COMMAND)

Hang a key binding off the escape key.

BINDING-COMMAND (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BINDING-KEY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BOUND-CHECK-MENU (MENU)

Adjust the menu view and selected item based on current view and new selection.

BYTES-TO-STRING (DATA)

Convert a list of bytes into a string.

BYTES-TO-WINDOW (BYTES)

A sick hack to assemble 4 bytes into a 32 bit number. This is because ratpoison sends the rp_command_request window in 8 byte chunks.

CALL-INTERACTIVELY (COMMAND &OPTIONAL (INPUT ))

Parse the command's arguments from input given the command's argument specifications then execute it. Returns a string or nil if user aborted.

CCONTEXT-DEFAULT-BG (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CCONTEXT-DEFAULT-BRIGHT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CCONTEXT-DEFAULT-FG (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CCONTEXT-GC (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CCONTEXT-PX (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CCONTEXT-WIN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CHECK-MENU-COMPLETE (MENU KEY-SEQ)

If the use entered a key not mapped in @var{*menu-map}, check if he's trying to type an entry's name. Match is case insensitive as long as the user types lower-case characters. If @var{key-seq} is nil, some other function has manipulated the current-input and is requesting a re-computation of the match.

CHOOSE-FRAME-BY-NUMBER (GROUP)

show a number in the corner of each frame and wait for the user to select one. Returns the selected frame or nil if aborted.

CHOOSE-NEW-FRAME-WINDOW (FRAME GROUP)

Find out what window should go in a newly created frame.

CLEAR-FRAME (FRAME GROUP)

Clear the given frame.

CLEAR-FRAME-OUTLINES (GROUP)

Clear the outlines drawn with DRAW-FRAME-OUTLINES.

CLEAR-WINDOW-MARKS (&OPTIONAL (GROUP (CURRENT-GROUP)) (WINDOWS (GROUP-WINDOWS GROUP)))

Clear all marks in the current group.

CLOSEST-SIBLING (TREE LEAF)

Return the sibling to the right/below of leaf or left/above if leaf is the most right/below of its siblings.

COLON (&OPTIONAL INITIAL-INPUT)

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

COMMAND-ALIAS-FROM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COMMAND-ALIAS-TO (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COMMAND-ARGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COMMAND-CLASS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COMMAND-MODE

Command mode allows you to type ratpoison 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}.

COMMAND-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

COMMANDS

List all available commands.

COMPLETE-PROGRAM (BASE)

return the list of programs in @var{*path-cache*} whose names begin with base. Automagically update the cache.

COMPONENT-PRESENT-P (VALUE)

Helper function for DIRECTORY-PATHNAME-P which checks whether VALUE is neither NIL nor the keyword :UNSPECIFIC.

CONC1 (LIST ARG)

Append arg to the end of list

COPY-FRAME-TREE (TREE)

Return a copy of the frame tree.

COPY-HEADS (SCREEN)

Return a copy of screen's heads.

COPY-KEY-INTO (FROM TO)

copy the contents of TO into FROM.

COPY-LAST-MESSAGE

Copy the last message displayed into the X selection

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.

CURFRAME

Display a window indicating which frame is focused.

DEFINE-KEYSYM (KEYSYM NAME)

Define a mapping from a keysym name to a keysym.

DEFINE-KEYSYM-NAME (STUMPWM-NAME KEYSYM-NAME)

Define a mapping from a STUMPWM-NAME to KEYSYM-NAME. This function is used to translate Emacs-like names to keysym names.

DELETE-WINDOW (&OPTIONAL (WINDOW (CURRENT-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.

DEREFERENCE-COMMAND-SYMBOL (COMMAND)

Given a string or symbol look it up in the command database and return whatever it finds: a command, an alias, or nil.

DESCRIBE-COMMAND (COM)

Print the online help associated with the specified command.

DESCRIBE-FUNCTION (FN)

Print the online help associated with the specified 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.

DESCRIBE-VARIABLE (VAR)

Print the online help associated with the specified variable.

DESTROY-WINDOW (WINDOW)

The window has been destroyed. clean up our data structures.

DIRECTORY-NO-DEREF (PATHSPEC)

Call directory without dereferencing symlinks in the results

DIRECTORY-PATHNAME-P (PATHSPEC)

Returns NIL if PATHSPEC (a pathname designator) does not designate a directory, PATHSPEC otherwise. It is irrelevant whether file or directory designated by PATHSPEC does actually exist.

DIRECTORY-WILDCARD (DIRNAME)

Returns a wild pathname designator that designates all files within the directory named by the non-wild pathname designator DIRNAME.

DRAW-FRAME-NUMBERS (GROUP)

Draw the number of each frame in its corner. Return the list of windows used to draw the numbers in. The caller must destroy them.

DRAW-FRAME-OUTLINE (GROUP F TL BR)

Draw an outline around FRAME.

DRAW-FRAME-OUTLINES (GROUP &OPTIONAL HEAD)

Draw an outline around all frames in GROUP.

DRAW-INPUT-BUCKET (SCREEN PROMPT INPUT &OPTIONAL (TAIL ) ERRORP)

Draw to the screen's input window the contents of input.

DUMP-WINDOW-PLACEMENT-RULES (FILE)

Dump *window-placement-rules* to FILE.

ECHO (STRING)

Display @var{string} in the message bar.

ECHO-FRAME-WINDOWS (&OPTIONAL (FMT *WINDOW-FORMAT*))

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

ECHO-GROUPS (SCREEN FMT &OPTIONAL VERBOSE (WFMT *WINDOW-FORMAT*))

Print a list of the windows to the screen.

ECHO-STRING-LIST (SCREEN STRINGS &REST HIGHLIGHTS)

Draw each string in l in the screen's message window. HIGHLIGHT is the nth entry to highlight.

ECHO-WINDOWS (&OPTIONAL (FMT *WINDOW-FORMAT*) (GROUP (CURRENT-GROUP)) (WINDOWS (GROUP-WINDOWS GROUP)))

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

EMACS

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

ERROR-HANDLER (DISPLAY ERROR-KEY &REST KEY-VALS &KEY ASYNCHRONOUS &ALLOW-OTHER-KEYS)

Handle X errors

EVAL-COMMAND (CMD &OPTIONAL INTERACTIVEP)

exec cmd and echo the result.

EVAL-LINE (CMD)

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

EXCHANGE-DIRECTION (DIR &OPTIONAL (WIN (CURRENT-WINDOW)))

Exchange the current window (by default) with the top window of the frame in specified direction. @table @asis @item up @item down @item left @item right @end table

EXCHANGE-WINDOWS (WIN1 WIN2)

Exchange the windows in their respective frames.

EXPAND-TREE (TREE AMOUNT DIR)

expand the frames in tree by AMOUNT in DIR direction. DIR can be :top :bottom :left :right

FCLEAR

Clear the current frame.

FIND-FRAME (GROUP X Y)

Return the frame of GROUP containing the pixel at X Y

FIND-FREE-GROUP-NUMBER (SCREEN)

Return a free group number in SCREEN.

FIND-FREE-HIDDEN-GROUP-NUMBER (SCREEN)

Return a free hidden group number for SCREEN. Hidden group numbers start at -1 and go down.

FIND-FREE-NUMBER (L &OPTIONAL (MIN 0) DIR)

Return a number that is not in the list l. If dir is :negative then look for a free number in the negative direction. anything else means positive direction.

FIND-FREE-WINDOW-NUMBER (GROUP)

Return a free window number for GROUP.

FIND-GROUP (SCREEN NAME)

Return the group with the name, NAME. Or NIL if none exists.

FIND-MATCHING-WINDOWS (PROPS ALL-GROUPS ALL-SCREENS)

Returns list of windows matching @var{props} (see run-or-raise documentation for details). @var{all-groups} will find windows on all groups. Same for @{all-screens}. Result is sorted by group and window number, with group being more significant (think radix sort).

FIND-MESSAGE-WINDOW-SCREEN (WIN)

Return the screen, if any, that message window WIN belongs.

FIND-SCREEN (ROOT)

Return the screen containing the root window.

FIND-WITHDRAWN-WINDOW (XWIN)

Return the window and screen for a withdrawn window.

FMT-GROUP-LIST (ML)

Given a group list all the groups in the group's screen.

FMT-HEAD-WINDOW-LIST (ML)

Using *window-format*, return a 1 line list of the windows, space seperated.

FMT-HEAD-WINDOW-LIST-HIDDEN-WINDOWS (ML)

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

FMT-URGENT-WINDOW-LIST (ML)

Using *window-format*, return a 1 line list of the urgent windows, space seperated.

FMT-WINDOW-LIST (ML)

Using *window-format*, return a 1 line list of the windows, space seperated.

FNEXT

Cycle through the frame tree to the next frame.

FOCUS-ALL (WIN)

Focus the window, frame, group and screen belonging to WIN. Raise the window in it's frame.

FOCUS-FORWARD (GROUP WINDOW-LIST &OPTIONAL PULL-P (PREDICATE (CONSTANTLY T)))

Set the focus to the next item in window-list from the focused window. If PULL-P is T then pull the window into the current frame.

FOCUS-FRAME-AFTER (GROUP FRAMES)

Given a list of frames focus the next one in the list after the current frame.

FORGET

Forget the window placement rule that matches the current window.

FOTHER

Jump to the last frame that had focus.

FRAME-DISPLAY-HEIGHT (GROUP FRAME)

Return a HEIGHT for frame that doesn't overlap the mode-line.

FRAME-DISPLAY-Y (GROUP FRAME)

Return a Y for frame that doesn't overlap the mode-line.

FRAME-HEIGHT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FRAME-INTERSECT (F1 F2)

Return a new frame representing (only) the intersection of F1 and F2. WIDTH and HEIGHT will be <= 0 if there is no overlap

FRAME-NUMBER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FRAME-RAISE-WINDOW (G F W &OPTIONAL (FOCUS T))

Raise the window w in frame f in group g. if FOCUS is T (default) then also focus the frame.

FRAME-WIDTH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FRAME-WINDOW (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FRAME-WINDOWLIST (&OPTIONAL (FMT *WINDOW-FORMAT*))

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.

FRAME-X (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FRAME-Y (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FRAMES-OVERLAP-P (F1 F2)

Returns T if frames F1 and F2 overlap at all

FSELECT (FRAME-NUMBER)

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

FULLSCREEN

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

FUNCALL-ON-LEAF (TREE LEAF FN)

Return a new tree with LEAF replaced with the result of calling FN on LEAF.

FUNCALL-ON-NODE (TREE FN MATCH)

Call fn on the node where match returns t.

GEOMETRY-HINTS (WIN)

Return hints for max width and height and increment hints. These hints have been modified to always be defined and never be greater than the root window's width and height.

GET-COMMAND-STRUCTURE (COMMAND &OPTIONAL (ONLY-ACTIVE T))

Return the command structure for COMMAND. COMMAND can be a string, symbol, command, or command-alias. By default only search active commands.

GET-EDGE (FRAME EDGE)

Returns the specified edge of FRAME. Valid values for EDGE are :TOP, :BOTTOM, :LEFT, and :RIGHT. An edge is a START, END, and OFFSET. For horizontal edges, START is the left coordinate, END is the right coordinate, and OFFSET is the Y coordinate. Similarly, for vertical lines, START is top, END is bottom, and OFFSET is X coordinate.

GET-FRAME-NUMBER-TRANSLATION (FRAME)

Given a frame return its number translation using *frame-number-map* as a char.

GET-GRAVITY-COORDS (GRAVITY WIDTH HEIGHT MINX MINY MAXX MAXY)

Return the x y coords for a window on with gravity etc

GET-INPUT-CHAR (KEY)

If @var{key} is a character suitable for menu completion (e.g. not backspace or F9), return it otherwise return nil

GET-NEXT-TIMEOUT (TIMERS)

Return the number of seconds until the next timeout or nil if there are no timers.

GET-WINDOW-PLACEMENT (SCREEN WINDOW)

Returns the ideal group and frame that WINDOW should belong to and whether the window should be raised.

GETSEL

Echo the X selection.

GKILL

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

GMERGE (FROM)

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

GMOVE (TO-GROUP)

Move the current window to the specified group.

GMOVE-MARKED (TO-GROUP)

move the marked windows to the specified group.

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.

GNEW-FLOAT (NAME)

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

GNEWBG (NAME)

Create a new group but do not switch to it.

GNEWBG-FLOAT (NAME)

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

GNEXT

Cycle to the next group in the group list.

GNEXT-WITH-WINDOW

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

GOTHER

Go back to the last group.

GPREV

Cycle to the previous group in the group list.

GPREV-WITH-WINDOW

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

GRAB-POINTER (SCREEN)

Grab the pointer and set the pointer shape.

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

GRENAME (NAME)

Rename the current group.

GROUP-FORWARD (CURRENT LIST)

Switch to the next non-hidden-group in the list, if one exists. Returns the new group.

GROUP-FORWARD-WITH-WINDOW (CURRENT LIST)

Switch to the next group in the list, if one exists, and moves the current window of the current group to the new one.

GROUPLIST (&OPTIONAL (FMT *GROUP-FORMAT*))

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

GROUPS (&OPTIONAL (FMT *GROUP-FORMAT*))

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.

GSELECT (TO-GROUP)

Select the first group that starts with @var{substring}. @var{substring} can also be a number, in which case @command{gselect} selects the group with that number.

HANDLE-KEYMAP (KMAPS CODE STATE KEY-SEQ GRAB UPDATE-FN)

Find the command mapped to the (code state) and return it.

HANDLE-RP-COMMANDS (ROOT)

Handle a ratpoison style command request.

HANDLE-STUMPWM-COMMANDS (ROOT)

Handle a StumpWM style command request.

HANDLE-UNMANAGED-WINDOW (XWIN X Y WIDTH HEIGHT BORDER-WIDTH VALUE-MASK)

Call this function for windows that stumpwm isn't managing. Basically just give the window what it wants.

HEAD-HEIGHT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HEAD-MODE-LINE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HEAD-NUMBER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HEAD-SCREEN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HEAD-WIDTH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HEAD-WINDOW (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HEAD-WINDOWS (GROUP HEAD)

Returns a list of windows on HEAD of GROUP

HEAD-X (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HEAD-Y (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HSPLIT (&OPTIONAL (RATIO 1/2))

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

INFO (&OPTIONAL (FMT *WINDOW-INFO-FORMAT*))

Display information about the current window.

INIT-SCREEN (SCREEN-NUMBER ID HOST)

Given a screen number, returns a screen structure with initialized members

INPUT-LINE-HISTORY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

INPUT-LINE-HISTORY-BK (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

INPUT-LINE-PASSWORD (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

INPUT-LINE-POSITION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

INPUT-LINE-STRING (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

INSERT-BEFORE (LIST ITEM NTH)

Insert ITEM before the NTH element of LIST.

INTERN1 (THING &OPTIONAL (PACKAGE *PACKAGE*) (RT *READTABLE*))

A DWIM intern.

INTERNAL-WINDOW-P (SCREEN WIN)

Return t if win is a window used by stumpwm

INVERT-RECT (SCREEN WIN X Y WIDTH HEIGHT)

invert the color in the rectangular area. Used for highlighting text.

IS-MODIFIER (KEYCODE)

Return t if keycode is a modifier

JOIN-SUBTREES (TREE LEAF)

expand the children of tree to occupy the space of LEAF. Return tree with leaf removed.

KEY-ALT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

KEY-CONTROL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

KEY-HYPER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

KEY-KEYSYM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

KEY-META (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

KEY-SHIFT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

KEY-SUPER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

KEYBOARD-QUIT

KEYSYM->KEYSYM-NAME (KEYSYM)

Return the name corresponding to KEYSYM.

KEYSYM->STUMPWM-NAME (KEYSYM)

Return the stumpwm key name corresponding to KEYSYM. If no mapping for the stumpwm key name exists, then fall back by calling KEYSYM->KEYSYM-NAME.

KEYSYM-NAME->KEYSYM (NAME)

Return the keysym corresponding to NAME.

KILL-WINDOW (&OPTIONAL (WINDOW (CURRENT-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.

KMAP-BINDINGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LASTMSG

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

LIST-SPLICE-REPLACE (ITEM LIST &REST REPLACEMENTS)

splice REPLACEMENTS into LIST where ITEM is, removing ITEM. Return the new list.

LIST-WINDOW-PROPERTIES

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

LOAD-RC-FILE (&OPTIONAL (CATCH-ERRORS T))

Load the user's .stumpwmrc file or the system wide one if that doesn't exist. Returns a values list: whether the file loaded (t if no rc files exist), the error if it didn't, and the rc file that was loaded. When CATCH-ERRORS is nil, errors are left to be handled further up.

LOADRC

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

LOOKUP-KEY-SEQUENCE (KMAP KEY-SEQ)

Return the command bound to the key sequenc, KEY-SEQ, in keymap KMAP.

MAKE-MODE-LINE-WINDOW (PARENT SCREEN)

Create a window suitable for a modeline.

MAKE-RULE-FOR-WINDOW (WINDOW &OPTIONAL LOCK TITLE)

Guess at a placement rule for WINDOW and add it to the current set.

MAKE-SCREEN-HEADS (SCREEN ROOT)

or use xdpyinfo to query the xinerama extension, if it's enabled.

MAKE-XLIB-WINDOW (XOBJECT)

For some reason the clx xid cache screws up returns pixmaps when they should be windows. So use this function to make a window out of them.

MAPCAR-HASH (FN HASH)

Just like maphash except it accumulates the result in a list.

MARK

Toggle the current window's mark.

MARKED-WINDOWS (GROUP)

Return the marked windows in the specified group.

MAX-WIDTH (FONT L)

Return the width of the longest string in L using FONT.

MAXIMIZE-WINDOW (WIN)

Maximize the window.

MERGE-GROUPS (FROM-GROUP TO-GROUP)

Merge all windows in FROM-GROUP into TO-GROUP.

MESSAGE-NO-TIMEOUT (FMT &REST ARGS)

Like message, but the window doesn't disappear after a few seconds.

META (KEY)

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

MIGRATE-FRAME-WINDOWS (GROUP SRC DEST)

Migrate all windows in SRC frame to DEST frame.

MOD->STRING (STATE)

Convert a stump modifier list to a string

MODALS-OF (WINDOW)

Given WINDOW return the modal dialogs which are shadowing it, if any.

MODE-LINE

A command to toggle the mode line visibility.

MODE-LINE-CC (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODE-LINE-CONTENTS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODE-LINE-FACTOR (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODE-LINE-FORMAT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODE-LINE-HEAD (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODE-LINE-HEIGHT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODE-LINE-MODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODE-LINE-POSITION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODE-LINE-SCREEN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODE-LINE-WINDOW (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODIFIERS

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

MODIFIERS-ALT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODIFIERS-ALTGR (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODIFIERS-HYPER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODIFIERS-META (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODIFIERS-NUMLOCK (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MODIFIERS-SUPER (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

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

MOVE-GROUP-TO-HEAD (SCREEN GROUP)

Move window to the head of the group's window list.

MOVE-WINDOW (DIR)

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

MOVE-WINDOW-TO-HEAD (GROUP WINDOW)

Move window to the head of the group's window list.

NEIGHBOUR (DIRECTION FRAME FRAMESET)

Returns the best neighbour of FRAME in FRAMESET on the DIRECTION edge. Valid directions are :UP, :DOWN, :LEFT, :RIGHT. eg: (NEIGHBOUR :UP F FS) finds the frame in FS that is the 'best' neighbour above F.

NETWM-GROUP (WINDOW &OPTIONAL (SCREEN (WINDOW-SCREEN WINDOW)))

Get the window's desktop property and return a matching group, if there exists one.

NETWM-GROUP-ID (GROUP)

netwm specifies that desktop/group numbers are contiguous and start at 0. Return a netwm compliant group id.

NETWM-SET-GROUP (WINDOW)

Set the desktop property for the given window.

NETWM-SET-GROUP-PROPERTIES (SCREEN)

Set NETWM properties regarding groups of SCREEN. Groups are known as "virtual desktops" in the NETWM standard.

NETWM-SET-PROPERTIES (SCREEN FOCUS-WINDOW)

Set NETWM properties on the root window of the specified screen. FOCUS-WINDOW is an extra window used for _NET_SUPPORTING_WM_CHECK.

NETWM-UPDATE-GROUPS (SCREEN)

update all windows to reflect a change in the group list.

NEXT

Go to the next window in the window list.

NEXT-GROUP (CURRENT &OPTIONAL (GROUPS (NON-HIDDEN-GROUPS (SCREEN-GROUPS (GROUP-SCREEN CURRENT)))))

Return the group following @var{current} in @var{groups}. If none are found return @code{NIL}.

NEXT-IN-FRAME

Go to the next window in the current frame.

NEXT-SIBLING (TREE LEAF)

Return the sibling of LEAF in TREE.

NEXT-URGENT

Jump to the next urgent window

NO-FOCUS (GROUP LAST-WIN)

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

NON-HIDDEN-GROUPS (GROUPS)

Return only those groups that are not hidden.

OFFSET-FRAMES (GROUP X Y)

move the screen's frames around.

OFFSET-TREE (TREE X Y)

move the screen's frames around.

ONLY

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

ONLY-MODALS (WINDOWS)

Out of WINDOWS, return a list of those which are modal.

ONLY-TRANSIENTS (WINDOWS)

Out of WINDOWS, return a list of those which are transient.

ONLY-URGENT (WINDOWS)

Return a list of all urgent windows on SCREEN

OTHER-HIDDEN-WINDOW (GROUP)

Return the last window that was accessed and that is hidden.

OTHER-IN-FRAME

Go to the last accessed window in the current frame.

OTHER-WINDOW (&OPTIONAL (GROUP (CURRENT-GROUP)))

Switch to the window last focused.

PARSE-COLOR-STRING (STRING)

parse a color coded string into a list of strings and color codes

PARSE-DISPLAY-STRING (DISPLAY)

Parse an X11 DISPLAY string and return the host and display from it.

PARSE-KEY (STRING)

Parse STRING and return a key structure. Raise an error of type kbd-parse if the key failed to parse.

PARSE-KEY-SEQ (KEYS)

KEYS is a key sequence. Parse it and return the list of keys.

PARSE-MODS (MODS END)

MODS is a sequence of <MOD CHAR> #- pairs. Return a list suitable for passing as the last argument to (apply #'make-key ...)

PATH-CACHE-MODIFICATION-DATES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATH-CACHE-PATHS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATH-CACHE-PROGRAMS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATHNAME-AS-DIRECTORY (PATHSPEC)

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

PLACE-WINDOW (SCREEN WINDOW)

Pick a group WINDOW and return the group-specific placement hints, if any.

POPULATE-FRAMES (GROUP)

Try to fill empty frames in GROUP with hidden windows

PREV

Go to the previous window in the window list.

PREV-IN-FRAME

Go to the previous window in the current frame.

PROBE-PATH (PATH)

Return the truename of a supplied path, or nil if it does not exist.

PROCESS-EXISTING-WINDOWS (SCREEN)

Windows present when stumpwm starts up must be absorbed by stumpwm.

PROCESS-INPUT (SCREEN PROMPT INPUT CODE STATE)

Process the key (code and state), given the current input buffer. Returns a new modified input buffer.

PROCESS-MAPPED-WINDOW (SCREEN XWIN)

Add the window to the screen's mapped window list and process it as needed.

PULL-HIDDEN-NEXT

Pull the next hidden window into the current frame.

PULL-HIDDEN-OTHER

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

PULL-HIDDEN-PREVIOUS

Pull the next hidden window into the current frame.

PULL-MARKED

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

PULL-OTHER-HIDDEN-WINDOW (GROUP)

pull the last accessed hidden window from any frame into the current frame and raise it.

PULL-WINDOW-BY-NUMBER (N &OPTIONAL (GROUP (CURRENT-GROUP)))

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

PUTSEL (STRING)

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

QUIT

Quit StumpWM.

RATCLICK (&OPTIONAL (BUTTON 1))

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.

RATIO-OR-PIXEL (LENGTH RATIO)

Return a ratio of length unless ratio is an integer. If ratio is an integer return the number of pixel desired.

RATRELWARP (DX DY)

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

RATWARP (X Y)

Warp the mouse to the specified location.

READ-FROM-KEYMAP (KMAPS &OPTIONAL UPDATE-FN)

Read a sequence of keys from the user, guided by the keymaps, KMAPS and return the binding or nil if the user hit an unbound sequence. The Caller is responsible for setting up the input focus.

READ-KEY

Return a dotted pair (code . state) key.

READ-KEY-NO-MODIFIERS

Like read-key but never returns a modifier key.

REDISPLAY

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

REFRESH

Refresh current window without changing its size.

REGISTER-URGENT-WINDOW (WINDOW)

Add WINDOW to its screen's list of urgent windows

REHASH (&OPTIONAL (PATHS (MAPCAR 'PARSE-NAMESTRING (SPLIT-STRING (GETENV PATH) :))))

Update the cache of programs in the path stored in @var{*programs-list*} when needed.

RELOAD

Reload StumpWM using @code{asdf}.

REMEMBER (LOCK TITLE)

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

REMOVE-FRAME (TREE LEAF)

Return a new tree with LEAF and it's sibling merged into one.

REMOVE-PLIST (PLIST &REST KEYS)

Remove the keys from the plist. Useful for re-using the &REST arg after removing some options.

REMOVE-SPLIT (&OPTIONAL (GROUP (CURRENT-GROUP)) (FRAME (TILE-GROUP-CURRENT-FRAME GROUP)))

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.

RENUMBER (NT &OPTIONAL (GROUP (CURRENT-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.

REPACK-WINDOW-NUMBERS (&OPTIONAL PRESERVED)

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

RESET-FRAME-INDICATOR-TIMER

Set the message window timer to timeout in *timeout-wait* seconds.

RESET-MESSAGE-WINDOW-TIMER

Set the message window timer to timeout in *timeout-wait* seconds.

RESIZE (WIDTH HEIGHT)

Resize the current frame by @var{width} and @var{height} pixels

RESIZE-FRAME (GROUP FRAME AMOUNT DIM)

Resize FRAME by AMOUNT in DIM dimension, DIM can be either :width or :height

RESIZE-HEAD (NUMBER X Y WIDTH HEIGHT)

Resize head number `number' to given dimension.

RESIZE-TREE (TREE W H &OPTIONAL (X (TREE-X TREE)) (Y (TREE-Y TREE)))

Scale TREE to width W and height H, ignoring aspect. If X and Y are provided, reposition the TREE as well.

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.

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.

RESTORE-DESKTOP (DDUMP)

Restore all frames, all groups, and all screens.

RESTORE-FROM-FILE (FILE)

Restores screen, groups, or frames from named file, depending on file's contents.

RESTORE-SCREEN (SCREEN SDUMP)

Restore all frames in all groups of given screen. Create groups if they don't already exist.

RESTORE-WINDOW (WINDOW)

Restore a withdrawn window

RESTORE-WINDOW-PLACEMENT-RULES (FILE)

Restore *window-placement-rules* from FILE.

RUN-EXPIRED-TIMERS (TIMERS)

Return a new list of valid timers and run the timer functions of those expired.

RUN-OR-PULL (CMD PROPS &OPTIONAL (ALL-GROUPS *RUN-OR-RAISE-ALL-GROUPS*) (ALL-SCREENS *RUN-OR-RAISE-ALL-SCREENS*))

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

RUN-PROG (PROG &REST OPTS &KEY ARGS OUTPUT (WAIT T) &ALLOW-OTHER-KEYS)

Common interface to shell. Does not return anything useful.

RUN-PROG-COLLECT-OUTPUT (PROG &REST ARGS)

run a command and read its output.

SAFE-ATOM-NAME (N)

Return the name of the atom with atom-id N or nil if there isn't one.

SAFE-BYTES-TO-ATOMS (LIST)

Return a list of atoms from list. Any number that cannot be converted to an atom is removed.

SCALE-HEAD (SCREEN OH NH)

Scales head OH to match the dimensions of NH.

SCALE-SCREEN (SCREEN HEADS)

Scale all frames of all groups of SCREEN to match the dimensions of HEADS.

SCREEN-TRUE-HEIGHT (SCREEN)

Return the height of the screen regardless of the modeline

SCROLL (STRING WIDTH DELAY)

Scroll STRING within the space of WIDTH characters, with a step of DELAY

SEARCH-KMAP (COMMAND KEYMAP &KEY (TEST 'EQUAL))

Search the keymap for the specified binding. Return the key sequences that run binding.

SELECT-FROM-MENU (SCREEN TABLE &OPTIONAL PROMPT (INITIAL-SELECTION 0))

Prompt the user to select from a menu on SCREEN. TABLE can be a list of values or an alist. If it's an alist, the CAR of each element is displayed in the menu. What is displayed as menu items must be strings. Returns the selected element in TABLE or nil if aborted. See *menu-map* for menu bindings.

SELECT-GROUP (SCREEN QUERY)

Attempt to match string QUERY against group number or partial name.

SELECT-WINDOW (QUERY)

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

SELECT-WINDOW-BY-NAME (NAME)

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

SELECT-WINDOW-BY-NUMBER (NUM &OPTIONAL (GROUP (CURRENT-GROUP)))

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

SELECT-WINDOW-FROM-MENU (WINDOWS FMT)

Allow the user to select a window from the list passed in @var{windows}. The @var{fmt} argument specifies the window formatting used. Returns the window selected.

SEND-CLIENT-MESSAGE (WINDOW TYPE &REST DATA)

Send a client message to a client's window.

SEND-ESCAPE

Send the escape key to the current window.

SEND-FAKE-CLICK (WIN BUTTON)

Send a fake click (button press + button release) to win.

SEND-FAKE-KEY (WIN KEY)

Send a fake key press event to win.

SEND-META-KEY (SCREEN KEY)

Send the key to the current window on the specified screen.

SET-MODE-LINE-WINDOW (ML XWIN)

Use an external window as mode-line.

SETUP-INPUT-WINDOW (SCREEN PROMPT INPUT)

Set the input window up to read input

SETUP-WIN-GRAVITY (SCREEN WIN GRAVITY)

Position the x, y of the window according to its gravity. This function expects to be wrapped in a with-state for win.

SHADOWS-OF (WINDOW)

Given modal window WINDOW return the list of windows in its shadow.

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.

SIBLING

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

SIBLING-INTERNAL (TREE LEAF FN)

helper for next-sibling and prev-sibling.

SNEXT

Go to the next screen.

SORT-GROUPS (SCREEN)

Return a copy of the screen's group list sorted by number.

SORT-SCREENS

Return the list of screen sorted by ID.

SORT-TIMERS (TIMERS)

Return a new list of timers sorted by time to time out.

SORT-WINDOWS (GROUP)

Return a copy of the screen's window list sorted by number.

SORT1 (LIST SORT-FN &REST KEYS &KEY &ALLOW-OTHER-KEYS)

Return a sorted copy of list.

SOTHER

Go to the last screen.

SPLIT-FRAME (GROUP HOW &OPTIONAL (RATIO 1/2))

Split the current frame into 2 frames. Return new frame number, if it succeeded. NIL otherwise. RATIO is a fraction of the screen to allocate to the new split window. If ratio is an integer then the number of pixels will be used. This can be handy to setup the desktop when starting.

SPLIT-FRAME-H (GROUP P RATIO)

Return 2 new frames. The first one stealing P's number and window

SPLIT-FRAME-V (GROUP P RATIO)

Return 2 new frames. The first one stealing P's number and window

SPLIT-SEQ (SEQ SEPARATORS &KEY TEST DEFAULT-VALUE)

split a sequence into sub sequences given the list of seperators.

SPREV

Go to the previous screen.

STRING-TO-BYTES (STRING)

Convert a string to a vector of octets.

STRING-TO-UTF8 (STRING)

Convert the string to a vector of octets.

STUMPWM-INTERNAL-LOOP

The internal loop that waits for events and handles them.

STUMPWM-NAME->KEYSYM (STUMPWM-NAME)

Return the keysym corresponding to STUMPWM-NAME. If no mapping for STUMPWM-NAME exists, then fallback by calling KEYSYM-NAME->KEYSYM.

SYNC-ALL-FRAME-WINDOWS (GROUP)

synchronize all frames in GROUP.

SYNC-FRAME-WINDOWS (GROUP FRAME)

synchronize windows attached to FRAME.

SYNC-HEAD-FRAME-WINDOWS (GROUP HEAD)

synchronize all frames in GROUP and HEAD.

SYNC-KEYS

Any time *top-map* is modified this must be called.

SYNC-WINDOW-PLACEMENT

Re-arrange existing windows according to placement rules

TIMER-ARGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TIMER-FUNCTION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TIMER-REPEAT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TIMER-TIME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TITLE (TITLE)

Override the current window's title.

TOP-MAPS (&OPTIONAL (GROUP (CURRENT-GROUP)))

Return all top level keymaps that are active.

TOP-WINDOWS

Return a list of semantically visible windows (on all screens)

TRANSIENTS-OF (WINDOW)

Return the transient dialogs belonging to WINDOW

TRANSLATE-ID (SRC SRC-START SRC-END FONT DST DST-START)

A simple replacement for xlib:translate-default. just the identity with a range check.

TREE-ACCUM-FN (TREE ACC FN)

Run an accumulator function on fn applied to each leaf

TREE-COLUMN-SPLIT (TREE)

Return t if the children of tree are side-by-side

TREE-ITERATE (TREE FN)

Call FN on every leaf in TREE

TREE-LEAF (TOP)

Return a leaf of the tree. Use this when you need a leaf but you don't care which one.

TREE-PARENT (TOP NODE)

Return the list in TOP that contains NODE.

TREE-ROW-SPLIT (TREE)

Return t if the children of tree are stacked vertically

TREE-SPLIT-TYPE (TREE)

return :row or :column

UNCOLORIFY (STRING)

Remove any color markup in STRING

UNGRAB-POINTER

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

UNMAP-FRAME-INDICATOR-WINDOW (SCREEN)

Unmap the screen's message window, if it is mapped.

UNMAP-MESSAGE-WINDOW (SCREEN)

Unmap the screen's message window, if it is mapped.

UNREGISTER-URGENT-WINDOW (WINDOW)

Remove WINDOW to its screen's list of urgent windows

UPDATE-ALL-MODE-LINES

Update all mode lines.

UPDATE-BORDER-ALL-SCREENS

After setting the border width call this to sync any existing windows.

UPDATE-COLORS-ALL-SCREENS

After setting the fg, bg, or border colors. call this to sync any existing windows.

UPDATE-MODE-LINES (SCREEN)

Update all mode lines on SCREEN

UTF8-TO-STRING (OCTETS)

Convert the list of octets to a string.

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.

VISIBLE-WINDOWS

Return a list of visible windows (on all screens)

VSPLIT (&OPTIONAL (RATIO 1/2))

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

WARP-POINTER (SCREEN X Y)

Move the pointer to the specified location.

WARP-POINTER-RELATIVE (DX DY)

Move the pointer by DX and DY relative to the current location.

WHERE-IS (CMD)

Print the key sequences bound to the specified command.

WINDOW-CLEAR-URGENCY (WINDOW)

Clear the urgency bit and/or _NET_WM_STATE_DEMANDS_ATTENTION on WINDOW

WINDOW-GANG (WINDOW)

Return a list of other windows in WINDOW's gang.

WINDOW-HEIGHT-INC (WINDOW)

Find out what is the correct step to change window height

WINDOW-MATCHES-PROPERTIES-P (WINDOW &KEY CLASS INSTANCE TYPE ROLE TITLE)

Returns T if window matches all the given properties

WINDOW-MATCHES-RULE-P (W RULE)

Returns T if window matches rule

WINDOW-MAXSIZE-P (WIN)

Returns T if WIN specifies maximum dimensions.

WINDOW-URGENT-P (WINDOW)

Returns T if WINDOW has the urgency bit and/or _NET_WM_STATE_DEMANDS_ATTENTION set

WINDOW-WIDTH-INC (WINDOW)

Find out what is the correct step to change window width

WINDOWLIST (&OPTIONAL (FMT *WINDOW-FORMAT*))

Allow the user to Select a window from the list of windows and focus the selected window. For information of menu bindings @xref{Menus}. The optional argument @var{fmt} can be specified to override the default window formatting.

WITHDRAW-WINDOW (WINDOW)

Withdrawing a window means just putting it in a list til we get a destroy event.

X11-MODS (KEY &OPTIONAL WITH-NUMLOCK WITH-CAPSLOCK)

Return the modifiers for key in a format that clx understands. if WITH-NUMLOCK is non-nil then include the numlock modifier. if WITH-CAPSLOCK is non-nil then include the capslock modifier. Most of the time these just gets in the way.

XWIN-KILL (WINDOW)

Kill the client associated with window.

XWIN-NET-WM-NAME (WIN)

Return the netwm wm name

XWIN-ROLE (WIN)

Return WM_WINDOW_ROLE

XWIN-SEND-CONFIGURATION-NOTIFY (XWIN X Y W H BW)

Send a synthetic configure notify event to the given window (ICCCM 4.1.5)

XWIN-STATE (XWIN)

Get the state (iconic, normal, withdraw of a window.

SETFXWIN-STATE (STATE XWIN)

Set the state (iconic, normal, withdrawn) of a window.

XWIN-STRUT (SCREEN WIN)

Return the area that the window wants to reserve along the edges of the screen. Values are left, right, top, bottom, left_start_y, left_end_y, right_start_y, right_end_y, top_start_x, top_end_x, bottom_start_x and bottom_end_x.

XWIN-TO-WINDOW (XWIN)

Build a window for XWIN

XWIN-TYPE (WIN)

Return one of :desktop, :dock, :toolbar, :utility, :splash, :dialog, :transient, and :normal. Right now only :dock, :dialog, :normal, and :transient are actually returned; see +NETWM-WINDOW-TYPES+.

Y-OR-N-P (MESSAGE)

ask a "y or n" question on the current screen and return T if the user presses 'y'

YES-OR-NO-P (MESSAGE)

ask a "yes or no" question on the current screen and return T if the user presses 'yes'

Undocumented

&FLOAT-FOCUS-NEXT (GROUP)

ACTIVATE-FULLSCREEN (WINDOW)

ADD-HEAD (SCREEN HEAD)

ADD-WM-STATE (XWIN STATE)

ALL-MODIFIER-CODES

ALL-WINDOWS

ALLOC-COLOR (SCREEN COLOR)

ARGUMENT-LINE-P (OBJECT)

SETFARGUMENT-LINE-START (NEW-VALUE INSTANCE)

SETFARGUMENT-LINE-STRING (NEW-VALUE INSTANCE)

ARGUMENT-POP-REST-OR-READ (INPUT PROMPT &OPTIONAL COMPLETIONS)

ARGV

SETFBINDING-COMMAND (NEW-VALUE INSTANCE)

SETFBINDING-KEY (NEW-VALUE INSTANCE)

BINDING-P (OBJECT)

SETFCCONTEXT-DEFAULT-BG (NEW-VALUE INSTANCE)

SETFCCONTEXT-DEFAULT-BRIGHT (NEW-VALUE INSTANCE)

SETFCCONTEXT-DEFAULT-FG (NEW-VALUE INSTANCE)

SETFCCONTEXT-GC (NEW-VALUE INSTANCE)

CCONTEXT-P (OBJECT)

SETFCCONTEXT-PX (NEW-VALUE INSTANCE)

SETFCCONTEXT-WIN (NEW-VALUE INSTANCE)

CODE-STATE->KEY (CODE STATE)

COLOR-EXISTS-P (COLOR)

COLUMNIZE (LIST COLUMNS &KEY COL-ALIGNS (PAD 1) (CHAR ) (ALIGN LEFT))

COMMAND-ACTIVE-P (COMMAND)

SETFCOMMAND-ALIAS-FROM (NEW-VALUE INSTANCE)

COMMAND-ALIAS-P (OBJECT)

SETFCOMMAND-ALIAS-TO (NEW-VALUE INSTANCE)

SETFCOMMAND-ARGS (NEW-VALUE INSTANCE)

SETFCOMMAND-CLASS (NEW-VALUE INSTANCE)

SETFCOMMAND-NAME (NEW-VALUE INSTANCE)

COMMAND-P (OBJECT)

COPY-ARGUMENT-LINE (INSTANCE)

COPY-BINDING (INSTANCE)

COPY-CCONTEXT (INSTANCE)

COPY-COMMAND (INSTANCE)

COPY-COMMAND-ALIAS (INSTANCE)

COPY-DDUMP (INSTANCE)

COPY-FDUMP (INSTANCE)

COPY-FRAME (INSTANCE)

COPY-GDUMP (INSTANCE)

COPY-HEAD (INSTANCE)

COPY-INPUT-LINE (INSTANCE)

COPY-KEY (INSTANCE)

COPY-KMAP (INSTANCE)

COPY-MENU-STATE (INSTANCE)

COPY-MODE-LINE (INSTANCE)

COPY-MODIFIERS (INSTANCE)

COPY-PATH-CACHE (INSTANCE)

COPY-SDUMP (INSTANCE)

COPY-TIMER (INSTANCE)

DDUMP-P (OBJECT)

DEACTIVATE-FULLSCREEN (WINDOW)

DEFAULT-BORDER-WIDTH-FOR-TYPE (WINDOW)

DENY-REQUEST-P (WINDOW DENY-LIST)

DEREFERENCE-KMAPS (KMAPS)

DESTROY-MODE-LINE-WINDOW (ML)

DISPLAY-BINDINGS-FOR-KEYMAPS (KEY-SEQ &REST KEYMAPS)

DRAW-CROSS (SCREEN WINDOW X Y WIDTH HEIGHT)

DUMP-DESKTOP

DUMP-GROUP (GROUP &OPTIONAL (WINDOW-DUMP-FN 'WINDOW-ID))

DUMP-SCREEN (SCREEN)

DUMP-TO-FILE (FOO NAME)

ECHO-IN-WINDOW (WIN FONT FG BG STRING)

ECHO-NTH-LAST-MESSAGE (SCREEN N)

EXECV (PROGRAM &REST ARGUMENTS)

EXPORT-SELECTION

FDUMP-P (OBJECT)

FIND-FREE-FRAME-NUMBER (GROUP)

FIND-MODE-LINE-WINDOW (XWIN)

FIND-WINDOW (XWIN)

FIND-WINDOW-BY-PARENT (XWIN &OPTIONAL (WINDOWS (ALL-WINDOWS)))

FIND-WM-STATE (XWIN STATE)

FLOAT-WINDOW-ALIGN (WINDOW)

FLOAT-WINDOW-MOVE-RESIZE (WIN &KEY X Y WIDTH HEIGHT (BORDER *FLOAT-WINDOW-BORDER*))

FMT-GROUP (ML)

FMT-GROUP-STATUS (GROUP)

FMT-HEAD (ML)

FMT-HIDDEN (S)

FMT-HIGHLIGHT (S)

FMT-MODELINE-TIME (ML)

FMT-WINDOW-MARKED (WINDOW)

FMT-WINDOW-STATUS (WINDOW)

FOCUS-FRAME (GROUP F)

FOCUS-FRAME-NEXT-SIBLING (GROUP)

FOCUS-LAST-FRAME (GROUP)

FOCUS-NEXT-FRAME (GROUP)

FOCUS-NEXT-WINDOW (GROUP)

FOCUS-PREV-FRAME (GROUP)

FOCUS-PREV-WINDOW (GROUP)

FONT-EXISTS-P (FONT-NAME)

FONT-HEIGHT (FONT)

FORMAT-EXPAND (FMT-ALIST FMT &REST ARGS)

FRAME-B (FRAME)

FRAME-BY-NUMBER (GROUP N)

FRAME-HEAD (GROUP FRAME)

SETFFRAME-HEIGHT (NEW-VALUE INSTANCE)

FRAME-IS-HEAD (GROUP FRAME)

SETFFRAME-NUMBER (NEW-VALUE INSTANCE)

FRAME-P (OBJECT)

FRAME-R (FRAME)

FRAME-SET-B (FRAME V)

FRAME-SET-R (FRAME V)

FRAME-SET-X (FRAME V)

FRAME-SET-Y (FRAME V)

FRAME-SORT-WINDOWS (GROUP F)

SETFFRAME-WIDTH (NEW-VALUE INSTANCE)

SETFFRAME-WINDOW (NEW-VALUE INSTANCE)

FRAME-WINDOWS (GROUP F)

SETFFRAME-X (NEW-VALUE INSTANCE)

SETFFRAME-Y (NEW-VALUE INSTANCE)

GDUMP-P (OBJECT)

GET-BG-COLOR (SCREEN CC COLOR)

GET-FG-COLOR (SCREEN CC COLOR)

GET-MODIFIER-MAP

GET-NORMALIZED-NORMAL-HINTS (XWIN)

GET-OR-CREATE-RULE-SCANNER (REGEX)

GRAB-KEYBOARD (XWIN)

GRAB-KEYS-ON-WINDOW (WIN)

GRAVITY-FOR-WINDOW (WIN)

GROUP-FRAMES (GROUP)

GROUP-HEADS (GROUP)

GROUP-MAP-NUMBER (GROUP)

HANDLE-EVENT (&REST EVENT-SLOTS &KEY DISPLAY EVENT-KEY &ALLOW-OTHER-KEYS)

HANDLE-MODE-LINE-WINDOW (XWIN X Y WIDTH HEIGHT)

HEAD-BY-NUMBER (SCREEN N)

HEAD-FRAMES (GROUP HEAD)

SETFHEAD-HEIGHT (NEW-VALUE INSTANCE)

SETFHEAD-MODE-LINE (NEW-VALUE INSTANCE)

SETFHEAD-NUMBER (NEW-VALUE INSTANCE)

HEAD-P (OBJECT)

SETFHEAD-SCREEN (NEW-VALUE INSTANCE)

SETFHEAD-WIDTH (NEW-VALUE INSTANCE)

SETFHEAD-WINDOW (NEW-VALUE INSTANCE)

SETFHEAD-X (NEW-VALUE INSTANCE)

SETFHEAD-Y (NEW-VALUE INSTANCE)

HIDE-WINDOW (WINDOW)

INPUT-ABORT (INPUT KEY)

INPUT-BACKWARD-CHAR (INPUT KEY)

INPUT-BACKWARD-KILL-WORD (INPUT KEY)

INPUT-BACKWARD-WORD (INPUT KEY)

INPUT-COMPLETE (INPUT DIRECTION)

INPUT-COMPLETE-BACKWARD (INPUT KEY)

INPUT-COMPLETE-FORWARD (INPUT KEY)

INPUT-DELETE-BACKWARD-CHAR (INPUT KEY)

INPUT-DELETE-FORWARD-CHAR (INPUT KEY)

INPUT-FIND-COMPLETIONS (STR COMPLETIONS)

INPUT-FORWARD-CHAR (INPUT KEY)

INPUT-FORWARD-KILL-WORD (INPUT KEY)

INPUT-FORWARD-WORD (INPUT KEY)

INPUT-HANDLE-KEY-PRESS-EVENT (&REST EVENT-SLOTS &KEY EVENT-KEY ROOT CODE STATE &ALLOW-OTHER-KEYS)

INPUT-HANDLE-SELECTION-EVENT (&KEY WINDOW SELECTION PROPERTY &ALLOW-OTHER-KEYS)

INPUT-HISTORY-BACK (INPUT KEY)

INPUT-HISTORY-FORWARD (INPUT KEY)

INPUT-KILL-LINE (INPUT KEY)

INPUT-KILL-TO-BEGINNING (INPUT KEY)

SETFINPUT-LINE-HISTORY (NEW-VALUE INSTANCE)

SETFINPUT-LINE-HISTORY-BK (NEW-VALUE INSTANCE)

INPUT-LINE-P (OBJECT)

SETFINPUT-LINE-PASSWORD (NEW-VALUE INSTANCE)

SETFINPUT-LINE-POSITION (NEW-VALUE INSTANCE)

SETFINPUT-LINE-STRING (NEW-VALUE INSTANCE)

INPUT-MOVE-BEGINNING-OF-LINE (INPUT KEY)

INPUT-MOVE-END-OF-LINE (INPUT KEY)

INPUT-SELF-INSERT (INPUT KEY)

INPUT-SUBMIT (INPUT KEY)

INPUT-YANK-SELECTION (INPUT KEY)

SETFKEY-ALT (NEW-VALUE INSTANCE)

SETFKEY-CONTROL (NEW-VALUE INSTANCE)

SETFKEY-HYPER (NEW-VALUE INSTANCE)

SETFKEY-KEYSYM (NEW-VALUE INSTANCE)

SETFKEY-META (NEW-VALUE INSTANCE)

KEY-MODS-P (KEY)

KEY-P (OBJECT)

SETFKEY-SHIFT (NEW-VALUE INSTANCE)

SETFKEY-SUPER (NEW-VALUE INSTANCE)

KEY-TO-KEYCODE+STATE (KEY)

KEYCODE->CHARACTER (CODE MODS)

KEYSYM-NAME->STUMPWM-NAME (KEYSYM-NAME)

KILL-GROUP (GROUP TO-GROUP)

SETFKMAP-BINDINGS (NEW-VALUE INSTANCE)

KMAP-OR-KMAP-SYMBOL-P (X)

KMAP-P (OBJECT)

KMAP-SYMBOL-P (X)

LOOKUP-COLOR (SCREEN COLOR)

LOOKUP-ERROR-RECOVERABLE-P

LOOKUP-SYMBOL (STRING)

MAKE-ARGUMENT-LINE (&KEY ((STRING DUM256) NIL) ((START DUM257) NIL))

MAKE-BINDING (&KEY ((KEY DUM84) NIL) ((COMMAND DUM85) NIL))

MAKE-CCONTEXT (&KEY ((WIN DUM100) NIL) ((PX DUM101) NIL) ((GC DUM102) NIL) ((DEFAULT-FG DUM103) NIL) ((DEFAULT-BRIGHT DUM104) NIL) ((DEFAULT-BG DUM105) NIL))

MAKE-COMMAND (&KEY ((NAME DUM38) NIL) ((CLASS DUM39) NIL) ((ARGS DUM40) NIL))

MAKE-COMMAND-ALIAS (&KEY ((FROM DUM0) NIL) ((TO DUM1) NIL))

MAKE-DDUMP (&KEY ((SCREENS DUM130) NIL) ((CURRENT DUM131) NIL))

MAKE-FDUMP (&KEY ((NUMBER DUM0) NIL) ((X DUM1) NIL) ((Y DUM2) NIL) ((WIDTH DUM3) NIL) ((HEIGHT DUM4) NIL) ((WINDOWS DUM5) NIL) ((CURRENT DUM6) NIL))

MAKE-FRAME (&KEY ((NUMBER DUM0) NIL) ((X DUM1) NIL) ((Y DUM2) NIL) ((WIDTH DUM3) NIL) ((HEIGHT DUM4) NIL) ((WINDOW DUM5) NIL))

MAKE-GDUMP (&KEY ((NUMBER DUM48) NIL) ((NAME DUM49) NIL) ((TREE DUM50) NIL) ((CURRENT DUM51) NIL))

MAKE-HEAD (&KEY ((NUMBER DUM48) NIL) ((X DUM49) NIL) ((Y DUM50) NIL) ((WIDTH DUM51) NIL) ((HEIGHT DUM52) NIL) ((WINDOW DUM53) NIL) ((SCREEN DUM54) NIL) ((MODE-LINE DUM55) NIL))

MAKE-HEAD-MODE-LINE (SCREEN HEAD FORMAT)

MAKE-INPUT-LINE (&KEY ((STRING DUM0) NIL) ((POSITION DUM1) NIL) ((HISTORY DUM2) NIL) ((HISTORY-BK DUM3) NIL) ((PASSWORD DUM4) NIL))

MAKE-INPUT-STRING (INITIAL-INPUT)

MAKE-KEY (&KEY ((KEYSYM DUM0) NIL) ((SHIFT DUM1) NIL) ((CONTROL DUM2) NIL) ((META DUM3) NIL) ((ALT DUM4) NIL) ((HYPER DUM5) NIL) ((SUPER DUM6) NIL))

MAKE-KMAP (&KEY ((BINDINGS DUM48) NIL))

MAKE-MENU-STATE (&KEY ((TABLE DUM0) NIL) ((PROMPT DUM1) NIL) ((SELECTED DUM2) NIL) ((VIEW-START DUM3) NIL) ((VIEW-END DUM4) NIL) ((CURRENT-INPUT DUM5) (MAKE-ARRAY 10 ELEMENT-TYPE 'CHARACTER ADJUSTABLE T FILL-POINTER 0)))

MAKE-MODE-LINE (&KEY ((SCREEN DUM0) NIL) ((HEAD DUM1) NIL) ((WINDOW DUM2) NIL) ((FORMAT DUM3) NIL) ((POSITION DUM4) NIL) ((CONTENTS DUM5) NIL) ((CC DUM6) NIL) ((HEIGHT DUM7) NIL) ((FACTOR DUM8) NIL) ((MODE DUM9) STUMP))

MAKE-MODE-LINE-GC (WINDOW SCREEN)

MAKE-MODIFIERS (&KEY ((META DUM213) NIL) ((ALT DUM214) NIL) ((HYPER DUM215) NIL) ((SUPER DUM216) NIL) ((ALTGR DUM217) NIL) ((NUMLOCK DUM218) NIL))

MAKE-PATH-CACHE (&KEY ((PROGRAMS DUM123) NIL) ((MODIFICATION-DATES DUM124) NIL) ((PATHS DUM125) NIL))

MAKE-SDUMP (&KEY ((NUMBER DUM90) NIL) ((GROUPS DUM91) NIL) ((CURRENT DUM92) NIL))

MAKE-TIMER (&KEY ((TIME DUM116) NIL) ((REPEAT DUM117) NIL) ((FUNCTION DUM118) NIL) ((ARGS DUM119) NIL))

MAYBE-CANCEL-MODE-LINE-TIMER

MAYBE-MAP-WINDOW (WINDOW)

MAYBE-RAISE-WINDOW (WINDOW)

MAYBE-SET-URGENCY (WINDOW)

SETFMENU-STATE-CURRENT-INPUT (NEW-VALUE INSTANCE)

SETFMENU-STATE-PROMPT (NEW-VALUE INSTANCE)

SETFMENU-STATE-SELECTED (NEW-VALUE INSTANCE)

SETFMENU-STATE-TABLE (NEW-VALUE INSTANCE)

SETFMENU-STATE-VIEW-END (NEW-VALUE INSTANCE)

SETFMENU-STATE-VIEW-START (NEW-VALUE INSTANCE)

SETFMODE-LINE-CC (NEW-VALUE INSTANCE)

SETFMODE-LINE-CONTENTS (NEW-VALUE INSTANCE)

MODE-LINE-CURRENT-GROUP (ML)

SETFMODE-LINE-FACTOR (NEW-VALUE INSTANCE)

SETFMODE-LINE-FORMAT (NEW-VALUE INSTANCE)

MODE-LINE-FORMAT-STRING (ML)

MODE-LINE-GC (ML)

SETFMODE-LINE-HEAD (NEW-VALUE INSTANCE)

SETFMODE-LINE-HEIGHT (NEW-VALUE INSTANCE)

SETFMODE-LINE-MODE (NEW-VALUE INSTANCE)

MODE-LINE-P (OBJECT)

SETFMODE-LINE-POSITION (NEW-VALUE INSTANCE)

SETFMODE-LINE-SCREEN (NEW-VALUE INSTANCE)

SETFMODE-LINE-WINDOW (NEW-VALUE INSTANCE)

SETFMODIFIERS-ALT (NEW-VALUE INSTANCE)

SETFMODIFIERS-ALTGR (NEW-VALUE INSTANCE)

SETFMODIFIERS-HYPER (NEW-VALUE INSTANCE)

SETFMODIFIERS-META (NEW-VALUE INSTANCE)

SETFMODIFIERS-NUMLOCK (NEW-VALUE INSTANCE)

MODIFIERS-P (OBJECT)

SETFMODIFIERS-SUPER (NEW-VALUE INSTANCE)

MODULE-STRING-AS-DIRECTORY (DIR)

MOVE-FOCUS-AND-OR-WINDOW (DIR &OPTIONAL WIN-P)

MOVE-MODE-LINE-TO-HEAD (ML HEAD)

MOVE-SCREEN-TO-HEAD (SCREEN)

MOVE-WINDOW-TO-GROUP (WINDOW TO-GROUP)

NETWM-REMOVE-WINDOW (WINDOW)

NETWM-SET-ALLOWED-ACTIONS (WINDOW)

NETWM-UPDATE-CLIENT-LIST (SCREEN)

NETWM-UPDATE-CLIENT-LIST-STACKING (SCREEN)

NEXT-SCREEN (&OPTIONAL (LIST (SORT-SCREENS)))

OFFSET-TREE-DIR (TREE AMOUNT DIR)

OTHER-WINDOW-IN-FRAME (GROUP)

PARSE-COLOR (S I)

PARSE-XINERAMA-HEAD (LINE)

SETFPATH-CACHE-MODIFICATION-DATES (NEW-VALUE INSTANCE)

PATH-CACHE-P (OBJECT)

SETFPATH-CACHE-PATHS (NEW-VALUE INSTANCE)

SETFPATH-CACHE-PROGRAMS (NEW-VALUE INSTANCE)

PERFORM-TOP-LEVEL-ERROR-ACTION (C)

PICK-PREFERRED-FRAME (WINDOW)

PLACE-MODE-LINE-WINDOW (SCREEN XWIN)

POP-TOP-MAP

PORTABLE-FILE-WRITE-DATE (PATHNAME)

PREV-SIBLING (TREE LEAF)

PULL-WINDOW (WIN &OPTIONAL (TO-FRAME (TILE-GROUP-CURRENT-FRAME (WINDOW-GROUP WIN))))

PUSH-LAST-MESSAGE (SCREEN STRINGS HIGHLIGHTS)

PUSH-TOP-MAP (NEW-TOP)

RAISE-MODALS-OF (WINDOW)

RAISE-MODALS-OF-GANG (WINDOW)

RAISE-TRANSIENTS-OF-GANG (WINDOW)

READ-DUMP-FROM-FILE (FILE)

READ-KEY-HANDLE-EVENT (&REST EVENT-SLOTS &KEY DISPLAY EVENT-KEY &ALLOW-OTHER-KEYS)

READ-KEY-OR-SELECTION

READ-KEY-OR-SELECTION-HANDLE-EVENT (&REST EVENT-SLOTS &KEY DISPLAY EVENT-KEY &ALLOW-OTHER-KEYS)

REALLY-RAISE-WINDOW (WINDOW)

RECOVER-FROM-LOOKUP-ERROR

REDRAW-CURRENT-MESSAGE (SCREEN)

REDRAW-MODE-LINE (ML &OPTIONAL FORCE)

REGISTER-WINDOW (WINDOW)

REMOVE-HEAD (SCREEN HEAD)

REMOVE-WM-STATE (XWIN STATE)

RENDER-STRINGS (SCREEN CC PADX PADY STRINGS HIGHLIGHTS &OPTIONAL (DRAW T))

REPARENT-WINDOW (SCREEN WINDOW)

REPEAT (N CHAR)

REPLACE-FRAME-IN-TREE (TREE F &REST FRAMES)

REPORT-KBD-PARSE-ERROR (C STREAM)

RESIZE-MODE-LINE (ML)

RESIZE-UNHIDE

RESTORE-GROUP (GROUP GDUMP &OPTIONAL AUTO-POPULATE (WINDOW-DUMP-FN 'WINDOW-ID))

RULE-MATCHING-WINDOW (WINDOW)

SCHEDULE-TIMER (TIMER WHEN)

SCREEN-ADD-MAPPED-WINDOW (SCREEN XWIN)

SCREEN-DISPLAY-STRING (SCREEN &OPTIONAL (ASSIGN T))

SCREEN-HEIGHT (SCREEN)

SCREEN-MESSAGE-GC (SCREEN)

SCREEN-MESSAGE-PIXMAP (SCREEN)

SCREEN-MESSAGE-WINDOW (SCREEN)

SCREEN-REMOVE-MAPPED-WINDOW (SCREEN XWIN)

SCREEN-ROOT (SCREEN)

SCREEN-SET-FOCUS (SCREEN WINDOW)

SCREEN-WIDTH (SCREEN)

SCREEN-WINDOWS (SCREEN)

SCREEN-X (SCREEN)

SCREEN-Y (SCREEN)

SDUMP-P (OBJECT)

SEND-SELECTION (REQUESTOR PROPERTY SELECTION TARGET TIME)

SET-COLOR (SCREEN CC S I)

SET-RESIZE-INCREMENT (VAL)

SETUP-MESSAGE-WINDOW (SCREEN LINES WIDTH)

SHOW-FRAME-INDICATOR (GROUP &OPTIONAL FORCE)

SHOW-FRAME-OUTLINE (GROUP &OPTIONAL (CLEAR T))

SHUTDOWN-INPUT-WINDOW (SCREEN)

SPLIT-FRAME-IN-DIR (GROUP DIR &OPTIONAL (RATIO 1/2))

STRING-MATCH (STRING PAT)

STUMPWM-INTERNAL (DISPLAY-STR)

STUMPWM-NAME->KEYSYM-NAME (STUMPWM-NAME)

SWITCH-TO-GROUP (NEW-GROUP)

SWITCH-TO-SCREEN (SCREEN)

SYNC-MODE-LINE (ML)

TILE-GROUP-FRAME-HEAD (GROUP HEAD)

SETFTILE-GROUP-FRAME-HEAD (FRAME GROUP HEAD)

TIME-12HR-TIME

TIME-24HR-AND-MINUTE

TIME-24HR-TIME

TIME-AM-PM

TIME-AM-PM-CAPS

TIME-CENTURY

TIME-DATE

TIME-DATE-AND-TIME

TIME-DATE-FULL

TIME-DAY-OF-MONTH

TIME-DAY-OF-MONTH-ZERO

TIME-DAY-OF-WEEK

TIME-DAY-OF-WEEK-SUN-START

TIME-DOW-NAME

TIME-DOW-SHORTNAME

TIME-HOUR

TIME-HOUR-12HR

TIME-HOUR-12HR-ZERO

TIME-HOUR-ZERO

TIME-MINUTE

TIME-MONTH

TIME-MONTH-NAME

TIME-MONTH-SHORTNAME

TIME-NEWLINE

TIME-PLIST (&OPTIONAL TIME)

TIME-SECOND

TIME-TAB

TIME-TZ

TIME-UNIX-ERA

TIME-YEAR

TIME-YEAR-SHORT

SETFTIMER-ARGS (NEW-VALUE INSTANCE)

SETFTIMER-FUNCTION (NEW-VALUE INSTANCE)

SETFTIMER-REPEAT (NEW-VALUE INSTANCE)

SETFTIMER-TIME (NEW-VALUE INSTANCE)

TREE-HEIGHT (TREE)

TREE-WIDTH (TREE)

TREE-X (TREE)

TREE-Y (TREE)

TURN-ON-MODE-LINE-TIMER

UNGRAB-KEYBOARD

UNGRAB-KEYS-ON-WINDOW (WIN)

UNHIDE-WINDOW (WINDOW)

UNMAP-ALL-FRAME-INDICATOR-WINDOWS

UNMAP-ALL-MESSAGE-WINDOWS

UNREGISTER-WINDOW (XWIN)

UPDATE-BORDER-FOR-SCREEN (SCREEN)

UPDATE-COLORS-FOR-SCREEN (SCREEN)

UPDATE-CONFIGURATION (WIN)

UPDATE-FULLSCREEN (WINDOW ACTION)

UPDATE-MODE-LINE-COLOR-CONTEXT (ML)

UPDATE-MODE-LINE-POSITION (ML X Y)

UPDATE-MODIFIER-MAP

UPDATE-RESIZE-MAP

UPDATE-WINDOW-GRAVITY

UPDATE-WINDOW-PROPERTIES (WINDOW ATOM)

WINDOW-BY-ID (ID)

WINDOW-HIDDEN-P (WINDOW)

WINDOW-ID (WINDOW)

WINDOW-IN-CURRENT-GROUP-P (WINDOW)

WINDOW-LEADER (WINDOW)

WINDOW-MAP-NUMBER (WINDOW)

WINDOW-MODAL-P (WINDOW)

WINDOW-NAME (WINDOW)

WINDOW-PROPERTY (WINDOW PROP)

WINDOW-SCREEN (WINDOW)

WINDOW-TRANSIENT-FOR (WINDOW)

WINDOW-TRANSIENT-P (WINDOW)

X-OF (WINDOW FILTER)

XWIN-BORDER-WIDTH (WIN)

SETFXWIN-BORDER-WIDTH (WIDTH WIN)

XWIN-CLASS (WIN)

XWIN-GRAB-BUTTONS (WIN)

XWIN-GRAB-KEYS (WIN SCREEN)

XWIN-HIDE (WINDOW)

XWIN-NAME (WIN)

XWIN-RES-NAME (WIN)

XWIN-UNGRAB-BUTTONS (WIN)

XWIN-UNGRAB-KEYS (WIN)

XWIN-UNHIDE (XWIN PARENT)

MACRO

Public

ADD-HOOK (HOOK FN)

Add @var{function} to the hook @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!")) (stumpmwm:add-hook stumpwm:*focus-frame-hook* 'my-rad-fn) @end example

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

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.

DEFINE-FRAME-PREFERENCE (TARGET-GROUP &REST 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 create restore dump-name class instance type role title) @end example @table @var @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 the current group matches @var{target-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 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 window's class must match @var{class}. @item instance The window's instance/resource name must match @var{instance}. @item type The window's type must match @var{type}. @item role The window's role must match @var{role}. @item title The window's title must match @var{title}. @end table

DEFINE-STUMPWM-COMMAND (NAME (&REST ARGS) &BODY BODY)

Deprecated. use `defcommand' instead.

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.

DEFINE-WINDOW-SLOT (ATTR)

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

DEFPROGRAM-SHORTCUT (NAME &KEY (COMMAND (STRING-DOWNCASE (STRING NAME))) (PROPS `'(CLASS ,(STRING-CAPITALIZE COMMAND))) (MAP *TOP-MAP*) (KEY (KBD (CONCAT H- (SUBSEQ COMMAND 0 1)))) (PULLP NIL) (PULL-NAME (INTERN1 (CONCAT (STRING NAME) -PULL))) (PULL-KEY (KBD (CONCAT H-M- (SUBSEQ COMMAND 0 1)))))

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-TO-HEAD (LIST ELT)

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

REMOVE-HOOK (HOOK FN)

Remove the specified function from the hook.

SAVE-FRAME-EXCURSION (&BODY BODY)

Execute body and then restore the current frame.

TIME (FORM)

Execute FORM and print timing information on *TRACE-OUTPUT*. On some hardware platforms estimated processor cycle counts are included in this output; this number is slightly inflated, since it includes the pipeline involved in reading the cycle counter -- executing (TIME NIL) a few times will give you an idea of the overhead, and its variance. The cycle counters are also per processor, not per thread: if multiple threads are running on the same processor, the reported counts will include cycles taken up by all threads running on the processor where TIME was executed. Furthermore, if the operating system migrates the thread to another processor between reads of the cycle counter, the results will be completely bogus. Finally, the counter is cycle counter, incremented by the hardware even when the process is halted -- which is to say that cycles pass normally during operations like SLEEP.

WITH-DATA-FILE ((S FILE &REST KEYS &KEY (IF-EXISTS SUPERSEDE) &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.

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.

Private

WITH-CURRENT-SCREEN (SCREEN &BODY BODY)

A macro to help us out with early set up.

WITH-FOCUS (XWIN &BODY BODY)

Set the focus to xwin, do body, then restore focus

Undocumented

DEF-THING-ATTR-MACRO (THING HASH-SLOT)

DEFINE-STUMP-EVENT-HANDLER (EVENT KEYS &BODY BODY)

FILL-KEYMAP (MAP &REST BINDINGS)

SET-ANY-COLOR (VAL COLOR)

GENERIC-FUNCTION

Private

FOCUS-WINDOW (WINDOW)

Give the specified window keyboard focus.

GROUP-ADD-HEAD (GROUP HEAD)

A head is being added to this group's screen.

GROUP-ADD-WINDOW (GROUP WINDOW &KEY RAISE FRAME &ALLOW-OTHER-KEYS)

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-BUTTON-PRESS (GROUP X Y CHILD)

The user clicked somewhere in the group.

GROUP-CURRENT-HEAD (GROUP)

The group is asked to return its current head.

GROUP-CURRENT-WINDOW (GROUP)

The group is asked to return its focused window.

GROUP-DELETE-WINDOW (GROUP WINDOW)

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-FOCUS-WINDOW (GROUP WIN)

The group is asked to focus the specified window wherever it is.

GROUP-INDICATE-FOCUS (GROUP)

The group is asked to in some way show the user where the keyboard focus is.

GROUP-LOST-FOCUS (GROUP)

The current window was hidden or destroyed or something happened to it. So the group is asked to do something smart about it.

GROUP-MOVE-REQUEST (GROUP WINDOW X Y RELATIVE-TO)

The window requested a position change.

GROUP-RAISE-REQUEST (GROUP WINDOW TYPE)

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-REMOVE-HEAD (GROUP HEAD)

A head is being removed from this group's screen.

GROUP-RESIZE-HEAD (GROUP OH NH)

A head is being resized on this group's screen.

GROUP-RESIZE-REQUEST (GROUP WINDOW WIDTH HEIGHT)

The window requested a width and/or height change.

GROUP-ROOT-EXPOSURE (GROUP)

The root window got an exposure event. If the group needs to redraw anything on it, this is where it should do it.

GROUP-STARTUP (GROUP)

Called on all groups while stumpwm is starting up.

GROUP-SUSPEND (GROUP)

When the group is no longer the current group, this function is called.

GROUP-SYNC-ALL-HEADS (GROUP)

Called when the head configuration for the group changes.

GROUP-SYNC-HEAD (GROUP HEAD)

When a head or its usable area is resized, this is called. When the modeline size changes, this is called.

GROUP-WAKE-UP (GROUP)

When the group becomes the current group, this function is called. This call is expected to set the focus.

RAISE-WINDOW (WINDOW)

Bring the window to the top of the window stack.

UPDATE-DECORATION (WINDOW)

Update the window decoration.

WINDOW-HEAD (WINDOW)

Report what window the head is currently on.

WINDOW-SYNC (WINDOW WHAT-CHANGED)

Some window slot has been updated and the window may need to sync itself. WHAT-CHANGED is a hint at what changed.

WINDOW-VISIBLE-P (WINDOW)

Return T if the window is visible

Undocumented

MODE-LINE-FORMAT-ELT (ELT)

SLOT-ACCESSOR

Private

SCREEN-FOCUS-WINDOW (OBJECT)

The window that gets focus when no window has focus

SETFSCREEN-FOCUS-WINDOW (NEW-VALUE OBJECT)

The window that gets focus when no window has focus

SCREEN-GROUPS (OBJECT)

the list of groups available on this screen

SETFSCREEN-GROUPS (NEW-VALUE OBJECT)

the list of groups available on this screen

SCREEN-HEADS (OBJECT)

heads of screen

SETFSCREEN-HEADS (NEW-VALUE OBJECT)

heads of screen

SCREEN-IGNORE-MSG-EXPOSE (OBJECT)

used to ignore the first expose even when mapping the message window.

SETFSCREEN-IGNORE-MSG-EXPOSE (NEW-VALUE OBJECT)

used to ignore the first expose even when mapping the message window.

SCREEN-KEY-WINDOW (OBJECT)

the window that accepts further keypresses after a toplevel key has been pressed.

SETFSCREEN-KEY-WINDOW (NEW-VALUE OBJECT)

the window that accepts further keypresses after a toplevel key has been pressed.

SCREEN-MAPPED-WINDOWS (OBJECT)

A list of all mapped windows. These are the raw xlib:window's. window structures are stored in groups.

SETFSCREEN-MAPPED-WINDOWS (NEW-VALUE OBJECT)

A list of all mapped windows. These are the raw xlib:window's. window structures are stored in groups.

SCREEN-URGENT-WINDOWS (OBJECT)

a list of windows for which (window-urgent-p) currently true.

SETFSCREEN-URGENT-WINDOWS (NEW-VALUE OBJECT)

a list of windows for which (window-urgent-p) currently true.

SCREEN-WITHDRAWN-WINDOWS (OBJECT)

A list of withdrawn windows. These are of type stumpwm::window and when they're mapped again they'll be put back in the group they were in when they were unmapped unless that group doesn't exist, in which case they go into the current group.

SETFSCREEN-WITHDRAWN-WINDOWS (NEW-VALUE OBJECT)

A list of withdrawn windows. These are of type stumpwm::window and when they're mapped again they'll be put back in the group they were in when they were unmapped unless that group doesn't exist, in which case they go into the current group.

Undocumented

FLOAT-GROUP-CURRENT-WINDOW (OBJECT)

SETFFLOAT-GROUP-CURRENT-WINDOW (NEW-VALUE OBJECT)

FLOAT-WINDOW-LAST-HEIGHT (OBJECT)

SETFFLOAT-WINDOW-LAST-HEIGHT (NEW-VALUE OBJECT)

FLOAT-WINDOW-LAST-WIDTH (OBJECT)

SETFFLOAT-WINDOW-LAST-WIDTH (NEW-VALUE OBJECT)

FLOAT-WINDOW-LAST-X (OBJECT)

SETFFLOAT-WINDOW-LAST-X (NEW-VALUE OBJECT)

FLOAT-WINDOW-LAST-Y (OBJECT)

SETFFLOAT-WINDOW-LAST-Y (NEW-VALUE OBJECT)

GROUP-NAME (OBJECT)

SETFGROUP-NAME (NEW-VALUE OBJECT)

GROUP-NUMBER (OBJECT)

SETFGROUP-NUMBER (NEW-VALUE OBJECT)

GROUP-SCREEN (OBJECT)

SETFGROUP-SCREEN (NEW-VALUE OBJECT)

GROUP-WINDOWS (OBJECT)

SETFGROUP-WINDOWS (NEW-VALUE OBJECT)

SCREEN-BG-COLOR (OBJECT)

SETFSCREEN-BG-COLOR (NEW-VALUE OBJECT)

SCREEN-BORDER-COLOR (OBJECT)

SETFSCREEN-BORDER-COLOR (NEW-VALUE OBJECT)

SCREEN-COLOR-MAP-BRIGHT (OBJECT)

SETFSCREEN-COLOR-MAP-BRIGHT (NEW-VALUE OBJECT)

SCREEN-COLOR-MAP-NORMAL (OBJECT)

SETFSCREEN-COLOR-MAP-NORMAL (NEW-VALUE OBJECT)

SCREEN-CURRENT-GROUP (OBJECT)

SETFSCREEN-CURRENT-GROUP (NEW-VALUE OBJECT)

SCREEN-CURRENT-MSG (OBJECT)

SETFSCREEN-CURRENT-MSG (NEW-VALUE OBJECT)

SCREEN-CURRENT-MSG-HIGHLIGHTS (OBJECT)

SETFSCREEN-CURRENT-MSG-HIGHLIGHTS (NEW-VALUE OBJECT)

SCREEN-FG-COLOR (OBJECT)

SETFSCREEN-FG-COLOR (NEW-VALUE OBJECT)

SCREEN-FLOAT-FOCUS-COLOR (OBJECT)

SETFSCREEN-FLOAT-FOCUS-COLOR (NEW-VALUE OBJECT)

SCREEN-FLOAT-UNFOCUS-COLOR (OBJECT)

SETFSCREEN-FLOAT-UNFOCUS-COLOR (NEW-VALUE OBJECT)

SCREEN-FOCUS (OBJECT)

SETFSCREEN-FOCUS (NEW-VALUE OBJECT)

SCREEN-FOCUS-COLOR (OBJECT)

SETFSCREEN-FOCUS-COLOR (NEW-VALUE OBJECT)

SCREEN-FONT (OBJECT)

SETFSCREEN-FONT (NEW-VALUE OBJECT)

SCREEN-FRAME-OUTLINE-GC (OBJECT)

SETFSCREEN-FRAME-OUTLINE-GC (NEW-VALUE OBJECT)

SCREEN-FRAME-OUTLINE-WIDTH (OBJECT)

SETFSCREEN-FRAME-OUTLINE-WIDTH (NEW-VALUE OBJECT)

SCREEN-FRAME-WINDOW (OBJECT)

SETFSCREEN-FRAME-WINDOW (NEW-VALUE OBJECT)

SCREEN-HOST (OBJECT)

SETFSCREEN-HOST (NEW-VALUE OBJECT)

SCREEN-ID (OBJECT)

SETFSCREEN-ID (NEW-VALUE OBJECT)

SCREEN-INPUT-WINDOW (OBJECT)

SETFSCREEN-INPUT-WINDOW (NEW-VALUE OBJECT)

SCREEN-LAST-MSG (OBJECT)

SETFSCREEN-LAST-MSG (NEW-VALUE OBJECT)

SCREEN-LAST-MSG-HIGHLIGHTS (OBJECT)

SETFSCREEN-LAST-MSG-HIGHLIGHTS (NEW-VALUE OBJECT)

SCREEN-MESSAGE-CC (OBJECT)

SETFSCREEN-MESSAGE-CC (NEW-VALUE OBJECT)

SCREEN-MODE-LINE-CC (OBJECT)

SETFSCREEN-MODE-LINE-CC (NEW-VALUE OBJECT)

SCREEN-MSG-BORDER-WIDTH (OBJECT)

SETFSCREEN-MSG-BORDER-WIDTH (NEW-VALUE OBJECT)

SCREEN-NUMBER (OBJECT)

SETFSCREEN-NUMBER (NEW-VALUE OBJECT)

SCREEN-UNFOCUS-COLOR (OBJECT)

SETFSCREEN-UNFOCUS-COLOR (NEW-VALUE OBJECT)

SCREEN-WIN-BG-COLOR (OBJECT)

SETFSCREEN-WIN-BG-COLOR (NEW-VALUE OBJECT)

TILE-GROUP-CURRENT-FRAME (OBJECT)

SETFTILE-GROUP-CURRENT-FRAME (NEW-VALUE OBJECT)

TILE-GROUP-FRAME-TREE (OBJECT)

SETFTILE-GROUP-FRAME-TREE (NEW-VALUE OBJECT)

TILE-GROUP-LAST-FRAME (OBJECT)

SETFTILE-GROUP-LAST-FRAME (NEW-VALUE OBJECT)

WINDOW-CLASS (OBJECT)

SETFWINDOW-CLASS (NEW-VALUE OBJECT)

WINDOW-FRAME (OBJECT)

SETFWINDOW-FRAME (NEW-VALUE OBJECT)

WINDOW-FULLSCREEN (OBJECT)

SETFWINDOW-FULLSCREEN (NEW-VALUE OBJECT)

WINDOW-GRAVITY (OBJECT)

SETFWINDOW-GRAVITY (NEW-VALUE OBJECT)

WINDOW-GROUP (OBJECT)

SETFWINDOW-GROUP (NEW-VALUE OBJECT)

WINDOW-HEIGHT (OBJECT)

SETFWINDOW-HEIGHT (NEW-VALUE OBJECT)

WINDOW-MARKED (OBJECT)

SETFWINDOW-MARKED (NEW-VALUE OBJECT)

WINDOW-NORMAL-HINTS (OBJECT)

SETFWINDOW-NORMAL-HINTS (NEW-VALUE OBJECT)

WINDOW-NUMBER (OBJECT)

SETFWINDOW-NUMBER (NEW-VALUE OBJECT)

WINDOW-PARENT (OBJECT)

SETFWINDOW-PARENT (NEW-VALUE OBJECT)

WINDOW-PLIST (OBJECT)

SETFWINDOW-PLIST (NEW-VALUE OBJECT)

WINDOW-RES (OBJECT)

SETFWINDOW-RES (NEW-VALUE OBJECT)

WINDOW-ROLE (OBJECT)

SETFWINDOW-ROLE (NEW-VALUE OBJECT)

WINDOW-STATE (OBJECT)

SETFWINDOW-STATE (NEW-VALUE OBJECT)

WINDOW-TITLE (OBJECT)

SETFWINDOW-TITLE (NEW-VALUE OBJECT)

WINDOW-TYPE (OBJECT)

SETFWINDOW-TYPE (NEW-VALUE OBJECT)

WINDOW-UNMAP-IGNORES (OBJECT)

SETFWINDOW-UNMAP-IGNORES (NEW-VALUE OBJECT)

WINDOW-USER-TITLE (OBJECT)

SETFWINDOW-USER-TITLE (NEW-VALUE OBJECT)

WINDOW-WIDTH (OBJECT)

SETFWINDOW-WIDTH (NEW-VALUE OBJECT)

WINDOW-X (OBJECT)

SETFWINDOW-X (NEW-VALUE OBJECT)

WINDOW-XWIN (OBJECT)

SETFWINDOW-XWIN (NEW-VALUE OBJECT)

WINDOW-Y (OBJECT)

SETFWINDOW-Y (NEW-VALUE OBJECT)

VARIABLE

Public

*ALL-MODIFIERS*

A list of all keycodes that are considered modifiers

*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

*COLORS*

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

*COMMAND-MODE-END-HOOK*

A hook called whenever command mode is ended

*COMMAND-MODE-START-HOOK*

A hook called whenever command mode is started

*CONTRIB-DIR*

The location of the contrib modules on your system.

*DATA-DIR*

The directory used by stumpwm to store data between sessions.

*DEBUG-EXPOSE-EVENTS*

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

*DEBUG-LEVEL*

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

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

*DEFAULT-GROUP-NAME*

The name of the default group.

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

*DEFAULT-WINDOW-NAME*

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

*DENY-MAP-REQUEST*

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

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

*DESTROY-WINDOW-HOOK*

A hook called whenever a window is destroyed or withdrawn.

*DISPLAY*

The display for the X server

*EDITOR-BINDINGS*

A list of key-bindings for line editing.

*EXECUTING-STUMPWM-COMMAND*

True when executing external commands.

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

*FOCUS-GROUP-HOOK*

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

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

*FRAME-INDICATOR-TEXT*

What appears in the frame indicator window?

*FRAME-INDICATOR-TIMER*

Keep track of the timer that hides the frame indicator.

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

*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

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

*GROUPS-MAP*

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

*HELP-MAP*

Help related bindings hang from this keymap

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

*HONOR-WINDOW-MOVES*

Allow windows to move between frames.

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

*INPUT-HISTORY-IGNORE-DUPLICATES*

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

*INPUT-MAP*

This is the keymap containing all input editing key bindings.

*INPUT-WINDOW-GRAVITY*

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

*INTERNAL-LOOP-HOOK*

A hook called inside stumpwm's inner loop.

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

*LAST-COMMAND*

Set to the last interactive command run.

*LIST-HIDDEN-GROUPS*

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

*MAX-LAST-MESSAGE-SIZE*

how many previous messages to keep.

*MAXSIZE-BORDER-WIDTH*

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

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

*MESSAGE-WINDOW-GRAVITY*

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

*MESSAGE-WINDOW-PADDING*

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

*MESSAGE-WINDOW-TIMER*

Keep track of the timer that hides the message window.

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

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

*MODE-LINE-BACKGROUND-COLOR*

The mode line background color.

*MODE-LINE-BORDER-COLOR*

The mode line border color.

*MODE-LINE-BORDER-WIDTH*

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

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

*MODE-LINE-FOREGROUND-COLOR*

The mode line foreground color.

*MODE-LINE-PAD-X*

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

*MODE-LINE-PAD-Y*

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

*MODE-LINE-POSITION*

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

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

*MODIFIERS*

A mapping from modifier type to x11 modifier.

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

*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

*NEW-FRAME-HOOK*

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

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

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

*NORMAL-BORDER-WIDTH*

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

*PLACE-WINDOW-HOOK*

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

*PROCESSING-EXISTING-WINDOWS*

True when processing pre-existing windows at startup.

*RECORD-LAST-MSG-OVERRIDE*

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

*RESIZE-HIDES-WINDOWS*

Set to T to hide windows during interactive resize

*RESIZE-INCREMENT*

Number of pixels to increment by when interactively resizing frames.

*RESIZE-MAP*

The keymap used for resizing a window

*ROOT-CLICK-FOCUSES-FRAME*

Set to NIL if you don't want clicking the root window to focus the frame containing the pointer when *mouse-focus-policy* is :click.

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

*ROOT-MAP*

This is the keymap by default bound to @kbd{C-t}. It is known as the @dfn{prefix map}.

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

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

*SCREEN-LIST*

The list of screens managed by stumpwm.

*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*} @end table

*SCREEN-MODE-LINE-FORMATTERS*

An alist containing format character format function pairs for formatting screen mode-lines. functions are passed the screen's current group.

*SHELL-PROGRAM*

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

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

*START-HOOK*

A hook called when stumpwm starts.

*STARTUP-MESSAGE*

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

*SUPPRESS-ABORT-MESSAGES*

Suppress abort message when non-nil.

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

*SUPPRESS-ECHO-TIMEOUT*

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

*SUPPRESS-FRAME-INDICATOR*

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

*TEXT-COLOR*

The color of message text.

*TIME-FORMAT-STRING-DEFAULT*

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

*TIME-MODELINE-STRING*

The default time value to pass to the modeline.

*TIMEOUT-FRAME-INDICATOR-WAIT*

The amount of time a frame indicator timeout takes.

*TIMEOUT-WAIT*

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

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

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

*TOP-MAP*

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

*TRANSIENT-BORDER-WIDTH*

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

*URGENT-WINDOW-HOOK*

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

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

*WINDOW-EVENTS*

The events to listen for on managed windows.

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

*WINDOW-FORMATTERS*

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

*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

*WINDOW-PARENT-EVENTS*

The events to listen for on managed windows' parents.

*WINDOW-PLACEMENT-RULES*

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

*X-SELECTION*

This holds stumpwm's current selection. It is generally set when killing text in the input bar.

*XWIN-TO-WINDOW*

Hash table for looking up windows quickly.

Undocumented

*MAXSIZE-GRAVITY*

*NORMAL-GRAVITY*

*TRANSIENT-GRAVITY*

*VERSION*

Private

*COMMAND-HASH*

A list of interactive stumpwm commands.

*COMMAND-TYPE-HASH*

A hash table of types and functions to deal with these types.

*CURRENT-MODE-LINE-FORMATTER-ARGS*

used in formatting modeline strings.

*CURRENT-MODE-LINE-FORMATTERS*

used in formatting modeline strings.

*DEFAULT-GROUP-TYPE*

The type of group that should be created by default.

*ESCAPE-FAKE-KEY*

The binding that sends the fake escape key to the current window.

*ESCAPE-KEY*

The escape key. Any keymap that wants to hang off the escape key should use this specific key struct instead of creating their own C-t.

*EVENT-FN-TABLE*

A hash of event types to functions

*GRAB-POINTER-COUNT*

The number of times the pointer has been grabbed

*GROUP-NUMBER-MAP*

Set this to a string to remap the group numbers to something more convenient.

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

*IGNORE-ECHO-TIMEOUT*

Assign this T and the message time out won't be touched. It is recommended this is assigned using LET.

*INPUT-COMPLETIONS*

The list of completions

*INPUT-CURRENT-COMPLETIONS*

The list of matching completions.

*INPUT-CURRENT-COMPLETIONS-IDX*

The current index in the current completions list.

*INPUT-HISTORY*

History for the input line.

*INPUT-LAST-COMMAND*

The last input command.

*INTERACTIVEP*

True when a defcommand is executed from colon or a keybinding

*LAST-UNHANDLED-ERROR*

If an unrecoverable error occurs, this variable will contain the condition and the backtrace.

*MAP-WINDOW-HOOK*

A hook called whenever a window is mapped.

*MAX-COMMAND-ALIAS-DEPTH*

*MENU-MAP*

The keymap used by the interactive menu.

*MENU-MAXIMUM-HEIGHT*

Defines the maxium number of lines to display in the menu before enabling scrolling. If NIL scrolling is disabled.

*MENU-SCROLLING-STEP*

Number of lines to scroll when hitting the menu list limit.

*MODE-LINE-TIMER*

The timer that updates the modeline

*PATH-CACHE*

A cache containing the programs in the path, used for completion.

*REDIRECT-STREAM*

This variable Keeps track of the stream all output is sent to when `redirect-all-output' is called so if it changes we can close it before reopening.

*RULE-SCANNERS-CACHE*

A cache for the ppcre scanners

*SHOW-COMMAND-BACKTRACE*

When this is T a backtrace is displayed with errors that occurred within an interactive call to a command.

*STUMPWM-NAME->KEYSYM-NAME-TRANSLATIONS*

Hashtable mapping from stumpwm key names to keysym names.

*TIMER-LIST*

List of active timers.

*UNMAP-WINDOW-HOOK*

A hook called whenever a window is withdrawn.

*WINDOW-INFO-FORMAT*

The format used in the info command. @xref{*window-format*} for formatting details.

*WINDOW-NUMBER-MAP*

Set this to a string to remap the window numbers to something more convenient.

+NETWM-ALLOWED-ACTIONS+

Allowed NETWM actions for managed windows

+NETWM-SUPPORTED+

Supported NETWM properties. Window types are in +WINDOW-TYPES+.

+NETWM-WINDOW-TYPES+

Alist mapping NETWM window types to keywords. Include only those we are ready to support.

Undocumented

*ALT-PREV-INDEX*

*ALT-PREV-TIME*

*BACKGROUND*

*BAR-CRIT-COLOR*

*BAR-HI-COLOR*

*BAR-MED-COLOR*

*COLOR-MAP*

*COLOR-STACK*

*FLOAT-GROUP-ROOT-MAP*

*FLOAT-GROUP-TOP-MAP*

*FLOAT-WINDOW-BORDER*

*FLOAT-WINDOW-TITLE-HEIGHT*

*FOREGROUND*

*GROUP-ROOT-MAP*

*GROUP-TOP-MAP*

*KEYSYM-NAME-TRANSLATIONS*

*LASTMSG-NTH*

*NAME-KEYSYM-TRANSLATIONS*

*RESIZE-BACKUP*

*REVERSE*

*SCROLL-PREV-DIR*

*SCROLL-PREV-INDEX*

*SCROLL-PREV-TIME*

*TILE-GROUP-ROOT-MAP*

*TILE-GROUP-TOP-MAP*

*TIME-DAY-NAMES*

*TIME-FORMAT-STRING-ALIST*

*TIME-MONTH-NAMES*

*TOP-MAP-LIST*

+DEFAULT-BACKGROUND-COLOR+

+DEFAULT-BORDER-COLOR+

+DEFAULT-FLOAT-FOCUS-COLOR+

+DEFAULT-FLOAT-UNFOCUS-COLOR+

+DEFAULT-FOCUS-COLOR+

+DEFAULT-FONT-NAME+

+DEFAULT-FOREGROUND-COLOR+

+DEFAULT-FRAME-OUTLINE-WIDTH+

+DEFAULT-UNFOCUS-COLOR+

+DEFAULT-WINDOW-BACKGROUND-COLOR+

CLASS

Public

Undocumented

DDUMP

FDUMP

GDUMP

SDUMP

Private

Undocumented

ARGUMENT-LINE

BINDING

CCONTEXT

COMMAND

COMMAND-ALIAS

FLOAT-GROUP

FLOAT-WINDOW

FRAME

GROUP

INPUT-LINE

KEY

KMAP

MODE-LINE

MODIFIERS

PATH-CACHE

SCREEN

TILE-GROUP

TILE-WINDOW

TIMER

WINDOW

CONDITION

Private

KBD-PARSE-ERROR

Raised when a kbd string failed to parse.

NOT-IMPLEMENTED

A function has been called that is not implemented yet.

STUMPWM-ERROR

Any stumpwm specific error should inherit this.

Undocumented

COMMAND-DOCSTRING-WARNING

CONSTANT

Private

Undocumented

+ICONIC-STATE+

+NORMAL-STATE+

+WITHDRAWN-STATE+