mwm: Make sure clients managed by mwm are in NormalState

Sharing of individual windows in Google Meets is not working because
the client state is not set, causing the windows not to be recognized
as sharable.
This commit makes sure the client state is set to NormalState when a
client is attached to (i.e. managed by) mwm.

monitor: Update indicator geometry when monitor geometry changes

The indicator geometry is not updated when the monitor geometry is
changed, causing the indicator size and/or position to be wrong when
the resolution or position of a monitor is changed.
This commit makes sure the indicator geometry is updated when the
geometry of the containing monitor is changed.

monitor: Use double-buffering to draw the status bar

The status bar sometimes flickers when it is redrawn because the
displayed bar is redrawn directly, without getting buffered.
This commit adds an intermediary buffer that is used to render the
status bar before its contents are copied into its window.

mwm: Implement rendering text vertically (not 縦書き)

To write status messages on vertical client indicators, we need to
be able to render text vertically.
This commit adds the mwm_render_text_vertical() function, which
renders text and rotates it 90 degrees clockwise.

monitor: Allow rendering of text on horizontal client indicators

The client indicators provide a lot of space that could be used to
display useful information.
This commit implements rendering of text on horizontal client
indicators.

monitor: Don't XMapRaise() statusbar every time it is redrawn

The statusbar is mapped raised everytime it is redrawn, even if it is
obscured by another window. If the other window is not tiled (that is,
its position and size are not controlled by mwm), it will try to bring
itself back to the front, and the two windows end up competing to be
on top of the stack.
This commit makes sure the statusbar is mapped only once, when it is
initialized. Since statusbars are never unmapped, there is no need to
map them every time they are redrawn.

mwm: Always set the border width

The border width is not set in _mwm_configure_request() if the client
did not request a specific border width. That means that clients that
leave their border width unspecified will end up with the default
border width (which is not zero).
This commit modifies _mwm_configure_request() to always set the
border width of a client to 0.

Fix a number of focus-related issues

The are a couple of issues with the way focusing is implemented (or
rather, neglected):
 - Focusing on a different client does not change the keyboard focus
 - The keyboard focus does not follow the pointer
 - The keyboard focus does not change when clicking on a window
 - The pointer does not follow the focus

This commit fixes the above issues by making the following changes:
 - Focus on a client when the pointer enters it
 - When focusing on a client, also move the keyboard focus
 - When focusing on a client, move the pointer over the client

client: Redraw clients if their geometry has changed

If the geometry of a client has been changed using client_set_geometry(),
the client should be redrawn. This commit makes the function mark the
client as needing a redraw, so that it will be redrawn the next time that
the monitor/workspace is redrawn.

monitor: Draw the background of the status bar in the background color

The background of the status bar is drawn in the focus color of the
current palette, meaning that the bar has a different background color
on focused and non-focused screens. This is no problem per-se, but it
makes it hard to predict if a status message will be readable or not,
especially if it uses colored text.
This commit changes the status bar to be drawn in the background color
and the focus color be used to draw a border on the left and bottom
sides of the status bar.

monitor: Don't rearrange clients if monitor doesn't need redrawing

The monitor_redraw() function unconditionally rearranges the visible
clients when it is called. However, if redrawing was not explicitly
requested, this is not necessary.
This commit changes the monitor_redraw() function not to rearrange
clients if a redraw is not necessary, so that only the status bar
and indicators will be redrawn.

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.