\input texinfo   @c -*-texinfo-*-
@c %**start of header
@setfilename wimpwm-ref.info
@settitle wimpwm User's Manual
@iftex
@afourpaper
@end iftex
@c %**end of header

@include version.texi

@ifinfo
This file documents the wimpwm window manager.

@dircategory Miscellaneous
@direntry
* Wimpwm: (wimpwm-ref). wimpwm User's Manual.
@end direntry

Copyright (C) 1999, 2000 Martin Grabmueller

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.
@end ifinfo




@c --- title page starts here ---

@titlepage
@title wimpwm
@subtitle User's Manual
@subtitle Version @value{VERSION}
@author Martin Grabmueller

@c  The following two commands
@c  start the copyright page.
@page
@vskip 0pt plus 1filll
Copyright @copyright{} 1999, 2000 Martin Grabmueller

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.
@end titlepage

@c --- title page ends here ---




@node Top, Introduction, (dir), (dir)
@comment  node-name,  next,  previous,  up

@ifinfo
This document describes how to use the window manager wimpwm.

This document applies to version @value{VERSION} of wimpwm.
@end ifinfo

@menu
* Introduction::                Introduction to wimpwm
* Using wimpwm::                How to use wimpwm
* Window Usage::                How to manage windows
* Working Set Usage::           How to manage working sets
* Configuration::               How to configure wimpwm
* Glossary::                    The glossary
@end menu




@node 	 Introduction, Using wimpwm, Top, Top
@comment  node-name,  next,  previous,  up
@chapter Introduction

wimpwm is a window manager for the X Window System. It is designed to
be small and fast, but only to a degree where it still is useful and
comfortable to use. The reason for starting "yet another"(TM) window
manager was that I tried a dozen and a half different window managers,
but none of them seemed to be the right thing for me.

wimpwm features interactive moving and resizing of windows with either
mouse or keyboard, window hiding and cycling through visible windows
with the keyboard. Also it provides a special kind of multiple
workspaces, so-called working sets. But its main advantage is that it is
small and fast, and not as distracting as most of the other window
managers out there.

@menu
* wimpwm History::              How wimpwm became what it is now
* Future Plans::                How will wimpwm change?
@end menu




@node wimpwm History, Future Plans, Introduction, Introduction
@comment  node-name,  next,  previous,  up
@section wimpwm History

wimpwm is the direct successor of Yakazao, the first window manager I
wrote.

I started the Yakazao project for two reasons.  First, I was tired of
trying to get used to new window managers when I was looking for a
window manager which completely suited my needs. The other reason was
that I always was curious about programming the Xlib.  So some day,
Yakazao was born.

When I started I was inspired by lwm (The Lightweight Window Manager),
which was cute and small. The idea of moving windows around with the
keyboard came from evilwm, whose keybinding partially have been adapted
for wimpwm. I also learned a lot from poking around in the code of aewm
(The Ascetic Window Manager) and took a lot of code from it to get a
running prototype. Later I replaced the code to learn how to do it
myself and to make sure that the look and feel of wimpwm better suited
my needs.

Over the time, Yakazao changed a lot.  The look mostly remained the same
since I first designed it, but the feel has drastically changed. I
changed the keyboard handling to support multi-key sequences, I
implemented root window menus and multiple working sets, including the
nice working set indicator which pops up when changing working sets.

Then I felt that some configuration mechanism was needed.  I decided to
follow the Emacs approach and implemented a tiny Scheme interpreter for
evaluating a configuration file and for setting variables.  This first
step to configurability was functional, but very limited.

I used Yakazao for several months at home, at work and at university,
and it was working fine, so I started another project.  This new project
was a Scheme interpreter called Sizzle.  Sizzle was designed to be
easily embedded into C applications.  I decided to replace the
rudimentary configuration abilities in Yakazao by embedding a real
Scheme interpreter, namely Sizzle.  The conversion to the new
interpreter was quite painless, and after an hour, I had a working
Sizzle-enabled window manager.  I then picked up the code to do some
more enhancements, so I finally decided that a new name was needed.  I
came up with @i{wimpwm}, which means that this window manager is for
wimps like me who fear complicated and bloated window managers.

Half a year later I stumbled across a window manager called pwm, which
was quite similar to what I would call my ideal window manager, but I
was so used to wimpwm that I instead started to change some of my code
to come closer to the look of pwm, which I liked a lot.  The result were
the tab-like titlebars with a 3D-look, similar to those of pwm, which in
turn took them from the BeOS window system.  But that was not enough for
me.  So I tweaked my code and implemented the automatic tab positioning
feature, which tries to move the tabs to a position where they disturb
least.  I could not resist to include the animation of the tabs, so that
tabs now shift into their now position visibly, when the client
configuration changes.




@node Future Plans,  , wimpwm History, Introduction
@comment  node-name,  next,  previous,  up
@section Future Plans

I plan to implement a command line similar to Emacs' minibuffer where
commands for wimpwm may be typed in and executed.

The configurability of wimpwm will be further enhanced. For now, you can
only change the contents of the application menu, define workspaces and
change the title font and some colors from the configuration files.

On top of my wishlist is the option to configure the keyboard-launchable
commands in the init files.





@node Using wimpwm, Window Usage, Introduction, Top
@comment  node-name,  next,  previous,  up
@chapter Using wimpwm

This chapter describes how you can make use of all the neat features
wimpwm provides. In many ways wimpwm is very different from other
window managers, so you will have to read over this to get a grip on
what is possible with wimpwm and what isn't.

@menu
* Keyboard Usage::              Key conventions used by wimpwm
* Changing Input Focus::        How to give input focus to windows
* Starting Programs::           Letting wimpwm start your programs 
* Hot Keys::                    Keyboard shortcuts
@end menu




@node Keyboard Usage, Changing Input Focus, Using wimpwm, Using wimpwm
@comment  node-name,  next,  previous,  up
@section Keyboard Usage

There are a few things to be said about keyboard usage in wimpwm. The
keyboard handling is a bit different from that used by other window
managers, which may be a bit strange at first, but there is a concept
behind similar to that used in Emacs, which may be quite familiar to
you. wimpwm defines modifier keys, which are to be pressed
simultaneously to be recognized. The default keys are @key{CTRL} and
@key{ALT}, so you have to press @key{CTRL}, @key{ALT} and another key
together so that wimpwm will recognize your wish. In this manual, I
will use the same short form for denoting such key sequences that Emacs
uses, so @code{C-A-a} means the same as @key{CTRL} @key{ALT} @key{a}.

Two prefix keys are predefined: @code{C-A-x} and
@code{C-A-c}. @code{C-A-x} begins several window manager commands, and
@code{C-A-c} begins key sequences which start programs.

For convenience, some commands do not require a prefix key. These are
the commands for positioning windows and changing the input focus, as
well as working set switching, because these operations are so common
that they deserve single-key key sequences.




@node Changing Input Focus, Starting Programs, Keyboard Usage, Using wimpwm
@comment  node-name,  next,  previous,  up
@section Changing Input Focus

wimpwm implements a focus policy called ``Sloppy Focus''. That means,
that the window in which the mouse pointer is positioned receives all
input focus. If you want to change the input focus, you have to move the
mouse pointer to the window which is to receive the focus. The input
focus is not taken away if you move the mouse away from a window, as
long as the pointer does not enter another window, so you can move the
pointer to the root window and back without losing the focus.

Another method for changing is provided by keyboard shortcuts. The key
sequence @code{C-A-DOWN} will move the focus to the next visible
window. You can repeat that key sequence, so that all visible windows
will be selected sequentially. The input wraps around, so that after
selecting the last window, you will select the first one again. This
method only selects visible windows so that you can hide windows to
unclutter your desktop, and then use the keyboard to switch through the
two or three windows you are actually working with at a given time.

The key sequence @code{C-A-UP} does the same like @code{C-A-DOWN}, but selects the previous window in the window list.




@node Starting Programs, Hot Keys, Changing Input Focus, Using wimpwm
@comment  node-name,  next,  previous,  up
@section Starting Programs

wimpwm defines the special prefix key @code{C-A-c} for starting
programs. Some keys are already bound to common programs by default.

@table @code
@item C-A-c C-A-x
Starts an xterm with the command @code{xterm}.
@item C-A-c C-A-e
Starts Emacs with the command @code{emacs}.
@item C-A-c C-A-n
Starts Netscape with the command @code{netscape}.
@item C-A-c C-A-r
Root shell with the command @code{xterm -title 'Root Shell' -bg rgb:ff/60/60 -e su -}.
@item C-A-c C-A-u
Starts an ssh session to my university using the command @code{xterm
-title Uni -e ssh -l mgrabmue fiesta.cs.tu-berlin.de} (this will not be of
use for many people, but it is for me, so I will leave it in).

@end table

In the future, the applications you can start and the keys to launch
them can be defined in wimpwm's initialization files.




@node Hot Keys,  , Starting Programs, Using wimpwm
@comment  node-name,  next,  previous,  up
@section Hot Keys

You can toggle through all visible windows with the key combinations
@code{C-A-UP} and @code{C-A-DOWN}.  If you want to recover hidden
windows, you can do that by typing @code{C-A-x C-A-b}, which will make
all windows visible.  Move windows by switching to the window-move mode
with @code{C-A-m} and the using the @code{C-A-<arrow key>} combinations.
@code{C-A-LEFT}, for example, will move the current window 16 pixels to
the left.

You can position windows in the corners of the desktop without switching
to window-move mode by pressing some keys kombinations.  @code{C-A-HOME}
will put the current window in the upper left corner of the desktop,
@code{C-A-END} in the lower right, @code{C-A-PGUP} in the upper right
and @code{C-A-PGDN} in the lower right corner.

@code{C-A-x C-A-0} hides the current window, @code{C-A-x C-A-1} hides
all windows except the current one and @code{C-A-x C-A-ESC} restarts
wimpwm.  If you ever need to log out, you can quit wimpwm with
@code{C-A-x C-A-c}. Be careful to save your work before you do so,
because wimpwm will not ask for confirmation.

In normal mode:
@table @code
@item C-A-LEFT
Select previous working set.
@item C-A-RIGHT
Select next working set.
@item C-A-UP
Select previous window.
@item C-A-DOWN
Select next window.
@item C-A-HOME
Place the current window in the upper-left corner.
@item C-A-END
Place the current window in the lower-left corner.
@item C-A-PGUP
Place the current window in the upper-right corner.
@item C-A-PGDN
Place the current window in the lower-right corner.
@item C-A-x C-A-0
Hide the current window.
@item C-A-x C-A-1
Hide all but the current window.
@item C-A-x C-A-r
Re-read the user's initialization file.
@item C-A-x C-A-Esc
Restart wimpwm.
@item C-A-x C-A-s
Enter stickify mode.  Click on a window to toggle its sticky state.
@end table

In move mode (enter move mode with @key{C-A-m}):
@table @code
@item C-A-LEFT
Move current window 16 pixels to the left.
@item C-A-RIGHT
Move current window 16 pixels to the right.
@item C-A-UP
Move current window 16 pixels up.
@item C-A-DOWN
Move current window 16 pixels down.
@end table

In resize mode (enter move mode with @key{C-A-r}):
@table @code
@item C-A-LEFT
Grow current window by 16 pixels horizontally.
@item C-A-RIGHT
Shrink current window by 16 pixels horizontally.
@item C-A-UP
Grow current window by 16 pixels vertically.
@item C-A-DOWN
Shrink current window by 16 pixels vertically.
@end table



@node Window Usage, Working Set Usage, Using wimpwm, Top
@comment  node-name,  next,  previous,  up
@chapter Window Usage

The main use for a window manager is (of course) managing windows. This
chapter explains which possibilities wimpwm provides for efficient window
manipulation.

@menu
* Raising and Lowering::        Managing the stacking order of windows
* Window Moving::               Managing window position
* Window Resizing::             Managing window size
* Window Hiding::               Managing window visibility
* Window Unhiding::             Restoring window visibility
* Window Destroying::           How to get rid of windows
* Window Menu::                 Menu for managing windows
@end menu




@node Raising and Lowering, Window Moving, Window Usage, Window Usage
@comment  node-name,  next,  previous,  up
@section Raising and Lowering

All windows managed by wimpwm can be arranged overlapping each
other. This stacking order can be changed by various means.

A click with the left mouse button on the title bar raises the window,
and a click with the the right mouse button puts it to the bottom of the
window stack. Be careful not to click into the little rectangle in the
title bar, because mouse clicks have another meaning in that context:
The left button hides the window and the right button destroys it.

You can change the stacking order by other means too, for example by
switching through all visible windows with the keyboard shortcuts
@code{C-A-UP} and @code{C-A-DOWN}, which will cycle through all visible
windows.




@node Window Moving, Window Resizing, Raising and Lowering, Window Usage
@comment  node-name,  next,  previous,  up
@section Window Moving

If you feel like moving some windows around, just click the middle mouse
button while pointing at the title bar of a window and you can move an
outline of the window across the screen. When releasing the button, the
window moves to the position where you stopped dragging the mouse.
While you are dragging the window, the moving window's geometry
(position and size) is displayed in the middle of the window's outline).

One feature of wimpwm is that windows, when moved with the mouse,
automatically snap to some coordinates. Currently windows snap to the
screen borders and to any borders of other windows.

Another possibility to shuffle windows around is to use the keyboard
shortcuts. To do this, you have to switch to window-move mode by
pressing @code{C-A-m}. Then @code{C-A-LEFT} moves the current window 16
pixels to the left, @code{C-A-RIGHT}, @code{C-A-UP} and @code{C-A-DOWN}
move the window 16 pixels to the left, top or bottom of the
screen.  Window-move mode is ended by pressing @code{C-A-RET}.

Using one of the key combinations @code{C-A-HOME}, @code{C-A-PGUP},
@code{C-A-PGDN} or @code{C-A-END} will immediately move the window to
the absolute upper left, upper right, lower right or lower left corner
of the screen.  You do not have to switch to Window-move mode to do
that.




@node Window Resizing, Window Hiding, Window Moving, Window Usage
@comment  node-name,  next,  previous,  up
@section Window Resizing

Window resizing works similar to window resizing in twm.  When you press
the middle button on the little box in the upper right corner of the
title bar, an outline of the window is drawn on the screen. Once you
move the mouse pointer over any edge of that outline, the outline will
grow and shrink as you move the mouse. When you release the mouse
button, the window will be resized so that it fills the outline you
dragged with your mouse. During resizing, the geometry of the window is
displayed in the middle of the window, to help you keep track of the
current size of the window.

Window resizing via keyboard sequences is also possible.  First, you
have to switch to window-resize mode by pressing @code{C-A-r}. Then you
can make the current window wider by pressing @code{C-A-RIGHT} and
taller by pressing @code{C-A-DOWN}. Hitting @code{C-A-LEFT} shrinks the
window horizontally and @code{C-A-UP} shrinks it vertically.
Window-resize mode is ended by pressing @code{C-A-RET}, just like
window-move mode.




@node Window Hiding, Window Unhiding, Window Resizing, Window Usage
@comment  node-name,  next,  previous,  up
@section Window Hiding

You can hide windows by simply clicking the left mouse button into the
little square in the upper right corner of the window's frame. A
keyboard shortcut is also available, @code{C-A-x C-A-0}.

For hiding more than one window, the key sequence @code{C-A-x C-A-1} is
defined. It hides all windows except the current window which has the
input focus.




@node Window Unhiding, Window Destroying, Window Hiding, Window Usage
@comment  node-name,  next,  previous,  up
@section Window Unhiding

The first possibility to make a hidden window visible again is to press
mouse button 2 on the root window and then select the window from the
menu.  Hidden windows have their names enclosed in parantheses in the
menu so you can more easily find out which to select.  The other
possibility is to use the keyboard sequence @code{C-A-x C-A-b}, which
makes all hidden windows visible again.




@node Window Destroying, Window Menu, Window Unhiding, Window Usage
@comment  node-name,  next,  previous,  up
@section Window Destroying

If you want to delete a window permanently, you can use the destroy
window function of wimpwm. Just click the right button into the square
in the title bar of the window which you want to close. Note that the
application which owns the window might be killed, if it is the last
window of that application or if the X client does not understand the X
delete command.  Better use the command or menu item the application
provides for exiting than the function the window manager provides.




@node Window Menu,  , Window Destroying, Window Usage
@comment  node-name,  next,  previous,  up
@section Window Menu

Pressing mouse button 2 on the root window shows the window menu.  All
windows managed by wimpwm are listed there, the names of hidden windows
are enclosed in parantheses.  You can bring a window to the top of the
window stacking order by selecting its name from the window menu.  Note
that the window will be brought to the current working set when you
select it from another working set.  If you do not want that, but rather
want to switch to the working set of the window, hold the control key
down when selecting the window.  That will warp you to the window's
working set and bring the window to the top, making it the current
window which receives keyboard events.




@node Working Set Usage, Configuration, Window Usage, Top
@comment  node-name,  next,  previous,  up
@chapter Working Set Usage

wimpwm implements a concept similar to multiple (or virtual)
workspaces. The user should be able to define so-called "working sets"
of windows which belong together, for example an editor for programming
and an xterm for testing, or a mail and a news reader. Each of the
working sets can then be hidden or displayed, either one working set at
a time or more than one, just as the user likes it. That concept makes
it easy to have a tidy uncluttered desktop but fast access to all
windows needed.

@menu
* Defining Working Sets::       How to define working sets
* Manipulating Working Sets::   How to work with working sets
* Windows and Working Sets::    
@end menu




@node Defining Working Sets, Manipulating Working Sets, Working Set Usage, Working Set Usage
@comment  node-name,  next,  previous,  up
@section Defining Working Sets

Working sets are defined through wimpwm's configuration files by
setting the wariable @var{working-set-list} to a list of strings.  These
are the names of the working sets which will be created.  You can create
any number of working sets, you can even specify an empty list, which
will wimpwm cause to create one unnamed working set where all operation
takes place.  Here are some examples:

@example
(define working-set-list '("Editing" "Mail" "Web"))
(define working-set-list '("1" "2" "3" "4"))
@end example

Note that wimpwm will create one working set called ``Default'' when no
working set list is defined in any configuration file.




@node Manipulating Working Sets, Windows and Working Sets, Defining Working Sets, Working Set Usage
@comment  node-name,  next,  previous,  up
@section Manipulating Working Sets

You can change working sets by selecting another working set than the
current one by selecting a working set from the working set menu.  Click
mouse button 3 on the root window, focus a working set name by moving
the mouse over the item you wish to use and release the button.  This
will hide all windows not belonging to the new working set and show all
windows which belong to it.

Another possibility is to switch to the next defined working set by
pressing @code{C-A-Right} or the previous working set by pressing
@code{C-A-Left}. This will wrap around to the first working set when you
are already on the last working set, and the other way around, too.

Another convenient method wimpwm provides for working set management is
the possibility to send windows to other working sets.  You can do that
by holding down the control key when selecting a working set from the
working set menu.  When you release the mouse button to select the
working set, the mouse cursor will turn into a cross.  You have to
select a window by clicking on it.  Then, the selected window will
disappear from the current working set and appear in the one you have
selected from the menu.

@node Windows and Working Sets,  , Manipulating Working Sets, Working Set Usage
@comment  node-name,  next,  previous,  up
@section Windows and Working Sets

You can move windows between different working sets by various means.

To move a window currently located on another working set onto the
current working set by selecting that window from the window menu.  The
window will be made visible and moved to the current working set.

You can also move to a window not located on the current working set
without moving it to another working set, by holding down the @key{Ctrl}
key while selecting the window from the window menu.  You will be warped
to the working set of the selected window.

It is also possible to make a window @i{sticky}, that means to make it
visible on all working sets.  Just press @code{C-A-x C-A-s} and click on
a window to change its sticky state.

If you want to send a window to a specific working set, hold down
@key{Ctrl} while selecting a working set form the working set menu.
Then click a window and the window will be sent to the target working
set.




@node Configuration, Glossary, Working Set Usage, Top
@comment  node-name,  next,  previous,  up
@chapter Configuration

wimpwm is configurable through configuration files.  A lot of variables
can be defined to change wimpwm's look and behaviour.

@menu
* Configuration Files::         Everything about wimpwm's configuration files
* Syntax::                      Configuration file syntax
* Variables::                   Predefined variables
@end menu




@node Configuration Files, Syntax, Configuration, Configuration
@comment  node-name,  next,  previous,  up
@section Configuration Files

Two kinds of configuration files are used by wimpwm. The first is the
system-wide configuration file called @code{system.wimpwm}, which is
installed together with the binary and documentation files on
installation, normally in @code{/usr/local/share/wimpwm/$version}, where
@code{$version} refers to the installed version of wimpwm.  This file is
read before the user-specific configuration file is loaded.
User-specific configuration files are the second kind.  They are located
in the users' home directories and are called @code{.wimpwm}.




@node Syntax, Variables, Configuration Files, Configuration
@comment  node-name,  next,  previous,  up
@section Syntax

Configuration files are Scheme source files, which are parsed by the
embedded Scheme interpreter Sizzle (Scheme is a functional programming
language derived from Lisp).  Thus, the full power of Scheme (or at
least, the power of programming the Scheme subset that Sizzle
implements) is usable in wimpwm initialization files.

Another benefit for the user is that she can use emacs'
@code{scheme-mode} for comfortable editing of configuration files.




@node Variables,  , Syntax, Configuration
@comment  node-name,  next,  previous,  up
@section Variables

wimpwm uses various predefined variables for operation.  The contents
of the root window menus is specified in configuration files and working
sets are defined there, too.  This is a list of all the variables you
can define in order to modify wimpwm's behaviour.

@table @var
@item window-menu-title
The title which will be given to the menu which lists the windows.
@item application-menu-title
The title for the application menu.
@item working-set-menu-title
The title for the working set menu.
@item application-list
This variable can be set to a list of applications which will appear in
the application list.  The syntax is as follows: The variable must hold
a list of lists, every sublist denotes one menu item.  The first entry
in every menu item must be a string which will appear on the menu, the
second entry is either a string, which is the command line to be
executed or a symbol, which tells the window manager what to do.  Two
symbols are currently defined; @code{restart} will restart the window
manager, causing it to re-read the cinfiguration files, and @code{exit},
which will exit wimpwm.

The following will create a menu where three
applications can be started from.
@example
(define application-list
  '(("Xterm" "xterm")
    ("Emacs" "emacs")
    ("Netscape" "netscape")))
@end example
And the next one allows you to start an xterm, to restart the window
manager or to exit your window manager session.
@example
(define application-list
  '(("Xterm" "xterm")
    ("Restart" restart)
    ("Exit" exit)))
@end example

@item tab-scroll-speed
If greater than zero, the window tab of the current window will scroll
from left to right and right to left.  This is a silly animation, but I
could not resist.  Note that automatic tab positioning is disabled if
this variable is not zero.
@item title-font
Set this to a valid X font name.  This font will be used for drawing the
window titles and menus.
@item border-width
Set this to any integer value.  It specifies the width of the border
drawn around the client windows.
@item title-active-color
Set this to a valid X color name.  It specifies the color for drawing
the title of active windows.
@item title-inactive-color
Set this to a valid X color name.  It specifies the color for drawing
the title of inactive windows.
@item background-color
Set this to a valid X color name.  It specifies the color for drawing
the background of the tabs and the menu titles.
@item background-color-highlight
Set this to a valid X color name.  It specifies the color for drawing
the highlighting  of the tabs and the menu titles.
@item background-color-shadow
Set this to a valid X color name.  It specifies the color for drawing
the shadow of the tabs and the menu titles.
@item border-color
Set this to a valid X color name.  It specifies the color for drawing
borders of the client windows.
@item cycle-candidate?
Set this to a predicate which determines whether a client window is
considered a candidate for window-cycling with the @key{C-A-<arrow>}
shortcuts.  The predicate receives the title string of the client and
should return a true value if the client is appropriate for cycling, and
false if not.
@end table



@node Glossary,  , Configuration, Top
@comment  node-name,  next,  previous,  up
@unnumbered Glossary

@table @var
@item box
Little bright square on the top right corner of the windows'
titlebar. Click there to hide, move or delete client windows.
@item configuration file
A file where wimpwm reads information from to find out how to display
menus etc.
@item frame
The frame is the black rectangle drawn around client windows by
wimpwm. Normally, the fram is only one pixel wide, but that can be
changed.  You can manipulate a window by clicking on the frame just as
you can with the title bar.
@item hiding
Making a window invisible.
@item key sequence
Sequence of one or more key presses which together form a command for
wimpwm.
@item mapping
The action of making a window appear on the screen.
@item prefix key
Any key which is not the last one in a key sequence.
@item root menus
Menus for starting programs and recovering hidden windows. You get these
windows by clicking on the root window.
@item root window
What other systems call the desktop, X users call the root window. Click
there to get the root menus.
@item snapping
Snapping is one of wimpwm's features. It means that window movement is
slightly restricted, so that window seem to get a bit stuck when they
are moved closely to the display borders or to the borders of other
windows. This helps to position windows more precisely.
@item tab
The tab is the rectangular little title bar window on top of client
windows.  Use the mouse there to raise, lower and move client windows.
@item unmapping
The action of making a window invisible.
@item working set
Originally a term from computer science describing the parts of a
program where a processor spends most of its time.  In wimpwm, a working
set is a collection of windows which can be hidden and recovered
together.
@end table




@contents

@bye

