workspace: Don't redraw workspace if it doesn't need redrawing

The mwm_redraw() function is called to redraw the clients as well as
the status bar and other indicators. The current implementation calls
monitor_redraw() and workspace_redraw() on all monitors and workspaces,
respectively, so these functions must make sure not to redraw anything
if it isn't necessary.
This commit changes the workspace_redraw() function so it does not
redraw the workspace if it was not explicitly requested.

mwm: Ignore BadWindow errors

There are windows that cannot be reconfigured when running on Xorg
with xdm (I'm not sure about other configurations, but at least this
does not affect Xephyr). Avoid the problem by ignoring BadWindow
errors until a proper solution is found.

mwm: Add missing command names

The array of command names in mwm_cmd() is incomplete, causing the
window manager to crash if debugging is enabled and a command is
executed whose name is not in the array.
This commit adds the missing names to the array and changes the way
the index is determined so that similar issues will not occur in the
future.

mwm: Use stderr for debug output

The timing of debug messages written with printf() is wrong because
stdout is buffered by glibc. This commit changes debug output to be
written to stderr.

mwm: Manage clients that were started before the window manager

The current implementation of mwm will not manage windows of clients
that were started before the window manager itself. This commit makes
mwm scan for existing clients during initialization.

mwm: Handle as many events as possible before redrawing

The current implementation redraws the monitors (where necessary) after
each handled event. This leads to problems when an application destroys
or unmaps multiple windows in one go, because mwm will attempt to redraw
the destroyed windows for which it hasn't processed the destroy/unmap
event yet.
This commit changes the mwm_run() function to handle all queued events
before redrawing anything.

workspace: When the focused client is detached, focus on the next one

When the focused client is detached from a workspace, the focus is moved
to the first client of the workspace. However, from a user point-of-view,
it seems better to move the focus to the next client.
This commit changes the workspace_detach_client() function to shift the
focus to the next client, if the focused client is removed.

kbptr: Implement keyboard pointer

The pointer is typically very awkward to use, especially on devices with mice or
similar input devices. This commit adds an experimental keyboard pointer, which
allows the user to move the pointer and perform clicks through the keyboard.
The keyboard pointer follows this basic idea: The user can move the pointer in
four directions: North, East, South, West. The pointer has a horizontal stride
and a vertical stride (the size of a step in horizontal or vertical direction,
respectively). With each step, the respective stride is reduced by half.
The origin of the pointer is the center of the focused window, and the initial
horizontal and vertical stride are a quarter of the window's width and height,
respectively.

For example in a 100x100px window (the point (0, 0) being the top left corner),
the pointer's origin is (50, 50). If the pointer makes one step north, it will
be at (50, 25). Moving another step north will put the pointer at (50, 12.5).
The user can also hold the shift key while moving, which will cause the stride
to be reduced once before the movement and once after the movement (this seemed
useful for targets that are close to the pointer).

This pointer behavior has two implications:

 1. If the stride reaches zero, the pointer can't be moved anymore
 2. The pointer can never leave the window (it asymptotically approaches the
    outermost pixel, strictly speaking)

Re-centering the pointer also replenishes the stride. If a user misses their
target, they have to start over from the center of the window. If a user wants
to point at another window, they have to move the focus to that window first.

mwm: Add functions for managing monitors, workspaces, clients, and more

This commit makes several enhancements to the mwm type. It adds functions
for:
 - attaching, detaching, and searching monitors
 - attaching, detaching, and searching workspaces
 - attaching, detaching, and searching clients
 - rendering UTF-8 using Pango and Xft
 - dealing with X11 Graphic Contexts
 - initializing colors and getting color values
 - executing MWM commands (for keyboard shortcuts)
 - dealing with X11 atoms
 - reading the root window title

client: Implement resizing and changing the visibility of clients

This commit implements functions to resize clients, and change their
visibility by moving them out of the root screen.

monitor: Implement statusbar and indicator bars

This implements the statusbar that indicates the active workspace
and displays the name of the root window (as status text).
This commit also implements the indicator bars, which highlight the
active/focused client (and will be used to display information about
clients in later versions).

workspace: Add functions for managing clients in workspaces

This commit adds functions to add and remove clients from workspaces,
arrange clients according to the monitor's layout function, and to
shift client positions within the workspace.

config: Add file for customization of themes and keyboard shortcuts

This commit adds a file that defines the mwm theme and a set of
keyboard shortcuts. This is where future customizations should be
added (and where other customizable settings should be moved).

keys: Add type for keyboard shortcuts

This commit adds a type for keyboard shortcut definitions.

theme: Add definitions for colors, palettes, and themes

Common definitions for colors, palettes, and themes are necessary
to make the style of mwm easily-customizable.
This commit adds a set of style-related types.

common: Add functions for comparing geoms and pointers

The loop_find() function needs a fallback comparison function to use
if no other comparison function was provided. This commit adds a
comparison function that compares two pointers.
Further, this commit adds a function that calculates the intersecting
area of two geometries.

layout: Add infrastructure and client layout functions

Infrastructure to support layout functions, and layout functions
themselves are necessary to correctly display a workspace. This
commit adds the necessary infrastructure to enable swift
implementations of layout functions.
Further, this commit adds a horizontal and a vertical layout
function.

main: Keep a pointer to the mwm instance in a global variable

There are cases when we cannot pass a pointer to the mwm context
directly. In these cases, we will need to refer to the mwm instance
through a global variable. This commit adds the global reference.

array: Remove type

All arrays that had been used for storing workspaces, clients, etc
have been replaced with loops. This removes the array implementation
since it is not used anymore.

loop: Add convenience functions and a foreach function without data

This commit adds convenience functions to the loop data type that
allow the caller to find the elements that come before or after an
element in a loop.
This further adds functions to shift the position of an element in
the loop to the back or the front, and a foreach function that
passes only the element pointer to the callback (this is useful for
calling things like free() from the foreach function).

loop: Fix several issues in the loop implementation

There were several bugs in the loop implementation, most notably
in the search and remove methods. This commit fixes the bugs so
that it is possible to retrieve elements and remove elements
from loop structures.

mwm: Use loopy lists to keep track of workspaces and monitors

The arrays used by the mwm type to track workspaces and monitors are
not ideal for some operations if they are sparsely populated.
This commit replaces them with cyclic lists.

workspace: Add type for keeping track of workspaces

A data type is needed that clients can be attached to, and that monitors
can be associated with so that they display a set of clients.
This commit adds the workspace type that keeps track of a set of clients
and can be displayed by a monitor.

client: Add data type for keeping track of clients

A data type is needed to keep track of clients and associate them with
workspaces. This commit adds the client type that serves that purpose.

loop: Add cyclic list type

Since we will often cycle through monitors, workspaces, and clients, it
would be beneficial to have a data structure that assists with that.
This commit adds the loop type, which implements a cyclic doubly-linked
list.

x, common: Add convenience functions and common types

This commit adds convenience functions that wrap functionality provided
by Xlib. Further, it adds a structure that defines the geometry of an
object.

mwm: Implement monitor detection

Monitors connected to the X Server have to be detected in order to
provide meaningful window manager functionality.
This commit implements dynamic detection of monitors and adds events
that a callback can be connected to, so that it will be executed when
a monitor has been added.

array: Make array_get() return an error if an element wasn't set

The array_get() function returns success when an entry is retrieved that
was never set. This makes it hard to distinguish uninitialized entries.
This commit changes array_get() to return an error if the caller is
attempting to retrieve an uninitialized entry.

main: Instantiate and run mwm

The main() function currently does nothing but parse teh commandline.
This commit changes the main() function so that it creates an mwm
instance and subsequently initializes and executes it.

mwm: Add datatype to manage global context

This commit adds the mwm data type, which stores the global state of
the window manager, and will be used to handle events.

monitor: Add data type for monitor management

To keep track of connected monitors, a data type is necessary.
This commit adds the monitor datatype that is used to keep track
of the size and position of a monitor.

array: Add dynamic array type

For storage of monitors, a data type is needed that automatically
grows and shrinks as needed.
This commit adds a dynamic array implementation.

Initial commit: Start with a minimal Makefile, manpage, and main.c

This commit adds a minimal Makefile, a short manpage, and a mwm
implementation that does nothing but print a help text.