Merge branch 'backport' into work
authorDana Jansens <danakj@orodu.net>
Sat, 2 Feb 2008 16:36:17 +0000 (11:36 -0500)
committerDana Jansens <danakj@orodu.net>
Sat, 2 Feb 2008 16:37:35 +0000 (11:37 -0500)
Conflicts:

openbox/client.c
openbox/event.c
openbox/mouse.c
openbox/openbox.c
openbox/prop.c
openbox/prop.h
openbox/screen.c
parser/parse.c
parser/parse.h

12 files changed:
1  2 
obt/prop.c
obt/prop.h
openbox/actions.c
openbox/actions.h
openbox/actions/desktop.c
openbox/client.c
openbox/client.h
openbox/event.c
openbox/keyboard.c
openbox/mouse.c
openbox/openbox.c
openbox/screen.c

diff --combined obt/prop.c
index 6eedce5,0000000..89d3950
mode 100644,000000..100644
--- /dev/null
@@@ -1,494 -1,0 +1,495 @@@
 +/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
 +
 +   obt/prop.c for the Openbox window manager
 +   Copyright (c) 2006        Mikael Magnusson
 +   Copyright (c) 2003-2007   Dana Jansens
 +
 +   This program is free software; you can 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 of the License, or
 +   (at your option) any later version.
 +
 +   This program 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.
 +
 +   See the COPYING file for a copy of the GNU General Public License.
 +*/
 +
 +#include "obt/prop.h"
 +#include "obt/display.h"
 +
 +#include <X11/Xatom.h>
 +#ifdef HAVE_STRING_H
 +#  include <string.h>
 +#endif
 +
 +Atom prop_atoms[OBT_PROP_NUM_ATOMS];
 +gboolean prop_started = FALSE;
 +
 +#define CREATE_NAME(var, name) (prop_atoms[OBT_PROP_##var] = \
 +                                XInternAtom((obt_display), (name), FALSE))
 +#define CREATE(var) CREATE_NAME(var, #var)
 +#define CREATE_(var) CREATE_NAME(var, "_" #var)
 +
 +void obt_prop_startup()
 +{
 +    if (prop_started) return;
 +    prop_started = TRUE;
 +
 +    g_assert(obt_display);
 +
 +    CREATE(CARDINAL);
 +    CREATE(WINDOW);
 +    CREATE(PIXMAP);
 +    CREATE(ATOM);
 +    CREATE(STRING);
 +    CREATE_NAME(UTF8, "UTF8_STRING");
 +
 +    CREATE(MANAGER);
 +
 +    CREATE(WM_COLORMAP_WINDOWS);
 +    CREATE(WM_PROTOCOLS);
 +    CREATE(WM_STATE);
 +    CREATE(WM_CHANGE_STATE);
 +    CREATE(WM_DELETE_WINDOW);
 +    CREATE(WM_TAKE_FOCUS);
 +    CREATE(WM_NAME);
 +    CREATE(WM_ICON_NAME);
 +    CREATE(WM_CLASS);
 +    CREATE(WM_WINDOW_ROLE);
 +    CREATE(WM_CLIENT_MACHINE);
 +    CREATE(WM_COMMAND);
 +    CREATE(WM_CLIENT_LEADER);
 +    CREATE_(MOTIF_WM_HINTS);
 +
 +    CREATE(SM_CLIENT_ID);
 +
 +    CREATE_(NET_WM_FULL_PLACEMENT);
 +
 +    CREATE_(NET_SUPPORTED);
 +    CREATE_(NET_CLIENT_LIST);
 +    CREATE_(NET_CLIENT_LIST_STACKING);
 +    CREATE_(NET_NUMBER_OF_DESKTOPS);
 +    CREATE_(NET_DESKTOP_GEOMETRY);
 +    CREATE_(NET_DESKTOP_VIEWPORT);
 +    CREATE_(NET_CURRENT_DESKTOP);
 +    CREATE_(NET_DESKTOP_NAMES);
 +    CREATE_(NET_ACTIVE_WINDOW);
 +/*    CREATE_(NET_RESTACK_WINDOW);*/
 +    CREATE_(NET_WORKAREA);
 +    CREATE_(NET_SUPPORTING_WM_CHECK);
 +    CREATE_(NET_DESKTOP_LAYOUT);
 +    CREATE_(NET_SHOWING_DESKTOP);
 +
 +    CREATE_(NET_CLOSE_WINDOW);
 +    CREATE_(NET_WM_MOVERESIZE);
 +    CREATE_(NET_MOVERESIZE_WINDOW);
 +    CREATE_(NET_REQUEST_FRAME_EXTENTS);
 +    CREATE_(NET_RESTACK_WINDOW);
 +
 +    CREATE_(NET_STARTUP_ID);
 +
 +    CREATE_(NET_WM_NAME);
 +    CREATE_(NET_WM_VISIBLE_NAME);
 +    CREATE_(NET_WM_ICON_NAME);
 +    CREATE_(NET_WM_VISIBLE_ICON_NAME);
 +    CREATE_(NET_WM_DESKTOP);
 +    CREATE_(NET_WM_WINDOW_TYPE);
 +    CREATE_(NET_WM_STATE);
 +    CREATE_(NET_WM_STRUT);
 +    CREATE_(NET_WM_STRUT_PARTIAL);
 +    CREATE_(NET_WM_ICON);
 +    CREATE_(NET_WM_ICON_GEOMETRY);
 +    CREATE_(NET_WM_PID);
 +    CREATE_(NET_WM_ALLOWED_ACTIONS);
 +    CREATE_(NET_WM_USER_TIME);
 +/*  CREATE_(NET_WM_USER_TIME_WINDOW); */
 +    CREATE_(KDE_NET_WM_FRAME_STRUT);
 +    CREATE_(NET_FRAME_EXTENTS);
 +
 +    CREATE_(NET_WM_PING);
 +#ifdef SYNC
 +    CREATE_(NET_WM_SYNC_REQUEST);
 +    CREATE_(NET_WM_SYNC_REQUEST_COUNTER);
 +#endif
 +
 +    CREATE_(NET_WM_WINDOW_TYPE_DESKTOP);
 +    CREATE_(NET_WM_WINDOW_TYPE_DOCK);
 +    CREATE_(NET_WM_WINDOW_TYPE_TOOLBAR);
 +    CREATE_(NET_WM_WINDOW_TYPE_MENU);
 +    CREATE_(NET_WM_WINDOW_TYPE_UTILITY);
 +    CREATE_(NET_WM_WINDOW_TYPE_SPLASH);
 +    CREATE_(NET_WM_WINDOW_TYPE_DIALOG);
 +    CREATE_(NET_WM_WINDOW_TYPE_NORMAL);
 +
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOPLEFT] = 0;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOP] = 1;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOPRIGHT] = 2;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_RIGHT] = 3;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT] = 4;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOM] = 5;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT] = 6;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_LEFT] = 7;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_MOVE] = 8;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_SIZE_KEYBOARD] = 9;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_MOVE_KEYBOARD] = 10;
 +    prop_atoms[OBT_PROP_NET_WM_MOVERESIZE_CANCEL] = 11;
 +
 +    CREATE_(NET_WM_ACTION_MOVE);
 +    CREATE_(NET_WM_ACTION_RESIZE);
 +    CREATE_(NET_WM_ACTION_MINIMIZE);
 +    CREATE_(NET_WM_ACTION_SHADE);
 +    CREATE_(NET_WM_ACTION_MAXIMIZE_HORZ);
 +    CREATE_(NET_WM_ACTION_MAXIMIZE_VERT);
 +    CREATE_(NET_WM_ACTION_FULLSCREEN);
 +    CREATE_(NET_WM_ACTION_CHANGE_DESKTOP);
 +    CREATE_(NET_WM_ACTION_CLOSE);
 +    CREATE_(NET_WM_ACTION_ABOVE);
 +    CREATE_(NET_WM_ACTION_BELOW);
 +
 +    CREATE_(NET_WM_STATE_MODAL);
 +/*    CREATE_(NET_WM_STATE_STICKY);*/
 +    CREATE_(NET_WM_STATE_MAXIMIZED_VERT);
 +    CREATE_(NET_WM_STATE_MAXIMIZED_HORZ);
 +    CREATE_(NET_WM_STATE_SHADED);
 +    CREATE_(NET_WM_STATE_SKIP_TASKBAR);
 +    CREATE_(NET_WM_STATE_SKIP_PAGER);
 +    CREATE_(NET_WM_STATE_HIDDEN);
 +    CREATE_(NET_WM_STATE_FULLSCREEN);
 +    CREATE_(NET_WM_STATE_ABOVE);
 +    CREATE_(NET_WM_STATE_BELOW);
 +    CREATE_(NET_WM_STATE_DEMANDS_ATTENTION);
 +
 +    prop_atoms[OBT_PROP_NET_WM_STATE_ADD] = 1;
 +    prop_atoms[OBT_PROP_NET_WM_STATE_REMOVE] = 0;
 +    prop_atoms[OBT_PROP_NET_WM_STATE_TOGGLE] = 2;
 +
 +    prop_atoms[OBT_PROP_NET_WM_ORIENTATION_HORZ] = 0;
 +    prop_atoms[OBT_PROP_NET_WM_ORIENTATION_VERT] = 1;
 +    prop_atoms[OBT_PROP_NET_WM_TOPLEFT] = 0;
 +    prop_atoms[OBT_PROP_NET_WM_TOPRIGHT] = 1;
 +    prop_atoms[OBT_PROP_NET_WM_BOTTOMRIGHT] = 2;
 +    prop_atoms[OBT_PROP_NET_WM_BOTTOMLEFT] = 3;
 +
 +    CREATE_(KDE_WM_CHANGE_STATE);
 +    CREATE_(KDE_NET_WM_WINDOW_TYPE_OVERRIDE);
 +
 +/*
 +    CREATE_NAME(ROOTPMAPId, "_XROOTPMAP_ID");
 +    CREATE_NAME(ESETROOTId, "ESETROOT_PMAP_ID");
 +*/
 +
 +    CREATE_(OPENBOX_PID);
 +    CREATE_(OB_THEME);
++    CREATE_(OB_CONFIG_FILE);
 +    CREATE_(OB_WM_ACTION_UNDECORATE);
 +    CREATE_(OB_WM_STATE_UNDECORATED);
 +    CREATE_(OB_CONTROL);
 +}
 +
 +Atom obt_prop_atom(ObtPropAtom a)
 +{
 +    g_assert(prop_started);
 +    g_assert(a < OBT_PROP_NUM_ATOMS);
 +    return prop_atoms[a];
 +}
 +
 +static gboolean get_prealloc(Window win, Atom prop, Atom type, gint size,
 +                             guchar *data, gulong num)
 +{
 +    gboolean ret = FALSE;
 +    gint res;
 +    guchar *xdata = NULL;
 +    Atom ret_type;
 +    gint ret_size;
 +    gulong ret_items, bytes_left;
 +    glong num32 = 32 / size * num; /* num in 32-bit elements */
 +
 +    res = XGetWindowProperty(obt_display, win, prop, 0l, num32,
 +                             FALSE, type, &ret_type, &ret_size,
 +                             &ret_items, &bytes_left, &xdata);
 +    if (res == Success && ret_items && xdata) {
 +        if (ret_size == size && ret_items >= num) {
 +            guint i;
 +            for (i = 0; i < num; ++i)
 +                switch (size) {
 +                case 8:
 +                    data[i] = xdata[i];
 +                    break;
 +                case 16:
 +                    ((guint16*)data)[i] = ((gushort*)xdata)[i];
 +                    break;
 +                case 32:
 +                    ((guint32*)data)[i] = ((gulong*)xdata)[i];
 +                    break;
 +                default:
 +                    g_assert_not_reached(); /* unhandled size */
 +                }
 +            ret = TRUE;
 +        }
 +        XFree(xdata);
 +    }
 +    return ret;
 +}
 +
 +static gboolean get_all(Window win, Atom prop, Atom type, gint size,
 +                        guchar **data, guint *num)
 +{
 +    gboolean ret = FALSE;
 +    gint res;
 +    guchar *xdata = NULL;
 +    Atom ret_type;
 +    gint ret_size;
 +    gulong ret_items, bytes_left;
 +
 +    res = XGetWindowProperty(obt_display, win, prop, 0l, G_MAXLONG,
 +                             FALSE, type, &ret_type, &ret_size,
 +                             &ret_items, &bytes_left, &xdata);
 +    if (res == Success) {
 +        if (ret_size == size && ret_items > 0) {
 +            guint i;
 +
 +            *data = g_malloc(ret_items * (size / 8));
 +            for (i = 0; i < ret_items; ++i)
 +                switch (size) {
 +                case 8:
 +                    (*data)[i] = xdata[i];
 +                    break;
 +                case 16:
 +                    ((guint16*)*data)[i] = ((gushort*)xdata)[i];
 +                    break;
 +                case 32:
 +                    ((guint32*)*data)[i] = ((gulong*)xdata)[i];
 +                    break;
 +                default:
 +                    g_assert_not_reached(); /* unhandled size */
 +                }
 +            *num = ret_items;
 +            ret = TRUE;
 +        }
 +        XFree(xdata);
 +    }
 +    return ret;
 +}
 +
 +static gboolean get_stringlist(Window win, Atom prop, gchar ***list, gint *nstr)
 +{
 +    XTextProperty tprop;
 +    gboolean ret = FALSE;
 +
 +    if (XGetTextProperty(obt_display, win, &tprop, prop) && tprop.nitems) {
 +        if (XTextPropertyToStringList(&tprop, list, nstr))
 +            ret = TRUE;
 +        XFree(tprop.value);
 +    }
 +    return ret;
 +}
 +
 +gboolean obt_prop_get32(Window win, Atom prop, Atom type, guint32 *ret)
 +{
 +    return get_prealloc(win, prop, type, 32, (guchar*)ret, 1);
 +}
 +
 +gboolean obt_prop_get_array32(Window win, Atom prop, Atom type, guint32 **ret,
 +                              guint *nret)
 +{
 +    return get_all(win, prop, type, 32, (guchar**)ret, nret);
 +}
 +
 +gboolean obt_prop_get_string_locale(Window win, Atom prop, gchar **ret)
 +{
 +    gchar **list;
 +    gint nstr;
 +    gchar *s;
 +
 +    if (get_stringlist(win, prop, &list, &nstr) && nstr) {
 +        s = g_locale_to_utf8(list[0], -1, NULL, NULL, NULL);
 +        XFreeStringList(list);
 +        if (s) {
 +            *ret = s;
 +            return TRUE;
 +        }
 +    }
 +    return FALSE;
 +}
 +
 +gboolean obt_prop_get_strings_locale(Window win, Atom prop, gchar ***ret)
 +{
 +    GSList *strs = NULL, *it;
 +    gchar *raw, *p;
 +    guint num, i, count = 0;
 +
 +    if (get_all(win, prop, OBT_PROP_ATOM(STRING), 8,
 +                (guchar**)&raw, &num))
 +    {
 +        p = raw;
 +        while (p < raw + num) {
 +            ++count;
 +            strs = g_slist_append(strs, p);
 +            p += strlen(p) + 1; /* next string */
 +        }
 +
 +        *ret = g_new0(gchar*, count + 1);
 +        (*ret)[count] = NULL; /* null terminated list */
 +
 +        for (i = 0, it = strs; it; ++i, it = g_slist_next(it)) {
 +            (*ret)[i] = g_locale_to_utf8(it->data, -1, NULL, NULL, NULL);
 +            /* make sure translation did not fail */
 +            if (!(*ret)[i])
 +                (*ret)[i] = g_strdup("");
 +        }
 +        g_free(raw);
 +        g_slist_free(strs);
 +        return TRUE;
 +    }
 +    return FALSE;
 +}
 +
 +gboolean obt_prop_get_string_utf8(Window win, Atom prop, gchar **ret)
 +{
 +    gchar *raw;
 +    gchar *str;
 +    guint num;
 +
 +    if (get_all(win, prop, OBT_PROP_ATOM(UTF8), 8,
 +                (guchar**)&raw, &num))
 +    {
 +        str = g_strndup(raw, num); /* grab the first string from the list */
 +        g_free(raw);
 +        if (g_utf8_validate(str, -1, NULL)) {
 +            *ret = str;
 +            return TRUE;
 +        }
 +        g_free(str);
 +    }
 +    return FALSE;
 +}
 +
 +gboolean obt_prop_get_strings_utf8(Window win, Atom prop, gchar ***ret)
 +{
 +    GSList *strs = NULL, *it;
 +    gchar *raw, *p;
 +    guint num, i, count = 0;
 +
 +    if (get_all(win, prop, OBT_PROP_ATOM(UTF8), 8,
 +                (guchar**)&raw, &num))
 +    {
 +        p = raw;
 +        while (p < raw + num) {
 +            ++count;
 +            strs = g_slist_append(strs, p);
 +            p += strlen(p) + 1; /* next string */
 +        }
 +
 +        *ret = g_new0(gchar*, count + 1);
 +
 +        for (i = 0, it = strs; it; ++i, it = g_slist_next(it)) {
 +            if (g_utf8_validate(it->data, -1, NULL))
 +                (*ret)[i] = g_strdup(it->data);
 +            else
 +                (*ret)[i] = g_strdup("");
 +        }
 +        g_free(raw);
 +        g_slist_free(strs);
 +        return TRUE;
 +    }
 +    return FALSE;
 +}
 +
 +void obt_prop_set32(Window win, Atom prop, Atom type, gulong val)
 +{
 +    XChangeProperty(obt_display, win, prop, type, 32, PropModeReplace,
 +                    (guchar*)&val, 1);
 +}
 +
 +void obt_prop_set_array32(Window win, Atom prop, Atom type, gulong *val,
 +                      guint num)
 +{
 +    XChangeProperty(obt_display, win, prop, type, 32, PropModeReplace,
 +                    (guchar*)val, num);
 +}
 +
 +void obt_prop_set_string_locale(Window win, Atom prop, const gchar *val)
 +{
 +    gchar const *s[2] = { val, NULL };
 +    obt_prop_set_strings_locale(win, prop, s);
 +}
 +
 +void obt_prop_set_strings_locale(Window win, Atom prop, const gchar **strs)
 +{
 +    gint i, count;
 +    gchar **lstrs;
 +    XTextProperty tprop;
 +
 +    /* count the strings in strs, and convert them to the locale format */
 +    for (count = 0; strs[count]; ++count);
 +    lstrs = g_new0(char*, count);
 +    for (i = 0; i < count; ++i) {
 +        lstrs[i] = g_locale_from_utf8(strs[i], -1, NULL, NULL, NULL);
 +        if (!lstrs[i]) {
 +            lstrs[i] = g_strdup(""); /* make it an empty string */
 +            g_warning("Unable to translate string '%s' from UTF8 to locale "
 +                      "format", strs[i]);
 +        }
 +    }
 +
 +
 +    XStringListToTextProperty(lstrs, count, &tprop);
 +    XSetTextProperty(obt_display, win, &tprop, prop);
 +    XFree(tprop.value);
 +}
 +
 +void obt_prop_set_string_utf8(Window win, Atom prop, const gchar *val)
 +{
 +    XChangeProperty(obt_display, win, prop, OBT_PROP_ATOM(UTF8), 8,
 +                    PropModeReplace, (const guchar*)val, strlen(val));
 +}
 +
 +void obt_prop_set_strings_utf8(Window win, Atom prop, const gchar **strs)
 +{
 +    GString *str;
 +    gchar const **s;
 +
 +    str = g_string_sized_new(0);
 +    for (s = strs; *s; ++s) {
 +        str = g_string_append(str, *s);
 +        str = g_string_append_c(str, '\0');
 +    }
 +    XChangeProperty(obt_display, win, prop, obt_prop_atom(OBT_PROP_UTF8), 8,
 +                    PropModeReplace, (guchar*)str->str, str->len);
 +    g_string_free(str, TRUE);
 +}
 +
 +void obt_prop_erase(Window win, Atom prop)
 +{
 +    XDeleteProperty(obt_display, win, prop);
 +}
 +
 +void obt_prop_message(gint screen, Window about, Atom messagetype,
 +                      glong data0, glong data1, glong data2, glong data3,
 +                      glong data4, glong mask)
 +{
 +    obt_prop_message_to(obt_root(screen), about, messagetype,
 +                        data0, data1, data2, data3, data4, mask);
 +}
 +
 +void obt_prop_message_to(Window to, Window about,
 +                         Atom messagetype,
 +                         glong data0, glong data1, glong data2, glong data3,
 +                         glong data4, glong mask)
 +{
 +    XEvent ce;
 +    ce.xclient.type = ClientMessage;
 +    ce.xclient.message_type = messagetype;
 +    ce.xclient.display = obt_display;
 +    ce.xclient.window = about;
 +    ce.xclient.format = 32;
 +    ce.xclient.data.l[0] = data0;
 +    ce.xclient.data.l[1] = data1;
 +    ce.xclient.data.l[2] = data2;
 +    ce.xclient.data.l[3] = data3;
 +    ce.xclient.data.l[4] = data4;
 +    XSendEvent(obt_display, to, FALSE, mask, &ce);
 +}
diff --combined obt/prop.h
index 4de3111,0000000..e123611
mode 100644,000000..100644
--- /dev/null
@@@ -1,277 -1,0 +1,278 @@@
 +/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
 +
 +   obt/prop.h for the Openbox window manager
 +   Copyright (c) 2006        Mikael Magnusson
 +   Copyright (c) 2003-2007   Dana Jansens
 +
 +   This program is free software; you can 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 of the License, or
 +   (at your option) any later version.
 +
 +   This program 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.
 +
 +   See the COPYING file for a copy of the GNU General Public License.
 +*/
 +
 +#ifndef __obt_prop_h
 +#define __obt_prop_h
 +
 +#include <X11/Xlib.h>
 +#include <glib.h>
 +
 +G_BEGIN_DECLS
 +
 +typedef enum {
 +    /* types */
 +    OBT_PROP_CARDINAL, /*!< The atom which represents the Cardinal data type */
 +    OBT_PROP_WINDOW,   /*!< The atom which represents window ids */
 +    OBT_PROP_PIXMAP,   /*!< The atom which represents pixmap ids */
 +    OBT_PROP_ATOM,     /*!< The atom which represents atom values */
 +    OBT_PROP_STRING,   /*!< The atom which represents ascii strings */
 +    OBT_PROP_UTF8,     /*!< The atom which represents utf8-encoded strings */
 +
 +    /* selection stuff */
 +    OBT_PROP_MANAGER,
 +
 +    /* window hints */
 +    OBT_PROP_WM_COLORMAP_WINDOWS,
 +    OBT_PROP_WM_PROTOCOLS,
 +    OBT_PROP_WM_STATE,
 +    OBT_PROP_WM_DELETE_WINDOW,
 +    OBT_PROP_WM_TAKE_FOCUS,
 +    OBT_PROP_WM_CHANGE_STATE,
 +    OBT_PROP_WM_NAME,
 +    OBT_PROP_WM_ICON_NAME,
 +    OBT_PROP_WM_CLASS,
 +    OBT_PROP_WM_WINDOW_ROLE,
 +    OBT_PROP_WM_CLIENT_MACHINE,
 +    OBT_PROP_WM_COMMAND,
 +    OBT_PROP_WM_CLIENT_LEADER,
 +    OBT_PROP_MOTIF_WM_HINTS,
 +
 +    /* SM atoms */
 +    OBT_PROP_SM_CLIENT_ID,
 +
 +    /* NETWM atoms */
 +
 +    /* Atoms that are used inside messages - these don't go in net_supported */
 +
 +    OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOPLEFT,
 +    OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOP,
 +    OBT_PROP_NET_WM_MOVERESIZE_SIZE_TOPRIGHT,
 +    OBT_PROP_NET_WM_MOVERESIZE_SIZE_RIGHT,
 +    OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT,
 +    OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOM,
 +    OBT_PROP_NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT,
 +    OBT_PROP_NET_WM_MOVERESIZE_SIZE_LEFT,
 +    OBT_PROP_NET_WM_MOVERESIZE_MOVE,
 +    OBT_PROP_NET_WM_MOVERESIZE_SIZE_KEYBOARD,
 +    OBT_PROP_NET_WM_MOVERESIZE_MOVE_KEYBOARD,
 +    OBT_PROP_NET_WM_MOVERESIZE_CANCEL,
 +
 +    OBT_PROP_NET_WM_STATE_ADD,
 +    OBT_PROP_NET_WM_STATE_REMOVE,
 +    OBT_PROP_NET_WM_STATE_TOGGLE,
 +
 +    OBT_PROP_NET_WM_ORIENTATION_HORZ,
 +    OBT_PROP_NET_WM_ORIENTATION_VERT,
 +    OBT_PROP_NET_WM_TOPLEFT,
 +    OBT_PROP_NET_WM_TOPRIGHT,
 +    OBT_PROP_NET_WM_BOTTOMRIGHT,
 +    OBT_PROP_NET_WM_BOTTOMLEFT,
 +
 +    OBT_PROP_PRIVATE_PADDING1,
 +    OBT_PROP_PRIVATE_PADDING2,
 +    OBT_PROP_PRIVATE_PADDING3,
 +    OBT_PROP_PRIVATE_PADDING4,
 +    OBT_PROP_PRIVATE_PADDING5,
 +    OBT_PROP_PRIVATE_PADDING6,
 +    OBT_PROP_PRIVATE_PADDING7,
 +    OBT_PROP_PRIVATE_PADDING8,
 +    OBT_PROP_PRIVATE_PADDING9,
 +    OBT_PROP_PRIVATE_PADDING10,
 +    OBT_PROP_PRIVATE_PADDING11,
 +    OBT_PROP_PRIVATE_PADDING12,
 +
 +    /* Everything below here must go in net_supported on the root window */
 +
 +    /* root window properties */
 +    OBT_PROP_NET_SUPPORTED,
 +    OBT_PROP_NET_CLIENT_LIST,
 +    OBT_PROP_NET_CLIENT_LIST_STACKING,
 +    OBT_PROP_NET_NUMBER_OF_DESKTOPS,
 +    OBT_PROP_NET_DESKTOP_GEOMETRY,
 +    OBT_PROP_NET_DESKTOP_VIEWPORT,
 +    OBT_PROP_NET_CURRENT_DESKTOP,
 +    OBT_PROP_NET_DESKTOP_NAMES,
 +    OBT_PROP_NET_ACTIVE_WINDOW,
 +/*    Atom net_restack_window;*/
 +    OBT_PROP_NET_WORKAREA,
 +    OBT_PROP_NET_SUPPORTING_WM_CHECK,
 +    OBT_PROP_NET_DESKTOP_LAYOUT,
 +    OBT_PROP_NET_SHOWING_DESKTOP,
 +
 +    /* root window messages */
 +    OBT_PROP_NET_CLOSE_WINDOW,
 +    OBT_PROP_NET_WM_MOVERESIZE,
 +    OBT_PROP_NET_MOVERESIZE_WINDOW,
 +    OBT_PROP_NET_REQUEST_FRAME_EXTENTS,
 +    OBT_PROP_NET_RESTACK_WINDOW,
 +
 +    /* helpful hints to apps that aren't used for anything */
 +    OBT_PROP_NET_WM_FULL_PLACEMENT,
 +
 +    /* startup-notification extension */
 +    OBT_PROP_NET_STARTUP_ID,
 +
 +    /* application window properties */
 +    OBT_PROP_NET_WM_NAME,
 +    OBT_PROP_NET_WM_VISIBLE_NAME,
 +    OBT_PROP_NET_WM_ICON_NAME,
 +    OBT_PROP_NET_WM_VISIBLE_ICON_NAME,
 +    OBT_PROP_NET_WM_DESKTOP,
 +    OBT_PROP_NET_WM_WINDOW_TYPE,
 +    OBT_PROP_NET_WM_STATE,
 +    OBT_PROP_NET_WM_STRUT,
 +    OBT_PROP_NET_WM_STRUT_PARTIAL,
 +    OBT_PROP_NET_WM_ICON,
 +    OBT_PROP_NET_WM_ICON_GEOMETRY,
 +    OBT_PROP_NET_WM_PID,
 +    OBT_PROP_NET_WM_ALLOWED_ACTIONS,
 +    OBT_PROP_NET_WM_USER_TIME,
 +/*  OBT_PROP_NET_WM_USER_TIME_WINDOW, */
 +    OBT_PROP_NET_FRAME_EXTENTS,
 +
 +    /* application protocols */
 +    OBT_PROP_NET_WM_PING,
 +#ifdef SYNC
 +    OBT_PROP_NET_WM_SYNC_REQUEST,
 +    OBT_PROP_NET_WM_SYNC_REQUEST_COUNTER,
 +#endif
 +
 +    OBT_PROP_NET_WM_WINDOW_TYPE_DESKTOP,
 +    OBT_PROP_NET_WM_WINDOW_TYPE_DOCK,
 +    OBT_PROP_NET_WM_WINDOW_TYPE_TOOLBAR,
 +    OBT_PROP_NET_WM_WINDOW_TYPE_MENU,
 +    OBT_PROP_NET_WM_WINDOW_TYPE_UTILITY,
 +    OBT_PROP_NET_WM_WINDOW_TYPE_SPLASH,
 +    OBT_PROP_NET_WM_WINDOW_TYPE_DIALOG,
 +    OBT_PROP_NET_WM_WINDOW_TYPE_NORMAL,
 +
 +    OBT_PROP_NET_WM_ACTION_MOVE,
 +    OBT_PROP_NET_WM_ACTION_RESIZE,
 +    OBT_PROP_NET_WM_ACTION_MINIMIZE,
 +    OBT_PROP_NET_WM_ACTION_SHADE,
 +/*    OBT_PROP_NET_WM_ACTION_STICK,*/
 +    OBT_PROP_NET_WM_ACTION_MAXIMIZE_HORZ,
 +    OBT_PROP_NET_WM_ACTION_MAXIMIZE_VERT,
 +    OBT_PROP_NET_WM_ACTION_FULLSCREEN,
 +    OBT_PROP_NET_WM_ACTION_CHANGE_DESKTOP,
 +    OBT_PROP_NET_WM_ACTION_CLOSE,
 +    OBT_PROP_NET_WM_ACTION_ABOVE,
 +    OBT_PROP_NET_WM_ACTION_BELOW,
 +
 +    OBT_PROP_NET_WM_STATE_MODAL,
 +/*    OBT_PROP_NET_WM_STATE_STICKY,*/
 +    OBT_PROP_NET_WM_STATE_MAXIMIZED_VERT,
 +    OBT_PROP_NET_WM_STATE_MAXIMIZED_HORZ,
 +    OBT_PROP_NET_WM_STATE_SHADED,
 +    OBT_PROP_NET_WM_STATE_SKIP_TASKBAR,
 +    OBT_PROP_NET_WM_STATE_SKIP_PAGER,
 +    OBT_PROP_NET_WM_STATE_HIDDEN,
 +    OBT_PROP_NET_WM_STATE_FULLSCREEN,
 +    OBT_PROP_NET_WM_STATE_ABOVE,
 +    OBT_PROP_NET_WM_STATE_BELOW,
 +    OBT_PROP_NET_WM_STATE_DEMANDS_ATTENTION,
 +
 +    /* KDE atoms */
 +
 +    OBT_PROP_KDE_WM_CHANGE_STATE,
 +    OBT_PROP_KDE_NET_WM_FRAME_STRUT,
 +    OBT_PROP_KDE_NET_WM_WINDOW_TYPE_OVERRIDE,
 +
 +/*
 +    OBT_PROP_ROOTPMAPID,
 +    OBT_PROP_ESETROOTID,
 +*/
 +
 +    /* Openbox specific atoms */
 +
 +    OBT_PROP_OB_WM_ACTION_UNDECORATE,
 +    OBT_PROP_OB_WM_STATE_UNDECORATED,
 +    OBT_PROP_OPENBOX_PID, /* this is depreecated in favour of ob_control */
 +    OBT_PROP_OB_THEME,
++    OBT_PROP_OB_CONFIG_FILE,
 +    OBT_PROP_OB_CONTROL,
 +
 +    OBT_PROP_NUM_ATOMS
 +} ObtPropAtom;
 +
 +Atom obt_prop_atom(ObtPropAtom a);
 +
 +gboolean obt_prop_get32(Window win, Atom prop, Atom type, guint32 *ret);
 +gboolean obt_prop_get_array32(Window win, Atom prop, Atom type, guint32 **ret,
 +                              guint *nret);
 +gboolean obt_prop_get_string_locale(Window win, Atom prop, gchar **ret);
 +gboolean obt_prop_get_string_utf8(Window win, Atom prop, gchar **ret);
 +gboolean obt_prop_get_strings_locale(Window win, Atom prop, gchar ***ret);
 +gboolean obt_prop_get_strings_utf8(Window win, Atom prop, gchar ***ret);
 +
 +void obt_prop_set32(Window win, Atom prop, Atom type, gulong val);
 +void obt_prop_set_array32(Window win, Atom prop, Atom type, gulong *val,
 +                          guint num);
 +void obt_prop_set_string_locale(Window win, Atom prop, const gchar *val);
 +void obt_prop_set_string_utf8(Window win, Atom prop, const gchar *val);
 +void obt_prop_set_strings_locale(Window win, Atom prop, const gchar **strs);
 +void obt_prop_set_strings_utf8(Window win, Atom prop, const gchar **strs);
 +
 +void obt_prop_erase(Window win, Atom prop);
 +
 +void obt_prop_message(gint screen, Window about, Atom messagetype,
 +                      glong data0, glong data1, glong data2, glong data3,
 +                      glong data4, glong mask);
 +void obt_prop_message_to(Window to, Window about, Atom messagetype,
 +                         glong data0, glong data1, glong data2, glong data3,
 +                         glong data4, glong mask);
 +
 +#define OBT_PROP_ATOM(prop) obt_prop_atom(OBT_PROP_##prop)
 +
 +#define OBT_PROP_GET32(win, prop, type, ret) \
 +    (obt_prop_get32(win, OBT_PROP_ATOM(prop), OBT_PROP_ATOM(type), ret))
 +#define OBT_PROP_GETA32(win, prop, type, ret, nret) \
 +    (obt_prop_get_array32(win, OBT_PROP_ATOM(prop), OBT_PROP_ATOM(type), \
 +                          ret, nret))
 +#define OBT_PROP_GETS(win, prop, type, ret) \
 +    (obt_prop_get_string_##type(win, OBT_PROP_ATOM(prop), ret))
 +#define OBT_PROP_GETSS(win, prop, type, ret) \
 +    (obt_prop_get_strings_##type(win, OBT_PROP_ATOM(prop), ret))
 +
 +#define OBT_PROP_SET32(win, prop, type, val) \
 +    (obt_prop_set32(win, OBT_PROP_ATOM(prop), OBT_PROP_ATOM(type), val))
 +#define OBT_PROP_SETA32(win, prop, type, val, num) \
 +    (obt_prop_set_array32(win, OBT_PROP_ATOM(prop), OBT_PROP_ATOM(type), \
 +                          val, num))
 +#define OBT_PROP_SETS(win, prop, type, val) \
 +    (obt_prop_set_string_##type(win, OBT_PROP_ATOM(prop), val))
 +#define OBT_PROP_SETSS(win, prop, type, strs) \
 +    (obt_prop_set_strings_##type(win, OBT_PROP_ATOM(prop), strs))
 +
 +#define OBT_PROP_ERASE(win, prop) (obt_prop_erase(win, OBT_PROP_ATOM(prop)))
 +
 +#define OBT_PROP_MSG(screen, about, msgtype, data0, data1, data2, data3, \
 +                     data4) \
 +    (obt_prop_message(screen, about, OBT_PROP_ATOM(msgtype), \
 +                      data0, data1, data2, data3, data4, \
 +                      SubstructureNotifyMask | SubstructureRedirectMask))
 +
 +#define OBT_PROP_MSG_TO(to, about, msgtype, data0, data1, data2, data3, \
 +                        data4, mask) \
 +    (obt_prop_message_to(to, about, OBT_PROP_ATOM(msgtype), \
 +                         data0, data1, data2, data3, data4, mask))
 +
 +G_END_DECLS
 +
 +#endif /* __obt_prop_h */
diff --combined openbox/actions.c
@@@ -23,6 -23,7 +23,7 @@@
  #include "event.h"
  #include "config.h"
  #include "client.h"
+ #include "openbox.h"
  #include "debug.h"
  
  #include "actions/all.h"
@@@ -35,6 -36,7 +36,7 @@@ static ObActionsAct* actions_build_act_
  
  static ObActionsAct *interactive_act = NULL;
  static guint         interactive_initial_state = 0;
+ static gboolean      replay_pointer = FALSE;
  
  struct _ObActionsDefinition {
      guint ref;
@@@ -158,21 -160,23 +160,21 @@@ ObActionsAct* actions_parse_string(cons
  
      if ((act = actions_build_act_from_string(name)))
          if (act->def->setup)
 -            act->options = act->def->setup(NULL, NULL, NULL);
 +            act->options = act->def->setup(NULL);
  
      return act;
  }
  
 -ObActionsAct* actions_parse(ObParseInst *i,
 -                            xmlDocPtr doc,
 -                            xmlNodePtr node)
 +ObActionsAct* actions_parse(xmlNodePtr node)
  {
      gchar *name;
      ObActionsAct *act = NULL;
  
 -    if (parse_attr_string("name", node, &name)) {
 +    if (obt_parse_attr_string(node, "name", &name)) {
          if ((act = actions_build_act_from_string(name)))
              /* there is more stuff to parse here */
              if (act->def->setup)
 -                act->options = act->def->setup(i, doc, node->xmlChildrenNode);
 +                act->options = act->def->setup(node->children);
  
          g_free(name);
      }
@@@ -220,6 -224,16 +222,16 @@@ static void actions_setup_data(ObAction
      data->client = client;
  }
  
+ void actions_set_need_pointer_replay_before_move(gboolean replay)
+ {
+     replay_pointer = replay;
+ }
+ gboolean actions_get_need_pointer_replay_before_move()
+ {
+     return replay_pointer;
+ }
  void actions_run_acts(GSList *acts,
                        ObUserAction uact,
                        guint state,
@@@ -332,8 -346,14 +344,14 @@@ gboolean actions_interactive_input_even
  void actions_client_move(ObActionsData *data, gboolean start)
  {
      static gulong ignore_start = 0;
-     if (start)
+     if (start) {
          ignore_start = event_start_ignore_all_enters();
 -            XAllowEvents(ob_display, ReplayPointer, event_curtime);
+         if (replay_pointer) {
+             /* replay the pointer event before any windows move */
++            XAllowEvents(obt_display, ReplayPointer, event_curtime);
+             replay_pointer = FALSE;
+         }
+     }
      else if (config_focus_follow &&
               data->context != OB_FRAME_CONTEXT_CLIENT)
      {
diff --combined openbox/actions.h
@@@ -18,8 -18,7 +18,8 @@@
  
  #include "misc.h"
  #include "frame.h"
 -#include "parser/parse.h"
 +#include "obt/parse.h"
 +
  #include <glib.h>
  #include <X11/Xlib.h>
  
@@@ -31,7 -30,8 +31,7 @@@ typedef struct _ObActionsGlobalData   O
  typedef struct _ObActionsClientData   ObActionsClientData;
  typedef struct _ObActionsSelectorData ObActionsSelectorData;
  
 -typedef gpointer (*ObActionsDataSetupFunc)(ObParseInst *i,
 -                                           xmlDocPtr doc, xmlNodePtr node);
 +typedef gpointer (*ObActionsDataSetupFunc)(xmlNodePtr node);
  typedef void     (*ObActionsDataFreeFunc)(gpointer options);
  typedef gboolean (*ObActionsRunFunc)(ObActionsData *data,
                                       gpointer options);
@@@ -64,7 -64,9 +64,7 @@@ gboolean actions_register(const gchar *
                            ObActionsInteractiveInputFunc i_input,
                            ObActionsInteractiveCancelFunc i_cancel);
  
 -ObActionsAct* actions_parse(ObParseInst *i,
 -                            xmlDocPtr doc,
 -                            xmlNodePtr node);
 +ObActionsAct* actions_parse(xmlNodePtr node);
  ObActionsAct* actions_parse_string(const gchar *name);
  
  gboolean actions_act_is_interactive(ObActionsAct *act);
  void actions_act_ref(ObActionsAct *act);
  void actions_act_unref(ObActionsAct *act);
  
- /*! Pass in a GSList of ObActionsAct's to be run.
-   @return TRUE if an action is in interactive state, FALSE is none are
+ /*! When this is true, an XAllowEvents with ReplayPointer will be called
+   if an action is going to maybe try moving windows around on screen (or
+   map/unmap windows)
  */
+ void actions_set_need_pointer_replay_before_move(gboolean replay);
+ /*! Returns if a ReplayPointer is still needed.  If it was called while running
+   actions then this will be false */
+ gboolean actions_get_need_pointer_replay_before_move();
+ /*! Pass in a GSList of ObActionsAct's to be run. */
  void actions_run_acts(GSList *acts,
                        ObUserAction uact,
                        guint state,
@@@ -26,8 -26,10 +26,8 @@@ typedef struct 
      gboolean follow;
  } Options;
  
 -static gpointer setup_go_func(ObParseInst *i, xmlDocPtr doc,
 -                                  xmlNodePtr node);
 -static gpointer setup_send_func(ObParseInst *i, xmlDocPtr doc,
 -                                xmlNodePtr node);
 +static gpointer setup_go_func(xmlNodePtr node);
 +static gpointer setup_send_func(xmlNodePtr node);
  static gboolean run_func(ObActionsData *data, gpointer options);
  
  void action_desktop_startup(void)
@@@ -38,7 -40,8 +38,7 @@@
                       NULL, NULL);
  }
  
 -static gpointer setup_go_func(ObParseInst *i, xmlDocPtr doc,
 -                                  xmlNodePtr node)
 +static gpointer setup_go_func(xmlNodePtr node)
  {
      xmlNodePtr n;
      Options *o;
@@@ -50,8 -53,8 +50,8 @@@
      /* wrap by default - it's handy! */
      o->rel.wrap = TRUE;
  
 -    if ((n = parse_find_node("to", node))) {
 -        gchar *s = parse_string(doc, n);
 +    if ((n = obt_parse_find_node(node, "to"))) {
 +        gchar *s = obt_parse_node_string(n);
          if (!g_ascii_strcasecmp(s, "last"))
              o->type = LAST;
          else if (!g_ascii_strcasecmp(s, "next")) {
          }
          else {
              o->type = ABSOLUTE;
 -            o->abs.desktop = parse_int(doc, n) - 1;
 +            o->abs.desktop = obt_parse_node_int(n) - 1;
          }
          g_free(s);
      }
  
 -    if ((n = parse_find_node("wrap", node)))
 -        o->rel.wrap = parse_bool(doc, n);
 +    if ((n = obt_parse_find_node(node, "wrap")))
 +        o->rel.wrap = obt_parse_node_bool(n);
  
      return o;
  }
  
 -static gpointer setup_send_func(ObParseInst *i, xmlDocPtr doc,
 -                                xmlNodePtr node)
 +static gpointer setup_send_func(xmlNodePtr node)
  {
      xmlNodePtr n;
      Options *o;
  
 -    o = setup_go_func(i, doc, node);
 +    o = setup_go_func(node);
      o->send = TRUE;
      o->follow = TRUE;
  
 -    if ((n = parse_find_node("follow", node)))
 -        o->follow = parse_bool(doc, n);
 +    if ((n = obt_parse_find_node(node, "follow")))
 +        o->follow = obt_parse_node_bool(n);
  
      return o;
  }
@@@ -136,12 -140,14 +136,14 @@@ static gboolean run_func(ObActionsData 
      if (d < screen_num_desktops && d != screen_desktop) {
          gboolean go = TRUE;
  
+         actions_client_move(data, TRUE);
          if (o->send && data->client && client_normal(data->client)) {
              client_set_desktop(data->client, d, o->follow, FALSE);
              go = o->follow;
          }
  
          if (go) screen_set_desktop(d, TRUE);
+         actions_client_move(data, FALSE);
      }
      return FALSE;
  }
diff --combined openbox/client.c
  #include "debug.h"
  #include "startupnotify.h"
  #include "dock.h"
 -#include "xerror.h"
  #include "screen.h"
  #include "moveresize.h"
  #include "ping.h"
  #include "place.h"
 -#include "prop.h"
 -#include "extensions.h"
  #include "frame.h"
  #include "session.h"
  #include "event.h"
@@@ -39,8 -42,6 +39,8 @@@
  #include "mouse.h"
  #include "render/render.h"
  #include "gettext.h"
 +#include "obt/display.h"
 +#include "obt/prop.h"
  
  #ifdef HAVE_UNISTD_H
  #  include <unistd.h>
@@@ -165,8 -166,8 +165,8 @@@ void client_set_list(void
      } else
          windows = NULL;
  
 -    PROP_SETA32(RootWindow(ob_display, ob_screen),
 -                net_client_list, window, (gulong*)windows, size);
 +    OBT_PROP_SETA32(obt_root(ob_screen), NET_CLIENT_LIST, WINDOW,
 +                    (gulong*)windows, size);
  
      if (windows)
          g_free(windows);
      stacking_set_list();
  }
  
 -void client_manage_all(void)
 -{
 -    guint i, j, nchild;
 -    Window w, *children;
 -    XWMHints *wmhints;
 -    XWindowAttributes attrib;
 -
 -    XQueryTree(ob_display, RootWindow(ob_display, ob_screen),
 -               &w, &w, &children, &nchild);
 -
 -    /* remove all icon windows from the list */
 -    for (i = 0; i < nchild; i++) {
 -        if (children[i] == None) continue;
 -        wmhints = XGetWMHints(ob_display, children[i]);
 -        if (wmhints) {
 -            if ((wmhints->flags & IconWindowHint) &&
 -                (wmhints->icon_window != children[i]))
 -                for (j = 0; j < nchild; j++)
 -                    if (children[j] == wmhints->icon_window) {
 -                        children[j] = None;
 -                        break;
 -                    }
 -            XFree(wmhints);
 -        }
 -    }
 -
 -    /* manage windows in reverse order from how they were originally mapped.
 -       this is an attempt to manage children windows before their parents, so
 -       that when the parent is mapped, it can find the child */
 -    for (i = 0; i < nchild; ++i) {
 -        if (children[i] == None)
 -            continue;
 -        if (XGetWindowAttributes(ob_display, children[i], &attrib)) {
 -            if (attrib.override_redirect) continue;
 -
 -            if (attrib.map_state != IsUnmapped)
 -                client_manage(children[i]);
 -        }
 -    }
 -    XFree(children);
 -}
 -
  void client_manage(Window window)
  {
      ObClient *self;
 -    XEvent e;
 -    XWindowAttributes attrib;
      XSetWindowAttributes attrib_set;
 -    XWMHints *wmhint;
      gboolean activate = FALSE;
      ObAppSettings *settings;
      gboolean transient = FALSE;
      Rect place, *monitor;
      Time launch_time, map_time;
  
 -    grab_server(TRUE);
 -
 -    /* check if it has already been unmapped by the time we started
 -       mapping. the grab does a sync so we don't have to here */
 -    if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
 -        XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e))
 -    {
 -        XPutBackEvent(ob_display, &e);
 -
 -        ob_debug("Trying to manage unmapped window. Aborting that.\n");
 -        grab_server(FALSE);
 -        return; /* don't manage it */
 -    }
 -
 -    /* make sure it isn't an override-redirect window */
 -    if (!XGetWindowAttributes(ob_display, window, &attrib) ||
 -        attrib.override_redirect)
 -    {
 -        grab_server(FALSE);
 -        return; /* don't manage it */
 -    }
 -
 -    /* is the window a docking app */
 -    if ((wmhint = XGetWMHints(ob_display, window))) {
 -        if ((wmhint->flags & StateHint) &&
 -            wmhint->initial_state == WithdrawnState)
 -        {
 -            dock_add(window, wmhint);
 -            grab_server(FALSE);
 -            XFree(wmhint);
 -            return;
 -        }
 -        XFree(wmhint);
 -    }
 -
 -    ob_debug("Managing window: 0x%lx\n", window);
 +    ob_debug("Managing window: 0x%lx", window);
  
      map_time = event_get_server_time();
  
      /* choose the events we want to receive on the CLIENT window */
      attrib_set.event_mask = CLIENT_EVENTMASK;
      attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
 -    XChangeWindowAttributes(ob_display, window,
 +    XChangeWindowAttributes(obt_display, window,
                              CWEventMask|CWDontPropagate, &attrib_set);
  
      /* create the ObClient struct, and populate it from the hints on the
         window */
      self = g_new0(ObClient, 1);
 -    self->obwin.type = Window_Client;
 +    self->obwin.type = OB_WINDOW_CLASS_CLIENT;
      self->window = window;
  
      /* non-zero defaults */
      /* get all the stuff off the window */
      client_get_all(self, TRUE);
  
 -    ob_debug("Window type: %d\n", self->type);
 -    ob_debug("Window group: 0x%x\n", self->group?self->group->leader:0);
 +    ob_debug("Window type: %d", self->type);
 +    ob_debug("Window group: 0x%x", self->group?self->group->leader:0);
  
      /* now we have all of the window's information so we can set this up.
         do this before creating the frame, so it can tell that we are still
  
      /* specify that if we exit, the window should not be destroyed and
         should be reparented back to root automatically */
 -    XChangeSaveSet(ob_display, window, SetModeInsert);
 +    XChangeSaveSet(obt_display, window, SetModeInsert);
  
      /* create the decoration frame for the client window */
      self->frame = frame_new(self);
      }
  
      /* remove the client's border */
 -    XSetWindowBorderWidth(ob_display, self->window, 0);
 +    XSetWindowBorderWidth(obt_display, self->window, 0);
  
      /* adjust the frame to the client's size before showing or placing
         the window */
  
      /* figure out placement for the window if the window is new */
      if (ob_state() == OB_STATE_RUNNING) {
 -        ob_debug("Positioned: %s @ %d %d\n",
 +        ob_debug("Positioned: %s @ %d %d",
                   (!self->positioned ? "no" :
                    (self->positioned == PPosition ? "program specified" :
                     (self->positioned == USPosition ? "user specified" :
                       "program + user specified" :
                       "BADNESS !?")))), place.x, place.y);
  
 -        ob_debug("Sized: %s @ %d %d\n",
 +        ob_debug("Sized: %s @ %d %d",
                   (!self->sized ? "no" :
                    (self->sized == PSize ? "program specified" :
                     (self->sized == USSize ? "user specified" :
          place.width = MIN(place.width, a->width);
          place.height = MIN(place.height, a->height);
  
 -        ob_debug("setting window size to %dx%d\n", place.width, place.height);
 +        ob_debug("setting window size to %dx%d", place.width, place.height);
  
          /* get the size of the client back */
          place.width -= self->frame->size.left + self->frame->size.right;
      }
  
      ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
 -             "some restrictions may apply\n",
 +             "some restrictions may apply",
               self->window, place.x, place.y, place.width, place.height);
      if (self->session)
          ob_debug("  but session requested %d, %d  %d x %d instead, "
 -                 "overriding\n",
 +                 "overriding",
                   self->session->x, self->session->y,
                   self->session->w, self->session->h);
  
      g_free(monitor);
      monitor = NULL;
  
 -    ob_debug_type(OB_DEBUG_FOCUS, "Going to try activate new window? %s\n",
 +    ob_debug_type(OB_DEBUG_FOCUS, "Going to try activate new window? %s",
                    activate ? "yes" : "no");
      if (activate) {
          gboolean raise = FALSE;
          /* This is focus stealing prevention */
          ob_debug_type(OB_DEBUG_FOCUS,
                        "Want to focus new window 0x%x at time %u "
 -                      "launched at %u (last user interaction time %u)\n",
 +                      "launched at %u (last user interaction time %u)",
                        self->window, map_time, launch_time,
                        event_last_user_time);
  
              ob_debug_type(OB_DEBUG_FOCUS,
                            "Not focusing the window because the user is inside "
                            "an Openbox menu or is move/resizing a window and "
 -                          "we don't want to interrupt them\n");
 +                          "we don't want to interrupt them");
          }
  
          /* if it's on another desktop */
              raise = TRUE;
              ob_debug_type(OB_DEBUG_FOCUS,
                            "Not focusing the window because its on another "
 -                          "desktop\n");
 +                          "desktop");
          }
          /* If something is focused, and it's not our relative... */
          else if (focus_client && client_search_focus_tree_full(self) == NULL &&
                  activate = FALSE;
                  ob_debug_type(OB_DEBUG_FOCUS,
                                "Not focusing the window because the user is "
 -                              "working in another window\n");
 +                              "working in another window");
              }
              /* If its a transient (and its parents aren't focused) */
              else if (client_has_parent(self)) {
                  activate = FALSE;
                  ob_debug_type(OB_DEBUG_FOCUS,
                                "Not focusing the window because it is a "
 -                              "transient, and its relatives aren't focused\n");
 +                              "transient, and its relatives aren't focused");
              }
              /* Don't steal focus from globally active clients.
                 I stole this idea from KWin. It seems nice.
                  activate = FALSE;
                  ob_debug_type(OB_DEBUG_FOCUS,
                                "Not focusing the window because a globally "
 -                              "active client has focus\n");
 +                              "active client has focus");
              }
              /* Don't move focus if it's not going to go to this window
                 anyway */
                  raise = TRUE;
                  ob_debug_type(OB_DEBUG_FOCUS,
                                "Not focusing the window because another window "
 -                              "would get the focus anyway\n");
 +                              "would get the focus anyway");
              }
              else if (!(self->desktop == screen_desktop ||
                         self->desktop == DESKTOP_ALL))
          if (!activate) {
              ob_debug_type(OB_DEBUG_FOCUS,
                            "Focus stealing prevention activated for %s at "
 -                          "time %u (last user interactioon time %u)\n",
 +                          "time %u (last user interactioon time %u)",
                            self->title, map_time, event_last_user_time);
              /* if the client isn't focused, then hilite it so the user
                 knows it is there */
  
      /* add to client list/map */
      client_list = g_list_append(client_list, self);
 -    g_hash_table_insert(window_map, &self->window, self);
 +    window_add(&self->window, CLIENT_AS_WINDOW(self));
  
      /* this has to happen after we're in the client_list */
      if (STRUT_EXISTS(self->strut))
      /* free the ObAppSettings shallow copy */
      g_free(settings);
  
 -    ob_debug("Managed window 0x%lx plate 0x%x (%s)\n",
 +    ob_debug("Managed window 0x%lx plate 0x%x (%s)",
               window, self->frame->window, self->class);
 -
 -    return;
  }
  
  
@@@ -553,7 -636,7 +553,7 @@@ ObClient *client_fake_manage(Window win
      ObClient *self;
      ObAppSettings *settings;
  
 -    ob_debug("Pretend-managing window: %lx\n", window);
 +    ob_debug("Pretend-managing window: %lx", window);
  
      /* do this minimal stuff to figure out the client's decorations */
  
      self->frame = frame_new(self);
      frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
  
 -    ob_debug("gave extents left %d right %d top %d bottom %d\n",
 +    ob_debug("gave extents left %d right %d top %d bottom %d",
               self->frame->size.left, self->frame->size.right,
               self->frame->size.top, self->frame->size.bottom);
  
@@@ -593,7 -676,7 +593,7 @@@ void client_unmanage(ObClient *self
      GSList *it;
      gulong ignore_start;
  
 -    ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)\n",
 +    ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)",
               self->window, self->frame->window,
               self->class, self->title ? self->title : "");
  
  
      /* we dont want events no more. do this before hiding the frame so we
         don't generate more events */
 -    XSelectInput(ob_display, self->window, NoEventMask);
 +    XSelectInput(obt_display, self->window, NoEventMask);
  
      /* ignore enter events from the unmap so it doesnt mess with the focus */
      if (!config_focus_under_mouse)
  
      frame_hide(self->frame);
      /* flush to send the hide to the server quickly */
 -    XFlush(ob_display);
 +    XFlush(obt_display);
  
      if (!config_focus_under_mouse)
          event_end_ignore_all_enters(ignore_start);
      mouse_grab_for_client(self, FALSE);
  
      /* remove the window from our save set */
 -    XChangeSaveSet(ob_display, self->window, SetModeDelete);
 +    XChangeSaveSet(obt_display, self->window, SetModeDelete);
  
      /* update the focus lists */
      focus_order_remove(self);
  
      client_list = g_list_remove(client_list, self);
      stacking_remove(self);
 -    g_hash_table_remove(window_map, &self->window);
 +    window_remove(self->window);
  
      /* once the client is out of the list, update the struts to remove its
         influence */
          self->decorations = 0; /* unmanaged windows have no decor */
  
          /* give the client its border back */
 -        XSetWindowBorderWidth(ob_display, self->window, self->border_width);
 +        XSetWindowBorderWidth(obt_display, self->window, self->border_width);
  
          client_move_resize(self, a.x, a.y, a.width, a.height);
      }
      if (ob_state() != OB_STATE_EXITING) {
          /* these values should not be persisted across a window
             unmapping/mapping */
 -        PROP_ERASE(self->window, net_wm_desktop);
 -        PROP_ERASE(self->window, net_wm_state);
 -        PROP_ERASE(self->window, wm_state);
 +        OBT_PROP_ERASE(self->window, NET_WM_DESKTOP);
 +        OBT_PROP_ERASE(self->window, NET_WM_STATE);
 +        OBT_PROP_ERASE(self->window, WM_STATE);
      } else {
          /* if we're left in an unmapped state, the client wont be mapped.
             this is bad, since we will no longer be managing the window on
             restart */
 -        XMapWindow(ob_display, self->window);
 +        XMapWindow(obt_display, self->window);
      }
  
      /* these should not be left on the window ever.  other window managers
         don't necessarily use them and it will mess them up (like compiz) */
 -    PROP_ERASE(self->window, net_wm_visible_name);
 -    PROP_ERASE(self->window, net_wm_visible_icon_name);
 +    OBT_PROP_ERASE(self->window, NET_WM_VISIBLE_NAME);
 +    OBT_PROP_ERASE(self->window, NET_WM_VISIBLE_ICON_NAME);
  
      /* update the list hints */
      client_set_list();
  
 -    ob_debug("Unmanaged window 0x%lx\n", self->window);
 +    ob_debug("Unmanaged window 0x%lx", self->window);
  
      /* free all data allocated in the client struct */
      g_slist_free(self->transients);
@@@ -770,7 -853,7 +770,7 @@@ static ObAppSettings *client_get_settin
              match = FALSE;
  
          if (match) {
 -            ob_debug("Window matching: %s\n", app->name);
 +            ob_debug("Window matching: %s", app->name);
  
              /* copy the settings to our struct, overriding the existing
                 settings if they are not defaults */
@@@ -825,17 -908,17 +825,17 @@@ static void client_restore_session_stat
      GList *it;
  
      ob_debug_type(OB_DEBUG_SM,
 -                  "Restore session for client %s\n", self->title);
 +                  "Restore session for client %s", self->title);
  
      if (!(it = session_state_find(self))) {
          ob_debug_type(OB_DEBUG_SM,
 -                      "Session data not found for client %s\n", self->title);
 +                      "Session data not found for client %s", self->title);
          return;
      }
  
      self->session = it->data;
  
 -    ob_debug_type(OB_DEBUG_SM, "Session data loaded for client %s\n",
 +    ob_debug_type(OB_DEBUG_SM, "Session data loaded for client %s",
                    self->title);
  
      RECT_SET_POINT(self->area, self->session->x, self->session->y);
          self->area.width = self->session->w;
      if (self->session->h > 0)
          self->area.height = self->session->h;
 -    XResizeWindow(ob_display, self->window,
 +    XResizeWindow(obt_display, self->window,
                    self->area.width, self->area.height);
  
      self->desktop = (self->session->desktop == DESKTOP_ALL ?
                       self->session->desktop :
                       MIN(screen_num_desktops - 1, self->session->desktop));
 -    PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
 +    OBT_PROP_SET32(self->window, NET_WM_DESKTOP, CARDINAL, self->desktop);
  
      self->shaded = self->session->shaded;
      self->iconic = self->session->iconic;
@@@ -1078,11 -1161,10 +1078,11 @@@ static void client_get_all(ObClient *se
  
  static void client_get_startup_id(ObClient *self)
  {
 -    if (!(PROP_GETS(self->window, net_startup_id, utf8, &self->startup_id)))
 +    if (!(OBT_PROP_GETS(self->window, NET_STARTUP_ID, utf8,
 +                        &self->startup_id)))
          if (self->group)
 -            PROP_GETS(self->group->leader,
 -                      net_startup_id, utf8, &self->startup_id);
 +            OBT_PROP_GETS(self->group->leader,
 +                          NET_STARTUP_ID, utf8, &self->startup_id);
  }
  
  static void client_get_area(ObClient *self)
      XWindowAttributes wattrib;
      Status ret;
  
 -    ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
 +    ret = XGetWindowAttributes(obt_display, self->window, &wattrib);
      g_assert(ret != BadWindow);
  
      RECT_SET(self->area, wattrib.x, wattrib.y, wattrib.width, wattrib.height);
      POINT_SET(self->root_pos, wattrib.x, wattrib.y);
      self->border_width = wattrib.border_width;
  
 -    ob_debug("client area: %d %d  %d %d  bw %d\n", wattrib.x, wattrib.y,
 +    ob_debug("client area: %d %d  %d %d  bw %d", wattrib.x, wattrib.y,
               wattrib.width, wattrib.height, wattrib.border_width);
  }
  
@@@ -1105,12 -1187,12 +1105,12 @@@ static void client_get_desktop(ObClien
  {
      guint32 d = screen_num_desktops; /* an always-invalid value */
  
 -    if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) {
 +    if (OBT_PROP_GET32(self->window, NET_WM_DESKTOP, CARDINAL, &d)) {
          if (d >= screen_num_desktops && d != DESKTOP_ALL)
              self->desktop = screen_num_desktops - 1;
          else
              self->desktop = d;
 -        ob_debug("client requested desktop 0x%x\n", self->desktop);
 +        ob_debug("client requested desktop 0x%x", self->desktop);
      } else {
          GSList *it;
          gboolean first = TRUE;
          if (all != screen_num_desktops) {
              self->desktop = all;
  
 -            ob_debug("client desktop set from parents: 0x%x\n",
 +            ob_debug("client desktop set from parents: 0x%x",
                       self->desktop);
          }
          /* try get from the startup-notification protocol */
              if (self->desktop >= screen_num_desktops &&
                  self->desktop != DESKTOP_ALL)
                  self->desktop = screen_num_desktops - 1;
 -            ob_debug("client desktop set from startup-notification: 0x%x\n",
 +            ob_debug("client desktop set from startup-notification: 0x%x",
                       self->desktop);
          }
          /* defaults to the current desktop */
          else {
              self->desktop = screen_desktop;
 -            ob_debug("client desktop set to the current desktop: %d\n",
 +            ob_debug("client desktop set to the current desktop: %d",
                       self->desktop);
          }
      }
@@@ -1158,32 -1240,32 +1158,32 @@@ static void client_get_state(ObClient *
      guint32 *state;
      guint num;
  
 -    if (PROP_GETA32(self->window, net_wm_state, atom, &state, &num)) {
 +    if (OBT_PROP_GETA32(self->window, NET_WM_STATE, ATOM, &state, &num)) {
          gulong i;
          for (i = 0; i < num; ++i) {
 -            if (state[i] == prop_atoms.net_wm_state_modal)
 +            if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_MODAL))
                  self->modal = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_shaded)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_SHADED))
                  self->shaded = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_hidden)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN))
                  self->iconic = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_skip_taskbar)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR))
                  self->skip_taskbar = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_skip_pager)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER))
                  self->skip_pager = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_fullscreen)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN))
                  self->fullscreen = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_maximized_vert)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT))
                  self->max_vert = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_maximized_horz)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ))
                  self->max_horz = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_above)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_ABOVE))
                  self->above = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_below)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_BELOW))
                  self->below = TRUE;
 -            else if (state[i] == prop_atoms.net_wm_state_demands_attention)
 +            else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION))
                  self->demands_attention = TRUE;
 -            else if (state[i] == prop_atoms.ob_wm_state_undecorated)
 +            else if (state[i] == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED))
                  self->undecorated = TRUE;
          }
  
@@@ -1195,14 -1277,14 +1195,14 @@@ static void client_get_shaped(ObClient 
  {
      self->shaped = FALSE;
  #ifdef   SHAPE
 -    if (extensions_shape) {
 +    if (obt_display_extension_shape) {
          gint foo;
          guint ufoo;
          gint s;
  
 -        XShapeSelectInput(ob_display, self->window, ShapeNotifyMask);
 +        XShapeSelectInput(obt_display, self->window, ShapeNotifyMask);
  
 -        XShapeQueryExtents(ob_display, self->window, &s, &foo,
 +        XShapeQueryExtents(obt_display, self->window, &s, &foo,
                             &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo,
                             &ufoo);
          self->shaped = (s != 0);
@@@ -1216,22 -1298,22 +1216,22 @@@ void client_update_transient_for(ObClie
      ObClient *target = NULL;
      gboolean trangroup = FALSE;
  
 -    if (XGetTransientForHint(ob_display, self->window, &t)) {
 +    if (XGetTransientForHint(obt_display, self->window, &t)) {
          if (t != self->window) { /* cant be transient to itself! */
 -            target = g_hash_table_lookup(window_map, &t);
 +            ObWindow *tw = window_find(t);
              /* if this happens then we need to check for it*/
 -            g_assert(target != self);
 -            if (target && !WINDOW_IS_CLIENT(target)) {
 -                /* this can happen when a dialog is a child of
 -                   a dockapp, for example */
 -                target = NULL;
 +            g_assert(tw != CLIENT_AS_WINDOW(self));
 +            if (tw && WINDOW_IS_CLIENT(tw)) {
 +                /* watch out for windows with a parent that is something
 +                   different, like a dockapp for example */
 +                target = WINDOW_AS_CLIENT(tw);
              }
          }
  
          /* Setting the transient_for to Root is actually illegal, however
             applications from time have done this to specify transient for
             their group */
 -        if (!target && self->group && t == RootWindow(ob_display, ob_screen))
 +        if (!target && self->group && t == obt_root(ob_screen))
              trangroup = TRUE;
      } else if (self->group && self->transient)
          trangroup = TRUE;
@@@ -1367,8 -1449,8 +1367,8 @@@ static void client_get_mwm_hints(ObClie
  
      self->mwmhints.flags = 0; /* default to none */
  
 -    if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
 -                    &hints, &num)) {
 +    if (OBT_PROP_GETA32(self->window, MOTIF_WM_HINTS, MOTIF_WM_HINTS,
 +                        &hints, &num)) {
          if (num >= OB_MWM_ELEMENTS) {
              self->mwmhints.flags = hints[0];
              self->mwmhints.functions = hints[1];
@@@ -1387,27 -1469,26 +1387,27 @@@ void client_get_type_and_transientness(
      self->type = -1;
      self->transient = FALSE;
  
 -    if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
 +    if (OBT_PROP_GETA32(self->window, NET_WM_WINDOW_TYPE, ATOM, &val, &num)) {
          /* use the first value that we know about in the array */
          for (i = 0; i < num; ++i) {
 -            if (val[i] == prop_atoms.net_wm_window_type_desktop)
 +            if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP))
                  self->type = OB_CLIENT_TYPE_DESKTOP;
 -            else if (val[i] == prop_atoms.net_wm_window_type_dock)
 +            else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK))
                  self->type = OB_CLIENT_TYPE_DOCK;
 -            else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
 +            else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR))
                  self->type = OB_CLIENT_TYPE_TOOLBAR;
 -            else if (val[i] == prop_atoms.net_wm_window_type_menu)
 +            else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU))
                  self->type = OB_CLIENT_TYPE_MENU;
 -            else if (val[i] == prop_atoms.net_wm_window_type_utility)
 +            else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY))
                  self->type = OB_CLIENT_TYPE_UTILITY;
 -            else if (val[i] == prop_atoms.net_wm_window_type_splash)
 +            else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH))
                  self->type = OB_CLIENT_TYPE_SPLASH;
 -            else if (val[i] == prop_atoms.net_wm_window_type_dialog)
 +            else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG))
                  self->type = OB_CLIENT_TYPE_DIALOG;
 -            else if (val[i] == prop_atoms.net_wm_window_type_normal)
 +            else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL))
                  self->type = OB_CLIENT_TYPE_NORMAL;
 -            else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
 +            else if (val[i] == OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE))
 +            {
                  /* prevent this window from getting any decor or
                     functionality */
                  self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
          g_free(val);
      }
  
 -    if (XGetTransientForHint(ob_display, self->window, &t))
 +    if (XGetTransientForHint(obt_display, self->window, &t))
          self->transient = TRUE;
  
      if (self->type == (ObClientType) -1) {
  void client_update_protocols(ObClient *self)
  {
      guint32 *proto;
 -    guint num_return, i;
 +    guint num_ret, i;
  
      self->focus_notify = FALSE;
      self->delete_window = FALSE;
  
 -    if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
 -        for (i = 0; i < num_return; ++i) {
 -            if (proto[i] == prop_atoms.wm_delete_window)
 +    if (OBT_PROP_GETA32(self->window, WM_PROTOCOLS, ATOM, &proto, &num_ret)) {
 +        for (i = 0; i < num_ret; ++i) {
 +            if (proto[i] == OBT_PROP_ATOM(WM_DELETE_WINDOW))
                  /* this means we can request the window to close */
                  self->delete_window = TRUE;
 -            else if (proto[i] == prop_atoms.wm_take_focus)
 +            else if (proto[i] == OBT_PROP_ATOM(WM_TAKE_FOCUS))
                  /* if this protocol is requested, then the window will be
                     notified whenever we want it to receive focus */
                  self->focus_notify = TRUE;
 -            else if (proto[i] == prop_atoms.net_wm_ping)
 +            else if (proto[i] == OBT_PROP_ATOM(NET_WM_PING))
                  /* if this protocol is requested, then the window will allow
                     pings to determine if it is still alive */
                  self->ping = TRUE;
  #ifdef SYNC
 -            else if (proto[i] == prop_atoms.net_wm_sync_request)
 +            else if (proto[i] == OBT_PROP_ATOM(NET_WM_SYNC_REQUEST))
                  /* if this protocol is requested, then resizing the
                     window will be synchronized between the frame and the
                     client */
@@@ -1482,8 -1563,7 +1482,8 @@@ void client_update_sync_request_counter
  {
      guint32 i;
  
 -    if (PROP_GET32(self->window, net_wm_sync_request_counter, cardinal, &i)) {
 +    if (OBT_PROP_GET32(self->window, NET_WM_SYNC_REQUEST_COUNTER, CARDINAL,&i))
 +    {
          self->sync_counter = i;
      } else
          self->sync_counter = None;
@@@ -1494,7 -1574,7 +1494,7 @@@ static void client_get_colormap(ObClien
  {
      XWindowAttributes wa;
  
 -    if (XGetWindowAttributes(ob_display, self->window, &wa))
 +    if (XGetWindowAttributes(obt_display, self->window, &wa))
          client_update_colormap(self, wa.colormap);
  }
  
@@@ -1502,7 -1582,7 +1502,7 @@@ void client_update_colormap(ObClient *s
  {
      if (colormap == self->colormap) return;
  
 -    ob_debug("Setting client %s colormap: 0x%x\n", self->title, colormap);
 +    ob_debug("Setting client %s colormap: 0x%x", self->title, colormap);
  
      if (client_focused(self)) {
          screen_install_colormap(self, FALSE); /* uninstall old one */
@@@ -1526,7 -1606,7 +1526,7 @@@ void client_update_normal_hints(ObClien
      SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
  
      /* get the hints from the window */
 -    if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
 +    if (XGetWMNormalHints(obt_display, self->window, &size, &ret)) {
          /* normal windows can't request placement! har har
          if (!client_normal(self))
          */
          if (size.flags & PResizeInc && size.width_inc && size.height_inc)
              SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
  
 -        ob_debug("Normal hints: min size (%d %d) max size (%d %d)\n   "
 -                 "size inc (%d %d) base size (%d %d)\n",
 +        ob_debug("Normal hints: min size (%d %d) max size (%d %d)",
                   self->min_size.width, self->min_size.height,
 -                 self->max_size.width, self->max_size.height,
 +                 self->max_size.width, self->max_size.height);
 +        ob_debug("size inc (%d %d) base size (%d %d)",
                   self->size_inc.width, self->size_inc.height,
                   self->base_size.width, self->base_size.height);
      }
      else
 -        ob_debug("Normal hints: not set\n");
 +        ob_debug("Normal hints: not set");
  }
  
  void client_setup_decor_and_functions(ObClient *self, gboolean reconfig)
@@@ -1738,38 -1818,38 +1738,38 @@@ static void client_change_allowed_actio
  
      /* desktop windows are kept on all desktops */
      if (self->type != OB_CLIENT_TYPE_DESKTOP)
 -        actions[num++] = prop_atoms.net_wm_action_change_desktop;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP);
  
      if (self->functions & OB_CLIENT_FUNC_SHADE)
 -        actions[num++] = prop_atoms.net_wm_action_shade;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE);
      if (self->functions & OB_CLIENT_FUNC_CLOSE)
 -        actions[num++] = prop_atoms.net_wm_action_close;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE);
      if (self->functions & OB_CLIENT_FUNC_MOVE)
 -        actions[num++] = prop_atoms.net_wm_action_move;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE);
      if (self->functions & OB_CLIENT_FUNC_ICONIFY)
 -        actions[num++] = prop_atoms.net_wm_action_minimize;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE);
      if (self->functions & OB_CLIENT_FUNC_RESIZE)
 -        actions[num++] = prop_atoms.net_wm_action_resize;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE);
      if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
 -        actions[num++] = prop_atoms.net_wm_action_fullscreen;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN);
      if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
 -        actions[num++] = prop_atoms.net_wm_action_maximize_horz;
 -        actions[num++] = prop_atoms.net_wm_action_maximize_vert;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ);
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT);
      }
      if (self->functions & OB_CLIENT_FUNC_ABOVE)
 -        actions[num++] = prop_atoms.net_wm_action_above;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE);
      if (self->functions & OB_CLIENT_FUNC_BELOW)
 -        actions[num++] = prop_atoms.net_wm_action_below;
 +        actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW);
      if (self->functions & OB_CLIENT_FUNC_UNDECORATE)
 -        actions[num++] = prop_atoms.ob_wm_action_undecorate;
 +        actions[num++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE);
  
 -    PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num);
 +    OBT_PROP_SETA32(self->window, NET_WM_ALLOWED_ACTIONS, ATOM, actions, num);
  
 -   /* make sure the window isn't breaking any rules now
 +    /* make sure the window isn't breaking any rules now
  
 -   don't check ICONIFY here.  just cuz a window can't iconify doesnt mean
 -   it can't be iconified with its parent
 -   */
 +       don't check ICONIFY here.  just cuz a window can't iconify doesnt mean
 +       it can't be iconified with its parent
 +    */
  
      if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
          if (self->frame) client_shade(self, FALSE);
@@@ -1793,7 -1873,7 +1793,7 @@@ void client_update_wmhints(ObClient *se
      /* assume a window takes input if it doesnt specify */
      self->can_focus = TRUE;
  
 -    if ((hints = XGetWMHints(ob_display, self->window)) != NULL) {
 +    if ((hints = XGetWMHints(obt_display, self->window)) != NULL) {
          gboolean ur;
  
          if (hints->flags & InputHint)
@@@ -1881,10 -1961,10 +1881,10 @@@ void client_update_title(ObClient *self
      g_free(self->title);
  
      /* try netwm */
 -    if (!PROP_GETS(self->window, net_wm_name, utf8, &data)) {
 +    if (!OBT_PROP_GETS(self->window, NET_WM_NAME, utf8, &data)) {
          /* try old x stuff */
 -        if (!(PROP_GETS(self->window, wm_name, locale, &data)
 -              || PROP_GETS(self->window, wm_name, utf8, &data))) {
 +        if (!(OBT_PROP_GETS(self->window, WM_NAME, locale, &data)
 +              || OBT_PROP_GETS(self->window, WM_NAME, utf8, &data))) {
              if (self->transient) {
      /*
      GNOME alert windows are not given titles:
          g_free(data);
      }
  
 -    PROP_SETS(self->window, net_wm_visible_name, visible);
 +    OBT_PROP_SETS(self->window, NET_WM_VISIBLE_NAME, utf8, visible);
      self->title = visible;
  
      if (self->frame)
      g_free(self->icon_title);
  
      /* try netwm */
 -    if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data))
 +    if (!OBT_PROP_GETS(self->window, NET_WM_ICON_NAME, utf8, &data))
          /* try old x stuff */
 -        if (!(PROP_GETS(self->window, wm_icon_name, locale, &data) ||
 -              PROP_GETS(self->window, wm_icon_name, utf8, &data)))
 +        if (!(OBT_PROP_GETS(self->window, WM_ICON_NAME, locale, &data) ||
 +              OBT_PROP_GETS(self->window, WM_ICON_NAME, utf8, &data)))
              data = g_strdup(self->title);
  
      if (self->client_machine) {
          g_free(data);
      }
  
 -    PROP_SETS(self->window, net_wm_visible_icon_name, visible);
 +    OBT_PROP_SETS(self->window, NET_WM_VISIBLE_ICON_NAME, utf8, visible);
      self->icon_title = visible;
  }
  
@@@ -1954,9 -2034,8 +1954,9 @@@ void client_update_strut(ObClient *self
      gboolean got = FALSE;
      StrutPartial strut;
  
 -    if (PROP_GETA32(self->window, net_wm_strut_partial, cardinal,
 -                    &data, &num)) {
 +    if (OBT_PROP_GETA32(self->window, NET_WM_STRUT_PARTIAL, CARDINAL,
 +                        &data, &num))
 +    {
          if (num == 12) {
              got = TRUE;
              STRUT_PARTIAL_SET(strut,
      }
  
      if (!got &&
 -        PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) {
 +        OBT_PROP_GETA32(self->window, NET_WM_STRUT, CARDINAL, &data, &num)) {
          if (num == 4) {
              Rect *a;
  
@@@ -2020,7 -2099,7 +2020,7 @@@ void client_update_icons(ObClient *self
          g_free(self->icons);
      self->nicons = 0;
  
 -    if (PROP_GETA32(self->window, net_wm_icon, cardinal, &data, &num)) {
 +    if (OBT_PROP_GETA32(self->window, NET_WM_ICON, CARDINAL, &data, &num)) {
          /* figure out how many valid icons are in here */
          i = 0;
          num_seen = num_small_seen = 0;
      } else {
          XWMHints *hints;
  
 -        if ((hints = XGetWMHints(ob_display, self->window))) {
 +        if ((hints = XGetWMHints(obt_display, self->window))) {
              if (hints->flags & IconPixmapHint) {
                  self->nicons = 1;
                  self->icons = g_new(ObClientIcon, self->nicons);
 -                xerror_set_ignore(TRUE);
 +                obt_display_ignore_errors(TRUE);
                  if (!RrPixmapToRGBA(ob_rr_inst,
                                      hints->icon_pixmap,
                                      (hints->flags & IconMaskHint ?
                      g_free(self->icons);
                      self->nicons = 0;
                  }
 -                xerror_set_ignore(FALSE);
 +                obt_display_ignore_errors(FALSE);
              }
              XFree(hints);
          }
                  (((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) +
                  (((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) +
                  (((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0);
 -        PROP_SETA32(self->window, net_wm_icon, cardinal, data, 48*48+2);
 +        OBT_PROP_SETA32(self->window, NET_WM_ICON, CARDINAL, data, 48*48+2);
          g_free(data);
      } else if (self->frame)
          /* don't draw the icon empty if we're just setting one now anyways,
@@@ -2148,8 -2227,7 +2148,8 @@@ void client_update_icon_geometry(ObClie
  
      RECT_SET(self->icon_geometry, 0, 0, 0, 0);
  
 -    if (PROP_GETA32(self->window, net_wm_icon_geometry, cardinal, &data, &num))
 +    if (OBT_PROP_GETA32(self->window, NET_WM_ICON_GEOMETRY, CARDINAL,
 +                        &data, &num))
      {
          if (num == 4)
              /* don't let them set it with an area < 0 */
@@@ -2166,23 -2244,23 +2166,23 @@@ static void client_get_session_ids(ObCl
      gchar *s;
      gchar **ss;
  
 -    if (!PROP_GET32(self->window, wm_client_leader, window, &leader))
 +    if (!OBT_PROP_GET32(self->window, WM_CLIENT_LEADER, WINDOW, &leader))
          leader = None;
  
      /* get the SM_CLIENT_ID */
      got = FALSE;
      if (leader)
 -        got = PROP_GETS(leader, sm_client_id, locale, &self->sm_client_id);
 +        got = OBT_PROP_GETS(leader, SM_CLIENT_ID, locale, &self->sm_client_id);
      if (!got)
 -        PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id);
 +        OBT_PROP_GETS(self->window, SM_CLIENT_ID, locale, &self->sm_client_id);
  
      /* get the WM_CLASS (name and class). make them "" if they are not
         provided */
      got = FALSE;
      if (leader)
 -        got = PROP_GETSS(leader, wm_class, locale, &ss);
 +        got = OBT_PROP_GETSS(leader, WM_CLASS, locale, &ss);
      if (!got)
 -        got = PROP_GETSS(self->window, wm_class, locale, &ss);
 +        got = OBT_PROP_GETSS(self->window, WM_CLASS, locale, &ss);
  
      if (got) {
          if (ss[0]) {
      /* get the WM_WINDOW_ROLE. make it "" if it is not provided */
      got = FALSE;
      if (leader)
 -        got = PROP_GETS(leader, wm_window_role, locale, &s);
 +        got = OBT_PROP_GETS(leader, WM_WINDOW_ROLE, locale, &s);
      if (!got)
 -        got = PROP_GETS(self->window, wm_window_role, locale, &s);
 +        got = OBT_PROP_GETS(self->window, WM_WINDOW_ROLE, locale, &s);
  
      if (got)
          self->role = s;
      got = FALSE;
  
      if (leader)
 -        got = PROP_GETSS(leader, wm_command, locale, &ss);
 +        got = OBT_PROP_GETSS(leader, WM_COMMAND, locale, &ss);
      if (!got)
 -        got = PROP_GETSS(self->window, wm_command, locale, &ss);
 +        got = OBT_PROP_GETSS(self->window, WM_COMMAND, locale, &ss);
  
      if (got) {
          /* merge/mash them all together */
      /* get the WM_CLIENT_MACHINE */
      got = FALSE;
      if (leader)
 -        got = PROP_GETS(leader, wm_client_machine, locale, &s);
 +        got = OBT_PROP_GETS(leader, WM_CLIENT_MACHINE, locale, &s);
      if (!got)
 -        got = PROP_GETS(self->window, wm_client_machine, locale, &s);
 +        got = OBT_PROP_GETS(self->window, WM_CLIENT_MACHINE, locale, &s);
  
      if (got) {
          gchar localhost[128];
  
          /* see if it has the PID set too (the PID requires that the
             WM_CLIENT_MACHINE be set) */
 -        if (PROP_GET32(self->window, net_wm_pid, cardinal, &pid))
 +        if (OBT_PROP_GET32(self->window, NET_WM_PID, CARDINAL, &pid))
              self->pid = pid;
      }
  }
@@@ -2274,12 -2352,12 +2274,12 @@@ static void client_change_wm_state(ObCl
          self->wmstate = NormalState;
  
      if (old != self->wmstate) {
 -        PROP_MSG(self->window, kde_wm_change_state,
 -                 self->wmstate, 1, 0, 0);
 +        OBT_PROP_MSG(ob_screen, self->window, KDE_WM_CHANGE_STATE,
 +                     self->wmstate, 1, 0, 0, 0);
  
          state[0] = self->wmstate;
          state[1] = None;
 -        PROP_SETA32(self->window, wm_state, wm_state, state, 2);
 +        OBT_PROP_SETA32(self->window, WM_STATE, WM_STATE, state, 2);
      }
  }
  
@@@ -2290,30 -2368,30 +2290,30 @@@ static void client_change_state(ObClien
  
      num = 0;
      if (self->modal)
 -        netstate[num++] = prop_atoms.net_wm_state_modal;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL);
      if (self->shaded)
 -        netstate[num++] = prop_atoms.net_wm_state_shaded;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED);
      if (self->iconic)
 -        netstate[num++] = prop_atoms.net_wm_state_hidden;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN);
      if (self->skip_taskbar)
 -        netstate[num++] = prop_atoms.net_wm_state_skip_taskbar;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR);
      if (self->skip_pager)
 -        netstate[num++] = prop_atoms.net_wm_state_skip_pager;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER);
      if (self->fullscreen)
 -        netstate[num++] = prop_atoms.net_wm_state_fullscreen;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN);
      if (self->max_vert)
 -        netstate[num++] = prop_atoms.net_wm_state_maximized_vert;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT);
      if (self->max_horz)
 -        netstate[num++] = prop_atoms.net_wm_state_maximized_horz;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ);
      if (self->above)
 -        netstate[num++] = prop_atoms.net_wm_state_above;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE);
      if (self->below)
 -        netstate[num++] = prop_atoms.net_wm_state_below;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW);
      if (self->demands_attention)
 -        netstate[num++] = prop_atoms.net_wm_state_demands_attention;
 +        netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION);
      if (self->undecorated)
 -        netstate[num++] = prop_atoms.ob_wm_state_undecorated;
 -    PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
 +        netstate[num++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED);
 +    OBT_PROP_SETA32(self->window, NET_WM_STATE, ATOM, netstate, num);
  
      if (self->frame)
          frame_adjust_state(self->frame);
@@@ -2393,7 -2471,15 +2393,15 @@@ static ObStackingLayer calc_layer(ObCli
                (self->decorations == 0 &&
                 !(self->max_horz && self->max_vert) &&
                 RECT_EQUAL(self->area, *monitor))) &&
-              (client_focused(self) || client_search_focus_tree(self)))
+              /* you are fullscreen while you or your children are focused.. */
+              (client_focused(self) || client_search_focus_tree(self) ||
+               /* you can be fullscreen if you're on another desktop */
+               (self->desktop != screen_desktop &&
+                self->desktop != DESKTOP_ALL) ||
+               /* and you can also be fullscreen if the focused client is on
+                  another monitor, or nothing else is focused */
+               (!focus_client ||
+                client_monitor(focus_client) != client_monitor(self))))
          l = OB_STACKING_LAYER_FULLSCREEN;
      else if (self->above) l = OB_STACKING_LAYER_ABOVE;
      else if (self->below) l = OB_STACKING_LAYER_BELOW;
@@@ -2419,23 -2505,54 +2427,54 @@@ static void client_calc_layer_recursive
          stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
      }
  
+     /* we've been restacked */
+     self->visited = TRUE;
      for (it = self->transients; it; it = g_slist_next(it))
          client_calc_layer_recursive(it->data, orig,
                                      self->layer);
  }
  
+ static void client_calc_layer_internal(ObClient *self)
+ {
+     GSList *sit;
+     /* transients take on the layer of their parents */
+     sit = client_search_all_top_parents(self);
+     for (; sit; sit = g_slist_next(sit))
+         client_calc_layer_recursive(sit->data, self, 0);
+ }
  void client_calc_layer(ObClient *self)
  {
-     ObClient *orig;
-     GSList *it;
+     GList *it;
  
-     orig = self;
+     /* skip over stuff above fullscreen layer */
+     for (it = stacking_list; it; it = g_list_next(it))
+         if (window_layer(it->data) <= OB_STACKING_LAYER_FULLSCREEN) break;
  
-     /* transients take on the layer of their parents */
-     it = client_search_all_top_parents(self);
+     /* find the windows in the fullscreen layer, and mark them not-visited */
+     for (; it; it = g_list_next(it)) {
+         if (window_layer(it->data) < OB_STACKING_LAYER_FULLSCREEN) break;
+         else if (WINDOW_IS_CLIENT(it->data))
+             WINDOW_AS_CLIENT(it->data)->visited = FALSE;
+     }
+     client_calc_layer_internal(self);
+     /* skip over stuff above fullscreen layer */
+     for (it = stacking_list; it; it = g_list_next(it))
+         if (window_layer(it->data) <= OB_STACKING_LAYER_FULLSCREEN) break;
  
-     for (; it; it = g_slist_next(it))
-         client_calc_layer_recursive(it->data, orig, 0);
+     /* now recalc any windows in the fullscreen layer which have not
+        had their layer recalced already */
+     for (; it; it = g_list_next(it)) {
+         if (window_layer(it->data) < OB_STACKING_LAYER_FULLSCREEN) break;
+         else if (WINDOW_IS_CLIENT(it->data) &&
+                  !WINDOW_AS_CLIENT(it->data)->visited)
+             client_calc_layer_internal(it->data);
+     }
  }
  
  gboolean client_should_show(ObClient *self)
@@@ -2572,7 -2689,7 +2611,7 @@@ static void client_apply_startup_state(
         pre-max/pre-fullscreen values
      */
      client_try_configure(self, &x, &y, &w, &h, &l, &l, FALSE);
 -    ob_debug("placed window 0x%x at %d, %d with size %d x %d\n",
 +    ob_debug("placed window 0x%x at %d, %d with size %d x %d",
               self->window, x, y, w, h);
      /* save the area, and make it where it should be for the premax stuff */
      oldarea = self->area;
      client_configure(self, x, y, w, h, FALSE, TRUE, FALSE);
  
      /* set the desktop hint, to make sure that it always exists */
 -    PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
 +    OBT_PROP_SET32(self->window, NET_WM_DESKTOP, CARDINAL, self->desktop);
  
      /* nothing to do for the other states:
         skip_taskbar
@@@ -2853,6 -2970,7 +2892,7 @@@ void client_try_configure(ObClient *sel
  void client_configure(ObClient *self, gint x, gint y, gint w, gint h,
                        gboolean user, gboolean final, gboolean force_reply)
  {
+     Rect oldframe;
      gint oldw, oldh;
      gboolean send_resize_client;
      gboolean moved = FALSE, resized = FALSE, rootmoved = FALSE;
  
      oldw = self->area.width;
      oldh = self->area.height;
+     oldframe = self->frame->area;
      RECT_SET(self->area, x, y, w, h);
  
      /* for app-requested resizes, always resize if 'resized' is true.
  
      /* if the client is enlarging, then resize the client before the frame */
      if (send_resize_client && (w > oldw || h > oldh)) {
 -        XMoveResizeWindow(ob_display, self->window,
 +        XMoveResizeWindow(obt_display, self->window,
                            self->frame->size.left, self->frame->size.top,
                            MAX(w, oldw), MAX(h, oldh));
          frame_adjust_client_area(self->frame);
          XEvent event;
  
          event.type = ConfigureNotify;
 -        event.xconfigure.display = ob_display;
 +        event.xconfigure.display = obt_display;
          event.xconfigure.event = self->window;
          event.xconfigure.window = self->window;
  
 -        ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d\n",
 +        ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d",
                   self->title, self->root_pos.x, self->root_pos.y, w, h);
  
          /* root window real coords */
       */
      if (send_resize_client && (w <= oldw || h <= oldh)) {
          frame_adjust_client_area(self->frame);
 -        XMoveResizeWindow(ob_display, self->window,
 +        XMoveResizeWindow(obt_display, self->window,
                            self->frame->size.left, self->frame->size.top, w, h);
      }
  
 -    XFlush(ob_display);
 +    XFlush(obt_display);
+     /* if it moved between monitors, then this can affect the stacking
+        layer of this window or others - for fullscreen windows */
+     if (screen_find_monitor(&self->frame->area) !=
+         screen_find_monitor(&oldframe))
+     {
+         client_calc_layer(self);
+     }
  }
  
  void client_fullscreen(ObClient *self, gboolean fs)
          RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0);
      }
  
 -    ob_debug("Window %s going fullscreen (%d)\n",
 +    ob_debug("Window %s going fullscreen (%d)",
               self->title, self->fullscreen);
  
      client_setup_decor_and_functions(self, FALSE);
@@@ -3047,7 -3174,7 +3096,7 @@@ static void client_iconify_recursive(Ob
  
  
      if (self->iconic != iconic) {
 -        ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
 +        ob_debug("%sconifying window: 0x%lx", (iconic ? "I" : "Uni"),
                   self->window);
  
          if (iconic) {
@@@ -3206,14 -3333,14 +3255,14 @@@ void client_close(ObClient *self
      if (!self->delete_window)
          /* don't use client_kill(), we should only kill based on PID in
             response to a lack of PING replies */
 -        XKillClient(ob_display, self->window);
 +        XKillClient(obt_display, self->window);
      else if (self->not_responding)
          client_kill(self);
      else
          /* request the client to close with WM_DELETE_WINDOW */
 -        PROP_MSG_TO(self->window, self->window, wm_protocols,
 -                    prop_atoms.wm_delete_window, event_curtime, 0, 0, 0,
 -                    NoEventMask);
 +        OBT_PROP_MSG_TO(self->window, self->window, WM_PROTOCOLS,
 +                        OBT_PROP_ATOM(WM_DELETE_WINDOW), event_curtime,
 +                        0, 0, 0, NoEventMask);
  }
  
  void client_kill(ObClient *self)
      if (!self->client_machine && self->pid) {
          /* running on the local host */
          if (!self->close_tried_term) {
 -            ob_debug("killing window 0x%x with pid %lu, with SIGTERM\n",
 +            ob_debug("killing window 0x%x with pid %lu, with SIGTERM",
                       self->window, self->pid);
              kill(self->pid, SIGTERM);
              self->close_tried_term = TRUE;
              client_update_title(self);
          }
          else {
 -            ob_debug("killing window 0x%x with pid %lu, with SIGKILL\n",
 +            ob_debug("killing window 0x%x with pid %lu, with SIGKILL",
                       self->window, self->pid);
              kill(self->pid, SIGKILL); /* kill -9 */
          }
      }
      else
 -        XKillClient(ob_display, self->window);
 +        XKillClient(obt_display, self->window);
  }
  
  void client_hilite(ObClient *self, gboolean hilite)
@@@ -3265,13 -3392,13 +3314,13 @@@ static void client_set_desktop_recursiv
  
      if (target != self->desktop && self->type != OB_CLIENT_TYPE_DESKTOP) {
  
 -        ob_debug("Setting desktop %u\n", target+1);
 +        ob_debug("Setting desktop %u", target+1);
  
          g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
  
          old = self->desktop;
          self->desktop = target;
 -        PROP_SET32(self->window, net_wm_desktop, cardinal, target);
 +        OBT_PROP_SET32(self->window, NET_WM_DESKTOP, CARDINAL, target);
          /* the frame can display the current desktop state */
          frame_adjust_state(self->frame);
          /* 'move' the window to the new desktop */
@@@ -3327,12 -3454,11 +3376,12 @@@ gboolean client_validate(ObClient *self
  {
      XEvent e;
  
 -    XSync(ob_display, FALSE); /* get all events on the server */
 +    XSync(obt_display, FALSE); /* get all events on the server */
  
 -    if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
 -        XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
 -        XPutBackEvent(ob_display, &e);
 +    if (XCheckTypedWindowEvent(obt_display, self->window, DestroyNotify, &e) ||
 +        XCheckTypedWindowEvent(obt_display, self->window, UnmapNotify, &e))
 +    {
 +        XPutBackEvent(obt_display, &e);
          return FALSE;
      }
  
@@@ -3367,9 -3493,9 +3416,9 @@@ void client_set_state(ObClient *self, A
      gboolean below = self->below;
      gint i;
  
 -    if (!(action == prop_atoms.net_wm_state_add ||
 -          action == prop_atoms.net_wm_state_remove ||
 -          action == prop_atoms.net_wm_state_toggle))
 +    if (!(action == OBT_PROP_ATOM(NET_WM_STATE_ADD) ||
 +          action == OBT_PROP_ATOM(NET_WM_STATE_REMOVE) ||
 +          action == OBT_PROP_ATOM(NET_WM_STATE_TOGGLE)))
          /* an invalid action was passed to the client message, ignore it */
          return;
  
          if (!state) continue;
  
          /* if toggling, then pick whether we're adding or removing */
 -        if (action == prop_atoms.net_wm_state_toggle) {
 -            if (state == prop_atoms.net_wm_state_modal)
 -                action = modal ? prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_maximized_vert)
 -                action = self->max_vert ? prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_maximized_horz)
 -                action = self->max_horz ? prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_shaded)
 -                action = shaded ? prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_skip_taskbar)
 +        if (action == OBT_PROP_ATOM(NET_WM_STATE_TOGGLE)) {
 +            if (state == OBT_PROP_ATOM(NET_WM_STATE_MODAL))
 +                action = modal ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT))
 +                action = self->max_vert ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ))
 +                action = self->max_horz ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_SHADED))
 +                action = shaded ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR))
                  action = self->skip_taskbar ?
 -                    prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_skip_pager)
 +                    OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER))
                  action = self->skip_pager ?
 -                    prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_hidden)
 +                    OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN))
                  action = self->iconic ?
 -                    prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_fullscreen)
 +                    OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN))
                  action = fullscreen ?
 -                    prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_above)
 -                action = self->above ? prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_below)
 -                action = self->below ? prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.net_wm_state_demands_attention)
 +                    OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_ABOVE))
 +                action = self->above ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_BELOW))
 +                action = self->below ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION))
                  action = self->demands_attention ?
 -                    prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 -            else if (state == prop_atoms.ob_wm_state_undecorated)
 -                action = undecorated ? prop_atoms.net_wm_state_remove :
 -                    prop_atoms.net_wm_state_add;
 +                    OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
 +            else if (state == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED))
 +                action = undecorated ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
 +                    OBT_PROP_ATOM(NET_WM_STATE_ADD);
          }
  
 -        if (action == prop_atoms.net_wm_state_add) {
 -            if (state == prop_atoms.net_wm_state_modal) {
 +        if (action == OBT_PROP_ATOM(NET_WM_STATE_ADD)) {
 +            if (state == OBT_PROP_ATOM(NET_WM_STATE_MODAL)) {
                  modal = TRUE;
 -            } else if (state == prop_atoms.net_wm_state_maximized_vert) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT)) {
                  max_vert = TRUE;
 -            } else if (state == prop_atoms.net_wm_state_maximized_horz) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ)) {
                  max_horz = TRUE;
 -            } else if (state == prop_atoms.net_wm_state_shaded) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SHADED)) {
                  shaded = TRUE;
 -            } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR)) {
                  self->skip_taskbar = TRUE;
 -            } else if (state == prop_atoms.net_wm_state_skip_pager) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER)) {
                  self->skip_pager = TRUE;
 -            } else if (state == prop_atoms.net_wm_state_hidden) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN)) {
                  iconic = TRUE;
 -            } else if (state == prop_atoms.net_wm_state_fullscreen) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN)) {
                  fullscreen = TRUE;
 -            } else if (state == prop_atoms.net_wm_state_above) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_ABOVE)) {
                  above = TRUE;
                  below = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_below) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_BELOW)) {
                  above = FALSE;
                  below = TRUE;
 -            } else if (state == prop_atoms.net_wm_state_demands_attention) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION)){
                  demands_attention = TRUE;
 -            } else if (state == prop_atoms.ob_wm_state_undecorated) {
 +            } else if (state == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED)) {
                  undecorated = TRUE;
              }
  
 -        } else { /* action == prop_atoms.net_wm_state_remove */
 -            if (state == prop_atoms.net_wm_state_modal) {
 +        } else { /* action == OBT_PROP_ATOM(NET_WM_STATE_REMOVE) */
 +            if (state == OBT_PROP_ATOM(NET_WM_STATE_MODAL)) {
                  modal = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_maximized_vert) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT)) {
                  max_vert = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_maximized_horz) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ)) {
                  max_horz = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_shaded) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SHADED)) {
                  shaded = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR)) {
                  self->skip_taskbar = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_skip_pager) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER)) {
                  self->skip_pager = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_hidden) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN)) {
                  iconic = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_fullscreen) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN)) {
                  fullscreen = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_above) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_ABOVE)) {
                  above = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_below) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_BELOW)) {
                  below = FALSE;
 -            } else if (state == prop_atoms.net_wm_state_demands_attention) {
 +            } else if (state == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION)){
                  demands_attention = FALSE;
 -            } else if (state == prop_atoms.ob_wm_state_undecorated) {
 +            } else if (state == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED)) {
                  undecorated = FALSE;
              }
          }
@@@ -3567,12 -3693,12 +3616,12 @@@ gboolean client_focus(ObClient *self
  
      if (!client_can_focus(self)) {
          ob_debug_type(OB_DEBUG_FOCUS,
 -                      "Client %s can't be focused\n", self->title);
 +                      "Client %s can't be focused", self->title);
          return FALSE;
      }
  
      ob_debug_type(OB_DEBUG_FOCUS,
 -                  "Focusing client \"%s\" (0x%x) at time %u\n",
 +                  "Focusing client \"%s\" (0x%x) at time %u",
                    self->title, self->window, event_curtime);
  
      /* if using focus_delay, stop the timer now so that focus doesn't
      */
      event_cancel_all_key_grabs();
  
 -    xerror_set_ignore(TRUE);
 -    xerror_occured = FALSE;
 +    obt_display_ignore_errors(TRUE);
  
      if (self->can_focus) {
          /* This can cause a BadMatch error with CurrentTime, or if an app
             passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
 -        XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
 +        XSetInputFocus(obt_display, self->window, RevertToPointerRoot,
                         event_curtime);
      }
  
      if (self->focus_notify) {
          XEvent ce;
          ce.xclient.type = ClientMessage;
 -        ce.xclient.message_type = prop_atoms.wm_protocols;
 -        ce.xclient.display = ob_display;
 +        ce.xclient.message_type = OBT_PROP_ATOM(WM_PROTOCOLS);
 +        ce.xclient.display = obt_display;
          ce.xclient.window = self->window;
          ce.xclient.format = 32;
 -        ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
 +        ce.xclient.data.l[0] = OBT_PROP_ATOM(WM_TAKE_FOCUS);
          ce.xclient.data.l[1] = event_curtime;
          ce.xclient.data.l[2] = 0l;
          ce.xclient.data.l[3] = 0l;
          ce.xclient.data.l[4] = 0l;
 -        XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
 +        XSendEvent(obt_display, self->window, FALSE, NoEventMask, &ce);
      }
  
 -    xerror_set_ignore(FALSE);
 +    obt_display_ignore_errors(FALSE);
  
 -    ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d\n", xerror_occured);
 -    return !xerror_occured;
 +    ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d",
 +                  obt_display_error_occured);
 +    return !obt_display_error_occured;
  }
  
  static void client_present(ObClient *self, gboolean here, gboolean raise,
@@@ -3941,15 -4067,15 +3990,15 @@@ static void detect_edge(Rect area, ObDi
              g_assert_not_reached();
      }
  
 -    ob_debug("my head %d size %d\n", my_head, my_size);
 -    ob_debug("head %d tail %d deest %d\n", head, tail, *dest);
 +    ob_debug("my head %d size %d", my_head, my_size);
 +    ob_debug("head %d tail %d deest %d", head, tail, *dest);
      if (!skip_head) {
 -        ob_debug("using near edge %d\n", head);
 +        ob_debug("using near edge %d", head);
          *dest = head;
          *near_edge = TRUE;
      }
      else if (!skip_tail) {
 -        ob_debug("using far edge %d\n", tail);
 +        ob_debug("using far edge %d", tail);
          *dest = tail;
          *near_edge = FALSE;
      }
@@@ -4014,7 -4140,7 +4063,7 @@@ void client_find_edge_directional(ObCli
              cur->desktop != screen_desktop)
              continue;
  
 -        ob_debug("trying window %s\n", cur->title);
 +        ob_debug("trying window %s", cur->title);
  
          detect_edge(cur->frame->area, dir, my_head, my_size, my_edge_start,
                      my_edge_size, dest, near_edge);
@@@ -4135,10 -4261,10 +4184,10 @@@ void client_find_resize_directional(ObC
          g_assert_not_reached();
      }
  
 -    ob_debug("head %d dir %d\n", head, dir);
 +    ob_debug("head %d dir %d", head, dir);
      client_find_edge_directional(self, dir, head, 1,
                                   e_start, e_size, &e, &near);
 -    ob_debug("edge %d\n", e);
 +    ob_debug("edge %d", e);
      *x = self->frame->area.x;
      *y = self->frame->area.y;
      *w = self->frame->area.width;
diff --combined openbox/client.h
@@@ -304,6 -304,9 +304,9 @@@ struct _ObClien
  
      /*! Where the window should iconify to/from */
      Rect icon_geometry;
+     /*! A boolean used for algorithms which need to mark clients as visited */
+     gboolean visited;
  };
  
  extern GList      *client_list;
@@@ -319,7 -322,10 +322,7 @@@ typedef void (*ObClientCallback)(ObClie
  void client_add_destroy_notify(ObClientCallback func, gpointer data);
  void client_remove_destroy_notify(ObClientCallback func);
  
 -/*! Manages all existing windows */
 -void client_manage_all();
 -/*! Manages a given window
 -*/
 +/*! Manages a given window */
  void client_manage(Window win);
  /*! Unmanages all managed windows */
  void client_unmanage_all();
diff --combined openbox/event.c
@@@ -24,6 -24,8 +24,6 @@@
  #include "dock.h"
  #include "actions.h"
  #include "client.h"
 -#include "xerror.h"
 -#include "prop.h"
  #include "config.h"
  #include "screen.h"
  #include "frame.h"
  #include "menu.h"
  #include "menuframe.h"
  #include "keyboard.h"
 -#include "modkeys.h"
  #include "mouse.h"
 -#include "mainloop.h"
  #include "focus.h"
  #include "focus_cycle.h"
  #include "moveresize.h"
  #include "group.h"
  #include "stacking.h"
 -#include "extensions.h"
 -#include "translate.h"
  #include "ping.h"
 +#include "obt/display.h"
 +#include "obt/prop.h"
 +#include "obt/keyboard.h"
  
  #include <X11/Xlib.h>
  #include <X11/Xatom.h>
@@@ -83,8 -86,8 +83,8 @@@ typedef struc
  
  static void event_process(const XEvent *e, gpointer data);
  static void event_handle_root(XEvent *e);
 -static gboolean event_handle_menu_keyboard(XEvent *e);
 -static gboolean event_handle_menu(XEvent *e);
 +static gboolean event_handle_menu_input(XEvent *e);
 +static void event_handle_menu(ObMenuFrame *frame, XEvent *e);
  static void event_handle_dock(ObDock *s, XEvent *e);
  static void event_handle_dockapp(ObDockApp *app, XEvent *e);
  static void event_handle_client(ObClient *c, XEvent *e);
@@@ -120,9 -123,9 +120,9 @@@ static void ice_watch(IceConn conn, Ice
  
      if (opening) {
          fd = IceConnectionNumber(conn);
 -        ob_main_loop_fd_add(ob_main_loop, fd, ice_handler, conn, NULL);
 +        obt_main_loop_fd_add(ob_main_loop, fd, ice_handler, conn, NULL);
      } else {
 -        ob_main_loop_fd_remove(ob_main_loop, fd);
 +        obt_main_loop_fd_remove(ob_main_loop, fd);
          fd = -1;
      }
  }
@@@ -132,7 -135,7 +132,7 @@@ void event_startup(gboolean reconfig
  {
      if (reconfig) return;
  
 -    ob_main_loop_x_add(ob_main_loop, event_process, NULL, NULL);
 +    obt_main_loop_x_add(ob_main_loop, event_process, NULL, NULL);
  
  #ifdef USE_SM
      IceAddConnectionWatch(ice_watch, NULL);
@@@ -159,15 -162,9 +159,15 @@@ static Window event_get_window(XEvent *
      /* pick a window */
      switch (e->type) {
      case SelectionClear:
 -        window = RootWindow(ob_display, ob_screen);
 +        window = obt_root(ob_screen);
 +        break;
 +    case CreateNotify:
 +        window = e->xcreatewindow.window;
          break;
      case MapRequest:
 +        window = e->xmaprequest.window;
 +        break;
 +    case MapNotify:
          window = e->xmap.window;
          break;
      case UnmapNotify:
          break;
      default:
  #ifdef XKB
 -        if (extensions_xkb && e->type == extensions_xkb_event_basep) {
 +        if (obt_display_extension_xkb &&
 +            e->type == obt_display_extension_xkb_basep)
 +        {
              switch (((XkbAnyEvent*)e)->xkb_type) {
              case XkbBellNotify:
                  window = ((XkbBellNotifyEvent*)e)->window;
          } else
  #endif
  #ifdef SYNC
 -        if (extensions_sync &&
 -            e->type == extensions_sync_event_basep + XSyncAlarmNotify)
 +        if (obt_display_extension_sync &&
 +            e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
          {
              window = None;
          } else
@@@ -235,8 -230,8 +235,8 @@@ static void event_set_curtime(XEvent *e
          break;
      default:
  #ifdef SYNC
 -        if (extensions_sync &&
 -            e->type == extensions_sync_event_basep + XSyncAlarmNotify)
 +        if (obt_display_extension_sync &&
 +            e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
          {
              t = ((XSyncAlarmNotifyEvent*)e)->time;
          }
@@@ -264,34 -259,34 +264,34 @@@ static void event_hack_mods(XEvent *e
      switch (e->type) {
      case ButtonPress:
      case ButtonRelease:
 -        e->xbutton.state = modkeys_only_modifier_masks(e->xbutton.state);
 +        e->xbutton.state = obt_keyboard_only_modmasks(e->xbutton.state);
          break;
      case KeyPress:
 -        e->xkey.state = modkeys_only_modifier_masks(e->xkey.state);
 +        e->xkey.state = obt_keyboard_only_modmasks(e->xkey.state);
          break;
      case KeyRelease:
  #ifdef XKB
          /* If XKB is present, then the modifiers are all strange from its
             magic.  Our X core protocol stuff won't work, so we use this to
             find what the modifier state is instead. */
 -        if (XkbGetState(ob_display, XkbUseCoreKbd, &xkb_state) == Success)
 +        if (XkbGetState(obt_display, XkbUseCoreKbd, &xkb_state) == Success)
              e->xkey.state =
 -                modkeys_only_modifier_masks(xkb_state.compat_state);
 +                obt_keyboard_only_modmasks(xkb_state.compat_state);
          else
  #endif
          {
 -            e->xkey.state = modkeys_only_modifier_masks(e->xkey.state);
 +            e->xkey.state = obt_keyboard_only_modmasks(e->xkey.state);
              /* remove from the state the mask of the modifier key being
                 released, if it is a modifier key being released that is */
 -            e->xkey.state &= ~modkeys_keycode_to_mask(e->xkey.keycode);
 +            e->xkey.state &= ~obt_keyboard_keycode_to_modmask(e->xkey.keycode);
          }
          break;
      case MotionNotify:
 -        e->xmotion.state = modkeys_only_modifier_masks(e->xmotion.state);
 +        e->xmotion.state = obt_keyboard_only_modmasks(e->xmotion.state);
          /* compress events */
          {
              XEvent ce;
 -            while (XCheckTypedWindowEvent(ob_display, e->xmotion.window,
 +            while (XCheckTypedWindowEvent(obt_display, e->xmotion.window,
                                            e->type, &ce)) {
                  e->xmotion.x = ce.xmotion.x;
                  e->xmotion.y = ce.xmotion.y;
@@@ -321,7 -316,7 +321,7 @@@ static gboolean wanted_focusevent(XEven
  
          /* These are the ones we want.. */
  
 -        if (win == RootWindow(ob_display, ob_screen)) {
 +        if (win == obt_root(ob_screen)) {
              /* If looking for a focus in on a client, then always return
                 FALSE for focus in's to the root window */
              if (in_client_only)
             but has disappeared.
          */
          if (in_client_only) {
 -            ObWindow *w = g_hash_table_lookup(window_map, &e->xfocus.window);
 +            ObWindow *w = window_find(e->xfocus.window);
              if (!w || !WINDOW_IS_CLIENT(w))
                  return FALSE;
          }
              return FALSE;
  
          /* Focus left the root window revertedto state */
 -        if (win == RootWindow(ob_display, ob_screen))
 +        if (win == obt_root(ob_screen))
              return FALSE;
  
          /* These are the ones we want.. */
@@@ -431,7 -426,7 +431,7 @@@ static void print_focusevent(XEvent *e
  
      g_assert(modestr);
      g_assert(detailstr);
 -    ob_debug_type(OB_DEBUG_FOCUS, "Focus%s 0x%x mode=%s detail=%s\n",
 +    ob_debug_type(OB_DEBUG_FOCUS, "Focus%s 0x%x mode=%s detail=%s",
                    (e->xfocus.type == FocusIn ? "In" : "Out"),
                    win,
                    modestr, detailstr);
@@@ -457,41 -452,39 +457,41 @@@ static gboolean event_ignore(XEvent *e
  
  static void event_process(const XEvent *ec, gpointer data)
  {
 +    XEvent ee, *e;
 +    ObEventData *ed = data;
 +
      Window window;
      ObClient *client = NULL;
      ObDock *dock = NULL;
      ObDockApp *dockapp = NULL;
      ObWindow *obwin = NULL;
 -    XEvent ee, *e;
 -    ObEventData *ed = data;
 +    ObMenuFrame *menu = NULL;
  
      /* make a copy we can mangle */
      ee = *ec;
      e = &ee;
  
      window = event_get_window(e);
 -    if ((obwin = g_hash_table_lookup(window_map, &window))) {
 +    if (window == obt_root(ob_screen))
 +        /* don't do any lookups, waste of cpu */;
 +    else if ((obwin = window_find(window))) {
          switch (obwin->type) {
 -        case Window_Dock:
 +        case OB_WINDOW_CLASS_DOCK:
              dock = WINDOW_AS_DOCK(obwin);
              break;
 -        case Window_DockApp:
 -            dockapp = WINDOW_AS_DOCKAPP(obwin);
 -            break;
 -        case Window_Client:
 +        case OB_WINDOW_CLASS_CLIENT:
              client = WINDOW_AS_CLIENT(obwin);
              break;
 -        case Window_Menu:
 -            /* not to be used for events */
 -            g_assert_not_reached();
 +        case OB_WINDOW_CLASS_MENUFRAME:
 +            menu = WINDOW_AS_MENUFRAME(obwin);
              break;
 -        case Window_Internal:
 +        case OB_WINDOW_CLASS_INTERNAL:
              /* we don't do anything with events directly on these windows */
              break;
          }
      }
 +    else
 +        dockapp = dock_find_dockapp(window);
  
      event_set_curtime(e);
      event_curserial = e->xany.serial;
  
      /* deal with it in the kernel */
  
 -    if (menu_frame_visible &&
 -        (e->type == EnterNotify || e->type == LeaveNotify))
 -    {
 -        /* crossing events for menu */
 -        event_handle_menu(e);
 -    } else if (e->type == FocusIn) {
 +    if (e->type == FocusIn) {
          if (client &&
              e->xfocus.detail == NotifyInferior)
          {
                 window with RevertToParent focus */
              frame_adjust_focus(client->frame, FALSE);
              /* focus_set_client(NULL) has already been called */
-             client_calc_layer(client);
          }
          else if (e->xfocus.detail == NotifyPointerRoot ||
                   e->xfocus.detail == NotifyDetailNone ||
              XEvent ce;
  
              ob_debug_type(OB_DEBUG_FOCUS,
 -                          "Focus went to root or pointer root/none\n");
 +                          "Focus went to root or pointer root/none");
  
              if (e->xfocus.detail == NotifyInferior ||
                  e->xfocus.detail == NotifyNonlinear)
                 But if the other focus in is something like PointerRoot then we
                 still want to fall back.
              */
 -            if (XCheckIfEvent(ob_display, &ce, event_look_for_focusin_client,
 +            if (XCheckIfEvent(obt_display, &ce, event_look_for_focusin_client,
                                NULL))
              {
 -                XPutBackEvent(ob_display, &ce);
 +                XPutBackEvent(obt_display, &ce);
                  ob_debug_type(OB_DEBUG_FOCUS,
 -                              "  but another FocusIn is coming\n");
 +                              "  but another FocusIn is coming");
              } else {
                  /* Focus has been reverted.
  
          else if (!client)
          {
              ob_debug_type(OB_DEBUG_FOCUS,
 -                          "Focus went to a window that is already gone\n");
 +                          "Focus went to a window that is already gone");
  
              /* If you send focus to a window and then it disappears, you can
                 get the FocusIn for it, after it is unmanaged.
          XEvent ce;
  
          /* Look for the followup FocusIn */
 -        if (!XCheckIfEvent(ob_display, &ce, event_look_for_focusin, NULL)) {
 +        if (!XCheckIfEvent(obt_display, &ce, event_look_for_focusin, NULL)) {
              /* There is no FocusIn, this means focus went to a window that
                 is not being managed, or a window on another screen. */
              Window win, root;
              gint i;
              guint u;
 -            xerror_set_ignore(TRUE);
 -            if (XGetInputFocus(ob_display, &win, &i) != 0 &&
 -                XGetGeometry(ob_display, win, &root, &i,&i,&u,&u,&u,&u) != 0 &&
 -                root != RootWindow(ob_display, ob_screen))
 +            obt_display_ignore_errors(TRUE);
 +            if (XGetInputFocus(obt_display, &win, &i) &&
 +                XGetGeometry(obt_display, win, &root, &i,&i,&u,&u,&u,&u) &&
 +                root != obt_root(ob_screen))
              {
                  ob_debug_type(OB_DEBUG_FOCUS,
 -                              "Focus went to another screen !\n");
 +                              "Focus went to another screen !");
                  focus_left_screen = TRUE;
              }
              else
                  ob_debug_type(OB_DEBUG_FOCUS,
 -                              "Focus went to a black hole !\n");
 -            xerror_set_ignore(FALSE);
 +                              "Focus went to a black hole !");
 +            obt_display_ignore_errors(FALSE);
              /* nothing is focused */
              focus_set_client(NULL);
          } else {
                  /* The FocusIn was ignored, this means it was on a window
                     that isn't a client. */
                  ob_debug_type(OB_DEBUG_FOCUS,
 -                              "Focus went to an unmanaged window 0x%x !\n",
 +                              "Focus went to an unmanaged window 0x%x !",
                                ce.xfocus.window);
                  focus_fallback(TRUE, config_focus_under_mouse, TRUE, TRUE);
              }
              frame_adjust_focus(client->frame, FALSE);
              /* focus_set_client(NULL) has already been called in this
                 section or by focus_fallback */
-             client_calc_layer(client);
          }
      }
      else if (client)
          event_handle_dockapp(dockapp, e);
      else if (dock)
          event_handle_dock(dock, e);
 -    else if (window == RootWindow(ob_display, ob_screen))
 +    else if (menu)
 +        event_handle_menu(menu, e);
 +    else if (window == obt_root(ob_screen))
          event_handle_root(e);
      else if (e->type == MapRequest)
 -        client_manage(window);
 +        window_manage(window);
      else if (e->type == MappingNotify) {
          /* keyboard layout changes for modifier mapping changes. reload the
             modifier map, and rebind all the key bindings as appropriate */
 -        ob_debug("Kepboard map changed. Reloading keyboard bindings.\n");
 -        modkeys_shutdown(TRUE);
 -        modkeys_startup(TRUE);
 +        ob_debug("Kepboard map changed. Reloading keyboard bindings.");
 +        obt_keyboard_reload();
          keyboard_rebind();
      }
      else if (e->type == ClientMessage) {
          /* This is for _NET_WM_REQUEST_FRAME_EXTENTS messages. They come for
             windows that are not managed yet. */
 -        if (e->xclient.message_type == prop_atoms.net_request_frame_extents) {
 +        if (e->xclient.message_type ==
 +            OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS))
 +        {
              /* Pretend to manage the client, getting information used to
                 determine its decorations */
              ObClient *c = client_fake_manage(e->xclient.window);
              vals[1] = c->frame->size.right;
              vals[2] = c->frame->size.top;
              vals[3] = c->frame->size.bottom;
 -            PROP_SETA32(e->xclient.window, net_frame_extents,
 -                        cardinal, vals, 4);
 +            OBT_PROP_SETA32(e->xclient.window, NET_FRAME_EXTENTS,
 +                            CARDINAL, vals, 4);
  
              /* Free the pretend client */
              client_fake_unmanage(c);
  
          /* we are not to be held responsible if someone sends us an
             invalid request! */
 -        xerror_set_ignore(TRUE);
 -        XConfigureWindow(ob_display, window,
 +        obt_display_ignore_errors(TRUE);
 +        XConfigureWindow(obt_display, window,
                           e->xconfigurerequest.value_mask, &xwc);
 -        xerror_set_ignore(FALSE);
 +        obt_display_ignore_errors(FALSE);
      }
  #ifdef SYNC
 -    else if (extensions_sync &&
 -        e->type == extensions_sync_event_basep + XSyncAlarmNotify)
 +    else if (obt_display_extension_sync &&
 +             e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
      {
          XSyncAlarmNotifyEvent *se = (XSyncAlarmNotifyEvent*)e;
          if (se->alarm == moveresize_alarm && moveresize_in_progress)
  
      if (e->type == ButtonPress || e->type == ButtonRelease) {
          /* If the button press was on some non-root window, or was physically
-            on the root window, the process it */
+            on the root window, then process it */
 -        if (window != RootWindow(ob_display, ob_screen) ||
 +        if (window != obt_root(ob_screen) ||
              e->xbutton.subwindow == None)
          {
              event_handle_user_input(client, e);
          else {
              ObWindow *w;
  
 -            if ((w = g_hash_table_lookup(window_map, &e->xbutton.subwindow)) &&
 +            if ((w = window_find(e->xbutton.subwindow)) &&
                  WINDOW_IS_INTERNAL(w))
              {
                  event_handle_user_input(client, e);
@@@ -742,7 -735,7 +740,7 @@@ static void event_handle_root(XEvent *e
  
      switch(e->type) {
      case SelectionClear:
 -        ob_debug("Another WM has requested to replace us. Exiting.\n");
 +        ob_debug("Another WM has requested to replace us. Exiting.");
          ob_exit_replace();
          break;
  
          if (e->xclient.format != 32) break;
  
          msgtype = e->xclient.message_type;
 -        if (msgtype == prop_atoms.net_current_desktop) {
 +        if (msgtype == OBT_PROP_ATOM(NET_CURRENT_DESKTOP)) {
              guint d = e->xclient.data.l[0];
              if (d < screen_num_desktops) {
                  event_curtime = e->xclient.data.l[1];
                  if (event_curtime == 0)
                      ob_debug_type(OB_DEBUG_APP_BUGS,
                                    "_NET_CURRENT_DESKTOP message is missing "
 -                                  "a timestamp\n");
 +                                  "a timestamp");
                  screen_set_desktop(d, TRUE);
              }
 -        } else if (msgtype == prop_atoms.net_number_of_desktops) {
 +        } else if (msgtype == OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS)) {
              guint d = e->xclient.data.l[0];
              if (d > 0 && d <= 1000)
                  screen_set_num_desktops(d);
 -        } else if (msgtype == prop_atoms.net_showing_desktop) {
 +        } else if (msgtype == OBT_PROP_ATOM(NET_SHOWING_DESKTOP)) {
              screen_show_desktop(e->xclient.data.l[0] != 0, NULL);
 -        } else if (msgtype == prop_atoms.ob_control) {
 -            ob_debug("OB_CONTROL: %d\n", e->xclient.data.l[0]);
 +        } else if (msgtype == OBT_PROP_ATOM(OB_CONTROL)) {
 +            ob_debug("OB_CONTROL: %d", e->xclient.data.l[0]);
              if (e->xclient.data.l[0] == 1)
                  ob_reconfigure();
              else if (e->xclient.data.l[0] == 2)
                  ob_restart();
              else if (e->xclient.data.l[0] == 3)
                  ob_exit(0);
 -        } else if (msgtype == prop_atoms.wm_protocols) {
 -            if ((Atom)e->xclient.data.l[0] == prop_atoms.net_wm_ping)
 +        } else if (msgtype == OBT_PROP_ATOM(WM_PROTOCOLS)) {
 +            if ((Atom)e->xclient.data.l[0] == OBT_PROP_ATOM(NET_WM_PING))
                  ping_got_pong(e->xclient.data.l[1]);
          }
          break;
      case PropertyNotify:
 -        if (e->xproperty.atom == prop_atoms.net_desktop_names) {
 -            ob_debug("UPDATE DESKTOP NAMES\n");
 +        if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_NAMES)) {
 +            ob_debug("UPDATE DESKTOP NAMES");
              screen_update_desktop_names();
          }
 -        else if (e->xproperty.atom == prop_atoms.net_desktop_layout)
 +        else if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_LAYOUT))
              screen_update_layout();
          break;
      case ConfigureNotify:
@@@ -806,17 -799,17 +804,17 @@@ void event_enter_client(ObClient *clien
          if (config_focus_delay) {
              ObFocusDelayData *data;
  
 -            ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
 +            obt_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
  
              data = g_new(ObFocusDelayData, 1);
              data->client = client;
              data->time = event_curtime;
              data->serial = event_curserial;
  
 -            ob_main_loop_timeout_add(ob_main_loop,
 -                                     config_focus_delay * 1000,
 -                                     focus_delay_func,
 -                                     data, focus_delay_cmp, focus_delay_dest);
 +            obt_main_loop_timeout_add(ob_main_loop,
 +                                      config_focus_delay * 1000,
 +                                      focus_delay_func,
 +                                      data, focus_delay_cmp, focus_delay_dest);
          } else {
              ObFocusDelayData data;
              data.client = client;
@@@ -994,7 -987,7 +992,7 @@@ static void event_handle_client(ObClien
                  event_end_ignore_all_enters(event_start_ignore_all_enters());
  
              ob_debug_type(OB_DEBUG_FOCUS,
 -                          "%sNotify mode %d detail %d on %lx\n",
 +                          "%sNotify mode %d detail %d on %lx",
                            (e->type == EnterNotify ? "Enter" : "Leave"),
                            e->xcrossing.mode,
                            e->xcrossing.detail, (client?client->window:0));
                     delay is up */
                  e->xcrossing.detail != NotifyInferior)
              {
 -                ob_main_loop_timeout_remove_data(ob_main_loop,
 -                                                 focus_delay_func,
 -                                                 client, FALSE);
 +                obt_main_loop_timeout_remove_data(ob_main_loop,
 +                                                  focus_delay_func,
 +                                                  client, FALSE);
              }
              break;
          default:
              {
                  ob_debug_type(OB_DEBUG_FOCUS,
                                "%sNotify mode %d detail %d serial %lu on %lx "
 -                              "IGNORED\n",
 +                              "IGNORED",
                                (e->type == EnterNotify ? "Enter" : "Leave"),
                                e->xcrossing.mode,
                                e->xcrossing.detail,
              else {
                  ob_debug_type(OB_DEBUG_FOCUS,
                                "%sNotify mode %d detail %d serial %lu on %lx, "
 -                              "focusing window\n",
 +                              "focusing window",
                                (e->type == EnterNotify ? "Enter" : "Leave"),
                                e->xcrossing.mode,
                                e->xcrossing.detail,
          RECT_TO_DIMS(client->area, x, y, w, h);
  
          ob_debug("ConfigureRequest for \"%s\" desktop %d wmstate %d "
 -                 "visibile %d\n"
 -                 "                     x %d y %d w %d h %d b %d\n",
 +                 "visibile %d",
                   client->title,
 -                 screen_desktop, client->wmstate, client->frame->visible,
 +                 screen_desktop, client->wmstate, client->frame->visible);
 +        ob_debug("                     x %d y %d w %d h %d b %d",
                   x, y, w, h, client->border_width);
  
          if (e->xconfigurerequest.value_mask & CWBorderWidth)
              /* get the sibling */
              if (e->xconfigurerequest.value_mask & CWSibling) {
                  ObWindow *win;
 -                win = g_hash_table_lookup(window_map,
 -                                          &e->xconfigurerequest.above);
 +                win = window_find(e->xconfigurerequest.above);
                  if (win && WINDOW_IS_CLIENT(win) &&
                      WINDOW_AS_CLIENT(win) != client)
                  {
          }
  
          ob_debug("ConfigureRequest x(%d) %d y(%d) %d w(%d) %d h(%d) %d "
 -                 "move %d resize %d\n",
 +                 "move %d resize %d",
                   e->xconfigurerequest.value_mask & CWX, x,
                   e->xconfigurerequest.value_mask & CWY, y,
                   e->xconfigurerequest.value_mask & CWWidth, w,
              ob_debug_type(OB_DEBUG_APP_BUGS,
                            "Application %s is trying to move via "
                            "ConfigureRequest to it's root window position "
 -                          "but it is not using StaticGravity\n",
 +                          "but it is not using StaticGravity",
                            client->title);
              /* don't move it */
              x = client->area.x;
  
              client_find_onscreen(client, &x, &y, w, h, FALSE);
  
 -            ob_debug("Granting ConfigureRequest x %d y %d w %d h %d\n",
 +            ob_debug("Granting ConfigureRequest x %d y %d w %d h %d",
                       x, y, w, h);
              client_configure(client, x, y, w, h, FALSE, TRUE, TRUE);
          }
          break;
      }
      case UnmapNotify:
 +        ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
 +                 "ignores left %d",
 +                 client->window, e->xunmap.event, e->xunmap.from_configure,
 +                 client->ignore_unmaps);
          if (client->ignore_unmaps) {
              client->ignore_unmaps--;
              break;
          }
 -        ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
 -                 "ignores left %d\n",
 -                 client->window, e->xunmap.event, e->xunmap.from_configure,
 -                 client->ignore_unmaps);
          client_unmanage(client);
          break;
      case DestroyNotify:
 -        ob_debug("DestroyNotify for window 0x%x\n", client->window);
 +        ob_debug("DestroyNotify for window 0x%x", client->window);
          client_unmanage(client);
          break;
      case ReparentNotify:
  
          /* we don't want the reparent event, put it back on the stack for the
             X server to deal with after we unmanage the window */
 -        XPutBackEvent(ob_display, e);
 +        XPutBackEvent(obt_display, e);
  
 -        ob_debug("ReparentNotify for window 0x%x\n", client->window);
 +        ob_debug("ReparentNotify for window 0x%x", client->window);
          client_unmanage(client);
          break;
      case MapRequest:
 -        ob_debug("MapRequest for 0x%lx\n", client->window);
 +        ob_debug("MapRequest for 0x%lx", client->window);
          if (!client->iconic) break; /* this normally doesn't happen, but if it
                                         does, we don't want it!
                                         it can happen now when the window is on
          if (e->xclient.format != 32) return;
  
          msgtype = e->xclient.message_type;
 -        if (msgtype == prop_atoms.wm_change_state) {
 +        if (msgtype == OBT_PROP_ATOM(WM_CHANGE_STATE)) {
              /* compress changes into a single change */
 -            while (XCheckTypedWindowEvent(ob_display, client->window,
 +            while (XCheckTypedWindowEvent(obt_display, client->window,
                                            e->type, &ce)) {
                  /* XXX: it would be nice to compress ALL messages of a
                     type, not just messages in a row without other
                     message types between. */
                  if (ce.xclient.message_type != msgtype) {
 -                    XPutBackEvent(ob_display, &ce);
 +                    XPutBackEvent(obt_display, &ce);
                      break;
                  }
                  e->xclient = ce.xclient;
              }
              client_set_wm_state(client, e->xclient.data.l[0]);
 -        } else if (msgtype == prop_atoms.net_wm_desktop) {
 +        } else if (msgtype == OBT_PROP_ATOM(NET_WM_DESKTOP)) {
              /* compress changes into a single change */
 -            while (XCheckTypedWindowEvent(ob_display, client->window,
 +            while (XCheckTypedWindowEvent(obt_display, client->window,
                                            e->type, &ce)) {
                  /* XXX: it would be nice to compress ALL messages of a
                     type, not just messages in a row without other
                     message types between. */
                  if (ce.xclient.message_type != msgtype) {
 -                    XPutBackEvent(ob_display, &ce);
 +                    XPutBackEvent(obt_display, &ce);
                      break;
                  }
                  e->xclient = ce.xclient;
                  (unsigned)e->xclient.data.l[0] == DESKTOP_ALL)
                  client_set_desktop(client, (unsigned)e->xclient.data.l[0],
                                     FALSE, FALSE);
 -        } else if (msgtype == prop_atoms.net_wm_state) {
 +        } else if (msgtype == OBT_PROP_ATOM(NET_WM_STATE)) {
              gulong ignore_start;
  
              /* can't compress these */
 -            ob_debug("net_wm_state %s %ld %ld for 0x%lx\n",
 +            ob_debug("net_wm_state %s %ld %ld for 0x%lx",
                       (e->xclient.data.l[0] == 0 ? "Remove" :
                        e->xclient.data.l[0] == 1 ? "Add" :
                        e->xclient.data.l[0] == 2 ? "Toggle" : "INVALID"),
                               e->xclient.data.l[1], e->xclient.data.l[2]);
              if (!config_focus_under_mouse)
                  event_end_ignore_all_enters(ignore_start);
 -        } else if (msgtype == prop_atoms.net_close_window) {
 -            ob_debug("net_close_window for 0x%lx\n", client->window);
 +        } else if (msgtype == OBT_PROP_ATOM(NET_CLOSE_WINDOW)) {
 +            ob_debug("net_close_window for 0x%lx", client->window);
              client_close(client);
 -        } else if (msgtype == prop_atoms.net_active_window) {
 -            ob_debug("net_active_window for 0x%lx source=%s\n",
 +        } else if (msgtype == OBT_PROP_ATOM(NET_ACTIVE_WINDOW)) {
 +            ob_debug("net_active_window for 0x%lx source=%s",
                       client->window,
                       (e->xclient.data.l[0] == 0 ? "unknown" :
                        (e->xclient.data.l[0] == 1 ? "application" :
                  if (e->xclient.data.l[1] == 0)
                      ob_debug_type(OB_DEBUG_APP_BUGS,
                                    "_NET_ACTIVE_WINDOW message for window %s is"
 -                                  " missing a timestamp\n", client->title);
 +                                  " missing a timestamp", client->title);
              } else
                  ob_debug_type(OB_DEBUG_APP_BUGS,
                                "_NET_ACTIVE_WINDOW message for window %s is "
 -                              "missing source indication\n");
 +                              "missing source indication");
              client_activate(client, FALSE, TRUE, TRUE,
                              (e->xclient.data.l[0] == 0 ||
                               e->xclient.data.l[0] == 2));
 -        } else if (msgtype == prop_atoms.net_wm_moveresize) {
 -            ob_debug("net_wm_moveresize for 0x%lx direction %d\n",
 +        } else if (msgtype == OBT_PROP_ATOM(NET_WM_MOVERESIZE)) {
 +            ob_debug("net_wm_moveresize for 0x%lx direction %d",
                       client->window, e->xclient.data.l[2]);
              if ((Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_topleft ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_top ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOP) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_topright ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPRIGHT) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_right ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_right ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_bottomright ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_bottom ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOM) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_bottomleft ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_left ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_LEFT) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_move ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_size_keyboard ||
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_KEYBOARD) ||
                  (Atom)e->xclient.data.l[2] ==
 -                prop_atoms.net_wm_moveresize_move_keyboard) {
 -
 +                OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE_KEYBOARD))
 +            {
                  moveresize_start(client, e->xclient.data.l[0],
                                   e->xclient.data.l[1], e->xclient.data.l[3],
                                   e->xclient.data.l[2]);
              }
              else if ((Atom)e->xclient.data.l[2] ==
 -                     prop_atoms.net_wm_moveresize_cancel)
 +                     OBT_PROP_ATOM(NET_WM_MOVERESIZE_CANCEL))
                  moveresize_end(TRUE);
 -        } else if (msgtype == prop_atoms.net_moveresize_window) {
 +        } else if (msgtype == OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW)) {
              gint ograv, x, y, w, h;
  
              ograv = client->gravity;
              else
                  h = client->area.height;
  
 -            ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)\n",
 +            ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)",
                       e->xclient.data.l[0] & 1 << 8, x,
                       e->xclient.data.l[0] & 1 << 9, y,
                       client->gravity);
              client_configure(client, x, y, w, h, FALSE, TRUE, FALSE);
  
              client->gravity = ograv;
 -        } else if (msgtype == prop_atoms.net_restack_window) {
 +        } else if (msgtype == OBT_PROP_ATOM(NET_RESTACK_WINDOW)) {
              if (e->xclient.data.l[0] != 2) {
                  ob_debug_type(OB_DEBUG_APP_BUGS,
                                "_NET_RESTACK_WINDOW sent for window %s with "
 -                              "invalid source indication %ld\n",
 +                              "invalid source indication %ld",
                                client->title, e->xclient.data.l[0]);
              } else {
                  ObClient *sibling = NULL;
                  if (e->xclient.data.l[1]) {
 -                    ObWindow *win = g_hash_table_lookup
 -                        (window_map, &e->xclient.data.l[1]);
 +                    ObWindow *win = window_find(e->xclient.data.l[1]);
                      if (WINDOW_IS_CLIENT(win) &&
                          WINDOW_AS_CLIENT(win) != client)
                      {
                      if (sibling == NULL)
                          ob_debug_type(OB_DEBUG_APP_BUGS,
                                        "_NET_RESTACK_WINDOW sent for window %s "
 -                                      "with invalid sibling 0x%x\n",
 +                                      "with invalid sibling 0x%x",
                                   client->title, e->xclient.data.l[1]);
                  }
                  if (e->xclient.data.l[2] == Below ||
                  } else
                      ob_debug_type(OB_DEBUG_APP_BUGS,
                                    "_NET_RESTACK_WINDOW sent for window %s "
 -                                  "with invalid detail %d\n",
 +                                  "with invalid detail %d",
                                    client->title, e->xclient.data.l[2]);
              }
          }
          if (!client_validate(client)) break;
  
          /* compress changes to a single property into a single change */
 -        while (XCheckTypedWindowEvent(ob_display, client->window,
 +        while (XCheckTypedWindowEvent(obt_display, client->window,
                                        e->type, &ce)) {
              Atom a, b;
  
  
              if (a == b)
                  continue;
 -            if ((a == prop_atoms.net_wm_name ||
 -                 a == prop_atoms.wm_name ||
 -                 a == prop_atoms.net_wm_icon_name ||
 -                 a == prop_atoms.wm_icon_name)
 +            if ((a == OBT_PROP_ATOM(NET_WM_NAME) ||
 +                 a == OBT_PROP_ATOM(WM_NAME) ||
 +                 a == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
 +                 a == OBT_PROP_ATOM(WM_ICON_NAME))
                  &&
 -                (b == prop_atoms.net_wm_name ||
 -                 b == prop_atoms.wm_name ||
 -                 b == prop_atoms.net_wm_icon_name ||
 -                 b == prop_atoms.wm_icon_name)) {
 +                (b == OBT_PROP_ATOM(NET_WM_NAME) ||
 +                 b == OBT_PROP_ATOM(WM_NAME) ||
 +                 b == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
 +                 b == OBT_PROP_ATOM(WM_ICON_NAME))) {
                  continue;
              }
 -            if (a == prop_atoms.net_wm_icon &&
 -                b == prop_atoms.net_wm_icon)
 +            if (a == OBT_PROP_ATOM(NET_WM_ICON) &&
 +                b == OBT_PROP_ATOM(NET_WM_ICON))
                  continue;
  
 -            XPutBackEvent(ob_display, &ce);
 +            XPutBackEvent(obt_display, &ce);
              break;
          }
  
          msgtype = e->xproperty.atom;
          if (msgtype == XA_WM_NORMAL_HINTS) {
 -            ob_debug("Update NORMAL hints\n");
 +            ob_debug("Update NORMAL hints");
              client_update_normal_hints(client);
              /* normal hints can make a window non-resizable */
              client_setup_decor_and_functions(client, FALSE);
              /* type may have changed, so update the layer */
              client_calc_layer(client);
              client_setup_decor_and_functions(client, TRUE);
 -        } else if (msgtype == prop_atoms.net_wm_name ||
 -                   msgtype == prop_atoms.wm_name ||
 -                   msgtype == prop_atoms.net_wm_icon_name ||
 -                   msgtype == prop_atoms.wm_icon_name) {
 +        } else if (msgtype == OBT_PROP_ATOM(NET_WM_NAME) ||
 +                   msgtype == OBT_PROP_ATOM(WM_NAME) ||
 +                   msgtype == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
 +                   msgtype == OBT_PROP_ATOM(WM_ICON_NAME)) {
              client_update_title(client);
 -        } else if (msgtype == prop_atoms.wm_protocols) {
 +        } else if (msgtype == OBT_PROP_ATOM(WM_PROTOCOLS)) {
              client_update_protocols(client);
              client_setup_decor_and_functions(client, TRUE);
          }
 -        else if (msgtype == prop_atoms.net_wm_strut) {
 +        else if (msgtype == OBT_PROP_ATOM(NET_WM_STRUT)) {
              client_update_strut(client);
          }
 -        else if (msgtype == prop_atoms.net_wm_strut_partial) {
 +        else if (msgtype == OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL)) {
              client_update_strut(client);
          }
 -        else if (msgtype == prop_atoms.net_wm_icon) {
 +        else if (msgtype == OBT_PROP_ATOM(NET_WM_ICON)) {
              client_update_icons(client);
          }
 -        else if (msgtype == prop_atoms.net_wm_icon_geometry) {
 +        else if (msgtype == OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY)) {
              client_update_icon_geometry(client);
          }
 -        else if (msgtype == prop_atoms.net_wm_user_time) {
 +        else if (msgtype == OBT_PROP_ATOM(NET_WM_USER_TIME)) {
              guint32 t;
              if (client == focus_client &&
 -                PROP_GET32(client->window, net_wm_user_time, cardinal, &t) &&
 -                t && !event_time_after(t, e->xproperty.time) &&
 +                OBT_PROP_GET32(client->window, NET_WM_USER_TIME, CARDINAL, &t)
 +                && t && !event_time_after(t, e->xproperty.time) &&
                  (!event_last_user_time ||
                   event_time_after(t, event_last_user_time)))
              {
              }
          }
  #ifdef SYNC
 -        else if (msgtype == prop_atoms.net_wm_sync_request_counter) {
 +        else if (msgtype == OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER)) {
              client_update_sync_request_counter(client);
          }
  #endif
      default:
          ;
  #ifdef SHAPE
 -        if (extensions_shape && e->type == extensions_shape_event_basep) {
 +        if (obt_display_extension_shape &&
 +            e->type == obt_display_extension_shape_basep)
 +        {
              client->shaped = ((XShapeEvent*)e)->shaped;
              frame_adjust_shape(client->frame);
          }
@@@ -1631,13 -1624,13 +1629,13 @@@ static void event_handle_dockapp(ObDock
              app->ignore_unmaps--;
              break;
          }
 -        dock_remove(app, TRUE);
 +        dock_unmanage(app, TRUE);
          break;
      case DestroyNotify:
 -        dock_remove(app, FALSE);
 +        dock_unmanage(app, FALSE);
          break;
      case ReparentNotify:
 -        dock_remove(app, FALSE);
 +        dock_unmanage(app, FALSE);
          break;
      case ConfigureNotify:
          dock_app_configure(app, e->xconfigure.width, e->xconfigure.height);
@@@ -1669,156 -1662,124 +1667,156 @@@ static ObMenuFrame* find_active_or_last
      return ret;
  }
  
 -static gboolean event_handle_menu_keyboard(XEvent *ev)
 +static gboolean event_handle_menu_input(XEvent *ev)
  {
 -    guint keycode, state;
 -    gunichar unikey;
 -    ObMenuFrame *frame;
      gboolean ret = FALSE;
  
 -    keycode = ev->xkey.keycode;
 -    state = ev->xkey.state;
 -    unikey = translate_unichar(keycode);
 +    if (ev->type == ButtonRelease) {
 +        ObMenuEntryFrame *e;
  
 -    frame = find_active_or_last_menu();
 -    if (frame == NULL)
 -        g_assert_not_reached(); /* there is no active menu */
 +        if (menu_hide_delay_reached() &&
 +            (ev->xbutton.button < 4 || ev->xbutton.button > 5))
 +        {
 +            if ((e = menu_entry_frame_under(ev->xbutton.x_root,
 +                                            ev->xbutton.y_root)))
 +            {
 +                menu_frame_select(e->frame, e, TRUE);
 +                menu_entry_frame_execute(e, ev->xbutton.state);
 +            }
 +            else
 +                menu_frame_hide_all();
 +        }
 +        ret = TRUE;
 +    }
 +    else if (ev->type == MotionNotify) {
 +        ObMenuFrame *f;
 +        ObMenuEntryFrame *e;
  
 -    /* Allow control while going thru the menu */
 -    else if (ev->type == KeyPress && (state & ~ControlMask) == 0) {
 -        frame->got_press = TRUE;
 +        if ((e = menu_entry_frame_under(ev->xmotion.x_root,
 +                                        ev->xmotion.y_root)))
 +            if (!(f = find_active_menu()) ||
 +                f == e->frame ||
 +                f->parent == e->frame ||
 +                f->child == e->frame)
 +                menu_frame_select(e->frame, e, FALSE);
 +    }
 +    else if (ev->type == KeyPress || ev->type == KeyRelease) {
 +        guint keycode, state;
 +        gunichar unikey;
 +        ObMenuFrame *frame;
  
 -        if (keycode == ob_keycode(OB_KEY_ESCAPE)) {
 -            menu_frame_hide_all();
 -            ret = TRUE;
 -        }
 +        keycode = ev->xkey.keycode;
 +        state = ev->xkey.state;
 +        unikey = obt_keyboard_keycode_to_unichar(keycode);
  
 -        else if (keycode == ob_keycode(OB_KEY_LEFT)) {
 -            /* Left goes to the parent menu */
 -            menu_frame_select(frame, NULL, TRUE);
 -            ret = TRUE;
 -        }
 +        frame = find_active_or_last_menu();
 +        if (frame == NULL)
 +            g_assert_not_reached(); /* there is no active menu */
  
 -        else if (keycode == ob_keycode(OB_KEY_RIGHT)) {
 -            /* Right goes to the selected submenu */
 -            if (frame->child) menu_frame_select_next(frame->child);
 -            ret = TRUE;
 -        }
 +        /* Allow control while going thru the menu */
 +        else if (ev->type == KeyPress && (state & ~ControlMask) == 0) {
 +            frame->got_press = TRUE;
  
 -        else if (keycode == ob_keycode(OB_KEY_UP)) {
 -            menu_frame_select_previous(frame);
 -            ret = TRUE;
 -        }
 +            if (keycode == ob_keycode(OB_KEY_ESCAPE)) {
 +                menu_frame_hide_all();
 +                ret = TRUE;
 +            }
  
 -        else if (keycode == ob_keycode(OB_KEY_DOWN)) {
 -            menu_frame_select_next(frame);
 -            ret = TRUE;
 -        }
 -    }
 +            else if (keycode == ob_keycode(OB_KEY_LEFT)) {
 +                /* Left goes to the parent menu */
 +                menu_frame_select(frame, NULL, TRUE);
 +                ret = TRUE;
 +            }
  
 -    /* Use KeyRelease events for running things so that the key release doesn't
 -       get sent to the focused application.
 +            else if (keycode == ob_keycode(OB_KEY_RIGHT)) {
 +                /* Right goes to the selected submenu */
 +                if (frame->child) menu_frame_select_next(frame->child);
 +                ret = TRUE;
 +            }
  
 -       Allow ControlMask only, and don't bother if the menu is empty */
 -    else if (ev->type == KeyRelease && (state & ~ControlMask) == 0 &&
 -             frame->entries && frame->got_press)
 -    {
 -        if (keycode == ob_keycode(OB_KEY_RETURN)) {
 -            /* Enter runs the active item or goes into the submenu.
 -               Control-Enter runs it without closing the menu. */
 -            if (frame->child)
 -                menu_frame_select_next(frame->child);
 -            else if (frame->selected)
 -                menu_entry_frame_execute(frame->selected, state);
 -
 -            ret = TRUE;
 -        }
 +            else if (keycode == ob_keycode(OB_KEY_UP)) {
 +                menu_frame_select_previous(frame);
 +                ret = TRUE;
 +            }
  
 -        /* keyboard accelerator shortcuts. (if it was a valid key) */
 -        else if (unikey != 0) {
 -            GList *start;
 -            GList *it;
 -            ObMenuEntryFrame *found = NULL;
 -            guint num_found = 0;
 -
 -            /* start after the selected one */
 -            start = frame->entries;
 -            if (frame->selected) {
 -                for (it = start; frame->selected != it->data;
 -                     it = g_list_next(it))
 -                    g_assert(it != NULL); /* nothing was selected? */
 -                /* next with wraparound */
 -                start = g_list_next(it);
 -                if (start == NULL) start = frame->entries;
 +            else if (keycode == ob_keycode(OB_KEY_DOWN)) {
 +                menu_frame_select_next(frame);
 +                ret = TRUE;
              }
 +        }
  
 -            it = start;
 -            do {
 -                ObMenuEntryFrame *e = it->data;
 -                gunichar entrykey = 0;
 +        /* Use KeyRelease events for running things so that the key release
 +           doesn't get sent to the focused application.
  
 -                if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL)
 -                    entrykey = e->entry->data.normal.shortcut;
 -                else if (e->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
 -                    entrykey = e->entry->data.submenu.submenu->shortcut;
 +           Allow ControlMask only, and don't bother if the menu is empty */
 +        else if (ev->type == KeyRelease && (state & ~ControlMask) == 0 &&
 +                 frame->entries && frame->got_press)
 +        {
 +            if (keycode == ob_keycode(OB_KEY_RETURN)) {
 +                /* Enter runs the active item or goes into the submenu.
 +                   Control-Enter runs it without closing the menu. */
 +                if (frame->child)
 +                    menu_frame_select_next(frame->child);
 +                else if (frame->selected)
 +                    menu_entry_frame_execute(frame->selected, state);
 +
 +                ret = TRUE;
 +            }
  
 -                if (unikey == entrykey) {
 -                    if (found == NULL) found = e;
 -                    ++num_found;
 +            /* keyboard accelerator shortcuts. (if it was a valid key) */
 +            else if (unikey != 0) {
 +                GList *start;
 +                GList *it;
 +                ObMenuEntryFrame *found = NULL;
 +                guint num_found = 0;
 +
 +                /* start after the selected one */
 +                start = frame->entries;
 +                if (frame->selected) {
 +                    for (it = start; frame->selected != it->data;
 +                         it = g_list_next(it))
 +                        g_assert(it != NULL); /* nothing was selected? */
 +                    /* next with wraparound */
 +                    start = g_list_next(it);
 +                    if (start == NULL) start = frame->entries;
                  }
  
 -                /* next with wraparound */
 -                it = g_list_next(it);
 -                if (it == NULL) it = frame->entries;
 -            } while (it != start);
 +                it = start;
 +                do {
 +                    ObMenuEntryFrame *e = it->data;
 +                    gunichar entrykey = 0;
  
 -            if (found) {
 -                if (found->entry->type == OB_MENU_ENTRY_TYPE_NORMAL &&
 -                    num_found == 1)
 -                {
 -                    menu_frame_select(frame, found, TRUE);
 -                    usleep(50000); /* highlight the item for a short bit so the
 -                                      user can see what happened */
 -                    menu_entry_frame_execute(found, state);
 -                } else {
 -                    menu_frame_select(frame, found, TRUE);
 -                    if (num_found == 1)
 -                        menu_frame_select_next(frame->child);
 -                }
 +                    if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL)
 +                        entrykey = e->entry->data.normal.shortcut;
 +                    else if (e->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
 +                        entrykey = e->entry->data.submenu.submenu->shortcut;
  
 -                ret = TRUE;
 +                    if (unikey == entrykey) {
 +                        if (found == NULL) found = e;
 +                        ++num_found;
 +                    }
 +
 +                    /* next with wraparound */
 +                    it = g_list_next(it);
 +                    if (it == NULL) it = frame->entries;
 +                } while (it != start);
 +
 +                if (found) {
 +                    if (found->entry->type == OB_MENU_ENTRY_TYPE_NORMAL &&
 +                        num_found == 1)
 +                    {
 +                        menu_frame_select(frame, found, TRUE);
 +                        usleep(50000); /* highlight the item for a short bit so
 +                                          the user can see what happened */
 +                        menu_entry_frame_execute(found, state);
 +                    } else {
 +                        menu_frame_select(frame, found, TRUE);
 +                        if (num_found == 1)
 +                            menu_frame_select_next(frame->child);
 +                    }
 +
 +                    ret = TRUE;
 +                }
              }
          }
      }
      return ret;
  }
  
 -static gboolean event_handle_menu(XEvent *ev)
 +static void event_handle_menu(ObMenuFrame *frame, XEvent *ev)
  {
      ObMenuFrame *f;
      ObMenuEntryFrame *e;
 -    gboolean ret = TRUE;
  
      switch (ev->type) {
 -    case ButtonRelease:
 -        if (menu_hide_delay_reached() &&
 -            (ev->xbutton.button < 4 || ev->xbutton.button > 5))
 -        {
 -            if ((e = menu_entry_frame_under(ev->xbutton.x_root,
 -                                            ev->xbutton.y_root)))
 -            {
 -                menu_frame_select(e->frame, e, TRUE);
 -                menu_entry_frame_execute(e, ev->xbutton.state);
 -            }
 -            else
 -                menu_frame_hide_all();
 -        }
 -        break;
      case EnterNotify:
          if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) {
              if (e->ignore_enters)
              menu_frame_select(e->frame, NULL, FALSE);
          }
          break;
 -    case MotionNotify:
 -        if ((e = menu_entry_frame_under(ev->xmotion.x_root,
 -                                        ev->xmotion.y_root)))
 -            if (!(f = find_active_menu()) ||
 -                f == e->frame ||
 -                f->parent == e->frame ||
 -                f->child == e->frame)
 -                menu_frame_select(e->frame, e, FALSE);
 -        break;
 -    case KeyPress:
 -    case KeyRelease:
 -        ret = event_handle_menu_keyboard(ev);
 -        break;
      }
 -    return ret;
  }
  
  static void event_handle_user_input(ObClient *client, XEvent *e)
               e->type == KeyRelease);
  
      if (menu_frame_visible) {
 -        if (event_handle_menu(e))
 +        if (event_handle_menu_input(e))
              /* don't use the event if the menu used it, but if the menu
                 didn't use it and it's a keypress that is bound, it will
                 close the menu and be used */
@@@ -1923,20 -1913,20 +1921,20 @@@ static gboolean focus_delay_func(gpoint
  
  static void focus_delay_client_dest(ObClient *client, gpointer data)
  {
 -    ob_main_loop_timeout_remove_data(ob_main_loop, focus_delay_func,
 -                                     client, FALSE);
 +    obt_main_loop_timeout_remove_data(ob_main_loop, focus_delay_func,
 +                                      client, FALSE);
  }
  
  void event_halt_focus_delay(void)
  {
      /* ignore all enter events up till the event which caused this to occur */
      if (event_curserial) event_ignore_enter_range(1, event_curserial);
 -    ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
 +    obt_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
  }
  
  gulong event_start_ignore_all_enters(void)
  {
 -    return NextRequest(ob_display);
 +    return NextRequest(obt_display);
  }
  
  static void event_ignore_enter_range(gulong start, gulong end)
      r->end = end;
      ignore_serials = g_slist_prepend(ignore_serials, r);
  
 -    ob_debug_type(OB_DEBUG_FOCUS, "ignoring enters from %lu until %lu\n",
 +    ob_debug_type(OB_DEBUG_FOCUS, "ignoring enters from %lu until %lu",
                    r->start, r->end);
  
      /* increment the serial so we don't ignore events we weren't meant to */
 -    PROP_ERASE(screen_support_win, motif_wm_hints);
 +    OBT_PROP_ERASE(screen_support_win, MOTIF_WM_HINTS);
  }
  
  void event_end_ignore_all_enters(gulong start)
         movement will be ignored until we create some further network traffic.
         Instead ignore up to NextRequest-1, then when we increment the serial,
         we will be *past* the range of ignored serials */
 -    event_ignore_enter_range(start, NextRequest(ob_display)-1);
 +    event_ignore_enter_range(start, NextRequest(obt_display)-1);
  }
  
  static gboolean is_enter_focus_event_ignored(XEvent *e)
@@@ -1998,24 -1988,24 +1996,24 @@@ void event_cancel_all_key_grabs(void
  {
      if (actions_interactive_act_running()) {
          actions_interactive_cancel_act();
 -        ob_debug("KILLED interactive action\n");
 +        ob_debug("KILLED interactive action");
      }
      else if (menu_frame_visible) {
          menu_frame_hide_all();
 -        ob_debug("KILLED open menus\n");
 +        ob_debug("KILLED open menus");
      }
      else if (moveresize_in_progress) {
          moveresize_end(TRUE);
 -        ob_debug("KILLED interactive moveresize\n");
 +        ob_debug("KILLED interactive moveresize");
      }
      else if (grab_on_keyboard()) {
          ungrab_keyboard();
 -        ob_debug("KILLED active grab on keyboard\n");
 +        ob_debug("KILLED active grab on keyboard");
      }
      else
          ungrab_passive_key();
  
 -    XSync(ob_display, FALSE);
 +    XSync(obt_display, FALSE);
  }
  
  gboolean event_time_after(Time t1, Time t2)
@@@ -2048,9 -2038,9 +2046,9 @@@ Time event_get_server_time(void
      /* Generate a timestamp */
      XEvent event;
  
 -    XChangeProperty(ob_display, screen_support_win,
 -                    prop_atoms.wm_class, prop_atoms.string,
 +    XChangeProperty(obt_display, screen_support_win,
 +                    OBT_PROP_ATOM(WM_CLASS), OBT_PROP_ATOM(STRING),
                      8, PropModeAppend, NULL, 0);
 -    XWindowEvent(ob_display, screen_support_win, PropertyChangeMask, &event);
 +    XWindowEvent(obt_display, screen_support_win, PropertyChangeMask, &event);
      return event.xproperty.time;
  }
diff --combined openbox/keyboard.c
@@@ -17,6 -17,7 +17,6 @@@
     See the COPYING file for a copy of the GNU General Public License.
  */
  
 -#include "mainloop.h"
  #include "focus.h"
  #include "screen.h"
  #include "frame.h"
@@@ -25,6 -26,7 +25,6 @@@
  #include "grab.h"
  #include "client.h"
  #include "actions.h"
 -#include "prop.h"
  #include "menuframe.h"
  #include "config.h"
  #include "keytree.h"
@@@ -44,20 -46,20 +44,20 @@@ static void grab_keys(gboolean grab
  {
      KeyBindingTree *p;
  
 -    ungrab_all_keys(RootWindow(ob_display, ob_screen));
 +    ungrab_all_keys(obt_root(ob_screen));
  
      if (grab) {
          p = curpos ? curpos->first_child : keyboard_firstnode;
          while (p) {
              if (p->key)
 -                grab_key(p->key, p->state, RootWindow(ob_display, ob_screen),
 +                grab_key(p->key, p->state, obt_root(ob_screen),
                           GrabModeAsync);
              p = p->next_sibling;
          }
          if (curpos)
              grab_key(config_keyboard_reset_keycode,
                       config_keyboard_reset_state,
 -                     RootWindow(ob_display, ob_screen), GrabModeAsync);
 +                     obt_root(ob_screen), GrabModeAsync);
      }
  }
  
@@@ -219,7 -221,7 +219,7 @@@ void keyboard_event(ObClient *client, c
      if (e->xkey.keycode == config_keyboard_reset_keycode &&
          e->xkey.state == config_keyboard_reset_state)
      {
 -        ob_main_loop_timeout_remove(ob_main_loop, chain_timeout);
 +        obt_main_loop_timeout_remove(ob_main_loop, chain_timeout);
          keyboard_reset_chains(-1);
          return;
      }
                  menu_frame_hide_all();
  
              if (p->first_child != NULL) { /* part of a chain */
 -                ob_main_loop_timeout_remove(ob_main_loop, chain_timeout);
 +                obt_main_loop_timeout_remove(ob_main_loop, chain_timeout);
                  /* 3 second timeout for chains */
 -                ob_main_loop_timeout_add(ob_main_loop, 3 * G_USEC_PER_SEC,
 -                                         chain_timeout, NULL,
 -                                         g_direct_equal, NULL);
 +                obt_main_loop_timeout_add(ob_main_loop, 3 * G_USEC_PER_SEC,
 +                                          chain_timeout, NULL,
 +                                          g_direct_equal, NULL);
                  set_curpos(p);
              } else if (p->chroot)         /* an empty chroot */
                  set_curpos(p);
      }
  }
  
+ static void node_rebind(KeyBindingTree *node)
+ {
+     if (node->first_child) {
+         /* find leaf nodes */
+         node_rebind(node->first_child);
+         /* for internal nodes, add them to the tree if they
+            are a chroot, but do this after adding their
+            children */
+         if (node->chroot)
+             keyboard_chroot(node->keylist);
+     }
+     else {
+         /* for leaf nodes, rebind each action assigned to it */
+         GSList *it;
+         while (node->actions) {
+             /* add each action, and remove them from the original tree so
+                they don't get free'd on us */
+             keyboard_bind(node->keylist, node->actions->data);
+             node->actions = g_slist_delete_link(node->actions, node->actions);
+         }
+         if (node->chroot)
+             keyboard_chroot(node->keylist);
+     }
+     /* go through each sibling */
+     if (node->next_sibling) node_rebind(node->next_sibling);
+ }
  void keyboard_rebind(void)
  {
-     tree_rebind(keyboard_firstnode);
+     KeyBindingTree *old;
+     old = keyboard_firstnode;
+     keyboard_firstnode = NULL;
+     node_rebind(old);
+     tree_destroy(old);
+     set_curpos(NULL);
      grab_keys(TRUE);
  }
  
@@@ -278,7 -317,7 +315,7 @@@ void keyboard_startup(gboolean reconfig
  
  void keyboard_shutdown(gboolean reconfig)
  {
 -    ob_main_loop_timeout_remove(ob_main_loop, chain_timeout);
 +    obt_main_loop_timeout_remove(ob_main_loop, chain_timeout);
  
      keyboard_unbind_all();
      set_curpos(NULL);
diff --combined openbox/mouse.c
  
  #include "openbox.h"
  #include "config.h"
 -#include "xerror.h"
  #include "actions.h"
  #include "event.h"
  #include "client.h"
 -#include "prop.h"
  #include "grab.h"
  #include "frame.h"
  #include "translate.h"
  #include "mouse.h"
  #include "gettext.h"
 +#include "obt/display.h"
  
  #include <glib.h>
  
@@@ -224,6 -225,17 +224,17 @@@ void mouse_event(ObClient *client, XEve
          button = e->xbutton.button;
          state = e->xbutton.state;
  
+         /* if the binding was in a client context, then we need to call
+            XAllowEvents with ReplayPointer at some point, to send the event
+            through to the client.  when this happens though depends.  if
+            windows are going to be moved on screen, then the click will end
+            up going somewhere wrong, so have the action system perform the
+            ReplayPointer for us if that is the case. */
+         if (CLIENT_CONTEXT(context, client))
+             actions_set_need_pointer_replay_before_move(TRUE);
+         else
+             actions_set_need_pointer_replay_before_move(FALSE);
          fire_binding(OB_MOUSE_ACTION_PRESS, context,
                       client, e->xbutton.state,
                       e->xbutton.button,
          if (grab_on_pointer())
              button = 0;
  
-         if (CLIENT_CONTEXT(context, client)) {
-             /* Replay the event, so it goes to the client*/
+         /* replay the pointer event if it hasn't been replayed yet (i.e. no
+            windows were moved) */
+         if (actions_get_need_pointer_replay_before_move())
 -            XAllowEvents(ob_display, ReplayPointer, event_curtime);
 +            XAllowEvents(obt_display, ReplayPointer, event_curtime);
-             /* Fall through to the release case! */
-         } else
+         /* in the client context, we won't get a button release because of the
+            way it is grabbed, so just fake one */
+         if (!CLIENT_CONTEXT(context, client))
              break;
  
      case ButtonRelease:
              Window wjunk;
              guint ujunk, b, w, h;
              /* this can cause errors to occur when the window closes */
 -            xerror_set_ignore(TRUE);
 -            junk1 = XGetGeometry(ob_display, e->xbutton.window,
 +            obt_display_ignore_errors(TRUE);
 +            junk1 = XGetGeometry(obt_display, e->xbutton.window,
                                   &wjunk, &junk1, &junk2, &w, &h, &b, &ujunk);
 -            xerror_set_ignore(FALSE);
 +            obt_display_ignore_errors(FALSE);
              if (junk1) {
                  if (e->xbutton.x >= (signed)-b &&
                      e->xbutton.y >= (signed)-b &&
diff --combined openbox/openbox.c
  #include "openbox.h"
  #include "session.h"
  #include "dock.h"
 -#include "modkeys.h"
  #include "event.h"
  #include "menu.h"
  #include "client.h"
 -#include "xerror.h"
 -#include "prop.h"
  #include "screen.h"
  #include "actions.h"
  #include "startupnotify.h"
  #include "framerender.h"
  #include "keyboard.h"
  #include "mouse.h"
 -#include "extensions.h"
  #include "menuframe.h"
  #include "grab.h"
  #include "group.h"
  #include "config.h"
  #include "ping.h"
 -#include "mainloop.h"
  #include "gettext.h"
 -#include "parser/parse.h"
  #include "render/render.h"
  #include "render/theme.h"
 +#include "obt/display.h"
 +#include "obt/prop.h"
 +#include "obt/keyboard.h"
 +#include "obt/parse.h"
  
  #ifdef HAVE_FCNTL_H
  #  include <fcntl.h>
  #include <X11/Xlib.h>
  #include <X11/keysym.h>
  
 -
 -RrInstance *ob_rr_inst;
 -RrTheme    *ob_rr_theme;
 -ObMainLoop *ob_main_loop;
 -Display    *ob_display;
 -gint        ob_screen;
 -gboolean    ob_replace_wm = FALSE;
 -gboolean    ob_sm_use = TRUE;
 -gchar      *ob_sm_id = NULL;
 -gchar      *ob_sm_save_file = NULL;
 -gboolean    ob_sm_restore = TRUE;
 -gboolean    ob_debug_xinerama = FALSE;
 +RrInstance  *ob_rr_inst;
 +RrTheme     *ob_rr_theme;
 +ObtMainLoop *ob_main_loop;
 +gint         ob_screen;
 +gboolean     ob_replace_wm = FALSE;
 +gboolean     ob_sm_use = TRUE;
 +gchar       *ob_sm_id = NULL;
 +gchar       *ob_sm_save_file = NULL;
 +gboolean     ob_sm_restore = TRUE;
 +gboolean     ob_debug_xinerama = FALSE;
  
  static ObState   state;
  static gboolean  xsync = FALSE;
@@@ -103,6 -107,7 +103,7 @@@ static KeyCode   keys[OB_NUM_KEYS]
  static gint      exitcode = 0;
  static guint     remote_control = 0;
  static gboolean  being_replaced = FALSE;
+ static gchar    *config_file = NULL;
  
  static void signal_handler(gint signal, gpointer data);
  static void remove_args(gint *argc, gchar **argv, gint index, gint num);
@@@ -116,8 -121,6 +117,8 @@@ gint main(gint argc, gchar **argv
  
      state = OB_STATE_STARTING;
  
 +    ob_debug_startup();
 +
      /* initialize the locale */
      if (!setlocale(LC_ALL, ""))
          g_message("Couldn't set locale from environment.");
      bind_textdomain_codeset(PACKAGE_NAME, "UTF-8");
      textdomain(PACKAGE_NAME);
  
 -    if (chdir(g_get_home_dir()) == -1)
 -        g_message(_("Unable to change to home directory '%s': %s"),
 -                  g_get_home_dir(), g_strerror(errno));
 -
      /* parse the command line args, which can change the argv[0] */
      parse_args(&argc, argv);
      /* parse the environment variables */
      program_name = g_path_get_basename(argv[0]);
      g_set_prgname(program_name);
  
 -    if (!remote_control) {
 -        parse_paths_startup();
 -
 +    if (!remote_control)
          session_startup(argc, argv);
 -    }
  
 -
 -    ob_display = XOpenDisplay(NULL);
 -    if (ob_display == NULL)
 +    if (!obt_display_open(NULL))
          ob_exit_with_error(_("Failed to open the display from the DISPLAY environment variable."));
 -    if (fcntl(ConnectionNumber(ob_display), F_SETFD, 1) == -1)
 -        ob_exit_with_error("Failed to set display as close-on-exec");
  
      if (remote_control) {
 -        prop_startup();
 -
          /* Send client message telling the OB process to:
           * remote_control = 1 -> reconfigure
           * remote_control = 2 -> restart */
 -        PROP_MSG(RootWindow(ob_display, ob_screen),
 -                 ob_control, remote_control, 0, 0, 0);
 -        XCloseDisplay(ob_display);
 +        OBT_PROP_MSG(ob_screen, obt_root(ob_screen),
 +                     OB_CONTROL, remote_control, 0, 0, 0, 0);
 +        obt_display_close(obt_display);
          exit(EXIT_SUCCESS);
      }
  
 -    ob_main_loop = ob_main_loop_new(ob_display);
 +    ob_main_loop = obt_main_loop_new();
  
      /* set up signal handler */
 -    ob_main_loop_signal_add(ob_main_loop, SIGUSR1, signal_handler, NULL, NULL);
 -    ob_main_loop_signal_add(ob_main_loop, SIGUSR2, signal_handler, NULL, NULL);
 -    ob_main_loop_signal_add(ob_main_loop, SIGTERM, signal_handler, NULL, NULL);
 -    ob_main_loop_signal_add(ob_main_loop, SIGINT, signal_handler, NULL, NULL);
 -    ob_main_loop_signal_add(ob_main_loop, SIGHUP, signal_handler, NULL, NULL);
 -    ob_main_loop_signal_add(ob_main_loop, SIGPIPE, signal_handler, NULL, NULL);
 -    ob_main_loop_signal_add(ob_main_loop, SIGCHLD, signal_handler, NULL, NULL);
 +    obt_main_loop_signal_add(ob_main_loop, SIGUSR1, signal_handler, NULL,NULL);
 +    obt_main_loop_signal_add(ob_main_loop, SIGUSR2, signal_handler, NULL,NULL);
 +    obt_main_loop_signal_add(ob_main_loop, SIGTERM, signal_handler, NULL,NULL);
 +    obt_main_loop_signal_add(ob_main_loop, SIGINT, signal_handler,  NULL,NULL);
 +    obt_main_loop_signal_add(ob_main_loop, SIGHUP, signal_handler,  NULL,NULL);
 +    obt_main_loop_signal_add(ob_main_loop, SIGPIPE, signal_handler, NULL,NULL);
 +    obt_main_loop_signal_add(ob_main_loop, SIGCHLD, signal_handler, NULL,NULL);
  
 -    ob_screen = DefaultScreen(ob_display);
 +    ob_screen = DefaultScreen(obt_display);
  
 -    ob_rr_inst = RrInstanceNew(ob_display, ob_screen);
 +    ob_rr_inst = RrInstanceNew(obt_display, ob_screen);
      if (ob_rr_inst == NULL)
          ob_exit_with_error(_("Failed to initialize the obrender library."));
  
 -    XSynchronize(ob_display, xsync);
 +    XSynchronize(obt_display, xsync);
  
      /* check for locale support */
      if (!XSupportsLocale())
      if (!XSetLocaleModifiers(""))
          g_message(_("Cannot set locale modifiers for the X server."));
  
 -    /* set our error handler */
 -    XSetErrorHandler(xerror_handler);
 -
      /* set the DISPLAY environment variable for any lauched children, to the
         display we're using, so they open in the right place. */
 -    setenv("DISPLAY", DisplayString(ob_display), TRUE);
 +    setenv("DISPLAY", DisplayString(obt_display), TRUE);
  
      /* create available cursors */
      cursors[OB_CURSOR_NONE] = None;
      cursors[OB_CURSOR_NORTHWEST] = load_cursor("top_left_corner",
                                                 XC_top_left_corner);
  
 -
 -    prop_startup(); /* get atoms values for the display */
 -    extensions_query_all(); /* find which extensions are present */
 -
      if (screen_annex()) { /* it will be ours! */
          do {
 -            modkeys_startup(reconfigure);
 +            if (reconfigure) obt_keyboard_reload();
  
              /* get the keycodes for keys we use */
 -            keys[OB_KEY_RETURN] = modkeys_sym_to_code(XK_Return);
 -            keys[OB_KEY_ESCAPE] = modkeys_sym_to_code(XK_Escape);
 -            keys[OB_KEY_LEFT] = modkeys_sym_to_code(XK_Left);
 -            keys[OB_KEY_RIGHT] = modkeys_sym_to_code(XK_Right);
 -            keys[OB_KEY_UP] = modkeys_sym_to_code(XK_Up);
 -            keys[OB_KEY_DOWN] = modkeys_sym_to_code(XK_Down);
 +            keys[OB_KEY_RETURN] = obt_keyboard_keysym_to_keycode(XK_Return);
 +            keys[OB_KEY_ESCAPE] = obt_keyboard_keysym_to_keycode(XK_Escape);
 +            keys[OB_KEY_LEFT] = obt_keyboard_keysym_to_keycode(XK_Left);
 +            keys[OB_KEY_RIGHT] = obt_keyboard_keysym_to_keycode(XK_Right);
 +            keys[OB_KEY_UP] = obt_keyboard_keysym_to_keycode(XK_Up);
 +            keys[OB_KEY_DOWN] = obt_keyboard_keysym_to_keycode(XK_Down);
  
              {
 -                ObParseInst *i;
 -                xmlDocPtr doc;
 -                xmlNodePtr node;
 +                ObtParseInst *i;
  
                  /* startup the parsing so everything can register sections
                     of the rc */
 -                i = parse_startup();
 +                i = obt_parse_instance_new();
  
                  /* register all the available actions */
                  actions_startup(reconfigure);
                  config_startup(i);
  
                  /* parse/load user options */
-                 if (obt_parse_load_config_file(i, "openbox", "rc.xml",
 -                if (parse_load_rc(config_file, &doc, &node)) {
 -                    parse_tree(i, doc, node->xmlChildrenNode);
 -                    parse_close(doc);
++                if ((config_file &&
++                     obt_parse_load_file(i, config_file, "openbox_config")) ||
++                    obt_parse_load_config_file(i, "openbox", "rc.xml",
 +                                               "openbox_config"))
 +                {
 +                    obt_parse_tree_from_root(i);
 +                    obt_parse_close(i);
-                 } else
+                 }
+                 else {
                      g_message(_("Unable to find a valid config file, using some simple defaults"));
+                     config_file = NULL;
+                 }
  
- /*
-                 if (config_type != NULL)
-                     PROP_SETS(obt_root(ob_screen), ob_config, config_type);
- */
+                 if (config_file) {
+                     gchar *p = g_filename_to_utf8(config_file, -1,
+                                                   NULL, NULL, NULL);
+                     if (p)
 -                        PROP_SETS(RootWindow(ob_display, ob_screen),
 -                                  ob_config_file, p);
++                        OBT_PROP_SETS(obt_root(ob_screen), OB_CONFIG_FILE,
++                                      utf8, p);
+                     g_free(p);
+                 }
+                 else
 -                    PROP_ERASE(RootWindow(ob_display, ob_screen),
 -                               ob_config_file);
++                    OBT_PROP_ERASE(obt_root(ob_screen), OB_CONFIG_FILE);
  
                  /* we're done with parsing now, kill it */
 -                parse_shutdown(i);
 +                obt_parse_instance_unref(i);
              }
  
              /* load the theme specified in the rc file */
                  if (ob_rr_theme == NULL)
                      ob_exit_with_error(_("Unable to load a theme."));
  
 -                PROP_SETS(RootWindow(ob_display, ob_screen),
 -                          ob_theme, ob_rr_theme->name);
 +                OBT_PROP_SETS(obt_root(ob_screen),
 +                              OB_THEME, utf8, ob_rr_theme->name);
              }
  
              if (reconfigure) {
                  ObWindow *w;
  
                  /* get all the existing windows */
 -                client_manage_all();
 +                window_manage_all();
                  focus_nothing();
  
                  /* focus what was focused if a wm was already running */
 -                if (PROP_GET32(RootWindow(ob_display, ob_screen),
 -                               net_active_window, window, &xid) &&
 -                    (w = g_hash_table_lookup(window_map, &xid)) &&
 -                    WINDOW_IS_CLIENT(w))
 +                if (OBT_PROP_GET32(obt_root(ob_screen),
 +                                   NET_ACTIVE_WINDOW, WINDOW, &xid) &&
 +                    (w = window_find(xid)) && WINDOW_IS_CLIENT(w))
                  {
                      client_focus(WINDOW_AS_CLIENT(w));
                  }
              reconfigure = FALSE;
  
              state = OB_STATE_RUNNING;
 -            ob_main_loop_run(ob_main_loop);
 +            obt_main_loop_run(ob_main_loop);
              state = OB_STATE_EXITING;
  
 -            if (!reconfigure) {
 -                dock_remove_all();
 -                client_unmanage_all();
 -            }
 +            if (!reconfigure)
 +                window_unmanage_all();
  
              menu_shutdown(reconfigure);
              menu_frame_shutdown(reconfigure);
              event_shutdown(reconfigure);
              config_shutdown();
              actions_shutdown(reconfigure);
 -            modkeys_shutdown(reconfigure);
          } while (reconfigure);
      }
  
 -    XSync(ob_display, FALSE);
 +    XSync(obt_display, FALSE);
  
      RrThemeFree(ob_rr_theme);
      RrInstanceFree(ob_rr_inst);
  
      session_shutdown(being_replaced);
  
 -    XCloseDisplay(ob_display);
 -
 -    parse_paths_shutdown();
 +    obt_display_close(obt_display);
  
      if (restart) {
          if (restart_path != NULL) {
      g_free(ob_sm_id);
      g_free(program_name);
  
 +    ob_debug_shutdown();
 +
      return exitcode;
  }
  
@@@ -425,11 -462,11 +437,11 @@@ static void signal_handler(gint signal
  {
      switch (signal) {
      case SIGUSR1:
 -        ob_debug("Caught signal %d. Restarting.\n", signal);
 +        ob_debug("Caught signal %d. Restarting.", signal);
          ob_restart();
          break;
      case SIGUSR2:
 -        ob_debug("Caught signal %d. Reconfiguring.\n", signal);
 +        ob_debug("Caught signal %d. Reconfiguring.", signal);
          ob_reconfigure();
          break;
      case SIGCHLD:
          while (waitpid(-1, NULL, WNOHANG) > 0);
          break;
      default:
 -        ob_debug("Caught signal %d. Exiting.\n", signal);
 +        ob_debug("Caught signal %d. Exiting.", signal);
          /* TERM and INT return a 0 code */
          ob_exit(!(signal == SIGTERM || signal == SIGINT));
      }
@@@ -462,6 -499,7 +474,7 @@@ static void print_help(
      g_print(_("  --help              Display this help and exit\n"));
      g_print(_("  --version           Display the version and exit\n"));
      g_print(_("  --replace           Replace the currently running window manager\n"));
+     g_print(_("  --config-file FILE  Specify the path to the config file to use\n"));
      g_print(_("  --sm-disable        Disable connection to the session manager\n"));
      g_print(_("\nPassing messages to a running Openbox instance:\n"));
      g_print(_("  --reconfigure       Reload Openbox's configuration\n"));
      g_print(_("  --sync              Run in synchronous mode\n"));
      g_print(_("  --debug             Display debugging output\n"));
      g_print(_("  --debug-focus       Display debugging output for focus handling\n"));
 +    g_print(_("  --debug-session     Display debugging output for session managment\n"));
      g_print(_("  --debug-xinerama    Split the display into fake xinerama screens\n"));
      g_print(_("\nPlease report bugs at %s\n"), PACKAGE_BUGREPORT);
  }
@@@ -518,19 -555,16 +531,19 @@@ static void parse_args(gint *argc, gcha
              xsync = TRUE;
          }
          else if (!strcmp(argv[i], "--debug")) {
 -            ob_debug_show_output(TRUE);
 -            ob_debug_enable(OB_DEBUG_SM, TRUE);
 +            ob_debug_enable(OB_DEBUG_NORMAL, TRUE);
              ob_debug_enable(OB_DEBUG_APP_BUGS, TRUE);
          }
          else if (!strcmp(argv[i], "--debug-focus")) {
 -            ob_debug_show_output(TRUE);
 -            ob_debug_enable(OB_DEBUG_SM, TRUE);
 +            ob_debug_enable(OB_DEBUG_NORMAL, TRUE);
              ob_debug_enable(OB_DEBUG_APP_BUGS, TRUE);
              ob_debug_enable(OB_DEBUG_FOCUS, TRUE);
          }
 +        else if (!strcmp(argv[i], "--debug-session")) {
 +            ob_debug_enable(OB_DEBUG_NORMAL, TRUE);
 +            ob_debug_enable(OB_DEBUG_APP_BUGS, TRUE);
 +            ob_debug_enable(OB_DEBUG_SM, TRUE);
 +        }
          else if (!strcmp(argv[i], "--debug-xinerama")) {
              ob_debug_xinerama = TRUE;
          }
          else if (!strcmp(argv[i], "--exit")) {
              remote_control = 3;
          }
+         else if (!strcmp(argv[i], "--config-file")) {
+             if (i == *argc - 1) /* no args left */
+                 /* not translated cuz it's sekret */
+                 g_printerr(_("--config-file requires an argument\n"));
+             else {
+                 /* this will be in the current locale encoding, which is
+                    what we want */
+                 config_file = argv[i+1];
+                 ++i; /* skip the argument */
+                 ob_debug("--config-file %s\n", config_file);
+             }
+         }
          else if (!strcmp(argv[i], "--sm-save-file")) {
              if (i == *argc - 1) /* no args left */
                  /* not translated cuz it's sekret */
                  ob_sm_save_file = g_strdup(argv[i+1]);
                  remove_args(argc, argv, i, 2);
                  --i; /* this arg was removed so go back */
 -                ob_debug_type(OB_DEBUG_SM, "--sm-save-file %s\n",
 +                ob_debug_type(OB_DEBUG_SM, "--sm-save-file %s",
                                ob_sm_save_file);
              }
          }
                  ob_sm_id = g_strdup(argv[i+1]);
                  remove_args(argc, argv, i, 2);
                  --i; /* this arg was removed so go back */
 -                ob_debug_type(OB_DEBUG_SM, "--sm-client-id %s\n", ob_sm_id);
 +                ob_debug_type(OB_DEBUG_SM, "--sm-client-id %s", ob_sm_id);
              }
          }
          else if (!strcmp(argv[i], "--sm-disable")) {
@@@ -588,10 -634,10 +613,10 @@@ static Cursor load_cursor(const gchar *
      Cursor c = None;
  
  #if USE_XCURSOR
 -    c = XcursorLibraryLoadCursor(ob_display, name);
 +    c = XcursorLibraryLoadCursor(obt_display, name);
  #endif
      if (c == None)
 -        c = XCreateFontCursor(ob_display, fontval);
 +        c = XCreateFontCursor(obt_display, fontval);
      return c;
  }
  
@@@ -623,14 -669,14 +648,14 @@@ void ob_reconfigure(
  void ob_exit(gint code)
  {
      exitcode = code;
 -    ob_main_loop_exit(ob_main_loop);
 +    obt_main_loop_exit(ob_main_loop);
  }
  
  void ob_exit_replace()
  {
      exitcode = 0;
      being_replaced = TRUE;
 -    ob_main_loop_exit(ob_main_loop);
 +    obt_main_loop_exit(ob_main_loop);
  }
  
  Cursor ob_cursor(ObCursor cursor)
diff --combined openbox/screen.c
  #include "debug.h"
  #include "openbox.h"
  #include "dock.h"
 -#include "xerror.h"
 -#include "prop.h"
  #include "grab.h"
  #include "startupnotify.h"
  #include "moveresize.h"
  #include "config.h"
 -#include "mainloop.h"
  #include "screen.h"
  #include "client.h"
  #include "session.h"
  #include "event.h"
  #include "focus.h"
  #include "popup.h"
 -#include "extensions.h"
  #include "render/render.h"
  #include "gettext.h"
 +#include "obt/display.h"
 +#include "obt/prop.h"
 +#include "obt/mainloop.h"
  
  #include <X11/Xlib.h>
  #ifdef HAVE_UNISTD_H
@@@ -90,10 -91,10 +90,10 @@@ static gboolean replace_wm(void
      Time timestamp;
  
      wm_sn = g_strdup_printf("WM_S%d", ob_screen);
 -    wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE);
 +    wm_sn_atom = XInternAtom(obt_display, wm_sn, FALSE);
      g_free(wm_sn);
  
 -    current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom);
 +    current_wm_sn_owner = XGetSelectionOwner(obt_display, wm_sn_atom);
      if (current_wm_sn_owner == screen_support_win)
          current_wm_sn_owner = None;
      if (current_wm_sn_owner) {
                        ob_screen);
              return FALSE;
          }
 -        xerror_set_ignore(TRUE);
 -        xerror_occured = FALSE;
 +        obt_display_ignore_errors(TRUE);
  
          /* We want to find out when the current selection owner dies */
 -        XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask);
 -        XSync(ob_display, FALSE);
 +        XSelectInput(obt_display, current_wm_sn_owner, StructureNotifyMask);
 +        XSync(obt_display, FALSE);
  
 -        xerror_set_ignore(FALSE);
 -        if (xerror_occured)
 +        obt_display_ignore_errors(FALSE);
 +        if (obt_display_error_occured)
              current_wm_sn_owner = None;
      }
  
      timestamp = event_get_server_time();
  
 -    XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win,
 +    XSetSelectionOwner(obt_display, wm_sn_atom, screen_support_win,
                         timestamp);
  
 -    if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) {
 +    if (XGetSelectionOwner(obt_display, wm_sn_atom) != screen_support_win) {
          g_message(_("Could not acquire window manager selection on screen %d"),
                    ob_screen);
          return FALSE;
        const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */
  
        while (wait < timeout) {
 -          if (XCheckWindowEvent(ob_display, current_wm_sn_owner,
 +          if (XCheckWindowEvent(obt_display, current_wm_sn_owner,
                                  StructureNotifyMask, &event) &&
                event.type == DestroyNotify)
                break;
      }
  
      /* Send client message indicating that we are now the WM */
 -    prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager,
 -                 timestamp, wm_sn_atom, screen_support_win, 0,
 -                 SubstructureNotifyMask);
 +    obt_prop_message(ob_screen, obt_root(ob_screen), OBT_PROP_ATOM(MANAGER),
 +                     timestamp, wm_sn_atom, screen_support_win, 0, 0,
 +                     SubstructureNotifyMask);
  
      return TRUE;
  }
@@@ -158,33 -160,37 +158,33 @@@ gboolean screen_annex(void
      XSetWindowAttributes attrib;
      pid_t pid;
      gint i, num_support;
 -    Atom *prop_atoms_start, *wm_supported_pos;
      gulong *supported;
  
      /* create the netwm support window */
      attrib.override_redirect = TRUE;
      attrib.event_mask = PropertyChangeMask;
 -    screen_support_win = XCreateWindow(ob_display,
 -                                       RootWindow(ob_display, ob_screen),
 +    screen_support_win = XCreateWindow(obt_display, obt_root(ob_screen),
                                         -100, -100, 1, 1, 0,
                                         CopyFromParent, InputOutput,
                                         CopyFromParent,
                                         CWEventMask | CWOverrideRedirect,
                                         &attrib);
 -    XMapWindow(ob_display, screen_support_win);
 -    XLowerWindow(ob_display, screen_support_win);
 +    XMapWindow(obt_display, screen_support_win);
 +    XLowerWindow(obt_display, screen_support_win);
  
      if (!replace_wm()) {
 -        XDestroyWindow(ob_display, screen_support_win);
 +        XDestroyWindow(obt_display, screen_support_win);
          return FALSE;
      }
  
 -    xerror_set_ignore(TRUE);
 -    xerror_occured = FALSE;
 -    XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
 -                 ROOT_EVENTMASK);
 -    xerror_set_ignore(FALSE);
 -    if (xerror_occured) {
 +    obt_display_ignore_errors(TRUE);
 +    XSelectInput(obt_display, obt_root(ob_screen), ROOT_EVENTMASK);
 +    obt_display_ignore_errors(FALSE);
 +    if (obt_display_error_occured) {
          g_message(_("A window manager is already running on screen %d"),
                    ob_screen);
  
 -        XDestroyWindow(ob_display, screen_support_win);
 +        XDestroyWindow(obt_display, screen_support_win);
          return FALSE;
      }
  
  
      /* set the OPENBOX_PID hint */
      pid = getpid();
 -    PROP_SET32(RootWindow(ob_display, ob_screen),
 -               openbox_pid, cardinal, pid);
 +    OBT_PROP_SET32(obt_root(ob_screen), OPENBOX_PID, CARDINAL, pid);
  
      /* set supporting window */
 -    PROP_SET32(RootWindow(ob_display, ob_screen),
 -               net_supporting_wm_check, window, screen_support_win);
 +    OBT_PROP_SET32(obt_root(ob_screen),
 +                   NET_SUPPORTING_WM_CHECK, WINDOW, screen_support_win);
  
      /* set properties on the supporting window */
 -    PROP_SETS(screen_support_win, net_wm_name, "Openbox");
 -    PROP_SET32(screen_support_win, net_supporting_wm_check,
 -               window, screen_support_win);
 +    OBT_PROP_SETS(screen_support_win, NET_WM_NAME, utf8, "Openbox");
 +    OBT_PROP_SET32(screen_support_win, NET_SUPPORTING_WM_CHECK,
 +                   WINDOW, screen_support_win);
  
      /* set the _NET_SUPPORTED_ATOMS hint */
  
 -    /* this is all the atoms after net_supported in the prop_atoms struct */
 -    prop_atoms_start = (Atom*)&prop_atoms;
 -    wm_supported_pos = (Atom*)&(prop_atoms.net_supported);
 -    num_support = sizeof(prop_atoms) / sizeof(Atom) -
 -        (wm_supported_pos - prop_atoms_start) - 1;
 +    /* this is all the atoms after NET_SUPPORTED in the ObtPropAtoms enum */
 +    num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1;
      i = 0;
      supported = g_new(gulong, num_support);
 -    supported[i++] = prop_atoms.net_supporting_wm_check;
 -    supported[i++] = prop_atoms.net_wm_full_placement;
 -    supported[i++] = prop_atoms.net_current_desktop;
 -    supported[i++] = prop_atoms.net_number_of_desktops;
 -    supported[i++] = prop_atoms.net_desktop_geometry;
 -    supported[i++] = prop_atoms.net_desktop_viewport;
 -    supported[i++] = prop_atoms.net_active_window;
 -    supported[i++] = prop_atoms.net_workarea;
 -    supported[i++] = prop_atoms.net_client_list;
 -    supported[i++] = prop_atoms.net_client_list_stacking;
 -    supported[i++] = prop_atoms.net_desktop_names;
 -    supported[i++] = prop_atoms.net_close_window;
 -    supported[i++] = prop_atoms.net_desktop_layout;
 -    supported[i++] = prop_atoms.net_showing_desktop;
 -    supported[i++] = prop_atoms.net_wm_name;
 -    supported[i++] = prop_atoms.net_wm_visible_name;
 -    supported[i++] = prop_atoms.net_wm_icon_name;
 -    supported[i++] = prop_atoms.net_wm_visible_icon_name;
 -    supported[i++] = prop_atoms.net_wm_desktop;
 -    supported[i++] = prop_atoms.net_wm_strut;
 -    supported[i++] = prop_atoms.net_wm_strut_partial;
 -    supported[i++] = prop_atoms.net_wm_icon;
 -    supported[i++] = prop_atoms.net_wm_icon_geometry;
 -    supported[i++] = prop_atoms.net_wm_window_type;
 -    supported[i++] = prop_atoms.net_wm_window_type_desktop;
 -    supported[i++] = prop_atoms.net_wm_window_type_dock;
 -    supported[i++] = prop_atoms.net_wm_window_type_toolbar;
 -    supported[i++] = prop_atoms.net_wm_window_type_menu;
 -    supported[i++] = prop_atoms.net_wm_window_type_utility;
 -    supported[i++] = prop_atoms.net_wm_window_type_splash;
 -    supported[i++] = prop_atoms.net_wm_window_type_dialog;
 -    supported[i++] = prop_atoms.net_wm_window_type_normal;
 -    supported[i++] = prop_atoms.net_wm_allowed_actions;
 -    supported[i++] = prop_atoms.net_wm_action_move;
 -    supported[i++] = prop_atoms.net_wm_action_resize;
 -    supported[i++] = prop_atoms.net_wm_action_minimize;
 -    supported[i++] = prop_atoms.net_wm_action_shade;
 -    supported[i++] = prop_atoms.net_wm_action_maximize_horz;
 -    supported[i++] = prop_atoms.net_wm_action_maximize_vert;
 -    supported[i++] = prop_atoms.net_wm_action_fullscreen;
 -    supported[i++] = prop_atoms.net_wm_action_change_desktop;
 -    supported[i++] = prop_atoms.net_wm_action_close;
 -    supported[i++] = prop_atoms.net_wm_action_above;
 -    supported[i++] = prop_atoms.net_wm_action_below;
 -    supported[i++] = prop_atoms.net_wm_state;
 -    supported[i++] = prop_atoms.net_wm_state_modal;
 -    supported[i++] = prop_atoms.net_wm_state_maximized_vert;
 -    supported[i++] = prop_atoms.net_wm_state_maximized_horz;
 -    supported[i++] = prop_atoms.net_wm_state_shaded;
 -    supported[i++] = prop_atoms.net_wm_state_skip_taskbar;
 -    supported[i++] = prop_atoms.net_wm_state_skip_pager;
 -    supported[i++] = prop_atoms.net_wm_state_hidden;
 -    supported[i++] = prop_atoms.net_wm_state_fullscreen;
 -    supported[i++] = prop_atoms.net_wm_state_above;
 -    supported[i++] = prop_atoms.net_wm_state_below;
 -    supported[i++] = prop_atoms.net_wm_state_demands_attention;
 -    supported[i++] = prop_atoms.net_moveresize_window;
 -    supported[i++] = prop_atoms.net_wm_moveresize;
 -    supported[i++] = prop_atoms.net_wm_user_time;
 +    supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT);
 +    supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP);
 +    supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS);
 +    supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY);
 +    supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT);
 +    supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW);
 +    supported[i++] = OBT_PROP_ATOM(NET_WORKAREA);
 +    supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST);
 +    supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING);
 +    supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES);
 +    supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW);
 +    supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT);
 +    supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_NAME);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ICON);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION);
 +    supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME);
  /*
 -    supported[i++] = prop_atoms.net_wm_user_time_window;
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW);
  */
 -    supported[i++] = prop_atoms.net_frame_extents;
 -    supported[i++] = prop_atoms.net_request_frame_extents;
 -    supported[i++] = prop_atoms.net_restack_window;
 -    supported[i++] = prop_atoms.net_startup_id;
 +    supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS);
 +    supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS);
 +    supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW);
 +    supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID);
  #ifdef SYNC
 -    supported[i++] = prop_atoms.net_wm_sync_request;
 -    supported[i++] = prop_atoms.net_wm_sync_request_counter;
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER);
  #endif
 -    supported[i++] = prop_atoms.net_wm_pid;
 -    supported[i++] = prop_atoms.net_wm_ping;
 -
 -    supported[i++] = prop_atoms.kde_wm_change_state;
 -    supported[i++] = prop_atoms.kde_net_wm_frame_strut;
 -    supported[i++] = prop_atoms.kde_net_wm_window_type_override;
 -
 -    supported[i++] = prop_atoms.ob_wm_action_undecorate;
 -    supported[i++] = prop_atoms.ob_wm_state_undecorated;
 -    supported[i++] = prop_atoms.openbox_pid;
 -    supported[i++] = prop_atoms.ob_theme;
 -    supported[i++] = prop_atoms.ob_config_file;
 -    supported[i++] = prop_atoms.ob_control;
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_PID);
 +    supported[i++] = OBT_PROP_ATOM(NET_WM_PING);
 +
 +    supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE);
 +    supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT);
 +    supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE);
 +
 +    supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE);
 +    supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED);
 +    supported[i++] = OBT_PROP_ATOM(OPENBOX_PID);
 +    supported[i++] = OBT_PROP_ATOM(OB_THEME);
++    supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE);
 +    supported[i++] = OBT_PROP_ATOM(OB_CONTROL);
      g_assert(i == num_support);
  
 -    PROP_SETA32(RootWindow(ob_display, ob_screen),
 -                net_supported, atom, supported, num_support);
 +    OBT_PROP_SETA32(obt_root(ob_screen),
 +                    NET_SUPPORTED, ATOM, supported, num_support);
      g_free(supported);
  
      screen_tell_ksplash();
@@@ -326,14 -337,14 +327,14 @@@ static void screen_tell_ksplash(void
         hear it anyways. perhaps it is for old ksplash. or new ksplash. or
         something. oh well. */
      e.xclient.type = ClientMessage;
 -    e.xclient.display = ob_display;
 -    e.xclient.window = RootWindow(ob_display, ob_screen);
 +    e.xclient.display = obt_display;
 +    e.xclient.window = obt_root(ob_screen);
      e.xclient.message_type =
 -        XInternAtom(ob_display, "_KDE_SPLASH_PROGRESS", False );
 +        XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False );
      e.xclient.format = 8;
      strcpy(e.xclient.data.b, "wm started");
 -    XSendEvent(ob_display, RootWindow(ob_display, ob_screen),
 -               False, SubstructureNotifyMask, &e );
 +    XSendEvent(obt_display, obt_root(ob_screen),
 +               False, SubstructureNotifyMask, &e);
  }
  
  void screen_startup(gboolean reconfig)
      screen_resize();
  
      /* have names already been set for the desktops? */
 -    if (PROP_GETSS(RootWindow(ob_display, ob_screen),
 -                   net_desktop_names, utf8, &names))
 -    {
 +    if (OBT_PROP_GETSS(obt_root(ob_screen), NET_DESKTOP_NAMES, utf8, &names)) {
          g_strfreev(names);
          namesexist = TRUE;
      }
              names[i] = g_strdup(it->data);
  
          /* set the root window property */
 -        PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names);
 +        OBT_PROP_SETSS(obt_root(ob_screen),
 +                       NET_DESKTOP_NAMES, utf8, (const gchar**)names);
  
          g_strfreev(names);
      }
         this will also set the default names from the config file up for
         desktops that don't have names yet */
      screen_num_desktops = 0;
 -    if (PROP_GET32(RootWindow(ob_display, ob_screen),
 -                   net_number_of_desktops, cardinal, &d))
 +    if (OBT_PROP_GET32(obt_root(ob_screen),
 +                       NET_NUMBER_OF_DESKTOPS, CARDINAL, &d))
      {
          if (d != config_desktops_num) {
              g_warning(_("Openbox is configured for %d desktops, but the current session has %d.  Overriding the Openbox configuration."),
  
      screen_desktop = screen_num_desktops;  /* something invalid */
      /* start on the current desktop when a wm was already running */
 -    if (PROP_GET32(RootWindow(ob_display, ob_screen),
 -                   net_current_desktop, cardinal, &d) &&
 +    if (OBT_PROP_GET32(obt_root(ob_screen),
 +                       NET_CURRENT_DESKTOP, CARDINAL, &d) &&
          d < screen_num_desktops)
      {
          screen_set_desktop(d, FALSE);
  
      /* don't start in showing-desktop mode */
      screen_showing_desktop = FALSE;
 -    PROP_SET32(RootWindow(ob_display, ob_screen),
 -               net_showing_desktop, cardinal, screen_showing_desktop);
 +    OBT_PROP_SET32(obt_root(ob_screen),
 +                   NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop);
  
      if (session_desktop_layout_present &&
          screen_validate_layout(&session_desktop_layout))
@@@ -440,16 -452,17 +441,16 @@@ void screen_shutdown(gboolean reconfig
      if (reconfig)
          return;
  
 -    XSelectInput(ob_display, RootWindow(ob_display, ob_screen),
 -                 NoEventMask);
 +    XSelectInput(obt_display, obt_root(ob_screen), NoEventMask);
  
      /* we're not running here no more! */
 -    PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid);
 +    OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID);
      /* not without us */
 -    PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported);
 +    OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED);
      /* don't keep this mode */
 -    PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop);
 +    OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP);
  
 -    XDestroyWindow(ob_display, screen_support_win);
 +    XDestroyWindow(obt_display, screen_support_win);
  
      g_strfreev(screen_desktop_names);
      screen_desktop_names = NULL;
@@@ -462,8 -475,8 +463,8 @@@ void screen_resize(void
      GList *it;
      gulong geometry[2];
  
 -    w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen));
 -    h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen));
 +    w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 +    h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
  
      if (w == oldw && h == oldh) return;
  
      /* Set the _NET_DESKTOP_GEOMETRY hint */
      screen_physical_size.width = geometry[0] = w;
      screen_physical_size.height = geometry[1] = h;
 -    PROP_SETA32(RootWindow(ob_display, ob_screen),
 -                net_desktop_geometry, cardinal, geometry, 2);
 +    OBT_PROP_SETA32(obt_root(ob_screen),
 +                    NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2);
  
      if (ob_state() == OB_STATE_STARTING)
          return;
@@@ -497,12 -510,13 +498,12 @@@ void screen_set_num_desktops(guint num
  
      old = screen_num_desktops;
      screen_num_desktops = num;
 -    PROP_SET32(RootWindow(ob_display, ob_screen),
 -               net_number_of_desktops, cardinal, num);
 +    OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num);
  
      /* set the viewport hint */
      viewport = g_new0(gulong, num * 2);
 -    PROP_SETA32(RootWindow(ob_display, ob_screen),
 -                net_desktop_viewport, cardinal, viewport, num * 2);
 +    OBT_PROP_SETA32(obt_root(ob_screen),
 +                    NET_DESKTOP_VIEWPORT, CARDINAL, viewport, num * 2);
      g_free(viewport);
  
      /* the number of rows/columns will differ */
@@@ -597,7 -611,8 +598,7 @@@ void screen_set_desktop(guint num, gboo
  
      if (previous == num) return;
  
 -    PROP_SET32(RootWindow(ob_display, ob_screen),
 -               net_current_desktop, cardinal, num);
 +    OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num);
  
      /* This whole thing decides when/how to save the screen_last_desktop so
         that it can be restored later if you want */
          }
      }
      screen_desktop_timeout = FALSE;
 -    ob_main_loop_timeout_remove(ob_main_loop, last_desktop_func);
 -    ob_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME,
 -                             last_desktop_func, NULL, NULL, NULL);
 +    obt_main_loop_timeout_remove(ob_main_loop, last_desktop_func);
 +    obt_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME,
 +                              last_desktop_func, NULL, NULL, NULL);
  
 -    ob_debug("Moving to desktop %d\n", num+1);
 +    ob_debug("Moving to desktop %d", num+1);
  
      /* ignore enter events caused by the move */
      ignore_start = event_start_ignore_all_enters();
@@@ -719,7 -734,7 +720,7 @@@ void screen_add_desktop(gboolean curren
                     parent - which will have to be on the same desktop */
                  !client_direct_parent(c))
              {
 -                ob_debug("moving window %s\n", c->title);
 +                ob_debug("moving window %s", c->title);
                  client_set_desktop(c, c->desktop+1, FALSE, TRUE);
              }
          }
@@@ -760,7 -775,7 +761,7 @@@ void screen_remove_desktop(gboolean cur
                     parent - which will have to be on the same desktop */
                  !client_direct_parent(c))
              {
 -                ob_debug("moving window %s\n", c->title);
 +                ob_debug("moving window %s", c->title);
                  client_set_desktop(c, c->desktop - 1, TRUE, TRUE);
              }
              /* raise all the windows that are on the current desktop which
                  (d == DESKTOP_ALL || d == screen_desktop))
              {
                  stacking_raise(CLIENT_AS_WINDOW(c));
 -                ob_debug("raising window %s\n", c->title);
 +                ob_debug("raising window %s", c->title);
              }
          }
      }
      /* fallback focus like we're changing desktops */
      if (screen_desktop < screen_num_desktops - 1) {
          screen_fallback_focus();
 -        ob_debug("fake desktop change\n");
 +        ob_debug("fake desktop change");
      }
  
      screen_set_num_desktops(screen_num_desktops-1);
@@@ -919,15 -934,15 +920,15 @@@ void screen_show_desktop_popup(guint d
                            MAX(a->width/3, POPUP_WIDTH));
      pager_popup_show(desktop_popup, screen_desktop_names[d], d);
  
 -    ob_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
 -    ob_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000,
 -                             hide_desktop_popup_func, NULL, NULL, NULL);
 +    obt_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
 +    obt_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000,
 +                              hide_desktop_popup_func, NULL, NULL, NULL);
      g_free(a);
  }
  
  void screen_hide_desktop_popup(void)
  {
 -    ob_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
 +    obt_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func);
      pager_popup_hide(desktop_popup);
  }
  
@@@ -1086,13 -1101,13 +1087,13 @@@ void screen_update_layout(void
      screen_desktop_layout.rows = 1;
      screen_desktop_layout.columns = screen_num_desktops;
  
 -    if (PROP_GETA32(RootWindow(ob_display, ob_screen),
 -                    net_desktop_layout, cardinal, &data, &num)) {
 +    if (OBT_PROP_GETA32(obt_root(ob_screen),
 +                        NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) {
          if (num == 3 || num == 4) {
  
 -            if (data[0] == prop_atoms.net_wm_orientation_vert)
 +            if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT))
                  l.orientation = OB_ORIENTATION_VERT;
 -            else if (data[0] == prop_atoms.net_wm_orientation_horz)
 +            else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ))
                  l.orientation = OB_ORIENTATION_HORZ;
              else
                  return;
              if (num < 4)
                  l.start_corner = OB_CORNER_TOPLEFT;
              else {
 -                if (data[3] == prop_atoms.net_wm_topleft)
 +                if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT))
                      l.start_corner = OB_CORNER_TOPLEFT;
 -                else if (data[3] == prop_atoms.net_wm_topright)
 +                else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT))
                      l.start_corner = OB_CORNER_TOPRIGHT;
 -                else if (data[3] == prop_atoms.net_wm_bottomright)
 +                else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT))
                      l.start_corner = OB_CORNER_BOTTOMRIGHT;
 -                else if (data[3] == prop_atoms.net_wm_bottomleft)
 +                else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT))
                      l.start_corner = OB_CORNER_BOTTOMLEFT;
                  else
                      return;
@@@ -1131,8 -1146,8 +1132,8 @@@ void screen_update_desktop_names(void
      g_strfreev(screen_desktop_names);
      screen_desktop_names = NULL;
  
 -    if (PROP_GETSS(RootWindow(ob_display, ob_screen),
 -                   net_desktop_names, utf8, &screen_desktop_names))
 +    if (OBT_PROP_GETSS(obt_root(ob_screen),
 +                       NET_DESKTOP_NAMES, utf8, &screen_desktop_names))
          for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i);
      else
          i = 0;
  
          /* if we changed any names, then set the root property so we can
             all agree on the names */
 -        PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,
 -                   screen_desktop_names);
 +        OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES,
 +                       utf8, (const gchar**)screen_desktop_names);
      }
  
      /* resize the pager for these names */
@@@ -1226,23 -1241,24 +1227,23 @@@ void screen_show_desktop(gboolean show
      }
  
      show = !!show; /* make it boolean */
 -    PROP_SET32(RootWindow(ob_display, ob_screen),
 -               net_showing_desktop, cardinal, show);
 +    OBT_PROP_SET32(obt_root(ob_screen), NET_SHOWING_DESKTOP, CARDINAL, show);
  }
  
  void screen_install_colormap(ObClient *client, gboolean install)
  {
      if (client == NULL || client->colormap == None) {
          if (install)
 -            XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
 +            XInstallColormap(obt_display, RrColormap(ob_rr_inst));
          else
 -            XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst));
 +            XUninstallColormap(obt_display, RrColormap(ob_rr_inst));
      } else {
 -        xerror_set_ignore(TRUE);
 +        obt_display_ignore_errors(TRUE);
          if (install)
 -            XInstallColormap(RrDisplay(ob_rr_inst), client->colormap);
 +            XInstallColormap(obt_display, client->colormap);
          else
 -            XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap);
 -        xerror_set_ignore(FALSE);
 +            XUninstallColormap(obt_display, client->colormap);
 +        obt_display_ignore_errors(FALSE);
      }
  }
  
@@@ -1284,54 -1300,6 +1285,54 @@@ typedef struct 
      } \
  }
  
 +static void get_xinerama_screens(Rect **xin_areas, guint *nxin)
 +{
 +    guint i;
 +    gint l, r, t, b;
 +
 +    if (ob_debug_xinerama) {
 +        gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 +        gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen));
 +        *nxin = 2;
 +        *xin_areas = g_new(Rect, *nxin + 1);
 +        RECT_SET((*xin_areas)[0], 0, 0, w/2, h);
 +        RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h);
 +    }
 +#ifdef XINERAMA
 +    else if (obt_display_extension_xinerama) {
 +        guint i;
 +        gint n;
 +        XineramaScreenInfo *info = XineramaQueryScreens(obt_display, &n);
 +        *nxin = n;
 +        *xin_areas = g_new(Rect, *nxin + 1);
 +        for (i = 0; i < *nxin; ++i)
 +            RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org,
 +                     info[i].width, info[i].height);
 +        XFree(info);
 +    }
 +#endif
 +    else {
 +        *nxin = 1;
 +        *xin_areas = g_new(Rect, *nxin + 1);
 +        RECT_SET((*xin_areas)[0], 0, 0,
 +                 WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)),
 +                 HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)));
 +    }
 +
 +    /* returns one extra with the total area in it */
 +    l = (*xin_areas)[0].x;
 +    t = (*xin_areas)[0].y;
 +    r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1;
 +    b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1;
 +    for (i = 1; i < *nxin; ++i) {
 +        l = MIN(l, (*xin_areas)[i].x);
 +        t = MIN(l, (*xin_areas)[i].y);
 +        r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1);
 +        b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1);
 +    }
 +    RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1);
 +}
 +
  void screen_update_areas(void)
  {
      guint i, j;
      GSList *sit;
  
      g_free(monitor_area);
 -    extensions_xinerama_screens(&monitor_area, &screen_num_monitors);
 +    get_xinerama_screens(&monitor_area, &screen_num_monitors);
  
      /* set up the user-specified margins */
      config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]);
  
      /* all the work areas are not used here, only the ones for the first
         monitor are */
 -    PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal,
 -                dims, 4 * screen_num_desktops);
 +    OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL,
 +                    dims, 4 * screen_num_desktops);
  
      /* the area has changed, adjust all the windows if they need it */
      for (it = client_list; it; it = g_list_next(it))
@@@ -1691,10 -1659,10 +1692,10 @@@ Rect* screen_physical_area_active(void
  void screen_set_root_cursor(void)
  {
      if (sn_app_starting())
 -        XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
 +        XDefineCursor(obt_display, obt_root(ob_screen),
                        ob_cursor(OB_CURSOR_BUSYPOINTER));
      else
 -        XDefineCursor(ob_display, RootWindow(ob_display, ob_screen),
 +        XDefineCursor(obt_display, obt_root(ob_screen),
                        ob_cursor(OB_CURSOR_POINTER));
  }
  
@@@ -1705,12 -1673,12 +1706,12 @@@ gboolean screen_pointer_pos(gint *x, gi
      guint u;
      gboolean ret;
  
 -    ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen),
 +    ret = !!XQueryPointer(obt_display, obt_root(ob_screen),
                            &w, &w, x, y, &i, &i, &u);
      if (!ret) {
 -        for (i = 0; i < ScreenCount(ob_display); ++i)
 +        for (i = 0; i < ScreenCount(obt_display); ++i)
              if (i != ob_screen)
 -                if (XQueryPointer(ob_display, RootWindow(ob_display, i),
 +                if (XQueryPointer(obt_display, obt_root(i),
                                    &w, &w, x, y, &i, &i, &u))
                      break;
      }