Merge branch 'backport' into work
authorDana Jansens <danakj@orodu.net>
Tue, 26 Feb 2008 06:00:26 +0000 (01:00 -0500)
committerDana Jansens <danakj@orodu.net>
Tue, 26 Feb 2008 06:00:26 +0000 (01:00 -0500)
1  2 
openbox/client.c
openbox/screen.c

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"
@@@ -40,8 -43,6 +40,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>
@@@ -184,8 -185,8 +184,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], NULL);
 -        }
 -    }
 -    XFree(children);
 -}
 -
  void client_manage(Window window, ObPrompt *prompt)
  {
      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();
  
      attrib_set.event_mask = CLIENT_EVENTMASK |
          (prompt ? prompt->event_mask : 0);
      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;
      self->prompt = prompt;
  
      /* 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
         should be reparented back to root automatically, unless we are managing
         an internal ObPrompt window  */
      if (!self->prompt)
 -        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;
  }
  
  
@@@ -568,7 -651,7 +568,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);
  
@@@ -607,7 -690,7 +607,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);
      /* remove the window from our save set, unless we are managing an internal
         ObPrompt window */
      if (!self->prompt)
 -        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 */
      RrImageUnref(self->icon_set);
@@@ -790,7 -873,7 +790,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 */
@@@ -845,17 -928,17 +845,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;
@@@ -1098,11 -1181,10 +1098,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);
  }
  
@@@ -1125,12 -1207,12 +1125,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);
          }
      }
@@@ -1178,32 -1260,32 +1178,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;
          }
  
@@@ -1215,14 -1297,14 +1215,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);
@@@ -1236,22 -1318,22 +1236,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;
@@@ -1387,8 -1469,8 +1387,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];
@@@ -1407,27 -1489,26 +1407,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 */
@@@ -1502,8 -1583,7 +1502,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;
@@@ -1514,7 -1594,7 +1514,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);
  }
  
@@@ -1522,7 -1602,7 +1522,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 */
@@@ -1546,7 -1626,7 +1546,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)
@@@ -1758,38 -1838,38 +1758,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);
@@@ -1813,7 -1893,7 +1813,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)
@@@ -1902,10 -1982,10 +1902,10 @@@ void client_update_title(ObClient *self
      g_free(self->original_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;
  }
  
@@@ -1976,9 -2056,8 +1976,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;
  
@@@ -2039,7 -2118,7 +2039,7 @@@ void client_update_icons(ObClient *self
         icon */
      grab_server(TRUE);
  
 -    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 = 0;
      if (!img) {
          XWMHints *hints;
  
 -        if ((hints = XGetWMHints(ob_display, self->window))) {
 +        if ((hints = XGetWMHints(obt_display, self->window))) {
              if (hints->flags & IconPixmapHint) {
                  gboolean xicon;
 -                xerror_set_ignore(TRUE);
 +                obt_display_ignore_errors(TRUE);
                  xicon = RrPixmapToRGBA(ob_rr_inst,
                                         hints->icon_pixmap,
                                         (hints->flags & IconMaskHint ?
                                          hints->icon_mask : None),
                                         (gint*)&w, (gint*)&h, &data);
 -                xerror_set_ignore(FALSE);
 +                obt_display_ignore_errors(FALSE);
  
  
                  if (xicon) {
                  (((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) +
                  (((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) +
                  (((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0);
 -        PROP_SETA32(self->window, net_wm_icon, cardinal, ldata, w*h+2);
 +        OBT_PROP_SETA32(self->window, NET_WM_ICON, CARDINAL, ldata, w*h+2);
          g_free(ldata);
      } else if (self->frame)
          /* don't draw the icon empty if we're just setting one now anyways,
@@@ -2161,8 -2240,7 +2161,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 */
@@@ -2179,23 -2257,23 +2179,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;
      }
  }
@@@ -2287,12 -2365,12 +2287,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);
      }
  }
  
@@@ -2303,30 -2381,30 +2303,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);
@@@ -2632,7 -2710,7 +2632,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
@@@ -2948,7 -3026,7 +2948,7 @@@ void client_configure(ObClient *self, g
  
      /* 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 */
@@@ -3095,7 -3173,7 +3095,7 @@@ void client_fullscreen(ObClient *self, 
          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);
@@@ -3121,7 -3199,7 +3121,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) {
@@@ -3296,12 -3374,12 +3296,12 @@@ 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 {
          /* 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);
  
          /* we're trying to close the window, so see if it is responding. if it
             is not, then we will let them kill the window */
@@@ -3335,8 -3413,8 +3335,8 @@@ static void client_prompt_kill(ObClien
      /* check if we're already prompting */
      if (!self->kill_prompt) {
          ObPromptAnswer answers[] = {
-             { _("No"), OB_KILL_RESULT_NO },
-             { _("Yes"), OB_KILL_RESULT_YES }
+             { _("Cancel"), OB_KILL_RESULT_NO },
+             { _("Force Exit"), OB_KILL_RESULT_YES }
          };
          gchar *m;
  
@@@ -3384,14 -3462,14 +3384,14 @@@ void client_kill(ObClient *self
              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 {
          /* running on a remote host */
 -        XKillClient(ob_display, self->window);
 +        XKillClient(obt_display, self->window);
      }
  }
  
@@@ -3421,13 -3499,13 +3421,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 */
@@@ -3483,12 -3561,11 +3483,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;
      }
  
@@@ -3523,9 -3600,9 +3523,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;
              }
          }
@@@ -3723,12 -3800,12 +3723,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,
@@@ -4065,15 -4142,15 +4065,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;
      }
@@@ -4138,7 -4215,7 +4138,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);
@@@ -4259,10 -4336,10 +4259,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/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();
@@@ -327,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) {
              /* TRANSLATORS: If you need to specify a different order of the
  
      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))
@@@ -445,16 -456,17 +445,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;
@@@ -467,8 -479,8 +467,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;
@@@ -502,12 -514,13 +502,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 */
@@@ -602,7 -615,8 +602,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);
  
+     if (ob_state() == OB_STATE_RUNNING)
+         screen_show_desktop_popup(screen_desktop);
      /* ignore enter events caused by the move */
      ignore_start = event_start_ignore_all_enters();
  
  
      if (event_curtime != CurrentTime)
          screen_desktop_user_time = event_curtime;
-     if (ob_state() == OB_STATE_RUNNING)
-         screen_show_desktop_popup(screen_desktop);
  }
  
  void screen_add_desktop(gboolean current)
                     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);
              }
          }
@@@ -770,7 -784,7 +770,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);
@@@ -929,15 -943,15 +929,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);
  }
  
@@@ -1096,13 -1110,13 +1096,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;
@@@ -1141,8 -1155,8 +1141,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 */
@@@ -1236,23 -1250,24 +1236,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);
      }
  }
  
@@@ -1294,54 -1309,6 +1294,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))
@@@ -1701,10 -1668,10 +1701,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));
  }
  
@@@ -1715,12 -1682,12 +1715,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;
      }