This is sawfish.info, produced by makeinfo version 4.8 from sawmill-20070102.texi. START-INFO-DIR-ENTRY * sawfish: (sawfish). sawfish programming manual END-INFO-DIR-ENTRY This is Edition 0.10, last updated 2 July 2007, of `The sawfish Programming Manual', for sawfish, Version 1.3. Copyright 1999 John Harper. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.  File: sawfish.info, Node: Top, Next: Copying, Prev: (dir), Up: (dir) This document describes the Lisp programming interface to `sawfish', an extensible X11 window manager. This is Edition 0.10 of its documentation, last updated 2 July 2007 for Sawfish version 1.3. * Menu: * Copying:: Distribution conditions * Introduction:: Brief introduction to sawfish * News:: Feature history * Colors:: Color type * Fonts:: Font type * Images:: Image type * Cursors:: Cursor type * Windows:: Window type * Customization:: Supporting user-configuration * Window Frames:: Decorating windows * Viewports:: Subdivided desktop areas * Workspaces:: Multiple desktop areas * Multi-Head Environments:: Multiple monitors * Window Placement:: Controlling placement of new windows * Popup Menus:: Displaying menus * Events:: Input event types * Commands:: Functions you can invoke interactively * Keymaps:: Bindings events to actions * Event Loop:: Handling input events * Miscellaneous Functions:: Useful features * Standard Hooks:: Hooking into wm actions * Standard Properties:: Window properties * Session Management:: Saving state across sessions * Low-level X Interface:: Accessing the server directly * FAQ:: Frequently asked questions * Function Index:: Menu of all documented functions * Variable Index:: All variables which have been mentioned * Concept Index:: Main index, references to all sections  File: sawfish.info, Node: Copying, Next: Introduction, Prev: Top, Up: Top 1 Copying ********* Sawfish is copyright (C) 1999 John Harper and is released under the terms of the GNU General Public License. See the included file `COPYING' for the full text of the license (or *note Copying: (emacs)Copying.). This is free software - you are welcome to redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. Sawfish is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.  File: sawfish.info, Node: Introduction, Next: News, Prev: Copying, Up: Top 2 Introduction ************** Sawfish is a lisp-extensible window manager for X11. Its aim is to allow all areas of window management (decoration, manipulation) to be customized as far as is possible, yet still remain as fast or faster than existing window managers. Despite this extensibility its policy is very minimal compared to most window managers. It does not implement desktop backgrounds, applications docks, or other things that may be achieved through separate applications. All high-level window management functions are implemented in Lisp for future extensibility or redefinition. Also, most received events are exported to the Lisp environment through key-bindings and hooks, similar to in Emacs. These events include pointer behavior and many internal X11 events. Sawfish uses the librep Lisp environment (*note Overview: (librep)Top.), this is a run-time library implementing a language similar to Emacs Lisp (*note Overview: (elisp)Top.), but with many extensions, and using lexical instead of dynamic scope. This manual assumes at least a basic knowledge of the language.  File: sawfish.info, Node: News, Next: Colors, Prev: Introduction, Up: Top 3 News ****** This lists the user-visible changes made to Sawfish, and which releases they occurred between. For more detailed information see the `ChangeLog' files in the Sawfish source tree. 1.3 === * Implemented EMWH "show desktop" mode * Set client window gravity to `StaticGravity' while reparenting windows (Michal Maru¹ka) * Support EWMH `SKIP_TASKBAR' state (Chris Boyle, me) * Window history keys may have multiple properties (not enabled by default for backwards compatibility, see `window-history-key' variable) * More placement modes are now multihead-aware (Steve Hill) * Translation updates: el (Simos Xenitellis, Kostas Papadimas), de (Christian Neumair), no (Kjartan Maraas), pt_BR (Alexandre Folle de Menezes), am (Daniel Yacob), es (German Poo Caaman~o), uk (Maxim Dzumanenko), sk (Stanislav Visnovsky) * Bug fixes: - compile with Gtk 2.2 - don't try to unfocus windows within the X error handler - don't cache frame objects while clicking in windows, they may get garbage collected - fixes "crash on shading" bug - set `_NET_WM_NAME' as `UTF8_STRING' type (Christian Krause) - `save-session' is now called `gnome-session-save'; fallback to looking in `/usr/gnome' for menus - fixed typo in `adjust-position-for-gravity/y' 1.2 === * Added an `OPTIONS' file describing the variables that may be customized * Some drawing optimizations: don't reinstall frame shape at each redraw, turn off graphics exposures in all contexts * Added a cache for X properties to minimize server round-trips * Added support for Xft fonts * Color objects now store alpha as well as rgb data * Support useful parts of 1.1 NET WM spec; also fixed some bugs / omissions in support for 1.0 spec (e.g. `_NET_WORKAREA') * Support for two dimensional workspace layouts and edge flipping (Michael Toomin) * Translation updates (Dmitry G. Mastrukov, Jordi Mallach, Vincent van Adrighem, Christian Rose, Stanislav Visnovsky, Daniel Yacob, Andras Timar, Sava Chankov, Christian Neumair, Peteris Krisjanis, Gustavo Noronha Silva, Christian Meyer, Fatih Demir, Hasbullah Bin Pit, Christophe Fergeau) * Bug fixes: - Don't pass null pointers to `accept ()' - Stacking list assertions no longer abort execution, they just print an error message - Handle minimum-size hints that are zero - Understand the Pango font names that the Gtk2 font selector uses - Fixed bugs when iconifying sticky windows - When servicing configure-window requests, respect the window's locked dimensions. Also handle moving in only one direction - `grow-pack' bug fixes (Daniel Pfeiffer) - Fixed some problems with fullscreen mode - Fixed some problems in the Gtk2 config tool - Other bug fixes (Greg Morris, Claudio Bley) 1.1 === * Reorganized the customization options. Removed user levels. Removed many obscure options (most are still available as lisp variables, just not from the UI). Viewports are no longer available in the UI * Updates to the `grow-pack' module (Kai Großjohann, Daniel Pfeiffer) * In matched windows, boolean options can be turned off as well as on (me, merlin) * New full screen maximization mode * Bug fixes: - Miscellaneous focus fixes - Be more selective about which X errors imply window deletion - Don't trigger a stacking-list assertion on logout - Check for window-ness in window-visibility (Michal Maru¹ka) - Reread WM_WINDOW_PROTOCOLS when it changes - Fixed bug of nautilus windows not being focused in focus follows mouse modes - Recover "lost" windows when selecting windows (merlin) - Show correct size when resizing windows (merlin) - Most placement modes now respect workarea (Federico Mena Quintero, me) - Miscellaneous fixes to wm-spec implementation. Includes code to support _NET_WM_STRUT - Call `bindtextdomaincodeset' function if rep implements it (Christophe Fergeau) - Make the current-directory stored in the session a valid filename - Don't put windows below the default depth just because their parent is - Miscellaneous viewport fixes (Federico Mena Quintero) - Don't let "transients above" and "layer" stacking constraints conflict with one another 1.0.1 ===== * Translation updates: pt (Carlos Perelló Marín), it (Michele Campeotto), pl (Zbigniew Chyla), zh_CN (Wang Jian), zh_TW (Abel Cheung), es (Eneko Lacunza), tr (Ömer Fadýl USTA), sv (Göran Uddeborg, Christian Rose), da (Ole Laursen), gl (Jesus Bravo Alvarez) * Bug fixes: - Fixed typo in `apply-command-keys' function (David Bustos) - Fixed bug in `wm-spec' module causing nautilus desktop window to cover panel - Adopt windows with a maximized hint correctly - Fixed bug in `display-window' function that can prevent the window getting focused - Don't allow windows to be moved or resized by third-parties when they're maximized (and the necessary option is set) - Fixed problem with localizing property names in the matched-windows configuration widget - Handle window gravity more correctly (Owen Taylor) - Forget everything about withdrawn windows - better ICCCM compliance - Fixed root-window event proxying (the infamous gmc bug) - Don't use dlmalloc on sparcs (Brian Nitz) 0.99 ==== * Requires `librep' 0.14 or newer * Translation updates: ja (Sato Satoru), no (Kjartan Maraas), es (Carlos Perelló Marín), fi (Antti Ahvensalmi), cs (Jiri Cerny), fr (Christian Marillat), de (Matthias Warkus, Christian Meyer), da (Ole Laursen), sk (Stanislav Visnovsky), tr (Özgür), sv (Christian Rose, Peter Winnberg), gl (Jesus Bravo Alvarez) * Do i18n on more text strings (Vlad Harchev, me) * Broken support for multiple-screen displays. Supplying the new `--multihead' option will fork extra copies of sawfish for each extra screen. This has some fundamental problems, but some people seem to want it (Michael Vogt, Mahmood Ali, me) * Window manager virtual modifier once again defaults to `M-' instead of `C-' * Added support for `Off2' and `Off3' events * `menu-program-stays-running' variable now defaults to true by popular demand * New command `focus-desktop' * Switch viewports more efficiently (by choosing the best order to move windows, to minimize the exposed area) * Monitor the `_WIN_WORKSPACE' property of each window * Bug fixes: - Check for X SHAPE extension, exit if it's not available - Wait for the focus-in event before changing sawfish's knowledge of the focused window when moving focus from one window to another - Be more ICCCM-compliant, don't send synthetic configure notify events when the window was resized - Fixed locale font handling - Don't leave grid traces when trying to move/resize a window that's locked in place - Fixed bug where the pointer being over the message window could confuse focus after window cycling - `decorate-transients' option works again with shaded windows - Documentation appears in tooltips again - Handle sticky properties better in the `window-history' module - Maximization fixes for multi-headed displays (Florent Guillaume) - Cancelling a resize of a maximized window no longer discards the window's maximized state 0.38 ==== * Translation updates: gl (Jesus Bravo Alvarez), sv (Martin Norbäck), de (Matthias Warkus, Christian Meyer), ru (Vlad Harchev), es (Joseba García Etxebarria), pl (Daniel Koc), fi (Antti Ahvensalmi), sk (Stanislav Visnovsky), az (Pablo Saratxaga), cz (Stanislav Brabec), no (Kjartan Maraas), el (Simos Xenitellis), it (Michele Campeotto), fr (Christian Marillat), ro (Marius Andreiana), ko (?) Extract some more translatable strings (Vlad Harchev) * `Crux' theme now has an extra button mode: `Default', like Mac OS Platinum but also has an iconify button. Used by default * The `grow-pack' module now works with windows which specify increments (Kai Großjohann) * New command `kill-client' * Fixed bugs: - Don't return a null pointer when no default cursor has been set, return `nil' instead - Avoid triggering assertions in the stacking list code when raising or lowering windows and the given sibling has been destroyed - Turned off the annoying code that beeps and prints a message when unfocusable windows are detected - The GNOME hints now listen for the `_WIN_WORKSPACE' property changing and will move the window in response - Don't forget maximized state of windows when they're moved, only if they're resized - Don't show special cursors when moving or resizing windows, or when hovering over the title bar - Corrected off-by-one error in `smart' placement modes - Identified and fixed some problems in the new GNOME/KDE window manager hints implementation (Rob Hodges, me) 0.37 ==== * New command line option `--window-history-file=FILE' * Search for user's rc file in this order: `~/.sawfishrc', `~/.sawfish/rc', `~/.sawmillrc' * New option `configure-ignore-stacking-requests' and a similarly-named window property. When set stacking requests from windows are ignored (Matt Tucker) * When restarting sawfish, reselect the previously selected workspace * Added a function that can recolour multiple image channels simultaneously * New function `exit-type' - returns the type of exit in progress * Translation updates: ja (Sato Satoru), sk (Stanislav Visnovsky), es (Iñaki García Etxebarria), hu (Robert Vanyi), tr (Fatih Demir), ro (Tutu Valentin), no (Kjartan Maraas), it (Michele Campeotto), pl (Daniel Koc) * Fixed bugs: - Fixed focus-handling in enter-only mode on window close and viewport switch - Fixed overflow error in the image recolouring module (Simon Budig) - Session management always uses a unique session file (Timo Korvola, me) - Fixed bug in random placement mode where windows could sometimes be placed off-screen - Fixed some auto-raise problems by reverting a misguided bug fix - Fixed bugs with aborted session saves - Cache stacking order of windows locally - this allows us to keep the order consistent, especially after window reparenting operations - Don't call `XParseColor' unless we actually _have_ a display connection (merlin) - Merged two calls to `setlocale' to avoid trashing the locale preferences - Check for presence of Xinerama extension before trying to use it - removes the annoying error message at startup - Added some more X server timestamp logic to correct for the timestamp discontinuities after APM resume 0.36 ==== * Added a new default theme: `Crux'. By default it recolours itself to match the current GTK+ selection colour. (Arlo Rose, me) * Updated translations: it (Michele Campeotto), fr (Christian Marillat) * Added a `shade-button' button class (many themes created it anyway) * Added a `sawfish.wm.util.recolor-image' module, currently contains a single function for recolouring parts of images based on a given colour gradient * Added new command `delete-group'. Deletes a whole group of windows. With default bindings, shift-click on the close button to invoke this command * Added support for KDE-style mini-icons. If the window has no normal icon, then `window-icon-image' will return the mini-icon * Fixed bugs: - Themes that use the module for reading the user's gtk preferences will once again get updated when the gtk theme changes - Fix another of the null-string translation bugs (Christian Marillat) - Work around `XUrgencyHint' not being defined before X11R6 - Fixed some long-standing bugs when decorating windows (use the correct mask when creating the overall window shape; for frame parts with no mask, set the local shape to the appropriate rectangle; be sure to generate at least one Expose event when reconfiguring frame parts) - Fixed crashing bug when `bind-keys' is called with zero arguments - Fixed typo in `crop-image' function when checking validity of HEIGHT parameter (martin@whoever.com) 0.35 ==== * Translation updates: ja (SATO Satoru), it (Michele Campeotto), zh_TW.Big5 (Chun-Chung Chen), pl (Daniel Koc), sk (Stanislav Visnovsky) * Items in `choice' widgets may now contain descriptive names, syntax is `(SYMBOL "DESCRIPTION")' * Changed `focus-windows-when-mapped' option to only apply to non-transient windows (this option is now enabled by default) * New placement modes `top-left' and `off-center'. `top-left' is now the default mode for non-transients * Enabled the module supporting the newly standardized GNOME/KDE window manager hints. Also made random changes to support KDE2 a lot better * Added WM_PROTOCOLS `_SAWFISH_WM_RAISE_WINDOW' and `_SAWFISH_WM_LOWER_WINDOW'. Used by `maybe-raise-window' and `maybe-lower-window' functions. These are similar to `WM_TAKE_FOCUS', in that if the window supports the protocol, it's up to it whether or not it raises (or lowers) the window in question. These functions should only be used where the user hasn't explicitly requested the restacking An example usage is an application that doesn't want its window to be raised due to a button-press event that initiates a drag operation * New option `menus-include-shortcuts', disabled by default (Unai Uribarri) * Don't interpret windows with `WM_TRANSIENT_FOR' set to the root window as children of all windows in the group (it causes too many annoying effects), instead just decorate these windows as transients * Handle `group' and `transient' iconification modes better, don't use a recursive method, instead use one pass to identify the windows to change, then another to make the changes. In `transients' mode, only change the state of shared transients if they will have no visible parents afterwards * In the (old) GNOME hints code, support a `_WIN_HINTS' client message (with a similar format to the `_WIN_STATE' message) * New module `sawfish.wm.commands.viewport-extras', some commands for viewport for viewport navigation (Dams Nadé) * Check for `never-iconify' and `never-maximize' window properties when appropriate * Support sixth and seventh mouse buttons (Steve Haslam) * Bug fixes: - Fixed problems with reverting changes to list-based options - Don't allow the empty list as a valid modifier list - Fixed bug where restarting the wm with `focus-windows-when-mapped' set would cause any shaded windows to be deleted - Ignore iconified windows in the grow-pack code - Added `font-ascent' and `font-descent' functions to the gaol - Catch errors when loading site-init and rep-defaults files - Don't use `""' to denote a null doc string (which has bad side effects when internationalized) - Don't need to run `sawfish-client -' to get a repl anymore, just `sawfish-client' - Fixed bugs in `composite-images' function - Fixed ordering of states output by `gtk-style' program (michaelj@maine.rr.com) - Fixed grabbing mono window icons in gdk-pixbuf mode - Reject button event descriptions that don't specify at least one mouse button - Accept `()' as a valid image modifier color component - Now grabs translatable strings from `defgroup' forms correctly 0.34 ==== * Added a virtual modifier key, the `W-' modifier. This modifier is used for all standard window-manager key bindings, it may be set to any of the standard X modifiers using the configuration tool * Optionally show window-icons when cycling through windows (Unai Uribarri Rodríguez, me) * Event handlers for low-level X windows now get passed the window as their second argument (Unai Uribarri Rodríguez) * Translation updates: fr (Christian Marillat), sv (Richard Hult), pt_BR (Flávio Bruno Leitner), it (Michele Campeotto) * Error handler module (`sawfish.wm.ext.error-handler'). When loaded it records the most recent errors, and the time at which they occurred. Use the `display-errors' command to display all recorded errors. * Added an option to not save window-history data for transient windows. Also added a `window-history-clear' command to forget history for all windows. * Rearranged window operations menu to hopefully be clearer * Attempt to catch and handle errors while loading custom options * Labels in menu items can now be functions, they should return the label text when called (with any menu arguments) * Moved installed message catalogues to $datadir/locale * `defcustom' forms may now a `:widget-flags' keyword, a constant list of symbols passed to the configuration tool. Current flags include: `expand-vertically' and `expand-horizontally' * Added a `sawfish.wm.util.ping' module, it implements the `_NET_WM_PING' protocol of the new window manager spec. * `destroy-notify-hook' is no longer called asynchronously * Bug fixes: - Fixed various bugs when dragging/resizing windows - Reverted the changes to make the click-to-focus click-through setting apply to window decorations - Fixed bug when handling 32-bit data in client messages and X properties - Fixed window-focus problems when switching viewports - Many bug-fixes to handling of maximized window state. Maximized state should now be preserved across wm and session restarts. It's also saved in the window-history attributes - Support the function hints of the MWM window manager properties - Updated the `sawfish.wm.state.wm-spec' module to match the current (almost final) draft of the new GNOME/KDE window manager spec - Fixed sporadic stacking bugs when unmapped windows exist - Fixed miscellaneous click-to-focus and focus-click-through related bugs 0.33 ==== * Added support for user-levels associated with individual commands * The GNOME hints code now understands that the do-not-cover flag is the same as sawfish's `avoid' property * Swap properties of sticky windows when entering and leaving workspaces as for normal windows (fixes the old problem where sticky windows can grab focus when a workspace is entered) * Changed the default settings of some customization options, hopefully to give a more "conventional" feel for new users * Better support for Xinerama (Geoff Reedy) * Added a new set of window stacking commands: `raise-window', `lower-window', `raise-lower-window'. The set of windows affected by these commands is determined by the `user-raise-type' (either the individual window, the window and any transients, or the entire group). The old commands of these names are now called `FOO-single-window'. Most modules now use these commands when raising or lowering windows, allowing the stacking model to be configured globally. * Translation updates: no (Kjartan Maraas), fi (Antti Ahvensalmi), it (Christopher R. Gabriel), pt_BR (Douglas Moura Ferreira), uk (Yuri Syrota), de (Matthias Warkus) * Fixed bugs: - If committing changes in the configurator causes new customization options or groups to be added, update the UI to reflect this - Added code to detect and correct the sporadic bug where windows become unfocusable in click-to-focus mode - Sanitized how the focus gets passed to and from transient windows (when passing focus back from a transient, give it to the most recently focused window in the group, not the transient's parent) Also, try to avoid displaying maximize buttons in windows whose hints prevent them from being maximized - Many fixes to how maximized windows are handled across session and window manager restarts. Also support GNOME window maximized hints when windows are created - Fixed some bugs in the `wm-spec' module - Don't trigger auto-raise hooks on leave/enter events generated by pointer grabs - The `edge-flip-delay' option now applies when dragging windows - Fixed the preview command in `sawfish-themer' - Miscellaneous fixes to the "smart" window placement modes - Fixed type description of `persisitent-group-ids' option - In `enter-exit' focus mode, focus isn't removed due to enter/leave events due to pointer grabs (fixes the bug with Mozilla URL completion) - Fixed (again) the `focus-click-through' behaviour with respect to frame decorations - Re-added hack to make GMC icons unfocusable - Fixed interactive placement to check for window destruction (merlin) - Fixed bug with tiled images with shapes (the shape mask would always be applied an integer number of times, ignoring the size of the frame part it's associated with) - Fixed `window-wants-input-p' to check if the `InputHint' is set before reading the value 0.32 ==== * `M-TAB' window cycling now works in both directions, bind keys to `CYCLE-COMMAND-backwards', e.g. `cycle-windows-backwards' (Merlin, me) * Added support for X `Urgency' hint: `window-urgent-p' and `window-state-change-hook' is called with `urgency' state when it changes * Some improvements to `shade-hover' mode (adapted from Eli Barzilay) * Functions that raise/lower groups of windows now generate the minimum number of expose events (Rob Hodges, me) * New window property `window-list-skip'. Unified with GNOME skip-winlist hint * Custom options may have tooltips, use `:tooltip' tag * Catch errors when applying custom changes and revert to previous state * Translation updates: uk (Yuri Syrota), pt_BR (Douglas Moura Ferreira), hu (Róbert Ványi), de (Christian Meyer), ja (SATO Satoru), da (Keld Jørn Simonsen), es (Iñaki García Etxebarria), fr (Christian Marillat) * Fixed bugs: - With click-to-focus in non-click-through mode, don't click-through into window decorations - `dimensions' property in window matching was called `size' by mistake - Export the various `sp-cost:' functions from the `sawfish.wm.placement.smart' module - Don't allow cycles in the transient-for relationship - Fixed some maximize bugs - GNOME skip-focus property no longer causes the window to be unfocusable, just uncyclable-to - Coerce auto-raise timeout to be at least one millisecond; support `disable-auto-raise' correctly - Window input hints defaults to true not false - Fixed typo when loading the defaults file (Ronald Wahl) - Fixed command spec of `move-window-FOO' commands (Yoshiki Hayashi) - When sending `WM_TAKE_FOCUS' message, only focus the window if its `Input' hint is set 0.31.1 ====== * Translation updates: da (Kenneth Christiansen), de (Christian Meyer), no (Kjartan Maraas), pt_BR (Rui Miguel Silva Seabra), sv (Johan Dahlin), uk (Yuri Syrota) * Bug fixes: - Fixed typos in `sawfish.wm.gnome.integration' and `sawfish-themer' (Christian Marillat) - Fixed bug when building on Tru64 (John H. Palmieri) - Remember to check return value when initializing Imlib 0.31 ==== * Requires librep version `0.13' * Organized all lisp code into a hierarchy of modules. Root points are `sawfish.wm' for window manager code, `sawfish.ui' for configurator and `sawfish.gtk' for GTK+ utilities Compatibility should have been preserved as far as possible, through the use of module aliases. The `user' module that unmodularized user code is loaded in should look very similar to the old environment. However, code using private functions, probably will not work New features written as modules can either import modules individually, or just open `sawfish.wm' to get the core functionality * All command handling is now written in Lisp. It's fully compatible except for how commands are defined. Since there is no longer a unified namespace the mapping from names to command definitions is maintained separately. `define-command' and `autoload-command' add entries to this mapping. `define-command' takes a name and a function (and some other optional arguments). The old style of defining commands still works, but only in the user module * `sawfish-client' now provides the same repl as the normal `rep' program. E.g. this allows the module system to be easily inspected Also, the module of each loaded theme is available for inspection under `themes.THEME-NAME'. (With themes using top-level defines instead of a single `let*' block, this is useful for debugging) * `sawfish.client' module provides lisp functions for communicating with a running window manager. Also, the protocol has been modified to support proper communication of errors, which are then re-raised on the client-side. This should make debugging client-server code more obvious * `Action' parts of menu items may now be lisp objects that don't have a read syntax. (E.g. this allows closures to be used, avoiding the problems arising from modularization) * Support for checked and radio-group menu items. Also a new function `add-window-menu-toggle' to add items to the `Toggle' sub-menu of each window * Handle `ConfigureRequest' events in a way that is compliant with the ICCCM--honour the window's `win_gravity' setting (defaulting to `NorthWest' gravity), instead of assuming `Static' gravity * Support more GC attributes in the `sawfish.wm.util.x' plugin (Ryan Pavlik) * Support for handling arbitrary windows as extra "root" windows. Used, e.g., to support Nautilus' desktop window. Allows the focus modes to work correctly To support this, new window property `desktop' denoting a "desktop" window; new function `desktop-window-p' recognizing one of these things (or the symbol `root') * Added `pointer-motion-threshold' option. Pointer motion events are only generated when the pointer moves at this many pixes away from the position it had when the button was pressed * New functions: `scale-image', `composite-images', and `crop-image'. * New option `maximize-avoid-avoided' (Jonas Linde) * New functions exported by `sawfish.wm.ext.tooltips' module: `display-tooltip', `remove-tooltip' * New function exported from `sawfish.wm.viewports' module: `select-workspace-and-viewport'. Renamed some workspace functions: `ws-move-window' => `move-window-to-workspace', `ws-copy-window' => `copy-window-to-workspace', `ws-insert-workspace' => `insert-workspace', `ws-move-workspace' => `move-workspace', `ws-remove-window' => `remove-workspace'. * Changed interface of `get-visible-window-edges' function to use proper keyword parameters, and added some new keywords * New commands `help:about' and `gnome-about'. Added a `sawfish-about' script to implement the first of these. Added associate menu items to the `Help' menu * New window property `cycle-skip', defines whether the window is included when cycling the focused window. (Dave Dribin, me) * Translation additions and updates: es (Iñaki García Etxebarria), tr (Fatih Demir), zh_CN.GB2312 (zw@zhaoway.com), fr (Christian Marillat), ja (SATO Satoru), de (Kai Lahmann), el (Simos Xenitellis), ga (Seán Ó Ceallaigh), ru (Valek Filippov), sl (Andraz Tori) * Bug fixes: - Don't let errors in `.sawfishrc' prevent customization settings being loaded - initialize event handler when creating X window proxies (Matt Tucker) - No longer able to `throw' out the top of the program by mistake - Fixed `find-head' function, to allow Xinerama support to work - When exiting, leave window configurations exactly as they were found (E. Jay Berkenbilt) - Fixed `synthesize-event' to scan the window tree for a child window accepting button events (E. Jay Berkenbilt) - Removed "yow! ..." debugging messages - `image-set' and related functions will add an alpha channel to the image when necessary (when using gdk-pixbuf) - Canonify `S-x' as `X' where possible - Catch and handle errors when matching properties in the `sawfish.wm.ext.match-window' - Escape underscores in menu items where they shouldn't introduce accelerators. (Added `quote-menu-item' function to help with this) - Fixed race-condition when exiting configurator embedded into the GNOME control center (Havoc Pennington, me) - Fixed bug in `set' method of the `icon' widget - Fixed shading behaviour of included themes (Daniel Lundell) - Compute the shape of the frame window each time the background of one of its parts changes 0.30.3 ====== * If a frame part has a non-nil `hidden' attribute, ignore it * When reframing windows, keep the absolute position of the client window constant * Support `FIXED_POSITION' GNOME hint (renamed old `fixed-position' property as `client-set-position'; `fixed-position' now means don't allow the window to be moved by the user) * `transients-above' option can now be set per-window * Translation updates: fr (Christian Marillat), en_GB (Robert Brady), de (Kai Lahmann), da (Keld Simonsen), ru (Valek Filippov), sl (Andraz Tori), no (Kjartan Maraas), gl (Jesus Bravo Alvarez), it (Michele Campeotto) * Fixed bugs when converting option values * Fixed `:require' keyword in `defcustom' always causing the module to be loaded, not just when the option is non-nil * Fixed bug when adding windows that are shaded * Fixed some minor bugs in the configurator 0.30.2 ====== * Window cycling now forwards terminating events to external applications as well as internal bindings (e.g. `M-TAB M-w' closes an activated Netscape window) * `quote-event' command now works with applications that ignore synthetic events (adapted from code by Timo Korvola) * Reorganized frame style and window type management. New function `define-frame-type-mapper' allows modules to affect the mapping from window type to frame type. E.g. the shading module uses this. (fixes the bug that changing the frame type of a shaded window didn't work) * Added function `variable-customized-p'; use this to avoid redefining user-modified options * Do type-directed deep conversion of values when converting to/from readable representations. This fixes the bug that options with `:type (optional color)' weren't being converted when passed between the wm and the configurator, leading to reader errors A side-effect of this is that updated custom files will not be compatible with previous versions of the wm (though old custom files will work with new versions) * Translation updates: no (Kjartan Maraas), de (Kai Lahmann), nl (Dennis Smit), sl (Andraz Tori) * Added primitives `map-windows' and `filter-windows' * Fixed bug of not retaining focus on startup when originally in PointerRoot mode and moving to click-to-focus mode (Brad Thompson) * Ensure that apps get sent a synthetic ConfigureNotify event after ConfigureRequest events are handled (fixes bug where menus in Java apps can appear at wrong position until window is moved) * When referencing known variables from subroutines, make sure that restricted environment doesn't prevent the variable being accessed (fixes bug where `default-bevel-percent' was being ignored) * When creating transient groups, don't compare null group ids (fixes xfmail related bugs) * Fixed `move-window-to-viewport' command to correct for 1... indexing * Fixed non-gnome workspace widget in configurator 0.30 ==== * New commands `activate-viewport-column', `activate-viewport-row' * New commands `raise-window-and-transients', `lower-window-and-transients' and `raise-lower-window-and-transients', `raise-transients-and-pass-through-click'. As the normal window stacking commands, but restacks the "transient-group" of the window. This includes the window itself and any transients it has, and any windows that it itself is a transient of. These commands are used in the default keymaps * Functions that deal with transient windows now understand the de facto standard of setting the `WM_TRANSIENT_FOR' property to the root window denotes that the window is a transient for the whole group * New image manipulation functions: `image-ref', `image-set', `image-fill', `image-map'. New color accessor function `color-rgb-8'. New function `root-window-id' * Improvements to `sawfish-ui': optionally use some GNOME widgets, more lisp widget types, some bug fixes * New command `command-sequence'. Allows individual bindings to invoke a sequence of commands * Options `iconify-group-mode' and `uniconify-group-mode' replace `iconify-whole-group' and `uniconify-whole-group'. New commands `iconify-transient-group', and `uniconify-transient-group' * Added `:type*' key to `defcustom', like `:type', but value is left unquoted * Translation updates: pl (Daniel Koc), ru (Valek Filippov), uk (Yuri Syrota), es (Iñaki García Etxebarria) * Fixed handling of `WM_NORMAL_HINTS' (was using base-size instead of min-size in places) * Fixed further locale / FontSet bug (Tomohiro KUBOTA) * `window-history' module won't resize a window to a size that violates its size constraints 0.29 ==== * Rewrote the configuration user interface. Improvements include: - Key bindings may now include parameters. E.g. this finally allows shell commands to be bound to keys using the GUI (use the new `run-shell-command' command) - Nautilus-like user-levels to tailor the options shown to the expertise of the user - Options may have much richer type descriptions (including `match-window' options). Also, extra widget types and containers may be added as extra Lisp modules - By default the stand-alone configurator commits changes to the window manager as they are made, instead of waiting for the `Try' button to be pressed - Added dependences--options with dependences are only editable when the value of their dependence is non-`nil' * Rewrote window stacking code to be based on "stacking predicates"--functions that accept or reject a possible stacking configuration. This allows the "stack-transients-above-parents" option to work correctly, only keeping transient windows above their _own_ parent windows * The configure-event handler now understands and handles the full complexity of stacking requests (Brad Thompson) * New frame-part attribute: `scale-foreground'. The `cursor' attribute may now be a function * Made the `centered', `centered-on-parent' and `under-pointer' placement modes clamp the window into the current work area (i.e. without overlapping windows that shouldn't be covered). Added a `stagger' placement mode * When grabbing window icons to images, preserve their shape masks * Moved `window-history' options to `placement' group. Fixed some more bugs and sub-optimal default option values * Don't set cursors for button classes, use the default value * GNOME `SKIP_FOCUS' window hint sets `never-focus' property on window, as well as the `ignored' property * Translation updates: de (Karl Eichwalder), ru (Valek Filippov), da (Kenneth Christiansen) * Added mostly-complete support for using gdk-pixbuf instead of Imlib (requires an experimental Xlib version of the gdk-pixbuf library) * Various bug fixes and other minor changes... 0.28.1 ====== * New options `--visual=TYPE' and `--depth=DEPTH'. These tell the window manager to use a different visual than the default * Made the `window-history' module behave more sanely (don't save iconified or shaded state; include window name when generating keys for transient windows) * Made `beos-window-module' the standard window menu (require `old-window-menu' to get the original version). Also made this display the windows' class names * Updated translations: es (Iñaki García Etxebarria), tr (Fatih Demir) 0.28 ==== * New module `window-history'--automatically saves window attributes when they are explicitly set by the user, then copies these attributes to windows with the same `WM_CLASS' as they are created. This is loaded automatically if you have no `.sawfishrc' * New method of allowing themes to implement only some of the (currently) four frame types. The variable `frame-type-fallback-alist' maps each frame type to the type to try if the original type isn't available in the chosen frame style. Note that for this to work, themes must return `nil' when they don't support the requested frame type, until now, the convention had been to return the default frame definition, so most if not all themes will need changing. (This doesn't include themes created using the `make-theme' module.) * Made the metrics used by the `best-fit' placement mode user-controllable. Set the `sp-cost-components' variable to a list of cost functions and the weight to apply to that metric. E.g. by default it gives 50% importance to the distance from the placement to the focused window, and 25% each to the distance to the pointer and to the "future-unusefulness" of the area being covered * New module `beos-window-menu' to redefine the window menu to group items by the window group that they are a member of (in the absence of actual group information, it will heuristically build groups by matching window titles) * New option `edge-flip-warp-pointer', whether or not to warp the pointer after edge-flipping (Paul Warren) * New option `display-window:uniconify-to-current-workspace', controls whether windows uniconified by `display-window' should be moved to the current workspace (John N S Gill) * Changed method of selecting when to use multi-byte aware rendering functions (except when initializing the locale fails, or returns a 7-bit locale); also, when creating a fontset fails, try to intelligently fall back to a similar group of fonts (Tomohiro Kubota) * The `x' library now supports creating and then drawing to pixmaps. The pixmaps can then be grabbed to images using the `make-image-from-x-drawable' function * Added a `Help' item to the root menu * Translation updates: fi (Antti Ahvensalmi), gl (Jesus Bravo Alvarez), de (Karl Eichwalder), nl (Jan Nieuwenhuizen), pl (Daniel Koc), tr (Fatih Demir) * Now supports the `Super' modifier * Fixed bug of sometimes ignoring pending X events * Fixed bug of calling focus change hooks too many times (only when our view of the focused window has actually changed) * Avoid problems when windows set weird size hints structures * Raise windows _after_ possibly moving them to a different layer, when they have been mapped * When the `cycle-windows' sequence is terminated by an unknown event, re-handle that event after exiting (so that e.g. `M-TAB' can be followed by another `M-' qualified event without releasing Meta) 0.27.2 ====== * Translation updates: da (Kenneth Christiansen), de (Karl Eichwalder), es (Iñaki García Etxebarria), ja (SATO Satoru) * Attempt to destructure the language code when parsing GNOME desktop items (e.g. if `LANG=de_DE' look for both `de_DE' and `de' translations) * New focus handler events `enter-root' and `leave-root' * Removed `raise-groups-on-focus' option, it caused unstable window flickering in certain cases * Fixed bug When transferring focus after a window is unmapped (inverted choice of when to look under pointer, and when to look in focus history) 0.27 ==== * Changed the name from `sawmill' to `sawfish'; all user-visible binaries have been renamed appropriately, the old programs will still work for now... * Added support for accelerators in menu definitions (this requires a new rep-gtk package) (Richard Kilgore). Added accelerators to many of the standard menu items * Added some (untested) support for Xinerama: `current-head', `current-head-dimensions', `current-head-offset'. Some placement modes should handle multiple heads sensibly, as should window maximization and edge snapping. * Added icons for GNOME control center applets (all icons by Tigert, except for the saw-blade logo by Glyph Lefkowitz) * New functions `map-window-properties' (me), `window-icon-image' (Bruce Miller) * Changed behaviour of `raise-group' and `lower-group' to preserve the stacking of the group, then change the selected window. Added new command `raise-lower-group' * New option `raise-groups-on-focus' * Updated translations: de (Hubert Nachbaur), es (Iñaki García Etxebarria), gl (Jesus Bravo Alvarez), ko (Man-Yong Lee), tr (Fatih Demir) * Try to handle errors more gracefully when creating window frames * Better handling of errors in the control center applet * Fixed the `below-client' frame-part attribute * Fixed the disappearing items in the match-windows dialog * Fixed the non-beautified entries in the keymaps dialog * Fixed interactive placement mode (Timo Korvola) * Invoke audio playing program asynchronously, may avoid deadlocks * Fixed `workspace-menu' to add the focus-marking asterisk (John N S Gill) * Fixed menu-obscuring bug after auto-raising windows * Ensure that `WM_STATE' property is set each time a window is mapped, not just the first time * Fixed bug when discarding grab in click-to-focus mode, even though successive events may be in the window's keymap * Only focus windows when they're mapped when they're visible * Fixed click-to-focus problems when unmapping transient windows 0.26 ==== * Added plugin `selection', adds functions `x-selection-active-p' and `x-get-selection' for retrieving X selections (Mark Probst) * New functions `prompt-for-window', `prompt-for-workspace' and `select-workspace-interactively' (Dave Pearson) * `window-anim' module enabling asynchronous animations after window events. Currently only two animation styles `wireframe' and `solid', and they only animate window iconification * `audio-events' module; maps window manager events to audio samples (played using esd by default, but can be configured to use any program) * When running programs in terminals from the GNOME apps menu, use the value of `xterm-program' to decide which terminal program to use (James Antill) * Translation updates: gl (Jesus Bravo Alvarez), pl (Daniel Koc) * New command `toggle-window-iconified' (Jens-Ulrik Petersen) * New option `raise-windows-when-unshaded' * Customization options for tooltip colors (Erik Assum) * Removed default binding to `A-x' * Added support for librep-with-module-system (cvs version) * Note that `ko' and `zh' languages need FontSets * When sticking a window not on the current viewport, move it to the current viewport (Merlin) * Fixed bug (?) of placing over avoided windows in `random' mode; also increased `sp-avoided-windows-weight' by an order of magnitude (Dan Winship) * Fixed bug of maximizing a window changing its viewport * Fixed window cycling losing grab if originally focused window is unmapped * Fixed `get-cursor' to use the correct background color when creating cursors from vectors (Alexander Barinov) * Fixed `get-font' to set `descent' property correctly * Changed double-buffering semantics in `x' plugin, also only support this if configure finds the correct header files * Fixed `synthesize-event' to generate correct relative pointer positions * Don't focus on non-visible windows (crashes GNOME control center) * Fixed bug of using `cp' to install GNOME desktop files 0.25.2 ====== * If no user customization file when saving options, inherit from the custom-defaults file * Rewrote window stacking (fixes bugs, more efficient) * Added `input-focus' to theme-callable functions * When focused window is unmapped, don't try to focus non-visible windows * Fixed `display-window' when it's applied to iconified windows * New variables `fonts-are-fontsets' and `fontset-languages-re' to work around broken X servers * Update edges for snapping to when dragging windows across workspaces or viewports * When passing keymaps to customization system, filter out, then later restore, bindings that aren't symbols * Most commands to move/copy windows between workspaces can now be told whether to select the destination workspace or not * In GNOME hints, never place windows on workspaces that don't exist (from the pager's POV). (Rob Hodges) * Fixed `ws-move-window' to not remove the window if source and dest are the same (Rob Hodges) * Fixed `sp-prune-points' function (Dan Winship) * Fixed `move-viewport-to-window' to only flip viewports if window isn't already on the current viewport (Merlin) * Try to detect and handle system clock being rewound * Optional second arg to `x-raise-window'; added symmetrical function `x-lower-window' * Fixed unix-domain server code assuming atomic writes to sockets * Added double buffering support to `x' module * Fixed grabs during multi-key sequences; also, print the current prefix keys if idle during a multi-key sequence 0.25.1 ====== * Only force windows onto the visible screen if they didn't explicitly set their position * Redefine `/' in themes to be the `quotient' function (integer division), which is what they expect. The `divide' function can be used for real division 0.25 ==== * New plugin `x', a basic Xlib binding for creating and drawing in windows (Merlin, me) * Added a method of reading textual input from the user from completion. Provision for completing functions, variables, commands, files, directories, etc.... Also supports reading passwords. (Topi Paavola, me) * Re-enabled the following interactive codes: `a' (function), `C' (command), `D' (directory), `f' (existing file), `F' (file), `k' (event), `n' (number), `N' (prefix or number), `s' (string), `S' (symbol), `v' (variable) * Support prefix keys in bindings (binding an event to a keymap, or the name of a keymap, marks that event as a prefix key for the associated keymap) * New command `call-command-with-output-to-screen', prompts for and invokes a command, then displays any output it emitted (bound to `A-x' in default keymaps) * New variable `multi-click-delay', maximum time in milliseconds between button presses to count as `click2' or `click3' events (Martin Blais) * New option `edge-flip-only-when-moving' (Yaron M. Minsky) * New window cycling commands `cycle-prefix', `cycle-class' (Kai Großjohann); can now be bound to events with more than one modifier (Timo Korvola) * New command `uniquify-window-name'; new property `unique-name'. Forces the window to have a unique name * New commands `size-window-add-column', `size-window-subtract-column', `size-window-add-row', `size-window-subtract-row' * Window edge snapping now has three variants: `magnetism' (the old method), `attraction' and `resistance'. (Merlin, me) * New commands `grow-window-{left,right,up,down}' and `pack-window-{left,right,up,down}' (Kai Großjohann) * Support the `WM_COLORMAP_WINDOWS' protocol * New functions `synthesize-event', `font-ascent', `font-descent', `call-with-keyboard-grabbed' * New functions `define-placement-mode' and `define-focus-mode'--make defining these things easier. Focus modes are now settable for each window individually * Made the tree-organised customization groups work better with the GNOME control center. Add the sawmill capplet desktop entries to the GNOME programs menu (under Settings). Also, beautify the names displayed in the bindings widget * When applicable, load the GNOME applications menu when the wm is first idle, reduces the latency of displaying the first root menu * Translation updates: de (Hubert Nachbaur), es (Iñaki García Etxebarria), ja (Sato Satoru), sv (Andreas Persenius) * Fix bug of not noticing when the keyboard / pointer / modifier mappings change * Fixed `current-event-string' function * Better method of reconfiguring frames when they're resized (helps opaque resizing) * Added some kludges to try and break the intermittent lockups some people have seen * Made the auto-gravity option work a lot better (John N S Gill, me) * Fixed bug where unmapped windows were being included in the snapping calculation * Fixed bug when uniconifying windows and merging workspaces * Fixed bug of warp-cursor-to-window trying to put the pointer outside the screen boundaries (Merlin) * Fixed bug of losing keyboard grab when originally focused window is deleted during `x-cycle' command * Fixed bug of trying to focus unviewable parent windows when focused window is unmapped 0.24 ==== * Configure requests events are now passed to the hook `configure-request-hook'. The new configure handler respects window gravity when resizing * New option `configure-auto-gravity'. When enabled the window gravity is implied by the position of the center of the window. (e.g. try placing the GNOME control center in the bottom right corner of the screen, then click on an item that causes it to resize) * Worked around the numerous reports of non-existent font errors that using `XCreateFontSet' causes--fall back to `XLoadQueryFont' if possible * There's now a library `custom-defaults' giving default customization options (only if the user has no `~/.sawmill/custom') Also, remove the need to call `custom-add-required' in `.sawmillrc', it's always done now * New window properties `focus-when-mapped', and `gravity' (overrides the hinted gravity value) * New placement modes `under-pointer' and `centered-on-parent' * New option `resize-edge-mode', replaces `resize-by-frame-class' and `resize-add-edges'>. Also allows twm-style resizing (Mark Probst, me) * Optionally display command documentation in tooltips; tooltips are now aligned into columns (if you use a monospaced font for them) * Variables `default-cursor', `synthetic-configure-mutex', `frame-draw-mutex', `frame-state-mutex' are now functions * New functions `x-keysym-name', `x-lookup-keysym', `decode-event', `encode-event'. * New option `move-resize-inhibit-configure' * Translation updates: es (Iñaki García Etxebarria), fr (Christian Gillot), gl (Jesus Bravo Alvarez), nl (Han-Wen Nienhuys), pt_PT (Rui Silva), sv (Andreas Persenius) * Fixed single-quoting in client readline (Matt Krai), copied bouncing parentheses hack * Removed `fp->win == 0' assertion, it should be harmless and was triggering for some people * Fixed bug of sending configure notify events to too many windows * Fixed off-by-one error in `ws-insert-workspace' (Kirk Saranathan) * Fixed maximization in single directions to work additively * Fixed bug of leaving tooltips displayed after the associated window has been deleted * Fixed bug of not removing `-clientId' option from restart parameters * Fixed bug of not translating customize group names 0.23 ==== * Customization groups are now organized as a tree structure, with groups able to contain subgroups * Define the list of features that will be presented to the user in `sawmill-defaults.jl', by calling `custom-add-required'. If you have a `.sawmillrc' you'll need to do this manually * New function `move-resize-window-to' doing a combined move/resize. New variable `synthetic-configure-mutex', when set holds off sending synthetic `ConfigureNotify' events to windows until it's unset (this is held while interactively moving or resizing windows) * New hook `after-add-window-hook'. Called with a single parameter, the window that's has just been adopted * New functions `x-kill-client', `delete-window-safely'. `send-client-message' now groks long integers (i.e. cons cells) in 32-bit data (Timo Korvola) * `window-put', `window-get', `image-put', `image-get', `font-put', `font-get': use `equal' to compare keys, not `eq' * New module `error-handler', implements a simple alternative error handler (and allows the much-maligned beep to be turned off), requires rep 0.11+ * Allow the pointer-warp position to be defined relative to the window (Kai Großjohann) * New module `shade-hover', unshades windows while the pointer is over them * Don't automatically warp to the new workspace when opening windows on a different workspace * Include iconified sticky windows in the `window-menu', shorten sticky entries as usual (James Antill) * Support the `TryExec' field in GNOME desktop files (Ian) * New commands: `raise-or-pass-through-click', `raise-and-pass-through-click-if-focused' * New module `move-cursor', various commands for moving the mouse pointer; these commands are bound to the cursor keys when moving or resizing windows * Translation updates: es (Iñaki García Etxebarria), fr (Fabien Ninoles), gl (Jesus Bravo Alvarez), ja (Satoru Sato), nl (Jan Nieuwenhuizen), tr (Fâtih Demir) * Fix bug of leaving window-name unset when `WM_NAME' is a null text property * Don't fail catastrophically if unable to open the default font * Fixed method of truncating maximized window dimensions * Fixed the match-window `skip-winlist' and `skip-tasklist' properties I'd stupidly broken * Fixed bug of trying to edge-flip sticky windows * Fixed the `move-workspace-forwards' and `move-workspace-backwards' commands * Fixed `uniconify-to-current-viewport' option * Fixed infinite-loop bug in `delete-empty-workspaces' command * Avoid generating empty sub-menus when reading GNOME menu tree 0.22 ==== * Window frame parts are now first-class lisp data objects, allowing a higher level of control by themes New or updated functions to access frame parts directly: `frame-part-get', `frame-part-put', `frame-part-window', `frame-part-x-window', `frame-part-position', `frame-part-dimensions', `frame-part-state', `map-frame-parts', `refresh-frame-part', `rebuild-frame-part' Other new functions: `refresh-window' * Updated `sawmill-themer' to emit code to tell the window manager that the theme is editable. The wm adds an `Edit Theme...' option to the Customize menu when appropriate * The `call-after-property-changed' function can now be given a list of properties to monitor (James Antill) * New function `call-after-state-changed', monitors a list of window states (i.e. things like iconified, shaded, ...) and calls a function when any of them change. The `window-state-change-hook' now has a second argument (apart from the window), the list of symbolic states that changed (James Antill) * Add support for `skip-winlist' and `skip-tasklist' to the window matcher when GNOME support is enabled (Ben Liblit) * Integrated patch supporting multi-byte languages from the Kondara MNU/Linux distribution (forwarded by Yukihiro Nakai) * Translation updates: de (Christoph Rauch), es (Iñaki García Etxebarria), gl (Jesus Bravo Alvarez), ja (Satoru Sato), tr (Fâtih Demir) * Use a combo box in the configurator to display the list of themes (it gets given scroll bars when too big for the screen) * Changed timestamp handling--attempt to detect and discard timestamps that arrive out of order * Added option controlling title justification to `mono' theme * Filter modifiers as well as the other lock modifiers (Matt Krai) * Fixed `display-message' function update background color, and gracefully handle invalid color specifiers (Matt Krai) * Reverted to grabbing events on the client window, not the frame, avoids some awkward-to-fix-correctly problems * Load i18n support _before_ other libraries; ensures that some static strings get translated * Fixed annoying flicker when cycling to an iconified window 0.21.1 ====== * Fixed problem causing spurious double-click events to be reported in click-to-focus mode * Fixed problem with binding `-Off' events in the `window-keymap'. (Matt Krai) * Don't try to grab non-existent keys (which actually grabs the entire keyboard) * Fixed some problems with reading unusually formatted GNOME menu entries 0.21 ==== * Frame pattern definitions (foreground, background, font) may now take alists as well as the old single object, or list of four objects. Possible states are `inactive', `focused', `highlighted', `clicked', `inactive-highlighted', `inactive-clicked'. (Last two are new) * New program `sawmill-themer'. A GUI for creating simple themes (those without any parts defined by functions) * New module `gnome-int', loaded by `sawmill-defaults' if GNOME is around, sets up some GNOME'ish things * New command `toggle-single-window-mode' * Translation updates/additions: de (Christoph Rauch), es (Iñaki García Etxebarria), nl (Han-Wen Nienhuys) * Optional removal of tooltips after time period (Morgan Schweers) * `Any-RET' completes interactive move or resize * Work around Imlib's annoying image caching, `make-image' now _always_ returns a new image * Fixed gc bug when building window frames * Fixed X property handling on Alpha's (George Lebl) * Make `call-command' accept closures * Make `(cursor . nil)' work correctly in frame definitions * Grab on frame window, not client window (ICCCM compliant) * Fixed the "uniconify to current workspace" option * Added window-maximization predicates to the gaol 0.20 ==== * Rewrote workspace handling--windows can now appear on multiple workspaces, with each instance having different properties (position, size, whatever...) Create new window instances by using the `copy-to-next-workspace', `copy-to-previous-workspace', and `copy-to-workspace:N' commands. Merge instances by moving them to the same workspace, or using the `delete-window-instance' command * Added linear-viewport commands--indexing two-dimensional virtual workspace areas by one-dimensional values (adapted from code by Eric Kidd) * Rewrote tooltips; especially how they're removed (also, don't show null keymaps) * Added new match-window property `ungrouped'. Means to put the window in a group on its own * Translation additions/updates: da (Wandy Christiansen), en_GB (me), es (Iñaki García Etxebarria), fr (Christian Gillot), gl (Jesus Bravo Alvarez) * Fixed bug of not refocusing unshaded windows * Fixed bug of not notifying windows of their actual position after placing them * Fixed bug when grabbing Hyper-modified buttons * Fixed the focus-flickering when moving windows opaquely * Fixed the `commandp' function when applied to autoload stubs * Fixed typo in `gnome-logout' command (Jens Finke) * Fixed `raise-window-and-pass-through-click' command to pass , etc, events through to frame parts * Fixed infinite-regress bug when reading GNOME menu entries (`Type=directory', but actually a file) * Fixed bug when showing window-move position with snapped movement (adapted from merlin@merlin.org) * Fixed bug when matching null text properties 0.19 ==== * Added tooltips for window frames (disabled by default) * Added `Grab...' button to match-windows dialogue, grabs the value of an X property from a window * Support for creating cursors from bitmaps, and for changing the colors of cursors * Internationalized all strings in the configurator * New functions: `frame-part-get', `server-grabbed-p', `forget-button-press', `resize-window-with-hints', `window-in-workspace-p', `windows-share-workspace-p' * New window properties: `never-focus', `raise-on-focus' * New pseudo-property (for window matching): `size', in terms of the window's size hints * Message catalogue additions/updates: Galician (Jesus Bravo Alvarez); Danish (Birger Langkjer) * Don't ignore initial state property of windows * Option to control height of drawn bevels (Chris Hanson) * More logical method of drawing diagonal gradients (Chris Hanson) * Fixed typo when looking for i18n theme README files (Jesus Bravo Alvarez) * Fixed `popup-apps-menu' command (Gérard Milmeister) * Fixed `define-frame-class' when creating keymaps * Fixed conversion of old-style `(set ...)' custom types * Fixed `raise-window-and-pass-through-click' command to pass-through subsequent clicks * Fixed problems when grabbing/ungrabbing customized keymaps * Fixed screen corruption when doing wireframe moving and `move-resize-raise-window' is set * Hacked around window-order problem when sticky windows exist 0.18 ==== * General subsystem for matching windows to properties as they're created. Allows matching on one or more of the window's X properties (e.g. name, class, etc...), and then setting any number of window manager properties as a result. See the `Matched Windows' customize group * Removed all `auto-FOO-alist' and `BAR-windows-re' variables, they're obsoleted by the general match-windows mechanism * Respect window's size hints when maximizing (both to see if the window is maximizable, and to truncate the maximized dimensions to an integral number of rows and columns) * Show actual colors in the configurator, not just their names * Added a new directory to the theme search path: `PREFIX/share/sawmill/themes'. Use this for system-wide themes (don't use the version specific directory) * Included a new theme `mono' * Deprecated the `show-message' function, replaced by `display-message' with a better calling interface; also displays multi-line strings * Deprecated the menu "expand variables when first in list" behaviour. Instead expand variables when the list is dotted to them, as is done for functions * Support the `Hyper' modifier, prefix is `H-' * In the configurator, look for i18n'd theme README files (Yukihiro Nakai) * Added option to disable the ability to grab a second edge while resizing (`resize-add-edges') * Included Danish message catalogue (Kenneth Christiansen) * Renamed `fixed-position' property as `sticky-viewport', and `focus-proxy-click' as `focus-click-through' * When evaluating mouse events, look in the window that the pointer was in when the button was pressed, not where the pointer currently is * Fixed bug where focus gets totally lost after closing a Motif application that has grabbed the keyboard * Fixed (again) the problems when handling remapped windows; also should be more ICCCM-compliant * Fixed typos in one-dimensional maximisation (Gérard Milmeister) * Fixed the logic deciding when it's necessary to switch workspaces after merging an empty one * Fixed interactive placement showing the window when edge-flipping (but it still doesn't work properly, rubber band traces are left) * Removed flicker when focusing already-focused windows 0.17 ==== * First version to use lexically scoped librep. This enables themes to run in a "safe" environment, but all existing themes will need to be ported; other language changes include the use of a single symbol namespace, and scheme-like function call semantics * Support for internationalization of messages and run-time documentation; an en_GB catalogue is the only translation currently, so please send me .po files for your native languages! New option `--disable-nls' to disable i18n * New functions `call-after-property-changed' and `gtkrc-call-after-changed' to allow themes to receive these events (hooks are now off-limits to themes) * New command `raise-window-and-pass-through-click'; bind it to a mouse button in the `window-keymap' to get the "raise window on click" behaviour that seems popular * New commands to move windows incrementally: `slide-window-X' and `slide-group-X' for X one of: `left', `right', `up', `down' * New commands to control `ignored' property of windows (Julian Missig) * New commands to toggle GNOME skip-winlist and skip-tasklist properties of windows * Respect window gravity with program-specified window placement () * Fixed a memory leak in the `stacking-order' function * Fixed the `bevel-image' function (Scott Sams) * Never look in the focused window's keymap by default with mouse events * Hacked around the "need an X11 connection to compile" misfeature * Fixed bug in `gnome-menu' code when GNOME binaries aren't in the first $PATH item; also accept non-alphanumeric language codes * Fixed interactive window placement (again) * Rewrote obscure documentation for some custom options * Fixed bug when grabbing events with `AnyModifier' and a specific button 0.16 ==== * Support window groups, both as defined by applications, and defined by the user (either interactively through the window's menu, or via the `auto-group-alist' and `persistent-group-ids' variables). For most commands working on single windows, there's also one operating on the group that the current window is a member of. (With the notable exception currently of moving windows.) There's also options controlling whether (de)iconification operates on windows or groups * Improved GNOME menu support--merge duplicate sub-menus, scan PATH for `gnome-share-directory', also look in `/etc/X11/applnk' for menu entries * Option to control whether edge-flipping flips viewports or workspaces (`edge-flip-type') * New hook `after-framing-hook': called whenever a window's frame is changed or recalibrated * New window placement mode: `first-fit-or-interactive' * Variables specifying common cursor shapes: (`move-cursor-shape', `resize-cursor-shape', `select-window-cursor-shape') * Fix interactive placement * Fix problem of window losing focus when `cycle-windows' only finds a single window; also, abort immediately if there's no windows to cycle through at all * Fix how the `WM_NORMAL_HINTS' property is read after it's been updated * Fix `maximize-fill' functions to respect the `maximize-ignore-when-filling' option * Fix interactive move/resize aborting if keyboard is already grabbed * Ungrab the keyboard as well as the pointer before popping menus 0.15 ==== * Changed how themes are loaded from tar files--the tar file must now contain a directory with the same name as the theme; it's this directory that stores the data files * Allow viewport edge-flipping to be enabled by the customization system, also enable flipping while moving windows * Unified the method of marking which windows should be avoided when maximizing, and which windows should be avoided when using the fitted placement methods. Set the `avoid' property instead of the `maximize-avoid' property; new functions `window-avoided-p' and `avoided-windows'; new regexp `avoided-windows-re' * New command `delete-empty-workspaces' * Default theme is now `microGUI' * When resizing only one edge of a window, moving the pointer past one of the perpendicular edges grabs that edge also * Only the first three buttons focus a window in click-to-focus mode * Changed behaviour of `window-id' and `window-frame-dimensions' functions. Replaced `query-last-pointer' function by `query-button-press-pointer' * New hooks: `while-moving-hook', `while-resizing-hook' * Notice when `WM_TRANSIENT_FOR' property changes * More bug fixes to the maximization code, mainly for efficiency; also make first-fit placement work from top-left again * Fix bug when matching events with `Any' modifier as well as other modifiers * Fix bug in `window-outside-viewport-p' (Andreas Degert) * Fix bug in `sawmill-client --' with long inputs * Fix bug when matching windows with session data--`SM_CLIENT_ID' or `WM_COMMAND' _has_ to match * Fix bugs when passive grabbing non-button-press pointer events 0.14 ==== * Rewrote window-maximization, many new options * New option `resize-by-frame-class', when enabled (the default), the resized window edges are chosen to match the class of the clicked frame part (i.e. matching the cursor shape) * Load GNOME support code automatically if it looks like GNOME is being used * Create unix-domain sockets in `/tmp' * New hooks: `window-moved-hook', `window-resized-hook', `after-initialization-hook', `shape-notify-hook'. * Improved how menus are displayed; the window-ops menu is shown by ButtonPress not ButtonRelease events * Refocus most-recently-focused window when switching viewport * Added `centered' placement style * Added symbol-completion to readline-based client * Fix bug of not noticing WM_NORMAL_HINTS property changes; follow the window's maximum size hints * Fix bug of not reframing windows when they change from unshaped to shaped, or vice versa 0.13 ==== * New option to only highlight frame parts when their window is focused (`highlight-when-unfocused') * Typing `ESC' while moving/resizing a window cancels the operation, restoring the original geometry * New session management hook `sm-after-restore-hook' * New function `set-frame-part-value'--makes customizing the `frame-part-classes' variables easier * Support for loading themes from tar files; needs librep 0.7 * Fix bug when allocating colors (choosing an incorrect cached color) * Fix image tiling in frame part backgrounds * Handle shifted keysyms when passive grabbing * Fix another race condition when active grabbing * Fix `_WIN_CLIENT_LIST' property not being set properly (both missing windows immediately after they're adopted, and of intentionally skipping ignored windows) * Fix some problems with viewports when exiting/restarting * Fix broken stacking of windows after they're mapped * Prevent smart window placement blowing up when large numbers of windows are open/opened (throttle back to random placement when the event queue is too large, as well as trying to prune the search space) 0.12 ==== * Remember most recently focused windows on each workspace, activate that window after changing workspaces; also, try to preserve focus when moving windows between workspaces * Option to disable auto-raise while cycling through windows (`cycle-disable-auto-raise'); option to restrict cycling to the current viewport (`cycle-all-viewports') * Option `lock-first-workspace' is now enabled by default, and prevents both the first and last interesting workspaces being moved inwards * Added readline support to the client program, pass `--with-readline' option to configure (from Christopher P Goller ) * Added shaped-transient frame to microGUI theme * New frame part attribute `below-client' * Release passive grabs when unadopting windows * When no window has the focus, the `root-window-keymap' is searched for key-press events * Fix bug when binding to the unix-domain socket * Fix focus sometimes being lost when the focused window is destroyed * Fix bug when reading GNOME menu entries without `Type' fields * Fix bug when removing title or border of `shaped-transient' window types (make the window completely unframed) * Fix bug when shading a transient window with `decorate-transients' enabled * Fix some bugs when placing windows that are almost as big or bigger than the screen * Fix some race-conditions between wm-generated and client-generated map/unmap/reparent events * Fix infamous "jerky pointer" bug, this will also make overlapping shaped frame-parts display correctly * Fix bug where `cycle-windows' could leave a window originally under the pointer that's unfocused, drawn as though it is focused 0.11 ==== * New option `lock-first-workspace', prevent the first workspace from being deleted when it's empty * New option `ignore-window-input-hint', to always give windows the focus, whether they say they will accept it or not * New options when cycling windows: `cycle-warp-pointer' and `cycle-focus-windows' * Restore the old method of setting the focus, should fix bug of losing focus totally when switching to a new workspace 0.10 ==== * Implemented virtual workspaces, bind to the `move-viewport-X' and `move-window-X' commands (for X being `left', `right', `up', or `down') * Added a new theme: `microGUI' by Ryan Lovett , based on the QNX Photon screenshots * Added a `Grab key' button in the bindings widget, replaces the current binding with the next pressed key * Lisp module to load the GNOME menus and use them to replace the applications menu. Add `(require 'gnome-menu)' to your `~/.sawmillrc' file to load it * Network server is disabled by default (since it can provide a security hole if X access control is disabled); re-enabled the old unix domain socket code (see the FAQ for more details) * Only give the input focus to windows that actually want it * New option to keep transient windows above their parents (`transients-above-parents') * New option to control how the workspace boundary is handled when moving windows between workspaces (`workspace-send-boundary-mode') * New commands `send-to-workspace:X' for X from 1 to 9 * While windows are hidden or shaded, unmap the client (for ICCCM compliance) * Slightly different method of handling destroyed clients, hopefully results in fewer annoying error messages * Support X installations without X11R6 session management (by not doing any session management) * Don't ask the session manager to save our environment * Fix bug where a window is destroyed/unmapped while it's being resized or moved * Fix bug where window can still be auto-raised even if it's been defocused * Fix problems when `--prefix' option has a trailing slash * Now handles client windows being reparented by a third party (i.e. swallowing apps) 0.9 === * The first-fit and best-fit algorithms are now much more intelligent, e.g. instead of falling back to random placement when a window can't be placed without overlapping an existing window, they will attempt to minimize this degree of overlapping * The `foreground' property of each frame part may now be an image instead of a piece of text * New theme `smaker', uses the foreground images capability to do a somewhat WindowMaker-like theme (with the absolute-e images). This theme is extensively customizable--all images, colors, dimensions, etc... * Use Imlib's fuzzy color matching for all color allocation; this should help on `PseudoColor' visuals * Added an `xterm' command to launch an xterm * Improved the bindings customization widget layout; added a `Copy' button to insert a copy of the current binding * Added `next-workspace-row' and `previous-workspace-row' commands. Together with the `workspace-columns' variable these mimic a 2d desktop * Removed the `cycle-through-workspaces' option, there's now `workspace-boundary-mode'--one of `stop', `wrap-around' or `keep-going' * Added option to include ignored windows when edge snapping (`move-snap-ignored-windows') * Fix race condition between startup of sawmill and gmc; sawmill now has earlier priority * Fix seg fault when running out of color cells while generating a window frame * Fix bug where the window-workspace mapping wasn't reloaded from saved sessions * Fix cancel/revert problems in bindings widget * Fix problems binding to shifted keys when using the XKEYBOARD extension and XFree86 * Be ICCCM compliant when a client requests to be moved * Fix crash when tiling small images into large images * Fix bug where windows could be snapped totally off-screen * Fix bug when windows change their `override_redirect' attribute while unmapped * Fix bug associated with WordPerfect's menu window 0.8 === * First attempt at best-fit window placement (doesn't really work properly yet...) * Added a customization option to focus windows when they're un-iconified (`focus-windows-on-uniconify') * Fix bug in click-to-focus mode where the click is only passed through to the client window, not to any local bindings of the wm * Don't leave windows unframed if there's an error in the user's startup files * Fix bug in `preallocated-workspaces' option * Don't place windows off-screen in first-fit mode 0.7 === * Added stack-based window cycling, bound to `M-TAB' by default. Hold , keep pressing until the correct window is reached, then let go of . * Added first-fit window placement (a.k.a smart-placement) * Completed first stage of workspace rewrite--shouldn't go ballistic when windows are removed anymore * Added `override-frame-part-classes' variable--allows all frame properties to be overridden on a per-class basis * Click-to-focus now accepts any button and any modifiers * Don't snap to gmc icons or panels * Added an `auto-window-type-alist' variable mapping window names to border types * New variables `eval-modifier-events' and `eval-key-release-events' to allow catching these types of keyboard events, disabled by default * Added functions for actively grabbing the keyboard * Removed the long names of the keyboard modifiers, only the single character modifiers are left * If no alt modifier, set it to the same as meta; new variables `alt-keysyms' and `meta-keysyms' describe the virtual modifier assignments * Fix bug when handling shaped frame parts--it was possible to go into a long enter-, leave-notify loop when the old shape was cleared * Fix bug where opaque resizing with snap-to-edges on moved the window as well as resizing it * Fix bug when raising the only managed window * Fix bug where very small client windows got weirdly shaped frames 0.6 === * Define the standard "classes" of frame parts (i.e. things like close button, title, left border, etc...) then allow the state of members of these classes to be set in one place (the `frame-part-classes' variable). This should ensure that different themes have the same feel (but a feel that may be customized by the user) * Allow frame parts to be removed if possible (if they have the `removable' property). Nothing makes use of this yet * Added window-shading, double-click button1 on the title bar * Created a sawmill capplet for the GNOME control center. Use the `--enable-capplet' configure option to build it * First attempt at a technical manual (very quickly written, so probably some inaccuracies) * In the `gtk' theme, draw bevels on window decorations * Use spin-buttons in the configurator to enter numbers * Add option `focus-proxy-click' controlling whether to pass the focus-inducing button-press event to the underlying window (in click-to-focus mode) * Changed the bindings in window borders, it's now the more usual button1 to resize, button2 to move * When clicking and dragging windows, ensure that the clicked frame part stays clicked until the button is released * If in click-to-focus mode, and there's no parent window to focus when the focused window is closed, focus the topmost window (not the window under the pointer as in the other focus modes) * Changing window frames is _much_ less ugly, no flicker at all! * Try to optimise window restacking some more * Sped up opaque window moving when the position display is enabled * Preserve iconified state across restarts * Optimise updating the shape of an unframed window (this stops gmc icons flashing annoyingly) * Fix bugs in click-to-focus mode where some windows were un-focusable * Fix bug where cycling through windows in click-to-focus mode didn't focus the activated window * Fix bug where comparing sawmill lisp objects caused a crash * Fix bug where initiating a resize in the middle of the window didn't allow any of the edges to be moved * Fix bug where changing the "decorate transients" option didn't alter any existing transient windows * Fix bug where iconifying a sticky or ignored window gave no way of reclaiming it--these windows now appear at the end of the window menu 0.5 === * Now does session management. The scheme is extensible, arbitrary Lisp modules can save and restore window state due to their own functionality (using the `sm-window-save-functions' and `sm-restore-window-hook' hooks). See `lisp/workspace.jl' for an example * Displays window position or dimensions whilst interactively moving or resizing a window (`move-show-position', `resize-show-dimensions') * Mechanism for setting frame styles on a per-window basis (this was always possible, just not easy). The `auto-frame-style-alist' variable associates window name regular expressions with frame styles. Also, the `window-ops-menu' has a new submenu with all possible styles * New option `preallocated-workspaces', the number of workspaces to create at startup * Window-workspace mapping is preserved through restart (as long as the GNOME hints are enabled) * Theme directories may contain a short `README' file that will be displayed in the configuration tool * Changed the custom file to `~/.sawmill/custom' instead of `~/.sawmill-custom'. The old file will be moved to the new location if it exists * Install `sawmill-menu' under `libexec' since it shouldn't be run manually * Option in `gradient' theme to create full-sized gradient images, trading memory for quality * Workaround the flicker when raising windows * Changed most of the `menus' and `custom' customize options into normal variables (they're not particularly intuitive) 0.4 === * Frame parts can now be highlighted when the mouse is over them, also they "un-click" and "re-click" as the pointer leaves and re-enters their window. ButtonRelease bindings are only activated when the mouse is in the window at the time * Frame part backgrounds can now be rendered on-the-fly using the new `renderer' property in frame definitions. This property is a function called with args `(IMAGE STATE)'; it should draw a background into IMAGE for the specified state (`nil', `focused', `highlighted' or `clicked') * New theme `gtk'. This reads the default GTK style and uses the associated colors and pixmaps to decorate windows. It doesn't try to handle engine-based themes. It should automatically detect when the default style changes (if changed by the GNOME control center). Do `sawmill-client -c gtk-reload-style' in the shell to reload the style manually * Functions for drawing color gradients and bevels into images. The new `gradient' theme uses these and on-the-fly rendering to do `afterstep'-like window titles * Configurator changes: use a paned widget to separate the list of groups from the settings (stops their relative sizes changing), allow each group to be customized separately, either through a new set of root-submenus or the commands `customize:GROUP' for each GROUP. * Changed the way that "themes" are organised, each theme now gets its own directory, which must include a `theme.jl' or `theme.jlc' script to initialise a frame-style of the same name as the directory. While this script is being evaluated the image path is set so that the theme can load any images stored in its directory. Also created the variable `theme-load-path' containing the list of directories searched when trying to load a theme. By default it contains two directories: `~/.sawmill/themes/' and `PREFIX/share/sawmill/VERSION/themes'. * Resizing now chooses the direction to resize the window in by the initial position of the pointer in relation to the window. The window is divided into a 3x3 grid, the pointer must be in one of the outer rectangles to resize in that direction * New commands `select-workspace:X' for X between 1 and 9 * Support multiple depths, or layers, of windows * It's now possible to move the current workspace up or down the list of all workspaces * New option `-c COMMAND' to `sawmill-client'; invokes the named interactive function * When an app asks for no title and no border, give it what it wants--use the new `unframed' window type * The maximize button works * Option to control placement of transient windows (`place-transient-mode') * Changing the frame style preserves the original window stacking order * Added documentation strings for most built-in functions * Fix bug of evaluating both KeyPress _and_ KeyRelease events * Fix bug of making the shape mask of unshaped client windows too big * Fix bug where already-handled BadWindow errors were being reported * Fix bug where the `window-ops-menu' could be displayed from one window but then affect a different window * Fix bug where click-to-focus doesn't work for new windows * Fix bug where deleting the last workspace selected the first, not the new last workspace * Fix bug where changing a colormap when no window is focused causes a segfault * Fix bug where iconifying a window may leave it in the clicked state after it's uniconified * Fix Caps_Lock and Num_Lock modifiers interfering with bindings * Fix accessing X properties on 64-bit architectures * Fix bug where pointer may be left grabbed after moving a window 0.3a ==== * Support the maximized GNOME window states * Where available, show documentation strings of commands in the configurator * Improve the method of handling clicks in frame-parts * Fix asynchronous client-server protocol * Fix interactive window moving/resizing (don't leave traces of the rubber-band, stop the window initially "jumping" to the pointer) 0.3 === * Implemented window maximization * Added support for snapping to window edges when interactively moving windows (`move-snap-edges' and `move-snap-epsilon') * First attempt at handling a subset of the Motif and OpenLook window hints * Removed the `sloppy-focus' variable, it's replaced by `focus-mode'. This can currently be one of `enter-exit' (normal focus follows pointer), `enter-only' ("sloppy" focus) or `click' (click to focus) * When resolving pointer events, scan the `keymap' property of the window under the pointer, not the focused window (as with keypress events) * The `sawmill-client' program can now communicate inter-host, since it uses X properties not raw sockets * New hook `before-exit-hook', called immediately before shutting down * Rewrote the GNOME support as a Lisp module * Placing windows interactively now works * Fixed the bug on Solaris where deleting windows could cause a segmentation fault 0.2 === * Added a user-customization system, inspired by Emacs' customize facility. Invoke this through the `sawmill-ui' program, or from the `Customize...' entry in the main menu. All changes are stored in the Lisp script `~/.sawmill-custom' * Selected windows may now be raised (`raise-selected-windows') * It's possible to prevent the mouse pointer being warped to selected windows (`warp-to-selected-windows') * The `brushed-metal' and `simple' themes now define all four standard frame types * Frame themes are now stored in a separate directory (`PREFIX/share/sawmill/VERSION/lisp/themes') so that the list of all available themes can be made automatically * The frame colors of the `simple' frame style can now be customized (`simple-normal-color' and `simple-active-color') * The `sawmill-defaults.jl' script enables GNOME compliance unconditionally (since it has no ill-effects even if GNOME isn't being used) * Transient windows can be given the same frames as normal windows (`decorate-transients') * Newly-displayed transient windows can be automatically given the focus if their parent window is focused (`transients-get-focus') * Any newly-displayed windows can be automatically given the input focus (`focus-windows-when-mapped') * The `foreground', `background' and `font' attributes of each frame part may now refer to a function * Fixed the window-move bug whereby the first motion event was discarded * Fixed the bug where windows may be placed partially off the root window, even if they needn't be * Fixed the shaped frame parts bug (they didn't work) * Miscellaneous other bug-fixes 0.1 === First proper release  File: sawfish.info, Node: Colors, Next: Fonts, Prev: News, Up: Top 4 Colors ******** Sawfish provides a primitive type allowing colors to be represented. Each color object allows a single color value to be named and passed between Lisp functions. -- Function: colorp arg Returns `t' when ARG is a member of the color type. -- Function: get-color name &optional alpha Returns the color object representing the color specified by the string NAME. This is according to the standard X11 color specifiers, either a named color from the `rgb.txt' database, or a string defining the red, green and blue components of the color, either eight or sixteen bits in hexadecimal, i.e. `#RRGGBB' or `#RRRRGGGGBBBB'. Optional argument ALPHA becomes the alpha value of the returned color. It is passed through to `get-color-rgb'. Signals an error if no known color has the name NAME. -- Function: get-color-rgb red green blue &optional alpha Return the color object representing the color with RGB components as specified (each component ranging from 0 to 65535). Optional argument ALPHA becomes the alpha value of the returned color. Use an integer value in the range from 0 to 65535. Integers outside that range are not supported, while non-integers such as `nil' are silently converted to 65535 (fully opaque). Given a color object, it's possible to find both the actual rgb values defining the color and one of the names that X11 uses to refer to the color. -- Function: color-rgb color Return a list of integers `(RED GREEN BLUE ALPHA)', the actual color values of the color represented by object COLOR. The individual values range from 0 to 65535. -- Function: color-rgb-8 color Return a list of integers `(RED GREEN BLUE ALPHA)', just like `color-rgb'. However, the color values are scaled to fit a range from from 0 to 255. -- Function: color-name color Return the name of the color represented by the color object COLOR. Note that this picks one name from the set of valid names for this color; it may well be different to the name used when the color was originally allocated. The X11 name does not include alpha information. Where a color object is used to define the foreground color of a piece of text, the `default-foreground' color provides the default value used if no actual color is specified. -- Variable: default-foreground The color used for text where no other color is defined.  File: sawfish.info, Node: Fonts, Next: Images, Prev: Colors, Up: Top 5 Fonts ******* As with the color type, the font type allows X11 fonts to be manipulated by Lisp code. -- Function: fontp arg Returns `t' if ARG is a font object. Sawfish supports two types of fonts: X11 core fonts (fontsets and fontstructs) and Xft fonts. Calling code must look up fonts by giving both a name and a type: an `"xlfd"' argument indicates the core fonts, and `"Xft"' indicates Xft fonts. These types are always literal strings. -- Function: font-type-exists-p type Returns true if fonts with the type described by the string TYPE can be loaded, false otherwise. -- Function: get-font-typed type name Return a font object representing the X11 font specified by the string NAME. Argument TYPE indicates the type of font to look for; it must be one of the strings `"xlfd"' for a X11 core fonts (based on fontsets or a fontstructs), or `"Xft"' for an Xft font. Signals an error if TYPE is not one of the literal strings listed above. Also signals an error if no font named NAME can be found within the requested type. -- Function: get-font name Return a font object representing the X11 core font (fontset or fontstruct) specified by the string NAME. Signals an error if no font named NAME is available among the X11 core fonts. Several functions allow the attributes associated with a font object to be found. -- Function: font-name font Returns the name of the X11 font represented by object FONT (a string). -- Function: font-type font Returns a string indicating the font's class. This is `"xlfd"' for X11 core fonts, or `"Xft"' for Xft fonts. -- Function: font-height font Returns the bounding height of glyphs in the font represented by object FONT. -- Function: font-ascent &optional font Returns the ascent of glyphs rendered using the font represented by FONT. If no font argument is given, use the default font. -- Function: font-descent &optional font Returns the descent of glyphs rendered using the font represented by FONT. If no font argument is given, use the default font. -- Function: text-width string &optional font Returns the number of horizontal pixels that would be required to display the text STRING using font object FONT (or the value of the `default-font' variable if FONT is undefined). As with colors, a default font may be specified, to be used where no other font is specified. -- Variable: default-font Font object used when no other font has been specified. Fonts can have Lisp properties associated with them (similar to the property lists associated with symbols). Currently these aren't actually used by the window manager. -- Function: font-put font property value Associate the lisp object VALUE with the property named by the symbol PROPERTY of the font object FONT. -- Function: font-get font property Return the value of the property named by the symbol PROPERTY of the font FONT, or `nil' if no such property exists. -- Variable: fonts-are-fontsets True if the X fonts in use are fontsets. This will be false if `setlocale' fails, or returns an ASCII locale, or if X doesn't support the locale.  File: sawfish.info, Node: Images, Next: Cursors, Prev: Fonts, Up: Top 6 Images ******** The image type allows arbitrary 24-bit images to be manipulated by the window manager. Images may be both loaded from files, and rendered dynamically. -- Function: imagep arg Returns `t' when ARG is a member of the image type. -- Function: make-image file-name &optional plist Creates and returns an image object containing the image defined by the contents of the file named FILE-NAME (a string). The `image-load-path' directory provides the search path used while trying to find a directory containing the file named FILE-NAME. All common image formats will likely be able to be loaded. But PNG, JPEG and XPM should always be supported. Argument PLIST becomes the property list of the returned image. Signals an error if file called FILE-NAME may be found, or if an image may not be constructed from the file. -- Variable: image-directory Directory containing built-in Sawfish images. By default, this is `SAWFISH-DIRECTORY/images'. -- Variable: image-load-path A list of directory names. This defines the search path used when loading images. By default, this is `("." IMAGE-DIRECTORY)'. Modifying IMAGE-DIRECTORY does not modify IMAGE-LOAD-PATH. -- Function: make-sized-image width height &optional color Create and return a new image, of size WIDTH, HEIGHT. If COLOR is defined it specifies the color of all pixels in the image. If undefined, all pixels will be black. -- Function: make-image-from-x-drawable id &optional mask-id Create and return an new image. The image is constructed by copying an X Drawable (identified by ID) into a Sawfish image object. The function automatically handles depth conversion. If MASK-ID is given, it identifies another X Drawable. Black pixels in this drawable indicate transparent pixels in the image object (non-black pixels have no effect on the image object). -- Function: copy-image image Returns a newly allocated image object, an exact copy of the image object IMAGE. -- Function: image-dimensions image Returns a cons-cell `(WIDTH . HEIGHT)' defining the dimensions of the image represented by IMAGE. -- Function: flip-image-horizontally image Flip the contents of IMAGE about the vertical axis. This is a mutating operation that returns the modified argument. -- Function: flip-image-vertically image Flip the contents of IMAGE about the horizontal axis. This is a mutating operation that returns the modified argument. -- Function: flip-image-diagonally image Flip the contents of IMAGE about an axis running from the top-left corner to the bottom-right corner of the image. This is a mutating operation that returns the modified argument. As with many of the other types, arbitrary state may be associated with image objects. -- Function: image-put image property value Set the property named PROPERTY (a symbol) of IMAGE to VALUE. -- Function: image-get image property Return the property named PROPERTY of IMAGE, or `nil' if no such property exists. The only predefined property is the symbol `tiled', used when an image is displayed in a window decoration. When set to a non-nil value the image is not scaled to the size of the decoration (the default), but is tiled across the decoration. When images are scaled across border decorations the pixels that are actually scaled are defined by the "border" of the image. The border defines the outer rectangle of pixels that are left as-is, and the inner rectangle which is scaled. -- Function: image-border image Returns a list of integers `(LEFT RIGHT TOP BOTTOM)', the border of the image object IMAGE. The number associated with each edge of the image defines the number of pixels adjacent to that edge that _will not_ be scaled. -- Function: set-image-border image left right top bottom Sets the border of IMAGE. The number associated with each edge of the image defines the number of pixels adjacent to that edge that _will not_ be scaled. The shape of the image may also be specified, this defines which pixels are treated as being transparent. Each image may define a single color as marking transparent pixels. Image shapes are not supported under GDK Pixbuf. Sawfish will print a diagnostic message to `STDERR' if the function is called without being supported. -- Function: image-shape-color image Return the color marking transparent pixels in IMAGE, or `nil' if no such color has been specified. -- Function: set-image-shape-color image color Specify that COLOR marks transparent pixels in IMAGE. It's also possible to define "color modifiers" for each image. These define the transformation applied to the value of each pixel when it is displayed. Four different modifiers exist for each image, one for each color component, and one for the image as a whole. -- Function: image-modifier image type Return the modifier defined by the symbol TYPE of IMAGE, a list of integers `(GAMMA BRIGHTNESS CONTRAST)'. Each integer has a value between zero and 255 representing the weight applied to the associated attribute when rendering the image. The four types are `red', `green', `blue' and `nil' (all colors). The argument must be `eq' to one of those symbols. -- Function: set-image-modifier image type gamma brightness contrast Set the image modifier of IMAGE defined by TYPE. TYPE may be one of the values of (not the symbols) `red', `green' or `blue'. There are also several other functions manipulating images: -- Function: bevel-image image border upwards &optional bevel-percent Transform the edgemost pixels of IMAGE to give it a "bevelled" effect. BORDER is an integer defining the width of the bevel. If UPWARDS is non-nil the bevel is raised, otherwise it is lowered. If BEVEL-PERCENT is defined it specifies the height or depth of the drawn bevel. When undefined, the value of the parameter is taken from the `default-bevel-percent' variable. -- Variable: default-bevel-percent Default height of drawn bevels, as a percentage. Normally 50%. -- Function: clear-image image &optional color Set all pixels in IMAGE to COLOR (or black if COLOR is undefined). -- Function: tile-image dest-image source-image Tiles SOURCE-IMAGE into DEST-IMAGE, starting from the upper-left corner, working outwards. -- Function: scale-image image width height Return a copy of IMAGE, scaled to WIDTH by HEIGHT pixels. -- Function: composite-images image1 image2 &optional x y Copy the contents of IMAGE2 into IMAGE1. IMAGE2 is cropped to fit. Arguments X and Y indicate the position in IMAGE1 of the top-left corner of IMAGE2. If not supplied, they default to 0. -- Function: crop-image image x y width height Return a new image that is a rectangular section of IMAGE. The result image starts at pixel (X, Y) in IMAGE, and extends over WIDTH and HEIGHT pixels in IMAGE. When the cropped image extends beyond the boundary of IMAGE, the behavior is undefined. The following functions allow users to manipulate images on a pixel-by-pixel level. They all use a list representation for pixels: (R, G, B, A) indicating the red, green, blue and alpha components -- Function: image-ref image x y Return a list (R, G, B, A) of the red, green, blue and alpha components of the pixel (X, Y) in IMAGE. When the pixel position extends outside the bounds of the image, the behavior is undefined. -- Function: image-set image x y pixel Set the pixel at (X, Y) in IMAGE to PIXEL. PIXEL is a list of four numbers (R, G, B, A), the red, green, blue and alpha components. When the pixel position extends outside the bounds of the image, the behavior is undefined. -- Function: image-map xform image Transform each pixel in IMAGE in place by calling XFORM on each pixel in the image. XFORM takes a single argument, a four element list (R, G, B, A) indicating the red, green, blue and alpha components of a pixel. XFORM should return the new value for the pixel it was given. The return format is the same four-element list. XFORM is allowed to return `nil'. In this case, `image-map' immediately returns an invalid object. -- Function: image-fill generator image Set each pixel in IMAGE based on the results of calling GENERATOR. GENERATOR takes two arguments: the X and Y coordinates of a pixel. It returns a four element list (R, G, B, A) indicating the red, green, blue and alpha components of a pixel. This new pixel replaces the current pixel contents at (X, Y). GENERATOR is allowed to return `nil'. In this case, `image-map' immediately returns an invalid object. -- Function: pixmap-cache-control max Tell Sawfish to cache no more than MAX pixels. Returns a four-element list indicating the current cache status: `(MAX-CACHED-PIXELS, CACHED-PIXELS, HITS, MISSES)'.  File: sawfish.info, Node: Cursors, Next: Windows, Prev: Images, Up: Top 7 Cursors ********* Cursors define the shape and hot-spot of the mouse pointer's image. A lisp type is provided for manipulating these objects. In addition, Sawfish provides functions for manipulating the position of the cursor. * Menu: * Cursor Appearance:: * Cursor Positioning::  File: sawfish.info, Node: Cursor Appearance, Next: Cursor Positioning, Prev: Cursors, Up: Cursors 7.1 Cursor Appearance ===================== -- Function: cursorp arg Returns `t' if ARG is a member of the cursor type. -- Function: get-cursor data Returns the cursor object representing the cursor defined by DATA. If DATA is a symbol, it's replaced by its `cursor-shape' property. Possible DATA values are an integer representing a glyph in the standard X11 cursor font, or a four-element vector. The format for a vector is `[IMAGE MASK FG BG]' where IMAGE and MASK are the filenames of standard X11 bitmaps, and FG and BG are colors (or names of colors). All bitmap files are searched for using the `image-load-path' variable. -- Function: recolor-cursor cursor fg bg Change the colors of the cursor object CURSOR to FG and BG (either color objects or the names of colors). -- Function: default-cursor &optional cursor Set the cursor object displayed in the root window, and in parts of window frames that have no other cursor specified, to CURSOR. If called with no argument, simply return the current such cursor object. So that the integer indices of glyphs in the X11 cursor font do not have to be remembered, the `cursor-shape' properties of the following symbols are automatically set: `X_cursor', `arrow', `based_arrow_down', `based_arrow_up', `boat', `bogosity', `bottom_left_corner', `bottom_right_corner', `bottom_side', `bottom_tee', `box_spiral', `center_ptr', `circle', `clock', `coffee_mug', `cross', `cross_reverse', `crosshair', `diamond_cross', `dot', `dotbox', `double_arrow', `draft_large', `draft_small', `draped_box', `exchange', `fleur', `gobbler', `gumby', `hand1', `hand2', `heart', `icon', `iron_cross', `left_ptr', `left_side', `left_tee', `leftbutton', `ll_angle', `lr_angle', `man', `middlebutton', `mouse', `pencil', `pirate', `plus', `question_arrow', `right_ptr', `right_side', `right_tee', `rightbutton', `rtl_logo', `sailboat', `sb_down_arrow', `sb_h_double_arrow', `sb_left_arrow', `sb_right_arrow', `sb_up_arrow', `sb_v_double_arrow', `shuttle', `sizing', `spider', `spraycan', `star', `target', `tcross', `top_left_arrow', `top_left_corner', `top_right_corner', `top_side', `top_tee', `trek', `ul_angle', `umbrella', `ur_angle', `watch', `xterm'. The glyphs associated with these names are shown in Appendix I, of Volume Two, `Xlib Reference Manual'.  File: sawfish.info, Node: Cursor Positioning, Prev: Cursor Appearance, Up: Cursors 7.2 Cursor Positioning ====================== Sawfish provides one basic command for adjusting the relative position of the cursor. -- Function: move-cursor right down Move the cursor RIGHT pixels to the right across the screen, and DOWN pixels down the screen. The cursor stops at the edge of the screen (although in multi-head environments, this may not be at the edge of the display). There are also more specialized cursor movement commands. -- Function: move-cursor-left-fine -- Function: move-cursor-right-fine -- Function: move-cursor-up-fine -- Function: move-cursor-down-fine Move the cursor 1 pixel in the indicated direction. -- Function: move-cursor-left -- Function: move-cursor-right -- Function: move-cursor-up -- Function: move-cursor-down Move the cursor `move-cursor-increment' pixels in the indicated direction. -- Variable: move-cursor-increment 16 The `move-cursor-DIRECTION' functions move this cursor this many pixels at a time.  File: sawfish.info, Node: Windows, Next: Customization, Prev: Cursors, Up: Top 8 Windows ********* One of the most important data types in sawfish is the window type. All managed client windows have a single window object associated with them. -- Function: windowp arg Returns `t' if ARG is a member of the window type, and has a client window associated with it. -- Function: managed-windows Returns a list containing all managed window objects, in the order that they were adopted by the window manager (first to last). -- Function: get-window-by-id xid Return a window object with id XID, or `nil'. -- Function: get-window-by-name name Return a window object with name NAME, or `nil'. -- Function: get-window-by-name-re name Return a window object with name matching regular expression NAME, or `nil'. -- Function: activate-window window Do everything necessary to make WINDOW active, including raising it, giving it focus, etc. Certain steps may be skipped (e.g., giving focus) if the window doesn't allow that operation. -- Function: filter-windows pred Return the list of windows (mapped or unmapped) that match the predicate function PRED. -- Function: map-windows function Call `(FUNCTION WINDOW)' on all existing windows. Returns the value of the last FUNCTION invocation. If any FUNCTION returns `nil', `map-windows' returns `nil' immediately. -- Function: window-class window Return the class that WINDOW belongs to as a string, or nil if WINDOW has no associated class. -- Function: get-window-wm-protocols window Return a list of symbols defining the X11 window manager protocols supported by client WINDOW. -- Function: window-supports-wm-protocol-p window atom Return true if WINDOW includes ATOM in its `WM_PROTOCOLS' property. * Menu: * Window Property Lists:: * Window Types:: * Window Attributes:: * Input Focus:: * X Properties:: * Window Stacking:: * Moving and Resizing Windows:: * Showing and Hiding Windows:: * Destroying Windows:: * Shading Windows:: * Iconifying Windows:: * Window Stickiness:: * Ignored Windows:: * Maximizing Windows:: * Animating Windows:: * Cycling Between Windows:: * Window Groups::  File: sawfish.info, Node: Window Property Lists, Next: Window Types, Up: Windows 8.1 Window Property Lists ========================= Many window manager extensions need to be able to associate Lisp data with individual windows. For example, the module handling iconification needs to associate a boolean value with each window--whether that window is iconified or not. To solve this problem, Sawfish gives each window a property list. These are exactly analogous to the property lists stored with each symbol (*note Property Lists: (librep)Property Lists.); they allow values to be associated with Lisp symbols, for a particular window. Note that these properties are different to the properties that X stores with each window, since these properties are internal to the window manager (*note X Properties::). For a list of the standard window properties, see *Note Standard Properties::. -- Function: window-put window property value Set the lisp property named PROPERTY (a symbol) associated with window object WINDOW to VALUE. Note that these are Lisp properties not X properties. -- Function: window-get window property Return the window property named PROPERTY (a symbol) associated with the window object WINDOW, or `nil' if no such property exists. Note that these are Lisp properties not X properties. -- Function: map-window-properties function window Call `(FUNCTION PROPERTY VALUE)' on each of the Lisp properties bound to WINDOW. Returns the value of the last FUNCTION invocation. If any FUNCTION returns `nil', `map-window-properties' returns `nil' immediately.  File: sawfish.info, Node: Window Types, Next: Window Attributes, Prev: Window Property Lists, Up: Windows 8.2 Window Types ================ Transient windows are pop-up or dialog windows associated with a main application. They tend to have less window decorations, and are intended to last a short time only. -- Function: window-transient-p arg Returns `t' if ARG represents a transient window. -- Function: mark-window-as-transient w Mark that the window associated with object W is a transient window. -- Function: transient-of-p child parent Return true if window CHILD is directly a transient for window PARENT, false otherwise. -- Function: indirect-transient-of-p descendant ancestor Return true if window DESCENDANT is (directly or indirectly) a transient for window ANCESTOR, false otherwise. -- Function: transient-parents child &optional indirectly Return the list of windows that window CHILD is a transient for. If INDIRECTLY is true, then return the list of all ancestors rather than parents. -- Function: transient-children parent &optional indirectly Return the list of windows that are transients for window PARENT. If INDIRECTLY is true, then return the list of all descendants rather than children. -- Function: transient-group window &optional by-depth Return the list of windows which is either a transient window for window WINDOW, or a window which WINDOW is a transient for. This always includes W. The `transient window for' relation holds for windows which are direct or indirect transients of the parent window in question. If the BY-DEPTH argument is true, then the retrurned list is in stacking order. -- Function: map-transient-group fun window Map the single argument function FUN over all windows in the same transient group as window WINDOW. -- Function: raise-window-and-transients window Raise window WINDOW to its highest allowed position in the stacking order. Also raise any transient windows that it has. -- Function: lower-window-and-transients window Lower window WINDOW to its lowest allowed position in the stacking order. Also lower any transient windows that it has. -- Function: raise-lower-window-and-transients window If window WINDOW is at its highest possible position, then lower it to its lowest possible position. Otherwise raise it as far as allowed. Also changes the level of any transient windows it has. -- Customizable: focus-windows-when-mapped Focus on application windows when they first appear. Defaults to true, must be true or false. -- Variable: decorate-transients Decorate dialog windows similarly to application windows. Defaults to false. Desktop windows are root windows or viewport windows. -- Function: desktop-window-p arg Returns `t' if ARG represents a desktop window. -- Function: mark-window-as-desktop w Mark that the window associated with object W is a desktop window. -- Variable: desktop-window-properties List of properties set (to true) on windows marked as desktops. Defaults to '(fixed-position sticky sticky-viewport) -- Variable: desktop-window-depth The stacking depth of desktop windows. Defaults to -4. Dock windows are simply those with the `dock-type' property. GNOME panels are one example. Sawfish does not currently assign them any special behavior. -- Function: dock-window-p arg Returns `t' if ARG represents a dock window. -- Function: mark-window-as-dock w Mark that the window associated with object W is a dock window. -- Variable: dock-window-properties List of properties set (to true) on windows marked as docks. Defaults to '(window-list-skip cycle-skip fixed-position focus-click-through avoid no-history never-iconify never-maximize sticky sticky-viewport placed) -- Variable: dock-window-depth The stacking depth of dock windows. Defaults to 0.  File: sawfish.info, Node: Window Attributes, Next: Input Focus, Prev: Window Types, Up: Windows 8.3 Window Attributes ===================== -- Function: window-name window Return the name associated with WINDOW. -- Function: window-full-name window Return the full-name associated with WINDOW. This may or may not be the same as the normal name. Sawfish provides functions to ensure that window names are unique. -- Function: uniquify-name proposal existing Uniquify the string PROPOSAL against the list of strings EXISTING. Uses the format string `uniquify-name-format' to generate unique names. -- Variable: uniquify-name-format Format to create unique window names. Defaults to `"%s [%d]"'. -- Function: uniquify-window-name window -- Command: uniquify-window-name window Force WINDOW to have a unique title. -- Function: window-icon-name window Return the icon name associated with WINDOW. -- Function: window-mapped-p window Return `t' if the client window associated with object WINDOW is mapped. (Note that this doesn't necessarily mean that it is visible.) -- Function: window-transient-p window Returns `nil' if WINDOW isn't marked as a transient window. Otherwise returns an integer, the xid of the parent window. -- Function: window-shaped-p window Return `t' if WINDOW is shaped (possibly not rectangular). -- Function: window-id window If window object WINDOW has a client window associated with, return an integer defining its xid, otherwise return `nil'. -- Function: root-window-id Returns the numeric ID of the root window of the managed screen. -- Function: window-group-id window If WINDOW is part of a group, return the X window id of the leader of that group. Otherwise return `nil'. -- Function: window-wants-input-p window Return `t' when the client window associated with object WINDOW has asked for the input focus to be assigned to it when applicable (through the `input' field of its `WM_HINTS' property). -- Function: window-really-wants-input-p window Return `nil' if the client window associated with object WINDOW should never be focused, `t' otherwise. -- Function: window-dimensions window Returns a cons cell `(WIDTH . HEIGHT)' defining the dimensions of the client window associated with object WINDOW. -- Function: window-position window Returns a cons-cell `(X . Y)' defining the position relative to the root window of WINDOW. -- Function: window-size-hints window Return an alist defining the size-hints structure specified by the client window associated with WINDOW. Possible keys in the alist are `min-height', `max-height', `min-width', `max-width', `height-inc', `width-inc', `min-aspect', `max-aspect', `base-height', `base-width', `user-position', `program-position', `user-size', `program-size', `window-gravity', `border-size'. -- Function: window-visibility window Returns a symbol defining the current visibility of WINDOW. Possible returned symbols are `fully-obscured', `partially-obscured' or `unobscured'. -- Function: window-urgent-p window Return `t' if the "Urgency" hint of the window associated with WINDOW is set.  File: sawfish.info, Node: Input Focus, Next: X Properties, Prev: Window Attributes, Up: Windows 8.4 Input Focus =============== The input focus defines exactly which client window will receive events generated by the keyboard. -- Function: input-focus Returns the window object of the currently focused window, or `nil' if no window is focused. -- Function: set-input-focus window Sets the focus to the client window associated with WINDOW. If WINDOW is `nil', then no window will have the focus. The window manager is responsible for switching the input focus from client window to client window. Sawfish implements several "focus modes" that provide this behavior. Each focus mode is bound to a symbol; the implementation is bound to that symbol's `focus-mode' property slot. -- Variable: focus-mode Defines the current method of using the mouse to assign the input focus. This is a symbol from the list `focus-modes'. -- Variable: focus-modes A list containing all names of focus modes. The built-in values are `enter-exit', `enter-only' and `click'. It is possible to add additional focus modes by defining your own handler function. The handler function must obey a "focus-mode-handler" protocol. -- Function Protocol: focus-mode-handler window event-name &optional args A function that implements the `focus-mode-handler' protocol can be used to define a focus mode. A `focus-mode-handler' responds to events associated with windows. Argument WINDOW is the window that received this event. Argument EVENT-NAME is one of the following symbols: `pointer-in' `pointer-out' The pointer has entered or exited the window. The handler is responsible for checking whether an entered window wants input events. The desktop never receives `pointer-in' or `pointer-out'; only normal windows do. `' `enter-root' `leave-root' The pointer has entered or exited the desktop (which is the WINDOW argument). Normal windows never receive `enter-root' or `leave-root'. `focus-in' `focus-out' The window argument has gotten or lost focus. Note that the `focus-in' handler is not responsible for updating the window-order list. `before-mode-change' `after-mode-change' Sawfish sends these synthetic events to each window before/after changing that window's focus mode. When the global focus mode changes, all windows get these events. `add-window' Sawfish sends this event to every window immediately after mapping it. Handlers can use this to initialize window-internal data structures. `warp-if-necessary' Warp the cursor to the window if doing so would make the cursor position "consistent" with the focus mode. For example, in `enter-exit' mode we warp the cursor if it is not already in this window. In `enter-only' mode, we warp the cursor if it is in another window, but not if it is over the desktop--a window would not lose focus when the cursor moved from it to the desktop. The protocol allows for any number of additional arguments, but does not define any. Any handler function must be prepared to receive and ignore them. Unsupported events may be ignored. The return value of this function is ignored. -- Function: define-focus-mode name fun Defines a new focus mode called NAME (a symbol). The focus-mode handler FUN implements this focus mode. See the documentation for `focus-mode-handler' for more information. -- Function: set-focus-mode window mode Set the focus mode of window WINDOW to MODE. This triggers `before-mode-change' and `after-mode-change' focus-mode events on WINDOW. -- Function: warp-pointer-if-necessary window Generate a `warp-if-necessary' event and send it to the window's focus function. -- Variable: focus-click-through When in `click' focus mode, the focus-assigning click is only passed through to the client window if this variable is `t' (the default). This option may be set on a per-window basis by setting the `focus-click-through' property of the window (using the `window-put' function). -- Variable: focus-ignore-pointer-events When true, pointer in/out events don't cause focus changes. This is independent of the current focus mode. -- Variable: focus-within-click-event When true, the current command is being called from within a click-to-focus button press event. This is a fluid object, not an ordinary variable. Sawfish also maintains the order in which windows were recently focused. -- Function: window-order &optional workspace allow-iconified all-viewports Return a list of windows, in most-recently-focused order. If WORKSPACE is an integer, then only windows on that workspace are included, otherwise all workspaces are searched. If ALLOW-ICONIFIED is non-nil, iconified windows are included. If `all-viewports' is non-nil, then all viewports of the workspace(s) are scanned. -- Function: window-order-push window Push window object WINDOW onto the top of the focus stack. -- Function: window-order-pop window Remove window object WINDOW from the focus stack. -- Function: window-order-most-recent &optional windows Return the most-recently focused window in the current workspace. If the optional argument WINDOWS is given, it must be a list of windows. In that case, the function will return the most-recently focused window from that list. -- Function: window-order-focus-most-recent Focus the most-recently-focused window of the current workspace. -- Variable: focus-dont-push When true, focusing a window doesn't change it's position in the stack of most-recently focused windows. -- Function: window-in-cycle-p window &keyword ignore-cycle-skip Returns `t' if the window WINDOW should be included when cycling between windows. Desktop windows and those with the `cycle-skip' property should normally not be included. When `t', the IGNORE-CYCLE-SKIP keyword argument forces the function to include windows with the `cycle-skip' property. -- Function: focus-push-map window keymap -- Function: focus-pop-map window Maintain a two-element keymap stack for WINDOW. `focus-push-map' makes KEYMAP current for WINDOW, but saves the existing keymap. We can restore this existing keymap with `focus-pop-map'. These functions are intended to support click-to-focus. They enforce certain sanity rules: pushing into a two-element stack will only overwrite the top element, while popping a one-element stack has no effect. -- Function: autoload-focus-mode name func MISSING. This does not seem to be used anywhere, and its behavior is unclear. -- Function: select-window Waits for the user to left-click on a window, and returns that window. The mouse cursor changes shape, and all normal input events are suppressed until a window is selected. -- Variable: select-window-cursor-shape The cursor shape to use when selecting a window. Defaults to `crosshair'.  File: sawfish.info, Node: X Properties, Next: Window Stacking, Prev: Input Focus, Up: Windows 8.5 X Properties ================ The X window system associates properties with windows (these are totally separate to the properties that sawfish associates with window _objects_, *note Window Property Lists::). Most inter-client communication is performed through manipulation of these properties. All functions defined below, that operate on X properties, accept their WINDOW parameter as either a window object (denoting the associated client window), the numeric xid of a window, or the symbol `root' denoting the root window. Sawfish represents X atoms (both the names and data types of X properties) as symbols. There is an exact correspondence between the names of atoms and the name of the symbol representing them. For example, the X atom `STRING' is represented by the lisp symbol `STRING'. -- Function: list-x-properties window Return a list of symbols defining the X properties set on WINDOW. -- Function: delete-x-property window property Deletes the X property named PROPERTY (a symbol) associated with WINDOW. -- Function: get-x-property window property Returns a list `(TYPE FORMAT DATA)' representing the X property PROPERTY of WINDOW. If no such property exists, return nil. TYPE is the atom defining the type of the property. FORMAT is an integer, either 8, 16 or 32, defining the number of bits in each of the data items. DATA is an array, either a string for an 8-bit format property, or a vector of integers otherwise. If TYPE is `ATOM' and FORMAT is 32, then DATA will be a vector of symbols, representing the atoms read. -- Function: set-x-property window property data type format Set the X property PROPERTY of WINDOW to the array DATA, either a string or a vector of integers. TYPE is a symbol representing the atom defining the type of the property; FORMAT is either 8, 16 or 32 defining the number of bits in the data values. If TYPE is `ATOM' and FORMAT is 32, then any symbols in DATA will be converted to their numeric X atoms. The standard X property formats don't allow for an array of strings to be stored, so these are often encoded as the strings concatenated, separated by zero characters. These are usually called "text properties". Sawfish has two functions for manipulating them: -- Function: get-x-text-property window property Similar to `get-x-property', but returns either `nil' or a vector of strings. -- Function: set-x-text-property window property data Sets the X text property PROPERTY of WINDOW to the array of strings DATA. It's also possible to detect when the value of any property associated with a managed window changes, using the `property-notify-hook'. *Note Standard Hooks::. The following convenience function takes advantage of this hook: -- Function: call-after-property-changed prop fun Arrange for function FUN to be called with arguments `(window property state)' when the X11 property named PROP (a symbol) changes. PROP may also be a list of property names to monitor.  File: sawfish.info, Node: Window Stacking, Next: Moving and Resizing Windows, Prev: X Properties, Up: Windows 8.6 Window Stacking =================== The stacking order of the display defines the order in which windows are shown, from topmost to bottommost. Sawfish maintains this list. Raising or lowering windows changes their positions in this list. * Menu: * Stacking Order:: * Raising and Lowering Windows::  File: sawfish.info, Node: Stacking Order, Next: Raising and Lowering Windows, Prev: Window Stacking, Up: Window Stacking 8.6.1 Stacking Order -------------------- -- Function: stacking-order Return a list of window objects defining the current stacking order of all client windows, from top-most to bottom-most. -- Function: mapped-stacking-order Similar to `stacking-order', but only returns windows that are mapped. -- Function: restack-windows list Restack all client windows specified in the list of window objects LIST in the order they occur in the list (from top to bottom). The stacking order of any unspecified windows isn't affected. Sawfish allows the stacking order to be managed as a sequence of layers, with windows being assigned a particular depth within the order. For any given window with depth D, it will be above all windows with depth less than D, and below all windows with depth greater than D. It may be above or below any other windows with depth D. The `depth' property of each window is used to store this depth. A depth of zero is "normal", with negative depths stacked below, and positive depths stacked above this normal level. -- Function: stacking-order-by-depth depth Similar to `stacking-order', but only returns windows with depth DEPTH. -- Function: window-depth window Returns the depth of WINDOW. -- Function: set-window-depth window depth Sets the stacking depth of WINDOW to DEPTH, then restacks the windows to reflect this change. -- Function: window-on-top-p window Returns `t' if WINDOW is at the top of its stacking depth. -- Function: stack-window-below below above Change stacking order of window BELOW so that it is immediately below window ABOVE. -- Function: stack-window-above above below Change stacking order of window ABOVE so that it is immediately above window BELOW. -- Macro: save-stacking-order &rest forms Evaluate FORMS in an implicit `progn', then restore the original window stacking order, returning the value of the `progn'. -- Function: restack-window w Assuming that the current stacking order is in a consistent state except, possibly, for the position of window W, restore the consistent state including window W. This is achieved by raising or lowering window W as appropriate.  File: sawfish.info, Node: Raising and Lowering Windows, Prev: Stacking Order, Up: Window Stacking 8.6.2 Raising and Lowering Windows ---------------------------------- Over time, Sawfish has accumulated several subtle variations of functions for raising and lowering windows. One set of functions operates on single windows. -- Function: lower-window window -- Command: lower-single-window window Lower WINDOW to the bottom of its stacking depth. -- Function: raise-window window -- Command: raise-single-window window Raise WINDOW to the top of its stacking depth. -- Function: raise-lower-window window -- Command: raise-lower-single-window window If WINDOW is the highest in its stacking level, lower it to the bottom of this level, otherwise raise it to the top of its level. Notice how the function name and command name for each pair differs slightly. Another set of functions supports operating on multiple windows simultaneously. Again, the function name and command name for each pair is different. -- Function: lower-window* window -- Command: lower-window window Lower WINDOW and possibly associated windows to the bottom of their stacking depths. -- Function: raise-window* window -- Command: raise-window window Raise WINDOW and possibly associated windows to the top of their stacking depth. -- Function: raise-lower-window* window -- Command: raise-lower-window window If WINDOW is the highest in its stacking level, lower it and possibly associated windows to the bottom of their level, otherwise raise them to the top of their level. -- Variable: user-raise-type Indicates which windows the `lower-window*', `raise-window*' and `raise-lower-window*' functions affect. This variable can be `none' Only the specific argument window is affected. `transients' The specific argument window and all of its transients are affected. This is the default. `group' The specific argument window and all windows in its group are affected. -- Function: maybe-raise-window w If window W supports the `_SAWFISH_WM_RAISE_WINDOW' protocol, ask it whether it wants to raise itself or not. Otherwise, raise the window unconditionally. -- Function: maybe-lower-window w If window W supports the `_SAWFISH_WM_LOWER_WINDOW' protocol, ask it whether it wants to lower itself or not. Otherwise, lower the window unconditionally. Sawfish has more general operations that raising a window to the top or lowering it to the bottom. It can place a window relative to one or more other managed windows. -- Function: raise-windows w order -- Function: lower-windows w order -- Function: raise-lower-windows w order Raise (or lower) all windows in ORDER, such that items earlier in the list are higher (or lower) than later items. The window W is special, always being the highest or lowest window, even if appears in the middle of ORDER. For `raise-lower-windows', if W would be raised or lowered, then all the other windows are also raised or lowered. There are also functions (and associated commands) to change a window's depth. -- Function: lower-window-depth window -- Command: lower-window-depth window Decrement the stacking depth of WINDOW. -- Function: raise-window-depth window -- Command: raise-window-depth window Increment the stacking depth of WINDOW. Sawfish provides special support for "click-to-focus" mode, where you may or may not want to raise the window or pass the click to the underlying application. -- Function: raise-and-pass-through-click w Raise the window that received the current event with `maybe-raise-window'. Then replay any pointer events that invoked the command. -- Function: raise-and-pass-through-click-if-focused w Raise the window that received the current event (if it's focused) with `maybe-raise-window'. Then replay any pointer events that invoked the command. -- Function: raise-or-pass-through-click w If the window that received the current event is not on top, raise it with `maybe-raise-window'. Otherwise replay any pointer events that invoked the command, sending them to the window. When the above commands are called interactively, Sawfish will try to invoke them on the window that received the current event. Failing that, Sawfish will invoke them on the currently focused window.  File: sawfish.info, Node: Moving and Resizing Windows, Next: Showing and Hiding Windows, Prev: Window Stacking, Up: Windows 8.7 Moving and Resizing Windows =============================== As noted above (*note Window Attributes::), the `window-dimensions' and `window-position' functions return the current configuration of a window. -- Function: move-window-to window x y Move the top-left corner of the window frame of WINDOW to (X, Y). -- Function: resize-window-to window width height Set the dimensions of the client window associated with object WINDOW to (WIDTH, HEIGHT). -- Function: move-resize-window-to window x y width height Move the top-left corner of the window frame of WINDOW to (X, Y), and set the dimensions of the frame to (WIDTH, HEIGHT). -- Function: resize-window-with-hints window cols rows &optional hints -- Function: resize-window-with-hints* window width height &optional hints Resize the window associated with object WINDOW so that it has certain X and Y dimensions. For the first function, the dimensions are COLS columns and ROWS rows. For the second function, the dimensions are WIDTH pixels and HEIGHT pixels. The HINTS parameters is either the size hints alist to use, or `nil' in which case the `window-size-hints' function is used to retrieve the window's hints. Usually, however, it is left to the user to configure windows. The following functions may be called interactively: their sole argument is then either the window that received the current event or the currently focused window. -- Command: move-window-interactively window Move WINDOW interactively using the mouse. Releasing any mouse button places the window at its current position. -- Command: resize-window-interactively window Resize WINDOW interactively using the mouse. Releasing any mouse button places the window at its current position. Note that this function selects the edge or edges of the window to move from the current position of the mouse when the resizing begins. The window is divided into a three-by-three grid; the rectangle containing the mouse pointer gives the direction to resize in. If the pointer is in the central rectangle the bottom and right edges are moved. -- Command: move-selected-window Wait for the user to select a window using the mouse, then interactively move that window. -- Command: resize-selected-window Wait for the user to select a window with the mouse, then interactively resize that window. The interactive move and resize behavior can be customized through the following variables: -- Variable: move-outline-mode A symbol defining the visual method of interactively moving windows. Current options include `box' for a wire-frame grid, and `opaque' for full redisplay. -- Variable: resize-outline-mode A symbol defining the visual method of interactively resizing windows. Current options include `box' for a wire-frame grid, and `opaque' for full redisplay. -- Variable: move-show-position When non-nil, the current window position is shown in the center of the screen. -- Variable: resize-show-position When non-nil, the window size is shown in the center of the screen. -- Variable: move-snap-edges When non-nil, the window position is "snapped" to edges of other windows within close proximity. -- Variable: move-snap-epsilon The distance in pixels before snapping together two edges. Windows have a "gravity" property, which affect how they are placed in particular positions. -- Function: window-gravity window &optional hints Returns the gravity of window. The order of precedence is Sawfish `gravity' window property, explicit HINTS argument, X window size hints. The default gravity when nothing else is specified is `north-west' (specified by ICCCM).  File: sawfish.info, Node: Showing and Hiding Windows, Next: Destroying Windows, Prev: Moving and Resizing Windows, Up: Windows 8.8 Showing and Hiding Windows ============================== Sawfish provides two low-level functions for withdrawing client windows from the display. These are used to implement both virtual workspaces (*note Workspaces::) and iconification (*note Iconifying Windows::). -- Function: hide-window window Prevent object WINDOW from being displayed. See `show-window'. -- Function: show-window window Ensure that WINDOW (if it has been mapped, and is within the screen boundary) is visible. See `hide-window'. -- Function: window-visible-p window Returns `t' if object WINDOW has not been hidden by the `hide-window' function.  File: sawfish.info, Node: Destroying Windows, Next: Shading Windows, Prev: Showing and Hiding Windows, Up: Windows 8.9 Destroying Windows ====================== There are several methods through which X11 client windows may be removed from the display. These differ in the level "politeness" they show the window and its owning application. -- Command: delete-window window Delete WINDOW, i.e. send a `WM_DELETE_WINDOW' client-message if possible, or just kill the associated X11 client if not. WINDOW may be a window object or a numeric window id. -- Command: delete-window-safely window If the application owning WINDOW supports it, send a `WM_DELETE_WINDOW' message to WINDOW. Otherwise just emit a beep. -- Command: destroy-window window Destroy WINDOW without giving the owning application any warning. WINDOW may be a window object or a numeric window id. -- Function: x-kill-client window Force a close down of the X11 client that created the window specified by WINDOW (a window object, or numeric id). When a managed window is destroyed, the `destroy-notify-hook' will subsequently be invoked (*note Standard Hooks::).  File: sawfish.info, Node: Shading Windows, Next: Iconifying Windows, Prev: Destroying Windows, Up: Windows 8.10 Shading Windows ==================== Many window managers allow a window to be "shaded"; when in this state only the title bar of the window is visible. -- Function: window-shaded-p window Returns true when WINDOW is shaded, false otherwise. -- Command: shade-window window Arrange for only the title bar of WINDOW to be visible. -- Command: unshade-window window If the window is shaded, restore it to it's original state. -- Command: toggle-window-shaded Toggle the shaded state of the window. -- Variable: raise-windows-when-unshaded nil When true, raise windows when they are unshaded. Defaults to false. The `shaded' property of a window is set to `t' when the window is shaded. If a window is added with this property already set, then the window will appear in its shaded state.  File: sawfish.info, Node: Iconifying Windows, Next: Window Stickiness, Prev: Shading Windows, Up: Windows 8.11 Iconifying Windows ======================= X defines an iconic state for windows, often windows in this state are displayed as small icons. Sawfish does not display these icons, instead iconified windows are shown slightly differently in the menu of all windows. -- Command: iconify-window window Iconify the window associated with object WINDOW. -- Command: uniconify-window window Return the window associated with WINDOW from its iconified state. -- Command: toggle-window-iconified window Minimize the window associated with WINDOW, or restore it if it is already minimized. -- Command: iconify-workspace-windows Minimize all windows in the current workspace. A window's iconic state may be tested through examination of its `iconified' property--when `t' the window is iconified. But it is preferable to use explicit testing functions instead: -- Function: window-iconified-p window Returns true if the window associated with WINDOW is iconified, false otherwise. -- Function: window-iconifiable-p window Returns true if the window associated with WINDOW can be iconified, false otherwise. Some reasons a window might not be iconifiable are: it has a `never-iconify' property; it is already iconified; it is not a desktop window; or it is marked `ignored' and `iconify-ignored' is not true. -- Variable: iconify-ignored nil Unmanaged (`ignored') windows may be iconified. Defaults to nil. Sawfish allows you to control certain behaviors when restoring minimized windows. -- Variable: focus-windows-on-uniconify Windows are focused after being unminimized. Defaults to false. -- Variable: raise-windows-on-uniconify Windows are raised after being unminimized. Defaults to true. -- Variable: uniconify-to-current-workspace Move windows to the current workspace when they are unminimized. Defaults to true. When iconifying, it is possible to force other windows to iconify. -- Customizable: iconify-group-mode -- Customizable: uniconify-group-mode Policy for performing chains of minimizations or restorations. When a particular window is minimized or restored, it can cause other windows to be minimized or restored at the same time. Their allowed values are set to the following list. By default, both variables are bound to the symbol `transients'. but they are not required to have the same value. `none' No additional windows are minimized or restored. `transients' All transient windows associated with the target window are minimized or restored. `group' All windows in the target window's group are minimized or restored. Finally, it's possible to get the icon that would normally be displayed for an iconified window. -- Function: window-icon-image window Return an image object representing the icon currently associated with WINDOW, or `nil' if there is no such image.  File: sawfish.info, Node: Window Stickiness, Next: Ignored Windows, Prev: Iconifying Windows, Up: Windows 8.12 Window Stickiness ====================== Windows normally exist in a single workspace and a single viewport into that workspace. When changing workspace or viewport, the current windows disappear. This is sometimes not the correct policy; there are certain windows that should "follow" the user from window to window. These are typically windows that are not bound to a particular activity. The most common example is a dashboard window for calling other applications. Another example might be a diagnostic program such as a load monitory. Each window has "stickiness" flags that govern this behavior. One flag controls stickiness across workspaces: sticky windows will appear in every workspace automatically. The other flag similarly governs stickiness across viewports. A window is "sticky" if either of these flags are set. Sticky windows are often `ignored', so they lack window decorations, and `avoid'ed so other windows do not cover them up. -- Function: window-sticky-p/workspace window -- Function: window-sticky-p/viewport window -- Function: window-sticky-p window Returns true if WINDOW is sticky across a particular environment (workspaces, viewports, or either), false otherwise. -- Function: make-window-sticky/workspace window -- Function: make-window-sticky/viewport window -- Function: make-window-sticky window Make the WINDOW sticky across some environment (workspaces, viewports, or both). -- Function: make-window-unsticky/workspace window -- Function: make-window-unsticky/viewport window -- Function: make-window-unsticky window Make the WINDOW unsticky across some environment (workspaces, viewports or both). -- Function: toggle-window-sticky window If `window-sticky-p' would report true for WINDOW, make WINDOW unsticky for all environments. Otherwise make it sticky for all environments.  File: sawfish.info, Node: Ignored Windows, Next: Maximizing Windows, Prev: Window Stickiness, Up: Windows 8.13 Ignored Windows ==================== Sawfish has a general concept of "ignored" windows; the user does not interact normally with those windows. The concept is actually defined by five different window properties: `ignored' The window does not receive frames. `never-focus' The window never receives the input focus. `cycle-skip' The window is ignored while window cycling. `window-list-skip' The window will not be included in the window list. `task-list-skip' The window will not be included in the task list. A monitor application such as "xload" might have all five of these flags set. Rather than directly manipulating the window properties, it is better to use the following access functions: -- Function: window-ignored-p window Returns true if the window has the `ignored' property, false otherwise. -- Command: make-window-ignored window Ignore the window WINDOW. -- Command: make-window-not-ignored window Unignore the window WINDOW. -- Command: toggle-window-ignored window If `window-ignored-p' would return true for WINDOW, make it unignored. Otherwise make it ignored. The remaining flags only have toggle functions implemented right now: -- Command: toggle-window-never-focus window -- Command: toggle-window-cycle-skip window -- Command: toggle-window-list-skip window -- Command: toggle-task-list-skip window Toggle the appropriate flag on WINDOW. All five of the flags are available through the window menu's "Toggle" entry.  File: sawfish.info, Node: Maximizing Windows, Next: Animating Windows, Prev: Ignored Windows, Up: Windows 8.14 Maximizing Windows ======================= The dimensions of a window may be temporarily "maximized", stretching as far as possible across the screen in one or two dimensions. -- Command: maximize-window window &optional direction Maximize both dimensions of WINDOW If defined, DIRECTION may be either `vertical' or `horizontal'. -- Command: maximize-window-vertically window Maximize the vertical dimension of WINDOW. -- Command: maximize-window-horizontally window Maximize the horizontal dimension of WINDOW. -- Command: unmaximize-window window &optional direction Restore the dimensions of WINDOW to its original, unmaximized, state. If defined, DIRECTION may be either `vertical' or `horizontal'. -- Command: maximize-window-toggle window Toggle the state of WINDOW between maximized and unmaximized. If defined, DIRECTION may be either `vertical' or `horizontal'. -- Command: maximize-window-vertically-toggle window Toggle the state of WINDOW between vertically maximized and unmaximized. -- Command: maximize-window-horizontally-toggle window Toggle the state of WINDOW between horizontally maximized and unmaximized. -- Function: window-maximized-p window Return `t' when WINDOW is in the maximized state. -- Function: window-maximized-vertically-p window Return `t' when WINDOW is vertically maximized. -- Function: window-maximized-horizontally-p window Return `t' when WINDOW is horizontally maximized.  File: sawfish.info, Node: Animating Windows, Next: Cycling Between Windows, Prev: Maximizing Windows, Up: Windows 8.15 Animating Windows ====================== Sawfish provides certain window animation capabilities. They have been described as "lame", so they are off by default. -- Variable: default-window-animator The default window animation mode, used if a window has no explicit animation set. Normally `none'. -- Function: define-window-animator name fun Define a window animator called NAME (a symbol) that is managed by function FUN. FUN is called as `(fun window op [action])' when it should change the state of an animation sequence. OP may be one of the symbols `start', `stop'. -- Function: autoload-window-animator name struct Construct an autoloader for window animator NAME from structure STRUCT. -- Function: run-window-animator window action Invoke an animation for action ACTION on WINDOW. ACTION may be one of the symbols `start', `stop'. -- Function: record-window-animator window animator Note that WINDOW currently has an animation running, being controlled by animator function ANIMATOR.  File: sawfish.info, Node: Cycling Between Windows, Next: Window Groups, Prev: Animating Windows, Up: Windows 8.16 Cycling Between Windows ============================ Sawfish provides two categories of commands for cycling between windows. The first category cycles between windows in an order that is essentially fixed. The second category cycles between windows in a dynamic order. * Menu: * Fixed Window Cycles:: * Dynamic Window Cycles::  File: sawfish.info, Node: Fixed Window Cycles, Next: Dynamic Window Cycles, Prev: Cycling Between Windows, Up: Cycling Between Windows 8.16.1 Fixed Window Cycles -------------------------- These commands organize the set of mangaged windows into loops. A loop may consist of all windows in a workspace, or it may consist of all windows anywhere. The positions of windows in this loop do not change, except when a new window is managed or unmanaged. -- Function: next-workspace-window -- Function: previous-workspace-window Switch focus to the "next" or "previous" window in the current workspace. -- Function: next-window -- Function: previous-window Switch focus to the "next" or "previous" window in this workspace. If this function reaches the "end" of the windows in this workspace, it switches to the next workspace and displays the first window there.  File: sawfish.info, Node: Dynamic Window Cycles, Prev: Fixed Window Cycles, Up: Cycling Between Windows 8.16.2 Dynamic Window Cycles ---------------------------- These commands implement something much close to Microsoft Windows' mechanism, working with a stack of recently used windows. -- Function: cycle-windows -- Function: cycle-windows-backwards Cycle through all cycleable windows. -- Function: cycle-group -- Function: cycle-group-backwards Cycle through all windows in this group. This is somewhat comparable to the behavior of windows. -- Function: cycle-prefix -- Function: cycle-prefix-backwards Cycle through all windows whose titles match that of the initial window (up to, but not including, the first colon). -- Function: cycle-class -- Function: cycle-class-backwards Cycle through all windows whose classes match that of the initial window. -- Function: cycle-dock -- Function: cycle-dock-backwards Cycle through all windows in the dock, even those with the `cycle-skip' property. Each of these cycling commands may include windows that are not visible on-screen. -- Variable: cycle-include-iconified If true, Sawfish includes iconified windows when cycling. Defaults to true. -- Variable: cycle-all-workspaces If true, Sawfish includes windows on all workspaces when cycling. Defaults to false. -- Variable: cycle-all-viewports If true, Sawfish includes windows on all viewports when cycling. Defaults to false. It is possible to configure the cycling to get more feedback during the process. -- Variable: cycle-show-window-names If true, Sawfish displays window names and icons while cycling through windows. Defaults to true. -- Variable: cycle-raise-windows t If true, Sawfish raises windows while they're temporarily selected during cycling. Defaults to true. It is also possible for you to define your own stacking cycle commands, or even to alter the window stack to suit your tastes. -- Function: define-cycle-command name body &rest rest Create a command that will not cause the current cycle operation to abort before execution. All arguments are passed to define-command. -- Function: define-cycle-command-pair forward-name reverse-name selector &rest rest Create a pair of commands for cycling through windows. The command named FORWARD-NAME cycles forwards, while the command named REVERSE-NAME cycles backwards. SELECTOR is called when initializing the cycle environment, it should return the list of windows to cycle through, or the symbol `t' to denote all cyclable windows. Any extra arguments are passed to each call to define-command. -- Function: window-order &optional workspace allow-iconified all-viewports Return managed windows in most-recently used order. If WORKSPACE is non-nil, then only managed windows in that workspace will be returned. If ALLOW-ICONIFIED is non-nil, then iconified windows will be returned instead of ignored. If ALL-VIEWPORTS is non-nil, then windows in all viewports will be returned, instead of just the current viewport. -- Function: window-order-push w Push window W onto the top of the cycle stack. -- Function: window-order-pop w Remove window W from the cycle stack. -- Function: window-order-most-recent &key windows Return the most-recently focused window in the current workspace. If the WINDOWS argument is given it should be a list of windows, in this case the function will restrict its search to the elements of this list. -- Function: window-order-focus-most-recent Switch input focus to the most-recently focused window in the current workspace.  File: sawfish.info, Node: Window Groups, Prev: Cycling Between Windows, Up: Windows 8.17 Window Groups ================== Sawfish provides extra tools and commands for dealing with ICCCM groups. Most "normal" groups work the same way as they do in the ICCCM standard: windows have a group property that is set to the X window ID of the group leader. These are "group IDs", and they are always positive integers. In addition, Sawfish allows group IDs to be: negative integers These are anonymous user-defined groups. symbols These are named user-defined groups. Named user-defined groups are saved as part of window properties when saving sessions. -- Function: window-group-ids Return the list of all group ids. There may be certain named groups that always exist, whether or not any window belongs to them. -- Variable: peristent-group-ids A list of symbols naming groups that always exist. In any case, a window is limited to belonging to one group, and always belongs to one group. * Menu: * Assigning Windows to Groups:: * Operations on Groups::  File: sawfish.info, Node: Assigning Windows to Groups, Next: Operations on Groups, Prev: Window Groups, Up: Window Groups 8.17.1 Assigning Windows to Groups ---------------------------------- It is possible to change the group of a window in Sawfish. Use `add-window-to-group', or if necessary you can set the window's `group' property explicitly. -- Function: add-window-to-group window group-id Place WINDOW in group GROUP-ID, replacing any previous group membership. If GROUP-ID is `nil', then Sawfish returns the window to whatever group membership was supplied by ICCCM. -- Function: add-window-to-new-group window Place WINDOW into a new group, which will have WINDOW as its sole member. This is an anonymous user-defined group. The new group ID is returned. The Sawfish group assignment never overrides the ICCCM group assignment, just suppresses it. The `window-actual-group-id' function implements this overriding. -- Function: window-actual-group-id window Return the (Sawfish) group ID for WINDOW. This is, in order of preference: * The group ID assigned by Sawfish * The group ID passed in by ICCCM. * The corresponding values for an owning window, if the given window is transient. * The window's own window ID. This means that a window is, at the very least, part of its own group. Each of the following functions operates on the "actual group ID" as returned by the above function. -- Function: windows-by-group group-id &optional by-depth Return the list of windows in the group with id GROUP-ID. If BY-DEPTH is non-nil, then return the windows in order of stacking, from topmost to bottommost. -- Function: windows-in-group w &optional by-depth Return the list of windows in the same group as window W. If BY-DEPTH is non-nil, then return the windows in order of stacking, from topmost to bottommost. -- Function: map-window-group fun w Map the single argument function FUN over all windows in the same group as window W. Note that FUN needs to operate using side-effects, rather than returning values. -- Function: map-other-window-groups fun w Map the single argument function FUN over all windows not in the same group as window W. Note that FUN needs to operate using side-effects, rather than returning values. -- Function: window-group-menu &optional w Return a menu definition suitable for `popup-menu'. This menu will allow the user to assign the window W into any group of a managed window, or into a brand new group. The window's current group is checked or otherwise marked.  File: sawfish.info, Node: Operations on Groups, Prev: Assigning Windows to Groups, Up: Window Groups 8.17.2 Operations on Groups --------------------------- Most of the window manipulation functions that operate on windows are also available for window groups. Each of these functions takes a window as argument; the affected group is that window's group. -- Function: iconify-group w -- Function: uniconify-group w -- Function: iconify-transient-group w -- Function: uniconify-transient-group w These operate like their single-window counterparts. They work by temporarily rebinding `iconify-group-mode' and `uniconify-group-mode'. -- Function: make-group-sticky w -- Function: make-group-unsticky w These operate like their single-window counterparts. -- Function: toggle-group-sticky w If window W is sticky, all windows in its group have their stickyness removed. Otherwise all windows in its group become sticky. -- Function: send-group-to-workspace w workspace -- Function: send-group-to-next-workspace w count -- Function: send-group-to-previous-workspace w count These operate like their single-window counterparts. -- Function: send-group-to-current-workspace w All windows in the group of W are moved from their existing workspaces to the nearest workspace that W is in. Sticky windows are not affected. If the window had the input focus and it is visible after the move, it retains the input focus. -- Function: move-group-to-current-viewport w -- Function: move-group-viewport w -- Function: move-group-left w -- Function: move-group-right w -- Function: move-group-up w -- Function: move-group-down w These operate like their single-window counterparts. -- Function: raise-group w -- Function: lower-group w -- Function: raise-lower-group w -- Function: raise-group-depth w -- Function: lower-group-depth w These operate like their single-window counterparts. -- Function: set-group-frame-style w style This operates like its single-window counterpart.  File: sawfish.info, Node: Customization, Next: Window Frames, Prev: Windows, Up: Top 9 Customization *************** Sawfish provides two levels of configuration: 1. "customization": setting variables to change the behavior of existing features of the window manager, and, 2. "extensibility": the ability to add entirely new features to the window manager through the creation of new Lisp modules. Obviously the first of these requires a lot less specialized knowledge than the second. But even then, the user has to edit startup files containing the Lisp forms setting the variables. To remove this need for hand-editing, Sawfish has a specialized system allowing all customizations to be made through a GUI, and then automatically reloaded each time that the window manager is started. -- Command: customize &optional group Invoke the user-customization GUI. GROUP defines the class of customization variables to configure, or all classes if GROUP is undefined. The `sawfish-ui' program can be used to invoke the GUI manually; if GNOME is being used, then the GNOME Control Center can also be used to customize certain classes. In order to provide these customization options however, an extra requirement is placed on the Lisp programmer. Instead of just using the `defvar' special form to declare variables, the `defcustom' macro must be used. This augments the variable with extra information for the GUI, including such things as its required data type. * Menu: * Defgroup and Defcustom:: * Customization Files:: * Customized Variable Status::  File: sawfish.info, Node: Defgroup and Defcustom, Next: Customization Files, Prev: Customization, Up: Customization 9.1 Defgroup and Defcustom ========================== Customization options are organized into groups. Each group has a name and contains a set of related options. Groups can be assigned to parent groups using the `:group' parameter during construction. -- Macro: defgroup group real-name &rest keys Declares a new customization group whose name is defined by the symbol GROUP. The string REAL-NAME is the title of the group as seen by the user. KEYS is a list, defining the properties of the group. The members of the list are grouped into pairs of elements, the first element names the property, the second defines its value. `:group GROUP' Specifies the parent customization group of this group. The value of this key is not evaluated. `:require STRUCT' Before displaying the customization UI for this group, `require' the structure STRUCT. This guarantees that all customizable variables will be known at display time. The value of this key is not evaluated. `:layout SYMBOL' Use a particular UI widget to display this group. The value is a symbol, one of: `single' Holds a single customizable item. `vbox' Holds any number of customizable items, arranging them vertically. This is the default. `hbox' Holds any number of customizable items, arranging them horizontally. `frame' Embed the items in a vbox in a frame. `keymaps' Use a special UI widget for customizing keymaps. The value of this key is not evaluated. This macro also creates an interactive function named `customize:GROUP' allowing the GUI to be invoked to configure the new group. While `defgroup' is a macro, there is a corresponding `custom-declare-group' function. -- Macro: defcustom variable value documentation &rest keys The first three arguments are analogous to the `defvar' special form, they declare a special variable stored in the symbol VARIABLE, whose value is set to VALUE if the variable is currently unbound, with a documentation string DOCUMENTATION. All other parameters are key-value pairs as with `defgroup'. The possible pairs are as follows: `:group GROUP' Specifies the customization group that this variable is a member of. This is a list of symbols, indicating a series of nested groups, e.g., `(workspace edge-flip)'. A variable in a top-level customization group can also be specified as a plain symbol, e.g., `workspace'. The value of this key is not evaluated. `:type TYPE' Specifies the required type of the variable. The current possibilities are: ``(symbol [OPTION ...])'' A symbol. The UI looks for a symbol property `:options' and interprets it as the list of valid symbols to select from. The OPTION arguments allow you to define a list at eval time. It is also possible to change this list at run time by changing the custom symbol's `:options' property; see the access functions `custom-add-options' and `custom-set-options' for more information. ``(choice OPTION ...)'' One of the OPTION elements. Each OPTION is a symbol. Unlike the `symbol' type, there is no expectation that this list will change at run-time. ``string'' An arbitrary string. ``(number [[MIN] MAX]'' Integer number. Two additional arguments specify the minimum and maximum allowed values for the integer. One additional argument specified the maximum allowed value; the minimum defaults to zero. Zero additional arguments implies no minimum nor maximum. ``boolean'' True (`t') or false (`nil') value. ``color'' A color. ``font'' A font name. ``file'' A file name. ``program'' A file name that must be an executable program. ``command'' A Sawfish command. ``event'' A Sawfish event. ``keymap'' A Sawfish keymap. ``frame-style'' The name of a defined Sawfish frame style. ``icon'' An X icon. ``modifier-list'' A list of X modifier keys. Except where specified, the values of these keys are not evaluated. `:require FEATURE' Denotes that the feature FEATURE must be loaded if the variable is set to a non-`nil' value by user customizations. This is necessary because customization options are loaded on startup, possibly before the modules that define them. The value of this key is not evaluated. `:allow-nil BOOL' Specifies whether the variable may be `nil', instead of a member of its actual type. This is only supported by the `string', `symbol', `font' and `color' types. `:set FUNCTION' Specifies that the variable must be set by calling FUNCTION instead of the default `custom-set-variable'. The function should accept three arguments: `(VARIABLE VALUE &optional REQUIRE)'. The usual action of this function is to translate the value into the correct type, then call `custom-set-variable'. This translation is necessary since many of the UI widgets accept strings representing more complex types (i.e. a color's name, instead of the actual object) `:get FUNCTION' Provides a function for reading the current value of the variable. Should return a value that's acceptable to the UI widget associated with the variable. Called with a single argument, the symbol containing the variable. `:before-set FUNCTION' `:after-set FUNCTION' Functions called both immediately before and after setting the value of the variable. Called with a single parameter: the variable itself. `:range (MIN . MAX)' The allowed range for numeric variables. If MIN is `nil' the the default minimum allowed value is zero; if MAX is `nil' then the default maximum is unbounded. This is obsolete, since the `:number' type now supports range declarations. The value of this key is not evaluated. `:tooltop STRING' A tooltip that appears when the user's mouse hovers over the widget item. `:depends SYMBOL' This widget item is only settable when the symbol-value for SYMBOL is non-nil. While `defcustom' is a macro, there is a corresponding `custom-declare-variable' function. Note that where necessary the types themselves define default `:set', `:get' and `:widget' values that may be overridden by values in the `defcustom' call. Usually, however, this will not be necessary. Consider the following example: (defgroup move "Move/Resize") (defcustom move-outline-mode 'opaque "The method of drawing windows being moved interactively." :type (set opaque box) :group move) (defcustom move-snap-epsilon 8 "Proximity in pixels before snapping to a window edge." :group move :type (number 0 64)) This defines a group and two customization options. There are two special accessor functions to make it easier to deal with lists of allowed symbols. -- Function: custom-add-option variable option Add symbol value OPTION to the list of symbols that can be stored in VARIABLE. The new option goes on the end of the list. -- Function: custom-get-options variable Return the list of symbols that can be stored in VARIABLE.  File: sawfish.info, Node: Customization Files, Next: Customized Variable Status, Prev: Defgroup and Defcustom, Up: Customization 9.2 Customization Files ======================= -- Variable: custom-user-file User configuration settings are stored in the file referenced by this variable. While this file contains valid Rep forms, users should not edit it directly: Sawfish will overwrite the file's contents each time a customization is made through the GUI. By default, this variable is set to `"~/.sawfish/custom"'. The `--custom-file' command-line option sets it to a different file on program startup. -- Variable: custom-default-file Default customization settings are stored in the file referenced by this variable. These settings are only applied if the user has no personal settings. By default, this variable is set to `"sawfish/wm/custom-defaults.jl"' relative to the `sawfish-lisp-lib-directory' directory. -- Function: custom-load-user-file If the file referenced by `custom-user-file' exists, load it. Otherwise if `custom-default-file' is non-nil, interpret it as a filename and load it.  File: sawfish.info, Node: Customized Variable Status, Prev: Customization Files, Up: Customization 9.3 Customized Variable Status ============================== To get information about a customizable variable, you can use the following functions. -- Function: variable-customized-p symbol Returns true if SYMBOL has been customized by the user, false otherwise. -- Function: variable-declared-p symbol -- Function: variable-default-value symbol The `variable-declared-p' function returns true if the variable named SYMBOL has a default value declared for it, false otherwise. The `variable-default-value' function returns the default value of that variable, or nil if no such default value exists. -- Function: variable-type symbol Returns the customizable type of the variable named SYMBOL.  File: sawfish.info, Node: Window Frames, Next: Viewports, Prev: Customization, Up: Top 10 Window Frames **************** Perhaps one of the most important features of a window manager is its ability to decorate client windows, typically seen as an added border, and then to allow the window to be manipulated through user input on the border. Sawfish provides an extremely flexible method of decorating windows, the look and feel of the border may be specified completely. Also, no limits are placed on which windows are given which borders, if necessary a completely different border could be dynamically created for each window! * Menu: * Frame Basics:: * Frame Part Classes:: * Frame Part Definition:: * Frame Functions:: * Frame Types:: * Frame Styles:: * Themes:: * Removing Frame Parts::  File: sawfish.info, Node: Frame Basics, Next: Frame Part Classes, Up: Window Frames 10.1 Frame Basics ================= The "frame" of a client window is defined as all decorations added by the window manager. Usually these decorations will be immediately adjacent to the outer edges of the window, but there is no requirement to use this model. In Sawfish, each window frame is constructed from a list of "frame parts", conceptually rectangular objects with a specified position relative to the edges of the client window. When shaped images are used to define frame parts, they are still thought of as being rectangular, just with some pixels missing from the display. Each frame part has a list of attributes associated with it, these include items defining the background of the part (i.e. a color or an image), and items defining the foreground of the part (i.e. probably some kind of text, with a color, font, etc...). Non-visual attributes may also be defined, such as, for example, the keymap mapping events occurring in the part to Lisp commands to execute (*note Keymaps::). So a window frame is defined in Lisp as a list of frame part definitions (*note Frame Part Definition::). These frame parts are added to the client window (in the order they are defined, so later frame parts are above earlier parts at the same position), to produce the entire window frame.  File: sawfish.info, Node: Frame Part Classes, Next: Frame Part Definition, Prev: Frame Basics, Up: Window Frames 10.2 Frame Part Classes ======================= Although one of the aims of Sawfish is to provide as much flexibility as possible, this can sometimes be detrimental to the overall experience. For example, it would be easier for the user if all themes use consistent keymaps and cursor images in conceptually similar parts of window frames. That is, it would be better if all close buttons had the same mouse button bindings and the same mouse cursor displayed when the pointer is over them. To achieve this, Sawfish defines a number of "classes" of frame parts, each with several default attributes. When defining a window frame, the definitions of each part then specifies which class it is a member of, and inherits the associated default attributes (provided that it hasn't explicitly specified values for these attributes). -- Variable: frame-part-classes This variable is an association list, associating symbols naming frame part classes with an association list of default attributes for that class. The names of the pre-defined classes are as follows, their meanings should be self-explanatory: `title', `menu-button', `close-button', `iconify-button', `maximize-button', `top-border', `left-border', `right-border', `bottom-border', `top-left-corner', `top-right-corner', `bottom-left-corner', `bottom-right-corner'. Extra classes can be created by adding to `frame-part-classes'. However, it's likely that more than one theme may need to use the same class, and that the user may then wish to customize any extra keymaps used. The `def-frame-class' macro should be used to add new classes, since it handles these situations. -- Macro: def-frame-class class alist-form &rest binding-forms ... Creates a new frame part class named by the symbol CLASS. The ALIST-FORM is evaluated to give an association list defining attributes for the class. Each key-value pairs is only set if no existing value exists for that key. If BINDING-FORMS are given, they will be evaluated when no keymap already exists for the class. A keymap will be created, and stored in the variable named `CLASS-name'. This variable may then be used within the BINDING-FORMS. So to define a hypothetical `shade-button' class, the following might be used: (def-frame-class shade-button '((cursor . left_ptr)) (bind-keys shade-button-keymap "Button1-Off" 'toggle-window-shaded)) In some cases it might be valuable to be able to override pre-defined frame part properties. For example, it might be your preference that text in window title bars is always blue. -- Function: define-frame-class class alist-form &optional with-keymap Creates a new frame part class named by the symbol CLASS. Unlike `def-frame-class', the trailing argument is just a boolean flag. This flag only indicates whether to create a keymap for the class. Any bindings have to be established through a separate call to `bind-keys'. The function returns `t' if it was able to create and bind the empty keymap, `nil' otherwise. This allows us to check for errors. -- Variable: override-frame-part-classes Similar to `frame-part-classes' except that the properties take precedence over values defined both in that variable and in the frame style itself. The following function may be used to simplify the customization of these two variables: -- Function: set-frame-part-value class key value &optional override Associate VALUE with property KEY for all frame parts of class CLASS. If OVERRIDE is non-nil, then the setting is installed in the `override-frame-part-classes' variable, otherwise it's stored in the `frame-part-classes' variable. The following example would override the colors of all title bars: (set-frame-part-value 'title 'background '("black" "white" "green" "blue") t) (See the next section for details about what is actually being set here.)  File: sawfish.info, Node: Frame Part Definition, Next: Frame Functions, Prev: Frame Part Classes, Up: Window Frames 10.3 Frame Part Definitions =========================== Each frame part is defined as an association list (or alist), a list of cons cells, the car of each cell defines the attribute, the cdr defines the value given to that attribute. So, for example, the alist `((foo . 1) (bar . 2))' specifies two attributes: `foo' with value `1', and `bar' with value `2'. *Note Association Lists: (librep)Association Lists. The attributes that may be defined are as follows: `(class . CLASS)' Specifies the frame part class of the part. `(background . DATA)' `(background . (NORMAL FOCUSED HIGHLIGHTED CLICKED))' Specifies the background of the part. May be a color, an image, or a string naming a color. If a single element, then it is used for all states of the part, otherwise if a list, then each of the four elements defines the background for that particular state. If an image is used it will be scaled to the size of the frame part, unless it's `tiled' property is set, in which case it will be tiled across the frame part. `(foreground . DATA)' `(foreground . (NORMAL FOCUSED HIGHLIGHTED CLICKED))' Specifies a foreground color or image for the frame part, either for all states, or for each individual state. Unlike the `background' attribute, by default images are not scaled when used to define the foreground of a frame part. `(scale-foreground . VALUE)' When VALUE is non-`nil', the foreground image of the frame part will be scaled to the size of the part. `(font . FONT)' `(font . (NORMAL FOCUSED HIGHLIGHTED CLICKED))' Specifies the font(s) of the part. `(text . VALUE)' Specifies the string to draw in the foreground of the frame part (unless the `foreground' property is an image). Either a string, or a function, that will be called each time that the part is refreshed, that will return the string to draw. `(x-justify . VALUE)' Defines the horizontal position of the foreground contents of the part (i.e. the text or foreground image). May be one of the symbols `left', `right' or `center', or a number. If a number it defines the number of pixels from the left edge if positive, or the right edge if negative. `(y-justify . VALUE)' Similar to `x-justify', but the accepted symbols are `top', `bottom' or `center' instead. `(renderer . FUNCTION)' This attribute may be used instead of the `background' attribute. When the part needs to be drawn FUNCTION will be called with an image in which to render the background, and the current state of the part, a symbol `focused', `highlighted', `clicked', or `nil' (for the normal state). `(render-scale . VALUE)' This attribute causes the size of the image used with the `renderer' property to be reduced by a factor of VALUE, an integer. `(left-edge . VALUE)' Defines the position of the left edge of the part, in relation to the left edge of the client window. `(right-edge . VALUE)' Defines the position of the right edge of the part, in relation to the right edge of the client window. `(top-edge . VALUE)' Defines the position of the top edge of the part, in relation to the top edge of the client window. `(bottom-edge . VALUE)' Defines the position of the bottom edge of the part, in relation to the bottom edge of the client window. `(width . VALUE)' Defines the width of the frame part. `(height . VALUE)' Defines the height of the frame part. `(keymap . VALUE)' Defines the keymap to use when evaluating events originating in this frame part. `(cursor . CURSOR)' Defines the cursor to display when the mouse is in this part. May be either a cursor object, or the argument to `get-cursor' to create the required cursor object. `(removable . VALUE)' When specified and VALUE is non-`nil', this frame part may be removed from the frame without being detrimental to the overall appearance of the frame. This is only important for button classes, which may sometimes be removed at the request of the client window. `(below-client . VALUE)' When specified and VALUE is non-`nil', then this frame part will be displayed beneath the client window. The default action is for frame parts to be stacked above the client window. `(hidden . VALUE)' When specified and VALUE is non-`nil', don't display this frame part. The values specified for the `background', `foreground', `render-scale', `font', `left-edge', `right-edge', `top-edge', `bottom-edge', `width', `height', `cursor', `below-client' and `hidden' attributes may actually be functions. In which case the function will be called (with a single argument, the window object) when the frame is constructed, the value returned will be used as the actual value of the attribute. The coordinate system used for specifying the part's position is relative to the window edge that the position is defined against. Positive values count in from the window edge towards the center of the window, while negative values count out from the edge, away from the center of the window. Consider the following example, a solid black title bar that is twenty pixels high, directly above the client window: `((background . "black") (foreground . "white") (text . ,window-name) (x-justify . 30) (y-justify . center) (left-edge . 0) (right-edge . 0) (top-edge . -20) (height . 20) (class . title)) The backquote operator is used since the definition is only mostly constant, the comma operator inserts the value of the `window-name' variable (a function giving the name of a window) into the definition; *note Backquoting: (librep)Backquoting.). This function is then used to dynamically specify the string drawn in the foreground. The window manager will automatically refresh the foreground of all frame parts of a window whenever any X property of that window changes. Given a framed window, and a particular frame part class, it is possible to retrieve the values of individual attributes from the complete list of definitions (including inherited or overrided definitions). -- Function: frame-part-get part property Returns the value of the property PROPERTY for the frame part object PART. Returns `nil' if no such attribute exists. -- Function: frame-part-put part prop value Set the property PROP of frame part PART to VALUE. -- Function: frame-part-state part Return the current state for frame part PART, one of the symbols `focused', `highlighted', `clicked', `inactive-highlighted', `inactive-clicked', or `nil' if the part is inactive.  File: sawfish.info, Node: Frame Functions, Next: Frame Types, Prev: Frame Part Definition, Up: Window Frames 10.4 Frame Functions ==================== -- Function: set-window-frame window frame-def Sets the frame of the client window associated with the object WINDOW to that defined by the list of frame part definitions FRAME-DEF. If the window is mapped the old frame will be destroyed and a new frame constructed. -- Function: window-frame window Return the list of frame part definitions defining the frame associated with WINDOW. -- Function: window-framed-p window Return `t' when WINDOW has been reparented to a frame created by the window manager. -- Function: refresh-window window Refresh all the frame parts belonging to WINDOW. -- Function: rebuild-frame window Recreates the window frame associated with WINDOW, from the previously defined frame definition. All frame parts are reinitialized and recalibrated. -- Function: window-frame-dimensions window Return a cons cell `(WIDTH . HEIGHT)' defining the dimensions of the frame associated with WINDOW. These will always be greater than or equal to the dimensions of the client window. If WINDOW is not framed, then this function returns the same values as `window-dimensions' would. -- Function: window-frame-offset window Return a cons cell `(X . Y)' defining the offset from the origin of the client window associated with WINDOW to the origin of its frame. -- Function: window-border-width window Return the width of the border of the window that WINDOW manages. -- Function: clicked-frame-part Return a pointer to the frame part object that was clicked on as part of the current event. Returns `nil' if no frame part was clicked on. -- Function: frame-part-dimensions part Return a cons cell `(WIDTH . HEIGHT)' of dimensions for frame part PART. -- Function: frame-part-position part Return a cons cell `(X . X)' of the _relative_ position of frame part PART against its window's frame origin. -- Function: frame-part-window part Return the window object associated with this frame part. -- Function: frame-part-x-window part Return the X11 window ID associated with this frame part. -- Function: frame-draw-mutex lock Called with LOCK equal to `t', frame part redraws will be delayed. The redraws will take place once the function is called with LOCK set to `nil'. -- Function: map-frame-parts function window Call `(FUNCTION PART)' on each the frame parts of WINDOW and return `nil'. If any FUNCTION returns `nil', `map-frame-parts' returns `nil' immediately. -- Function: rebuild-frame-part part Build a new copy of the frame part PART and install the copy in the owning window, replacing the old part. -- Function: refresh-frame-part part The frame part PART will be redrawn at the next opportunity.  File: sawfish.info, Node: Frame Types, Next: Frame Styles, Prev: Frame Functions, Up: Window Frames 10.5 Frame Types ================ In order to visually differentiate between different types of windows, several predefined types of window frame exist. -- Function: window-type window Returns a symbol naming the frame type currently associated with WINDOW. These frame types currently include the following: `default' The normal frame type. Includes all decorations, both borders and the title bar. `transient' The frame for a transient window. This usually does not include a title bar, but does have all four borders. `shaped' Shaped windows are normally decorated with only a title-bar, since their boundary is not rectangular it makes no sense to surround them with a rectangular border. `shaped-transient' A combination of the `shaped' and `transient' types, normally just a very small title border with no text. `shaded' A shaded window (normally just the title bar). `shaded-transient' A shaded transient window. `unframed' No frame at all, just the client window itself. The predefined `nil-frame' variable contains a null frame that may be used for this frame type. -- Function: define-frame-type-mapper fun Function FUN maps from {WINDOW, FRAME-TYPE} to FRAME-TYPE. Each time we want to determine a window's frame-type (`shaded', `transient', etc.), we calculate an initial frame type with `window-type' and run the results through each frame type mapper in sequence (most recent to oldest). The frame type returned from the final mapper function is "the" frame type. This sequence of mappers allows us to override window frame types based on window properties. For example, any shaded window has to have `shaded' or `shaded-transient' type, regardless of what its normal type is. -- Function: window-type-add-border type -- Function: window-type-add-title type -- Function: window-type-remove-border type -- Function: window-type-remove-title type Given a window type of TYPE, return the closest matching window type with the given property change. For example: (window-type-add-title 'unframed) => 'shaped This is because shaped windows normally have title bars but not borders, while unframed windows normally have neither. -- Function: frame-type-menu window Returns a list of frame types, suitable for use by the graphical customizer. The frame type of WINDOW is automatically checked. We provide a function to simplify monitoring of window changes to certain window states. This monitoring runs on top of the `window-state-change-hook'. -- Function: call-after-state-changed states fun Arrange for function FUN to be called with arguments `(window changed-states)' when one of the states defined by the list of symbols STATES has been changed. STATES may also be a single symbol.  File: sawfish.info, Node: Frame Styles, Next: Themes, Prev: Frame Types, Up: Window Frames 10.6 Frame Styles ================= Frame styles are used to encapsulate frames of the different types that have a single visual appearance. Each frame style associates a name with a function that creates a frame definition for a particular window and frame type combination. Several window properties are used while choosing frame styles: -- Window Property: frame-style The user-chosen frame style of the window. If `nil', Sawfish will use the default frame style. -- Window Property: current-frame-style The current frame style of the window. This is not set explicitly; window update functions will change it behind the scenes. -- Window Property: ignored When set, the window is not given a frame. It is possible to edit certain frame styles in place with `sawfish-themer'. -- Function: frame-style-editable-p style Returns `t' if STYLE can be edited interactively, `nil' otherwise. -- Command: edit-frame-style style Prompts for a frame style (defaulting to the value of `default-frame-style'), and runs `sawfish-themer-program' on it. -- Function: reload-frame-style name Reloads the frame style NAME from disk if it is already known to the system. All windows with that style are reframed.  File: sawfish.info, Node: Themes, Next: Removing Frame Parts, Prev: Frame Styles, Up: Window Frames 10.7 Themes =========== Themes and frame styles are currently almost synonymous, the slight difference being that themes provide a mechanism for loading frame styles from the filing system as they are required. Although it is possible that themes may include other user-interface settings in a later version, at the moment it seems unlikely. When a frame style is requested, if it is not already available (i.e. if the `add-frame-style' function hasn't been called for that style) then the window manager will attempt to load a theme of the same name from the filing system. Each theme is stored in a directory; this directory must have the same name as the name of the theme itself. Within this directory there must be a Lisp script named `theme.jl' or `theme.jlc'. This script will be evaluated, it should provide a frame style of the same name as the theme (by calling `add-frame-style'). While the theme script is evaluating the `image-load-path' variable is set to include the theme directory as its first element. This ensures that any image files stored in the directory can be loaded using the `make-image' function. Since rep has no module system, any global variables defined within the theme must be prefixed by the name of the theme to ensure their uniqueness. For example, in the theme `foo', a variable `bar' would actually be called `foo:bar'. In most cases however, rep's lexical scoping can be used to avoid declaring any global variables or functions, the only usual exception is when declaring customization options with `defcustom'; these must be globally visible. Since themes are generally passed around very casually, sawfish evaluates all theme code in a very restricted environment; the idea being that themes should only be able to affect the look of the window manager. Despite this, it is still possible for malicious themes to lock, and possibly crash, the window manager; in the first case sending a `SIGINT' signal may unblock it. Hopefully themes are unable to affect the rest of the user's environment, but there are no guarantees... -- Variable: theme-load-path A list of directory names, provides the search path for locating theme directories. By default this includes the user's theme directory and the system theme directory. -- Variable: user-theme-directory The name of the user's theme directory, by default `~/.sawfish/themes'. -- Variable: system-theme-directory The name of the directory holding themes from the current Sawfish version, by default (expand-file-name "../themes" sawfish-lisp-lib-directory) -- Variable: site-theme-directory The name of the directory holding system-wide themes, by default (expand-file-name "../../themes" sawfish-lisp-lib-directory) -- Variable: theme-update-interval Number of seconds between checking if theme files have been modified. Default 60. -- Variable: themes-are-gaoled If `t', non-nil themes are assumed to be malicious. They will be evaluated in a restricted environment.  File: sawfish.info, Node: Removing Frame Parts, Prev: Themes, Up: Window Frames 10.8 Removing Frame Parts ========================= It is often useful to be able to disable certain parts of a window's frame. For example, a window may hint to the window manager that it doesn't want a maximize button. Sawfish allows all parts of a particular class to be disabled or enabled on a window by window basis. However, not all frame styles will support this (it depends on the frame part's `removable' property, *Note Frame Part Definition::). -- Function: add-frame-class window class Enable all frame parts that are a member of CLASS in WINDOW. -- Function: frame-class-removed-p window class Returns `t' if the frame part CLASS has been removed from WINDOW, `nil' otherwise. -- Function: remove-frame-class window class Disable all frame parts that are a member of CLASS in WINDOW where possible.  File: sawfish.info, Node: Viewports, Next: Workspaces, Prev: Window Frames, Up: Top 11 Viewports ************ It is sometimes useful to have a logical display that is larger than the computer screen. This is most often implemented by displaying only a portion of the logical display at any time. Sawfish does this using "viewports". When viewports are enabled, the Sawfish logical display becomes infinitely large in the two directions "across" and "down" (to the maximum representable size of integers). Sawfish divides this logical display into a potentially infinite grid of cells. Each cell of the grid is the same size of the virtual display. -- Variable: viewport-dimensions The current number of viewports across and down the virtual display. This is a cons cell `(ACROSS . DOWN)'. Defaults to `(1 . 1)'. -- Function: set-number-of-viewports width height Change `viewport-dimensions' to have the value `(WIDTH . HEIGHT)'. The user then tells Sawfish to move the physical display from cell to cell. On a cell change, windows in previous cells are removed, and windows in the current cell appear. Windows that span two or more cells will appear in each cell, appropriately displaced. Note that cell indices start at zero in each dimension. Indices are never negative. -- Function: screen-viewport Returns the currently displayed viewport as a pair `(X, Y)'. -- Function: set-screen-viewport col row Change the physical display to view cell `(COL, ROW)'. -- Function: move-viewport right down Move the viewport to see the cell RIGHT slots to the right and DOWN slots down. Either argument may be zero or negative. -- Function: set-window-viewport window col row Move WINDOW to the cell at `(COL, ROW)'. The relative position of the window within the cells is preserved. -- Function: move-window-viewport window col-delta row-delta Move WINDOW to the cell COL-DELTA positions across and ROW-DELTA positions down from its current cell. The relative position of the window with its cells its preserved. -- Function: move-viewport-to-window window Move the viewport to a cell that shows window WINDOW. For a window that spans multiple cells, this function will pick the cell showing the window's top-left corner. -- Function: move-window-to-current-viewport window Move WINDOW from its existing viewport to the current viewport. The window's relative position in the existing viewport is preserved after the move. -- Function: window-viewport window Returns a cons cell `(COL . ROW)' of the viewport holding the top-left corner of WINDOW. -- Function: window-outside-viewport-p window -- Function: window-outside-workspace-p window Returns true if WINDOW is completely outside the current viewport in any direction. The `window-outside-workspace-p' function is an obsolete alias for the first function; the "workspace" term is now used for another concept (*note Workspaces::). -- Function: window-absolute-position window Returns a cons cell `(X . Y)' of the position of WINDOW in its containing viewport. The containing viewport may or may not be the current viewport. -- Function: set-viewport x y Change the position of the physical display, such that location `(X, Y)' is at the top-left of the display. The physical display may be showing more than one cell at this point. All windows are redisplayed as appropriate. -- Variable: uniconify-to-current-viewport When true, windows uniconify to the current viewport, rather than to the viewport they were iconified on. Defaults to true.  File: sawfish.info, Node: Workspaces, Next: Multi-Head Environments, Prev: Viewports, Up: Top 12 Workspaces ************* Workspaces provide another way for users to organize their windows in Sawfish. Instead of stretching the screen real estate to the right and down, workplaces stack screens on top of each other. The user drills down into the stack, or pops up through the stack, seeing the appropriate windows in each workspace. * Menu: * Workspace Intervals:: ``Interesting'' workspaces * Workspace Manipulation:: Creating, rearranging, deleting * Workspaces and Windows:: Adding, removing * Edge Flipping:: Moving workspaces using the mouse  File: sawfish.info, Node: Workspace Intervals, Next: Workspace Manipulation, Prev: Workspaces, Up: Workspaces 12.1 Workspace Intervals ======================== While the stack of workspaces conceptually goes from negative infinity to positive infinity, we normally present only the first non-empty workspace through the last non-empty workspace to the user. The non-empty interval is occasionally re-normalized to start with zero. We typically refer to workplaces with lower IDs being to the "left" of workplaces with higher IDs, as if on a number line. -- Variable: current-workspace The ID of the currently active workspace. This is an integer. The "default" workspace has ID 0. -- Function: workspace-limits Returns a pair `(FIRST-INDEX . LAST-INDEX)' defining the subset of the workspace continuum that is "interesting" to the user (typically, all those that have ever been explicitly created). -- Function: workspace-id-to-logical space-id &optional limits Takes an absolute workspace ID and returns its position in the interval of "interesting" workspaces. If LIMITS is provided, it must be a pair `(FIRST-INDEX . LAST-INDEX)' like that returned by `workspace-limits'. If it is not provided, the function uses the result of `workspace-limits' directly. -- Function: workspace-id-from-logical offset &optional limits Takes an offset position into an interval of "interesting" workspaces, and returns the workplace ID at that position. If LIMITS is provided, it must be a pair `(FIRST-INDEX . LAST-INDEX)' like that returned by `workspace-limits'. If it is not provided, the function uses the result of `workspace-limits' directly. -- Function: popup-workspace-list Display the menu containing the list of all workspaces. -- Function: workspace-menu Returns a list of workspaces, suitable for display in a menu. -- Customizable: workspace-names A list of workspace names. When displaying the workspace menu, the first N workspaces use the corresponding list elements as their display names (where N is the length of the list). Normally they get the display name `space N' for some value of N.  File: sawfish.info, Node: Workspace Manipulation, Next: Workspaces and Windows, Prev: Workspace Intervals, Up: Workspaces 12.2 Workspace Manipulation =========================== Sawfish has various functions to create, rearrage and delete workspaces. Windows in a deleted workspace are not lost; they are moved to another workspace. -- Function: select-workspace space &key dont-focus force Activate workspace SPACE, making it current. By default in `enter' and `click' focus modes, the most recently used window will receive focus. The caller can disable this behavior by passing a true DONT-FOCUS keyword argument. If the FORCE keyword argument is true, we will go through the activation process even if SPACE already is current. -- Function: select-workspace-from-first count Select the workspace in position COUNT from the list of "interesting" workspaces. -- Function: select-workspace-and-viewport space col row Select workspace SPACE and then switch to viewport `(COL, ROW)' in that workspace. -- Function: insert-workspace &optional before Insert a new workspace, returning its index. The new index appears before the workspace indicated by BEFORE, or the current workspace if BEFORE is `nil'. -- Function: insert-workspace-after Create a new workspace following the current workspace. -- Function: insert-workspace-before Create a new workspace preceeding the current workspace. -- Function: move-workspace space count Move the workspace SPACE COUNT positions forward, or COUNT positions backwards if COUNT is negative. -- Function: move-workspace-forwards &optional count Move the current workspace one place to the right (or COUNT places to the right if COUNT is defined). -- Function: move-workspace-backwards &optional count Move the current workspace one place to the left (or COUNT places to the left if COUNT is defined). -- Function: next-workspace count -- Function: previous-workspace count Switch from the current workspace (index I) to the workspace I+COUNT. The `previous-workspace' function is identical to `(next-workspace (- COUNT))'. These functions do not have default values for their COUNT arguments. -- Function: remove-workspace &optional index Remove workspace INDEX (or the current workspace if INDEX is `nil'). All windows in that workspace are moved to the next workspace INDEX+1. This will change the set of "interesting" workspaces. -- Function: merge-next-workspace Delete the current workspace. Its member windows are relocated to the next workspace. -- Function: merge-previous-workspace Delete the current workspace. Its member windows are relocated to the previous workspace. -- Function: set-number-of-workspaces wanted Add or remove workspaces until the number of "interesting" workspaces is equal to WANTED. When adding workplaces, the new workplaces get indices higher than any existing indices. When removing workplaces, the lowest workplaces are always chosen for removal (their windows are merged into the new lowest-index workspace). -- Variable: lock-first-workspace When true, preserve the outermost empty workspaces in the pager. Don't quietly remove them when they become empty. Defaults to true.  File: sawfish.info, Node: Workspaces and Windows, Next: Edge Flipping, Prev: Workspace Manipulation, Up: Workspaces 12.3 Workspaces and Windows =========================== Workspaces do not need to have windows assigned to them, but most operations with workspaces involve adding and removing windows. -- Function: all-workspaces Returns a list of indices for all workspaces that contain windows. Sticky windows appear in the current workspace. -- Function: workspace-empty-p space Returns true if workspace SPACE contains zero (non-sticky) windows. -- Function: delete-empty-workspaces Delete any workspaces that don't contain any windows. -- Variable: workspace-boundary-mode How to act when passing the first or last workspace, one of `stop', `wrap-around' or `keep-going'. Defaults to `stop'. Each window can be a member of any (positive) number of workspaces; their `workspaces' property contains a list of workspace ids. Sticky windows appear on all workspaces, and have their `sticky' property set (with a null `workspaces' property). If Sawfish begins managing a window with its `workspaces' property set, then the window is added to those workspaces automatically. -- Function: window-in-workspace-p window space Returns true if WINDOW is a member of workspace SPACE, false otherwise. -- Function: window-appears-in-workspace-p window space Returns true if WINDOW appears in workspace SPACE, false otherwise. To appear, WINDOW has to be visible, but it can either be assigned to the workspace or be sticky. -- Function: windows-share-workspace-p window1 window2 Returns true if WINDOW1 and WINDOW2 are members of at least one common workspace. -- Function: nearest-workspace-with-window window space Returns the nearest workspace to SPACE that contains WINDOW. -- Function: workspace-windows &optional space include-iconified Returns a list of all windows that are members of the current workspace (or SPACE if it is not `nil'). The list normally does not contain iconified windows, but they can by included by specifying a true INCLUDE-ICONIFIED argument. -- Function: popup-window-menu Display the menu of all managed windows. -- Function: move-window-to-workspace window old new &optional was-focused Move WINDOW from workspace OLD to workspace NEW. We need the old workspace as an explicit argument because a window can be in more than one workspace. The function does the right thing if the window already appears in workspace NEW. If WAS-FOCUSED is true and the window is visible, it gets the input focus in the new workspace. -- Function: copy-window-to-workspace window old new &optional was-focused Arrange it so WINDOW appears in both OLD and NEW workspaces. If WAS-FOCUSED is true and the window is visible, it gets the input focus in the new workspace. -- Function: send-to-next-workspace window count &optional copy select Move the window COUNT workspaces to the right. COUNT does not default to one. The window is normally removed from the current workspace (if it is in that workspace), or from the first workspace it belongs to. Supplying a true COPY argument causes Sawfish to copy the window instead. If SELECT is true, then we switch to the destination workspace. If the moved window had input focus before the move, it will have input focus after the move as well. -- Function: send-to-previous-workspace window count &optional copy select Move the window COUNT workspaces to the left. COUNT does not default to one. The window is normally removed from the current workspace (if it is in that workspace), or from the first workspace it belongs to. Supplying a true COPY argument causes Sawfish to copy the window instead. If SELECT is true, then we switch to the destination workspace. If the moved window had input focus before the move, it will have input focus after the move as well. This is identical to `(send-to-next-workspace window count copy select)'. -- Function: copy-to-next-workspace window count select Copy the window COUNT workspaces to the left. COUNT does not default to one. If SELECT is true, then we switch to the destination workspace. If the moved window had input focus before the move, it will have input focus after the move as well. This is identical to `(send-to-next-workspace window count t select)'. -- Function: copy-to-previous-workspace window count &optional select Copy the window COUNT workspaces to the right. COUNT does not default to one. If SELECT is true, then we switch to the destination workspace. If the moved window had input focus before the move, it will have input focus after the move as well. This is identical to `(send-to-previous-workspace window count t select)'. -- Function: send-window-to-workspace-from-first window count &optional copy select Move WINDOW to the workspace at position COUNT in the "interesting" list. The window is normally removed from the current workspace (if it is in that workspace), or from the first workspace it belongs to. Supplying a true COPY argument causes Sawfish to copy the window instead. If SELECT is true, then we switch to the destination workspace. If the moved window had input focus before the move, it will have input focus after the move as well. -- Variable: workspace-send-boundary-mode How to act when passing the first or last workspace, while moving a window. One of `stop', `keep-going', `wrap-around'. Defaults to `stop'. -- Function: delete-window-instance window Remove the copy of WINDOW on the current workspace. If this is the last instance remaining, then delete the actual window. Note that this behavior differs from the merging that happens when you delete a workspace. -- Function: map-window-workspaces fun window Map function FUN over all workspaces containing WINDOW. When a window appears on more than one workspace, some of its properties may be swapped in and out on demand when the current workspace is changed. -- Variable: workspace-local-properties Window properties whose values may differ on differnet workspaces. Defaults to the empty list. -- Variable: add-swapped-properties props Add all properties in the list PROPS to WORKSPACE-LOCAL-PROPERTIES. It is possible to hide all "normal" windows across workspaces. "Normal" in this case excludes desktop windows and dock windows, but includes sticky and ignored windows. The hidden windows are no longer considered "viewable" according to `window-viewable-p'. -- Function: show-desktop Hide all windows except the desktop and dock windows. -- Function: hide-desktop Undo the effects of the `show-desktop' command. -- Function: showing-desktop-p Return true if non-desktop and non-dock windows are hidden, false otherwise.  File: sawfish.info, Node: Edge Flipping, Prev: Workspaces and Windows, Up: Workspaces 12.4 Edge Flipping ================== Sawfish provides a way to flip between workspaces (or viewports) automatically by moving the mouse to the edge of the screen. The technique is called "edge flipping". These definitions are stored in the `sawfish.wm.ext.edge-flip' structure. They can only be enabled through the customization interface. -- Customizable: edge-flip-enabled nil When true, select the next desktop when the pointer hits screen edge. Defaults to false. -- Customizable: edge-flip-type Indicates what is selected when hitting the screen edge. Must be one of `viewport' or `workspace'. Defaults to `workspace'. -- Customizable: edge-flip-only-when-moving When true, Sawfish only flips when the user is interactively moving a window. Defaults to false. This variable is not customizable, but it can be edited. -- Variable: edge-flip-delay Milliseconds to delay before edge flipping. Defaults to 250. Flippers are implemented as invisible windows on the edges of the display (the windows overlap at the corners). When the pointer moves over any of these windows, Sawfish generates `enter-flipper-hook' and `leave-flipper-hook' events. Programmers can add their own callbacks to perform other actions with the flippers. This depends on manually enabling the flippers, using the following functions in the `sawfish.wm.util.flippers' structure. Note that you may have to manually remove the `edge-flip-enter' and `edge-flip-leave' callbacks from the hooks before adding your own callbacks. -- Function: enable-flippers Add edge windows used to implement flipping. -- Function: disable-flippers Remove the edge windows used to implement flipping.  File: sawfish.info, Node: Multi-Head Environments, Next: Window Placement, Prev: Workspaces, Up: Top 13 Multi-Head Environments ************************** Sawfish has special functions to support environments with multiple monitors displaying a single logical screen (as provided by Xinerama). -- Function: find-head x y Return a ID for the display head that point (X, Y) is in. The return value is an integer; the default head has ID zero. Returns `nil' if it cannot determine the head from X and Y. -- Function: head-count Return the number of display heads on the machine. -- Function: head-dimensions id Return the cons cell `(WIDTH . HEIGHT)' of the dimensions of the display head indicated by ID. ID must be a non-negative integer. Without Xinerama support, ID must be zero and the function returns the screen size. -- Function: head-offset id Return the cons cell `(X . Y)' of the dimensions of the display head indicated by ID. ID must be a non-negative integer. Without Xinerama support, ID must be zero and the function returns `(0 . 0)'. -- Function: pointer-head Return the ID of the head containing the mouse pointer. -- Function: current-head &optional window Return the ID of the head containing the window with input focus. If WINDOW is supplied and a window, return the head containing that window. If WINDOW is supplied and NIL, return `(pointer-head)'. -- Function: current-head-dimensions &optional window Return a cons-cell defining the size in pixels of the current head (that containing the window WINDOW, or the pointer if WINDOW is false). Returns the screen dimensions if no such head can be identified. -- Function: current-head-offset &optional window Return a cons-cell defining the origin of the current head (that containing the window WINDOW, or the pointer if WINDOW is false). Returns `'(0 . 0)' if no such head can be identified.  File: sawfish.info, Node: Window Placement, Next: Popup Menus, Prev: Multi-Head Environments, Up: Top 14 Window Placement ******************* Sawfish supports multiple ways of placing new windows on the display. There is a "current" placement mode for normal windows, and another mode for transient windows. -- Variable: place-window-mode A symbol indicating the method of placing normal windows. This defaults to `top-left'. -- Variable: place-transient-mode A symbol indicating the method of placing transient windows. This defaults to `centered-on-parent'. -- Function: placement-mode name Return the placement mode object corresponding to NAME. -- Variable: placement-modes List of names of all placement modes. Sawfish 1.3 ships with the following placement modes: * `randomly' The new window is placed at a random location on the screen. * `interactively' Prompt the user to select a position with the mouse. The new window is created such that its top-left corner is at that position. * `centered' The new window is created at the center of the screen. * `centered-on-parent' The new window has a parent, it is centered on that parent. If the new window instead has a focused window in the same group, it is centered on that focused window. Otherwise the new window is simply `centered'. * `under-pointer' Create the new window so that it's under the pointer, without going off the edge of the screen. * `first-fit' * `best-fit' Look for positions where the new window would have a small overlap area with already visible windows. The `first-fit' algorithm uses the first "good" position found. The `best-fit' algorithm looks at all possible positions and picks the best of them. * `best-fit-group' As `best-fit', but the new window is only checked for overlap with other windows in its group. * `first-fit-or-interactive' As `first-fit', but if Sawfish cannot find a "good" position, it falls back to `interactively' mode. * `stagger' Attempts to place each new window below and to the right of the previous window. See `stagger-placement-step'. * `top-left' Interpret the top-left to bottom-right screen diagonal as a series of slots, each of which may have a window. Find the first empty slot and place the window there. _Sawfish will shrink the window to prevent it from going past the right or bottom edge, or even beneath a special window like a panel._ If Sawfish is not allowed to shrink the window enough to prevent this, it instead places the window randomly. * `off-center' Tries to put windows in the center of the screen, but in such a way that the newly placed window doesn't fully obscure an existing window. This is to handle the case where two windows of the same size are created one after the other, so that the user is sure to see (at least part of) both windows. Make no changes to the window's position. The window remains wherever the X server placed it initially. In all of these placement modes, the mode is responsible for taking the window object as an argument, and manipulating its position with, e.g., `move-window-to'. -- Variable: stagger-placement-step In `stagger' placement mode, the distance down and to the right from the previously placed window to the new one. This is measured in pixels. There are two circumstances in which Sawfish will place a window: either the window has just been created, or Sawfish has begun managing the window's display. In the latter case, the window will have the `placed' property. -- Variable: ignore-program-positions When `t', program position size hints are not considered when placing windows. "Avoided" windows should be kept unobscured by other windows wherever possible. In particular, first-fit and best-fit methods will attempt to place new windows away from them, and maximized windows will not stretch over them. -- Function: window-avoided-p window Return t if WINDOW should be kept unobscured by other windows wherever possible. -- Function: avoided-windows &optional window Returns a list of all windows that should be left unobscured where possible. If WINDOW is defined, then it defines a window that will be never returned in the list. -- Variable: dont-avoid-ignored When non-nil, ignored windows aren't avoided by default. Defaults to non-nil. -- Variable: avoid-by-default When non-nil, any unspecified windows are avoided by default. Defaults to nil. You can define your own placement modes. -- Function: define-placement-mode name fun &keywords for-normal for-dialogs Define a new window placement mode called NAME (a symbol). The function FUN will be called with a single argument when a window should be placed using this mode. The single argument is the window to be placed. If the FOR-NORMAL keyword is `t', then this placement mode is marked as valid for `place-window-mode'. The same applies to FOR-DIALOGS and `place-transient-mode'. -- Function: autoload-placement-mode name module-name &keywords for-normal for-dialogs Define placement mode NAME (a symbol) to be loaded from structure STRUCTURE-NAME (a symbol) when first referenced. The KEYWORD-ARGS are passed along to the call to `define-placement-mode' that creates the placement mode.  File: sawfish.info, Node: Popup Menus, Next: Events, Prev: Window Placement, Up: Top 15 Popup Menus ************** Popup menus are one of the two main methods through which the user may invoke Lisp code (the other is via keymaps, *note Keymaps::). The `popup-menu' function is invoked with a list of menu item definitions and the associated Lisp function to call for each item. This starts a subprocess to display the menu, then at a later date the chosen menu item is received and evaluated. Each menu item is specified by a list, the first element of which is a string providing the label for the menu item, the second element is a function to be called if that item is selected by the user. If this function has an interactive specification it will be invoked using the `call-command' function, otherwise `funcall' will be used. Alternatively the second element may be a lisp form to evaluate. So, for example, a single-level menu could be defined by: (("Item 1" function-1) ("Item 2" function-2) () ("Item 3" function-3)) The null item will create a separator line in the displayed menu. If the cdr of first element of any item is a symbol, then the rest of the item is defined by the value of the named variable. If this value is functional then the definition is found by calling the function. Consider the following definition: (("Workspaces" . workspace-menu) ("Windows" . window-menu) ("Programs" . apps-menu) ("Customize" . custom-menu) ("About..." (customize 'about)) () ("Restart" restart) ("Quit" quit)) This is the definition of Sawfish's root menu. We can see that four submenus are created dynamically by dereferencing variables (in fact, three of this variables contain functions) (`workspace-menu', `window-menu', `apps-menu' and `custom-menu'). Note that these must be special variables, i.e. initially declared using the `defvar' special form. The `apps-menu' variable can thus be used to redefine the applications menu. The default definition is as follows: (("xterm" (system "xterm &")) ("Emacs" (system "emacs &")) ("Netscape" (system "netscape &")) ("The GIMP" (system "gimp &")) ("XFIG" (system "xfig &")) ("GV" (system "gv &")) ("xcalc" (system "xcalc &"))) The `system' function simply executes its single argument using `/bin/sh'. When displaying a menu item, it is possible to also display the corresponding keyboard shortcut in the menu. -- Variable: menus-include-shortcuts When true, menu items also display key-binding information. Defaults to false. The actual creation of a menu is performed by an auxiliary process, distributed with Sawfish. Since the overhead of starting the menu subprocess may be noticeable on some systems, it is possible to leave it running between menu requests. -- Variable: menu-program Location of the program implementing Sawfish's menu interface. -- Variable: menu-program-stays-running This variable defines if, and for how long, the menu subprocess is allowed to remain executing for after the last menu has completed. If `nil', the program is terminated immediately, if `t' it is left running indefinitely, if an integer then the program will run for that many seconds (unless another menu is displayed). The actual interface to invoke the external menu program is hidden in the `popup-menu' function. -- Function: popup-menu spec Displays a menu defined by the list of item definitions SPEC. In addition, Sawfish provides various canned menus, and functions to display those menus. -- Variable: root-menu Contains the root menu definition. -- Function: popup-root-menu Display the main menu. By default, this is bound to Button2-click on the root window. -- Variable: apps-menu The variable containing the definition of the applications submenu of the root menu. The default root menu includes this as a child menu. -- Function: popup-apps-menu Display the applications menu. -- Function: window-ops-menu The variable containing the definition of all window operations. -- Function: popup-window-menu Display the menu listing all window operations. This has several bindings by default. In particular, clicking on a window's menu button displays this menu. -- Variable: window-ops-toggle-menu A list of flags describing windows, e.g., "sticky" or "shaded". This list is displayed in a menu, and by selecting items in this menu a user can turn the flags on and off for a given window. -- Function: add-window-menu-toggle label command &optional predicate Add additional flags to `window-ops-toggle-menu'. The COMMAND is a function (or a symbol pointing to a function) that gets run when the menu item is selected. If PREDICATE is non-nil, it must be a function taking a window as argument. If PREDICATE return true, the menu item will have a check mark next to it.  File: sawfish.info, Node: Events, Next: Commands, Prev: Popup Menus, Up: Top 16 Events ********* Events refer to input events from X that the window manager receives, either for the root window, the window frames it creates, or grabbed from the client windows themselves. Each event induced by the mouse or keyboard has a Lisp representation. -- Function: eventp object This function returns `t' if its argument is an input event. * Menu: * Event Representation:: Objects versus string names * Event Modifiers:: Meta, Alt, Buttons * Event Actions:: Keys and Clicks * Event Matching:: * Synthetic Events:: Creating events that seem real  File: sawfish.info, Node: Event Representation, Next: Event Modifiers, Prev: Events, Up: Events 16.1 Event Representation ========================= Each input event is represented by a cons cell containing two integers, and these integers encode the event. The encoding is opaque; the only way to access an event meaningfully is via the functions provided. Each event has a string representation, called its "name". Names consist of zero or more modifiers, followed by a key or mouse action indicator. Modifiers are separated from succeeding elements by hyphens `-'. For example, hitting while holding down the and keys would generate an event named . This notation is designed to closely match Emacs Lisp's notation. Functions are available to convert between the name of an event and the actual event itself, and vice versa. -- Function: lookup-event event-name Create and return a new input event whose name is EVENT-NAME. (lookup-event "C-x") => (120 . 65540) (lookup-event "C-M-Button1-Click1") => (1 . 131340) -- Function: event-name event This function returns a string naming the input event EVENT. (event-name (lookup-event "C-x")) => "C-x"  File: sawfish.info, Node: Event Modifiers, Next: Event Actions, Prev: Event Representation, Up: Events 16.2 Event Modifiers ==================== Sawfish event modifiers are copied directly from the standard X modifiers: The standard X modifier names are provided, as well as four special modifiers , and that are mapped to the keysyms of the same name. The following table lists the possible modifier prefixes: The control modifier The meta modifier The alt modifier The shift modifier The hyper modifier The super modifier; note that this is a lowercase `s' The standard X modifiers, for K between 1 and 5 A special modifier that matches any set of modifiers in events. *Note Event Matching::. A special modifier that matches key release events, not the default key press events. Mouse events never have modifiers; they have separate actions instead. *Note Event Actions::. The K'th mouse button is currently pressed. A placeholder "window manager" modifier that can be bound to a real modifier on the fly. See `wm-modifier' below. The default Sawfish bindings use the modifier. For convenience, if no X keysym generates , Sawfish will treat the first defined modifier of , and (in that order) as . The mapping from keysyms to modifiers is exposed in the following variables: -- Variable: meta-keysyms A list defining the names of the X keysyms generating the virtual `Meta' or `M' modifier. -- Variable: alt-keysyms A list defining the names of the X keysyms generating the virtual `Alt' or `A' modifier. -- Variable: hyper-keysyms A list defining the names of the X keysyms generating the virtual `Hyper' or `H' modifier. -- Variable: super-keysyms A list defining the names of the X keysyms generating the virtual `Super' modifier. There are two functions to manipulate the placeholder "window manager" () modifier. Unfortunately, these are low-level functions that operate on integer encodings. -- Function: wm-modifier Return the current value (an integer) of the placeholder "window manager" () modifier. -- Customizable: wm-modifier-value An integer encoding zero or more modifier keys that form the placeholder "window manager" () modifier. Setting this value through the customization UI automatically calls `set-wm-modifier'. -- Function: set-wm-modifier modifiers Set the value of the placeholder "window manager" () modifier to MODIFIERS (an integer).  File: sawfish.info, Node: Event Actions, Next: Event Matching, Prev: Event Modifiers, Up: Events 16.3 Event Actions ================== Sawfish recognizes keyboard actions and mouse actions. Key Press Key Release Keys pressed on the keyboard generate one or more key press events, followed by a key release event. Bindings normally recognize key press events only. To recognize key releases, add a modifier to the bound event. Generally keys have the same names as their X keysyms. The following unusual names are worth listing: `SPC', `TAB', `RET', `ESC', `BS', `DEL', `Up', `Down', `Left', `Right'. For example, pressing the key while is held down generates a `Control-DEL' event, while releasing the key while is held down generates a `H-Release-a' event. Button Clicks Button presses generate actions. If Sawfish receives several clicks in close succession (less than `multi-click-delay' milliseconds between clicks), the second and third events are and , respectively. Any further clicks are simple events. For consistency, is a synonym for . Button Releases Once the button has been released from a action, Sawfish receives a corresponding action. The actions and are synonyms. Pointer Motion Pointer motion generates actions. The action does not indicate anything about the pointer position; use e.g., `query-last-pointer' to find that information. For example, a single click of the left mouse button with the key held would be described as `M-Button1-Click1'. After triple-clicking with the key held down, Sawfish will receive a `Alt-Off3' event. -- Variable: multi-click-delay An integer indicating the maximum number of milliseconds between successive clicks. Defaults to 250 milliseconds at startup; if `nil', Sawfish uses 250 milliseconds.  File: sawfish.info, Node: Event Matching, Next: Synthetic Events, Prev: Event Actions, Up: Events 16.4 Event Matching =================== There is a special function that matches event objects. If the actions of two event objects are not identical, the events do not match. If they are identical, then the events match if the modifiers are identical, or if one of the modifiers is . *Note Event Modifiers::. -- Function: event-match ev1 ev2 Returns `t' if events EV1 and EV2 match, `nil' otherwise.  File: sawfish.info, Node: Synthetic Events, Prev: Event Matching, Up: Events 16.5 Synthetic Events ===================== It is possible to create an event inside Sawfish that mimics a real keyboard or mouse event. -- Function: synthesize-event event window &optional propagate Generate a synthetic key press or button press and send it to the X window bound to the WINDOW object. This press is automatically followed by the appropriate release event. The current pointer position becomes the position of the event. EVENT is either an event object, or the string representation of an event (such as `"A-f"' or `"C-M-Button3-Click2"'). Strings are parsed into event objects before any work is done. *Note Event Representation::. If PROPAGATE is true, the event will propagate up the window ancestor chain until it is handled.  File: sawfish.info, Node: Commands, Next: Keymaps, Prev: Events, Up: Top 17 Commands *********** A "command" is a Lisp function which may be called interactively, that is, as a result of being bound to an input event. To support this, we mark them with metadata that the runtime system can query. * Menu: * Old-style Command Definition:: Emacs-Lisp style * New-style Command Definition:: Common-Lisp style * Interactive Calling Specification:: * Operations on Commands:: Accessors and the like * Invoking Commands:: call-commmand, command hooks * Default Commands:: Sawfish ships with a few commands  File: sawfish.info, Node: Old-style Command Definition, Next: New-style Command Definition, Prev: Commands, Up: Commands 17.1 Old-style Command Definition ================================= The old-style command declaration syntax looks very much like that of GNU Emacs Lisp. Commands are defined like any other function (using `defun'), but the first form in the body must be an "interactive declaration". This marks that the function may be called interactively and tells the `call-command' function how to compute the argument values to apply to the command. The interactive declaration looks like a call to the special form `interactive', in actual fact this special form always returns `nil' and has no side-effects. The only effect of this form is to show the `call-command' function that the function definition may be called interactively. The second element of the declaration form (after the `interactive' symbol) defines how the argument values applied to the command are computed. The structure of an interactive declaration, then, is: (interactive [CALLING-SPEC]) When a command is defined this is how it includes the interactive declaration: (defun some-command (arg1) "Optional documentation string." (interactive ...) ... The CALLING-SPEC is defined in *Note Interactive Calling Specification::.  File: sawfish.info, Node: New-style Command Definition, Next: Interactive Calling Specification, Prev: Old-style Command Definition, Up: Commands 17.2 New-style Command Definition ================================= The new syntax does not depend on special magic in `defun'. Instead, it uses keyword arguments to indicate the calling specification and other properties. -- Function: define-command name fun #!key spec type doc doc-key class Define a window managed command called NAME (a symbol). The function FUN will be called to execute the command. SPEC and TYPE may be used to define the arguments expected by the command; SPEC is an interactive specification and TYPE is a custom-type specification. *Note Interactive Calling Specification::. DOC is the documentation string associated with the command. The command-documentation may be stored in the doc file, rather than in the code itself; if it exists, the DOC-KEY will be used to look up the doc file entry. If both arguments are provided, both will be stored. But the `command-documentation' function favors the built-in doc string over the doc file entry. CLASS is an annotation for the command. It allows the definition to mark the class as `'advanced', for example. Other parts of Sawfish can then take advantage of this note. -- Function: define-command-to-screen name fun #!key spec type doc doc-key class As `define-command', but any printed output of FUN is sent to the screen. -- Function: autoload-command name module #!key spec type doc doc-key class Record that loading the module called MODULE (a symbol) will provde a command called NAME. The keyword values have the same meanings as for `define-command'. Defining those properties as part of the autoload provides useful feedback to the user without having to do loading.  File: sawfish.info, Node: Interactive Calling Specification, Next: Operations on Commands, Prev: New-style Command Definition, Up: Commands 17.3 Interactive Calling Specification ====================================== The CALLING-SPEC argument to `interactive' or `define-command' defines the argument values applied to the command when it is called interactively. It may be one of: * `nil' or undefined (i.e. `(interactive)') No arguments are given to the command, this type of interactive declaration just shows that the function may be called interactively. * A string This is interpreted as zero or more lines (each separated by a newline character). Each line defines how to compute one argument value. The first one or two characters of each line is a prefix defining exactly how to compute the argument, the rest of the line is an optional argument which some prefixes may use. See below for a list of prefixes. A null line produces an argument value of `nil'. * Anything else The form is evaluated and expected to return a _list_ of arguments to apply to the command. The currently available prefixes are, `e' The event which caused this command to be invoked. `E' The event which caused this command, cooked into a string. `p' The prefix argument as a number, this will be 1 if no prefix argument has been entered. `P' The raw prefix argument. `t' The symbol `t'. `%f' The window which currently has the input focus, or `nil' if no window is focused. `%w' The result of calling the `current-event-window' function. `%W' The result of calling the `current-event-window' function, or if this returns `nil' or `root', the currently focused window.  File: sawfish.info, Node: Operations on Commands, Next: Invoking Commands, Prev: Interactive Calling Specification, Up: Commands 17.4 Operations on Commands =========================== Once a command has been defined, we can extract certain information about it. -- Function: commandp OBJECT This function returns `t' if its argument may be called interactively. If OBJECT is a function (i.e. a symbol or a lambda-expression) it is a command if it contains an interactive declaration The only other object which is a command is a function call form; the use of these types of commands is discouraged but they can be useful sometimes. -- Function: command-documentation name Return the documentation for the command NAME. It returns the first documentation found by looking at (in order): the documentation property of the command; the doc file entry associated with the doc key property; or the documentation for the function with the same name. -- Function: command-spec name -- Function: command-type name -- Function: command-class name Return the specification, type or class (respectively) of the named command.  File: sawfish.info, Node: Invoking Commands, Next: Default Commands, Prev: Operations on Commands, Up: Commands 17.5 Invoking Commands ====================== When a command is to be invoked, the `call-command' function is used. This builds a list of argument values to apply to the command (using its interactive declaration) then calls the command. -- Function: call-command command &optional prefix-arg This function calls the command COMMAND interactively. See the documentation of `commandp' above for what constitutes a command. If the PREFIX-ARGUMENT is non-nil it defines the value of the `current-prefix-arg' variable for this command, normally the value of this variable would be taken from the global `prefix-arg' variable. There is a corresponding `call-command' command that prompts for a command to execute. -- Function: apply-command name &rest args Call the function underlying the command NAME, passing in ARGS as the arguments. This is useful for calling a command in a non-interactive context. -- Variable: current-prefix-arg When invoking an interactive command, this is set to the current prefix argument. -- Variable: this-command The command currently being called, or `nil' if no command is being called. -- Variable: last-command The command previously called, or `nil' if there is no such command. *Note Command Hooks::, for hooks run before and after commands.  File: sawfish.info, Node: Default Commands, Prev: Invoking Commands, Up: Commands 17.6 Default Commands ===================== Sawfish defines several commands by default. -- Function: run-shell-command The command prompts the user for a string, and executes that string as under `system'. -- Function: quit -- Function: restart -- Function: destroy-window -- Function: kill-client -- Function: no-operation Calls the function of the same name. `destroy-window' and `kill-client' both take `%W' as argument.  File: sawfish.info, Node: Keymaps, Next: Event Loop, Prev: Commands, Up: Top 18 Keymaps ********** Keymaps are used to associate events with commands. When an event occurs, the associated command is found and evaluated. A keymap is simply a list whose first element is the symbol `keymap'. -- Function: keymapp arg Returns `t' if ARG may be used as a keymap. -- Function: make-keymap Returns a newly-created empty keymap. -- Function: bind-keys keymap &rest bindings Installs zero or more key bindings into the keymap KEYMAP, then returns KEYMAP. Each binding is defined by two elements in the list of BINDINGS, the first defines the name of the input event (or the event itself) and the second defines the command to be associated with the event. For example to bind two keys in the keymap KEYMAP; the event `C-f' to the command `foo' and the event `C-b' to the command `bar' the following form would be used, (bind-keys KEYMAP "C-f" 'foo "C-b" 'bar) -- Function: unbind-keys KEYMAP &rest KEYS Removes the bindings of the events KEYS (these may be the names of the events or the event objects themselves) from the keymap KEYMAP. -- Function: search-keymap event keymap Search for a binding of the event EVENT in KEYMAP. If a binding is found a cons cell `(COMMAND . EVENT)' is returned. There are several pre-defined keymaps that are always available: `global-keymap' Keymap containing bindings active anywhere. `window-keymap' Keymap containing bindings active when a client window is focused. `root-window-keymap' Keymap containing bindings active when the pointer is in the root window. `title-keymap' `border-keymap' Keymaps active in the title and borders of window frames. `close-button-keymap' `iconify-button-keymap' `maximize-button-keymap' `menu-button-keymap' `shade-button-keymap' Keymaps active in the standard window frame buttons. `override-keymap' Must be a keymap, a symbol, or `nil'. If it is a keymap, this becomes the keymap in which all lookups occur (overriding the window, root and global keymaps). If it is a symbol, Sawfish finds the symbol's value and tries again. If it is `nil', Sawfish behaves normally.  File: sawfish.info, Node: Event Loop, Next: Miscellaneous Functions, Prev: Keymaps, Up: Top 19 Event Loop ************* The event loop reads all X events received on any of the windows that Sawfish is aware off. Many of these events invoke hooks, as described in *Note Standard Hooks::. Keyboard and pointer events are translated to their Lisp equivalents (*note Events::) and then used to scan all active keymaps for a binding. If a binding is found, the associated command is invoked through the `call-command' function. The active keymaps are determined as follows: * If the variable `override-keymap' is non-nil, then this is the only keymap searched * Otherwise three keymaps are searched: 1. the `keymap' property of the currently "clicked" frame part if there is one, 2. the `keymap' property of the currently focused window 3. the contents of the variable `global-keymap'. Note that for `ButtonRelease' events, the frame part's keymap is only searched if the pointer is actually within the frame part when the release event occurs. If no binding may be found in any of the active keymaps, then the `unbound-key-hook' hook is called. This is an `or' type hook--the first function that returns non-nil will terminate the hook call. -- Function: lookup-event-binding event Perform the usual binding lookup for the event object OBJECT. Returns the command found, or `nil' if no binding exists. By default, both key-release events, and events that are bound to modifier keys (e.g. ), are ignored. However, this behavior may be changed: -- Variable: eval-modifier-events When non-nil, key events bound to modifier keys are evaluated. -- Variable: eval-key-release-events When non-nil, key-release events are evaluated. While a command is being evaluated, information about the event that caused it may be found: -- Function: current-event Return the event which caused the current command to be invoked -- Function: current-event-string Returns the string which the current event would usually insert. -- Function: current-event-window &optional win Extract the owning window of the current X event (this is a window object, or the symbol `root' for the root window, or `nil' if there is no window or no event). This is stored internally as the current event window, and returned. -- Function: last-event Return the previous event which occurred. -- Function: proxy-current-event window &optional mask propagate Send the current X event to WINDOW, either a window object, a numeric window id, or the symbol `root'. If a `ButtonPress' event the pointer grab will be released first. MASK may be an integer defining the X event mask to pass to the `XSendEvent' function. If not defined, a mask is chosen that would usually be used to select the type of event being proxied. PROPAGATE is a flag (`nil'/non-`nil') passed directly to an underlying `XSendEvent' call. (And if someone would like to explain what _that_ means, please do so .... -- Function: allow-events mode This is a wrapper for the `XAllowEvents' function. The MODE parameter may be one of the following symbols: `async-pointer', `async-keyboard', `sync-pointer', `sync-keyboard', `replay-pointer', `replay-keyboard', `async-both', `sync-both'. Events that have to be grabbed to be received (i.e. all bindings in the `global-keymap' and the `window-keymap') are grabbed synchronously. This means that no more events will be received until either the command returns, or `allow-events' is called. This is normally not important, but if the command expects to receive further events it must call `allow-events'. See the interactive move and resize functions for an example. -- Function: forget-button-press Cause the next button press to be treated as a single click event, no matter how soon it occurs after the prevous button-press event. -- Function: accept-x-input &optional mask Handle any X events received. If MASK is non-nil then only events matching this numeric value are handled (see the X header files for details). -- Function: x-events-queued Returns the number of X events waiting to be handled.  File: sawfish.info, Node: Miscellaneous Functions, Next: Standard Hooks, Prev: Event Loop, Up: Top 20 Miscellaneous Functions ************************** * Menu: * Pointer Functions:: * Grab Functions:: * Display Functions:: * Gradient Functions:: * Other Functions::  File: sawfish.info, Node: Pointer Functions, Next: Grab Functions, Up: Miscellaneous Functions 20.1 Pointer Functions ====================== -- Function: query-pointer &optional from-server Returns a cons cell `(X . Y)' representing the current mouse pointer position, relative to the origin of the root window. If there is a mouse update current event, the position is read directly from that event. Otherwise it is read from the server. If FROM-SERVER is non-nil then the position is read directly from the server in any case. -- Function: query-pointer-window Returns the top-level window under the mouse pointer, or `nil' if the cursor is in the root window. -- Function: query-last-pointer Returns a cons cell `(X . Y)' representing the second most recent mouse pointer position, relative to the root window. -- Function: query-button-press-pointer Returns `(MOUSE-X . MOUSE-Y)' representing the mouse position relative to the root window at the last button-press event. Use this function to track the displacement of the pointer during a drag. -- Function: query-button-press-window Returns the window that the mouse was in when the button was pressed. -- Function: warp-cursor x y Move the mouse pointer to position (X, Y) relative to the origin of the root window. -- Function: warp-cursor-to-window window &optional x y Move the mouse pointer to position (X, Y) relative to the client window associated with object WINDOW. If X and Y are `nil', then they are taken as the top-left corner of the window's frame. -- Variable: warp-to-window-offset Offset (%) from window edges when warping pointer. A negative number means outside the left window edge. -- Variable: warp-to-window-enabled When false, disable warping the cursor to windows. -- Variable: pointer-motion-threshold If set to an integer value, a pointer must move by this many pixels on either axis before Sawfish considers it to have moved. If the pointer has not moved by this amount, Sawfish will ignore `MotionNotify' events from X. The variable defaults to 2 pixels. If not an integer, Sawfish assumes a threshold of 0 pixels.  File: sawfish.info, Node: Grab Functions, Next: Display Functions, Prev: Pointer Functions, Up: Miscellaneous Functions 20.2 Grab Functions =================== -- Function: grab-server Prevent any other clients from accessing the X server. -- Function: ungrab-server After a call to `grab-server' this will allow other clients to access the X server again. Note that calls to `grab-server' and `ungrab-server' _nest_. -- Macro: with-server-grabbed &rest forms Evaluate forms with the server grabbed. Releases the grab afterwards. -- Function: call-with-server-ungrabbed thunk Return the result of calling the zero-parameter function THUNK. If the server is currently grabbed, ungrab it first, restoring the original grab status after the call to THUNK returns. -- Function: server-grabbed-p Returns `t' if the X server is currently grabbed. -- Function: grab-pointer &optional window cursor ptr-sync kbd-sync confine-to Grab the mouse pointer and direct all pointer events to window object WINDOW. If CURSOR is defined and a cursor object, display this while the pointer is grabbed. If WINDOW is a window object corresponding to a visible window, the grab will be made on its frame. If WINDOW is an integer, it specifies the window ID of the grab window. Otherwise the grab will be made on the root window. This includes WINDOW corresponding to a non-viewable window. CONFINE-TO, if non-`nil', is a visible window to confine the pointer to. It is interpreted similarly to the rules for WINDOW, except that the "otherwise" case is to not confine the pointer. If the window id of a non-viewable window was specified for either WINDOW of CONFINE-TO, the grab will be made on the root window without confining the pointer. If PTR-SYNC or KBD-SYNC is non-NIL, the pointer or keyboard will be frozen, i.e., the device will not produce events until either the grab is released or events are re-enabled using `allow-events'. Returns non-nil if the grab succeeded. -- Function: ungrab-pointer Release the grab on the mouse pointer. -- Function: grab-keyboard &optional window ptr-sync kbd-sync Grab the keyboard and direct all keyboard events to window object WINDOW. If WINDOW is a window object corresponding to a visible window, the grab will be made on its frame. If WINDOW is an integer, it specifies the window ID of the grab window. Otherwise the grab will be made on the root window. This includes WINDOW corresponding to a non-viewable window. If PTR-SYNC or KBD-SYNC is non-NIL, the pointer or keyboard will be frozen, i.e., the device will not produce events until either the grab is released or events are re-enabled using `allow-events'. Returns non-nil if the grab succeeded. -- Function: ungrab-keyboard Release the grab on the keyboard. -- Function: call-with-keyboard-grabbed thunk Call the zero-parameter function THUNK with the keyboard grabbed. If unable to grab the keyboard then THUNK won't be called.  File: sawfish.info, Node: Display Functions, Next: Gradient Functions, Prev: Grab Functions, Up: Miscellaneous Functions 20.3 Display Functions ====================== -- Function: screen-width Return the width of the root window. -- Function: screen-height Return the height of the root window. -- Function: screen-dimensions Return the screen dimensions in pixels as a cons cell `(WIDTH . HEIGHT)'. -- Function: draw-window-outline mode x y width height Draw an outline of a window of dimensions (WIDTH, HEIGHT) at position (X, Y) relative to the root window. MODE is a symbol defining the type of outline drawn, currently it may only be `box' for a 3x3 grid. Use the `erase-window-outline' to erase the grid. Also note that since these functions draw directly on the root window the server should be grabbed until the outline is erased. -- Function: erase-window-outline mode x y width height Erase a previously drawn outline of a window of dimensions (WIDTH, HEIGHT) at position (X, Y) relative to the root window. MODE is a symbol defining the type of outline drawn, currently it may only be `box' for a 3x3 grid. -- Function: display-message &optional text attributes Display the string TEXT in a window on the screen. If TEXT is `nil' then any string previously displayed is removed. Returns the numeric id of the window displaying the message, or `nil' if no message is displayed. ATTRIBUTES is an alist specifying how the string should be displayed; each element of the list is a cons cell `(ATTR . VALUE)' associating an attribute ATTR (a symbol) with it's value. Possible attributes currently include: `font' The font to use `foreground' The color (or color name) to draw the text with `background' The color (or color name) to draw the background with `x-justify' The justification method for multi-line strings. One of the symbols `left', `right', or `center' `spacing' The number of extra pixels of vertical spacing to leave between text lines. `position' A cons cell defining the coordinates at which to display the message window. The cell is `(X . Y)'. X and Y are integers or `nil' (for centered display). If negative they count in from the left and bottom edges respectively. `head' The head on which to center the message when a position is not specified or given as nil. If not provided defaults to the head containing the window that has the input focus.  File: sawfish.info, Node: Gradient Functions, Next: Other Functions, Prev: Display Functions, Up: Miscellaneous Functions 20.4 Gradient Functions ======================= The `gradient' feature allows color gradients to be drawn in images. (Evaluate `(require 'gradient)' to load this feature.) -- Function: draw-vertical-gradient image from to Draw a vertical color gradient in IMAGE. The color at the top of the image will be FROM, the color at the bottom TO, with a smooth transition between. -- Function: draw-horizontal-gradient image from to Draw a horizontal color gradient in IMAGE, from left to right. The color at the left of the image will be FROM, the color at the right TO, with a smooth transition between. -- Function: draw-diagonal-gradient image from to Draw a horizontal color gradient in IMAGE, from the top-left corner to the bottom-right. The color at the top-left of the image will be FROM, the color at the bottom-right TO, with a smooth transition between.  File: sawfish.info, Node: Other Functions, Prev: Gradient Functions, Up: Miscellaneous Functions 20.5 Other Functions ==================== -- Function: sync-server Flush all pending X requests, don't wait for them to finish. -- Function: send-client-message window type data format Send an X `ClientMessage' event to WINDOW (a window object, the symbol `root' or a numeric xid). The event will be of the type TYPE (a symbol), contain the array of integers DATA (i.e. a vector or a string), and will be transferred as FORMAT sized quantities (8, 16 or 32). -- Function: create-window parent x y width height Create an unmapped window that is a child of PARENT (a window object, an integer window id, or the symbol `root'), with the specified dimensions. Returns the window id of the new window. -- Function: exit-type If Sawfish is shutting down, this function returns one of the strings `"user-quit"', `"user-restart"' or `"session-quit"'. If Sawfish is not shutting down, it returns `nil'. -- Function: x-atom symbol Return the integer identifying the X atom with the same name as SYMBOL. -- Function: x-atom-name integer Return the symbol with the same name as the X atom identified by the integer INTEGER. -- Variable: canonical-display-name A string containing the canonical name of the X display. This includes the full host name and the screen number. For example: `"foo.bar.com:0.0"'. -- Variable: display-name A string containing the name of the X display, exactly as passed to Sawfish. For example: `":0"', or `"foo:0.0"'. -- Variable: saved-command-line-args Holds a list of all of the command line arguments (including the executable name). -- Variable: sawfish-directory The home directory for Sawfish files. For example: `"/usr/share/sawfish"'. -- Variable: sawfish-exec-directory The directory for architechture-specific Sawfish executables. For example: `"/usr/lib/sawfish/1.3/i386-pc-linux-gnu"'. -- Variable: sawfish-lisp-lib-directory The top-level directory for Sawfish lisp files. For example: `"/usr/share/sawfish/1.3/lisp"'. -- Variable: sawfish-locale-directory The system directory where Sawfish can find locale files. This is not part of the Sawfish distribution. For example: `"/usr/share/locale"'. -- Variable: sawfish-site-lisp-directory The top-level directory for site-specific Sawfish lisp files. For example: `"/usr/share/sawfish/site-lisp"'. -- Variable: sawfish-version The version number of the running Sawfish. -- Function: primitive-play-sample filename Plays the sound file FILENAME (which must be a string). -- Function: call-with-error-handler thunk Call the zero-parameter function THUNK. If an error occurs, trap it and pass its `car' and `cdr' to `error-handler-function'. -- Function: load-module name Ensure that module NAME has been loaded. This does _not_ import its bindings or make them accessible. -- Function: eval-in form struct-name Evaluates FORM in the structure named by STRUCT-NAME. Compare this with `eval', which takes a structure object as its second parameter, not a structure name. -- Variable: *user-module* `*user-module*' is the default module for human interaction with Sawfish. -- Function: user-eval form -- Function: user-require feature `user-eval' evaluates `form' in `*user-module*'. `user-require' evaluates `(require FEATURE)' in `*user-module*'. -- Function: quote-menu-item string Escape any `_' characters in STRING such that the result can be used as the label of a menu item. -- Function: make-directory-recursively dir Create directory DIR. Any missing parent directories will also be created. -- Function: locate-file filename dirs Search for a file FILENAME in any of the directories named by the list of strings DIRS. -- Function: clamp x lower upper Return X clamped between LOWER and UPPER. If X is less than LOWER, return LOWER; if it is larger than UPPER return UPPER. Otherwise return X. -- Function: clamp* x y lower upper Return the interval (X, X+W) clamped between LOWER and UPPER. If X is less than LOWER, return LOWER. If X+W is larger than UPPER, return UPPER-W; this is a value of X that satisfies the upper bound, although it may violate the lower bound. Otherwise return X. -- Function: uniquify-list lst Remove all duplicates values from LST, using `eq'. The order of elements is not preserved.  File: sawfish.info, Node: Standard Hooks, Next: Standard Properties, Prev: Miscellaneous Functions, Up: Top 21 Standard Hooks ***************** Sawfish provides many hooks to allow extension of previously defined functions. Also, many X events are exported to the Lisp environment via the hooks mechanism. For more details on the hooks mechanism see *Note Normal Hooks: (librep)Normal Hooks. As well as using the standard `call-hook' function, sawfish also provides the `call-window-hook' function. This is used to invoke hooks which refer to a single window. If the hook has a local value defined in the window's property list then this value is used, before the default value defined by the actual variable. -- Function: call-window-hook hook window &optional args hook-type Call HOOK for WINDOW with further arguments ARGS. See `call-hook' for a description of HOOK-TYPE. Each function in the hook is called with arguments `(WINDOW . ARGS)'. The available hooks are listed below. * Menu: * Command Hooks:: * Key Hooks:: * Window Construction Hooks:: * Window Destruction Hooks:: * Window Mapping Hooks:: * Window Motion Hooks:: * X Hooks:: * Pointer Motion Hooks:: * Workspace Hooks:: * Startup and Shutdown Hooks:: * Other Hooks::  File: sawfish.info, Node: Command Hooks, Next: Key Hooks, Prev: Standard Hooks, Up: Standard Hooks 21.1 Command Hooks ================== -- Hook: pre-command-hook Called before each command is evaluated. -- Hook: post-command-hook Called after each command is evaluated.  File: sawfish.info, Node: Key Hooks, Next: Window Construction Hooks, Prev: Command Hooks, Up: Standard Hooks 21.2 Key Hooks ============== -- Hook: unbound-key-hook Called when an key or pointer event has been received which there is no binding for. The hook functions return no arguments. This is an `or'-type hookk--the first function that returns non-`nil' will terminate the hook call. Under normal circumstances, an unbound key release causes a `throw' to top-level. Adding _any_ function to this hook suppresses that behavior.  File: sawfish.info, Node: Window Construction Hooks, Next: Window Destruction Hooks, Prev: Key Hooks, Up: Standard Hooks 21.3 Window Construction Hooks ============================== -- Window Hook: before-add-window-hook -- Window Hook: add-window-hook Called when the window is first adopted by the window manager. This occurs before the window is created, installed or placed. At this early stage, the only safe action is to set properties of the window (with `window-set'). `add-window-hook' is a deprecated hook, replaced by `before-add-window-hook'. It is called immediately after `before-add-window-hook'. -- Window Hook: after-add-window-hook Called when the window is first adopted by the window manager. This occurs after the window has been created, installed and placed. -- Window Hook: after-framing-hook Called after a window gets a frame assigned, or after a window's frame is rebuilt.  File: sawfish.info, Node: Window Destruction Hooks, Next: Window Mapping Hooks, Prev: Window Construction Hooks, Up: Standard Hooks 21.4 Window Destruction Hooks ============================= -- Window Hook: destroy-notify-hook Called when the window is destroyed. Note that this may be called asynchronously to the normal event loop. In general, once the window manager knows the window has been destroyed, it will attempt to call this hook as soon as possible.  File: sawfish.info, Node: Window Mapping Hooks, Next: Window Motion Hooks, Prev: Window Destruction Hooks, Up: Standard Hooks 21.5 Window Mapping Hooks ========================= -- Window Hook: map-notify-hook -- Window Hook: unmap-notify-hook -- Window Hook: reparent-notify-hook -- Window Hook: shape-notify-hook Called with a window is mapped, unmapped, reparented, or has its shape changed, respectively. Note that iconifying and uniconifying windows triggers unmapping and mapping, respectively. -- Window Hook: iconify-window-hook -- Window Hook: uniconify-window-hook -- Window Hook: shade-window-hook -- Window Hook: unshade-window-hook -- Window Hook: window-maximized-hook -- Window Hook: window-unmaximized-hook -- Window Hook: window-depth-change-hook Called when a window is iconified, uniconified, shaded, unshaded, maximized, unmaximized, or has its depth changed, respectively. -- Window Hook: visibility-notify-hook Called when a window's visibility changes. In addition to the window, the hook is called one one of the symbols `fully-obscured', `partially-obscured', or `unobscured'. -- Window Hook: place-window-hook Called the first time a window is mapped, or if the window does not have a true `placed' property. This is an `or'-type hook--the first function that returns non-`nil' will terminate the hook call.  File: sawfish.info, Node: Window Motion Hooks, Next: X Hooks, Prev: Window Mapping Hooks, Up: Standard Hooks 21.6 Window Motion Hooks ======================== -- Window Hook: window-moved-hook -- Window Hook: window-resized-hook Called whenever the window is moved or resized. This hook is called inside the `move-window-to' and `move-resize-window-to' functions, so any operation that moves the window will trigger this hook. The window motion does not have to be interactive. Note that outline window sizing and movement does not use `move-window-to' or `move-resize-window-to', except at the very end of the operation. Compare with `while-moving-hook' and `while-resizing-hook'. -- Window Hook: before-move-hook -- Window Hook: before-resize-hook Called before starting an interactive move or resize. -- Window Hook: while-moving-hook -- Window Hook: while-resizing-hook Called during every pointer motion event during a move or resize. This includes outline window motion. The calls take place before the window or its outline are actually moved. Compare with `window-moved-hook' and `window-resized-hook'. -- Window Hook: after-move-hook -- Window Hook: after-resize-hook Called after completion of an interactive move or resize. In addition to the window, the hook is called with a list of symbols indicating how the window was moved or resized: `horizontal' and `vertical' for movement, `right', `left', `bottom' and `top' for resizing. -- Hook: after-restacking-hook Called after any window restacking operation, including (but possibly not limited to `restack-windows', `x-raise-window' and `x-lower-window'. The hook functions take no arguments.  File: sawfish.info, Node: X Hooks, Next: Pointer Motion Hooks, Prev: Window Motion Hooks, Up: Standard Hooks 21.7 X Hooks ============ -- Window Hook: configure-request-hook Called when an X `ConfigureRequest' event is received. In addition to the window, the hook is called with an association list of configure request properties. This alist may contain items `(stack . above)', `(stack . below)', `(position . COORDINATES)', and `(dimensions . DIMENSIONS)'. -- Window Hook: property-notify-hook Called whenever an X window property (not a Sawfish window property) changes. In addition to the window, the hook is called with the atom name and one of the symbols `new-value' or `deleted'. -- Window Hook: window-state-change-hook Called whenver certain window manager hints change for a window. Currently only `urgency' is monitored. The hint is an additional argument to the hook.  File: sawfish.info, Node: Pointer Motion Hooks, Next: Workspace Hooks, Prev: X Hooks, Up: Standard Hooks 21.8 Pointer Motion Hooks ========================= In the hooks below, FOCUS-MODE is one of the symbols `normal', `grab' or `ungrab'. -- Window Hook: enter-notify-hook -- Window Hook: enter-frame-part-hook Called when the pointer enters a window (including the root window). If the window was part of a frame, then `enter-frame-part-hook' is called with three arguments: the window, the frame part class (*note Frame Part Classes::), and FOCUS-MODE. Otherwise `enter-notify-hook' is called with two arguments: the window and FOCUS-MODE. The root window is considered to be a valid window for this hook. Sawfish will report entering the root window. -- Window Hook: leave-notify-hook -- Window Hook: leave-frame-part-hook Called when the pointer leaves a window (including the root window). If the window was part of a frame, then `leave-frame-part-hook' is called with three arguments: the window, the frame part class (*note Frame Part Classes::), and FOCUS-MODE. Otherwise `leave-notify-hook' is called with two arguments: the window and FOCUS-MODE. The root window is considered to be a valid window for this hook. Sawfish will report leaving the root window. -- Window Hook: focus-in-hook Called when focus gains focus. The hook functions take two arguments: the window that received focus, and FOCUS-MODE. If your FOCUS-MODE is set to `enter-exit', your window focus is tightly bound to your pointer position; focus-related hooks and enter/leave hooks will be called in lockstep. For other values of `focus-mode', Sawfish will trigger fewer focus-related hook calls than enter/leave hook calls. This hook is never called for the root window, because the root window never gets focus. -- Window Hook: focus-out-hook Called when a window loses focus. The hook functions take two arguments: the window that lost focus, and FOCUS-MODE. If your FOCUS-MODE is set to `enter-exit', your window focus is tightly bound to your pointer position; focus-related hooks and enter/leave hooks will be called in lockstep. For other values of `focus-mode', Sawfish will trigger fewer focus-related hook calls than enter/leave hook calls. This hook is never called for the root window, because the root window never gets focus.  File: sawfish.info, Node: Workspace Hooks, Next: Startup and Shutdown Hooks, Prev: Pointer Motion Hooks, Up: Standard Hooks 21.9 Workspace Hooks ==================== -- Hook: enter-workspace-hook -- Hook: leave-workspace-hook Called when switching from one workspace to another. This includes switching caused by adding or removing a workspace. The hook is called with a _list_ containing the workspace in question. -- Window Hook: add-to-workspace-hook -- Window Hook: remove-from-workspace-hook Called when a window is added or removed from a workspace. In addition to the window, the hook is called with a _list_ containing the workspace being changed. If the window is in multiple workspaces, then removing triggers `remove-from-workspace-hook' for each workspace. -- Hook: workspace-state-change-hook Called when any aspect of the workspaces change, including adding a workspace, removing a workspace, moving a workspace, inserting or removing a window from a workspace, etc. This hook is called with no arguments, so you should use one of the more specific hooks if possible. -- Hook: viewport-resized-hook Called when the number of rows and columns in each virtual workspace is changed. -- Hook: viewport-moved-hook Called when the origin of the viewport into the virtual workspace is moved. -- Hook: enter-flipper-hook -- Hook: leave-flipper-hook When viewport edge-flipping is enabled, these hooks are called as the pointer enters and leaves the pixel-wide border on the edge of the screen. They're called with a single argument, one of the symbols `left', `right', `top', `bottom' indicating the edge in question.  File: sawfish.info, Node: Startup and Shutdown Hooks, Next: Other Hooks, Prev: Workspace Hooks, Up: Standard Hooks 21.10 Startup and Shutdown Hooks ================================ -- Hook: after-initialization-hook Called after adopting the initial set of windows. -- Window Hook: remove-window-hook Called on each window as Sawfish shuts down (possibly for a restart). The hook functions take no arguments. -- Hook: before-exit-hook Called immediately before exiting. -- Hook: sm-window-save-functions -- Hook: sm-restore-window-hook -- Hook: sm-after-restore-hook Session management hooks, *Note Session Management::.  File: sawfish.info, Node: Other Hooks, Prev: Startup and Shutdown Hooks, Up: Standard Hooks 21.11 Other Hooks ================= -- Hook: gtkrc-changed-hook When using the `gtkrc' module to load the current gtk style parameters, this hook is called when the style changes. -- Window Hook: client-message-hook Called with arguments `(WINDOW TYPE DATA-ARRAY)'. This is an `or'-type hook--the first function that returns non-`nil' will terminate the hook call.  File: sawfish.info, Node: Standard Properties, Next: Session Management, Prev: Standard Hooks, Up: Top 22 Standard Window Properties ***************************** As described in an earlier section of this manual, each window has a property list, which may be used to associate arbitrary lisp data with symbolic keys (*note Window Property Lists::). The following table documents a subset of the keys currently used. `ignored' When set, the window is ignored in many operations. `avoid' When set, the window will not be covered when maximizing, or when placing using the first-fit or best-fit methods `workspaces' A list of integers defining the workspaces that the window is a member of, or nil if the window is sticky. *Note Workspaces::. `sticky' Whether the window should appear on all workspaces. `sticky-viewport' When set, the window will appear in all viewports of its workspace. `keymap' An optional, window-local, keymap. *Note Keymaps::. `focus-click-through' When set, and click-to-focus mode is enabled, the click that focuses a window is passed through to the client window. `ignore-window-input-hint' When set the value of the window's input hint is ignored, i.e. the focus _will_ be given to the window when appropriate `never-focus' When set the window will _never_ be given the input focus `focus-when-mapped' Focus the window when it is mapped on to the display. `ignore-program-position' When set the window's program-position property is ignored, use this with windows that set this hint incorrectly. `place-mode' When set, the placement mode to be used with this window. `placement-weight' When set, the weight assigned to the pixels in this window when doing fitted window placement. `type' The frame-type of the window, or `nil'. *Note Frame Types::. `frame-style' The frame style explicitly chosen by the user, or unset. *Note Frame Styles::. `current-frame-style' The frame style currently used for the window. *Note Frame Styles::. `removed-classes' A list of frame part classes removed from the decorations of this window. *Note Removing Frame Parts::. `shaded' Is the window shaded? *Note Shading Windows::. `hide-client' Is the client window visible within its frame. Used to implement window shading. `depth' An integer, the layer that the window is a member of. Layer zero is the depth of "normal" windows, negative depths are below this level, while positive depths are above. *Note Window Stacking::. `placed' Has the window been placed in a position yet? The `place-window-hook' is only called when this is unset. `iconified' Is the window iconified? *Note Iconifying Windows::. `gravity' When set, overrides the window gravity field of the window's size hints. May be one of the symbols: `north-west', `north', `north-east', `west', `center', `east', `south-west', `south', `south-east'. `fixed-position' When set, the user is not allowed to change the position of this window. `client-set-position' When set, the program owning the window has manually moved the window after it was mapped.  File: sawfish.info, Node: Session Management, Next: Low-level X Interface, Prev: Standard Properties, Up: Top 23 Session Management ********************* Sawfish has fully integrated support for the X session management protocols. Also, this support is extensible to allow all Lisp modules to save and reload their own window state. There are two methods of doing this. If the module only wants to save and restore the values of properties in each window's property list (i.e. those values set via `window-put'), then the following functions may be used: -- Function: sm-add-saved-properties &rest properties -- Function: sm-add-restored-properties &rest properties Arrange for all symbols PROPERTIES to be saved or restored with the session. -- Variable: sm-saved-window-properties -- Variable: sm-restored-window-properties Lists of properties (symbols) to be saved or restored with each session. If a Lisp module chooses to use this method it may add a function to the `add-window-hook' to act on the reloaded properties when the session is reloaded. For more complex window properties that can't be saved straight from the window's plist two hooks are available: -- Variable: sm-window-save-functions A list of functions, each of which is called when the state of each window is saved. Each function is called with a single argument (the window) and should return a list of alist elements that will be saved in the state file. (As such, only values with valid read syntaxes may be included.) -- Variable: sm-restore-window-hook List of functions called when the state of a window is restored. Each is called with arguments `(WINDOW ALIST)', where ALIST defines the state saved for the window. Each function should look for the properties it saved, and then take any action dependent on the values. The following hook is also called. -- Variable: sm-after-restore-hook Hook called after loading a saved session. -- Variable: sm-save-directory The directory that will contain all Sawfish sessions. It must be a string. By default it is `"~/.sawfish/sessions"'. -- Variable: sm-sloppy-id-matching When loading sessions, the algorithm that matches saved session data to running clients requires that if one has a session id, then so must the other, and they must match. Setting this variable to true turns that feature off, allowing some broken clients to be session managed. Defaults to false.  File: sawfish.info, Node: Low-level X Interface, Next: FAQ, Prev: Session Management, Up: Top 24 Low-level X Interface ************************ * Menu: * X Server:: * X Windows:: * X Selections:: * X Keysyms:: * X Bitmaps and Pixmaps:: * X Drawing:: * Available X Symbols::  File: sawfish.info, Node: X Server, Next: X Windows, Prev: Low-level X Interface, Up: Low-level X Interface 24.1 X Server ============= -- Function: x-server-timestamp &optional from-server store Return a recent X server timestamp as an integer. If FROM-SERVER is non-NIL, the timestamp is read directly from the server; otherwise the most recent timestamp seen by the window manager (i.e., from an event) is returned. If STORE is true, this becomes the most recent timestamp seen by the window manager.  File: sawfish.info, Node: X Windows, Next: X Selections, Prev: X Server, Up: Low-level X Interface 24.2 X Windows ============== -- Function: x-create-window (x . y) (width . height) bw attrs &optional event-handler Create a new X window at `(X, Y)' with dimensions `(WIDTH, HEIGHT)' and border width BW. ATTRS is an alist mapping attribute names to values. Allowed attribute names are `background' and `border-color'. -- Function: x-configure-window window attrs Reconfigure the window associated with WINDOW. ATTRS is an alist mapping attribute names to values. Allowed attribute names are `x', `y', `width', `height' and `border-width'. -- Function: x-destroy-window window Destroy the X window WINDOW. -- Function: x-map-window window &optional unraised Map the window associated with WINDOW to the display. If UNRAISED is not specified, the window will be mapped at the top of the window stack. -- Function: x-unmap-window window Unmap the window associated with WINDOW. -- Function: x-window-id window Return the X window ID (an integer) associated with WINDOW. -- Function: x-window-p obj Return `t' if OBJ is associated with an X window object. -- Function: x-change-window-attributes window attrs Set attributes of the window associated with WINDOW. ATTRS is an alist mapping attribute names (symbols) to values. Allowed attribute names are `background' and `border-color'.  File: sawfish.info, Node: X Selections, Next: X Keysyms, Prev: X Windows, Up: Low-level X Interface 24.3 X Selections ================= -- Function: x-get-selection sel Return the string corresponding to the current value of the X11 selection defined by SEL, or `nil' if the selection currently has no value. SEL should be one of `PRIMARY', `SECONDARY' or `CLIPBOARD'. -- Function: x-selection-active-p sel Returns t if the X11 selection defined by the symbol SEL is available for reading. SEL should be one of `PRIMARY', `SECONDARY' or `CLIPBOARD'.  File: sawfish.info, Node: X Keysyms, Next: X Bitmaps and Pixmaps, Prev: X Selections, Up: Low-level X Interface 24.4 X Keysyms ============== -- Function: x-keysym-name ks Return the Lisp symbol naming the X11 keysym represented by the integer KS. -- Function: x-lookup-keysym name Return the X11 keysym (an integer) named by the Lisp symbol NAME.  File: sawfish.info, Node: X Bitmaps and Pixmaps, Next: X Drawing, Prev: X Keysyms, Up: Low-level X Interface 24.5 X Windows ============== -- Function: x-bitmap-p Return `t' if ARG is an X-bitmap object. -- Function: x-create-bitmap (width . height) Create a bitmap of size WIDTHxHEIGHT. -- Function: x-create-pixmap (width . height) Create a pixmap of size WIDTHxHEIGHT. -- Function: x-destroy-drawable drawable Destroy the X drawable DRAWABLE. -- Function: x-drawable-height drawable Return the height in pixels of DRAWABLE. -- Function: x-drawable-id drawable Return the X11 drawable-ID (an integer) associated with DRAWABLE. -- Function: x-drawable-p obj Return `t' if OBJ is an X drawable object. -- Function: x-drawable-width drawable Return the width in pixels of DRAWABLE. -- Function: x-grab-image-from-drawable drawable mask Return a new image object copied from DRAWABLE. MASK is a stencil mask for the image; black pixels in MASK become transparent in the returned image. -- Function: x-pixmap-p obj Return `t' if OBJ is an X pixmap object.  File: sawfish.info, Node: X Drawing, Next: Available X Symbols, Prev: X Bitmaps and Pixmaps, Up: Low-level X Interface 24.6 X Windows ============== -- Function: x-clear-window window Clear the window associated with WINDOW to its background color. -- Function: x-copy-area window gc (x . y) (width . height) (dest-x . dest-y) Copy a region of WINDOW with top-left corner `(X, Y)' and dimensions `(WIDTH, HEIGHT)' to the position `(DEST-X, DEST-Y)' using GC. -- Function: x-create-gc window attrs Create a new GC for the specified window WINDOW. ATTRS is an alist mapping attributes to values. Allowed attribute names are `foreground', `background', `line-width', `line-style', `cap-style', `join-style', `fill-style', `fill-rule', `arc-mode', `tile', `stipple', `ts-x-origin', `ts-y-origin', `clip-mask', `clip-x-origin', `clip-y-origin' and `function'. -- Function: x-change-gc gc attrs Sets attributes of the X Graphical Context. ATTRS is an association list of attribute names and values. Allowed attribute names are `foreground', `background', `line-width', `line-style', `cap-style', `join-style', `fill-style', `fill-rule', `arc-mode', `tile', `stipple', `ts-x-origin', `ts-y-origin', `clip-mask', `clip-x-origin', `clip-y-origin' and `function'. -- Function: x-create-root-xor-gc Create a graphics context specialized for XOR-ing onto the root window. This is used for drawing outlines for window movement. -- Function: x-destroy-gc gc Destroy the X graphics context GC. -- Function: x-draw-arc window gc (x . y) (width . height) (angle1 . angle2) Draw a single circular or elliptical arc in WINDOW using the graphics context GC. The center of the circle or ellipse is the center of an imaginary rectangle at `(X, Y)'. The major and minor axes are the `(WIDTH, HEIGHT)' of that rectangle. The arc sweeps from ANGLE1 to ANGLE2; positive angles are rotated counter-clockwise from zero, and negative angles are rotated clockwise from zero. -- Function: x-draw-image image window (x . y) &optional (width . height) Render the image object IMAGE in WINDOW at position `(X, Y)'. If WIDTH and HEIGHT are defined the image is first scaled to these dimensions; otherwise it is drawn using its natural dimensions. -- Function: x-draw-line window gc (x1 . y1) (x2 . y2) Draw a line from `(X1, Y1)' to `(X2, Y2)' in WINDOW using the graphics context GC. -- Function: x-draw-rectangle window gc (x . y) (width . height) Draw a rectangle with its top-left corner at `(X, Y)' and dimensions `(WIDTH, HEIGHT)' in WINDOW using the graphics context GC. -- Function: x-draw-string window gc (x . y) string &optional font Draw the specified string at `(X, Y)' in WINDOW using the graphics context GC. If FONT is specified use that font. -- Function: x-fill-arc window gc (x . y) (width . height) (angle1 . angle2) Draw a single filled circular or elliptical arc in WINDOW using the graphics context GC. The center of the circle or ellipse is the center of an imaginary rectangle at `(X, Y)'. The major and minor axes are the `(WIDTH, HEIGHT)' of that rectangle. The arc sweeps from ANGLE1 to ANGLE2; positive angles are rotated counter-clockwise from zero, and negative angles are rotated clockwise from zero. -- Function: x-fill-polygon window gc points &optional draw-mode Draw a single filled polygon in WINDOW using the graphics context GC. POINTS is a list of `(X, Y)' pairs that defines the polygon vertices. DRAW-MODE is a hint to the X server on how to draw the polygon; if supplied, it should be one of the symbols `convex' or `non-convex'. The default mode is "Convex". -- Function: x-fill-rectangle window gc (x . y) (width . height) Draw a filled rectangle with its top-left corner at `(X, Y)' and dimensions `(WIDTH, HEIGHT)' in WINDOW using the graphics context GC. -- Function: x-gc-p obj Returns `t' if OBJ is an X GraphicsContext object. -- Function: x-gc-set-dashes gc pixels-list &optional offset Set the dash style of graphics context GC to the value of PIXELS-LIST. PIXELS-LIST is a list of cons cells `((pixels-on . pixels-off) ...)' indicating runs of on and off pixels in a dash segment. If OFFSET is given, this should be an integer indicating the number of pixels to offset the dashes. -- Function: x-window-back-buffer window Return the X object ID (an integer) for the back buffer associated with WINDOW. If no such back buffer exists, the function will attempt to create one. If the function is unable to find or create a back buffer (possibly because the X server does not support them), it returns the window's own ID. -- Function: x-window-swap-buffers window Swap the fore and back buffers of the window associated with WINDOW. If the X server does not support double buffers, the function quietly does nothing.  File: sawfish.info, Node: Available X Symbols, Prev: X Drawing, Up: Low-level X Interface 24.7 Available X Symbols ======================== The following symbols can be used where X window attributes are expected: `border-width' `border-color' `expose' `convex' `non-convex' `line-width' `line-style' `cap-style' `join-style' `fill-style' `fill-rule' `arc-mode' `tile' `stipple' `ts-x-origin' `ts-y-origin' `clip-mask' `clip-x-origin' `clip-y-origin' The following symbols can be used where X window attribute values are expected: `line-solid' `line-on-off-dash' `line-double-dash' `cap-not-last' `cap-butt' `cap-round' `cap-projecting' `join-miter' `join-round' `join-bevel' `fill-solid' `fill-tiled' `fill-stippled' `fill-opaque-stippled' `even-odd-rule' `winding-rule' `arc-chord' `arc-pie-slice' `function' `clear' `and' `and-reverse' `copy' `and-inverted' `no-op' `xor' `or' `nor' `equiv' `invert' `or-reverse' `copy-inverted' `or-inverted' `nand' `set'  File: sawfish.info, Node: FAQ, Next: Function Index, Prev: Low-level X Interface, Up: Top 25 Frequently Asked Questions ***************************** 1. Why is it now called _Sawfish_? Because the old name (`Sawmill') was already being used by another company, who were in the process of registering it as a trademark. The rename should be mostly painless, all old binaries still work for the time being, but will be phased out over time. Where before you would execute a program called `sawmill*', replace it by `sawfish*'. E.g. `sawmill' becomes `sawfish', and `sawmill-client' becomes `sawfish-client'. Your `~/.sawmill' directory will automatically be renamed `~/.sawfish' unless it would overwrite an existing file. Both `~/.sawfishrc' and `~/.sawmillrc' will be checked currently (though only one will be actually loaded). My apologies for any inconvenience caused. 2. But why _Sawfish_, and not ? Well I had to choose something! And hopefully it satisfies the main requirements: * There are no other computer-related users of the name (as checked in April 2000,) * It's similar enough to the old name to hopefully carry some recognition across, * It has no tenuous relationship to window-managing. 3. I installed Sawfish but it's not working! All I see when I start X is the default stipple background: no programs, no menus, no pager. This is exactly what it's supposed to do. Sawfish is a _window manager_ and as such is not responsible for setting the background, starting programs or displaying a pager--these can all be done using separate applications (e.g. by using a desktop environment such as GNOME). The default menu binding is somewhat obscure; you must middle-click on the background to bring up the menus. (If you have a two-button mouse, try clicking both buttons simultaneously) If, after reading this, you still think that sawfish isn't working, please send mail describing the problem to the sawfish mailing list 4. How do I add customizations? There are several files controlling this: `~/.sawfishrc' Hand written lisp code, loaded at startup. This is where almost all explicit customization should be done. `sawmill-defaults' This lisp library is only loaded if there's no `.sawfishrc' file. `~/.sawfish/custom' This stores customizations created by the configuration tool; it shouldn't really be edited manually. This file is loaded _after_ `sawmill-defaults', but _before_ `.sawfishrc'. 5. I created `.sawfishrc', now things have changed? If a `~/.sawfishrc' file exists, it prevents `sawmill-defaults' from being loaded. But it's `sawmill-defaults' that loads some of the common window manager features, so add the line (require 'sawmill-defaults) to your `.sawfishrc' file if you want to start with all the standard features loaded. 6. What's this `sawfish-client' program? This allows you to connect to a window manager process and evaluate arbitrary Lisp forms. Do `sawfish-client -?' for more details (`sawfish-client -' for a read-eval-print loop) By default you can only connect from the host running the wm (through a unix-domain socket). To enable the network based server, evaluate the lisp form `(server-net-init)'. Note however that this connects through the X server, meaning that anyone who can open windows on your display can also execute any Lisp code on the host running the window manager (and by extension, _execute any program_). So _don't_ run the net server with X access control disabled (unless you're not connected to a network) 7. How do I bind a key to execute a shell command? Bind a key to the `run-shell-command' command; remember to enter the shell command you want to execute in the string entry in the `Edit binding' dialog window. 8. How do I make clicking on a window raise the window? Bind the event `Button1-Click1' in the `window-keymap' to the `raise-window-and-pass-through-click' command 9. How do I redefine the `Applications' menu? See the `Popup Menus' node in the Info manual (*note Popup Menus::) 10. How do I read the Info manual? Either execute the command `info sawfish', or enter the Info mode within Emacs (`C-h i') and type `g (sawfish) RET'. If you're using GNOME, then try executing `gnome-help-browser info:sawfish'. 11. How do I create a new theme? See the `Window Frames' node of the Info manual (*note Window Frames::) Basically though, create a directory `~/.sawfish/themes/FOO' where FOO is the name of your theme. Then copy any images into this directory and create a file `theme.jl' that will be loaded to initialise the theme The configuration tool will display the contents of a file called `README' in the directory (but make it 80-column text, and only a few lines) Recent versions of sawfish include a program `sawfish-themer' that allows simple themes to be created using a GTK+ interface. Ian McKellar has created `GimpMill': GimpMill is a GIMP plugin written in Python using James Henstrige's really cool Python GIMP bindings. It allows the construction of Sawmill themes within The GIMP - extending the GIMP interface to allow theme creation like the GAP extends it to allow animation creation. GimpMill is available from `http://www.yakk.net/projects.gimpmill.html' 12. How do I port an Enlightenment theme to sawfish? There's no automatic translation available. Get the images used in the window border, then write a `theme.jl' file telling the window manager how they are used to form a window frame See the `themes/brushed-metal' directory for an example, and the Info manual for the documentation 13. Are there any other themes available? Thanks to those nice people at themes.org, there's now `http://sawmill.themes.org/' for your theming pleasure 14. Why don't GTK themes work with sawfish? There was a problem with older versions of the `gtk-engines' package preventing engine based themes working with several interpreted languages. Get the latest `gtk-engines' from `ftp://ftp.gnome.org/' 15. Why don't you use GUILE? Mainly because I'm lazy; I had already written rep, and therefore understood it completely, whereas I have never used GUILE. Also, rep has some features not available in GUILE (byte-code compilation, autoloading, built-in event-loop, ...) But before you flame me: yes I do think scheme is a more elegant language 16. Will you add feature X? Possibly. But only if it can be written in Lisp, or doesn't conflict with the overall design aims. These aims are to build a lightweight, generally applicable, set of core window management functions, then write _all_ high-level functionality as Lisp extensions 17. Will you add background setting? No. This can easily be done by a separate application (e.g. with the GNOME hints, simply monitor property `_WIN_WORKSPACE' on the root window). 18. Is there a sawfish mailing list? Yes. See `http://lists.eazel.com/mailman/listinfo/' for subscription instructions and archived messages. 19. Is there a sawfish IRC channel? From Ryan Pavlik : Sawmill has an irc channel too! It's on EFNet, and called (of all crazy things), #sawmill. So break out your irc clients, or hop on over if you're already addicted. Theme, lisp, general sawmill, and most other random discussion welcome. If you need an EFNet server, check www.efnet.net for a listing. 20. Why does sawfish look weird/crash on Solaris? Sawfish works stably on Solaris, but you may need to do two things: 1. Disable use of MIT-SHM by Imlib (run the program `imlib_config', the MIT-SHM option is on the `Rendering' page) 2. Recompile GTK+ using the `--disable-xim' option to configure 21. Why don't some windows ever get focused? If you don't have the option `give focus to windows even when they haven't asked for it' checked (group Focus/Advanced), then windows that don't ask for focus don't get it. Windows ask to receive focus by setting their WM_HINTS property appropriately; for example if I xprop a gnome-terminal: WM_HINTS(WM_HINTS): Client accepts input or input focus: True Initial state is Normal State. window id # of group leader: 0x5c00001 22. Why doesn't the GNOME desk-guide / tasklist show the true state of my desktop? It seems that there is a problem with these applets that only occurs after restarting sawfish-they seem to lose track of the current window states. The simplest way to correct this is to execute the following shell commands: $ save-session $ killall panel (assuming you have a session manager to restart the panel afterwards!) 23. What do these `bytecode-error' messages mean? It means that you're trying to execute Lisp code that was compiled for an outdated version of the Lisp virtual machine. Recompile any Lisp files that you have installed locally. 24. How do I compile Lisp files? Use the shell command: sawfish --batch -l compiler -f compile-batch FILES... where FILES... are the names of the files you want to compile. They will normally have `.jl' suffixes, the compiler will create associated files with `.jlc' suffixes containing the compiled Lisp code.  File: sawfish.info, Node: Function Index, Next: Variable Index, Prev: FAQ, Up: Top Function Index ************** [index] * Menu: * accept-x-input: Event Loop. (line 100) * activate-window: Windows. (line 28) * add-frame-class: Removing Frame Parts. (line 14) * add-window-menu-toggle: Popup Menus. (line 124) * add-window-to-group: Assigning Windows to Groups. (line 11) * add-window-to-new-group: Assigning Windows to Groups. (line 16) * all-workspaces: Workspaces and Windows. (line 10) * allow-events: Event Loop. (line 81) * apply-command: Invoking Commands. (line 23) * autoload-command: New-style Command Definition. (line 37) * autoload-focus-mode: Input Focus. (line 184) * autoload-placement-mode: Window Placement. (line 138) * autoload-window-animator: Animating Windows. (line 20) * avoided-windows: Window Placement. (line 111) * bevel-image: Images. (line 140) * bind-keys: Keymaps. (line 17) * call-after-property-changed: X Properties. (line 70) * call-after-state-changed: Frame Types. (line 79) * call-command: Invoking Commands. (line 11) * call-window-hook: Standard Hooks. (line 18) * call-with-error-handler: Other Functions. (line 78) * call-with-keyboard-grabbed: Grab Functions. (line 82) * call-with-server-ungrabbed: Grab Functions. (line 20) * clamp: Other Functions. (line 112) * clamp*: Other Functions. (line 117) * clear-image: Images. (line 152) * clicked-frame-part: Frame Functions. (line 45) * color-name: Colors. (line 50) * color-rgb: Colors. (line 40) * color-rgb-8: Colors. (line 45) * colorp: Colors. (line 11) * command-class: Operations on Commands. (line 29) * command-documentation: Operations on Commands. (line 20) * command-spec: Operations on Commands. (line 27) * command-type: Operations on Commands. (line 28) * commandp: Operations on Commands. (line 10) * composite-images: Images. (line 162) * copy-image: Images. (line 51) * copy-to-next-workspace: Workspaces and Windows. (line 104) * copy-to-previous-workspace: Workspaces and Windows. (line 115) * copy-window-to-workspace: Workspaces and Windows. (line 68) * create-window: Other Functions. (line 18) * crop-image: Images. (line 167) * current-event: Event Loop. (line 53) * current-event-string: Event Loop. (line 56) * current-event-window: Event Loop. (line 59) * current-head: Multi-Head Environments. (line 33) * current-head-dimensions: Multi-Head Environments. (line 38) * current-head-offset: Multi-Head Environments. (line 44) * cursorp: Cursor Appearance. (line 7) * custom-add-option: Defgroup and Defcustom. (line 219) * custom-get-options: Defgroup and Defcustom. (line 223) * custom-load-user-file: Customization Files. (line 24) * customize: Customization. (line 22) * cycle-class: Dynamic Window Cycles. (line 26) * cycle-class-backwards: Dynamic Window Cycles. (line 27) * cycle-dock: Dynamic Window Cycles. (line 31) * cycle-dock-backwards: Dynamic Window Cycles. (line 32) * cycle-group: Dynamic Window Cycles. (line 14) * cycle-group-backwards: Dynamic Window Cycles. (line 15) * cycle-prefix: Dynamic Window Cycles. (line 21) * cycle-prefix-backwards: Dynamic Window Cycles. (line 22) * cycle-windows: Dynamic Window Cycles. (line 10) * cycle-windows-backwards: Dynamic Window Cycles. (line 11) * def-frame-class: Frame Part Classes. (line 40) * default-cursor: Cursor Appearance. (line 26) * defcustom: Defgroup and Defcustom. (line 60) * defgroup: Defgroup and Defcustom. (line 11) * define-command: New-style Command Definition. (line 11) * define-command-to-screen: New-style Command Definition. (line 32) * define-cycle-command: Dynamic Window Cycles. (line 65) * define-cycle-command-pair: Dynamic Window Cycles. (line 72) * define-focus-mode: Input Focus. (line 95) * define-frame-class: Frame Part Classes. (line 63) * define-frame-type-mapper: Frame Types. (line 44) * define-placement-mode: Window Placement. (line 127) * define-window-animator: Animating Windows. (line 14) * delete-empty-workspaces: Workspaces and Windows. (line 17) * delete-window: Destroying Windows. (line 11) * delete-window-instance: Workspaces and Windows. (line 145) * delete-window-safely: Destroying Windows. (line 16) * delete-x-property: X Properties. (line 25) * desktop-window-p: Window Types. (line 73) * destroy-window <1>: Default Commands. (line 15) * destroy-window: Destroying Windows. (line 20) * disable-flippers: Edge Flipping. (line 47) * display-message: Display Functions. (line 35) * dock-window-p: Window Types. (line 91) * draw-diagonal-gradient: Gradient Functions. (line 20) * draw-horizontal-gradient: Gradient Functions. (line 15) * draw-vertical-gradient: Gradient Functions. (line 10) * draw-window-outline: Display Functions. (line 17) * edit-frame-style: Frame Styles. (line 31) * enable-flippers: Edge Flipping. (line 44) * erase-window-outline: Display Functions. (line 28) * eval-in: Other Functions. (line 86) * event-match: Event Matching. (line 13) * event-name: Event Representation. (line 30) * eventp: Events. (line 12) * exit-type: Other Functions. (line 25) * filter-windows: Windows. (line 33) * find-head: Multi-Head Environments. (line 10) * flip-image-diagonally: Images. (line 67) * flip-image-horizontally: Images. (line 59) * flip-image-vertically: Images. (line 63) * focus-pop-map: Input Focus. (line 172) * focus-push-map: Input Focus. (line 171) * font-ascent: Fonts. (line 55) * font-descent: Fonts. (line 59) * font-get: Fonts. (line 82) * font-height: Fonts. (line 51) * font-name: Fonts. (line 43) * font-put: Fonts. (line 78) * font-type: Fonts. (line 47) * font-type-exists-p: Fonts. (line 19) * fontp: Fonts. (line 10) * forget-button-press: Event Loop. (line 96) * frame-class-removed-p: Removing Frame Parts. (line 17) * frame-draw-mutex: Frame Functions. (line 64) * frame-part-dimensions: Frame Functions. (line 50) * frame-part-get: Frame Part Definition. (line 164) * frame-part-position: Frame Functions. (line 54) * frame-part-put: Frame Part Definition. (line 168) * frame-part-state: Frame Part Definition. (line 171) * frame-part-window: Frame Functions. (line 58) * frame-part-x-window: Frame Functions. (line 61) * frame-style-editable-p: Frame Styles. (line 28) * frame-type-menu: Frame Types. (line 71) * get-color: Colors. (line 14) * get-color-rgb: Colors. (line 27) * get-cursor: Cursor Appearance. (line 10) * get-font: Fonts. (line 33) * get-font-typed: Fonts. (line 23) * get-window-by-id: Windows. (line 18) * get-window-by-name: Windows. (line 21) * get-window-by-name-re: Windows. (line 24) * get-window-wm-protocols: Windows. (line 46) * get-x-property: X Properties. (line 29) * get-x-text-property: X Properties. (line 57) * grab-keyboard: Grab Functions. (line 60) * grab-pointer: Grab Functions. (line 29) * grab-server: Grab Functions. (line 7) * head-count: Multi-Head Environments. (line 15) * head-dimensions: Multi-Head Environments. (line 18) * head-offset: Multi-Head Environments. (line 24) * hide-desktop: Workspaces and Windows. (line 173) * hide-window: Showing and Hiding Windows. (line 11) * iconify-group: Operations on Groups. (line 11) * iconify-transient-group: Operations on Groups. (line 13) * iconify-window: Iconifying Windows. (line 12) * iconify-workspace-windows: Iconifying Windows. (line 22) * image-border: Images. (line 92) * image-dimensions: Images. (line 55) * image-fill: Images. (line 206) * image-get: Images. (line 78) * image-map: Images. (line 194) * image-modifier: Images. (line 125) * image-put: Images. (line 75) * image-ref: Images. (line 179) * image-set: Images. (line 186) * image-shape-color: Images. (line 113) * imagep: Images. (line 11) * indirect-transient-of-p: Window Types. (line 22) * input-focus: Input Focus. (line 10) * insert-workspace: Workspace Manipulation. (line 29) * insert-workspace-after: Workspace Manipulation. (line 34) * insert-workspace-before: Workspace Manipulation. (line 37) * interactive: Old-style Command Definition. (line 23) * keymapp: Keymaps. (line 11) * kill-client: Default Commands. (line 16) * last-event: Event Loop. (line 65) * list-x-properties: X Properties. (line 22) * load-module: Other Functions. (line 82) * locate-file: Other Functions. (line 108) * lookup-event: Event Representation. (line 21) * lookup-event-binding: Event Loop. (line 36) * lower-group: Operations on Groups. (line 49) * lower-group-depth: Operations on Groups. (line 52) * lower-single-window: Raising and Lowering Windows. (line 12) * lower-window: Raising and Lowering Windows. (line 11) * lower-window*: Raising and Lowering Windows. (line 29) * lower-window-and-transients: Window Types. (line 54) * lower-window-depth: Raising and Lowering Windows. (line 88) * lower-windows: Raising and Lowering Windows. (line 75) * make-directory-recursively: Other Functions. (line 104) * make-group-sticky: Operations on Groups. (line 19) * make-group-unsticky: Operations on Groups. (line 20) * make-image: Images. (line 14) * make-image-from-x-drawable: Images. (line 42) * make-keymap: Keymaps. (line 14) * make-sized-image: Images. (line 37) * make-window-ignored: Ignored Windows. (line 37) * make-window-not-ignored: Ignored Windows. (line 40) * make-window-sticky: Window Stickiness. (line 33) * make-window-sticky/viewport: Window Stickiness. (line 32) * make-window-sticky/workspace: Window Stickiness. (line 31) * make-window-unsticky: Window Stickiness. (line 39) * make-window-unsticky/viewport: Window Stickiness. (line 38) * make-window-unsticky/workspace: Window Stickiness. (line 37) * managed-windows: Windows. (line 14) * map-frame-parts: Frame Functions. (line 69) * map-other-window-groups: Assigning Windows to Groups. (line 58) * map-transient-group: Window Types. (line 46) * map-window-group: Assigning Windows to Groups. (line 53) * map-window-properties: Window Property Lists. (line 34) * map-window-workspaces: Workspaces and Windows. (line 151) * map-windows: Windows. (line 37) * mapped-stacking-order: Stacking Order. (line 11) * mark-window-as-desktop: Window Types. (line 76) * mark-window-as-dock: Window Types. (line 94) * mark-window-as-transient: Window Types. (line 14) * maximize-window: Maximizing Windows. (line 10) * maximize-window-horizontally: Maximizing Windows. (line 18) * maximize-window-horizontally-toggle: Maximizing Windows. (line 36) * maximize-window-toggle: Maximizing Windows. (line 27) * maximize-window-vertically: Maximizing Windows. (line 15) * maximize-window-vertically-toggle: Maximizing Windows. (line 32) * maybe-lower-window: Raising and Lowering Windows. (line 65) * maybe-raise-window: Raising and Lowering Windows. (line 60) * merge-next-workspace: Workspace Manipulation. (line 67) * merge-previous-workspace: Workspace Manipulation. (line 71) * move-cursor: Cursor Positioning. (line 10) * move-cursor-down: Cursor Positioning. (line 27) * move-cursor-down-fine: Cursor Positioning. (line 21) * move-cursor-left: Cursor Positioning. (line 24) * move-cursor-left-fine: Cursor Positioning. (line 18) * move-cursor-right: Cursor Positioning. (line 25) * move-cursor-right-fine: Cursor Positioning. (line 19) * move-cursor-up: Cursor Positioning. (line 26) * move-cursor-up-fine: Cursor Positioning. (line 20) * move-group-down: Operations on Groups. (line 45) * move-group-left: Operations on Groups. (line 42) * move-group-right: Operations on Groups. (line 43) * move-group-to-current-viewport: Operations on Groups. (line 39) * move-group-up: Operations on Groups. (line 44) * move-group-viewport: Operations on Groups. (line 40) * move-resize-window-to: Moving and Resizing Windows. (line 18) * move-selected-window: Moving and Resizing Windows. (line 54) * move-viewport: Viewports. (line 40) * move-viewport-to-window: Viewports. (line 53) * move-window-interactively: Moving and Resizing Windows. (line 39) * move-window-to: Moving and Resizing Windows. (line 11) * move-window-to-current-viewport: Viewports. (line 58) * move-window-to-workspace: Workspaces and Windows. (line 57) * move-window-viewport: Viewports. (line 48) * move-workspace: Workspace Manipulation. (line 40) * move-workspace-backwards: Workspace Manipulation. (line 48) * move-workspace-forwards: Workspace Manipulation. (line 44) * nearest-workspace-with-window: Workspaces and Windows. (line 44) * next-window: Fixed Window Cycles. (line 17) * next-workspace: Workspace Manipulation. (line 52) * next-workspace-window: Fixed Window Cycles. (line 12) * no-operation: Default Commands. (line 17) * pixmap-cache-control: Images. (line 217) * placement-mode: Window Placement. (line 19) * pointer-head: Multi-Head Environments. (line 30) * popup-apps-menu: Popup Menus. (line 108) * popup-menu: Popup Menus. (line 90) * popup-root-menu: Popup Menus. (line 99) * popup-window-menu <1>: Popup Menus. (line 114) * popup-window-menu: Workspaces and Windows. (line 53) * popup-workspace-list: Workspace Intervals. (line 38) * previous-window: Fixed Window Cycles. (line 18) * previous-workspace: Workspace Manipulation. (line 53) * previous-workspace-window: Fixed Window Cycles. (line 13) * primitive-play-sample: Other Functions. (line 75) * proxy-current-event: Event Loop. (line 68) * query-button-press-pointer: Pointer Functions. (line 24) * query-button-press-window: Pointer Functions. (line 31) * query-last-pointer: Pointer Functions. (line 20) * query-pointer: Pointer Functions. (line 7) * query-pointer-window: Pointer Functions. (line 16) * quit: Default Commands. (line 13) * quote-menu-item: Other Functions. (line 100) * raise-and-pass-through-click: Raising and Lowering Windows. (line 100) * raise-and-pass-through-click-if-focused: Raising and Lowering Windows. (line 105) * raise-group: Operations on Groups. (line 48) * raise-group-depth: Operations on Groups. (line 51) * raise-lower-group: Operations on Groups. (line 50) * raise-lower-single-window: Raising and Lowering Windows. (line 20) * raise-lower-window: Raising and Lowering Windows. (line 19) * raise-lower-window*: Raising and Lowering Windows. (line 39) * raise-lower-window-and-transients: Window Types. (line 58) * raise-lower-windows: Raising and Lowering Windows. (line 76) * raise-or-pass-through-click: Raising and Lowering Windows. (line 110) * raise-single-window: Raising and Lowering Windows. (line 16) * raise-window: Raising and Lowering Windows. (line 15) * raise-window*: Raising and Lowering Windows. (line 34) * raise-window-and-transients: Window Types. (line 50) * raise-window-depth: Raising and Lowering Windows. (line 92) * raise-windows: Raising and Lowering Windows. (line 74) * rebuild-frame: Frame Functions. (line 24) * rebuild-frame-part: Frame Functions. (line 74) * recolor-cursor: Cursor Appearance. (line 22) * record-window-animator: Animating Windows. (line 28) * refresh-frame-part: Frame Functions. (line 78) * refresh-window: Frame Functions. (line 21) * reload-frame-style: Frame Styles. (line 35) * remove-frame-class: Removing Frame Parts. (line 21) * remove-workspace: Workspace Manipulation. (line 61) * resize-selected-window: Moving and Resizing Windows. (line 58) * resize-window-interactively: Moving and Resizing Windows. (line 43) * resize-window-to: Moving and Resizing Windows. (line 14) * resize-window-with-hints: Moving and Resizing Windows. (line 22) * resize-window-with-hints*: Moving and Resizing Windows. (line 24) * restack-window: Stacking Order. (line 56) * restack-windows: Stacking Order. (line 15) * restart: Default Commands. (line 14) * root-window-id: Window Attributes. (line 47) * run-shell-command: Default Commands. (line 9) * run-window-animator: Animating Windows. (line 24) * save-stacking-order: Stacking Order. (line 52) * scale-image: Images. (line 159) * screen-dimensions: Display Functions. (line 13) * screen-height: Display Functions. (line 10) * screen-viewport: Viewports. (line 34) * screen-width: Display Functions. (line 7) * search-keymap: Keymaps. (line 38) * select-window: Input Focus. (line 188) * select-workspace: Workspace Manipulation. (line 11) * select-workspace-and-viewport: Workspace Manipulation. (line 25) * select-workspace-from-first: Workspace Manipulation. (line 21) * send-client-message: Other Functions. (line 10) * send-group-to-current-workspace: Operations on Groups. (line 33) * send-group-to-next-workspace: Operations on Groups. (line 29) * send-group-to-previous-workspace: Operations on Groups. (line 30) * send-group-to-workspace: Operations on Groups. (line 28) * send-to-next-workspace: Workspaces and Windows. (line 74) * send-to-previous-workspace: Workspaces and Windows. (line 88) * send-window-to-workspace-from-first: Workspaces and Windows. (line 127) * server-grabbed-p: Grab Functions. (line 25) * set-focus-mode: Input Focus. (line 102) * set-frame-part-value: Frame Part Classes. (line 82) * set-group-frame-style: Operations on Groups. (line 55) * set-image-border: Images. (line 99) * set-image-modifier: Images. (line 134) * set-image-shape-color: Images. (line 117) * set-input-focus: Input Focus. (line 14) * set-number-of-viewports: Viewports. (line 23) * set-number-of-workspaces: Workspace Manipulation. (line 75) * set-screen-viewport: Viewports. (line 37) * set-viewport: Viewports. (line 79) * set-window-depth: Stacking Order. (line 37) * set-window-frame: Frame Functions. (line 7) * set-window-viewport: Viewports. (line 44) * set-wm-modifier: Event Modifiers. (line 94) * set-x-property: X Properties. (line 41) * set-x-text-property: X Properties. (line 61) * shade-window: Shading Windows. (line 13) * show-desktop: Workspaces and Windows. (line 170) * show-window: Showing and Hiding Windows. (line 14) * showing-desktop-p: Workspaces and Windows. (line 176) * sm-add-restored-properties: Session Management. (line 17) * sm-add-saved-properties: Session Management. (line 16) * stack-window-above: Stacking Order. (line 48) * stack-window-below: Stacking Order. (line 44) * stacking-order: Stacking Order. (line 7) * stacking-order-by-depth: Stacking Order. (line 30) * sync-server: Other Functions. (line 7) * synthesize-event: Synthetic Events. (line 10) * text-width: Fonts. (line 63) * tile-image: Images. (line 155) * toggle-group-sticky: Operations on Groups. (line 23) * toggle-task-list-skip: Ignored Windows. (line 52) * toggle-window-cycle-skip: Ignored Windows. (line 50) * toggle-window-iconified: Iconifying Windows. (line 18) * toggle-window-ignored: Ignored Windows. (line 43) * toggle-window-list-skip: Ignored Windows. (line 51) * toggle-window-never-focus: Ignored Windows. (line 49) * toggle-window-shaded: Shading Windows. (line 19) * toggle-window-sticky: Window Stickiness. (line 43) * transient-children: Window Types. (line 31) * transient-group: Window Types. (line 36) * transient-of-p: Window Types. (line 18) * transient-parents: Window Types. (line 26) * unbind-keys: Keymaps. (line 34) * ungrab-keyboard: Grab Functions. (line 79) * ungrab-pointer: Grab Functions. (line 57) * ungrab-server: Grab Functions. (line 10) * uniconify-group: Operations on Groups. (line 12) * uniconify-transient-group: Operations on Groups. (line 14) * uniconify-window: Iconifying Windows. (line 15) * uniquify-list: Other Functions. (line 124) * uniquify-name: Window Attributes. (line 16) * uniquify-window-name: Window Attributes. (line 24) * unmaximize-window: Maximizing Windows. (line 21) * unshade-window: Shading Windows. (line 16) * user-eval: Other Functions. (line 95) * user-require: Other Functions. (line 96) * variable-customized-p: Customized Variable Status. (line 10) * variable-declared-p: Customized Variable Status. (line 14) * variable-default-value: Customized Variable Status. (line 15) * variable-type: Customized Variable Status. (line 21) * warp-cursor: Pointer Functions. (line 35) * warp-cursor-to-window: Pointer Functions. (line 39) * warp-pointer-if-necessary: Input Focus. (line 107) * window-absolute-position: Viewports. (line 74) * window-actual-group-id: Assigning Windows to Groups. (line 25) * window-appears-in-workspace-p: Workspaces and Windows. (line 35) * window-avoided-p: Window Placement. (line 107) * window-border-width: Frame Functions. (line 42) * window-class: Windows. (line 42) * window-depth: Stacking Order. (line 34) * window-dimensions: Window Attributes. (line 63) * window-frame: Frame Functions. (line 13) * window-frame-dimensions: Frame Functions. (line 29) * window-frame-offset: Frame Functions. (line 37) * window-framed-p: Frame Functions. (line 17) * window-full-name: Window Attributes. (line 10) * window-get: Window Property Lists. (line 29) * window-gravity: Moving and Resizing Windows. (line 92) * window-group-id: Window Attributes. (line 50) * window-group-ids: Window Groups. (line 20) * window-group-menu: Assigning Windows to Groups. (line 63) * window-icon-image: Iconifying Windows. (line 80) * window-icon-name: Window Attributes. (line 28) * window-iconifiable-p: Iconifying Windows. (line 33) * window-iconified-p: Iconifying Windows. (line 29) * window-id: Window Attributes. (line 43) * window-ignored-p: Ignored Windows. (line 33) * window-in-cycle-p: Input Focus. (line 163) * window-in-workspace-p: Workspaces and Windows. (line 31) * window-mapped-p: Window Attributes. (line 31) * window-maximized-horizontally-p: Maximizing Windows. (line 46) * window-maximized-p: Maximizing Windows. (line 40) * window-maximized-vertically-p: Maximizing Windows. (line 43) * window-name: Window Attributes. (line 7) * window-on-top-p: Stacking Order. (line 41) * window-ops-menu: Popup Menus. (line 111) * window-order <1>: Dynamic Window Cycles. (line 84) * window-order: Input Focus. (line 134) * window-order-focus-most-recent <1>: Dynamic Window Cycles. (line 108) * window-order-focus-most-recent: Input Focus. (line 156) * window-order-most-recent <1>: Dynamic Window Cycles. (line 102) * window-order-most-recent: Input Focus. (line 150) * window-order-pop <1>: Dynamic Window Cycles. (line 99) * window-order-pop: Input Focus. (line 147) * window-order-push <1>: Dynamic Window Cycles. (line 96) * window-order-push: Input Focus. (line 144) * window-outside-viewport-p: Viewports. (line 67) * window-outside-workspace-p: Viewports. (line 68) * window-position: Window Attributes. (line 67) * window-put: Window Property Lists. (line 24) * window-really-wants-input-p: Window Attributes. (line 59) * window-shaded-p: Shading Windows. (line 10) * window-shaped-p: Window Attributes. (line 40) * window-size-hints: Window Attributes. (line 71) * window-sticky-p: Window Stickiness. (line 27) * window-sticky-p/viewport: Window Stickiness. (line 26) * window-sticky-p/workspace: Window Stickiness. (line 25) * window-supports-wm-protocol-p: Windows. (line 50) * window-transient-p <1>: Window Attributes. (line 36) * window-transient-p: Window Types. (line 11) * window-type: Frame Types. (line 10) * window-type-add-border: Frame Types. (line 58) * window-type-add-title: Frame Types. (line 59) * window-type-remove-border: Frame Types. (line 60) * window-type-remove-title: Frame Types. (line 61) * window-urgent-p: Window Attributes. (line 84) * window-viewport: Viewports. (line 63) * window-visibility: Window Attributes. (line 79) * window-visible-p: Showing and Hiding Windows. (line 18) * window-wants-input-p: Window Attributes. (line 54) * windowp: Windows. (line 10) * windows-by-group: Assigning Windows to Groups. (line 43) * windows-in-group: Assigning Windows to Groups. (line 48) * windows-share-workspace-p: Workspaces and Windows. (line 40) * with-server-grabbed: Grab Functions. (line 16) * wm-modifier: Event Modifiers. (line 85) * workspace-empty-p: Workspaces and Windows. (line 14) * workspace-id-from-logical: Workspace Intervals. (line 31) * workspace-id-to-logical: Workspace Intervals. (line 24) * workspace-limits: Workspace Intervals. (line 19) * workspace-menu: Workspace Intervals. (line 41) * workspace-windows: Workspaces and Windows. (line 47) * x-atom: Other Functions. (line 30) * x-atom-name: Other Functions. (line 34) * x-bitmap-p: X Bitmaps and Pixmaps. (line 7) * x-change-gc: X Drawing. (line 24) * x-change-window-attributes: X Windows. (line 36) * x-clear-window: X Drawing. (line 7) * x-configure-window: X Windows. (line 14) * x-copy-area: X Drawing. (line 11) * x-create-bitmap: X Bitmaps and Pixmaps. (line 10) * x-create-gc: X Drawing. (line 16) * x-create-pixmap: X Bitmaps and Pixmaps. (line 13) * x-create-root-xor-gc: X Drawing. (line 32) * x-create-window: X Windows. (line 8) * x-destroy-drawable: X Bitmaps and Pixmaps. (line 16) * x-destroy-gc: X Drawing. (line 36) * x-destroy-window: X Windows. (line 19) * x-draw-arc: X Drawing. (line 40) * x-draw-image: X Drawing. (line 50) * x-draw-line: X Drawing. (line 55) * x-draw-rectangle: X Drawing. (line 59) * x-draw-string: X Drawing. (line 64) * x-drawable-height: X Bitmaps and Pixmaps. (line 19) * x-drawable-id: X Bitmaps and Pixmaps. (line 22) * x-drawable-p: X Bitmaps and Pixmaps. (line 25) * x-drawable-width: X Bitmaps and Pixmaps. (line 28) * x-events-queued: Event Loop. (line 105) * x-fill-arc: X Drawing. (line 69) * x-fill-polygon: X Drawing. (line 78) * x-fill-rectangle: X Drawing. (line 87) * x-gc-p: X Drawing. (line 92) * x-gc-set-dashes: X Drawing. (line 95) * x-get-selection: X Selections. (line 7) * x-grab-image-from-drawable: X Bitmaps and Pixmaps. (line 31) * x-keysym-name: X Keysyms. (line 7) * x-kill-client: Destroying Windows. (line 24) * x-lookup-keysym: X Keysyms. (line 11) * x-map-window: X Windows. (line 22) * x-pixmap-p: X Bitmaps and Pixmaps. (line 36) * x-selection-active-p: X Selections. (line 13) * x-server-timestamp: X Server. (line 7) * x-unmap-window: X Windows. (line 27) * x-window-back-buffer: X Drawing. (line 102) * x-window-id: X Windows. (line 30) * x-window-p: X Windows. (line 33) * x-window-swap-buffers: X Drawing. (line 111)  File: sawfish.info, Node: Variable Index, Next: Concept Index, Prev: Function Index, Up: Top Variable Index ************** [index] * Menu: * *user-module*: Other Functions. (line 91) * add-swapped-properties: Workspaces and Windows. (line 162) * add-to-workspace-hook: Workspace Hooks. (line 13) * add-window-hook: Window Construction Hooks. (line 8) * after-add-window-hook: Window Construction Hooks. (line 18) * after-framing-hook: Window Construction Hooks. (line 23) * after-initialization-hook: Startup and Shutdown Hooks. (line 7) * after-move-hook: Window Motion Hooks. (line 34) * after-resize-hook: Window Motion Hooks. (line 35) * after-restacking-hook: Window Motion Hooks. (line 42) * alt-keysyms: Event Modifiers. (line 69) * apps-menu: Popup Menus. (line 103) * avoid: Standard Properties. (line 14) * avoid-by-default: Window Placement. (line 120) * before-add-window-hook: Window Construction Hooks. (line 7) * before-exit-hook: Startup and Shutdown Hooks. (line 14) * before-move-hook: Window Motion Hooks. (line 22) * before-resize-hook: Window Motion Hooks. (line 23) * canonical-display-name: Other Functions. (line 38) * client-message-hook: Other Hooks. (line 11) * client-set-position: Standard Properties. (line 100) * configure-request-hook: X Hooks. (line 7) * current-frame-style <1>: Standard Properties. (line 63) * current-frame-style: Frame Styles. (line 18) * current-prefix-arg: Invoking Commands. (line 28) * current-workspace: Workspace Intervals. (line 15) * custom-default-file: Customization Files. (line 17) * custom-user-file: Customization Files. (line 7) * cycle-all-viewports: Dynamic Window Cycles. (line 47) * cycle-all-workspaces: Dynamic Window Cycles. (line 43) * cycle-include-iconified: Dynamic Window Cycles. (line 39) * cycle-raise-windows: Dynamic Window Cycles. (line 58) * cycle-show-window-names: Dynamic Window Cycles. (line 54) * decorate-transients: Window Types. (line 67) * default-bevel-percent: Images. (line 149) * default-font: Fonts. (line 71) * default-foreground: Colors. (line 62) * default-window-animator: Animating Windows. (line 10) * depth: Standard Properties. (line 78) * desktop-window-depth: Window Types. (line 84) * desktop-window-properties: Window Types. (line 79) * destroy-notify-hook: Window Destruction Hooks. (line 7) * display-name: Other Functions. (line 43) * dock-window-depth: Window Types. (line 104) * dock-window-properties: Window Types. (line 97) * dont-avoid-ignored: Window Placement. (line 116) * edge-flip-delay: Edge Flipping. (line 29) * edge-flip-enabled: Edge Flipping. (line 15) * edge-flip-only-when-moving: Edge Flipping. (line 23) * edge-flip-type: Edge Flipping. (line 19) * enter-flipper-hook: Workspace Hooks. (line 36) * enter-frame-part-hook: Pointer Motion Hooks. (line 11) * enter-notify-hook: Pointer Motion Hooks. (line 10) * enter-workspace-hook: Workspace Hooks. (line 7) * eval-key-release-events: Event Loop. (line 47) * eval-modifier-events: Event Loop. (line 44) * fixed-position: Standard Properties. (line 96) * focus-click-through <1>: Standard Properties. (line 31) * focus-click-through: Input Focus. (line 111) * focus-dont-push: Input Focus. (line 159) * focus-ignore-pointer-events: Input Focus. (line 120) * focus-in-hook: Pointer Motion Hooks. (line 40) * focus-mode: Input Focus. (line 25) * focus-modes: Input Focus. (line 29) * focus-out-hook: Pointer Motion Hooks. (line 53) * focus-when-mapped: Standard Properties. (line 42) * focus-windows-on-uniconify: Iconifying Windows. (line 46) * focus-windows-when-mapped: Window Types. (line 63) * focus-within-click-event: Input Focus. (line 124) * fonts-are-fontsets: Fonts. (line 86) * frame-part-classes: Frame Part Classes. (line 21) * frame-style <1>: Standard Properties. (line 59) * frame-style: Frame Styles. (line 14) * gravity: Standard Properties. (line 90) * gtkrc-changed-hook: Other Hooks. (line 7) * hide-client: Standard Properties. (line 74) * hyper-keysyms: Event Modifiers. (line 73) * iconified: Standard Properties. (line 87) * iconify-group-mode: Iconifying Windows. (line 58) * iconify-ignored: Iconifying Windows. (line 40) * iconify-window-hook: Window Mapping Hooks. (line 17) * ignore-program-position: Standard Properties. (line 45) * ignore-program-positions: Window Placement. (line 98) * ignore-window-input-hint: Standard Properties. (line 35) * ignored <1>: Standard Properties. (line 11) * ignored: Frame Styles. (line 22) * image-directory: Images. (line 28) * image-load-path: Images. (line 32) * keymap: Standard Properties. (line 28) * last-command: Invoking Commands. (line 36) * leave-flipper-hook: Workspace Hooks. (line 37) * leave-frame-part-hook: Pointer Motion Hooks. (line 26) * leave-notify-hook: Pointer Motion Hooks. (line 25) * leave-workspace-hook: Workspace Hooks. (line 8) * lock-first-workspace: Workspace Manipulation. (line 84) * map-notify-hook: Window Mapping Hooks. (line 7) * menu-program: Popup Menus. (line 77) * menu-program-stays-running: Popup Menus. (line 80) * menus-include-shortcuts: Popup Menus. (line 68) * meta-keysyms: Event Modifiers. (line 65) * move-cursor-increment: Cursor Positioning. (line 31) * move-outline-mode: Moving and Resizing Windows. (line 65) * move-show-position: Moving and Resizing Windows. (line 75) * move-snap-edges: Moving and Resizing Windows. (line 82) * move-snap-epsilon: Moving and Resizing Windows. (line 86) * multi-click-delay: Event Actions. (line 47) * never-focus: Standard Properties. (line 39) * override-frame-part-classes: Frame Part Classes. (line 74) * peristent-group-ids: Window Groups. (line 26) * place-mode: Standard Properties. (line 49) * place-transient-mode: Window Placement. (line 15) * place-window-hook: Window Mapping Hooks. (line 32) * place-window-mode: Window Placement. (line 11) * placed: Standard Properties. (line 83) * placement-modes: Window Placement. (line 22) * placement-weight: Standard Properties. (line 52) * pointer-motion-threshold: Pointer Functions. (line 53) * post-command-hook: Command Hooks. (line 10) * pre-command-hook: Command Hooks. (line 7) * property-notify-hook: X Hooks. (line 14) * raise-windows-on-uniconify: Iconifying Windows. (line 49) * raise-windows-when-unshaded: Shading Windows. (line 22) * remove-from-workspace-hook: Workspace Hooks. (line 14) * remove-window-hook: Startup and Shutdown Hooks. (line 10) * removed-classes: Standard Properties. (line 67) * reparent-notify-hook: Window Mapping Hooks. (line 9) * resize-outline-mode: Moving and Resizing Windows. (line 70) * resize-show-position: Moving and Resizing Windows. (line 79) * root-menu: Popup Menus. (line 96) * saved-command-line-args: Other Functions. (line 47) * sawfish-directory: Other Functions. (line 51) * sawfish-exec-directory: Other Functions. (line 55) * sawfish-lisp-lib-directory: Other Functions. (line 59) * sawfish-locale-directory: Other Functions. (line 63) * sawfish-site-lisp-directory: Other Functions. (line 68) * sawfish-version: Other Functions. (line 72) * select-window-cursor-shape: Input Focus. (line 193) * shade-window-hook: Window Mapping Hooks. (line 19) * shaded: Standard Properties. (line 71) * shape-notify-hook: Window Mapping Hooks. (line 10) * site-theme-directory: Themes. (line 61) * sm-after-restore-hook <1>: Session Management. (line 50) * sm-after-restore-hook: Startup and Shutdown Hooks. (line 19) * sm-restore-window-hook <1>: Session Management. (line 40) * sm-restore-window-hook: Startup and Shutdown Hooks. (line 18) * sm-restored-window-properties: Session Management. (line 22) * sm-save-directory: Session Management. (line 53) * sm-saved-window-properties: Session Management. (line 21) * sm-sloppy-id-matching: Session Management. (line 57) * sm-window-save-functions <1>: Session Management. (line 33) * sm-window-save-functions: Startup and Shutdown Hooks. (line 17) * stagger-placement-step: Window Placement. (line 88) * sticky: Standard Properties. (line 22) * sticky-viewport: Standard Properties. (line 25) * super-keysyms: Event Modifiers. (line 77) * system-theme-directory: Themes. (line 56) * theme-load-path: Themes. (line 47) * theme-update-interval: Themes. (line 65) * themes-are-gaoled: Themes. (line 69) * this-command: Invoking Commands. (line 32) * type: Standard Properties. (line 56) * unbound-key-hook: Key Hooks. (line 7) * uniconify-group-mode: Iconifying Windows. (line 59) * uniconify-to-current-viewport: Viewports. (line 85) * uniconify-to-current-workspace: Iconifying Windows. (line 52) * uniconify-window-hook: Window Mapping Hooks. (line 18) * uniquify-name-format: Window Attributes. (line 21) * unmap-notify-hook: Window Mapping Hooks. (line 8) * unshade-window-hook: Window Mapping Hooks. (line 20) * user-raise-type: Raising and Lowering Windows. (line 45) * user-theme-directory: Themes. (line 52) * viewport-dimensions: Viewports. (line 18) * viewport-moved-hook: Workspace Hooks. (line 32) * viewport-resized-hook: Workspace Hooks. (line 28) * visibility-notify-hook: Window Mapping Hooks. (line 27) * warp-to-window-enabled: Pointer Functions. (line 50) * warp-to-window-offset: Pointer Functions. (line 46) * while-moving-hook: Window Motion Hooks. (line 26) * while-resizing-hook: Window Motion Hooks. (line 27) * window-depth-change-hook: Window Mapping Hooks. (line 23) * window-maximized-hook: Window Mapping Hooks. (line 21) * window-moved-hook: Window Motion Hooks. (line 7) * window-ops-toggle-menu: Popup Menus. (line 119) * window-resized-hook: Window Motion Hooks. (line 8) * window-state-change-hook: X Hooks. (line 19) * window-unmaximized-hook: Window Mapping Hooks. (line 22) * wm-modifier-value: Event Modifiers. (line 89) * workspace-boundary-mode: Workspaces and Windows. (line 20) * workspace-local-properties: Workspaces and Windows. (line 158) * workspace-names: Workspace Intervals. (line 44) * workspace-send-boundary-mode: Workspaces and Windows. (line 140) * workspace-state-change-hook: Workspace Hooks. (line 21) * workspaces: Standard Properties. (line 18)  File: sawfish.info, Node: Concept Index, Prev: Variable Index, Up: Top Concept Index ************* [index] * Menu: * Attributes, of windows: Window Attributes. (line 6) * Classes, of frame parts: Frame Part Classes. (line 6) * Colors: Colors. (line 6) * Command Hooks: Command Hooks. (line 6) * Commands: Commands. (line 6) * Copying: Copying. (line 6) * Cursors: Cursors. (line 6) * Customization: Customization. (line 6) * Customization files: Customization Files. (line 6) * defcustom: Defgroup and Defcustom. (line 6) * defgroup: Defgroup and Defcustom. (line 6) * Desktop workspaces: Workspaces. (line 6) * Destroying windows: Destroying Windows. (line 6) * Display functions: Display Functions. (line 6) * Environments, multi-head: Multi-Head Environments. (line 6) * Event loop: Event Loop. (line 6) * Event Matching: Event Matching. (line 6) * Event Modifiers: Event Modifiers. (line 6) * Events: Events. (line 6) * Events, Synthesizing: Synthetic Events. (line 6) * Events, Synthetic: Synthetic Events. (line 6) * Files, customization: Customization Files. (line 6) * Focus, input: Input Focus. (line 6) * Fonts: Fonts. (line 6) * Frame basics: Frame Basics. (line 6) * Frame functions: Frame Functions. (line 6) * Frame part classes: Frame Part Classes. (line 6) * Frame part definitions: Frame Part Definition. (line 6) * Frame parts, removing: Removing Frame Parts. (line 6) * Frame styles: Frame Styles. (line 6) * Frame types: Frame Types. (line 6) * Frames, of windows: Window Frames. (line 6) * Functions, display: Display Functions. (line 6) * Functions, grab: Grab Functions. (line 6) * Functions, gradients: Gradient Functions. (line 6) * Functions, other: Other Functions. (line 6) * Functions, pointer: Pointer Functions. (line 6) * Grab functions: Grab Functions. (line 6) * Gradient functions: Gradient Functions. (line 6) * Groups, assigning windows to: Assigning Windows to Groups. (line 6) * Groups, operations on: Operations on Groups. (line 6) * Groups, windows: Window Groups. (line 6) * Hiding and showing windows: Showing and Hiding Windows. (line 6) * Hooks, Command: Command Hooks. (line 6) * Hooks, Key: Key Hooks. (line 6) * Hooks, Other: Other Hooks. (line 6) * Hooks, Pointer Motion: Pointer Motion Hooks. (line 6) * Hooks, standard: Standard Hooks. (line 6) * Hooks, Startup and Shutdown: Startup and Shutdown Hooks. (line 6) * Hooks, Window Construction: Window Construction Hooks. (line 6) * Hooks, Window Destruction: Window Destruction Hooks. (line 6) * Hooks, Window Mapping: Window Mapping Hooks. (line 6) * Hooks, Window Motion: Window Motion Hooks. (line 6) * Hooks, Workspace: Workspace Hooks. (line 6) * Hooks, X: X Hooks. (line 6) * Iconifying windows: Iconifying Windows. (line 6) * Images: Images. (line 6) * Input focus: Input Focus. (line 6) * Introduction: Introduction. (line 6) * Key Hooks: Key Hooks. (line 6) * Keyboard focus: Input Focus. (line 6) * Keymaps: Keymaps. (line 6) * Matching, Events: Event Matching. (line 6) * Maximizing windows: Maximizing Windows. (line 6) * Menus, popup: Popup Menus. (line 6) * Miscellaneous functions: Miscellaneous Functions. (line 6) * Modifiers, for events: Event Modifiers. (line 6) * Monitors, multiple: Multi-Head Environments. (line 6) * Moving and resizing windows: Moving and Resizing Windows. (line 6) * Multi-head environments: Multi-Head Environments. (line 6) * Other functions: Other Functions. (line 6) * Other Hooks: Other Hooks. (line 6) * Placement of windows: Window Placement. (line 6) * Pointer functions: Pointer Functions. (line 6) * Pointer Motion Hooks: Pointer Motion Hooks. (line 6) * Popup menus: Popup Menus. (line 6) * Properties, X: X Properties. (line 6) * Property lists, of windows: Window Property Lists. (line 6) * Removing frame parts: Removing Frame Parts. (line 6) * Resizing and moving windows: Moving and Resizing Windows. (line 6) * Session management: Session Management. (line 6) * Shading windows: Shading Windows. (line 6) * Showing and hiding windows: Showing and Hiding Windows. (line 6) * Stacking, of windows: Window Stacking. (line 6) * Standard hooks: Standard Hooks. (line 6) * Standard window properties: Standard Properties. (line 6) * Startup and Shutdown Hooks: Startup and Shutdown Hooks. (line 6) * Sticky, windows: Window Stickiness. (line 6) * Styles, frame: Frame Styles. (line 6) * Synthetic Events: Synthetic Events. (line 6) * Themes: Themes. (line 6) * Types, of windows: Window Types. (line 6) * Viewports: Viewports. (line 6) * Window attributes: Window Attributes. (line 6) * Window Construction Hooks: Window Construction Hooks. (line 6) * Window cycles, dynamic: Dynamic Window Cycles. (line 6) * Window cycles, fixed: Fixed Window Cycles. (line 6) * Window Destruction Hooks: Window Destruction Hooks. (line 6) * Window frames: Window Frames. (line 6) * Window frames, basics: Frame Basics. (line 6) * Window frames, frame part classes: Frame Part Classes. (line 6) * Window frames, frame part definitions: Frame Part Definition. (line 6) * Window frames, functions: Frame Functions. (line 6) * Window frames, removing frame parts: Removing Frame Parts. (line 6) * Window frames, styles: Frame Styles. (line 6) * Window frames, themes: Themes. (line 6) * Window frames, types: Frame Types. (line 6) * Window Mapping Hooks: Window Mapping Hooks. (line 6) * Window Motion Hooks: Window Motion Hooks. (line 6) * Window properties, standard: Standard Properties. (line 6) * Window property lists: Window Property Lists. (line 6) * Window stacking: Window Stacking. (line 6) * Window stickiness: Window Stickiness. (line 6) * Window types: Window Types. (line 6) * Windows: Windows. (line 6) * Windows, Animating: Animating Windows. (line 6) * Windows, attributes of: Window Attributes. (line 6) * Windows, cycling between: Cycling Between Windows. (line 6) * Windows, destroying: Destroying Windows. (line 6) * Windows, iconifying: Iconifying Windows. (line 6) * Windows, ignored: Ignored Windows. (line 6) * Windows, input focus: Input Focus. (line 6) * Windows, lowering: Raising and Lowering Windows. (line 6) * Windows, maximizing: Maximizing Windows. (line 6) * Windows, moving and resizing: Moving and Resizing Windows. (line 6) * Windows, raising: Raising and Lowering Windows. (line 6) * Windows, shading: Shading Windows. (line 6) * Windows, showing and hiding: Showing and Hiding Windows. (line 6) * Windows, stacking: Window Stacking. (line 6) * Windows, types of: Window Types. (line 6) * Windows, X properties: X Properties. (line 6) * Workspace Hooks: Workspace Hooks. (line 6) * Workspaces: Workspaces. (line 6) * X Hooks: X Hooks. (line 6) * X properties: X Properties. (line 6)  Tag Table: Node: Top738 Node: Copying2299 Node: Introduction3113 Node: News4300 Node: Colors97869 Node: Fonts100433 Node: Images103790 Node: Cursors113083 Node: Cursor Appearance113450 Node: Cursor Positioning115941 Node: Windows117048 Node: Window Property Lists119321 Node: Window Types120976 Node: Window Attributes125061 Node: Input Focus128388 Node: X Properties135862 Node: Window Stacking139067 Node: Stacking Order139492 Node: Raising and Lowering Windows141893 Node: Moving and Resizing Windows146444 Node: Showing and Hiding Windows150438 Node: Destroying Windows151233 Node: Shading Windows152428 Node: Iconifying Windows153380 Node: Window Stickiness156478 Node: Ignored Windows158491 Node: Maximizing Windows160151 Node: Animating Windows161790 Node: Cycling Between Windows162985 Node: Fixed Window Cycles163440 Node: Dynamic Window Cycles164345 Node: Window Groups168213 Node: Assigning Windows to Groups169316 Node: Operations on Groups172040 Node: Customization174126 Node: Defgroup and Defcustom175732 Node: Customization Files183817 Node: Customized Variable Status185012 Node: Window Frames185855 Node: Frame Basics186664 Node: Frame Part Classes188060 Node: Frame Part Definition192217 Node: Frame Functions199121 Node: Frame Types202134 Node: Frame Styles205178 Node: Themes206549 Node: Removing Frame Parts209739 Node: Viewports210671 Node: Workspaces214399 Node: Workspace Intervals215065 Node: Workspace Manipulation217303 Node: Workspaces and Windows220723 Node: Edge Flipping227926 Node: Multi-Head Environments229757 Node: Window Placement231769 Node: Popup Menus237579 Node: Events242642 Node: Event Representation243340 Node: Event Modifiers244637 Node: Event Actions247407 Node: Event Matching249427 Node: Synthetic Events249950 Node: Commands250840 Node: Old-style Command Definition251475 Node: New-style Command Definition252846 Node: Interactive Calling Specification254800 Node: Operations on Commands256592 Node: Invoking Commands257799 Node: Default Commands259297 Node: Keymaps259841 Node: Event Loop262173 Node: Miscellaneous Functions266547 Node: Pointer Functions266824 Node: Grab Functions269107 Node: Display Functions272302 Node: Gradient Functions274994 Node: Other Functions276039 Node: Standard Hooks280737 Node: Command Hooks282008 Node: Key Hooks282301 Node: Window Construction Hooks282884 Node: Window Destruction Hooks283863 Node: Window Mapping Hooks284358 Node: Window Motion Hooks285780 Node: X Hooks287576 Node: Pointer Motion Hooks288532 Node: Workspace Hooks291066 Node: Startup and Shutdown Hooks292828 Node: Other Hooks293493 Node: Standard Properties293987 Node: Session Management297265 Node: Low-level X Interface299815 Node: X Server300099 Node: X Windows300645 Node: X Selections302154 Node: X Keysyms302753 Node: X Bitmaps and Pixmaps303128 Node: X Drawing304270 Node: Available X Symbols309443 Node: FAQ310416 Node: Function Index320547 Node: Variable Index369357 Node: Concept Index386685  End Tag Table