stumpwm

API Reference

stumpwm

A tiling, keyboard driven window manager

STUMPWM

  • Variable *SUPPRESS-ABORT-MESSAGES*
    nil
    Suppress abort message when non-nil.
  • Variable *TIMEOUT-WAIT*
    5
    Specifies, in seconds, how long a message will appear for. This must be an integer.
  • Variable *TIMEOUT-FRAME-INDICATOR-WAIT*
    1
    The amount of time a frame indicator timeout takes.
  • Variable *FRAME-INDICATOR-TIMER*
    nil
    Keep track of the timer that hides the frame indicator.
  • Variable *FRAME-INDICATOR-TEXT*
    " current frame "
    What appears in the frame indicator window?
  • Variable *SUPPRESS-FRAME-INDICATOR*
    nil
    Set this to T if you never want to see the frame indicator.
  • Variable *SUPPRESS-WINDOW-PLACEMENT-INDICATOR*
    nil
    Set to T if you never want to see messages that windows were placed according to rules.
  • Variable *MESSAGE-WINDOW-TIMER*
    nil
    Keep track of the timer that hides the message window.
  • Variable *COMMAND-MODE-START-HOOK*
    '(stumpwm:command-mode-start-message)
    A hook called whenever command mode is started
  • Variable *COMMAND-MODE-END-HOOK*
    '(stumpwm:command-mode-end-message)
    A hook called whenever command mode is ended
  • Variable *URGENT-WINDOW-HOOK*
    'nil
    A hook called whenever a window sets the property indicating that it demands the user's attention
  • Variable *NEW-WINDOW-HOOK*
    'nil
    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.
  • Variable *DESTROY-WINDOW-HOOK*
    'nil
    A hook called whenever a window is destroyed or withdrawn.
  • Variable *FOCUS-WINDOW-HOOK*
    'nil
    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).
  • Variable *PLACE-WINDOW-HOOK*
    'nil
    A hook called whenever a window is placed by rule. Arguments are window group and frame
  • Variable *START-HOOK*
    'nil
    A hook called when stumpwm starts.
  • Variable *QUIT-HOOK*
    'nil
    A hook called when stumpwm quits.
  • Variable *RESTART-HOOK*
    'nil
    A hook called when stumpwm restarts.
  • Variable *INTERNAL-LOOP-HOOK*
    'nil
    A hook called inside stumpwm's inner loop.
  • Variable *EVENT-PROCESSING-HOOK*
    'nil
    A hook called inside stumpwm's inner loop, before the default event processing takes place. This hook is run inside (with-event-queue ...).
  • Variable *FOCUS-FRAME-HOOK*
    'nil
    A hook called when a frame is given focus. The hook functions are called with 2 arguments: the current frame and the last frame.
  • Variable *NEW-FRAME-HOOK*
    'nil
    A hook called when a new frame is created. the hook is called with the frame as an argument.
  • Variable *SPLIT-FRAME-HOOK*
    'nil
    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.
  • Variable *MESSAGE-HOOK*
    'nil
    A hook called whenever stumpwm displays a message. The hook function is passed any number of arguments. Each argument is a line of text.
  • Variable *TOP-LEVEL-ERROR-HOOK*
    'nil
    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*.
  • Variable *FOCUS-GROUP-HOOK*
    'nil
    A hook called whenever stumpwm switches groups. It is called with 2 arguments: the current group and the last group.
  • Variable *KEY-PRESS-HOOK*
    'nil
    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.
  • Variable *ROOT-CLICK-HOOK*
    'nil
    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.
  • Variable *NEW-MODE-LINE-HOOK*
    'nil
    Called whenever the mode-line is created. It is called with argument, the mode-line
  • Variable *DESTROY-MODE-LINE-HOOK*
    'nil
    Called whenever the mode-line is destroyed. It is called with argument, the mode-line
  • Variable *MODE-LINE-CLICK-HOOK*
    'nil
    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.
  • Variable *PRE-COMMAND-HOOK*
    'nil
    Called before a command is called. It is called with 1 argument: the command as a symbol.
  • Variable *POST-COMMAND-HOOK*
    'nil
    Called after a command is called. It is called with 1 argument: the command as a symbol.
  • Variable *DISPLAY*
    nil
    The display for the X server
  • Variable *SHELL-PROGRAM*
    "/bin/sh"
    The shell program used by @code{run-shell-command}.
  • Variable *MAXSIZE-BORDER-WIDTH*
    1
    The width in pixels given to the borders of windows with maxsize or ratio hints.
  • Variable *TRANSIENT-BORDER-WIDTH*
    1
    The width in pixels given to the borders of transient or pop-up windows.
  • Variable *NORMAL-BORDER-WIDTH*
    1
    The width in pixels given to the borders of regular windows.
  • Variable *TEXT-COLOR*
    "white"
    The color of message text.
  • Variable +WITHDRAWN-STATE+
    0
  • Variable +NORMAL-STATE+
    1
  • Variable +ICONIC-STATE+
    3
  • Variable *WINDOW-EVENTS*
    '(:structure-notify :property-change :colormap-change :focus-change
      :enter-window)
    The events to listen for on managed windows.
  • Variable *WINDOW-PARENT-EVENTS*
    '(:substructure-notify :substructure-redirect)
    The events to listen for on managed windows' parents.
  • Variable *MESSAGE-WINDOW-PADDING*
    5
    The number of pixels that pad the text in the message window.
  • Variable *MESSAGE-WINDOW-GRAVITY*
    :top-right
    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 @item :top @item :left @item :right @item :bottom @end table
  • Variable *EDITOR-BINDINGS*
    nil
    A list of key-bindings for line editing.
  • Variable *INPUT-WINDOW-GRAVITY*
    :top-right
    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 @item :top @item :left @item :right @item :bottom @end table
  • Variable *NORMAL-GRAVITY*
    :center
  • Variable *MAXSIZE-GRAVITY*
    :center
  • Variable *TRANSIENT-GRAVITY*
    :center
  • Variable *TOP-LEVEL-ERROR-ACTION*
    :abort
    If an error is encountered at the top level, in STUMPWM-INTERNAL-LOOP, then this variable decides what action shall be taken. By default it will print a message to the screen and to *standard-output*. Valid values are :message, :break, :abort. :break will break to the debugger. This can be problematic because if the user hit's a mapped key the ENTIRE keyboard will be frozen and you will have to login remotely to regain control. :abort quits stumpwm.
  • Variable *WINDOW-NAME-SOURCE*
    :title
    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
  • Function FRAME-X (instance)
  • Function (setf FRAME-X) (value instance)
  • Function FRAME-Y (instance)
  • Function (setf FRAME-Y) (value instance)
  • Function FRAME-WIDTH (instance)
  • Function (setf FRAME-WIDTH) (value instance)
  • Function FRAME-HEIGHT (instance)
  • Function (setf FRAME-HEIGHT) (value instance)
  • Variable *FRAME-NUMBER-MAP*
    "0123456789abcdefghijklmnopqrstuvxwyz"
    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.
  • Struct MODIFIERS
    META
    ALT
    HYPER
    SUPER
    ALTGR
    NUMLOCK
  • Function MODIFIERS-P (object)
  • Function MODIFIERS-META (instance)
  • Function (setf MODIFIERS-META) (value instance)
  • Function MODIFIERS-ALT (instance)
  • Function (setf MODIFIERS-ALT) (value instance)
  • Function MODIFIERS-HYPER (instance)
  • Function (setf MODIFIERS-HYPER) (value instance)
  • Function MODIFIERS-SUPER (instance)
  • Function (setf MODIFIERS-SUPER) (value instance)
  • Function MODIFIERS-ALTGR (instance)
  • Function (setf MODIFIERS-ALTGR) (value instance)
  • Function MODIFIERS-NUMLOCK (instance)
  • Function (setf MODIFIERS-NUMLOCK) (value instance)
  • Variable *ALL-MODIFIERS*
    nil
    A list of all keycodes that are considered modifiers
  • Variable *MODIFIERS*
    nil
    A mapping from modifier type to x11 modifier.
  • Variable *SCREEN-LIST*
    'nil
    The list of screens managed by stumpwm.
  • Variable *INITIALIZING*
    nil
    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.
  • Variable *PROCESSING-EXISTING-WINDOWS*
    nil
    True when processing pre-existing windows at startup.
  • Variable *EXECUTING-STUMPWM-COMMAND*
    nil
    True when executing external commands.
  • Macro WITH-RESTARTS-MENU (&body body)
    Execute BODY. If an error occurs allow the user to pick a restart from a menu of possible restarts. If a restart is not chosen, resignal the error.
  • Function RUN-HOOK-WITH-ARGS (hook &rest args)
    Call each function in HOOK and pass args to it.
  • Function RUN-HOOK (hook)
    Call each function in HOOK.
  • Macro 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!")) (stumpwm:add-hook stumpwm:*focus-frame-hook* 'my-rad-fn) @end example
  • Macro REMOVE-HOOK (hook fn)
    Remove the specified function from the hook.
  • Macro REMOVE-ALL-HOOKS (hook)
    Remove all functions from a hook
  • Function SPLIT-STRING (string &optional (separators " "))
    Splits STRING into substrings where there are matches for SEPARATORS. Each match for SEPARATORS is a splitting point. The substrings between the splitting points are made into a list which is returned. ***If SEPARATORS is absent, it defaults to "[ ftnrv]+". If there is match for SEPARATORS at the beginning of STRING, we do not include a null substring for that. Likewise, if there is a match at the end of STRING, we don't include a null substring for that. Modifies the match data; use `save-match-data' if necessary.
  • Variable *DEBUG-LEVEL*
    0
    Set this variable to a number > 0 to turn on debugging. The greater the number the more debugging output.
  • Variable *DEBUG-EXPOSE-EVENTS*
    nil
    Set this variable for a visual indication of expose events on internal StumpWM windows.
  • Variable *DEBUG-STREAM*
    (make-synonym-stream '*error-output*)
    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.
  • Function DFORMAT (level fmt &rest args)
  • Function REDIRECT-ALL-OUTPUT (file)
    Elect to redirect all output to the specified file. For instance, if you want everything to go to ~/.stumpwm.d/debug-output.txt you would do: @example (redirect-all-output (data-dir-file "debug-output" "txt")) @end example
  • Function FORMAT-EXPAND (fmt-alist fmt &rest args)
  • Variable *WINDOW-FORMATTERS*
    '((#\n stumpwm::window-map-number) (#\s stumpwm::fmt-window-status)
      (#\t stumpwm::window-name) (#\c stumpwm:window-class)
      (#\i stumpwm:window-res) (#\r stumpwm:window-role)
      (#\m stumpwm::fmt-window-marked) (#\h stumpwm:window-height)
      (#\w stumpwm:window-width) (#\g stumpwm::gravity-for-window))
    an alist containing format character format function pairs for formatting window lists.
  • Variable *WINDOW-FORMAT*
    "%m%n%s%50t"
    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.
  • Variable *GROUP-FORMATTERS*
    '((#\n stumpwm::group-map-number) (#\s stumpwm::fmt-group-status)
      (#\t stumpwm:group-name))
    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}.
  • Variable *GROUP-FORMAT*
    "%n%s%t"
    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
  • Variable *LIST-HIDDEN-GROUPS*
    nil
    Controls whether hidden groups are displayed by 'groups' and 'vgroups' commands
  • Variable *X-SELECTION*
    nil
    This is a plist of stumpwm's current selections. The different properties are generally set when killing text in the input bar.
  • Variable *LAST-COMMAND*
    nil
    Set to the last interactive command run.
  • Variable *MAX-LAST-MESSAGE-SIZE*
    20
    how many previous messages to keep.
  • Variable *RECORD-LAST-MSG-OVERRIDE*
    nil
    assign this to T and messages won't be recorded. It is recommended this is assigned using LET.
  • Variable *SUPPRESS-ECHO-TIMEOUT*
    nil
    Assign this T and messages will not time out. It is recommended this is assigned using LET.
  • Variable *RUN-OR-RAISE-ALL-GROUPS*
    t
    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.
  • Variable *RUN-OR-RAISE-ALL-SCREENS*
    nil
    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.
  • Variable *DENY-MAP-REQUEST*
    nil
    A list of window properties that stumpwm should deny matching windows' requests to become mapped for the first time.
  • Variable *DENY-RAISE-REQUEST*
    nil
    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.
  • Variable *SUPPRESS-DENY-MESSAGES*
    nil
    For complete focus on the task at hand, set this to @code{T} and no raise/map denial messages will be seen.
  • Variable *HONOR-WINDOW-MOVES*
    t
    Allow windows to move between frames.
  • Variable *RESIZE-HIDES-WINDOWS*
    nil
    Set to T to hide windows during interactive resize
  • Variable *MIN-FRAME-WIDTH*
    50
    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.
  • Variable *MIN-FRAME-HEIGHT*
    50
    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.
  • Variable *NEW-FRAME-ACTION*
    :last-window
    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
  • Variable *NEW-WINDOW-PREFERRED-FRAME*
    '(:focused)
    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.
  • Variable *STARTUP-MESSAGE*
    "^2*welcome to the ^bstump^b ^bw^bindow ^bm^banager!
    press ^5*~a ?^2* for help."
    This is the message StumpWM displays when it starts. Set it to NIL to suppress.
  • Variable *DEFAULT-PACKAGE*
    (find-package '#:stumpwm-user)
    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.
  • Function CONCAT (&rest strings)
  • Variable *WINDOW-PLACEMENT-RULES*
    'nil
    List of rules governing window placement. Use define-frame-preference to add rules
  • Macro 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
  • Function CLEAR-WINDOW-PLACEMENT-RULES
    Clear all window placement rules.
  • Variable *MOUSE-FOCUS-POLICY*
    :ignore
    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.
  • Variable *ROOT-CLICK-FOCUSES-FRAME*
    t
    Set to NIL if you don't want clicking the root window to focus the frame containing the pointer.
  • Variable *BANISH-POINTER-TO*
    :head
    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
  • Variable *XWIN-TO-WINDOW*
    (make-hash-table)
    Hash table for looking up windows quickly.
  • Variable *RESIZE-MAP*
    nil
    The keymap used for resizing a window
  • Variable *DEFAULT-GROUP-NAME*
    "default"
    The name of the default group.
  • Variable *WINDOW-BORDER-STYLE*
    :thick
    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.
  • Variable *DATA-DIR*
    nil
    The directory used by stumpwm to store data between sessions.
  • Function DATA-DIR-FILE (name &optional type)
    Return a pathname inside stumpwm's data dir with the specified name and type
  • Macro 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.
  • Macro MOVE-TO-HEAD (list elt)
    Move the specified element in in LIST to the head of the list.
  • Condition STUMPWM-CONDITION  (CONDITION)
    Any stumpmwm specific condition should inherit from this.
  • Condition STUMPWM-ERROR  (STUMPWM-CONDITION, ERROR)
    Any stumpwm specific error should inherit this.
  • Condition STUMPWM-WARNING  (WARNING, STUMPWM-CONDITION)
    Adds a message slot to warning. Any stumpwm specific warning should inherit from this.
  • Function COMMAND-MODE-START-MESSAGE
  • Function COMMAND-MODE-END-MESSAGE
  • Function GETENV (var)
    Return the value of the environment variable.
  • Function (setf GETENV) (val var)
    Set the value of the environment variable, @var{var} to @var{val}.
  • Function PATHNAME-IS-EXECUTABLE-P (pathname)
    Return T if the pathname describes an executable file.
  • Function 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.
  • Function PATHNAME-AS-DIRECTORY (pathspec)
    Converts the non-wild pathname designator PATHSPEC to directory form.
  • Function LIST-DIRECTORY (dirname)
    Returns a fresh list of pathnames corresponding to the truenames of all files within the directory named by the non-wild pathname designator DIRNAME. The pathnames of sub-directories are returned in directory form - see PATHNAME-AS-DIRECTORY.
  • Variable *TOP-MAP*
    nil
    The top level key map. This is where you'll find the binding for the @dfn{prefix map}.
  • Variable *ROOT-MAP*
    nil
    This is the keymap by default bound to @kbd{C-t}. It is known as the @dfn{prefix map}.
  • Function MAKE-SPARSE-KEYMAP
    Create an empty keymap. If you want to create a new list of bindings in the key binding tree, this is where you start. To hang frame related bindings off @kbd{C-t C-f} one might use the following code: @example (defvar *my-frame-bindings* (let ((m (stumpwm:make-sparse-keymap))) (stumpwm:define-key m (stumpwm:kbd "f") "curframe") (stumpwm:define-key m (stumpwm:kbd "M-b") "move-focus left") m ; NOTE: this is important )) (stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "C-f") '*my-frame-bindings*) @end example
  • Function LOOKUP-COMMAND (keymap command)
    Return a list of keys that are bound to command
  • Function LOOKUP-KEY (keymap key &optional accept-default)
  • Function KBD (keys)
    This compiles a key string into a key structure used by `define-key', `undefine-key', `set-prefix-key' and others.
  • Function DEFINE-KEY (map key command)
    Add a keybinding mapping for the key, @var{key}, to the command, @var{command}, in the specified keymap. If @var{command} is nil, remove an 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.
  • Function UNDEFINE-KEY (map key)
    Clear the key binding in the specified keybinding.
  • Variable *INPUT-MAP*
    nil
    This is the keymap containing all input editing key bindings.
  • Variable *INPUT-HISTORY-IGNORE-DUPLICATES*
    nil
    Do not add a command to the input history if it's already the first in the list.
  • Variable *NUMPAD-MAP*
    '((87 10 . 16) (88 11 . 16) (89 12 . 16) (106 61 . 16) (83 13 . 16)
      (84 14 . 16) (85 15 . 16) (86 21 . 17) (79 16 . 16) (80 17 . 16) (81 18 . 16)
      (63 17 . 17) (82 20 . 16) (104 36 . 16) (91 60 . 16) (90 19 . 16))
    A keycode to keycode map to re-wire numpads when the numlock key is active
  • Function COMPLETING-READ (screen prompt completions &key (initial-input "") require-match)
    Read a line of input through stumpwm and return it with TAB completion. completions can be a list, an fbound symbol, or a function. if its an fbound symbol or a function then that function is passed the substring to complete on and is expected to return a list of matches. If require-match argument is non-nil then the input must match with an element of the completions.
  • Function 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.
  • Function READ-ONE-CHAR (screen)
    Read a single character from the user.
  • Function INPUT-GOTO-CHAR (input point)
    Move the cursor to the specified point in the string
  • Function INPUT-INSERT-STRING (input string)
    Insert @var{string} into the input at the current position. @var{input} must be of type @var{input-line}. Input functions are passed this structure as their first argument.
  • Function INPUT-POINT (input)
    Return the position of the cursor.
  • Function INPUT-VALIDATE-REGION (input start end)
    Return a value pair of numbers where the first number is < the second and neither excedes the bounds of the input string.
  • Function INPUT-DELETE-REGION (input start end)
    Delete the region between start and end in the input string
  • Function INPUT-INSERT-CHAR (input char)
    Insert @var{char} into the input at the current position. @var{input} must be of type @var{input-line}. Input functions are passed this structure as their first argument.
  • Function INPUT-SUBSTRING (input start end)
    Return a the substring in INPUT bounded by START and END.
  • Function GRAB-POINTER (screen)
    Grab the pointer and set the pointer shape.
  • Function UNGRAB-POINTER
    Remove the grab on the cursor and restore the cursor shape.
  • Macro DEFCOMMAND (name (&rest args) (&rest interactive-args) &body body)
    Create a command function and store its interactive hints in *command-hash*. The local variable %interactivep% can be used to check if the command was called interactively. If it is non-NIL then it was called from a keybinding or from the colon command. The NAME argument can be a string, or a list of two symbols. If the latter, the first symbol names the command, and the second indicates the type of group under which this command will be usable. Currently, tile-group and floating-group are the two possible values. INTERACTIVE-ARGS is a list of the following form: ((TYPE PROMPT) (TYPE PROMPT) ...) each element in INTERACTIVE-ARGS declares the type and prompt for the command's arguments. TYPE can be one of the following: @table @var @item :y-or-n A yes or no question returning T or NIL. @item :variable A lisp variable @item :function A lisp function @item :command A stumpwm command as a string. @item :key-seq A key sequence starting from *TOP-MAP* @item :window-number An existing window number @item :number An integer number @item :string A string @item :key A single key chord @item :window-name An existing window's name @item :direction A direction symbol. One of :UP :DOWN :LEFT :RIGHT @item :gravity A gravity symbol. One of :center :top :right :bottom :left :top-right :top-left :bottom-right :bottom-left @item :group An existing group @item :frame A frame @item :shell A shell command @item :rest The rest of the input 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.
  • Macro DEFINE-STUMPWM-COMMAND (name (&rest args) &body body)
    Deprecated. use `defcommand' instead.
  • Macro DEFCOMMAND-ALIAS (alias original)
    Since interactive commands are functions and can conflict with package symbols. But for backwards compatibility this macro creates an alias name for the command that is only accessible interactively.
  • Function ARGUMENT-LINE-END-P (input)
    Return T if we're outta arguments from the input line.
  • Function ARGUMENT-POP (input)
    Pop the next argument off.
  • Function ARGUMENT-POP-OR-READ (input prompt &optional completions)
  • Function ARGUMENT-POP-REST (input)
    Return the remainder of the argument text.
  • Macro DEFINE-STUMPWM-TYPE (type (input prompt) &body body)
    Create a new type that can be used for command arguments. @var{type} can be any symbol. When @var{body} is evaluated @var{input} is bound to the argument-line. It is passed to @code{argument-pop}, @code{argument-pop-rest}, etc. @var{prompt} is the prompt that should be used when prompting the user for the argument. @example (define-stumpwm-type :symbol (input prompt) (or (find-symbol (string-upcase (or (argument-pop input) ;; Whitespace messes up find-symbol. (string-trim " " (completing-read (current-screen) prompt ;; find all symbols in the ;; stumpwm package. (let (acc) (do-symbols (s (find-package "STUMPWM")) (push (string-downcase (symbol-name s)) acc)) acc))) (throw 'error "Abort."))) "STUMPWM") (throw 'error "Symbol not in STUMPWM package"))) (defcommand "symbol" (sym) ((:symbol "Pick a symbol: ")) (message "~a" (with-output-to-string (s) (describe sym s)))) @end example This code creates a new type called @code{:symbol} which finds the symbol in the stumpwm package. The command @code{symbol} uses it and then describes the symbol.
  • Function RUN-COMMANDS (&rest commands)
    Run each stumpwm command in sequence. This could be used if you're used to ratpoison's rc file and you just want to run commands or don't know lisp very well. One might put the following in one's rc file: @example (stumpwm:run-commands "escape C-z" "exec firefox" "split") @end example
  • Function COLON (&optional initial-input)
    Read a command from the user. @var{initial-text} is optional. When supplied, the text will appear in the prompt.
  • Function MENU-STATE-TABLE (instance)
  • Function (setf MENU-STATE-TABLE) (value instance)
  • Function MENU-STATE-SELECTED (instance)
  • Function (setf MENU-STATE-SELECTED) (value instance)
  • Function SELECT-FROM-MENU (screen table &optional (prompt "search:") (initial-selection 0) extra-keymap (filter-pred #'menu-item-matches-regexp))
    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. EXTRA-KEYMAP can be a keymap whose bindings will take precedence over the default bindings. FILTER-PRED should be a a function returning T when a certain menu item should be visible to the user. It should accept arguments ITEM-STRING (the string shown to the user), ITEM-OBJECT (the object corresponding to the menu item), and USER-INPUT (the current user input). The default is MENU-ITEM-MATCHES-REGEXP. Returns the selected element in TABLE or nil if aborted.
  • Function SCREEN-HEIGHT (screen)
  • Function SCREEN-WIDTH (screen)
  • Function SCREEN-WINDOWS (screen)
  • Function SCREEN-CURRENT-WINDOW (screen)
    Return the current window on the specified screen
  • Function CURRENT-WINDOW
    Return the current window on the current screen
  • Function SCREEN-ROOT (screen)
  • Function SET-FG-COLOR (color)
    Set the foreground color for the message bar and input bar. @var{color} can be any color recognized by X.
  • Function SET-BG-COLOR (color)
    Set the background color for the message bar and input bar. @var{color} can be any color recognized by X.
  • Function SET-BORDER-COLOR (color)
    Set the border color for the message bar and input bar. @var{color} can be any color recognized by X.
  • Function SET-WIN-BG-COLOR (color)
    Set the background color of the window. The background color will only be visible for windows with size increment hints such as @samp{emacs} and @samp{xterm}.
  • Function SET-FOCUS-COLOR (color)
    Set the border color for focused windows. This is only used when there is more than one frame.
  • Function SET-UNFOCUS-COLOR (color)
    Set the border color for windows without focus. This is only used when there is more than one frame.
  • Function SET-FLOAT-FOCUS-COLOR (color)
    Set the border color for focused windows in a float group.
  • Function SET-FLOAT-UNFOCUS-COLOR (color)
    Set the border color for windows without focus in a float group.
  • Function SET-MSG-BORDER-WIDTH (width)
    Set the border width for the message bar, input bar and frame indicator.
  • Function SET-FRAME-OUTLINE-WIDTH (width)
  • Function SET-FONT (font)
    Set the font(s) for the message bar and input bar.
  • Function CURRENT-SCREEN
    Return the current screen.
  • Function SNEXT
    Go to the next screen.
  • Function SPREV
    Go to the previous screen.
  • Function SOTHER
    Go to the last screen.
  • Function CURRENT-HEAD (&optional (group (current-group)))
  • Function REFRESH-HEADS (&optional (screen (current-screen)))
    Refresh screens in case a monitor was connected, but a ConfigureNotify event was snarfed by another program.
  • Class GROUP
    SCREEN   Accessor: GROUP-SCREEN
    WINDOWS   Accessor: GROUP-WINDOWS
    CURRENT-WINDOW   Accessor: GROUP-CURRENT-WINDOW
    NUMBER   Accessor: GROUP-NUMBER
    NAME   Accessor: GROUP-NAME
    ON-TOP-WINDOWS   Accessor: GROUP-ON-TOP-WINDOWS
  • Generic-Function GROUP-STARTUP (group)
    Called on all groups while stumpwm is starting up.
  • Generic-Function GROUP-ADD-WINDOW (group window &key &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.
  • Generic-Function 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.
  • Generic-Function GROUP-WAKE-UP (group)
    When the group becomes the current group, this function is called. This call is expected to set the focus.
  • Generic-Function GROUP-SUSPEND (group)
    When the group is no longer the current group, this function is called.
  • Generic-Function GROUP-CURRENT-WINDOW (group)
    The group is asked to return its focused window.
  • Generic-Function GROUP-CURRENT-HEAD (group)
    The group is asked to return its current head.
  • Generic-Function GROUP-RESIZE-REQUEST (group window width height)
    The window requested a width and/or height change.
  • Generic-Function GROUP-MOVE-REQUEST (group window x y relative-to)
    The window requested a position change.
  • Generic-Function 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.
  • Generic-Function 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.
  • Generic-Function GROUP-INDICATE-FOCUS (group)
    The group is asked to in some way show the user where the keyboard focus is.
  • Generic-Function GROUP-FOCUS-WINDOW (group win)
    The group is asked to focus the specified window wherever it is.
  • Generic-Function GROUP-BUTTON-PRESS (group x y child)
    The user clicked somewhere in the group.
  • Generic-Function 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.
  • Generic-Function GROUP-ADD-HEAD (group head)
    A head is being added to this group's screen.
  • Generic-Function GROUP-REMOVE-HEAD (group head)
    A head is being removed from this group's screen.
  • Generic-Function GROUP-RESIZE-HEAD (group oh nh)
    A head is being resized on this group's screen.
  • Generic-Function GROUP-SYNC-ALL-HEADS (group)
    Called when the head configuration for the group changes.
  • Generic-Function 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.
  • Method GROUP-CURRENT-HEAD (group)
  • Method GROUP-DELETE-WINDOW (group window)
  • Function CURRENT-GROUP (&optional (screen (current-screen)))
    Return the current group for the current screen, unless otherwise specified.
  • Function TOGGLE-ALWAYS-SHOW
  • Function MOVE-WINDOW-TO-GROUP (window to-group)
  • Function 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.
  • Function GNEW (name)
    Create a new group with the specified name. The new group becomes the current group. If @var{name} begins with a dot (``.'') the group new group will be created in the hidden state. Hidden groups have group numbers less than one and are invisible to from gprev, gnext, and, optionally, groups and vgroups commands.
  • Function GNEWBG (name)
    Create a new group but do not switch to it.
  • Function GNEXT
    Cycle to the next group in the group list.
  • Function GPREV
    Cycle to the previous group in the group list.
  • Function GNEXT-WITH-WINDOW
    Cycle to the next group in the group list, taking the current window along.
  • Function GPREV-WITH-WINDOW
    Cycle to the previous group in the group list, taking the current window along.
  • Function GOTHER
    Go back to the last group.
  • Function GRENAME (name)
    Rename the current group.
  • Function 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.
  • Function VGROUPS (&optional gfmt wfmt)
    Like @command{groups} but also display the windows in each group. The optional arguments @var{gfmt} and @var{wfmt} can be used to override the default group formatting and window formatting, respectively.
  • Function 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.
  • Function GROUPLIST (&optional (fmt *group-format*))
    Allow the user to select a group from a list, like windowlist but for groups
  • Function GMOVE (to-group)
    Move the current window to the specified group.
  • Function GMOVE-AND-FOLLOW (to-group)
    Move the current window to the specified group, and switch to it.
  • Function GMOVE-MARKED (to-group)
    move the marked windows to the specified group.
  • Function GKILL
    Kill the current group. All windows in the current group are migrated to the next group.
  • Function GMERGE (from)
    Merge @var{from} into the current group. @var{from} is not deleted.
  • Variable *GROUPS-MAP*
    nil
    The keymap that group related key bindings sit on. It is bound to @kbd{C-t g} by default.
  • Variable *HELP-MAP*
    nil
    Help related bindings hang from this keymap
  • Variable *GROUP-TOP-MAPS*
    '((stumpwm::tile-group stumpwm::*tile-group-top-map*)
      (stumpwm:group stumpwm::*group-top-map*))
    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.
  • Function 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}.
  • Function SET-PREFIX-KEY (key)
    Change the stumpwm prefix key to KEY. @example (stumpwm:set-prefix-key (stumpwm:kbd "C-M-H-s-z")) @end example This will change the prefix key to @key{Control} + @key{Meta} + @key{Hyper} + @key{Super} + the @key{z} key. By most standards, a terrible prefix key but it makes a great example.
  • Function BIND (key command)
    Hang a key binding off the escape key.
  • Function SEND-ESCAPE
    Send the escape key to the current window.
  • Variable *DEFAULT-WINDOW-NAME*
    "unnamed"
    The name given to a window that does not supply its own name.
  • Class WINDOW
    XWIN   Accessor: WINDOW-XWIN
    WIDTH   Accessor: WINDOW-WIDTH
    HEIGHT   Accessor: WINDOW-HEIGHT
    X   Accessor: WINDOW-X
    Y   Accessor: WINDOW-Y
    GRAVITY   Accessor: WINDOW-GRAVITY
    GROUP   Accessor: WINDOW-GROUP
    NUMBER   Accessor: WINDOW-NUMBER
    PARENT   Accessor: WINDOW-PARENT
    TITLE   Accessor: WINDOW-TITLE
    USER-TITLE   Accessor: WINDOW-USER-TITLE
    CLASS   Accessor: WINDOW-CLASS
    TYPE   Accessor: WINDOW-TYPE
    RES   Accessor: WINDOW-RES
    ROLE   Accessor: WINDOW-ROLE
    UNMAP-IGNORES   Accessor: WINDOW-UNMAP-IGNORES
    STATE   Accessor: WINDOW-STATE
    NORMAL-HINTS   Accessor: WINDOW-NORMAL-HINTS
    MARKED   Accessor: WINDOW-MARKED
    PLIST   Accessor: WINDOW-PLIST
    FULLSCREEN   Accessor: WINDOW-FULLSCREEN
  • Generic-Function UPDATE-DECORATION (window)
    Update the window decoration.
  • Generic-Function FOCUS-WINDOW (window &optional raise)
    Give the specified window keyboard focus and (optionally) raise.
  • Generic-Function RAISE-WINDOW (window)
    Bring the window to the top of the window stack.
  • Generic-Function WINDOW-VISIBLE-P (window)
    Return T if the window is visible
  • Generic-Function 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.
  • Generic-Function WINDOW-HEAD (window)
    Report what window the head is currently on.
  • Generic-Function REALLY-RAISE-WINDOW (window)
    Really bring the window to the top of the window stack in group
  • Method WINDOW-GROUP ((window window))
  • Function NEXT-URGENT
    Jump to the next urgent window
  • Function WINDOW-SCREEN (window)
  • Function UPDATE-CONFIGURATION (win)
  • Method RAISE-WINDOW (win)
    Map the window if needed and bring it to the top of the stack. Does not affect focus.
  • Macro DEFINE-WINDOW-SLOT (attr)
    Create a new window attribute and corresponding get/set functions.
  • Function SET-NORMAL-GRAVITY (gravity)
    Set the default gravity for normal windows. Possible values are @code{:center} @code{:top} @code{:left} @code{:right} @code{:bottom} @code{:top-left} @code{:top-right} @code{:bottom-left} and @code{:bottom-right}.
  • Function SET-MAXSIZE-GRAVITY (gravity)
    Set the default gravity for maxsize windows.
  • Function SET-TRANSIENT-GRAVITY (gravity)
    Set the default gravity for transient/pop-up windows.
  • Function SET-WINDOW-GEOMETRY (win &key x y width height border-width)
  • Function NO-FOCUS (group last-win)
    don't focus any window but still read keyboard events.
  • Method FOCUS-WINDOW (window &optional (raise t))
    Make the window visible and give it keyboard focus. If raise is t, raise the window.
  • Function 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.
  • Function 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.
  • Function TITLE (title)
    Override the current window's title.
  • Function SELECT-WINDOW (query)
    Switch to the first window that starts with @var{query}.
  • Function SELECT-WINDOW-BY-NAME (name)
    Switch to the first window whose name is exactly @var{name}.
  • Function SELECT-WINDOW-BY-NUMBER (num &optional (group (current-group)))
    Find the window with the given number and focus it in its frame.
  • Function OTHER-WINDOW (&optional (group (current-group)))
    Switch to the window last focused.
  • Function 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.
  • Function REPACK-WINDOW-NUMBERS (&optional preserved)
    Ensure that used window numbers do not have gaps; ignore PRESERVED window numbers.
  • Function WINDOWLIST (&optional (fmt *window-format*) window-list)
    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. The optional argument @var{window-list} can be provided to show a custom window list (see @command{windowlist-by-class}). The default window list is the list of all window in the current group. Also note that the default window list is sorted by number and if the @var{windows-list} is provided, it is shown unsorted (as-is).
  • Function WINDOWLIST-BY-CLASS (&optional (fmt *window-format-by-class*))
    Allow the user to select a window from the list of windows (sorted by class) and focus the selected window. For information of menu bindings @xref{Menus}. The optional argument @var{fmt} can be specified to override the default window formatting. This is a simple wrapper around the command @command{windowlist}.
  • Function WINDOW-SEND-STRING (string &optional (window (current-window)))
    Send the string of characters to the current window as if they'd been typed.
  • Function MARK
    Toggle the current window's mark.
  • Function CLEAR-WINDOW-MARKS (&optional (group (current-group)) (windows (group-windows group)))
    Clear all marks in the current group.
  • Function 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.
  • Function INFO (&optional (fmt *window-info-format*))
    Display information about the current window.
  • Function REFRESH
    Refresh current window without changing its size.
  • Function TOGGLE-ALWAYS-ON-TOP
    Toggle whether the current window always appears over other windows. The order windows are added to this list determines priority.
  • Method (setf WINDOW-X) (val (window float-window))
  • Method (setf WINDOW-Y) (val (window float-window))
  • Method (setf WINDOW-WIDTH) (val (window float-window))
  • Method (setf WINDOW-HEIGHT) (val (window float-window))
  • Method UPDATE-DECORATION ((window float-window))
  • Method WINDOW-SYNC ((window float-window) hint)
  • Method WINDOW-HEAD ((window float-window))
  • Method WINDOW-VISIBLE-P ((win float-window))
  • Method (setf WINDOW-FULLSCREEN) (val (window float-window))
  • Method REALLY-RAISE-WINDOW ((window float-window))
  • Method GROUP-STARTUP ((group float-group))
  • Method GROUP-ADD-WINDOW ((group float-group) window &key &allow-other-keys)
  • Method GROUP-ADD-WINDOW (group (window float-window) &key &allow-other-keys)
  • Method GROUP-DELETE-WINDOW ((group float-group) (window float-window))
  • Method GROUP-WAKE-UP ((group float-group))
  • Method GROUP-SUSPEND ((group float-group))
  • Method GROUP-RESIZE-REQUEST ((group float-group) window width height)
  • Method GROUP-MOVE-REQUEST ((group float-group) window x y relative-to)
  • Method GROUP-RAISE-REQUEST ((group float-group) window type)
  • Method GROUP-LOST-FOCUS ((group float-group))
  • Method GROUP-INDICATE-FOCUS ((group float-group))
  • Method GROUP-FOCUS-WINDOW ((group float-group) window)
  • Method GROUP-ROOT-EXPOSURE ((group float-group))
  • Method GROUP-ADD-HEAD ((group float-group) head)
  • Method GROUP-REMOVE-HEAD ((group float-group) head)
  • Method GROUP-RESIZE-HEAD ((group float-group) oh nh)
  • Method GROUP-SYNC-ALL-HEADS ((group float-group))
  • Method GROUP-SYNC-HEAD ((group float-group) head)
  • Method GROUP-BUTTON-PRESS (group x y (window float-window))
  • Method GROUP-BUTTON-PRESS ((group float-group) x y where)
  • Function GNEW-FLOAT (name)
    Create a floating window group with the specified name and switch to it.
  • Function GNEWBG-FLOAT (name)
    Create a floating window group with the specified name, but do not switch to it.
  • Variable *IGNORE-WM-INC-HINTS*
    nil
    Set this to T if you never want windows to resize based on incremental WM_HINTs, like xterm and emacs.
  • Method UPDATE-DECORATION ((window tile-window))
  • Method WINDOW-SYNC ((window tile-window) hint)
  • Method WINDOW-VISIBLE-P ((window tile-window))
  • Method WINDOW-HEAD ((window tile-window))
  • Method (setf WINDOW-FULLSCREEN) (val (window tile-window))
  • Method REALLY-RAISE-WINDOW ((window tile-window))
  • Function NEXT
    Go to the next window in the window list.
  • Function PREV
    Go to the previous window in the window list.
  • Function PULL-WINDOW-BY-NUMBER (n &optional (group (current-group)))
    Pull window N from another frame into the current frame and focus it.
  • Function PULL-HIDDEN-NEXT
    Pull the next hidden window into the current frame.
  • Function PULL-HIDDEN-PREVIOUS
    Pull the next hidden window into the current frame.
  • Function PULL-HIDDEN-OTHER
    Pull the last focused, hidden window into the current frame.
  • Function PULL-FROM-WINDOWLIST
    Pulls a window selected from the list of windows. This allows a behavior similar to Emacs' switch-to-buffer when selecting another window.
  • Function EXCHANGE-DIRECTION (dir &optional (win (current-window)))
    Exchange the current window (by default) with the top window of the frame in specified direction. (bound to @kbd{C-t x} by default) @table @asis @item up @item down @item left @item right @end table
  • Function ECHO-FRAME-WINDOWS (&optional (fmt *window-format*))
    Display a list of all the windows in the current frame.
  • Function 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.
  • Function GRAVITY (gravity)
    Set a window's gravity within its frame. Gravity controls where the window will appear in a frame if it is smaller that the frame. Possible values are: @table @var @item center @item top @item right @item bottom @item left @item top-right @item top-left @item bottom-right @item bottom-left @end table
  • Function PULL-MARKED
    Pull all marked windows into the current frame and clear the marks.
  • Function REMEMBER (lock title)
    Make a generic placement rule for the current window. Might be too specific/not specific enough!
  • Function FORGET
    Forget the window placement rule that matches the current window.
  • Function DUMP-WINDOW-PLACEMENT-RULES (file)
    Dump *window-placement-rules* to FILE.
  • Function RESTORE-WINDOW-PLACEMENT-RULES (file)
    Restore *window-placement-rules* from FILE.
  • Function REDISPLAY
    Refresh current window by a pair of resizes, also make it occupy entire frame.
  • Function UNMAXIMIZE
    Use the size the program requested for current window (if any) instead of maximizing it.
  • Function 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.
  • Method GROUP-STARTUP ((group tile-group))
  • Method GROUP-WAKE-UP ((group tile-group))
  • Method GROUP-DELETE-WINDOW ((group tile-group) (window tile-window))
  • Method GROUP-DELETE-WINDOW ((group tile-group) (window float-window))
  • Method GROUP-ADD-WINDOW ((group tile-group) window &key frame raise &allow-other-keys)
  • Method GROUP-MOVE-REQUEST ((group tile-group) (window tile-window) x y relative-to)
  • Method GROUP-RESIZE-REQUEST ((group tile-group) (window tile-window) width height)
  • Method GROUP-RESIZE-REQUEST ((group tile-group) (window float-window) width height)
  • Method GROUP-MOVE-REQUEST ((group tile-group) (window float-window) x y relative-to)
  • Method GROUP-RAISE-REQUEST ((group tile-group) window stack-mode)
  • Method GROUP-LOST-FOCUS ((group tile-group))
  • Method GROUP-INDICATE-FOCUS ((group tile-group))
  • Method GROUP-FOCUS-WINDOW ((group tile-group) (win tile-window))
  • Method GROUP-FOCUS-WINDOW ((group tile-group) (window float-window))
  • Method GROUP-BUTTON-PRESS ((group tile-group) x y (where (eql :root)))
  • Method GROUP-BUTTON-PRESS ((group tile-group) x y (where window))
  • Method GROUP-ROOT-EXPOSURE ((group tile-group))
  • Method GROUP-ADD-HEAD ((group tile-group) head)
  • Method GROUP-REMOVE-HEAD ((group tile-group) head)
  • Method GROUP-RESIZE-HEAD ((group tile-group) oh nh)
  • Method GROUP-SYNC-ALL-HEADS ((group tile-group))
  • Method GROUP-SYNC-HEAD ((group tile-group) head)
  • Macro SAVE-FRAME-EXCURSION (&body body)
    Execute body and then restore the current frame.
  • Function HSPLIT (&optional (ratio "1/2"))
    Split the current frame into 2 side-by-side frames.
  • Function VSPLIT (&optional (ratio "1/2"))
    Split the current frame into 2 frames, one on top of the other.
  • Function 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.
  • Function ONLY
    Delete all the frames but the current one and grow it to take up the entire head.
  • Function CURFRAME
    Display a window indicating which frame is focused.
  • Function FNEXT
    Cycle through the frame tree to the next frame.
  • Function SIBLING
    Jump to the frame's sibling. If a frame is split into two frames, these two frames are siblings.
  • Function FOTHER
    Jump to the last frame that had focus.
  • Function 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.
  • Function RESIZE (width height)
    Resize the current frame by @var{width} and @var{height} pixels
  • Function FCLEAR
    Clear the current frame.
  • Function MOVE-FOCUS (dir)
    Focus the frame adjacent to the current one in the specified direction. The following are valid directions: @table @asis @item up @item down @item left @item right @end table
  • Function MOVE-WINDOW (dir)
    Just like move-focus except that the current is pulled along.
  • Function NEXT-IN-FRAME
    Go to the next window in the current frame.
  • Function PREV-IN-FRAME
    Go to the previous window in the current frame.
  • Function OTHER-IN-FRAME
    Go to the last accessed window in the current frame.
  • Function BALANCE-FRAMES
    Make frames the same height or width in the current frame's subtree.
  • Function FLOAT-THIS
    Transforms a tile-window into a float-window
  • Function UNFLOAT-THIS
    Transforms a float-window into a tile-window
  • Generic-Function GRAVITY-COORDS (gravity width height minx miny maxx maxy)
    Get the X and Y coordinates to place something of width WIDTH and height HEIGHT within an area defined by MINX MINY MAXX and MAXY, guided by GRAVITY.
  • Method GRAVITY-COORDS ((gravity (eql :top-right)) (width number) (height number) (minx number) (miny number) (maxx number) (maxy number))
  • Method GRAVITY-COORDS ((gravity (eql :top-left)) (width number) (height number) (minx number) (miny number) (maxx number) (maxy number))
  • Method GRAVITY-COORDS ((gravity (eql :bottom-right)) (width number) (height number) (minx number) (miny number) (maxx number) (maxy number))
  • Method GRAVITY-COORDS ((gravity (eql :bottom-left)) (width number) (height number) (minx number) (miny number) (maxx number) (maxy number))
  • Method GRAVITY-COORDS ((gravity (eql :right)) (width number) (height number) (minx number) (miny number) (maxx number) (maxy number))
  • Method GRAVITY-COORDS ((gravity (eql :left)) (width number) (height number) (minx number) (miny number) (maxx number) (maxy number))
  • Method GRAVITY-COORDS ((gravity (eql :top)) (width number) (height number) (minx number) (miny number) (maxx number) (maxy number))
  • Method GRAVITY-COORDS ((gravity (eql :bottom)) (width number) (height number) (minx number) (miny number) (maxx number) (maxy number))
  • Method GRAVITY-COORDS ((gravity (eql :center)) (width number) (height number) (minx number) (miny number) (maxx number) (maxy number))
  • Function ECHO-STRING (screen msg)
    Display @var{string} in the message bar on @var{screen}. You almost always want to use @command{message}.
  • Function MESSAGE (fmt &rest args)
    run FMT and ARGS through `format' and echo the result to the current screen.
  • Function ERR (fmt &rest args)
    run FMT and ARGS through format and echo the result to the current screen along with a backtrace. For careful study, the message does not time out.
  • Function LASTMSG
    Display the last message. If the previous command was lastmsg, then continue cycling back through the message history.
  • Function SET-X-SELECTION (text &optional (selection :primary))
    Set the X11 selection string to @var{string}.
  • Function GET-X-SELECTION (&optional timeout (selection :primary))
    Return the x selection no matter what client own it.
  • Function PUTSEL (string)
    Stuff the string @var{string} into the X selection.
  • Function GETSEL
    Echo the X selection.
  • Function COPY-LAST-MESSAGE
    Copy the last message displayed into the X selection
  • Variable *MODULE-DIR*
    (stumpwm:pathname-as-directory
     (stumpwm:concat (stumpwm:getenv "home") "/.stumpwm.d/modules"))
    The location of the contrib modules on your system.
  • Variable *LOAD-PATH*
    nil
    A list of paths in which modules can be found, by default it is populated by any asdf systems found in `*module-dir*' set from the configure script when StumpWM was built, or later by the user using `add-to-load-path'
  • Function INIT-LOAD-PATH (path)
    Recursively builds a list of paths that contain modules. This is called each time StumpWM starts with the argument `*module-dir'
  • Function SET-MODULE-DIR (dir)
    Sets the location of the for StumpWM to find modules
  • Function LIST-MODULES
    Return a list of the available modules.
  • Function FIND-MODULE (name)
  • Function SET-CONTRIB-DIR
    Deprecated, use `add-to-load-path' instead
  • Function ADD-TO-LOAD-PATH (path)
    If `PATH' is not in `*LOAD-PATH*' add it, check if `PATH' contains an asdf system, and if so add it to the central registry
  • Function LOAD-MODULE (name)
    Loads the contributed module with the given NAME.
  • Generic-Function IO-CHANNEL-IOPORT (io-loop channel)
    Returns the I/O facility operated on by CHANNEL, in a representation understood by IO-LOOP. CHANNEL may be either an I/O channel or an object representing an underlying I/O facility, such as a stream object. An I/O loop implementation should implement methods for any primitive I/O facilities that it can monitor for events, and abstract channels should return whatever IO-CHANNEL-IOPORT returns for the primitive facility that it operates on. An I/O channel may also return NIL to indicate that it is only interested in purely virtual events, such as :TIMEOUT or :LOOP.
  • Generic-Function IO-CHANNEL-EVENTS (channel)
    Returns a list of events that CHANNEL is interested in. An event specification may be a simple symbol, or a list of a symbol and additional data for the event. Specific I/O loop implementations may implement additional events, but the following event specifications should be supported by all I/O loops: :READ -- The channel will be notified when its I/O port can be read from without blocking. :WRITE -- The channel will be notified when its I/O port can be written to without blocking. (:TIMEOUT TIME-SPEC) -- TIME-SPEC is a point in time in the same units as from (GET-INTERNAL-REAL-TIME), at which point the channel will be notified. It is permissible for TIME-SPEC to be a real number of any representation, but the system does not guarantee any particular level of accuracy. :LOOP -- The channel will be notifed for each iteration of the I/O loop, just before blocking for incoming events. This should be considered a hack to be avoided, but may be useful for certain libraries (such as XLIB). If, at any time, an empty list is returned, the channel is unregistered with the I/O loop. The I/O loop will check what events a channel is interested in when it is first registered with the loop, and whenever the channel has been notified of an event. If the channel changes its mind at any other point in time, it should use the IO-LOOP-UPDATE function to notify the I/O loop of such changes. The I/O loop may also update spuriously at any time, but such updates are not guaranteed.
  • Generic-Function IO-CHANNEL-HANDLE (channel event &key &allow-other-keys)
    Called by the I/O loop to notify a channel that an event has occurred. EVENT is the symbol corresponding to the event specification from IO-CHANNEL-EVENTS (that is, :READ, :WRITE, :TIMEOUT or :LOOP). A number of keyword arguments with additional data specific to a certain event may also be passed, but no such arguments are currently defined.
  • Generic-Function IO-LOOP-ADD (io-loop channel)
    Add a channel to the given I/O multiplexer to be monitored.
  • Generic-Function IO-LOOP-REMOVE (io-loop channel)
    Unregister a channel from the I/O multiplexer.
  • Generic-Function IO-LOOP-UPDATE (io-loop channel)
    Make the I/O loop update its knowledge of what events CHANNEL is interested in. See the documentation for IO-CHANNEL-EVENTS for more information.
  • Generic-Function IO-LOOP (io-loop &key &allow-other-keys)
    Run the given I/O multiplexer, watching for events on any channels registered with it. IO-LOOP will return when it has no channels left registered with it.
  • Variable *DEFAULT-IO-LOOP*
    nil
    The default I/O loop implementation. Should be generically optimal for the given LISP implementation and operating system.
  • Variable *CURRENT-IO-LOOP*
    nil
    Dynamically bound to the I/O loop currently running, providing an easy way for event callbacks to register new channels.
  • Variable *CURRENT-IO-CHANNEL*
    nil
    While processing an I/O channel, this variable is dynamically bound to the channel in question. This is provided primarily for error-handling code.
  • Method IO-CHANNEL-HANDLE (channel event &key &allow-other-keys)
  • Method IO-LOOP-ADD ((info sbcl-io-loop) channel)
  • Method IO-LOOP-REMOVE ((info sbcl-io-loop) channel)
  • Method IO-LOOP-UPDATE ((info sbcl-io-loop) channel)
  • Method IO-LOOP ((info sbcl-io-loop) &key description)
  • Method IO-CHANNEL-IOPORT (io-loop (channel fd-stream))
  • Method IO-CHANNEL-IOPORT ((io-loop sbcl-io-loop) (channel display))
  • Method IO-LOOP-ADD ((info xlib-io-loop) channel)
  • Method IO-LOOP-REMOVE ((info xlib-io-loop) channel)
  • Method IO-LOOP-UPDATE ((info xlib-io-loop) channel)
  • Method IO-LOOP ((info xlib-io-loop) &key description)
  • Method IO-CHANNEL-IOPORT ((io-loop xlib-io-loop) (channel display))
  • Method IO-CHANNEL-IOPORT (io-loop (channel synonym-stream))
  • Class CALLBACK-CHANNEL
    Implements a convenience I/O channel which takes an underlying I/O facility and calls the given callback functions when an event occurs on the channel. The :STREAM init-argument specifies the I/O facility to monitor, :READ specifies a function to be called back when a read event occurs, and :WRITE a corresponding function for write events. Timeouts are not supported. By default, the channel will listen for read events iff a read callback function is given and correspondingly for write events, but CALLBACK-CHANNEL-EVENTS can be SETF'd to specify events explicitly in case certain events are only interesting sporadically. To restore default behavior, set it to :AUTO.
    CURRENT
    STREAM   Reader: CALLBACK-CHANNEL-STREAM
    READ-FUNCTION
    WRITE-FUNCTION
    EVENTS   Accessor: CALLBACK-CHANNEL-EVENTS
  • Method IO-LOOP-ADD (info (channel callback-channel))
  • Method IO-LOOP-ADD (info (channel callback-channel))
  • Method IO-LOOP-REMOVE (info (channel callback-channel))
  • Method IO-CHANNEL-IOPORT (io-loop (channel callback-channel))
  • Method IO-CHANNEL-EVENTS ((channel callback-channel))
  • Method IO-CHANNEL-HANDLE ((channel callback-channel) (event (eql :read)) &key)
  • Method (setf CALLBACK-CHANNEL-EVENTS) (events channel)
  • Variable *TOPLEVEL-IO*
    nil
    Top-level I/O loop
  • Function TIMER-P (object)
  • Function RUN-WITH-TIMER (secs repeat function &rest args)
    Perform an action after a delay of SECS seconds. Repeat the action every REPEAT seconds, if repeat is non-nil. SECS and REPEAT may be reals. The action is to call FUNCTION with arguments ARGS.
  • Function CANCEL-TIMER (timer)
    Remove TIMER from the list of active timers.
  • Method IO-CHANNEL-IOPORT (io-loop (channel stumpwm-timer-channel))
  • Method IO-CHANNEL-EVENTS ((channel stumpwm-timer-channel))
  • Method IO-CHANNEL-HANDLE ((channel stumpwm-timer-channel) (event (eql :timeout)) &key)
  • Method IO-CHANNEL-HANDLE ((channel stumpwm-timer-channel) (event (eql :loop)) &key)
  • Method IO-CHANNEL-IOPORT (io-loop (channel request-channel))
  • Method IO-CHANNEL-EVENTS ((channel request-channel))
  • Method IO-CHANNEL-HANDLE ((channel request-channel) (event (eql :read)) &key)
  • Function CALL-IN-MAIN-THREAD (fn)
  • Method IO-CHANNEL-IOPORT (io-loop (channel display-channel))
  • Method IO-CHANNEL-EVENTS ((channel display-channel))
  • Method IO-CHANNEL-HANDLE ((channel display-channel) (event (eql :read)) &key)
  • Method IO-CHANNEL-HANDLE ((channel display-channel) (event (eql :loop)) &key)
  • Function STUMPWM (&optional (display-str (or (getenv "display") ":0")))
    Start the stump window manager.
  • Function RESTARTS-MENU (err)
    Display a menu with the active restarts and let the user pick one. Error is the error being recovered from. If the user aborts the menu, the error is re-signalled.
  • Function BANISH (&optional where)
    Warp the mouse the lower right corner of the current head.
  • Function RATWARP (x y)
    Warp the mouse to the specified location.
  • Function RATRELWARP (dx dy)
    Warp the mouse by the specified amount from its current position.
  • Function 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.
  • Function 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.
  • Function RUN-SHELL-COMMAND (cmd &optional collect-output-p)
    Run the specified shell command. If @var{collect-output-p} is @code{T} then run the command synchonously and collect the output. Be careful. If the shell command doesn't return, it will hang StumpWM. In such a case, kill the shell command to resume StumpWM.
  • Function EVAL-LINE (cmd)
    Evaluate the s-expression and display the result(s).
  • Function ECHO (string)
    Display @var{string} in the message bar.
  • Function META (key)
    Send a fake key to the current window. @var{key} is a typical StumpWM key, like @kbd{C-M-o}.
  • Function LOADRC
    Reload the @file{~/.stumpwmrc} file.
  • Function KEYBOARD-QUIT
  • Function QUIT
    Quit StumpWM.
  • Function RESTART-SOFT
    Soft Restart StumpWM. The lisp process isn't restarted. Instead, control jumps to the very beginning of the stumpwm program. This differs from RESTART, which restarts the unix process. Since the process isn't restarted, existing customizations remain after the restart.
  • Function RESTART-HARD
    Restart stumpwm. This is handy if a new stumpwm executable has been made and you wish to replace the existing process with it. Any run-time customizations will be lost after the restart.
  • Function 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}.
  • Function 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.
  • Function RELOAD
    Reload StumpWM using @code{asdf}.
  • Function EMACS
    Start emacs unless it is already running, in which case focus it.
  • Function COPY-UNHANDLED-ERROR
    When an unhandled error occurs, StumpWM restarts and attempts to continue. Unhandled errors should be reported to the mailing list so they can be fixed. Use this command to copy the unhandled error and backtrace to the X11 selection so you can paste in your email when submitting the bug report.
  • Macro 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.
  • Function SHOW-WINDOW-PROPERTIES
    Shows the properties of the current window. These properties can be used for matching windows with run-or-raise or window placement rules.
  • Function LIST-WINDOW-PROPERTIES
    List all the properties of the current window and their values, like xprop.
  • Macro DEFINE-INTERACTIVE-KEYMAP (name (&key on-enter on-exit abort-if) &body key-bindings)
    Declare an interactive keymap mode. This can be used for developing interactive modes or command trees, such as @command{iresize}. The NAME argument follows the same convention as in @command{defcommand}. ON-ENTER and ON-EXIT are optional functions to run before and after the interactive keymap mode, respectivelly. If ABORT-IF is defined, the interactive keymap will only be activated if calling ABORT-IF returns true. KEY-BINDINGS is a list of the following form: ((KEY COMMAND) (KEY COMMAND) ...) each element in KEY-BINDINGS declare a command inside the interactive keymap. Be aware that these commands won't require a prefix to run.
  • Variable *RESIZE-INCREMENT*
    10
    Number of pixels to increment by when interactively resizing frames.
  • Function SETUP-IRESIZE
    Start the interactive resize mode.
  • Function RESIZE-DIRECTION (d)
  • Function IRESIZE
    Starts interactive command "IRESIZE"
  • Function IRESIZE
    Starts interactive command "IRESIZE"
  • Function EXIT-IRESIZE
  • Function COMMANDS
    List all available commands.
  • 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.
  • Function DESCRIBE-VARIABLE (var)
    Print the online help associated with the specified variable.
  • Function DESCRIBE-FUNCTION (fn)
    Print the online help associated with the specified function.
  • Function DESCRIBE-COMMAND (com)
    Print the online help associated with the specified command.
  • Function WHERE-IS (cmd)
    Print the key sequences bound to the specified command.
  • Function WHICH-KEY-MODE
    Toggle which-key-mode
  • Function MODIFIERS
    List the modifiers stumpwm recognizes and what MOD-X it thinks they're on.
  • Struct FDUMP
    NUMBER
    X
    Y
    WIDTH
    HEIGHT
    WINDOWS
    CURRENT
  • Function FDUMP-NUMBER (instance)
  • Function (setf FDUMP-NUMBER) (value instance)
  • Function FDUMP-X (instance)
  • Function (setf FDUMP-X) (value instance)
  • Function FDUMP-Y (instance)
  • Function (setf FDUMP-Y) (value instance)
  • Function FDUMP-WIDTH (instance)
  • Function (setf FDUMP-WIDTH) (value instance)
  • Function FDUMP-HEIGHT (instance)
  • Function (setf FDUMP-HEIGHT) (value instance)
  • Function FDUMP-WINDOWS (instance)
  • Function (setf FDUMP-WINDOWS) (value instance)
  • Function FDUMP-CURRENT (instance)
  • Function (setf FDUMP-CURRENT) (value instance)
  • Struct GDUMP
    NUMBER
    NAME
    TREE
    CURRENT
  • Function GDUMP-NUMBER (instance)
  • Function (setf GDUMP-NUMBER) (value instance)
  • Function GDUMP-NAME (instance)
  • Function (setf GDUMP-NAME) (value instance)
  • Function GDUMP-TREE (instance)
  • Function (setf GDUMP-TREE) (value instance)
  • Function GDUMP-CURRENT (instance)
  • Function (setf GDUMP-CURRENT) (value instance)
  • Struct SDUMP
    NUMBER
    GROUPS
    CURRENT
  • Function SDUMP-NUMBER (instance)
  • Function (setf SDUMP-NUMBER) (value instance)
  • Function SDUMP-GROUPS (instance)
  • Function (setf SDUMP-GROUPS) (value instance)
  • Function SDUMP-CURRENT (instance)
  • Function (setf SDUMP-CURRENT) (value instance)
  • Struct DDUMP
    SCREENS
    CURRENT
  • Function DDUMP-SCREENS (instance)
  • Function (setf DDUMP-SCREENS) (value instance)
  • Function DDUMP-CURRENT (instance)
  • Function (setf DDUMP-CURRENT) (value instance)
  • Function DUMP-GROUP-TO-FILE (file)
    Dumps the frames of the current group of the current screen to the named file.
  • Function DUMP-SCREEN-TO-FILE (file)
    Dumps the frames of all groups of the current screen to the named file
  • Function DUMP-DESKTOP-TO-FILE (file)
    Dumps the frames of all groups of all screens to the named file
  • Function RESTORE-FROM-FILE (file)
    Restores screen, groups, or frames from named file, depending on file's contents.
  • Function PLACE-EXISTING-WINDOWS
    Re-arrange existing windows according to placement rules.
  • Variable *TIME-FORMAT-STRING-DEFAULT*
    "%a %b %e %y %k:%m:%s"
    The default value for `echo-date', (e.g, Thu Mar 3 2005 23:05:25).
  • Variable *TIME-MODELINE-STRING*
    "%a %b %e %k:%m:%s"
    The default time value to pass to the modeline.
  • Function ECHO-DATE
    Display the date and time.
  • Function TIME-FORMAT (str)
  • Variable *MODE-LINE-POSITION*
    :top
    Specifies where the mode line is displayed. Valid values are :top and :bottom.
  • Variable *MODE-LINE-BORDER-WIDTH*
    1
    Specifies how thick the mode line's border will be. Integer value.
  • Variable *MODE-LINE-PAD-X*
    5
    Specifies the number of padding pixels between the text and the side of the mode line. Integer value.
  • Variable *MODE-LINE-PAD-Y*
    1
    The number of padding pixels between the modeline text and the top/bottom of the modeline? Integer value.
  • Variable *MODE-LINE-BACKGROUND-COLOR*
    "gray20"
    The mode line background color.
  • Variable *MODE-LINE-FOREGROUND-COLOR*
    "gray50"
    The mode line foreground color.
  • Variable *MODE-LINE-BORDER-COLOR*
    "gray30"
    The mode line border color.
  • Variable *SCREEN-MODE-LINE-FORMAT*
    "[^b%n^b] %w"
    This variable describes what will be displayed on the modeline for each screen. Turn it on with the function TOGGLE-MODE-LINE or the mode-line command. It is a list where each element may be a string, a symbol, or a list. For a symbol its value is used. For a list of the form (:eval FORM) FORM is evaluated and the result is used as a mode line element. If it is a string the string is printed with the following formatting options: @table @asis @item %h List the number of the head the mode-line belongs to @item %w List all windows in the current group windows using @var{*window-format*} @item %W List all windows on the current head of the current group using @var{*window-format*} @item %g List the groups using @var{*group-format*} @item %n The current group's name @item %u Using @var{*window-format*}, return a 1 line list of the urgent windows, space seperated. @item %v Using @var{*window-format*}, return a 1 line list of the windows, space separated. The currently focused window is highlighted with fmt-highlight. Any non-visible windows are colored the *hidden-window-color*. @item %d Using @var{*time-modeline-string*}, print the time. @end table A number of modules have been written that extends the possible formatting strings. See their documentation for details.
  • Variable *SCREEN-MODE-LINE-FORMATTERS*
    nil
    An alist containing format character format function pairs for formatting screen mode-lines. functions are passed the mode line.
  • Variable *MODE-LINE-TIMEOUT*
    60
    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.
  • Function ADD-SCREEN-MODE-LINE-FORMATTER (character fmt-fun)
    Add a format function to a format character (or overwrite an existing one).
  • Struct MODE-LINE
    SCREEN
    HEAD
    WINDOW
    FORMAT
    POSITION
    CONTENTS
    CC
    HEIGHT
    FACTOR
    MODE
  • Function TOGGLE-MODE-LINE (screen head &optional (format '*screen-mode-line-format*))
    Toggle the state of the mode line for the specified screen
  • Function ENABLE-MODE-LINE (screen head state &optional format)
    Set the state of SCREEN's HEAD's mode-line. If STATE is T and FORMAT is specified, then the mode-line's format is updated.
  • Function MODE-LINE
    A command to toggle the mode line visibility.
  • Variable *HIDDEN-WINDOW-COLOR*
    "^5*"
    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.
  • Variable *MODE-LINE-HIGHLIGHT-TEMPLATE*
    "^r~a^r"
    The string passed to FORMAT to highlight things in the mode line.
  • Function 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.
  • Function BAR (percent width full empty)
    Return a progress bar string of WIDTH characters composed of characters FULL and EMPTY at PERCENT complete.
  • Variable *COLORS*
    '("black" "red" "green" "yellow" "blue" "magenta" "cyan" "white")
    Eight colors by default. You can redefine these to whatever you like and then call (update-color-map).
  • Function ADJUST-COLOR (color amt)
  • Function LOOKUP-COLOR (screen color)
  • Function UPDATE-COLOR-MAP (screen)
    Read *colors* and cache their pixel colors for use when rendering colored text.
  • Function UPDATE-SCREEN-COLOR-CONTEXT (screen)
  • Function MOVE-WINDOWS-TO-GROUP (windows &optional (arggroup nil))
    Move all windows from the list to the group
  • Macro ACT-ON-MATCHING-WINDOWS ((var &optional (range '(current-screen))) condition &rest code)
    Run code on all windows matching condition; var is the shared lambda variable. Range can be any screen/group/frame or :screen/:group/:frame for the current instance. Condition is just the code to evaluate.
  • Variable *VERSION*
    "1.0.0 compiled on wed may 17 2017 18:44:45"
  • Function VERSION
    Print version information and compilation date.

Also exports

  • COMMON-LISP:TIME

STUMPWM-USER

No exported symbols.