moving from https://github.com/perberos/mate-desktop-environment

52 files changed, 47155 insertions, 0 deletions

diff --git a/src/core/async-getprop.c b/src/core/async-getprop.c
new file mode 100644
index 00000000..80322b41
--- /dev/null
+++ b/src/core/async-getprop.c
@@ -0,0 +1,680 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Asynchronous X property getting hack */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ * Copyright (C) 1986, 1998  The Open Group
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation.
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of The Open Group shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from The Open Group.
+ */
+
+#include <assert.h>
+
+#undef DEBUG_SPEW
+#ifdef DEBUG_SPEW
+#include <stdio.h>
+#endif
+
+#include "async-getprop.h"
+
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+typedef struct _ListNode ListNode;
+typedef struct _AgPerDisplayData AgPerDisplayData;
+
+struct _ListNode
+{
+  ListNode *next;
+};
+
+struct _AgGetPropertyTask
+{
+  ListNode node;
+  
+  AgPerDisplayData *dd;
+  Window window;
+  Atom property;
+
+  unsigned long request_seq;
+  int error;
+
+  Atom actual_type;
+  int  actual_format;
+
+  unsigned long  n_items;
+  unsigned long  bytes_after;
+  char          *data;
+
+  Bool have_reply;
+};
+
+struct _AgPerDisplayData
+{
+  ListNode node;
+  _XAsyncHandler async;
+  
+  Display *display;
+  ListNode *pending_tasks;
+  ListNode *pending_tasks_tail;
+  ListNode *completed_tasks;
+  ListNode *completed_tasks_tail;
+  int n_tasks_pending;
+  int n_tasks_completed;
+};
+
+static ListNode *display_datas = NULL;
+static ListNode *display_datas_tail = NULL;
+
+static void
+append_to_list (ListNode **head,
+                ListNode **tail,
+                ListNode  *task)
+{
+  task->next = NULL;
+  
+  if (*tail == NULL)
+    {
+      assert (*head == NULL);
+      *head = task;
+      *tail = task;
+    }
+  else
+    {
+      (*tail)->next = task;
+      *tail = task;
+    }
+}
+
+static void
+remove_from_list (ListNode **head,
+                  ListNode **tail,
+                  ListNode  *task)
+{
+  ListNode *prev;
+  ListNode *node;
+
+  prev = NULL;
+  node = *head;
+  while (node != NULL)
+    {
+      if (node == task)
+        {
+          if (prev)
+            prev->next = node->next;
+          else
+            *head = node->next;
+
+          if (node == *tail)
+            *tail = prev;
+          
+          break;
+        }
+      
+      prev = node;
+      node = node->next;
+    }
+
+  /* can't remove what's not there */
+  assert (node != NULL);
+
+  node->next = NULL;
+}
+
+static void
+move_to_completed (AgPerDisplayData  *dd,
+                   AgGetPropertyTask *task)
+{
+  remove_from_list (&dd->pending_tasks,
+                    &dd->pending_tasks_tail,
+                    &task->node);
+  
+  append_to_list (&dd->completed_tasks,
+                  &dd->completed_tasks_tail,
+                  &task->node);
+
+  dd->n_tasks_pending -= 1;
+  dd->n_tasks_completed += 1;
+}
+
+static AgGetPropertyTask*
+find_pending_by_request_sequence (AgPerDisplayData *dd,
+                                  unsigned long     request_seq)
+{
+  ListNode *node;
+
+  /* if the sequence is after our last pending task, we
+   * aren't going to find a match
+   */
+  {
+    AgGetPropertyTask *task = (AgGetPropertyTask*) dd->pending_tasks_tail;
+    if (task != NULL)
+      {
+        if (task->request_seq < request_seq)
+          return NULL;
+        else if (task->request_seq == request_seq)
+          return task; /* why not check this */
+      }
+  }
+
+  /* Generally we should get replies in the order we sent
+   * requests, so we should usually be using the task
+   * at the head of the list, if we use any task at all.
+   * I'm not sure this is 100% guaranteed, if it is,
+   * it would be a big speedup.
+   */
+  
+  node = dd->pending_tasks;
+  while (node != NULL)
+    {
+      AgGetPropertyTask *task = (AgGetPropertyTask*) node;
+      
+      if (task->request_seq == request_seq)
+        return task;
+      
+      node = node->next;
+    }
+  
+  return NULL;
+}
+
+static Bool
+async_get_property_handler (Display *dpy,
+                            xReply  *rep,
+                            char    *buf,
+                            int      len,
+                            XPointer data)
+{
+  xGetPropertyReply  replbuf;
+  xGetPropertyReply *reply;
+  AgGetPropertyTask *task;
+  AgPerDisplayData *dd;
+  int bytes_read;
+
+  dd = (AgPerDisplayData*) data;
+  
+#if 0
+  printf ("%s: seeing request seq %ld buflen %d\n", __FUNCTION__,
+          dpy->last_request_read, len);
+#endif
+  
+  task = find_pending_by_request_sequence (dd, dpy->last_request_read);
+
+  if (task == NULL)
+    return False;
+
+  assert (dpy->last_request_read == task->request_seq);
+
+  task->have_reply = True;
+  move_to_completed (dd, task);
+  
+  /* read bytes so far */
+  bytes_read = SIZEOF (xReply);
+
+  if (rep->generic.type == X_Error)
+    {
+      xError errbuf;
+
+      task->error = rep->error.errorCode;
+      
+#ifdef DEBUG_SPEW
+      printf ("%s: error code = %d (ignoring error, eating %d bytes, generic.length = %ld)\n",
+              __FUNCTION__, task->error, (SIZEOF (xError) - bytes_read),
+              rep->generic.length);
+#endif
+
+      /* We return True (meaning we consumed the reply)
+       * because otherwise it would invoke the X error handler,
+       * and an async API is useless if you have to synchronously
+       * trap X errors. Also GetProperty can always fail, pretty
+       * much, so trapping errors is always what you want.
+       *
+       * We have to eat all the error reply data here.
+       * (kind of a charade as we know sizeof(xError) == sizeof(xReply))
+       *
+       * Passing discard = True seems to break things; I don't understand
+       * why, because there should be no extra data in an error reply,
+       * right?
+       */
+      _XGetAsyncReply (dpy, (char *)&errbuf, rep, buf, len,
+                       (SIZEOF (xError) - bytes_read) >> 2, /* in 32-bit words */
+                       False); /* really seems like it should be True */
+      
+      return True;
+    }
+
+#ifdef DEBUG_SPEW
+  printf ("%s: already read %d bytes reading %d more for total of %d; generic.length = %ld\n",
+          __FUNCTION__, bytes_read, (SIZEOF (xGetPropertyReply) - bytes_read) >> 2,
+          SIZEOF (xGetPropertyReply), rep->generic.length);
+#endif
+
+  /* (kind of a silly as we know sizeof(xGetPropertyReply) == sizeof(xReply)) */
+  reply = (xGetPropertyReply *)
+    _XGetAsyncReply (dpy, (char *)&replbuf, rep, buf, len,
+                     (SIZEOF (xGetPropertyReply) - bytes_read) >> 2, /* in 32-bit words */
+                     False); /* False means expecting more data to follow,
+                              * don't eat the rest of the reply
+                              */
+
+  bytes_read = SIZEOF (xGetPropertyReply);
+
+#ifdef DEBUG_SPEW
+  printf ("%s: have reply propertyType = %ld format = %d n_items = %ld\n",
+          __FUNCTION__, reply->propertyType, reply->format, reply->nItems);
+#endif
+
+  assert (task->data == NULL);
+
+  /* This is all copied from XGetWindowProperty().  Not sure we should
+   * LockDisplay(). Not sure I'm passing the right args to
+   * XGetAsyncData(). Not sure about a lot of things.
+   */
+
+  /* LockDisplay (dpy); */
+
+  if (reply->propertyType != None)
+    {
+      long nbytes, netbytes;
+
+      /* this alignment macro from matecorba2 */
+#define ALIGN_VALUE(this, boundary) \
+  (( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))
+
+      switch (reply->format)
+        {
+          /*
+           * One extra byte is malloced than is needed to contain the property
+           * data, but this last byte is null terminated and convenient for
+           * returning string properties, so the client doesn't then have to
+           * recopy the string to make it null terminated.
+           */
+        case 8:
+          nbytes = reply->nItems;
+          /* there's padding to word boundary */
+          netbytes = ALIGN_VALUE (nbytes, 4);
+          if (nbytes + 1 > 0 &&
+              (task->data = (char *) Xmalloc ((unsigned)nbytes + 1)))
+            {
+#ifdef DEBUG_SPEW
+              printf ("%s: already read %d bytes using %ld, more eating %ld more\n",
+                      __FUNCTION__, bytes_read, nbytes, netbytes);
+#endif
+              /* _XReadPad (dpy, (char *) task->data, netbytes); */
+              _XGetAsyncData (dpy, task->data, buf, len,
+                              bytes_read, nbytes,
+                              netbytes);
+            }
+          break;
+
+        case 16:
+          nbytes = reply->nItems * sizeof (short);
+          netbytes = reply->nItems << 1;
+          netbytes = ALIGN_VALUE (netbytes, 4); /* align to word boundary */
+          if (nbytes + 1 > 0 &&
+              (task->data = (char *) Xmalloc ((unsigned)nbytes + 1)))
+            {
+#ifdef DEBUG_SPEW
+              printf ("%s: already read %d bytes using %ld more, eating %ld more\n",
+                      __FUNCTION__, bytes_read, nbytes, netbytes);
+#endif
+              /* _XRead16Pad (dpy, (short *) task->data, netbytes); */
+              _XGetAsyncData (dpy, task->data, buf, len,
+                              bytes_read, nbytes, netbytes);
+            }
+          break;
+
+        case 32:
+          /* NOTE buffer is in longs to match XGetWindowProperty() */
+          nbytes = reply->nItems * sizeof (long);
+          netbytes = reply->nItems << 2; /* wire size is always 32 bits though */
+          if (nbytes + 1 > 0 &&
+              (task->data = (char *) Xmalloc ((unsigned)nbytes + 1)))
+            {
+#ifdef DEBUG_SPEW
+              printf ("%s: already read %d bytes using %ld more, eating %ld more\n",
+                      __FUNCTION__, bytes_read, nbytes, netbytes);
+#endif
+
+              /* We have to copy the XGetWindowProperty() crackrock
+               * and get format 32 as long even on 64-bit platforms.
+               */
+              if (sizeof (long) == 8)
+                {
+                  char *netdata;
+                  char *lptr;
+                  char *end_lptr;
+                  
+                  /* Store the 32-bit values in the end of the array */
+                  netdata = task->data + nbytes / 2;
+
+                  _XGetAsyncData (dpy, netdata, buf, len,
+                                  bytes_read, netbytes,
+                                  netbytes);
+
+                  /* Now move the 32-bit values to the front */
+                  
+                  lptr = task->data;
+                  end_lptr = task->data + nbytes;
+                  while (lptr != end_lptr)
+                    {
+                      *(long*) lptr = *(CARD32*) netdata;
+                      lptr += sizeof (long);
+                      netdata += sizeof (CARD32);
+                    }
+                }
+              else
+                {
+                  /* Here the wire format matches our actual format */
+                  _XGetAsyncData (dpy, task->data, buf, len,
+                                  bytes_read, netbytes,
+                                  netbytes);
+                }
+            }
+          break;
+
+        default:
+          /*
+           * This part of the code should never be reached.  If it is,
+           * the server sent back a property with an invalid format.
+           * This is a BadImplementation error.
+           *
+           * However this async GetProperty API doesn't report errors
+           * via the standard X mechanism, so don't do anything about
+           * it, other than store it in task->error.
+           */
+          {
+#if 0
+            xError error;
+#endif
+            
+            task->error = BadImplementation;
+
+#if 0
+            error.sequenceNumber = task->request_seq;
+            error.type = X_Error;
+            error.majorCode = X_GetProperty;
+            error.minorCode = 0;
+            error.errorCode = BadImplementation;
+
+            _XError (dpy, &error);
+#endif
+          }
+
+          nbytes = netbytes = 0L;
+          break;
+        }
+
+      if (task->data == NULL)
+        {
+          task->error = BadAlloc;
+
+#ifdef DEBUG_SPEW
+          printf ("%s: already read %d bytes eating %ld\n",
+                  __FUNCTION__, bytes_read, netbytes);
+#endif
+          /* _XEatData (dpy, (unsigned long) netbytes); */
+          _XGetAsyncData (dpy, NULL, buf, len,
+                          bytes_read, 0, netbytes);
+
+          /* UnlockDisplay (dpy); */
+          return BadAlloc; /* not Success */
+        }
+
+      (task->data)[nbytes] = '\0';
+    }
+
+#ifdef DEBUG_SPEW
+  printf ("%s: have data\n", __FUNCTION__);
+#endif
+
+  task->actual_type = reply->propertyType;
+  task->actual_format = reply->format;
+  task->n_items = reply->nItems;
+  task->bytes_after = reply->bytesAfter;
+
+  /* UnlockDisplay (dpy); */
+
+  return True;
+}
+
+static AgPerDisplayData*
+get_display_data (Display *display,
+                  Bool     create)
+{
+  ListNode *node;
+  AgPerDisplayData *dd;
+  
+  node = display_datas;
+  while (node != NULL)
+    {
+      dd = (AgPerDisplayData*) node;
+      
+      if (dd->display == display)
+        return dd;
+      
+      node = node->next;
+    }
+
+  if (!create)
+    return NULL;
+  
+  dd = Xcalloc (1, sizeof (AgPerDisplayData));
+  if (dd == NULL)
+    return NULL;
+
+  dd->display = display;
+  dd->async.next = display->async_handlers;
+  dd->async.handler = async_get_property_handler;
+  dd->async.data = (XPointer) dd;
+  dd->display->async_handlers = &dd->async;
+
+  append_to_list (&display_datas,
+                  &display_datas_tail,
+                  &dd->node);
+  
+  return dd;
+}
+
+static void
+maybe_free_display_data (AgPerDisplayData *dd)
+{
+  if (dd->pending_tasks == NULL &&
+      dd->completed_tasks == NULL)
+    {
+      DeqAsyncHandler (dd->display, &dd->async);
+      remove_from_list (&display_datas, &display_datas_tail,
+                        &dd->node);
+      XFree (dd);
+    }
+}
+
+AgGetPropertyTask*
+ag_task_create (Display *dpy,
+                Window   window,
+                Atom     property,
+                long     offset,
+                long     length,
+                Bool     delete,
+                Atom     req_type)
+{
+  AgGetPropertyTask *task;
+  xGetPropertyReq *req;
+  AgPerDisplayData *dd;  
+  
+  /* Fire up our request */
+  LockDisplay (dpy);
+
+  dd = get_display_data (dpy, True);
+  if (dd == NULL)
+    {
+      UnlockDisplay (dpy);
+      return NULL;
+    }
+  
+  GetReq (GetProperty, req);
+  req->window = window;
+  req->property = property;
+  req->type = req_type;
+  req->delete = delete;
+  req->longOffset = offset;
+  req->longLength = length;
+
+  /* Queue up our async task */
+  task = Xcalloc (1, sizeof (AgGetPropertyTask));
+  if (task == NULL)
+    {
+      UnlockDisplay (dpy);
+      return NULL;
+    }
+
+  task->dd = dd;
+  task->window = window;
+  task->property = property;
+  task->request_seq = dpy->request;
+
+  append_to_list (&dd->pending_tasks,
+                  &dd->pending_tasks_tail,
+                  &task->node);
+  dd->n_tasks_pending += 1;
+  
+  UnlockDisplay (dpy);
+
+  SyncHandle ();
+
+  return task;
+}
+
+static void
+free_task (AgGetPropertyTask *task)
+{
+  remove_from_list (&task->dd->completed_tasks,
+                    &task->dd->completed_tasks_tail,
+                    &task->node);
+  task->dd->n_tasks_completed -= 1;
+  maybe_free_display_data (task->dd);
+  XFree (task);
+}
+
+Status
+ag_task_get_reply_and_free (AgGetPropertyTask  *task,
+                            Atom               *actual_type,
+                            int                *actual_format,
+                            unsigned long      *nitems,
+                            unsigned long      *bytesafter,
+                            unsigned char     **prop)
+{
+  Display *dpy;
+
+  *prop = NULL;
+
+  dpy = task->dd->display; /* Xlib macros require a variable named "dpy" */
+  
+  if (task->error != Success)
+    {
+      Status s = task->error;
+
+      free_task (task);
+      
+      return s;
+    }
+
+  if (!task->have_reply)
+    {
+      free_task (task);
+
+      return BadAlloc; /* not Success */
+    }
+
+  *actual_type = task->actual_type;
+  *actual_format = task->actual_format;
+  *nitems = task->n_items;
+  *bytesafter = task->bytes_after;
+
+  *prop = (unsigned char*) task->data; /* pass out ownership of task->data */
+
+  SyncHandle ();
+
+  free_task (task);
+  
+  return Success;
+}
+
+Bool
+ag_task_have_reply (AgGetPropertyTask *task)
+{
+  return task->have_reply;
+}
+
+Atom
+ag_task_get_property (AgGetPropertyTask *task)
+{
+  return task->property;
+}
+
+Window
+ag_task_get_window (AgGetPropertyTask *task)
+{
+  return task->window;
+}
+
+Display*
+ag_task_get_display (AgGetPropertyTask *task)
+{
+  return task->dd->display;
+}
+
+AgGetPropertyTask*
+ag_get_next_completed_task (Display *display)
+{
+  AgPerDisplayData *dd;
+
+  dd = get_display_data (display, False);
+
+  if (dd == NULL)
+    return NULL;
+  
+#ifdef DEBUG_SPEW
+  printf ("%d pending %d completed\n",
+          dd->n_tasks_pending,
+          dd->n_tasks_completed);
+#endif
+
+  return (AgGetPropertyTask*) dd->completed_tasks;
+}
+
+void*
+ag_Xmalloc (unsigned long bytes)
+{
+  return (void*) Xmalloc (bytes);
+}
+
+void*
+ag_Xmalloc0 (unsigned long bytes)
+{
+  return (void*) Xcalloc (bytes, 1);
+}
diff --git a/src/core/async-getprop.h b/src/core/async-getprop.h
new file mode 100644
index 00000000..c857e930
--- /dev/null
+++ b/src/core/async-getprop.h
@@ -0,0 +1,67 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Asynchronous X property getting hack */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation.
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of The Open Group shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from The Open Group.
+ */
+
+#ifndef ASYNC_GETPROP_H
+#define ASYNC_GETPROP_H
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+typedef struct _AgGetPropertyTask AgGetPropertyTask;
+
+AgGetPropertyTask* ag_task_create             (Display            *display,
+                                               Window              window,
+                                               Atom                property,
+                                               long                offset,
+                                               long                length,
+                                               Bool                delete,
+                                               Atom                req_type);
+Status             ag_task_get_reply_and_free (AgGetPropertyTask  *task,
+                                               Atom               *actual_type,
+                                               int                *actual_format,
+                                               unsigned long      *nitems,
+                                               unsigned long      *bytesafter,
+                                               unsigned char     **prop);
+
+Bool     ag_task_have_reply   (AgGetPropertyTask *task);
+Atom     ag_task_get_property (AgGetPropertyTask *task);
+Window   ag_task_get_window   (AgGetPropertyTask *task);
+Display* ag_task_get_display  (AgGetPropertyTask *task);
+
+AgGetPropertyTask* ag_get_next_completed_task (Display *display);
+
+/* so other headers don't have to include internal Xlib goo */
+void*    ag_Xmalloc  (unsigned long bytes);
+void*    ag_Xmalloc0 (unsigned long bytes);
+
+#endif
+
+
+
+
diff --git a/src/core/atomnames.h b/src/core/atomnames.h
new file mode 100644
index 00000000..551482ac
--- /dev/null
+++ b/src/core/atomnames.h
@@ -0,0 +1,166 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003, 2004 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * Copyright (C) 2008 Thomas Thurman
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file atomnames.h  A list of atom names.
+ *
+ * This is a list of the names of all the X atoms that Marco uses.
+ * Each is wrapped in a macro "item()" which is undefined here; the
+ * idea is that when you need to make a big list of all the X atoms,
+ * you can define item(), include this file, and then undefine it
+ * again.
+ *
+ * If you also define EWMH_ATOMS_ONLY then you will only get _NET_WM_*
+ * atoms rather than all of them.
+ */
+
+#ifndef item
+#error "item(x) must be defined when you include atomnames.h"
+#endif
+
+#ifndef EWMH_ATOMS_ONLY
+
+item(WM_PROTOCOLS)
+item(WM_TAKE_FOCUS)
+item(WM_DELETE_WINDOW)
+item(WM_STATE)
+item(_MOTIF_WM_HINTS)
+item(WM_CHANGE_STATE)
+item(SM_CLIENT_ID)
+item(WM_CLIENT_LEADER)
+item(WM_WINDOW_ROLE)
+item(UTF8_STRING)
+item(WM_ICON_SIZE)
+item(_KWM_WIN_ICON)
+item(_MARCO_RESTART_MESSAGE)    
+item(_MARCO_RELOAD_THEME_MESSAGE)
+item(_MARCO_SET_KEYBINDINGS_MESSAGE)
+item(_MARCO_TOGGLE_VERBOSE)
+item(_MATE_PANEL_ACTION)
+item(_MATE_PANEL_ACTION_MAIN_MENU)
+item(_MATE_PANEL_ACTION_RUN_DIALOG)
+item(_MARCO_SENTINEL)
+item(_MARCO_VERSION)
+item(WM_CLIENT_MACHINE)
+item(MANAGER)
+item(TARGETS)
+item(MULTIPLE)
+item(TIMESTAMP)
+item(VERSION)
+item(ATOM_PAIR)
+
+/* Oddities: These are used, and we need atoms for them,
+ * but when we need all _NET_WM hints (i.e. when we're making
+ * lists of which _NET_WM hints we support in order to advertise
+ * it) we haven't historically listed them.  I don't know what
+ * the reason for this is.  It may be a bug.
+ */
+item(_NET_WM_SYNC_REQUEST)
+item(_NET_WM_SYNC_REQUEST_COUNTER)
+item(_NET_WM_VISIBLE_NAME)
+item(_NET_WM_VISIBLE_ICON_NAME)
+item(_NET_SUPPORTING_WM_CHECK)
+
+/* But I suppose it's quite reasonable not to advertise using
+ * _NET_SUPPORTED that we support _NET_SUPPORTED :)
+ */
+item(_NET_SUPPORTED)
+
+#endif /* !EWMH_ATOMS_ONLY */
+
+/**************************************************************************/
+
+item(_NET_WM_NAME)
+item(_NET_CLOSE_WINDOW)
+item(_NET_WM_STATE)
+item(_NET_WM_STATE_SHADED)
+item(_NET_WM_STATE_MAXIMIZED_HORZ)
+item(_NET_WM_STATE_MAXIMIZED_VERT)
+item(_NET_WM_DESKTOP)
+item(_NET_NUMBER_OF_DESKTOPS)
+item(_NET_CURRENT_DESKTOP)
+item(_NET_WM_WINDOW_TYPE)
+item(_NET_WM_WINDOW_TYPE_DESKTOP)
+item(_NET_WM_WINDOW_TYPE_DOCK)
+item(_NET_WM_WINDOW_TYPE_TOOLBAR)
+item(_NET_WM_WINDOW_TYPE_MENU)
+item(_NET_WM_WINDOW_TYPE_DIALOG)
+item(_NET_WM_WINDOW_TYPE_NORMAL)
+item(_NET_WM_STATE_MODAL)
+item(_NET_CLIENT_LIST)
+item(_NET_CLIENT_LIST_STACKING)
+item(_NET_WM_STATE_SKIP_TASKBAR)
+item(_NET_WM_STATE_SKIP_PAGER)
+item(_NET_WM_ICON_NAME)
+item(_NET_WM_ICON)
+item(_NET_WM_ICON_GEOMETRY)
+item(_NET_WM_MOVERESIZE)
+item(_NET_ACTIVE_WINDOW)
+item(_NET_WM_STRUT)
+item(_NET_WM_STATE_HIDDEN)
+item(_NET_WM_WINDOW_TYPE_UTILITY)
+item(_NET_WM_WINDOW_TYPE_SPLASH)
+item(_NET_WM_STATE_FULLSCREEN)
+item(_NET_WM_PING)
+item(_NET_WM_PID)
+item(_NET_WORKAREA)
+item(_NET_SHOWING_DESKTOP)
+item(_NET_DESKTOP_LAYOUT)
+item(_NET_DESKTOP_NAMES)
+item(_NET_WM_ALLOWED_ACTIONS)
+item(_NET_WM_ACTION_MOVE)
+item(_NET_WM_ACTION_RESIZE)
+item(_NET_WM_ACTION_SHADE)
+item(_NET_WM_ACTION_STICK)
+item(_NET_WM_ACTION_MAXIMIZE_HORZ)
+item(_NET_WM_ACTION_MAXIMIZE_VERT)
+item(_NET_WM_ACTION_CHANGE_DESKTOP)
+item(_NET_WM_ACTION_CLOSE)
+item(_NET_WM_STATE_ABOVE)
+item(_NET_WM_STATE_BELOW)
+item(_NET_STARTUP_ID)
+item(_NET_WM_STRUT_PARTIAL)
+item(_NET_WM_ACTION_FULLSCREEN)
+item(_NET_WM_ACTION_MINIMIZE)
+item(_NET_FRAME_EXTENTS)
+item(_NET_REQUEST_FRAME_EXTENTS)
+item(_NET_WM_USER_TIME)
+item(_NET_WM_STATE_DEMANDS_ATTENTION)
+item(_NET_MOVERESIZE_WINDOW)
+item(_NET_DESKTOP_GEOMETRY)
+item(_NET_DESKTOP_VIEWPORT)
+item(_NET_WM_USER_TIME_WINDOW)
+item(_NET_WM_ACTION_ABOVE)
+item(_NET_WM_ACTION_BELOW)
+item(_NET_WM_STATE_STICKY)
+item(_NET_WM_FULLSCREEN_MONITORS)
+
+#if 0
+/* We apparently never use: */
+/* item(_NET_RESTACK_WINDOW) */
+#endif
+
+/* eof atomnames.h */
+
diff --git a/src/core/bell.c b/src/core/bell.c
new file mode 100644
index 00000000..560b3569
--- /dev/null
+++ b/src/core/bell.c
@@ -0,0 +1,397 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco visual bell */
+
+/*
+ * Copyright (C) 2002 Sun Microsystems Inc.
+ * Copyright (C) 2005, 2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file bell.c Ring the bell or flash the screen
+ *
+ * Sometimes, X programs "ring the bell", whatever that means. Marco lets
+ * the user configure the bell to be audible or visible (aka visual), and
+ * if it's visual it can be configured to be frame-flash or fullscreen-flash.
+ * We never get told about audible bells; X handles them just fine by itself.
+ *
+ * Visual bells come in at meta_bell_notify(), which checks we are actually
+ * in visual mode and calls through to bell_visual_notify(). That
+ * function then checks what kind of visual flash you like, and calls either
+ * bell_flash_fullscreen()-- which calls bell_flash_screen() to do
+ * its work-- or bell_flash_frame(), which flashes the focussed window
+ * using bell_flash_window_frame(), unless there is no such window, in
+ * which case it flashes the screen instead. bell_flash_window_frame()
+ * flashes the frame and calls bell_unflash_frame() as a timeout to
+ * remove the flash.
+ *
+ * The visual bell was the result of a discussion in Bugzilla here:
+ * <http://bugzilla.gnome.org/show_bug.cgi?id=99886>.
+ *
+ * Several of the functions in this file are ifdeffed out entirely if we are
+ * found not to have the XKB extension, which is required to do these clever
+ * things with bells; some others are entirely no-ops in that case.
+ */
+
+#include <config.h>
+#include "bell.h"
+#include "screen-private.h"
+#include "prefs.h"
+#include <canberra-gtk.h>
+
+/**
+ * Flashes one entire screen.  This is done by making a window the size of the
+ * whole screen (or reusing the old one, if it's still around), mapping it,
+ * painting it white and then black, and then unmapping it. We set saveunder so
+ * that all the windows behind it come back immediately.
+ *
+ * Unlike frame flashes, we don't do fullscreen flashes with a timeout; rather,
+ * we do them in one go, because we don't have to rely on the theme code
+ * redrawing the frame for us in order to do the flash.
+ *
+ * \param display  The display which owns the screen (rather redundant)
+ * \param screen   The screen to flash
+ *
+ * \bug The way I read it, this appears not to do the flash
+ * the first time we flash a particular display. Am I wrong?
+ *
+ * \bug This appears to destroy our current XSync status.
+ */
+static void
+bell_flash_screen (MetaDisplay *display,
+			MetaScreen  *screen)
+{
+  Window root = screen->xroot;
+  int width = screen->rect.width;
+  int height = screen->rect.height;
+
+  if (screen->flash_window == None)
+    {
+      Visual *visual = (Visual *)CopyFromParent;
+      XSetWindowAttributes xswa;
+      int depth = CopyFromParent;
+      xswa.save_under = True;
+      xswa.override_redirect = True;
+      /*
+       * TODO: use XGetVisualInfo and determine which is an
+       * overlay, if one is present, and use the Overlay visual
+       * for this window (for performance reasons).
+       * Not sure how to tell this yet...
+       */
+      screen->flash_window = XCreateWindow (display->xdisplay, root,
+					    0, 0, width, height,
+					    0, depth,
+					    InputOutput,
+					    visual,
+				    /* note: XSun doesn't like SaveUnder here */
+					    CWSaveUnder | CWOverrideRedirect,
+					    &xswa);
+      XSelectInput (display->xdisplay, screen->flash_window, ExposureMask);
+      XMapWindow (display->xdisplay, screen->flash_window);
+      XSync (display->xdisplay, False);
+      XFlush (display->xdisplay);
+      XUnmapWindow (display->xdisplay, screen->flash_window);
+    }
+  else
+    {
+      /* just draw something in the window */
+      GC gc = XCreateGC (display->xdisplay, screen->flash_window, 0, NULL);
+      XMapWindow (display->xdisplay, screen->flash_window);
+      XSetForeground (display->xdisplay, gc,
+		      WhitePixel (display->xdisplay,
+				  XScreenNumberOfScreen (screen->xscreen)));
+      XFillRectangle (display->xdisplay, screen->flash_window, gc,
+		      0, 0, width, height);
+      XSetForeground (display->xdisplay, gc,
+		      BlackPixel (display->xdisplay,
+				  XScreenNumberOfScreen (screen->xscreen)));
+      XFillRectangle (display->xdisplay, screen->flash_window, gc,
+		      0, 0, width, height);
+      XFlush (display->xdisplay);
+      XSync (display->xdisplay, False);
+      XUnmapWindow (display->xdisplay, screen->flash_window);
+      XFreeGC (display->xdisplay, gc);
+    }
+
+  if (meta_prefs_get_focus_mode () != META_FOCUS_MODE_CLICK &&
+      !display->mouse_mode)
+    meta_display_increment_focus_sentinel (display);
+  XFlush (display->xdisplay);
+}
+
+/**
+ * Flashes one screen, or all screens, in response to a bell event.
+ * If the event is on a particular window, flash the screen that
+ * window is on. Otherwise, flash every screen on this display.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param display  The display the event came in on
+ * \param xkb_ev   The bell event
+ */
+#ifdef HAVE_XKB
+static void
+bell_flash_fullscreen (MetaDisplay *display,
+			    XkbAnyEvent *xkb_ev)
+{
+  XkbBellNotifyEvent *xkb_bell_ev = (XkbBellNotifyEvent *) xkb_ev;
+  MetaScreen *screen;
+
+  g_assert (xkb_ev->xkb_type == XkbBellNotify);
+  if (xkb_bell_ev->window != None)
+    {
+      screen = meta_display_screen_for_xwindow (display, xkb_bell_ev->window);
+      if (screen)
+	bell_flash_screen (display, screen);
+    }
+  else
+    {
+      GSList *screen_list = display->screens;
+      while (screen_list)
+	{
+	  screen = (MetaScreen *) screen_list->data;
+	  bell_flash_screen (display, screen);
+	  screen_list = screen_list->next;
+	}
+    }
+}
+
+/**
+ * Makes a frame be not flashed; this is the timeout half of
+ * bell_flash_window_frame(). This is done simply by clearing the
+ * flash flag and queuing a redraw of the frame.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param data  The frame to unflash, cast to a gpointer so it can go into
+ *              a callback function.
+ * \return Always FALSE, so we don't get called again.
+ *
+ * \bug This is the parallel to bell_flash_window_frame(), so it should
+ * really be called meta_bell_unflash_window_frame().
+ */
+static gboolean
+bell_unflash_frame (gpointer data)
+{
+  MetaFrame *frame = (MetaFrame *) data;
+  frame->is_flashing = 0;
+  meta_frame_queue_draw (frame);
+  return FALSE;
+}
+
+/**
+ * Makes a frame flash and then return to normal shortly afterwards.
+ * This is done by setting a flag so that the theme
+ * code will temporarily draw the frame as focussed if it's unfocussed and
+ * vice versa, and then queueing a redraw. Lastly, we create a timeout so
+ * that the flag can be unset and the frame re-redrawn.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param window  The window to flash
+ */
+static void
+bell_flash_window_frame (MetaWindow *window)
+{
+  g_assert (window->frame != NULL);
+  window->frame->is_flashing = 1;
+  meta_frame_queue_draw (window->frame);
+  g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE, 100,
+      bell_unflash_frame, window->frame, NULL);
+}
+
+/**
+ * Flashes the frame of the focussed window. If there is no focussed window,
+ * flashes the screen.
+ *
+ * \param display  The display the bell event came in on
+ * \param xkb_ev   The bell event we just received
+ */
+static void
+bell_flash_frame (MetaDisplay *display,
+		  XkbAnyEvent *xkb_ev)
+{
+  XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent *) xkb_ev;
+  MetaWindow *window;
+
+  g_assert (xkb_ev->xkb_type == XkbBellNotify);
+  window = meta_display_lookup_x_window (display, xkb_bell_event->window);
+  if (!window && (display->focus_window))
+    {
+      window = display->focus_window;
+    }
+  if (window && window->frame)
+    {
+      bell_flash_window_frame (window);
+    }
+  else /* revert to fullscreen flash if there's no focussed window */
+    {
+      bell_flash_fullscreen (display, xkb_ev);
+    }
+}
+
+/**
+ * Gives the user some kind of visual bell substitute, in response to a
+ * bell event. What this is depends on the "visual bell type" pref.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param display  The display the bell event came in on
+ * \param xkb_ev   The bell event we just received
+ *
+ * \bug This should be merged with meta_bell_notify().
+ */
+static void
+bell_visual_notify (MetaDisplay *display,
+			 XkbAnyEvent *xkb_ev)
+{
+  switch (meta_prefs_get_visual_bell_type ())
+    {
+    case META_VISUAL_BELL_FULLSCREEN_FLASH:
+      bell_flash_fullscreen (display, xkb_ev);
+      break;
+    case META_VISUAL_BELL_FRAME_FLASH:
+      bell_flash_frame (display, xkb_ev); /* does nothing yet */
+      break;
+    case META_VISUAL_BELL_INVALID:
+      /* do nothing */
+      break;
+    }
+}
+
+void
+meta_bell_notify (MetaDisplay *display,
+		  XkbAnyEvent *xkb_ev)
+{
+  /* flash something */
+  if (meta_prefs_get_visual_bell ())
+    bell_visual_notify (display, xkb_ev);
+
+  if (meta_prefs_bell_is_audible ())
+    {
+      ca_proplist *p;
+      XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent*) xkb_ev;
+      MetaWindow *window;
+      int res;
+
+      ca_proplist_create (&p);
+      ca_proplist_sets (p, CA_PROP_EVENT_ID, "bell-window-system");
+      ca_proplist_sets (p, CA_PROP_EVENT_DESCRIPTION, _("Bell event"));
+      ca_proplist_sets (p, CA_PROP_CANBERRA_CACHE_CONTROL, "permanent");
+
+      window = meta_display_lookup_x_window (display, xkb_bell_event->window);
+      if (!window && (display->focus_window) && (display->focus_window->frame))
+        window = display->focus_window;
+
+      if (window)
+        {
+          ca_proplist_sets (p, CA_PROP_WINDOW_NAME, window->title);
+          ca_proplist_setf (p, CA_PROP_WINDOW_X11_XID, "%lu", (unsigned long)window->xwindow);
+          ca_proplist_sets (p, CA_PROP_APPLICATION_NAME, window->res_name);
+          ca_proplist_setf (p, CA_PROP_APPLICATION_PROCESS_ID, "%d", window->net_wm_pid);
+        }
+
+      /* First, we try to play a real sound ... */
+      res = ca_context_play_full (ca_gtk_context_get (), 1, p, NULL, NULL);
+
+      ca_proplist_destroy (p);
+
+      if (res != CA_SUCCESS && res != CA_ERROR_DISABLED)
+        {
+          /* ...and in case that failed we use the classic X11 bell. */
+          XkbForceDeviceBell (display->xdisplay,
+                              xkb_bell_event->device,
+                              xkb_bell_event->bell_class,
+                              xkb_bell_event->bell_id,
+                              xkb_bell_event->percent);
+        }
+    }
+}
+#endif /* HAVE_XKB */
+
+void
+meta_bell_set_audible (MetaDisplay *display, gboolean audible)
+{
+}
+
+gboolean
+meta_bell_init (MetaDisplay *display)
+{
+#ifdef HAVE_XKB
+  int xkb_base_error_type, xkb_opcode;
+
+  if (!XkbQueryExtension (display->xdisplay, &xkb_opcode,
+			  &display->xkb_base_event_type,
+			  &xkb_base_error_type,
+			  NULL, NULL))
+    {
+      display->xkb_base_event_type = -1;
+      g_message ("could not find XKB extension.");
+      return FALSE;
+    }
+  else
+    {
+      unsigned int mask = XkbBellNotifyMask;
+      gboolean visual_bell_auto_reset = FALSE;
+      /* TRUE if and when non-broken version is available */
+      XkbSelectEvents (display->xdisplay,
+		       XkbUseCoreKbd,
+		       XkbBellNotifyMask,
+		       XkbBellNotifyMask);
+      XkbChangeEnabledControls (display->xdisplay,
+				XkbUseCoreKbd,
+				XkbAudibleBellMask,
+                                0);
+      if (visual_bell_auto_reset) {
+	XkbSetAutoResetControls (display->xdisplay,
+				 XkbAudibleBellMask,
+				 &mask,
+				 &mask);
+      }
+      return TRUE;
+    }
+#endif
+  return FALSE;
+}
+
+void
+meta_bell_shutdown (MetaDisplay *display)
+{
+#ifdef HAVE_XKB
+  /* TODO: persist initial bell state in display, reset here */
+  XkbChangeEnabledControls (display->xdisplay,
+			    XkbUseCoreKbd,
+			    XkbAudibleBellMask,
+			    XkbAudibleBellMask);
+#endif
+}
+
+/**
+ * Deals with a frame being destroyed. This is important because if we're
+ * using a visual bell, we might be flashing the edges of the frame, and
+ * so we'd have a timeout function waiting ready to un-flash them. If the
+ * frame's going away, we can tell the timeout not to bother.
+ *
+ * \param frame  The frame which is being destroyed
+ */
+void
+meta_bell_notify_frame_destroy (MetaFrame *frame)
+{
+  if (frame->is_flashing)
+    g_source_remove_by_funcs_user_data (&g_timeout_funcs, frame);
+}
diff --git a/src/core/bell.h b/src/core/bell.h
new file mode 100644
index 00000000..95e3ea9e
--- /dev/null
+++ b/src/core/bell.h
@@ -0,0 +1,108 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file bell.h Ring the bell or flash the screen
+ *
+ * Sometimes, X programs "ring the bell", whatever that means. Marco lets
+ * the user configure the bell to be audible or visible (aka visual), and
+ * if it's visual it can be configured to be frame-flash or fullscreen-flash.
+ * We never get told about audible bells; X handles them just fine by itself.
+ *
+ * The visual bell was the result of a discussion in Bugzilla here:
+ * <http://bugzilla.gnome.org/show_bug.cgi?id=99886>.
+ */
+
+/*
+ * Copyright (C) 2002 Sun Microsystems Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <X11/Xlib.h>
+#ifdef HAVE_XKB
+#include <X11/XKBlib.h>
+#endif
+#include "display-private.h"
+#include "frame-private.h"
+
+#ifdef HAVE_XKB
+/**
+ * Gives the user some kind of visual bell; in fact, this is our response
+ * to any kind of bell request, but we set it up so that we only get
+ * notified about visual bells, and X deals with audible ones.
+ *
+ * If the configure script found we had no XKB, this does not exist.
+ *
+ * \param display  The display the bell event came in on
+ * \param xkb_ev   The bell event we just received
+ */
+void meta_bell_notify (MetaDisplay *display, XkbAnyEvent *xkb_ev);
+#endif
+
+/**
+ * Turns the bell to audible or visual. This tells X what to do, but
+ * not Marco; you will need to set the "visual bell" pref for that.
+ *
+ * If the configure script found we had no XKB, this is a no-op.
+ *
+ * \param display  The display we're configuring
+ * \param audible  True for an audible bell, false for a visual bell
+ */
+void meta_bell_set_audible (MetaDisplay *display, gboolean audible);
+
+/**
+ * Initialises the bell subsystem. This involves intialising
+ * XKB (which, despite being a keyboard extension, is the
+ * place to look for bell notifications), then asking it
+ * to send us bell notifications, and then also switching
+ * off the audible bell if we're using a visual one ourselves.
+ *
+ * Unlike most X extensions we use, we only initialise XKB here
+ * (rather than in main()). It's possible that XKB is not
+ * installed at all, but if that was known at build time
+ * we will have HAVE_XKB undefined, which will cause this
+ * function to be a no-op.
+ *
+ * \param display  The display which is opening
+ *
+ * \bug There is a line of code that's never run that tells
+ * XKB to reset the bell status after we quit. Bill H said
+ * (<http://bugzilla.gnome.org/show_bug.cgi?id=99886#c12>)
+ * that XFree86's implementation is broken so we shouldn't
+ * call it, but that was in 2002. Is it working now?
+ */
+gboolean meta_bell_init (MetaDisplay *display);
+
+/**
+ * Shuts down the bell subsystem.
+ *
+ * \param display  The display which is closing
+ *
+ * \bug This is never called! If we had XkbSetAutoResetControls
+ * enabled in meta_bell_init(), this wouldn't be a problem, but
+ * we don't.
+ */
+void meta_bell_shutdown (MetaDisplay *display);
+
+/**
+ * Deals with a frame being destroyed. This is important because if we're
+ * using a visual bell, we might be flashing the edges of the frame, and
+ * so we'd have a timeout function waiting ready to un-flash them. If the
+ * frame's going away, we can tell the timeout not to bother.
+ *
+ * \param frame  The frame which is being destroyed
+ */
+void meta_bell_notify_frame_destroy (MetaFrame *frame);
diff --git a/src/core/boxes.c b/src/core/boxes.c
new file mode 100644
index 00000000..2ae5f06a
--- /dev/null
+++ b/src/core/boxes.c
@@ -0,0 +1,1926 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Simple box operations */
+
+/*
+ * Copyright (C) 2005, 2006 Elijah Newren
+ * [meta_rectangle_intersect() is copyright the GTK+ Team according to Havoc,
+ * see gdkrectangle.c.  As far as Havoc knows, he probably wrote
+ * meta_rectangle_equal(), and I'm guessing it's (C) Red Hat.  So...]
+ * Copyright (C) 1995-2000  GTK+ Team
+ * Copyright (C) 2002 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "boxes.h"
+#include "util.h"
+#include <X11/Xutil.h>  /* Just for the definition of the various gravities */
+
+char*
+meta_rectangle_to_string (const MetaRectangle *rect,
+                          char                *output)
+{
+  /* 25 chars: 2 commas, space, plus, trailing \0 + 5 for each digit.
+   * Should be more than enough space.  Note that of this space, the
+   * trailing \0 will be overwritten for all but the last rectangle.
+   */
+  g_snprintf (output, RECT_LENGTH, "%d,%d +%d,%d",
+              rect->x, rect->y, rect->width, rect->height);
+
+  return output;
+}
+
+char*
+meta_rectangle_region_to_string (GList      *region,
+                                 const char *separator_string,
+                                 char       *output)
+{
+  /* 27 chars: 2 commas, 2 square brackets, space, plus, trailing \0 + 5
+   * for each digit.  Should be more than enough space.  Note that of this
+   * space, the trailing \0 will be overwritten for all but the last
+   * rectangle.
+   */
+  char rect_string[RECT_LENGTH];
+
+  GList *tmp = region;
+  char *cur = output;
+
+  if (region == NULL)
+    g_snprintf (output, 10, "(EMPTY)");
+
+  while (tmp)
+    {
+      MetaRectangle *rect = tmp->data;
+      g_snprintf (rect_string, RECT_LENGTH, "[%d,%d +%d,%d]",
+                  rect->x, rect->y, rect->width, rect->height);
+      cur = g_stpcpy (cur, rect_string);
+      tmp = tmp->next;
+      if (tmp)
+        cur = g_stpcpy (cur, separator_string);
+    }
+
+  return output;
+}
+
+char*
+meta_rectangle_edge_to_string (const MetaEdge *edge,
+                               char           *output)
+{
+  /* 25 chars: 2 commas, space, plus, trailing \0 + 5 for each digit.
+   * Should be more than enough space.  Note that of this space, the
+   * trailing \0 will be overwritten for all but the last rectangle.
+   *
+   * Plus 2 for parenthesis, 4 for 2 more numbers, 2 more commas, and
+   * 2 more spaces, for a total of 10 more.
+   */
+  g_snprintf (output, EDGE_LENGTH, "[%d,%d +%d,%d], %2d, %2d",
+              edge->rect.x, edge->rect.y, edge->rect.width, edge->rect.height,
+              edge->side_type, edge->edge_type);
+
+  return output;
+}
+
+char*
+meta_rectangle_edge_list_to_string (GList      *edge_list,
+                                    const char *separator_string,
+                                    char       *output)
+{
+  /* 27 chars: 2 commas, 2 square brackets, space, plus, trailing \0 + 5 for
+   * each digit.  Should be more than enough space.  Note that of this
+   * space, the trailing \0 will be overwritten for all but the last
+   * rectangle.
+   *
+   * Plus 2 for parenthesis, 4 for 2 more numbers, 2 more commas, and
+   * 2 more spaces, for a total of 10 more.
+   */
+  char rect_string[EDGE_LENGTH];
+
+  char *cur = output;
+  GList *tmp = edge_list;
+
+  if (edge_list == NULL)
+    g_snprintf (output, 10, "(EMPTY)");
+
+  while (tmp)
+    {
+      MetaEdge      *edge = tmp->data;
+      MetaRectangle *rect = &edge->rect;
+      g_snprintf (rect_string, EDGE_LENGTH, "([%d,%d +%d,%d], %2d, %2d)",
+                  rect->x, rect->y, rect->width, rect->height,
+                  edge->side_type, edge->edge_type);
+      cur = g_stpcpy (cur, rect_string);
+      tmp = tmp->next;
+      if (tmp)
+        cur = g_stpcpy (cur, separator_string);
+    }
+
+  return output;
+}
+
+MetaRectangle
+meta_rect (int x, int y, int width, int height)
+{
+  MetaRectangle temporary;
+  temporary.x = x;
+  temporary.y = y;
+  temporary.width  = width;
+  temporary.height = height;
+
+  return temporary;
+}
+
+int
+meta_rectangle_area (const MetaRectangle *rect)
+{
+  g_return_val_if_fail (rect != NULL, 0);
+  return rect->width * rect->height;
+}
+
+gboolean
+meta_rectangle_intersect (const MetaRectangle *src1,
+			  const MetaRectangle *src2,
+			  MetaRectangle *dest)
+{
+  int dest_x, dest_y;
+  int dest_w, dest_h;
+  int return_val;
+
+  g_return_val_if_fail (src1 != NULL, FALSE);
+  g_return_val_if_fail (src2 != NULL, FALSE);
+  g_return_val_if_fail (dest != NULL, FALSE);
+
+  return_val = FALSE;
+
+  dest_x = MAX (src1->x, src2->x);
+  dest_y = MAX (src1->y, src2->y);
+  dest_w = MIN (src1->x + src1->width, src2->x + src2->width) - dest_x;
+  dest_h = MIN (src1->y + src1->height, src2->y + src2->height) - dest_y;
+
+  if (dest_w > 0 && dest_h > 0)
+    {
+      dest->x = dest_x;
+      dest->y = dest_y;
+      dest->width = dest_w;
+      dest->height = dest_h;
+      return_val = TRUE;
+    }
+  else
+    {
+      dest->width = 0;
+      dest->height = 0;
+    }
+
+  return return_val;
+}
+
+gboolean
+meta_rectangle_equal (const MetaRectangle *src1,
+                      const MetaRectangle *src2)
+{
+  return ((src1->x == src2->x) &&
+          (src1->y == src2->y) &&
+          (src1->width == src2->width) &&
+          (src1->height == src2->height));
+}
+
+void
+meta_rectangle_union (const MetaRectangle *rect1,
+                      const MetaRectangle *rect2,
+                      MetaRectangle       *dest)
+{
+  int dest_x, dest_y;
+  int dest_w, dest_h;
+
+  dest_x = rect1->x;
+  dest_y = rect1->y;
+  dest_w = rect1->width;
+  dest_h = rect1->height;
+
+  if (rect2->x < dest_x)
+    {
+      dest_w += dest_x - rect2->x;
+      dest_x = rect2->x;
+    }
+  if (rect2->y < dest_y)
+    {
+      dest_h += dest_y - rect2->y;
+      dest_y = rect2->y;
+    }
+  if (rect2->x + rect2->width > dest_x + dest_w)
+    dest_w = rect2->x + rect2->width - dest_x;
+  if (rect2->y + rect2->height > dest_y + dest_h)
+    dest_h = rect2->y + rect2->height - dest_y;
+
+  dest->x = dest_x;
+  dest->y = dest_y;
+  dest->width = dest_w;
+  dest->height = dest_h;
+}
+
+gboolean
+meta_rectangle_overlap (const MetaRectangle *rect1,
+                        const MetaRectangle *rect2)
+{
+  g_return_val_if_fail (rect1 != NULL, FALSE);
+  g_return_val_if_fail (rect2 != NULL, FALSE);
+
+  return !((rect1->x + rect1->width  <= rect2->x) ||
+           (rect2->x + rect2->width  <= rect1->x) ||
+           (rect1->y + rect1->height <= rect2->y) ||
+           (rect2->y + rect2->height <= rect1->y));
+}
+
+gboolean
+meta_rectangle_vert_overlap (const MetaRectangle *rect1,
+                             const MetaRectangle *rect2)
+{
+  return (rect1->y < rect2->y + rect2->height &&
+          rect2->y < rect1->y + rect1->height);
+}
+
+gboolean
+meta_rectangle_horiz_overlap (const MetaRectangle *rect1,
+                              const MetaRectangle *rect2)
+{
+  return (rect1->x < rect2->x + rect2->width &&
+          rect2->x < rect1->x + rect1->width);
+}
+
+gboolean
+meta_rectangle_could_fit_rect (const MetaRectangle *outer_rect,
+                               const MetaRectangle *inner_rect)
+{
+  return (outer_rect->width  >= inner_rect->width &&
+          outer_rect->height >= inner_rect->height);
+}
+
+gboolean
+meta_rectangle_contains_rect  (const MetaRectangle *outer_rect,
+                               const MetaRectangle *inner_rect)
+{
+  return
+    inner_rect->x                      >= outer_rect->x &&
+    inner_rect->y                      >= outer_rect->y &&
+    inner_rect->x + inner_rect->width  <= outer_rect->x + outer_rect->width &&
+    inner_rect->y + inner_rect->height <= outer_rect->y + outer_rect->height;
+}
+
+void
+meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
+                                    MetaRectangle       *rect,
+                                    int                  gravity,
+                                    int                  new_width,
+                                    int                  new_height)
+{
+  /* FIXME: I'm too deep into this to know whether the below comment is
+   * still clear or not now that I've moved it out of constraints.c.
+   * boxes.h has a good comment, but I'm not sure if the below info is also
+   * helpful on top of that (or whether it has superfluous info).
+   */
+
+  /* These formulas may look overly simplistic at first but you can work
+   * everything out with a left_frame_with, right_frame_width,
+   * border_width, and old and new client area widths (instead of old total
+   * width and new total width) and you come up with the same formulas.
+   *
+   * Also, note that the reason we can treat NorthWestGravity and
+   * StaticGravity the same is because we're not given a location at
+   * which to place the window--the window was already placed
+   * appropriately before.  So, NorthWestGravity for this function
+   * means to just leave the upper left corner of the outer window
+   * where it already is, and StaticGravity for this function means to
+   * just leave the upper left corner of the inner window where it
+   * already is.  But leaving either of those two corners where they
+   * already are will ensure that the other corner is fixed as well
+   * (since frame size doesn't change)--thus making the two
+   * equivalent.
+   */
+
+  /* First, the x direction */
+  int adjust = 0;
+  switch (gravity)
+    {
+    case NorthWestGravity:
+    case WestGravity:
+    case SouthWestGravity:
+      rect->x = old_rect->x;
+      break;
+
+    case NorthGravity:
+    case CenterGravity:
+    case SouthGravity:
+      /* FIXME: Needing to adjust new_width kind of sucks, but not doing so
+       * would cause drift.
+       */
+      new_width -= (old_rect->width - new_width) % 2;
+      rect->x = old_rect->x + (old_rect->width - new_width)/2;
+      break;
+
+    case NorthEastGravity:
+    case EastGravity:
+    case SouthEastGravity:
+      rect->x = old_rect->x + (old_rect->width - new_width);
+      break;
+
+    case StaticGravity:
+    default:
+      rect->x = old_rect->x;
+      break;
+    }
+  rect->width = new_width;
+
+  /* Next, the y direction */
+  adjust = 0;
+  switch (gravity)
+    {
+    case NorthWestGravity:
+    case NorthGravity:
+    case NorthEastGravity:
+      rect->y = old_rect->y;
+      break;
+
+    case WestGravity:
+    case CenterGravity:
+    case EastGravity:
+      /* FIXME: Needing to adjust new_height kind of sucks, but not doing so
+       * would cause drift.
+       */
+      new_height -= (old_rect->height - new_height) % 2;
+      rect->y = old_rect->y + (old_rect->height - new_height)/2;
+      break;
+
+    case SouthWestGravity:
+    case SouthGravity:
+    case SouthEastGravity:
+      rect->y = old_rect->y + (old_rect->height - new_height);
+      break;
+
+    case StaticGravity:
+    default:
+      rect->y = old_rect->y;
+      break;
+    }
+  rect->height = new_height;
+}
+
+/* Not so simple helper function for get_minimal_spanning_set_for_region() */
+static GList*
+merge_spanning_rects_in_region (GList *region)
+{
+  /* NOTE FOR ANY OPTIMIZATION PEOPLE OUT THERE: Please see the
+   * documentation of get_minimal_spanning_set_for_region() for performance
+   * considerations that also apply to this function.
+   */
+
+  GList* compare;
+  compare = region;
+
+  if (region == NULL)
+    {
+      meta_warning ("Region to merge was empty!  Either you have a some "
+                    "pathological STRUT list or there's a bug somewhere!\n");
+      return NULL;
+    }
+
+  while (compare && compare->next)
+    {
+      MetaRectangle *a = compare->data;
+      GList *other = compare->next;
+
+      g_assert (a->width > 0 && a->height > 0);
+
+      while (other)
+        {
+          MetaRectangle *b = other->data;
+          GList *delete_me = NULL;
+
+          g_assert (b->width > 0 && b->height > 0);
+
+          /* If a contains b, just remove b */
+          if (meta_rectangle_contains_rect (a, b))
+            {
+              delete_me = other;
+            }
+          /* If b contains a, just remove a */
+          else if (meta_rectangle_contains_rect (a, b))
+            {
+              delete_me = compare;
+            }
+          /* If a and b might be mergeable horizontally */
+          else if (a->y == b->y && a->height == b->height)
+            {
+              /* If a and b overlap */
+              if (meta_rectangle_overlap (a, b))
+                {
+                  int new_x = MIN (a->x, b->x);
+                  a->width = MAX (a->x + a->width, b->x + b->width) - new_x;
+                  a->x = new_x;
+                  delete_me = other;
+                }
+              /* If a and b are adjacent */
+              else if (a->x + a->width == b->x || a->x == b->x + b->width)
+                {
+                  int new_x = MIN (a->x, b->x);
+                  a->width = MAX (a->x + a->width, b->x + b->width) - new_x;
+                  a->x = new_x;
+                  delete_me = other;
+                }
+            }
+          /* If a and b might be mergeable vertically */
+          else if (a->x == b->x && a->width == b->width)
+            {
+              /* If a and b overlap */
+              if (meta_rectangle_overlap (a, b))
+                {
+                  int new_y = MIN (a->y, b->y);
+                  a->height = MAX (a->y + a->height, b->y + b->height) - new_y;
+                  a->y = new_y;
+                  delete_me = other;
+                }
+              /* If a and b are adjacent */
+              else if (a->y + a->height == b->y || a->y == b->y + b->height)
+                {
+                  int new_y = MIN (a->y, b->y);
+                  a->height = MAX (a->y + a->height, b->y + b->height) - new_y;
+                  a->y = new_y;
+                  delete_me = other;
+                }
+            }
+
+          other = other->next;
+
+          /* Delete any rectangle in the list that is no longer wanted */
+          if (delete_me != NULL)
+            {
+              /* Deleting the rect we compare others to is a little tricker */
+              if (compare == delete_me)
+                {
+                  compare = compare->next;
+                  other = compare->next;
+                  a = compare->data;
+                }
+
+              /* Okay, we can free it now */
+              g_free (delete_me->data);
+              region = g_list_delete_link (region, delete_me);
+            }
+
+        }
+
+      compare = compare->next;
+    }
+
+  return region;
+}
+
+/* Simple helper function for get_minimal_spanning_set_for_region()... */
+static gint
+compare_rect_areas (gconstpointer a, gconstpointer b)
+{
+  const MetaRectangle *a_rect = (gconstpointer) a;
+  const MetaRectangle *b_rect = (gconstpointer) b;
+
+  int a_area = meta_rectangle_area (a_rect);
+  int b_area = meta_rectangle_area (b_rect);
+
+  return b_area - a_area; /* positive ret value denotes b > a, ... */
+}
+
+/* This function is trying to find a "minimal spanning set (of rectangles)"
+ * for a given region.
+ *
+ * The region is given by taking basic_rect, then removing the areas
+ * covered by all the rectangles in the all_struts list, and then expanding
+ * the resulting region by the given number of pixels in each direction.
+ *
+ * A "minimal spanning set (of rectangles)" is the best name I could come
+ * up with for the concept I had in mind.  Basically, for a given region, I
+ * want a set of rectangles with the property that a window is contained in
+ * the region if and only if it is contained within at least one of the
+ * rectangles.
+ *
+ * The GList* returned will be a list of (allocated) MetaRectangles.
+ * The list will need to be freed by calling
+ * meta_rectangle_free_spanning_set() on it (or by manually
+ * implementing that function...)
+ */
+GList*
+meta_rectangle_get_minimal_spanning_set_for_region (
+  const MetaRectangle *basic_rect,
+  const GSList  *all_struts)
+{
+  /* NOTE FOR OPTIMIZERS: This function *might* be somewhat slow,
+   * especially due to the call to merge_spanning_rects_in_region() (which
+   * is O(n^2) where n is the size of the list generated in this function).
+   * This is made more onerous due to the fact that it involves a fair
+   * number of memory allocation and deallocation calls.  However, n is 1
+   * for default installations of Mate (because partial struts aren't used
+   * by default and only partial struts increase the size of the spanning
+   * set generated).  With one partial strut, n will be 2 or 3.  With 2
+   * partial struts, n will probably be 4 or 5.  So, n probably isn't large
+   * enough to make this worth bothering.  Further, it is only called from
+   * workspace.c:ensure_work_areas_validated (at least as of the time of
+   * writing this comment), which in turn should only be called if the
+   * strut list changes or the screen or xinerama size changes.  If it ever
+   * does show up on profiles (most likely because people start using
+   * ridiculously huge numbers of partial struts), possible optimizations
+   * include:
+   *
+   * (1) rewrite merge_spanning_rects_in_region() to be O(n) or O(nlogn).
+   *     I'm not totally sure it's possible, but with a couple copies of
+   *     the list and sorting them appropriately, I believe it might be.
+   * (2) only call merge_spanning_rects_in_region() with a subset of the
+   *     full list of rectangles.  I believe from some of my preliminary
+   *     debugging and thinking about it that it is possible to figure out
+   *     apriori groups of rectangles which are only merge candidates with
+   *     each other.  (See testboxes.c:get_screen_region() when which==2
+   *     and track the steps of this function carefully to see what gave
+   *     me the hint that this might work)
+   * (3) figure out how to avoid merge_spanning_rects_in_region().  I think
+   *     it might be possible to modify this function to make that
+   *     possible, and I spent just a little while thinking about it, but n
+   *     wasn't large enough to convince me to care yet.
+   * (4) Some of the stuff Rob mentioned at http://mail.gnome.org/archives\
+   *     /marco-devel-list/2005-November/msg00028.html.  (Sorry for the
+   *     URL splitting.)
+   */
+
+  GList         *ret;
+  GList         *tmp_list;
+  const GSList  *strut_iter;
+  MetaRectangle *temp_rect;
+
+  /* The algorithm is basically as follows:
+   *   Initialize rectangle_set to basic_rect
+   *   Foreach strut:
+   *     Foreach rectangle in rectangle_set:
+   *       - Split the rectangle into new rectangles that don't overlap the
+   *         strut (but which are as big as possible otherwise)
+   *       - Remove the old (pre-split) rectangle from the rectangle_set,
+   *         and replace it with the new rectangles generated from the
+   *         splitting
+   */
+
+  temp_rect = g_new (MetaRectangle, 1);
+  *temp_rect = *basic_rect;
+  ret = g_list_prepend (NULL, temp_rect);
+
+  strut_iter = all_struts;
+  for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)
+    {
+      GList *rect_iter;
+      MetaRectangle *strut_rect = &((MetaStrut*)strut_iter->data)->rect;
+
+      tmp_list = ret;
+      ret = NULL;
+      rect_iter = tmp_list;
+      while (rect_iter)
+        {
+          MetaRectangle *rect = (MetaRectangle*) rect_iter->data;
+          if (!meta_rectangle_overlap (rect, strut_rect))
+            ret = g_list_prepend (ret, rect);
+          else
+            {
+              /* If there is area in rect left of strut */
+              if (BOX_LEFT (*rect) < BOX_LEFT (*strut_rect))
+                {
+                  temp_rect = g_new (MetaRectangle, 1);
+                  *temp_rect = *rect;
+                  temp_rect->width = BOX_LEFT (*strut_rect) - BOX_LEFT (*rect);
+                  ret = g_list_prepend (ret, temp_rect);
+                }
+              /* If there is area in rect right of strut */
+              if (BOX_RIGHT (*rect) > BOX_RIGHT (*strut_rect))
+                {
+                  int new_x;
+                  temp_rect = g_new (MetaRectangle, 1);
+                  *temp_rect = *rect;
+                  new_x = BOX_RIGHT (*strut_rect);
+                  temp_rect->width = BOX_RIGHT(*rect) - new_x;
+                  temp_rect->x = new_x;
+                  ret = g_list_prepend (ret, temp_rect);
+                }
+              /* If there is area in rect above strut */
+              if (BOX_TOP (*rect) < BOX_TOP (*strut_rect))
+                {
+                  temp_rect = g_new (MetaRectangle, 1);
+                  *temp_rect = *rect;
+                  temp_rect->height = BOX_TOP (*strut_rect) - BOX_TOP (*rect);
+                  ret = g_list_prepend (ret, temp_rect);
+                }
+              /* If there is area in rect below strut */
+              if (BOX_BOTTOM (*rect) > BOX_BOTTOM (*strut_rect))
+                {
+                  int new_y;
+                  temp_rect = g_new (MetaRectangle, 1);
+                  *temp_rect = *rect;
+                  new_y = BOX_BOTTOM (*strut_rect);
+                  temp_rect->height = BOX_BOTTOM (*rect) - new_y;
+                  temp_rect->y = new_y;
+                  ret = g_list_prepend (ret, temp_rect);
+                }
+              g_free (rect);
+            }
+          rect_iter = rect_iter->next;
+        }
+      g_list_free (tmp_list);
+    }
+
+  /* Sort by maximal area, just because I feel like it... */
+  ret = g_list_sort (ret, compare_rect_areas);
+
+  /* Merge rectangles if possible so that the list really is minimal */
+  ret = merge_spanning_rects_in_region (ret);
+
+  return ret;
+}
+
+GList*
+meta_rectangle_expand_region (GList     *region,
+                              const int  left_expand,
+                              const int  right_expand,
+                              const int  top_expand,
+                              const int  bottom_expand)
+{
+  return meta_rectangle_expand_region_conditionally (region,
+                                                     left_expand,
+                                                     right_expand,
+                                                     top_expand,
+                                                     bottom_expand,
+                                                     0,
+                                                     0);
+}
+
+GList*
+meta_rectangle_expand_region_conditionally (GList     *region,
+                                            const int  left_expand,
+                                            const int  right_expand,
+                                            const int  top_expand,
+                                            const int  bottom_expand,
+                                            const int  min_x,
+                                            const int  min_y)
+{
+  GList *tmp_list = region;
+  while (tmp_list)
+    {
+      MetaRectangle *rect = (MetaRectangle*) tmp_list->data;
+      if (rect->width >= min_x)
+        {
+          rect->x      -= left_expand;
+          rect->width  += (left_expand + right_expand);
+        }
+      if (rect->height >= min_y)
+        {
+          rect->y      -= top_expand;
+          rect->height += (top_expand + bottom_expand);
+        }
+      tmp_list = tmp_list->next;
+    }
+
+  return region;
+}
+
+void
+meta_rectangle_expand_to_avoiding_struts (MetaRectangle       *rect,
+                                          const MetaRectangle *expand_to,
+                                          const MetaDirection  direction,
+                                          const GSList        *all_struts)
+{
+  const GSList *strut_iter;
+
+  /* If someone wants this function to handle more fine-grained
+   * direction expanding in the future (e.g. only left, or fully
+   * horizontal plus upward), feel free.  But I'm hard-coding for both
+   * horizontal directions (exclusive-)or both vertical directions.
+   */
+  g_assert ((direction == META_DIRECTION_HORIZONTAL) ^
+            (direction == META_DIRECTION_VERTICAL  ));
+
+  if (direction == META_DIRECTION_HORIZONTAL)
+    {
+      rect->x      = expand_to->x;
+      rect->width  = expand_to->width;
+    }
+  else
+    {
+      rect->y      = expand_to->y;
+      rect->height = expand_to->height;
+    }
+
+
+  /* Run over all struts */
+  for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)
+    {
+      MetaStrut *strut = (MetaStrut*) strut_iter->data;
+
+      /* Skip struts that don't overlap */
+      if (!meta_rectangle_overlap (&strut->rect, rect))
+        continue;
+
+      if (direction == META_DIRECTION_HORIZONTAL)
+        {
+          if (strut->side == META_SIDE_LEFT)
+            {
+              int offset = BOX_RIGHT(strut->rect) - BOX_LEFT(*rect);
+              rect->x     += offset;
+              rect->width -= offset;
+            }
+          else if (strut->side == META_SIDE_RIGHT)
+            {
+              int offset = BOX_RIGHT (*rect) - BOX_LEFT(strut->rect);
+              rect->width -= offset;
+            }
+          /* else ignore the strut */
+        }
+      else /* direction == META_DIRECTION_VERTICAL */
+        {
+          if (strut->side == META_SIDE_TOP)
+            {
+              int offset = BOX_BOTTOM(strut->rect) - BOX_TOP(*rect);
+              rect->y      += offset;
+              rect->height -= offset;
+            }
+          else if (strut->side == META_SIDE_BOTTOM)
+            {
+              int offset = BOX_BOTTOM(*rect) - BOX_TOP(strut->rect);
+              rect->height -= offset;
+            }
+          /* else ignore the strut */
+        }
+    } /* end loop over struts */
+} /* end meta_rectangle_expand_to_avoiding_struts */
+
+void
+meta_rectangle_free_list_and_elements (GList *filled_list)
+{
+  g_list_foreach (filled_list,
+                  (void (*)(gpointer,gpointer))&g_free, /* ew, for ugly */
+                  NULL);
+  g_list_free (filled_list);
+}
+
+gboolean
+meta_rectangle_could_fit_in_region (const GList         *spanning_rects,
+                                    const MetaRectangle *rect)
+{
+  const GList *temp;
+  gboolean     could_fit;
+
+  temp = spanning_rects;
+  could_fit = FALSE;
+  while (!could_fit && temp != NULL)
+    {
+      could_fit = could_fit || meta_rectangle_could_fit_rect (temp->data, rect);
+      temp = temp->next;
+    }
+
+  return could_fit;
+}
+
+gboolean
+meta_rectangle_contained_in_region (const GList         *spanning_rects,
+                                    const MetaRectangle *rect)
+{
+  const GList *temp;
+  gboolean     contained;
+
+  temp = spanning_rects;
+  contained = FALSE;
+  while (!contained && temp != NULL)
+    {
+      contained = contained || meta_rectangle_contains_rect (temp->data, rect);
+      temp = temp->next;
+    }
+
+  return contained;
+}
+
+gboolean
+meta_rectangle_overlaps_with_region (const GList         *spanning_rects,
+                                     const MetaRectangle *rect)
+{
+  const GList *temp;
+  gboolean     overlaps;
+
+  temp = spanning_rects;
+  overlaps = FALSE;
+  while (!overlaps && temp != NULL)
+    {
+      overlaps = overlaps || meta_rectangle_overlap (temp->data, rect);
+      temp = temp->next;
+    }
+
+  return overlaps;
+}
+
+
+void
+meta_rectangle_clamp_to_fit_into_region (const GList         *spanning_rects,
+                                         FixedDirections      fixed_directions,
+                                         MetaRectangle       *rect,
+                                         const MetaRectangle *min_size)
+{
+  const GList *temp;
+  const MetaRectangle *best_rect = NULL;
+  int                  best_overlap = 0;
+
+  /* First, find best rectangle from spanning_rects to which we can clamp
+   * rect to fit into.
+   */
+  for (temp = spanning_rects; temp; temp = temp->next)
+    {
+      MetaRectangle *compare_rect = temp->data;
+      int            maximal_overlap_amount_for_compare;
+
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip this rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_X) &&
+          (compare_rect->x > rect->x ||
+           compare_rect->x + compare_rect->width < rect->x + rect->width))
+        continue;
+
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip this rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_Y) &&
+          (compare_rect->y > rect->y ||
+           compare_rect->y + compare_rect->height < rect->y + rect->height))
+        continue;
+
+      /* If compare can't hold the min_size window, skip this rectangle. */
+      if (compare_rect->width  < min_size->width ||
+          compare_rect->height < min_size->height)
+        continue;
+
+      /* Determine maximal overlap amount */
+      maximal_overlap_amount_for_compare =
+        MIN (rect->width,  compare_rect->width) *
+        MIN (rect->height, compare_rect->height);
+
+      /* See if this is the best rect so far */
+      if (maximal_overlap_amount_for_compare > best_overlap)
+        {
+          best_rect    = compare_rect;
+          best_overlap = maximal_overlap_amount_for_compare;
+        }
+    }
+
+  /* Clamp rect appropriately */
+  if (best_rect == NULL)
+    {
+      meta_warning ("No rect whose size to clamp to found!\n");
+
+      /* If it doesn't fit, at least make it no bigger than it has to be */
+      if (!(fixed_directions & FIXED_DIRECTION_X))
+        rect->width  = min_size->width;
+      if (!(fixed_directions & FIXED_DIRECTION_Y))
+        rect->height = min_size->height;
+    }
+  else
+    {
+      rect->width  = MIN (rect->width,  best_rect->width);
+      rect->height = MIN (rect->height, best_rect->height);
+    }
+}
+
+void
+meta_rectangle_clip_to_region (const GList         *spanning_rects,
+                               FixedDirections      fixed_directions,
+                               MetaRectangle       *rect)
+{
+  const GList *temp;
+  const MetaRectangle *best_rect = NULL;
+  int                  best_overlap = 0;
+
+  /* First, find best rectangle from spanning_rects to which we will clip
+   * rect into.
+   */
+  for (temp = spanning_rects; temp; temp = temp->next)
+    {
+      MetaRectangle *compare_rect = temp->data;
+      MetaRectangle  overlap;
+      int            maximal_overlap_amount_for_compare;
+
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip the rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_X) &&
+          (compare_rect->x > rect->x ||
+           compare_rect->x + compare_rect->width < rect->x + rect->width))
+        continue;
+
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip the rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_Y) &&
+          (compare_rect->y > rect->y ||
+           compare_rect->y + compare_rect->height < rect->y + rect->height))
+        continue;
+
+      /* Determine maximal overlap amount */
+      meta_rectangle_intersect (rect, compare_rect, &overlap);
+      maximal_overlap_amount_for_compare = meta_rectangle_area (&overlap);
+
+      /* See if this is the best rect so far */
+      if (maximal_overlap_amount_for_compare > best_overlap)
+        {
+          best_rect    = compare_rect;
+          best_overlap = maximal_overlap_amount_for_compare;
+        }
+    }
+
+  /* Clip rect appropriately */
+  if (best_rect == NULL)
+    meta_warning ("No rect to clip to found!\n");
+  else
+    {
+      /* Extra precaution with checking fixed direction shouldn't be needed
+       * due to logic above, but it shouldn't hurt either.
+       */
+      if (!(fixed_directions & FIXED_DIRECTION_X))
+        {
+          /* Find the new left and right */
+          int new_x = MAX (rect->x, best_rect->x);
+          rect->width = MIN ((rect->x + rect->width)           - new_x,
+                             (best_rect->x + best_rect->width) - new_x);
+          rect->x = new_x;
+        }
+
+      /* Extra precaution with checking fixed direction shouldn't be needed
+       * due to logic above, but it shouldn't hurt either.
+       */
+      if (!(fixed_directions & FIXED_DIRECTION_Y))
+        {
+          /* Clip the top, if needed */
+          int new_y = MAX (rect->y, best_rect->y);
+          rect->height = MIN ((rect->y + rect->height)           - new_y,
+                              (best_rect->y + best_rect->height) - new_y);
+          rect->y = new_y;
+        }
+    }
+}
+
+void
+meta_rectangle_shove_into_region (const GList         *spanning_rects,
+                                  FixedDirections      fixed_directions,
+                                  MetaRectangle       *rect)
+{
+  const GList *temp;
+  const MetaRectangle *best_rect = NULL;
+  int                  best_overlap = 0;
+  int                  shortest_distance = G_MAXINT;
+
+  /* First, find best rectangle from spanning_rects to which we will shove
+   * rect into.
+   */
+
+  for (temp = spanning_rects; temp; temp = temp->next)
+    {
+      MetaRectangle *compare_rect = temp->data;
+      int            maximal_overlap_amount_for_compare;
+      int            dist_to_compare;
+
+      /* If x is fixed and the entire width of rect doesn't fit in compare,
+       * skip this rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_X) &&
+          (compare_rect->x > rect->x ||
+           compare_rect->x + compare_rect->width < rect->x + rect->width))
+        continue;
+
+      /* If y is fixed and the entire height of rect doesn't fit in compare,
+       * skip this rectangle.
+       */
+      if ((fixed_directions & FIXED_DIRECTION_Y) &&
+          (compare_rect->y > rect->y ||
+           compare_rect->y + compare_rect->height < rect->y + rect->height))
+        continue;
+
+      /* Determine maximal overlap amount between rect & compare_rect */
+      maximal_overlap_amount_for_compare =
+        MIN (rect->width,  compare_rect->width) *
+        MIN (rect->height, compare_rect->height);
+
+      /* Determine distance necessary to put rect into compare_rect */
+      dist_to_compare = 0;
+      if (compare_rect->x > rect->x)
+        dist_to_compare += compare_rect->x - rect->x;
+      if (compare_rect->x + compare_rect->width < rect->x + rect->width)
+        dist_to_compare += (rect->x + rect->width) -
+                           (compare_rect->x + compare_rect->width);
+      if (compare_rect->y > rect->y)
+        dist_to_compare += compare_rect->y - rect->y;
+      if (compare_rect->y + compare_rect->height < rect->y + rect->height)
+        dist_to_compare += (rect->y + rect->height) -
+                           (compare_rect->y + compare_rect->height);
+
+      /* See if this is the best rect so far */
+      if ((maximal_overlap_amount_for_compare > best_overlap) ||
+          (maximal_overlap_amount_for_compare == best_overlap &&
+           dist_to_compare                    <  shortest_distance))
+        {
+          best_rect         = compare_rect;
+          best_overlap      = maximal_overlap_amount_for_compare;
+          shortest_distance = dist_to_compare;
+        }
+    }
+
+  /* Shove rect appropriately */
+  if (best_rect == NULL)
+    meta_warning ("No rect to shove into found!\n");
+  else
+    {
+      /* Extra precaution with checking fixed direction shouldn't be needed
+       * due to logic above, but it shouldn't hurt either.
+       */
+      if (!(fixed_directions & FIXED_DIRECTION_X))
+        {
+          /* Shove to the right, if needed */
+          if (best_rect->x > rect->x)
+            rect->x = best_rect->x;
+
+          /* Shove to the left, if needed */
+          if (best_rect->x + best_rect->width < rect->x + rect->width)
+            rect->x = (best_rect->x + best_rect->width) - rect->width;
+        }
+
+      /* Extra precaution with checking fixed direction shouldn't be needed
+       * due to logic above, but it shouldn't hurt either.
+       */
+      if (!(fixed_directions & FIXED_DIRECTION_Y))
+        {
+          /* Shove down, if needed */
+          if (best_rect->y > rect->y)
+            rect->y = best_rect->y;
+
+          /* Shove up, if needed */
+          if (best_rect->y + best_rect->height < rect->y + rect->height)
+            rect->y = (best_rect->y + best_rect->height) - rect->height;
+        }
+    }
+}
+
+void
+meta_rectangle_find_linepoint_closest_to_point (double x1,
+                                                double y1,
+                                                double x2,
+                                                double y2,
+                                                double px,
+                                                double py,
+                                                double *valx,
+                                                double *valy)
+{
+  /* I'll use the shorthand rx, ry for the return values, valx & valy.
+   * Now, we need (rx,ry) to be on the line between (x1,y1) and (x2,y2).
+   * For that to happen, we first need the slope of the line from (x1,y1)
+   * to (rx,ry) must match the slope of (x1,y1) to (x2,y2), i.e.:
+   *   (ry-y1)   (y2-y1)
+   *   ------- = -------
+   *   (rx-x1)   (x2-x1)
+   * If x1==x2, though, this gives divide by zero errors, so we want to
+   * rewrite the equation by multiplying both sides by (rx-x1)*(x2-x1):
+   *   (ry-y1)(x2-x1) = (y2-y1)(rx-x1)
+   * This is a valid requirement even when x1==x2 (when x1==x2, this latter
+   * equation will basically just mean that rx must be equal to both x1 and
+   * x2)
+   *
+   * The other requirement that we have is that the line from (rx,ry) to
+   * (px,py) must be perpendicular to the line from (x1,y1) to (x2,y2).  So
+   * we just need to get a vector in the direction of each line, take the
+   * dot product of the two, and ensure that the result is 0:
+   *   (rx-px)*(x2-x1) + (ry-py)*(y2-y1) = 0.
+   *
+   * This gives us two equations and two unknowns:
+   *
+   *   (ry-y1)(x2-x1) = (y2-y1)(rx-x1)
+   *   (rx-px)*(x2-x1) + (ry-py)*(y2-y1) = 0.
+   *
+   * This particular pair of equations is always solvable so long as
+   * (x1,y1) and (x2,y2) are not the same point (and note that anyone who
+   * calls this function that way is braindead because it means that they
+   * really didn't specify a line after all).  However, the caller should
+   * be careful to avoid making (x1,y1) and (x2,y2) too close (e.g. like
+   * 10^{-8} apart in each coordinate), otherwise roundoff error could
+   * cause issues.  Solving these equations by hand (or using Maple(TM) or
+   * Mathematica(TM) or whatever) results in slightly messy expressions,
+   * but that's all the below few lines do.
+   */
+
+  double diffx, diffy, den;
+  diffx = x2 - x1;
+  diffy = y2 - y1;
+  den = diffx * diffx + diffy * diffy;
+
+  *valx = (py * diffx * diffy + px * diffx * diffx +
+           y2 * x1 * diffy - y1 * x2 * diffy) / den;
+  *valy = (px * diffx * diffy + py * diffy * diffy +
+           x2 * y1 * diffx - x1 * y2 * diffx) / den;
+}
+
+/***************************************************************************/
+/*                                                                         */
+/* Switching gears to code for edges instead of just rectangles            */
+/*                                                                         */
+/***************************************************************************/
+
+gboolean
+meta_rectangle_edge_aligns (const MetaRectangle *rect, const MetaEdge *edge)
+{
+  /* The reason for the usage of <= below instead of < is because we are
+   * interested in in-the-way-or-adject'ness.  So, a left (i.e. vertical
+   * edge) occupying y positions 0-9 (which has a y of 0 and a height of
+   * 10) and a rectangle with top at y=10 would be considered to "align" by
+   * this function.
+   */
+  switch (edge->side_type)
+    {
+    case META_SIDE_LEFT:
+    case META_SIDE_RIGHT:
+      return BOX_TOP (*rect)      <= BOX_BOTTOM (edge->rect) &&
+             BOX_TOP (edge->rect) <= BOX_BOTTOM (*rect);
+    case META_SIDE_TOP:
+    case META_SIDE_BOTTOM:
+      return BOX_LEFT (*rect)      <= BOX_RIGHT (edge->rect) &&
+             BOX_LEFT (edge->rect) <= BOX_RIGHT (*rect);
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+static GList*
+get_rect_minus_overlap (const GList   *rect_in_list,
+                        MetaRectangle *overlap)
+{
+  MetaRectangle *temp;
+  MetaRectangle *rect = rect_in_list->data;
+  GList *ret = NULL;
+
+  if (BOX_LEFT (*rect) < BOX_LEFT (*overlap))
+    {
+      temp = g_new (MetaRectangle, 1);
+      *temp = *rect;
+      temp->width = BOX_LEFT (*overlap) - BOX_LEFT (*rect);
+      ret = g_list_prepend (ret, temp);
+    }
+  if (BOX_RIGHT (*rect) > BOX_RIGHT (*overlap))
+    {
+      temp = g_new (MetaRectangle, 1);
+      *temp = *rect;
+      temp->x = BOX_RIGHT (*overlap);
+      temp->width = BOX_RIGHT (*rect) - BOX_RIGHT (*overlap);
+      ret = g_list_prepend (ret, temp);
+    }
+  if (BOX_TOP (*rect) < BOX_TOP (*overlap))
+    {
+      temp = g_new (MetaRectangle, 1);
+      temp->x      = overlap->x;
+      temp->width  = overlap->width;
+      temp->y      = BOX_TOP (*rect);
+      temp->height = BOX_TOP (*overlap) - BOX_TOP (*rect);
+      ret = g_list_prepend (ret, temp);
+    }
+  if (BOX_BOTTOM (*rect) > BOX_BOTTOM (*overlap))
+    {
+      temp = g_new (MetaRectangle, 1);
+      temp->x      = overlap->x;
+      temp->width  = overlap->width;
+      temp->y      = BOX_BOTTOM (*overlap);
+      temp->height = BOX_BOTTOM (*rect) - BOX_BOTTOM (*overlap);
+      ret = g_list_prepend (ret, temp);
+    }
+
+  return ret;
+}
+
+static GList*
+replace_rect_with_list (GList *old_element,
+                        GList *new_list)
+{
+  GList *ret;
+  g_assert (old_element != NULL);
+
+  if (!new_list)
+    {
+      /* If there is no new list, just remove the old_element */
+      ret = g_list_remove_link (old_element, old_element);
+    }
+  else
+    {
+      /* Fix up the prev and next pointers everywhere */
+      ret = new_list;
+      if (old_element->prev)
+        {
+          old_element->prev->next = new_list;
+          new_list->prev = old_element->prev;
+        }
+      if (old_element->next)
+        {
+          GList *tmp = g_list_last (new_list);
+          old_element->next->prev = tmp;
+          tmp->next = old_element->next;
+        }
+    }
+
+  /* Free the old_element and return the appropriate "next" point */
+  g_free (old_element->data);
+  g_list_free_1 (old_element);
+  return ret;
+}
+
+/* Make a copy of the strut list, make sure that copy only contains parts
+ * of the old_struts that intersect with the region rect, and then do some
+ * magic to make all the new struts disjoint (okay, we we break up struts
+ * that aren't disjoint in a way that the overlapping part is only included
+ * once, so it's not really magic...).
+ */
+static GList*
+get_disjoint_strut_rect_list_in_region (const GSList        *old_struts,
+                                        const MetaRectangle *region)
+{
+  GList *strut_rects;
+  GList *tmp;
+
+  /* First, copy the list */
+  strut_rects = NULL;
+  while (old_struts)
+    {
+      MetaRectangle *cur = &((MetaStrut*)old_struts->data)->rect;
+      MetaRectangle *copy = g_new (MetaRectangle, 1);
+      *copy = *cur;
+      if (meta_rectangle_intersect (copy, region, copy))
+        strut_rects = g_list_prepend (strut_rects, copy);
+      else
+        g_free (copy);
+
+      old_struts = old_struts->next;
+    }
+
+  /* Now, loop over the list and check for intersections, fixing things up
+   * where they do intersect.
+   */
+  tmp = strut_rects;
+  while (tmp)
+    {
+      GList *compare;
+
+      MetaRectangle *cur = tmp->data;
+
+      compare = tmp->next;
+      while (compare)
+        {
+          MetaRectangle *comp = compare->data;
+          MetaRectangle overlap;
+
+          if (meta_rectangle_intersect (cur, comp, &overlap))
+            {
+              /* Get a list of rectangles for each strut that don't overlap
+               * the intersection region.
+               */
+              GList *cur_leftover  = get_rect_minus_overlap (tmp,  &overlap);
+              GList *comp_leftover = get_rect_minus_overlap (compare, &overlap);
+
+              /* Add the intersection region to cur_leftover */
+              MetaRectangle *overlap_allocated = g_new (MetaRectangle, 1);
+              *overlap_allocated = overlap;
+              cur_leftover = g_list_prepend (cur_leftover, overlap_allocated);
+
+              /* Fix up tmp, compare, and cur -- maybe struts too */
+              if (strut_rects == tmp)
+                {
+                  strut_rects = replace_rect_with_list (tmp, cur_leftover);
+                  tmp = strut_rects;
+                }
+              else
+                tmp   = replace_rect_with_list (tmp,     cur_leftover);
+              compare = replace_rect_with_list (compare, comp_leftover);
+
+              if (compare == NULL)
+                break;
+
+              cur = tmp->data;
+            }
+
+          compare = compare->next;
+        }
+
+      tmp = tmp->next;
+    }
+
+  return strut_rects;
+}
+
+gint
+meta_rectangle_edge_cmp_ignore_type (gconstpointer a, gconstpointer b)
+{
+  const MetaEdge *a_edge_rect = (gconstpointer) a;
+  const MetaEdge *b_edge_rect = (gconstpointer) b;
+  int a_compare, b_compare;
+
+  /* Edges must be both vertical or both horizontal, or it doesn't make
+   * sense to compare them.
+   */
+  g_assert ((a_edge_rect->rect.width  == 0 && b_edge_rect->rect.width == 0) ||
+            (a_edge_rect->rect.height == 0 && b_edge_rect->rect.height == 0));
+
+  a_compare = b_compare = 0;  /* gcc-3.4.2 sucks at figuring initialized'ness */
+
+  if (a_edge_rect->side_type == META_SIDE_LEFT ||
+      a_edge_rect->side_type == META_SIDE_RIGHT)
+    {
+      a_compare = a_edge_rect->rect.x;
+      b_compare = b_edge_rect->rect.x;
+      if (a_compare == b_compare)
+        {
+          a_compare = a_edge_rect->rect.y;
+          b_compare = b_edge_rect->rect.y;
+        }
+    }
+  else if (a_edge_rect->side_type == META_SIDE_TOP ||
+           a_edge_rect->side_type == META_SIDE_BOTTOM)
+    {
+      a_compare = a_edge_rect->rect.y;
+      b_compare = b_edge_rect->rect.y;
+      if (a_compare == b_compare)
+        {
+          a_compare = a_edge_rect->rect.x;
+          b_compare = b_edge_rect->rect.x;
+        }
+    }
+  else
+    g_assert ("Some idiot wanted to sort sides of different types.\n");
+
+  return a_compare - b_compare; /* positive value denotes a > b ... */
+}
+
+/* To make things easily testable, provide a nice way of sorting edges */
+gint
+meta_rectangle_edge_cmp (gconstpointer a, gconstpointer b)
+{
+  const MetaEdge *a_edge_rect = (gconstpointer) a;
+  const MetaEdge *b_edge_rect = (gconstpointer) b;
+
+  int a_compare, b_compare;
+
+  a_compare = a_edge_rect->side_type;
+  b_compare = b_edge_rect->side_type;
+
+  if (a_compare == b_compare)
+    return meta_rectangle_edge_cmp_ignore_type (a, b);
+
+  return a_compare - b_compare; /* positive value denotes a > b ... */
+}
+
+/* Determine whether two given edges overlap */
+static gboolean
+edges_overlap (const MetaEdge *edge1,
+               const MetaEdge *edge2)
+{
+  if (edge1->rect.width == 0 && edge2->rect.width == 0)
+    {
+      return meta_rectangle_vert_overlap (&edge1->rect, &edge2->rect) &&
+             edge1->rect.x == edge2->rect.x;
+    }
+  else if (edge1->rect.height == 0 && edge2->rect.height == 0)
+    {
+      return meta_rectangle_horiz_overlap (&edge1->rect, &edge2->rect) &&
+             edge1->rect.y == edge2->rect.y;
+    }
+  else
+    {
+      return FALSE;
+    }
+}
+
+static gboolean
+rectangle_and_edge_intersection (const MetaRectangle *rect,
+                                 const MetaEdge      *edge,
+                                 MetaEdge            *overlap,
+                                 int                 *handle_type)
+{
+  const MetaRectangle *rect2  = &edge->rect;
+  MetaRectangle *result = &overlap->rect;
+  gboolean intersect = TRUE;
+
+  /* We don't know how to set these, so set them to invalid values */
+  overlap->edge_type = -1;
+  overlap->side_type = -1;
+
+  /* Figure out what the intersection is */
+  result->x = MAX (rect->x, rect2->x);
+  result->y = MAX (rect->y, rect2->y);
+  result->width  = MIN (BOX_RIGHT (*rect),  BOX_RIGHT (*rect2))  - result->x;
+  result->height = MIN (BOX_BOTTOM (*rect), BOX_BOTTOM (*rect2)) - result->y;
+
+  /* Find out if the intersection is empty; have to do it this way since
+   * edges have a thickness of 0
+   */
+  if ((result->width <  0 || result->height <  0) ||
+      (result->width == 0 && result->height == 0))
+    {
+      result->width = 0;
+      result->height = 0;
+      intersect = FALSE;
+    }
+  else
+    {
+      /* Need to figure out the handle_type, a somewhat weird quantity:
+       *   0 - overlap is in middle of rect
+       *  -1 - overlap is at the side of rect, and is on the opposite side
+       *       of rect than the edge->side_type side
+       *   1 - overlap is at the side of rect, and the side of rect it is
+       *       on is the edge->side_type side
+       */
+      switch (edge->side_type)
+        {
+        case META_SIDE_LEFT:
+          if (result->x == rect->x)
+            *handle_type = 1;
+          else if (result->x == BOX_RIGHT (*rect))
+            *handle_type = -1;
+          else
+            *handle_type = 0;
+          break;
+        case META_SIDE_RIGHT:
+          if (result->x == rect->x)
+            *handle_type = -1;
+          else if (result->x == BOX_RIGHT (*rect))
+            *handle_type = 1;
+          else
+            *handle_type = 0;
+          break;
+        case META_SIDE_TOP:
+          if (result->y == rect->y)
+            *handle_type = 1;
+          else if (result->y == BOX_BOTTOM (*rect))
+            *handle_type = -1;
+          else
+            *handle_type = 0;
+          break;
+        case META_SIDE_BOTTOM:
+          if (result->y == rect->y)
+            *handle_type = -1;
+          else if (result->y == BOX_BOTTOM (*rect))
+            *handle_type = 1;
+          else
+            *handle_type = 0;
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+    }
+  return intersect;
+}
+
+/* Add all edges of the given rect to cur_edges and return the result.  If
+ * rect_is_internal is false, the side types are switched (LEFT<->RIGHT and
+ * TOP<->BOTTOM).
+ */
+static GList*
+add_edges (GList               *cur_edges,
+           const MetaRectangle *rect,
+           gboolean             rect_is_internal)
+{
+  MetaEdge *temp_edge;
+  int i;
+
+  for (i=0; i<4; i++)
+    {
+      temp_edge = g_new (MetaEdge, 1);
+      temp_edge->rect = *rect;
+      switch (i)
+        {
+        case 0:
+          temp_edge->side_type =
+            rect_is_internal ? META_SIDE_LEFT : META_SIDE_RIGHT;
+          temp_edge->rect.width = 0;
+          break;
+        case 1:
+          temp_edge->side_type =
+            rect_is_internal ? META_SIDE_RIGHT : META_SIDE_LEFT;
+          temp_edge->rect.x     += temp_edge->rect.width;
+          temp_edge->rect.width  = 0;
+          break;
+        case 2:
+          temp_edge->side_type =
+            rect_is_internal ? META_SIDE_TOP : META_SIDE_BOTTOM;
+          temp_edge->rect.height = 0;
+          break;
+        case 3:
+          temp_edge->side_type =
+            rect_is_internal ? META_SIDE_BOTTOM : META_SIDE_TOP;
+          temp_edge->rect.y      += temp_edge->rect.height;
+          temp_edge->rect.height  = 0;
+          break;
+        }
+      temp_edge->edge_type = META_EDGE_SCREEN;
+      cur_edges = g_list_prepend (cur_edges, temp_edge);
+    }
+
+  return cur_edges;
+}
+
+/* Remove any part of old_edge that intersects remove and add any resulting
+ * edges to cur_list.  Return cur_list when finished.
+ */
+static GList*
+split_edge (GList *cur_list,
+            const MetaEdge *old_edge,
+            const MetaEdge *remove)
+{
+  MetaEdge *temp_edge;
+  switch (old_edge->side_type)
+    {
+    case META_SIDE_LEFT:
+    case META_SIDE_RIGHT:
+      g_assert (meta_rectangle_vert_overlap (&old_edge->rect, &remove->rect));
+      if (BOX_TOP (old_edge->rect)  < BOX_TOP (remove->rect))
+        {
+          temp_edge = g_new (MetaEdge, 1);
+          *temp_edge = *old_edge;
+          temp_edge->rect.height = BOX_TOP (remove->rect)
+                                 - BOX_TOP (old_edge->rect);
+          cur_list = g_list_prepend (cur_list, temp_edge);
+        }
+      if (BOX_BOTTOM (old_edge->rect) > BOX_BOTTOM (remove->rect))
+        {
+          temp_edge = g_new (MetaEdge, 1);
+          *temp_edge = *old_edge;
+          temp_edge->rect.y      = BOX_BOTTOM (remove->rect);
+          temp_edge->rect.height = BOX_BOTTOM (old_edge->rect)
+                                 - BOX_BOTTOM (remove->rect);
+          cur_list = g_list_prepend (cur_list, temp_edge);
+        }
+      break;
+    case META_SIDE_TOP:
+    case META_SIDE_BOTTOM:
+      g_assert (meta_rectangle_horiz_overlap (&old_edge->rect, &remove->rect));
+      if (BOX_LEFT (old_edge->rect)  < BOX_LEFT (remove->rect))
+        {
+          temp_edge = g_new (MetaEdge, 1);
+          *temp_edge = *old_edge;
+          temp_edge->rect.width = BOX_LEFT (remove->rect)
+                                - BOX_LEFT (old_edge->rect);
+          cur_list = g_list_prepend (cur_list, temp_edge);
+        }
+      if (BOX_RIGHT (old_edge->rect) > BOX_RIGHT (remove->rect))
+        {
+          temp_edge = g_new (MetaEdge, 1);
+          *temp_edge = *old_edge;
+          temp_edge->rect.x     = BOX_RIGHT (remove->rect);
+          temp_edge->rect.width = BOX_RIGHT (old_edge->rect)
+                                - BOX_RIGHT (remove->rect);
+          cur_list = g_list_prepend (cur_list, temp_edge);
+        }
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+
+  return cur_list;
+}
+
+/* Split up edge and remove preliminary edges from strut_edges depending on
+ * if and how rect and edge intersect.
+ */
+static void
+fix_up_edges (MetaRectangle *rect,         MetaEdge *edge,
+              GList         **strut_edges, GList    **edge_splits,
+              gboolean      *edge_needs_removal)
+{
+  MetaEdge overlap;
+  int      handle_type;
+
+  if (!rectangle_and_edge_intersection (rect, edge, &overlap, &handle_type))
+    return;
+
+  if (handle_type == 0 || handle_type == 1)
+    {
+      /* Put the result of removing overlap from edge into edge_splits */
+      *edge_splits = split_edge (*edge_splits, edge, &overlap);
+      *edge_needs_removal = TRUE;
+    }
+
+  if (handle_type == -1 || handle_type == 1)
+    {
+      /* Remove the overlap from strut_edges */
+      /* First, loop over the edges of the strut */
+      GList *tmp = *strut_edges;
+      while (tmp)
+        {
+          MetaEdge *cur = tmp->data;
+          /* If this is the edge that overlaps, then we need to split it */
+          if (edges_overlap (cur, &overlap))
+            {
+              GList *delete_me = tmp;
+
+              /* Split this edge into some new ones */
+              *strut_edges = split_edge (*strut_edges, cur, &overlap);
+
+              /* Delete the old one */
+              tmp = tmp->next;
+              g_free (cur);
+              *strut_edges = g_list_delete_link (*strut_edges, delete_me);
+            }
+          else
+            tmp = tmp->next;
+        }
+    }
+}
+
+/* This function removes intersections of edges with the rectangles from the
+ * list of edges.
+ */
+GList*
+meta_rectangle_remove_intersections_with_boxes_from_edges (
+  GList        *edges,
+  const GSList *rectangles)
+{
+  const GSList *rect_iter;
+  const int opposing = 1;
+
+  /* Now remove all intersections of rectangles with the edge list */
+  rect_iter = rectangles;
+  while (rect_iter)
+    {
+      MetaRectangle *rect = rect_iter->data;
+      GList *edge_iter = edges;
+      while (edge_iter)
+        {
+          MetaEdge *edge = edge_iter->data;
+          MetaEdge overlap;
+          int      handle;
+          gboolean edge_iter_advanced = FALSE;
+
+          /* If this edge overlaps with this rect... */
+          if (rectangle_and_edge_intersection (rect, edge, &overlap, &handle))
+            {
+
+              /* "Intersections" where the edges touch but are opposite
+               * sides (e.g. a left edge against the right edge) should not
+               * be split.  Note that the comments in
+               * rectangle_and_edge_intersection() say that opposing edges
+               * occur when handle is -1, BUT you need to remember that we
+               * treat the left side of a window as a right edge because
+               * it's what the right side of the window being moved should
+               * be-resisted-by/snap-to.  So opposing is really 1.  Anyway,
+               * we just keep track of it in the opposing constant set up
+               * above and if handle isn't equal to that, then we know the
+               * edge should be split.
+               */
+              if (handle != opposing)
+                {
+                  /* Keep track of this edge so we can delete it below */
+                  GList *delete_me = edge_iter;
+                  edge_iter = edge_iter->next;
+                  edge_iter_advanced = TRUE;
+
+                  /* Split the edge and add the result to beginning of edges */
+                  edges = split_edge (edges, edge, &overlap);
+
+                  /* Now free the edge... */
+                  g_free (edge);
+                  edges = g_list_delete_link (edges, delete_me);
+                }
+            }
+
+          if (!edge_iter_advanced)
+            edge_iter = edge_iter->next;
+        }
+
+      rect_iter = rect_iter->next;
+    }
+
+  return edges;
+}
+
+/* This function is trying to find all the edges of an onscreen region. */
+GList*
+meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
+                                    const GSList        *all_struts)
+{
+  GList        *ret;
+  GList        *fixed_strut_rects;
+  GList        *edge_iter;
+  const GList  *strut_rect_iter;
+
+  /* The algorithm is basically as follows:
+   *   Make sure the struts are disjoint
+   *   Initialize the edge_set to the edges of basic_rect
+   *   Foreach strut:
+   *     Put together a preliminary new edge from the edges of the strut
+   *     Foreach edge in edge_set:
+   *       - Split the edge if it is partially contained inside the strut
+   *       - If the edge matches an edge of the strut (i.e. a strut just
+   *         against the edge of the screen or a not-next-to-edge-of-screen
+   *         strut adjacent to another), then both the edge from the
+   *         edge_set and the preliminary edge for the strut will need to
+   *         be split
+   *     Add any remaining "preliminary" strut edges to the edge_set
+   */
+
+  /* Make sure the struts are disjoint */
+  fixed_strut_rects =
+    get_disjoint_strut_rect_list_in_region (all_struts, basic_rect);
+
+  /* Start off the list with the edges of basic_rect */
+  ret = add_edges (NULL, basic_rect, TRUE);
+
+  strut_rect_iter = fixed_strut_rects;
+  while (strut_rect_iter)
+    {
+      MetaRectangle *strut_rect = (MetaRectangle*) strut_rect_iter->data;
+
+      /* Get the new possible edges we may need to add from the strut */
+      GList *new_strut_edges = add_edges (NULL, strut_rect, FALSE);
+
+      edge_iter = ret;
+      while (edge_iter)
+        {
+          MetaEdge *cur_edge = edge_iter->data;
+          GList *splits_of_cur_edge = NULL;
+          gboolean edge_needs_removal = FALSE;
+
+          fix_up_edges (strut_rect,       cur_edge,
+                        &new_strut_edges, &splits_of_cur_edge,
+                        &edge_needs_removal);
+
+          if (edge_needs_removal)
+            {
+              /* Delete the old edge */
+              GList *delete_me = edge_iter;
+              edge_iter = edge_iter->next;
+              g_free (cur_edge);
+              ret = g_list_delete_link (ret, delete_me);
+
+              /* Add the new split parts of the edge */
+              ret = g_list_concat (splits_of_cur_edge, ret);
+            }
+          else
+            {
+              edge_iter = edge_iter->next;
+            }
+
+          /* edge_iter was already advanced above */
+        }
+
+      ret = g_list_concat (new_strut_edges, ret);
+      strut_rect_iter = strut_rect_iter->next;
+    }
+
+  /* Sort the list */
+  ret = g_list_sort (ret, meta_rectangle_edge_cmp);
+
+  /* Free the fixed struts list */
+  meta_rectangle_free_list_and_elements (fixed_strut_rects);
+
+  return ret;
+}
+
+GList*
+meta_rectangle_find_nonintersected_xinerama_edges (
+                                    const GList         *xinerama_rects,
+                                    const GSList        *all_struts)
+{
+  /* This function cannot easily be merged with
+   * meta_rectangle_find_onscreen_edges() because real screen edges
+   * and strut edges both are of the type "there ain't anything
+   * immediately on the other side"; xinerama edges are different.
+   */
+  GList *ret;
+  const GList  *cur;
+  GSList *temp_rects;
+
+  /* Initialize the return list to be empty */
+  ret = NULL;
+
+  /* start of ret with all the edges of xineramas that are adjacent to
+   * another xinerama.
+   */
+  cur = xinerama_rects;
+  while (cur)
+    {
+      MetaRectangle *cur_rect = cur->data;
+      const GList *compare = xinerama_rects;
+      while (compare)
+        {
+          MetaRectangle *compare_rect = compare->data;
+
+          /* Check if cur might be horizontally adjacent to compare */
+          if (meta_rectangle_vert_overlap(cur_rect, compare_rect))
+            {
+              MetaSide side_type;
+              int y      = MAX (cur_rect->y, compare_rect->y);
+              int height = MIN (BOX_BOTTOM (*cur_rect) - y,
+                                BOX_BOTTOM (*compare_rect) - y);
+              int width  = 0;
+              int x;
+
+              if (BOX_LEFT (*cur_rect)  == BOX_RIGHT (*compare_rect))
+                {
+                  /* compare_rect is to the left of cur_rect */
+                  x = BOX_LEFT (*cur_rect);
+                  side_type = META_SIDE_LEFT;
+                }
+              else if (BOX_RIGHT (*cur_rect) == BOX_LEFT (*compare_rect))
+                {
+                  /* compare_rect is to the right of cur_rect */
+                  x = BOX_RIGHT (*cur_rect);
+                  side_type = META_SIDE_RIGHT;
+                }
+              else
+                /* These rectangles aren't adjacent after all */
+                x = INT_MIN;
+
+              /* If the rectangles really are adjacent */
+              if (x != INT_MIN)
+                {
+                  /* We need a left edge for the xinerama on the right, and
+                   * a right edge for the xinerama on the left.  Just fill
+                   * up the edges and stick 'em on the list.
+                   */
+                  MetaEdge *new_edge  = g_new (MetaEdge, 1);
+
+                  new_edge->rect = meta_rect (x, y, width, height);
+                  new_edge->side_type = side_type;
+                  new_edge->edge_type = META_EDGE_XINERAMA;
+
+                  ret = g_list_prepend (ret, new_edge);
+                }
+            }
+
+          /* Check if cur might be vertically adjacent to compare */
+          if (meta_rectangle_horiz_overlap(cur_rect, compare_rect))
+            {
+              MetaSide side_type;
+              int x      = MAX (cur_rect->x, compare_rect->x);
+              int width  = MIN (BOX_RIGHT (*cur_rect) - x,
+                                BOX_RIGHT (*compare_rect) - x);
+              int height = 0;
+              int y;
+
+              if (BOX_TOP (*cur_rect)  == BOX_BOTTOM (*compare_rect))
+                {
+                  /* compare_rect is to the top of cur_rect */
+                  y = BOX_TOP (*cur_rect);
+                  side_type = META_SIDE_TOP;
+                }
+              else if (BOX_BOTTOM (*cur_rect) == BOX_TOP (*compare_rect))
+                {
+                  /* compare_rect is to the bottom of cur_rect */
+                  y = BOX_BOTTOM (*cur_rect);
+                  side_type = META_SIDE_BOTTOM;
+                }
+              else
+                /* These rectangles aren't adjacent after all */
+                y = INT_MIN;
+
+              /* If the rectangles really are adjacent */
+              if (y != INT_MIN)
+                {
+                  /* We need a top edge for the xinerama on the bottom, and
+                   * a bottom edge for the xinerama on the top.  Just fill
+                   * up the edges and stick 'em on the list.
+                   */
+                  MetaEdge *new_edge = g_new (MetaEdge, 1);
+
+                  new_edge->rect = meta_rect (x, y, width, height);
+                  new_edge->side_type = side_type;
+                  new_edge->edge_type = META_EDGE_XINERAMA;
+
+                  ret = g_list_prepend (ret, new_edge);
+                }
+            }
+
+          compare = compare->next;
+        }
+      cur = cur->next;
+    }
+
+  temp_rects = NULL;
+  for (; all_struts; all_struts = all_struts->next)
+    temp_rects = g_slist_prepend (temp_rects,
+                                  &((MetaStrut*)all_struts->data)->rect);
+  ret = meta_rectangle_remove_intersections_with_boxes_from_edges (ret,
+                                                                   temp_rects);
+  g_slist_free (temp_rects);
+
+  /* Sort the list */
+  ret = g_list_sort (ret, meta_rectangle_edge_cmp);
+
+  return ret;
+}
diff --git a/src/core/constraints.c b/src/core/constraints.c
new file mode 100644
index 00000000..6abc7d5c
--- /dev/null
+++ b/src/core/constraints.c
@@ -0,0 +1,1382 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco size/position constraints */
+
+/*
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2005, 2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "constraints.h"
+#include "workspace.h"
+#include "place.h"
+#include "prefs.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+#if 0
+ // This is the short and sweet version of how to hack on this file; see
+ // doc/how-constraints-works.txt for the gory details.  The basics of
+ // understanding this file can be shown by the steps needed to add a new
+ // constraint, which are:
+ //   1) Add a new entry in the ConstraintPriority enum; higher values
+ //      have higher priority
+ //   2) Write a new function following the format of the example below,
+ //      "constrain_whatever".
+ //   3) Add your function to the all_constraints and all_constraint_names
+ //      arrays (the latter of which is for debugging purposes)
+ // 
+ // An example constraint function, constrain_whatever:
+ //
+ // /* constrain_whatever does the following:
+ //  *   Quits (returning true) if priority is higher than PRIORITY_WHATEVER
+ //  *   If check_only is TRUE
+ //  *     Returns whether the constraint is satisfied or not
+ //  *   otherwise
+ //  *     Enforces the constraint
+ //  * Note that the value of PRIORITY_WHATEVER is centralized with the
+ //  * priorities of other constraints in the definition of ConstrainPriority
+ //  * for easier maintenance and shuffling of priorities.
+ //  */
+ // static gboolean
+ // constrain_whatever (MetaWindow         *window,
+ //                     ConstraintInfo     *info,
+ //                     ConstraintPriority  priority,
+ //                     gboolean            check_only)
+ // {
+ //   if (priority > PRIORITY_WHATEVER)
+ //     return TRUE;
+ //
+ //   /* Determine whether constraint applies; note that if the constraint
+ //    * cannot possibly be satisfied, constraint_applies should be set to
+ //    * false.  If we don't do this, all constraints with a lesser priority
+ //    * will be dropped along with this one, and we'd rather apply as many as
+ //    * possible.
+ //    */
+ //   if (!constraint_applies)
+ //     return TRUE;
+ //
+ //   /* Determine whether constraint is already satisfied; if we're only
+ //    * checking the status of whether the constraint is satisfied, we end
+ //    * here.
+ //    */
+ //   if (check_only || constraint_already_satisfied)
+ //     return constraint_already_satisfied;
+ //
+ //   /* Enforce constraints */
+ //   return TRUE;  /* Note that we exited early if check_only is FALSE; also,
+ //                  * we know we can return TRUE here because we exited early
+ //                  * if the constraint could not be satisfied; not that the
+ //                  * return value is heeded in this case...
+ //                  */
+ // }
+#endif
+
+typedef enum
+{
+  PRIORITY_MINIMUM = 0, /* Dummy value used for loop start = min(all priorities) */
+  PRIORITY_ASPECT_RATIO = 0,
+  PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA = 0,
+  PRIORITY_ENTIRELY_VISIBLE_ON_WORKAREA = 1,
+  PRIORITY_SIZE_HINTS_INCREMENTS = 1,
+  PRIORITY_MAXIMIZATION = 2,
+  PRIORITY_FULLSCREEN = 2,
+  PRIORITY_SIZE_HINTS_LIMITS = 3,
+  PRIORITY_TITLEBAR_VISIBLE = 4,
+  PRIORITY_PARTIALLY_VISIBLE_ON_WORKAREA = 4,
+  PRIORITY_MAXIMUM = 4 /* Dummy value used for loop end = max(all priorities) */
+} ConstraintPriority;
+
+typedef enum
+{
+  ACTION_MOVE,
+  ACTION_RESIZE,
+  ACTION_MOVE_AND_RESIZE
+} ActionType;
+
+typedef struct
+{
+  MetaRectangle        orig;
+  MetaRectangle        current;
+  MetaFrameGeometry   *fgeom;
+  ActionType           action_type;
+  gboolean             is_user_action;
+
+  /* I know that these two things probably look similar at first, but they
+   * have much different uses.  See doc/how-constraints-works.txt for for
+   * explanation of the differences and similarity between resize_gravity
+   * and fixed_directions
+   */
+  int                  resize_gravity;
+  FixedDirections      fixed_directions;
+
+  /* work_area_xinerama - current xinerama region minus struts
+   * entire_xinerama    - current xienrama, including strut regions
+   */
+  MetaRectangle        work_area_xinerama;
+  MetaRectangle        entire_xinerama;
+
+  /* Spanning rectangles for the non-covered (by struts) region of the
+   * screen and also for just the current xinerama
+   */
+  GList  *usable_screen_region;
+  GList  *usable_xinerama_region;
+} ConstraintInfo;
+
+static gboolean constrain_maximization       (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_fullscreen         (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_size_increments    (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_size_limits        (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_aspect_ratio       (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_to_single_xinerama (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_fully_onscreen     (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_titlebar_visible   (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+static gboolean constrain_partially_onscreen (MetaWindow         *window,
+                                              ConstraintInfo     *info,
+                                              ConstraintPriority  priority,
+                                              gboolean            check_only);
+
+static void setup_constraint_info        (ConstraintInfo      *info,
+                                          MetaWindow          *window,
+                                          MetaFrameGeometry   *orig_fgeom,
+                                          MetaMoveResizeFlags  flags,
+                                          int                  resize_gravity,
+                                          const MetaRectangle *orig,
+                                          MetaRectangle       *new);
+static void place_window_if_needed       (MetaWindow     *window,
+                                          ConstraintInfo *info);
+static void update_onscreen_requirements (MetaWindow     *window,
+                                          ConstraintInfo *info);
+static void extend_by_frame              (MetaRectangle           *rect,
+                                          const MetaFrameGeometry *fgeom);
+static void unextend_by_frame            (MetaRectangle           *rect,
+                                          const MetaFrameGeometry *fgeom);
+static inline void get_size_limits       (const MetaWindow        *window,
+                                          const MetaFrameGeometry *fgeom,
+                                          gboolean include_frame,
+                                          MetaRectangle *min_size,
+                                          MetaRectangle *max_size);
+
+typedef gboolean (* ConstraintFunc) (MetaWindow         *window,
+                                     ConstraintInfo     *info,
+                                     ConstraintPriority  priority,
+                                     gboolean            check_only);
+
+typedef struct {
+  ConstraintFunc func;
+  const char* name;
+} Constraint;
+
+static const Constraint all_constraints[] = {
+  {constrain_maximization,       "constrain_maximization"},
+  {constrain_fullscreen,         "constrain_fullscreen"},
+  {constrain_size_increments,    "constrain_size_increments"},
+  {constrain_size_limits,        "constrain_size_limits"},
+  {constrain_aspect_ratio,       "constrain_aspect_ratio"},
+  {constrain_to_single_xinerama, "constrain_to_single_xinerama"},
+  {constrain_fully_onscreen,     "constrain_fully_onscreen"},
+  {constrain_titlebar_visible,   "constrain_titlebar_visible"},
+  {constrain_partially_onscreen, "constrain_partially_onscreen"},
+  {NULL,                         NULL}
+};
+
+static gboolean
+do_all_constraints (MetaWindow         *window,
+                    ConstraintInfo     *info,
+                    ConstraintPriority  priority,
+                    gboolean            check_only)
+{
+  const Constraint *constraint;
+  gboolean          satisfied;
+
+  constraint = &all_constraints[0];
+  satisfied = TRUE;
+  while (constraint->func != NULL)
+    {
+      satisfied = satisfied &&
+                  (*constraint->func) (window, info, priority, check_only);
+
+      if (!check_only)
+        {
+          /* Log how the constraint modified the position */
+          meta_topic (META_DEBUG_GEOMETRY,
+                      "info->current is %d,%d +%d,%d after %s\n",
+                      info->current.x, info->current.y, 
+                      info->current.width, info->current.height,
+                      constraint->name);
+        }
+      else if (!satisfied)
+        {
+          /* Log which constraint was not satisfied */
+          meta_topic (META_DEBUG_GEOMETRY,
+                      "constraint %s not satisfied.\n",
+                      constraint->name);
+          return FALSE;
+        }
+      ++constraint;
+    }
+
+  return TRUE;
+}
+
+void
+meta_window_constrain (MetaWindow          *window,
+                       MetaFrameGeometry   *orig_fgeom,
+                       MetaMoveResizeFlags  flags,
+                       int                  resize_gravity,
+                       const MetaRectangle *orig,
+                       MetaRectangle       *new)
+{
+  ConstraintInfo info;
+  ConstraintPriority priority = PRIORITY_MINIMUM;
+  gboolean satisfied = FALSE;
+
+  /* WARNING: orig and new specify positions and sizes of the inner window,
+   * not the outer.  This is a common gotcha since half the constraints
+   * deal with inner window position/size and half deal with outer.  See
+   * doc/how-constraints-works.txt for more information.
+   */
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Constraining %s in move from %d,%d %dx%d to %d,%d %dx%d\n",
+              window->desc,
+              orig->x, orig->y, orig->width, orig->height,
+              new->x,  new->y,  new->width,  new->height);
+
+  setup_constraint_info (&info,
+                         window, 
+                         orig_fgeom, 
+                         flags,
+                         resize_gravity,
+                         orig,
+                         new);
+  place_window_if_needed (window, &info);
+
+  while (!satisfied && priority <= PRIORITY_MAXIMUM) {
+    gboolean check_only = TRUE;
+
+    /* Individually enforce all the high-enough priority constraints */
+    do_all_constraints (window, &info, priority, !check_only);
+
+    /* Check if all high-enough priority constraints are simultaneously 
+     * satisfied
+     */
+    satisfied = do_all_constraints (window, &info, priority, check_only);
+
+    /* Drop the least important constraints if we can't satisfy them all */
+    priority++;
+  }
+
+  /* Make sure we use the constrained position */
+  *new = info.current;
+
+  /* We may need to update window->require_fully_onscreen,
+   * window->require_on_single_xinerama, and perhaps other quantities
+   * if this was a user move or user move-and-resize operation.
+   */
+  update_onscreen_requirements (window, &info);
+
+  /* Ew, what an ugly way to do things.  Destructors (in a real OOP language,
+   * not gobject-style--gobject would be more pain than it's worth) or
+   * smart pointers would be so much nicer here.  *shrug*
+   */
+  if (!orig_fgeom)
+    g_free (info.fgeom);
+}
+
+static void
+setup_constraint_info (ConstraintInfo      *info,
+                       MetaWindow          *window,
+                       MetaFrameGeometry   *orig_fgeom,
+                       MetaMoveResizeFlags  flags,
+                       int                  resize_gravity,
+                       const MetaRectangle *orig,
+                       MetaRectangle       *new)
+{
+  const MetaXineramaScreenInfo *xinerama_info;
+  MetaWorkspace *cur_workspace;
+
+  info->orig    = *orig;
+  info->current = *new;
+
+  /* Create a fake frame geometry if none really exists */
+  if (orig_fgeom && !window->fullscreen)
+    info->fgeom = orig_fgeom;
+  else
+    info->fgeom = g_new0 (MetaFrameGeometry, 1);
+
+  if (flags & META_IS_MOVE_ACTION && flags & META_IS_RESIZE_ACTION)
+    info->action_type = ACTION_MOVE_AND_RESIZE;
+  else if (flags & META_IS_RESIZE_ACTION)
+    info->action_type = ACTION_RESIZE;
+  else if (flags & META_IS_MOVE_ACTION)
+    info->action_type = ACTION_MOVE;
+  else
+    g_error ("BAD, BAD developer!  No treat for you!  (Fix your calls to "
+             "meta_window_move_resize_internal()).\n");
+
+  info->is_user_action = (flags & META_IS_USER_ACTION);
+
+  info->resize_gravity = resize_gravity;
+
+  /* FIXME: fixed_directions might be more sane if we (a) made it
+   * depend on the grab_op type instead of current amount of movement
+   * (thus implying that it only has effect when user_action is true,
+   * and (b) ignored it for aspect ratio windows -- at least in those
+   * cases where both directions do actually change size.
+   */
+  info->fixed_directions = FIXED_DIRECTION_NONE;
+  /* If x directions don't change but either y direction does */
+  if ( orig->x == new->x && orig->x + orig->width  == new->x + new->width   &&
+      (orig->y != new->y || orig->y + orig->height != new->y + new->height))
+    {
+      info->fixed_directions = FIXED_DIRECTION_X;
+    }
+  /* If y directions don't change but either x direction does */
+  if ( orig->y == new->y && orig->y + orig->height == new->y + new->height  &&
+      (orig->x != new->x || orig->x + orig->width  != new->x + new->width ))
+    {
+      info->fixed_directions = FIXED_DIRECTION_Y;
+    }
+  /* The point of fixed directions is just that "move to nearest valid
+   * position" is sometimes a poorer choice than "move to nearest
+   * valid position but only change this coordinate" for windows the
+   * user is explicitly moving.  This isn't ever true for things that
+   * aren't explicit user interaction, though, so just clear it out.
+   */
+  if (!info->is_user_action)
+    info->fixed_directions = FIXED_DIRECTION_NONE;
+
+  xinerama_info =
+    meta_screen_get_xinerama_for_rect (window->screen, &info->current);
+  meta_window_get_work_area_for_xinerama (window,
+                                          xinerama_info->number,
+                                          &info->work_area_xinerama);
+
+  if (!window->fullscreen || window->fullscreen_monitors[0] == -1)
+    {
+      info->entire_xinerama = xinerama_info->rect;
+    }
+  else
+    {
+      int i = 0;
+      long monitor;
+
+      monitor = window->fullscreen_monitors[i];
+      info->entire_xinerama =
+        window->screen->xinerama_infos[monitor].rect;
+      for (i = 1; i <= 3; i++)
+        {
+          monitor = window->fullscreen_monitors[i];
+          meta_rectangle_union (&info->entire_xinerama,
+                                &window->screen->xinerama_infos[monitor].rect,
+                                &info->entire_xinerama);
+        }
+    }
+
+  cur_workspace = window->screen->active_workspace;
+  info->usable_screen_region   = 
+    meta_workspace_get_onscreen_region (cur_workspace);
+  info->usable_xinerama_region = 
+    meta_workspace_get_onxinerama_region (cur_workspace, 
+                                          xinerama_info->number);
+
+  /* Workaround braindead legacy apps that don't know how to
+   * fullscreen themselves properly.
+   */
+  if (meta_prefs_get_force_fullscreen() &&
+      meta_rectangle_equal (new, &xinerama_info->rect) &&
+      window->has_fullscreen_func &&
+      !window->fullscreen)
+    {
+      /*
+      meta_topic (META_DEBUG_GEOMETRY,
+      */
+      meta_warning (
+                  "Treating resize request of legacy application %s as a "
+                  "fullscreen request\n",
+                  window->desc);
+      meta_window_make_fullscreen_internal (window);
+    }
+
+  /* Log all this information for debugging */
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Setting up constraint info:\n"
+              "  orig: %d,%d +%d,%d\n"
+              "  new : %d,%d +%d,%d\n"
+              "  fgeom: %d,%d,%d,%d\n"
+              "  action_type     : %s\n"
+              "  is_user_action  : %s\n"
+              "  resize_gravity  : %s\n"
+              "  fixed_directions: %s\n"
+              "  work_area_xinerama: %d,%d +%d,%d\n"
+              "  entire_xinerama   : %d,%d +%d,%d\n",
+              info->orig.x, info->orig.y, info->orig.width, info->orig.height,
+              info->current.x, info->current.y, 
+                info->current.width, info->current.height,
+              info->fgeom->left_width, info->fgeom->right_width,
+                info->fgeom->top_height, info->fgeom->bottom_height,
+              (info->action_type == ACTION_MOVE) ? "Move" :
+                (info->action_type == ACTION_RESIZE) ? "Resize" :
+                (info->action_type == ACTION_MOVE_AND_RESIZE) ? "Move&Resize" :
+                "Freakin' Invalid Stupid",
+              (info->is_user_action) ? "true" : "false",
+              meta_gravity_to_string (info->resize_gravity),
+              (info->fixed_directions == FIXED_DIRECTION_NONE) ? "None" :
+                (info->fixed_directions == FIXED_DIRECTION_X) ? "X fixed" :
+                (info->fixed_directions == FIXED_DIRECTION_Y) ? "Y fixed" :
+                "Freakin' Invalid Stupid",
+              info->work_area_xinerama.x, info->work_area_xinerama.y,
+                info->work_area_xinerama.width, 
+                info->work_area_xinerama.height,
+              info->entire_xinerama.x, info->entire_xinerama.y,
+                info->entire_xinerama.width, info->entire_xinerama.height);
+}
+
+static void
+place_window_if_needed(MetaWindow     *window,
+                       ConstraintInfo *info)
+{
+  gboolean did_placement;
+
+  /* Do placement if any, so we go ahead and apply position
+   * constraints in a move-only context. Don't place
+   * maximized/minimized/fullscreen windows until they are
+   * unmaximized, unminimized and unfullscreened.
+   */
+  did_placement = FALSE;
+  if (!window->placed &&
+      window->calc_placement &&
+      !(window->maximized_horizontally ||
+        window->maximized_vertically) &&
+      !window->minimized &&
+      !window->fullscreen)
+    {
+      MetaRectangle placed_rect = info->orig;
+      MetaWorkspace *cur_workspace;
+      const MetaXineramaScreenInfo *xinerama_info;
+
+      meta_window_place (window, info->fgeom, info->orig.x, info->orig.y,
+                         &placed_rect.x, &placed_rect.y);
+      did_placement = TRUE;
+
+      /* placing the window may have changed the xinerama.  Find the
+       * new xinerama and update the ConstraintInfo
+       */
+      xinerama_info =
+        meta_screen_get_xinerama_for_rect (window->screen, &placed_rect);
+      info->entire_xinerama = xinerama_info->rect;
+      meta_window_get_work_area_for_xinerama (window,
+                                              xinerama_info->number,
+                                              &info->work_area_xinerama);
+      cur_workspace = window->screen->active_workspace;
+      info->usable_xinerama_region = 
+        meta_workspace_get_onxinerama_region (cur_workspace, 
+                                              xinerama_info->number);
+
+
+      info->current.x = placed_rect.x;
+      info->current.y = placed_rect.y;
+
+      /* Since we just barely placed the window, there's no reason to
+       * consider any of the directions fixed.
+       */
+      info->fixed_directions = FIXED_DIRECTION_NONE;
+    }
+
+  if (window->placed || did_placement)
+    {
+      if (window->maximize_horizontally_after_placement ||
+          window->maximize_vertically_after_placement   ||
+          window->fullscreen_after_placement)
+        {
+          /* define a sane saved_rect so that the user can unmaximize or
+           * make unfullscreen to something reasonable.
+           */
+          if (info->current.width >= info->work_area_xinerama.width)
+            {
+              info->current.width = .75 * info->work_area_xinerama.width;
+              info->current.x = info->work_area_xinerama.x +
+                       .125 * info->work_area_xinerama.width;
+            }
+          if (info->current.height >= info->work_area_xinerama.height)
+            {
+              info->current.height = .75 * info->work_area_xinerama.height;
+              info->current.y = info->work_area_xinerama.y +
+                       .083 * info->work_area_xinerama.height;
+            }
+
+          if (window->maximize_horizontally_after_placement ||
+              window->maximize_vertically_after_placement)
+            meta_window_maximize_internal (window,   
+                (window->maximize_horizontally_after_placement ?
+                 META_MAXIMIZE_HORIZONTAL : 0 ) |
+                (window->maximize_vertically_after_placement ?
+                 META_MAXIMIZE_VERTICAL : 0), &info->current);
+
+          /* maximization may have changed frame geometry */
+          if (window->frame && !window->fullscreen)
+            meta_frame_calc_geometry (window->frame, info->fgeom);
+
+          if (window->fullscreen_after_placement)
+            {
+              window->saved_rect = info->current;
+              window->fullscreen = TRUE;
+              window->fullscreen_after_placement = FALSE;
+            }
+
+          window->maximize_horizontally_after_placement = FALSE;
+          window->maximize_vertically_after_placement = FALSE;
+        }
+      if (window->minimize_after_placement)
+        {
+          meta_window_minimize (window);
+          window->minimize_after_placement = FALSE;
+        }
+    }
+}
+
+static void
+update_onscreen_requirements (MetaWindow     *window,
+                              ConstraintInfo *info)
+{
+  gboolean old;
+
+  /* We only apply the various onscreen requirements to normal windows */
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK)
+    return;
+
+  /* We don't want to update the requirements for fullscreen windows;
+   * fullscreen windows are specially handled anyway, and it updating
+   * the requirements when windows enter fullscreen mode mess up the
+   * handling of the window when it leaves that mode (especially when
+   * the application sends a bunch of configurerequest events).  See
+   * #353699.
+   */
+  if (window->fullscreen)
+    return;
+
+  /* USABILITY NOTE: Naturally, I only want the require_fully_onscreen,
+   * require_on_single_xinerama, and require_titlebar_visible flags to
+   * *become false* due to user interactions (which is allowed since
+   * certain constraints are ignored for user interactions regardless of
+   * the setting of these flags).  However, whether to make these flags
+   * *become true* due to just an application interaction is a little
+   * trickier.  It's possible that users may find not doing that strange
+   * since two application interactions that resize in opposite ways don't
+   * necessarily end up cancelling--but it may also be strange for the user
+   * to have an application resize the window so that it's onscreen, the
+   * user forgets about it, and then later the app is able to resize itself
+   * off the screen.  Anyway, for now, I think the latter is the more
+   * problematic case but this may need to be revisited.
+   */
+
+  /* The require onscreen/on-single-xinerama and titlebar_visible
+   * stuff is relative to the outer window, not the inner
+   */
+  extend_by_frame (&info->current, info->fgeom);
+
+  /* Update whether we want future constraint runs to require the
+   * window to be on fully onscreen.
+   */
+  old = window->require_fully_onscreen;
+  window->require_fully_onscreen =
+    meta_rectangle_contained_in_region (info->usable_screen_region,
+                                        &info->current);
+  if (old ^ window->require_fully_onscreen)
+    meta_topic (META_DEBUG_GEOMETRY,
+                "require_fully_onscreen for %s toggled to %s\n",
+                window->desc,
+                window->require_fully_onscreen ? "TRUE" : "FALSE");
+
+  /* Update whether we want future constraint runs to require the
+   * window to be on a single xinerama.
+   */
+  old = window->require_on_single_xinerama;
+  window->require_on_single_xinerama =
+    meta_rectangle_contained_in_region (info->usable_xinerama_region,
+                                        &info->current);
+  if (old ^ window->require_on_single_xinerama)
+    meta_topic (META_DEBUG_GEOMETRY,
+                "require_on_single_xinerama for %s toggled to %s\n",
+                window->desc, 
+                window->require_on_single_xinerama ? "TRUE" : "FALSE");
+
+  /* Update whether we want future constraint runs to require the
+   * titlebar to be visible.
+   */
+  if (window->frame && window->decorated)
+    {
+      MetaRectangle titlebar_rect;
+
+      titlebar_rect = info->current;
+      titlebar_rect.height = info->fgeom->top_height;
+      old = window->require_titlebar_visible;
+      window->require_titlebar_visible =
+        meta_rectangle_overlaps_with_region (info->usable_screen_region,
+                                             &titlebar_rect);
+      if (old ^ window->require_titlebar_visible)
+        meta_topic (META_DEBUG_GEOMETRY,
+                    "require_titlebar_visible for %s toggled to %s\n",
+                    window->desc,
+                    window->require_titlebar_visible ? "TRUE" : "FALSE");
+    }
+
+  /* Don't forget to restore the position of the window */
+  unextend_by_frame (&info->current, info->fgeom);
+}
+
+static void
+extend_by_frame (MetaRectangle           *rect,
+                 const MetaFrameGeometry *fgeom)
+{
+  rect->x -= fgeom->left_width;
+  rect->y -= fgeom->top_height;
+  rect->width  += fgeom->left_width + fgeom->right_width;
+  rect->height += fgeom->top_height + fgeom->bottom_height;
+}
+
+static void
+unextend_by_frame (MetaRectangle           *rect,
+                   const MetaFrameGeometry *fgeom)
+{
+  rect->x += fgeom->left_width;
+  rect->y += fgeom->top_height;
+  rect->width  -= fgeom->left_width + fgeom->right_width;
+  rect->height -= fgeom->top_height + fgeom->bottom_height;
+}
+
+static inline void
+get_size_limits (const MetaWindow        *window,
+                 const MetaFrameGeometry *fgeom,
+                 gboolean                 include_frame,
+                 MetaRectangle *min_size,
+                 MetaRectangle *max_size)
+{
+  /* We pack the results into MetaRectangle structs just for convienience; we
+   * don't actually use the position of those rects.
+   */
+  min_size->width  = window->size_hints.min_width;
+  min_size->height = window->size_hints.min_height;
+  max_size->width  = window->size_hints.max_width;
+  max_size->height = window->size_hints.max_height;
+
+  if (include_frame)
+    {
+      int fw = fgeom->left_width + fgeom->right_width;
+      int fh = fgeom->top_height + fgeom->bottom_height;
+
+      min_size->width  += fw;
+      min_size->height += fh;
+      max_size->width  += fw;
+      max_size->height += fh;
+    }
+}
+
+static gboolean
+constrain_maximization (MetaWindow         *window,
+                        ConstraintInfo     *info,
+                        ConstraintPriority  priority,
+                        gboolean            check_only)
+{
+  MetaRectangle target_size;
+  MetaRectangle min_size, max_size;
+  gboolean hminbad, vminbad;
+  gboolean horiz_equal, vert_equal;
+  gboolean constraint_already_satisfied;
+
+  if (priority > PRIORITY_MAXIMIZATION)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't */
+  if (!window->maximized_horizontally && !window->maximized_vertically)
+    return TRUE;
+
+  /* Calculate target_size = maximized size of (window + frame) */
+  if (window->maximized_horizontally && window->maximized_vertically)
+    target_size = info->work_area_xinerama;
+  else
+    {
+      /* Amount of maximization possible in a single direction depends
+       * on which struts could occlude the window given its current
+       * position.  For example, a vertical partial strut on the right
+       * is only relevant for a horizontally maximized window when the
+       * window is at a vertical position where it could be occluded
+       * by that partial strut.
+       */
+      MetaDirection  direction;
+      GSList        *active_workspace_struts;
+
+      if (window->maximized_horizontally)
+        direction = META_DIRECTION_HORIZONTAL;
+      else
+        direction = META_DIRECTION_VERTICAL;
+      active_workspace_struts = window->screen->active_workspace->all_struts;
+
+      target_size = info->current;
+      extend_by_frame (&target_size, info->fgeom);
+      meta_rectangle_expand_to_avoiding_struts (&target_size,
+                                                &info->entire_xinerama,
+                                                direction,
+                                                active_workspace_struts);
+   }
+  /* Now make target_size = maximized size of client window */
+  unextend_by_frame (&target_size, info->fgeom);
+
+  /* Check min size constraints; max size constraints are ignored for maximized
+   * windows, as per bug 327543.
+   */
+  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  hminbad = target_size.width < min_size.width && window->maximized_horizontally;
+  vminbad = target_size.height < min_size.height && window->maximized_vertically;
+  if (hminbad || vminbad)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  horiz_equal = target_size.x      == info->current.x &&
+                target_size.width  == info->current.width;
+  vert_equal  = target_size.y      == info->current.y &&
+                target_size.height == info->current.height;
+  constraint_already_satisfied =
+    (horiz_equal || !window->maximized_horizontally) &&
+    (vert_equal  || !window->maximized_vertically);
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  if (window->maximized_horizontally)
+    {
+      info->current.x      = target_size.x;
+      info->current.width  = target_size.width;
+    }
+  if (window->maximized_vertically)
+    {
+      info->current.y      = target_size.y;
+      info->current.height = target_size.height;
+    }
+  return TRUE;
+}
+
+static gboolean
+constrain_fullscreen (MetaWindow         *window,
+                      ConstraintInfo     *info,
+                      ConstraintPriority  priority,
+                      gboolean            check_only)
+{
+  MetaRectangle min_size, max_size, xinerama;
+  gboolean too_big, too_small, constraint_already_satisfied;
+
+  if (priority > PRIORITY_FULLSCREEN)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't */
+  if (!window->fullscreen)
+    return TRUE;
+
+  xinerama = info->entire_xinerama;
+
+  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  too_big =   !meta_rectangle_could_fit_rect (&xinerama, &min_size);
+  too_small = !meta_rectangle_could_fit_rect (&max_size, &xinerama);
+  if (too_big || too_small)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  constraint_already_satisfied =
+    meta_rectangle_equal (&info->current, &xinerama);
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  info->current = xinerama;
+  return TRUE;
+}
+
+static gboolean
+constrain_size_increments (MetaWindow         *window,
+                           ConstraintInfo     *info,
+                           ConstraintPriority  priority,
+                           gboolean            check_only)
+{
+  int bh, hi, bw, wi, extra_height, extra_width;
+  int new_width, new_height;
+  gboolean constraint_already_satisfied;
+  MetaRectangle *start_rect;
+
+  if (priority > PRIORITY_SIZE_HINTS_INCREMENTS)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't */
+  if (META_WINDOW_MAXIMIZED (window) || window->fullscreen || 
+      info->action_type == ACTION_MOVE)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  bh = window->size_hints.base_height;
+  hi = window->size_hints.height_inc;
+  bw = window->size_hints.base_width;
+  wi = window->size_hints.width_inc;
+  extra_height = (info->current.height - bh) % hi;
+  extra_width  = (info->current.width  - bw) % wi;
+  /* ignore size increments for maximized windows */
+  if (window->maximized_horizontally)
+    extra_width *= 0;
+  if (window->maximized_vertically)
+    extra_height *= 0;
+  /* constraint is satisfied iff there is no extra height or width */
+  constraint_already_satisfied = 
+    (extra_height == 0 && extra_width == 0);
+
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  new_width  = info->current.width  - extra_width;
+  new_height = info->current.height - extra_height;
+
+  /* Adjusting down instead of up (as done in the above two lines) may
+   * violate minimum size constraints; fix the adjustment if this
+   * happens.
+   */
+  if (new_width  < window->size_hints.min_width)
+    new_width  += ((window->size_hints.min_width  - new_width)/wi  + 1)*wi;
+  if (new_height < window->size_hints.min_height)
+    new_height += ((window->size_hints.min_height - new_height)/hi + 1)*hi;
+
+  /* Figure out what original rect to pass to meta_rectangle_resize_with_gravity
+   * See bug 448183
+   */
+  if (info->action_type == ACTION_MOVE_AND_RESIZE)
+    start_rect = &info->current;
+  else
+    start_rect = &info->orig;
+    
+  /* Resize to the new size */
+  meta_rectangle_resize_with_gravity (start_rect,
+                                      &info->current, 
+                                      info->resize_gravity,
+                                      new_width,
+                                      new_height);
+  return TRUE;
+}
+
+static gboolean
+constrain_size_limits (MetaWindow         *window,
+                       ConstraintInfo     *info,
+                       ConstraintPriority  priority,
+                       gboolean            check_only)
+{
+  MetaRectangle min_size, max_size;
+  gboolean too_big, too_small, constraint_already_satisfied;
+  int new_width, new_height;
+  MetaRectangle *start_rect;
+
+  if (priority > PRIORITY_SIZE_HINTS_LIMITS)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't.
+   *
+   * Note: The old code didn't apply this constraint for fullscreen or
+   * maximized windows--but that seems odd to me.  *shrug*
+   */
+  if (info->action_type == ACTION_MOVE)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
+  /* We ignore max-size limits for maximized windows; see #327543 */
+  if (window->maximized_horizontally)
+    max_size.width = MAX (max_size.width, info->current.width);
+  if (window->maximized_vertically)
+    max_size.height = MAX (max_size.height, info->current.height);
+  too_small = !meta_rectangle_could_fit_rect (&info->current, &min_size);
+  too_big   = !meta_rectangle_could_fit_rect (&max_size, &info->current);
+  constraint_already_satisfied = !too_big && !too_small;
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  new_width  = CLAMP (info->current.width,  min_size.width,  max_size.width);
+  new_height = CLAMP (info->current.height, min_size.height, max_size.height);
+  
+  /* Figure out what original rect to pass to meta_rectangle_resize_with_gravity
+   * See bug 448183
+   */
+  if (info->action_type == ACTION_MOVE_AND_RESIZE)
+    start_rect = &info->current;
+  else
+    start_rect = &info->orig;
+  
+  meta_rectangle_resize_with_gravity (start_rect,
+                                      &info->current, 
+                                      info->resize_gravity,
+                                      new_width,
+                                      new_height);
+  return TRUE;
+}
+
+static gboolean
+constrain_aspect_ratio (MetaWindow         *window,
+                        ConstraintInfo     *info,
+                        ConstraintPriority  priority,
+                        gboolean            check_only)
+{
+  double minr, maxr;
+  gboolean constraints_are_inconsistent, constraint_already_satisfied;
+  int fudge, new_width, new_height;
+  double best_width, best_height;
+  double alt_width, alt_height;
+  MetaRectangle *start_rect;
+
+  if (priority > PRIORITY_ASPECT_RATIO)
+    return TRUE;
+
+  /* Determine whether constraint applies; exit if it doesn't. */
+  minr =         window->size_hints.min_aspect.x /
+         (double)window->size_hints.min_aspect.y;
+  maxr =         window->size_hints.max_aspect.x /
+         (double)window->size_hints.max_aspect.y;
+  constraints_are_inconsistent = minr > maxr;
+  if (constraints_are_inconsistent ||
+      META_WINDOW_MAXIMIZED (window) || window->fullscreen || 
+      info->action_type == ACTION_MOVE)
+    return TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is.  We
+   * need the following to hold:
+   *
+   *                 width
+   *         minr <= ------ <= maxr
+   *                 height
+   *
+   * But we need to allow for some slight fudging since width and height
+   * are integers instead of floating point numbers (this is particularly
+   * important when minr == maxr), so we allow width and height to be off
+   * a little bit from strictly satisfying these equations.  For just one
+   * sided resizing, we have to make the fudge factor a little bigger
+   * because of how meta_rectangle_resize_with_gravity treats those as
+   * being a resize increment (FIXME: I should handle real resize
+   * increments better here...)
+   */
+  switch (info->resize_gravity)
+    {
+    case WestGravity:
+    case NorthGravity:
+    case SouthGravity:
+    case EastGravity:
+      fudge = 2;
+      break;
+
+    case NorthWestGravity:
+    case SouthWestGravity:
+    case CenterGravity:
+    case NorthEastGravity:
+    case SouthEastGravity:
+    case StaticGravity:
+    default:
+      fudge = 1;
+      break;
+    }
+  constraint_already_satisfied = 
+    info->current.width - (info->current.height * minr ) > -minr*fudge &&
+    info->current.width - (info->current.height * maxr ) <  maxr*fudge;
+  if (check_only || constraint_already_satisfied)
+    return constraint_already_satisfied;
+
+  /*** Enforce constraint ***/
+  new_width = info->current.width;
+  new_height = info->current.height;
+
+  switch (info->resize_gravity)
+    {
+    case WestGravity:
+    case EastGravity:
+      /* Yeah, I suck for doing implicit rounding -- sue me */
+      new_height = CLAMP (new_height, new_width / maxr,  new_width / minr);
+      break;
+
+    case NorthGravity:
+    case SouthGravity:
+      /* Yeah, I suck for doing implicit rounding -- sue me */
+      new_width  = CLAMP (new_width,  new_height * minr, new_height * maxr);
+      break;
+
+    case NorthWestGravity:
+    case SouthWestGravity:
+    case CenterGravity:
+    case NorthEastGravity:
+    case SouthEastGravity:
+    case StaticGravity:
+    default:
+      /* Find what width would correspond to new_height, and what height would
+       * correspond to new_width */
+      alt_width  = CLAMP (new_width,  new_height * minr, new_height * maxr);
+      alt_height = CLAMP (new_height, new_width / maxr,  new_width / minr);
+
+      /* The line connecting the points (alt_width, new_height) and
+       * (new_width, alt_height) provide a range of
+       * valid-for-the-aspect-ratio-constraint sizes.  We want the
+       * size in that range closest to the value requested, i.e. the
+       * point on the line which is closest to the point (new_width,
+       * new_height)
+       */
+      meta_rectangle_find_linepoint_closest_to_point (alt_width, new_height,
+                                                      new_width, alt_height,
+                                                      new_width, new_height,
+                                                      &best_width, &best_height);
+
+      /* Yeah, I suck for doing implicit rounding -- sue me */
+      new_width  = best_width;
+      new_height = best_height;
+
+      break;
+    }
+
+  /* Figure out what original rect to pass to meta_rectangle_resize_with_gravity
+   * See bug 448183
+   */
+  if (info->action_type == ACTION_MOVE_AND_RESIZE)
+    start_rect = &info->current;
+  else
+    start_rect = &info->orig;
+
+  meta_rectangle_resize_with_gravity (start_rect,
+                                      &info->current, 
+                                      info->resize_gravity,
+                                      new_width,
+                                      new_height);
+
+  return TRUE;
+}
+
+static gboolean
+do_screen_and_xinerama_relative_constraints (
+  MetaWindow     *window,
+  GList          *region_spanning_rectangles,
+  ConstraintInfo *info,
+  gboolean        check_only)
+{
+  gboolean exit_early = FALSE, constraint_satisfied;
+  MetaRectangle how_far_it_can_be_smushed, min_size, max_size;
+
+#ifdef WITH_VERBOSE_MODE
+  if (meta_is_verbose ())
+    {
+      /* First, log some debugging information */
+      char spanning_region[1 + 28 * g_list_length (region_spanning_rectangles)];
+
+      meta_topic (META_DEBUG_GEOMETRY,
+             "screen/xinerama constraint; region_spanning_rectangles: %s\n",
+             meta_rectangle_region_to_string (region_spanning_rectangles, ", ",
+                                              spanning_region));
+    }
+#endif
+
+  /* Determine whether constraint applies; exit if it doesn't */
+  how_far_it_can_be_smushed = info->current;
+  get_size_limits (window, info->fgeom, TRUE, &min_size, &max_size);
+  extend_by_frame (&info->current, info->fgeom);
+
+  if (info->action_type != ACTION_MOVE)
+    {
+      if (!(info->fixed_directions & FIXED_DIRECTION_X))
+        how_far_it_can_be_smushed.width = min_size.width;
+
+      if (!(info->fixed_directions & FIXED_DIRECTION_Y))
+        how_far_it_can_be_smushed.height = min_size.height;
+    }
+  if (!meta_rectangle_could_fit_in_region (region_spanning_rectangles,
+                                           &how_far_it_can_be_smushed))
+    exit_early = TRUE;
+
+  /* Determine whether constraint is already satisfied; exit if it is */
+  constraint_satisfied = 
+    meta_rectangle_contained_in_region (region_spanning_rectangles,
+                                        &info->current);
+  if (exit_early || constraint_satisfied || check_only)
+    {
+      unextend_by_frame (&info->current, info->fgeom);
+      return constraint_satisfied;
+    }
+
+  /* Enforce constraint */
+
+  /* Clamp rectangle size for resize or move+resize actions */
+  if (info->action_type != ACTION_MOVE)
+    meta_rectangle_clamp_to_fit_into_region (region_spanning_rectangles,
+                                             info->fixed_directions,
+                                             &info->current,
+                                             &min_size);
+
+  if (info->is_user_action && info->action_type == ACTION_RESIZE)
+    /* For user resize, clip to the relevant region */
+    meta_rectangle_clip_to_region (region_spanning_rectangles,
+                                   info->fixed_directions,
+                                   &info->current);
+  else
+    /* For everything else, shove the rectangle into the relevant region */
+    meta_rectangle_shove_into_region (region_spanning_rectangles,
+                                      info->fixed_directions,
+                                      &info->current);
+
+  unextend_by_frame (&info->current, info->fgeom);
+  return TRUE;
+}
+
+static gboolean
+constrain_to_single_xinerama (MetaWindow         *window,
+                              ConstraintInfo     *info,
+                              ConstraintPriority  priority,
+                              gboolean            check_only)
+{
+  if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA)
+    return TRUE;
+
+  /* Exit early if we know the constraint won't apply--note that this constraint
+   * is only meant for normal windows (e.g. we don't want docks to be shoved 
+   * "onscreen" by their own strut) and we can't apply it to frameless windows
+   * or else users will be unable to move windows such as XMMS across xineramas.
+   */
+  if (window->type == META_WINDOW_DESKTOP   ||
+      window->type == META_WINDOW_DOCK      ||
+      window->screen->n_xinerama_infos == 1 ||
+      !window->require_on_single_xinerama   ||
+      !window->frame                        ||
+      info->is_user_action)
+    return TRUE;
+
+  /* Have a helper function handle the constraint for us */
+  return do_screen_and_xinerama_relative_constraints (window, 
+                                                 info->usable_xinerama_region,
+                                                 info,
+                                                 check_only);
+}
+
+static gboolean
+constrain_fully_onscreen (MetaWindow         *window,
+                          ConstraintInfo     *info,
+                          ConstraintPriority  priority,
+                          gboolean            check_only)
+{
+  if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_WORKAREA)
+    return TRUE;
+
+  /* Exit early if we know the constraint won't apply--note that this constraint
+   * is only meant for normal windows (e.g. we don't want docks to be shoved 
+   * "onscreen" by their own strut).
+   */
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK    ||
+      window->fullscreen                  ||
+      !window->require_fully_onscreen     || 
+      info->is_user_action)
+    return TRUE;
+
+  /* Have a helper function handle the constraint for us */
+  return do_screen_and_xinerama_relative_constraints (window, 
+                                                 info->usable_screen_region,
+                                                 info,
+                                                 check_only);
+}
+
+static gboolean
+constrain_titlebar_visible (MetaWindow         *window,
+                            ConstraintInfo     *info,
+                            ConstraintPriority  priority,
+                            gboolean            check_only)
+{
+  gboolean unconstrained_user_action;
+  gboolean retval;
+  int bottom_amount;
+  int horiz_amount_offscreen, vert_amount_offscreen;
+  int horiz_amount_onscreen,  vert_amount_onscreen;
+
+  if (priority > PRIORITY_TITLEBAR_VISIBLE)
+    return TRUE;
+
+  /* Allow the titlebar beyond the top of the screen only if the user wasn't
+   * clicking on the frame to start the move.
+   */
+  unconstrained_user_action =
+    info->is_user_action && !window->display->grab_frame_action;
+
+  /* Exit early if we know the constraint won't apply--note that this constraint
+   * is only meant for normal windows (e.g. we don't want docks to be shoved 
+   * "onscreen" by their own strut).
+   */
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK    ||
+      window->fullscreen                  ||
+      !window->require_titlebar_visible   ||
+      !window->decorated                  ||
+      unconstrained_user_action)
+    return TRUE;
+
+  /* Determine how much offscreen things are allowed.  We first need to
+   * figure out how much must remain on the screen.  For that, we use 25%
+   * window width/height but clamp to the range of (10,75) pixels.  This is
+   * somewhat of a seat of my pants random guess at what might look good.
+   * Then, the amount that is allowed off is just the window size minus
+   * this amount (but no less than 0 for tiny windows).
+   */
+  horiz_amount_onscreen = info->current.width  / 4;
+  vert_amount_onscreen  = info->current.height / 4;
+  horiz_amount_onscreen = CLAMP (horiz_amount_onscreen, 10, 75);
+  vert_amount_onscreen  = CLAMP (vert_amount_onscreen,  10, 75);
+  horiz_amount_offscreen = info->current.width - horiz_amount_onscreen;
+  vert_amount_offscreen  = info->current.height - vert_amount_onscreen;
+  horiz_amount_offscreen = MAX (horiz_amount_offscreen, 0);
+  vert_amount_offscreen  = MAX (vert_amount_offscreen,  0);
+  /* Allow the titlebar to touch the bottom panel;  If there is no titlebar,
+   * require vert_amount to remain on the screen.
+   */
+  if (window->frame)
+    {
+      bottom_amount = info->current.height + info->fgeom->bottom_height;
+      vert_amount_onscreen = info->fgeom->top_height;
+    }
+  else
+    bottom_amount = vert_amount_offscreen;
+
+  /* Extend the region, have a helper function handle the constraint,
+   * then return the region to its original size.
+   */
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              horiz_amount_offscreen,
+                                              horiz_amount_offscreen, 
+                                              0, /* Don't let titlebar off */
+                                              bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+  retval =
+    do_screen_and_xinerama_relative_constraints (window, 
+                                                 info->usable_screen_region,
+                                                 info,
+                                                 check_only);
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              -horiz_amount_offscreen,
+                                              -horiz_amount_offscreen,
+                                              0, /* Don't let titlebar off */
+                                              -bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+
+  return retval;
+}
+
+static gboolean
+constrain_partially_onscreen (MetaWindow         *window,
+                              ConstraintInfo     *info,
+                              ConstraintPriority  priority,
+                              gboolean            check_only)
+{
+  gboolean retval;
+  int top_amount, bottom_amount;
+  int horiz_amount_offscreen, vert_amount_offscreen;
+  int horiz_amount_onscreen,  vert_amount_onscreen;
+
+  if (priority > PRIORITY_PARTIALLY_VISIBLE_ON_WORKAREA)
+    return TRUE;
+
+  /* Exit early if we know the constraint won't apply--note that this constraint
+   * is only meant for normal windows (e.g. we don't want docks to be shoved 
+   * "onscreen" by their own strut).
+   */
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK)
+    return TRUE;
+
+  /* Determine how much offscreen things are allowed.  We first need to
+   * figure out how much must remain on the screen.  For that, we use 25%
+   * window width/height but clamp to the range of (10,75) pixels.  This is
+   * somewhat of a seat of my pants random guess at what might look good.
+   * Then, the amount that is allowed off is just the window size minus
+   * this amount (but no less than 0 for tiny windows).
+   */
+  horiz_amount_onscreen = info->current.width  / 4;
+  vert_amount_onscreen  = info->current.height / 4;
+  horiz_amount_onscreen = CLAMP (horiz_amount_onscreen, 10, 75);
+  vert_amount_onscreen  = CLAMP (vert_amount_onscreen,  10, 75);
+  horiz_amount_offscreen = info->current.width - horiz_amount_onscreen;
+  vert_amount_offscreen  = info->current.height - vert_amount_onscreen;
+  horiz_amount_offscreen = MAX (horiz_amount_offscreen, 0);
+  vert_amount_offscreen  = MAX (vert_amount_offscreen,  0);
+  top_amount = vert_amount_offscreen;
+  /* Allow the titlebar to touch the bottom panel;  If there is no titlebar,
+   * require vert_amount to remain on the screen.
+   */
+  if (window->frame)
+    {
+      bottom_amount = info->current.height + info->fgeom->bottom_height;
+      vert_amount_onscreen = info->fgeom->top_height;
+    }
+  else
+    bottom_amount = vert_amount_offscreen;
+
+  /* Extend the region, have a helper function handle the constraint,
+   * then return the region to its original size.
+   */
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              horiz_amount_offscreen,
+                                              horiz_amount_offscreen, 
+                                              top_amount,
+                                              bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+  retval =
+    do_screen_and_xinerama_relative_constraints (window, 
+                                                 info->usable_screen_region,
+                                                 info,
+                                                 check_only);
+  meta_rectangle_expand_region_conditionally (info->usable_screen_region,
+                                              -horiz_amount_offscreen,
+                                              -horiz_amount_offscreen,
+                                              -top_amount,
+                                              -bottom_amount,
+                                              horiz_amount_onscreen,
+                                              vert_amount_onscreen);
+
+  return retval;
+}
diff --git a/src/core/constraints.h b/src/core/constraints.h
new file mode 100644
index 00000000..d374581f
--- /dev/null
+++ b/src/core/constraints.h
@@ -0,0 +1,48 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco size/position constraints */
+
+/* 
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_CONSTRAINTS_H
+#define META_CONSTRAINTS_H
+
+#include "util.h"
+#include "window-private.h"
+#include "frame-private.h"
+
+typedef enum
+{
+  META_IS_CONFIGURE_REQUEST = 1 << 0,
+  META_DO_GRAVITY_ADJUST    = 1 << 1,
+  META_IS_USER_ACTION       = 1 << 2,
+  META_IS_MOVE_ACTION       = 1 << 3,
+  META_IS_RESIZE_ACTION     = 1 << 4
+} MetaMoveResizeFlags;
+
+void meta_window_constrain (MetaWindow          *window,
+                            MetaFrameGeometry   *orig_fgeom,
+                            MetaMoveResizeFlags  flags,
+                            int                  resize_gravity,
+                            const MetaRectangle *orig,
+                            MetaRectangle       *new);
+
+#endif /* META_CONSTRAINTS_H */
diff --git a/src/core/core.c b/src/core/core.c
new file mode 100644
index 00000000..963cbfa7
--- /dev/null
+++ b/src/core/core.c
@@ -0,0 +1,779 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco interface used by GTK+ UI to talk to core */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "core.h"
+#include "frame-private.h"
+#include "workspace.h"
+#include "prefs.h"
+
+/* Looks up the MetaWindow representing the frame of the given X window.
+ * Used as a helper function by a bunch of the functions below.
+ *
+ * FIXME: The functions that use this function throw the result away
+ * after use. Many of these functions tend to be called in small groups,
+ * which results in get_window() getting called several times in succession
+ * with the same parameters. We should profile to see whether this wastes
+ * much time, and if it does we should look into a generalised
+ * meta_core_get_window_info() which takes a bunch of pointers to variables
+ * to put its results in, and only fills in the non-null ones.
+ */
+static MetaWindow *
+get_window (Display *xdisplay,
+            Window   frame_xwindow)
+{
+  MetaDisplay *display;
+  MetaWindow *window;
+  
+  display = meta_display_for_x_display (xdisplay);
+  window = meta_display_lookup_x_window (display, frame_xwindow);
+
+  if (window == NULL || window->frame == NULL)
+    {
+      meta_bug ("No such frame window 0x%lx!\n", frame_xwindow);
+      return NULL;
+    }
+
+  return window;
+}
+
+void
+meta_core_get (Display *xdisplay,
+    Window xwindow,
+    ...)
+{
+  va_list args;
+  MetaCoreGetType request;
+
+  MetaDisplay *display = meta_display_for_x_display (xdisplay);
+  MetaWindow *window = meta_display_lookup_x_window (display, xwindow);
+
+  va_start (args, xwindow);
+
+  request = va_arg (args, MetaCoreGetType);
+
+  /* Now, we special-case the first request slightly. Mostly, requests
+   * for information on windows which have no frame are errors.
+   * But sometimes we may want to know *whether* a window has a frame.
+   * In this case, pass the key META_CORE_WINDOW_HAS_FRAME
+   * as the *first* request, with a pointer to a boolean; if the window
+   * has no frame, this will be set to False and meta_core_get will
+   * exit immediately (so the values of any other requests will be
+   * undefined). Otherwise it will be set to True and meta_core_get will
+   * continue happily on its way.
+   */
+
+  if (request != META_CORE_WINDOW_HAS_FRAME &&
+      (window == NULL || window->frame == NULL)) {
+    meta_bug ("No such frame window 0x%lx!\n", xwindow);
+    return;
+  }
+
+  while (request != META_CORE_GET_END) {
+    
+    gpointer answer = va_arg (args, gpointer);
+
+    switch (request) {
+      case META_CORE_WINDOW_HAS_FRAME:
+        *((gboolean*)answer) = window != NULL && window->frame != NULL;
+        if (!*((gboolean*)answer)) return; /* see above */
+        break; 
+      case META_CORE_GET_CLIENT_WIDTH:
+        *((gint*)answer) = window->rect.width;
+        break;
+      case META_CORE_GET_CLIENT_HEIGHT:
+        *((gint*)answer) = window->rect.height;
+        break;
+      case META_CORE_IS_TITLEBAR_ONSCREEN:
+        *((gboolean*)answer) = meta_window_titlebar_is_onscreen (window);
+        break;
+      case META_CORE_GET_CLIENT_XWINDOW:
+        *((Window*)answer) = window->xwindow;
+        break;
+      case META_CORE_GET_FRAME_FLAGS:
+        *((MetaFrameFlags*)answer) = meta_frame_get_flags (window->frame);
+        break; 
+      case META_CORE_GET_FRAME_TYPE:
+          {
+          MetaFrameType base_type = META_FRAME_TYPE_LAST;
+
+          switch (window->type)
+            {
+            case META_WINDOW_NORMAL:
+              base_type = META_FRAME_TYPE_NORMAL;
+              break;
+
+            case META_WINDOW_DIALOG:
+              base_type = META_FRAME_TYPE_DIALOG;
+              break;
+
+            case META_WINDOW_MODAL_DIALOG:
+              base_type = META_FRAME_TYPE_MODAL_DIALOG;
+              break;
+
+            case META_WINDOW_MENU:
+              base_type = META_FRAME_TYPE_MENU;
+              break;
+
+            case META_WINDOW_UTILITY:
+              base_type = META_FRAME_TYPE_UTILITY;
+              break;
+
+            case META_WINDOW_DESKTOP:
+            case META_WINDOW_DOCK:
+            case META_WINDOW_TOOLBAR:
+            case META_WINDOW_SPLASHSCREEN:
+              /* No frame */
+              base_type = META_FRAME_TYPE_LAST;
+              break;
+
+            }
+
+          if (base_type == META_FRAME_TYPE_LAST)
+            {
+              /* can't add border if undecorated */
+              *((MetaFrameType*)answer) = META_FRAME_TYPE_LAST; 
+            }
+          else if (window->border_only)
+            {
+              /* override base frame type */
+              *((MetaFrameType*)answer) = META_FRAME_TYPE_BORDER; 
+            }
+          else
+            {
+              *((MetaFrameType*)answer) = base_type;
+            }
+
+          break; 
+          }
+      case META_CORE_GET_MINI_ICON:
+        *((GdkPixbuf**)answer) = window->mini_icon;
+        break;
+      case META_CORE_GET_ICON:
+        *((GdkPixbuf**)answer) = window->icon;
+        break;
+      case META_CORE_GET_X:
+        meta_window_get_position (window, (int*)answer, NULL);
+        break;
+      case META_CORE_GET_Y:
+        meta_window_get_position (window, NULL, (int*)answer);
+        break;
+      case META_CORE_GET_FRAME_WORKSPACE:
+        *((gint*)answer) = meta_window_get_net_wm_desktop (window);
+        break;
+      case META_CORE_GET_FRAME_X:
+        *((gint*)answer) = window->frame->rect.x;
+        break;
+      case META_CORE_GET_FRAME_Y:
+        *((gint*)answer) = window->frame->rect.y;
+        break;
+      case META_CORE_GET_FRAME_WIDTH:
+        *((gint*)answer) = window->frame->rect.width;
+        break;
+      case META_CORE_GET_FRAME_HEIGHT:
+        *((gint*)answer) = window->frame->rect.height;
+        break;
+      case META_CORE_GET_SCREEN_WIDTH:
+        *((gint*)answer) = window->screen->rect.width;
+        break;
+      case META_CORE_GET_SCREEN_HEIGHT:
+        *((gint*)answer) = window->screen->rect.height;
+        break;
+
+      default:
+        meta_warning(_("Unknown window information request: %d"), request);
+    }
+
+    request = va_arg (args, MetaCoreGetType);
+  } 
+
+  va_end (args);
+}
+
+void
+meta_core_queue_frame_resize (Display *xdisplay,
+                              Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+}
+
+void
+meta_core_user_move (Display *xdisplay,
+                     Window   frame_xwindow,
+                     int      x,
+                     int      y)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_move (window, TRUE, x, y);
+}
+
+void
+meta_core_user_resize  (Display *xdisplay,
+                        Window   frame_xwindow,
+                        int      gravity,
+                        int      width,
+                        int      height)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_resize_with_gravity (window, TRUE, width, height, gravity);
+}
+
+void
+meta_core_user_raise (Display *xdisplay,
+                      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  meta_window_raise (window);
+}
+
+void
+meta_core_user_lower_and_unfocus (Display *xdisplay,
+                                  Window   frame_xwindow,
+                                  guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  meta_window_lower (window);
+
+  if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK &&
+      meta_prefs_get_raise_on_click ())
+    {
+      /* Move window to the back of the focusing workspace's MRU list.
+       * Do extra sanity checks to avoid possible race conditions.
+       * (Borrowed from window.c.)
+       */
+      if (window->screen->active_workspace &&
+          meta_window_located_on_workspace (window, 
+                                            window->screen->active_workspace))
+        {
+          GList* link;
+          link = g_list_find (window->screen->active_workspace->mru_list, 
+                              window);
+          g_assert (link);
+
+          window->screen->active_workspace->mru_list = 
+            g_list_remove_link (window->screen->active_workspace->mru_list,
+                                link);
+          g_list_free (link);
+
+          window->screen->active_workspace->mru_list = 
+            g_list_append (window->screen->active_workspace->mru_list, 
+                           window);
+        }
+    }
+
+  /* focus the default window, if needed */
+  if (window->has_focus)
+    meta_workspace_focus_default_window (window->screen->active_workspace,
+                                         NULL,
+                                         timestamp);
+}
+
+void
+meta_core_user_focus (Display *xdisplay,
+                      Window   frame_xwindow,
+                      guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  meta_window_focus (window, timestamp);
+}
+
+void
+meta_core_minimize (Display *xdisplay,
+                    Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_minimize (window);
+}
+
+void
+meta_core_maximize (Display *xdisplay,
+                    Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  meta_window_maximize (window, 
+                        META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+}
+
+void
+meta_core_toggle_maximize_vertically (Display *xdisplay,
+				      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  if (META_WINDOW_MAXIMIZED_VERTICALLY (window))
+    meta_window_unmaximize (window, 
+                            META_MAXIMIZE_VERTICAL);
+  else
+    meta_window_maximize (window,
+    			    META_MAXIMIZE_VERTICAL);
+}
+
+void
+meta_core_toggle_maximize_horizontally (Display *xdisplay,
+				        Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  if (META_WINDOW_MAXIMIZED_HORIZONTALLY (window))
+    meta_window_unmaximize (window, 
+                            META_MAXIMIZE_HORIZONTAL);
+  else
+    meta_window_maximize (window,
+    			    META_MAXIMIZE_HORIZONTAL);
+}
+
+void
+meta_core_toggle_maximize (Display *xdisplay,
+                           Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  if (META_WINDOW_MAXIMIZED (window))
+    meta_window_unmaximize (window, 
+                            META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+  else
+    meta_window_maximize (window,
+                          META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+}
+
+void
+meta_core_unmaximize (Display *xdisplay,
+                      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+
+  meta_window_unmaximize (window,
+                          META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL);
+}
+
+void
+meta_core_delete (Display *xdisplay,
+                  Window   frame_xwindow,
+                  guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+     
+  meta_window_delete (window, timestamp);
+}
+
+void
+meta_core_unshade (Display *xdisplay,
+                   Window   frame_xwindow,
+                   guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_unshade (window, timestamp);
+}
+
+void
+meta_core_shade (Display *xdisplay,
+                 Window   frame_xwindow,
+                 guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  meta_window_shade (window, timestamp);
+}
+
+void
+meta_core_unstick (Display *xdisplay,
+                   Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_unstick (window);
+}
+
+void
+meta_core_make_above (Display *xdisplay,
+                      Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_make_above (window);
+}
+
+void
+meta_core_unmake_above (Display *xdisplay,
+                        Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_unmake_above (window);
+}
+
+void
+meta_core_stick (Display *xdisplay,
+                 Window   frame_xwindow)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_stick (window);
+}
+
+void
+meta_core_change_workspace (Display *xdisplay,
+                            Window   frame_xwindow,
+                            int      new_workspace)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+
+  meta_window_change_workspace (window,
+                                meta_screen_get_workspace_by_index (window->screen,
+                                                                    new_workspace));
+}
+
+int
+meta_core_get_num_workspaces (Screen  *xscreen)
+{
+  MetaScreen *screen;
+
+  screen = meta_screen_for_x_screen (xscreen);
+
+  return meta_screen_get_n_workspaces (screen);
+}
+
+int
+meta_core_get_active_workspace (Screen *xscreen)
+{
+  MetaScreen *screen;
+
+  screen = meta_screen_for_x_screen (xscreen);
+
+  return meta_workspace_index (screen->active_workspace);
+}
+
+void
+meta_core_show_window_menu (Display *xdisplay,
+                            Window   frame_xwindow,
+                            int      root_x,
+                            int      root_y,
+                            int      button,
+                            guint32  timestamp)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  
+  if (meta_prefs_get_raise_on_click ())
+    meta_window_raise (window);
+  meta_window_focus (window, timestamp);
+
+  meta_window_show_menu (window, root_x, root_y, button, timestamp);
+}
+
+void
+meta_core_get_menu_accelerator (MetaMenuOp           menu_op,
+                                int                  workspace,
+                                unsigned int        *keysym,
+                                MetaVirtualModifier *modifiers)
+{
+  const char *name;
+
+  name = NULL;
+  
+  switch (menu_op)
+    {
+    case META_MENU_OP_NONE:
+      /* No keybinding for this one */
+      break;
+    case META_MENU_OP_DELETE:
+      name = "close";
+      break;
+    case META_MENU_OP_MINIMIZE:
+      name = "minimize";
+      break;
+    case META_MENU_OP_UNMAXIMIZE:
+      name = "unmaximize";
+      break;
+    case META_MENU_OP_MAXIMIZE:
+      name = "maximize";
+      break;
+    case META_MENU_OP_UNSHADE:
+    case META_MENU_OP_SHADE:
+      name = "toggle_shaded";
+      break;
+    case META_MENU_OP_UNSTICK:
+    case META_MENU_OP_STICK:
+      name = "toggle_on_all_workspaces";
+      break;
+    case META_MENU_OP_ABOVE:
+    case META_MENU_OP_UNABOVE:
+      name = "toggle_above";
+      break;
+    case META_MENU_OP_WORKSPACES:
+      switch (workspace)
+        {
+        case 1:
+          name = "move_to_workspace_1";
+          break;
+        case 2:
+          name = "move_to_workspace_2";
+          break;
+        case 3:
+          name = "move_to_workspace_3";
+          break; 
+        case 4:
+          name = "move_to_workspace_4";
+          break; 
+        case 5:
+          name = "move_to_workspace_5";
+          break; 
+        case 6:
+          name = "move_to_workspace_6";
+          break; 
+        case 7:
+          name = "move_to_workspace_7";
+          break; 
+        case 8:
+          name = "move_to_workspace_8";
+          break; 
+        case 9:
+          name = "move_to_workspace_9";
+          break; 
+        case 10:
+          name = "move_to_workspace_10";
+          break;
+        case 11:
+          name = "move_to_workspace_11";
+          break;
+        case 12:
+          name = "move_to_workspace_12";
+          break;
+        }
+      break;
+    case META_MENU_OP_MOVE:
+      name = "begin_move";
+      break;
+    case META_MENU_OP_RESIZE:
+      name = "begin_resize";
+      break;
+    case META_MENU_OP_MOVE_LEFT:
+      name = "move_to_workspace_left";
+      break;
+    case META_MENU_OP_MOVE_RIGHT:
+      name = "move_to_workspace_right";
+      break;
+    case META_MENU_OP_MOVE_UP:
+      name = "move_to_workspace_up";
+      break;
+    case META_MENU_OP_MOVE_DOWN:
+      name = "move_to_workspace_down";
+      break;
+    case META_MENU_OP_RECOVER:
+      /* No keybinding for this one */
+      break;
+    }
+
+  if (name)
+    {
+      meta_prefs_get_window_binding (name, keysym, modifiers);
+    }
+  else
+    {
+      *keysym = 0;
+      *modifiers = 0;
+    }
+}
+
+const char*
+meta_core_get_workspace_name_with_index (Display *xdisplay,
+                                         Window   xroot,
+                                         int      index)
+{
+  MetaDisplay *display;
+  MetaScreen *screen;
+  MetaWorkspace *workspace;
+
+  display = meta_display_for_x_display (xdisplay);
+  screen = meta_display_screen_for_root (display, xroot);
+  g_assert (screen != NULL);
+  workspace = meta_screen_get_workspace_by_index (screen, index);
+  return workspace ? meta_workspace_get_name (workspace) : NULL;
+}
+
+gboolean
+meta_core_begin_grab_op (Display    *xdisplay,
+                         Window      frame_xwindow,
+                         MetaGrabOp  op,
+                         gboolean    pointer_already_grabbed,
+                         gboolean    frame_action,
+                         int         button,
+                         gulong      modmask,
+                         guint32     timestamp,
+                         int         root_x,
+                         int         root_y)
+{
+  MetaWindow *window = get_window (xdisplay, frame_xwindow);
+  MetaDisplay *display;
+  MetaScreen *screen;
+  
+  display = meta_display_for_x_display (xdisplay);
+  screen = meta_display_screen_for_xwindow (display, frame_xwindow);
+
+  g_assert (screen != NULL);
+  
+  return meta_display_begin_grab_op (display, screen, window,
+                                     op, pointer_already_grabbed,
+                                     frame_action,
+                                     button, modmask,
+                                     timestamp, root_x, root_y);
+}
+
+void
+meta_core_end_grab_op (Display *xdisplay,
+                       guint32  timestamp)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  meta_display_end_grab_op (display, timestamp);
+}
+
+MetaGrabOp
+meta_core_get_grab_op (Display *xdisplay)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  return display->grab_op;
+}
+
+Window
+meta_core_get_grab_frame (Display *xdisplay)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  g_assert (display != NULL);
+  g_assert (display->grab_op == META_GRAB_OP_NONE || 
+            display->grab_screen != NULL);
+  g_assert (display->grab_op == META_GRAB_OP_NONE ||
+            display->grab_screen->display->xdisplay == xdisplay);
+  
+  if (display->grab_op != META_GRAB_OP_NONE &&
+      display->grab_window &&
+      display->grab_window->frame)
+    return display->grab_window->frame->xwindow;
+  else
+    return None;
+}
+
+int
+meta_core_get_grab_button (Display  *xdisplay)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  if (display->grab_op == META_GRAB_OP_NONE)
+    return -1;
+  
+  return display->grab_button;
+}
+
+void
+meta_core_grab_buttons  (Display *xdisplay,
+                         Window   frame_xwindow)
+{
+  MetaDisplay *display;
+    
+  display = meta_display_for_x_display (xdisplay);
+
+  meta_verbose ("Grabbing buttons on frame 0x%lx\n", frame_xwindow);
+  meta_display_grab_window_buttons (display, frame_xwindow);
+}
+
+void
+meta_core_set_screen_cursor (Display *xdisplay,
+                             Window   frame_on_screen,
+                             MetaCursor cursor)
+{
+  MetaWindow *window = get_window (xdisplay, frame_on_screen);
+
+  meta_frame_set_screen_cursor (window->frame, cursor);
+}
+
+void
+meta_core_increment_event_serial (Display *xdisplay)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (xdisplay);
+
+  meta_display_increment_event_serial (display);
+}
+
+void
+meta_invalidate_default_icons (void)
+{
+  MetaDisplay *display = meta_get_display ();
+  GSList *windows;
+  GSList *l;
+
+  if (display == NULL)
+    return; /* We can validly be called before the display is opened. */
+
+  windows = meta_display_list_windows (display);
+  for (l = windows; l != NULL; l = l->next)
+    {
+      MetaWindow *window = (MetaWindow*)l->data;
+
+      if (window->icon_cache.origin == USING_FALLBACK_ICON)
+        {
+          meta_icon_cache_free (&(window->icon_cache));
+          meta_window_update_icon_now (window);
+        }
+    }
+
+  g_slist_free (windows);
+}
+
diff --git a/src/core/delete.c b/src/core/delete.c
new file mode 100644
index 00000000..f0590e3b
--- /dev/null
+++ b/src/core/delete.c
@@ -0,0 +1,266 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window deletion */
+
+/*
+ * Copyright (C) 2001, 2002 Havoc Pennington
+ * Copyright (C) 2004 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _SVID_SOURCE /* for gethostname() */
+
+#include <config.h>
+#include "util.h"
+#include "window-private.h"
+#include "errors.h"
+#include "workspace.h"
+
+#include <sys/types.h>
+#include <signal.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void meta_window_present_delete_dialog (MetaWindow *window,
+                                               guint32     timestamp);
+
+static void
+delete_ping_reply_func (MetaDisplay *display,
+                        Window       xwindow,
+                        guint32      timestamp,
+                        void        *user_data)
+{
+  meta_topic (META_DEBUG_PING,
+              "Got reply to delete ping for %s\n",
+              ((MetaWindow*)user_data)->desc);
+
+  /* we do nothing */
+}
+
+static void
+dialog_exited (GPid     pid,
+               int      status,
+               gpointer user_data)
+{
+  MetaWindow *ours = (MetaWindow*) user_data;
+
+  ours->dialog_pid = -1;
+
+  /* exit status of 1 means the user pressed "Force Quit" */
+  if (WIFEXITED (status) && WEXITSTATUS (status) == 1)
+    meta_window_kill (ours);
+}
+
+static void
+delete_ping_timeout_func (MetaDisplay *display,
+                          Window       xwindow,
+                          guint32      timestamp,
+                          void        *user_data)
+{
+  MetaWindow *window = user_data;
+  char *window_title;
+  gchar *window_content, *tmp;
+  GPid dialog_pid;
+
+  meta_topic (META_DEBUG_PING,
+              "Got delete ping timeout for %s\n",
+              window->desc);
+
+  if (window->dialog_pid >= 0)
+    {
+      meta_window_present_delete_dialog (window, timestamp);
+      return;
+    }
+
+  window_title = g_locale_from_utf8 (window->title, -1, NULL, NULL, NULL);
+
+  /* Translators: %s is a window title */
+  tmp = g_strdup_printf (_("<tt>%s</tt> is not responding."),
+                         window_title);
+  window_content = g_strdup_printf (
+      "<big><b>%s</b></big>\n\n<i>%s</i>",
+      tmp,
+      _("You may choose to wait a short while for it to "
+        "continue or force the application to quit entirely."));
+
+  g_free (window_title);
+
+  dialog_pid =
+    meta_show_dialog ("--question",
+                      window_content, 0,
+                      window->screen->number,
+                      _("_Wait"), _("_Force Quit"), window->xwindow,
+                      NULL, NULL);
+
+  g_free (window_content);
+  g_free (tmp);
+
+  window->dialog_pid = dialog_pid;
+  g_child_watch_add (dialog_pid, dialog_exited, window);
+}
+
+void
+meta_window_delete (MetaWindow  *window,
+                    guint32      timestamp)
+{
+  meta_error_trap_push (window->display);
+  if (window->delete_window)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Deleting %s with delete_window request\n",
+                  window->desc);
+      meta_window_send_icccm_message (window,
+                                      window->display->atom_WM_DELETE_WINDOW,
+                                      timestamp);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Deleting %s with explicit kill\n",
+                  window->desc);
+      XKillClient (window->display->xdisplay, window->xwindow);
+    }
+  meta_error_trap_pop (window->display, FALSE);
+
+  meta_display_ping_window (window->display,
+                            window,
+                            timestamp,
+                            delete_ping_reply_func,
+                            delete_ping_timeout_func,
+                            window);
+
+  if (window->has_focus)
+    {
+      /* FIXME Clean this up someday
+       * http://bugzilla.gnome.org/show_bug.cgi?id=108706
+       */
+#if 0
+      /* This is unfortunately going to result in weirdness
+       * if the window doesn't respond to the delete event.
+       * I don't know how to avoid that though.
+       */
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing default window because focus window %s was deleted/killed\n",
+                  window->desc);
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window);
+#else
+      meta_topic (META_DEBUG_FOCUS,
+                  "Not unfocusing %s on delete/kill\n",
+                  window->desc);
+#endif
+    }
+  else
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Window %s was deleted/killed but didn't have focus\n",
+                  window->desc);
+    }
+}
+
+
+void
+meta_window_kill (MetaWindow *window)
+{
+  char buf[257];
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Killing %s brutally\n",
+              window->desc);
+
+  if (window->wm_client_machine != NULL &&
+      window->net_wm_pid > 0)
+    {
+      if (gethostname (buf, sizeof(buf)-1) == 0)
+        {
+          if (strcmp (buf, window->wm_client_machine) == 0)
+            {
+              meta_topic (META_DEBUG_WINDOW_OPS,
+                          "Killing %s with kill()\n",
+                          window->desc);
+
+              if (kill (window->net_wm_pid, 9) < 0)
+                meta_topic (META_DEBUG_WINDOW_OPS,
+                            "Failed to signal %s: %s\n",
+                            window->desc, strerror (errno));
+            }
+        }
+      else
+        {
+          meta_warning (_("Failed to get hostname: %s\n"),
+                        strerror (errno));
+        }
+    }
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Disconnecting %s with XKillClient()\n",
+              window->desc);
+  meta_error_trap_push (window->display);
+  XKillClient (window->display->xdisplay, window->xwindow);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+void
+meta_window_free_delete_dialog (MetaWindow *window)
+{
+  if (window->dialog_pid >= 0)
+    {
+      kill (window->dialog_pid, 9);
+      window->dialog_pid = -1;
+    }
+}
+
+static void
+meta_window_present_delete_dialog (MetaWindow *window, guint32 timestamp)
+{
+  meta_topic (META_DEBUG_PING,
+              "Presenting existing ping dialog for %s\n",
+              window->desc);
+
+  if (window->dialog_pid >= 0)
+    {
+      GSList *windows;
+      GSList *tmp;
+
+      /* Activate transient for window that belongs to
+       * marco-dialog
+       */
+
+      windows = meta_display_list_windows (window->display);
+      tmp = windows;
+      while (tmp != NULL)
+        {
+          MetaWindow *w = tmp->data;
+
+          if (w->xtransient_for == window->xwindow &&
+              w->res_class &&
+              g_ascii_strcasecmp (w->res_class, "marco-dialog") == 0)
+            {
+              meta_window_activate (w, timestamp);
+              break;
+            }
+
+          tmp = tmp->next;
+        }
+
+      g_slist_free (windows);
+    }
+}
diff --git a/src/core/display-private.h b/src/core/display-private.h
new file mode 100644
index 00000000..692e25f2
--- /dev/null
+++ b/src/core/display-private.h
@@ -0,0 +1,513 @@
+/* Marco X display handler */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_DISPLAY_PRIVATE_H
+#define META_DISPLAY_PRIVATE_H
+
+#ifndef PACKAGE
+	#error "config.h not included"
+#endif
+
+#include <glib.h>
+#include <X11/Xlib.h>
+#include "eventqueue.h"
+#include "common.h"
+#include "boxes.h"
+#include "display.h"
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+	#include <libsn/sn.h>
+#endif
+
+#ifdef HAVE_XSYNC
+	#include <X11/extensions/sync.h>
+#endif
+
+typedef struct _MetaKeyBinding MetaKeyBinding;
+typedef struct _MetaStack      MetaStack;
+typedef struct _MetaUISlave    MetaUISlave;
+typedef struct _MetaWorkspace  MetaWorkspace;
+
+typedef struct _MetaGroupPropHooks  MetaGroupPropHooks;
+
+typedef struct MetaEdgeResistanceData MetaEdgeResistanceData;
+
+typedef void (*MetaWindowPingFunc) (MetaDisplay* display, Window xwindow, guint32 timestamp, gpointer user_data);
+
+
+#define _NET_WM_STATE_REMOVE        0    /* remove/unset property */
+#define _NET_WM_STATE_ADD           1    /* add/set property */
+#define _NET_WM_STATE_TOGGLE        2    /* toggle property  */
+
+/* This is basically a bogus number, just has to be large enough
+ * to handle the expected case of the alt+tab operation, where
+ * we want to ignore serials from UnmapNotify on the tab popup,
+ * and the LeaveNotify/EnterNotify from the pointer ungrab
+ */
+#define N_IGNORED_SERIALS           4
+
+struct _MetaDisplay {
+	char* name;
+	Display* xdisplay;
+
+	Window leader_window;
+	Window timestamp_pinging_window;
+
+	/* Pull in all the names of atoms as fields; we will intern them when the
+	 * class is constructed.
+	 */
+	#define item(x)  Atom atom_##x;
+		#include "atomnames.h"
+	#undef item
+
+	/* This is the actual window from focus events,
+	 * not the one we last set
+	 */
+	MetaWindow* focus_window;
+
+	/* window we are expecting a FocusIn event for or the current focus
+	 * window if we are not expecting any FocusIn/FocusOut events; not
+	 * perfect because applications can call XSetInputFocus directly.
+	 * (It could also be messed up if a timestamp later than current
+	 * time is sent to meta_display_set_input_focus_window, though that
+	 * would be a programming error).  See bug 154598 for more info.
+	 */
+	MetaWindow* expected_focus_window;
+
+	/* last timestamp passed to XSetInputFocus */
+	guint32 last_focus_time;
+
+	/* last user interaction time in any app */
+	guint32 last_user_time;
+
+	/* whether we're using mousenav (only relevant for sloppy&mouse focus modes;
+	 * !mouse_mode means "keynav mode")
+	 */
+	guint mouse_mode: 1;
+
+	/* Helper var used when focus_new_windows setting is 'strict'; only
+	 * relevant in 'strict' mode and if the focus window is a terminal.
+	 * In that case, we don't allow new windows to take focus away from
+	 * a terminal, but if the user explicitly did something that should
+	 * allow a different window to gain focus (e.g. global keybinding or
+	 * clicking on a dock), then we will allow the transfer.
+	 */
+	guint allow_terminal_deactivation: 1;
+
+	guint static_gravity_works: 1;
+
+	/*< private-ish >*/
+	guint error_trap_synced_at_last_pop: 1;
+	MetaEventQueue* events;
+	GSList* screens;
+	MetaScreen* active_screen;
+	GHashTable* window_ids;
+	int error_traps;
+	int (*error_trap_handler) (Display* display, XErrorEvent* error);  
+	int server_grab_count;
+
+	/* serials of leave/unmap events that may
+	 * correspond to an enter event we should
+	 * ignore
+	 */
+	unsigned long ignored_serials[N_IGNORED_SERIALS];
+	Window ungrab_should_not_cause_focus_window;
+  
+	guint32 current_time;
+
+	/* Pings which we're waiting for a reply from */
+	GSList* pending_pings;
+
+	/* Pending autoraise */
+	guint       autoraise_timeout_id;
+	MetaWindow* autoraise_window;
+
+	/* Alt+click button grabs */
+	unsigned int window_grab_modifiers;
+
+	/* current window operation */
+	MetaGrabOp  grab_op;
+	MetaScreen* grab_screen;
+	MetaWindow* grab_window;
+	Window      grab_xwindow;
+	int         grab_button;
+	int         grab_anchor_root_x;
+	int         grab_anchor_root_y;
+	MetaRectangle grab_anchor_window_pos;
+	int         grab_latest_motion_x;
+	int         grab_latest_motion_y;
+	gulong      grab_mask;
+	guint       grab_have_pointer : 1;
+	guint       grab_have_keyboard : 1;
+	guint       grab_wireframe_active : 1;
+	guint       grab_was_cancelled : 1;    /* Only used in wireframe mode */
+	guint       grab_frame_action : 1;
+	MetaRectangle grab_wireframe_rect;
+	MetaRectangle grab_wireframe_last_xor_rect;
+	MetaRectangle grab_initial_window_pos;
+	int         grab_initial_x, grab_initial_y;  /* These are only relevant for */
+	gboolean    grab_threshold_movement_reached; /* raise_on_click == FALSE.    */
+	MetaResizePopup* grab_resize_popup;
+	GTimeVal    grab_last_moveresize_time;
+	guint32     grab_motion_notify_time;
+	int         grab_wireframe_last_display_width;
+	int         grab_wireframe_last_display_height;
+	GList*      grab_old_window_stacking;
+	MetaEdgeResistanceData* grab_edge_resistance_data;
+	unsigned int grab_last_user_action_was_snap;
+
+	/* we use property updates as sentinels for certain window focus events
+	 * to avoid some race conditions on EnterNotify events
+	 */
+	int         sentinel_counter;
+
+	#ifdef HAVE_XKB
+		int         xkb_base_event_type;
+		guint32     last_bell_time;
+	#endif
+	
+	#ifdef HAVE_XSYNC
+		/* alarm monitoring client's _NET_WM_SYNC_REQUEST_COUNTER */
+		XSyncAlarm  grab_sync_request_alarm;
+	#endif
+	
+	int       grab_resize_timeout_id;
+
+	/* Keybindings stuff */
+	MetaKeyBinding* key_bindings;
+	int             n_key_bindings;
+	int             min_keycode;
+	int             max_keycode;
+	KeySym* keymap;
+	int keysyms_per_keycode;
+	XModifierKeymap* modmap;
+	unsigned int ignored_modifier_mask;
+	unsigned int num_lock_mask;
+	unsigned int scroll_lock_mask;
+	unsigned int hyper_mask;
+	unsigned int super_mask;
+	unsigned int meta_mask;
+
+	/* Xinerama cache */
+	unsigned int xinerama_cache_invalidated: 1;
+
+	/* Opening the display */
+	unsigned int display_opening: 1;
+
+	/* Closing down the display */
+	int closing;
+
+	/* To detect double clicks
+	 *
+	 * https://github.com/stefano-k/Mate-Desktop-Environment/commit/b0e5fb03eb21dae8f02692f11ef391bfc5ccba33
+	 */
+	guint button_click_number;
+	Window button_click_window;
+	int button_click_x;
+	int button_click_y;
+	guint32 button_click_time;
+
+	/* Managed by group.c */
+	GHashTable* groups_by_leader;
+
+	/* currently-active window menu if any */
+	MetaWindowMenu* window_menu;
+	MetaWindow* window_with_menu;
+
+	/* Managed by window-props.c */
+	gpointer* prop_hooks_table;
+	GHashTable* prop_hooks;
+
+	/* Managed by group-props.c */
+	MetaGroupPropHooks* group_prop_hooks;
+
+	/* Managed by compositor.c */
+	MetaCompositor* compositor;
+  
+	#ifdef HAVE_STARTUP_NOTIFICATION
+		SnDisplay* sn_display;
+	#endif
+	
+	#ifdef HAVE_XSYNC
+		int xsync_event_base;
+		int xsync_error_base;
+	#endif
+	
+	#ifdef HAVE_SHAPE
+		int shape_event_base;
+		int shape_error_base;
+	#endif
+	
+	#ifdef HAVE_RENDER
+		int render_event_base;
+		int render_error_base;
+	#endif
+	
+	#ifdef HAVE_COMPOSITE_EXTENSIONS
+		int composite_event_base;
+		int composite_error_base;
+		int composite_major_version;
+		int composite_minor_version;
+		int damage_event_base;
+		int damage_error_base;
+		int xfixes_event_base;
+		int xfixes_error_base;
+	#endif
+	
+	#ifdef HAVE_XSYNC
+		unsigned int have_xsync : 1;
+		#define META_DISPLAY_HAS_XSYNC(display) ((display)->have_xsync)
+	#else
+		#define META_DISPLAY_HAS_XSYNC(display) FALSE
+	#endif
+	
+	#ifdef HAVE_SHAPE
+		unsigned int have_shape : 1;
+		#define META_DISPLAY_HAS_SHAPE(display) ((display)->have_shape)
+	#else
+		#define META_DISPLAY_HAS_SHAPE(display) FALSE
+	#endif
+	
+	#ifdef HAVE_RENDER
+		unsigned int have_render : 1;
+		#define META_DISPLAY_HAS_RENDER(display) ((display)->have_render)
+	#else
+		#define META_DISPLAY_HAS_RENDER(display) FALSE
+	#endif
+	
+	#ifdef HAVE_COMPOSITE_EXTENSIONS
+		unsigned int have_composite : 1;
+		unsigned int have_damage : 1;
+		unsigned int have_xfixes : 1;
+		#define META_DISPLAY_HAS_COMPOSITE(display) ((display)->have_composite)
+		#define META_DISPLAY_HAS_DAMAGE(display) ((display)->have_damage)
+		#define META_DISPLAY_HAS_XFIXES(display) ((display)->have_xfixes)
+	#else
+		#define META_DISPLAY_HAS_COMPOSITE(display) FALSE
+		#define META_DISPLAY_HAS_DAMAGE(display) FALSE
+		#define META_DISPLAY_HAS_XFIXES(display) FALSE
+	#endif
+};
+
+/* Xserver time can wraparound, thus comparing two timestamps needs to take
+ * this into account.  Here's a little macro to help out.  If no wraparound
+ * has occurred, this is equivalent to
+ *   time1 < time2
+ * Of course, the rest of the ugliness of this macro comes from accounting
+ * for the fact that wraparound can occur and the fact that a timestamp of
+ * 0 must be special-cased since it means older than anything else. 
+ *
+ * Note that this is NOT an equivalent for time1 <= time2; if that's what
+ * you need then you'll need to swap the order of the arguments and negate
+ * the result.
+ */
+#define XSERVER_TIME_IS_BEFORE_ASSUMING_REAL_TIMESTAMPS(time1, time2) \
+	( (( (time1) < (time2) ) && ( (time2) - (time1) < ((guint32)-1)/2 )) || \
+		(( (time1) > (time2) ) && ( (time1) - (time2) > ((guint32)-1)/2 )) \
+	)
+#define XSERVER_TIME_IS_BEFORE(time1, time2) \
+	( (time1) == 0 || \
+		(XSERVER_TIME_IS_BEFORE_ASSUMING_REAL_TIMESTAMPS(time1, time2) && \
+		(time2) != 0) \
+	)
+
+gboolean      meta_display_open                (void);
+void          meta_display_close               (MetaDisplay *display,
+                                                guint32      timestamp);
+MetaScreen*   meta_display_screen_for_x_screen (MetaDisplay *display,
+                                                Screen      *screen);
+MetaScreen*   meta_display_screen_for_xwindow  (MetaDisplay *display,
+                                                Window       xindow);
+void          meta_display_grab                (MetaDisplay *display);
+void          meta_display_ungrab              (MetaDisplay *display);
+
+void          meta_display_unmanage_screen     (MetaDisplay **display,
+                                                MetaScreen  *screen,
+                                                guint32      timestamp);
+
+void          meta_display_unmanage_windows_for_screen (MetaDisplay *display,
+                                                        MetaScreen  *screen,
+                                                        guint32      timestamp);
+
+/* Utility function to compare the stacking of two windows */
+int           meta_display_stack_cmp           (const void *a,
+                                                const void *b);
+
+/* A given MetaWindow may have various X windows that "belong"
+ * to it, such as the frame window.
+ */
+MetaWindow* meta_display_lookup_x_window     (MetaDisplay *display,
+                                              Window       xwindow);
+void        meta_display_register_x_window   (MetaDisplay *display,
+                                              Window      *xwindowp,
+                                              MetaWindow  *window);
+void        meta_display_unregister_x_window (MetaDisplay *display,
+                                              Window       xwindow);
+/* Return whether the xwindow is a no focus window for any of the screens */
+gboolean    meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display,
+                                                       Window xwindow);
+
+GSList*     meta_display_list_windows        (MetaDisplay *display);
+
+MetaDisplay* meta_display_for_x_display  (Display     *xdisplay);
+MetaDisplay* meta_get_display            (void);
+
+Cursor         meta_display_create_x_cursor (MetaDisplay *display,
+                                             MetaCursor   cursor);
+
+void     meta_display_set_grab_op_cursor (MetaDisplay *display,
+                                          MetaScreen  *screen,
+                                          MetaGrabOp   op,
+                                          gboolean     change_pointer,
+                                          Window       grab_xwindow,
+                                          guint32      timestamp);
+
+gboolean meta_display_begin_grab_op (MetaDisplay *display,
+                                     MetaScreen  *screen,
+                                     MetaWindow  *window,
+                                     MetaGrabOp   op,
+                                     gboolean     pointer_already_grabbed,
+                                     gboolean     frame_action,
+                                     int          button,
+                                     gulong       modmask,
+                                     guint32      timestamp,
+                                     int          root_x,
+                                     int          root_y);
+void     meta_display_end_grab_op   (MetaDisplay *display,
+                                     guint32      timestamp);
+
+void    meta_display_check_threshold_reached (MetaDisplay *display,
+                                              int          x,
+                                              int          y);
+void     meta_display_grab_window_buttons    (MetaDisplay *display,
+                                              Window       xwindow);
+void     meta_display_ungrab_window_buttons  (MetaDisplay *display,
+                                              Window       xwindow);
+
+void meta_display_grab_focus_window_button   (MetaDisplay *display,
+                                              MetaWindow  *window);
+void meta_display_ungrab_focus_window_button (MetaDisplay *display,
+                                              MetaWindow  *window);
+
+/* Next two functions are defined in edge-resistance.c */
+void meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display);
+void meta_display_cleanup_edges                         (MetaDisplay *display);
+
+/* make a request to ensure the event serial has changed */
+void     meta_display_increment_event_serial (MetaDisplay *display);
+
+void     meta_display_update_active_window_hint (MetaDisplay *display);
+
+guint32  meta_display_get_current_time           (MetaDisplay *display);
+guint32  meta_display_get_current_time_roundtrip (MetaDisplay *display);
+
+/* utility goo */
+const char* meta_event_mode_to_string   (int m);
+const char* meta_event_detail_to_string (int d);
+
+void meta_display_queue_retheme_all_windows (MetaDisplay *display);
+void meta_display_retheme_all (void);
+
+void meta_display_set_cursor_theme (const char *theme, 
+				    int         size);
+
+void meta_display_ping_window      (MetaDisplay        *display,
+                                    MetaWindow         *window,
+                                    guint32             timestamp,
+                                    MetaWindowPingFunc  ping_reply_func,
+                                    MetaWindowPingFunc  ping_timeout_func,
+                                    void               *user_data);
+gboolean meta_display_window_has_pending_pings (MetaDisplay        *display,
+						MetaWindow         *window);
+
+typedef enum
+{
+  META_TAB_LIST_NORMAL,
+  META_TAB_LIST_DOCKS,
+  META_TAB_LIST_GROUP
+} MetaTabList;
+
+typedef enum
+{
+  META_TAB_SHOW_ICON,      /* Alt-Tab mode */
+  META_TAB_SHOW_INSTANTLY  /* Alt-Esc mode */
+} MetaTabShowType;
+
+GList* meta_display_get_tab_list (MetaDisplay   *display,
+                                  MetaTabList    type,
+                                  MetaScreen    *screen,
+                                  MetaWorkspace *workspace);
+
+MetaWindow* meta_display_get_tab_next (MetaDisplay   *display,
+                                       MetaTabList    type,
+				       MetaScreen    *screen,
+                                       MetaWorkspace *workspace,
+                                       MetaWindow    *window,
+                                       gboolean       backward);
+
+MetaWindow* meta_display_get_tab_current (MetaDisplay   *display,
+                                          MetaTabList    type,
+                                          MetaScreen    *screen,
+                                          MetaWorkspace *workspace);
+
+int meta_resize_gravity_from_grab_op (MetaGrabOp op);
+
+gboolean meta_grab_op_is_moving   (MetaGrabOp op);
+gboolean meta_grab_op_is_resizing (MetaGrabOp op);
+
+void meta_display_devirtualize_modifiers (MetaDisplay        *display,
+                                          MetaVirtualModifier modifiers,
+                                          unsigned int       *mask);
+
+void meta_display_increment_focus_sentinel (MetaDisplay *display);
+void meta_display_decrement_focus_sentinel (MetaDisplay *display);
+gboolean meta_display_focus_sentinel_clear (MetaDisplay *display);
+
+/* meta_display_set_input_focus_window is like XSetInputFocus, except
+ * that (a) it can't detect timestamps later than the current time,
+ * since Marco isn't part of the XServer, and thus gives erroneous
+ * behavior in this circumstance (so don't do it), (b) it uses
+ * display->last_focus_time since we don't have access to the true
+ * Xserver one, (c) it makes use of display->user_time since checking
+ * whether a window should be allowed to be focused should depend
+ * on user_time events (see bug 167358, comment 15 in particular)
+ */
+void meta_display_set_input_focus_window   (MetaDisplay *display, 
+                                            MetaWindow  *window,
+                                            gboolean     focus_frame,
+                                            guint32      timestamp);
+
+/* meta_display_focus_the_no_focus_window is called when the
+ * designated no_focus_window should be focused, but is otherwise the
+ * same as meta_display_set_input_focus_window
+ */
+void meta_display_focus_the_no_focus_window (MetaDisplay *display, 
+                                             MetaScreen  *screen,
+                                             guint32      timestamp);
+
+void meta_display_queue_autoraise_callback  (MetaDisplay *display,
+                                             MetaWindow  *window);
+void meta_display_remove_autoraise_callback (MetaDisplay *display);
+
+#endif /* META_DISPLAY_PRIVATE_H */
diff --git a/src/core/display.c b/src/core/display.c
new file mode 100644
index 00000000..59ec9021
--- /dev/null
+++ b/src/core/display.c
@@ -0,0 +1,5355 @@
+/* Marco X display handler */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003, 2004 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file display.c Handles operations on an X display.
+ *
+ * The display is represented as a MetaDisplay struct.
+ */
+
+#include <config.h>
+#include "display-private.h"
+#include "util.h"
+#include "main.h"
+#include "screen-private.h"
+#include "window-private.h"
+#include "window-props.h"
+#include "group-props.h"
+#include "frame-private.h"
+#include "errors.h"
+#include "keybindings.h"
+#include "prefs.h"
+#include "resizepopup.h"
+#include "xprops.h"
+#include "workspace.h"
+#include "bell.h"
+#include "effects.h"
+#include "compositor.h"
+#include <X11/Xatom.h>
+#include <X11/cursorfont.h>
+
+#ifdef HAVE_SOLARIS_XINERAMA
+	#include <X11/extensions/xinerama.h>
+#endif
+
+#ifdef HAVE_XFREE_XINERAMA
+	#include <X11/extensions/Xinerama.h>
+#endif
+
+#ifdef HAVE_RANDR
+	#include <X11/extensions/Xrandr.h>
+#endif
+
+#ifdef HAVE_SHAPE
+	#include <X11/extensions/shape.h>
+#endif
+
+#ifdef HAVE_RENDER
+	#include <X11/extensions/Xrender.h>
+#endif
+
+#ifdef HAVE_XKB
+	#include <X11/XKBlib.h>
+#endif
+
+#ifdef HAVE_XCURSOR
+	#include <X11/Xcursor/Xcursor.h>
+#endif
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+	#include <X11/extensions/Xcomposite.h>
+	#include <X11/extensions/Xdamage.h>
+	#include <X11/extensions/Xfixes.h>
+	#include <gtk/gtk.h>
+#endif
+
+#include <string.h>
+
+#define GRAB_OP_IS_WINDOW_SWITCH(g)                     \
+        (g == META_GRAB_OP_KEYBOARD_TABBING_NORMAL  ||  \
+         g == META_GRAB_OP_KEYBOARD_TABBING_DOCK    ||  \
+         g == META_GRAB_OP_KEYBOARD_TABBING_GROUP   ||  \
+         g == META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL ||  \
+         g == META_GRAB_OP_KEYBOARD_ESCAPING_DOCK   ||  \
+         g == META_GRAB_OP_KEYBOARD_ESCAPING_GROUP)
+
+/**
+ * \defgroup pings Pings
+ *
+ * Sometimes we want to see whether a window is responding,
+ * so we send it a "ping" message and see whether it sends us back a "pong"
+ * message within a reasonable time. Here we have a system which lets us
+ * nominate one function to be called if we get the pong in time and another
+ * function if we don't. The system is rather more complicated than it needs
+ * to be, since we only ever use it to destroy windows which are asked to
+ * close themselves and don't do so within a reasonable amount of time, and
+ * therefore we always use the same callbacks. It's possible that we might
+ * use it for other things in future, or on the other hand we might decide
+ * that we're never going to do so and simplify it a bit.
+ */
+
+/**
+ * Describes a ping on a window. When we send a ping to a window, we build
+ * one of these structs, and it eventually gets passed to the timeout function
+ * or to the function which handles the response from the window. If the window
+ * does or doesn't respond to the ping, we use this information to deal with
+ * these facts; we have a handler function for each.
+ *
+ * \ingroup pings
+ */
+typedef struct 
+{
+  MetaDisplay *display;
+  Window       xwindow;
+  guint32      timestamp;
+  MetaWindowPingFunc ping_reply_func;
+  MetaWindowPingFunc ping_timeout_func;
+  void        *user_data;
+  guint        ping_timeout_id;
+} MetaPingData;
+
+typedef struct 
+{
+  MetaDisplay *display;
+  Window xwindow;
+} MetaAutoRaiseData;
+
+/**
+ * The display we're managing.  This is a singleton object.  (Historically,
+ * this was a list of displays, but there was never any way to add more
+ * than one element to it.)  The goofy name is because we don't want it
+ * to shadow the parameter in its object methods.
+ */
+static MetaDisplay *the_display = NULL;
+
+#ifdef WITH_VERBOSE_MODE
+static void   meta_spew_event           (MetaDisplay    *display,
+                                         XEvent         *event);
+#endif
+
+static gboolean event_callback          (XEvent         *event,
+                                         gpointer        data);
+static Window event_get_modified_window (MetaDisplay    *display,
+                                         XEvent         *event);
+static guint32 event_get_time           (MetaDisplay    *display,
+                                         XEvent         *event);
+static void    process_request_frame_extents (MetaDisplay    *display,
+                                              XEvent         *event);
+static void    process_pong_message     (MetaDisplay    *display,
+                                         XEvent         *event);
+static void    process_selection_request (MetaDisplay   *display,
+                                          XEvent        *event);
+static void    process_selection_clear   (MetaDisplay   *display,
+                                          XEvent        *event);
+
+static void    update_window_grab_modifiers (MetaDisplay *display);
+
+static void    prefs_changed_callback    (MetaPreference pref,
+                                          void          *data);
+
+static void    sanity_check_timestamps   (MetaDisplay *display,
+                                          guint32      known_good_timestamp);
+
+MetaGroup*     get_focussed_group (MetaDisplay *display);
+
+/**
+ * Destructor for MetaPingData structs. Will destroy the
+ * event source for the struct as well.
+ *
+ * \ingroup pings
+ */
+static void
+ping_data_free (MetaPingData *ping_data)
+{
+  /* Remove the timeout */
+  if (ping_data->ping_timeout_id != 0)
+    g_source_remove (ping_data->ping_timeout_id);
+
+  g_free (ping_data);
+}
+
+/**
+ * Frees every pending ping structure for the given X window on the
+ * given display. This means that we also destroy the timeouts.
+ *
+ * \param display The display the window appears on
+ * \param xwindow The X ID of the window whose pings we should remove
+ *
+ * \ingroup pings
+ *
+ */
+static void
+remove_pending_pings_for_window (MetaDisplay *display, Window xwindow)
+{
+  GSList *tmp;
+  GSList *dead;
+
+  /* could obviously be more efficient, don't care */
+  
+  /* build list to be removed */
+  dead = NULL;
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      if (ping_data->xwindow == xwindow)
+        dead = g_slist_prepend (dead, ping_data);
+    }
+
+  /* remove what we found */
+  for (tmp = dead; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      display->pending_pings = g_slist_remove (display->pending_pings, ping_data);
+      ping_data_free (ping_data);
+    }
+
+  g_slist_free (dead);
+}
+
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+static void
+sn_error_trap_push (SnDisplay *sn_display,
+                    Display   *xdisplay)
+{
+  MetaDisplay *display;
+  display = meta_display_for_x_display (xdisplay);
+  if (display != NULL)
+    meta_error_trap_push (display);
+}
+
+static void
+sn_error_trap_pop (SnDisplay *sn_display,
+                   Display   *xdisplay)
+{
+  MetaDisplay *display;
+  display = meta_display_for_x_display (xdisplay);
+  if (display != NULL)
+    meta_error_trap_pop (display, FALSE);
+}
+#endif
+
+static void
+enable_compositor (MetaDisplay *display,
+                   gboolean     composite_windows)
+{
+  GSList *list;
+
+  if (!META_DISPLAY_HAS_COMPOSITE (display) ||
+      !META_DISPLAY_HAS_DAMAGE (display) ||
+      !META_DISPLAY_HAS_XFIXES (display) ||
+      !META_DISPLAY_HAS_RENDER (display))
+    {
+      meta_warning (_("Missing %s extension required for compositing"),
+                    !META_DISPLAY_HAS_COMPOSITE (display) ? "composite" :
+                    !META_DISPLAY_HAS_DAMAGE (display) ? "damage" :
+                    !META_DISPLAY_HAS_XFIXES (display) ? "xfixes" : "render");
+      return;
+    }
+
+  if (!display->compositor)
+      display->compositor = meta_compositor_new (display);
+
+  if (!display->compositor)
+    return;
+  
+  for (list = display->screens; list != NULL; list = list->next)
+    {
+      MetaScreen *screen = list->data;
+      
+      meta_compositor_manage_screen (screen->display->compositor,
+				     screen);
+
+      if (composite_windows)
+        meta_screen_composite_all_windows (screen);
+    }
+}
+
+static void
+disable_compositor (MetaDisplay *display)
+{
+  GSList *list;
+  
+  if (!display->compositor)
+    return;
+  
+  for (list = display->screens; list != NULL; list = list->next)
+    {
+      MetaScreen *screen = list->data;
+      
+      meta_compositor_unmanage_screen (screen->display->compositor,
+				       screen);
+    }
+  
+  meta_compositor_destroy (display->compositor);
+  display->compositor = NULL;
+}
+
+/**
+ * Opens a new display, sets it up, initialises all the X extensions
+ * we will need, and adds it to the list of displays.
+ *
+ * \return True if the display was opened successfully, and False
+ * otherwise-- that is, if the display doesn't exist or it already
+ * has a window manager.
+ *
+ * \ingroup main
+ */
+gboolean
+meta_display_open (void)
+{
+  Display *xdisplay;
+  GSList *screens;
+  GSList *tmp;
+  int i;
+  guint32 timestamp;
+
+  /* A list of all atom names, so that we can intern them in one go. */
+  char *atom_names[] = {
+#define item(x) #x,
+#include "atomnames.h"
+#undef item
+  };
+  Atom atoms[G_N_ELEMENTS(atom_names)];
+  
+  meta_verbose ("Opening display '%s'\n", XDisplayName (NULL));
+
+  xdisplay = meta_ui_get_display ();
+  
+  if (xdisplay == NULL)
+    {
+      meta_warning (_("Failed to open X Window System display '%s'\n"),
+		    XDisplayName (NULL));
+      return FALSE;
+    }
+
+  if (meta_is_syncing ())
+    XSynchronize (xdisplay, True);
+  
+  g_assert (the_display == NULL);
+  the_display = g_new (MetaDisplay, 1);
+
+  the_display->closing = 0;
+  
+  /* here we use XDisplayName which is what the user
+   * probably put in, vs. DisplayString(display) which is
+   * canonicalized by XOpenDisplay()
+   */
+  the_display->name = g_strdup (XDisplayName (NULL));
+  the_display->xdisplay = xdisplay;
+  the_display->error_trap_synced_at_last_pop = TRUE;
+  the_display->error_traps = 0;
+  the_display->error_trap_handler = NULL;
+  the_display->server_grab_count = 0;
+  the_display->display_opening = TRUE;
+
+  the_display->pending_pings = NULL;
+  the_display->autoraise_timeout_id = 0;
+  the_display->autoraise_window = NULL;
+  the_display->focus_window = NULL;
+  the_display->expected_focus_window = NULL;
+  the_display->grab_old_window_stacking = NULL;
+
+  the_display->mouse_mode = TRUE; /* Only relevant for mouse or sloppy focus */
+  the_display->allow_terminal_deactivation = TRUE; /* Only relevant for when a
+                                                  terminal has the focus */
+
+#ifdef HAVE_XSYNC
+  the_display->grab_sync_request_alarm = None;
+#endif
+  
+  /* FIXME copy the checks from GDK probably */
+  the_display->static_gravity_works = g_getenv ("MARCO_USE_STATIC_GRAVITY") != NULL;
+  
+  meta_bell_init (the_display);
+
+  meta_display_init_keys (the_display);
+
+  update_window_grab_modifiers (the_display);
+
+  meta_prefs_add_listener (prefs_changed_callback, the_display);
+
+  meta_verbose ("Creating %d atoms\n", (int) G_N_ELEMENTS (atom_names));
+  XInternAtoms (the_display->xdisplay, atom_names, G_N_ELEMENTS (atom_names),
+                False, atoms);
+  {
+    int i = 0;    
+#define item(x) the_display->atom_##x = atoms[i++];
+#include "atomnames.h"
+#undef item
+  }
+
+  the_display->prop_hooks = NULL;
+  meta_display_init_window_prop_hooks (the_display);
+  the_display->group_prop_hooks = NULL;
+  meta_display_init_group_prop_hooks (the_display);
+  
+  /* Offscreen unmapped window used for _NET_SUPPORTING_WM_CHECK,
+   * created in screen_new
+   */
+  the_display->leader_window = None;
+  the_display->timestamp_pinging_window = None;
+
+  the_display->xinerama_cache_invalidated = TRUE;
+
+  the_display->groups_by_leader = NULL;
+
+  the_display->window_with_menu = NULL;
+  the_display->window_menu = NULL;
+  
+  the_display->screens = NULL;
+  the_display->active_screen = NULL;
+  
+#ifdef HAVE_STARTUP_NOTIFICATION
+  the_display->sn_display = sn_display_new (the_display->xdisplay,
+                                        sn_error_trap_push,
+                                        sn_error_trap_pop);
+#endif
+  
+  the_display->events = NULL;
+
+  /* Get events */
+  meta_ui_add_event_func (the_display->xdisplay,
+                          event_callback,
+                          the_display);
+  
+  the_display->window_ids = g_hash_table_new (meta_unsigned_long_hash,
+                                          meta_unsigned_long_equal);
+  
+  i = 0;
+  while (i < N_IGNORED_SERIALS)
+    {
+      the_display->ignored_serials[i] = 0;
+      ++i;
+    }
+  the_display->ungrab_should_not_cause_focus_window = None;
+  
+  the_display->current_time = CurrentTime;
+  the_display->sentinel_counter = 0;
+
+  the_display->grab_resize_timeout_id = 0;
+  the_display->grab_have_keyboard = FALSE;
+  
+#ifdef HAVE_XKB  
+  the_display->last_bell_time = 0;
+#endif
+
+  the_display->grab_op = META_GRAB_OP_NONE;
+  the_display->grab_wireframe_active = FALSE;
+  the_display->grab_window = NULL;
+  the_display->grab_screen = NULL;
+  the_display->grab_resize_popup = NULL;
+
+  the_display->grab_edge_resistance_data = NULL;
+
+#ifdef HAVE_XSYNC
+  {
+    int major, minor;
+
+    the_display->have_xsync = FALSE;
+    
+    the_display->xsync_error_base = 0;
+    the_display->xsync_event_base = 0;
+
+    /* I don't think we really have to fill these in */
+    major = SYNC_MAJOR_VERSION;
+    minor = SYNC_MINOR_VERSION;
+    
+    if (!XSyncQueryExtension (the_display->xdisplay,
+                              &the_display->xsync_event_base,
+                              &the_display->xsync_error_base) ||
+        !XSyncInitialize (the_display->xdisplay,
+                          &major, &minor))
+      {
+        the_display->xsync_error_base = 0;
+        the_display->xsync_event_base = 0;
+      }
+    else
+      the_display->have_xsync = TRUE;
+    
+    meta_verbose ("Attempted to init Xsync, found version %d.%d error base %d event base %d\n",
+                  major, minor,
+                  the_display->xsync_error_base,
+                  the_display->xsync_event_base);
+  }
+#else  /* HAVE_XSYNC */
+  meta_verbose ("Not compiled with Xsync support\n");
+#endif /* !HAVE_XSYNC */
+
+
+#ifdef HAVE_SHAPE
+  {
+    the_display->have_shape = FALSE;
+    
+    the_display->shape_error_base = 0;
+    the_display->shape_event_base = 0;
+    
+    if (!XShapeQueryExtension (the_display->xdisplay,
+                               &the_display->shape_event_base,
+                               &the_display->shape_error_base))
+      {
+        the_display->shape_error_base = 0;
+        the_display->shape_event_base = 0;
+      }
+    else
+      the_display->have_shape = TRUE;
+    
+    meta_verbose ("Attempted to init Shape, found error base %d event base %d\n",
+                  the_display->shape_error_base,
+                  the_display->shape_event_base);
+  }
+#else  /* HAVE_SHAPE */
+  meta_verbose ("Not compiled with Shape support\n");
+#endif /* !HAVE_SHAPE */
+
+#ifdef HAVE_RENDER
+  {
+    the_display->have_render = FALSE;
+    
+    the_display->render_error_base = 0;
+    the_display->render_event_base = 0;
+    
+    if (!XRenderQueryExtension (the_display->xdisplay,
+                                &the_display->render_event_base,
+                                &the_display->render_error_base))
+      {
+        the_display->render_error_base = 0;
+        the_display->render_event_base = 0;
+      }
+    else
+      the_display->have_render = TRUE;
+    
+    meta_verbose ("Attempted to init Render, found error base %d event base %d\n",
+                  the_display->render_error_base,
+                  the_display->render_event_base);
+  }
+#else  /* HAVE_RENDER */
+  meta_verbose ("Not compiled with Render support\n");
+#endif /* !HAVE_RENDER */
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  {
+    the_display->have_composite = FALSE;
+
+    the_display->composite_error_base = 0;
+    the_display->composite_event_base = 0;
+
+    if (!XCompositeQueryExtension (the_display->xdisplay,
+                                   &the_display->composite_event_base,
+                                   &the_display->composite_error_base))
+      {
+        the_display->composite_error_base = 0;
+        the_display->composite_event_base = 0;
+      } 
+    else
+      {
+        the_display->composite_major_version = 0;
+        the_display->composite_minor_version = 0;
+        if (XCompositeQueryVersion (the_display->xdisplay,
+                                    &the_display->composite_major_version,
+                                    &the_display->composite_minor_version))
+          {
+            the_display->have_composite = TRUE;
+          }
+        else
+          {
+            the_display->composite_major_version = 0;
+            the_display->composite_minor_version = 0;
+          }
+      }
+
+    meta_verbose ("Attempted to init Composite, found error base %d event base %d "
+                  "extn ver %d %d\n",
+                  the_display->composite_error_base, 
+                  the_display->composite_event_base,
+                  the_display->composite_major_version,
+                  the_display->composite_minor_version);
+
+    the_display->have_damage = FALSE;
+
+    the_display->damage_error_base = 0;
+    the_display->damage_event_base = 0;
+
+    if (!XDamageQueryExtension (the_display->xdisplay,
+                                &the_display->damage_event_base,
+                                &the_display->damage_error_base))
+      {
+        the_display->damage_error_base = 0;
+        the_display->damage_event_base = 0;
+      } 
+    else
+      the_display->have_damage = TRUE;
+
+    meta_verbose ("Attempted to init Damage, found error base %d event base %d\n",
+                  the_display->damage_error_base, 
+                  the_display->damage_event_base);
+
+    the_display->have_xfixes = FALSE;
+
+    the_display->xfixes_error_base = 0;
+    the_display->xfixes_event_base = 0;
+
+    if (!XFixesQueryExtension (the_display->xdisplay,
+                               &the_display->xfixes_event_base,
+                               &the_display->xfixes_error_base))
+      {
+        the_display->xfixes_error_base = 0;
+        the_display->xfixes_event_base = 0;
+      } 
+    else
+      the_display->have_xfixes = TRUE;
+
+    meta_verbose ("Attempted to init XFixes, found error base %d event base %d\n",
+                  the_display->xfixes_error_base, 
+                  the_display->xfixes_event_base);
+  }
+#else /* HAVE_COMPOSITE_EXTENSIONS */
+  meta_verbose ("Not compiled with Composite support\n");
+#endif /* !HAVE_COMPOSITE_EXTENSIONS */
+      
+#ifdef HAVE_XCURSOR
+  {
+    XcursorSetTheme (the_display->xdisplay, meta_prefs_get_cursor_theme ());
+    XcursorSetDefaultSize (the_display->xdisplay, meta_prefs_get_cursor_size ());
+  }
+#else /* HAVE_XCURSOR */
+  meta_verbose ("Not compiled with Xcursor support\n");
+#endif /* !HAVE_XCURSOR */
+
+  /* Create the leader window here. Set its properties and
+   * use the timestamp from one of the PropertyNotify events
+   * that will follow.
+   */
+  {
+    gulong data[1];
+    XEvent event;
+
+    /* We only care about the PropertyChangeMask in the next 30 or so lines of
+     * code.  Note that gdk will at some point unset the PropertyChangeMask for
+     * this window, so we can't rely on it still being set later.  See bug
+     * 354213 for details.
+     */
+    the_display->leader_window =
+      meta_create_offscreen_window (the_display->xdisplay,
+                                    DefaultRootWindow (the_display->xdisplay),
+                                    PropertyChangeMask);
+
+    meta_prop_set_utf8_string_hint (the_display,
+                                    the_display->leader_window,
+                                    the_display->atom__NET_WM_NAME,
+                                    "Marco");
+    
+    meta_prop_set_utf8_string_hint (the_display,
+                                    the_display->leader_window,
+                                    the_display->atom__MARCO_VERSION,
+                                    VERSION);
+
+    data[0] = the_display->leader_window;
+    XChangeProperty (the_display->xdisplay,
+                     the_display->leader_window,
+                     the_display->atom__NET_SUPPORTING_WM_CHECK,
+                     XA_WINDOW,
+                     32, PropModeReplace, (guchar*) data, 1);
+
+    XWindowEvent (the_display->xdisplay,
+                  the_display->leader_window,
+                  PropertyChangeMask,
+                  &event);
+
+    timestamp = event.xproperty.time;
+
+    /* Make it painfully clear that we can't rely on PropertyNotify events on
+     * this window, as per bug 354213.
+     */
+    XSelectInput(the_display->xdisplay,
+                 the_display->leader_window,
+                 NoEventMask);
+  }
+
+  /* Make a little window used only for pinging the server for timestamps; note
+   * that meta_create_offscreen_window already selects for PropertyChangeMask.
+   */
+  the_display->timestamp_pinging_window =
+    meta_create_offscreen_window (the_display->xdisplay,
+                                  DefaultRootWindow (the_display->xdisplay),
+                                  PropertyChangeMask);
+
+  the_display->last_focus_time = timestamp;
+  the_display->last_user_time = timestamp;
+  the_display->compositor = NULL;
+  
+  screens = NULL;
+  
+  i = 0;
+  while (i < ScreenCount (xdisplay))
+    {
+      MetaScreen *screen;
+
+      screen = meta_screen_new (the_display, i, timestamp);
+
+      if (screen)
+        screens = g_slist_prepend (screens, screen);
+      ++i;
+    }
+  
+  the_display->screens = screens;
+  
+  if (screens == NULL)
+    {
+      /* This would typically happen because all the screens already
+       * have window managers.
+       */
+      meta_display_close (the_display, timestamp);
+      return FALSE;
+    }
+
+  /* We don't composite the windows here because they will be composited 
+     faster with the call to meta_screen_manage_all_windows further down 
+     the code */
+  if (meta_prefs_get_compositing_manager ())
+    enable_compositor (the_display, FALSE);
+   
+  meta_display_grab (the_display);
+  
+  /* Now manage all existing windows */
+  tmp = the_display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+	
+      meta_screen_manage_all_windows (screen);
+
+      tmp = tmp->next;
+    }
+
+  {
+    Window focus;
+    int ret_to;
+
+    /* kinda bogus because GetInputFocus has no possible errors */
+    meta_error_trap_push (the_display);
+
+    /* FIXME: This is totally broken; see comment 9 of bug 88194 about this */
+    focus = None;
+    ret_to = RevertToPointerRoot;
+    XGetInputFocus (the_display->xdisplay, &focus, &ret_to);
+
+    /* Force a new FocusIn (does this work?) */
+
+    /* Use the same timestamp that was passed to meta_screen_new(),
+     * as it is the most recent timestamp.
+     */
+    if (focus == None || focus == PointerRoot)
+      /* Just focus the no_focus_window on the first screen */
+      meta_display_focus_the_no_focus_window (the_display,
+                                              the_display->screens->data,
+                                              timestamp);
+    else
+      {
+        MetaWindow * window;
+        window  = meta_display_lookup_x_window (the_display, focus);
+        if (window)
+          meta_display_set_input_focus_window (the_display, window, FALSE, timestamp);
+        else
+          /* Just focus the no_focus_window on the first screen */
+          meta_display_focus_the_no_focus_window (the_display,
+                                                  the_display->screens->data,
+                                                  timestamp);
+      }
+
+    meta_error_trap_pop (the_display, FALSE);
+  }
+  
+  meta_display_ungrab (the_display);  
+
+  /* Done opening new display */
+  the_display->display_opening = FALSE;
+
+  return TRUE;
+}
+
+static void
+listify_func (gpointer key, gpointer value, gpointer data)
+{
+  GSList **listp;
+
+  listp = data;
+  *listp = g_slist_prepend (*listp, value);
+}
+
+static gint
+ptrcmp (gconstpointer a, gconstpointer b)
+{
+  if (a < b)
+    return -1;
+  else if (a > b)
+    return 1;
+  else
+    return 0;
+}
+
+GSList*
+meta_display_list_windows (MetaDisplay *display)
+{
+  GSList *winlist;
+  GSList *tmp;
+  GSList *prev;
+  
+  winlist = NULL;
+  g_hash_table_foreach (display->window_ids,
+                        listify_func,
+                        &winlist);
+
+  /* Uniquify the list, since both frame windows and plain
+   * windows are in the hash
+   */
+  winlist = g_slist_sort (winlist, ptrcmp);
+
+  prev = NULL;
+  tmp = winlist;
+  while (tmp != NULL)
+    {
+      GSList *next;
+
+      next = tmp->next;
+      
+      if (next &&
+          next->data == tmp->data)
+        {
+          /* Delete tmp from list */
+
+          if (prev)
+            prev->next = next;
+
+          if (tmp == winlist)
+            winlist = next;
+          
+          g_slist_free_1 (tmp);
+
+          /* leave prev unchanged */
+        }
+      else
+        {
+          prev = tmp;
+        }
+      
+      tmp = next;
+    }
+
+  return winlist;
+}
+
+void
+meta_display_close (MetaDisplay *display,
+                    guint32      timestamp)
+{
+  GSList *tmp;
+
+  g_assert (display != NULL);
+
+  if (display->closing != 0)
+    {
+      /* The display's already been closed. */
+      return;
+    }
+
+  if (display->error_traps > 0)
+    meta_bug ("Display closed with error traps pending\n");
+
+  display->closing += 1;
+
+  meta_prefs_remove_listener (prefs_changed_callback, display);
+  
+  meta_display_remove_autoraise_callback (display);
+
+  if (display->grab_old_window_stacking)
+    g_list_free (display->grab_old_window_stacking);
+  
+  /* Stop caring about events */
+  meta_ui_remove_event_func (display->xdisplay,
+                             event_callback,
+                             display);
+  
+  /* Free all screens */
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+      meta_screen_free (screen, timestamp);
+      tmp = tmp->next;
+    }
+
+  g_slist_free (display->screens);
+  display->screens = NULL;
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  if (display->sn_display)
+    {
+      sn_display_unref (display->sn_display);
+      display->sn_display = NULL;
+    }
+#endif
+  
+  /* Must be after all calls to meta_window_free() since they
+   * unregister windows
+   */
+  g_hash_table_destroy (display->window_ids);
+
+  if (display->leader_window != None)
+    XDestroyWindow (display->xdisplay, display->leader_window);
+
+  XFlush (display->xdisplay);
+
+  meta_display_free_window_prop_hooks (display);
+  meta_display_free_group_prop_hooks (display);
+  
+  g_free (display->name);
+
+  meta_display_shutdown_keys (display);
+
+  if (display->compositor)
+    meta_compositor_destroy (display->compositor);
+  
+  g_free (display);
+  display = NULL;
+
+  meta_quit (META_EXIT_SUCCESS);
+}
+
+MetaScreen*
+meta_display_screen_for_root (MetaDisplay *display,
+                              Window       xroot)
+{
+  GSList *tmp;
+
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+
+      if (xroot == screen->xroot)
+        return screen;
+
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+MetaScreen*
+meta_display_screen_for_xwindow (MetaDisplay *display,
+                                 Window       xwindow)
+{
+  XWindowAttributes attr;
+  int result;
+  
+  meta_error_trap_push (display);
+  attr.screen = NULL;
+  result = XGetWindowAttributes (display->xdisplay, xwindow, &attr);
+  meta_error_trap_pop (display, TRUE);
+
+  /* Note, XGetWindowAttributes is on all kinds of crack
+   * and returns 1 on success 0 on failure, rather than Success
+   * on success.
+   */
+  if (result == 0 || attr.screen == NULL)
+    return NULL;
+  
+  return meta_display_screen_for_x_screen (display, attr.screen);
+}
+
+MetaScreen*
+meta_display_screen_for_x_screen (MetaDisplay *display,
+                                  Screen      *xscreen)
+{
+  GSList *tmp;
+
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+
+      if (xscreen == screen->xscreen)
+        return screen;
+
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+/* Grab/ungrab routines taken from fvwm */
+void
+meta_display_grab (MetaDisplay *display)
+{
+  if (display->server_grab_count == 0)
+    {
+      XGrabServer (display->xdisplay);
+    }
+  display->server_grab_count += 1;
+  meta_verbose ("Grabbing display, grab count now %d\n",
+                display->server_grab_count);
+}
+
+void
+meta_display_ungrab (MetaDisplay *display)
+{
+  if (display->server_grab_count == 0)
+    meta_bug ("Ungrabbed non-grabbed server\n");
+  
+  display->server_grab_count -= 1;
+  if (display->server_grab_count == 0)
+    {
+      /* FIXME we want to purge all pending "queued" stuff
+       * at this point, such as window hide/show
+       */
+      XUngrabServer (display->xdisplay);
+      XFlush (display->xdisplay);
+    }
+
+  meta_verbose ("Ungrabbing display, grab count now %d\n",
+                display->server_grab_count);
+}
+
+/**
+ * Returns the singleton MetaDisplay if "xdisplay" matches the X display it's
+ * managing; otherwise gives a warning and returns NULL.  When we were claiming
+ * to be able to manage multiple displays, this was supposed to find the
+ * display out of the list which matched that display.  Now it's merely an
+ * extra sanity check.
+ *
+ * \param xdisplay  An X display
+ * \return  The singleton X display, or NULL if "xdisplay" isn't the one
+ *          we're managing.
+ */
+MetaDisplay*
+meta_display_for_x_display (Display *xdisplay)
+{
+  if (the_display->xdisplay == xdisplay)
+    return the_display;
+
+  meta_warning ("Could not find display for X display %p, probably going to crash\n",
+                xdisplay);
+  
+  return NULL;
+}
+
+/**
+ * Accessor for the singleton MetaDisplay.
+ *
+ * \return  The only MetaDisplay there is.  This can be NULL, but only
+ *          during startup.
+ */
+MetaDisplay*
+meta_get_display (void)
+{
+  return the_display;
+}
+
+#ifdef WITH_VERBOSE_MODE
+static gboolean dump_events = TRUE;
+#endif
+
+static gboolean
+grab_op_is_mouse_only (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_MOVING:
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:      
+    case META_GRAB_OP_RESIZING_SW:      
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_RESIZING_E:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+static gboolean
+grab_op_is_mouse (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_MOVING:
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:      
+    case META_GRAB_OP_RESIZING_SW:      
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_MOVING:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+static gboolean
+grab_op_is_keyboard (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_KEYBOARD_MOVING:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_TABBING_NORMAL:
+    case META_GRAB_OP_KEYBOARD_TABBING_DOCK:
+    case META_GRAB_OP_KEYBOARD_TABBING_GROUP:
+    case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL:
+    case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
+    case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
+    case META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+gboolean
+meta_grab_op_is_resizing (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:      
+    case META_GRAB_OP_RESIZING_SW:      
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      return TRUE;
+
+    default:
+      return FALSE;
+    }
+}
+
+gboolean
+meta_grab_op_is_moving (MetaGrabOp op)
+{
+  switch (op)
+    {
+    case META_GRAB_OP_MOVING:
+    case META_GRAB_OP_KEYBOARD_MOVING:
+      return TRUE;
+      
+    default:
+      return FALSE;
+    }
+}
+
+/* Get time of current event, or CurrentTime if none. */
+guint32
+meta_display_get_current_time (MetaDisplay *display)
+{
+  return display->current_time;
+}
+
+/* Get a timestamp, even if it means a roundtrip */
+guint32
+meta_display_get_current_time_roundtrip (MetaDisplay *display)
+{
+  guint32 timestamp;
+  
+  timestamp = meta_display_get_current_time (display);
+  if (timestamp == CurrentTime)
+    {
+      XEvent property_event;
+
+      /* Using the property XA_PRIMARY because it's safe; nothing
+       * would use it as a property. The type doesn't matter.
+       */
+      XChangeProperty (display->xdisplay,
+                       display->timestamp_pinging_window,
+                       XA_PRIMARY, XA_STRING, 8,
+                       PropModeAppend, NULL, 0);
+      XWindowEvent (display->xdisplay,
+                    display->timestamp_pinging_window,
+                    PropertyChangeMask,
+                    &property_event);
+      timestamp = property_event.xproperty.time;
+    }
+
+  sanity_check_timestamps (display, timestamp);
+
+  return timestamp;
+}
+
+static void
+add_ignored_serial (MetaDisplay  *display,
+                    unsigned long serial)
+{
+  int i;
+
+  /* don't add the same serial more than once */
+  if (display->ignored_serials[N_IGNORED_SERIALS-1] == serial)
+    return;
+  
+  /* shift serials to the left */
+  i = 0;
+  while (i < (N_IGNORED_SERIALS - 1))
+    {
+      display->ignored_serials[i] = display->ignored_serials[i+1];
+      ++i;
+    }
+  /* put new one on the end */
+  display->ignored_serials[i] = serial;
+}
+
+static gboolean
+serial_is_ignored (MetaDisplay  *display,
+                   unsigned long serial)
+{
+  int i;
+
+  i = 0;
+  while (i < N_IGNORED_SERIALS)
+    {
+      if (display->ignored_serials[i] == serial)
+        return TRUE;
+      ++i;
+    }
+  return FALSE;
+}
+
+static void
+reset_ignores (MetaDisplay *display)
+{
+  int i;
+
+  i = 0;
+  while (i < N_IGNORED_SERIALS)
+    {
+      display->ignored_serials[i] = 0;
+      ++i;
+    }
+
+  display->ungrab_should_not_cause_focus_window = None;
+}
+
+static gboolean 
+window_raise_with_delay_callback (void *data)
+{
+  MetaWindow *window;
+  MetaAutoRaiseData *auto_raise;
+
+  auto_raise = data;
+
+  meta_topic (META_DEBUG_FOCUS, 
+	      "In autoraise callback for window 0x%lx\n", 
+	      auto_raise->xwindow);
+
+  auto_raise->display->autoraise_timeout_id = 0;
+  auto_raise->display->autoraise_window = NULL;
+
+  window  = meta_display_lookup_x_window (auto_raise->display, 
+					  auto_raise->xwindow);
+  
+  if (window == NULL) 
+    return FALSE;
+
+  /* If we aren't already on top, check whether the pointer is inside
+   * the window and raise the window if so.
+   */      
+  if (meta_stack_get_top (window->screen->stack) != window) 
+    {
+      int x, y, root_x, root_y;
+      Window root, child;
+      unsigned int mask;
+      gboolean same_screen;
+      gboolean point_in_window;
+
+      meta_error_trap_push (window->display);
+      same_screen = XQueryPointer (window->display->xdisplay,
+				   window->xwindow,
+				   &root, &child,
+				   &root_x, &root_y, &x, &y, &mask);
+      meta_error_trap_pop (window->display, TRUE);
+
+      point_in_window = 
+        (window->frame && POINT_IN_RECT (root_x, root_y, window->frame->rect)) ||
+        (window->frame == NULL && POINT_IN_RECT (root_x, root_y, window->rect));
+      if (same_screen && point_in_window)
+	meta_window_raise (window);
+      else
+	meta_topic (META_DEBUG_FOCUS, 
+		    "Pointer not inside window, not raising %s\n", 
+		    window->desc);
+    }
+
+  return FALSE;
+}
+
+void
+meta_display_queue_autoraise_callback (MetaDisplay *display,
+                                       MetaWindow  *window)
+{
+  MetaAutoRaiseData *auto_raise_data;
+
+  meta_topic (META_DEBUG_FOCUS, 
+              "Queuing an autoraise timeout for %s with delay %d\n", 
+              window->desc, 
+              meta_prefs_get_auto_raise_delay ());
+  
+  auto_raise_data = g_new (MetaAutoRaiseData, 1);
+  auto_raise_data->display = window->display;
+  auto_raise_data->xwindow = window->xwindow;
+  
+  if (display->autoraise_timeout_id != 0)
+    g_source_remove (display->autoraise_timeout_id);
+
+  display->autoraise_timeout_id = 
+    g_timeout_add_full (G_PRIORITY_DEFAULT,
+                        meta_prefs_get_auto_raise_delay (),
+                        window_raise_with_delay_callback,
+                        auto_raise_data,
+                        g_free);
+  display->autoraise_window = window;
+}
+
+#if 0
+static void
+handle_net_restack_window (MetaDisplay* display,
+                           XEvent *event)
+{
+  MetaWindow *window;
+
+  window = meta_display_lookup_x_window (display,
+                                         event->xclient.window);
+
+  if (window)
+    {
+      /* FIXME: The EWMH includes a sibling for the restack request, but we
+       * (stupidly) don't currently support these types of raises.
+       *
+       * Also, unconditionally following these is REALLY stupid--we should
+       * combine this code with the stuff in
+       * meta_window_configure_request() which is smart about whether to
+       * follow the request or do something else (though not smart enough
+       * and is also too stupid to handle the sibling stuff).
+       */
+      switch (event->xclient.data.l[2])
+        {
+        case Above:
+          meta_window_raise (window);
+          break;
+        case Below:
+          meta_window_lower (window);
+          break;
+        case TopIf:
+        case BottomIf:
+        case Opposite:
+          break;          
+        }
+    }
+}
+#endif
+
+/* We do some of our event handling in core/frames.c, which expects
+ * GDK events delivered by GTK+.  However, since the transition to
+ * client side windows, we can't let GDK see button events, since the
+ * client-side tracking of implicit and explicit grabs it does will
+ * get confused by our direct use of X grabs.
+ *
+ * So we do a very minimal GDK => GTK event conversion here and send on the
+ * events we care about, and then filter them out so they don't go
+ * through the normal GDK event handling.
+ *
+ * To reduce the amount of code, the only events fields filled out
+ * below are the ones that frames.c uses. If frames.c is modified to
+ * use more fields, more fields need to be filled out below.
+ * 
+ * https://github.com/stefano-k/Mate-Desktop-Environment/commit/b0e5fb03eb21dae8f02692f11ef391bfc5ccba33
+ */
+
+static gboolean maybe_send_event_to_gtk(MetaDisplay* display, XEvent* xevent)
+{
+	/* We're always using the default display */
+	GdkDisplay* gdk_display = gdk_display_get_default();
+	GdkEvent gdk_event;
+	GdkWindow* gdk_window;
+	Window window;
+
+	switch (xevent->type)
+	{
+		case ButtonPress:
+		case ButtonRelease:
+			window = xevent->xbutton.window;
+			break;
+
+		case MotionNotify:
+			window = xevent->xmotion.window;
+			break;
+
+		case EnterNotify:
+
+		case LeaveNotify:
+			window = xevent->xcrossing.window;
+			break;
+
+		default:
+			return FALSE;
+	}
+
+	gdk_window = gdk_window_lookup_for_display(gdk_display, window);
+
+	if (gdk_window == NULL)
+	{
+		return FALSE;
+	}
+
+	/* If GDK already things it has a grab, we better let it see events; this
+	 * is the menu-navigation case and events need to get sent to the appropriate
+	 * (client-side) subwindow for individual menu items.
+	 */
+
+	if (gdk_display_pointer_is_grabbed(gdk_display))
+	{
+		return FALSE;
+	}
+
+	memset(&gdk_event, 0, sizeof(gdk_event));
+
+	switch (xevent->type)
+	{
+
+		case ButtonPress:
+
+		case ButtonRelease:
+
+			if (xevent->type == ButtonPress)
+			{
+				GtkSettings* settings = gtk_settings_get_default();
+
+				int double_click_time;
+				int double_click_distance;
+
+				g_object_get (settings,
+					"gtk-double-click-time", &double_click_time,
+					"gtk-double-click-distance", &double_click_distance,
+					NULL);
+
+				if (xevent->xbutton.button == display->button_click_number &&
+					xevent->xbutton.window == display->button_click_window &&
+					xevent->xbutton.time < display->button_click_time + double_click_time &&
+					ABS(xevent->xbutton.x - display->button_click_x) <= double_click_distance &&
+					ABS (xevent->xbutton.y - display->button_click_y) <= double_click_distance)
+				{
+
+					gdk_event.button.type = GDK_2BUTTON_PRESS;
+					display->button_click_number = 0;
+				}
+				else
+				{
+					gdk_event.button.type = GDK_BUTTON_PRESS;
+					display->button_click_number = xevent->xbutton.button;
+					display->button_click_window = xevent->xbutton.window;
+					display->button_click_time = xevent->xbutton.time;
+					display->button_click_x = xevent->xbutton.x;
+					display->button_click_y = xevent->xbutton.y;
+				}
+			}
+			else
+			{
+				gdk_event.button.type = GDK_BUTTON_RELEASE;
+			}
+
+			gdk_event.button.window = gdk_window;
+			gdk_event.button.button = xevent->xbutton.button;
+			gdk_event.button.time = xevent->xbutton.time;
+			gdk_event.button.x = xevent->xbutton.x;
+			gdk_event.button.y = xevent->xbutton.y;
+			gdk_event.button.x_root = xevent->xbutton.x_root;
+			gdk_event.button.y_root = xevent->xbutton.y_root;
+
+			break;
+
+		case MotionNotify:
+			gdk_event.motion.type = GDK_MOTION_NOTIFY;
+			gdk_event.motion.window = gdk_window;
+			break;
+
+		case EnterNotify:
+
+		case LeaveNotify:
+			gdk_event.crossing.type = xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY;
+			gdk_event.crossing.window = gdk_window;
+			gdk_event.crossing.x = xevent->xcrossing.x;
+			gdk_event.crossing.y = xevent->xcrossing.y;
+			break;
+
+		default:
+			g_assert_not_reached();
+			break;
+	}
+
+	/* If we've gotten here, we've filled in the gdk_event and should send it on */
+	gtk_main_do_event(&gdk_event);
+	return TRUE;
+}
+
+/**
+ * This is the most important function in the whole program. It is the heart,
+ * it is the nexus, it is the Grand Central Station of Marco's world.
+ * When we create a MetaDisplay, we ask GDK to pass *all* events for *all*
+ * windows to this function. So every time anything happens that we might
+ * want to know about, this function gets called. You see why it gets a bit
+ * busy around here. Most of this function is a ginormous switch statement
+ * dealing with all the kinds of events that might turn up.
+ *
+ * \param event The event that just happened
+ * \param data  The MetaDisplay that events are coming from, cast to a gpointer
+ *              so that it can be sent to a callback
+ *
+ * \ingroup main
+ */
+static gboolean event_callback(XEvent* event, gpointer data)
+{
+  MetaWindow *window;
+  MetaWindow *property_for_window;
+  MetaDisplay *display;
+  Window modified;
+  gboolean frame_was_receiver;
+  gboolean filter_out_event;
+
+  display = data;
+  
+#ifdef WITH_VERBOSE_MODE
+  if (dump_events)
+    meta_spew_event (display, event);
+#endif
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  sn_display_process_event (display->sn_display, event);
+#endif
+  
+  filter_out_event = FALSE;
+  display->current_time = event_get_time (display, event);
+  display->xinerama_cache_invalidated = TRUE;
+  
+  modified = event_get_modified_window (display, event);
+  
+  if (event->type == ButtonPress)
+    {
+      /* filter out scrollwheel */
+      if (event->xbutton.button == 4 ||
+	  event->xbutton.button == 5)
+	return FALSE;
+    }
+  else if (event->type == UnmapNotify)
+    {
+      if (meta_ui_window_should_not_cause_focus (display->xdisplay,
+                                                 modified))
+        {
+          add_ignored_serial (display, event->xany.serial);
+          meta_topic (META_DEBUG_FOCUS,
+                      "Adding EnterNotify serial %lu to ignored focus serials\n",
+                      event->xany.serial);
+        }
+    }
+  else if (event->type == LeaveNotify &&
+           event->xcrossing.mode == NotifyUngrab &&
+           modified == display->ungrab_should_not_cause_focus_window)
+    {
+      add_ignored_serial (display, event->xany.serial);
+      meta_topic (META_DEBUG_FOCUS,
+                  "Adding LeaveNotify serial %lu to ignored focus serials\n",
+                  event->xany.serial);
+    }
+
+  if (modified != None)
+    window = meta_display_lookup_x_window (display, modified);
+  else
+    window = NULL;
+
+  /* We only want to respond to _NET_WM_USER_TIME property notify
+   * events on _NET_WM_USER_TIME_WINDOW windows; in particular,
+   * responding to UnmapNotify events is kind of bad.
+   */
+  property_for_window = NULL;
+  if (window && modified == window->user_time_window)
+    {
+      property_for_window = window;
+      window = NULL;
+    }
+    
+
+  frame_was_receiver = FALSE;
+  if (window &&
+      window->frame &&
+      modified == window->frame->xwindow)
+    {
+      /* Note that if the frame and the client both have an
+       * XGrabButton (as is normal with our setup), the event
+       * goes to the frame.
+       */
+      frame_was_receiver = TRUE;
+      meta_topic (META_DEBUG_EVENTS, "Frame was receiver of event for %s\n",
+                  window->desc);
+    }
+
+#ifdef HAVE_XSYNC
+  if (META_DISPLAY_HAS_XSYNC (display) && 
+      event->type == (display->xsync_event_base + XSyncAlarmNotify) &&
+      ((XSyncAlarmNotifyEvent*)event)->alarm == display->grab_sync_request_alarm)
+    {
+      filter_out_event = TRUE; /* GTK doesn't want to see this really */
+      
+      if (display->grab_op != META_GRAB_OP_NONE &&
+          display->grab_window != NULL &&
+          grab_op_is_mouse (display->grab_op))
+	meta_window_handle_mouse_grab_op_event (display->grab_window, event);
+    }
+#endif /* HAVE_XSYNC */
+
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (display) && 
+      event->type == (display->shape_event_base + ShapeNotify))
+    {
+      filter_out_event = TRUE; /* GTK doesn't want to see this really */
+      
+      if (window && !frame_was_receiver)
+        {
+          XShapeEvent *sev = (XShapeEvent*) event;
+
+          if (sev->kind == ShapeBounding)
+            {
+              if (sev->shaped && !window->has_shape)
+                {
+                  window->has_shape = TRUE;                  
+                  meta_topic (META_DEBUG_SHAPES,
+                              "Window %s now has a shape\n",
+                              window->desc);
+                }
+              else if (!sev->shaped && window->has_shape)
+                {
+                  window->has_shape = FALSE;
+                  meta_topic (META_DEBUG_SHAPES,
+                              "Window %s no longer has a shape\n",
+                              window->desc);
+                }
+              else
+                {
+                  meta_topic (META_DEBUG_SHAPES,
+                              "Window %s shape changed\n",
+                              window->desc);
+                }
+
+              if (window->frame)
+                {
+                  window->frame->need_reapply_frame_shape = TRUE;
+		  meta_warning("from event callback\n");		  
+                  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+                }
+            }
+        }
+      else
+        {
+          meta_topic (META_DEBUG_SHAPES,
+                      "ShapeNotify not on a client window (window %s frame_was_receiver = %d)\n",
+                      window ? window->desc : "(none)",
+                      frame_was_receiver);
+        }
+    }
+#endif /* HAVE_SHAPE */
+
+  if (window && ((event->type == KeyPress) || (event->type == ButtonPress)))
+    {
+      if (CurrentTime == display->current_time)
+        {
+          /* We can't use missing (i.e. invalid) timestamps to set user time,
+           * nor do we want to use them to sanity check other timestamps.
+           * See bug 313490 for more details.
+           */
+          meta_warning ("Event has no timestamp! You may be using a broken "
+                        "program such as xse.  Please ask the authors of that "
+                        "program to fix it.\n");
+        }
+      else
+        {
+          meta_window_set_user_time (window, display->current_time);
+          sanity_check_timestamps (display, display->current_time);
+        }
+    }
+  
+  switch (event->type)
+    {
+    case KeyPress:
+    case KeyRelease:
+      meta_display_process_key_event (display, window, event);
+      break;
+    case ButtonPress:
+      if ((window &&
+           grab_op_is_mouse (display->grab_op) &&
+           display->grab_button != (int) event->xbutton.button &&
+           display->grab_window == window) ||
+          grab_op_is_keyboard (display->grab_op))
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "Ending grab op %u on window %s due to button press\n",
+                      display->grab_op,
+                      (display->grab_window ?
+                       display->grab_window->desc : 
+                       "none"));
+          if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
+            {
+              MetaScreen *screen;
+              meta_topic (META_DEBUG_WINDOW_OPS, 
+                          "Syncing to old stack positions.\n");
+              screen = 
+                meta_display_screen_for_root (display, event->xany.window);
+
+              if (screen!=NULL)
+                meta_stack_set_positions (screen->stack,
+                                          display->grab_old_window_stacking);
+            }
+          meta_display_end_grab_op (display,
+                                    event->xbutton.time);
+        }
+      else if (window && display->grab_op == META_GRAB_OP_NONE)
+        {
+          gboolean begin_move = FALSE;
+          unsigned int grab_mask;
+          gboolean unmodified;
+
+          grab_mask = display->window_grab_modifiers;
+          if (g_getenv ("MARCO_DEBUG_BUTTON_GRABS"))
+            grab_mask |= ControlMask;
+
+          /* Two possible sources of an unmodified event; one is a
+           * client that's letting button presses pass through to the
+           * frame, the other is our focus_window_grab on unmodified
+           * button 1.  So for all such events we focus the window.
+           */
+          unmodified = (event->xbutton.state & grab_mask) == 0;
+          
+          if (unmodified ||
+              event->xbutton.button == 1)
+            {
+              /* don't focus if frame received, will be lowered in
+               * frames.c or special-cased if the click was on a
+               * minimize/close button.
+               */
+              if (!frame_was_receiver)
+                {
+                  if (meta_prefs_get_raise_on_click ()) 
+                    meta_window_raise (window);
+                  else
+                    meta_topic (META_DEBUG_FOCUS,
+                                "Not raising window on click due to don't-raise-on-click option\n");
+
+                  /* Don't focus panels--they must explicitly request focus.
+                   * See bug 160470
+                   */
+		  if (window->type != META_WINDOW_DOCK)
+                    {
+                      meta_topic (META_DEBUG_FOCUS,
+                                  "Focusing %s due to unmodified button %u press (display.c)\n",
+                                  window->desc, event->xbutton.button);
+                      meta_window_focus (window, event->xbutton.time);
+                    }
+                  else
+                    /* However, do allow terminals to lose focus due to new
+                     * window mappings after the user clicks on a panel.
+                     */
+                    display->allow_terminal_deactivation = TRUE;
+                }
+              
+              /* you can move on alt-click but not on
+               * the click-to-focus
+               */
+              if (!unmodified)
+                begin_move = TRUE;
+            }
+          else if (!unmodified && event->xbutton.button == meta_prefs_get_mouse_button_resize())
+            {
+              if (window->has_resize_func)
+                {
+                  gboolean north, south;
+                  gboolean west, east;
+                  int root_x, root_y;
+                  MetaGrabOp op;
+
+                  meta_window_get_position (window, &root_x, &root_y);
+
+                  west = event->xbutton.x_root <  (root_x + 1 * window->rect.width  / 3);
+                  east = event->xbutton.x_root >  (root_x + 2 * window->rect.width  / 3);
+                  north = event->xbutton.y_root < (root_y + 1 * window->rect.height / 3);
+                  south = event->xbutton.y_root > (root_y + 2 * window->rect.height / 3);
+
+                  if (north && west)
+                    op = META_GRAB_OP_RESIZING_NW;
+                  else if (north && east)
+                    op = META_GRAB_OP_RESIZING_NE;
+                  else if (south && west)
+                    op = META_GRAB_OP_RESIZING_SW;
+                  else if (south && east)
+                    op = META_GRAB_OP_RESIZING_SE;
+                  else if (north)
+                    op = META_GRAB_OP_RESIZING_N;
+                  else if (west)
+                    op = META_GRAB_OP_RESIZING_W;
+                  else if (east)
+                    op = META_GRAB_OP_RESIZING_E;
+                  else if (south)
+                    op = META_GRAB_OP_RESIZING_S;
+                  else /* Middle region is no-op to avoid user triggering wrong action */
+                    op = META_GRAB_OP_NONE;
+                  
+                  if (op != META_GRAB_OP_NONE)
+                    meta_display_begin_grab_op (display,
+                                                window->screen,
+                                                window,
+                                                op,
+                                                TRUE,
+                                                FALSE,
+                                                event->xbutton.button,
+                                                0,
+                                                event->xbutton.time,
+                                                event->xbutton.x_root,
+                                                event->xbutton.y_root);
+                }
+            }
+          else if (event->xbutton.button == meta_prefs_get_mouse_button_menu())
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_show_menu (window,
+                                     event->xbutton.x_root,
+                                     event->xbutton.y_root,
+                                     event->xbutton.button,
+                                     event->xbutton.time);
+            }
+
+          if (!frame_was_receiver && unmodified)
+            {
+              /* This is from our synchronous grab since
+               * it has no modifiers and was on the client window
+               */
+              int mode;
+              
+              /* When clicking a different app in click-to-focus
+               * in application-based mode, and the different
+               * app is not a dock or desktop, eat the focus click.
+               */
+              if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK &&
+                  meta_prefs_get_application_based () &&
+                  !window->has_focus &&
+                  window->type != META_WINDOW_DOCK &&
+                  window->type != META_WINDOW_DESKTOP &&
+                  (display->focus_window == NULL ||
+                   !meta_window_same_application (window,
+                                                  display->focus_window)))
+                mode = AsyncPointer; /* eat focus click */
+              else
+                mode = ReplayPointer; /* give event back */
+
+              meta_verbose ("Allowing events mode %s time %u\n",
+                            mode == AsyncPointer ? "AsyncPointer" : "ReplayPointer",
+                            (unsigned int)event->xbutton.time);
+              
+              XAllowEvents (display->xdisplay,
+                            mode, event->xbutton.time);
+            }
+
+          if (begin_move && window->has_move_func)
+            {
+              meta_display_begin_grab_op (display,
+                                          window->screen,
+                                          window,
+                                          META_GRAB_OP_MOVING,
+                                          TRUE,
+                                          FALSE,
+                                          event->xbutton.button,
+                                          0,
+                                          event->xbutton.time,
+                                          event->xbutton.x_root,
+                                          event->xbutton.y_root);
+            }
+        }
+      break;
+    case ButtonRelease:
+      if (display->grab_window == window &&
+          grab_op_is_mouse (display->grab_op))
+        meta_window_handle_mouse_grab_op_event (window, event);
+      break;
+    case MotionNotify:
+      if (display->grab_window == window &&
+          grab_op_is_mouse (display->grab_op))
+        meta_window_handle_mouse_grab_op_event (window, event);
+      break;
+    case EnterNotify:
+      if (display->grab_window == window &&
+          grab_op_is_mouse (display->grab_op))
+        {
+          meta_window_handle_mouse_grab_op_event (window, event);
+          break;
+        }
+
+      /* If the mouse switches screens, active the default window on the new
+       * screen; this will make keybindings and workspace-launched items
+       * actually appear on the right screen.
+       */
+      {
+        MetaScreen *new_screen = 
+          meta_display_screen_for_root (display, event->xcrossing.root);
+
+        if (new_screen != NULL && display->active_screen != new_screen)
+          meta_workspace_focus_default_window (new_screen->active_workspace, 
+                                               NULL,
+                                               event->xcrossing.time);
+      }
+
+      /* Check if we've entered a window; do this even if window->has_focus to
+       * avoid races.
+       */
+      if (window && !serial_is_ignored (display, event->xany.serial) &&
+               event->xcrossing.mode != NotifyGrab && 
+               event->xcrossing.mode != NotifyUngrab &&
+               event->xcrossing.detail != NotifyInferior &&
+               meta_display_focus_sentinel_clear (display))
+        {
+          switch (meta_prefs_get_focus_mode ())
+            {
+            case META_FOCUS_MODE_SLOPPY:
+            case META_FOCUS_MODE_MOUSE:
+              display->mouse_mode = TRUE;
+              if (window->type != META_WINDOW_DOCK &&
+                  window->type != META_WINDOW_DESKTOP)
+                {
+                  meta_topic (META_DEBUG_FOCUS,
+                              "Focusing %s due to enter notify with serial %lu "
+                              "at time %lu, and setting display->mouse_mode to "
+                              "TRUE.\n",
+                              window->desc, 
+                              event->xany.serial,
+                              event->xcrossing.time);
+
+                  meta_window_focus (window, event->xcrossing.time);
+
+                  /* stop ignoring stuff */
+                  reset_ignores (display);
+                  
+                  if (meta_prefs_get_auto_raise ()) 
+                    {
+                      meta_display_queue_autoraise_callback (display, window);
+                    }
+                  else
+                    {
+                      meta_topic (META_DEBUG_FOCUS,
+                                  "Auto raise is disabled\n");		      
+                    }
+                }
+              /* In mouse focus mode, we defocus when the mouse *enters*
+               * the DESKTOP window, instead of defocusing on LeaveNotify.
+               * This is because having the mouse enter override-redirect
+               * child windows unfortunately causes LeaveNotify events that
+               * we can't distinguish from the mouse actually leaving the
+               * toplevel window as we expect.  But, since we filter out
+               * EnterNotify events on override-redirect windows, this
+               * alternative mechanism works great.
+               */
+              if (window->type == META_WINDOW_DESKTOP &&
+                  meta_prefs_get_focus_mode() == META_FOCUS_MODE_MOUSE &&
+                  display->expected_focus_window != NULL)
+                {
+                  meta_topic (META_DEBUG_FOCUS,
+                              "Unsetting focus from %s due to mouse entering "
+                              "the DESKTOP window\n",
+                              display->expected_focus_window->desc);
+                  meta_display_focus_the_no_focus_window (display, 
+                                                          window->screen,
+                                                          event->xcrossing.time);
+                }
+              break;
+            case META_FOCUS_MODE_CLICK:
+              break;
+            }
+          
+          if (window->type == META_WINDOW_DOCK)
+            meta_window_raise (window);
+        }
+      break;
+    case LeaveNotify:
+      if (display->grab_window == window &&
+          grab_op_is_mouse (display->grab_op))
+        meta_window_handle_mouse_grab_op_event (window, event);
+      else if (window != NULL)
+        {
+          if (window->type == META_WINDOW_DOCK &&
+              event->xcrossing.mode != NotifyGrab &&
+              event->xcrossing.mode != NotifyUngrab &&
+              !window->has_focus)
+            meta_window_lower (window);
+        }
+      break;
+    case FocusIn:
+    case FocusOut:
+      if (window)
+        {
+          meta_window_notify_focus (window, event);
+        }
+      else if (meta_display_xwindow_is_a_no_focus_window (display,
+                                                          event->xany.window))
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focus %s event received on no_focus_window 0x%lx "
+                      "mode %s detail %s\n",
+                      event->type == FocusIn ? "in" :
+                      event->type == FocusOut ? "out" :
+                      "???",
+                      event->xany.window,
+                      meta_event_mode_to_string (event->xfocus.mode),
+                      meta_event_detail_to_string (event->xfocus.detail));
+        }
+      else
+        {
+          MetaScreen *screen =
+                meta_display_screen_for_root(display,
+                                             event->xany.window);
+          if (screen == NULL)
+            break;
+
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focus %s event received on root window 0x%lx "
+                      "mode %s detail %s\n",
+                      event->type == FocusIn ? "in" :
+                      event->type == FocusOut ? "out" :
+                      "???",
+                      event->xany.window,
+                      meta_event_mode_to_string (event->xfocus.mode),
+                      meta_event_detail_to_string (event->xfocus.detail));
+          
+          if (event->type == FocusIn &&
+              event->xfocus.detail == NotifyDetailNone)
+            {
+              meta_topic (META_DEBUG_FOCUS, 
+                          "Focus got set to None, probably due to "
+                          "brain-damage in the X protocol (see bug "
+                          "125492).  Setting the default focus window.\n");
+              meta_workspace_focus_default_window (screen->active_workspace,
+                                                   NULL,
+                                                   meta_display_get_current_time_roundtrip (display));
+            }
+          else if (event->type == FocusIn &&
+              event->xfocus.mode == NotifyNormal &&
+              event->xfocus.detail == NotifyInferior)
+            {
+              meta_topic (META_DEBUG_FOCUS,
+                          "Focus got set to root window, probably due to "
+                          "mate-session logout dialog usage (see bug "
+                          "153220).  Setting the default focus window.\n");
+              meta_workspace_focus_default_window (screen->active_workspace,
+                                                   NULL,
+                                                   meta_display_get_current_time_roundtrip (display));
+            }
+
+        }
+      break;
+    case KeymapNotify:
+      break;
+    case Expose:
+      break;
+    case GraphicsExpose:
+      break;
+    case NoExpose:
+      break;
+    case VisibilityNotify:
+      break;
+    case CreateNotify:
+      break;
+      
+    case DestroyNotify:
+      if (window)
+        {
+          /* FIXME: It sucks that DestroyNotify events don't come with
+           * a timestamp; could we do something better here?  Maybe X
+           * will change one day?
+           */
+          guint32 timestamp;
+          timestamp = meta_display_get_current_time_roundtrip (display);
+
+          if (display->grab_op != META_GRAB_OP_NONE &&
+              display->grab_window == window)
+            meta_display_end_grab_op (display, timestamp);
+          
+          if (frame_was_receiver)
+            {
+              meta_warning ("Unexpected destruction of frame 0x%lx, not sure if this should silently fail or be considered a bug\n",
+                            window->frame->xwindow);
+              meta_error_trap_push (display);
+              meta_window_destroy_frame (window->frame->window);
+              meta_error_trap_pop (display, FALSE);
+            }
+          else
+            {
+              /* Unmanage destroyed window */
+              meta_window_free (window, timestamp);
+              window = NULL;
+            }
+        }
+      break;
+    case UnmapNotify:
+      if (window)
+        {
+          /* FIXME: It sucks that UnmapNotify events don't come with
+           * a timestamp; could we do something better here?  Maybe X
+           * will change one day?
+           */
+          guint32 timestamp;
+          timestamp = meta_display_get_current_time_roundtrip (display);
+
+          if (display->grab_op != META_GRAB_OP_NONE &&
+              display->grab_window == window &&
+              ((window->frame == NULL) || !window->frame->mapped))
+            meta_display_end_grab_op (display, timestamp);
+      
+          if (!frame_was_receiver)
+            {
+              if (window->unmaps_pending == 0)
+                {
+                  meta_topic (META_DEBUG_WINDOW_STATE,
+                              "Window %s withdrawn\n",
+                              window->desc);
+
+                  meta_effect_run_close (window, NULL, NULL);
+
+                  /* Unmanage withdrawn window */		  
+                  window->withdrawn = TRUE;
+                  meta_window_free (window, timestamp);
+                  window = NULL;
+                }
+              else
+                {
+                  window->unmaps_pending -= 1;
+                  meta_topic (META_DEBUG_WINDOW_STATE,
+                              "Received pending unmap, %d now pending\n",
+                              window->unmaps_pending);
+                }
+            }
+
+          /* Unfocus on UnmapNotify, do this after the possible
+           * window_free above so that window_free can see if window->has_focus
+           * and move focus to another window
+           */
+          if (window)
+            meta_window_notify_focus (window, event);
+        }
+      break;
+    case MapNotify:
+      break;
+    case MapRequest:
+      if (window == NULL)
+        {
+          window = meta_window_new (display, event->xmaprequest.window,
+                                    FALSE);
+        }
+      /* if frame was receiver it's some malicious send event or something */
+      else if (!frame_was_receiver && window)        
+        {
+          meta_verbose ("MapRequest on %s mapped = %d minimized = %d\n",
+                        window->desc, window->mapped, window->minimized);
+          if (window->minimized)
+            {
+              meta_window_unminimize (window);
+              if (window->workspace != window->screen->active_workspace)
+                {
+                  meta_verbose ("Changing workspace due to MapRequest mapped = %d minimized = %d\n",
+                                window->mapped, window->minimized);
+                  meta_window_change_workspace (window,
+                                                window->screen->active_workspace);
+                }
+            }
+        }
+      break;
+    case ReparentNotify:
+      break;
+    case ConfigureNotify:
+      /* Handle screen resize */
+      {
+	MetaScreen *screen;
+
+        screen = meta_display_screen_for_root (display,
+                                               event->xconfigure.window);
+
+	if (screen != NULL)
+          {
+#ifdef HAVE_RANDR
+            /* do the resize the official way */
+            XRRUpdateConfiguration (event);
+#else
+            /* poke around in Xlib */
+            screen->xscreen->width   = event->xconfigure.width;
+            screen->xscreen->height  = event->xconfigure.height;
+#endif
+            
+            meta_screen_resize (screen, 
+                                event->xconfigure.width,
+                                event->xconfigure.height);
+          }
+      }
+      break;
+    case ConfigureRequest:
+      /* This comment and code is found in both twm and fvwm */
+      /*
+       * According to the July 27, 1988 ICCCM draft, we should ignore size and
+       * position fields in the WM_NORMAL_HINTS property when we map a window.
+       * Instead, we'll read the current geometry.  Therefore, we should respond
+       * to configuration requests for windows which have never been mapped.
+       */
+      if (window == NULL)
+        {
+          unsigned int xwcm;
+          XWindowChanges xwc;
+          
+          xwcm = event->xconfigurerequest.value_mask &
+            (CWX | CWY | CWWidth | CWHeight | CWBorderWidth);
+
+          xwc.x = event->xconfigurerequest.x;
+          xwc.y = event->xconfigurerequest.y;
+          xwc.width = event->xconfigurerequest.width;
+          xwc.height = event->xconfigurerequest.height;
+          xwc.border_width = event->xconfigurerequest.border_width;
+
+          meta_verbose ("Configuring withdrawn window to %d,%d %dx%d border %d (some values may not be in mask)\n",
+                        xwc.x, xwc.y, xwc.width, xwc.height, xwc.border_width);
+          meta_error_trap_push (display);
+          XConfigureWindow (display->xdisplay, event->xconfigurerequest.window,
+                            xwcm, &xwc);
+          meta_error_trap_pop (display, FALSE);
+        }
+      else
+        {
+          if (!frame_was_receiver)
+            meta_window_configure_request (window, event);
+        }
+      break;
+    case GravityNotify:
+      break;
+    case ResizeRequest:
+      break;
+    case CirculateNotify:
+      break;
+    case CirculateRequest:
+      break;
+    case PropertyNotify:
+      {
+        MetaGroup *group;
+        MetaScreen *screen;
+        
+        if (window && !frame_was_receiver)
+          meta_window_property_notify (window, event);
+        else if (property_for_window && !frame_was_receiver)
+          meta_window_property_notify (property_for_window, event);
+
+        group = meta_display_lookup_group (display,
+                                           event->xproperty.window);
+        if (group != NULL)
+          meta_group_property_notify (group, event);
+        
+        screen = NULL;
+        if (window == NULL &&
+            group == NULL) /* window/group != NULL means it wasn't a root window */
+          screen = meta_display_screen_for_root (display,
+                                                 event->xproperty.window);
+            
+        if (screen != NULL)
+          {
+            if (event->xproperty.atom ==
+                display->atom__NET_DESKTOP_LAYOUT)
+              meta_screen_update_workspace_layout (screen);
+            else if (event->xproperty.atom ==
+                     display->atom__NET_DESKTOP_NAMES)
+              meta_screen_update_workspace_names (screen);
+#if 0
+            else if (event->xproperty.atom ==
+                     display->atom__NET_RESTACK_WINDOW)
+              handle_net_restack_window (display, event);
+#endif
+
+            /* we just use this property as a sentinel to avoid
+             * certain race conditions.  See the comment for the
+             * sentinel_counter variable declaration in display.h
+	     */
+	    if (event->xproperty.atom ==
+		display->atom__MARCO_SENTINEL)
+	      {
+		meta_display_decrement_focus_sentinel (display);
+	      }
+          }
+      }
+      break;
+    case SelectionClear:
+      /* do this here instead of at end of function
+       * so we can return
+       */
+
+      /* FIXME: Clearing display->current_time here makes no sense to
+       * me; who put this here and why?
+       */
+      display->current_time = CurrentTime;
+
+      process_selection_clear (display, event);
+      /* Note that processing that may have resulted in
+       * closing the display... so return right away.
+       */
+      return FALSE;
+    case SelectionRequest:
+      process_selection_request (display, event);
+      break;
+    case SelectionNotify:
+      break;
+    case ColormapNotify:
+      if (window && !frame_was_receiver)
+        window->colormap = event->xcolormap.colormap;
+      break;
+    case ClientMessage:
+      if (window)
+        {
+          if (!frame_was_receiver)
+            meta_window_client_message (window, event);
+        }
+      else
+        {
+          MetaScreen *screen;
+
+          screen = meta_display_screen_for_root (display,
+                                                 event->xclient.window);
+          
+          if (screen)
+            {
+              if (event->xclient.message_type ==
+                  display->atom__NET_CURRENT_DESKTOP)
+                {
+                  int space;
+                  MetaWorkspace *workspace;
+                  guint32 time;
+              
+                  space = event->xclient.data.l[0];
+                  time = event->xclient.data.l[1];
+              
+                  meta_verbose ("Request to change current workspace to %d with "
+                                "specified timestamp of %u\n",
+                                space, time);
+
+                  workspace =
+                    meta_screen_get_workspace_by_index (screen,
+                                                        space);
+
+                  /* Handle clients using the older version of the spec... */
+                  if (time == 0 && workspace)
+                    {
+                      meta_warning ("Received a NET_CURRENT_DESKTOP message "
+                                    "from a broken (outdated) client who sent "
+                                    "a 0 timestamp\n");
+                      time = meta_display_get_current_time_roundtrip (display);
+                    }
+
+                  if (workspace)
+                    meta_workspace_activate (workspace, time);
+                  else
+                    meta_verbose ("Don't know about workspace %d\n", space);
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__NET_NUMBER_OF_DESKTOPS)
+                {
+                  int num_spaces;
+              
+                  num_spaces = event->xclient.data.l[0];
+              
+                  meta_verbose ("Request to set number of workspaces to %d\n",
+                                num_spaces);
+
+                  meta_prefs_set_num_workspaces (num_spaces);
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__NET_SHOWING_DESKTOP)
+                {
+                  gboolean showing_desktop;
+                  guint32  timestamp;
+                  
+                  showing_desktop = event->xclient.data.l[0] != 0;
+                  /* FIXME: Braindead protocol doesn't have a timestamp */
+                  timestamp = meta_display_get_current_time_roundtrip (display);
+                  meta_verbose ("Request to %s desktop\n",
+                                showing_desktop ? "show" : "hide");
+                  
+                  if (showing_desktop)
+                    meta_screen_show_desktop (screen, timestamp);
+                  else
+                    {
+                      meta_screen_unshow_desktop (screen);
+                      meta_workspace_focus_default_window (screen->active_workspace, NULL, timestamp);
+                    }
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__MARCO_RESTART_MESSAGE)
+                {
+                  meta_verbose ("Received restart request\n");
+                  meta_restart ();
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__MARCO_RELOAD_THEME_MESSAGE)
+                {
+                  meta_verbose ("Received reload theme request\n");
+                  meta_ui_set_current_theme (meta_prefs_get_theme (),
+                                             TRUE);
+                  meta_display_retheme_all ();
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__MARCO_SET_KEYBINDINGS_MESSAGE)
+                {
+                  meta_verbose ("Received set keybindings request = %d\n",
+                                (int) event->xclient.data.l[0]);
+                  meta_set_keybindings_disabled (!event->xclient.data.l[0]);
+                }
+              else if (event->xclient.message_type ==
+                       display->atom__MARCO_TOGGLE_VERBOSE)
+                {
+                  meta_verbose ("Received toggle verbose message\n");
+                  meta_set_verbose (!meta_is_verbose ());
+                }
+	      else if (event->xclient.message_type ==
+		       display->atom_WM_PROTOCOLS) 
+		{
+                  meta_verbose ("Received WM_PROTOCOLS message\n");
+                  
+		  if ((Atom)event->xclient.data.l[0] == display->atom__NET_WM_PING)
+                    {
+                      process_pong_message (display, event);
+
+                      /* We don't want ping reply events going into
+                       * the GTK+ event loop because gtk+ will treat
+                       * them as ping requests and send more replies.
+                       */
+                      filter_out_event = TRUE;
+                    }
+		}
+            }
+
+          if (event->xclient.message_type ==
+              display->atom__NET_REQUEST_FRAME_EXTENTS)
+            {
+              meta_verbose ("Received _NET_REQUEST_FRAME_EXTENTS message\n");
+              process_request_frame_extents (display, event);
+            }
+        }
+      break;
+    case MappingNotify:
+      {
+        gboolean ignore_current;
+
+        ignore_current = FALSE;
+        
+        /* Check whether the next event is an identical MappingNotify
+         * event.  If it is, ignore the current event, we'll update
+         * when we get the next one.
+         */
+	if (XPending (display->xdisplay))
+          {
+            XEvent next_event;
+            
+            XPeekEvent (display->xdisplay, &next_event);
+            
+            if (next_event.type == MappingNotify &&
+                next_event.xmapping.request == event->xmapping.request)
+              ignore_current = TRUE;
+          }
+
+        if (!ignore_current)
+          {
+            /* Let XLib know that there is a new keyboard mapping.
+             */
+            XRefreshKeyboardMapping (&event->xmapping);
+            meta_display_process_mapping_event (display, event);
+          }
+      }
+      break;
+    default:
+#ifdef HAVE_XKB
+      if (event->type == display->xkb_base_event_type) 
+	{
+	  XkbAnyEvent *xkb_ev = (XkbAnyEvent *) event;
+	  
+	  switch (xkb_ev->xkb_type)
+	    {
+	    case XkbBellNotify:
+              if (XSERVER_TIME_IS_BEFORE(display->last_bell_time,
+                                         xkb_ev->time - 100))
+                {
+                  display->last_bell_time = xkb_ev->time;
+                  meta_bell_notify (display, xkb_ev);
+                }
+	      break;
+	    }
+	}
+#endif
+      break;
+    }
+
+	if (display->compositor)
+	{
+		meta_compositor_process_event (display->compositor, event, window);
+	}
+  
+	/* generates event on wrong window.
+  	 * https://github.com/stefano-k/Mate-Desktop-Environment/commit/b0e5fb03eb21dae8f02692f11ef391bfc5ccba33
+  	 */
+	if (maybe_send_event_to_gtk(display, event))
+	{
+		filter_out_event = TRUE;
+	}
+
+	display->current_time = CurrentTime;
+	return filter_out_event;
+}
+
+/* Return the window this has to do with, if any, rather
+ * than the frame or root window that was selecting
+ * for substructure
+ */
+static Window
+event_get_modified_window (MetaDisplay *display,
+                           XEvent *event)
+{
+  switch (event->type)
+    {
+    case KeyPress:
+    case KeyRelease:
+    case ButtonPress:
+    case ButtonRelease:
+    case MotionNotify:
+    case FocusIn:
+    case FocusOut:
+    case KeymapNotify:
+    case Expose:
+    case GraphicsExpose:
+    case NoExpose:
+    case VisibilityNotify:
+    case ResizeRequest:
+    case PropertyNotify:
+    case SelectionClear:
+    case SelectionRequest:
+    case SelectionNotify:
+    case ColormapNotify:
+    case ClientMessage:
+    case EnterNotify:
+    case LeaveNotify:
+      return event->xany.window;
+      
+    case CreateNotify:
+      return event->xcreatewindow.window;
+      
+    case DestroyNotify:
+      return event->xdestroywindow.window;
+
+    case UnmapNotify:
+      return event->xunmap.window;
+
+    case MapNotify:
+      return event->xmap.window;
+
+    case MapRequest:
+      return event->xmaprequest.window;
+
+    case ReparentNotify:
+     return event->xreparent.window;
+      
+    case ConfigureNotify:
+      return event->xconfigure.window;
+      
+    case ConfigureRequest:
+      return event->xconfigurerequest.window;
+
+    case GravityNotify:
+      return event->xgravity.window;
+
+    case CirculateNotify:
+      return event->xcirculate.window;
+
+    case CirculateRequest:
+      return event->xcirculaterequest.window;
+
+    case MappingNotify:
+      return None;
+
+    default:
+#ifdef HAVE_SHAPE
+      if (META_DISPLAY_HAS_SHAPE (display) && 
+          event->type == (display->shape_event_base + ShapeNotify))
+        {
+          XShapeEvent *sev = (XShapeEvent*) event;
+          return sev->window;
+        }
+#endif
+
+      return None;
+    }
+}
+
+static guint32
+event_get_time (MetaDisplay *display,
+                XEvent      *event)
+{
+  switch (event->type)
+    {
+    case KeyPress:
+    case KeyRelease:
+      return event->xkey.time;
+      
+    case ButtonPress:
+    case ButtonRelease:
+      return event->xbutton.time;
+      
+    case MotionNotify:
+      return event->xmotion.time;
+
+    case PropertyNotify:
+      return event->xproperty.time;
+
+    case SelectionClear:
+    case SelectionRequest:
+    case SelectionNotify:
+      return event->xselection.time;
+
+    case EnterNotify:
+    case LeaveNotify:
+      return event->xcrossing.time;
+
+    case FocusIn:
+    case FocusOut:
+    case KeymapNotify:      
+    case Expose:
+    case GraphicsExpose:
+    case NoExpose:
+    case MapNotify:
+    case UnmapNotify:
+    case VisibilityNotify:
+    case ResizeRequest:
+    case ColormapNotify:
+    case ClientMessage:
+    case CreateNotify:
+    case DestroyNotify:
+    case MapRequest:
+    case ReparentNotify:
+    case ConfigureNotify:
+    case ConfigureRequest:
+    case GravityNotify:
+    case CirculateNotify:
+    case CirculateRequest:
+    case MappingNotify:
+    default:
+      return CurrentTime;
+    }
+}
+
+#ifdef WITH_VERBOSE_MODE
+const char*
+meta_event_detail_to_string (int d)
+{
+  const char *detail = "???";
+  switch (d)
+    {
+      /* We are an ancestor in the A<->B focus change relationship */
+    case NotifyAncestor:
+      detail = "NotifyAncestor";
+      break;
+    case NotifyDetailNone:
+      detail = "NotifyDetailNone";
+      break;
+      /* We are a descendant in the A<->B focus change relationship */
+    case NotifyInferior:
+      detail = "NotifyInferior";
+      break;
+    case NotifyNonlinear:
+      detail = "NotifyNonlinear";
+      break;
+    case NotifyNonlinearVirtual:
+      detail = "NotifyNonlinearVirtual";
+      break;
+    case NotifyPointer:
+      detail = "NotifyPointer";
+      break;
+    case NotifyPointerRoot:
+      detail = "NotifyPointerRoot";
+      break;
+    case NotifyVirtual:
+      detail = "NotifyVirtual";
+      break;
+    }
+
+  return detail;
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+const char*
+meta_event_mode_to_string (int m)
+{
+  const char *mode = "???";
+  switch (m)
+    {
+    case NotifyNormal:
+      mode = "NotifyNormal";
+      break;
+    case NotifyGrab:
+      mode = "NotifyGrab";
+      break;
+    case NotifyUngrab:
+      mode = "NotifyUngrab";
+      break;
+      /* not sure any X implementations are missing this, but
+       * it seems to be absent from some docs.
+       */
+#ifdef NotifyWhileGrabbed
+    case NotifyWhileGrabbed:
+      mode = "NotifyWhileGrabbed";
+      break;
+#endif
+    }
+
+  return mode;
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+stack_mode_to_string (int mode)
+{
+  switch (mode)
+    {
+    case Above:
+      return "Above";
+    case Below:
+      return "Below";
+    case TopIf:
+      return "TopIf";
+    case BottomIf:
+      return "BottomIf";
+    case Opposite:
+      return "Opposite";      
+    }
+
+  return "Unknown";
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+static char*
+key_event_description (Display *xdisplay,
+                       XEvent  *event)
+{
+  KeySym keysym;
+  const char *str;
+  
+  keysym = XKeycodeToKeysym (xdisplay, event->xkey.keycode, 0);  
+
+  str = XKeysymToString (keysym);
+  
+  return g_strdup_printf ("Key '%s' state 0x%x", 
+                          str ? str : "none", event->xkey.state);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef HAVE_XSYNC
+#ifdef WITH_VERBOSE_MODE
+static gint64
+sync_value_to_64 (const XSyncValue *value)
+{
+  gint64 v;
+
+  v = XSyncValueLow32 (*value);
+  v |= (((gint64)XSyncValueHigh32 (*value)) << 32);
+  
+  return v;
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+alarm_state_to_string (XSyncAlarmState state)
+{
+  switch (state)
+    {
+    case XSyncAlarmActive:
+      return "Active";
+    case XSyncAlarmInactive:
+      return "Inactive";
+    case XSyncAlarmDestroyed:
+      return "Destroyed";
+    default:
+      return "(unknown)";
+    }
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#endif /* HAVE_XSYNC */
+
+#ifdef WITH_VERBOSE_MODE
+static void
+meta_spew_event (MetaDisplay *display,
+                 XEvent      *event)
+{
+  const char *name = NULL;
+  char *extra = NULL;
+  char *winname;
+  MetaScreen *screen;
+
+  if (!meta_is_verbose())
+    return;
+  
+  /* filter overnumerous events */
+  if (event->type == Expose || event->type == MotionNotify ||
+      event->type == NoExpose)
+    return;
+      
+  switch (event->type)
+    {
+    case KeyPress:
+      name = "KeyPress";
+      extra = key_event_description (display->xdisplay, event);
+      break;
+    case KeyRelease:
+      name = "KeyRelease";
+      extra = key_event_description (display->xdisplay, event);
+      break;
+    case ButtonPress:
+      name = "ButtonPress";
+      extra = g_strdup_printf ("button %u state 0x%x x %d y %d root 0x%lx same_screen %d",
+                               event->xbutton.button,
+                               event->xbutton.state,
+                               event->xbutton.x,
+                               event->xbutton.y,
+                               event->xbutton.root,
+                               event->xbutton.same_screen);
+      break;
+    case ButtonRelease:
+      name = "ButtonRelease";
+      extra = g_strdup_printf ("button %u state 0x%x x %d y %d root 0x%lx same_screen %d",
+                               event->xbutton.button,
+                               event->xbutton.state,
+                               event->xbutton.x,
+                               event->xbutton.y,
+                               event->xbutton.root,
+                               event->xbutton.same_screen);
+      break;
+    case MotionNotify:
+      name = "MotionNotify";
+      extra = g_strdup_printf ("win: 0x%lx x: %d y: %d",
+                               event->xmotion.window,
+                               event->xmotion.x,
+                               event->xmotion.y);
+      break;
+    case EnterNotify:
+      name = "EnterNotify";
+      extra = g_strdup_printf ("win: 0x%lx root: 0x%lx subwindow: 0x%lx mode: %s detail: %s focus: %d x: %d y: %d",
+                               event->xcrossing.window,
+                               event->xcrossing.root,
+                               event->xcrossing.subwindow,
+                               meta_event_mode_to_string (event->xcrossing.mode),
+                               meta_event_detail_to_string (event->xcrossing.detail),
+                               event->xcrossing.focus,
+                               event->xcrossing.x,
+                               event->xcrossing.y);
+      break;
+    case LeaveNotify:
+      name = "LeaveNotify";
+      extra = g_strdup_printf ("win: 0x%lx root: 0x%lx subwindow: 0x%lx mode: %s detail: %s focus: %d x: %d y: %d",
+                               event->xcrossing.window,
+                               event->xcrossing.root,
+                               event->xcrossing.subwindow,
+                               meta_event_mode_to_string (event->xcrossing.mode),
+                               meta_event_detail_to_string (event->xcrossing.detail),
+                               event->xcrossing.focus,
+                               event->xcrossing.x,
+                               event->xcrossing.y);
+      break;
+    case FocusIn:
+      name = "FocusIn";
+      extra = g_strdup_printf ("detail: %s mode: %s\n",
+                               meta_event_detail_to_string (event->xfocus.detail),
+                               meta_event_mode_to_string (event->xfocus.mode));
+      break;
+    case FocusOut:
+      name = "FocusOut";
+      extra = g_strdup_printf ("detail: %s mode: %s\n",
+                               meta_event_detail_to_string (event->xfocus.detail),
+                               meta_event_mode_to_string (event->xfocus.mode));
+      break;
+    case KeymapNotify:
+      name = "KeymapNotify";
+      break;
+    case Expose:
+      name = "Expose";
+      break;
+    case GraphicsExpose:
+      name = "GraphicsExpose";
+      break;
+    case NoExpose:
+      name = "NoExpose";
+      break;
+    case VisibilityNotify:
+      name = "VisibilityNotify";
+      break;
+    case CreateNotify:
+      name = "CreateNotify";
+      extra = g_strdup_printf ("parent: 0x%lx window: 0x%lx",
+                               event->xcreatewindow.parent,
+                               event->xcreatewindow.window);
+      break;
+    case DestroyNotify:
+      name = "DestroyNotify";
+      extra = g_strdup_printf ("event: 0x%lx window: 0x%lx",
+                               event->xdestroywindow.event,
+                               event->xdestroywindow.window);
+      break;
+    case UnmapNotify:
+      name = "UnmapNotify";
+      extra = g_strdup_printf ("event: 0x%lx window: 0x%lx from_configure: %d",
+                               event->xunmap.event,
+                               event->xunmap.window,
+                               event->xunmap.from_configure);
+      break;
+    case MapNotify:
+      name = "MapNotify";
+      extra = g_strdup_printf ("event: 0x%lx window: 0x%lx override_redirect: %d",
+                               event->xmap.event,
+                               event->xmap.window,
+                               event->xmap.override_redirect);
+      break;
+    case MapRequest:
+      name = "MapRequest";
+      extra = g_strdup_printf ("window: 0x%lx parent: 0x%lx\n",
+                               event->xmaprequest.window,
+                               event->xmaprequest.parent);
+      break;
+    case ReparentNotify:
+      name = "ReparentNotify";
+      extra = g_strdup_printf ("window: 0x%lx parent: 0x%lx event: 0x%lx\n",
+                               event->xreparent.window,
+                               event->xreparent.parent,
+                               event->xreparent.event);
+      break;
+    case ConfigureNotify:
+      name = "ConfigureNotify";
+      extra = g_strdup_printf ("x: %d y: %d w: %d h: %d above: 0x%lx override_redirect: %d",
+                               event->xconfigure.x,
+                               event->xconfigure.y,
+                               event->xconfigure.width,
+                               event->xconfigure.height,
+                               event->xconfigure.above,
+                               event->xconfigure.override_redirect);
+      break;
+    case ConfigureRequest:
+      name = "ConfigureRequest";
+      extra = g_strdup_printf ("parent: 0x%lx window: 0x%lx x: %d %sy: %d %sw: %d %sh: %d %sborder: %d %sabove: %lx %sstackmode: %s %s",
+                               event->xconfigurerequest.parent,
+                               event->xconfigurerequest.window,
+                               event->xconfigurerequest.x,
+                               event->xconfigurerequest.value_mask &
+                               CWX ? "" : "(unset) ",
+                               event->xconfigurerequest.y,
+                               event->xconfigurerequest.value_mask &
+                               CWY ? "" : "(unset) ",
+                               event->xconfigurerequest.width,
+                               event->xconfigurerequest.value_mask &
+                               CWWidth ? "" : "(unset) ",
+                               event->xconfigurerequest.height,
+                               event->xconfigurerequest.value_mask &
+                               CWHeight ? "" : "(unset) ",
+                               event->xconfigurerequest.border_width,
+                               event->xconfigurerequest.value_mask &
+                               CWBorderWidth ? "" : "(unset)",
+                               event->xconfigurerequest.above,
+                               event->xconfigurerequest.value_mask &
+                               CWSibling ? "" : "(unset)",
+                               stack_mode_to_string (event->xconfigurerequest.detail),
+                               event->xconfigurerequest.value_mask &
+                               CWStackMode ? "" : "(unset)");
+      break;
+    case GravityNotify:
+      name = "GravityNotify";
+      break;
+    case ResizeRequest:
+      name = "ResizeRequest";
+      extra = g_strdup_printf ("width = %d height = %d",
+                               event->xresizerequest.width,
+                               event->xresizerequest.height);
+      break;
+    case CirculateNotify:
+      name = "CirculateNotify";
+      break;
+    case CirculateRequest:
+      name = "CirculateRequest";
+      break;
+    case PropertyNotify:
+      {
+        char *str;
+        const char *state;
+            
+        name = "PropertyNotify";
+            
+        meta_error_trap_push (display);
+        str = XGetAtomName (display->xdisplay,
+                            event->xproperty.atom);
+        meta_error_trap_pop (display, TRUE);
+
+        if (event->xproperty.state == PropertyNewValue)
+          state = "PropertyNewValue";
+        else if (event->xproperty.state == PropertyDelete)
+          state = "PropertyDelete";
+        else
+          state = "???";
+            
+        extra = g_strdup_printf ("atom: %s state: %s",
+                                 str ? str : "(unknown atom)",
+                                 state);
+        meta_XFree (str);
+      }
+      break;
+    case SelectionClear:
+      name = "SelectionClear";
+      break;
+    case SelectionRequest:
+      name = "SelectionRequest";
+      break;
+    case SelectionNotify:
+      name = "SelectionNotify";
+      break;
+    case ColormapNotify:
+      name = "ColormapNotify";
+      break;
+    case ClientMessage:
+      {
+        char *str;
+        name = "ClientMessage";
+        meta_error_trap_push (display);
+        str = XGetAtomName (display->xdisplay,
+                            event->xclient.message_type);
+        meta_error_trap_pop (display, TRUE);
+        extra = g_strdup_printf ("type: %s format: %d\n",
+                                 str ? str : "(unknown atom)",
+                                 event->xclient.format);
+        meta_XFree (str);
+      }
+      break;
+    case MappingNotify:
+      name = "MappingNotify";
+      break;
+    default:
+#ifdef HAVE_XSYNC
+      if (META_DISPLAY_HAS_XSYNC (display) && 
+          event->type == (display->xsync_event_base + XSyncAlarmNotify))
+        {
+          XSyncAlarmNotifyEvent *aevent = (XSyncAlarmNotifyEvent*) event;
+          
+          name = "XSyncAlarmNotify";
+          extra =
+            g_strdup_printf ("alarm: 0x%lx"
+                             " counter_value: %" G_GINT64_FORMAT
+                             " alarm_value: %" G_GINT64_FORMAT
+                             " time: %u alarm state: %s",
+                             aevent->alarm,
+                             (gint64) sync_value_to_64 (&aevent->counter_value),
+                             (gint64) sync_value_to_64 (&aevent->alarm_value),
+                             (unsigned int)aevent->time,
+                             alarm_state_to_string (aevent->state));
+        }
+      else
+#endif /* HAVE_XSYNC */
+#ifdef HAVE_SHAPE
+        if (META_DISPLAY_HAS_SHAPE (display) && 
+            event->type == (display->shape_event_base + ShapeNotify))
+          {
+            XShapeEvent *sev = (XShapeEvent*) event;
+
+            name = "ShapeNotify";
+
+            extra =
+              g_strdup_printf ("kind: %s "
+                               "x: %d y: %d w: %u h: %u "
+                               "shaped: %d",
+                               sev->kind == ShapeBounding ?
+                               "ShapeBounding" :
+                               (sev->kind == ShapeClip ?
+                               "ShapeClip" : "(unknown)"),
+                               sev->x, sev->y, sev->width, sev->height,
+                               sev->shaped);
+          }
+        else
+#endif /* HAVE_SHAPE */      
+        {
+          name = "(Unknown event)";
+          extra = g_strdup_printf ("type: %d", event->xany.type);
+        }
+      break;
+    }
+
+  screen = meta_display_screen_for_root (display, event->xany.window);
+      
+  if (screen)
+    winname = g_strdup_printf ("root %d", screen->number);
+  else
+    winname = g_strdup_printf ("0x%lx", event->xany.window);
+      
+  meta_topic (META_DEBUG_EVENTS,
+              "%s on %s%s %s %sserial %lu\n", name, winname,
+              extra ? ":" : "", extra ? extra : "",
+              event->xany.send_event ? "SEND " : "",
+              event->xany.serial);
+
+  g_free (winname);
+
+  if (extra)
+    g_free (extra);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+MetaWindow*
+meta_display_lookup_x_window (MetaDisplay *display,
+                              Window       xwindow)
+{
+  return g_hash_table_lookup (display->window_ids, &xwindow);
+}
+
+void
+meta_display_register_x_window (MetaDisplay *display,
+                                Window      *xwindowp,
+                                MetaWindow  *window)
+{
+  g_return_if_fail (g_hash_table_lookup (display->window_ids, xwindowp) == NULL);
+  
+  g_hash_table_insert (display->window_ids, xwindowp, window);
+}
+
+void
+meta_display_unregister_x_window (MetaDisplay *display,
+                                  Window       xwindow)
+{
+  g_return_if_fail (g_hash_table_lookup (display->window_ids, &xwindow) != NULL);
+
+  g_hash_table_remove (display->window_ids, &xwindow);
+
+  /* Remove any pending pings */
+  remove_pending_pings_for_window (display, xwindow);
+}
+
+gboolean
+meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display,
+                                           Window xwindow)
+{
+  gboolean is_a_no_focus_window = FALSE;
+  GSList *temp = display->screens;
+  while (temp != NULL) {
+    MetaScreen *screen = temp->data;
+    if (screen->no_focus_window == xwindow) {
+      is_a_no_focus_window = TRUE;
+      break;
+    }
+    temp = temp->next;
+  }
+
+  return is_a_no_focus_window;
+}
+
+Cursor
+meta_display_create_x_cursor (MetaDisplay *display,
+                              MetaCursor cursor)
+{
+  Cursor xcursor;
+  guint glyph;
+
+  switch (cursor)
+    {
+    case META_CURSOR_DEFAULT:
+      glyph = XC_left_ptr;
+      break;
+    case META_CURSOR_NORTH_RESIZE:
+      glyph = XC_top_side;
+      break;
+    case META_CURSOR_SOUTH_RESIZE:
+      glyph = XC_bottom_side;
+      break;
+    case META_CURSOR_WEST_RESIZE:
+      glyph = XC_left_side;
+      break;
+    case META_CURSOR_EAST_RESIZE:
+      glyph = XC_right_side;
+      break;
+    case META_CURSOR_SE_RESIZE:
+      glyph = XC_bottom_right_corner;
+      break;
+    case META_CURSOR_SW_RESIZE:
+      glyph = XC_bottom_left_corner;
+      break;
+    case META_CURSOR_NE_RESIZE:
+      glyph = XC_top_right_corner;
+      break;
+    case META_CURSOR_NW_RESIZE:
+      glyph = XC_top_left_corner;
+      break;
+    case META_CURSOR_MOVE_OR_RESIZE_WINDOW:
+      glyph = XC_fleur;
+      break;
+    case META_CURSOR_BUSY:
+      glyph = XC_watch;
+      break;
+      
+    default:
+      g_assert_not_reached ();
+      glyph = 0; /* silence compiler */
+      break;
+    }
+  
+  xcursor = XCreateFontCursor (display->xdisplay, glyph);
+
+  return xcursor;
+}
+
+static Cursor
+xcursor_for_op (MetaDisplay *display,
+                MetaGrabOp   op)
+{
+  MetaCursor cursor = META_CURSOR_DEFAULT;
+  
+  switch (op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+      cursor = META_CURSOR_SE_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+      cursor = META_CURSOR_SOUTH_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+      cursor = META_CURSOR_SW_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+      cursor = META_CURSOR_NORTH_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+      cursor = META_CURSOR_NE_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      cursor = META_CURSOR_NW_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+      cursor = META_CURSOR_WEST_RESIZE;
+      break;
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+      cursor = META_CURSOR_EAST_RESIZE;
+      break;
+    case META_GRAB_OP_MOVING:
+    case META_GRAB_OP_KEYBOARD_MOVING:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+      cursor = META_CURSOR_MOVE_OR_RESIZE_WINDOW;
+      break;
+      
+    default:
+      break;
+    }
+
+  if (cursor == META_CURSOR_DEFAULT)
+    return None;
+  return meta_display_create_x_cursor (display, cursor);
+}
+
+void
+meta_display_set_grab_op_cursor (MetaDisplay *display,
+                                 MetaScreen  *screen,
+                                 MetaGrabOp   op,
+                                 gboolean     change_pointer,
+                                 Window       grab_xwindow,
+                                 guint32      timestamp)
+{
+  Cursor cursor;
+
+  cursor = xcursor_for_op (display, op);
+
+#define GRAB_MASK (PointerMotionMask |                          \
+                   ButtonPressMask | ButtonReleaseMask |        \
+		   EnterWindowMask | LeaveWindowMask)
+
+  if (change_pointer)
+    {
+      meta_error_trap_push_with_return (display);
+      XChangeActivePointerGrab (display->xdisplay,
+                                GRAB_MASK,
+                                cursor,
+                                timestamp);
+
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Changed pointer with XChangeActivePointerGrab()\n");
+
+      if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "Error trapped from XChangeActivePointerGrab()\n");
+          if (display->grab_have_pointer)
+            display->grab_have_pointer = FALSE;
+        }
+    }
+  else
+    {
+      g_assert (screen != NULL);
+
+      meta_error_trap_push (display);
+      if (XGrabPointer (display->xdisplay,
+                        grab_xwindow,
+                        False,
+                        GRAB_MASK,
+                        GrabModeAsync, GrabModeAsync,
+                        screen->xroot,
+                        cursor,
+                        timestamp) == GrabSuccess)
+        {
+          display->grab_have_pointer = TRUE;
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "XGrabPointer() returned GrabSuccess time %u\n",
+                      timestamp);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "XGrabPointer() failed time %u\n",
+                      timestamp);
+        }
+      meta_error_trap_pop (display, TRUE);
+    }
+
+#undef GRAB_MASK
+  
+  if (cursor != None)
+    XFreeCursor (display->xdisplay, cursor);
+}
+
+gboolean
+meta_display_begin_grab_op (MetaDisplay *display,
+			    MetaScreen  *screen,
+                            MetaWindow  *window,
+                            MetaGrabOp   op,
+                            gboolean     pointer_already_grabbed,
+                            gboolean     frame_action,
+                            int          button,
+                            gulong       modmask,
+                            guint32      timestamp,
+                            int          root_x,
+                            int          root_y)
+{
+  Window grab_xwindow;
+  
+  if (grab_op_is_mouse (op) && meta_grab_op_is_moving (op))
+    {
+      if (display->compositor)
+	{
+	  meta_compositor_begin_move (display->compositor,
+				      window, &window->rect,
+				      root_x, root_y);
+	}
+    }
+  
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Doing grab op %u on window %s button %d pointer already grabbed: %d pointer pos %d,%d\n",
+              op, window ? window->desc : "none", button, pointer_already_grabbed,
+              root_x, root_y);
+  
+  if (display->grab_op != META_GRAB_OP_NONE)
+    {
+      if (window)
+        meta_warning ("Attempt to perform window operation %u on window %s when operation %u on %s already in effect\n",
+                      op, window->desc, display->grab_op,
+                      display->grab_window ? display->grab_window->desc : "none");
+      return FALSE;
+    }
+
+  if (window &&
+      (meta_grab_op_is_moving (op) || meta_grab_op_is_resizing (op)))
+    {
+      if (meta_prefs_get_raise_on_click ())
+        meta_window_raise (window);
+      else
+        {
+          display->grab_initial_x = root_x;
+          display->grab_initial_y = root_y;
+          display->grab_threshold_movement_reached = FALSE;
+        }
+    }
+
+  /* FIXME:
+   *   If we have no MetaWindow we do our best
+   *   and try to do the grab on the RootWindow.
+   *   This will fail if anyone else has any
+   *   key grab on the RootWindow.
+   */
+  if (window)
+    grab_xwindow = window->frame ? window->frame->xwindow : window->xwindow;
+  else
+    grab_xwindow = screen->xroot;
+
+  display->grab_have_pointer = FALSE;
+  
+  if (pointer_already_grabbed)
+    display->grab_have_pointer = TRUE;
+  
+  meta_display_set_grab_op_cursor (display, screen, op, FALSE, grab_xwindow,
+                                   timestamp);
+
+  if (!display->grab_have_pointer)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "XGrabPointer() failed\n");
+      return FALSE;
+    }
+
+  /* Grab keys for keyboard ops and mouse move/resizes; see #126497 */
+  if (grab_op_is_keyboard (op) || grab_op_is_mouse_only (op))
+    {
+      if (window)
+        display->grab_have_keyboard =
+                     meta_window_grab_all_keys (window, timestamp);
+
+      else
+        display->grab_have_keyboard =
+                     meta_screen_grab_all_keys (screen, timestamp);
+      
+      if (!display->grab_have_keyboard)
+        {
+          meta_topic (META_DEBUG_WINDOW_OPS,
+                      "grabbing all keys failed, ungrabbing pointer\n");
+          XUngrabPointer (display->xdisplay, timestamp);
+          display->grab_have_pointer = FALSE;
+          return FALSE;
+        }
+    }
+  
+  display->grab_op = op;
+  display->grab_window = window;
+  display->grab_screen = screen;
+  display->grab_xwindow = grab_xwindow;
+  display->grab_button = button;
+  display->grab_mask = modmask;
+  display->grab_anchor_root_x = root_x;
+  display->grab_anchor_root_y = root_y;
+  display->grab_latest_motion_x = root_x;
+  display->grab_latest_motion_y = root_y;
+  display->grab_last_moveresize_time.tv_sec = 0;
+  display->grab_last_moveresize_time.tv_usec = 0;
+  display->grab_motion_notify_time = 0;
+  display->grab_old_window_stacking = NULL;
+#ifdef HAVE_XSYNC
+  display->grab_sync_request_alarm = None;
+  display->grab_last_user_action_was_snap = FALSE;
+#endif
+  display->grab_was_cancelled = FALSE;
+  display->grab_frame_action = frame_action;
+
+  if (display->grab_resize_timeout_id)
+    {
+      g_source_remove (display->grab_resize_timeout_id);
+      display->grab_resize_timeout_id = 0;
+    }
+	
+  if (display->grab_window)
+    {
+      meta_window_get_client_root_coords (display->grab_window,
+                                          &display->grab_initial_window_pos);
+      display->grab_anchor_window_pos = display->grab_initial_window_pos;
+
+      display->grab_wireframe_active =
+        (meta_prefs_get_reduced_resources () && !meta_prefs_get_mate_accessibility ())  && 
+        (meta_grab_op_is_resizing (display->grab_op) ||
+         meta_grab_op_is_moving (display->grab_op));
+      
+      if (display->grab_wireframe_active)
+        {
+          meta_window_calc_showing (display->grab_window);
+          meta_window_begin_wireframe (window);
+        }
+      
+#ifdef HAVE_XSYNC
+      if (!display->grab_wireframe_active &&
+          meta_grab_op_is_resizing (display->grab_op) &&
+          display->grab_window->sync_request_counter != None)
+        {
+          XSyncAlarmAttributes values;
+	  XSyncValue init;
+
+          meta_error_trap_push_with_return (display);
+
+	  /* Set the counter to 0, so we know that the application's
+	   * responses to the client messages will always trigger
+	   * a PositiveTransition
+	   */
+	  
+	  XSyncIntToValue (&init, 0);
+	  XSyncSetCounter (display->xdisplay,
+			   display->grab_window->sync_request_counter, init);
+	  
+	  display->grab_window->sync_request_serial = 0;
+	  display->grab_window->sync_request_time.tv_sec = 0;
+	  display->grab_window->sync_request_time.tv_usec = 0;
+	  
+          values.trigger.counter = display->grab_window->sync_request_counter;
+          values.trigger.value_type = XSyncAbsolute;
+          values.trigger.test_type = XSyncPositiveTransition;
+          XSyncIntToValue (&values.trigger.wait_value,
+			   display->grab_window->sync_request_serial + 1);
+	  
+          /* After triggering, increment test_value by this.
+           * (NOT wait_value above)
+           */
+          XSyncIntToValue (&values.delta, 1);
+	  
+          /* we want events (on by default anyway) */
+          values.events = True;
+          
+          display->grab_sync_request_alarm = XSyncCreateAlarm (display->xdisplay,
+                                                         XSyncCACounter |
+                                                         XSyncCAValueType |
+                                                         XSyncCAValue |
+                                                         XSyncCATestType |
+                                                         XSyncCADelta |
+                                                         XSyncCAEvents,
+                                                         &values);
+
+          if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+	    display->grab_sync_request_alarm = None;
+
+          meta_topic (META_DEBUG_RESIZING,
+                      "Created update alarm 0x%lx\n",
+                      display->grab_sync_request_alarm);
+        }
+#endif
+    }
+  
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Grab op %u on window %s successful\n",
+              display->grab_op, window ? window->desc : "(null)");
+
+  g_assert (display->grab_window != NULL || display->grab_screen != NULL);
+  g_assert (display->grab_op != META_GRAB_OP_NONE);
+
+  /* If this is a move or resize, cache the window edges for
+   * resistance/snapping
+   */
+  if (meta_grab_op_is_resizing (display->grab_op) || 
+      meta_grab_op_is_moving (display->grab_op))
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Computing edges to resist-movement or snap-to for %s.\n",
+                  window->desc);
+      meta_display_compute_resistance_and_snapping_edges (display);
+    }
+
+  /* Save the old stacking */
+  if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Saving old stack positions; old pointer was %p.\n",
+                  display->grab_old_window_stacking);
+      display->grab_old_window_stacking = 
+        meta_stack_get_positions (screen->stack);
+    }
+
+  /* Do this last, after everything is set up. */
+  switch (op)
+    {
+    case META_GRAB_OP_KEYBOARD_TABBING_NORMAL:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_NORMAL,
+                                    META_TAB_SHOW_ICON);
+      break;
+    case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_NORMAL,
+                                    META_TAB_SHOW_INSTANTLY);
+      break;
+
+    case META_GRAB_OP_KEYBOARD_TABBING_DOCK:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_DOCKS,
+                                    META_TAB_SHOW_ICON);
+      break;
+    case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_DOCKS,
+                                    META_TAB_SHOW_INSTANTLY);
+      break;
+    case META_GRAB_OP_KEYBOARD_TABBING_GROUP:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_GROUP,
+                                    META_TAB_SHOW_ICON);
+      break;
+     case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
+      meta_screen_ensure_tab_popup (screen,
+                                    META_TAB_LIST_GROUP,
+                                    META_TAB_SHOW_INSTANTLY);
+      
+    case META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING:
+      meta_screen_ensure_workspace_popup (screen);
+      break;
+
+    default:
+      break;
+    }
+
+  if (display->grab_window)
+    {
+      meta_window_refresh_resize_popup (display->grab_window);
+    }
+  
+  return TRUE;
+}
+
+void
+meta_display_end_grab_op (MetaDisplay *display,
+                          guint32      timestamp)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Ending grab op %u at time %u\n", display->grab_op, timestamp);
+  
+  if (display->grab_op == META_GRAB_OP_NONE)
+    return;
+
+  if (display->grab_window != NULL)
+    display->grab_window->shaken_loose = FALSE;
+  
+  if (display->grab_window != NULL &&
+      !meta_prefs_get_raise_on_click () &&
+      (meta_grab_op_is_moving (display->grab_op) ||
+       meta_grab_op_is_resizing (display->grab_op)))
+    {
+      /* Only raise the window in orthogonal raise
+       * ('do-not-raise-on-click') mode if the user didn't try to move
+       * or resize the given window by at least a threshold amount.
+       * For raise on click mode, the window was raised at the
+       * beginning of the grab_op.
+       */
+      if (!display->grab_threshold_movement_reached)
+        meta_window_raise (display->grab_window);
+    }
+
+  if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op) ||
+      display->grab_op == META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING)
+    {
+      meta_ui_tab_popup_free (display->grab_screen->tab_popup);
+      display->grab_screen->tab_popup = NULL;
+
+      /* If the ungrab here causes an EnterNotify, ignore it for
+       * sloppy focus
+       */
+      display->ungrab_should_not_cause_focus_window = display->grab_xwindow;
+    }
+  
+  /* If this was a move or resize clear out the edge cache */
+  if (meta_grab_op_is_resizing (display->grab_op) || 
+      meta_grab_op_is_moving (display->grab_op))
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Clearing out the edges for resistance/snapping");
+      meta_display_cleanup_edges (display);
+    }
+
+  if (display->grab_old_window_stacking != NULL)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Clearing out the old stack position, which was %p.\n",
+                  display->grab_old_window_stacking);
+      g_list_free (display->grab_old_window_stacking);
+      display->grab_old_window_stacking = NULL;
+    }
+
+  if (display->grab_wireframe_active)
+    {
+      display->grab_wireframe_active = FALSE;
+      meta_window_end_wireframe (display->grab_window);
+
+      if (!display->grab_was_cancelled)
+        {
+          if (meta_grab_op_is_moving (display->grab_op))
+            meta_window_move (display->grab_window,
+                              TRUE,
+                              display->grab_wireframe_rect.x,
+                              display->grab_wireframe_rect.y);
+          if (meta_grab_op_is_resizing (display->grab_op))
+            meta_window_resize_with_gravity (display->grab_window,
+                                             TRUE,
+                                             display->grab_wireframe_rect.width,
+                                             display->grab_wireframe_rect.height,
+                                             meta_resize_gravity_from_grab_op (display->grab_op));
+        }
+      meta_window_calc_showing (display->grab_window);
+    }
+
+  if (display->compositor &&
+      display->grab_window &&
+      grab_op_is_mouse (display->grab_op) && 
+      meta_grab_op_is_moving (display->grab_op))
+    {
+      meta_compositor_end_move (display->compositor,
+				display->grab_window);
+    }
+  
+  if (display->grab_have_pointer)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Ungrabbing pointer with timestamp %u\n", timestamp);
+      XUngrabPointer (display->xdisplay, timestamp);
+    }
+
+  if (display->grab_have_keyboard)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Ungrabbing all keys timestamp %u\n", timestamp);
+      if (display->grab_window)
+        meta_window_ungrab_all_keys (display->grab_window, timestamp);
+      else
+        meta_screen_ungrab_all_keys (display->grab_screen, timestamp);
+    }
+
+#ifdef HAVE_XSYNC
+  if (display->grab_sync_request_alarm != None)
+    {
+      XSyncDestroyAlarm (display->xdisplay,
+                         display->grab_sync_request_alarm);
+      display->grab_sync_request_alarm = None;
+    }
+#endif /* HAVE_XSYNC */
+  
+  display->grab_window = NULL;
+  display->grab_screen = NULL;
+  display->grab_xwindow = None;
+  display->grab_op = META_GRAB_OP_NONE;
+
+  if (display->grab_resize_popup)
+    {
+      meta_ui_resize_popup_free (display->grab_resize_popup);
+      display->grab_resize_popup = NULL;
+    }
+
+  if (display->grab_resize_timeout_id)
+    {
+      g_source_remove (display->grab_resize_timeout_id);
+      display->grab_resize_timeout_id = 0;
+    }
+}
+
+void
+meta_display_check_threshold_reached (MetaDisplay *display,
+                                      int          x,
+                                      int          y)
+{
+  /* Don't bother doing the check again if we've already reached the threshold */
+  if (meta_prefs_get_raise_on_click () ||
+      display->grab_threshold_movement_reached)
+    return;
+
+  if (ABS (display->grab_initial_x - x) >= 8 ||
+      ABS (display->grab_initial_y - y) >= 8)
+    display->grab_threshold_movement_reached = TRUE;
+}
+
+static void
+meta_change_button_grab (MetaDisplay *display,
+                         Window       xwindow,
+                         gboolean     grab,
+                         gboolean     sync,
+                         int          button,
+                         int          modmask)
+{
+  unsigned int ignored_mask;
+
+  meta_verbose ("%s 0x%lx sync = %d button = %d modmask 0x%x\n",
+                grab ? "Grabbing" : "Ungrabbing",
+                xwindow,
+                sync, button, modmask);
+  
+  meta_error_trap_push (display);
+  
+  ignored_mask = 0;
+  while (ignored_mask <= display->ignored_modifier_mask)
+    {
+      if (ignored_mask & ~(display->ignored_modifier_mask))
+        {
+          /* Not a combination of ignored modifiers
+           * (it contains some non-ignored modifiers)
+           */
+          ++ignored_mask;
+          continue;
+        }
+
+      if (meta_is_debugging ())
+        meta_error_trap_push_with_return (display);
+
+      /* GrabModeSync means freeze until XAllowEvents */
+      
+      if (grab)
+        XGrabButton (display->xdisplay, button, modmask | ignored_mask,
+                     xwindow, False,
+                     ButtonPressMask | ButtonReleaseMask |    
+                     PointerMotionMask | PointerMotionHintMask,
+                     sync ? GrabModeSync : GrabModeAsync,
+                     GrabModeAsync,
+                     False, None);
+      else
+        XUngrabButton (display->xdisplay, button, modmask | ignored_mask,
+                       xwindow);
+
+      if (meta_is_debugging ())
+        {
+          int result;
+          
+          result = meta_error_trap_pop_with_return (display, FALSE);
+          
+          if (result != Success)
+            meta_verbose ("Failed to %s button %d with mask 0x%x for window 0x%lx error code %d\n",
+                          grab ? "grab" : "ungrab",
+                          button, modmask | ignored_mask, xwindow, result);
+        }
+      
+      ++ignored_mask;
+    }
+
+  meta_error_trap_pop (display, FALSE);
+}
+
+void
+meta_display_grab_window_buttons (MetaDisplay *display,
+                                  Window       xwindow)
+{  
+  /* Grab Alt + button1 for moving window.
+   * Grab Alt + button2 for resizing window.
+   * Grab Alt + button3 for popping up window menu.
+   * Grab Alt + Shift + button1 for snap-moving window.
+   */
+  meta_verbose ("Grabbing window buttons for 0x%lx\n", xwindow);
+  
+  /* FIXME If we ignored errors here instead of spewing, we could
+   * put one big error trap around the loop and avoid a bunch of
+   * XSync()
+   */
+
+  if (display->window_grab_modifiers != 0)
+    {
+      gboolean debug = g_getenv ("MARCO_DEBUG_BUTTON_GRABS") != NULL;
+      int i;
+      for (i = 1; i < 4; i++)
+        {
+          meta_change_button_grab (display, xwindow,
+                                   TRUE,
+                                   FALSE,
+                                   i, display->window_grab_modifiers);  
+          
+          /* This is for debugging, since I end up moving the Xnest
+           * otherwise ;-)
+           */
+          if (debug)
+            meta_change_button_grab (display, xwindow,
+                                     TRUE,
+                                     FALSE,
+                                     i, ControlMask);
+        }
+
+      /* In addition to grabbing Alt+Button1 for moving the window,
+       * grab Alt+Shift+Button1 for snap-moving the window.  See bug
+       * 112478.  Unfortunately, this doesn't work with
+       * Shift+Alt+Button1 for some reason; so at least part of the
+       * order still matters, which sucks (please FIXME).
+       */
+      meta_change_button_grab (display, xwindow,
+                               TRUE,
+                               FALSE,
+                               1, display->window_grab_modifiers | ShiftMask);
+    }
+}
+
+void
+meta_display_ungrab_window_buttons  (MetaDisplay *display,
+                                     Window       xwindow)
+{
+  gboolean debug;
+  int i;
+
+  if (display->window_grab_modifiers == 0)
+    return;
+  
+  debug = g_getenv ("MARCO_DEBUG_BUTTON_GRABS") != NULL;
+  i = 1;
+  while (i < 4)
+    {
+      meta_change_button_grab (display, xwindow,
+                               FALSE, FALSE, i,
+                               display->window_grab_modifiers);
+      
+      if (debug)
+        meta_change_button_grab (display, xwindow,
+                                 FALSE, FALSE, i, ControlMask);
+      
+      ++i;
+    }
+}
+
+/* Grab buttons we only grab while unfocused in click-to-focus mode */
+#define MAX_FOCUS_BUTTON 4
+void
+meta_display_grab_focus_window_button (MetaDisplay *display,
+                                       MetaWindow  *window)
+{
+  /* Grab button 1 for activating unfocused windows */
+  meta_verbose ("Grabbing unfocused window buttons for %s\n", window->desc);
+
+#if 0
+  /* FIXME:115072 */
+  /* Don't grab at all unless in click to focus mode. In click to
+   * focus, we may sometimes be clever about intercepting and eating
+   * the focus click. But in mouse focus, we never do that since the
+   * focus window may not be raised, and who wants to think about
+   * mouse focus anyway.
+   */
+  if (meta_prefs_get_focus_mode () != META_FOCUS_MODE_CLICK)
+    {
+      meta_verbose (" (well, not grabbing since not in click to focus mode)\n");
+      return;
+    }
+#endif
+  
+  if (window->have_focus_click_grab)
+    {
+      meta_verbose (" (well, not grabbing since we already have the grab)\n");
+      return;
+    }
+  
+  /* FIXME If we ignored errors here instead of spewing, we could
+   * put one big error trap around the loop and avoid a bunch of
+   * XSync()
+   */
+  
+  {
+    int i = 1;
+    while (i < MAX_FOCUS_BUTTON)
+      {
+        meta_change_button_grab (display,
+                                 window->xwindow,
+                                 TRUE, TRUE,
+                                 i, 0);
+        
+        ++i;
+      }
+
+    window->have_focus_click_grab = TRUE;
+  }
+}
+
+void
+meta_display_ungrab_focus_window_button (MetaDisplay *display,
+                                         MetaWindow  *window)
+{
+  meta_verbose ("Ungrabbing unfocused window buttons for %s\n", window->desc);
+
+  if (!window->have_focus_click_grab)
+    return;
+  
+  {
+    int i = 1;
+    while (i < MAX_FOCUS_BUTTON)
+      {
+        meta_change_button_grab (display, window->xwindow,
+                                 FALSE, FALSE, i, 0);
+        
+        ++i;
+      }
+
+    window->have_focus_click_grab = FALSE;
+  }
+}
+
+void
+meta_display_increment_event_serial (MetaDisplay *display)
+{
+  /* We just make some random X request */
+  XDeleteProperty (display->xdisplay, display->leader_window,
+                   display->atom__MOTIF_WM_HINTS);
+}
+
+void
+meta_display_update_active_window_hint (MetaDisplay *display)
+{
+  GSList *tmp;
+  
+  gulong data[1];
+
+  if (display->focus_window)
+    data[0] = display->focus_window->xwindow;
+  else
+    data[0] = None;
+  
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+      
+      meta_error_trap_push (display);
+      XChangeProperty (display->xdisplay, screen->xroot,
+                       display->atom__NET_ACTIVE_WINDOW,
+                       XA_WINDOW,
+                       32, PropModeReplace, (guchar*) data, 1);
+
+      meta_error_trap_pop (display, FALSE);
+
+      tmp = tmp->next;
+    }
+}
+
+void
+meta_display_queue_retheme_all_windows (MetaDisplay *display)
+{
+  GSList* windows;
+  GSList *tmp;
+
+  windows = meta_display_list_windows (display);
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+      
+      meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+      if (window->frame)
+        {
+          window->frame->need_reapply_frame_shape = TRUE;
+          
+          meta_frame_queue_draw (window->frame);
+        }
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (windows);
+}
+
+void
+meta_display_retheme_all (void)
+{
+  meta_display_queue_retheme_all_windows (meta_get_display ());
+}
+
+void 
+meta_display_set_cursor_theme (const char *theme, 
+			       int         size)
+{
+#ifdef HAVE_XCURSOR     
+  GSList *tmp;
+
+  MetaDisplay *display = meta_get_display ();
+
+  XcursorSetTheme (display->xdisplay, theme);
+  XcursorSetDefaultSize (display->xdisplay, size);
+
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+	  	  
+      meta_screen_update_cursor (screen);
+
+      tmp = tmp->next;
+    }
+
+#endif
+}
+
+/**
+ * Stores whether syncing is currently enabled.
+ */
+static gboolean is_syncing = FALSE;
+
+/**
+ * Returns whether X synchronisation is currently enabled.
+ *
+ * \return true if we must wait for events whenever we send X requests;
+ * false otherwise.
+ *
+ * \bug This is *only* called by meta_display_open, but by that time
+ * we have already turned syncing on or off on startup, and we don't
+ * have any way to do so while Marco is running, so it's rather
+ * pointless.
+ */
+gboolean
+meta_is_syncing (void)
+{
+  return is_syncing;
+}
+
+/**
+ * A handy way to turn on synchronisation on or off for every display.
+ *
+ * \bug Of course there is only one display ever anyway, so this can
+ * be rather hugely simplified.
+ */
+void
+meta_set_syncing (gboolean setting)
+{
+  if (setting != is_syncing)
+    {
+      is_syncing = setting;
+      if (meta_get_display ())
+        XSynchronize (meta_get_display ()->xdisplay, is_syncing);
+    }
+}
+
+/**
+ * How long, in milliseconds, we should wait after pinging a window
+ * before deciding it's not going to get back to us.
+ */
+#define PING_TIMEOUT_DELAY 5000
+
+/**
+ * Does whatever it is we decided to do when a window didn't respond
+ * to a ping. We also remove the ping from the display's list of
+ * pending pings. This function is called by the event loop when the timeout
+ * times out which we created at the start of the ping.
+ *
+ * \param data All the information about this ping. It is a MetaPingData
+ *             cast to a void* in order to be passable to a timeout function.
+ *             This function will also free this parameter.
+ *
+ * \return Always returns false, because this function is called as a
+ *         timeout and we don't want to run the timer again.
+ *
+ * \ingroup pings
+ */
+static gboolean
+meta_display_ping_timeout (gpointer data)
+{
+  MetaPingData *ping_data;
+
+  ping_data = data;
+
+  ping_data->ping_timeout_id = 0;
+
+  meta_topic (META_DEBUG_PING,
+              "Ping %u on window %lx timed out\n",
+              ping_data->timestamp, ping_data->xwindow);
+  
+  (* ping_data->ping_timeout_func) (ping_data->display, ping_data->xwindow,
+                                    ping_data->timestamp, ping_data->user_data);
+
+  ping_data->display->pending_pings =
+    g_slist_remove (ping_data->display->pending_pings,
+                    ping_data);
+  ping_data_free (ping_data);
+  
+  return FALSE;
+}
+
+/**
+ * Sends a ping request to a window. The window must respond to
+ * the request within a certain amount of time. If it does, we
+ * will call one callback; if the time passes and we haven't had
+ * a response, we call a different callback. The window must have
+ * the hint showing that it can respond to a ping; if it doesn't,
+ * we call the "got a response" callback immediately and return.
+ * This function returns straight away after setting things up;
+ * the callbacks will be called from the event loop.
+ *
+ * \param display  The MetaDisplay that the window is on
+ * \param window   The MetaWindow to send the ping to
+ * \param timestamp The timestamp of the ping. Used for uniqueness.
+ *                  Cannot be CurrentTime; use a real timestamp!
+ * \param ping_reply_func The callback to call if we get a response.
+ * \param ping_timeout_func The callback to call if we don't get a response.
+ * \param user_data Arbitrary data that will be passed to the callback
+ *                  function. (In practice it's often a pointer to
+ *                  the window.)
+ *
+ * \bug This should probably be a method on windows, rather than displays
+ *      for one of their windows.
+ *
+ * \ingroup pings
+ */
+void
+meta_display_ping_window (MetaDisplay       *display,
+			  MetaWindow        *window,
+			  guint32            timestamp,
+			  MetaWindowPingFunc ping_reply_func,
+			  MetaWindowPingFunc ping_timeout_func,
+			  gpointer           user_data)
+{
+  MetaPingData *ping_data;
+
+  if (timestamp == CurrentTime)
+    {
+      meta_warning ("Tried to ping a window with CurrentTime! Not allowed.\n");
+      return;
+    }
+
+  if (!window->net_wm_ping)
+    {
+      if (ping_reply_func)
+        (* ping_reply_func) (display, window->xwindow, timestamp, user_data);
+
+      return;
+    }
+  
+  ping_data = g_new (MetaPingData, 1);
+  ping_data->display = display;
+  ping_data->xwindow = window->xwindow;
+  ping_data->timestamp = timestamp;
+  ping_data->ping_reply_func = ping_reply_func;
+  ping_data->ping_timeout_func = ping_timeout_func;
+  ping_data->user_data = user_data;
+  ping_data->ping_timeout_id = g_timeout_add (PING_TIMEOUT_DELAY,
+					      meta_display_ping_timeout,
+					      ping_data);
+  
+  display->pending_pings = g_slist_prepend (display->pending_pings, ping_data);
+
+  meta_topic (META_DEBUG_PING,
+              "Sending ping with timestamp %u to window %s\n",
+              timestamp, window->desc);
+  meta_window_send_icccm_message (window,
+                                  display->atom__NET_WM_PING,
+                                  timestamp);
+}
+
+static void
+process_request_frame_extents (MetaDisplay    *display,
+                               XEvent         *event)
+{
+  /* The X window whose frame extents will be set. */
+  Window xwindow = event->xclient.window;
+  unsigned long data[4] = { 0, 0, 0, 0 };
+
+  MotifWmHints *hints = NULL;
+  gboolean hints_set = FALSE;
+
+  meta_verbose ("Setting frame extents for 0x%lx\n", xwindow);
+
+  /* See if the window is decorated. */
+  hints_set = meta_prop_get_motif_hints (display,
+                                         xwindow,
+                                         display->atom__MOTIF_WM_HINTS,
+                                         &hints);
+  if ((hints_set && hints->decorations) || !hints_set)
+    {
+      int top = 0;
+      int bottom = 0;
+      int left = 0;
+      int right = 0;
+
+      MetaScreen *screen;
+
+      screen = meta_display_screen_for_xwindow (display,
+                                                event->xclient.window);
+      if (screen == NULL)
+        {
+          meta_warning ("Received request to set _NET_FRAME_EXTENTS "
+                        "on 0x%lx which is on a screen we are not managing\n",
+                        event->xclient.window);
+          meta_XFree (hints);
+          return;
+        }
+
+      /* Return estimated frame extents for a normal window. */
+      meta_ui_theme_get_frame_borders (screen->ui,
+                                       META_FRAME_TYPE_NORMAL,
+                                       0,
+                                       &top,
+                                       &bottom,
+                                       &left,
+                                       &right);
+
+      data[0] = left;
+      data[1] = right;
+      data[2] = top;
+      data[3] = bottom;
+    }
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Setting _NET_FRAME_EXTENTS on unmanaged window 0x%lx "
+              "to top = %lu, left = %lu, bottom = %lu, right = %lu\n",
+              xwindow, data[0], data[1], data[2], data[3]);
+
+  meta_error_trap_push (display);
+  XChangeProperty (display->xdisplay, xwindow,
+                   display->atom__NET_FRAME_EXTENTS,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 4);
+  meta_error_trap_pop (display, FALSE);
+
+  meta_XFree (hints);
+}
+
+/**
+ * Process the pong (the response message) from the ping we sent
+ * to the window. This involves removing the timeout, calling the
+ * reply handler function, and freeing memory.
+ *
+ * \param display  the display we got the pong from
+ * \param event    the XEvent which is a pong; we can tell which
+ *                 ping it corresponds to because it bears the
+ *                 same timestamp.
+ *
+ * \ingroup pings
+ */
+static void
+process_pong_message (MetaDisplay    *display,
+                      XEvent         *event)
+{
+  GSList *tmp;
+  guint32 timestamp = event->xclient.data.l[1];
+
+  meta_topic (META_DEBUG_PING, "Received a pong with timestamp %u\n",
+              timestamp);
+  
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+			  
+      if (timestamp == ping_data->timestamp)
+        {
+          meta_topic (META_DEBUG_PING,
+                      "Matching ping found for pong %u\n", 
+                      ping_data->timestamp);
+
+          /* Remove the ping data from the list */
+          display->pending_pings = g_slist_remove (display->pending_pings,
+                                                   ping_data);
+
+          /* Remove the timeout */
+          if (ping_data->ping_timeout_id != 0)
+            {
+              g_source_remove (ping_data->ping_timeout_id);
+              ping_data->ping_timeout_id = 0;
+            }
+          
+          /* Call callback */
+          (* ping_data->ping_reply_func) (display, 
+                                          ping_data->xwindow,
+                                          ping_data->timestamp, 
+                                          ping_data->user_data);
+			      
+          ping_data_free (ping_data);
+
+          break;
+        }
+    }
+}
+
+/**
+ * Finds whether a window has any pings waiting on it.
+ *
+ * \param display The MetaDisplay of the window.
+ * \param window  The MetaWindow whose pings we want to know about.
+ *
+ * \return True if there is at least one ping which has been sent
+ *         to the window without getting a response; false otherwise.
+ *
+ * \bug This should probably be a method on windows, rather than displays
+ *      for one of their windows.
+ *
+ * \ingroup pings
+ */
+gboolean
+meta_display_window_has_pending_pings (MetaDisplay *display,
+				       MetaWindow  *window)
+{
+  GSList *tmp;
+
+  for (tmp = display->pending_pings; tmp; tmp = tmp->next)
+    {
+      MetaPingData *ping_data = tmp->data;
+
+      if (ping_data->xwindow == window->xwindow) 
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+MetaGroup*
+get_focussed_group (MetaDisplay *display)
+{
+  if (display->focus_window)
+    return display->focus_window->group;
+  else
+    return NULL;
+}
+
+#define IN_TAB_CHAIN(w,t) (((t) == META_TAB_LIST_NORMAL && META_WINDOW_IN_NORMAL_TAB_CHAIN (w)) \
+    || ((t) == META_TAB_LIST_DOCKS && META_WINDOW_IN_DOCK_TAB_CHAIN (w)) \
+    || ((t) == META_TAB_LIST_GROUP && META_WINDOW_IN_GROUP_TAB_CHAIN (w, get_focussed_group(w->display))))
+
+static MetaWindow*
+find_tab_forward (MetaDisplay   *display,
+                  MetaTabList    type,
+                  MetaScreen    *screen, 
+                  MetaWorkspace *workspace,
+                  GList         *start,
+                  gboolean       skip_first)
+{
+  GList *tmp;
+
+  g_return_val_if_fail (start != NULL, NULL);
+  g_return_val_if_fail (workspace != NULL, NULL);
+
+  tmp = start;
+  if (skip_first)
+    tmp = tmp->next;
+
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (window->screen == screen &&
+	  IN_TAB_CHAIN (window, type))
+        return window;
+
+      tmp = tmp->next;
+    }
+
+  tmp = workspace->mru_list;
+  while (tmp != start && tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (IN_TAB_CHAIN (window, type))
+        return window;
+
+      tmp = tmp->next;
+    }  
+
+  return NULL;
+}
+
+static MetaWindow*
+find_tab_backward (MetaDisplay   *display,
+                   MetaTabList    type,
+                   MetaScreen    *screen, 
+                   MetaWorkspace *workspace,
+                   GList         *start,
+                   gboolean       skip_last)
+{
+  GList *tmp;
+
+  g_return_val_if_fail (start != NULL, NULL);
+  g_return_val_if_fail (workspace != NULL, NULL);
+
+  tmp = start;
+  if (skip_last)  
+    tmp = tmp->prev;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (window->screen == screen &&
+	  IN_TAB_CHAIN (window, type))
+        return window;
+
+      tmp = tmp->prev;
+    }
+
+  tmp = g_list_last (workspace->mru_list);
+  while (tmp != start)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (IN_TAB_CHAIN (window, type))
+        return window;
+
+      tmp = tmp->prev;
+    }
+
+  return NULL;
+}
+
+GList*
+meta_display_get_tab_list (MetaDisplay   *display,
+                           MetaTabList    type,
+                           MetaScreen    *screen,
+                           MetaWorkspace *workspace)
+{
+  GList *tab_list;
+
+  g_return_val_if_fail (workspace != NULL, NULL);
+
+  /* Windows sellout mode - MRU order. Collect unminimized windows
+   * then minimized so minimized windows aren't in the way so much.
+   */
+  {
+    GList *tmp;
+    
+    tab_list = NULL;
+    tmp = workspace->mru_list;
+    while (tmp != NULL)
+      {
+        MetaWindow *window = tmp->data;
+        
+        if (!window->minimized &&
+            window->screen == screen &&
+            IN_TAB_CHAIN (window, type))
+          tab_list = g_list_prepend (tab_list, window);
+        
+        tmp = tmp->next;
+      }
+  }
+
+  {
+    GList *tmp;
+    
+    tmp = workspace->mru_list;
+    while (tmp != NULL)
+      {
+        MetaWindow *window = tmp->data;
+        
+        if (window->minimized &&
+            window->screen == screen &&
+            IN_TAB_CHAIN (window, type))
+          tab_list = g_list_prepend (tab_list, window);
+        
+        tmp = tmp->next;
+      }
+  }
+
+  tab_list = g_list_reverse (tab_list);
+
+  {
+    GSList *tmp;
+    MetaWindow *l_window;
+
+    tmp = meta_display_list_windows (display);
+
+    /* Go through all windows */
+    while (tmp != NULL)
+      {
+        l_window=tmp->data;
+
+        /* Check to see if it demands attention */
+        if (l_window->wm_state_demands_attention && 
+            l_window->workspace!=workspace &&
+            IN_TAB_CHAIN (l_window, type)) 
+          {
+            /* if it does, add it to the popup */
+            tab_list = g_list_prepend (tab_list, l_window);
+          }
+
+        tmp = tmp->next;
+      } /* End while tmp!=NULL */
+  }
+  
+  return tab_list;
+}
+
+MetaWindow*
+meta_display_get_tab_next (MetaDisplay   *display,
+                           MetaTabList    type,
+                           MetaScreen    *screen,
+                           MetaWorkspace *workspace,
+                           MetaWindow    *window,
+                           gboolean       backward)
+{
+  gboolean skip;
+  GList *tab_list;
+  MetaWindow *ret;
+  tab_list = meta_display_get_tab_list(display,
+                                       type,
+                                       screen,
+                                       workspace);
+
+  if (tab_list == NULL)
+    return NULL;
+  
+  if (window != NULL)
+    {
+      g_assert (window->display == display);
+      
+      if (backward)
+        ret = find_tab_backward (display, type, screen, workspace,
+                                 g_list_find (tab_list,
+                                              window),
+                                 TRUE);
+      else
+        ret = find_tab_forward (display, type, screen, workspace,
+                                g_list_find (tab_list,
+                                             window),
+                                TRUE);
+    }
+  else
+    {
+      skip = display->focus_window != NULL && 
+             tab_list->data == display->focus_window;
+      if (backward)
+        ret = find_tab_backward (display, type, screen, workspace,
+                                 tab_list, skip);
+      else
+        ret = find_tab_forward (display, type, screen, workspace,
+                                tab_list, skip);
+    }
+
+  g_list_free (tab_list);
+  return ret;
+}
+
+MetaWindow*
+meta_display_get_tab_current (MetaDisplay   *display,
+                              MetaTabList    type,
+                              MetaScreen    *screen,
+                              MetaWorkspace *workspace)
+{
+  MetaWindow *window;
+
+  window = display->focus_window;
+  
+  if (window != NULL &&
+      window->screen == screen &&
+      IN_TAB_CHAIN (window, type) &&
+      (workspace == NULL ||
+       meta_window_located_on_workspace (window, workspace)))
+    return window;
+  else
+    return NULL;
+}
+
+int
+meta_resize_gravity_from_grab_op (MetaGrabOp op)
+{
+  int gravity;
+  
+  gravity = -1;
+  switch (op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+      gravity = NorthWestGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_RESIZING_S:
+      gravity = NorthGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_RESIZING_SW:
+      gravity = NorthEastGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_RESIZING_N:
+      gravity = SouthGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NE:
+      gravity = SouthWestGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_NW:
+      gravity = SouthEastGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_RESIZING_E:
+      gravity = WestGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_RESIZING_W:
+      gravity = EastGravity;
+      break;
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+      gravity = CenterGravity;
+      break;
+    default:
+      break;
+    }
+
+  return gravity;
+}
+
+static MetaScreen*
+find_screen_for_selection (MetaDisplay *display,
+                           Window       owner,
+                           Atom         selection)
+{  
+  GSList *tmp;  
+  
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+      
+      if (screen->wm_sn_selection_window == owner &&
+          screen->wm_sn_atom == selection)
+        return screen;
+  
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+/* from fvwm2, Copyright Matthias Clasen, Dominik Vogt */
+static gboolean
+convert_property (MetaDisplay *display,
+                  MetaScreen  *screen,
+                  Window       w,
+                  Atom         target,
+                  Atom         property)
+{
+#define N_TARGETS 4
+  Atom conversion_targets[N_TARGETS];
+  long icccm_version[] = { 2, 0 };
+
+  conversion_targets[0] = display->atom_TARGETS;
+  conversion_targets[1] = display->atom_MULTIPLE;
+  conversion_targets[2] = display->atom_TIMESTAMP;
+  conversion_targets[3] = display->atom_VERSION;
+
+  meta_error_trap_push_with_return (display);
+  if (target == display->atom_TARGETS)
+    XChangeProperty (display->xdisplay, w, property,
+		     XA_ATOM, 32, PropModeReplace,
+		     (unsigned char *)conversion_targets, N_TARGETS);
+  else if (target == display->atom_TIMESTAMP)
+    XChangeProperty (display->xdisplay, w, property,
+		     XA_INTEGER, 32, PropModeReplace,
+		     (unsigned char *)&screen->wm_sn_timestamp, 1);
+  else if (target == display->atom_VERSION)
+    XChangeProperty (display->xdisplay, w, property,
+		     XA_INTEGER, 32, PropModeReplace,
+		     (unsigned char *)icccm_version, 2);
+  else
+    {
+      meta_error_trap_pop_with_return (display, FALSE);
+      return FALSE;
+    }
+  
+  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+    return FALSE;
+
+  /* Be sure the PropertyNotify has arrived so we
+   * can send SelectionNotify
+   */
+  /* FIXME the error trap pop synced anyway, right? */
+  meta_topic (META_DEBUG_SYNC, "Syncing on %s\n", G_STRFUNC);
+  XSync (display->xdisplay, False);
+
+  return TRUE;
+}
+
+/* from fvwm2, Copyright Matthias Clasen, Dominik Vogt */
+static void
+process_selection_request (MetaDisplay   *display,
+                           XEvent        *event)
+{
+  XSelectionEvent reply;
+  MetaScreen *screen;
+
+  screen = find_screen_for_selection (display,
+                                      event->xselectionrequest.owner,
+                                      event->xselectionrequest.selection);
+
+  if (screen == NULL)
+    {
+      char *str;
+      
+      meta_error_trap_push (display);
+      str = XGetAtomName (display->xdisplay,
+                          event->xselectionrequest.selection);
+      meta_error_trap_pop (display, TRUE);
+      
+      meta_verbose ("Selection request with selection %s window 0x%lx not a WM_Sn selection we recognize\n",
+                    str ? str : "(bad atom)", event->xselectionrequest.owner);
+      
+      meta_XFree (str);
+
+      return;
+    }
+  
+  reply.type = SelectionNotify;
+  reply.display = display->xdisplay;
+  reply.requestor = event->xselectionrequest.requestor;
+  reply.selection = event->xselectionrequest.selection;
+  reply.target = event->xselectionrequest.target;
+  reply.property = None;
+  reply.time = event->xselectionrequest.time;
+
+  if (event->xselectionrequest.target == display->atom_MULTIPLE)
+    {
+      if (event->xselectionrequest.property != None)
+        {
+          Atom type, *adata;
+          int i, format;
+          unsigned long num, rest;
+          unsigned char *data;
+
+          meta_error_trap_push_with_return (display);
+          if (XGetWindowProperty (display->xdisplay,
+                                  event->xselectionrequest.requestor,
+                                  event->xselectionrequest.property, 0, 256, False,
+                                  display->atom_ATOM_PAIR,
+                                  &type, &format, &num, &rest, &data) != Success)
+            {
+              meta_error_trap_pop_with_return (display, TRUE);
+              return;
+            }
+          
+          if (meta_error_trap_pop_with_return (display, TRUE) == Success)
+            {              
+              /* FIXME: to be 100% correct, should deal with rest > 0,
+               * but since we have 4 possible targets, we will hardly ever
+               * meet multiple requests with a length > 8
+               */
+              adata = (Atom*)data;
+              i = 0;
+              while (i < (int) num)
+                {
+                  if (!convert_property (display, screen,
+                                         event->xselectionrequest.requestor,
+                                         adata[i], adata[i+1]))
+                    adata[i+1] = None;
+                  i += 2;
+                }
+
+              meta_error_trap_push (display);
+              XChangeProperty (display->xdisplay,
+                               event->xselectionrequest.requestor,
+                               event->xselectionrequest.property,
+                               display->atom_ATOM_PAIR,
+                               32, PropModeReplace, data, num);
+              meta_error_trap_pop (display, FALSE);
+              meta_XFree (data);
+            }
+        }
+    }
+  else
+    {
+      if (event->xselectionrequest.property == None)
+        event->xselectionrequest.property = event->xselectionrequest.target;
+      
+      if (convert_property (display, screen,
+                            event->xselectionrequest.requestor,
+                            event->xselectionrequest.target,
+                            event->xselectionrequest.property))
+        reply.property = event->xselectionrequest.property;
+    }
+
+  XSendEvent (display->xdisplay,
+              event->xselectionrequest.requestor,
+              False, 0L, (XEvent*)&reply);
+
+  meta_verbose ("Handled selection request\n");
+}
+
+static void
+process_selection_clear (MetaDisplay   *display,
+                         XEvent        *event)
+{
+  /* We need to unmanage the screen on which we lost the selection */
+  MetaScreen *screen;
+
+  screen = find_screen_for_selection (display,
+                                      event->xselectionclear.window,
+                                      event->xselectionclear.selection);
+  
+
+  if (screen != NULL)
+    {
+      meta_verbose ("Got selection clear for screen %d on display %s\n",
+                    screen->number, display->name);
+      
+      meta_display_unmanage_screen (&display, 
+                                    screen,
+                                    event->xselectionclear.time);
+
+      if (!display)
+        the_display = NULL;
+
+      /* display and screen may both be invalid memory... */
+      
+      return;
+    }
+
+  {
+    char *str;
+            
+    meta_error_trap_push (display);
+    str = XGetAtomName (display->xdisplay,
+                        event->xselectionclear.selection);
+    meta_error_trap_pop (display, TRUE);
+
+    meta_verbose ("Selection clear with selection %s window 0x%lx not a WM_Sn selection we recognize\n",
+                  str ? str : "(bad atom)", event->xselectionclear.window);
+
+    meta_XFree (str);
+  }
+}
+
+void
+meta_display_unmanage_screen (MetaDisplay **displayp,
+                              MetaScreen  *screen,
+                              guint32      timestamp)
+{
+  MetaDisplay *display = *displayp;
+
+  meta_verbose ("Unmanaging screen %d on display %s\n",
+                screen->number, display->name);
+  
+  g_return_if_fail (g_slist_find (display->screens, screen) != NULL);
+  
+  meta_screen_free (screen, timestamp);
+  display->screens = g_slist_remove (display->screens, screen);
+
+  if (display->screens == NULL)
+    {
+      meta_display_close (display, timestamp);
+      *displayp = NULL;
+    }
+}
+
+void
+meta_display_unmanage_windows_for_screen (MetaDisplay *display,
+                                          MetaScreen  *screen,
+                                          guint32      timestamp)
+{
+  GSList *tmp;
+  GSList *winlist;
+
+  winlist = meta_display_list_windows (display);
+  winlist = g_slist_sort (winlist, meta_display_stack_cmp);
+
+  /* Unmanage all windows */
+  tmp = winlist;
+  while (tmp != NULL)
+    {
+      meta_window_free (tmp->data, timestamp);
+      
+      tmp = tmp->next;
+    }
+  g_slist_free (winlist);
+}
+
+int
+meta_display_stack_cmp (const void *a,
+                        const void *b)
+{
+  MetaWindow *aw = (void*) a;
+  MetaWindow *bw = (void*) b;
+
+  if (aw->screen == bw->screen)
+    return meta_stack_windows_cmp (aw->screen->stack, aw, bw);
+  /* Then assume screens are stacked by number */
+  else if (aw->screen->number < bw->screen->number)
+    return -1;
+  else if (aw->screen->number > bw->screen->number)
+    return 1;
+  else
+    return 0; /* not reached in theory, if windows on same display */
+}
+
+void
+meta_display_devirtualize_modifiers (MetaDisplay        *display,
+                                     MetaVirtualModifier modifiers,
+                                     unsigned int       *mask)
+{
+  *mask = 0;
+  
+  if (modifiers & META_VIRTUAL_SHIFT_MASK)
+    *mask |= ShiftMask;
+  if (modifiers & META_VIRTUAL_CONTROL_MASK)
+    *mask |= ControlMask;
+  if (modifiers & META_VIRTUAL_ALT_MASK)
+    *mask |= Mod1Mask;
+  if (modifiers & META_VIRTUAL_META_MASK)
+    *mask |= display->meta_mask;
+  if (modifiers & META_VIRTUAL_HYPER_MASK)
+    *mask |= display->hyper_mask;
+  if (modifiers & META_VIRTUAL_SUPER_MASK)
+    *mask |= display->super_mask;
+  if (modifiers & META_VIRTUAL_MOD2_MASK)
+    *mask |= Mod2Mask;
+  if (modifiers & META_VIRTUAL_MOD3_MASK)
+    *mask |= Mod3Mask;
+  if (modifiers & META_VIRTUAL_MOD4_MASK)
+    *mask |= Mod4Mask;
+  if (modifiers & META_VIRTUAL_MOD5_MASK)
+    *mask |= Mod5Mask;  
+}
+
+static void
+update_window_grab_modifiers (MetaDisplay *display)
+     
+{
+  MetaVirtualModifier virtual_mods;
+  unsigned int mods;
+    
+  virtual_mods = meta_prefs_get_mouse_button_mods ();
+  meta_display_devirtualize_modifiers (display, virtual_mods,
+                                       &mods);
+    
+  display->window_grab_modifiers = mods;
+}
+
+static void
+prefs_changed_callback (MetaPreference pref,
+                        void          *data)
+{
+  MetaDisplay *display = data;
+  
+  /* It may not be obvious why we regrab on focus mode
+   * change; it's because we handle focus clicks a
+   * bit differently for the different focus modes.
+   */
+  if (pref == META_PREF_MOUSE_BUTTON_MODS ||
+      pref == META_PREF_FOCUS_MODE)
+    {
+      MetaDisplay *display = data;
+      GSList *windows;
+      GSList *tmp;
+      
+      windows = meta_display_list_windows (display);
+      
+      /* Ungrab all */
+      tmp = windows;
+      while (tmp != NULL)
+        {
+          MetaWindow *w = tmp->data;
+          meta_display_ungrab_window_buttons (display, w->xwindow);
+          meta_display_ungrab_focus_window_button (display, w);
+          tmp = tmp->next;
+        }
+
+      /* change our modifier */
+      if (pref == META_PREF_MOUSE_BUTTON_MODS)
+        update_window_grab_modifiers (display);
+
+      /* Grab all */
+      tmp = windows;
+      while (tmp != NULL)
+        {
+          MetaWindow *w = tmp->data;
+          if (w->type != META_WINDOW_DOCK)
+            {
+              meta_display_grab_focus_window_button (display, w);
+              meta_display_grab_window_buttons (display, w->xwindow);
+            }
+          tmp = tmp->next;
+        }
+
+      g_slist_free (windows);
+    }
+  else if (pref == META_PREF_AUDIBLE_BELL)
+    {
+      meta_bell_set_audible (display, meta_prefs_bell_is_audible ());
+    }
+  else if (pref == META_PREF_COMPOSITING_MANAGER)
+    {
+      gboolean cm = meta_prefs_get_compositing_manager ();
+
+      if (cm)
+        enable_compositor (display, TRUE);
+      else
+	disable_compositor (display);
+    }
+}
+
+void
+meta_display_increment_focus_sentinel (MetaDisplay *display)
+{
+  unsigned long data[1];
+
+  data[0] = meta_display_get_current_time (display);
+  
+  XChangeProperty (display->xdisplay,
+                   ((MetaScreen*) display->screens->data)->xroot,
+                   display->atom__MARCO_SENTINEL,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  
+  display->sentinel_counter += 1;
+}
+
+void
+meta_display_decrement_focus_sentinel (MetaDisplay *display)
+{
+  display->sentinel_counter -= 1;
+
+  if (display->sentinel_counter < 0)
+    display->sentinel_counter = 0;
+}
+
+gboolean
+meta_display_focus_sentinel_clear (MetaDisplay *display)
+{
+  return (display->sentinel_counter == 0);
+}
+
+static void
+sanity_check_timestamps (MetaDisplay *display,
+                         guint32      timestamp)
+{
+  if (XSERVER_TIME_IS_BEFORE (timestamp, display->last_focus_time))
+    {
+      meta_warning ("last_focus_time (%u) is greater than comparison "
+                    "timestamp (%u).  This most likely represents a buggy "
+                    "client sending inaccurate timestamps in messages such as "
+                    "_NET_ACTIVE_WINDOW.  Trying to work around...\n",
+                    display->last_focus_time, timestamp);
+      display->last_focus_time = timestamp;
+    }
+  if (XSERVER_TIME_IS_BEFORE (timestamp, display->last_user_time))
+    {
+      GSList *windows;
+      GSList *tmp;
+
+      meta_warning ("last_user_time (%u) is greater than comparison "
+                    "timestamp (%u).  This most likely represents a buggy "
+                    "client sending inaccurate timestamps in messages such as "
+                    "_NET_ACTIVE_WINDOW.  Trying to work around...\n",
+                    display->last_user_time, timestamp);
+      display->last_user_time = timestamp;
+
+      windows = meta_display_list_windows (display);
+      tmp = windows;
+      while (tmp != NULL)
+        {
+          MetaWindow *window = tmp->data;
+          
+          if (XSERVER_TIME_IS_BEFORE (timestamp, window->net_wm_user_time))
+            {
+              meta_warning ("%s appears to be one of the offending windows "
+                            "with a timestamp of %u.  Working around...\n",
+                            window->desc, window->net_wm_user_time);
+              window->net_wm_user_time = timestamp;
+            }
+          
+          tmp = tmp->next;
+        }
+
+      g_slist_free (windows);
+    }
+}
+
+static gboolean
+timestamp_too_old (MetaDisplay *display,
+                   MetaWindow  *window,
+                   guint32     *timestamp)
+{
+  /* FIXME: If Soeren's suggestion in bug 151984 is implemented, it will allow
+   * us to sanity check the timestamp here and ensure it doesn't correspond to
+   * a future time (though we would want to rename to 
+   * timestamp_too_old_or_in_future).
+   */
+
+  if (*timestamp == CurrentTime)
+    {
+      meta_warning ("Got a request to focus %s with a timestamp of 0.  This "
+                    "shouldn't happen!\n",
+                    window ? window->desc : "the no_focus_window");
+      meta_print_backtrace ();
+      *timestamp = meta_display_get_current_time_roundtrip (display);
+      return FALSE;
+    }
+  else if (XSERVER_TIME_IS_BEFORE (*timestamp, display->last_focus_time))
+    {
+      if (XSERVER_TIME_IS_BEFORE (*timestamp, display->last_user_time))
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Ignoring focus request for %s since %u "
+                      "is less than %u and %u.\n",
+                      window ? window->desc : "the no_focus_window",
+                      *timestamp,
+                      display->last_user_time,
+                      display->last_focus_time);
+          return TRUE;
+        }
+      else
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Received focus request for %s which is newer than most "
+                      "recent user_time, but less recent than "
+                      "last_focus_time (%u < %u < %u); adjusting "
+                      "accordingly.  (See bug 167358)\n",
+                      window ? window->desc : "the no_focus_window",
+                      display->last_user_time,
+                      *timestamp,
+                      display->last_focus_time);
+          *timestamp = display->last_focus_time;
+          return FALSE;
+        }
+    }
+
+  return FALSE;
+}
+
+void
+meta_display_set_input_focus_window (MetaDisplay *display, 
+                                     MetaWindow  *window,
+                                     gboolean     focus_frame,
+                                     guint32      timestamp)
+{
+  if (timestamp_too_old (display, window, &timestamp))
+    return;
+
+  meta_error_trap_push (display);
+  XSetInputFocus (display->xdisplay,
+                  focus_frame ? window->frame->xwindow : window->xwindow,
+                  RevertToPointerRoot,
+                  timestamp);
+  meta_error_trap_pop (display, FALSE);
+
+  display->expected_focus_window = window;
+  display->last_focus_time = timestamp;
+  display->active_screen = window->screen;
+
+  if (window != display->autoraise_window)
+    meta_display_remove_autoraise_callback (window->display);
+}
+
+void
+meta_display_focus_the_no_focus_window (MetaDisplay *display, 
+                                        MetaScreen  *screen,
+                                        guint32      timestamp)
+{
+  if (timestamp_too_old (display, NULL, &timestamp))
+    return;
+
+  XSetInputFocus (display->xdisplay,
+                  screen->no_focus_window,
+                  RevertToPointerRoot,
+                  timestamp);
+  display->expected_focus_window = NULL;
+  display->last_focus_time = timestamp;
+  display->active_screen = screen;
+
+  meta_display_remove_autoraise_callback (display);
+}
+
+void
+meta_display_remove_autoraise_callback (MetaDisplay *display)
+{
+  if (display->autoraise_timeout_id != 0)
+    {
+      g_source_remove (display->autoraise_timeout_id);
+      display->autoraise_timeout_id = 0;
+      display->autoraise_window = NULL;
+    }
+}
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+void
+meta_display_get_compositor_version (MetaDisplay *display,
+                                     int         *major,
+                                     int         *minor)
+{
+  *major = display->composite_major_version;
+  *minor = display->composite_minor_version;
+}
+#endif
+
+Display *
+meta_display_get_xdisplay (MetaDisplay *display)
+{
+  return display->xdisplay;
+}
+
+MetaCompositor *
+meta_display_get_compositor (MetaDisplay *display)
+{
+  return display->compositor;
+}
+
+GSList *
+meta_display_get_screens (MetaDisplay *display)
+{
+  return display->screens;
+}
+
+gboolean
+meta_display_has_shape (MetaDisplay *display)
+{
+  return META_DISPLAY_HAS_SHAPE (display);
+}
+
+MetaWindow *
+meta_display_get_focus_window (MetaDisplay *display)
+{
+  return display->focus_window;
+}
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+int 
+meta_display_get_damage_event_base (MetaDisplay *display)
+{
+  return display->damage_event_base;
+}
+#endif
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#ifdef HAVE_SHAPE
+int
+meta_display_get_shape_event_base (MetaDisplay *display)
+{
+  return display->shape_event_base;
+}
+#endif
+#endif
diff --git a/src/core/edge-resistance.c b/src/core/edge-resistance.c
new file mode 100644
index 00000000..fd3f2d44
--- /dev/null
+++ b/src/core/edge-resistance.c
@@ -0,0 +1,1277 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Edge resistance for move/resize operations */
+
+/* 
+ * Copyright (C) 2005, 2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "edge-resistance.h"
+#include "boxes.h"
+#include "display-private.h"
+#include "workspace.h"
+
+/* A simple macro for whether a given window's edges are potentially
+ * relevant for resistance/snapping during a move/resize operation
+ */
+#define WINDOW_EDGES_RELEVANT(window, display) \
+  meta_window_should_be_showing (window) &&    \
+  window->screen == display->grab_screen &&    \
+  window         != display->grab_window &&    \
+  window->type   != META_WINDOW_DESKTOP &&     \
+  window->type   != META_WINDOW_MENU    &&     \
+  window->type   != META_WINDOW_SPLASHSCREEN
+
+struct ResistanceDataForAnEdge
+{
+  gboolean     timeout_setup;
+  guint        timeout_id;
+  int          timeout_edge_pos;
+  gboolean     timeout_over;
+  GSourceFunc  timeout_func;
+  MetaWindow  *window;
+  int          keyboard_buildup;
+};
+typedef struct ResistanceDataForAnEdge ResistanceDataForAnEdge;
+
+struct MetaEdgeResistanceData
+{
+  GArray *left_edges;
+  GArray *right_edges;
+  GArray *top_edges;
+  GArray *bottom_edges;
+
+  ResistanceDataForAnEdge left_data;
+  ResistanceDataForAnEdge right_data;
+  ResistanceDataForAnEdge top_data;
+  ResistanceDataForAnEdge bottom_data;
+};
+
+/* !WARNING!: this function can return invalid indices (namely, either -1 or
+ * edges->len); this is by design, but you need to remember this.
+ */
+static int
+find_index_of_edge_near_position (const GArray *edges,
+                                  int           position,
+                                  gboolean      want_interval_min,
+                                  gboolean      horizontal)
+{
+  /* This is basically like a binary search, except that we're trying to
+   * find a range instead of an exact value.  So, if we have in our array
+   *   Value: 3  27 316 316 316 505 522 800 1213
+   *   Index: 0   1   2   3   4   5   6   7    8
+   * and we call this function with position=500 & want_interval_min=TRUE
+   * then we should get 5 (because 505 is the first value bigger than 500).
+   * If we call this function with position=805 and want_interval_min=FALSE
+   * then we should get 7 (because 800 is the last value smaller than 800).
+   * A couple more, to make things clear:
+   *    position  want_interval_min  correct_answer
+   *         316               TRUE               2
+   *         316              FALSE               4
+   *           2              FALSE              -1
+   *        2000               TRUE               9
+   */
+  int low, high, mid;
+  int compare;
+  MetaEdge *edge;
+
+  /* Initialize mid, edge, & compare in the off change that the array only
+   * has one element.
+   */
+  mid  = 0;
+  edge = g_array_index (edges, MetaEdge*, mid);
+  compare = horizontal ? edge->rect.x : edge->rect.y;
+
+  /* Begin the search... */
+  low  = 0;
+  high = edges->len - 1;
+  while (low < high)
+    {
+      mid = low + (high - low)/2;
+      edge = g_array_index (edges, MetaEdge*, mid);
+      compare = horizontal ? edge->rect.x : edge->rect.y;
+
+      if (compare == position)
+        break;
+
+      if (compare > position)
+        high = mid - 1;
+      else
+        low = mid + 1;
+    }
+
+  /* mid should now be _really_ close to the index we want, so we start
+   * linearly searching.  However, note that we don't know if mid is less
+   * than or greater than what we need and it's possible that there are
+   * several equal values equal to what we were searching for and we ended
+   * up in the middle of them instead of at the end.  So we may need to
+   * move mid multiple locations over.
+   */
+  if (want_interval_min)
+    {
+      while (compare >= position && mid > 0)
+        {
+          mid--;
+          edge = g_array_index (edges, MetaEdge*, mid);
+          compare = horizontal ? edge->rect.x : edge->rect.y;
+        }
+      while (compare < position && mid < (int)edges->len - 1)
+        {
+          mid++;
+          edge = g_array_index (edges, MetaEdge*, mid);
+          compare = horizontal ? edge->rect.x : edge->rect.y;
+        }
+
+      /* Special case for no values in array big enough */
+      if (compare < position)
+        return edges->len;
+
+      /* Return the found value */
+      return mid;
+    }
+  else
+    {
+      while (compare <= position && mid < (int)edges->len - 1)
+        {
+          mid++;
+          edge = g_array_index (edges, MetaEdge*, mid);
+          compare = horizontal ? edge->rect.x : edge->rect.y;
+        }
+      while (compare > position && mid > 0)
+        {
+          mid--;
+          edge = g_array_index (edges, MetaEdge*, mid);
+          compare = horizontal ? edge->rect.x : edge->rect.y;
+        }
+
+      /* Special case for no values in array small enough */
+      if (compare > position)
+        return -1;
+
+      /* Return the found value */
+      return mid;
+    }
+}
+
+static gboolean
+points_on_same_side (int ref, int pt1, int pt2)
+{
+  return (pt1 - ref) * (pt2 - ref) > 0;
+}
+
+static int
+find_nearest_position (const GArray        *edges,
+                       int                  position,
+                       int                  old_position,
+                       const MetaRectangle *new_rect,
+                       gboolean             horizontal,
+                       gboolean             only_forward)
+{
+  /* This is basically just a binary search except that we're looking
+   * for the value closest to position, rather than finding that
+   * actual value.  Also, we ignore any edges that aren't relevant
+   * given the horizontal/vertical position of new_rect.
+   */
+  int low, high, mid;
+  int compare;
+  MetaEdge *edge;
+  int best, best_dist, i;
+  gboolean edges_align;
+
+  /* Initialize mid, edge, & compare in the off change that the array only
+   * has one element.
+   */
+  mid  = 0;
+  edge = g_array_index (edges, MetaEdge*, mid);
+  compare = horizontal ? edge->rect.x : edge->rect.y;
+
+  /* Begin the search... */
+  low  = 0;
+  high = edges->len - 1;
+  while (low < high)
+    {
+      mid = low + (high - low)/2;
+      edge = g_array_index (edges, MetaEdge*, mid);
+      compare = horizontal ? edge->rect.x : edge->rect.y;
+
+      if (compare == position)
+        break;
+
+      if (compare > position)
+        high = mid - 1;
+      else
+        low = mid + 1;
+    }
+
+  /* mid should now be _really_ close to the index we want, so we
+   * start searching nearby for something that overlaps and is closer
+   * than the original position.
+   */
+  best = old_position;
+  best_dist = INT_MAX;
+
+  /* Start the search at mid */
+  edge = g_array_index (edges, MetaEdge*, mid);
+  compare = horizontal ? edge->rect.x : edge->rect.y;
+  edges_align = meta_rectangle_edge_aligns (new_rect, edge);
+  if (edges_align &&
+      (!only_forward || !points_on_same_side (position, compare, old_position)))
+    {
+      int dist = ABS (compare - position);
+      if (dist < best_dist)
+        {
+          best = compare;
+          best_dist = dist;
+        }
+    }
+
+  /* Now start searching higher than mid */
+  for (i = mid + 1; i < (int)edges->len; i++)
+    {
+      edge = g_array_index (edges, MetaEdge*, i);
+      compare = horizontal ? edge->rect.x : edge->rect.y;
+  
+      edges_align = horizontal ? 
+        meta_rectangle_vert_overlap (&edge->rect, new_rect) :
+        meta_rectangle_horiz_overlap (&edge->rect, new_rect);
+
+      if (edges_align &&
+          (!only_forward ||
+           !points_on_same_side (position, compare, old_position)))
+        {
+          int dist = ABS (compare - position);
+          if (dist < best_dist)
+            {
+              best = compare;
+              best_dist = dist;
+            }
+          break;
+        }
+    }
+
+  /* Now start searching lower than mid */
+  for (i = mid-1; i >= 0; i--)
+    {
+      edge = g_array_index (edges, MetaEdge*, i);
+      compare = horizontal ? edge->rect.x : edge->rect.y;
+  
+      edges_align = horizontal ? 
+        meta_rectangle_vert_overlap (&edge->rect, new_rect) :
+        meta_rectangle_horiz_overlap (&edge->rect, new_rect);
+
+      if (edges_align &&
+          (!only_forward ||
+           !points_on_same_side (position, compare, old_position)))
+        {
+          int dist = ABS (compare - position);
+          if (dist < best_dist)
+            {
+              best = compare;
+              best_dist = dist;
+            }
+          break;
+        }
+    }
+
+  /* Return the best one found */
+  return best;
+}
+
+static gboolean
+movement_towards_edge (MetaSide side, int increment)
+{
+  switch (side)
+    {
+    case META_SIDE_LEFT:
+    case META_SIDE_TOP:
+      return increment < 0;
+    case META_SIDE_RIGHT:
+    case META_SIDE_BOTTOM:
+      return increment > 0;
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+static gboolean
+edge_resistance_timeout (gpointer data)
+{
+  ResistanceDataForAnEdge *resistance_data = data;
+
+  resistance_data->timeout_over = TRUE;
+  resistance_data->timeout_id = 0;
+  (*resistance_data->timeout_func)(resistance_data->window);
+
+  return FALSE;
+}
+
+static int
+apply_edge_resistance (MetaWindow                *window,
+                       int                        old_pos,
+                       int                        new_pos,
+                       const MetaRectangle       *old_rect,
+                       const MetaRectangle       *new_rect,
+                       GArray                    *edges,
+                       ResistanceDataForAnEdge   *resistance_data,
+                       GSourceFunc                timeout_func,
+                       gboolean                   xdir,
+                       gboolean                   keyboard_op)
+{
+  int i, begin, end;
+  int last_edge;
+  gboolean increasing = new_pos > old_pos;
+  int      increment = increasing ? 1 : -1;
+
+  const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_WINDOW    = 16;
+  const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW   =  0;
+  const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA  = 32;
+  const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA =  0;
+  const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_SCREEN    = 32;
+  const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_SCREEN   =  0;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW   =   0;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA =   0;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN   =   0;
+
+  /* Quit if no movement was specified */
+  if (old_pos == new_pos)
+    return new_pos;
+
+  /* Remove the old timeout if it's no longer relevant */
+  if (resistance_data->timeout_setup &&
+      ((resistance_data->timeout_edge_pos > old_pos &&
+        resistance_data->timeout_edge_pos > new_pos)  ||
+       (resistance_data->timeout_edge_pos < old_pos &&
+        resistance_data->timeout_edge_pos < new_pos)))
+    {
+      resistance_data->timeout_setup = FALSE;
+      if (resistance_data->timeout_id != 0)
+        {
+          g_source_remove (resistance_data->timeout_id);
+          resistance_data->timeout_id = 0;
+        }
+    }
+
+  /* Get the range of indices in the edge array that we move past/to. */
+  begin = find_index_of_edge_near_position (edges, old_pos,  increasing, xdir);
+  end   = find_index_of_edge_near_position (edges, new_pos, !increasing, xdir);
+
+  /* begin and end can be outside the array index, if the window is partially
+   * off the screen
+   */
+  last_edge = edges->len - 1;
+  begin = CLAMP (begin, 0, last_edge);
+  end   = CLAMP (end,   0, last_edge);
+
+  /* Loop over all these edges we're moving past/to. */
+  i = begin;
+  while ((increasing  && i <= end) ||
+         (!increasing && i >= end))
+    {
+      gboolean  edges_align;
+      MetaEdge *edge = g_array_index (edges, MetaEdge*, i);
+      int       compare = xdir ? edge->rect.x : edge->rect.y;
+
+      /* Find out if this edge is relevant */
+      edges_align = meta_rectangle_edge_aligns (new_rect, edge)  ||
+                    meta_rectangle_edge_aligns (old_rect, edge);
+
+      /* Nothing to do unless the edges align */
+      if (!edges_align)
+        {
+          /* Go to the next edge in the range */
+          i += increment;
+          continue;
+        }
+
+      /* Rest is easier to read if we split on keyboard vs. mouse op */
+      if (keyboard_op)
+        {
+          if ((old_pos < compare && compare < new_pos) ||
+              (old_pos > compare && compare > new_pos))
+            return compare;
+        }
+      else /* mouse op */
+        {
+          int threshold;
+
+          /* TIMEOUT RESISTANCE: If the edge is relevant and we're moving
+           * towards it, then we may want to have some kind of time delay
+           * before the user can move past this edge.
+           */
+          if (movement_towards_edge (edge->side_type, increment))
+            {
+              /* First, determine the length of time for the resistance */
+              int timeout_length_ms = 0;
+              switch (edge->edge_type)
+                {
+                case META_EDGE_WINDOW:
+                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW;
+                  break;
+                case META_EDGE_XINERAMA:
+                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA;
+                  break;
+                case META_EDGE_SCREEN:
+                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN;
+                  break;
+                }
+
+              if (!resistance_data->timeout_setup &&
+                  timeout_length_ms != 0)
+                {
+                  resistance_data->timeout_id = 
+                    g_timeout_add (timeout_length_ms,
+                                   edge_resistance_timeout,
+                                   resistance_data);
+                  resistance_data->timeout_setup = TRUE;
+                  resistance_data->timeout_edge_pos = compare;
+                  resistance_data->timeout_over = FALSE;
+                  resistance_data->timeout_func = timeout_func;
+                  resistance_data->window = window;
+                }
+              if (!resistance_data->timeout_over &&
+                  timeout_length_ms != 0)
+                return compare;
+            }
+
+          /* PIXEL DISTANCE MOUSE RESISTANCE: If the edge matters and the
+           * user hasn't moved at least threshold pixels past this edge,
+           * stop movement at this edge.  (Note that this is different from
+           * keyboard resistance precisely because keyboard move ops are
+           * relative to previous positions, whereas mouse move ops are
+           * relative to differences in mouse position and mouse position
+           * is an absolute quantity rather than a relative quantity)
+           */
+
+          /* First, determine the threshold */
+          threshold = 0;
+          switch (edge->edge_type)
+            {
+            case META_EDGE_WINDOW:
+              if (movement_towards_edge (edge->side_type, increment))
+                threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_WINDOW;
+              else
+                threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW;
+              break;
+            case META_EDGE_XINERAMA:
+              if (movement_towards_edge (edge->side_type, increment))
+                threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA;
+              else
+                threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA;
+              break;
+            case META_EDGE_SCREEN:
+              if (movement_towards_edge (edge->side_type, increment))
+                threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_SCREEN;
+              else
+                threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_SCREEN;
+              break;
+            }
+
+          if (ABS (compare - new_pos) < threshold)
+            return compare;
+        }
+
+      /* Go to the next edge in the range */
+      i += increment;
+    }
+
+  return new_pos;
+}
+
+static int
+apply_edge_snapping (int                  old_pos,
+                     int                  new_pos,
+                     const MetaRectangle *new_rect,
+                     GArray              *edges,
+                     gboolean             xdir,
+                     gboolean             keyboard_op)
+{
+  int snap_to;
+
+  if (old_pos == new_pos)
+    return new_pos;
+
+  snap_to = find_nearest_position (edges,
+                                   new_pos,
+                                   old_pos,
+                                   new_rect,
+                                   xdir,
+                                   keyboard_op);
+
+  /* If mouse snap-moving, the user could easily accidentally move just a
+   * couple pixels in a direction they didn't mean to move; so ignore snap
+   * movement in those cases unless it's only a small number of pixels
+   * anyway.
+   */
+  if (!keyboard_op &&
+      ABS (snap_to - old_pos) >= 8 &&
+      ABS (new_pos - old_pos) < 8)
+    return old_pos;
+  else
+    /* Otherwise, return the snapping position found */
+    return snap_to;
+}
+
+/* This function takes the position (including any frame) of the window and
+ * a proposed new position (ignoring edge resistance/snapping), and then
+ * applies edge resistance to EACH edge (separately) updating new_outer.
+ * It returns true if new_outer is modified, false otherwise.
+ *
+ * display->grab_edge_resistance_data MUST already be setup or calling this
+ * function will cause a crash.
+ */
+static gboolean 
+apply_edge_resistance_to_each_side (MetaDisplay         *display,
+                                    MetaWindow          *window,
+                                    const MetaRectangle *old_outer,
+                                    MetaRectangle       *new_outer,
+                                    GSourceFunc          timeout_func,
+                                    gboolean             auto_snap,
+                                    gboolean             keyboard_op,
+                                    gboolean             is_resize)
+{
+  MetaEdgeResistanceData *edge_data;
+  MetaRectangle           modified_rect;
+  gboolean                modified;
+  int new_left, new_right, new_top, new_bottom;
+
+  g_assert (display->grab_edge_resistance_data != NULL);
+  edge_data = display->grab_edge_resistance_data;
+
+  if (auto_snap)
+    {
+      /* Do the auto snapping instead of normal edge resistance; in all
+       * cases, we allow snapping to opposite kinds of edges (e.g. left
+       * sides of windows to both left and right edges.
+       */
+
+      new_left   = apply_edge_snapping (BOX_LEFT (*old_outer),
+                                        BOX_LEFT (*new_outer),
+                                        new_outer,
+                                        edge_data->left_edges,
+                                        TRUE,
+                                        keyboard_op);
+
+      new_right  = apply_edge_snapping (BOX_RIGHT (*old_outer),
+                                        BOX_RIGHT (*new_outer),
+                                        new_outer,
+                                        edge_data->right_edges,
+                                        TRUE,
+                                        keyboard_op);
+
+      new_top    = apply_edge_snapping (BOX_TOP (*old_outer),
+                                        BOX_TOP (*new_outer),
+                                        new_outer,
+                                        edge_data->top_edges,
+                                        FALSE,
+                                        keyboard_op);
+
+      new_bottom = apply_edge_snapping (BOX_BOTTOM (*old_outer),
+                                        BOX_BOTTOM (*new_outer),
+                                        new_outer,
+                                        edge_data->bottom_edges,
+                                        FALSE,
+                                        keyboard_op);
+    }
+  else
+    {
+      /* Disable edge resistance for resizes when windows have size
+       * increment hints; see #346782.  For all other cases, apply
+       * them.
+       */
+      if (!is_resize || window->size_hints.width_inc == 1)
+        {
+          /* Now, apply the normal horizontal edge resistance */
+          new_left   = apply_edge_resistance (window,
+                                              BOX_LEFT (*old_outer),
+                                              BOX_LEFT (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->left_edges,
+                                              &edge_data->left_data,
+                                              timeout_func,
+                                              TRUE,
+                                              keyboard_op);
+          new_right  = apply_edge_resistance (window,
+                                              BOX_RIGHT (*old_outer),
+                                              BOX_RIGHT (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->right_edges,
+                                              &edge_data->right_data,
+                                              timeout_func,
+                                              TRUE,
+                                              keyboard_op);
+        }
+      else
+        {
+          new_left  = new_outer->x;
+          new_right = new_outer->x + new_outer->width;
+        }
+      /* Same for vertical resizes... */
+      if (!is_resize || window->size_hints.height_inc == 1)
+        {
+          new_top    = apply_edge_resistance (window,
+                                              BOX_TOP (*old_outer),
+                                              BOX_TOP (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->top_edges,
+                                              &edge_data->top_data,
+                                              timeout_func,
+                                              FALSE,
+                                              keyboard_op);
+          new_bottom = apply_edge_resistance (window,
+                                              BOX_BOTTOM (*old_outer),
+                                              BOX_BOTTOM (*new_outer),
+                                              old_outer,
+                                              new_outer,
+                                              edge_data->bottom_edges,
+                                              &edge_data->bottom_data,
+                                              timeout_func,
+                                              FALSE,
+                                              keyboard_op);
+        }
+      else
+        {
+          new_top    = new_outer->y;
+          new_bottom = new_outer->y + new_outer->height;
+        }
+    }
+
+  /* Determine whether anything changed, and save the changes */
+  modified_rect = meta_rect (new_left, 
+                             new_top,
+                             new_right - new_left,
+                             new_bottom - new_top);
+  modified = !meta_rectangle_equal (new_outer, &modified_rect);
+  *new_outer = modified_rect;
+  return modified;
+}
+
+void
+meta_display_cleanup_edges (MetaDisplay *display)
+{
+  guint i,j;
+  MetaEdgeResistanceData *edge_data = display->grab_edge_resistance_data;
+  GHashTable *edges_to_be_freed;
+
+  g_assert (edge_data != NULL);
+
+  /* We first need to clean out any window edges */
+  edges_to_be_freed = g_hash_table_new_full (g_direct_hash, g_direct_equal,
+                                             g_free, NULL);
+  for (i = 0; i < 4; i++)
+    {
+      GArray *tmp = NULL;
+      MetaSide side;
+      switch (i)
+        {
+        case 0:
+          tmp = edge_data->left_edges;
+          side = META_SIDE_LEFT;
+          break;
+        case 1:
+          tmp = edge_data->right_edges;
+          side = META_SIDE_RIGHT;
+          break;
+        case 2:
+          tmp = edge_data->top_edges;
+          side = META_SIDE_TOP;
+          break;
+        case 3:
+          tmp = edge_data->bottom_edges;
+          side = META_SIDE_BOTTOM;
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+
+      for (j = 0; j < tmp->len; j++)
+        {
+          MetaEdge *edge = g_array_index (tmp, MetaEdge*, j);
+          if (edge->edge_type == META_EDGE_WINDOW &&
+              edge->side_type == side)
+            {
+              /* The same edge will appear in two arrays, and we can't free
+               * it yet we still need to compare edge->side_type for the other
+               * array that it is in.  So store it in a hash table for later
+               * freeing.  Could also do this in a simple linked list.
+               */
+              g_hash_table_insert (edges_to_be_freed, edge, edge);
+            }
+        }
+    }
+
+  /* Now free all the window edges (the key destroy function is g_free) */
+  g_hash_table_destroy (edges_to_be_freed);
+
+  /* Now free the arrays and data */
+  g_array_free (edge_data->left_edges, TRUE);
+  g_array_free (edge_data->right_edges, TRUE);
+  g_array_free (edge_data->top_edges, TRUE);
+  g_array_free (edge_data->bottom_edges, TRUE);
+  edge_data->left_edges = NULL;
+  edge_data->right_edges = NULL;
+  edge_data->top_edges = NULL;
+  edge_data->bottom_edges = NULL;
+
+  /* Cleanup the timeouts */
+  if (edge_data->left_data.timeout_setup   &&
+      edge_data->left_data.timeout_id   != 0)
+    g_source_remove (edge_data->left_data.timeout_id);
+  if (edge_data->right_data.timeout_setup  &&
+      edge_data->right_data.timeout_id  != 0)
+    g_source_remove (edge_data->right_data.timeout_id);
+  if (edge_data->top_data.timeout_setup    &&
+      edge_data->top_data.timeout_id    != 0)
+    g_source_remove (edge_data->top_data.timeout_id);
+  if (edge_data->bottom_data.timeout_setup &&
+      edge_data->bottom_data.timeout_id != 0)
+    g_source_remove (edge_data->bottom_data.timeout_id);
+
+  g_free (display->grab_edge_resistance_data);
+  display->grab_edge_resistance_data = NULL;
+}
+
+static int
+stupid_sort_requiring_extra_pointer_dereference (gconstpointer a, 
+                                                 gconstpointer b)
+{
+  const MetaEdge * const *a_edge = a;
+  const MetaEdge * const *b_edge = b;
+  return meta_rectangle_edge_cmp_ignore_type (*a_edge, *b_edge);
+}
+
+static void
+cache_edges (MetaDisplay *display,
+             GList *window_edges,
+             GList *xinerama_edges,
+             GList *screen_edges)
+{
+  MetaEdgeResistanceData *edge_data;
+  GList *tmp;
+  int num_left, num_right, num_top, num_bottom;
+  int i;
+
+  /*
+   * 0th: Print debugging information to the log about the edges
+   */
+#ifdef WITH_VERBOSE_MODE
+  if (meta_is_verbose())
+    {
+      int max_edges = MAX (MAX( g_list_length (window_edges), 
+                                g_list_length (xinerama_edges)),
+                           g_list_length (screen_edges));
+      char big_buffer[(EDGE_LENGTH+2)*max_edges];
+
+      meta_rectangle_edge_list_to_string (window_edges, ", ", big_buffer);
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "Window edges for resistance  : %s\n", big_buffer);
+
+      meta_rectangle_edge_list_to_string (xinerama_edges, ", ", big_buffer);
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "Xinerama edges for resistance: %s\n", big_buffer);
+
+      meta_rectangle_edge_list_to_string (screen_edges, ", ", big_buffer);
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "Screen edges for resistance  : %s\n", big_buffer);
+    }
+#endif
+
+  /*
+   * 1st: Get the total number of each kind of edge
+   */
+  num_left = num_right = num_top = num_bottom = 0;
+  for (i = 0; i < 3; i++)
+    {
+      tmp = NULL;
+      switch (i)
+        {
+        case 0:
+          tmp = window_edges;
+          break;
+        case 1:
+          tmp = xinerama_edges;
+          break;
+        case 2:
+          tmp = screen_edges;
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+
+      while (tmp)
+        {
+          MetaEdge *edge = tmp->data;
+          switch (edge->side_type)
+            {
+            case META_SIDE_LEFT:
+              num_left++;
+              break;
+            case META_SIDE_RIGHT:
+              num_right++;
+              break;
+            case META_SIDE_TOP:
+              num_top++;
+              break;
+            case META_SIDE_BOTTOM:
+              num_bottom++;
+              break;
+            default:
+              g_assert_not_reached ();
+            }
+          tmp = tmp->next;
+        }
+    }
+
+  /*
+   * 2nd: Allocate the edges
+   */
+  g_assert (display->grab_edge_resistance_data == NULL);
+  display->grab_edge_resistance_data = g_new (MetaEdgeResistanceData, 1);
+  edge_data = display->grab_edge_resistance_data;
+  edge_data->left_edges   = g_array_sized_new (FALSE,
+                                               FALSE,
+                                               sizeof(MetaEdge*),
+                                               num_left + num_right);
+  edge_data->right_edges  = g_array_sized_new (FALSE,
+                                               FALSE,
+                                               sizeof(MetaEdge*),
+                                               num_left + num_right);
+  edge_data->top_edges    = g_array_sized_new (FALSE,
+                                               FALSE,
+                                               sizeof(MetaEdge*),
+                                               num_top + num_bottom);
+  edge_data->bottom_edges = g_array_sized_new (FALSE,
+                                               FALSE,
+                                               sizeof(MetaEdge*),
+                                               num_top + num_bottom);
+
+  /*
+   * 3rd: Add the edges to the arrays
+   */
+  for (i = 0; i < 3; i++)
+    {
+      tmp = NULL;
+      switch (i)
+        {
+        case 0:
+          tmp = window_edges;
+          break;
+        case 1:
+          tmp = xinerama_edges;
+          break;
+        case 2:
+          tmp = screen_edges;
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+
+      while (tmp)
+        {
+          MetaEdge *edge = tmp->data;
+          switch (edge->side_type)
+            {
+            case META_SIDE_LEFT:
+            case META_SIDE_RIGHT:
+              g_array_append_val (edge_data->left_edges, edge);
+              g_array_append_val (edge_data->right_edges, edge);
+              break;
+            case META_SIDE_TOP:
+            case META_SIDE_BOTTOM:
+              g_array_append_val (edge_data->top_edges, edge);
+              g_array_append_val (edge_data->bottom_edges, edge);
+              break;
+            default:
+              g_assert_not_reached ();
+            }
+          tmp = tmp->next;
+        }
+    }
+
+  /*
+   * 4th: Sort the arrays (FIXME: This is kinda dumb since the arrays were
+   * individually sorted earlier and we could have done this faster and
+   * avoided this sort by sticking them into the array with some simple
+   * merging of the lists).
+   */
+  g_array_sort (display->grab_edge_resistance_data->left_edges, 
+                stupid_sort_requiring_extra_pointer_dereference);
+  g_array_sort (display->grab_edge_resistance_data->right_edges, 
+                stupid_sort_requiring_extra_pointer_dereference);
+  g_array_sort (display->grab_edge_resistance_data->top_edges, 
+                stupid_sort_requiring_extra_pointer_dereference);
+  g_array_sort (display->grab_edge_resistance_data->bottom_edges, 
+                stupid_sort_requiring_extra_pointer_dereference);
+}
+
+static void
+initialize_grab_edge_resistance_data (MetaDisplay *display)
+{
+  MetaEdgeResistanceData *edge_data = display->grab_edge_resistance_data;
+
+  edge_data->left_data.timeout_setup   = FALSE;
+  edge_data->right_data.timeout_setup  = FALSE;
+  edge_data->top_data.timeout_setup    = FALSE;
+  edge_data->bottom_data.timeout_setup = FALSE;
+
+  edge_data->left_data.keyboard_buildup   = 0;
+  edge_data->right_data.keyboard_buildup  = 0;
+  edge_data->top_data.keyboard_buildup    = 0;
+  edge_data->bottom_data.keyboard_buildup = 0;
+}
+
+void
+meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display)
+{
+  GList *stacked_windows;
+  GList *cur_window_iter;
+  GList *edges;
+  /* Lists of window positions (rects) and their relative stacking positions */
+  int stack_position;
+  GSList *obscuring_windows, *window_stacking;
+  /* The portions of the above lists that still remain at the stacking position
+   * in the layer that we are working on
+   */
+  GSList *rem_windows, *rem_win_stacking;
+
+  /*
+   * 1st: Get the list of relevant windows, from bottom to top
+   */
+  stacked_windows = 
+    meta_stack_list_windows (display->grab_screen->stack,
+                             display->grab_screen->active_workspace);
+
+  /*
+   * 2nd: we need to separate that stacked list into a list of windows that
+   * can obscure other edges.  To make sure we only have windows obscuring
+   * those below it instead of going both ways, we also need to keep a
+   * counter list.  Messy, I know.
+   */
+  obscuring_windows = window_stacking = NULL;
+  cur_window_iter = stacked_windows;
+  stack_position = 0;
+  while (cur_window_iter != NULL)
+    {
+      MetaWindow *cur_window = cur_window_iter->data;
+      if (WINDOW_EDGES_RELEVANT (cur_window, display))
+        {
+          MetaRectangle *new_rect;
+          new_rect = g_new (MetaRectangle, 1);
+          meta_window_get_outer_rect (cur_window, new_rect);
+          obscuring_windows = g_slist_prepend (obscuring_windows, new_rect);
+          window_stacking = 
+            g_slist_prepend (window_stacking, GINT_TO_POINTER (stack_position));
+        }
+
+      stack_position++;
+      cur_window_iter = cur_window_iter->next;
+    }
+  /* Put 'em in bottom to top order */
+  rem_windows = obscuring_windows = g_slist_reverse (obscuring_windows);
+  rem_win_stacking = window_stacking = g_slist_reverse (window_stacking);
+
+  /*
+   * 3rd: loop over the windows again, this time getting the edges from
+   * them and removing intersections with the relevant obscuring_windows &
+   * obscuring_docks.
+   */
+  edges = NULL;
+  stack_position = 0;
+  cur_window_iter = stacked_windows;
+  while (cur_window_iter != NULL)
+    {
+      MetaRectangle  cur_rect;
+      MetaWindow    *cur_window = cur_window_iter->data;
+      meta_window_get_outer_rect (cur_window, &cur_rect);
+
+      /* Check if we want to use this window's edges for edge
+       * resistance (note that dock edges are considered screen edges
+       * which are handled separately
+       */
+      if (WINDOW_EDGES_RELEVANT (cur_window, display) &&
+          cur_window->type != META_WINDOW_DOCK)
+        {
+          GList *new_edges;
+          MetaEdge *new_edge;
+          MetaRectangle reduced;
+
+          /* We don't care about snapping to any portion of the window that
+           * is offscreen (we also don't care about parts of edges covered
+           * by other windows or DOCKS, but that's handled below).
+           */
+          meta_rectangle_intersect (&cur_rect, 
+                                    &display->grab_screen->rect,
+                                    &reduced);
+
+          new_edges = NULL;
+
+          /* Left side of this window is resistance for the right edge of
+           * the window being moved.
+           */
+          new_edge = g_new (MetaEdge, 1);
+          new_edge->rect = reduced;
+          new_edge->rect.width = 0;
+          new_edge->side_type = META_SIDE_RIGHT;
+          new_edge->edge_type = META_EDGE_WINDOW;
+          new_edges = g_list_prepend (new_edges, new_edge);
+
+          /* Right side of this window is resistance for the left edge of
+           * the window being moved.
+           */
+          new_edge = g_new (MetaEdge, 1);
+          new_edge->rect = reduced;
+          new_edge->rect.x += new_edge->rect.width;
+          new_edge->rect.width = 0;
+          new_edge->side_type = META_SIDE_LEFT;
+          new_edge->edge_type = META_EDGE_WINDOW;
+          new_edges = g_list_prepend (new_edges, new_edge);
+          
+          /* Top side of this window is resistance for the bottom edge of
+           * the window being moved.
+           */
+          new_edge = g_new (MetaEdge, 1);
+          new_edge->rect = reduced;
+          new_edge->rect.height = 0;
+          new_edge->side_type = META_SIDE_BOTTOM;
+          new_edge->edge_type = META_EDGE_WINDOW;
+          new_edges = g_list_prepend (new_edges, new_edge);
+
+          /* Top side of this window is resistance for the bottom edge of
+           * the window being moved.
+           */
+          new_edge = g_new (MetaEdge, 1);
+          new_edge->rect = reduced;
+          new_edge->rect.y += new_edge->rect.height;
+          new_edge->rect.height = 0;
+          new_edge->side_type = META_SIDE_TOP;
+          new_edge->edge_type = META_EDGE_WINDOW;
+          new_edges = g_list_prepend (new_edges, new_edge);
+
+          /* Update the remaining windows to only those at a higher
+           * stacking position than this one.
+           */
+          while (rem_win_stacking && 
+                 stack_position >= GPOINTER_TO_INT (rem_win_stacking->data))
+            {
+              rem_windows      = rem_windows->next;
+              rem_win_stacking = rem_win_stacking->next;
+            }
+
+          /* Remove edge portions overlapped by rem_windows and rem_docks */
+          new_edges = 
+            meta_rectangle_remove_intersections_with_boxes_from_edges (
+              new_edges,
+              rem_windows);
+
+          /* Save the new edges */
+          edges = g_list_concat (new_edges, edges);
+        }
+
+      stack_position++;
+      cur_window_iter = cur_window_iter->next;
+    }
+
+  /*
+   * 4th: Free the extra memory not needed and sort the list
+   */
+  g_list_free (stacked_windows);
+  /* Free the memory used by the obscuring windows/docks lists */
+  g_slist_free (window_stacking);
+  /* FIXME: Shouldn't there be a helper function to make this one line of code
+   * to free a list instead of four ugly ones?
+   */
+  g_slist_foreach (obscuring_windows, 
+                   (void (*)(gpointer,gpointer))&g_free, /* ew, for ugly */
+                   NULL);
+  g_slist_free (obscuring_windows);
+
+  /* Sort the list.  FIXME: Should I bother with this sorting?  I just
+   * sort again later in cache_edges() anyway...
+   */
+  edges = g_list_sort (edges, meta_rectangle_edge_cmp);
+
+  /*
+   * 5th: Cache the combination of these edges with the onscreen and
+   * xinerama edges in an array for quick access.  Free the edges since
+   * they've been cached elsewhere.
+   */
+  cache_edges (display,
+               edges,
+               display->grab_screen->active_workspace->xinerama_edges,
+               display->grab_screen->active_workspace->screen_edges);
+  g_list_free (edges);
+
+  /*
+   * 6th: Initialize the resistance timeouts and buildups
+   */
+  initialize_grab_edge_resistance_data (display);
+}
+
+/* Note that old_[xy] and new_[xy] are with respect to inner positions of
+ * the window.
+ */
+void
+meta_window_edge_resistance_for_move (MetaWindow  *window,
+                                      int          old_x,
+                                      int          old_y,
+                                      int         *new_x,
+                                      int         *new_y,
+                                      GSourceFunc  timeout_func,
+                                      gboolean     snap,
+                                      gboolean     is_keyboard_op)
+{
+  MetaRectangle old_outer, proposed_outer, new_outer;
+  gboolean is_resize;
+
+  if (window == window->display->grab_window &&
+      window->display->grab_wireframe_active)
+    {
+      meta_window_get_xor_rect (window,
+                                &window->display->grab_wireframe_rect,
+                                &old_outer);
+    }
+  else
+    {
+      meta_window_get_outer_rect (window, &old_outer);
+    }
+  proposed_outer = old_outer;
+  proposed_outer.x += (*new_x - old_x);
+  proposed_outer.y += (*new_y - old_y);
+  new_outer = proposed_outer;
+
+  window->display->grab_last_user_action_was_snap = snap;
+  is_resize = FALSE;
+  if (apply_edge_resistance_to_each_side (window->display,
+                                          window,
+                                          &old_outer,
+                                          &new_outer,
+                                          timeout_func,
+                                          snap,
+                                          is_keyboard_op,
+                                          is_resize))
+    {
+      /* apply_edge_resistance_to_each_side independently applies
+       * resistance to both the right and left edges of new_outer as both
+       * could meet areas of resistance.  But we don't want a resize, so we
+       * just have both edges move according to the stricter of the
+       * resistances.  Same thing goes for top & bottom edges.
+       */
+      MetaRectangle *reference;
+      int left_change, right_change, smaller_x_change;
+      int top_change, bottom_change, smaller_y_change;
+
+      if (snap && !is_keyboard_op)
+        reference = &proposed_outer;
+      else
+        reference = &old_outer;
+
+      left_change  = BOX_LEFT (new_outer)  - BOX_LEFT (*reference);
+      right_change = BOX_RIGHT (new_outer) - BOX_RIGHT (*reference);
+      if (     snap && is_keyboard_op && left_change == 0)
+        smaller_x_change = right_change;
+      else if (snap && is_keyboard_op && right_change == 0)
+        smaller_x_change = left_change;
+      else if (ABS (left_change) < ABS (right_change))
+        smaller_x_change = left_change;
+      else
+        smaller_x_change = right_change;
+
+      top_change    = BOX_TOP (new_outer)    - BOX_TOP (*reference);
+      bottom_change = BOX_BOTTOM (new_outer) - BOX_BOTTOM (*reference);
+      if (     snap && is_keyboard_op && top_change == 0)
+        smaller_y_change = bottom_change;
+      else if (snap && is_keyboard_op && bottom_change == 0)
+        smaller_y_change = top_change;
+      else if (ABS (top_change) < ABS (bottom_change))
+        smaller_y_change = top_change;
+      else
+        smaller_y_change = bottom_change;
+
+      *new_x = old_x + smaller_x_change + 
+              (BOX_LEFT (*reference) - BOX_LEFT (old_outer));
+      *new_y = old_y + smaller_y_change +
+              (BOX_TOP (*reference) - BOX_TOP (old_outer));
+
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "outer x & y move-to coordinate changed from %d,%d to %d,%d\n",
+                  proposed_outer.x, proposed_outer.y,
+                  old_outer.x + (*new_x - old_x),
+                  old_outer.y + (*new_y - old_y));
+    }
+}
+
+/* Note that old_(width|height) and new_(width|height) are with respect to
+ * sizes of the inner window.
+ */
+void
+meta_window_edge_resistance_for_resize (MetaWindow  *window,
+                                        int          old_width,
+                                        int          old_height,
+                                        int         *new_width,
+                                        int         *new_height,
+                                        int          gravity,
+                                        GSourceFunc  timeout_func,
+                                        gboolean     snap,
+                                        gboolean     is_keyboard_op)
+{
+  MetaRectangle old_outer, new_outer;
+  int proposed_outer_width, proposed_outer_height;
+  gboolean is_resize;
+
+  if (window == window->display->grab_window &&
+      window->display->grab_wireframe_active)
+    {
+      meta_window_get_xor_rect (window,
+                                &window->display->grab_wireframe_rect,
+                                &old_outer);
+    }
+  else
+    {
+      meta_window_get_outer_rect (window, &old_outer);
+    }
+  proposed_outer_width  = old_outer.width  + (*new_width  - old_width);
+  proposed_outer_height = old_outer.height + (*new_height - old_height);
+  meta_rectangle_resize_with_gravity (&old_outer, 
+                                      &new_outer,
+                                      gravity,
+                                      proposed_outer_width,
+                                      proposed_outer_height);
+
+  window->display->grab_last_user_action_was_snap = snap;
+  is_resize = TRUE;
+  if (apply_edge_resistance_to_each_side (window->display,
+                                          window,
+                                          &old_outer,
+                                          &new_outer,
+                                          timeout_func,
+                                          snap,
+                                          is_keyboard_op,
+                                          is_resize))
+    {
+      *new_width  = old_width  + (new_outer.width  - old_outer.width);
+      *new_height = old_height + (new_outer.height - old_outer.height);
+
+      meta_topic (META_DEBUG_EDGE_RESISTANCE,
+                  "outer width & height got changed from %d,%d to %d,%d\n",
+                  proposed_outer_width, proposed_outer_height,
+                  new_outer.width, new_outer.height);
+    }
+}
diff --git a/src/core/edge-resistance.h b/src/core/edge-resistance.h
new file mode 100644
index 00000000..14ba17a0
--- /dev/null
+++ b/src/core/edge-resistance.h
@@ -0,0 +1,48 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Edge resistance for move/resize operations */
+
+/* 
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_EDGE_RESISTANCE_H
+#define META_EDGE_RESISTANCE_H
+
+#include "window-private.h"
+
+void        meta_window_edge_resistance_for_move   (MetaWindow  *window,
+                                                    int          old_x,
+                                                    int          old_y,
+                                                    int         *new_x,
+                                                    int         *new_y,
+                                                    GSourceFunc  timeout_func,
+                                                    gboolean     snap,
+                                                    gboolean     is_keyboard_op);
+void        meta_window_edge_resistance_for_resize (MetaWindow  *window,
+                                                    int          old_width,
+                                                    int          old_height,
+                                                    int         *new_width,
+                                                    int         *new_height,
+                                                    int          gravity,
+                                                    GSourceFunc  timeout_func,
+                                                    gboolean     snap,
+                                                    gboolean     is_keyboard_op);
+
+#endif /* META_EDGE_RESISTANCE_H */
+
diff --git a/src/core/effects.c b/src/core/effects.c
new file mode 100644
index 00000000..1392b7c2
--- /dev/null
+++ b/src/core/effects.c
@@ -0,0 +1,735 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file effects.c "Special effects" other than compositor effects.
+ * 
+ * Before we had a serious compositor, we supported swooping
+ * rectangles for minimising and so on.  These are still supported
+ * today, even when the compositor is enabled.  The file contains two
+ * parts:
+ *
+ *  1) A set of functions, each of which implements a special effect.
+ *     (Only the minimize function does anything interesting; we should
+ *      probably get rid of the rest.)
+ *
+ *  2) A set of functions for moving a highlighted wireframe box around
+ *     the screen, optionally with height and width shown in the middle.
+ *     This is used for moving and resizing when reduced_resources is set.
+ *
+ * There was formerly a system which allowed callers to drop in their
+ * own handlers for various things; it was never used (people who want
+ * their own handlers can just modify this file, after all) and it added
+ * a good deal of extra complexity, so it has been removed.  If you want it,
+ * it can be found in svn r3769.
+ *
+ * Once upon a time there were three different ways of drawing the box
+ * animation: window wireframe, window opaque, and root. People who had
+ * the shape extension theoretically had the choice of all three, and
+ * people who didn't weren't given the choice of the wireframe option.
+ * In practice, though, the opaque animation was never perfect, so it came
+ * down to the wireframe option for those who had the extension and
+ * the root option for those who didn't; there was actually no way of choosing
+ * any other option anyway.  Work on the opaque animation stopped in 2002;
+ * anyone who wants something like that these days will be using the
+ * compositor anyway.
+ *
+ * In svn r3769 this was made explicit.
+ */
+
+/* 
+ * Copyright (C) 2001 Anders Carlsson, Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "effects.h"
+#include "display-private.h"
+#include "ui.h"
+#include "window-private.h"
+#include "prefs.h"
+
+#ifdef HAVE_SHAPE
+#include <X11/extensions/shape.h>
+#endif
+
+#define META_MINIMIZE_ANIMATION_LENGTH 0.25
+#define META_SHADE_ANIMATION_LENGTH 0.2
+
+#include <string.h>
+
+typedef struct MetaEffect MetaEffect;
+typedef struct MetaEffectPriv MetaEffectPriv;
+
+typedef struct
+{
+  MetaScreen *screen;
+
+  double millisecs_duration;
+  GTimeVal start_time;
+
+#ifdef HAVE_SHAPE
+  /** For wireframe window */
+  Window wireframe_xwindow;
+#else
+  /** Rectangle to erase */
+  MetaRectangle last_rect;
+
+  /** First time we've plotted anything in this animation? */
+  gboolean first_time;
+
+  /** For wireframe drawn on root window */
+  GC gc;
+#endif
+
+  MetaRectangle start_rect;
+  MetaRectangle end_rect;
+  
+} BoxAnimationContext;
+
+/**
+ * Information we need to know during a maximise or minimise effect.
+ */
+typedef struct
+{
+  /** This is the normal-size window. */
+  MetaRectangle window_rect;
+  /** This is the size of the window when it's an icon. */
+  MetaRectangle icon_rect;
+} MetaMinimizeEffect, MetaUnminimizeEffect;
+
+struct MetaEffectPriv
+{
+  MetaEffectFinished finished;
+  gpointer           finished_data;
+};
+
+struct MetaEffect
+{
+  /** The window the effect is applied to. */
+  MetaWindow *window;
+  /** Which effect is happening here. */
+  MetaEffectType type;
+  /** The effect handler can hang data here. */
+  gpointer info;
+
+  union
+  {
+    MetaMinimizeEffect      minimize;
+    /* ... and theoretically anything else */
+  } u;
+  
+  MetaEffectPriv *priv;
+};
+
+static void run_default_effect_handler (MetaEffect *effect);
+static void run_handler (MetaEffect *effect);
+static void effect_free (MetaEffect *effect);
+
+static MetaEffect *
+create_effect (MetaEffectType      type,
+               MetaWindow         *window,
+               MetaEffectFinished  finished,
+               gpointer            finished_data);
+
+static void
+draw_box_animation (MetaScreen     *screen,
+                    MetaRectangle  *initial_rect,
+                    MetaRectangle  *destination_rect,
+                    double          seconds_duration);
+
+/**
+ * Creates an effect.
+ *
+ */
+static MetaEffect*
+create_effect (MetaEffectType      type,
+               MetaWindow         *window,
+               MetaEffectFinished  finished,
+               gpointer            finished_data)
+{
+    MetaEffect *effect = g_new (MetaEffect, 1);
+
+    effect->type = type;
+    effect->window = window;
+    effect->priv = g_new (MetaEffectPriv, 1);
+    effect->priv->finished = finished;
+    effect->priv->finished_data = finished_data;
+
+    return effect;
+}
+
+/**
+ * Destroys an effect.  If the effect has a "finished" hook, it will be
+ * called before cleanup.
+ *
+ * \param effect  The effect.
+ */
+static void
+effect_free (MetaEffect *effect)
+{
+  if (effect->priv->finished)
+    effect->priv->finished (effect->priv->finished_data);
+    
+  g_free (effect->priv);
+  g_free (effect);
+}
+
+void
+meta_effect_run_focus (MetaWindow	    *window,
+		       MetaEffectFinished   finished,
+		       gpointer		    data)
+{
+    MetaEffect *effect;
+
+    g_return_if_fail (window != NULL);
+
+    effect = create_effect (META_EFFECT_FOCUS, window, finished, data);
+    
+    run_handler (effect);
+}
+
+void
+meta_effect_run_minimize (MetaWindow         *window,
+                          MetaRectangle      *window_rect,
+                          MetaRectangle      *icon_rect,
+                          MetaEffectFinished  finished,
+                          gpointer            data)
+{
+    MetaEffect *effect;
+
+    g_return_if_fail (window != NULL);
+    g_return_if_fail (icon_rect != NULL);
+    
+    effect = create_effect (META_EFFECT_MINIMIZE, window, finished, data);
+
+    effect->u.minimize.window_rect = *window_rect;
+    effect->u.minimize.icon_rect = *icon_rect;
+
+    run_handler (effect);
+}
+
+void
+meta_effect_run_unminimize (MetaWindow         *window,
+                            MetaRectangle      *window_rect,
+                            MetaRectangle      *icon_rect,
+                            MetaEffectFinished  finished,
+                            gpointer            data)
+{
+    MetaEffect *effect;
+
+    g_return_if_fail (window != NULL);
+    g_return_if_fail (icon_rect != NULL);
+    
+    effect = create_effect (META_EFFECT_UNMINIMIZE, window, finished, data);
+
+    effect->u.minimize.window_rect = *window_rect;
+    effect->u.minimize.icon_rect = *icon_rect;
+
+    run_handler (effect);
+}
+
+void
+meta_effect_run_close (MetaWindow         *window,
+		       MetaEffectFinished  finished,
+		       gpointer            data)
+{
+    MetaEffect *effect;
+    
+    g_return_if_fail (window != NULL);
+
+    effect = create_effect (META_EFFECT_CLOSE, window,
+                            finished, data);
+
+    run_handler (effect);
+}
+
+
+/* old ugly minimization effect */
+
+#ifdef HAVE_SHAPE  
+static void
+update_wireframe_window (MetaDisplay         *display,
+                         Window               xwindow,
+                         const MetaRectangle *rect)
+{
+  XMoveResizeWindow (display->xdisplay,
+                     xwindow,
+                     rect->x, rect->y,
+                     rect->width, rect->height);
+
+#define OUTLINE_WIDTH 3
+  
+  if (rect->width > OUTLINE_WIDTH * 2 &&
+      rect->height > OUTLINE_WIDTH * 2)
+    {
+      XRectangle xrect;
+      Region inner_xregion;
+      Region outer_xregion;
+      
+      inner_xregion = XCreateRegion ();
+      outer_xregion = XCreateRegion ();
+
+      xrect.x = 0;
+      xrect.y = 0;
+      xrect.width = rect->width;
+      xrect.height = rect->height;
+  
+      XUnionRectWithRegion (&xrect, outer_xregion, outer_xregion);
+  
+      xrect.x += OUTLINE_WIDTH;
+      xrect.y += OUTLINE_WIDTH;
+      xrect.width -= OUTLINE_WIDTH * 2;
+      xrect.height -= OUTLINE_WIDTH * 2;  
+  
+      XUnionRectWithRegion (&xrect, inner_xregion, inner_xregion);
+
+      XSubtractRegion (outer_xregion, inner_xregion, outer_xregion);
+
+      XShapeCombineRegion (display->xdisplay, xwindow,
+                           ShapeBounding, 0, 0, outer_xregion, ShapeSet);
+  
+      XDestroyRegion (outer_xregion);
+      XDestroyRegion (inner_xregion);
+    }
+  else
+    {
+      /* Unset the shape */
+      XShapeCombineMask (display->xdisplay, xwindow,
+                         ShapeBounding, 0, 0, None, ShapeSet);
+    }
+}
+#endif
+
+/**
+ * A hack to force the X server to synchronize with the
+ * graphics hardware.
+ */
+static void
+graphics_sync (BoxAnimationContext *context)
+{
+  XImage *image;
+  
+  image = XGetImage (context->screen->display->xdisplay,
+                     context->screen->xroot,
+                     0, 0, 1, 1,
+                     AllPlanes, ZPixmap);
+
+  XDestroyImage (image);
+}
+
+static gboolean
+effects_draw_box_animation_timeout (BoxAnimationContext *context)
+{
+  double elapsed;
+  GTimeVal current_time;
+  MetaRectangle draw_rect;
+  double fraction;
+  
+#ifndef HAVE_SHAPE
+  if (!context->first_time)
+    {
+       /* Restore the previously drawn background */
+       XDrawRectangle (context->screen->display->xdisplay,
+                       context->screen->xroot,
+                       context->gc,
+                       context->last_rect.x, context->last_rect.y,
+                       context->last_rect.width, context->last_rect.height);
+    }
+  else
+    context->first_time = FALSE;
+
+#endif /* !HAVE_SHAPE */
+
+  g_get_current_time (&current_time);
+  
+  /* We use milliseconds for all times */
+  elapsed =
+    ((((double)current_time.tv_sec - context->start_time.tv_sec) * G_USEC_PER_SEC +
+      (current_time.tv_usec - context->start_time.tv_usec))) / 1000.0;
+  
+  if (elapsed < 0)
+    {
+      /* Probably the system clock was set backwards? */
+      meta_warning ("System clock seemed to go backwards?\n");
+      elapsed = G_MAXDOUBLE; /* definitely done. */
+    }
+
+  if (elapsed > context->millisecs_duration)
+    {
+      /* All done */
+#ifdef HAVE_SHAPE
+        XDestroyWindow (context->screen->display->xdisplay,
+                          context->wireframe_xwindow);
+#else
+        meta_display_ungrab (context->screen->display);
+        meta_ui_pop_delay_exposes (context->screen->ui);
+        XFreeGC (context->screen->display->xdisplay,
+                 context->gc);
+#endif /* !HAVE_SHAPE */
+
+      graphics_sync (context);
+      
+      g_free (context);
+      return FALSE;
+    }
+
+  g_assert (context->millisecs_duration > 0.0);
+  fraction = elapsed / context->millisecs_duration;
+  
+  draw_rect = context->start_rect;
+  
+  /* Now add a delta proportional to elapsed time. */
+  draw_rect.x += (context->end_rect.x - context->start_rect.x) * fraction;
+  draw_rect.y += (context->end_rect.y - context->start_rect.y) * fraction;
+  draw_rect.width += (context->end_rect.width - context->start_rect.width) * fraction;
+  draw_rect.height += (context->end_rect.height - context->start_rect.height) * fraction;
+  
+  /* don't confuse X or gdk-pixbuf with bogus rectangles */
+  if (draw_rect.width < 1)
+    draw_rect.width = 1;
+  if (draw_rect.height < 1)
+    draw_rect.height = 1;
+
+#ifdef HAVE_SHAPE
+  update_wireframe_window (context->screen->display,
+                           context->wireframe_xwindow,
+                           &draw_rect);
+#else
+  context->last_rect = draw_rect;
+
+  /* Draw the rectangle */
+  XDrawRectangle (context->screen->display->xdisplay,
+                  context->screen->xroot,
+                  context->gc,
+                  draw_rect.x, draw_rect.y,
+                  draw_rect.width, draw_rect.height);
+    
+#endif /* !HAVE_SHAPE */
+
+  /* kick changes onto the server */
+  graphics_sync (context);
+  
+  return TRUE;
+}
+ 
+void
+draw_box_animation (MetaScreen     *screen,
+                    MetaRectangle  *initial_rect,
+                    MetaRectangle  *destination_rect,
+                    double          seconds_duration)
+{
+  BoxAnimationContext *context;
+
+#ifdef HAVE_SHAPE
+  XSetWindowAttributes attrs;
+#else
+  XGCValues gc_values;
+#endif
+    
+  g_return_if_fail (seconds_duration > 0.0);
+
+  if (g_getenv ("MARCO_DEBUG_EFFECTS"))
+    seconds_duration *= 10; /* slow things down */
+  
+  /* Create the animation context */
+  context = g_new0 (BoxAnimationContext, 1);
+
+  context->screen = screen;
+
+  context->millisecs_duration = seconds_duration * 1000.0;
+
+  context->start_rect = *initial_rect;
+  context->end_rect = *destination_rect;
+
+#ifdef HAVE_SHAPE
+
+  attrs.override_redirect = True;
+  attrs.background_pixel = BlackPixel (screen->display->xdisplay,
+                                       screen->number);
+
+  context->wireframe_xwindow = XCreateWindow (screen->display->xdisplay,
+                                              screen->xroot,
+                                              initial_rect->x,
+                                              initial_rect->y,
+                                              initial_rect->width,
+                                              initial_rect->height,
+                                              0,
+                                              CopyFromParent,
+                                              CopyFromParent,
+                                              (Visual *)CopyFromParent,
+                                              CWOverrideRedirect | CWBackPixel,
+                                              &attrs);
+
+  update_wireframe_window (screen->display,
+                           context->wireframe_xwindow,
+                           initial_rect);
+
+  XMapWindow (screen->display->xdisplay,
+              context->wireframe_xwindow);
+
+#else /* !HAVE_SHAPE */
+
+  context->first_time = TRUE;
+  gc_values.subwindow_mode = IncludeInferiors;
+  gc_values.function = GXinvert;
+
+  context->gc = XCreateGC (screen->display->xdisplay,
+                           screen->xroot,
+                           GCSubwindowMode | GCFunction,
+                           &gc_values);
+      
+  /* Grab the X server to avoid screen dirt */
+  meta_display_grab (context->screen->display);
+  meta_ui_push_delay_exposes (context->screen->ui);
+#endif
+
+  /* Do this only after we get the pixbuf from the server,
+   * so that the animation doesn't get truncated.
+   */
+  g_get_current_time (&context->start_time);
+  
+  /* Add the timeout - a short one, could even use an idle,
+   * but this is maybe more CPU-friendly.
+   */
+  g_timeout_add (15,
+                 (GSourceFunc)effects_draw_box_animation_timeout,
+                 context);
+
+  /* kick changes onto the server */
+  XFlush (context->screen->display->xdisplay);  
+}
+
+void
+meta_effects_begin_wireframe (MetaScreen          *screen,
+                              const MetaRectangle *rect,
+                              int                  width,
+                              int                  height)
+{
+  /* Grab the X server to avoid screen dirt */
+  meta_display_grab (screen->display);
+  meta_ui_push_delay_exposes (screen->ui);  
+
+  meta_effects_update_wireframe (screen, 
+                                 NULL, -1, -1,
+                                 rect, width, height);
+}
+
+static void
+draw_xor_rect (MetaScreen          *screen,
+               const MetaRectangle *rect,
+               int                  width,
+               int                  height)
+{
+  /* The lines in the center can't overlap the rectangle or each
+   * other, or the XOR gets reversed. So we have to draw things
+   * a bit oddly.
+   */
+  XSegment segments[8];
+  MetaRectangle shrunk_rect;
+  int i;
+  
+#define LINE_WIDTH META_WIREFRAME_XOR_LINE_WIDTH
+
+  /* We don't want the wireframe going outside the window area.
+   * It makes it harder for the user to position windows and it exposes other
+   * annoying bugs.
+   */
+  shrunk_rect = *rect;
+
+  shrunk_rect.x += LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  shrunk_rect.y += LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  shrunk_rect.width -= LINE_WIDTH + 2 * (LINE_WIDTH % 2);
+  shrunk_rect.height -= LINE_WIDTH + 2 * (LINE_WIDTH % 2);
+
+  XDrawRectangle (screen->display->xdisplay,
+                  screen->xroot,
+                  screen->root_xor_gc,
+                  shrunk_rect.x, shrunk_rect.y,
+                  shrunk_rect.width, shrunk_rect.height);
+
+  /* Don't put lines inside small rectangles where they won't fit */
+  if (shrunk_rect.width < (LINE_WIDTH * 4) ||
+      shrunk_rect.height < (LINE_WIDTH * 4))
+    return;
+
+  if ((width >= 0) && (height >= 0))
+    {
+      XGCValues gc_values = { 0 };
+
+      if (XGetGCValues (screen->display->xdisplay,
+                        screen->root_xor_gc, 
+                        GCFont, &gc_values))
+        {
+          char *text;
+          int text_length;
+
+          XFontStruct *font_struct;
+          int text_width, text_height; 
+          int box_x, box_y;
+          int box_width, box_height;
+
+          font_struct = XQueryFont (screen->display->xdisplay,
+                                    gc_values.font);
+
+          if (font_struct != NULL)
+            {
+              text = g_strdup_printf ("%d x %d", width, height);
+              text_length = strlen (text);
+
+              text_width = text_length * font_struct->max_bounds.width;
+              text_height = font_struct->max_bounds.descent + 
+                            font_struct->max_bounds.ascent;
+
+              box_width = text_width + 2 * LINE_WIDTH;
+              box_height = text_height + 2 * LINE_WIDTH;
+
+
+              box_x = shrunk_rect.x + (shrunk_rect.width - box_width) / 2;
+              box_y = shrunk_rect.y + (shrunk_rect.height - box_height) / 2;
+
+              if ((box_width < shrunk_rect.width) &&
+                  (box_height < shrunk_rect.height))
+                {
+                  XFillRectangle (screen->display->xdisplay,
+                                  screen->xroot,
+                                  screen->root_xor_gc,
+                                  box_x, box_y,
+                                  box_width, box_height);
+                  XDrawString (screen->display->xdisplay, 
+                               screen->xroot,
+                               screen->root_xor_gc,
+                               box_x + LINE_WIDTH,
+                               box_y + LINE_WIDTH + font_struct->max_bounds.ascent,
+                               text, text_length);
+                }
+
+              g_free (text);
+
+              XFreeFontInfo (NULL, font_struct, 1);
+
+              if ((box_width + LINE_WIDTH) >= (shrunk_rect.width / 3))
+                return;
+
+              if ((box_height + LINE_WIDTH) >= (shrunk_rect.height / 3))
+                return;
+            }
+        }
+    }
+
+  /* Two vertical lines at 1/3 and 2/3 */
+  segments[0].x1 = shrunk_rect.x + shrunk_rect.width / 3;
+  segments[0].y1 = shrunk_rect.y + LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  segments[0].x2 = segments[0].x1;
+  segments[0].y2 = shrunk_rect.y + shrunk_rect.height - LINE_WIDTH / 2;  
+
+  segments[1] = segments[0];
+  segments[1].x1 = shrunk_rect.x + (shrunk_rect.width / 3) * 2;
+  segments[1].x2 = segments[1].x1;
+
+  /* Now make two horizontal lines at 1/3 and 2/3, but not
+   * overlapping the verticals
+   */
+
+  segments[2].x1 = shrunk_rect.x + LINE_WIDTH / 2 + LINE_WIDTH % 2;
+  segments[2].x2 = segments[0].x1 - LINE_WIDTH / 2;
+  segments[2].y1 = shrunk_rect.y + shrunk_rect.height / 3;
+  segments[2].y2 = segments[2].y1;
+
+  segments[3] = segments[2];
+  segments[3].x1 = segments[2].x2 + LINE_WIDTH;
+  segments[3].x2 = segments[1].x1 - LINE_WIDTH / 2;
+  
+  segments[4] = segments[3];
+  segments[4].x1 = segments[3].x2 + LINE_WIDTH;
+  segments[4].x2 = shrunk_rect.x + shrunk_rect.width - LINE_WIDTH / 2;
+
+  /* Second horizontal line is just like the first, but
+   * shifted down
+   */
+  i = 5;
+  while (i < 8)
+    {
+      segments[i] = segments[i - 3];
+      segments[i].y1 = shrunk_rect.y + (shrunk_rect.height / 3) * 2;
+      segments[i].y2 = segments[i].y1;
+      ++i;
+    }
+  
+  XDrawSegments (screen->display->xdisplay,
+                 screen->xroot,
+                 screen->root_xor_gc,
+                 segments,
+                 G_N_ELEMENTS (segments));
+}
+
+void
+meta_effects_update_wireframe (MetaScreen          *screen,
+                               const MetaRectangle *old_rect,
+                               int                  old_width,
+                               int                  old_height,
+                               const MetaRectangle *new_rect,
+                               int                  new_width,
+                               int                  new_height)
+{
+  if (old_rect)
+    draw_xor_rect (screen, old_rect, old_width, old_height);
+    
+  if (new_rect)
+    draw_xor_rect (screen, new_rect, new_width, new_height);
+    
+  XFlush (screen->display->xdisplay);
+}
+
+void
+meta_effects_end_wireframe (MetaScreen          *screen,
+                            const MetaRectangle *old_rect,
+                            int                  old_width,
+                            int                  old_height)
+{
+  meta_effects_update_wireframe (screen, 
+                                 old_rect, old_width, old_height,
+                                 NULL, -1, -1);
+  
+  meta_display_ungrab (screen->display);
+  meta_ui_pop_delay_exposes (screen->ui);
+}
+
+static void
+run_default_effect_handler (MetaEffect *effect)
+{
+    switch (effect->type)
+    {
+    case META_EFFECT_MINIMIZE:
+       draw_box_animation (effect->window->screen,
+                     &(effect->u.minimize.window_rect),
+                     &(effect->u.minimize.icon_rect),
+                     META_MINIMIZE_ANIMATION_LENGTH);
+       break;
+
+    default:
+       break;
+    }
+}
+
+static void
+run_handler (MetaEffect *effect)
+{
+  if (meta_prefs_get_mate_animations ())
+    run_default_effect_handler (effect);
+
+  effect_free (effect);
+}
diff --git a/src/core/effects.h b/src/core/effects.h
new file mode 100644
index 00000000..91d09e15
--- /dev/null
+++ b/src/core/effects.h
@@ -0,0 +1,170 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file effects.h "Special effects" other than compositor effects.
+ * 
+ * Before we had a serious compositor, we supported swooping
+ * rectangles for minimising and so on.  These are still supported
+ * today, even when the compositor is enabled.  The file contains two
+ * parts:
+ *
+ *  1) A set of functions, each of which implements a special effect.
+ *     (Only the minimize function does anything interesting; we should
+ *      probably get rid of the rest.)
+ *
+ *  2) A set of functions for moving a highlighted wireframe box around
+ *     the screen, optionally with height and width shown in the middle.
+ *     This is used for moving and resizing when reduced_resources is set.
+ *
+ * There was formerly a system which allowed callers to drop in their
+ * own handlers for various things; it was never used (people who want
+ * their own handlers can just modify this file, after all) and it added
+ * a good deal of extra complexity, so it has been removed.  If you want it,
+ * it can be found in svn r3769.
+ */
+
+/* 
+ * Copyright (C) 2001 Anders Carlsson, Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_EFFECTS_H
+#define META_EFFECTS_H
+
+#include "util.h"
+#include "screen-private.h"
+
+typedef enum
+{
+  META_EFFECT_MINIMIZE,
+  META_EFFECT_UNMINIMIZE,
+  META_EFFECT_FOCUS,
+  META_EFFECT_CLOSE,
+  META_NUM_EFFECTS
+} MetaEffectType;
+
+/**
+ * A callback which will be called when the effect has finished.
+ */
+typedef void (* MetaEffectFinished) (gpointer    data);
+
+/**
+ * Performs the minimize effect.
+ *
+ * \param window       The window we're moving
+ * \param window_rect  Its current state
+ * \param target       Where it should end up
+ * \param finished     Callback for when it's finished
+ * \param data         Data for callback
+ */
+void        meta_effect_run_minimize     (MetaWindow         *window,
+                                          MetaRectangle	     *window_rect,
+                                          MetaRectangle	     *target,
+                                          MetaEffectFinished  finished,
+                                          gpointer            data);
+
+/**
+ * Performs the unminimize effect.  There is no such effect.
+ * FIXME: delete this.
+ *
+ * \param window       The window we're moving
+ * \param icon_rect    Its current state
+ * \param window_rect  Where it should end up
+ * \param finished     Callback for when it's finished
+ * \param data         Data for callback
+ */
+void        meta_effect_run_unminimize (MetaWindow         *window,
+                                          MetaRectangle      *window_rect,
+                                          MetaRectangle      *icon_rect,
+                                          MetaEffectFinished  finished,
+                                          gpointer            data);
+
+/**
+ * Performs the close effect.  There is no such effect.
+ * FIXME: delete this.
+ *
+ * \param window       The window we're moving
+ * \param finished     Callback for when it's finished
+ * \param data         Data for callback
+ */
+void        meta_effect_run_close        (MetaWindow         *window,
+                                          MetaEffectFinished  finished,
+                                          gpointer            data);
+
+/**
+ * Performs the focus effect.  There is no such effect.
+ * FIXME: delete this.
+ *
+ * \param window       The window we're moving
+ * \param finished     Callback for when it's finished
+ * \param data         Data for callback
+ */
+void        meta_effect_run_focus        (MetaWindow         *window,
+                                          MetaEffectFinished  finished,
+                                          gpointer            data);
+
+/**
+ * Grabs the server and paints a wireframe rectangle on the screen.
+ * Since this involves starting a grab, please be considerate of other
+ * users and don't keep the grab for long.  You may move the wireframe
+ * around using meta_effects_update_wireframe() and remove it, and undo
+ * the grab, using meta_effects_end_wireframe().
+ *
+ * \param screen  The screen to draw the rectangle on.
+ * \param rect    The size of the rectangle to draw.
+ * \param width   The width to display in the middle (or 0 not to)
+ * \param height  The width to display in the middle (or 0 not to)
+ */
+void meta_effects_begin_wireframe  (MetaScreen          *screen,
+                                    const MetaRectangle *rect,
+                                    int                  width,
+                                    int                  height);
+
+/**
+ * Moves a wireframe rectangle around after its creation by
+ * meta_effects_begin_wireframe().  (Perhaps we ought to remember the old
+ * positions and not require people to pass them in?)
+ *
+ * \param old_rect  Where the rectangle is now
+ * \param old_width The width that was displayed on it (or 0 if there wasn't)
+ * \param old_height The height that was displayed on it (or 0 if there wasn't)
+ * \param new_rect  Where the rectangle is going
+ * \param new_width The width that will be displayed on it (or 0 not to)
+ * \param new_height The height that will be displayed on it (or 0 not to)
+ */
+void meta_effects_update_wireframe (MetaScreen          *screen,
+                                    const MetaRectangle *old_rect,
+                                    int                  old_width,
+                                    int                  old_height,
+                                    const MetaRectangle *new_rect,
+                                    int                  new_width,
+                                    int                  new_height);
+
+/**
+ * Removes a wireframe rectangle from the screen and ends the grab started by
+ * meta_effects_begin_wireframe().
+ *
+ * \param old_rect  Where the rectangle is now
+ * \param old_width The width that was displayed on it (or 0 if there wasn't)
+ * \param old_height The height that was displayed on it (or 0 if there wasn't)
+ */
+void meta_effects_end_wireframe    (MetaScreen          *screen,
+                                    const MetaRectangle *old_rect,
+                                    int                  width,
+                                    int                  height);
+
+#endif /* META_EFFECTS_H */
diff --git a/src/core/errors.c b/src/core/errors.c
new file mode 100644
index 00000000..3b2a6334
--- /dev/null
+++ b/src/core/errors.c
@@ -0,0 +1,288 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X error handling */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington, error trapping inspired by GDK
+ * code copyrighted by the GTK team.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "errors.h"
+#include "display-private.h"
+#include <errno.h>
+#include <stdlib.h>
+#include <gdk/gdk.h>
+
+static int x_error_handler    (Display     *display,
+                               XErrorEvent *error);
+static int x_io_error_handler (Display     *display);
+
+void
+meta_errors_init (void)
+{
+  XSetErrorHandler (x_error_handler);
+  XSetIOErrorHandler (x_io_error_handler);
+}
+
+typedef struct ForeignDisplay ForeignDisplay;
+
+struct ForeignDisplay
+{
+    Display *dpy;
+    ErrorHandler handler;
+    gpointer data;
+    ForeignDisplay *next;
+};
+
+static ForeignDisplay *foreign_displays;
+
+void
+meta_errors_register_foreign_display (Display      *foreign_dpy,
+				      ErrorHandler  handler,
+				      gpointer      data)
+{
+    ForeignDisplay *info = g_new0 (ForeignDisplay, 1);
+    info->dpy = foreign_dpy;
+    info->handler = handler;
+    info->data = data;
+    info->next = foreign_displays;
+    foreign_displays = info;
+}
+
+static void
+meta_error_trap_push_internal (MetaDisplay *display,
+                               gboolean     need_sync)
+{
+  /* GDK resets the error handler on each push */
+  int (* old_error_handler) (Display     *,
+                             XErrorEvent *);
+
+  if (need_sync)
+    {
+      XSync (display->xdisplay, False);
+    }
+  
+  gdk_error_trap_push ();
+
+  /* old_error_handler will just be equal to x_error_handler
+   * for nested traps
+   */
+  old_error_handler = XSetErrorHandler (x_error_handler);
+  
+  /* Replace GDK handler, but save it so we can chain up */
+  if (display->error_trap_handler == NULL)
+    {
+      g_assert (display->error_traps == 0);
+      display->error_trap_handler = old_error_handler;
+      g_assert (display->error_trap_handler != x_error_handler);
+    }
+
+  display->error_traps += 1;
+
+  meta_topic (META_DEBUG_ERRORS, "%d traps remain\n", display->error_traps);
+}
+
+static int
+meta_error_trap_pop_internal  (MetaDisplay *display,
+                               gboolean     need_sync)
+{
+  int result;
+
+  g_assert (display->error_traps > 0);
+
+  if (need_sync)
+    {
+      XSync (display->xdisplay, False);
+    }
+
+  result = gdk_error_trap_pop ();
+
+  display->error_traps -= 1;
+  
+  if (display->error_traps == 0)
+    {
+      /* check that GDK put our handler back; this
+       * assumes that there are no pending GDK traps from GDK itself
+       */
+      
+      int (* restored_error_handler) (Display     *,
+                                      XErrorEvent *);
+
+      restored_error_handler = XSetErrorHandler (x_error_handler);
+
+      /* remove this */
+      display->error_trap_handler = NULL;
+    }
+
+  meta_topic (META_DEBUG_ERRORS, "%d traps\n", display->error_traps);
+  
+  return result;
+}
+
+void
+meta_error_trap_push (MetaDisplay *display)
+{
+  meta_error_trap_push_internal (display, FALSE);
+}
+
+void
+meta_error_trap_pop (MetaDisplay *display,
+                     gboolean     last_request_was_roundtrip)
+{
+  gboolean need_sync;
+
+  /* we only have to sync when popping the outermost trap */
+  need_sync = (display->error_traps == 1 && !last_request_was_roundtrip);
+
+  if (need_sync)
+    meta_topic (META_DEBUG_SYNC, "Syncing on error_trap_pop, traps = %d, roundtrip = %d\n",
+                display->error_traps, last_request_was_roundtrip);
+
+  display->error_trap_synced_at_last_pop = need_sync || last_request_was_roundtrip;
+  
+  meta_error_trap_pop_internal (display, need_sync);
+}
+
+void
+meta_error_trap_push_with_return (MetaDisplay *display)
+{
+  gboolean need_sync;
+
+  /* We don't sync on push_with_return if there are no traps
+   * currently, because we assume that any errors were either covered
+   * by a previous pop, or were fatal.
+   *
+   * More generally, we don't sync if we were synchronized last time
+   * we popped. This is known to be the case if there are no traps,
+   * but we also keep a flag so we know whether it's the case otherwise.
+   */
+
+  if (!display->error_trap_synced_at_last_pop)
+    need_sync = TRUE;
+  else
+    need_sync = FALSE;
+
+  if (need_sync)
+    meta_topic (META_DEBUG_SYNC, "Syncing on error_trap_push_with_return, traps = %d\n",
+                display->error_traps);
+  
+  meta_error_trap_push_internal (display, FALSE);
+}
+
+int
+meta_error_trap_pop_with_return  (MetaDisplay *display,
+                                  gboolean     last_request_was_roundtrip)
+{
+  if (!last_request_was_roundtrip)
+    meta_topic (META_DEBUG_SYNC, "Syncing on error_trap_pop_with_return, traps = %d, roundtrip = %d\n",
+                display->error_traps, last_request_was_roundtrip);
+
+  display->error_trap_synced_at_last_pop = TRUE;
+  
+  return meta_error_trap_pop_internal (display,
+                                       !last_request_was_roundtrip);
+}
+
+static int
+x_error_handler (Display     *xdisplay,
+                 XErrorEvent *error)
+{
+  int retval;
+  gchar buf[64];
+  MetaDisplay *display;
+  ForeignDisplay *foreign;
+
+  for (foreign = foreign_displays; foreign != NULL; foreign = foreign->next)
+  {
+      if (foreign->dpy == xdisplay)
+      {
+	  foreign->handler (xdisplay, error, foreign->data);
+
+	  return 0;
+      }
+  }
+  
+  XGetErrorText (xdisplay, error->error_code, buf, 63);  
+
+  display = meta_display_for_x_display (xdisplay);
+
+  /* Display can be NULL here because the compositing manager
+   * has its own Display, but Xlib only has one global error handler
+   */
+  if (display->error_traps > 0)
+    {
+      /* we're in an error trap, chain to the trap handler
+       * saved from GDK
+       */
+      meta_verbose ("X error: %s serial %ld error_code %d request_code %d minor_code %d)\n",
+                    buf,
+                    error->serial, 
+                    error->error_code, 
+                    error->request_code,
+                    error->minor_code);
+
+      g_assert (display->error_trap_handler != NULL);
+      g_assert (display->error_trap_handler != x_error_handler);
+      
+      retval = (* display->error_trap_handler) (xdisplay, error);
+    }
+  else
+    {
+      meta_bug ("Unexpected X error: %s serial %ld error_code %d request_code %d minor_code %d)\n",
+                buf,
+                error->serial, 
+                error->error_code, 
+                error->request_code,
+                error->minor_code);
+
+      retval = 1; /* compiler warning */
+    }
+
+  return retval;
+}
+
+static int
+x_io_error_handler (Display *xdisplay)
+{
+  MetaDisplay *display;
+
+  display = meta_display_for_x_display (xdisplay);
+
+  if (display == NULL)
+    meta_bug ("IO error received for unknown display?\n");
+  
+  if (errno == EPIPE)
+    {
+      meta_warning (_("Lost connection to the display '%s';\n"
+                      "most likely the X server was shut down or you killed/destroyed\n"
+                      "the window manager.\n"),
+                    display->name);
+    }
+  else
+    {
+      meta_warning (_("Fatal IO error %d (%s) on display '%s'.\n"),
+                    errno, g_strerror (errno),
+                    display->name);
+    }
+
+  /* Xlib would force an exit anyhow */
+  exit (1);
+  
+  return 0;
+}
diff --git a/src/core/eventqueue.c b/src/core/eventqueue.c
new file mode 100644
index 00000000..2799cae9
--- /dev/null
+++ b/src/core/eventqueue.c
@@ -0,0 +1,184 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X event source for main loop */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington (based on GDK code (C) Owen
+ * Taylor, Red Hat Inc.)
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  */
+
+#include "eventqueue.h"
+#include <X11/Xlib.h>
+
+static gboolean eq_prepare  (GSource     *source,
+                             gint        *timeout);
+static gboolean eq_check    (GSource     *source);
+static gboolean eq_dispatch (GSource     *source,
+                             GSourceFunc  callback,
+                             gpointer     user_data);
+static void     eq_destroy  (GSource     *source);
+
+static GSourceFuncs eq_funcs = {
+  eq_prepare,
+  eq_check,
+  eq_dispatch,
+  eq_destroy
+};
+
+struct _MetaEventQueue
+{
+  GSource source;
+
+  Display *display;
+  GPollFD poll_fd;
+  int connection_fd;
+  GQueue *events;
+};
+
+MetaEventQueue*
+meta_event_queue_new (Display *display, MetaEventQueueFunc func, gpointer data)
+{
+  GSource *source;
+  MetaEventQueue *eq;
+
+  source = g_source_new (&eq_funcs, sizeof (MetaEventQueue));
+  eq = (MetaEventQueue*) source;
+  
+  eq->connection_fd = ConnectionNumber (display);
+  eq->poll_fd.fd = eq->connection_fd;
+  eq->poll_fd.events = G_IO_IN;
+
+  eq->events = g_queue_new ();
+
+  eq->display = display;
+  
+  g_source_set_priority (source, G_PRIORITY_DEFAULT);
+  g_source_add_poll (source, &eq->poll_fd);
+  g_source_set_can_recurse (source, TRUE);
+
+  g_source_set_callback (source, (GSourceFunc) func, data, NULL);
+  
+  g_source_attach (source, NULL);
+  g_source_unref (source);
+
+  return eq;
+}
+
+void
+meta_event_queue_free (MetaEventQueue *eq)
+{
+  GSource *source;
+
+  source = (GSource*) eq;
+  
+  g_source_destroy (source);
+}
+
+static gboolean
+eq_events_pending (MetaEventQueue *eq)
+{
+  return eq->events->length > 0 || XPending (eq->display);
+}
+
+static void
+eq_queue_events (MetaEventQueue *eq)
+{
+  XEvent xevent;
+
+  while (XPending (eq->display))
+    {
+      XEvent *copy;
+      
+      XNextEvent (eq->display, &xevent);
+
+      copy = g_new (XEvent, 1);
+      *copy = xevent;
+
+      g_queue_push_tail (eq->events, copy);
+    }
+}
+
+static gboolean  
+eq_prepare (GSource *source, gint *timeout)
+{
+  MetaEventQueue *eq;
+
+  eq = (MetaEventQueue*) source;
+  
+  *timeout = -1;
+
+  return eq_events_pending (eq);
+}
+
+static gboolean  
+eq_check (GSource  *source) 
+{
+  MetaEventQueue *eq;
+
+  eq = (MetaEventQueue*) source;
+
+  if (eq->poll_fd.revents & G_IO_IN)
+    return eq_events_pending (eq);
+  else
+    return FALSE;
+}
+
+static gboolean  
+eq_dispatch (GSource *source, GSourceFunc callback, gpointer user_data)
+{
+  MetaEventQueue *eq;
+
+  eq = (MetaEventQueue*) source;
+  
+  eq_queue_events (eq);
+
+  if (eq->events->length > 0)
+    {
+      XEvent *event;
+      MetaEventQueueFunc func;
+
+      event = g_queue_pop_head (eq->events);
+      func = (MetaEventQueueFunc) callback;
+      
+      (* func) (event, user_data);
+
+      g_free (event);
+    }
+  
+  return TRUE;
+}
+
+static void
+eq_destroy (GSource *source)
+{
+  MetaEventQueue *eq;
+
+  eq = (MetaEventQueue*) source;
+
+  while (eq->events->length > 0)
+    {
+      XEvent *event;
+      
+      event = g_queue_pop_head (eq->events);
+
+      g_free (event);
+    }
+
+  g_queue_free (eq->events);
+
+  /* source itself is freed by glib */
+}
diff --git a/src/core/eventqueue.h b/src/core/eventqueue.h
new file mode 100644
index 00000000..8f3596af
--- /dev/null
+++ b/src/core/eventqueue.h
@@ -0,0 +1,40 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X event source for main loop */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_EVENT_QUEUE_H
+#define META_EVENT_QUEUE_H
+
+#include <glib.h>
+#include <X11/Xlib.h>
+
+typedef struct _MetaEventQueue MetaEventQueue;
+
+typedef void   (* MetaEventQueueFunc) (XEvent         *event,
+                                       gpointer        data);
+
+MetaEventQueue* meta_event_queue_new  (Display            *display,
+                                       MetaEventQueueFunc  func,
+                                       gpointer            data);
+void            meta_event_queue_free (MetaEventQueue     *eq);
+
+#endif
diff --git a/src/core/frame-private.h b/src/core/frame-private.h
new file mode 100644
index 00000000..bde352dc
--- /dev/null
+++ b/src/core/frame-private.h
@@ -0,0 +1,88 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X window decorations */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_FRAME_PRIVATE_H
+#define META_FRAME_PRIVATE_H
+
+#include "frame.h"
+#include "window-private.h"
+
+typedef struct _MetaFrameGeometry MetaFrameGeometry;
+
+struct _MetaFrameGeometry
+{  
+  /* border sizes (space between frame and child) */
+  int left_width;
+  int right_width;
+  int top_height;
+  int bottom_height;
+};
+
+struct _MetaFrame
+{
+  /* window we frame */
+  MetaWindow *window;
+
+  /* reparent window */
+  Window xwindow;
+
+  MetaCursor current_cursor;
+
+  /* This rect is trusted info from where we put the
+   * frame, not the result of ConfigureNotify
+   */
+  MetaRectangle rect;
+
+  /* position of client, size of frame */
+  int child_x;
+  int child_y;
+  int right_width;
+  int bottom_height;
+
+  guint mapped : 1;
+  guint need_reapply_frame_shape : 1;
+  guint is_flashing : 1; /* used by the visual bell flash */
+};
+
+void     meta_window_ensure_frame           (MetaWindow *window);
+void     meta_window_destroy_frame          (MetaWindow *window);
+void     meta_frame_queue_draw              (MetaFrame  *frame);
+
+MetaFrameFlags meta_frame_get_flags (MetaFrame *frame);
+
+/* These should ONLY be called from meta_window_move_resize_internal */
+void meta_frame_calc_geometry      (MetaFrame         *frame,
+                                    MetaFrameGeometry *geomp);
+void meta_frame_sync_to_window     (MetaFrame         *frame,
+                                    int                gravity,
+                                    gboolean           need_move,
+                                    gboolean           need_resize);
+
+void meta_frame_set_screen_cursor (MetaFrame	*frame,
+				   MetaCursor	cursor);
+
+#endif
+
+
+
+
diff --git a/src/core/frame.c b/src/core/frame.c
new file mode 100644
index 00000000..2d0bbb51
--- /dev/null
+++ b/src/core/frame.c
@@ -0,0 +1,421 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X window decorations */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003, 2004 Red Hat, Inc.
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "frame-private.h"
+#include "bell.h"
+#include "errors.h"
+#include "keybindings.h"
+
+#ifdef HAVE_RENDER
+#include <X11/extensions/Xrender.h>
+#endif
+
+#define EVENT_MASK (SubstructureRedirectMask |                     \
+                    StructureNotifyMask | SubstructureNotifyMask | \
+                    ExposureMask |                                 \
+                    ButtonPressMask | ButtonReleaseMask |          \
+                    PointerMotionMask | PointerMotionHintMask |    \
+                    EnterWindowMask | LeaveWindowMask |            \
+                    FocusChangeMask |                              \
+                    ColormapChangeMask)
+
+void
+meta_window_ensure_frame (MetaWindow *window)
+{
+  MetaFrame *frame;
+  XSetWindowAttributes attrs;
+  Visual *visual;
+  
+  if (window->frame)
+    return;
+  
+  /* See comment below for why this is required. */
+  meta_display_grab (window->display);
+  
+  frame = g_new (MetaFrame, 1);
+
+  frame->window = window;
+  frame->xwindow = None;
+
+  frame->rect = window->rect;
+  frame->child_x = 0;
+  frame->child_y = 0;
+  frame->bottom_height = 0;
+  frame->right_width = 0;
+  frame->current_cursor = 0;
+
+  frame->mapped = FALSE;
+  frame->need_reapply_frame_shape = TRUE;
+  frame->is_flashing = FALSE;
+  
+  meta_verbose ("Framing window %s: visual %s default, depth %d default depth %d\n",
+                window->desc,
+                XVisualIDFromVisual (window->xvisual) ==
+                XVisualIDFromVisual (window->screen->default_xvisual) ?
+                "is" : "is not",
+                window->depth, window->screen->default_depth);
+  meta_verbose ("Frame geometry %d,%d  %dx%d\n",
+                frame->rect.x, frame->rect.y,
+                frame->rect.width, frame->rect.height);
+  
+  /* Default depth/visual handles clients with weird visuals; they can
+   * always be children of the root depth/visual obviously, but
+   * e.g. DRI games can't be children of a parent that has the same
+   * visual as the client. NULL means default visual.
+   *
+   * We look for an ARGB visual if we can find one, otherwise use
+   * the default of NULL.
+   */
+  
+  /* Special case for depth 32 windows (assumed to be ARGB),
+   * we use the window's visual. Otherwise we just use the system visual.
+   */
+  if (window->depth == 32)
+    visual = window->xvisual;
+  else
+    visual = NULL;
+  
+  frame->xwindow = meta_ui_create_frame_window (window->screen->ui,
+                                                window->display->xdisplay,
+                                                visual,
+                                                frame->rect.x,
+                                                frame->rect.y,
+						frame->rect.width,
+						frame->rect.height,
+						frame->window->screen->number);
+
+  meta_verbose ("Frame for %s is 0x%lx\n", frame->window->desc, frame->xwindow);
+  attrs.event_mask = EVENT_MASK;
+  XChangeWindowAttributes (window->display->xdisplay,
+			   frame->xwindow, CWEventMask, &attrs);
+  
+  meta_display_register_x_window (window->display, &frame->xwindow, window);
+
+  /* Now that frame->xwindow is registered with window, we can set its
+   * background.
+   */
+  meta_ui_reset_frame_bg (window->screen->ui, frame->xwindow);
+
+  /* Reparent the client window; it may be destroyed,
+   * thus the error trap. We'll get a destroy notify later
+   * and free everything. Comment in FVWM source code says
+   * we need a server grab or the child can get its MapNotify
+   * before we've finished reparenting and getting the decoration
+   * window onscreen, so ensure_frame must be called with
+   * a grab.
+   */
+  meta_error_trap_push (window->display);
+  if (window->mapped)
+    {
+      window->mapped = FALSE; /* the reparent will unmap the window,
+                               * we don't want to take that as a withdraw
+                               */
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "Incrementing unmaps_pending on %s for reparent\n", window->desc);
+      window->unmaps_pending += 1;
+    }
+  /* window was reparented to this position */
+  window->rect.x = 0;
+  window->rect.y = 0;
+
+  XReparentWindow (window->display->xdisplay,
+                   window->xwindow,
+                   frame->xwindow,
+                   window->rect.x,
+                   window->rect.y);
+  /* FIXME handle this error */
+  meta_error_trap_pop (window->display, FALSE);
+  
+  /* stick frame to the window */
+  window->frame = frame;
+  
+  if (window->title)
+    meta_ui_set_frame_title (window->screen->ui,
+                             window->frame->xwindow,
+                             window->title);
+
+  /* Move keybindings to frame instead of window */
+  meta_window_grab_keys (window);
+
+  /* Shape mask */
+  meta_ui_apply_frame_shape (frame->window->screen->ui,
+                             frame->xwindow,
+                             frame->rect.width,
+                             frame->rect.height,
+                             frame->window->has_shape);
+  frame->need_reapply_frame_shape = FALSE;
+  
+  meta_display_ungrab (window->display);
+}
+
+void
+meta_window_destroy_frame (MetaWindow *window)
+{
+  MetaFrame *frame;
+  
+  if (window->frame == NULL)
+    return;
+
+  meta_verbose ("Unframing window %s\n", window->desc);
+  
+  frame = window->frame;
+  
+  meta_bell_notify_frame_destroy (frame);
+  
+  /* Unparent the client window; it may be destroyed,
+   * thus the error trap.
+   */
+  meta_error_trap_push (window->display);
+  if (window->mapped)
+    {
+      window->mapped = FALSE; /* Keep track of unmapping it, so we
+                               * can identify a withdraw initiated
+                               * by the client.
+                               */
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "Incrementing unmaps_pending on %s for reparent back to root\n", window->desc);
+      window->unmaps_pending += 1;
+    }
+  XReparentWindow (window->display->xdisplay,
+                   window->xwindow,
+                   window->screen->xroot,
+                   /* Using anything other than meta_window_get_position()
+                    * coordinates here means we'll need to ensure a configure
+                    * notify event is sent; see bug 399552.
+                    */
+                   window->frame->rect.x,
+                   window->frame->rect.y);
+  meta_error_trap_pop (window->display, FALSE);
+
+  meta_ui_destroy_frame_window (window->screen->ui, frame->xwindow);
+
+  meta_display_unregister_x_window (window->display,
+                                    frame->xwindow);
+  
+  window->frame = NULL;
+
+  /* Move keybindings to window instead of frame */
+  meta_window_grab_keys (window);
+  
+  g_free (frame);
+  
+  /* Put our state back where it should be */
+  meta_window_queue (window, META_QUEUE_CALC_SHOWING);
+  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+}
+
+
+MetaFrameFlags
+meta_frame_get_flags (MetaFrame *frame)
+{
+  MetaFrameFlags flags;
+
+  flags = 0;
+
+  if (frame->window->border_only)
+    {
+      ; /* FIXME this may disable the _function_ as well as decor
+         * in some cases, which is sort of wrong.
+         */
+    }
+  else
+    {
+      flags |= META_FRAME_ALLOWS_MENU;
+      
+      if (frame->window->has_close_func)
+        flags |= META_FRAME_ALLOWS_DELETE;
+      
+      if (frame->window->has_maximize_func)
+        flags |= META_FRAME_ALLOWS_MAXIMIZE;
+      
+      if (frame->window->has_minimize_func)
+        flags |= META_FRAME_ALLOWS_MINIMIZE;
+      
+      if (frame->window->has_shade_func)
+        flags |= META_FRAME_ALLOWS_SHADE;
+    }  
+  
+  if (META_WINDOW_ALLOWS_MOVE (frame->window))
+    flags |= META_FRAME_ALLOWS_MOVE;
+
+  if (META_WINDOW_ALLOWS_HORIZONTAL_RESIZE (frame->window))
+    flags |= META_FRAME_ALLOWS_HORIZONTAL_RESIZE;
+
+  if (META_WINDOW_ALLOWS_VERTICAL_RESIZE (frame->window))
+    flags |= META_FRAME_ALLOWS_VERTICAL_RESIZE;
+  
+  if (frame->window->has_focus)
+    flags |= META_FRAME_HAS_FOCUS;
+
+  if (frame->window->shaded)
+    flags |= META_FRAME_SHADED;
+
+  if (frame->window->on_all_workspaces)
+    flags |= META_FRAME_STUCK;
+
+  /* FIXME: Should we have some kind of UI for windows that are just vertically
+   * maximized or just horizontally maximized?
+   */
+  if (META_WINDOW_MAXIMIZED (frame->window))
+    flags |= META_FRAME_MAXIMIZED;
+
+  if (frame->window->fullscreen)
+    flags |= META_FRAME_FULLSCREEN;
+
+  if (frame->is_flashing)
+    flags |= META_FRAME_IS_FLASHING;
+
+  if (frame->window->wm_state_above)
+    flags |= META_FRAME_ABOVE;
+  
+  return flags;
+}
+
+void
+meta_frame_calc_geometry (MetaFrame         *frame,
+                          MetaFrameGeometry *geomp)
+{
+  MetaFrameGeometry geom;
+  MetaWindow *window;
+
+  window = frame->window;
+
+  meta_ui_get_frame_geometry (window->screen->ui,
+                              frame->xwindow,
+                              &geom.top_height,
+                              &geom.bottom_height,
+                              &geom.left_width,
+                              &geom.right_width);
+  
+  *geomp = geom;
+}
+
+static void
+update_shape (MetaFrame *frame)
+{
+  if (frame->need_reapply_frame_shape)
+    {
+      meta_ui_apply_frame_shape (frame->window->screen->ui,
+                                 frame->xwindow,
+                                 frame->rect.width,
+                                 frame->rect.height,
+                                 frame->window->has_shape);
+      frame->need_reapply_frame_shape = FALSE;
+    }
+}
+
+void
+meta_frame_sync_to_window (MetaFrame *frame,
+                           int        resize_gravity,
+                           gboolean   need_move,
+                           gboolean   need_resize)
+{
+  if (!(need_move || need_resize))
+    {
+      update_shape (frame);
+      return;
+    }
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Syncing frame geometry %d,%d %dx%d (SE: %d,%d)\n",
+              frame->rect.x, frame->rect.y,
+              frame->rect.width, frame->rect.height,
+              frame->rect.x + frame->rect.width,
+              frame->rect.y + frame->rect.height);
+
+  /* set bg to none to avoid flicker */
+  if (need_resize)
+    {
+      meta_ui_unflicker_frame_bg (frame->window->screen->ui,
+                                  frame->xwindow,
+                                  frame->rect.width,
+                                  frame->rect.height);
+
+      /* we need new shape if we're resized */
+      frame->need_reapply_frame_shape = TRUE;
+    }
+
+  /* Done before the window resize, because doing it before means
+   * part of the window being resized becomes unshaped, which may
+   * be sort of hard to see with bg = None. If we did it after
+   * window resize, part of the window being resized would become
+   * shaped, which might be more visible.
+   */
+  update_shape (frame);
+  
+  meta_ui_move_resize_frame (frame->window->screen->ui,
+			     frame->xwindow,
+			     frame->rect.x,
+			     frame->rect.y,
+			     frame->rect.width,
+			     frame->rect.height);
+
+  if (need_resize)
+    {
+      meta_ui_reset_frame_bg (frame->window->screen->ui,
+                              frame->xwindow);
+
+      /* If we're interactively resizing the frame, repaint
+       * it immediately so we don't start to lag.
+       */
+      if (frame->window->display->grab_window ==
+          frame->window)
+        meta_ui_repaint_frame (frame->window->screen->ui,
+                               frame->xwindow);
+    }
+}
+
+void
+meta_frame_queue_draw (MetaFrame *frame)
+{
+  meta_ui_queue_frame_draw (frame->window->screen->ui,
+                            frame->xwindow);
+}
+
+void
+meta_frame_set_screen_cursor (MetaFrame	*frame,
+			      MetaCursor cursor)
+{
+  Cursor xcursor;
+  if (cursor == frame->current_cursor)
+    return;
+  frame->current_cursor = cursor;
+  if (cursor == META_CURSOR_DEFAULT)
+    XUndefineCursor (frame->window->display->xdisplay, frame->xwindow);
+  else
+    { 
+      xcursor = meta_display_create_x_cursor (frame->window->display, cursor);
+      XDefineCursor (frame->window->display->xdisplay, frame->xwindow, xcursor);
+      XFlush (frame->window->display->xdisplay);
+      XFreeCursor (frame->window->display->xdisplay, xcursor);
+    }
+}
+
+Window
+meta_frame_get_xwindow (MetaFrame *frame)
+{
+  return frame->xwindow;
+}
diff --git a/src/core/group-private.h b/src/core/group-private.h
new file mode 100644
index 00000000..bf8dd5a3
--- /dev/null
+++ b/src/core/group-private.h
@@ -0,0 +1,43 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window group private header */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_GROUP_PRIVATE_H
+#define META_GROUP_PRIVATE_H
+
+#include "group.h"
+
+struct _MetaGroup
+{
+  int refcount;
+  MetaDisplay *display;
+  GSList *windows;
+  Window group_leader;
+  char *startup_id;
+  char *wm_client_machine;
+};
+
+#endif
+
+
+
+
diff --git a/src/core/group-props.c b/src/core/group-props.c
new file mode 100644
index 00000000..05e82900
--- /dev/null
+++ b/src/core/group-props.c
@@ -0,0 +1,234 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* MetaGroup property handling */
+
+/* 
+ * Copyright (C) 2002 Red Hat, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "group-props.h"
+#include "group-private.h"
+#include "xprops.h"
+#include <X11/Xatom.h>
+
+typedef void (* InitValueFunc)   (MetaDisplay   *display,
+                                  Atom           property,
+                                  MetaPropValue *value);
+typedef void (* ReloadValueFunc) (MetaGroup     *group,
+                                  MetaPropValue *value);
+
+struct _MetaGroupPropHooks
+{
+  Atom property;
+  InitValueFunc   init_func;
+  ReloadValueFunc reload_func;
+};
+
+static void                init_prop_value   (MetaDisplay   *display,
+                                              Atom           property,
+                                              MetaPropValue *value);
+static void                reload_prop_value (MetaGroup     *group,
+                                              MetaPropValue *value);
+static MetaGroupPropHooks* find_hooks        (MetaDisplay   *display,
+                                              Atom           property);
+
+
+
+void
+meta_group_reload_property (MetaGroup *group,
+                            Atom       property)
+{
+  meta_group_reload_properties (group, &property, 1);
+}
+
+void
+meta_group_reload_properties (MetaGroup  *group,
+                              const Atom *properties,
+                              int         n_properties)
+{
+  int i;
+  MetaPropValue *values;
+
+  g_return_if_fail (properties != NULL);
+  g_return_if_fail (n_properties > 0);
+  
+  values = g_new0 (MetaPropValue, n_properties);
+  
+  i = 0;
+  while (i < n_properties)
+    {
+      init_prop_value (group->display, properties[i], &values[i]);
+      ++i;
+    }
+  
+  meta_prop_get_values (group->display, group->group_leader,
+                        values, n_properties);
+
+  i = 0;
+  while (i < n_properties)
+    {
+      reload_prop_value (group, &values[i]);
+      
+      ++i;
+    }
+
+  meta_prop_free_values (values, n_properties);
+  
+  g_free (values);
+}
+
+/* Fill in the MetaPropValue used to get the value of "property" */
+static void
+init_prop_value (MetaDisplay   *display,
+                 Atom           property,
+                 MetaPropValue *value)
+{
+  MetaGroupPropHooks *hooks;  
+
+  value->type = META_PROP_VALUE_INVALID;
+  value->atom = None;
+  
+  hooks = find_hooks (display, property);
+  if (hooks && hooks->init_func != NULL)
+    (* hooks->init_func) (display, property, value);
+}
+
+static void
+reload_prop_value (MetaGroup    *group,
+                   MetaPropValue *value)
+{
+  MetaGroupPropHooks *hooks;  
+  
+  hooks = find_hooks (group->display, value->atom);
+  if (hooks && hooks->reload_func != NULL)
+    (* hooks->reload_func) (group, value);
+}
+
+static void
+init_wm_client_machine (MetaDisplay   *display,
+                        Atom           property,
+                        MetaPropValue *value)
+{
+  value->type = META_PROP_VALUE_STRING;
+  value->atom = display->atom_WM_CLIENT_MACHINE;
+}
+
+static void
+reload_wm_client_machine (MetaGroup     *group,
+                          MetaPropValue *value)
+{
+  g_free (group->wm_client_machine);
+  group->wm_client_machine = NULL;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    group->wm_client_machine = g_strdup (value->v.str);
+
+  meta_verbose ("Group has client machine \"%s\"\n",
+                group->wm_client_machine ? group->wm_client_machine : "unset");
+}
+
+static void
+init_net_startup_id (MetaDisplay   *display,
+                     Atom           property,
+                     MetaPropValue *value)
+{
+  value->type = META_PROP_VALUE_UTF8;
+  value->atom = display->atom__NET_STARTUP_ID;
+}
+
+static void
+reload_net_startup_id (MetaGroup     *group,
+                       MetaPropValue *value)
+{
+  g_free (group->startup_id);
+  group->startup_id = NULL;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    group->startup_id = g_strdup (value->v.str);
+  
+  meta_verbose ("Group has startup id \"%s\"\n",
+                group->startup_id ? group->startup_id : "unset");
+}
+
+#define N_HOOKS 3
+
+void
+meta_display_init_group_prop_hooks (MetaDisplay *display)
+{
+  int i;
+  MetaGroupPropHooks *hooks;
+  
+  g_assert (display->group_prop_hooks == NULL);
+
+  display->group_prop_hooks = g_new0 (MetaGroupPropHooks, N_HOOKS); 
+  hooks = display->group_prop_hooks;
+  
+  i = 0;
+
+  hooks[i].property = display->atom_WM_CLIENT_MACHINE;
+  hooks[i].init_func = init_wm_client_machine;
+  hooks[i].reload_func = reload_wm_client_machine;
+  ++i;
+
+  hooks[i].property = display->atom__NET_WM_PID;
+  hooks[i].init_func = NULL;
+  hooks[i].reload_func = NULL;
+  ++i;
+
+  hooks[i].property = display->atom__NET_STARTUP_ID;
+  hooks[i].init_func = init_net_startup_id;
+  hooks[i].reload_func = reload_net_startup_id;
+  ++i;
+  
+  if (i != N_HOOKS)
+    {
+      g_error ("Initialized %d group hooks should have been %d\n", i, N_HOOKS);
+    }
+}
+
+void
+meta_display_free_group_prop_hooks (MetaDisplay *display)
+{
+  g_assert (display->group_prop_hooks != NULL);
+  
+  g_free (display->group_prop_hooks);
+  display->group_prop_hooks = NULL;
+}
+
+static MetaGroupPropHooks*
+find_hooks (MetaDisplay *display,
+            Atom         property)
+{
+  int i;
+
+  /* FIXME we could sort the array and do binary search or
+   * something
+   */
+  
+  i = 0;
+  while (i < N_HOOKS)
+    {
+      if (display->group_prop_hooks[i].property == property)
+        return &display->group_prop_hooks[i];
+      
+      ++i;
+    }
+
+  return NULL;
+}
diff --git a/src/core/group-props.h b/src/core/group-props.h
new file mode 100644
index 00000000..ffde0901
--- /dev/null
+++ b/src/core/group-props.h
@@ -0,0 +1,37 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* MetaGroup property handling */
+
+/* 
+ * Copyright (C) 2002 Red Hat, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_GROUP_PROPS_H
+#define META_GROUP_PROPS_H
+
+#include "group.h"
+
+void meta_group_reload_property         (MetaGroup   *group,
+                                         Atom         property);
+void meta_group_reload_properties       (MetaGroup   *group,
+                                         const Atom  *properties,
+                                         int          n_properties);
+void meta_display_init_group_prop_hooks (MetaDisplay *display);
+void meta_display_free_group_prop_hooks (MetaDisplay *display);
+
+#endif /* META_GROUP_PROPS_H */
diff --git a/src/core/group.c b/src/core/group.c
new file mode 100644
index 00000000..35db53c7
--- /dev/null
+++ b/src/core/group.c
@@ -0,0 +1,274 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window groups */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2003 Rob Adams
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "util.h"
+#include "group-private.h"
+#include "group-props.h"
+#include "window.h"
+
+static MetaGroup*
+meta_group_new (MetaDisplay *display,
+                Window       group_leader)
+{
+  MetaGroup *group;
+#define N_INITIAL_PROPS 3
+  Atom initial_props[N_INITIAL_PROPS];
+  int i;
+  
+  g_assert (N_INITIAL_PROPS == (int) G_N_ELEMENTS (initial_props));
+  
+  group = g_new0 (MetaGroup, 1);
+
+  group->display = display;
+  group->windows = NULL;
+  group->group_leader = group_leader;
+  group->refcount = 1; /* owned by caller, hash table has only weak ref */
+  
+  if (display->groups_by_leader == NULL)
+    display->groups_by_leader = g_hash_table_new (meta_unsigned_long_hash,
+                                                  meta_unsigned_long_equal);
+
+  g_assert (g_hash_table_lookup (display->groups_by_leader, &group_leader) == NULL);
+
+  g_hash_table_insert (display->groups_by_leader,
+                       &group->group_leader,
+                       group);
+
+  /* Fill these in the order we want them to be gotten */
+  i = 0;
+  initial_props[i++] = display->atom_WM_CLIENT_MACHINE;
+  initial_props[i++] = display->atom__NET_WM_PID;
+  initial_props[i++] = display->atom__NET_STARTUP_ID;
+  g_assert (N_INITIAL_PROPS == i);
+  
+  meta_group_reload_properties (group, initial_props, N_INITIAL_PROPS);
+
+  meta_topic (META_DEBUG_GROUPS,
+              "Created new group with leader 0x%lx\n",
+              group->group_leader);
+  
+  return group;
+}
+
+static void
+meta_group_unref (MetaGroup *group)
+{
+  g_return_if_fail (group->refcount > 0);
+
+  group->refcount -= 1;
+  if (group->refcount == 0)
+    {
+      meta_topic (META_DEBUG_GROUPS,
+                  "Destroying group with leader 0x%lx\n",
+                  group->group_leader);      
+      
+      g_assert (group->display->groups_by_leader != NULL);
+      
+      g_hash_table_remove (group->display->groups_by_leader,
+                           &group->group_leader);
+
+      /* mop up hash table, this is how it gets freed on display close */
+      if (g_hash_table_size (group->display->groups_by_leader) == 0)
+        {
+          g_hash_table_destroy (group->display->groups_by_leader);
+          group->display->groups_by_leader = NULL;
+        }
+
+      g_free (group->wm_client_machine);
+      g_free (group->startup_id);
+      
+      g_free (group);
+    }
+}
+
+MetaGroup*
+meta_window_get_group (MetaWindow *window)
+{
+  if (window->unmanaging)
+    return NULL;
+
+  return window->group;
+}
+
+void
+meta_window_compute_group (MetaWindow* window)
+{
+  MetaGroup *group;
+  MetaWindow *ancestor;
+
+  /* use window->xwindow if no window->xgroup_leader */
+      
+  group = NULL;
+      
+  /* Determine the ancestor of the window; its group setting will override the
+   * normal grouping rules; see bug 328211.
+   */
+  ancestor = meta_window_find_root_ancestor (window);
+
+  if (window->display->groups_by_leader)
+    {
+      if (ancestor != window)
+        group = ancestor->group;
+      else if (window->xgroup_leader != None)
+        group = g_hash_table_lookup (window->display->groups_by_leader,
+                                     &window->xgroup_leader);
+      else
+        group = g_hash_table_lookup (window->display->groups_by_leader,
+                                     &window->xwindow);
+    }
+      
+  if (group != NULL)
+    {
+      window->group = group;
+      group->refcount += 1;
+    }
+  else
+    {
+      if (ancestor != window && ancestor->xgroup_leader != None)
+        group = meta_group_new (window->display,
+                                ancestor->xgroup_leader);
+      else if (window->xgroup_leader != None)
+        group = meta_group_new (window->display,
+                                window->xgroup_leader);
+      else
+        group = meta_group_new (window->display,
+                                window->xwindow);
+          
+      window->group = group;
+    }
+
+  window->group->windows = g_slist_prepend (window->group->windows, window);
+
+  meta_topic (META_DEBUG_GROUPS,
+              "Adding %s to group with leader 0x%lx\n",
+              window->desc, group->group_leader);
+
+}
+
+static void
+remove_window_from_group (MetaWindow *window)
+{
+  if (window->group != NULL)
+    {
+      meta_topic (META_DEBUG_GROUPS,
+                  "Removing %s from group with leader 0x%lx\n",
+                  window->desc, window->group->group_leader);
+      
+      window->group->windows =
+        g_slist_remove (window->group->windows,
+                        window);
+      meta_group_unref (window->group);
+      window->group = NULL;
+    }
+}
+
+void
+meta_window_group_leader_changed (MetaWindow *window)
+{
+  remove_window_from_group (window);
+  meta_window_compute_group (window);
+}
+
+void
+meta_window_shutdown_group (MetaWindow *window)
+{
+  remove_window_from_group (window);
+}
+
+MetaGroup*
+meta_display_lookup_group (MetaDisplay *display,
+                           Window       group_leader)
+{
+  MetaGroup *group;
+  
+  group = NULL;
+  
+  if (display->groups_by_leader)
+    group = g_hash_table_lookup (display->groups_by_leader,
+                                 &group_leader);
+
+  return group;
+}
+
+GSList*
+meta_group_list_windows (MetaGroup *group)
+{
+  return g_slist_copy (group->windows);
+}
+
+void
+meta_group_update_layers (MetaGroup *group)
+{
+  GSList *tmp;
+  GSList *frozen_stacks;
+  
+  if (group->windows == NULL)
+    return;
+
+  frozen_stacks = NULL;
+  tmp = group->windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      /* we end up freezing the same stack a lot of times,
+       * but doesn't hurt anything. have to handle
+       * groups that span 2 screens.
+       */
+      meta_stack_freeze (window->screen->stack);
+      frozen_stacks = g_slist_prepend (frozen_stacks, window->screen->stack);
+
+      meta_stack_update_layer (window->screen->stack,
+                               window);
+      
+      tmp = tmp->next;
+    }
+
+  tmp = frozen_stacks;
+  while (tmp != NULL)
+    {
+      meta_stack_thaw (tmp->data);
+      tmp = tmp->next;
+    }
+
+  g_slist_free (frozen_stacks);
+}
+
+const char*
+meta_group_get_startup_id (MetaGroup *group)
+{
+  return group->startup_id;
+}
+
+gboolean
+meta_group_property_notify (MetaGroup  *group,
+                            XEvent     *event)
+{
+  meta_group_reload_property (group,
+                              event->xproperty.atom);
+
+  return TRUE;
+
+}
diff --git a/src/core/group.h b/src/core/group.h
new file mode 100644
index 00000000..f71c2c47
--- /dev/null
+++ b/src/core/group.h
@@ -0,0 +1,53 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window groups */
+
+/* 
+ * Copyright (C) 2002 Red Hat Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_GROUP_H
+#define META_GROUP_H
+
+#include "window-private.h"
+
+/* note, can return NULL */
+MetaGroup* meta_window_get_group       (MetaWindow *window);
+void       meta_window_compute_group   (MetaWindow* window);
+void       meta_window_shutdown_group  (MetaWindow *window);
+
+void       meta_window_group_leader_changed (MetaWindow *window);
+
+/* note, can return NULL */
+MetaGroup* meta_display_lookup_group   (MetaDisplay *display,
+                                        Window       group_leader);
+
+GSList*    meta_group_list_windows     (MetaGroup *group);
+
+void       meta_group_update_layers    (MetaGroup *group);
+
+const char* meta_group_get_startup_id  (MetaGroup *group);
+
+gboolean meta_group_property_notify   (MetaGroup  *group,
+                                       XEvent     *event);
+
+#endif
+
+
+
+
diff --git a/src/core/iconcache.c b/src/core/iconcache.c
new file mode 100644
index 00000000..af9411ba
--- /dev/null
+++ b/src/core/iconcache.c
@@ -0,0 +1,849 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window icons */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "iconcache.h"
+#include "ui.h"
+#include "errors.h"
+
+#include <X11/Xatom.h>
+
+/* The icon-reading code is also in libwnck, please sync bugfixes */
+
+static void
+get_fallback_icons (MetaScreen     *screen,
+                    GdkPixbuf     **iconp,
+                    int             ideal_width,
+                    int             ideal_height,
+                    GdkPixbuf     **mini_iconp,
+                    int             ideal_mini_width,
+                    int             ideal_mini_height)
+{
+  /* we don't scale, should be fixed if we ever un-hardcode the icon
+   * size
+   */
+  *iconp = meta_ui_get_default_window_icon (screen->ui);
+  *mini_iconp = meta_ui_get_default_mini_icon (screen->ui);
+}
+
+static gboolean
+find_largest_sizes (gulong *data,
+                    gulong  nitems,
+                    int    *width,
+                    int    *height)
+{
+  *width = 0;
+  *height = 0;
+
+  while (nitems > 0)
+    {
+      int w, h;
+
+      if (nitems < 3)
+        return FALSE; /* no space for w, h */
+
+      w = data[0];
+      h = data[1];
+
+      if (nitems < ((gulong)(w * h) + 2))
+        return FALSE; /* not enough data */
+
+      *width = MAX (w, *width);
+      *height = MAX (h, *height);
+
+      data += (w * h) + 2;
+      nitems -= (w * h) + 2;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+find_best_size (gulong  *data,
+                gulong   nitems,
+                int      ideal_width,
+                int      ideal_height,
+                int     *width,
+                int     *height,
+                gulong **start)
+{
+  int best_w;
+  int best_h;
+  gulong *best_start;
+  int max_width, max_height;
+
+  *width = 0;
+  *height = 0;
+  *start = NULL;
+
+  if (!find_largest_sizes (data, nitems, &max_width, &max_height))
+    return FALSE;
+
+  if (ideal_width < 0)
+    ideal_width = max_width;
+  if (ideal_height < 0)
+    ideal_height = max_height;
+
+  best_w = 0;
+  best_h = 0;
+  best_start = NULL;
+
+  while (nitems > 0)
+    {
+      int w, h;
+      gboolean replace;
+
+      replace = FALSE;
+
+      if (nitems < 3)
+        return FALSE; /* no space for w, h */
+
+      w = data[0];
+      h = data[1];
+
+      if (nitems < ((gulong)(w * h) + 2))
+        break; /* not enough data */
+
+      if (best_start == NULL)
+        {
+          replace = TRUE;
+        }
+      else
+        {
+          /* work with averages */
+          const int ideal_size = (ideal_width + ideal_height) / 2;
+          int best_size = (best_w + best_h) / 2;
+          int this_size = (w + h) / 2;
+
+          /* larger than desired is always better than smaller */
+          if (best_size < ideal_size &&
+              this_size >= ideal_size)
+            replace = TRUE;
+          /* if we have too small, pick anything bigger */
+          else if (best_size < ideal_size &&
+                   this_size > best_size)
+            replace = TRUE;
+          /* if we have too large, pick anything smaller
+           * but still >= the ideal
+           */
+          else if (best_size > ideal_size &&
+                   this_size >= ideal_size &&
+                   this_size < best_size)
+            replace = TRUE;
+        }
+
+      if (replace)
+        {
+          best_start = data + 2;
+          best_w = w;
+          best_h = h;
+        }
+
+      data += (w * h) + 2;
+      nitems -= (w * h) + 2;
+    }
+
+  if (best_start)
+    {
+      *start = best_start;
+      *width = best_w;
+      *height = best_h;
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+static void
+argbdata_to_pixdata (gulong *argb_data, int len, guchar **pixdata)
+{
+  guchar *p;
+  int i;
+
+  *pixdata = g_new (guchar, len * 4);
+  p = *pixdata;
+
+  /* One could speed this up a lot. */
+  i = 0;
+  while (i < len)
+    {
+      guint argb;
+      guint rgba;
+
+      argb = argb_data[i];
+      rgba = (argb << 8) | (argb >> 24);
+
+      *p = rgba >> 24;
+      ++p;
+      *p = (rgba >> 16) & 0xff;
+      ++p;
+      *p = (rgba >> 8) & 0xff;
+      ++p;
+      *p = rgba & 0xff;
+      ++p;
+
+      ++i;
+    }
+}
+
+static gboolean
+read_rgb_icon (MetaDisplay   *display,
+               Window         xwindow,
+               int            ideal_width,
+               int            ideal_height,
+               int            ideal_mini_width,
+               int            ideal_mini_height,
+               int           *width,
+               int           *height,
+               guchar       **pixdata,
+               int           *mini_width,
+               int           *mini_height,
+               guchar       **mini_pixdata)
+{
+  Atom type;
+  int format;
+  gulong nitems;
+  gulong bytes_after;
+  int result, err;
+  guchar *data;
+  gulong *best;
+  int w, h;
+  gulong *best_mini;
+  int mini_w, mini_h;
+  gulong *data_as_long;
+
+  meta_error_trap_push_with_return (display);
+  type = None;
+  data = NULL;
+  result = XGetWindowProperty (display->xdisplay,
+			       xwindow,
+                               display->atom__NET_WM_ICON,
+			       0, G_MAXLONG,
+			       False, XA_CARDINAL, &type, &format, &nitems,
+			       &bytes_after, &data);
+  err = meta_error_trap_pop_with_return (display, TRUE);
+
+  if (err != Success ||
+      result != Success)
+    return FALSE;
+
+  if (type != XA_CARDINAL)
+    {
+      XFree (data);
+      return FALSE;
+    }
+
+  data_as_long = (gulong *)data;
+
+  if (!find_best_size (data_as_long, nitems,
+                       ideal_width, ideal_height,
+                       &w, &h, &best))
+    {
+      XFree (data);
+      return FALSE;
+    }
+
+  if (!find_best_size (data_as_long, nitems,
+                       ideal_mini_width, ideal_mini_height,
+                       &mini_w, &mini_h, &best_mini))
+    {
+      XFree (data);
+      return FALSE;
+    }
+
+  *width = w;
+  *height = h;
+
+  *mini_width = mini_w;
+  *mini_height = mini_h;
+
+  argbdata_to_pixdata (best, w * h, pixdata);
+  argbdata_to_pixdata (best_mini, mini_w * mini_h, mini_pixdata);
+
+  XFree (data);
+
+  return TRUE;
+}
+
+static void
+free_pixels (guchar *pixels, gpointer data)
+{
+  g_free (pixels);
+}
+
+static void
+get_pixmap_geometry (MetaDisplay *display,
+                     Pixmap       pixmap,
+                     int         *w,
+                     int         *h,
+                     int         *d)
+{
+  Window root_ignored;
+  int x_ignored, y_ignored;
+  guint width, height;
+  guint border_width_ignored;
+  guint depth;
+
+  if (w)
+    *w = 1;
+  if (h)
+    *h = 1;
+  if (d)
+    *d = 1;
+
+  XGetGeometry (display->xdisplay,
+                pixmap, &root_ignored, &x_ignored, &y_ignored,
+                &width, &height, &border_width_ignored, &depth);
+
+  if (w)
+    *w = width;
+  if (h)
+    *h = height;
+  if (d)
+    *d = depth;
+}
+
+static GdkPixbuf*
+apply_mask (GdkPixbuf *pixbuf,
+            GdkPixbuf *mask)
+{
+  int w, h;
+  int i, j;
+  GdkPixbuf *with_alpha;
+  guchar *src;
+  guchar *dest;
+  int src_stride;
+  int dest_stride;
+
+  w = MIN (gdk_pixbuf_get_width (mask), gdk_pixbuf_get_width (pixbuf));
+  h = MIN (gdk_pixbuf_get_height (mask), gdk_pixbuf_get_height (pixbuf));
+
+  with_alpha = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
+
+  dest = gdk_pixbuf_get_pixels (with_alpha);
+  src = gdk_pixbuf_get_pixels (mask);
+
+  dest_stride = gdk_pixbuf_get_rowstride (with_alpha);
+  src_stride = gdk_pixbuf_get_rowstride (mask);
+
+  i = 0;
+  while (i < h)
+    {
+      j = 0;
+      while (j < w)
+        {
+          guchar *s = src + i * src_stride + j * 3;
+          guchar *d = dest + i * dest_stride + j * 4;
+
+          /* s[0] == s[1] == s[2], they are 255 if the bit was set, 0
+           * otherwise
+           */
+          if (s[0] == 0)
+            d[3] = 0;   /* transparent */
+          else
+            d[3] = 255; /* opaque */
+
+          ++j;
+        }
+
+      ++i;
+    }
+
+  return with_alpha;
+}
+
+static gboolean
+try_pixmap_and_mask (MetaDisplay *display,
+                     Pixmap       src_pixmap,
+                     Pixmap       src_mask,
+                     GdkPixbuf  **iconp,
+                     int          ideal_width,
+                     int          ideal_height,
+                     GdkPixbuf  **mini_iconp,
+                     int          ideal_mini_width,
+                     int          ideal_mini_height)
+{
+  GdkPixbuf *unscaled = NULL;
+  GdkPixbuf *mask = NULL;
+  int w, h;
+
+  if (src_pixmap == None)
+    return FALSE;
+
+  meta_error_trap_push (display);
+
+  get_pixmap_geometry (display, src_pixmap, &w, &h, NULL);
+
+  unscaled = meta_gdk_pixbuf_get_from_pixmap (NULL,
+                                              src_pixmap,
+                                              0, 0, 0, 0,
+                                              w, h);
+
+  if (unscaled && src_mask != None)
+    {
+      get_pixmap_geometry (display, src_mask, &w, &h, NULL);
+      mask = meta_gdk_pixbuf_get_from_pixmap (NULL,
+                                              src_mask,
+                                              0, 0, 0, 0,
+                                              w, h);
+    }
+
+  meta_error_trap_pop (display, FALSE);
+
+  if (mask)
+    {
+      GdkPixbuf *masked;
+
+      masked = apply_mask (unscaled, mask);
+      g_object_unref (G_OBJECT (unscaled));
+      unscaled = masked;
+
+      g_object_unref (G_OBJECT (mask));
+      mask = NULL;
+    }
+
+  if (unscaled)
+    {
+      *iconp =
+        gdk_pixbuf_scale_simple (unscaled,
+                                 ideal_width > 0 ? ideal_width :
+                                 gdk_pixbuf_get_width (unscaled),
+                                 ideal_height > 0 ? ideal_height :
+                                 gdk_pixbuf_get_height (unscaled),
+                                 GDK_INTERP_BILINEAR);
+      *mini_iconp =
+        gdk_pixbuf_scale_simple (unscaled,
+                                 ideal_mini_width > 0 ? ideal_mini_width :
+                                 gdk_pixbuf_get_width (unscaled),
+                                 ideal_mini_height > 0 ? ideal_mini_height :
+                                 gdk_pixbuf_get_height (unscaled),
+                                 GDK_INTERP_BILINEAR);
+
+      g_object_unref (G_OBJECT (unscaled));
+      
+      if (*iconp && *mini_iconp)
+        return TRUE;
+      else
+        {
+          if (*iconp)
+            g_object_unref (G_OBJECT (*iconp));
+          if (*mini_iconp)
+            g_object_unref (G_OBJECT (*mini_iconp));
+          return FALSE;
+        }
+    }
+  else
+    return FALSE;
+}
+
+static void
+get_kwm_win_icon (MetaDisplay *display,
+                  Window       xwindow,
+                  Pixmap      *pixmap,
+                  Pixmap      *mask)
+{
+  Atom type;
+  int format;
+  gulong nitems;
+  gulong bytes_after;
+  guchar *data;
+  Pixmap *icons;
+  int err, result;
+
+  *pixmap = None;
+  *mask = None;
+
+  meta_error_trap_push_with_return (display);
+  icons = NULL;
+  result = XGetWindowProperty (display->xdisplay, xwindow,
+                               display->atom__KWM_WIN_ICON,
+			       0, G_MAXLONG,
+			       False,
+                               display->atom__KWM_WIN_ICON,
+			       &type, &format, &nitems,
+			       &bytes_after, &data);
+  icons = (Pixmap *)data;
+
+  err = meta_error_trap_pop_with_return (display, TRUE);
+  if (err != Success ||
+      result != Success)
+    return;
+
+  if (type != display->atom__KWM_WIN_ICON)
+    {
+      XFree (icons);
+      return;
+    }
+
+  *pixmap = icons[0];
+  *mask = icons[1];
+
+  XFree (icons);
+
+  return;
+}
+
+void
+meta_icon_cache_init (MetaIconCache *icon_cache)
+{
+  g_return_if_fail (icon_cache != NULL);
+
+  icon_cache->origin = USING_NO_ICON;
+  icon_cache->prev_pixmap = None;
+  icon_cache->prev_mask = None;
+#if 0
+  icon_cache->icon = NULL;
+  icon_cache->mini_icon = NULL;
+  icon_cache->ideal_width = -1; /* won't be a legit width */
+  icon_cache->ideal_height = -1;
+  icon_cache->ideal_mini_width = -1;
+  icon_cache->ideal_mini_height = -1;
+#endif
+  icon_cache->want_fallback = TRUE;
+  icon_cache->wm_hints_dirty = TRUE;
+  icon_cache->kwm_win_icon_dirty = TRUE;
+  icon_cache->net_wm_icon_dirty = TRUE;
+}
+
+static void
+clear_icon_cache (MetaIconCache *icon_cache,
+                  gboolean       dirty_all)
+{
+#if 0
+  if (icon_cache->icon)
+    g_object_unref (G_OBJECT (icon_cache->icon));
+  icon_cache->icon = NULL;
+
+  if (icon_cache->mini_icon)
+    g_object_unref (G_OBJECT (icon_cache->mini_icon));
+  icon_cache->mini_icon = NULL;
+#endif
+  
+  icon_cache->origin = USING_NO_ICON;
+
+  if (dirty_all)
+    {
+      icon_cache->wm_hints_dirty = TRUE;
+      icon_cache->kwm_win_icon_dirty = TRUE;
+      icon_cache->net_wm_icon_dirty = TRUE;
+    }
+}
+
+void
+meta_icon_cache_free (MetaIconCache *icon_cache)
+{
+  clear_icon_cache (icon_cache, FALSE);
+}
+
+void
+meta_icon_cache_property_changed (MetaIconCache *icon_cache,
+                                  MetaDisplay   *display,
+                                  Atom           atom)
+{
+  if (atom == display->atom__NET_WM_ICON)
+    icon_cache->net_wm_icon_dirty = TRUE;
+  else if (atom == display->atom__KWM_WIN_ICON)
+    icon_cache->kwm_win_icon_dirty = TRUE;
+  else if (atom == XA_WM_HINTS)
+    icon_cache->wm_hints_dirty = TRUE;
+}
+
+gboolean
+meta_icon_cache_get_icon_invalidated (MetaIconCache *icon_cache)
+{
+  if (icon_cache->origin <= USING_KWM_WIN_ICON &&
+      icon_cache->kwm_win_icon_dirty)
+    return TRUE;
+  else if (icon_cache->origin <= USING_WM_HINTS &&
+           icon_cache->wm_hints_dirty)
+    return TRUE;
+  else if (icon_cache->origin <= USING_NET_WM_ICON &&
+           icon_cache->net_wm_icon_dirty)
+    return TRUE;
+  else if (icon_cache->origin < USING_FALLBACK_ICON &&
+           icon_cache->want_fallback)
+    return TRUE;
+  else if (icon_cache->origin == USING_NO_ICON)
+    return TRUE;
+  else if (icon_cache->origin == USING_FALLBACK_ICON &&
+           !icon_cache->want_fallback)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+static void
+replace_cache (MetaIconCache *icon_cache,
+               IconOrigin     origin,
+               GdkPixbuf     *new_icon,
+               GdkPixbuf     *new_mini_icon)
+{
+  clear_icon_cache (icon_cache, FALSE);
+
+  icon_cache->origin = origin;
+
+#if 0
+  if (new_icon)
+    g_object_ref (G_OBJECT (new_icon));
+
+  icon_cache->icon = new_icon;
+
+  if (new_mini_icon)
+    g_object_ref (G_OBJECT (new_mini_icon));
+
+  icon_cache->mini_icon = new_mini_icon;
+#endif
+}
+
+static GdkPixbuf*
+scaled_from_pixdata (guchar *pixdata,
+                     int     w,
+                     int     h,
+                     int     new_w,
+                     int     new_h)
+{
+  GdkPixbuf *src;
+  GdkPixbuf *dest;
+  
+  src = gdk_pixbuf_new_from_data (pixdata,
+                                  GDK_COLORSPACE_RGB,
+                                  TRUE,
+                                  8,
+                                  w, h, w * 4,
+                                  free_pixels, 
+                                  NULL);
+
+  if (src == NULL)
+    return NULL;
+
+  if (w != h)
+    {
+      GdkPixbuf *tmp;
+      int size;
+
+      size = MAX (w, h);
+      
+      tmp = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, size, size);
+
+      if (tmp)
+	{
+	  gdk_pixbuf_fill (tmp, 0);
+	  gdk_pixbuf_copy_area (src, 0, 0, w, h,
+				tmp,
+				(size - w) / 2, (size - h) / 2);
+	  
+	  g_object_unref (src);
+	  src = tmp;
+	}
+    }
+  
+  if (w != new_w || h != new_h)
+    {
+      dest = gdk_pixbuf_scale_simple (src, new_w, new_h, GDK_INTERP_BILINEAR);
+      
+      g_object_unref (G_OBJECT (src));
+    }
+  else
+    {
+      dest = src;
+    }
+
+  return dest;
+}
+
+gboolean
+meta_read_icons (MetaScreen     *screen,
+                 Window          xwindow,
+                 MetaIconCache  *icon_cache,
+                 Pixmap          wm_hints_pixmap,
+                 Pixmap          wm_hints_mask,
+                 GdkPixbuf     **iconp,
+                 int             ideal_width,
+                 int             ideal_height,
+                 GdkPixbuf     **mini_iconp,
+                 int             ideal_mini_width,
+                 int             ideal_mini_height)
+{
+  guchar *pixdata;
+  int w, h;
+  guchar *mini_pixdata;
+  int mini_w, mini_h;
+  Pixmap pixmap;
+  Pixmap mask;
+
+  /* Return value is whether the icon changed */
+
+  g_return_val_if_fail (icon_cache != NULL, FALSE);
+
+  *iconp = NULL;
+  *mini_iconp = NULL;
+
+#if 0
+  if (ideal_width != icon_cache->ideal_width ||
+      ideal_height != icon_cache->ideal_height ||
+      ideal_mini_width != icon_cache->ideal_mini_width ||
+      ideal_mini_height != icon_cache->ideal_mini_height)
+    clear_icon_cache (icon_cache, TRUE);
+
+  icon_cache->ideal_width = ideal_width;
+  icon_cache->ideal_height = ideal_height;
+  icon_cache->ideal_mini_width = ideal_mini_width;
+  icon_cache->ideal_mini_height = ideal_mini_height;
+#endif
+  
+  if (!meta_icon_cache_get_icon_invalidated (icon_cache))
+    return FALSE; /* we have no new info to use */
+
+  pixdata = NULL;
+
+  /* Our algorithm here assumes that we can't have for example origin
+   * < USING_NET_WM_ICON and icon_cache->net_wm_icon_dirty == FALSE
+   * unless we have tried to read NET_WM_ICON.
+   *
+   * Put another way, if an icon origin is not dirty, then we have
+   * tried to read it at the current size. If it is dirty, then
+   * we haven't done that since the last change.
+   */
+
+  if (icon_cache->origin <= USING_NET_WM_ICON &&
+      icon_cache->net_wm_icon_dirty)
+
+    {
+      icon_cache->net_wm_icon_dirty = FALSE;
+
+      if (read_rgb_icon (screen->display, xwindow,
+                         ideal_width, ideal_height,
+                         ideal_mini_width, ideal_mini_height,
+                         &w, &h, &pixdata,
+                         &mini_w, &mini_h, &mini_pixdata))
+        {
+          *iconp = scaled_from_pixdata (pixdata, w, h,
+                                        ideal_width, ideal_height);
+
+          *mini_iconp = scaled_from_pixdata (mini_pixdata, mini_w, mini_h,
+                                             ideal_mini_width, ideal_mini_height);
+
+          if (*iconp && *mini_iconp)
+            {
+              replace_cache (icon_cache, USING_NET_WM_ICON,
+                             *iconp, *mini_iconp);
+              
+              return TRUE;
+            }
+          else
+            {
+              if (*iconp)
+                g_object_unref (G_OBJECT (*iconp));
+              if (*mini_iconp)
+                g_object_unref (G_OBJECT (*mini_iconp));
+            }
+        }
+    }
+
+  if (icon_cache->origin <= USING_WM_HINTS &&
+      icon_cache->wm_hints_dirty)
+    {
+      icon_cache->wm_hints_dirty = FALSE;
+
+      pixmap = wm_hints_pixmap;
+      mask = wm_hints_mask;
+
+      /* We won't update if pixmap is unchanged;
+       * avoids a get_from_drawable() on every geometry
+       * hints change
+       */
+      if ((pixmap != icon_cache->prev_pixmap ||
+           mask != icon_cache->prev_mask) &&
+          pixmap != None)
+        {
+          if (try_pixmap_and_mask (screen->display,
+                                   pixmap, mask,
+                                   iconp, ideal_width, ideal_height,
+                                   mini_iconp, ideal_mini_width, ideal_mini_height))
+            {
+              icon_cache->prev_pixmap = pixmap;
+              icon_cache->prev_mask = mask;
+
+              replace_cache (icon_cache, USING_WM_HINTS,
+                             *iconp, *mini_iconp);
+
+              return TRUE;
+            }
+        }
+    }
+
+  if (icon_cache->origin <= USING_KWM_WIN_ICON &&
+      icon_cache->kwm_win_icon_dirty)
+    {
+      icon_cache->kwm_win_icon_dirty = FALSE;
+
+      get_kwm_win_icon (screen->display, xwindow, &pixmap, &mask);
+
+      if ((pixmap != icon_cache->prev_pixmap ||
+           mask != icon_cache->prev_mask) &&
+          pixmap != None)
+        {
+          if (try_pixmap_and_mask (screen->display, pixmap, mask,
+                                   iconp, ideal_width, ideal_height,
+                                   mini_iconp, ideal_mini_width, ideal_mini_height))
+            {
+              icon_cache->prev_pixmap = pixmap;
+              icon_cache->prev_mask = mask;
+
+              replace_cache (icon_cache, USING_KWM_WIN_ICON,
+                             *iconp, *mini_iconp);
+
+              return TRUE;
+            }
+        }
+    }
+
+  if (icon_cache->want_fallback &&
+      icon_cache->origin < USING_FALLBACK_ICON)
+    {
+      get_fallback_icons (screen,
+                          iconp,
+                          ideal_width,
+                          ideal_height,
+                          mini_iconp,
+                          ideal_mini_width,
+                          ideal_mini_height);
+
+      replace_cache (icon_cache, USING_FALLBACK_ICON,
+                     *iconp, *mini_iconp);
+      
+      return TRUE;
+    }
+
+  if (!icon_cache->want_fallback &&
+      icon_cache->origin == USING_FALLBACK_ICON)
+    {
+      /* Get rid of current icon */
+      clear_icon_cache (icon_cache, FALSE);
+
+      return TRUE;
+    }
+
+  /* found nothing new */
+  return FALSE;
+}
diff --git a/src/core/iconcache.h b/src/core/iconcache.h
new file mode 100644
index 00000000..85ea9c66
--- /dev/null
+++ b/src/core/iconcache.h
@@ -0,0 +1,79 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window icons */
+
+/* 
+ * Copyright (C) 2002 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_ICON_CACHE_H
+#define META_ICON_CACHE_H
+
+#include "screen-private.h"
+
+typedef struct _MetaIconCache MetaIconCache;
+
+typedef enum
+{
+  /* These MUST be in ascending order of preference;
+   * i.e. if we get _NET_WM_ICON and already have
+   * WM_HINTS, we prefer _NET_WM_ICON
+   */
+  USING_NO_ICON,
+  USING_FALLBACK_ICON,
+  USING_KWM_WIN_ICON,
+  USING_WM_HINTS,
+  USING_NET_WM_ICON
+} IconOrigin;
+
+struct _MetaIconCache
+{
+  int origin;
+  Pixmap prev_pixmap;
+  Pixmap prev_mask;
+  guint want_fallback : 1;
+  /* TRUE if these props have changed */
+  guint wm_hints_dirty : 1;
+  guint kwm_win_icon_dirty : 1;
+  guint net_wm_icon_dirty : 1;
+};
+
+void           meta_icon_cache_init                 (MetaIconCache *icon_cache);
+void           meta_icon_cache_free                 (MetaIconCache *icon_cache);
+void           meta_icon_cache_property_changed     (MetaIconCache *icon_cache,
+                                                     MetaDisplay   *display,
+                                                     Atom           atom);
+gboolean       meta_icon_cache_get_icon_invalidated (MetaIconCache *icon_cache);
+
+gboolean meta_read_icons         (MetaScreen     *screen,
+                                  Window          xwindow,
+                                  MetaIconCache  *icon_cache,
+                                  Pixmap          wm_hints_pixmap,
+                                  Pixmap          wm_hints_mask,
+                                  GdkPixbuf     **iconp,
+                                  int             ideal_width,
+                                  int             ideal_height,
+                                  GdkPixbuf     **mini_iconp,
+                                  int             ideal_mini_width,
+                                  int             ideal_mini_height);
+
+#endif
+
+
+
+
diff --git a/src/core/keybindings.c b/src/core/keybindings.c
new file mode 100644
index 00000000..b9371c85
--- /dev/null
+++ b/src/core/keybindings.c
@@ -0,0 +1,3352 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco Keybindings */ 
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _SVID_SOURCE /* for putenv() */
+
+#include <config.h>
+#include "keybindings.h"
+#include "workspace.h"
+#include "errors.h"
+#include "edge-resistance.h"
+#include "ui.h"
+#include "frame-private.h"
+#include "place.h"
+#include "prefs.h"
+#include "effects.h"
+#include "util.h"
+
+#include <X11/keysym.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef HAVE_XKB
+#include <X11/XKBlib.h>
+#endif
+
+static gboolean all_bindings_disabled = FALSE;
+
+typedef void (* MetaKeyHandlerFunc) (MetaDisplay    *display,
+                                     MetaScreen     *screen,
+                                     MetaWindow     *window,
+                                     XEvent         *event,
+                                     MetaKeyBinding *binding);
+
+/* Prototypes for handlers */
+#define keybind(name, handler, param, flags, stroke, description) \
+static void \
+handler (MetaDisplay    *display,\
+         MetaScreen     *screen,\
+         MetaWindow     *window,\
+         XEvent         *event,\
+         MetaKeyBinding *binding);
+#include "all-keybindings.h"
+#undef keybind
+
+/* These can't be bound to anything, but they are used to handle
+ * various other events.  TODO: Possibly we should include them as event
+ * handler functions and have some kind of flag to say they're unbindable.
+ */
+
+static void handle_workspace_switch  (MetaDisplay    *display,
+                                      MetaScreen     *screen,
+                                      MetaWindow     *window,
+                                      XEvent         *event,
+                                      MetaKeyBinding *binding);
+
+static gboolean process_mouse_move_resize_grab (MetaDisplay *display,
+                                                MetaScreen  *screen,
+                                                MetaWindow  *window,
+                                                XEvent      *event,
+                                                KeySym       keysym);
+
+static gboolean process_keyboard_move_grab (MetaDisplay *display,
+                                            MetaScreen  *screen,
+                                            MetaWindow  *window,
+                                            XEvent      *event,
+                                            KeySym       keysym);
+
+static gboolean process_keyboard_resize_grab (MetaDisplay *display,
+                                              MetaScreen  *screen,
+                                              MetaWindow  *window,
+                                              XEvent      *event,
+                                              KeySym       keysym);
+
+static gboolean process_tab_grab           (MetaDisplay *display,
+                                            MetaScreen  *screen,
+                                            XEvent      *event,
+                                            KeySym       keysym);
+
+static gboolean process_workspace_switch_grab (MetaDisplay *display,
+                                               MetaScreen  *screen,
+                                               XEvent      *event,
+                                               KeySym       keysym);
+
+static void regrab_key_bindings         (MetaDisplay *display);
+
+typedef struct
+{
+  const char *name;
+  MetaKeyHandlerFunc func;
+  gint data, flags;
+} MetaKeyHandler;
+
+struct _MetaKeyBinding
+{
+  const char *name;
+  KeySym keysym;
+  KeyCode keycode;
+  unsigned int mask;
+  MetaVirtualModifier modifiers;
+  const MetaKeyHandler *handler;
+};
+
+#define keybind(name, handler, param, flags, stroke, description) \
+   { #name, handler, param, flags },
+static const MetaKeyHandler key_handlers[] = {
+#include "all-keybindings.h"
+   { NULL, NULL, 0, 0 }
+};
+#undef keybind
+
+static void
+reload_keymap (MetaDisplay *display)
+{
+  if (display->keymap)
+    meta_XFree (display->keymap);
+
+  display->keymap = XGetKeyboardMapping (display->xdisplay,
+                                         display->min_keycode,
+                                         display->max_keycode -
+                                         display->min_keycode + 1,
+                                         &display->keysyms_per_keycode);  
+}
+
+static void
+reload_modmap (MetaDisplay *display)
+{
+  XModifierKeymap *modmap;
+  int map_size;
+  int i;
+  
+  if (display->modmap)
+    XFreeModifiermap (display->modmap);
+
+  modmap = XGetModifierMapping (display->xdisplay);
+  display->modmap = modmap;
+
+  display->ignored_modifier_mask = 0;
+
+  /* Multiple bits may get set in each of these */
+  display->num_lock_mask = 0;
+  display->scroll_lock_mask = 0;
+  display->meta_mask = 0;
+  display->hyper_mask = 0;
+  display->super_mask = 0;
+  
+  /* there are 8 modifiers, and the first 3 are shift, shift lock,
+   * and control
+   */
+  map_size = 8 * modmap->max_keypermod;
+  i = 3 * modmap->max_keypermod;
+  while (i < map_size)
+    {
+      /* get the key code at this point in the map,
+       * see if its keysym is one we're interested in
+       */
+      int keycode = modmap->modifiermap[i];
+      
+      if (keycode >= display->min_keycode &&
+          keycode <= display->max_keycode)
+        {
+          int j = 0;
+          KeySym *syms = display->keymap +
+            (keycode - display->min_keycode) * display->keysyms_per_keycode;
+
+          while (j < display->keysyms_per_keycode)
+            {
+              if (syms[j] != 0)
+                {
+                  const char *str;
+                  
+                  str = XKeysymToString (syms[j]);
+                  meta_topic (META_DEBUG_KEYBINDINGS,
+                              "Keysym %s bound to modifier 0x%x\n",
+                              str ? str : "none",
+                              (1 << ( i / modmap->max_keypermod)));
+                }
+              
+              if (syms[j] == XK_Num_Lock)
+                {
+                  /* Mod1Mask is 1 << 3 for example, i.e. the
+                   * fourth modifier, i / keyspermod is the modifier
+                   * index
+                   */
+                  
+                  display->num_lock_mask |= (1 << ( i / modmap->max_keypermod));
+                }
+              else if (syms[j] == XK_Scroll_Lock)
+                {
+                  display->scroll_lock_mask |= (1 << ( i / modmap->max_keypermod));
+                }
+              else if (syms[j] == XK_Super_L ||
+                       syms[j] == XK_Super_R)
+                {
+                  display->super_mask |= (1 << ( i / modmap->max_keypermod));
+                }
+              else if (syms[j] == XK_Hyper_L ||
+                       syms[j] == XK_Hyper_R)
+                {
+                  display->hyper_mask |= (1 << ( i / modmap->max_keypermod));
+                }              
+              else if (syms[j] == XK_Meta_L ||
+                       syms[j] == XK_Meta_R)
+                {
+                  display->meta_mask |= (1 << ( i / modmap->max_keypermod));
+                }
+              
+              ++j;
+            }
+        }
+      
+      ++i;
+    }
+
+  display->ignored_modifier_mask = (display->num_lock_mask |
+                                    display->scroll_lock_mask |
+                                    LockMask);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Ignoring modmask 0x%x num lock 0x%x scroll lock 0x%x hyper 0x%x super 0x%x meta 0x%x\n",
+              display->ignored_modifier_mask,
+              display->num_lock_mask,
+              display->scroll_lock_mask,
+              display->hyper_mask,
+              display->super_mask,
+              display->meta_mask);
+}
+
+static void
+reload_keycodes (MetaDisplay *display)
+{
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Reloading keycodes for binding tables\n");
+
+  if (display->key_bindings)
+    {
+      int i;
+      
+      i = 0;
+      while (i < display->n_key_bindings)
+        {
+          if (display->key_bindings[i].keycode == 0)
+              display->key_bindings[i].keycode = XKeysymToKeycode (
+                      display->xdisplay, display->key_bindings[i].keysym);
+          
+          ++i;
+        }
+    }
+}
+
+static void
+reload_modifiers (MetaDisplay *display)
+{
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Reloading keycodes for binding tables\n");
+  
+  if (display->key_bindings)
+    {
+      int i;
+      
+      i = 0;
+      while (i < display->n_key_bindings)
+        {
+          meta_display_devirtualize_modifiers (display,
+                                               display->key_bindings[i].modifiers,
+                                               &display->key_bindings[i].mask);
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      " Devirtualized mods 0x%x -> 0x%x (%s)\n",
+                      display->key_bindings[i].modifiers,
+                      display->key_bindings[i].mask,
+                      display->key_bindings[i].name);          
+          
+          ++i;
+        }
+    }
+}
+
+
+static int
+count_bindings (const MetaKeyPref *prefs,
+                int                n_prefs)
+{
+  int i;
+  int count;
+
+  count = 0;
+  i = 0;
+  while (i < n_prefs)
+    {
+      GSList *tmp = prefs[i].bindings;
+
+      while (tmp)
+        {
+          MetaKeyCombo *combo = tmp->data;
+
+          if (combo && (combo->keysym != None || combo->keycode != 0))
+            {
+              count += 1;
+
+              if (prefs[i].add_shift &&
+                  (combo->modifiers & META_VIRTUAL_SHIFT_MASK) == 0)
+                count += 1;
+            }
+
+          tmp = tmp->next;
+        }
+      
+      ++i;
+    }
+
+  return count;
+}
+
+/* FIXME: replace this with a temporary hash */
+static const MetaKeyHandler*
+find_handler (const MetaKeyHandler *handlers,
+              const char           *name)
+{
+  const MetaKeyHandler *iter;
+
+  iter = handlers;
+  while (iter->name)
+    {
+      if (strcmp (iter->name, name) == 0)
+        return iter;
+
+      ++iter;
+    }
+
+  return NULL;
+}
+
+static void
+rebuild_binding_table (MetaDisplay        *display,
+                       MetaKeyBinding    **bindings_p,
+                       int                *n_bindings_p,
+                       const MetaKeyPref  *prefs,
+                       int                 n_prefs)
+{
+  int n_bindings;
+  int src, dest;
+  
+  n_bindings = count_bindings (prefs, n_prefs);
+  g_free (*bindings_p);
+  *bindings_p = g_new0 (MetaKeyBinding, n_bindings);
+
+  src = 0;
+  dest = 0;
+  while (src < n_prefs)
+    {
+      GSList *tmp = prefs[src].bindings;
+
+      while (tmp)
+        {
+          MetaKeyCombo *combo = tmp->data;
+
+          if (combo && (combo->keysym != None || combo->keycode != 0))
+            {
+              const MetaKeyHandler *handler = find_handler (key_handlers, prefs[src].name);
+
+              (*bindings_p)[dest].name = prefs[src].name;
+              (*bindings_p)[dest].handler = handler;
+              (*bindings_p)[dest].keysym = combo->keysym;
+              (*bindings_p)[dest].keycode = combo->keycode;
+              (*bindings_p)[dest].modifiers = combo->modifiers;
+              (*bindings_p)[dest].mask = 0;
+          
+              ++dest;
+
+              if (prefs[src].add_shift &&
+                  (combo->modifiers & META_VIRTUAL_SHIFT_MASK) == 0)
+                {
+                  meta_topic (META_DEBUG_KEYBINDINGS,
+                              "Binding %s also needs Shift grabbed\n",
+                               prefs[src].name);
+              
+                  (*bindings_p)[dest].name = prefs[src].name;
+                  (*bindings_p)[dest].handler = handler;
+                  (*bindings_p)[dest].keysym = combo->keysym;
+                  (*bindings_p)[dest].keycode = combo->keycode;
+                  (*bindings_p)[dest].modifiers = combo->modifiers |
+                    META_VIRTUAL_SHIFT_MASK;
+                  (*bindings_p)[dest].mask = 0;
+              
+                  ++dest;
+                }
+            }
+            
+          tmp = tmp->next;
+        }
+      
+      ++src;
+    }
+
+  g_assert (dest == n_bindings);
+  
+  *n_bindings_p = dest;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              " %d bindings in table\n",
+              *n_bindings_p);
+}
+
+static void
+rebuild_key_binding_table (MetaDisplay *display)
+{
+  const MetaKeyPref *prefs;
+  int n_prefs;
+  
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Rebuilding key binding table from preferences\n");
+  
+  meta_prefs_get_key_bindings (&prefs, &n_prefs);
+  rebuild_binding_table (display,
+                         &display->key_bindings,
+                         &display->n_key_bindings,
+                         prefs, n_prefs);
+}
+
+static void
+regrab_key_bindings (MetaDisplay *display)
+{
+  GSList *tmp;
+  GSList *windows;
+
+  meta_error_trap_push (display); /* for efficiency push outer trap */
+  
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *screen = tmp->data;
+
+      meta_screen_ungrab_keys (screen);
+      meta_screen_grab_keys (screen);
+
+      tmp = tmp->next;
+    }
+
+  windows = meta_display_list_windows (display);
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+      
+      meta_window_ungrab_keys (w);
+      meta_window_grab_keys (w);
+      
+      tmp = tmp->next;
+    }
+  meta_error_trap_pop (display, FALSE);
+
+  g_slist_free (windows);
+}
+
+static MetaKeyBindingAction
+display_get_keybinding_action (MetaDisplay  *display,
+                               unsigned int  keysym,
+                               unsigned int  keycode,
+                               unsigned long mask)
+{
+  int i;
+
+  i = display->n_key_bindings - 1;
+  while (i >= 0)
+    {
+      if (display->key_bindings[i].keysym == keysym &&
+          display->key_bindings[i].keycode == keycode &&
+          display->key_bindings[i].mask == mask)
+        {
+          return meta_prefs_get_keybinding_action (display->key_bindings[i].name);
+        }
+      
+      --i;
+    }
+
+  return META_KEYBINDING_ACTION_NONE;
+}
+
+void
+meta_display_process_mapping_event (MetaDisplay *display,
+                                    XEvent      *event)
+{ 
+  if (event->xmapping.request == MappingModifier)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Received MappingModifier event, will reload modmap and redo keybindings\n");
+
+      reload_modmap (display);
+
+      reload_modifiers (display);
+      
+      regrab_key_bindings (display);
+    }
+  else if (event->xmapping.request == MappingKeyboard)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Received MappingKeyboard event, will reload keycodes and redo keybindings\n");
+
+      reload_keymap (display);
+      reload_modmap (display);
+      
+      reload_keycodes (display);
+
+      regrab_key_bindings (display);
+    }
+}
+
+static void
+bindings_changed_callback (MetaPreference pref,
+                           void          *data)
+{
+  MetaDisplay *display;
+
+  display = data;
+  
+  switch (pref)
+    {
+    case META_PREF_KEYBINDINGS:
+      rebuild_key_binding_table (display);
+      reload_keycodes (display);
+      reload_modifiers (display);
+      regrab_key_bindings (display);
+      break;
+    default:
+      break;
+    }
+}
+
+
+void
+meta_display_init_keys (MetaDisplay *display)
+{
+  /* Keybindings */
+  display->keymap = NULL;
+  display->keysyms_per_keycode = 0;
+  display->modmap = NULL;
+  display->min_keycode = 0;
+  display->max_keycode = 0;
+  display->ignored_modifier_mask = 0;
+  display->num_lock_mask = 0;
+  display->scroll_lock_mask = 0;
+  display->hyper_mask = 0;
+  display->super_mask = 0;
+  display->meta_mask = 0;
+  display->key_bindings = NULL;
+  display->n_key_bindings = 0;
+
+  XDisplayKeycodes (display->xdisplay,
+                    &display->min_keycode,
+                    &display->max_keycode);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Display has keycode range %d to %d\n",
+              display->min_keycode,
+              display->max_keycode);
+
+  reload_keymap (display);
+  reload_modmap (display);
+
+  rebuild_key_binding_table (display);
+
+  reload_keycodes (display);
+  reload_modifiers (display);
+  
+  /* Keys are actually grabbed in meta_screen_grab_keys() */
+  
+  meta_prefs_add_listener (bindings_changed_callback, display);
+}
+
+void
+meta_display_shutdown_keys (MetaDisplay *display)
+{
+  /* Note that display->xdisplay is invalid in this function */
+  
+  meta_prefs_remove_listener (bindings_changed_callback, display);
+
+  if (display->keymap)
+    meta_XFree (display->keymap);
+  
+  if (display->modmap)
+    XFreeModifiermap (display->modmap);
+  g_free (display->key_bindings);
+}
+
+static const char*
+keysym_name (int keysym)
+{
+  const char *name;
+  
+  name = XKeysymToString (keysym);
+  if (name == NULL)
+    name = "(unknown)";
+
+  return name;
+}
+
+/* Grab/ungrab, ignoring all annoying modifiers like NumLock etc. */
+static void
+meta_change_keygrab (MetaDisplay *display,
+                     Window       xwindow,
+                     gboolean     grab,
+                     int          keysym,
+                     unsigned int keycode,
+                     int          modmask)
+{
+  unsigned int ignored_mask;
+
+  /* Grab keycode/modmask, together with
+   * all combinations of ignored modifiers.
+   * X provides no better way to do this.
+   */
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "%s keybinding %s keycode %d mask 0x%x on 0x%lx\n",
+              grab ? "Grabbing" : "Ungrabbing",
+              keysym_name (keysym), keycode,
+              modmask, xwindow);
+
+  /* efficiency, avoid so many XSync() */
+  meta_error_trap_push (display);
+  
+  ignored_mask = 0;
+  while (ignored_mask <= display->ignored_modifier_mask)
+    {
+      if (ignored_mask & ~(display->ignored_modifier_mask))
+        {
+          /* Not a combination of ignored modifiers
+           * (it contains some non-ignored modifiers)
+           */
+          ++ignored_mask;
+          continue;
+        }
+
+      if (meta_is_debugging ())
+        meta_error_trap_push_with_return (display);
+      if (grab)
+        XGrabKey (display->xdisplay, keycode,
+                  modmask | ignored_mask,
+                  xwindow,
+                  True,
+                  GrabModeAsync, GrabModeSync);
+      else
+        XUngrabKey (display->xdisplay, keycode,
+                    modmask | ignored_mask,
+                    xwindow);
+
+      if (meta_is_debugging ())
+        {
+          int result;
+          
+          result = meta_error_trap_pop_with_return (display, FALSE);
+          
+          if (grab && result != Success)
+            {      
+              if (result == BadAccess)
+                meta_warning (_("Some other program is already using the key %s with modifiers %x as a binding\n"), keysym_name (keysym), modmask | ignored_mask);
+              else
+                meta_topic (META_DEBUG_KEYBINDINGS,
+                            "Failed to grab key %s with modifiers %x\n",
+                            keysym_name (keysym), modmask | ignored_mask);
+            }
+        }
+
+      ++ignored_mask;
+    }
+
+  meta_error_trap_pop (display, FALSE);
+}
+
+static void
+meta_grab_key (MetaDisplay *display,
+               Window       xwindow,
+               int          keysym,
+               unsigned int keycode,
+               int          modmask)
+{
+  meta_change_keygrab (display, xwindow, TRUE, keysym, keycode, modmask);
+}
+
+static void
+grab_keys (MetaKeyBinding *bindings,
+           int             n_bindings,
+           MetaDisplay    *display,
+           Window          xwindow,
+           gboolean        binding_per_window)
+{
+  int i;
+
+  g_assert (n_bindings == 0 || bindings != NULL);
+
+  meta_error_trap_push (display);
+  
+  i = 0;
+  while (i < n_bindings)
+    {
+      if (!!binding_per_window ==
+          !!(bindings[i].handler->flags & BINDING_PER_WINDOW) &&
+          bindings[i].keycode != 0)
+        {
+          meta_grab_key (display, xwindow,
+                         bindings[i].keysym,
+                         bindings[i].keycode,
+                         bindings[i].mask);
+        }
+      
+      ++i;
+    }
+
+  meta_error_trap_pop (display, FALSE);
+}
+
+static void
+ungrab_all_keys (MetaDisplay *display,
+                 Window       xwindow)
+{
+  if (meta_is_debugging ())
+    meta_error_trap_push_with_return (display);
+  else
+    meta_error_trap_push (display);
+
+  XUngrabKey (display->xdisplay, AnyKey, AnyModifier,
+              xwindow);
+
+  if (meta_is_debugging ())
+    {
+      int result;
+      
+      result = meta_error_trap_pop_with_return (display, FALSE);
+      
+      if (result != Success)    
+        meta_topic (META_DEBUG_KEYBINDINGS,
+                    "Ungrabbing all keys on 0x%lx failed\n", xwindow);
+    }
+  else
+    meta_error_trap_pop (display, FALSE);
+}
+
+void
+meta_screen_grab_keys (MetaScreen *screen)
+{
+  if (screen->all_keys_grabbed)
+    return;
+
+  if (screen->keys_grabbed)
+    return;
+
+  grab_keys (screen->display->key_bindings,
+             screen->display->n_key_bindings,
+             screen->display, screen->xroot,
+             FALSE);
+
+  screen->keys_grabbed = TRUE;
+}
+
+void
+meta_screen_ungrab_keys (MetaScreen  *screen)
+{
+  if (screen->keys_grabbed)
+    {
+      ungrab_all_keys (screen->display, screen->xroot);
+      screen->keys_grabbed = FALSE;
+    }
+}
+
+void
+meta_window_grab_keys (MetaWindow  *window)
+{
+  if (window->all_keys_grabbed)
+    return;
+
+  if (window->type == META_WINDOW_DOCK)
+    {
+      if (window->keys_grabbed)
+        ungrab_all_keys (window->display, window->xwindow);
+      window->keys_grabbed = FALSE;
+      return;
+    }
+  
+  if (window->keys_grabbed)
+    {
+      if (window->frame && !window->grab_on_frame)
+        ungrab_all_keys (window->display, window->xwindow);
+      else if (window->frame == NULL &&
+               window->grab_on_frame)
+        ; /* continue to regrab on client window */
+      else
+        return; /* already all good */
+    }
+  
+  grab_keys (window->display->key_bindings,
+             window->display->n_key_bindings,
+             window->display,
+             window->frame ? window->frame->xwindow : window->xwindow,
+             TRUE);
+
+  window->keys_grabbed = TRUE;
+  window->grab_on_frame = window->frame != NULL;
+}
+
+void
+meta_window_ungrab_keys (MetaWindow  *window)
+{
+  if (window->keys_grabbed)
+    {
+      if (window->grab_on_frame &&
+          window->frame != NULL)
+        ungrab_all_keys (window->display,
+                         window->frame->xwindow);
+      else if (!window->grab_on_frame)
+        ungrab_all_keys (window->display,
+                         window->xwindow);
+
+      window->keys_grabbed = FALSE;
+    }
+}
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+grab_status_to_string (int status)
+{
+  switch (status)
+    {
+    case AlreadyGrabbed:
+      return "AlreadyGrabbed";
+    case GrabSuccess:
+      return "GrabSuccess";
+    case GrabNotViewable:
+      return "GrabNotViewable";
+    case GrabFrozen:
+      return "GrabFrozen";
+    case GrabInvalidTime:
+      return "GrabInvalidTime";
+    default:
+      return "(unknown)";
+    }
+}
+#endif /* WITH_VERBOSE_MODE */
+
+static gboolean
+grab_keyboard (MetaDisplay *display,
+               Window       xwindow,
+               guint32      timestamp)
+{
+  int result;
+  int grab_status;
+  
+  /* Grab the keyboard, so we get key releases and all key
+   * presses
+   */
+  meta_error_trap_push_with_return (display);
+
+  grab_status = XGrabKeyboard (display->xdisplay,
+                               xwindow, True,
+                               GrabModeAsync, GrabModeAsync,
+                               timestamp);
+  
+  if (grab_status != GrabSuccess)
+    {
+      meta_error_trap_pop_with_return (display, TRUE);
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "XGrabKeyboard() returned failure status %s time %u\n",
+                  grab_status_to_string (grab_status),
+                  timestamp);
+      return FALSE;
+    }
+  else
+    {
+      result = meta_error_trap_pop_with_return (display, TRUE);
+      if (result != Success)
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "XGrabKeyboard() resulted in an error\n");
+          return FALSE;
+        }
+    }
+       
+  meta_topic (META_DEBUG_KEYBINDINGS, "Grabbed all keys\n");
+       
+  return TRUE;
+}
+
+static void
+ungrab_keyboard (MetaDisplay *display, guint32 timestamp)
+{
+  meta_error_trap_push (display);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Ungrabbing keyboard with timestamp %u\n",
+              timestamp);
+  XUngrabKeyboard (display->xdisplay, timestamp);
+  meta_error_trap_pop (display, FALSE);
+}
+
+gboolean
+meta_screen_grab_all_keys (MetaScreen *screen, guint32 timestamp)
+{
+  gboolean retval;
+
+  if (screen->all_keys_grabbed)
+    return FALSE;
+  
+  if (screen->keys_grabbed)
+    meta_screen_ungrab_keys (screen);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Grabbing all keys on RootWindow\n");
+  retval = grab_keyboard (screen->display, screen->xroot, timestamp);
+  if (retval)
+    screen->all_keys_grabbed = TRUE;
+  else
+    meta_screen_grab_keys (screen);
+
+  return retval;
+}
+
+void
+meta_screen_ungrab_all_keys (MetaScreen *screen, guint32 timestamp)
+{
+  if (screen->all_keys_grabbed)
+    {
+      ungrab_keyboard (screen->display, timestamp);
+
+      screen->all_keys_grabbed = FALSE;
+      screen->keys_grabbed = FALSE;
+
+      /* Re-establish our standard bindings */
+      meta_screen_grab_keys (screen);
+    }
+}
+
+gboolean
+meta_window_grab_all_keys (MetaWindow  *window,
+                           guint32      timestamp)
+{
+  Window grabwindow;
+  gboolean retval;
+  
+  if (window->all_keys_grabbed)
+    return FALSE;
+  
+  if (window->keys_grabbed)
+    meta_window_ungrab_keys (window);
+
+  /* Make sure the window is focused, otherwise the grab
+   * won't do a lot of good.
+   */
+  meta_topic (META_DEBUG_FOCUS,
+              "Focusing %s because we're grabbing all its keys\n",
+              window->desc);
+  meta_window_focus (window, timestamp);
+  
+  grabwindow = window->frame ? window->frame->xwindow : window->xwindow;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Grabbing all keys on window %s\n", window->desc);
+  retval = grab_keyboard (window->display, grabwindow, timestamp);
+  if (retval)
+    {
+      window->keys_grabbed = FALSE;
+      window->all_keys_grabbed = TRUE;
+      window->grab_on_frame = window->frame != NULL;
+    }
+
+  return retval;
+}
+
+void
+meta_window_ungrab_all_keys (MetaWindow *window, guint32 timestamp)
+{
+  if (window->all_keys_grabbed)
+    {
+      ungrab_keyboard (window->display, timestamp);
+
+      window->grab_on_frame = FALSE;
+      window->all_keys_grabbed = FALSE;
+      window->keys_grabbed = FALSE;
+
+      /* Re-establish our standard bindings */
+      meta_window_grab_keys (window);
+    }
+}
+
+static gboolean 
+is_modifier (MetaDisplay *display,
+             unsigned int keycode)
+{
+  int i;
+  int map_size;
+  gboolean retval = FALSE;  
+
+  g_assert (display->modmap);
+  
+  map_size = 8 * display->modmap->max_keypermod;
+  i = 0;
+  while (i < map_size)
+    {
+      if (keycode == display->modmap->modifiermap[i])
+        {
+          retval = TRUE;
+          break;
+        }
+      ++i;
+    }
+  
+  return retval;
+}
+
+/* Indexes:
+ * shift = 0
+ * lock = 1
+ * control = 2
+ * mod1 = 3
+ * mod2 = 4
+ * mod3 = 5
+ * mod4 = 6
+ * mod5 = 7
+ */
+
+static gboolean 
+is_specific_modifier (MetaDisplay *display,
+                      unsigned int keycode,
+                      unsigned int mask)
+{
+  int i;
+  int end;
+  gboolean retval = FALSE;
+  int mod_index;
+  
+  g_assert (display->modmap);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Checking whether code 0x%x is bound to modifier 0x%x\n",
+              keycode, mask);
+  
+  mod_index = 0;
+  mask = mask >> 1;
+  while (mask != 0)
+    {
+      mod_index += 1;
+      mask = mask >> 1;
+    }
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Modifier has index %d\n", mod_index);
+  
+  end = (mod_index + 1) * display->modmap->max_keypermod;
+  i = mod_index * display->modmap->max_keypermod;
+  while (i < end)
+    {
+      if (keycode == display->modmap->modifiermap[i])
+        {
+          retval = TRUE;
+          break;
+        }
+      ++i;
+    }
+  
+  return retval;
+}
+
+static unsigned int
+get_primary_modifier (MetaDisplay *display,
+                      unsigned int entire_binding_mask)
+{
+  /* The idea here is to see if the "main" modifier
+   * for Alt+Tab has been pressed/released. So if the binding
+   * is Alt+Shift+Tab then releasing Alt is the thing that
+   * ends the operation. It's pretty random how we order
+   * these.
+   */
+  unsigned int masks[] = { Mod5Mask, Mod4Mask, Mod3Mask,
+                           Mod2Mask, Mod1Mask, ControlMask,
+                           ShiftMask, LockMask };
+
+  int i;
+  
+  i = 0;
+  while (i < (int) G_N_ELEMENTS (masks))
+    {
+      if (entire_binding_mask & masks[i])
+        return masks[i];
+      ++i;
+    }
+
+  return 0;
+}
+
+static gboolean
+keycode_is_primary_modifier (MetaDisplay *display,
+                             unsigned int keycode,
+                             unsigned int entire_binding_mask)
+{
+  unsigned int primary_modifier;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Checking whether code 0x%x is the primary modifier of mask 0x%x\n",
+              keycode, entire_binding_mask);
+  
+  primary_modifier = get_primary_modifier (display, entire_binding_mask);
+  if (primary_modifier != 0)
+    return is_specific_modifier (display, keycode, primary_modifier);
+  else
+    return FALSE;
+}
+
+static gboolean
+primary_modifier_still_pressed (MetaDisplay *display,
+                                unsigned int entire_binding_mask)
+{
+  unsigned int primary_modifier;
+  int x, y, root_x, root_y;
+  Window root, child;
+  guint mask;
+  MetaScreen *random_screen;
+  Window      random_xwindow;
+  
+  primary_modifier = get_primary_modifier (display, entire_binding_mask);
+  
+  random_screen = display->screens->data;
+  random_xwindow = random_screen->no_focus_window;
+  XQueryPointer (display->xdisplay,
+                 random_xwindow, /* some random window */
+                 &root, &child,
+                 &root_x, &root_y,
+                 &x, &y,
+                 &mask);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Primary modifier 0x%x full grab mask 0x%x current state 0x%x\n",
+              primary_modifier, entire_binding_mask, mask);
+  
+  if ((mask & primary_modifier) == 0)
+    return FALSE;
+  else
+    return TRUE;
+}
+
+/* now called from only one place, may be worth merging */
+static gboolean
+process_event (MetaKeyBinding       *bindings,
+               int                   n_bindings,
+               MetaDisplay          *display,
+               MetaScreen           *screen,
+               MetaWindow           *window,
+               XEvent               *event,
+               KeySym                keysym,
+               gboolean              on_window)
+{
+  int i;
+
+  /* we used to have release-based bindings but no longer. */
+  if (event->type == KeyRelease)
+    return FALSE;
+
+  /*
+   * TODO: This would be better done with a hash table;
+   * it doesn't suit to use O(n) for such a common operation.
+   */
+  for (i=0; i<n_bindings; i++)
+    {
+      const MetaKeyHandler *handler = bindings[i].handler;
+
+      if ((!on_window && handler->flags & BINDING_PER_WINDOW) ||
+          event->type != KeyPress ||
+          bindings[i].keycode != event->xkey.keycode ||
+          ((event->xkey.state & 0xff & ~(display->ignored_modifier_mask)) !=
+           bindings[i].mask))
+        continue;
+        
+      /*
+       * window must be non-NULL for on_window to be true,
+       * and so also window must be non-NULL if we get here and
+       * this is a BINDING_PER_WINDOW binding.
+       */
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Binding keycode 0x%x mask 0x%x matches event 0x%x state 0x%x\n",
+                  bindings[i].keycode, bindings[i].mask,
+                  event->xkey.keycode, event->xkey.state);
+
+      if (handler == NULL)
+        meta_bug ("Binding %s has no handler\n", bindings[i].name);
+      else
+        meta_topic (META_DEBUG_KEYBINDINGS,
+                    "Running handler for %s\n",
+                    bindings[i].name);
+          
+      /* Global keybindings count as a let-the-terminal-lose-focus
+       * due to new window mapping until the user starts
+       * interacting with the terminal again.
+       */
+      display->allow_terminal_deactivation = TRUE;
+
+      (* handler->func) (display, screen,
+                         bindings[i].handler->flags & BINDING_PER_WINDOW? window: NULL,
+                         event,
+                         &bindings[i]);
+      return TRUE;
+    }
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "No handler found for this event in this binding table\n");
+  return FALSE;
+}
+
+/* Handle a key event. May be called recursively: some key events cause
+ * grabs to be ended and then need to be processed again in their own
+ * right. This cannot cause infinite recursion because we never call
+ * ourselves when there wasn't a grab, and we always clear the grab
+ * first; the invariant is enforced using an assertion. See #112560.
+ * FIXME: We need to prove there are no race conditions here.
+ * FIXME: Does it correctly handle alt-Tab being followed by another
+ * grabbing keypress without letting go of alt?
+ * FIXME: An iterative solution would probably be simpler to understand
+ * (and help us solve the other fixmes).
+ */
+void
+meta_display_process_key_event (MetaDisplay *display,
+                                MetaWindow  *window,
+                                XEvent      *event)
+{
+  KeySym keysym;
+  gboolean keep_grab;
+  gboolean all_keys_grabbed;
+  const char *str;
+  MetaScreen *screen;
+
+  XAllowEvents (display->xdisplay,
+                all_bindings_disabled ? ReplayKeyboard : AsyncKeyboard,
+                event->xkey.time);
+  if (all_bindings_disabled)
+    return;
+  
+  /* if key event was on root window, we have a shortcut */
+  screen = meta_display_screen_for_root (display, event->xkey.window);
+  
+  /* else round-trip to server */
+  if (screen == NULL)
+    screen = meta_display_screen_for_xwindow (display,
+                                              event->xany.window);
+
+  if (screen == NULL)
+    return; /* event window is destroyed */
+  
+  /* ignore key events on popup menus and such. */
+  if (window == NULL &&
+      meta_ui_window_is_widget (screen->ui, event->xany.window))
+    return;
+  
+  /* window may be NULL */
+  
+  keysym = XKeycodeToKeysym (display->xdisplay, event->xkey.keycode, 0);
+
+  str = XKeysymToString (keysym);
+  
+  /* was topic */
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Processing key %s event, keysym: %s state: 0x%x window: %s\n",
+              event->type == KeyPress ? "press" : "release",
+              str ? str : "none", event->xkey.state,
+              window ? window->desc : "(no window)");
+
+  keep_grab = TRUE;
+  all_keys_grabbed = window ? window->all_keys_grabbed : screen->all_keys_grabbed;
+  if (all_keys_grabbed)
+    {
+      if (display->grab_op == META_GRAB_OP_NONE)
+        return;
+      /* If we get here we have a global grab, because
+        * we're in some special keyboard mode such as window move
+        * mode.
+        */
+      if (window ? (window == display->grab_window) :
+          (screen == display->grab_screen))
+        {
+          switch (display->grab_op)
+            {
+            case META_GRAB_OP_MOVING:
+            case META_GRAB_OP_RESIZING_SE:
+            case META_GRAB_OP_RESIZING_S:      
+            case META_GRAB_OP_RESIZING_SW:      
+            case META_GRAB_OP_RESIZING_N:
+            case META_GRAB_OP_RESIZING_NE:
+            case META_GRAB_OP_RESIZING_NW:
+            case META_GRAB_OP_RESIZING_W:
+            case META_GRAB_OP_RESIZING_E:
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for mouse-only move/resize\n");
+              g_assert (window != NULL);
+              keep_grab = process_mouse_move_resize_grab (display, screen,
+                                                          window, event, keysym);
+              break;
+ 
+            case META_GRAB_OP_KEYBOARD_MOVING:
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for keyboard move\n");
+              g_assert (window != NULL);
+              keep_grab = process_keyboard_move_grab (display, screen,
+                                                      window, event, keysym);
+              break;
+              
+            case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+            case META_GRAB_OP_KEYBOARD_RESIZING_S:
+            case META_GRAB_OP_KEYBOARD_RESIZING_N:
+            case META_GRAB_OP_KEYBOARD_RESIZING_W:
+            case META_GRAB_OP_KEYBOARD_RESIZING_E:
+            case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+            case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+            case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+            case META_GRAB_OP_KEYBOARD_RESIZING_NW:          
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for keyboard resize\n");
+              g_assert (window != NULL);
+              keep_grab = process_keyboard_resize_grab (display, screen,
+                                                        window, event, keysym);
+              break;
+ 
+            case META_GRAB_OP_KEYBOARD_TABBING_NORMAL:
+            case META_GRAB_OP_KEYBOARD_TABBING_DOCK:
+            case META_GRAB_OP_KEYBOARD_TABBING_GROUP:
+            case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL:
+            case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
+            case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for keyboard tabbing/cycling\n");
+              keep_grab = process_tab_grab (display, screen, event, keysym);
+              break;
+              
+            case META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING:
+              meta_topic (META_DEBUG_KEYBINDINGS,
+                          "Processing event for keyboard workspace switching\n");
+              keep_grab = process_workspace_switch_grab (display, screen, event, keysym);
+              break;
+ 
+            default:
+              break;
+            }
+        }
+      if (!keep_grab)
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Ending grab op %u on key event sym %s\n",
+                      display->grab_op, XKeysymToString (keysym));
+          meta_display_end_grab_op (display, event->xkey.time);
+          return;
+        }
+      }
+  /* Do the normal keybindings */
+  process_event (display->key_bindings,
+                 display->n_key_bindings,
+                 display, screen, window, event, keysym,
+                 !all_keys_grabbed && window);
+}
+
+static gboolean
+process_mouse_move_resize_grab (MetaDisplay *display,
+                                MetaScreen  *screen,
+                                MetaWindow  *window,
+                                XEvent      *event,
+                                KeySym       keysym)
+{
+  /* don't care about releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  if (keysym == XK_Escape)
+    {
+      /* End move or resize and restore to original state.  If the
+       * window was a maximized window that had been "shaken loose" we
+       * need to remaximize it.  In normal cases, we need to do a
+       * moveresize now to get the position back to the original.  In
+       * wireframe mode, we just need to set grab_was_cancelled to tru
+       * to avoid avoid moveresizing to the position of the wireframe.
+       */
+      if (window->shaken_loose)
+        meta_window_maximize (window,
+                              META_MAXIMIZE_HORIZONTAL |
+                              META_MAXIMIZE_VERTICAL);
+      else if (!display->grab_wireframe_active)
+        meta_window_move_resize (display->grab_window,
+                                 TRUE,
+                                 display->grab_initial_window_pos.x,
+                                 display->grab_initial_window_pos.y,
+                                 display->grab_initial_window_pos.width,
+                                 display->grab_initial_window_pos.height);
+      else
+        display->grab_was_cancelled = TRUE;
+
+      /* End grab */
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+process_keyboard_move_grab (MetaDisplay *display,
+                            MetaScreen  *screen,
+                            MetaWindow  *window,
+                            XEvent      *event,
+                            KeySym       keysym)
+{
+  gboolean handled;
+  int x, y;
+  int incr;
+  gboolean smart_snap;
+  
+  handled = FALSE;
+
+  /* don't care about releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  /* don't end grab on modifier key presses */
+  if (is_modifier (display, event->xkey.keycode))
+    return TRUE;
+
+  if (display->grab_wireframe_active)
+    {
+      x = display->grab_wireframe_rect.x;
+      y = display->grab_wireframe_rect.y;
+    }
+  else
+    {
+      meta_window_get_position (window, &x, &y);
+    }
+
+  smart_snap = (event->xkey.state & ShiftMask) != 0;
+  
+#define SMALL_INCREMENT 1
+#define NORMAL_INCREMENT 10
+
+  if (smart_snap)
+    incr = 1;
+  else if (event->xkey.state & ControlMask)
+    incr = SMALL_INCREMENT;
+  else
+    incr = NORMAL_INCREMENT;
+
+  if (keysym == XK_Escape)
+    {
+      /* End move and restore to original state.  If the window was a
+       * maximized window that had been "shaken loose" we need to
+       * remaximize it.  In normal cases, we need to do a moveresize
+       * now to get the position back to the original.  In wireframe
+       * mode, we just need to set grab_was_cancelled to tru to avoid
+       * avoid moveresizing to the position of the wireframe.
+       */
+      if (window->shaken_loose)
+        meta_window_maximize (window,
+                              META_MAXIMIZE_HORIZONTAL |
+                              META_MAXIMIZE_VERTICAL);
+      else if (!display->grab_wireframe_active)
+        meta_window_move_resize (display->grab_window,
+                                 TRUE,
+                                 display->grab_initial_window_pos.x,
+                                 display->grab_initial_window_pos.y,
+                                 display->grab_initial_window_pos.width,
+                                 display->grab_initial_window_pos.height);
+      else
+        display->grab_was_cancelled = TRUE;
+    }
+  
+  /* When moving by increments, we still snap to edges if the move
+   * to the edge is smaller than the increment. This is because
+   * Shift + arrow to snap is sort of a hidden feature. This way
+   * people using just arrows shouldn't get too frustrated.
+   */
+  switch (keysym)
+    {
+    case XK_KP_Home:
+    case XK_KP_Prior:
+    case XK_Up:
+    case XK_KP_Up:
+      y -= incr;
+      handled = TRUE;
+      break;
+    case XK_KP_End:
+    case XK_KP_Next:
+    case XK_Down:
+    case XK_KP_Down:
+      y += incr;
+      handled = TRUE;
+      break;
+    }
+  
+  switch (keysym)
+    {
+    case XK_KP_Home:
+    case XK_KP_End:
+    case XK_Left:
+    case XK_KP_Left:
+      x -= incr;
+      handled = TRUE;
+      break;
+    case XK_KP_Prior:
+    case XK_KP_Next:
+    case XK_Right:
+    case XK_KP_Right:
+      x += incr;
+      handled = TRUE;
+      break;
+    }
+
+  if (handled)
+    {
+      MetaRectangle old_rect;
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Computed new window location %d,%d due to keypress\n",
+                  x, y);
+
+      if (display->grab_wireframe_active)
+        old_rect = display->grab_wireframe_rect;
+      else
+        meta_window_get_client_root_coords (window, &old_rect);
+
+      meta_window_edge_resistance_for_move (window, 
+                                            old_rect.x,
+                                            old_rect.y,
+                                            &x,
+                                            &y,
+                                            NULL,
+                                            smart_snap,
+                                            TRUE);
+
+      if (display->grab_wireframe_active)
+        {
+          meta_window_update_wireframe (window, x, y,
+                                        display->grab_wireframe_rect.width,
+                                        display->grab_wireframe_rect.height);
+        }
+      else
+        {
+          meta_window_move (window, TRUE, x, y);
+        }
+      
+      meta_window_update_keyboard_move (window);
+    }
+
+  return handled;
+}
+
+static gboolean
+process_keyboard_resize_grab_op_change (MetaDisplay *display,
+                                        MetaScreen  *screen,
+                                        MetaWindow  *window,
+                                        XEvent      *event,
+                                        KeySym       keysym)
+{
+  gboolean handled;
+
+  handled = FALSE;
+  switch (display->grab_op)
+    {
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+      switch (keysym)
+        {
+        case XK_Up:
+        case XK_KP_Up:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N;          
+          handled = TRUE;
+          break;
+        case XK_Down:
+        case XK_KP_Down:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
+          handled = TRUE;
+          break;
+        case XK_Left:
+        case XK_KP_Left:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
+          handled = TRUE;
+          break;
+        case XK_Right:
+        case XK_KP_Right:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
+          handled = TRUE;
+          break;
+        }
+      break;
+      
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+      switch (keysym)
+        {
+        case XK_Left:
+        case XK_KP_Left:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
+          handled = TRUE;
+          break;
+        case XK_Right:
+        case XK_KP_Right:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
+          handled = TRUE;
+          break;
+        }
+      break;
+
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+      switch (keysym)
+        {
+        case XK_Left:
+        case XK_KP_Left:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
+          handled = TRUE;
+          break;
+        case XK_Right:
+        case XK_KP_Right:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
+          handled = TRUE;
+          break;
+        }
+      break;
+      
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+      switch (keysym)
+        {
+        case XK_Up:
+        case XK_KP_Up:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N;          
+          handled = TRUE;
+          break;
+        case XK_Down:
+        case XK_KP_Down:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
+          handled = TRUE;
+          break;
+        }
+      break;
+
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+      switch (keysym)
+        {
+        case XK_Up:
+        case XK_KP_Up:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N; 
+          handled = TRUE;
+          break;
+        case XK_Down:
+        case XK_KP_Down:
+          display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
+          handled = TRUE;
+          break;
+        }
+      break;
+      
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  if (handled)
+    {
+      meta_window_update_keyboard_resize (window, TRUE);
+      return TRUE; 
+    }
+
+  return FALSE;
+}
+
+static gboolean
+process_keyboard_resize_grab (MetaDisplay *display,
+                              MetaScreen  *screen,
+                              MetaWindow  *window,
+                              XEvent      *event,
+                              KeySym       keysym)
+{
+  gboolean handled;
+  int height_inc;
+  int width_inc;
+  int width, height;
+  gboolean smart_snap;
+  int gravity;
+  
+  handled = FALSE;
+
+  /* don't care about releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  /* don't end grab on modifier key presses */
+  if (is_modifier (display, event->xkey.keycode))
+    return TRUE;
+
+  if (keysym == XK_Escape)
+    {
+      /* End resize and restore to original state.  If not in
+       * wireframe mode, we need to do a moveresize now to get the
+       * position back to the original.  If we are in wireframe mode,
+       * we need to avoid moveresizing to the position of the
+       * wireframe.
+       */
+      if (!display->grab_wireframe_active)
+        meta_window_move_resize (display->grab_window,
+                                 TRUE,
+                                 display->grab_initial_window_pos.x,
+                                 display->grab_initial_window_pos.y,
+                                 display->grab_initial_window_pos.width,
+                                 display->grab_initial_window_pos.height);
+      else
+        display->grab_was_cancelled = TRUE;
+
+      return FALSE;
+    }
+
+  if (process_keyboard_resize_grab_op_change (display, screen, window, 
+                                              event, keysym))
+    return TRUE;
+
+  if (display->grab_wireframe_active)
+    {
+      width = display->grab_wireframe_rect.width;
+      height = display->grab_wireframe_rect.height;
+    }
+  else
+    {
+      width = window->rect.width;
+      height = window->rect.height;
+    }
+
+  gravity = meta_resize_gravity_from_grab_op (display->grab_op);
+
+  smart_snap = (event->xkey.state & ShiftMask) != 0;
+  
+#define SMALL_INCREMENT 1
+#define NORMAL_INCREMENT 10
+
+  if (smart_snap)
+    {
+      height_inc = 1;
+      width_inc = 1;
+    }
+  else if (event->xkey.state & ControlMask)
+    {
+      width_inc = SMALL_INCREMENT;
+      height_inc = SMALL_INCREMENT;
+    }  
+  else
+    {
+      width_inc = NORMAL_INCREMENT;
+      height_inc = NORMAL_INCREMENT;
+    }
+
+  /* If this is a resize increment window, make the amount we resize
+   * the window by match that amount (well, unless snap resizing...)
+   */
+  if (window->size_hints.width_inc > 1)
+    width_inc = window->size_hints.width_inc;
+  if (window->size_hints.height_inc > 1)
+    height_inc = window->size_hints.height_inc;
+  
+  switch (keysym)
+    {
+    case XK_Up:
+    case XK_KP_Up:
+      switch (gravity)
+        {
+        case NorthGravity:
+        case NorthWestGravity:
+        case NorthEastGravity:
+          /* Move bottom edge up */
+          height -= height_inc;
+          break;
+
+        case SouthGravity:
+        case SouthWestGravity:
+        case SouthEastGravity:
+          /* Move top edge up */
+          height += height_inc;
+          break;
+
+        case EastGravity:
+        case WestGravity:
+        case CenterGravity:
+          g_assert_not_reached ();
+          break;
+        }
+      
+      handled = TRUE;
+      break;
+
+    case XK_Down:
+    case XK_KP_Down:
+      switch (gravity)
+        {
+        case NorthGravity:
+        case NorthWestGravity:
+        case NorthEastGravity:
+          /* Move bottom edge down */
+          height += height_inc;
+          break;
+
+        case SouthGravity:
+        case SouthWestGravity:
+        case SouthEastGravity:
+          /* Move top edge down */
+          height -= height_inc;
+          break;
+
+        case EastGravity:
+        case WestGravity:
+        case CenterGravity:
+          g_assert_not_reached ();
+          break;
+        }
+      
+      handled = TRUE;
+      break;
+      
+    case XK_Left:
+    case XK_KP_Left:
+      switch (gravity)
+        {
+        case EastGravity:
+        case SouthEastGravity:
+        case NorthEastGravity:
+          /* Move left edge left */
+          width += width_inc;
+          break;
+
+        case WestGravity:
+        case SouthWestGravity:
+        case NorthWestGravity:
+          /* Move right edge left */
+          width -= width_inc;
+          break;
+
+        case NorthGravity:
+        case SouthGravity:
+        case CenterGravity:
+          g_assert_not_reached ();
+          break;
+        }
+      
+      handled = TRUE;
+      break;
+      
+    case XK_Right:
+    case XK_KP_Right:
+      switch (gravity)
+        {
+        case EastGravity:
+        case SouthEastGravity:
+        case NorthEastGravity:
+          /* Move left edge right */
+          width -= width_inc;
+          break;
+
+        case WestGravity:
+        case SouthWestGravity:
+        case NorthWestGravity:
+          /* Move right edge right */
+          width += width_inc;
+          break;
+
+        case NorthGravity:
+        case SouthGravity:
+        case CenterGravity:
+          g_assert_not_reached ();
+          break;
+        }
+      
+      handled = TRUE;
+      break;
+          
+    default:
+      break;
+    }
+
+  /* fixup hack (just paranoia, not sure it's required) */
+  if (height < 1)
+    height = 1;
+  if (width < 1)
+    width = 1;
+  
+  if (handled)
+    {
+      MetaRectangle old_rect;
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Computed new window size due to keypress: "
+                  "%dx%d, gravity %s\n",
+                  width, height, meta_gravity_to_string (gravity));
+      
+      if (display->grab_wireframe_active)
+        old_rect = display->grab_wireframe_rect;
+      else
+        old_rect = window->rect;  /* Don't actually care about x,y */
+
+      /* Do any edge resistance/snapping */
+      meta_window_edge_resistance_for_resize (window,
+                                              old_rect.width,
+                                              old_rect.height,
+                                              &width,
+                                              &height,
+                                              gravity,
+                                              NULL,
+                                              smart_snap,
+                                              TRUE);
+
+      if (display->grab_wireframe_active)
+        {
+          MetaRectangle new_position;
+          meta_rectangle_resize_with_gravity (&display->grab_wireframe_rect, 
+                                              &new_position,
+                                              gravity,
+                                              width,
+                                              height);
+          meta_window_update_wireframe (window, 
+                                        new_position.x,
+                                        new_position.y,
+                                        new_position.width, 
+                                        new_position.height);
+        }
+      else
+        {
+          /* We don't need to update unless the specified width and height
+           * are actually different from what we had before.
+           */
+          if (window->rect.width != width || window->rect.height != height)
+            meta_window_resize_with_gravity (window, 
+                                             TRUE,
+                                             width,
+                                             height,
+                                             gravity);
+        }
+      meta_window_update_keyboard_resize (window, FALSE);
+    }
+
+  return handled;
+}
+
+static gboolean
+end_keyboard_grab (MetaDisplay *display,
+		   unsigned int keycode)
+{
+#ifdef HAVE_XKB
+  if (display->xkb_base_event_type > 0)
+    {
+      unsigned int primary_modifier;
+      XkbStateRec state;
+  
+      primary_modifier = get_primary_modifier (display, display->grab_mask);
+      
+      XkbGetState (display->xdisplay, XkbUseCoreKbd, &state);
+
+      if (!(primary_modifier & state.mods))
+	return TRUE;
+    }
+  else
+#endif
+    {
+      if (keycode_is_primary_modifier (display, keycode, display->grab_mask))
+	return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+process_tab_grab (MetaDisplay *display,
+                  MetaScreen  *screen,
+                  XEvent      *event,
+                  KeySym       keysym)
+{
+  MetaKeyBindingAction action;
+  gboolean popup_not_showing;
+  gboolean backward;
+  gboolean key_used;
+  Window      prev_xwindow;
+  MetaWindow *prev_window;
+
+  if (screen != display->grab_screen)
+    return FALSE;
+
+  g_return_val_if_fail (screen->tab_popup != NULL, FALSE);
+
+  if (event->type == KeyRelease &&
+      end_keyboard_grab (display, event->xkey.keycode))
+    {
+      /* We're done, move to the new window. */
+      Window target_xwindow;
+      MetaWindow *target_window;
+
+      target_xwindow =
+        (Window) meta_ui_tab_popup_get_selected (screen->tab_popup);
+      target_window =
+        meta_display_lookup_x_window (display, target_xwindow);
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Ending tab operation, primary modifier released\n");
+      
+      if (target_window)
+        {
+          target_window->tab_unminimized = FALSE;
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Activating target window\n");
+
+          meta_topic (META_DEBUG_FOCUS, "Activating %s due to tab popup "
+                      "selection and turning mouse_mode off\n",
+                      target_window->desc);
+          display->mouse_mode = FALSE;
+          meta_window_activate (target_window, event->xkey.time);
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Ending grab early so we can focus the target window\n");
+          meta_display_end_grab_op (display, event->xkey.time);
+
+          return TRUE; /* we already ended the grab */
+        }
+      
+      return FALSE; /* end grab */
+    }
+  
+  /* don't care about other releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  /* don't end grab on modifier key presses */
+  if (is_modifier (display, event->xkey.keycode))
+    return TRUE;
+
+  prev_xwindow = (Window) meta_ui_tab_popup_get_selected (screen->tab_popup);
+  prev_window  = meta_display_lookup_x_window (display, prev_xwindow);
+  action = display_get_keybinding_action (display,
+                                          keysym,
+                                          event->xkey.keycode,
+                                          display->grab_mask);
+
+  /* Cancel when alt-Escape is pressed during using alt-Tab, and vice
+   * versa.
+   */
+  switch (action)
+    {
+    case META_KEYBINDING_ACTION_CYCLE_PANELS:
+    case META_KEYBINDING_ACTION_CYCLE_WINDOWS:
+    case META_KEYBINDING_ACTION_CYCLE_PANELS_BACKWARD:
+    case META_KEYBINDING_ACTION_CYCLE_WINDOWS_BACKWARD:
+      /* CYCLE_* are traditionally Escape-based actions,
+       * and should cancel traditionally Tab-based ones.
+       */
+       switch (display->grab_op)
+        {
+        case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL:
+        case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
+         /* carry on */
+          break;
+        default:
+          return FALSE;
+        }
+       break;
+    case META_KEYBINDING_ACTION_SWITCH_PANELS:
+    case META_KEYBINDING_ACTION_SWITCH_WINDOWS:
+    case META_KEYBINDING_ACTION_SWITCH_PANELS_BACKWARD:
+    case META_KEYBINDING_ACTION_SWITCH_WINDOWS_BACKWARD:
+      /* SWITCH_* are traditionally Tab-based actions,
+       * and should cancel traditionally Escape-based ones.
+       */
+      switch (display->grab_op)
+        {
+        case META_GRAB_OP_KEYBOARD_TABBING_NORMAL:
+        case META_GRAB_OP_KEYBOARD_TABBING_DOCK:
+          /* carry on */
+          break;
+        default:
+          /* Also, we must re-lower and re-minimize whatever window
+           * we'd previously raised and unminimized.
+           */
+          meta_stack_set_positions (screen->stack,
+                                    screen->display->grab_old_window_stacking);
+          if (prev_window && prev_window->tab_unminimized)
+            {
+              meta_window_minimize (prev_window);
+              prev_window->tab_unminimized = FALSE;
+            }
+          return FALSE;
+        }
+      break;
+    case META_KEYBINDING_ACTION_CYCLE_GROUP:
+    case META_KEYBINDING_ACTION_CYCLE_GROUP_BACKWARD:
+    case META_KEYBINDING_ACTION_SWITCH_GROUP:
+    case META_KEYBINDING_ACTION_SWITCH_GROUP_BACKWARD:
+      switch (display->grab_op)
+        {
+        case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
+        case META_GRAB_OP_KEYBOARD_TABBING_GROUP:
+          /* carry on */
+             break;
+        default:
+             return FALSE;
+        }
+ 
+      break;
+    default:
+      break;
+    }
+
+  /* !! TO HERE !!
+   * alt-f6 during alt-{Tab,Escape} does not end the grab
+   * but does change the grab op (and redraws the window,
+   * of course).
+   * See _{SWITCH,CYCLE}_GROUP.@@@
+   */
+   
+  popup_not_showing = FALSE;
+  key_used = FALSE;
+  backward = FALSE;
+
+  switch (action)
+    {
+    case META_KEYBINDING_ACTION_CYCLE_PANELS:
+    case META_KEYBINDING_ACTION_CYCLE_WINDOWS:
+    case META_KEYBINDING_ACTION_CYCLE_GROUP:
+      popup_not_showing = TRUE;
+      key_used = TRUE;
+      break;
+    case META_KEYBINDING_ACTION_CYCLE_PANELS_BACKWARD:
+    case META_KEYBINDING_ACTION_CYCLE_WINDOWS_BACKWARD:
+    case META_KEYBINDING_ACTION_CYCLE_GROUP_BACKWARD:
+      popup_not_showing = TRUE;
+      key_used = TRUE;
+      backward = TRUE;
+      break;
+    case META_KEYBINDING_ACTION_SWITCH_PANELS:
+    case META_KEYBINDING_ACTION_SWITCH_WINDOWS:
+    case META_KEYBINDING_ACTION_SWITCH_GROUP:
+      key_used = TRUE;
+      break;
+    case META_KEYBINDING_ACTION_SWITCH_PANELS_BACKWARD:
+    case META_KEYBINDING_ACTION_SWITCH_WINDOWS_BACKWARD:
+    case META_KEYBINDING_ACTION_SWITCH_GROUP_BACKWARD:
+      key_used = TRUE;
+      backward = TRUE;
+      break;
+    default:
+      break;
+    }
+  
+  if (key_used)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Key pressed, moving tab focus in popup\n");
+
+      if (event->xkey.state & ShiftMask)
+        backward = !backward;
+
+      if (backward)
+        meta_ui_tab_popup_backward (screen->tab_popup);
+      else
+        meta_ui_tab_popup_forward (screen->tab_popup);
+      
+      if (popup_not_showing)
+        {
+          /* We can't actually change window focus, due to the grab.
+           * but raise the window.
+           */
+          Window target_xwindow;
+          MetaWindow *target_window;
+
+          meta_stack_set_positions (screen->stack,
+                                    display->grab_old_window_stacking);
+
+          target_xwindow =
+            (Window) meta_ui_tab_popup_get_selected (screen->tab_popup);
+          target_window =
+            meta_display_lookup_x_window (display, target_xwindow);
+          
+          if (prev_window && prev_window->tab_unminimized)
+            {
+              prev_window->tab_unminimized = FALSE;
+              meta_window_minimize (prev_window);
+            }
+
+          if (target_window)
+            {
+              meta_window_raise (target_window);
+              target_window->tab_unminimized = target_window->minimized;
+              meta_window_unminimize (target_window);
+            }
+        }
+    }
+  else
+    {
+      /* end grab */
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Ending tabbing/cycling, uninteresting key pressed\n");
+
+      meta_topic (META_DEBUG_KEYBINDINGS, 
+                  "Syncing to old stack positions.\n");
+      meta_stack_set_positions (screen->stack,
+                                screen->display->grab_old_window_stacking);
+
+      if (prev_window && prev_window->tab_unminimized)
+        {
+          meta_window_minimize (prev_window);
+          prev_window->tab_unminimized = FALSE;
+        }
+    }
+  
+  return key_used;
+}
+
+static void
+handle_switch_to_workspace (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *event_window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  gint which = binding->handler->data;
+  MetaWorkspace *workspace;
+  
+  if (which < 0)
+    {
+      /* Negative workspace numbers are directions with respect to the
+       * current workspace.  While we could insta-switch here by setting
+       * workspace to the result of meta_workspace_get_neighbor(), when
+       * people request a workspace switch to the left or right via
+       * the keyboard, they actually want a tab popup.  So we should
+       * go there instead.
+       *
+       * Note that we're the only caller of that function, so perhaps
+       * we should merge with it.
+       */
+      handle_workspace_switch (display, screen, event_window, event, binding);
+      return;
+    }
+
+  workspace = meta_screen_get_workspace_by_index (screen, which);
+  
+  if (workspace)
+    {
+      meta_workspace_activate (workspace, event->xkey.time);
+    }
+  else
+    {
+      /* We could offer to create it I suppose */
+    }
+}
+
+static void
+error_on_command (int         command_index,
+                  const char *command,
+                  const char *message,
+                  int         screen_number,
+                  guint32     timestamp)
+{
+  if (command_index < 0)
+    meta_warning ("Error on terminal command \"%s\": %s\n", command, message);  
+  else
+    meta_warning ("Error on command %d \"%s\": %s\n",
+                  command_index, command, message);  
+
+  /*
+    marco-dialog said:
+        
+    FIXME offer to change the value of the command's mateconf key
+  */
+
+  if (command && strcmp(command, "")!=0)
+    {
+      char *text = g_strdup_printf (
+                                    /* Displayed when a keybinding which is
+                                     * supposed to launch a program fails.
+                                     */
+                                    _("There was an error running "
+                                      "<tt>%s</tt>:\n\n%s"),
+                                    command,
+                                    message);
+
+      meta_show_dialog ("--error",
+                        text,
+                        NULL,
+                        screen_number,
+                        NULL, NULL, 0,
+                        NULL, NULL);
+
+      g_free (text);
+
+    }
+  else
+    {
+      meta_show_dialog ("--error",
+                        message,
+                        NULL,
+                        screen_number,
+                        NULL, NULL, 0,
+                        NULL, NULL);
+    }
+}
+
+static void
+set_display_setup_func (void *data)
+{
+  const char *screen_name = data;
+  char *full;
+
+  full = g_strdup_printf ("DISPLAY=%s", screen_name);
+
+  putenv (full);
+
+  /* do not free full, because putenv is lame */
+} 
+
+static gboolean
+meta_spawn_command_line_async_on_screen (const gchar *command_line,
+                                         MetaScreen  *screen,
+                                         GError     **error)
+{
+  gboolean retval;
+  gchar **argv = NULL;
+
+  g_return_val_if_fail (command_line != NULL, FALSE);
+
+  if (!g_shell_parse_argv (command_line,
+                           NULL, &argv,
+                           error))
+    return FALSE;
+  
+  retval = g_spawn_async (NULL,
+                          argv,
+                          NULL,
+                          G_SPAWN_SEARCH_PATH,
+                          set_display_setup_func,
+                          screen->screen_name,
+                          NULL,
+                          error);
+  g_strfreev (argv);
+
+  return retval;
+}
+
+
+static void
+handle_run_command (MetaDisplay    *display,
+                    MetaScreen     *screen,
+                    MetaWindow     *window,
+                    XEvent         *event,
+                    MetaKeyBinding *binding)
+{
+  gint which = binding->handler->data;
+  const char *command;
+  GError *err;
+  
+  command = meta_prefs_get_command (which);
+
+  if (command == NULL)
+    {
+      char *s;
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "No command %d to run in response to keybinding press\n",
+                  which);
+      
+      s = g_strdup_printf (_("No command %d has been defined.\n"),
+                           which + 1);
+      error_on_command (which, NULL, s, screen->number, event->xkey.time);
+      g_free (s);
+      
+      return;
+    }
+
+  err = NULL;
+  if (!meta_spawn_command_line_async_on_screen (command, screen, &err))
+    {
+      error_on_command (which, command, err->message, screen->number, event->xkey.time);
+      
+      g_error_free (err);
+    }
+}
+
+
+static void
+handle_maximize_vertically (MetaDisplay    *display,
+                      MetaScreen     *screen,
+                      MetaWindow     *window,
+                      XEvent         *event,
+                      MetaKeyBinding *binding)
+{
+  if (window->has_resize_func)
+    {
+      if (window->maximized_vertically)
+        meta_window_unmaximize (window, META_MAXIMIZE_VERTICAL);
+      else
+        meta_window_maximize (window, META_MAXIMIZE_VERTICAL);
+    }
+}
+
+static void
+handle_maximize_horizontally (MetaDisplay    *display,
+                       MetaScreen     *screen,
+                       MetaWindow     *window,
+                       XEvent         *event,
+                       MetaKeyBinding *binding)
+{
+  if (window->has_resize_func)
+    {
+      if (window->maximized_horizontally)
+        meta_window_unmaximize (window, META_MAXIMIZE_HORIZONTAL);
+      else
+        meta_window_maximize (window, META_MAXIMIZE_HORIZONTAL);
+    }
+}
+
+/* Move a window to a corner; to_bottom/to_right are FALSE for the
+ * top or left edge, or TRUE for the bottom/right edge.  xchange/ychange
+ * are FALSE if that dimension is not to be changed, TRUE otherwise.
+ * Together they describe which of the four corners, or four sides,
+ * is desired.
+ */
+static void
+handle_move_to_corner_backend (MetaDisplay    *display,
+           MetaScreen     *screen,
+           MetaWindow     *window,
+           gboolean        xchange,
+           gboolean        ychange,
+           gboolean        to_right,
+           gboolean        to_bottom)
+{
+  MetaRectangle work_area;
+  MetaRectangle outer;
+  int orig_x, orig_y;
+  int new_x, new_y;
+  int frame_width, frame_height;
+
+  meta_window_get_work_area_all_xineramas (window, &work_area);
+  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_position (window, &orig_x, &orig_y);
+
+  frame_width = (window->frame ? window->frame->child_x : 0);
+  frame_height = (window->frame ? window->frame->child_y : 0);
+
+  if (xchange) {
+    new_x = work_area.x + (to_right ?
+            (work_area.width + frame_width) - outer.width :
+            0);
+  } else {
+    new_x = orig_x;
+  }
+
+  if (ychange) {
+    new_y = work_area.y + (to_bottom ?
+            (work_area.height + frame_height) - outer.height :
+            0);
+  } else {
+    new_y = orig_y;
+  }
+
+  meta_window_move_resize (window,
+          FALSE,
+          new_x,
+          new_y,
+          window->rect.width,
+          window->rect.height);
+}
+
+static void
+handle_move_to_corner_nw  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, FALSE, FALSE);
+}
+
+static void
+handle_move_to_corner_ne  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, TRUE, FALSE);
+}
+
+static void
+handle_move_to_corner_sw  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, FALSE, TRUE);
+}
+
+static void
+handle_move_to_corner_se  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, TRUE, TRUE);
+}
+
+static void
+handle_move_to_side_n     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, FALSE, TRUE, FALSE, FALSE);
+}
+
+static void
+handle_move_to_side_s     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, FALSE, TRUE, FALSE, TRUE);
+}
+
+static void
+handle_move_to_side_e     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, FALSE, TRUE, FALSE);
+}
+
+static void
+handle_move_to_side_w     (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  handle_move_to_corner_backend (display, screen, window, TRUE, FALSE, FALSE, FALSE);
+}
+
+static void
+handle_move_to_center  (MetaDisplay    *display,
+                        MetaScreen     *screen,
+                        MetaWindow     *window,
+                        XEvent         *event,
+                        MetaKeyBinding *binding)
+{
+  MetaRectangle work_area;
+  MetaRectangle outer;
+  int orig_x, orig_y;
+  int frame_width, frame_height;
+
+  meta_window_get_work_area_all_xineramas (window, &work_area);
+  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_position (window, &orig_x, &orig_y);
+
+  frame_width = (window->frame ? window->frame->child_x : 0);
+  frame_height = (window->frame ? window->frame->child_y : 0);
+
+  meta_window_move_resize (window,
+          TRUE,
+          work_area.x + (work_area.width +frame_width -outer.width )/2,
+          work_area.y + (work_area.height+frame_height-outer.height)/2,
+          window->rect.width,
+          window->rect.height);
+}
+
+static gboolean
+process_workspace_switch_grab (MetaDisplay *display,
+                               MetaScreen  *screen,
+                               XEvent      *event,
+                               KeySym       keysym)
+{
+  MetaWorkspace *workspace;
+
+  if (screen != display->grab_screen)
+    return FALSE;
+
+  g_return_val_if_fail (screen->tab_popup != NULL, FALSE);
+
+  if (event->type == KeyRelease &&
+      end_keyboard_grab (display, event->xkey.keycode))
+    {
+      /* We're done, move to the new workspace. */
+      MetaWorkspace *target_workspace;
+
+      target_workspace =
+        (MetaWorkspace *) meta_ui_tab_popup_get_selected (screen->tab_popup);
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Ending workspace tab operation, primary modifier released\n");
+
+      if (target_workspace == screen->active_workspace)
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Ending grab so we can focus on the target workspace\n");
+          meta_display_end_grab_op (display, event->xkey.time);
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Focusing default window on target workspace\n");
+
+          meta_workspace_focus_default_window (target_workspace, 
+                                               NULL,
+                                               event->xkey.time);
+
+          return TRUE; /* we already ended the grab */
+        }
+
+      /* Workspace switching should have already occurred on KeyPress */
+      meta_warning ("target_workspace != active_workspace.  Some other event must have occurred.\n");
+      
+      return FALSE; /* end grab */
+    }
+  
+  /* don't care about other releases, but eat them, don't end grab */
+  if (event->type == KeyRelease)
+    return TRUE;
+
+  /* don't end grab on modifier key presses */
+  if (is_modifier (display, event->xkey.keycode))
+    return TRUE;
+
+  /* select the next workspace in the tabpopup */
+  workspace =
+    (MetaWorkspace *) meta_ui_tab_popup_get_selected (screen->tab_popup);
+  
+  if (workspace)
+    {
+      MetaWorkspace *target_workspace;
+      MetaKeyBindingAction action;
+
+      action = display_get_keybinding_action (display,
+                                              keysym,
+                                              event->xkey.keycode,
+                                              display->grab_mask);
+
+      switch (action)
+        {
+        case META_KEYBINDING_ACTION_WORKSPACE_UP:
+          target_workspace = meta_workspace_get_neighbor (workspace,
+                                                          META_MOTION_UP);
+          break;
+
+        case META_KEYBINDING_ACTION_WORKSPACE_DOWN:
+          target_workspace = meta_workspace_get_neighbor (workspace,
+                                                          META_MOTION_DOWN);
+          break;
+
+        case META_KEYBINDING_ACTION_WORKSPACE_LEFT:
+          target_workspace = meta_workspace_get_neighbor (workspace,
+                                                          META_MOTION_LEFT);
+          break;
+
+        case META_KEYBINDING_ACTION_WORKSPACE_RIGHT:
+          target_workspace = meta_workspace_get_neighbor (workspace,
+                                                          META_MOTION_RIGHT);
+          break;
+
+        default:
+          target_workspace = NULL;
+          break;
+        }
+
+      if (target_workspace)
+        {
+          meta_ui_tab_popup_select (screen->tab_popup,
+                                    (MetaTabEntryKey) target_workspace);
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Tab key pressed, moving tab focus in popup\n");
+
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Activating target workspace\n");
+
+          meta_workspace_activate (target_workspace, event->xkey.time);
+
+          return TRUE; /* we already ended the grab */
+        }
+    }
+
+  /* end grab */
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Ending workspace tabbing & focusing default window; uninteresting key pressed\n");
+  workspace =
+    (MetaWorkspace *) meta_ui_tab_popup_get_selected (screen->tab_popup);
+  meta_workspace_focus_default_window (workspace, NULL, event->xkey.time);
+  return FALSE;
+}
+
+static void
+handle_show_desktop (MetaDisplay    *display,
+                       MetaScreen     *screen,
+                       MetaWindow     *window,
+                       XEvent         *event,
+                       MetaKeyBinding *binding)
+{
+  if (screen->active_workspace->showing_desktop)
+    {
+      meta_screen_unshow_desktop (screen);
+      meta_workspace_focus_default_window (screen->active_workspace, 
+                                           NULL,
+                                           event->xkey.time);
+    }
+  else
+    meta_screen_show_desktop (screen, event->xkey.time);
+}
+
+static void
+handle_panel (MetaDisplay    *display,
+                         MetaScreen     *screen,
+                         MetaWindow     *window,
+                         XEvent         *event,
+                         MetaKeyBinding *binding)
+{
+  MetaKeyBindingAction action = binding->handler->data;
+  Atom action_atom;
+  XClientMessageEvent ev;
+
+  action_atom = None;
+  switch (action)
+    {
+    /* FIXME: The numbers are wrong */
+    case META_KEYBINDING_ACTION_PANEL_MAIN_MENU:
+      action_atom = display->atom__MATE_PANEL_ACTION_MAIN_MENU;
+      break;
+    case META_KEYBINDING_ACTION_PANEL_RUN_DIALOG:
+      action_atom = display->atom__MATE_PANEL_ACTION_RUN_DIALOG;
+      break;
+    default:
+      return;
+    }
+   
+  ev.type = ClientMessage;
+  ev.window = screen->xroot;
+  ev.message_type = display->atom__MATE_PANEL_ACTION;
+  ev.format = 32;
+  ev.data.l[0] = action_atom;
+  ev.data.l[1] = event->xkey.time;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Sending panel message with timestamp %lu, and turning mouse_mode "
+              "off due to keybinding press\n", event->xkey.time);
+  display->mouse_mode = FALSE;
+
+  meta_error_trap_push (display);
+
+  /* Release the grab for the panel before sending the event */
+  XUngrabKeyboard (display->xdisplay, event->xkey.time);
+
+  XSendEvent (display->xdisplay,
+	      screen->xroot,
+	      False,
+	      StructureNotifyMask,
+	      (XEvent*) &ev);
+
+  meta_error_trap_pop (display, FALSE);
+}
+
+static void
+handle_activate_window_menu (MetaDisplay    *display,
+                      MetaScreen     *screen,
+                      MetaWindow     *event_window,
+                      XEvent         *event,
+                      MetaKeyBinding *binding)
+{
+  if (display->focus_window)
+    {
+      int x, y;
+
+      meta_window_get_position (display->focus_window,
+                                &x, &y);
+      
+      if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
+	  x += display->focus_window->rect.width;
+
+      meta_window_show_menu (display->focus_window,
+                             x, y,
+                             0,
+                             event->xkey.time);
+    }
+}
+
+static MetaGrabOp
+tab_op_from_tab_type (MetaTabList type)
+{
+  switch (type)
+    {
+    case META_TAB_LIST_NORMAL:
+      return META_GRAB_OP_KEYBOARD_TABBING_NORMAL;
+    case META_TAB_LIST_DOCKS:
+      return META_GRAB_OP_KEYBOARD_TABBING_DOCK;
+    case META_TAB_LIST_GROUP:
+      return META_GRAB_OP_KEYBOARD_TABBING_GROUP;
+    }
+
+  g_assert_not_reached ();
+  
+  return 0;
+}
+
+static MetaGrabOp
+cycle_op_from_tab_type (MetaTabList type)
+{
+  switch (type)
+    {
+    case META_TAB_LIST_NORMAL:
+      return META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL;
+    case META_TAB_LIST_DOCKS:
+      return META_GRAB_OP_KEYBOARD_ESCAPING_DOCK;
+    case META_TAB_LIST_GROUP:
+      return META_GRAB_OP_KEYBOARD_ESCAPING_GROUP;
+    }
+
+  g_assert_not_reached ();
+  
+  return 0;
+}
+
+static void
+do_choose_window (MetaDisplay    *display,
+                  MetaScreen     *screen,
+                  MetaWindow     *event_window,
+                  XEvent         *event,
+                  MetaKeyBinding *binding,
+                  gboolean        backward,
+                  gboolean        show_popup)
+{
+  MetaTabList type = binding->handler->data;
+  MetaWindow *initial_selection;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Tab list = %u show_popup = %d\n", type, show_popup);
+  
+  /* reverse direction if shift is down */
+  if (event->xkey.state & ShiftMask)
+    backward = !backward;
+  
+  initial_selection = meta_display_get_tab_next (display,
+                                                 type,
+                                                 screen,
+                                                 screen->active_workspace,
+                                                 NULL,
+                                                 backward);
+
+  /* Note that focus_window may not be in the tab chain, but it's OK */
+  if (initial_selection == NULL)
+    initial_selection = meta_display_get_tab_current (display,
+                                                      type, screen,
+                                                      screen->active_workspace);
+  
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Initially selecting window %s\n",
+              initial_selection ? initial_selection->desc : "(none)");  
+
+  if (initial_selection != NULL)
+    {
+      if (binding->mask == 0)
+        {
+          /* If no modifiers, we can't do the "hold down modifier to keep
+           * moving" thing, so we just instaswitch by one window.
+           */
+          meta_topic (META_DEBUG_FOCUS,
+                      "Activating %s and turning off mouse_mode due to "
+                      "switch/cycle windows with no modifiers\n",
+                      initial_selection->desc);
+          display->mouse_mode = FALSE;
+          meta_window_activate (initial_selection, event->xkey.time);
+        }
+      else if (meta_display_begin_grab_op (display,
+                                           screen,
+                                           NULL,
+                                           show_popup ?
+                                           tab_op_from_tab_type (type) :
+                                           cycle_op_from_tab_type (type),
+                                           FALSE,
+                                           FALSE,
+                                           0,
+                                           binding->mask,
+                                           event->xkey.time,
+                                           0, 0))
+        {
+          if (!primary_modifier_still_pressed (display,
+                                               binding->mask))
+            {
+              /* This handles a race where modifier might be released
+               * before we establish the grab. must end grab
+               * prior to trying to focus a window.
+               */
+              meta_topic (META_DEBUG_FOCUS, 
+                          "Ending grab, activating %s, and turning off "
+                          "mouse_mode due to switch/cycle windows where "
+                          "modifier was released prior to grab\n",
+                          initial_selection->desc);
+              meta_display_end_grab_op (display, event->xkey.time);
+              display->mouse_mode = FALSE;
+              meta_window_activate (initial_selection, event->xkey.time);
+            }
+          else
+            {
+              meta_ui_tab_popup_select (screen->tab_popup,
+                                        (MetaTabEntryKey) initial_selection->xwindow);
+              
+              if (show_popup)
+                meta_ui_tab_popup_set_showing (screen->tab_popup,
+                                               TRUE);
+              else
+                {
+                  meta_window_raise (initial_selection);
+                  initial_selection->tab_unminimized = 
+                    initial_selection->minimized;
+                  meta_window_unminimize (initial_selection);
+                }
+            }
+        }
+    }
+}
+
+static void
+handle_switch (MetaDisplay    *display,
+                    MetaScreen     *screen,
+                    MetaWindow     *event_window,
+                    XEvent         *event,
+                    MetaKeyBinding *binding)
+{
+  gint backwards = binding->handler->flags & BINDING_IS_REVERSED;
+
+  do_choose_window (display, screen, event_window, event, binding,
+                    backwards, TRUE);
+}
+
+static void
+handle_cycle (MetaDisplay    *display,
+                    MetaScreen     *screen,
+                    MetaWindow     *event_window,
+                    XEvent         *event,
+                    MetaKeyBinding *binding)
+{
+  gint backwards = binding->handler->flags & BINDING_IS_REVERSED;
+
+  do_choose_window (display, screen, event_window, event, binding,
+                    backwards, FALSE);
+}
+
+
+static void
+handle_toggle_fullscreen  (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->fullscreen)
+    meta_window_unmake_fullscreen (window);
+  else if (window->has_fullscreen_func)
+    meta_window_make_fullscreen (window);
+}
+
+static void
+handle_toggle_above       (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->wm_state_above)
+    meta_window_unmake_above (window);
+  else
+    meta_window_make_above (window);
+}
+
+static void
+handle_toggle_maximized    (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (META_WINDOW_MAXIMIZED (window))
+    meta_window_unmaximize (window,
+                            META_MAXIMIZE_HORIZONTAL |
+                            META_MAXIMIZE_VERTICAL);
+  else if (window->has_maximize_func)
+    meta_window_maximize (window,
+                          META_MAXIMIZE_HORIZONTAL |
+                          META_MAXIMIZE_VERTICAL);
+}
+
+static void
+handle_maximize           (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->has_maximize_func)
+    meta_window_maximize (window,
+                          META_MAXIMIZE_HORIZONTAL |
+                          META_MAXIMIZE_VERTICAL);
+}
+
+static void
+handle_unmaximize         (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->maximized_vertically || window->maximized_horizontally)
+    meta_window_unmaximize (window,
+                            META_MAXIMIZE_HORIZONTAL |
+                            META_MAXIMIZE_VERTICAL);
+}
+
+static void
+handle_toggle_shaded      (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->shaded)
+    meta_window_unshade (window, event->xkey.time);
+  else if (window->has_shade_func)
+    meta_window_shade (window, event->xkey.time);
+}
+
+static void
+handle_close              (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->has_close_func)
+    meta_window_delete (window, event->xkey.time);
+}
+
+static void
+handle_minimize        (MetaDisplay    *display,
+                        MetaScreen     *screen,
+                        MetaWindow     *window,
+                        XEvent         *event,
+                        MetaKeyBinding *binding)
+{
+  if (window->has_minimize_func)
+    meta_window_minimize (window);
+}
+
+static void
+handle_begin_move         (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->has_move_func)
+    {
+      meta_window_begin_grab_op (window,
+                                 META_GRAB_OP_KEYBOARD_MOVING,
+                                 FALSE,
+                                 event->xkey.time);
+    }
+}
+
+static void
+handle_begin_resize       (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->has_resize_func)
+    {
+      meta_window_begin_grab_op (window,
+                                 META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
+                                 FALSE,
+                                 event->xkey.time);
+    }
+}
+
+static void
+handle_toggle_on_all_workspaces (MetaDisplay    *display,
+                           MetaScreen     *screen,
+                           MetaWindow     *window,
+                           XEvent         *event,
+                           MetaKeyBinding *binding)
+{
+  if (window->on_all_workspaces)
+    meta_window_unstick (window);
+  else
+    meta_window_stick (window);
+}
+
+static void
+handle_move_to_workspace  (MetaDisplay    *display,
+                              MetaScreen     *screen,
+                              MetaWindow     *window,
+                              XEvent         *event,
+                              MetaKeyBinding *binding)
+{
+  gint which = binding->handler->data;
+  gboolean flip = (which < 0);
+  MetaWorkspace *workspace;
+  
+  /* If which is zero or positive, it's a workspace number, and the window
+   * should move to the workspace with that number.
+   *
+   * However, if it's negative, it's a direction with respect to the current
+   * position; it's expressed as a member of the MetaMotionDirection enum,
+   * all of whose members are negative.  Such a change is called a flip.
+   */
+
+  if (window->always_sticky)
+    return;
+  
+  workspace = NULL;
+  if (flip)
+    {      
+      workspace = meta_workspace_get_neighbor (screen->active_workspace,
+                                               which);
+    }
+  else
+    {
+      workspace = meta_screen_get_workspace_by_index (screen, which);
+    }
+  
+  if (workspace)
+    {
+      /* Activate second, so the window is never unmapped */
+      meta_window_change_workspace (window, workspace);
+      if (flip)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Resetting mouse_mode to FALSE due to "
+                      "handle_move_to_workspace() call with flip set.\n");
+          workspace->screen->display->mouse_mode = FALSE;
+          meta_workspace_activate_with_focus (workspace,
+                                              window,
+                                              event->xkey.time);
+        }
+    }
+  else
+    {
+      /* We could offer to create it I suppose */
+    }  
+}
+
+static void 
+handle_raise_or_lower (MetaDisplay    *display,
+                       MetaScreen     *screen,
+		       MetaWindow     *window,
+		       XEvent         *event,
+		       MetaKeyBinding *binding)
+{
+  /* Get window at pointer */
+  
+  MetaWindow *above = NULL;
+      
+  /* Check if top */
+  if (meta_stack_get_top (window->screen->stack) == window)
+    {
+      meta_window_lower (window);
+      return;
+    }
+      
+  /* else check if windows in same layer are intersecting it */
+  
+  above = meta_stack_get_above (window->screen->stack, window, TRUE); 
+
+  while (above)
+    {
+      MetaRectangle tmp, win_rect, above_rect;
+      
+      if (above->mapped)
+        {
+          meta_window_get_outer_rect (window, &win_rect);
+          meta_window_get_outer_rect (above, &above_rect);
+          
+          /* Check if obscured */
+          if (meta_rectangle_intersect (&win_rect, &above_rect, &tmp))
+            {
+              meta_window_raise (window);
+              return;
+            }
+        }
+	  
+      above = meta_stack_get_above (window->screen->stack, above, TRUE); 
+    }
+
+  /* window is not obscured */
+  meta_window_lower (window);
+}
+
+static void
+handle_raise (MetaDisplay    *display,
+              MetaScreen     *screen,
+              MetaWindow     *window,
+              XEvent         *event,
+              MetaKeyBinding *binding)
+{
+  meta_window_raise (window);
+}
+
+static void
+handle_lower (MetaDisplay    *display,
+              MetaScreen     *screen,
+              MetaWindow     *window,
+              XEvent         *event,
+              MetaKeyBinding *binding)
+{
+  meta_window_lower (window);
+}
+
+static void
+handle_workspace_switch  (MetaDisplay    *display,
+                          MetaScreen     *screen,
+                          MetaWindow     *window,
+                          XEvent         *event,
+                          MetaKeyBinding *binding)
+{
+  gint motion = binding->handler->data;
+  unsigned int grab_mask;
+     
+  g_assert (motion < 0); 
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Starting tab between workspaces, showing popup\n");
+
+  /* FIXME should we use binding->mask ? */
+  grab_mask = event->xkey.state & ~(display->ignored_modifier_mask);
+  
+  if (meta_display_begin_grab_op (display,
+                                  screen,
+                                  NULL,
+                                  META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING,
+                                  FALSE,
+                                  FALSE,
+                                  0,
+                                  grab_mask,
+                                  event->xkey.time,
+                                  0, 0))
+    {
+      MetaWorkspace *next;
+      gboolean grabbed_before_release;
+      
+      next = meta_workspace_get_neighbor (screen->active_workspace, motion);
+      g_assert (next); 
+
+      grabbed_before_release = primary_modifier_still_pressed (display, grab_mask);
+      
+      meta_topic (META_DEBUG_KEYBINDINGS,
+		  "Activating target workspace\n");
+
+      if (!grabbed_before_release)
+        {
+          /* end the grab right away, modifier possibly released
+           * before we could establish the grab and receive the
+           * release event. Must end grab before we can switch
+           * spaces.
+           */
+          meta_display_end_grab_op (display, event->xkey.time);
+        }
+      
+      meta_workspace_activate (next, event->xkey.time);
+
+      if (grabbed_before_release)
+        {
+          meta_ui_tab_popup_select (screen->tab_popup, (MetaTabEntryKey) next);
+          
+          /* only after selecting proper space */
+          meta_ui_tab_popup_set_showing (screen->tab_popup, TRUE);
+        }
+    }
+}
+
+static void
+handle_set_spew_mark (MetaDisplay    *display,
+                  MetaScreen     *screen,
+                  MetaWindow     *window,
+                  XEvent         *event,
+                  MetaKeyBinding *binding)
+{
+  meta_verbose ("-- MARK MARK MARK MARK --\n");
+}
+
+void
+meta_set_keybindings_disabled (gboolean setting)
+{
+  all_bindings_disabled = setting;
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Keybindings %s\n", all_bindings_disabled ? "disabled" : "enabled");
+}
+
+static void
+handle_run_terminal (MetaDisplay    *display,
+                     MetaScreen     *screen,
+                     MetaWindow     *window,
+                     XEvent         *event,
+                     MetaKeyBinding *binding)
+{
+  const char *command;
+  GError *err;
+  
+  command = meta_prefs_get_terminal_command ();
+
+  if (command == NULL)
+    {
+      char *s;
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "No terminal command to run in response to "
+		  "keybinding press\n");
+      
+      s = g_strdup_printf (_("No terminal command has been defined.\n"));
+      error_on_command (-1, NULL, s, screen->number, event->xkey.time);
+      g_free (s);
+      
+      return;
+    }
+
+  err = NULL;
+  if (!meta_spawn_command_line_async_on_screen (command, screen, &err))
+    {
+      error_on_command (-1, command, err->message, screen->number,
+                        event->xkey.time);
+      
+      g_error_free (err);
+    }
+}
diff --git a/src/core/keybindings.h b/src/core/keybindings.h
new file mode 100644
index 00000000..618520b4
--- /dev/null
+++ b/src/core/keybindings.h
@@ -0,0 +1,60 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file keybindings.h  Grab and ungrab keys, and process the key events
+ *
+ * Performs global X grabs on the keys we need to be told about, like
+ * the one to close a window.  It also deals with incoming key events.
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_KEYBINDINGS_H
+#define META_KEYBINDINGS_H
+
+#include "display-private.h"
+#include "window.h"
+
+void     meta_display_init_keys             (MetaDisplay *display);
+void     meta_display_shutdown_keys         (MetaDisplay *display);
+void     meta_screen_grab_keys              (MetaScreen  *screen);
+void     meta_screen_ungrab_keys            (MetaScreen  *screen);
+gboolean meta_screen_grab_all_keys          (MetaScreen  *screen,
+                                             guint32      timestamp);
+void     meta_screen_ungrab_all_keys        (MetaScreen  *screen, 
+                                             guint32      timestamp);
+void     meta_window_grab_keys              (MetaWindow  *window);
+void     meta_window_ungrab_keys            (MetaWindow  *window);
+gboolean meta_window_grab_all_keys          (MetaWindow  *window,
+                                             guint32      timestamp);
+void     meta_window_ungrab_all_keys        (MetaWindow  *window,
+                                             guint32      timestamp);
+void     meta_display_process_key_event     (MetaDisplay *display,
+                                             MetaWindow  *window,
+                                             XEvent      *event);
+void     meta_set_keybindings_disabled      (gboolean     setting);
+void     meta_display_process_mapping_event (MetaDisplay *display,
+                                             XEvent      *event);
+
+#endif
+
+
+
+
diff --git a/src/core/main.c b/src/core/main.c
new file mode 100644
index 00000000..38c69b0a
--- /dev/null
+++ b/src/core/main.c
@@ -0,0 +1,673 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco main() */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/**
+ * \file 
+ * Program startup.
+ * Functions which parse the command-line arguments, create the display,
+ * kick everything off and then close down Marco when it's time to go.
+ */
+
+/**
+ * \mainpage
+ * Marco - a boring window manager for the adult in you
+ *
+ * Many window managers are like Marshmallow Froot Loops; Marco
+ * is like Cheerios.
+ *
+ * The best way to get a handle on how the whole system fits together
+ * is discussed in doc/code-overview.txt; if you're looking for functions
+ * to investigate, read main(), meta_display_open(), and event_callback().
+ */
+
+#define _GNU_SOURCE
+#define _SVID_SOURCE /* for putenv() and some signal-related functions */
+
+#include <config.h>
+#include "main.h"
+#include "util.h"
+#include "display-private.h"
+#include "errors.h"
+#include "ui.h"
+#include "session.h"
+#include "prefs.h"
+
+#include <glib-object.h>
+#include <glib/gprintf.h>
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <wait.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <locale.h>
+#include <time.h>
+#include <unistd.h>
+
+/**
+ * The exit code we'll return to our parent process when we eventually die.
+ */
+static MetaExitCode meta_exit_code = META_EXIT_SUCCESS;
+
+/**
+ * Handle on the main loop, so that we have an easy way of shutting Marco
+ * down.
+ */
+static GMainLoop *meta_main_loop = NULL;
+
+/**
+ * If set, Marco will spawn an identical copy of itself immediately
+ * before quitting.
+ */
+static gboolean meta_restart_after_quit = FALSE;
+
+static void prefs_changed_callback (MetaPreference pref,
+                                    gpointer       data);
+
+/**
+ * Prints log messages. If Marco was compiled with backtrace support,
+ * also prints a backtrace (see meta_print_backtrace()).
+ *
+ * \param log_domain  the domain the error occurred in (we ignore this)
+ * \param log_level   the log level so that we can filter out less
+ *                    important messages
+ * \param message     the message to log
+ * \param user_data   arbitrary data (we ignore this)
+ */
+static void
+log_handler (const gchar   *log_domain,
+             GLogLevelFlags log_level,
+             const gchar   *message,
+             gpointer       user_data)
+{
+  meta_warning ("Log level %d: %s\n", log_level, message);
+  meta_print_backtrace ();
+}
+
+/**
+ * Prints the version notice. This is shown when Marco is called
+ * with the --version switch.
+ */
+static void
+version (void)
+{
+  const int latest_year = 2009;
+  char yearbuffer[256];
+  GDate date;
+
+  /* this is all so the string to translate stays constant.
+   * see how much we love the translators.
+   */
+  g_date_set_dmy (&date, 1, G_DATE_JANUARY, latest_year);
+  if (g_date_strftime (yearbuffer, sizeof (yearbuffer), "%Y", &date)==0)
+    /* didn't work?  fall back to decimal representation */
+    g_sprintf (yearbuffer, "%d", latest_year);
+
+  g_print (_("marco %s\n"
+             "Copyright (C) 2001-%s Havoc Pennington, Red Hat, Inc., and others\n"
+             "This is free software; see the source for copying conditions.\n"
+             "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"),
+           VERSION, yearbuffer);
+  exit (0);
+}
+
+/**
+ * Prints a list of which configure script options were used to
+ * build this copy of Marco. This is actually always called
+ * on startup, but it's all no-op unless we're in verbose mode
+ * (see meta_set_verbose).
+ */
+static void
+meta_print_compilation_info (void)
+{
+#ifdef HAVE_SHAPE
+  meta_verbose ("Compiled with shape extension\n");
+#else
+  meta_verbose ("Compiled without shape extension\n");
+#endif
+#ifdef HAVE_XINERAMA
+  meta_topic (META_DEBUG_XINERAMA, "Compiled with Xinerama extension\n");
+#else
+  meta_topic (META_DEBUG_XINERAMA, "Compiled without Xinerama extension\n");
+#endif
+#ifdef HAVE_XFREE_XINERAMA
+  meta_topic (META_DEBUG_XINERAMA, " (using XFree86 Xinerama)\n");
+#else
+  meta_topic (META_DEBUG_XINERAMA, " (not using XFree86 Xinerama)\n");
+#endif
+#ifdef HAVE_SOLARIS_XINERAMA
+  meta_topic (META_DEBUG_XINERAMA, " (using Solaris Xinerama)\n");
+#else
+  meta_topic (META_DEBUG_XINERAMA, " (not using Solaris Xinerama)\n");
+#endif
+#ifdef HAVE_XSYNC
+  meta_verbose ("Compiled with sync extension\n");
+#else
+  meta_verbose ("Compiled without sync extension\n");
+#endif
+#ifdef HAVE_RANDR
+  meta_verbose ("Compiled with randr extension\n");
+#else
+  meta_verbose ("Compiled without randr extension\n");
+#endif
+#ifdef HAVE_STARTUP_NOTIFICATION
+  meta_verbose ("Compiled with startup notification\n");
+#else
+  meta_verbose ("Compiled without startup notification\n");
+#endif
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  meta_verbose ("Compiled with composite extensions\n");
+#else
+  meta_verbose ("Compiled without composite extensions\n");
+#endif
+}
+
+/**
+ * Prints the version number, the current timestamp (not the
+ * build date), the locale, the character encoding, and a list
+ * of configure script options that were used to build this
+ * copy of Marco. This is actually always called
+ * on startup, but it's all no-op unless we're in verbose mode
+ * (see meta_set_verbose).
+ */
+static void
+meta_print_self_identity (void)
+{
+  char buf[256];
+  GDate d;
+  const char *charset;
+
+  /* Version and current date. */
+  g_date_clear (&d, 1);
+  g_date_set_time_t (&d, time (NULL));
+  g_date_strftime (buf, sizeof (buf), "%x", &d);
+  meta_verbose ("Marco version %s running on %s\n",
+    VERSION, buf);
+  
+  /* Locale and encoding. */
+  g_get_charset (&charset);
+  meta_verbose ("Running in locale \"%s\" with encoding \"%s\"\n",
+    setlocale (LC_ALL, NULL), charset);
+
+  /* Compilation settings. */
+  meta_print_compilation_info ();
+}
+
+/**
+ * The set of possible options that can be set on Marco's
+ * command line. This type exists so that meta_parse_options() can
+ * write to an instance of it.
+ */
+typedef struct
+{
+  gchar *save_file;
+  gchar *display_name;
+  gchar *client_id;
+  gboolean replace_wm;
+  gboolean disable_sm;
+  gboolean print_version;
+  gboolean sync;
+  gboolean composite;
+  gboolean no_composite;
+  gboolean no_force_fullscreen;
+} MetaArguments;
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#define COMPOSITE_OPTS_FLAGS 0
+#else /* HAVE_COMPOSITE_EXTENSIONS */
+/* No compositor, so don't show the arguments in --help */
+#define COMPOSITE_OPTS_FLAGS G_OPTION_FLAG_HIDDEN
+#endif /* HAVE_COMPOSITE_EXTENSIONS */
+
+/**
+ * Parses argc and argv and returns the
+ * arguments that Marco understands in meta_args.
+ *
+ * The strange call signature has to be written like it is so
+ * that g_option_context_parse() gets a chance to modify argc and
+ * argv.
+ *
+ * \param argc  Pointer to the number of arguments Marco was given
+ * \param argv  Pointer to the array of arguments Marco was given
+ * \param meta_args  The result of parsing the arguments.
+ **/
+static void
+meta_parse_options (int *argc, char ***argv,
+                    MetaArguments *meta_args)
+{
+  MetaArguments my_args = {NULL, NULL, NULL,
+                           FALSE, FALSE, FALSE, FALSE, FALSE};
+  GOptionEntry options[] = {
+    {
+      "sm-disable", 0, 0, G_OPTION_ARG_NONE,
+      &my_args.disable_sm,
+      N_("Disable connection to session manager"),
+      NULL
+    },
+    {
+      "replace", 0, 0, G_OPTION_ARG_NONE,
+      &my_args.replace_wm,
+      N_("Replace the running window manager with Marco"),
+      NULL
+    },
+    {
+      "sm-client-id", 0, 0, G_OPTION_ARG_STRING,
+      &my_args.client_id,
+      N_("Specify session management ID"),
+      "ID"
+    },
+    {
+      "display", 'd', 0, G_OPTION_ARG_STRING,
+      &my_args.display_name, N_("X Display to use"),
+      "DISPLAY"
+    },
+    {
+      "sm-save-file", 0, 0, G_OPTION_ARG_FILENAME,
+      &my_args.save_file,
+      N_("Initialize session from savefile"),
+      "FILE"
+    },
+    {
+      "version", 0, 0, G_OPTION_ARG_NONE,
+      &my_args.print_version,
+      N_("Print version"),
+      NULL
+    },
+    {
+      "sync", 0, 0, G_OPTION_ARG_NONE,
+      &my_args.sync,
+      N_("Make X calls synchronous"),
+      NULL
+    },
+    {
+      "composite", 'c', COMPOSITE_OPTS_FLAGS, G_OPTION_ARG_NONE,
+      &my_args.composite,
+      N_("Turn compositing on"),
+      NULL
+    },
+    {
+      "no-composite", 0, COMPOSITE_OPTS_FLAGS, G_OPTION_ARG_NONE,
+      &my_args.no_composite,
+      N_("Turn compositing off"),
+      NULL
+    },
+    {
+      "no-force-fullscreen", 0, COMPOSITE_OPTS_FLAGS, G_OPTION_ARG_NONE,
+      &my_args.no_force_fullscreen,
+      N_("Don't make fullscreen windows that are maximized and have no decorations"),
+      NULL
+    },
+    {NULL}
+  };
+  GOptionContext *ctx;
+  GError *error = NULL;
+
+  ctx = g_option_context_new (NULL);
+  g_option_context_add_main_entries (ctx, options, "marco");
+  if (!g_option_context_parse (ctx, argc, argv, &error))
+    {
+      g_print ("marco: %s\n", error->message);
+      exit(1);
+    }
+  g_option_context_free (ctx);
+  /* Return the parsed options through the meta_args param. */
+  *meta_args = my_args;
+}
+
+/**
+ * Selects which display Marco should use. It first tries to use
+ * display_name as the display. If display_name is NULL then
+ * try to use the environment variable MARCO_DISPLAY. If that
+ * also is NULL, use the default - :0.0
+ */
+static void
+meta_select_display (gchar *display_name)
+{
+  gchar *envVar = "";
+  if (display_name)
+    envVar = g_strconcat ("DISPLAY=", display_name, NULL);
+  else if (g_getenv ("MARCO_DISPLAY"))
+    envVar = g_strconcat ("DISPLAY=",
+      g_getenv ("MARCO_DISPLAY"), NULL);
+  /* DO NOT FREE envVar, putenv() sucks */
+  putenv (envVar);
+}
+
+static void
+meta_finalize (void)
+{
+  MetaDisplay *display = meta_get_display();
+
+  meta_session_shutdown ();
+
+  if (display)
+    meta_display_close (display,
+                        CurrentTime); /* I doubt correct timestamps matter here */
+}
+
+static int sigterm_pipe_fds[2] = { -1, -1 };
+
+static void
+sigterm_handler (int signum)
+{
+  if (sigterm_pipe_fds[1] >= 0)
+    {
+      int dummy;
+
+      dummy = write (sigterm_pipe_fds[1], "", 1);
+      close (sigterm_pipe_fds[1]);
+      sigterm_pipe_fds[1] = -1;
+    }
+}
+
+static gboolean
+on_sigterm (void)
+{
+  meta_quit (META_EXIT_SUCCESS);
+  return FALSE;
+}
+
+/**
+ * This is where the story begins. It parses commandline options and
+ * environment variables, sets up the screen, hands control off to
+ * GTK, and cleans up afterwards.
+ *
+ * \param argc Number of arguments (as usual)
+ * \param argv Array of arguments (as usual)
+ *
+ * \bug It's a bit long. It would be good to split it out into separate
+ * functions.
+ */
+int
+main (int argc, char **argv)
+{
+  struct sigaction act;
+  sigset_t empty_mask;
+  MetaArguments meta_args;
+  const gchar *log_domains[] = {
+    NULL, G_LOG_DOMAIN, "Gtk", "Gdk", "GLib",
+    "Pango", "GLib-GObject", "GThread"
+  };
+  guint i;
+  GIOChannel *channel;
+
+  if (!g_thread_supported ())
+    g_thread_init (NULL);
+  
+  if (setlocale (LC_ALL, "") == NULL)
+    meta_warning ("Locale not understood by C library, internationalization will not work\n");
+
+  g_type_init ();
+  
+  sigemptyset (&empty_mask);
+  act.sa_handler = SIG_IGN;
+  act.sa_mask    = empty_mask;
+  act.sa_flags   = 0;
+  if (sigaction (SIGPIPE,  &act, NULL) < 0)
+    g_printerr ("Failed to register SIGPIPE handler: %s\n",
+                g_strerror (errno));
+#ifdef SIGXFSZ
+  if (sigaction (SIGXFSZ,  &act, NULL) < 0)
+    g_printerr ("Failed to register SIGXFSZ handler: %s\n",
+                g_strerror (errno));
+#endif
+
+  if (pipe (sigterm_pipe_fds) != 0)
+    g_printerr ("Failed to create SIGTERM pipe: %s\n",
+                g_strerror (errno));
+
+  channel = g_io_channel_unix_new (sigterm_pipe_fds[0]);
+  g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
+  g_io_add_watch (channel, G_IO_IN, (GIOFunc) on_sigterm, NULL);
+  g_io_channel_set_close_on_unref (channel, TRUE);
+  g_io_channel_unref (channel);
+
+  act.sa_handler = &sigterm_handler;
+  if (sigaction (SIGTERM, &act, NULL) < 0)
+    g_printerr ("Failed to register SIGTERM handler: %s\n",
+		g_strerror (errno));
+
+  if (g_getenv ("MARCO_VERBOSE"))
+    meta_set_verbose (TRUE);
+  if (g_getenv ("MARCO_DEBUG"))
+    meta_set_debugging (TRUE);
+
+  if (g_get_home_dir ())
+    if (chdir (g_get_home_dir ()) < 0)
+      meta_warning ("Could not change to home directory %s.\n",
+                    g_get_home_dir ());
+
+  meta_print_self_identity ();
+  
+  bindtextdomain (GETTEXT_PACKAGE, MARCO_LOCALEDIR);
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+  textdomain (GETTEXT_PACKAGE);
+
+  /* Parse command line arguments.*/
+  meta_parse_options (&argc, &argv, &meta_args);
+
+  meta_set_syncing (meta_args.sync || (g_getenv ("MARCO_SYNC") != NULL));
+
+  if (meta_args.print_version)
+    version ();
+
+  meta_select_display (meta_args.display_name);
+  
+  if (meta_args.replace_wm)
+    meta_set_replace_current_wm (TRUE);
+
+  if (meta_args.save_file && meta_args.client_id)
+    meta_fatal ("Can't specify both SM save file and SM client id\n");
+  
+  meta_main_loop = g_main_loop_new (NULL, FALSE);
+  
+  meta_ui_init (&argc, &argv);  
+
+  /* must be after UI init so we can override GDK handlers */
+  meta_errors_init ();
+
+  /* Load prefs */
+  meta_prefs_init ();
+  meta_prefs_add_listener (prefs_changed_callback, NULL);
+
+
+#if 1
+
+  for (i=0; i<G_N_ELEMENTS(log_domains); i++)
+    g_log_set_handler (log_domains[i],
+                       G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
+                       log_handler, NULL);
+
+#endif
+
+  if (g_getenv ("MARCO_G_FATAL_WARNINGS") != NULL)
+    g_log_set_always_fatal (G_LOG_LEVEL_MASK);
+  
+  meta_ui_set_current_theme (meta_prefs_get_theme (), FALSE);
+
+  /* Try to find some theme that'll work if the theme preference
+   * doesn't exist.  First try Simple (the default theme) then just
+   * try anything in the themes directory.
+   */
+  if (!meta_ui_have_a_theme ())
+    meta_ui_set_current_theme ("Simple", FALSE);
+  
+  if (!meta_ui_have_a_theme ())
+    {
+      const char *dir_entry = NULL;
+      GError *err = NULL;
+      GDir   *themes_dir = NULL;
+      
+      if (!(themes_dir = g_dir_open (MARCO_DATADIR"/themes", 0, &err)))
+        {
+          meta_fatal (_("Failed to scan themes directory: %s\n"), err->message);
+          g_error_free (err);
+        } 
+      else 
+        {
+          while (((dir_entry = g_dir_read_name (themes_dir)) != NULL) && 
+                 (!meta_ui_have_a_theme ()))
+            {
+              meta_ui_set_current_theme (dir_entry, FALSE);
+            }
+          
+          g_dir_close (themes_dir);
+        }
+    }
+  
+  if (!meta_ui_have_a_theme ())
+    meta_fatal (_("Could not find a theme! Be sure %s exists and contains the usual themes.\n"),
+                MARCO_DATADIR"/themes");
+  
+  /* Connect to SM as late as possible - but before managing display,
+   * or we might try to manage a window before we have the session
+   * info
+   */
+  if (!meta_args.disable_sm)
+    {
+      if (meta_args.client_id == NULL)
+        {
+          const gchar *desktop_autostart_id;
+  
+          desktop_autostart_id = g_getenv ("DESKTOP_AUTOSTART_ID");
+ 
+          if (desktop_autostart_id != NULL)
+            meta_args.client_id = g_strdup (desktop_autostart_id);
+        }
+
+      /* Unset DESKTOP_AUTOSTART_ID in order to avoid child processes to
+       * use the same client id. */
+      g_unsetenv ("DESKTOP_AUTOSTART_ID");
+
+      meta_session_init (meta_args.client_id, meta_args.save_file);
+    }
+  /* Free memory possibly allocated by the argument parsing which are
+   * no longer needed.
+   */
+  g_free (meta_args.save_file);
+  g_free (meta_args.display_name);
+  g_free (meta_args.client_id);
+
+  if (meta_args.composite || meta_args.no_composite)
+    meta_prefs_set_compositing_manager (meta_args.composite);
+
+  if (meta_args.no_force_fullscreen)
+    meta_prefs_set_force_fullscreen (FALSE);
+
+  if (!meta_display_open ())
+    meta_exit (META_EXIT_ERROR);
+  
+  g_main_loop_run (meta_main_loop);
+
+  meta_finalize ();
+
+  if (meta_restart_after_quit)
+    {
+      GError *err;
+
+      err = NULL;
+      if (!g_spawn_async (NULL,
+                          argv,
+                          NULL,
+                          G_SPAWN_SEARCH_PATH,
+                          NULL,
+                          NULL,
+                          NULL,
+                          &err))
+        {
+          meta_fatal (_("Failed to restart: %s\n"),
+                      err->message);
+          g_error_free (err); /* not reached anyhow */
+          meta_exit_code = META_EXIT_ERROR;
+        }
+    }
+  
+  return meta_exit_code;
+}
+
+/**
+ * Stops Marco. This tells the event loop to stop processing; it is rather
+ * dangerous to use this rather than meta_restart() because this will leave
+ * the user with no window manager. We generally do this only if, for example,
+ * the session manager asks us to; we assume the session manager knows what
+ * it's talking about.
+ *
+ * \param code The success or failure code to return to the calling process.
+ */
+void
+meta_quit (MetaExitCode code)
+{
+  meta_exit_code = code;
+
+  if (g_main_loop_is_running (meta_main_loop))
+    g_main_loop_quit (meta_main_loop);
+}
+
+/**
+ * Restarts Marco. In practice, this tells the event loop to stop
+ * processing, having first set the meta_restart_after_quit flag which
+ * tells Marco to spawn an identical copy of itself before quitting.
+ * This happens on receipt of a _MARCO_RESTART_MESSAGE client event.
+ */
+void
+meta_restart (void)
+{
+  meta_restart_after_quit = TRUE;
+  meta_quit (META_EXIT_SUCCESS);
+}
+
+/**
+ * Called on pref changes. (One of several functions of its kind and purpose.)
+ *
+ * \bug Why are these particular prefs handled in main.c and not others?
+ * Should they be?
+ *
+ * \param pref  Which preference has changed
+ * \param data  Arbitrary data (which we ignore)
+ */
+static void
+prefs_changed_callback (MetaPreference pref,
+                        gpointer       data)
+{
+  switch (pref)
+    {
+    case META_PREF_THEME:
+      meta_ui_set_current_theme (meta_prefs_get_theme (), FALSE);
+      meta_display_retheme_all ();
+      break;
+
+    case META_PREF_CURSOR_THEME:
+    case META_PREF_CURSOR_SIZE:
+      meta_display_set_cursor_theme (meta_prefs_get_cursor_theme (),
+				     meta_prefs_get_cursor_size ());
+      break;
+    default:
+      /* handled elsewhere or otherwise */
+      break;
+    }
+}
diff --git a/src/core/marco-Xatomtype.h b/src/core/marco-Xatomtype.h
new file mode 100644
index 00000000..5698ed31
--- /dev/null
+++ b/src/core/marco-Xatomtype.h
@@ -0,0 +1,136 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file marco-Xatomtype.h  Types for communicating with X about properties
+ *
+ * This files defines crock C structures for calling XGetWindowProperty and
+ * XChangeProperty.  All fields must be longs as the semantics of property
+ * routines will handle conversion to and from actual 32 bit objects.  If your
+ * compiler doesn't treat &structoflongs the same as &arrayoflongs[0], you
+ * will have some work to do.
+ */
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifndef _XATOMTYPE_H_
+#define _XATOMTYPE_H_
+
+#define BOOL long
+#define SIGNEDINT long
+#define UNSIGNEDINT unsigned long
+#define RESOURCEID unsigned long
+
+
+/* this structure may be extended, but do not change the order */
+typedef struct {
+    UNSIGNEDINT flags;
+    SIGNEDINT x, y, width, height;	/* need to cvt; only for pre-ICCCM */
+    SIGNEDINT minWidth, minHeight;	/* need to cvt */
+    SIGNEDINT maxWidth, maxHeight;	/* need to cvt */
+    SIGNEDINT widthInc, heightInc;	/* need to cvt */
+    SIGNEDINT minAspectX, minAspectY;	/* need to cvt */
+    SIGNEDINT maxAspectX, maxAspectY;	/* need to cvt */
+    SIGNEDINT baseWidth,baseHeight;	/* need to cvt; ICCCM version 1 */
+    SIGNEDINT winGravity;		/* need to cvt; ICCCM version 1 */
+} xPropSizeHints;
+#define OldNumPropSizeElements 15	/* pre-ICCCM */
+#define NumPropSizeElements 18		/* ICCCM version 1 */
+
+/* this structure may be extended, but do not change the order */
+/* RGB properties */
+typedef struct {
+	RESOURCEID colormap;
+	UNSIGNEDINT red_max;
+	UNSIGNEDINT red_mult;
+	UNSIGNEDINT green_max;
+	UNSIGNEDINT green_mult;
+	UNSIGNEDINT blue_max;
+	UNSIGNEDINT blue_mult;
+	UNSIGNEDINT base_pixel;
+	RESOURCEID visualid;		/* ICCCM version 1 */
+	RESOURCEID killid;		/* ICCCM version 1 */
+} xPropStandardColormap;
+#define OldNumPropStandardColormapElements 8  /* pre-ICCCM */
+#define NumPropStandardColormapElements 10  /* ICCCM version 1 */
+
+
+/* this structure may be extended, but do not change the order */
+typedef struct {
+    UNSIGNEDINT flags;
+    BOOL input;				/* need to convert */
+    SIGNEDINT initialState;		/* need to cvt */
+    RESOURCEID iconPixmap;
+    RESOURCEID iconWindow;
+    SIGNEDINT  iconX;			/* need to cvt */
+    SIGNEDINT  iconY;			/* need to cvt */
+    RESOURCEID iconMask;
+    UNSIGNEDINT windowGroup;
+  } xPropWMHints;
+#define NumPropWMHintsElements 9 /* number of elements in this structure */
+
+/* this structure defines the icon size hints information */
+typedef struct {
+    SIGNEDINT minWidth, minHeight;	/* need to cvt */
+    SIGNEDINT maxWidth, maxHeight;	/* need to cvt */
+    SIGNEDINT widthInc, heightInc;	/* need to cvt */
+  } xPropIconSize;
+#define NumPropIconSizeElements 6 /* number of elements in this structure */
+
+/* this structure defines the window manager state information */
+typedef struct {
+    SIGNEDINT state;			/* need to cvt */
+    RESOURCEID iconWindow;
+} xPropWMState;
+#define NumPropWMStateElements 2	/* number of elements in struct */
+
+#undef BOOL
+#undef SIGNEDINT
+#undef UNSIGNEDINT
+#undef RESOURCEID
+
+#endif /* _XATOMTYPE_H_ */
diff --git a/src/core/place.c b/src/core/place.c
new file mode 100644
index 00000000..cb1458f0
--- /dev/null
+++ b/src/core/place.c
@@ -0,0 +1,932 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window placement */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "place.h"
+#include "workspace.h"
+#include "prefs.h"
+#include <gdk/gdk.h>
+#include <math.h>
+#include <stdlib.h>
+
+typedef enum
+{
+  META_LEFT,
+  META_RIGHT,
+  META_TOP,
+  META_BOTTOM
+} MetaWindowDirection;
+
+static gint
+northwestcmp (gconstpointer a, gconstpointer b)
+{
+  MetaWindow *aw = (gpointer) a;
+  MetaWindow *bw = (gpointer) b;
+  int from_origin_a;
+  int from_origin_b;
+  int ax, ay, bx, by;
+
+  /* we're interested in the frame position for cascading,
+   * not meta_window_get_position()
+   */
+  if (aw->frame)
+    {
+      ax = aw->frame->rect.x;
+      ay = aw->frame->rect.y;
+    }
+  else
+    {
+      ax = aw->rect.x;
+      ay = aw->rect.y;
+    }
+
+  if (bw->frame)
+    {
+      bx = bw->frame->rect.x;
+      by = bw->frame->rect.y;
+    }
+  else
+    {
+      bx = bw->rect.x;
+      by = bw->rect.y;
+    }
+  
+  /* probably there's a fast good-enough-guess we could use here. */
+  from_origin_a = sqrt (ax * ax + ay * ay);
+  from_origin_b = sqrt (bx * bx + by * by);
+    
+  if (from_origin_a < from_origin_b)
+    return -1;
+  else if (from_origin_a > from_origin_b)
+    return 1;
+  else
+    return 0;
+}
+
+static void
+find_next_cascade (MetaWindow *window,
+                   MetaFrameGeometry *fgeom,
+                   /* visible windows on relevant workspaces */
+                   GList      *windows,
+                   int         x,
+                   int         y,
+                   int        *new_x,
+                   int        *new_y)
+{
+  GList *tmp;
+  GList *sorted;
+  int cascade_x, cascade_y;
+  int x_threshold, y_threshold;
+  int window_width, window_height;
+  int cascade_stage;
+  MetaRectangle work_area;
+  const MetaXineramaScreenInfo* current;
+  
+  sorted = g_list_copy (windows);
+  sorted = g_list_sort (sorted, northwestcmp);
+
+  /* This is a "fuzzy" cascade algorithm. 
+   * For each window in the list, we find where we'd cascade a
+   * new window after it. If a window is already nearly at that
+   * position, we move on.
+   */
+  
+  /* arbitrary-ish threshold, honors user attempts to
+   * manually cascade.
+   */
+#define CASCADE_FUZZ 15
+  if (fgeom)
+    {
+      x_threshold = MAX (fgeom->left_width, CASCADE_FUZZ);
+      y_threshold = MAX (fgeom->top_height, CASCADE_FUZZ);
+    }
+  else
+    {
+      x_threshold = CASCADE_FUZZ;
+      y_threshold = CASCADE_FUZZ;
+    }
+  
+  /* Find furthest-SE origin of all workspaces.
+   * cascade_x, cascade_y are the target position
+   * of NW corner of window frame.
+   */
+
+  current = meta_screen_get_current_xinerama (window->screen);
+  meta_window_get_work_area_for_xinerama (window, current->number, &work_area);
+
+  cascade_x = MAX (0, work_area.x);
+  cascade_y = MAX (0, work_area.y);
+  
+  /* Find first cascade position that's not used. */
+  
+  window_width = window->frame ? window->frame->rect.width : window->rect.width;
+  window_height = window->frame ? window->frame->rect.height : window->rect.height;
+  
+  cascade_stage = 0;
+  tmp = sorted;
+  while (tmp != NULL)
+    {
+      MetaWindow *w;
+      int wx, wy;
+      
+      w = tmp->data;
+
+      /* we want frame position, not window position */
+      if (w->frame)
+        {
+          wx = w->frame->rect.x;
+          wy = w->frame->rect.y;
+        }
+      else
+        {
+          wx = w->rect.x;
+          wy = w->rect.y;
+        }
+      
+      if (ABS (wx - cascade_x) < x_threshold &&
+          ABS (wy - cascade_y) < y_threshold)
+        {
+          /* This window is "in the way", move to next cascade
+           * point. The new window frame should go at the origin
+           * of the client window we're stacking above.
+           */
+          meta_window_get_position (w, &wx, &wy);
+          cascade_x = wx;
+          cascade_y = wy;
+          
+          /* If we go off the screen, start over with a new cascade */
+	  if (((cascade_x + window_width) >
+               (work_area.x + work_area.width)) ||
+              ((cascade_y + window_height) >
+	       (work_area.y + work_area.height)))
+	    {
+	      cascade_x = MAX (0, work_area.x);
+	      cascade_y = MAX (0, work_area.y);
+              
+#define CASCADE_INTERVAL 50 /* space between top-left corners of cascades */
+              cascade_stage += 1;
+	      cascade_x += CASCADE_INTERVAL * cascade_stage;
+              
+	      /* start over with a new cascade translated to the right, unless
+               * we are out of space
+               */
+              if ((cascade_x + window_width) <
+                  (work_area.x + work_area.width))
+                {
+                  tmp = sorted;
+                  continue;
+                }
+              else
+                {
+                  /* All out of space, this cascade_x won't work */
+                  cascade_x = MAX (0, work_area.x);
+                  break;
+                }
+	    }
+        }
+      else
+        {
+          /* Keep searching for a further-down-the-diagonal window. */
+        }
+        
+      tmp = tmp->next;
+    }
+
+  /* cascade_x and cascade_y will match the last window in the list
+   * that was "in the way" (in the approximate cascade diagonal)
+   */
+  
+  g_list_free (sorted);
+
+  /* Convert coords to position of window, not position of frame. */
+  if (fgeom == NULL)
+    {
+      *new_x = cascade_x;
+      *new_y = cascade_y;
+    }
+  else
+    {
+      *new_x = cascade_x + fgeom->left_width;
+      *new_y = cascade_y + fgeom->top_height;
+    }
+}
+
+static void
+find_most_freespace (MetaWindow *window,
+                     MetaFrameGeometry *fgeom,
+                     /* visible windows on relevant workspaces */
+                     MetaWindow *focus_window,
+                     int         x,
+                     int         y,
+                     int        *new_x,
+                     int        *new_y)
+{
+  MetaWindowDirection side;
+  int max_area;
+  int max_width, max_height, left, right, top, bottom;
+  int left_space, right_space, top_space, bottom_space;
+  int frame_size_left, frame_size_top;
+  MetaRectangle work_area;
+  MetaRectangle avoid;
+  MetaRectangle outer;
+
+  frame_size_left = fgeom ? fgeom->left_width : 0;
+  frame_size_top  = fgeom ? fgeom->top_height : 0;
+
+  meta_window_get_work_area_current_xinerama (focus_window, &work_area);
+  meta_window_get_outer_rect (focus_window, &avoid);
+  meta_window_get_outer_rect (window, &outer);
+
+  /* Find the areas of choosing the various sides of the focus window */
+  max_width  = MIN (avoid.width, outer.width);
+  max_height = MIN (avoid.height, outer.height);
+  left_space   = avoid.x - work_area.x;
+  right_space  = work_area.width - (avoid.x + avoid.width - work_area.x);
+  top_space    = avoid.y - work_area.y;
+  bottom_space = work_area.height - (avoid.y + avoid.height - work_area.y);
+  left   = MIN (left_space,   outer.width);
+  right  = MIN (right_space,  outer.width);
+  top    = MIN (top_space,    outer.height);
+  bottom = MIN (bottom_space, outer.height);
+
+  /* Find out which side of the focus_window can show the most of the window */
+  side = META_LEFT;
+  max_area = left*max_height;
+  if (right*max_height > max_area)
+    {
+      side = META_RIGHT;
+      max_area = right*max_height;
+    }
+  if (top*max_width > max_area)
+    {
+      side = META_TOP;
+      max_area = top*max_width;
+    }
+  if (bottom*max_width > max_area)
+    {
+      side = META_BOTTOM;
+      max_area = bottom*max_width;
+    }
+
+  /* Give up if there's no where to put it (i.e. focus window is maximized) */
+  if (max_area == 0)
+    return;
+
+  /* Place the window on the relevant side; if the whole window fits,
+   * make it adjacent to the focus window; if not, make sure the
+   * window doesn't go off the edge of the screen.
+   */
+  switch (side)
+    {
+    case META_LEFT:
+      *new_y = avoid.y + frame_size_top;
+      if (left_space > outer.width)
+        *new_x = avoid.x - outer.width + frame_size_left;
+      else
+        *new_x = work_area.x + frame_size_left;
+      break;
+    case META_RIGHT:
+      *new_y = avoid.y + frame_size_top;
+      if (right_space > outer.width)
+        *new_x = avoid.x + avoid.width + frame_size_left;
+      else
+        *new_x = work_area.x + work_area.width - outer.width + frame_size_left;
+      break;
+    case META_TOP:
+      *new_x = avoid.x + frame_size_left;
+      if (top_space > outer.height)
+        *new_y = avoid.y - outer.height + frame_size_top;
+      else
+        *new_y = work_area.y + frame_size_top;
+      break;
+    case META_BOTTOM:
+      *new_x = avoid.x + frame_size_left;
+      if (bottom_space > outer.height)
+        *new_y = avoid.y + avoid.height + frame_size_top;
+      else
+        *new_y = work_area.y + work_area.height - outer.height + frame_size_top;
+      break;
+    }
+}
+
+static void
+avoid_being_obscured_as_second_modal_dialog (MetaWindow *window,
+                                             MetaFrameGeometry *fgeom,
+                                             int        *x,
+                                             int        *y)
+{
+  /* We can't center this dialog if it was denied focus and it
+   * overlaps with the focus window and this dialog is modal and this
+   * dialog is in the same app as the focus window (*phew*...please
+   * don't make me say that ten times fast). See bug 307875 comment 11
+   * and 12 for details, but basically it means this is probably a
+   * second modal dialog for some app while the focus window is the
+   * first modal dialog.  We should probably make them simultaneously
+   * visible in general, but it becomes mandatory to do so due to
+   * buggy apps (e.g. those using gtk+ *sigh*) because in those cases
+   * this second modal dialog also happens to be modal to the first
+   * dialog in addition to the main window, while it has only let us
+   * know about the modal-to-the-main-window part.
+   */
+
+  MetaWindow *focus_window;
+  MetaRectangle overlap;
+
+  focus_window = window->display->focus_window;
+
+  if (window->denied_focus_and_not_transient &&
+      window->wm_state_modal && /* FIXME: Maybe do this for all transients? */
+      meta_window_same_application (window, focus_window) &&
+      meta_rectangle_intersect (&window->rect,
+                                &focus_window->rect,
+                                &overlap))
+    {
+      find_most_freespace (window, fgeom, focus_window, *x, *y, x, y);
+      meta_topic (META_DEBUG_PLACEMENT,
+                  "Dialog window %s was denied focus but may be modal "
+                  "to the focus window; had to move it to avoid the "
+                  "focus window\n",
+                  window->desc);
+    }
+}
+
+static gboolean
+rectangle_overlaps_some_window (MetaRectangle *rect,
+                                GList         *windows)
+{
+  GList *tmp;
+  MetaRectangle dest;
+  
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *other = tmp->data;
+      MetaRectangle other_rect;      
+
+      switch (other->type)
+        {
+        case META_WINDOW_DOCK:
+        case META_WINDOW_SPLASHSCREEN:
+        case META_WINDOW_DESKTOP:
+        case META_WINDOW_DIALOG:
+        case META_WINDOW_MODAL_DIALOG:
+          break;
+
+        case META_WINDOW_NORMAL:
+        case META_WINDOW_UTILITY:
+        case META_WINDOW_TOOLBAR:
+        case META_WINDOW_MENU:
+          meta_window_get_outer_rect (other, &other_rect);
+          
+          if (meta_rectangle_intersect (rect, &other_rect, &dest))
+            return TRUE;
+          break;
+        }
+      
+      tmp = tmp->next;
+    }
+
+  return FALSE;
+}
+
+static gint
+leftmost_cmp (gconstpointer a, gconstpointer b)
+{
+  MetaWindow *aw = (gpointer) a;
+  MetaWindow *bw = (gpointer) b;
+  int ax, bx;
+
+  /* we're interested in the frame position for cascading,
+   * not meta_window_get_position()
+   */
+  if (aw->frame)
+    ax = aw->frame->rect.x;
+  else
+    ax = aw->rect.x;
+
+  if (bw->frame)
+    bx = bw->frame->rect.x;
+  else
+    bx = bw->rect.x;
+
+  if (ax < bx)
+    return -1;
+  else if (ax > bx)
+    return 1;
+  else
+    return 0;
+}
+
+static gint
+topmost_cmp (gconstpointer a, gconstpointer b)
+{
+  MetaWindow *aw = (gpointer) a;
+  MetaWindow *bw = (gpointer) b;
+  int ay, by;
+
+  /* we're interested in the frame position for cascading,
+   * not meta_window_get_position()
+   */
+  if (aw->frame)
+    ay = aw->frame->rect.y;
+  else
+    ay = aw->rect.y;
+
+  if (bw->frame)
+    by = bw->frame->rect.y;
+  else
+    by = bw->rect.y;
+
+  if (ay < by)
+    return -1;
+  else if (ay > by)
+    return 1;
+  else
+    return 0;
+}
+
+static void
+center_tile_rect_in_area (MetaRectangle *rect,
+                          MetaRectangle *work_area)
+{
+  int fluff;
+
+  /* The point here is to tile a window such that "extra"
+   * space is equal on either side (i.e. so a full screen
+   * of windows tiled this way would center the windows
+   * as a group)
+   */
+
+  fluff = (work_area->width % (rect->width+1)) / 2;
+  rect->x = work_area->x + fluff;
+  fluff = (work_area->height % (rect->height+1)) / 3;
+  rect->y = work_area->y + fluff;
+}
+
+/* Find the leftmost, then topmost, empty area on the workspace
+ * that can contain the new window.
+ *
+ * Cool feature to have: if we can't fit the current window size,
+ * try shrinking the window (within geometry constraints). But
+ * beware windows such as Emacs with no sane minimum size, we
+ * don't want to create a 1x1 Emacs.
+ */
+static gboolean
+find_first_fit (MetaWindow *window,
+                MetaFrameGeometry *fgeom,
+                /* visible windows on relevant workspaces */
+                GList      *windows,
+		int         xinerama,
+                int         x,
+                int         y,
+                int        *new_x,
+                int        *new_y)
+{
+  /* This algorithm is limited - it just brute-force tries
+   * to fit the window in a small number of locations that are aligned
+   * with existing windows. It tries to place the window on
+   * the bottom of each existing window, and then to the right
+   * of each existing window, aligned with the left/top of the
+   * existing window in each of those cases.
+   */  
+  int retval;
+  GList *below_sorted;
+  GList *right_sorted;
+  GList *tmp;
+  MetaRectangle rect;
+  MetaRectangle work_area;
+  
+  retval = FALSE;
+
+  /* Below each window */
+  below_sorted = g_list_copy (windows);
+  below_sorted = g_list_sort (below_sorted, leftmost_cmp);
+  below_sorted = g_list_sort (below_sorted, topmost_cmp);  
+
+  /* To the right of each window */
+  right_sorted = g_list_copy (windows);
+  right_sorted = g_list_sort (right_sorted, topmost_cmp);
+  right_sorted = g_list_sort (right_sorted, leftmost_cmp);
+  
+  rect.width = window->rect.width;
+  rect.height = window->rect.height;
+  
+  if (fgeom)
+    {
+      rect.width += fgeom->left_width + fgeom->right_width;
+      rect.height += fgeom->top_height + fgeom->bottom_height;
+    }
+
+#ifdef WITH_VERBOSE_MODE
+    {
+      char xinerama_location_string[RECT_LENGTH];
+      meta_rectangle_to_string (&window->screen->xinerama_infos[xinerama].rect,
+                                xinerama_location_string);
+      meta_topic (META_DEBUG_XINERAMA,
+		  "Natural xinerama is %s\n",
+		  xinerama_location_string);
+    }
+#endif
+
+    meta_window_get_work_area_for_xinerama (window, xinerama, &work_area);
+
+    center_tile_rect_in_area (&rect, &work_area);
+
+    if (meta_rectangle_contains_rect (&work_area, &rect) &&
+        !rectangle_overlaps_some_window (&rect, windows))
+      {
+        *new_x = rect.x;
+        *new_y = rect.y;
+        if (fgeom)
+          {
+            *new_x += fgeom->left_width;
+            *new_y += fgeom->top_height;
+          }
+    
+        retval = TRUE;
+       
+        goto out;
+      }
+
+    /* try below each window */
+    tmp = below_sorted;
+    while (tmp != NULL)
+      {
+        MetaWindow *w = tmp->data;
+        MetaRectangle outer_rect;
+
+        meta_window_get_outer_rect (w, &outer_rect);
+      
+        rect.x = outer_rect.x;
+        rect.y = outer_rect.y + outer_rect.height;
+      
+        if (meta_rectangle_contains_rect (&work_area, &rect) &&
+            !rectangle_overlaps_some_window (&rect, below_sorted))
+          {
+            *new_x = rect.x;
+            *new_y = rect.y;
+            if (fgeom)
+              {
+                *new_x += fgeom->left_width;
+                *new_y += fgeom->top_height;
+              }
+          
+            retval = TRUE;
+          
+            goto out;
+          }
+
+        tmp = tmp->next;
+      }
+
+    /* try to the right of each window */
+    tmp = right_sorted;
+    while (tmp != NULL)
+      {
+        MetaWindow *w = tmp->data;
+        MetaRectangle outer_rect;
+   
+        meta_window_get_outer_rect (w, &outer_rect);
+     
+        rect.x = outer_rect.x + outer_rect.width;
+        rect.y = outer_rect.y;
+   
+        if (meta_rectangle_contains_rect (&work_area, &rect) &&
+            !rectangle_overlaps_some_window (&rect, right_sorted))
+          {
+            *new_x = rect.x;
+            *new_y = rect.y;
+            if (fgeom)
+              {
+                *new_x += fgeom->left_width;
+                *new_y += fgeom->top_height;
+              }
+        
+            retval = TRUE;
+       
+            goto out;
+          }
+
+        tmp = tmp->next;
+      }
+      
+ out:
+
+  g_list_free (below_sorted);
+  g_list_free (right_sorted);
+  return retval;
+}
+
+void
+meta_window_place (MetaWindow        *window,
+                   MetaFrameGeometry *fgeom,
+                   int                x,
+                   int                y,
+                   int               *new_x,
+                   int               *new_y)
+{
+  GList *windows;
+  const MetaXineramaScreenInfo *xi;
+
+  /* frame member variables should NEVER be used in here, only
+   * MetaFrameGeometry. But remember fgeom == NULL
+   * for undecorated windows. Also, this function should
+   * NEVER have side effects other than computing the
+   * placement coordinates.
+   */
+  
+  meta_topic (META_DEBUG_PLACEMENT, "Placing window %s\n", window->desc);
+
+  windows = NULL;
+  
+  switch (window->type)
+    {
+      /* Run placement algorithm on these. */
+    case META_WINDOW_NORMAL:
+    case META_WINDOW_DIALOG:
+    case META_WINDOW_MODAL_DIALOG:
+    case META_WINDOW_SPLASHSCREEN:
+      break;
+          
+      /* Assume the app knows best how to place these, no placement
+       * algorithm ever (other than "leave them as-is")
+       */
+    case META_WINDOW_DESKTOP:
+    case META_WINDOW_DOCK:
+    case META_WINDOW_TOOLBAR:
+    case META_WINDOW_MENU:
+    case META_WINDOW_UTILITY:
+      goto done_no_constraints;
+    }
+  
+  if (meta_prefs_get_disable_workarounds ())
+    {
+      switch (window->type)
+        {
+          /* Only accept USPosition on normal windows because the app is full
+           * of shit claiming the user set -geometry for a dialog or dock
+           */
+        case META_WINDOW_NORMAL:
+          if (window->size_hints.flags & USPosition)
+            {
+              /* don't constrain with placement algorithm */
+              meta_topic (META_DEBUG_PLACEMENT,
+                          "Honoring USPosition for %s instead of using placement algorithm\n", window->desc);
+
+              goto done;
+            }
+          break;
+
+          /* Ignore even USPosition on dialogs, splashscreen */
+        case META_WINDOW_DIALOG:
+        case META_WINDOW_MODAL_DIALOG:
+        case META_WINDOW_SPLASHSCREEN:
+          break;
+          
+          /* Assume the app knows best how to place these. */
+        case META_WINDOW_DESKTOP:
+        case META_WINDOW_DOCK:
+        case META_WINDOW_TOOLBAR:
+        case META_WINDOW_MENU:
+        case META_WINDOW_UTILITY:
+          if (window->size_hints.flags & PPosition)
+            {
+              meta_topic (META_DEBUG_PLACEMENT,
+                          "Not placing non-normal non-dialog window with PPosition set\n");
+              goto done_no_constraints;
+            }
+          break;
+        }
+    }
+  else
+    {
+      /* workarounds enabled */
+      
+      if ((window->size_hints.flags & PPosition) ||
+          (window->size_hints.flags & USPosition))
+        {
+          meta_topic (META_DEBUG_PLACEMENT,
+                      "Not placing window with PPosition or USPosition set\n");
+          avoid_being_obscured_as_second_modal_dialog (window, fgeom, &x, &y);
+          goto done_no_constraints;
+        }
+    }
+  
+  if ((window->type == META_WINDOW_DIALOG ||
+       window->type == META_WINDOW_MODAL_DIALOG) &&
+      window->xtransient_for != None)
+    {
+      /* Center horizontally, at top of parent vertically */
+
+      MetaWindow *parent;
+          
+      parent =
+        meta_display_lookup_x_window (window->display,
+                                      window->xtransient_for);
+
+      if (parent)
+        {
+          int w;
+
+          meta_window_get_position (parent, &x, &y);
+          w = parent->rect.width;
+
+          /* center of parent */
+          x = x + w / 2;
+          /* center of child over center of parent */
+          x -= window->rect.width / 2;
+
+          /* "visually" center window over parent, leaving twice as
+           * much space below as on top.
+           */
+          y += (parent->rect.height - window->rect.height)/3;
+
+          /* put top of child's frame, not top of child's client */
+          if (fgeom)
+            y += fgeom->top_height;
+
+          meta_topic (META_DEBUG_PLACEMENT, "Centered window %s over transient parent\n",
+                      window->desc);
+          
+          avoid_being_obscured_as_second_modal_dialog (window, fgeom, &x, &y);
+
+          goto done;
+        }
+    }
+  
+  /* FIXME UTILITY with transient set should be stacked up
+   * on the sides of the parent window or something.
+   */
+  
+  if (window->type == META_WINDOW_DIALOG ||
+      window->type == META_WINDOW_MODAL_DIALOG ||
+      window->type == META_WINDOW_SPLASHSCREEN)
+    {
+      /* Center on current xinerama (i.e. on current monitor) */
+      int w, h;
+
+      /* Warning, this function is a round trip! */
+      xi = meta_screen_get_current_xinerama (window->screen);
+
+      w = xi->rect.width;
+      h = xi->rect.height;
+
+      x = (w - window->rect.width) / 2;
+      y = (h - window->rect.height) / 2;
+
+      x += xi->rect.x;
+      y += xi->rect.y;
+      
+      meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on screen %d xinerama %d\n",
+                  window->desc, window->screen->number, xi->number);
+
+      goto done_check_denied_focus;
+    }
+  
+  /* Find windows that matter (not minimized, on same workspace
+   * as placed window, may be shaded - if shaded we pretend it isn't
+   * for placement purposes)
+   */
+  {
+    GSList *all_windows;
+    GSList *tmp;
+    
+    all_windows = meta_display_list_windows (window->display);
+
+    tmp = all_windows;
+    while (tmp != NULL)
+      {
+        MetaWindow *w = tmp->data;
+
+        if (meta_window_showing_on_its_workspace (w) &&
+            w != window && 
+            (window->workspace == w->workspace ||
+             window->on_all_workspaces || w->on_all_workspaces))
+          windows = g_list_prepend (windows, w);
+
+        tmp = tmp->next;
+      }
+
+    g_slist_free (all_windows);
+  }
+
+  /* Warning, this is a round trip! */
+  xi = meta_screen_get_current_xinerama (window->screen);
+  
+  /* "Origin" placement algorithm */
+  x = xi->rect.x;
+  y = xi->rect.y;
+
+  if (find_first_fit (window, fgeom, windows,
+                      xi->number,
+                      x, y, &x, &y))
+    goto done_check_denied_focus;
+
+  /* Maximize windows if they are too big for their work area (bit of
+   * a hack here). Assume undecorated windows probably don't intend to
+   * be maximized.  
+   */
+  if (window->has_maximize_func && window->decorated &&
+      !window->fullscreen)
+    {
+      MetaRectangle workarea;
+      MetaRectangle outer;
+
+      meta_window_get_work_area_for_xinerama (window,
+                                              xi->number,
+                                              &workarea);      
+      meta_window_get_outer_rect (window, &outer);
+      
+      /* If the window is bigger than the screen, then automaximize.  Do NOT
+       * auto-maximize the directions independently.  See #419810.
+       */
+      if (outer.width >= workarea.width && outer.height >= workarea.height)
+        {
+          window->maximize_horizontally_after_placement = TRUE;
+          window->maximize_vertically_after_placement = TRUE;
+        }
+    }
+
+  /* If no placement has been done, revert to cascade to avoid 
+   * fully overlapping window (e.g. starting multiple terminals)
+   * */
+  if (x == xi->rect.x && y == xi->rect.y)  
+    find_next_cascade (window, fgeom, windows, x, y, &x, &y);
+
+ done_check_denied_focus:
+  /* If the window is being denied focus and isn't a transient of the
+   * focus window, we do NOT want it to overlap with the focus window
+   * if at all possible.  This is guaranteed to only be called if the
+   * focus_window is non-NULL, and we try to avoid that window.
+   */
+  if (window->denied_focus_and_not_transient)
+    {
+      gboolean       found_fit;
+      MetaWindow    *focus_window;
+      MetaRectangle  overlap;
+
+      focus_window = window->display->focus_window;
+      g_assert (focus_window != NULL);
+
+      /* No need to do anything if the window doesn't overlap at all */
+      found_fit = !meta_rectangle_intersect (&window->rect,
+                                             &focus_window->rect,
+                                             &overlap);
+
+      /* Try to do a first fit again, this time only taking into account the
+       * focus window.
+       */
+      if (!found_fit)
+        {
+          GList *focus_window_list;
+          focus_window_list = g_list_prepend (NULL, focus_window);
+
+          /* Reset x and y ("origin" placement algorithm) */
+          x = xi->rect.x;
+          y = xi->rect.y;
+
+          found_fit = find_first_fit (window, fgeom, focus_window_list,
+                                      xi->number,
+                                      x, y, &x, &y);
+          g_list_free (focus_window_list);
+	}
+
+      /* If that still didn't work, just place it where we can see as much
+       * as possible.
+       */
+      if (!found_fit)
+        find_most_freespace (window, fgeom, focus_window, x, y, &x, &y);
+    }
+  
+ done:
+  g_list_free (windows);
+  
+ done_no_constraints:
+
+  *new_x = x;
+  *new_y = y;
+}
diff --git a/src/core/place.h b/src/core/place.h
new file mode 100644
index 00000000..85b7cd3f
--- /dev/null
+++ b/src/core/place.h
@@ -0,0 +1,37 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco window placement */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_PLACE_H
+#define META_PLACE_H
+
+#include "window-private.h"
+#include "frame-private.h"
+
+void meta_window_place (MetaWindow *window,
+                        MetaFrameGeometry *fgeom,
+                        int         x,
+                        int         y,
+                        int        *new_x,
+                        int        *new_y);
+
+#endif
diff --git a/src/core/prefs.c b/src/core/prefs.c
new file mode 100644
index 00000000..494d3da1
--- /dev/null
+++ b/src/core/prefs.c
@@ -0,0 +1,2794 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco preferences */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington, Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2006 Elijah Newren
+ * Copyright (C) 2008 Thomas Thurman
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "prefs.h"
+#include "ui.h"
+#include "util.h"
+#ifdef HAVE_MATECONF
+#include <mateconf/mateconf-client.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+
+#define MAX_REASONABLE_WORKSPACES 36
+
+#define MAX_COMMANDS (32 + NUM_EXTRA_COMMANDS)
+#define NUM_EXTRA_COMMANDS 2
+#define SCREENSHOT_COMMAND_IDX (MAX_COMMANDS - 2)
+#define WIN_SCREENSHOT_COMMAND_IDX (MAX_COMMANDS - 1)
+
+/* If you add a key, it needs updating in init() and in the mateconf
+ * notify listener and of course in the .schemas file.
+ *
+ * Keys which are handled by one of the unified handlers below are
+ * not given a name here, because the purpose of the unified handlers
+ * is that keys should be referred to exactly once.
+ */
+#define KEY_TITLEBAR_FONT "/apps/marco/general/titlebar_font"
+#define KEY_NUM_WORKSPACES "/apps/marco/general/num_workspaces"
+#define KEY_COMPOSITOR "/apps/marco/general/compositing_manager"
+#define KEY_MATE_ACCESSIBILITY "/desktop/mate/interface/accessibility"
+
+#define KEY_COMMAND_DIRECTORY "/apps/marco/keybinding_commands"
+#define KEY_COMMAND_PREFIX "/apps/marco/keybinding_commands/command_"
+
+#define KEY_TERMINAL_DIR "/desktop/mate/applications/terminal"
+#define KEY_TERMINAL_COMMAND KEY_TERMINAL_DIR "/exec"
+
+#define KEY_SCREEN_BINDINGS_PREFIX "/apps/marco/global_keybindings"
+#define KEY_WINDOW_BINDINGS_PREFIX "/apps/marco/window_keybindings"
+#define KEY_LIST_BINDINGS_SUFFIX "_list"
+
+#define KEY_WORKSPACE_NAME_DIRECTORY "/apps/marco/workspace_names"
+#define KEY_WORKSPACE_NAME_PREFIX "/apps/marco/workspace_names/name_"
+
+
+#ifdef HAVE_MATECONF
+static MateConfClient *default_client = NULL;
+static GList *changes = NULL;
+static guint changed_idle;
+static GList *listeners = NULL;
+#endif
+
+static gboolean use_system_font = FALSE;
+static PangoFontDescription *titlebar_font = NULL;
+static MetaVirtualModifier mouse_button_mods = Mod1Mask;
+static MetaFocusMode focus_mode = META_FOCUS_MODE_CLICK;
+static MetaFocusNewWindows focus_new_windows = META_FOCUS_NEW_WINDOWS_SMART;
+static gboolean raise_on_click = TRUE;
+static char* current_theme = NULL;
+static int num_workspaces = 4;
+static MetaActionTitlebar action_double_click_titlebar = META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE;
+static MetaActionTitlebar action_middle_click_titlebar = META_ACTION_TITLEBAR_LOWER;
+static MetaActionTitlebar action_right_click_titlebar = META_ACTION_TITLEBAR_MENU;
+static gboolean application_based = FALSE;
+static gboolean disable_workarounds = FALSE;
+static gboolean auto_raise = FALSE;
+static gboolean auto_raise_delay = 500;
+static gboolean provide_visual_bell = FALSE;
+static gboolean bell_is_audible = TRUE;
+static gboolean reduced_resources = FALSE;
+static gboolean mate_accessibility = FALSE;
+static gboolean mate_animations = TRUE;
+static char *cursor_theme = NULL;
+static int   cursor_size = 24;
+static gboolean compositing_manager = FALSE;
+static gboolean resize_with_right_button = FALSE;
+static gboolean force_fullscreen = TRUE;
+
+static MetaVisualBellType visual_bell_type = META_VISUAL_BELL_FULLSCREEN_FLASH;
+static MetaButtonLayout button_layout;
+
+/* The screenshot commands are at the end */
+static char *commands[MAX_COMMANDS] = { NULL, };
+
+static char *terminal_command = NULL;
+
+static char *workspace_names[MAX_REASONABLE_WORKSPACES] = { NULL, };
+
+#ifdef HAVE_MATECONF
+static gboolean handle_preference_update_enum (const gchar *key, MateConfValue *value);
+
+static gboolean update_key_binding     (const char *name,
+                                        const char *value);
+static gboolean find_and_update_list_binding (MetaKeyPref *bindings,
+                                              const char  *name,
+                                              GSList      *value);
+static gboolean update_key_list_binding (const char *name,
+                                         GSList      *value);
+static gboolean update_command            (const char  *name,
+                                           const char  *value);
+static gboolean update_workspace_name     (const char  *name,
+                                           const char  *value);
+
+static void change_notify (MateConfClient    *client,
+                           guint           cnxn_id,
+                           MateConfEntry     *entry,
+                           gpointer        user_data);
+
+static char* mateconf_key_for_workspace_name (int i);
+
+static void queue_changed (MetaPreference  pref);
+
+typedef enum
+  {
+    META_LIST_OF_STRINGS,
+    META_LIST_OF_MATECONFVALUE_STRINGS
+  } MetaStringListType;
+
+static gboolean update_list_binding       (MetaKeyPref *binding,
+                                           GSList      *value,
+                                           MetaStringListType type_of_value);
+
+static void     cleanup_error             (GError **error);
+static gboolean get_bool                  (const char *key, gboolean *val);
+static void maybe_give_disable_workarounds_warning (void);
+
+static void titlebar_handler (MetaPreference, const gchar*, gboolean*);
+static void theme_name_handler (MetaPreference, const gchar*, gboolean*);
+static void mouse_button_mods_handler (MetaPreference, const gchar*, gboolean*);
+static void button_layout_handler (MetaPreference, const gchar*, gboolean*);
+
+#endif /* HAVE_MATECONF */
+
+static gboolean update_binding            (MetaKeyPref *binding,
+                                           const char  *value);
+
+static void     init_bindings             (void);
+static void     init_commands             (void);
+static void     init_workspace_names      (void);
+
+#ifndef HAVE_MATECONF
+static void     init_button_layout        (void);
+#endif /* !HAVE_MATECONF */
+
+#ifdef HAVE_MATECONF
+
+typedef struct
+{
+  MetaPrefsChangedFunc func;
+  gpointer data;
+} MetaPrefsListener;
+
+static MateConfEnumStringPair symtab_focus_mode[] =
+  {
+    { META_FOCUS_MODE_CLICK,  "click" },
+    { META_FOCUS_MODE_SLOPPY, "sloppy" },
+    { META_FOCUS_MODE_MOUSE,  "mouse" },
+    { 0, NULL },
+  };
+
+static MateConfEnumStringPair symtab_focus_new_windows[] =
+  {
+    { META_FOCUS_NEW_WINDOWS_SMART,  "smart" },
+    { META_FOCUS_NEW_WINDOWS_STRICT, "strict" },
+    { 0, NULL },
+  };
+
+static MateConfEnumStringPair symtab_visual_bell_type[] =
+  {
+    /* Note to the reader: 0 is an invalid value; these start at 1. */
+    { META_VISUAL_BELL_FULLSCREEN_FLASH, "fullscreen" },
+    { META_VISUAL_BELL_FRAME_FLASH,      "frame_flash" },
+    { 0, NULL },
+  };
+
+static MateConfEnumStringPair symtab_titlebar_action[] =
+  {
+    { META_ACTION_TITLEBAR_TOGGLE_SHADE,    "toggle_shade" },
+    { META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE, "toggle_maximize" },
+    { META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE_HORIZONTALLY,
+                                "toggle_maximize_horizontally" },
+    { META_ACTION_TITLEBAR_TOGGLE_MAXIMIZE_VERTICALLY,
+                                "toggle_maximize_vertically" },
+    { META_ACTION_TITLEBAR_MINIMIZE,        "minimize" },
+    { META_ACTION_TITLEBAR_NONE,            "none" },
+    { META_ACTION_TITLEBAR_LOWER,           "lower" },
+    { META_ACTION_TITLEBAR_MENU,            "menu" },
+    { META_ACTION_TITLEBAR_TOGGLE_SHADE,    "toggle_shade" },
+    { 0, NULL },
+  };
+
+/**
+ * The details of one preference which is constrained to be
+ * one of a small number of string values-- in other words,
+ * an enumeration.
+ *
+ * We could have done this other ways.  One particularly attractive
+ * possibility would have been to represent the entire symbol table
+ * as a space-separated string literal in the list of symtabs, so
+ * the focus mode enums could have been represented simply by
+ * "click sloppy mouse".  However, the simplicity gained would have
+ * been outweighed by the bugs caused when the ordering of the enum
+ * strings got out of sync with the actual enum statement.  Also,
+ * there is existing library code to use this kind of symbol tables.
+ *
+ * Other things we might consider doing to clean this up in the
+ * future include:
+ *
+ *   - most of the keys begin with the same prefix, and perhaps we
+ *     could assume it if they don't start with a slash
+ *
+ *   - there are several cases where a single identifier could be used
+ *     to generate an entire entry, and perhaps this could be done
+ *     with a macro.  (This would reduce clarity, however, and is
+ *     probably a bad thing.)
+ *
+ *   - these types all begin with a gchar* (and contain a MetaPreference)
+ *     and we can factor out the repeated code in the handlers by taking
+ *     advantage of this using some kind of union arrangement.
+ */
+typedef struct
+{
+  gchar *key;
+  MetaPreference pref;
+  MateConfEnumStringPair *symtab;
+  gpointer target;
+} MetaEnumPreference;
+
+typedef struct
+{
+  gchar *key;
+  MetaPreference pref;
+  gboolean *target;
+  gboolean becomes_true_on_destruction;
+} MetaBoolPreference;
+
+typedef struct
+{
+  gchar *key;
+  MetaPreference pref;
+
+  /**
+   * A handler.  Many of the string preferences aren't stored as
+   * strings and need parsing; others of them have default values
+   * which can't be solved in the general case.  If you include a
+   * function pointer here, it will be called before the string
+   * value is written out to the target variable.
+   *
+   * The function is passed two arguments: the preference, and
+   * the new string as a gchar*.  It returns a gboolean;
+   * only if this is true, the listeners will be informed that
+   * the preference has changed.
+   *
+   * This may be NULL.  If it is, see "target", below.
+   */
+  void (*handler) (MetaPreference pref,
+                     const gchar *string_value,
+                     gboolean *inform_listeners);
+
+  /**
+   * Where to write the incoming string.
+   *
+   * This must be NULL if the handler is non-NULL.
+   * If the incoming string is NULL, no change will be made.
+   */
+  gchar **target;
+
+} MetaStringPreference;
+
+#define METAINTPREFERENCE_NO_CHANGE_ON_DESTROY G_MININT
+
+typedef struct
+{
+  gchar *key;
+  MetaPreference pref;
+  gint *target;
+  /**
+   * Minimum and maximum values of the integer.
+   * If the new value is out of bounds, it will be discarded with a warning.
+   */
+  gint minimum, maximum;
+  /**
+   * Value to use if the key is destroyed.
+   * If this is METAINTPREFERENCE_NO_CHANGE_ON_DESTROY, it will
+   * not be changed when the key is destroyed.
+   */
+  gint value_if_destroyed;
+} MetaIntPreference;
+
+/* FIXMEs: */
+/* @@@ Don't use NULL lines at the end; glib can tell you how big it is */
+/* @@@ /apps/marco/general should be assumed if first char is not / */
+/* @@@ Will it ever be possible to merge init and update? If not, why not? */
+
+static MetaEnumPreference preferences_enum[] =
+  {
+    { "/apps/marco/general/focus_new_windows",
+      META_PREF_FOCUS_NEW_WINDOWS,
+      symtab_focus_new_windows,
+      &focus_new_windows,
+    },
+    { "/apps/marco/general/focus_mode",
+      META_PREF_FOCUS_MODE,
+      symtab_focus_mode,
+      &focus_mode,
+    },
+    { "/apps/marco/general/visual_bell_type",
+      META_PREF_VISUAL_BELL_TYPE,
+      symtab_visual_bell_type,
+      &visual_bell_type,
+    },
+    { "/apps/marco/general/action_double_click_titlebar",
+      META_PREF_ACTION_DOUBLE_CLICK_TITLEBAR,
+      symtab_titlebar_action,
+      &action_double_click_titlebar,
+    },
+    { "/apps/marco/general/action_middle_click_titlebar",
+      META_PREF_ACTION_MIDDLE_CLICK_TITLEBAR,
+      symtab_titlebar_action,
+      &action_middle_click_titlebar,
+    },
+    { "/apps/marco/general/action_right_click_titlebar",
+      META_PREF_ACTION_RIGHT_CLICK_TITLEBAR,
+      symtab_titlebar_action,
+      &action_right_click_titlebar,
+    },
+    { NULL, 0, NULL, NULL },
+  };
+
+static MetaBoolPreference preferences_bool[] =
+  {
+    { "/apps/marco/general/raise_on_click",
+      META_PREF_RAISE_ON_CLICK,
+      &raise_on_click,
+      TRUE,
+    },
+    { "/apps/marco/general/titlebar_uses_system_font",
+      META_PREF_TITLEBAR_FONT, /* note! shares a pref */
+      &use_system_font,
+      TRUE,
+    },
+    { "/apps/marco/general/application_based",
+      META_PREF_APPLICATION_BASED,
+      NULL, /* feature is known but disabled */
+      FALSE,
+    },
+    { "/apps/marco/general/disable_workarounds",
+      META_PREF_DISABLE_WORKAROUNDS,
+      &disable_workarounds,
+      FALSE,
+    },
+    { "/apps/marco/general/auto_raise",
+      META_PREF_AUTO_RAISE,
+      &auto_raise,
+      FALSE,
+    },
+    { "/apps/marco/general/visual_bell",
+      META_PREF_VISUAL_BELL,
+      &provide_visual_bell, /* FIXME: change the name: it's confusing */
+      FALSE,
+    },
+    { "/apps/marco/general/audible_bell",
+      META_PREF_AUDIBLE_BELL,
+      &bell_is_audible, /* FIXME: change the name: it's confusing */
+      FALSE,
+    },
+    { "/apps/marco/general/reduced_resources",
+      META_PREF_REDUCED_RESOURCES,
+      &reduced_resources,
+      FALSE,
+    },
+    { "/desktop/mate/interface/accessibility",
+      META_PREF_MATE_ACCESSIBILITY,
+      &mate_accessibility,
+      FALSE,
+    },
+    { "/desktop/mate/interface/enable_animations",
+      META_PREF_MATE_ANIMATIONS,
+      &mate_animations,
+      TRUE,
+    },
+    { "/apps/marco/general/compositing_manager",
+      META_PREF_COMPOSITING_MANAGER,
+      &compositing_manager,
+      FALSE,
+    },
+    { "/apps/marco/general/resize_with_right_button",
+      META_PREF_RESIZE_WITH_RIGHT_BUTTON,
+      &resize_with_right_button,
+      FALSE,
+    },
+    { NULL, 0, NULL, FALSE },
+  };
+
+static MetaStringPreference preferences_string[] =
+  {
+    { "/apps/marco/general/mouse_button_modifier",
+      META_PREF_MOUSE_BUTTON_MODS,
+      mouse_button_mods_handler,
+      NULL,
+    },
+    { "/apps/marco/general/theme",
+      META_PREF_THEME,
+      theme_name_handler,
+      NULL,
+    },
+    { KEY_TITLEBAR_FONT,
+      META_PREF_TITLEBAR_FONT,
+      titlebar_handler,
+      NULL,
+    },
+    { KEY_TERMINAL_COMMAND,
+      META_PREF_TERMINAL_COMMAND,
+      NULL,
+      &terminal_command,
+    },
+    { "/apps/marco/general/button_layout",
+      META_PREF_BUTTON_LAYOUT,
+      button_layout_handler,
+      NULL,
+    },
+    { "/desktop/mate/peripherals/mouse/cursor_theme",
+      META_PREF_CURSOR_THEME,
+      NULL,
+      &cursor_theme,
+    },
+    { NULL, 0, NULL, NULL },
+  };
+
+static MetaIntPreference preferences_int[] =
+  {
+    { "/apps/marco/general/num_workspaces",
+      META_PREF_NUM_WORKSPACES,
+      &num_workspaces,
+      /* I would actually recommend we change the destroy value to 4
+       * and get rid of METAINTPREFERENCE_NO_CHANGE_ON_DESTROY entirely.
+       *  -- tthurman
+       */
+      1, MAX_REASONABLE_WORKSPACES, METAINTPREFERENCE_NO_CHANGE_ON_DESTROY,
+    },
+    { "/apps/marco/general/auto_raise_delay",
+      META_PREF_AUTO_RAISE_DELAY,
+      &auto_raise_delay,
+      0, 10000, 0,
+      /* @@@ Get rid of MAX_REASONABLE_AUTO_RAISE_DELAY */
+    },
+    { "/desktop/mate/peripherals/mouse/cursor_size",
+      META_PREF_CURSOR_SIZE,
+      &cursor_size,
+      1, 128, 24,
+    },
+    { NULL, 0, NULL, 0, 0, 0, },
+  };
+
+static void
+handle_preference_init_enum (void)
+{
+  MetaEnumPreference *cursor = preferences_enum;
+
+  while (cursor->key!=NULL)
+    {
+      char *value;
+      GError *error = NULL;
+
+      if (cursor->target==NULL)
+        {
+          ++cursor;
+          continue;
+        }
+
+      value = mateconf_client_get_string (default_client,
+                                       cursor->key,
+                                       &error);
+      cleanup_error (&error);
+
+      if (value==NULL)
+        {
+          ++cursor;
+          continue;
+        }
+
+      if (!mateconf_string_to_enum (cursor->symtab,
+                                 value,
+                                 (gint *) cursor->target))
+        meta_warning (_("MateConf key '%s' is set to an invalid value\n"),
+                      cursor->key);
+
+      g_free (value);
+
+      ++cursor;
+    }
+}
+
+static void
+handle_preference_init_bool (void)
+{
+  MetaBoolPreference *cursor = preferences_bool;
+
+  while (cursor->key!=NULL)
+    {
+      if (cursor->target!=NULL)
+        get_bool (cursor->key, cursor->target);
+
+      ++cursor;
+    }
+
+  maybe_give_disable_workarounds_warning ();
+}
+
+static void
+handle_preference_init_string (void)
+{
+  MetaStringPreference *cursor = preferences_string;
+
+  while (cursor->key!=NULL)
+    {
+      char *value;
+      GError *error = NULL;
+      gboolean dummy = TRUE;
+
+      /* the string "value" will be newly allocated */
+      value = mateconf_client_get_string (default_client,
+                                       cursor->key,
+                                       &error);
+      cleanup_error (&error);
+
+      if (cursor->handler)
+        {
+          if (cursor->target)
+            meta_bug ("%s has both a target and a handler\n", cursor->key);
+
+          cursor->handler (cursor->pref, value, &dummy);
+
+          g_free (value);
+        }
+      else if (cursor->target)
+        {
+          if (*(cursor->target))
+            g_free (*(cursor->target));
+
+          *(cursor->target) = value;
+        }
+
+      ++cursor;
+    }
+}
+
+static void
+handle_preference_init_int (void)
+{
+  MetaIntPreference *cursor = preferences_int;
+
+  
+  while (cursor->key!=NULL)
+    {
+      gint value;
+      GError *error = NULL;
+
+      value = mateconf_client_get_int (default_client,
+                                    cursor->key,
+                                    &error);
+      cleanup_error (&error);
+
+      if (value < cursor->minimum || value > cursor->maximum)
+        {
+          meta_warning (_("%d stored in MateConf key %s is out of range %d to %d\n"),
+                        value, cursor->key,  cursor->minimum, cursor->maximum);
+          /* Former behaviour for out-of-range values was:
+           *   - number of workspaces was clamped;
+           *   - auto raise delay was always reset to zero even if too high!;
+           *   - cursor size was ignored.
+           *
+           * These seem to be meaningless variations.  If they did
+           * have meaning we could have put them into MetaIntPreference.
+           * The last of these is the closest to how we behave for
+           * other types, so I think we should standardise on that.
+           */
+        }
+      else if (cursor->target)
+        *cursor->target = value;
+
+      ++cursor;
+    }
+}
+
+static gboolean
+handle_preference_update_enum (const gchar *key, MateConfValue *value)
+{
+  MetaEnumPreference *cursor = preferences_enum;
+  gint old_value;
+
+  while (cursor->key!=NULL && strcmp (key, cursor->key)!=0)
+    ++cursor;
+
+  if (cursor->key==NULL)
+    /* Didn't recognise that key. */
+    return FALSE;
+      
+  /* Setting it to null (that is, removing it) always means
+   * "don't change".
+   */
+
+  if (value==NULL)
+    return TRUE;
+
+  /* Check the type.  Enums are always strings. */
+
+  if (value->type != MATECONF_VALUE_STRING)
+    {
+      meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                    key);
+      /* But we did recognise it. */
+      return TRUE;
+    }
+
+  /* We need to know whether the value changes, so
+   * store the current value away.
+   */
+
+  old_value = * ((gint *) cursor->target);
+  
+  /* Now look it up... */
+
+  if (!mateconf_string_to_enum (cursor->symtab,
+                             mateconf_value_get_string (value),
+                             (gint *) cursor->target))
+    {
+      /*
+       * We found it, but it was invalid.  Complain.
+       *
+       * FIXME: This replicates the original behaviour, but in the future
+       * we might consider reverting invalid keys to their original values.
+       * (We know the old value, so we can look up a suitable string in
+       * the symtab.)
+       *
+       * (Empty comment follows so the translators don't see this.)
+       */
+
+      /*  */      
+      meta_warning (_("MateConf key '%s' is set to an invalid value\n"),
+                    key);
+      return TRUE;
+    }
+
+  /* Did it change?  If so, tell the listeners about it. */
+
+  if (old_value != *((gint *) cursor->target))
+    queue_changed (cursor->pref);
+
+  return TRUE;
+}
+
+static gboolean
+handle_preference_update_bool (const gchar *key, MateConfValue *value)
+{
+  MetaBoolPreference *cursor = preferences_bool;
+  gboolean old_value;
+
+  while (cursor->key!=NULL && strcmp (key, cursor->key)!=0)
+    ++cursor;
+
+  if (cursor->key==NULL)
+    /* Didn't recognise that key. */
+    return FALSE;
+
+  if (cursor->target==NULL)
+    /* No work for us to do. */
+    return TRUE;
+      
+  if (value==NULL)
+    {
+      /* Value was destroyed; let's get out of here. */
+
+      if (cursor->becomes_true_on_destruction)
+        /* This preserves the behaviour of the old system, but
+         * for all I know that might have been an oversight.
+         */
+        *((gboolean *)cursor->target) = TRUE;
+
+      return TRUE;
+    }
+
+  /* Check the type. */
+
+  if (value->type != MATECONF_VALUE_BOOL)
+    {
+      meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                    key);
+      /* But we did recognise it. */
+      return TRUE;
+    }
+
+  /* We need to know whether the value changes, so
+   * store the current value away.
+   */
+
+  old_value = * ((gboolean *) cursor->target);
+  
+  /* Now look it up... */
+
+  *((gboolean *) cursor->target) = mateconf_value_get_bool (value);
+
+  /* Did it change?  If so, tell the listeners about it. */
+
+  if (old_value != *((gboolean *) cursor->target))
+    queue_changed (cursor->pref);
+
+  if (cursor->pref==META_PREF_DISABLE_WORKAROUNDS)
+    maybe_give_disable_workarounds_warning ();
+
+  return TRUE;
+}
+
+static gboolean
+handle_preference_update_string (const gchar *key, MateConfValue *value)
+{
+  MetaStringPreference *cursor = preferences_string;
+  const gchar *value_as_string;
+  gboolean inform_listeners = TRUE;
+
+  while (cursor->key!=NULL && strcmp (key, cursor->key)!=0)
+    ++cursor;
+
+  if (cursor->key==NULL)
+    /* Didn't recognise that key. */
+    return FALSE;
+
+  if (value==NULL)
+    return TRUE;
+
+  /* Check the type. */
+
+  if (value->type != MATECONF_VALUE_STRING)
+    {
+      meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                    key);
+      /* But we did recognise it. */
+      return TRUE;
+    }
+
+  /* Docs: "The returned string is not a copy, don't try to free it." */
+  value_as_string = mateconf_value_get_string (value);
+
+  if (cursor->handler)
+    cursor->handler (cursor->pref, value_as_string, &inform_listeners);
+  else if (cursor->target)
+    {
+      if (*(cursor->target))
+        g_free(*(cursor->target));
+
+      if (value_as_string!=NULL)
+        *(cursor->target) = g_strdup (value_as_string);
+      else
+        *(cursor->target) = NULL;
+
+      inform_listeners =
+        (value_as_string==NULL && *(cursor->target)==NULL) ||
+        (value_as_string!=NULL && *(cursor->target)!=NULL &&
+         strcmp (value_as_string, *(cursor->target))==0);
+    }
+
+  if (inform_listeners)
+    queue_changed (cursor->pref);
+
+  return TRUE;
+}
+
+static gboolean
+handle_preference_update_int (const gchar *key, MateConfValue *value)
+{
+  MetaIntPreference *cursor = preferences_int;
+  gint new_value;
+
+  while (cursor->key!=NULL && strcmp (key, cursor->key)!=0)
+    ++cursor;
+
+  if (cursor->key==NULL)
+    /* Didn't recognise that key. */
+    return FALSE;
+
+  if (cursor->target==NULL)
+    /* No work for us to do. */
+    return TRUE;
+      
+  if (value==NULL)
+    {
+      /* Value was destroyed. */
+
+      if (cursor->value_if_destroyed != METAINTPREFERENCE_NO_CHANGE_ON_DESTROY)
+        *((gint *)cursor->target) = cursor->value_if_destroyed;
+
+      return TRUE;
+    }
+
+  /* Check the type. */
+
+  if (value->type != MATECONF_VALUE_INT)
+    {
+      meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                    key);
+      /* But we did recognise it. */
+      return TRUE;
+    }
+
+  new_value = mateconf_value_get_int (value);
+
+  if (new_value < cursor->minimum || new_value > cursor->maximum)
+    {
+      meta_warning (_("%d stored in MateConf key %s is out of range %d to %d\n"),
+                    new_value, cursor->key,
+                    cursor->minimum, cursor->maximum);
+      return TRUE;
+    }
+
+  /* Did it change?  If so, tell the listeners about it. */
+
+  if (*cursor->target != new_value)
+    {
+      *cursor->target = new_value;
+      queue_changed (cursor->pref);
+    }
+
+  return TRUE;
+  
+}
+
+
+/****************************************************************************/
+/* Listeners.                                                               */
+/****************************************************************************/
+
+void
+meta_prefs_add_listener (MetaPrefsChangedFunc func,
+                         gpointer             data)
+{
+  MetaPrefsListener *l;
+
+  l = g_new (MetaPrefsListener, 1);
+  l->func = func;
+  l->data = data;
+
+  listeners = g_list_prepend (listeners, l);
+}
+
+void
+meta_prefs_remove_listener (MetaPrefsChangedFunc func,
+                            gpointer             data)
+{
+  GList *tmp;
+
+  tmp = listeners;
+  while (tmp != NULL)
+    {
+      MetaPrefsListener *l = tmp->data;
+
+      if (l->func == func &&
+          l->data == data)
+        {
+          g_free (l);
+          listeners = g_list_delete_link (listeners, tmp);
+
+          return;
+        }
+      
+      tmp = tmp->next;
+    }
+
+  meta_bug ("Did not find listener to remove\n");
+}
+
+static void
+emit_changed (MetaPreference pref)
+{
+  GList *tmp;
+  GList *copy;
+
+  meta_topic (META_DEBUG_PREFS, "Notifying listeners that pref %s changed\n",
+              meta_preference_to_string (pref));
+  
+  copy = g_list_copy (listeners);
+  
+  tmp = copy;
+
+  while (tmp != NULL)
+    {
+      MetaPrefsListener *l = tmp->data;
+
+      (* l->func) (pref, l->data);
+
+      tmp = tmp->next;
+    }
+
+  g_list_free (copy);
+}
+
+static gboolean
+changed_idle_handler (gpointer data)
+{
+  GList *tmp;
+  GList *copy;
+
+  changed_idle = 0;
+  
+  copy = g_list_copy (changes); /* reentrancy paranoia */
+
+  g_list_free (changes);
+  changes = NULL;
+  
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaPreference pref = GPOINTER_TO_INT (tmp->data);
+
+      emit_changed (pref);
+      
+      tmp = tmp->next;
+    }
+
+  g_list_free (copy);
+  
+  return FALSE;
+}
+
+static void
+queue_changed (MetaPreference pref)
+{
+  meta_topic (META_DEBUG_PREFS, "Queueing change of pref %s\n",
+              meta_preference_to_string (pref));  
+
+  if (g_list_find (changes, GINT_TO_POINTER (pref)) == NULL)
+    changes = g_list_prepend (changes, GINT_TO_POINTER (pref));
+  else
+    meta_topic (META_DEBUG_PREFS, "Change of pref %s was already pending\n",
+                meta_preference_to_string (pref));
+
+  /* add idle at priority below the mateconf notify idle */
+  if (changed_idle == 0)
+    changed_idle = g_idle_add_full (META_PRIORITY_PREFS_NOTIFY,
+                                    changed_idle_handler, NULL, NULL);
+}
+
+#else /* HAVE_MATECONF */
+
+void
+meta_prefs_add_listener (MetaPrefsChangedFunc func,
+                         gpointer             data)
+{
+  /* Nothing, because they have mateconf turned off */
+}
+
+void
+meta_prefs_remove_listener (MetaPrefsChangedFunc func,
+                            gpointer             data)
+{
+  /* Nothing, because they have mateconf turned off */
+}
+
+#endif /* HAVE_MATECONF */
+
+
+/****************************************************************************/
+/* Initialisation.                                                          */
+/****************************************************************************/
+
+#ifdef HAVE_MATECONF
+/* @@@ again, use glib's ability to tell you the size of the array */
+static gchar *mateconf_dirs_we_are_interested_in[] = {
+  "/apps/marco",
+  KEY_TERMINAL_DIR,
+  KEY_MATE_ACCESSIBILITY,
+  "/desktop/mate/peripherals/mouse",
+  "/desktop/mate/interface",
+  NULL,
+};
+#endif
+
+void
+meta_prefs_init (void)
+{
+#ifdef HAVE_MATECONF
+  GError *err = NULL;
+  gchar **mateconf_dir_cursor;
+  
+  if (default_client != NULL)
+    return;
+  
+  /* returns a reference which we hold forever */
+  default_client = mateconf_client_get_default ();
+
+  for (mateconf_dir_cursor=mateconf_dirs_we_are_interested_in;
+       *mateconf_dir_cursor!=NULL;
+       mateconf_dir_cursor++)
+    {
+      mateconf_client_add_dir (default_client,
+                            *mateconf_dir_cursor,
+                            MATECONF_CLIENT_PRELOAD_RECURSIVE,
+                            &err);
+      cleanup_error (&err);
+    }
+
+  /* Pick up initial values. */
+
+  handle_preference_init_enum ();
+  handle_preference_init_bool ();
+  handle_preference_init_string ();
+  handle_preference_init_int ();
+
+  /* @@@ Is there any reason we don't do the add_dir here? */
+  for (mateconf_dir_cursor=mateconf_dirs_we_are_interested_in;
+       *mateconf_dir_cursor!=NULL;
+       mateconf_dir_cursor++)
+    {
+      mateconf_client_notify_add (default_client,
+                               *mateconf_dir_cursor,
+                               change_notify,
+                               NULL,
+                               NULL,
+                               &err);
+      cleanup_error (&err);
+    }
+
+#else  /* HAVE_MATECONF */
+
+  /* Set defaults for some values that can't be set at initialization time of
+   * the static globals.  In the case of the theme, note that there is code
+   * elsewhere that will do everything possible to fallback to an existing theme
+   * if the one here does not exist.
+   */
+  titlebar_font = pango_font_description_from_string ("Sans Bold 10");
+  current_theme = g_strdup ("ClearlooksRe");
+  
+  init_button_layout();
+#endif /* HAVE_MATECONF */
+  
+  init_bindings ();
+  init_commands ();
+  init_workspace_names ();
+}
+
+
+/****************************************************************************/
+/* Updates.                                                                 */
+/****************************************************************************/
+
+#ifdef HAVE_MATECONF
+
+gboolean (*preference_update_handler[]) (const gchar*, MateConfValue*) = {
+  handle_preference_update_enum,
+  handle_preference_update_bool,
+  handle_preference_update_string,
+  handle_preference_update_int,
+  NULL
+};
+
+static void
+change_notify (MateConfClient    *client,
+               guint           cnxn_id,
+               MateConfEntry     *entry,
+               gpointer        user_data)
+{
+  const char *key;
+  MateConfValue *value;
+  gint i=0;
+  
+  key = mateconf_entry_get_key (entry);
+  value = mateconf_entry_get_value (entry);
+
+  /* First, search for a handler that might know what to do. */
+
+  /* FIXME: When this is all working, since the first item in every
+   * array is the gchar* of the key, there's no reason we can't
+   * find the correct record for that key here and save code duplication.
+   */
+
+  while (preference_update_handler[i]!=NULL)
+    {
+      if (preference_update_handler[i] (key, value))
+        goto out; /* Get rid of this eventually */
+
+      i++;
+    }
+  
+  if (g_str_has_prefix (key, KEY_WINDOW_BINDINGS_PREFIX) ||
+      g_str_has_prefix (key, KEY_SCREEN_BINDINGS_PREFIX))
+    {
+      if (g_str_has_suffix (key, KEY_LIST_BINDINGS_SUFFIX))
+        {
+          GSList *list;
+
+          if (value && value->type != MATECONF_VALUE_LIST)
+            {
+              meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                            key);
+              goto out;
+            }
+
+          list = value ? mateconf_value_get_list (value) : NULL;
+
+          if (update_key_list_binding (key, list))
+            queue_changed (META_PREF_KEYBINDINGS);
+        }
+      else
+        {
+          const char *str;
+
+          if (value && value->type != MATECONF_VALUE_STRING)
+            {
+              meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                            key);
+              goto out;
+            }
+
+          str = value ? mateconf_value_get_string (value) : NULL;
+
+          if (update_key_binding (key, str))
+            queue_changed (META_PREF_KEYBINDINGS);
+        }
+    }
+  else if (g_str_has_prefix (key, KEY_COMMAND_PREFIX))
+    {
+      const char *str;
+
+      if (value && value->type != MATECONF_VALUE_STRING)
+        {
+          meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                        key);
+          goto out;
+        }
+
+      str = value ? mateconf_value_get_string (value) : NULL;
+
+      if (update_command (key, str))
+        queue_changed (META_PREF_COMMANDS);
+    }
+  else if (g_str_has_prefix (key, KEY_WORKSPACE_NAME_PREFIX))
+    {
+      const char *str;
+
+      if (value && value->type != MATECONF_VALUE_STRING)
+        {
+          meta_warning (_("MateConf key \"%s\" is set to an invalid type\n"),
+                        key);
+          goto out;
+        }
+
+      str = value ? mateconf_value_get_string (value) : NULL;
+
+      if (update_workspace_name (key, str))
+        queue_changed (META_PREF_WORKSPACE_NAMES);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_PREFS, "Key %s doesn't mean anything to Marco\n",
+                  key);
+    }
+  
+ out:
+  /* nothing */
+  return; /* AIX compiler wants something after a label like out: */
+}
+
+static void
+cleanup_error (GError **error)
+{
+  if (*error)
+    {
+      meta_warning ("%s\n", (*error)->message);
+      
+      g_error_free (*error);
+      *error = NULL;
+    }
+}
+
+/* get_bool returns TRUE if *val is filled in, FALSE otherwise */
+/* @@@ probably worth moving this inline; only used once */
+static gboolean
+get_bool (const char *key, gboolean *val)
+{
+  GError     *err = NULL;
+  MateConfValue *value;
+  gboolean    filled_in = FALSE;
+
+  value = mateconf_client_get (default_client, key, &err);
+  cleanup_error (&err);
+  if (value)
+    {
+      if (value->type == MATECONF_VALUE_BOOL)
+        {
+          *val = mateconf_value_get_bool (value);
+          filled_in = TRUE;
+        }
+      mateconf_value_free (value);
+    }
+
+  return filled_in;
+}
+
+/**
+ * Special case: give a warning the first time disable_workarounds
+ * is turned on.
+ */
+static void
+maybe_give_disable_workarounds_warning (void)
+{
+  static gboolean first_disable = TRUE;
+    
+  if (first_disable && disable_workarounds)
+    {
+      first_disable = FALSE;
+
+      meta_warning (_("Workarounds for broken applications disabled. "
+                      "Some applications may not behave properly.\n"));
+    }
+}
+
+#endif /* HAVE_MATECONF */
+
+MetaVirtualModifier
+meta_prefs_get_mouse_button_mods  (void)
+{
+  return mouse_button_mods;
+}
+
+MetaFocusMode
+meta_prefs_get_focus_mode (void)
+{
+  return focus_mode;
+}
+
+MetaFocusNewWindows
+meta_prefs_get_focus_new_windows (void)
+{
+  return focus_new_windows;
+}
+
+gboolean
+meta_prefs_get_raise_on_click (void)
+{
+  /* Force raise_on_click on for click-to-focus, as requested by Havoc
+   * in #326156.
+   */
+  return raise_on_click || focus_mode == META_FOCUS_MODE_CLICK;
+}
+
+const char*
+meta_prefs_get_theme (void)
+{
+  return current_theme;
+}
+
+const char*
+meta_prefs_get_cursor_theme (void)
+{
+  return cursor_theme;
+}
+
+int
+meta_prefs_get_cursor_size (void)
+{
+  return cursor_size;
+}
+
+
+/****************************************************************************/
+/* Handlers for string preferences.                                         */
+/****************************************************************************/
+
+#ifdef HAVE_MATECONF
+
+static void
+titlebar_handler (MetaPreference pref,
+                  const gchar    *string_value,
+                  gboolean       *inform_listeners)
+{
+  PangoFontDescription *new_desc = NULL;
+
+  if (string_value)
+    new_desc = pango_font_description_from_string (string_value);
+
+  if (new_desc == NULL)
+    {
+      meta_warning (_("Could not parse font description "
+                      "\"%s\" from MateConf key %s\n"),
+                    string_value ? string_value : "(null)",
+                    KEY_TITLEBAR_FONT);
+
+      *inform_listeners = FALSE;
+
+      return;
+    }
+
+  /* Is the new description the same as the old? */
+
+  if (titlebar_font &&
+      pango_font_description_equal (new_desc, titlebar_font))
+    {
+      pango_font_description_free (new_desc);
+      *inform_listeners = FALSE;
+      return;
+    }
+
+  /* No, so free the old one and put ours in instead. */
+
+  if (titlebar_font)
+    pango_font_description_free (titlebar_font);
+
+  titlebar_font = new_desc;
+
+}
+
+static void
+theme_name_handler (MetaPreference pref,
+                    const gchar *string_value,
+                    gboolean *inform_listeners)
+{
+  g_free (current_theme);
+
+  /* Fallback crackrock */
+  if (string_value == NULL)
+    current_theme = g_strdup ("ClearlooksRe");
+  else
+    current_theme = g_strdup (string_value);
+}
+
+static void
+mouse_button_mods_handler (MetaPreference pref,
+                           const gchar *string_value,
+                           gboolean *inform_listeners)
+{
+  MetaVirtualModifier mods;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Mouse button modifier has new mateconf value \"%s\"\n",
+              string_value);
+  if (string_value && meta_ui_parse_modifier (string_value, &mods))
+    {
+      mouse_button_mods = mods;
+    }
+  else
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Failed to parse new mateconf value\n");
+          
+      meta_warning (_("\"%s\" found in configuration database is "
+                      "not a valid value for mouse button modifier\n"),
+                    string_value);
+
+      *inform_listeners = FALSE;
+    }
+}
+
+static gboolean
+button_layout_equal (const MetaButtonLayout *a,
+                     const MetaButtonLayout *b)
+{  
+  int i;
+
+  i = 0;
+  while (i < MAX_BUTTONS_PER_CORNER)
+    {
+      if (a->left_buttons[i] != b->left_buttons[i])
+        return FALSE;
+      if (a->right_buttons[i] != b->right_buttons[i])
+        return FALSE;
+      if (a->left_buttons_has_spacer[i] != b->left_buttons_has_spacer[i])
+        return FALSE;
+      if (a->right_buttons_has_spacer[i] != b->right_buttons_has_spacer[i])
+        return FALSE;
+      ++i;
+    }
+
+  return TRUE;
+}
+
+static MetaButtonFunction
+button_function_from_string (const char *str)
+{
+  /* FIXME: mateconf_string_to_enum is the obvious way to do this */
+
+  if (strcmp (str, "menu") == 0)
+    return META_BUTTON_FUNCTION_MENU;
+  else if (strcmp (str, "minimize") == 0)
+    return META_BUTTON_FUNCTION_MINIMIZE;
+  else if (strcmp (str, "maximize") == 0)
+    return META_BUTTON_FUNCTION_MAXIMIZE;
+  else if (strcmp (str, "close") == 0)
+    return META_BUTTON_FUNCTION_CLOSE;
+  else if (strcmp (str, "shade") == 0)
+    return META_BUTTON_FUNCTION_SHADE;
+  else if (strcmp (str, "above") == 0)
+    return META_BUTTON_FUNCTION_ABOVE;
+  else if (strcmp (str, "stick") == 0)
+    return META_BUTTON_FUNCTION_STICK;
+  else 
+    /* don't know; give up */
+    return META_BUTTON_FUNCTION_LAST;
+}
+
+static MetaButtonFunction
+button_opposite_function (MetaButtonFunction ofwhat)
+{
+  switch (ofwhat)
+    {
+    case META_BUTTON_FUNCTION_SHADE:
+      return META_BUTTON_FUNCTION_UNSHADE;
+    case META_BUTTON_FUNCTION_UNSHADE:
+      return META_BUTTON_FUNCTION_SHADE;
+
+    case META_BUTTON_FUNCTION_ABOVE:
+      return META_BUTTON_FUNCTION_UNABOVE;
+    case META_BUTTON_FUNCTION_UNABOVE:
+      return META_BUTTON_FUNCTION_ABOVE;
+
+    case META_BUTTON_FUNCTION_STICK:
+      return META_BUTTON_FUNCTION_UNSTICK;
+    case META_BUTTON_FUNCTION_UNSTICK:
+      return META_BUTTON_FUNCTION_STICK;
+
+    default:
+      return META_BUTTON_FUNCTION_LAST;
+    }
+}
+
+static void
+button_layout_handler (MetaPreference pref,
+                         const gchar *string_value,
+                         gboolean *inform_listeners)
+{
+  MetaButtonLayout new_layout;
+  char **sides = NULL;
+  int i;
+  
+  /* We need to ignore unknown button functions, for
+   * compat with future versions
+   */
+  
+  if (string_value)
+    sides = g_strsplit (string_value, ":", 2);
+
+  if (sides != NULL && sides[0] != NULL)
+    {
+      char **buttons;
+      int b;
+      gboolean used[META_BUTTON_FUNCTION_LAST];
+
+      i = 0;
+      while (i < META_BUTTON_FUNCTION_LAST)
+        {
+          used[i] = FALSE;
+          new_layout.left_buttons_has_spacer[i] = FALSE;
+          ++i;
+        }
+      
+      buttons = g_strsplit (sides[0], ",", -1);
+      i = 0;
+      b = 0;
+      while (buttons[b] != NULL)
+        {
+          MetaButtonFunction f = button_function_from_string (buttons[b]);
+          if (i > 0 && strcmp("spacer", buttons[b]) == 0)
+            {
+              new_layout.left_buttons_has_spacer[i-1] = TRUE;
+              f = button_opposite_function (f);
+
+              if (f != META_BUTTON_FUNCTION_LAST)
+                {
+                  new_layout.left_buttons_has_spacer[i-2] = TRUE;
+                }
+            }
+          else
+            {
+              if (f != META_BUTTON_FUNCTION_LAST && !used[f])
+                {
+                  new_layout.left_buttons[i] = f;
+                  used[f] = TRUE;
+                  ++i;
+
+                  f = button_opposite_function (f);
+
+                  if (f != META_BUTTON_FUNCTION_LAST)
+                      new_layout.left_buttons[i++] = f;
+
+                }
+              else
+                {
+                  meta_topic (META_DEBUG_PREFS, "Ignoring unknown or already-used button name \"%s\"\n",
+                              buttons[b]);
+                }
+            }
+          
+          ++b;
+        }
+
+      new_layout.left_buttons[i] = META_BUTTON_FUNCTION_LAST;
+      new_layout.left_buttons_has_spacer[i] = FALSE;
+      
+      g_strfreev (buttons);
+    }
+
+  if (sides != NULL && sides[0] != NULL && sides[1] != NULL)
+    {
+      char **buttons;
+      int b;
+      gboolean used[META_BUTTON_FUNCTION_LAST];
+
+      i = 0;
+      while (i < META_BUTTON_FUNCTION_LAST)
+        {
+          used[i] = FALSE;
+          new_layout.right_buttons_has_spacer[i] = FALSE;
+          ++i;
+        }
+      
+      buttons = g_strsplit (sides[1], ",", -1);
+      i = 0;
+      b = 0;
+      while (buttons[b] != NULL)
+        {
+          MetaButtonFunction f = button_function_from_string (buttons[b]);
+          if (i > 0 && strcmp("spacer", buttons[b]) == 0)
+            {
+              new_layout.right_buttons_has_spacer[i-1] = TRUE;
+              f = button_opposite_function (f);
+              if (f != META_BUTTON_FUNCTION_LAST)
+                {
+                  new_layout.right_buttons_has_spacer[i-2] = TRUE;
+                }
+            }
+          else
+            {
+              if (f != META_BUTTON_FUNCTION_LAST && !used[f])
+                {
+                  new_layout.right_buttons[i] = f;
+                  used[f] = TRUE;
+                  ++i;
+
+                  f = button_opposite_function (f);
+
+                  if (f != META_BUTTON_FUNCTION_LAST)
+                      new_layout.right_buttons[i++] = f;
+
+                }
+              else
+                {
+                  meta_topic (META_DEBUG_PREFS, "Ignoring unknown or already-used button name \"%s\"\n",
+                              buttons[b]);
+                }
+            }
+          
+          ++b;
+        }
+
+      new_layout.right_buttons[i] = META_BUTTON_FUNCTION_LAST;
+      new_layout.right_buttons_has_spacer[i] = FALSE;
+      
+      g_strfreev (buttons);
+    }
+
+  g_strfreev (sides);
+  
+  /* Invert the button layout for RTL languages */
+  if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
+  {
+    MetaButtonLayout rtl_layout;
+    int j;
+    
+    for (i = 0; new_layout.left_buttons[i] != META_BUTTON_FUNCTION_LAST; i++);
+    for (j = 0; j < i; j++)
+      {
+        rtl_layout.right_buttons[j] = new_layout.left_buttons[i - j - 1];
+        if (j == 0)
+          rtl_layout.right_buttons_has_spacer[i - 1] = new_layout.left_buttons_has_spacer[i - j - 1];
+        else
+          rtl_layout.right_buttons_has_spacer[j - 1] = new_layout.left_buttons_has_spacer[i - j - 1];
+      }
+    rtl_layout.right_buttons[j] = META_BUTTON_FUNCTION_LAST;
+    rtl_layout.right_buttons_has_spacer[j] = FALSE;
+      
+    for (i = 0; new_layout.right_buttons[i] != META_BUTTON_FUNCTION_LAST; i++);
+    for (j = 0; j < i; j++)
+      {
+        rtl_layout.left_buttons[j] = new_layout.right_buttons[i - j - 1];
+        if (j == 0)
+          rtl_layout.left_buttons_has_spacer[i - 1] = new_layout.right_buttons_has_spacer[i - j - 1];
+        else
+          rtl_layout.left_buttons_has_spacer[j - 1] = new_layout.right_buttons_has_spacer[i - j - 1];
+      }
+    rtl_layout.left_buttons[j] = META_BUTTON_FUNCTION_LAST;
+    rtl_layout.left_buttons_has_spacer[j] = FALSE;
+
+    new_layout = rtl_layout;
+  }
+  
+  if (button_layout_equal (&button_layout, &new_layout))
+    {
+      /* Same as before, so duck out */
+      *inform_listeners = FALSE;
+    }
+  else
+    {
+      button_layout = new_layout;
+    }
+}
+
+#endif /* HAVE_MATECONF */
+
+const PangoFontDescription*
+meta_prefs_get_titlebar_font (void)
+{
+  if (use_system_font)
+    return NULL;
+  else
+    return titlebar_font;
+}
+
+int
+meta_prefs_get_num_workspaces (void)
+{
+  return num_workspaces;
+}
+
+gboolean
+meta_prefs_get_application_based (void)
+{
+  return FALSE; /* For now, we never want this to do anything */
+  
+  return application_based;
+}
+
+gboolean
+meta_prefs_get_disable_workarounds (void)
+{
+  return disable_workarounds;
+}
+
+#ifdef HAVE_MATECONF
+#define MAX_REASONABLE_AUTO_RAISE_DELAY 10000
+  
+#endif /* HAVE_MATECONF */
+
+#ifdef WITH_VERBOSE_MODE
+const char*
+meta_preference_to_string (MetaPreference pref)
+{
+  /* FIXME: another case for mateconf_string_to_enum */
+  switch (pref)
+    {
+    case META_PREF_MOUSE_BUTTON_MODS:
+      return "MOUSE_BUTTON_MODS";
+
+    case META_PREF_FOCUS_MODE:
+      return "FOCUS_MODE";
+
+    case META_PREF_FOCUS_NEW_WINDOWS:
+      return "FOCUS_NEW_WINDOWS";
+
+    case META_PREF_RAISE_ON_CLICK:
+      return "RAISE_ON_CLICK";
+      
+    case META_PREF_THEME:
+      return "THEME";
+
+    case META_PREF_TITLEBAR_FONT:
+      return "TITLEBAR_FONT";
+
+    case META_PREF_NUM_WORKSPACES:
+      return "NUM_WORKSPACES";
+
+    case META_PREF_APPLICATION_BASED:
+      return "APPLICATION_BASED";
+
+    case META_PREF_KEYBINDINGS:
+      return "KEYBINDINGS";
+
+    case META_PREF_DISABLE_WORKAROUNDS:
+      return "DISABLE_WORKAROUNDS";
+
+    case META_PREF_ACTION_DOUBLE_CLICK_TITLEBAR:
+      return "ACTION_DOUBLE_CLICK_TITLEBAR";
+
+    case META_PREF_ACTION_MIDDLE_CLICK_TITLEBAR:
+      return "ACTION_MIDDLE_CLICK_TITLEBAR";
+
+    case META_PREF_ACTION_RIGHT_CLICK_TITLEBAR:
+      return "ACTION_RIGHT_CLICK_TITLEBAR";
+
+    case META_PREF_AUTO_RAISE:
+      return "AUTO_RAISE";
+      
+    case META_PREF_AUTO_RAISE_DELAY:
+      return "AUTO_RAISE_DELAY";
+
+    case META_PREF_COMMANDS:
+      return "COMMANDS";
+
+    case META_PREF_TERMINAL_COMMAND:
+      return "TERMINAL_COMMAND";
+
+    case META_PREF_BUTTON_LAYOUT:
+      return "BUTTON_LAYOUT";
+
+    case META_PREF_WORKSPACE_NAMES:
+      return "WORKSPACE_NAMES";
+
+    case META_PREF_VISUAL_BELL:
+      return "VISUAL_BELL";
+
+    case META_PREF_AUDIBLE_BELL:
+      return "AUDIBLE_BELL";
+
+    case META_PREF_VISUAL_BELL_TYPE:
+      return "VISUAL_BELL_TYPE";
+
+    case META_PREF_REDUCED_RESOURCES:
+      return "REDUCED_RESOURCES";
+
+    case META_PREF_MATE_ACCESSIBILITY:
+      return "MATE_ACCESSIBILTY";
+
+    case META_PREF_MATE_ANIMATIONS:
+      return "MATE_ANIMATIONS";
+
+    case META_PREF_CURSOR_THEME:
+      return "CURSOR_THEME";
+
+    case META_PREF_CURSOR_SIZE:
+      return "CURSOR_SIZE";
+
+    case META_PREF_COMPOSITING_MANAGER:
+      return "COMPOSITING_MANAGER";
+
+    case META_PREF_RESIZE_WITH_RIGHT_BUTTON:
+      return "RESIZE_WITH_RIGHT_BUTTON";
+
+    case META_PREF_FORCE_FULLSCREEN:
+      return "FORCE_FULLSCREEN";
+    }
+
+  return "(unknown)";
+}
+#endif /* WITH_VERBOSE_MODE */
+
+void
+meta_prefs_set_num_workspaces (int n_workspaces)
+{
+#ifdef HAVE_MATECONF
+  GError *err;
+  
+  if (default_client == NULL)
+    return;
+
+  if (n_workspaces < 1)
+    n_workspaces = 1;
+  if (n_workspaces > MAX_REASONABLE_WORKSPACES)
+    n_workspaces = MAX_REASONABLE_WORKSPACES;
+  
+  err = NULL;
+  mateconf_client_set_int (default_client,
+                        KEY_NUM_WORKSPACES,
+                        n_workspaces,
+                        &err);
+
+  if (err)
+    {
+      meta_warning (_("Error setting number of workspaces to %d: %s\n"),
+                    num_workspaces,
+                    err->message);
+      g_error_free (err);
+    }
+#endif /* HAVE_MATECONF */
+}
+
+#define keybind(name, handler, param, flags, stroke, description) \
+  { #name, NULL, !!(flags & BINDING_REVERSES), !!(flags & BINDING_PER_WINDOW) },
+static MetaKeyPref key_bindings[] = {
+#include "all-keybindings.h"
+  { NULL, NULL, FALSE }
+};
+#undef keybind
+
+#ifndef HAVE_MATECONF
+
+/**
+ * A type to map names of keybindings (such as "switch_windows")
+ * to the binding strings themselves (such as "<Alt>Tab").
+ * It exists only when MateConf is turned off in ./configure and
+ * functions as a sort of ersatz MateConf.
+ */
+typedef struct
+{
+  const char *name;
+  const char *keybinding;
+} MetaSimpleKeyMapping;
+
+/* FIXME: This would be neater if the array only contained entries whose
+ * default keystroke was non-null.  You COULD do this by defining
+ * ONLY_BOUND_BY_DEFAULT around various blocks at the cost of making
+ * the bindings file way more complicated.  However, we could stop this being
+ * data and move it into code.  Then the compiler would optimise away
+ * the problem lines.
+ */
+
+#define keybind(name, handler, param, flags, stroke, description) \
+  { #name, stroke },
+
+static MetaSimpleKeyMapping key_string_bindings[] = {
+#include "all-keybindings.h"
+  { NULL, NULL }
+};
+#undef keybind
+
+#endif /* NOT HAVE_MATECONF */
+
+static void
+init_bindings (void)
+{
+#ifdef HAVE_MATECONF
+  const char *prefix[] = {
+    KEY_WINDOW_BINDINGS_PREFIX,
+    KEY_SCREEN_BINDINGS_PREFIX,
+    NULL
+  };
+  int i;
+  GSList *list, *l, *list_val;
+  const char *str_val;
+  const char *key;
+  MateConfEntry *entry;
+  MateConfValue *value;
+
+  for (i = 0; prefix[i]; i++)
+    {
+      list = mateconf_client_all_entries (default_client, prefix[i], NULL);
+      for (l = list; l; l = l->next)
+        {
+          entry = l->data;
+          key = mateconf_entry_get_key (entry);
+          value = mateconf_entry_get_value (entry);
+          if (g_str_has_suffix (key, KEY_LIST_BINDINGS_SUFFIX))
+            {
+              list_val = mateconf_client_get_list (default_client, key, MATECONF_VALUE_STRING, NULL);
+ 
+              update_key_list_binding (key, list_val);
+              g_slist_foreach (list_val, (GFunc)g_free, NULL);
+              g_slist_free (list_val);
+            }
+          else
+            {
+              str_val = mateconf_value_get_string (value);
+              update_key_binding (key, str_val);
+            }
+          mateconf_entry_free (entry);
+        }
+      g_slist_free (list);
+    }
+#else /* HAVE_MATECONF */
+  int i = 0;
+  int which = 0;
+  while (key_string_bindings[i].name)
+    {
+      if (key_string_bindings[i].keybinding == NULL) {
+        ++i;
+        continue;
+      }
+    
+      while (strcmp(key_bindings[which].name, 
+                    key_string_bindings[i].name) != 0)
+        which++;
+
+      /* Set the binding */
+      update_binding (&key_bindings[which], 
+                      key_string_bindings[i].keybinding);
+
+      ++i;
+    }
+#endif /* HAVE_MATECONF */
+}
+
+static void
+init_commands (void)
+{
+#ifdef HAVE_MATECONF
+  GSList *list, *l;
+  const char *str_val;
+  const char *key;
+  MateConfEntry *entry;
+  MateConfValue *value;
+
+  list = mateconf_client_all_entries (default_client, KEY_COMMAND_DIRECTORY, NULL);
+  for (l = list; l; l = l->next)
+    {
+      entry = l->data;
+      key = mateconf_entry_get_key (entry);
+      value = mateconf_entry_get_value (entry);
+      str_val = mateconf_value_get_string (value);
+      update_command (key, str_val);
+      mateconf_entry_free (entry);
+    }
+  g_slist_free (list);
+#else
+  int i;
+  for (i = 0; i < MAX_COMMANDS; i++)
+    commands[i] = NULL;
+#endif /* HAVE_MATECONF */
+}
+
+static void
+init_workspace_names (void)
+{
+#ifdef HAVE_MATECONF
+  GSList *list, *l;
+  const char *str_val;
+  const char *key;
+  MateConfEntry *entry;
+  MateConfValue *value;
+
+  list = mateconf_client_all_entries (default_client, KEY_WORKSPACE_NAME_DIRECTORY, NULL);
+  for (l = list; l; l = l->next)
+    {
+      entry = l->data;
+      key = mateconf_entry_get_key (entry);
+      value = mateconf_entry_get_value (entry);
+      str_val = mateconf_value_get_string (value);
+      update_workspace_name (key, str_val);
+      mateconf_entry_free (entry);
+    }
+  g_slist_free (list);
+#else
+  int i;
+  for (i = 0; i < MAX_REASONABLE_WORKSPACES; i++)
+    workspace_names[i] = g_strdup_printf (_("Workspace %d"), i + 1);
+
+  meta_topic (META_DEBUG_PREFS,
+              "Initialized workspace names\n");
+#endif /* HAVE_MATECONF */
+}
+
+static gboolean
+update_binding (MetaKeyPref *binding,
+                const char  *value)
+{
+  unsigned int keysym;
+  unsigned int keycode;
+  MetaVirtualModifier mods;
+  MetaKeyCombo *combo;
+  gboolean changed;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Binding \"%s\" has new mateconf value \"%s\"\n",
+              binding->name, value ? value : "none");
+  
+  keysym = 0;
+  keycode = 0;
+  mods = 0;
+  if (value)
+    {
+      if (!meta_ui_parse_accelerator (value, &keysym, &keycode, &mods))
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Failed to parse new mateconf value\n");
+          meta_warning (_("\"%s\" found in configuration database is not a valid value for keybinding \"%s\"\n"),
+                        value, binding->name);
+
+          return FALSE;
+        }
+    }
+
+  /* If there isn't already a first element, make one. */
+  if (!binding->bindings)
+    {
+      MetaKeyCombo *blank = g_malloc0 (sizeof (MetaKeyCombo));
+      binding->bindings = g_slist_alloc();
+      binding->bindings->data = blank;
+    }
+  
+   combo = binding->bindings->data;
+
+#ifdef HAVE_MATECONF
+   /* Bug 329676: Bindings which can be shifted must not have no modifiers,
+    * nor only SHIFT as a modifier.
+    */
+
+  if (binding->add_shift &&
+      0 != keysym &&
+      (META_VIRTUAL_SHIFT_MASK == mods || 0 == mods))
+    {
+      gchar *old_setting;
+      gchar *key;
+      GError *err = NULL;
+      
+      meta_warning ("Cannot bind \"%s\" to %s: it needs a modifier "
+                    "such as Ctrl or Alt.\n",
+                    binding->name,
+                    value);
+
+      old_setting = meta_ui_accelerator_name (combo->keysym,
+                                              combo->modifiers);
+
+      if (!strcmp(old_setting, value))
+        {
+          /* We were about to set it to the same value
+           * that it had originally! This must be caused
+           * by getting an invalid string back from
+           * meta_ui_accelerator_name. Bail out now
+           * so we don't get into an infinite loop.
+           */
+           g_free (old_setting);
+           return TRUE;
+        }
+
+      meta_warning ("Reverting \"%s\" to %s.\n",
+                    binding->name,
+                    old_setting);
+
+      /* FIXME: add_shift is currently screen_bindings only, but
+       * there's no really good reason it should always be.
+       * So we shouldn't blindly add KEY_SCREEN_BINDINGS_PREFIX
+       * onto here.
+       */
+      key = g_strconcat (KEY_SCREEN_BINDINGS_PREFIX, "/",
+                         binding->name, NULL);
+      
+      mateconf_client_set_string (mateconf_client_get_default (),
+                               key, old_setting, &err);
+
+      if (err)
+        {
+          meta_warning ("Error while reverting keybinding: %s\n",
+                        err->message);
+          g_error_free (err);
+          err = NULL;
+        }
+      
+      g_free (old_setting);
+      g_free (key);
+
+      /* The call to mateconf_client_set_string() will cause this function
+       * to be called again with the new value, so there's no need to
+       * carry on.
+       */
+      return TRUE;
+    }
+#endif
+  
+  changed = FALSE;
+  if (keysym != combo->keysym ||
+      keycode != combo->keycode ||
+      mods != combo->modifiers)
+    {
+      changed = TRUE;
+      
+      combo->keysym = keysym;
+      combo->keycode = keycode;
+      combo->modifiers = mods;
+      
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "New keybinding for \"%s\" is keysym = 0x%x keycode = 0x%x mods = 0x%x\n",
+                  binding->name, combo->keysym, combo->keycode,
+                  combo->modifiers);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Keybinding for \"%s\" is unchanged\n", binding->name);
+    }
+  
+  return changed;
+}
+
+#ifdef HAVE_MATECONF
+static gboolean
+update_list_binding (MetaKeyPref *binding,
+                     GSList      *value,
+                     MetaStringListType type_of_value)
+{
+  unsigned int keysym;
+  unsigned int keycode;
+  MetaVirtualModifier mods;
+  gboolean changed = FALSE;
+  const gchar *pref_string;
+  GSList *pref_iterator = value, *tmp;
+  MetaKeyCombo *combo;
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Binding \"%s\" has new mateconf value\n",
+              binding->name);
+  
+  if (binding->bindings == NULL)
+    {
+      /* We need to insert a dummy element into the list, because the first
+       * element is the one governed by update_binding. We only handle the
+       * subsequent elements.
+       */
+      MetaKeyCombo *blank = g_malloc0 (sizeof (MetaKeyCombo));
+      binding->bindings = g_slist_alloc();
+      binding->bindings->data = blank;
+    }
+       
+  /* Okay, so, we're about to provide a new list of key combos for this
+   * action. Delete any pre-existing list.
+   */
+  tmp = binding->bindings->next;
+  while (tmp)
+    {
+      g_free (tmp->data);
+      tmp = tmp->next;
+    }
+  g_slist_free (binding->bindings->next);
+  binding->bindings->next = NULL;
+  
+  while (pref_iterator)
+    {
+      keysym = 0;
+      keycode = 0;
+      mods = 0;
+
+      if (!pref_iterator->data)
+        {
+          pref_iterator = pref_iterator->next;
+          continue;
+        }
+
+      switch (type_of_value)
+        {
+        case META_LIST_OF_STRINGS:
+          pref_string = pref_iterator->data;
+          break;
+        case META_LIST_OF_MATECONFVALUE_STRINGS:
+          pref_string = mateconf_value_get_string (pref_iterator->data);
+          break;
+        default:
+          g_assert_not_reached ();
+        }
+      
+      if (!meta_ui_parse_accelerator (pref_string, &keysym, &keycode, &mods))
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Failed to parse new mateconf value\n");
+          meta_warning (_("\"%s\" found in configuration database is not a valid value for keybinding \"%s\"\n"),
+                        pref_string, binding->name);
+
+          /* Should we remove this value from the list in mateconf? */
+          pref_iterator = pref_iterator->next;
+          continue;
+        }
+
+      /* Bug 329676: Bindings which can be shifted must not have no modifiers,
+       * nor only SHIFT as a modifier.
+       */
+
+      if (binding->add_shift &&
+          0 != keysym &&
+          (META_VIRTUAL_SHIFT_MASK == mods || 0 == mods))
+        {
+          meta_warning ("Cannot bind \"%s\" to %s: it needs a modifier "
+                        "such as Ctrl or Alt.\n",
+                        binding->name,
+                        pref_string);
+
+          /* Should we remove this value from the list in mateconf? */
+
+          pref_iterator = pref_iterator->next;
+          continue;
+        }
+  
+      changed = TRUE;
+
+      combo = g_malloc0 (sizeof (MetaKeyCombo));
+      combo->keysym = keysym;
+      combo->keycode = keycode;
+      combo->modifiers = mods;
+      binding->bindings->next = g_slist_prepend (binding->bindings->next, combo);
+
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                      "New keybinding for \"%s\" is keysym = 0x%x keycode = 0x%x mods = 0x%x\n",
+                      binding->name, keysym, keycode, mods);
+
+      pref_iterator = pref_iterator->next;
+    }  
+  return changed;
+}
+
+static const gchar*
+relative_key (const gchar* key)
+{
+  const gchar* end;
+  
+  end = strrchr (key, '/');
+
+  ++end;
+
+  return end;
+}
+
+/* Return value is TRUE if a preference changed and we need to
+ * notify
+ */
+static gboolean
+find_and_update_binding (MetaKeyPref *bindings, 
+                         const char  *name,
+                         const char  *value)
+{
+  const char *key;
+  int i;
+  
+  if (*name == '/')
+    key = relative_key (name);
+  else
+    key = name;
+
+  i = 0;
+  while (bindings[i].name &&
+         strcmp (key, bindings[i].name) != 0)
+    ++i;
+
+  if (bindings[i].name)
+    return update_binding (&bindings[i], value);
+  else
+    return FALSE;
+}
+
+static gboolean
+update_key_binding (const char *name,
+                       const char *value)
+{
+  return find_and_update_binding (key_bindings, name, value);
+}
+
+static gboolean
+find_and_update_list_binding (MetaKeyPref *bindings,
+                              const char  *name,
+                              GSList      *value)
+{
+  const char *key;
+  int i;
+  gchar *name_without_suffix = g_strdup(name);
+
+  name_without_suffix[strlen(name_without_suffix) - strlen(KEY_LIST_BINDINGS_SUFFIX)] = 0;
+
+  if (*name_without_suffix == '/')
+    key = relative_key (name_without_suffix);
+  else
+    key = name_without_suffix;
+
+  i = 0;
+  while (bindings[i].name &&
+         strcmp (key, bindings[i].name) != 0)
+    ++i;
+
+  g_free (name_without_suffix);
+
+  if (bindings[i].name)
+    return update_list_binding (&bindings[i], value, META_LIST_OF_MATECONFVALUE_STRINGS);
+  else
+    return FALSE;
+}
+
+static gboolean
+update_key_list_binding (const char *name,
+                            GSList *value)
+{
+  return find_and_update_list_binding (key_bindings, name, value);
+}
+
+static gboolean
+update_command (const char  *name,
+                const char  *value)
+{
+  char *p;
+  int i;
+  
+  p = strrchr (name, '_');
+  if (p == NULL)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Command %s has no underscore?\n", name);
+      return FALSE;
+    }
+  
+  ++p;
+
+  if (g_ascii_isdigit (*p))
+    {
+      i = atoi (p);
+      i -= 1; /* count from 0 not 1 */
+    }
+  else
+    {
+      p = strrchr (name, '/');
+      ++p;
+
+      if (strcmp (p, "command_screenshot") == 0)
+        {
+          i = SCREENSHOT_COMMAND_IDX;
+        }
+      else if (strcmp (p, "command_window_screenshot") == 0)
+        {
+          i = WIN_SCREENSHOT_COMMAND_IDX;
+        }
+      else
+        {
+          meta_topic (META_DEBUG_KEYBINDINGS,
+                      "Command %s doesn't end in number?\n", name);
+          return FALSE;
+        }
+    }
+  
+  if (i >= MAX_COMMANDS)
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Command %d is too highly numbered, ignoring\n", i);
+      return FALSE;
+    }
+
+  if ((commands[i] == NULL && value == NULL) ||
+      (commands[i] && value && strcmp (commands[i], value) == 0))
+    {
+      meta_topic (META_DEBUG_KEYBINDINGS,
+                  "Command %d is unchanged\n", i);
+      return FALSE;
+    }
+  
+  g_free (commands[i]);
+  commands[i] = g_strdup (value);
+
+  meta_topic (META_DEBUG_KEYBINDINGS,
+              "Updated command %d to \"%s\"\n",
+              i, commands[i] ? commands[i] : "none");
+  
+  return TRUE;
+}
+
+#endif /* HAVE_MATECONF */
+
+const char*
+meta_prefs_get_command (int i)
+{
+  g_return_val_if_fail (i >= 0 && i < MAX_COMMANDS, NULL);
+  
+  return commands[i];
+}
+
+char*
+meta_prefs_get_mateconf_key_for_command (int i)
+{
+  char *key;
+
+  switch (i)
+    {
+    case SCREENSHOT_COMMAND_IDX:
+      key = g_strdup (KEY_COMMAND_PREFIX "screenshot");
+      break;
+    case WIN_SCREENSHOT_COMMAND_IDX:
+      key = g_strdup (KEY_COMMAND_PREFIX "window_screenshot");
+      break;
+    default:
+      key = g_strdup_printf (KEY_COMMAND_PREFIX"%d", i + 1);
+      break;
+    }
+  
+  return key;
+}
+
+const char*
+meta_prefs_get_terminal_command (void)
+{
+  return terminal_command;
+}
+
+const char*
+meta_prefs_get_mateconf_key_for_terminal_command (void)
+{
+  return KEY_TERMINAL_COMMAND;
+}
+
+#ifdef HAVE_MATECONF
+static gboolean
+update_workspace_name (const char  *name,
+                       const char  *value)
+{
+  char *p;
+  int i;
+  
+  p = strrchr (name, '_');
+  if (p == NULL)
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace name %s has no underscore?\n", name);
+      return FALSE;
+    }
+  
+  ++p;
+
+  if (!g_ascii_isdigit (*p))
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace name %s doesn't end in number?\n", name);
+      return FALSE;
+    }
+  
+  i = atoi (p);
+  i -= 1; /* count from 0 not 1 */
+  
+  if (i >= MAX_REASONABLE_WORKSPACES)
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace name %d is too highly numbered, ignoring\n", i);
+      return FALSE;
+    }
+
+  if (workspace_names[i] && value && strcmp (workspace_names[i], value) == 0)
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace name %d is unchanged\n", i);
+      return FALSE;
+    }  
+
+  /* This is a bad hack. We have to treat empty string as
+   * "unset" because the root window property can't contain
+   * null. So it gets empty string instead and we don't want
+   * that to result in setting the empty string as a value that
+   * overrides "unset".
+   */
+  if (value != NULL && *value != '\0')
+    {
+      g_free (workspace_names[i]);
+      workspace_names[i] = g_strdup (value);
+    }
+  else
+    {
+      /* use a default name */
+      char *d;
+
+      d = g_strdup_printf (_("Workspace %d"), i + 1);
+      if (workspace_names[i] && strcmp (workspace_names[i], d) == 0)
+        {
+          g_free (d);
+          return FALSE;
+        }
+      else
+        {
+          g_free (workspace_names[i]);
+          workspace_names[i] = d;
+        }
+    }
+  
+  meta_topic (META_DEBUG_PREFS,
+              "Updated workspace name %d to \"%s\"\n",
+              i, workspace_names[i] ? workspace_names[i] : "none");
+  
+  return TRUE;
+}
+#endif /* HAVE_MATECONF */
+
+const char*
+meta_prefs_get_workspace_name (int i)
+{
+  g_return_val_if_fail (i >= 0 && i < MAX_REASONABLE_WORKSPACES, NULL);
+
+  g_assert (workspace_names[i] != NULL);
+
+  meta_topic (META_DEBUG_PREFS,
+              "Getting workspace name for %d: \"%s\"\n",
+              i, workspace_names[i]);
+  
+  return workspace_names[i];
+}
+
+void
+meta_prefs_change_workspace_name (int         i,
+                                  const char *name)
+{
+#ifdef HAVE_MATECONF
+  char *key;
+  GError *err;
+  
+  g_return_if_fail (i >= 0 && i < MAX_REASONABLE_WORKSPACES);
+
+  meta_topic (META_DEBUG_PREFS,
+              "Changing name of workspace %d to %s\n",
+              i, name ? name : "none");
+
+  /* This is a bad hack. We have to treat empty string as
+   * "unset" because the root window property can't contain
+   * null. So it gets empty string instead and we don't want
+   * that to result in setting the empty string as a value that
+   * overrides "unset".
+   */
+  if (name && *name == '\0')
+    name = NULL;
+  
+  if ((name == NULL && workspace_names[i] == NULL) ||
+      (name && workspace_names[i] && strcmp (name, workspace_names[i]) == 0))
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Workspace %d already has name %s\n",
+                  i, name ? name : "none");
+      return;
+    }
+  
+  key = mateconf_key_for_workspace_name (i);
+
+  err = NULL;
+  if (name != NULL)
+    mateconf_client_set_string (default_client,
+                             key, name,
+                             &err);
+  else
+    mateconf_client_unset (default_client,
+                        key, &err);
+
+  
+  if (err)
+    {
+      meta_warning (_("Error setting name for workspace %d to \"%s\": %s\n"),
+                    i, name ? name : "none",
+                    err->message);
+      g_error_free (err);
+    }
+  
+  g_free (key);
+#else
+  g_free (workspace_names[i]);
+  workspace_names[i] = g_strdup (name);
+#endif /* HAVE_MATECONF */
+}
+
+#ifdef HAVE_MATECONF
+static char*
+mateconf_key_for_workspace_name (int i)
+{
+  char *key;
+  
+  key = g_strdup_printf (KEY_WORKSPACE_NAME_PREFIX"%d", i + 1);
+  
+  return key;
+}
+#endif /* HAVE_MATECONF */
+
+void
+meta_prefs_get_button_layout (MetaButtonLayout *button_layout_p)
+{
+  *button_layout_p = button_layout;
+}
+
+gboolean
+meta_prefs_get_visual_bell (void)
+{
+  return provide_visual_bell;
+}
+
+gboolean
+meta_prefs_bell_is_audible (void)
+{
+  return bell_is_audible;
+}
+
+MetaVisualBellType
+meta_prefs_get_visual_bell_type (void)
+{
+  return visual_bell_type;
+}
+
+void
+meta_prefs_get_key_bindings (const MetaKeyPref **bindings,
+                                int                *n_bindings)
+{
+  
+  *bindings = key_bindings;
+  *n_bindings = (int) G_N_ELEMENTS (key_bindings) - 1;
+}
+
+MetaActionTitlebar
+meta_prefs_get_action_double_click_titlebar (void)
+{
+  return action_double_click_titlebar;
+}
+
+MetaActionTitlebar
+meta_prefs_get_action_middle_click_titlebar (void)
+{
+  return action_middle_click_titlebar;
+}
+
+MetaActionTitlebar
+meta_prefs_get_action_right_click_titlebar (void)
+{
+  return action_right_click_titlebar;
+}
+
+gboolean
+meta_prefs_get_auto_raise (void)
+{
+  return auto_raise;
+}
+
+int
+meta_prefs_get_auto_raise_delay (void)
+{
+  return auto_raise_delay;
+}
+
+gboolean
+meta_prefs_get_reduced_resources (void)
+{
+  return reduced_resources;
+}
+
+gboolean
+meta_prefs_get_mate_accessibility ()
+{
+  return mate_accessibility;
+}
+
+gboolean
+meta_prefs_get_mate_animations ()
+{
+  return mate_animations;
+}
+
+MetaKeyBindingAction
+meta_prefs_get_keybinding_action (const char *name)
+{
+  int i;
+
+  i = G_N_ELEMENTS (key_bindings) - 2; /* -2 for dummy entry at end */
+  while (i >= 0)
+    {
+      if (strcmp (key_bindings[i].name, name) == 0)
+        return (MetaKeyBindingAction) i;
+      
+      --i;
+    }
+
+  return META_KEYBINDING_ACTION_NONE;
+}
+
+/* This is used by the menu system to decide what key binding
+ * to display next to an option. We return the first non-disabled
+ * binding, if any.
+ */
+void
+meta_prefs_get_window_binding (const char          *name,
+                               unsigned int        *keysym,
+                               MetaVirtualModifier *modifiers)
+{
+  int i;
+
+  i = G_N_ELEMENTS (key_bindings) - 2; /* -2 for dummy entry at end */
+  while (i >= 0)
+    {
+      if (key_bindings[i].per_window &&
+          strcmp (key_bindings[i].name, name) == 0)
+        {
+          GSList *s = key_bindings[i].bindings;
+
+          while (s)
+            {
+              MetaKeyCombo *c = s->data;
+
+              if (c->keysym!=0 || c->modifiers!=0)
+                {
+                  *keysym = c->keysym;
+                  *modifiers = c->modifiers;
+                  return;
+                }
+
+              s = s->next;
+            }
+
+          /* Not found; return the disabled value */
+          *keysym = *modifiers = 0;
+          return;
+        }
+      
+      --i;
+    }
+
+  g_assert_not_reached ();
+}
+
+gboolean
+meta_prefs_get_compositing_manager (void)
+{
+  return compositing_manager;
+}
+
+guint
+meta_prefs_get_mouse_button_resize (void)
+{
+  return resize_with_right_button ? 3: 2;
+}
+
+guint
+meta_prefs_get_mouse_button_menu (void)
+{
+  return resize_with_right_button ? 2: 3;
+}
+
+gboolean
+meta_prefs_get_force_fullscreen (void)
+{
+  return force_fullscreen;
+}
+
+void
+meta_prefs_set_compositing_manager (gboolean whether)
+{
+#ifdef HAVE_MATECONF
+  GError *err = NULL;
+
+  mateconf_client_set_bool (default_client,
+                         KEY_COMPOSITOR,
+                         whether,
+                         &err);
+
+  if (err)
+    {
+      meta_warning (_("Error setting compositor status: %s\n"),
+                    err->message);
+      g_error_free (err);
+    }
+#else
+  compositing_manager = whether;
+#endif
+}
+
+#ifndef HAVE_MATECONF
+static void
+init_button_layout(void)
+{
+  MetaButtonLayout button_layout_ltr = {
+    {    
+      /* buttons in the group on the left side */
+      META_BUTTON_FUNCTION_MENU,
+      META_BUTTON_FUNCTION_LAST
+    },
+    {
+      /* buttons in the group on the right side */
+      META_BUTTON_FUNCTION_MINIMIZE,
+      META_BUTTON_FUNCTION_MAXIMIZE,
+      META_BUTTON_FUNCTION_CLOSE,
+      META_BUTTON_FUNCTION_LAST
+    }
+  };
+  MetaButtonLayout button_layout_rtl = {
+    {    
+      /* buttons in the group on the left side */
+      META_BUTTON_FUNCTION_CLOSE,
+      META_BUTTON_FUNCTION_MAXIMIZE,
+      META_BUTTON_FUNCTION_MINIMIZE,
+      META_BUTTON_FUNCTION_LAST
+    },
+    {
+      /* buttons in the group on the right side */
+      META_BUTTON_FUNCTION_MENU,
+      META_BUTTON_FUNCTION_LAST
+    }
+  };
+
+  button_layout = meta_ui_get_direction() == META_UI_DIRECTION_LTR ?
+    button_layout_ltr : button_layout_rtl;
+};
+
+#endif
+
+void
+meta_prefs_set_force_fullscreen (gboolean whether)
+{
+  force_fullscreen = whether;
+}
+
diff --git a/src/core/schema-bindings.c b/src/core/schema-bindings.c
new file mode 100644
index 00000000..2f1da821
--- /dev/null
+++ b/src/core/schema-bindings.c
@@ -0,0 +1,195 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Thomas Thurman
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/** \file  Schema bindings generator.
+ *
+ * This program simply takes the items given in the binding list in
+ * all-keybindings.h and turns them into a portion of
+ * the MateConf .schemas file.
+ *
+ * FIXME: also need to make 50-marco-desktop-key.xml
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include <glib.h>
+#include "config.h"
+
+#define _(x) x
+
+static void single_stanza (gboolean is_window, const char *name,
+               const char *default_value,
+               gboolean can_reverse,
+               const char *description);
+
+char *about_keybindings, *about_reversible_keybindings;
+
+char *source_filename, *target_filename;
+FILE *source_file, *target_file;
+
+static void
+single_stanza (gboolean is_window, const char *name,
+               const char *default_value,
+               gboolean can_reverse,
+               const char *description)
+{
+  char *keybinding_type = is_window? "window": "global";
+  char *escaped_default_value, *escaped_description;
+
+  if (description==NULL)
+    return; /* it must be undocumented, so it can't go in this table */
+
+  escaped_description = g_markup_escape_text (description, -1);
+  escaped_default_value = default_value==NULL? "disabled":
+        g_markup_escape_text (default_value, -1);
+  
+  fprintf (target_file, "    <schema>\n");
+  fprintf (target_file, "      <key>/schemas/apps/marco/%s_keybindings/%s</key>\n",
+            keybinding_type, name);
+  fprintf (target_file, "      <applyto>/apps/marco/%s_keybindings/%s</applyto>\n",
+            keybinding_type, name);
+  fprintf (target_file, "      <owner>marco</owner>\n");
+  fprintf (target_file, "      <type>string</type>\n");
+  fprintf (target_file, "      <default>%s</default>\n", escaped_default_value);
+  
+  fprintf (target_file, "      <locale name=\"C\">\n");
+  fprintf (target_file, "        <short>%s</short>\n", description);
+  fprintf (target_file, "        <long>%s</long>\n",
+                   can_reverse? about_reversible_keybindings:
+                   about_keybindings);
+  fprintf (target_file, "      </locale>\n");
+  fprintf (target_file, "    </schema>\n\n");
+
+  g_free (escaped_description);
+
+  if (default_value!=NULL)
+    g_free (escaped_default_value);
+}
+
+static void produce_bindings ();
+
+static void
+produce_bindings ()
+{
+  /* 10240 is ridiculous overkill; we're writing the input file and
+   * the lines are always 80 chars or less.
+   */
+  char buffer[10240];
+
+  source_file = fopen(source_filename, "r");
+
+  if (!source_file)
+    {
+      g_error ("Cannot compile without %s: %s\n",
+        source_filename, strerror (errno));
+    }
+
+  target_file = fopen(target_filename, "w");
+
+  if (!target_file)
+    {
+      g_error ("Cannot create %s: %s\n",
+        target_filename, strerror (errno));
+    }
+
+  while (fgets (buffer, sizeof (buffer), source_file))
+    {
+      if (strstr (buffer, "<!-- GENERATED -->"))
+         break;
+         
+      fprintf (target_file, "%s", buffer);
+    }
+
+  if (!feof (source_file))
+    {
+#define keybind(name, handler, param, flags, stroke, description) \
+  single_stanza ( \
+               flags & BINDING_PER_WINDOW, \
+               #name, \
+               stroke, \
+               flags & BINDING_REVERSES, \
+               description);
+#include "all-keybindings.h"
+#undef keybind
+    }
+
+  while (fgets (buffer, sizeof (buffer), source_file))
+      fprintf (target_file, "%s", buffer);
+
+  if (fclose (source_file)!=0)
+    {
+      g_error ("Cannot close %s: %s\n",
+        source_filename, strerror (errno));
+    }
+
+  if (fclose (target_file)!=0)
+    {
+      g_error ("Cannot close %s: %s\n",
+        target_filename, strerror (errno));
+    }
+}
+
+int
+main (int argc, char **argv)
+{
+  if (argc!=3)
+    {
+      g_error ("Syntax: %s <source.in.in> <target.in>\n", argv[0]);
+    }
+  
+  source_filename = argv[1];
+  target_filename = argv[2];
+
+  /* Translators: Please don't translate "Control", "Shift", etc, since these
+   * are hardcoded (in gtk/gtkaccelgroup.c; it's not marco's fault).
+   * "disabled" must also stay as it is.
+   */
+  about_keybindings = g_markup_escape_text(_( \
+        "The format looks like \"<Control>a\" or \"<Shift><Alt>F1\".\n\n"\
+        "The parser is fairly liberal and allows "\
+  	"lower or upper case, and also abbreviations such as \"<Ctl>\" and " \
+	"\"<Ctrl>\". If you set the option to the special string " \
+	"\"disabled\", then there will be no keybinding for this action."),
+        -1);
+
+  about_reversible_keybindings = g_markup_escape_text(_( \
+        "The format looks like \"<Control>a\" or \"<Shift><Alt>F1\".\n\n"\
+        "The parser is fairly liberal and allows "\
+  	"lower or upper case, and also abbreviations such as \"<Ctl>\" and " \
+	"\"<Ctrl>\". If you set the option to the special string " \
+	"\"disabled\", then there will be no keybinding for this action.\n\n"\
+	"This keybinding may be reversed by holding down the \"shift\" key; "
+	"therefore, \"shift\" cannot be one of the keys it uses."),
+	-1);
+
+  produce_bindings ();
+
+  g_free (about_keybindings);
+  g_free (about_reversible_keybindings);
+  
+  return 0;
+}
+
+/* eof schema-bindings.c */
+
diff --git a/src/core/screen-private.h b/src/core/screen-private.h
new file mode 100644
index 00000000..30941eab
--- /dev/null
+++ b/src/core/screen-private.h
@@ -0,0 +1,226 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file screen-private.h  Screens which Marco manages
+ *
+ * Managing X screens.
+ * This file contains methods on this class which are available to
+ * routines in core but not outside it.  (See screen.h for the routines
+ * which the rest of the world is allowed to use.)
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_SCREEN_PRIVATE_H
+#define META_SCREEN_PRIVATE_H
+
+#include "display-private.h"
+#include "screen.h"
+#include <X11/Xutil.h>
+#include "ui.h"
+
+typedef struct _MetaXineramaScreenInfo MetaXineramaScreenInfo;
+
+struct _MetaXineramaScreenInfo
+{
+  int number;
+  MetaRectangle rect;
+};
+
+typedef void (* MetaScreenWindowFunc) (MetaScreen *screen, MetaWindow *window,
+                                       gpointer user_data);
+
+typedef enum
+{
+  META_SCREEN_TOPLEFT,
+  META_SCREEN_TOPRIGHT,
+  META_SCREEN_BOTTOMLEFT,
+  META_SCREEN_BOTTOMRIGHT
+} MetaScreenCorner;
+
+typedef enum
+{
+  META_SCREEN_UP,
+  META_SCREEN_DOWN,
+  META_SCREEN_LEFT,
+  META_SCREEN_RIGHT
+} MetaScreenDirection;
+
+#define META_WIREFRAME_XOR_LINE_WIDTH 2
+
+struct _MetaScreen
+{
+  MetaDisplay *display;
+  int number;
+  char *screen_name;
+  Screen *xscreen;
+  Window xroot;
+  int default_depth;
+  Visual *default_xvisual;
+  MetaRectangle rect;  /* Size of screen; rect.x & rect.y are always 0 */
+  MetaUI *ui;
+  MetaTabPopup *tab_popup;
+  
+  MetaWorkspace *active_workspace;
+
+  /* This window holds the focus when we don't want to focus
+   * any actual clients
+   */
+  Window no_focus_window;
+  
+  GList *workspaces;
+
+  MetaStack *stack;
+
+  MetaCursor current_cursor;
+
+  Window flash_window;
+
+  Window wm_sn_selection_window;
+  Atom wm_sn_atom;
+  guint32 wm_sn_timestamp;
+  
+  MetaXineramaScreenInfo *xinerama_infos;
+  int n_xinerama_infos;
+
+  /* Cache the current Xinerama */
+  int last_xinerama_index;
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  SnMonitorContext *sn_context;
+  GSList *startup_sequences;
+  guint startup_sequence_timeout;
+#endif
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  Window wm_cm_selection_window;
+  guint32 wm_cm_timestamp;
+#endif
+
+  guint work_area_idle;
+
+  int rows_of_workspaces;
+  int columns_of_workspaces;
+  MetaScreenCorner starting_corner;
+  guint vertical_workspaces : 1;
+  
+  guint keys_grabbed : 1;
+  guint all_keys_grabbed : 1;
+  
+  int closing;
+
+  /* gc for XOR on root window */
+  GC root_xor_gc;
+
+  /* Managed by compositor.c */
+  gpointer compositor_data;
+};
+
+MetaScreen*   meta_screen_new                 (MetaDisplay                *display,
+                                               int                         number,
+                                               guint32                     timestamp);
+void          meta_screen_free                (MetaScreen                 *screen,
+                                               guint32                     timestamp);
+void          meta_screen_manage_all_windows  (MetaScreen                 *screen);
+void          meta_screen_foreach_window      (MetaScreen                 *screen,
+                                               MetaScreenWindowFunc        func,
+                                               gpointer                    data);
+void          meta_screen_queue_frame_redraws (MetaScreen                 *screen);
+void          meta_screen_queue_window_resizes (MetaScreen                 *screen);
+
+int           meta_screen_get_n_workspaces    (MetaScreen                 *screen);
+
+MetaWorkspace* meta_screen_get_workspace_by_index (MetaScreen    *screen,
+                                                   int            index);
+
+void          meta_screen_set_cursor          (MetaScreen                 *screen,
+                                               MetaCursor                  cursor);
+void          meta_screen_update_cursor       (MetaScreen                 *screen);
+
+void          meta_screen_ensure_tab_popup    (MetaScreen                 *screen,
+                                               MetaTabList                 list_type,
+                                               MetaTabShowType             show_type);
+void          meta_screen_ensure_workspace_popup (MetaScreen *screen);
+
+MetaWindow*   meta_screen_get_mouse_window     (MetaScreen                 *screen,
+                                                MetaWindow                 *not_this_one);
+
+const MetaXineramaScreenInfo* meta_screen_get_current_xinerama    (MetaScreen    *screen);
+const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_rect   (MetaScreen    *screen,
+                                                                   MetaRectangle *rect);
+const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_window (MetaScreen    *screen,
+                                                                   MetaWindow    *window);
+
+
+const MetaXineramaScreenInfo* meta_screen_get_xinerama_neighbor (MetaScreen *screen,
+                                                                 int         which_xinerama,
+                                                                 MetaScreenDirection dir);
+void          meta_screen_get_natural_xinerama_list (MetaScreen *screen,
+                                                     int**       xineramas_list,
+                                                     int*        n_xineramas);
+
+void          meta_screen_update_workspace_layout (MetaScreen             *screen);
+void          meta_screen_update_workspace_names  (MetaScreen             *screen);
+void          meta_screen_queue_workarea_recalc   (MetaScreen             *screen);
+
+Window meta_create_offscreen_window (Display *xdisplay,
+                                     Window   parent,
+                                     long     valuemask);
+
+typedef struct MetaWorkspaceLayout MetaWorkspaceLayout;
+
+struct MetaWorkspaceLayout
+{
+  int rows;
+  int cols;
+  int *grid;
+  int grid_area;
+  int current_row;
+  int current_col;
+};
+
+void meta_screen_calc_workspace_layout (MetaScreen          *screen,
+                                        int                  num_workspaces,
+                                        int                  current_space,
+                                        MetaWorkspaceLayout *layout);
+void meta_screen_free_workspace_layout (MetaWorkspaceLayout *layout);
+
+void meta_screen_resize (MetaScreen *screen,
+                         int         width,
+                         int         height);
+
+void     meta_screen_minimize_all_on_active_workspace_except (MetaScreen *screen,
+                                                              MetaWindow *keep);
+
+/* Show/hide the desktop (temporarily hide all windows) */
+void     meta_screen_show_desktop        (MetaScreen *screen,
+                                          guint32     timestamp);
+void     meta_screen_unshow_desktop      (MetaScreen *screen);
+
+/* Update whether the destkop is being shown for the current active_workspace */
+void     meta_screen_update_showing_desktop_hint          (MetaScreen *screen);
+
+gboolean meta_screen_apply_startup_properties (MetaScreen *screen,
+                                               MetaWindow *window);
+void	 meta_screen_composite_all_windows (MetaScreen *screen);
+
+#endif
diff --git a/src/core/screen.c b/src/core/screen.c
new file mode 100644
index 00000000..f9db9c71
--- /dev/null
+++ b/src/core/screen.c
@@ -0,0 +1,2815 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X screen handler */
+
+/* 
+ * Copyright (C) 2001, 2002 Havoc Pennington
+ * Copyright (C) 2002, 2003 Red Hat Inc.
+ * Some ICCCM manager selection code derived from fvwm2,
+ * Copyright (C) 2001 Dominik Vogt, Matthias Clasen, and fvwm2 team
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "screen-private.h"
+#include "util.h"
+#include "errors.h"
+#include "window-private.h"
+#include "frame-private.h"
+#include "prefs.h"
+#include "workspace.h"
+#include "keybindings.h"
+#include "stack.h"
+#include "xprops.h"
+#include "compositor.h"
+
+#ifdef HAVE_SOLARIS_XINERAMA
+#include <X11/extensions/xinerama.h>
+#endif
+#ifdef HAVE_XFREE_XINERAMA
+#include <X11/extensions/Xinerama.h>
+#endif
+
+#include <X11/Xatom.h>
+#include <locale.h>
+#include <string.h>
+#include <stdio.h>
+
+static char* get_screen_name (MetaDisplay *display,
+                              int          number);
+
+static void update_num_workspaces  (MetaScreen *screen,
+                                    guint32     timestamp);
+static void update_focus_mode      (MetaScreen *screen);
+static void set_workspace_names    (MetaScreen *screen);
+static void prefs_changed_callback (MetaPreference pref,
+                                    gpointer       data);
+
+static void set_desktop_geometry_hint (MetaScreen *screen);
+static void set_desktop_viewport_hint (MetaScreen *screen);
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+static void meta_screen_sn_event   (SnMonitorEvent *event,
+                                    void           *user_data);
+#endif
+
+static int
+set_wm_check_hint (MetaScreen *screen)
+{
+  unsigned long data[1];
+
+  g_return_val_if_fail (screen->display->leader_window != None, 0);
+  
+  data[0] = screen->display->leader_window;
+
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_SUPPORTING_WM_CHECK,
+                   XA_WINDOW,
+                   32, PropModeReplace, (guchar*) data, 1);
+
+  return Success;
+}
+
+static void
+unset_wm_check_hint (MetaScreen *screen)
+{
+  XDeleteProperty (screen->display->xdisplay, screen->xroot, 
+                   screen->display->atom__NET_SUPPORTING_WM_CHECK);
+}
+
+static int
+set_supported_hint (MetaScreen *screen)
+{
+  Atom atoms[] = {
+#define EWMH_ATOMS_ONLY
+#define item(x)  screen->display->atom_##x,
+#include "atomnames.h"
+#undef item
+#undef EWMH_ATOMS_ONLY
+  };
+
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_SUPPORTED,
+                   XA_ATOM,
+                   32, PropModeReplace,
+                   (guchar*) atoms, G_N_ELEMENTS(atoms));
+  
+  return Success;
+}
+
+static int
+set_wm_icon_size_hint (MetaScreen *screen)
+{
+#define N_VALS 6
+  gulong vals[N_VALS];
+
+  /* min width, min height, max w, max h, width inc, height inc */
+  vals[0] = META_ICON_WIDTH;
+  vals[1] = META_ICON_HEIGHT;
+  vals[2] = META_ICON_WIDTH;
+  vals[3] = META_ICON_HEIGHT;
+  vals[4] = 0;
+  vals[5] = 0;
+  
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom_WM_ICON_SIZE,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) vals, N_VALS);
+  
+  return Success;
+#undef N_VALS
+}
+
+static void
+reload_xinerama_infos (MetaScreen *screen)
+{
+  MetaDisplay *display;
+
+  {
+    GList *tmp;
+
+    tmp = screen->workspaces;
+    while (tmp != NULL)
+      {
+        MetaWorkspace *space = tmp->data;
+
+        meta_workspace_invalidate_work_area (space);
+        
+        tmp = tmp->next;
+      }
+  }
+
+  display = screen->display;
+  
+  if (screen->xinerama_infos)
+    g_free (screen->xinerama_infos);
+  
+  screen->xinerama_infos = NULL;
+  screen->n_xinerama_infos = 0;
+  screen->last_xinerama_index = 0;
+
+  screen->display->xinerama_cache_invalidated = TRUE;
+  
+#ifdef HAVE_XFREE_XINERAMA
+  if (XineramaIsActive (display->xdisplay))
+    {
+      XineramaScreenInfo *infos;
+      int n_infos;
+      int i;
+      
+      n_infos = 0;
+      infos = XineramaQueryScreens (display->xdisplay, &n_infos);
+
+      meta_topic (META_DEBUG_XINERAMA,
+                  "Found %d Xinerama screens on display %s\n",
+                  n_infos, display->name);
+
+      if (n_infos > 0)
+        {
+          screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_infos);
+          screen->n_xinerama_infos = n_infos;
+          
+          i = 0;
+          while (i < n_infos)
+            {
+              screen->xinerama_infos[i].number = infos[i].screen_number;
+              screen->xinerama_infos[i].rect.x = infos[i].x_org;
+              screen->xinerama_infos[i].rect.y = infos[i].y_org;
+              screen->xinerama_infos[i].rect.width = infos[i].width;
+              screen->xinerama_infos[i].rect.height = infos[i].height;
+
+              meta_topic (META_DEBUG_XINERAMA,
+                          "Xinerama %d is %d,%d %d x %d\n",
+                          screen->xinerama_infos[i].number,
+                          screen->xinerama_infos[i].rect.x,
+                          screen->xinerama_infos[i].rect.y,
+                          screen->xinerama_infos[i].rect.width,
+                          screen->xinerama_infos[i].rect.height);
+              
+              ++i;
+            }
+        }
+      
+      meta_XFree (infos);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_XINERAMA,
+                  "No XFree86 Xinerama extension or XFree86 Xinerama inactive on display %s\n",
+                  display->name);
+    }
+#else
+  meta_topic (META_DEBUG_XINERAMA,
+              "Marco compiled without XFree86 Xinerama support\n");
+#endif /* HAVE_XFREE_XINERAMA */
+
+#ifdef HAVE_SOLARIS_XINERAMA
+  /* This code from GDK, Copyright (C) 2002 Sun Microsystems */
+  if (screen->n_xinerama_infos == 0 &&
+      XineramaGetState (screen->display->xdisplay,
+                        screen->number))
+    {
+      XRectangle monitors[MAXFRAMEBUFFERS];
+      unsigned char hints[16];
+      int result;
+      int n_monitors;
+      int i;
+
+      n_monitors = 0;
+      result = XineramaGetInfo (screen->display->xdisplay,
+                                screen->number,
+				monitors, hints,
+                                &n_monitors);
+      /* Yes I know it should be Success but the current implementation 
+       * returns the num of monitor
+       */
+      if (result > 0)
+	{
+          g_assert (n_monitors > 0);
+          
+          screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_monitors);
+          screen->n_xinerama_infos = n_monitors;
+          
+          i = 0;
+          while (i < n_monitors)
+            {
+              screen->xinerama_infos[i].number = i;
+              screen->xinerama_infos[i].rect.x = monitors[i].x;
+              screen->xinerama_infos[i].rect.y = monitors[i].y;
+              screen->xinerama_infos[i].rect.width = monitors[i].width;
+              screen->xinerama_infos[i].rect.height = monitors[i].height;
+
+              meta_topic (META_DEBUG_XINERAMA,
+                          "Xinerama %d is %d,%d %d x %d\n",
+                          screen->xinerama_infos[i].number,
+                          screen->xinerama_infos[i].rect.x,
+                          screen->xinerama_infos[i].rect.y,
+                          screen->xinerama_infos[i].rect.width,
+                          screen->xinerama_infos[i].rect.height);              
+              
+              ++i;
+            }
+	}
+    }
+  else if (screen->n_xinerama_infos == 0)
+    {
+      meta_topic (META_DEBUG_XINERAMA,
+                  "No Solaris Xinerama extension or Solaris Xinerama inactive on display %s\n",
+                  display->name);
+    }
+#else
+  meta_topic (META_DEBUG_XINERAMA,
+              "Marco compiled without Solaris Xinerama support\n");
+#endif /* HAVE_SOLARIS_XINERAMA */
+
+  
+  /* If no Xinerama, fill in the single screen info so
+   * we can use the field unconditionally
+   */
+  if (screen->n_xinerama_infos == 0)
+    {
+      if (g_getenv ("MARCO_DEBUG_XINERAMA"))
+        {
+          meta_topic (META_DEBUG_XINERAMA,
+                      "Pretending a single monitor has two Xinerama screens\n");
+          
+          screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 2);
+          screen->n_xinerama_infos = 2;
+          
+          screen->xinerama_infos[0].number = 0;
+          screen->xinerama_infos[0].rect = screen->rect;
+          screen->xinerama_infos[0].rect.width = screen->rect.width / 2;
+
+          screen->xinerama_infos[1].number = 1;
+          screen->xinerama_infos[1].rect = screen->rect;
+          screen->xinerama_infos[1].rect.x = screen->rect.width / 2;
+          screen->xinerama_infos[1].rect.width = screen->rect.width / 2;
+        }
+      else
+        {
+          meta_topic (META_DEBUG_XINERAMA,
+                      "No Xinerama screens, using default screen info\n");
+          
+          screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 1);
+          screen->n_xinerama_infos = 1;
+          
+          screen->xinerama_infos[0].number = 0;
+          screen->xinerama_infos[0].rect = screen->rect;
+        }
+    }
+
+  g_assert (screen->n_xinerama_infos > 0);
+  g_assert (screen->xinerama_infos != NULL);
+}
+
+MetaScreen*
+meta_screen_new (MetaDisplay *display,
+                 int          number,
+                 guint32      timestamp)
+{
+  MetaScreen *screen;
+  Window xroot;
+  Display *xdisplay;
+  XWindowAttributes attr;
+  Window new_wm_sn_owner;
+  Window current_wm_sn_owner;
+  gboolean replace_current_wm;
+  Atom wm_sn_atom;
+  char buf[128];
+  guint32 manager_timestamp;
+  gulong current_workspace;
+  
+  replace_current_wm = meta_get_replace_current_wm ();
+  
+  /* Only display->name, display->xdisplay, and display->error_traps
+   * can really be used in this function, since normally screens are
+   * created from the MetaDisplay constructor
+   */
+  
+  xdisplay = display->xdisplay;
+  
+  meta_verbose ("Trying screen %d on display '%s'\n",
+                number, display->name);
+
+  xroot = RootWindow (xdisplay, number);
+
+  /* FVWM checks for None here, I don't know if this
+   * ever actually happens
+   */
+  if (xroot == None)
+    {
+      meta_warning (_("Screen %d on display '%s' is invalid\n"),
+                    number, display->name);
+      return NULL;
+    }
+
+  sprintf (buf, "WM_S%d", number);
+  wm_sn_atom = XInternAtom (xdisplay, buf, False);  
+  
+  current_wm_sn_owner = XGetSelectionOwner (xdisplay, wm_sn_atom);
+
+  if (current_wm_sn_owner != None)
+    {
+      XSetWindowAttributes attrs;
+      
+      if (!replace_current_wm)
+        {
+          meta_warning (_("Screen %d on display \"%s\" already has a window manager; try using the --replace option to replace the current window manager.\n"),
+                        number, display->name);
+
+          return NULL;
+        }
+
+      /* We want to find out when the current selection owner dies */
+      meta_error_trap_push_with_return (display);
+      attrs.event_mask = StructureNotifyMask;
+      XChangeWindowAttributes (xdisplay,
+                               current_wm_sn_owner, CWEventMask, &attrs);
+      if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+        current_wm_sn_owner = None; /* don't wait for it to die later on */
+    }
+
+  /* We need SelectionClear and SelectionRequest events on the new_wm_sn_owner,
+   * but those cannot be masked, so we only need NoEventMask.
+   */
+  new_wm_sn_owner = meta_create_offscreen_window (xdisplay, xroot, NoEventMask);
+
+  manager_timestamp = timestamp;
+  
+  XSetSelectionOwner (xdisplay, wm_sn_atom, new_wm_sn_owner,
+                      manager_timestamp);
+
+  if (XGetSelectionOwner (xdisplay, wm_sn_atom) != new_wm_sn_owner)
+    {
+      meta_warning (_("Could not acquire window manager selection on screen %d display \"%s\"\n"),
+                    number, display->name);
+
+      XDestroyWindow (xdisplay, new_wm_sn_owner);
+      
+      return NULL;
+    }
+  
+  {
+    /* Send client message indicating that we are now the WM */
+    XClientMessageEvent ev;
+    
+    ev.type = ClientMessage;
+    ev.window = xroot;
+    ev.message_type = display->atom_MANAGER;
+    ev.format = 32;
+    ev.data.l[0] = manager_timestamp;
+    ev.data.l[1] = wm_sn_atom;
+
+    XSendEvent (xdisplay, xroot, False, StructureNotifyMask, (XEvent*)&ev);
+  }
+
+  /* Wait for old window manager to go away */
+  if (current_wm_sn_owner != None)
+    {
+      XEvent event;
+
+      /* We sort of block infinitely here which is probably lame. */
+      
+      meta_verbose ("Waiting for old window manager to exit\n");
+      do
+        {
+          XWindowEvent (xdisplay, current_wm_sn_owner,
+                        StructureNotifyMask, &event);
+        }
+      while (event.type != DestroyNotify);
+    }
+  
+  /* select our root window events */
+  meta_error_trap_push_with_return (display);
+
+  /* We need to or with the existing event mask since
+   * gtk+ may be interested in other events.
+   */
+  XGetWindowAttributes (xdisplay, xroot, &attr);
+  XSelectInput (xdisplay,
+                xroot,
+                SubstructureRedirectMask | SubstructureNotifyMask |
+                ColormapChangeMask | PropertyChangeMask |
+                LeaveWindowMask | EnterWindowMask |
+                KeyPressMask | KeyReleaseMask |
+                FocusChangeMask | StructureNotifyMask |
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+                ExposureMask |
+#endif
+		attr.your_event_mask);
+  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+    {
+      meta_warning (_("Screen %d on display \"%s\" already has a window manager\n"),
+                    number, display->name);
+
+      XDestroyWindow (xdisplay, new_wm_sn_owner);
+      
+      return NULL;
+    }
+  
+  screen = g_new (MetaScreen, 1);
+  screen->closing = 0;
+  
+  screen->display = display;
+  screen->number = number;
+  screen->screen_name = get_screen_name (display, number);
+  screen->xscreen = ScreenOfDisplay (xdisplay, number);
+  screen->xroot = xroot;
+  screen->rect.x = screen->rect.y = 0;
+  screen->rect.width = WidthOfScreen (screen->xscreen);
+  screen->rect.height = HeightOfScreen (screen->xscreen);
+  screen->current_cursor = -1; /* invalid/unset */
+  screen->default_xvisual = DefaultVisualOfScreen (screen->xscreen);
+  screen->default_depth = DefaultDepthOfScreen (screen->xscreen);
+  screen->flash_window = None;
+
+  screen->wm_sn_selection_window = new_wm_sn_owner;
+  screen->wm_sn_atom = wm_sn_atom;
+  screen->wm_sn_timestamp = manager_timestamp;
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  screen->wm_cm_selection_window = meta_create_offscreen_window (xdisplay, 
+                                                                 xroot, 
+                                                                 NoEventMask);
+#endif
+  screen->work_area_idle = 0;
+
+  screen->active_workspace = NULL;
+  screen->workspaces = NULL;
+  screen->rows_of_workspaces = 1;
+  screen->columns_of_workspaces = -1;
+  screen->vertical_workspaces = FALSE;
+  screen->starting_corner = META_SCREEN_TOPLEFT;
+  screen->compositor_data = NULL;
+
+  {
+    XFontStruct *font_info;
+    XGCValues gc_values;
+    gulong value_mask = 0;
+    
+    gc_values.subwindow_mode = IncludeInferiors;
+    value_mask |= GCSubwindowMode;
+    gc_values.function = GXinvert;
+    value_mask |= GCFunction;
+    gc_values.line_width = META_WIREFRAME_XOR_LINE_WIDTH;
+    value_mask |= GCLineWidth;
+
+    font_info = XLoadQueryFont (screen->display->xdisplay, "fixed");
+
+    if (font_info != NULL)
+      {
+        gc_values.font = font_info->fid;
+        value_mask |= GCFont;
+        XFreeFontInfo (NULL, font_info, 1);
+      }
+    else
+      meta_warning ("xserver doesn't have 'fixed' font.\n");
+
+    screen->root_xor_gc = XCreateGC (screen->display->xdisplay,
+                                     screen->xroot,
+                                     value_mask,
+                                     &gc_values);
+  }
+  
+  screen->xinerama_infos = NULL;
+  screen->n_xinerama_infos = 0;
+  screen->last_xinerama_index = 0;  
+  
+  reload_xinerama_infos (screen);
+  
+  meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
+
+  /* Handle creating a no_focus_window for this screen */  
+  screen->no_focus_window =
+    meta_create_offscreen_window (display->xdisplay,
+                                  screen->xroot,
+                                  FocusChangeMask|KeyPressMask|KeyReleaseMask);
+  XMapWindow (display->xdisplay, screen->no_focus_window);
+  /* Done with no_focus_window stuff */
+  
+  set_wm_icon_size_hint (screen);
+  
+  set_supported_hint (screen);
+  
+  set_wm_check_hint (screen);
+
+  set_desktop_viewport_hint (screen);
+
+  set_desktop_geometry_hint (screen);
+
+  meta_screen_update_workspace_layout (screen);
+
+  /* Get current workspace */
+  current_workspace = 0;
+  if (meta_prop_get_cardinal (screen->display,
+                              screen->xroot,
+                              screen->display->atom__NET_CURRENT_DESKTOP,
+                              &current_workspace))
+    meta_verbose ("Read existing _NET_CURRENT_DESKTOP = %d\n",
+                  (int) current_workspace);
+  else
+    meta_verbose ("No _NET_CURRENT_DESKTOP present\n");
+  
+  /* Screens must have at least one workspace at all times,
+   * so create that required workspace.
+   */
+  meta_workspace_activate (meta_workspace_new (screen), timestamp);
+  update_num_workspaces (screen, timestamp);
+  
+  set_workspace_names (screen);
+
+  screen->all_keys_grabbed = FALSE;
+  screen->keys_grabbed = FALSE;
+  meta_screen_grab_keys (screen);
+
+  screen->ui = meta_ui_new (screen->display->xdisplay,
+                            screen->xscreen);
+
+  screen->tab_popup = NULL;
+  
+  screen->stack = meta_stack_new (screen);
+
+  meta_prefs_add_listener (prefs_changed_callback, screen);
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  screen->sn_context =
+    sn_monitor_context_new (screen->display->sn_display,
+                            screen->number,
+                            meta_screen_sn_event,
+                            screen,
+                            NULL);
+  screen->startup_sequences = NULL;
+  screen->startup_sequence_timeout = 0;
+#endif
+
+  /* Switch to the _NET_CURRENT_DESKTOP workspace */
+  {
+    MetaWorkspace *space;
+    
+    space = meta_screen_get_workspace_by_index (screen,
+                                                current_workspace);
+    
+    if (space != NULL)
+      meta_workspace_activate (space, timestamp);
+  }
+
+  meta_verbose ("Added screen %d ('%s') root 0x%lx\n",
+                screen->number, screen->screen_name, screen->xroot);
+  
+  return screen;
+}
+
+void
+meta_screen_free (MetaScreen *screen,
+                  guint32     timestamp)
+{
+  MetaDisplay *display;
+  XGCValues gc_values = { 0 };
+
+  display = screen->display;
+
+  screen->closing += 1;
+  
+  meta_display_grab (display);
+
+  if (screen->display->compositor)
+    {
+      meta_compositor_unmanage_screen (screen->display->compositor,
+				       screen);
+    }
+  
+  meta_display_unmanage_windows_for_screen (display, screen, timestamp);
+  
+  meta_prefs_remove_listener (prefs_changed_callback, screen);
+  
+  meta_screen_ungrab_keys (screen);
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+  g_slist_foreach (screen->startup_sequences,
+                   (GFunc) sn_startup_sequence_unref, NULL);
+  g_slist_free (screen->startup_sequences);
+  screen->startup_sequences = NULL;
+
+  if (screen->startup_sequence_timeout != 0)
+    {
+      g_source_remove (screen->startup_sequence_timeout);
+      screen->startup_sequence_timeout = 0;
+    }
+  if (screen->sn_context)
+    {
+      sn_monitor_context_unref (screen->sn_context);
+      screen->sn_context = NULL;
+    }
+#endif
+  
+  meta_ui_free (screen->ui);
+
+  meta_stack_free (screen->stack);
+
+  meta_error_trap_push_with_return (screen->display);
+  XSelectInput (screen->display->xdisplay, screen->xroot, 0);
+  if (meta_error_trap_pop_with_return (screen->display, FALSE) != Success)
+    meta_warning (_("Could not release screen %d on display \"%s\"\n"),
+                  screen->number, screen->display->name);
+
+  unset_wm_check_hint (screen);
+
+  XDestroyWindow (screen->display->xdisplay,
+                  screen->wm_sn_selection_window);
+  
+  if (screen->work_area_idle != 0)
+    g_source_remove (screen->work_area_idle);
+
+
+  if (XGetGCValues (screen->display->xdisplay,
+                    screen->root_xor_gc,
+                    GCFont,
+                    &gc_values))
+    {
+      XUnloadFont (screen->display->xdisplay,
+                   gc_values.font);
+    }
+
+  XFreeGC (screen->display->xdisplay,
+           screen->root_xor_gc);
+  
+  if (screen->xinerama_infos)
+    g_free (screen->xinerama_infos);
+  
+  g_free (screen->screen_name);
+  g_free (screen);
+
+  XFlush (display->xdisplay);
+  meta_display_ungrab (display);
+}
+
+typedef struct
+{
+  Window		xwindow;
+  XWindowAttributes	attrs;
+} WindowInfo;
+
+static GList *
+list_windows (MetaScreen *screen)
+{
+  Window ignored1, ignored2;
+  Window *children;
+  guint n_children, i;
+  GList *result;
+
+  XQueryTree (screen->display->xdisplay,
+              screen->xroot,
+              &ignored1, &ignored2, &children, &n_children);
+
+  result = NULL;
+  for (i = 0; i < n_children; ++i)
+    {
+      WindowInfo *info = g_new0 (WindowInfo, 1);
+
+      meta_error_trap_push_with_return (screen->display);
+      
+      XGetWindowAttributes (screen->display->xdisplay,
+                            children[i], &info->attrs);
+
+      if (meta_error_trap_pop_with_return (screen->display, TRUE))
+	{
+          meta_verbose ("Failed to get attributes for window 0x%lx\n",
+                        children[i]);
+	  g_free (info);
+        }
+      else
+        {
+	  info->xwindow = children[i];
+	}
+
+      result = g_list_prepend (result, info);
+    }
+
+  if (children)
+    XFree (children);
+
+  return g_list_reverse (result);
+}
+
+void
+meta_screen_manage_all_windows (MetaScreen *screen)
+{
+  GList *windows;
+  GList *list;
+
+  meta_display_grab (screen->display);
+  
+  windows = list_windows (screen);
+
+  meta_stack_freeze (screen->stack);
+  for (list = windows; list != NULL; list = list->next)
+    {
+      WindowInfo *info = list->data;
+      MetaWindow *window;
+
+      window = meta_window_new_with_attrs (screen->display, info->xwindow, TRUE,
+                                           &info->attrs);
+      if (info->xwindow == screen->no_focus_window ||
+          info->xwindow == screen->flash_window ||
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+          info->xwindow == screen->wm_cm_selection_window ||
+#endif
+          info->xwindow == screen->wm_sn_selection_window) {
+        meta_verbose ("Not managing our own windows\n");
+        continue;
+      }
+
+      if (screen->display->compositor)
+        meta_compositor_add_window (screen->display->compositor, window,
+                                    info->xwindow, &info->attrs);
+    }
+  meta_stack_thaw (screen->stack);
+
+  g_list_foreach (windows, (GFunc)g_free, NULL);
+  g_list_free (windows);
+
+  meta_display_ungrab (screen->display);
+}
+
+void
+meta_screen_composite_all_windows (MetaScreen *screen)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaDisplay *display;
+  GList *windows, *list;
+
+  display = screen->display;
+  if (!display->compositor)
+    return;
+
+  windows = list_windows (screen);
+
+  meta_stack_freeze (screen->stack);
+
+  for (list = windows; list != NULL; list = list->next)
+    {
+      WindowInfo *info = list->data;
+
+      if (info->xwindow == screen->no_focus_window ||
+          info->xwindow == screen->flash_window ||
+          info->xwindow == screen->wm_sn_selection_window ||
+          info->xwindow == screen->wm_cm_selection_window) {
+        meta_verbose ("Not managing our own windows\n");
+        continue;
+      }
+
+      meta_compositor_add_window (display->compositor,
+                                  meta_display_lookup_x_window (display,
+                                                                info->xwindow),
+				  info->xwindow, &info->attrs);
+    }
+
+  meta_stack_thaw (screen->stack);
+
+  g_list_foreach (windows, (GFunc)g_free, NULL);
+  g_list_free (windows);
+#endif
+}
+
+MetaScreen*
+meta_screen_for_x_screen (Screen *xscreen)
+{
+  MetaDisplay *display;
+  
+  display = meta_display_for_x_display (DisplayOfScreen (xscreen));
+
+  if (display == NULL)
+    return NULL;
+  
+  return meta_display_screen_for_x_screen (display, xscreen);
+}
+
+static void
+prefs_changed_callback (MetaPreference pref,
+                        gpointer       data)
+{
+  MetaScreen *screen = data;
+  
+  if (pref == META_PREF_NUM_WORKSPACES)
+    {
+      /* MateConf doesn't provide timestamps, but luckily update_num_workspaces
+       * often doesn't need it...
+       */
+      guint32 timestamp = 
+        meta_display_get_current_time_roundtrip (screen->display);
+      update_num_workspaces (screen, timestamp);
+    }
+  else if (pref == META_PREF_FOCUS_MODE)
+    {
+      update_focus_mode (screen);
+    }
+  else if (pref == META_PREF_WORKSPACE_NAMES)
+    {
+      set_workspace_names (screen);
+    }
+}
+
+
+static char*
+get_screen_name (MetaDisplay *display,
+                 int          number)
+{
+  char *p;
+  char *dname;
+  char *scr;
+  
+  /* DisplayString gives us a sort of canonical display,
+   * vs. the user-entered name from XDisplayName()
+   */
+  dname = g_strdup (DisplayString (display->xdisplay));
+
+  /* Change display name to specify this screen.
+   */
+  p = strrchr (dname, ':');
+  if (p)
+    {
+      p = strchr (p, '.');
+      if (p)
+        *p = '\0';
+    }
+  
+  scr = g_strdup_printf ("%s.%d", dname, number);
+
+  g_free (dname);
+
+  return scr;
+}
+
+static gint
+ptrcmp (gconstpointer a, gconstpointer b)
+{
+  if (a < b)
+    return -1;
+  else if (a > b)
+    return 1;
+  else
+    return 0;
+}
+
+static void
+listify_func (gpointer key, gpointer value, gpointer data)
+{
+  GSList **listp;
+  
+  listp = data;
+
+  *listp = g_slist_prepend (*listp, value);
+}
+
+void
+meta_screen_foreach_window (MetaScreen *screen,
+                            MetaScreenWindowFunc func,
+                            gpointer data)
+{
+  GSList *winlist;
+  GSList *tmp;
+
+  /* If we end up doing this often, just keeping a list
+   * of windows might be sensible.
+   */
+  
+  winlist = NULL;
+  g_hash_table_foreach (screen->display->window_ids,
+                        listify_func,
+                        &winlist);
+  
+  winlist = g_slist_sort (winlist, ptrcmp);
+  
+  tmp = winlist;
+  while (tmp != NULL)
+    {
+      /* If the next node doesn't contain this window
+       * a second time, delete the window.
+       */
+      if (tmp->next == NULL ||
+          (tmp->next && tmp->next->data != tmp->data))
+        {
+          MetaWindow *window = tmp->data;
+
+          if (window->screen == screen)
+            (* func) (screen, window, data);
+        }
+      
+      tmp = tmp->next;
+    }
+  g_slist_free (winlist);
+}
+
+static void
+queue_draw (MetaScreen *screen, MetaWindow *window, gpointer data)
+{
+  if (window->frame)
+    meta_frame_queue_draw (window->frame);
+}
+
+void
+meta_screen_queue_frame_redraws (MetaScreen *screen)
+{
+  meta_screen_foreach_window (screen, queue_draw, NULL);
+}
+
+static void
+queue_resize (MetaScreen *screen, MetaWindow *window, gpointer data)
+{
+  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+}
+
+void
+meta_screen_queue_window_resizes (MetaScreen *screen)
+{
+  meta_screen_foreach_window (screen, queue_resize, NULL);
+}
+
+int
+meta_screen_get_n_workspaces (MetaScreen *screen)
+{
+  return g_list_length (screen->workspaces);
+}
+
+MetaWorkspace*
+meta_screen_get_workspace_by_index (MetaScreen  *screen,
+                                    int          idx)
+{
+  GList *tmp;
+  int i;
+
+  /* should be robust, idx is maybe from an app */
+  if (idx < 0)
+    return NULL;
+  
+  i = 0;
+  tmp = screen->workspaces;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *w = tmp->data;
+
+      if (i == idx)
+        return w;
+
+      ++i;
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+static void
+set_number_of_spaces_hint (MetaScreen *screen,
+			   int         n_spaces)
+{
+  unsigned long data[1];
+
+  if (screen->closing > 0)
+    return;
+
+  data[0] = n_spaces;
+
+  meta_verbose ("Setting _NET_NUMBER_OF_DESKTOPS to %lu\n", data[0]);
+
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_NUMBER_OF_DESKTOPS,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static void
+set_desktop_geometry_hint (MetaScreen *screen)
+{
+  unsigned long data[2];
+
+  if (screen->closing > 0)
+    return;
+
+  data[0] = screen->rect.width;
+  data[1] = screen->rect.height;
+
+  meta_verbose ("Setting _NET_DESKTOP_GEOMETRY to %lu, %lu\n", data[0], data[1]);
+
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_DESKTOP_GEOMETRY,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 2);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static void
+set_desktop_viewport_hint (MetaScreen *screen)
+{
+  unsigned long data[2];
+
+  if (screen->closing > 0)
+    return;
+
+  /*
+   * Marco does not implement viewports, so this is a fixed 0,0
+   */
+  data[0] = 0;
+  data[1] = 0;
+
+  meta_verbose ("Setting _NET_DESKTOP_VIEWPORT to 0, 0\n");
+
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_DESKTOP_VIEWPORT,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 2);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static void
+update_num_workspaces (MetaScreen *screen,
+                       guint32     timestamp)
+{
+  int new_num;
+  GList *tmp;
+  int i;
+  GList *extras;
+  MetaWorkspace *last_remaining;
+  gboolean need_change_space;
+  
+  new_num = meta_prefs_get_num_workspaces ();
+
+  g_assert (new_num > 0);
+
+  last_remaining = NULL;
+  extras = NULL;
+  i = 0;
+  tmp = screen->workspaces;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *w = tmp->data;
+
+      if (i >= new_num)
+        extras = g_list_prepend (extras, w);
+      else
+        last_remaining = w;
+          
+      ++i;
+      tmp = tmp->next;
+    }
+
+  g_assert (last_remaining);
+  
+  /* Get rid of the extra workspaces by moving all their windows
+   * to last_remaining, then activating last_remaining if
+   * one of the removed workspaces was active. This will be a bit
+   * wacky if the config tool for changing number of workspaces
+   * is on a removed workspace ;-)
+   */
+  need_change_space = FALSE;
+  tmp = extras;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *w = tmp->data;
+
+      meta_workspace_relocate_windows (w, last_remaining);      
+
+      if (w == screen->active_workspace)
+        need_change_space = TRUE;
+      
+      tmp = tmp->next;
+    }
+
+  if (need_change_space)
+    meta_workspace_activate (last_remaining, timestamp);
+
+  /* Should now be safe to free the workspaces */
+  tmp = extras;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *w = tmp->data;
+
+      g_assert (w->windows == NULL);
+      meta_workspace_free (w);
+      
+      tmp = tmp->next;
+    }
+  
+  g_list_free (extras);
+  
+  while (i < new_num)
+    {
+      meta_workspace_new (screen);
+      ++i;
+    }
+
+  set_number_of_spaces_hint (screen, new_num);
+
+  meta_screen_queue_workarea_recalc (screen);
+}
+
+static void
+update_focus_mode (MetaScreen *screen)
+{
+  /* nothing to do anymore */ ;
+}
+
+void
+meta_screen_set_cursor (MetaScreen *screen,
+                        MetaCursor  cursor)
+{
+  Cursor xcursor;
+
+  if (cursor == screen->current_cursor)
+    return;
+
+  screen->current_cursor = cursor;
+  
+  xcursor = meta_display_create_x_cursor (screen->display, cursor);
+  XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
+  XFlush (screen->display->xdisplay);
+  XFreeCursor (screen->display->xdisplay, xcursor);
+}
+
+void
+meta_screen_update_cursor (MetaScreen *screen)
+{
+  Cursor xcursor;
+
+  xcursor = meta_display_create_x_cursor (screen->display, 
+					  screen->current_cursor);
+  XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
+  XFlush (screen->display->xdisplay);
+  XFreeCursor (screen->display->xdisplay, xcursor);
+}
+
+#define MAX_PREVIEW_SIZE 150.0
+
+static GdkPixbuf *
+get_window_pixbuf (MetaWindow *window,
+                   int        *width,
+                   int        *height)
+{
+  Pixmap pmap;
+  GdkPixbuf *pixbuf, *scaled;
+  double ratio;
+
+  pmap = meta_compositor_get_window_pixmap (window->display->compositor,
+                                            window);
+  if (pmap == None)
+    return NULL;
+
+  pixbuf = meta_ui_get_pixbuf_from_pixmap (pmap);
+  if (pixbuf == NULL) 
+    return NULL;
+
+  *width = gdk_pixbuf_get_width (pixbuf);
+  *height = gdk_pixbuf_get_height (pixbuf);
+
+  /* Scale pixbuf to max dimension MAX_PREVIEW_SIZE */
+  if (*width > *height)
+    {
+      ratio = ((double) *width) / MAX_PREVIEW_SIZE;
+      *width = (int) MAX_PREVIEW_SIZE;
+      *height = (int) (((double) *height) / ratio);
+    }
+  else
+    {
+      ratio = ((double) *height) / MAX_PREVIEW_SIZE;
+      *height = (int) MAX_PREVIEW_SIZE;
+      *width = (int) (((double) *width) / ratio);
+    }
+
+  scaled = gdk_pixbuf_scale_simple (pixbuf, *width, *height,
+                                    GDK_INTERP_BILINEAR);
+  g_object_unref (pixbuf);
+  return scaled;
+}
+                                         
+void
+meta_screen_ensure_tab_popup (MetaScreen      *screen,
+                              MetaTabList      list_type,
+                              MetaTabShowType  show_type)
+{
+  MetaTabEntry *entries;
+  GList *tab_list;
+  GList *tmp;
+  int len;
+  int i;
+
+  if (screen->tab_popup)
+    return;
+
+  tab_list = meta_display_get_tab_list (screen->display,
+                                        list_type,
+                                        screen,
+                                        screen->active_workspace);
+  
+  len = g_list_length (tab_list);
+
+  entries = g_new (MetaTabEntry, len + 1);
+  entries[len].key = NULL;
+  entries[len].title = NULL;
+  entries[len].icon = NULL;
+  
+  i = 0;
+  tmp = tab_list;
+  while (i < len)
+    {
+      MetaWindow *window;
+      MetaRectangle r;
+      GdkPixbuf *win_pixbuf;
+      int width, height;
+
+      window = tmp->data;
+      
+      entries[i].key = (MetaTabEntryKey) window->xwindow;
+      entries[i].title = window->title;
+
+      win_pixbuf = get_window_pixbuf (window, &width, &height);
+      if (win_pixbuf == NULL)
+        entries[i].icon = g_object_ref (window->icon);
+      else
+        {
+          int icon_width, icon_height, t_width, t_height;
+#define ICON_OFFSET 6
+
+          icon_width = gdk_pixbuf_get_width (window->icon);
+          icon_height = gdk_pixbuf_get_height (window->icon);
+
+          t_width = width + ICON_OFFSET;
+          t_height = height + ICON_OFFSET;
+
+          entries[i].icon = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
+                                            t_width, t_height);
+          gdk_pixbuf_fill (entries[i].icon, 0x00000000);
+          gdk_pixbuf_copy_area (win_pixbuf, 0, 0, width, height,
+                                entries[i].icon, 0, 0);
+          g_object_unref (win_pixbuf);
+          gdk_pixbuf_composite (window->icon, entries[i].icon, 
+                                t_width - icon_width, t_height - icon_height,
+                                icon_width, icon_height,
+                                t_width - icon_width, t_height - icon_height, 
+                                1.0, 1.0, GDK_INTERP_BILINEAR, 255);
+        }
+                                
+      entries[i].blank = FALSE;
+      entries[i].hidden = !meta_window_showing_on_its_workspace (window);
+      entries[i].demands_attention = window->wm_state_demands_attention;
+      
+      if (show_type == META_TAB_SHOW_INSTANTLY ||
+          !entries[i].hidden                   ||
+          !meta_window_get_icon_geometry (window, &r))
+        meta_window_get_outer_rect (window, &r);
+      
+      entries[i].rect = r;
+
+      /* Find inside of highlight rectangle to be used when window is
+       * outlined for tabbing.  This should be the size of the
+       * east/west frame, and the size of the south frame, on those
+       * sides.  On the top it should be the size of the south frame
+       * edge.
+       */
+#define OUTLINE_WIDTH 5
+      /* Top side */
+      if (!entries[i].hidden &&
+          window->frame && window->frame->bottom_height > 0 &&
+          window->frame->child_y >= window->frame->bottom_height)
+        entries[i].inner_rect.y = window->frame->bottom_height;
+      else
+        entries[i].inner_rect.y = OUTLINE_WIDTH;
+
+      /* Bottom side */
+      if (!entries[i].hidden &&
+          window->frame && window->frame->bottom_height != 0)
+        entries[i].inner_rect.height = r.height
+          - entries[i].inner_rect.y - window->frame->bottom_height;
+      else
+        entries[i].inner_rect.height = r.height
+          - entries[i].inner_rect.y - OUTLINE_WIDTH;
+
+      /* Left side */
+      if (!entries[i].hidden && window->frame && window->frame->child_x != 0)
+        entries[i].inner_rect.x = window->frame->child_x;
+      else
+        entries[i].inner_rect.x = OUTLINE_WIDTH;
+
+      /* Right side */
+      if (!entries[i].hidden &&
+          window->frame && window->frame->right_width != 0)
+        entries[i].inner_rect.width = r.width
+          - entries[i].inner_rect.x - window->frame->right_width;
+      else
+        entries[i].inner_rect.width = r.width
+          - entries[i].inner_rect.x - OUTLINE_WIDTH;
+      
+      ++i;
+      tmp = tmp->next;
+    }
+
+  screen->tab_popup = meta_ui_tab_popup_new (entries, 
+                                             screen->number,
+                                             len,
+                                             5, /* FIXME */
+                                             TRUE);
+
+  for (i = 0; i < len; i++) 
+    g_object_unref (entries[i].icon);
+
+  g_free (entries);
+
+  g_list_free (tab_list);
+  
+  /* don't show tab popup, since proper window isn't selected yet */
+}
+
+void
+meta_screen_ensure_workspace_popup (MetaScreen *screen)
+{
+  MetaTabEntry *entries;
+  int len;
+  int i;
+  MetaWorkspaceLayout layout;
+  int n_workspaces;
+  int current_workspace;
+  
+  if (screen->tab_popup)
+    return;
+
+  current_workspace = meta_workspace_index (screen->active_workspace);
+  n_workspaces = meta_screen_get_n_workspaces (screen);
+
+  meta_screen_calc_workspace_layout (screen, n_workspaces,
+                                     current_workspace, &layout);
+
+  len = layout.grid_area;
+  
+  entries = g_new (MetaTabEntry, len + 1);
+  entries[len].key = NULL;
+  entries[len].title = NULL;
+  entries[len].icon = NULL;
+
+  i = 0;
+  while (i < len)
+    {
+      if (layout.grid[i] >= 0)
+        {
+          MetaWorkspace *workspace;
+          
+          workspace = meta_screen_get_workspace_by_index (screen,
+                                                          layout.grid[i]);
+          
+          entries[i].key = (MetaTabEntryKey) workspace;
+          entries[i].title = meta_workspace_get_name (workspace);
+          entries[i].icon = NULL;
+          entries[i].blank = FALSE;
+          
+          g_assert (entries[i].title != NULL);
+        }
+      else
+        {
+          entries[i].key = NULL;
+          entries[i].title = NULL;
+          entries[i].icon = NULL;
+          entries[i].blank = TRUE;
+        }
+      entries[i].hidden = FALSE;
+      entries[i].demands_attention = FALSE;
+
+      ++i;
+    }
+
+  screen->tab_popup = meta_ui_tab_popup_new (entries, 
+                                             screen->number,
+                                             len,
+                                             layout.cols,
+                                             FALSE);      
+
+  g_free (entries);
+  meta_screen_free_workspace_layout (&layout);
+
+  /* don't show tab popup, since proper space isn't selected yet */
+}
+
+MetaWindow*
+meta_screen_get_mouse_window (MetaScreen  *screen,
+                              MetaWindow  *not_this_one)
+{
+  MetaWindow *window;
+  Window root_return, child_return;
+  int root_x_return, root_y_return;
+  int win_x_return, win_y_return;
+  unsigned int mask_return;
+  
+  if (not_this_one)
+    meta_topic (META_DEBUG_FOCUS,
+                "Focusing mouse window excluding %s\n", not_this_one->desc);
+
+  meta_error_trap_push (screen->display);
+  XQueryPointer (screen->display->xdisplay,
+                 screen->xroot,
+                 &root_return,
+                 &child_return,
+                 &root_x_return,
+                 &root_y_return,
+                 &win_x_return,
+                 &win_y_return,
+                 &mask_return);
+  meta_error_trap_pop (screen->display, TRUE);
+
+  window = meta_stack_get_default_focus_window_at_point (screen->stack,
+                                                         screen->active_workspace,
+                                                         not_this_one,
+                                                         root_x_return,
+                                                         root_y_return);
+
+  return window;
+}
+
+const MetaXineramaScreenInfo*
+meta_screen_get_xinerama_for_rect (MetaScreen    *screen,
+				   MetaRectangle *rect)
+{
+  int i;
+  int best_xinerama, xinerama_score;
+
+  if (screen->n_xinerama_infos == 1)
+    return &screen->xinerama_infos[0];
+
+  best_xinerama = 0;
+  xinerama_score = 0;
+
+  for (i = 0; i < screen->n_xinerama_infos; i++)
+    {
+      MetaRectangle dest;
+      if (meta_rectangle_intersect (&screen->xinerama_infos[i].rect,
+                                    rect,
+                                    &dest))
+        {
+          int cur = meta_rectangle_area (&dest);
+          if (cur > xinerama_score)
+            {
+              xinerama_score = cur;
+              best_xinerama = i;
+            }
+        }
+    }
+
+  return &screen->xinerama_infos[best_xinerama];
+}
+
+const MetaXineramaScreenInfo*
+meta_screen_get_xinerama_for_window (MetaScreen *screen,
+				     MetaWindow *window)
+{
+  MetaRectangle window_rect;
+  
+  meta_window_get_outer_rect (window, &window_rect);
+
+  return meta_screen_get_xinerama_for_rect (screen, &window_rect);
+}
+
+const MetaXineramaScreenInfo* 
+meta_screen_get_xinerama_neighbor (MetaScreen         *screen,
+                                   int                 which_xinerama,
+                                   MetaScreenDirection direction)
+{
+  MetaXineramaScreenInfo* input = screen->xinerama_infos + which_xinerama;
+  MetaXineramaScreenInfo* current;
+  int i;
+
+  for (i = 0; i < screen->n_xinerama_infos; i++)
+    {
+      current = screen->xinerama_infos + i;
+
+      if ((direction == META_SCREEN_RIGHT && 
+           current->rect.x == input->rect.x + input->rect.width &&
+           meta_rectangle_vert_overlap(&current->rect, &input->rect)) ||
+          (direction == META_SCREEN_LEFT && 
+           input->rect.x == current->rect.x + current->rect.width &&
+           meta_rectangle_vert_overlap(&current->rect, &input->rect)) ||
+          (direction == META_SCREEN_UP && 
+           input->rect.y == current->rect.y + current->rect.height &&
+           meta_rectangle_horiz_overlap(&current->rect, &input->rect)) ||
+          (direction == META_SCREEN_DOWN && 
+           current->rect.y == input->rect.y + input->rect.height &&
+           meta_rectangle_horiz_overlap(&current->rect, &input->rect)))
+        {
+          return current;
+        }
+    }
+  
+  return NULL;
+}
+
+void
+meta_screen_get_natural_xinerama_list (MetaScreen *screen,
+                                       int**       xineramas_list,
+                                       int*        n_xineramas)
+{
+  const MetaXineramaScreenInfo* current;
+  const MetaXineramaScreenInfo* tmp;
+  GQueue* xinerama_queue;
+  int* visited;
+  int cur = 0;
+  int i;
+
+  *n_xineramas = screen->n_xinerama_infos;
+  *xineramas_list = g_new (int, screen->n_xinerama_infos);
+
+  /* we calculate a natural ordering by which to choose xineramas for
+   * window placement.  We start at the current xinerama, and perform
+   * a breadth-first search of the xineramas starting from that
+   * xinerama.  We choose preferentially left, then right, then down,
+   * then up.  The visitation order produced by this traversal is the
+   * natural xinerama ordering.
+   */
+
+  visited = g_new (int, screen->n_xinerama_infos);
+  for (i = 0; i < screen->n_xinerama_infos; i++)
+    {
+      visited[i] = FALSE;
+    }
+
+  current = meta_screen_get_current_xinerama (screen);
+  xinerama_queue = g_queue_new ();
+  g_queue_push_tail (xinerama_queue, (gpointer) current);
+  visited[current->number] = TRUE;
+
+  while (!g_queue_is_empty (xinerama_queue))
+    {
+      current = (const MetaXineramaScreenInfo*) 
+        g_queue_pop_head (xinerama_queue);
+
+      (*xineramas_list)[cur++] = current->number;
+
+      /* enqueue each of the directions */
+      tmp = meta_screen_get_xinerama_neighbor (screen,
+                                               current->number,
+                                               META_SCREEN_LEFT);
+      if (tmp && !visited[tmp->number])
+        {
+          g_queue_push_tail (xinerama_queue,
+                             (MetaXineramaScreenInfo*) tmp);
+          visited[tmp->number] = TRUE;
+        }
+      tmp = meta_screen_get_xinerama_neighbor (screen,
+                                               current->number,
+                                               META_SCREEN_RIGHT);
+      if (tmp && !visited[tmp->number])
+        {
+          g_queue_push_tail (xinerama_queue,
+                             (MetaXineramaScreenInfo*) tmp);
+          visited[tmp->number] = TRUE;
+        }
+      tmp = meta_screen_get_xinerama_neighbor (screen,
+                                               current->number,
+                                               META_SCREEN_UP);
+      if (tmp && !visited[tmp->number])
+        {
+          g_queue_push_tail (xinerama_queue,
+                             (MetaXineramaScreenInfo*) tmp);
+          visited[tmp->number] = TRUE;
+        }
+      tmp = meta_screen_get_xinerama_neighbor (screen,
+                                               current->number,
+                                               META_SCREEN_DOWN);
+      if (tmp && !visited[tmp->number])
+        {
+          g_queue_push_tail (xinerama_queue,
+                             (MetaXineramaScreenInfo*) tmp);
+          visited[tmp->number] = TRUE;
+        }
+    }
+
+  /* in case we somehow missed some set of xineramas, go through the
+   * visited list and add in any xineramas that were missed
+   */
+  for (i = 0; i < screen->n_xinerama_infos; i++)
+    {
+      if (visited[i] == FALSE)
+        {
+          (*xineramas_list)[cur++] = i;
+        }
+    }
+
+  g_free (visited);
+  g_queue_free (xinerama_queue);
+}
+
+const MetaXineramaScreenInfo*
+meta_screen_get_current_xinerama (MetaScreen *screen)
+{
+  if (screen->n_xinerama_infos == 1)
+    return &screen->xinerama_infos[0];
+  
+  /* Sadly, we have to do it this way. Yuck.
+   */
+  
+  if (screen->display->xinerama_cache_invalidated)
+    {
+      Window root_return, child_return;
+      int win_x_return, win_y_return;
+      unsigned int mask_return;
+      int i;
+      MetaRectangle pointer_position;
+      
+      screen->display->xinerama_cache_invalidated = FALSE;
+      
+      pointer_position.width = pointer_position.height = 1;
+      XQueryPointer (screen->display->xdisplay,
+                     screen->xroot,
+                     &root_return,
+                     &child_return,
+                     &pointer_position.x,
+                     &pointer_position.y,
+                     &win_x_return,
+                     &win_y_return,
+                     &mask_return);
+
+      screen->last_xinerama_index = 0;
+      for (i = 0; i < screen->n_xinerama_infos; i++)
+        {
+          if (meta_rectangle_contains_rect (&screen->xinerama_infos[i].rect,
+                                            &pointer_position))
+            {
+              screen->last_xinerama_index = i;
+              break;
+            }
+        }
+      
+      meta_topic (META_DEBUG_XINERAMA,
+                  "Rechecked current Xinerama, now %d\n",
+                  screen->last_xinerama_index);
+    }
+
+  return &screen->xinerama_infos[screen->last_xinerama_index];
+}
+
+#define _NET_WM_ORIENTATION_HORZ 0
+#define _NET_WM_ORIENTATION_VERT 1
+
+#define _NET_WM_TOPLEFT     0
+#define _NET_WM_TOPRIGHT    1
+#define _NET_WM_BOTTOMRIGHT 2
+#define _NET_WM_BOTTOMLEFT  3
+
+void
+meta_screen_update_workspace_layout (MetaScreen *screen)
+{
+  gulong *list;
+  int n_items;
+  
+  list = NULL;
+  n_items = 0;
+
+  if (meta_prop_get_cardinal_list (screen->display,
+                                   screen->xroot,
+                                   screen->display->atom__NET_DESKTOP_LAYOUT,
+                                   &list, &n_items))
+    {
+      if (n_items == 3 || n_items == 4)
+        {
+          int cols, rows;
+          
+          switch (list[0])
+            {
+            case _NET_WM_ORIENTATION_HORZ:
+              screen->vertical_workspaces = FALSE;
+              break;
+            case _NET_WM_ORIENTATION_VERT:
+              screen->vertical_workspaces = TRUE;
+              break;
+            default:
+              meta_warning ("Someone set a weird orientation in _NET_DESKTOP_LAYOUT\n");
+              break;
+            }
+
+          cols = list[1];
+          rows = list[2];
+
+          if (rows <= 0 && cols <= 0)
+            {
+              meta_warning ("Columns = %d rows = %d in _NET_DESKTOP_LAYOUT makes no sense\n", rows, cols);
+            }
+          else
+            {
+              if (rows > 0)
+                screen->rows_of_workspaces = rows;
+              else
+                screen->rows_of_workspaces = -1;
+              
+              if (cols > 0)
+                screen->columns_of_workspaces = cols;
+              else
+                screen->columns_of_workspaces = -1;
+            }
+
+          if (n_items == 4)
+            {
+              switch (list[3])
+                {
+                  case _NET_WM_TOPLEFT:
+                    screen->starting_corner = META_SCREEN_TOPLEFT;
+                    break;
+                  case _NET_WM_TOPRIGHT:
+                    screen->starting_corner = META_SCREEN_TOPRIGHT;
+                    break;
+                  case _NET_WM_BOTTOMRIGHT:
+                    screen->starting_corner = META_SCREEN_BOTTOMRIGHT;
+                    break;
+                  case _NET_WM_BOTTOMLEFT:
+                    screen->starting_corner = META_SCREEN_BOTTOMLEFT;
+                    break;
+                  default:
+                    meta_warning ("Someone set a weird starting corner in _NET_DESKTOP_LAYOUT\n");
+                    break;
+                }
+            }
+          else
+            screen->starting_corner = META_SCREEN_TOPLEFT;
+        }
+      else
+        {
+          meta_warning ("Someone set _NET_DESKTOP_LAYOUT to %d integers instead of 4 "
+                        "(3 is accepted for backwards compat)\n", n_items);
+        }
+
+      meta_XFree (list);
+    }
+
+  meta_verbose ("Workspace layout rows = %d cols = %d orientation = %d starting corner = %u\n",
+                screen->rows_of_workspaces,
+                screen->columns_of_workspaces,
+                screen->vertical_workspaces,
+                screen->starting_corner);
+}
+
+static void
+set_workspace_names (MetaScreen *screen)
+{
+  /* This updates names on root window when the pref changes,
+   * note we only get prefs change notify if things have
+   * really changed.
+   */
+  GString *flattened;
+  int i;
+  int n_spaces;
+
+  /* flatten to nul-separated list */
+  n_spaces = meta_screen_get_n_workspaces (screen);
+  flattened = g_string_new ("");
+  i = 0;
+  while (i < n_spaces)
+    {
+      const char *name;
+
+      name = meta_prefs_get_workspace_name (i);
+
+      if (name)
+        g_string_append_len (flattened, name,
+                             strlen (name) + 1);
+      else
+        g_string_append_len (flattened, "", 1);
+      
+      ++i;
+    }
+  
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay,
+                   screen->xroot,
+                   screen->display->atom__NET_DESKTOP_NAMES,
+		   screen->display->atom_UTF8_STRING,
+                   8, PropModeReplace,
+		   (unsigned char *)flattened->str, flattened->len);
+  meta_error_trap_pop (screen->display, FALSE);
+  
+  g_string_free (flattened, TRUE);
+}
+
+void
+meta_screen_update_workspace_names (MetaScreen *screen)
+{
+  char **names;
+  int n_names;
+  int i;
+
+  /* this updates names in prefs when the root window property changes,
+   * iff the new property contents don't match what's already in prefs
+   */
+  
+  names = NULL;
+  n_names = 0;
+  if (!meta_prop_get_utf8_list (screen->display,
+                                screen->xroot,
+                                screen->display->atom__NET_DESKTOP_NAMES,
+                                &names, &n_names))
+    {
+      meta_verbose ("Failed to get workspace names from root window %d\n",
+                    screen->number);
+      return;
+    }
+
+  i = 0;
+  while (i < n_names)
+    {
+      meta_topic (META_DEBUG_PREFS,
+                  "Setting workspace %d name to \"%s\" due to _NET_DESKTOP_NAMES change\n",
+                  i, names[i] ? names[i] : "null");
+      meta_prefs_change_workspace_name (i, names[i]);
+      
+      ++i;
+    }
+  
+  g_strfreev (names);
+}
+
+Window
+meta_create_offscreen_window (Display *xdisplay,
+                              Window   parent,
+                              long     valuemask)
+{
+  XSetWindowAttributes attrs;
+
+  /* we want to be override redirect because sometimes we
+   * create a window on a screen we aren't managing.
+   * (but on a display we are managing at least one screen for)
+   */
+  attrs.override_redirect = True;
+  attrs.event_mask = valuemask;
+  
+  return XCreateWindow (xdisplay,
+                        parent,
+                        -100, -100, 1, 1,
+                        0,
+                        CopyFromParent,
+                        CopyFromParent,
+                        (Visual *)CopyFromParent,
+                        CWOverrideRedirect | CWEventMask,
+                        &attrs);
+}
+
+static void
+set_work_area_hint (MetaScreen *screen)
+{
+  int num_workspaces;
+  GList *tmp_list;
+  unsigned long *data, *tmp;
+  MetaRectangle area;
+  
+  num_workspaces = meta_screen_get_n_workspaces (screen);
+  data = g_new (unsigned long, num_workspaces * 4);
+  tmp_list = screen->workspaces;
+  tmp = data;
+  
+  while (tmp_list != NULL)
+    {
+      MetaWorkspace *workspace = tmp_list->data;
+
+      if (workspace->screen == screen)
+        {
+          meta_workspace_get_work_area_all_xineramas (workspace, &area);
+          tmp[0] = area.x;
+          tmp[1] = area.y;
+          tmp[2] = area.width;
+          tmp[3] = area.height;
+
+	  tmp += 4;
+        }
+      
+      tmp_list = tmp_list->next;
+    }
+  
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+		   screen->display->atom__NET_WORKAREA,
+		   XA_CARDINAL, 32, PropModeReplace,
+		   (guchar*) data, num_workspaces*4);
+  g_free (data);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static gboolean
+set_work_area_idle_func (MetaScreen *screen)
+{
+  meta_topic (META_DEBUG_WORKAREA,
+              "Running work area idle function\n");
+  
+  screen->work_area_idle = 0;
+  
+  set_work_area_hint (screen);
+  
+  return FALSE;
+}
+
+void
+meta_screen_queue_workarea_recalc (MetaScreen *screen)
+{
+  /* Recompute work area in an idle */
+  if (screen->work_area_idle == 0)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Adding work area hint idle function\n");
+      screen->work_area_idle =
+        g_idle_add_full (META_PRIORITY_WORK_AREA_HINT,
+                         (GSourceFunc) set_work_area_idle_func,
+                         screen,
+                         NULL);
+    }
+}
+
+
+#ifdef WITH_VERBOSE_MODE
+static char *
+meta_screen_corner_to_string (MetaScreenCorner corner)
+{
+  switch (corner)
+    {
+    case META_SCREEN_TOPLEFT:
+      return "TopLeft";
+    case META_SCREEN_TOPRIGHT:
+      return "TopRight";
+    case META_SCREEN_BOTTOMLEFT:
+      return "BottomLeft";
+    case META_SCREEN_BOTTOMRIGHT:
+      return "BottomRight";
+    }
+
+  return "Unknown";
+}
+#endif /* WITH_VERBOSE_MODE */
+
+void
+meta_screen_calc_workspace_layout (MetaScreen          *screen,
+                                   int                  num_workspaces,
+                                   int                  current_space,
+                                   MetaWorkspaceLayout *layout)
+{
+  int rows, cols;
+  int grid_area;
+  int *grid;
+  int i, r, c;
+  int current_row, current_col;
+  
+  rows = screen->rows_of_workspaces;
+  cols = screen->columns_of_workspaces;
+  if (rows <= 0 && cols <= 0)
+    cols = num_workspaces;
+
+  if (rows <= 0)
+    rows = num_workspaces / cols + ((num_workspaces % cols) > 0 ? 1 : 0);
+  if (cols <= 0)
+    cols = num_workspaces / rows + ((num_workspaces % rows) > 0 ? 1 : 0);
+
+  /* paranoia */
+  if (rows < 1)
+    rows = 1;
+  if (cols < 1)
+    cols = 1;
+
+  g_assert (rows != 0 && cols != 0);
+  
+  grid_area = rows * cols;
+  
+  meta_verbose ("Getting layout rows = %d cols = %d current = %d "
+                "num_spaces = %d vertical = %s corner = %s\n",
+                rows, cols, current_space, num_workspaces,
+                screen->vertical_workspaces ? "(true)" : "(false)",
+                meta_screen_corner_to_string (screen->starting_corner));
+  
+  /* ok, we want to setup the distances in the workspace array to go     
+   * in each direction. Remember, there are many ways that a workspace   
+   * array can be setup.                                                 
+   * see http://www.freedesktop.org/standards/wm-spec/1.2/html/x109.html 
+   * and look at the _NET_DESKTOP_LAYOUT section for details.            
+   * For instance:
+   */
+  /* starting_corner = META_SCREEN_TOPLEFT                         
+   *  vertical_workspaces = 0                 vertical_workspaces=1
+   *       1234                                    1357            
+   *       5678                                    2468            
+   *                                                               
+   * starting_corner = META_SCREEN_TOPRIGHT                        
+   *  vertical_workspaces = 0                 vertical_workspaces=1
+   *       4321                                    7531            
+   *       8765                                    8642            
+   *                                                               
+   * starting_corner = META_SCREEN_BOTTOMLEFT                      
+   *  vertical_workspaces = 0                 vertical_workspaces=1
+   *       5678                                    2468            
+   *       1234                                    1357            
+   *                                                               
+   * starting_corner = META_SCREEN_BOTTOMRIGHT                     
+   *  vertical_workspaces = 0                 vertical_workspaces=1
+   *       8765                                    8642            
+   *       4321                                    7531            
+   *
+   */
+  /* keep in mind that we could have a ragged layout, e.g. the "8"
+   * in the above grids could be missing
+   */
+
+  
+  grid = g_new (int, grid_area);
+
+  current_row = -1;
+  current_col = -1;
+  i = 0;
+  
+  switch (screen->starting_corner) 
+    {
+    case META_SCREEN_TOPLEFT:
+      if (screen->vertical_workspaces) 
+        {
+          c = 0;
+          while (c < cols)
+            {
+              r = 0;
+              while (r < rows)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  ++r;
+                }
+              ++c;
+            }
+        }
+      else
+        {
+          r = 0;
+          while (r < rows)
+            {
+              c = 0;
+              while (c < cols)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  ++c;
+                }
+              ++r;
+            }
+        }
+      break;
+    case META_SCREEN_TOPRIGHT:
+      if (screen->vertical_workspaces) 
+        {
+          c = cols - 1;
+          while (c >= 0)
+            {
+              r = 0;
+              while (r < rows)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  ++r;
+                }
+              --c;
+            }
+        }
+      else
+        {
+          r = 0;
+          while (r < rows)
+            {
+              c = cols - 1;
+              while (c >= 0)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  --c;
+                }
+              ++r;
+            }
+        }
+      break;
+    case META_SCREEN_BOTTOMLEFT:
+      if (screen->vertical_workspaces) 
+        {
+          c = 0;
+          while (c < cols)
+            {
+              r = rows - 1;
+              while (r >= 0)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  --r;
+                }
+              ++c;
+            }
+        }
+      else
+        {
+          r = rows - 1;
+          while (r >= 0)
+            {
+              c = 0;
+              while (c < cols)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  ++c;
+                }
+              --r;
+            }
+        }
+      break;
+    case META_SCREEN_BOTTOMRIGHT:
+      if (screen->vertical_workspaces) 
+        {
+          c = cols - 1;
+          while (c >= 0)
+            {
+              r = rows - 1;
+              while (r >= 0)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  --r;
+                }
+              --c;
+            }
+        }
+      else
+        {
+          r = rows - 1;
+          while (r >= 0)
+            {
+              c = cols - 1;
+              while (c >= 0)
+                {
+                  grid[r*cols+c] = i;
+                  ++i;
+                  --c;
+                }
+              --r;
+            }
+        }
+      break;
+    }  
+
+  if (i != grid_area)
+    meta_bug ("did not fill in the whole workspace grid in %s (%d filled)\n",
+              G_STRFUNC, i);
+  
+  current_row = 0;
+  current_col = 0;
+  r = 0;
+  while (r < rows)
+    {
+      c = 0;
+      while (c < cols)
+        {
+          if (grid[r*cols+c] == current_space)
+            {
+              current_row = r;
+              current_col = c;
+            }
+          else if (grid[r*cols+c] >= num_workspaces)
+            {
+              /* flag nonexistent spaces with -1 */
+              grid[r*cols+c] = -1;
+            }
+          ++c;
+        }
+      ++r;
+    }
+
+  layout->rows = rows;
+  layout->cols = cols;
+  layout->grid = grid;
+  layout->grid_area = grid_area;
+  layout->current_row = current_row;
+  layout->current_col = current_col;
+
+#ifdef WITH_VERBOSE_MODE
+  if (meta_is_verbose ())
+    {
+      r = 0;
+      while (r < layout->rows)
+        {
+          meta_verbose (" ");
+          meta_push_no_msg_prefix ();
+          c = 0;
+          while (c < layout->cols)
+            {
+              if (r == layout->current_row &&
+                  c == layout->current_col)
+                meta_verbose ("*%2d ", layout->grid[r*layout->cols+c]);
+              else
+                meta_verbose ("%3d ", layout->grid[r*layout->cols+c]);
+              ++c;
+            }
+          meta_verbose ("\n");
+          meta_pop_no_msg_prefix ();
+          ++r;
+        }
+    }
+#endif /* WITH_VERBOSE_MODE */
+}
+
+void
+meta_screen_free_workspace_layout (MetaWorkspaceLayout *layout)
+{
+  g_free (layout->grid);
+}
+
+static void
+meta_screen_resize_func (MetaScreen *screen,
+                         MetaWindow *window,
+                         void       *user_data)
+{
+  if (window->struts)
+    {
+      meta_window_update_struts (window);
+    }
+  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+
+  meta_window_recalc_features (window);
+}
+
+void
+meta_screen_resize (MetaScreen *screen,
+                    int         width,
+                    int         height)
+{  
+  screen->rect.width = width;
+  screen->rect.height = height;
+
+  reload_xinerama_infos (screen);
+  set_desktop_geometry_hint (screen);
+  
+  /* Queue a resize on all the windows */
+  meta_screen_foreach_window (screen, meta_screen_resize_func, 0);
+}
+
+void
+meta_screen_update_showing_desktop_hint (MetaScreen *screen)
+{
+  unsigned long data[1];
+
+  data[0] = screen->active_workspace->showing_desktop ? 1 : 0;
+      
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_SHOWING_DESKTOP,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+static void
+queue_windows_showing (MetaScreen *screen)
+{
+  GSList *windows;
+  GSList *tmp;
+
+  /* Must operate on all windows on display instead of just on the
+   * active_workspace's window list, because the active_workspace's
+   * window list may not contain the on_all_workspace windows.
+   */
+  windows = meta_display_list_windows (screen->display);
+
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      if (w->screen == screen)
+        meta_window_queue (w, META_QUEUE_CALC_SHOWING);
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (windows);
+}
+
+void
+meta_screen_minimize_all_on_active_workspace_except (MetaScreen *screen,
+                                                     MetaWindow *keep)
+{
+  GList *windows;
+  GList *tmp;
+
+  windows = screen->active_workspace->windows;
+  
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+      
+      if (w->screen == screen  &&
+          w->has_minimize_func &&
+	  w != keep)
+	meta_window_minimize (w);
+      
+      tmp = tmp->next;
+    }
+}
+
+void
+meta_screen_show_desktop (MetaScreen *screen, 
+                          guint32     timestamp)
+{
+  GList *windows;
+
+  if (screen->active_workspace->showing_desktop)
+    return;
+  
+  screen->active_workspace->showing_desktop = TRUE;
+  
+  queue_windows_showing (screen);
+
+  /* Focus the most recently used META_WINDOW_DESKTOP window, if there is one;
+   * see bug 159257.
+   */
+  windows = screen->active_workspace->mru_list;
+  while (windows != NULL)
+    {
+      MetaWindow *w = windows->data;
+      
+      if (w->screen == screen  && 
+          w->type == META_WINDOW_DESKTOP)
+        {
+          meta_window_focus (w, timestamp);
+          break;
+        }
+      
+      windows = windows->next;
+    }
+
+  
+  meta_screen_update_showing_desktop_hint (screen);
+}
+
+void
+meta_screen_unshow_desktop (MetaScreen *screen)
+{
+  if (!screen->active_workspace->showing_desktop)
+    return;
+
+  screen->active_workspace->showing_desktop = FALSE;
+
+  queue_windows_showing (screen);
+
+  meta_screen_update_showing_desktop_hint (screen);
+}
+
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+static gboolean startup_sequence_timeout (void *data);
+
+static void
+update_startup_feedback (MetaScreen *screen)
+{
+  if (screen->startup_sequences != NULL)
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Setting busy cursor\n");
+      meta_screen_set_cursor (screen, META_CURSOR_BUSY);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Setting default cursor\n");
+      meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
+    }
+}
+
+static void
+add_sequence (MetaScreen        *screen,
+              SnStartupSequence *sequence)
+{
+  meta_topic (META_DEBUG_STARTUP,
+              "Adding sequence %s\n",
+              sn_startup_sequence_get_id (sequence));
+  sn_startup_sequence_ref (sequence);
+  screen->startup_sequences = g_slist_prepend (screen->startup_sequences,
+                                               sequence);
+
+  /* our timeout just polls every second, instead of bothering
+   * to compute exactly when we may next time out
+   */
+  if (screen->startup_sequence_timeout == 0)
+    screen->startup_sequence_timeout = g_timeout_add (1000,
+                                                      startup_sequence_timeout,
+                                                      screen);
+
+  update_startup_feedback (screen);
+}
+
+static void
+remove_sequence (MetaScreen        *screen,
+                 SnStartupSequence *sequence)
+{
+  meta_topic (META_DEBUG_STARTUP,
+              "Removing sequence %s\n",
+              sn_startup_sequence_get_id (sequence));
+  
+  screen->startup_sequences = g_slist_remove (screen->startup_sequences,
+                                              sequence);
+  sn_startup_sequence_unref (sequence);
+  
+  if (screen->startup_sequences == NULL &&
+      screen->startup_sequence_timeout != 0)
+    {
+      g_source_remove (screen->startup_sequence_timeout);
+      screen->startup_sequence_timeout = 0;
+    }
+
+  update_startup_feedback (screen);
+}
+
+typedef struct
+{
+  GSList *list;
+  GTimeVal now;
+} CollectTimedOutData;
+
+/* This should be fairly long, as it should never be required unless
+ * apps or .desktop files are buggy, and it's confusing if
+ * OpenOffice or whatever seems to stop launching - people
+ * might decide they need to launch it again.
+ */
+#define STARTUP_TIMEOUT 15000
+
+static void
+collect_timed_out_foreach (void *element,
+                           void *data)
+{
+  CollectTimedOutData *ctod = data;
+  SnStartupSequence *sequence = element;
+  long tv_sec, tv_usec;
+  double elapsed;
+  
+  sn_startup_sequence_get_last_active_time (sequence, &tv_sec, &tv_usec);
+
+  elapsed =
+    ((((double)ctod->now.tv_sec - tv_sec) * G_USEC_PER_SEC +
+      (ctod->now.tv_usec - tv_usec))) / 1000.0;
+
+  meta_topic (META_DEBUG_STARTUP,
+              "Sequence used %g seconds vs. %g max: %s\n",
+              elapsed, (double) STARTUP_TIMEOUT,
+              sn_startup_sequence_get_id (sequence));
+  
+  if (elapsed > STARTUP_TIMEOUT)
+    ctod->list = g_slist_prepend (ctod->list, sequence);
+}
+
+static gboolean
+startup_sequence_timeout (void *data)
+{
+  MetaScreen *screen = data;
+  CollectTimedOutData ctod;
+  GSList *tmp;
+  
+  ctod.list = NULL;
+  g_get_current_time (&ctod.now);
+  g_slist_foreach (screen->startup_sequences,
+                   collect_timed_out_foreach,
+                   &ctod);
+
+  tmp = ctod.list;
+  while (tmp != NULL)
+    {
+      SnStartupSequence *sequence = tmp->data;
+
+      meta_topic (META_DEBUG_STARTUP,
+                  "Timed out sequence %s\n",
+                  sn_startup_sequence_get_id (sequence));
+      
+      sn_startup_sequence_complete (sequence);
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (ctod.list);
+  
+  if (screen->startup_sequences != NULL)
+    {
+      return TRUE;
+    }
+  else
+    {
+      /* remove */
+      screen->startup_sequence_timeout = 0;
+      return FALSE;
+    }
+}
+
+static void
+meta_screen_sn_event (SnMonitorEvent *event,
+                      void           *user_data)
+{
+  MetaScreen *screen;
+  SnStartupSequence *sequence;
+  
+  screen = user_data;
+
+  sequence = sn_monitor_event_get_startup_sequence (event);
+  
+  switch (sn_monitor_event_get_type (event))
+    {
+    case SN_MONITOR_EVENT_INITIATED:
+      {
+        const char *wmclass;
+
+        wmclass = sn_startup_sequence_get_wmclass (sequence);
+        
+        meta_topic (META_DEBUG_STARTUP,
+                    "Received startup initiated for %s wmclass %s\n",
+                    sn_startup_sequence_get_id (sequence),
+                    wmclass ? wmclass : "(unset)");
+        add_sequence (screen, sequence);
+      }
+      break;
+
+    case SN_MONITOR_EVENT_COMPLETED:
+      {
+        meta_topic (META_DEBUG_STARTUP,
+                    "Received startup completed for %s\n",
+                    sn_startup_sequence_get_id (sequence));
+        remove_sequence (screen,
+                         sn_monitor_event_get_startup_sequence (event));
+      }
+      break;
+
+    case SN_MONITOR_EVENT_CHANGED:
+      meta_topic (META_DEBUG_STARTUP,
+                  "Received startup changed for %s\n",
+                  sn_startup_sequence_get_id (sequence));
+      break;
+
+    case SN_MONITOR_EVENT_CANCELED:
+      meta_topic (META_DEBUG_STARTUP,
+                  "Received startup canceled for %s\n",
+                  sn_startup_sequence_get_id (sequence));
+      break;
+    }
+}
+#endif
+
+/* Sets the initial_timestamp and initial_workspace properties
+ * of a window according to information given us by the
+ * startup-notification library.
+ *
+ * Returns TRUE if startup properties have been applied, and
+ * FALSE if they have not (for example, if they had already
+ * been applied.)
+ */
+gboolean
+meta_screen_apply_startup_properties (MetaScreen *screen,
+                                      MetaWindow *window)
+{
+#ifdef HAVE_STARTUP_NOTIFICATION
+  const char *startup_id;
+  GSList *tmp;
+  SnStartupSequence *sequence;
+  
+  /* Does the window have a startup ID stored? */
+  startup_id = meta_window_get_startup_id (window);
+
+  meta_topic (META_DEBUG_STARTUP,
+              "Applying startup props to %s id \"%s\"\n",
+              window->desc,
+              startup_id ? startup_id : "(none)");
+  
+  sequence = NULL;
+  if (startup_id == NULL)
+    {
+      /* No startup ID stored for the window. Let's ask the
+       * startup-notification library whether there's anything
+       * stored for the resource name or resource class hints.
+       */
+      tmp = screen->startup_sequences;
+      while (tmp != NULL)
+        {
+          const char *wmclass;
+
+          wmclass = sn_startup_sequence_get_wmclass (tmp->data);
+
+          if (wmclass != NULL &&
+              ((window->res_class &&
+                strcmp (wmclass, window->res_class) == 0) ||
+               (window->res_name &&
+                strcmp (wmclass, window->res_name) == 0)))
+            {
+              sequence = tmp->data;
+
+              g_assert (window->startup_id == NULL);
+              window->startup_id = g_strdup (sn_startup_sequence_get_id (sequence));
+              startup_id = window->startup_id;
+
+              meta_topic (META_DEBUG_STARTUP,
+                          "Ending legacy sequence %s due to window %s\n",
+                          sn_startup_sequence_get_id (sequence),
+                          window->desc);
+              
+              sn_startup_sequence_complete (sequence);
+              break;
+            }
+          
+          tmp = tmp->next;
+        }
+    }
+
+  /* Still no startup ID? Bail. */
+  if (startup_id == NULL)
+    return FALSE;
+  
+  /* We might get this far and not know the sequence ID (if the window
+   * already had a startup ID stored), so let's look for one if we don't
+   * already know it.
+   */
+  if (sequence == NULL)
+    {
+      tmp = screen->startup_sequences;
+      while (tmp != NULL)
+        {
+          const char *id;
+          
+          id = sn_startup_sequence_get_id (tmp->data);
+          
+          if (strcmp (id, startup_id) == 0)
+            {
+              sequence = tmp->data;
+              break;
+            }
+          
+          tmp = tmp->next;
+        }
+    }
+
+  if (sequence != NULL)
+    {
+      gboolean changed_something = FALSE;
+          
+      meta_topic (META_DEBUG_STARTUP,
+                  "Found startup sequence for window %s ID \"%s\"\n",
+                  window->desc, startup_id);
+
+      if (!window->initial_workspace_set)
+        {
+          int space = sn_startup_sequence_get_workspace (sequence);
+          if (space >= 0)
+            {
+              meta_topic (META_DEBUG_STARTUP,
+                          "Setting initial window workspace to %d based on startup info\n",
+                          space);
+              
+              window->initial_workspace_set = TRUE;
+              window->initial_workspace = space;
+              changed_something = TRUE;
+            }
+        }
+
+      if (!window->initial_timestamp_set)
+        {
+          guint32 timestamp = sn_startup_sequence_get_timestamp (sequence);
+          meta_topic (META_DEBUG_STARTUP,
+                      "Setting initial window timestamp to %u based on startup info\n",
+                      timestamp);
+              
+          window->initial_timestamp_set = TRUE;
+          window->initial_timestamp = timestamp;
+          changed_something = TRUE;
+        }
+
+      return changed_something;
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Did not find startup sequence for window %s ID \"%s\"\n",
+                  window->desc, startup_id);
+    }
+  
+#endif /* HAVE_STARTUP_NOTIFICATION */
+
+  return FALSE;
+}
+
+int
+meta_screen_get_screen_number (MetaScreen *screen)
+{
+  return screen->number;
+}
+
+MetaDisplay *
+meta_screen_get_display (MetaScreen *screen)
+{
+  return screen->display;
+}
+
+Window
+meta_screen_get_xroot (MetaScreen *screen)
+{
+  return screen->xroot;
+}
+
+void 
+meta_screen_get_size (MetaScreen *screen,
+                      int        *width,
+                      int        *height)
+{
+  *width = screen->rect.width;
+  *height = screen->rect.height;
+}
+
+gpointer
+meta_screen_get_compositor_data (MetaScreen *screen)
+{
+  return screen->compositor_data;
+}
+
+void
+meta_screen_set_compositor_data (MetaScreen *screen,
+                                 gpointer    compositor)
+{
+  screen->compositor_data = compositor;
+}
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+void
+meta_screen_set_cm_selection (MetaScreen *screen)
+{
+  char selection[32];
+  Atom a;
+
+  screen->wm_cm_timestamp = meta_display_get_current_time_roundtrip (
+                                                               screen->display);
+
+  g_snprintf (selection, sizeof(selection), "_NET_WM_CM_S%d", screen->number);
+  meta_verbose ("Setting selection: %s\n", selection);
+  a = XInternAtom (screen->display->xdisplay, selection, FALSE);
+  XSetSelectionOwner (screen->display->xdisplay, a, 
+                      screen->wm_cm_selection_window, screen->wm_cm_timestamp);
+}
+
+void
+meta_screen_unset_cm_selection (MetaScreen *screen)
+{
+  char selection[32];
+  Atom a;
+
+  g_snprintf (selection, sizeof(selection), "_NET_WM_CM_S%d", screen->number);
+  a = XInternAtom (screen->display->xdisplay, selection, FALSE);
+  XSetSelectionOwner (screen->display->xdisplay, a,
+                      None, screen->wm_cm_timestamp);
+}
+#endif /* HAVE_COMPOSITE_EXTENSIONS */
diff --git a/src/core/session.c b/src/core/session.c
new file mode 100644
index 00000000..80d22365
--- /dev/null
+++ b/src/core/session.c
@@ -0,0 +1,1831 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco Session Management */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington (some code in here from
+ * libmateui, (C) Tom Tromey, Carsten Schaar)
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "session.h"
+#include <X11/Xatom.h>
+
+#include <time.h>
+#include <sys/wait.h>
+
+#ifndef HAVE_SM
+void
+meta_session_init (const char *client_id,
+                   const char *save_file)
+{
+  meta_topic (META_DEBUG_SM, "Compiled without session management support\n");
+}
+
+void
+meta_session_shutdown (void)
+{
+  /* nothing */
+}
+
+const MetaWindowSessionInfo*
+meta_window_lookup_saved_state (MetaWindow *window)
+{
+  return NULL;
+}
+
+void
+meta_window_release_saved_state (const MetaWindowSessionInfo *info)
+{
+  ;
+}
+#else /* HAVE_SM */
+
+#include <X11/ICE/ICElib.h>
+#include <X11/SM/SMlib.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <glib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "main.h"
+#include "util.h"
+#include "display-private.h"
+#include "workspace.h"
+
+static void ice_io_error_handler (IceConn connection);
+
+static void new_ice_connection (IceConn connection, IcePointer client_data, 
+				Bool opening, IcePointer *watch_data);
+
+static void        save_state         (void);
+static char*       load_state         (const char *previous_save_file);
+static void        regenerate_save_file (void);
+static const char* full_save_file       (void);
+static void        warn_about_lame_clients_and_finish_interact (gboolean shutdown);
+static void        disconnect         (void);
+
+/* This is called when data is available on an ICE connection.  */
+static gboolean
+process_ice_messages (GIOChannel *channel,
+                      GIOCondition condition,
+                      gpointer client_data)
+{
+  IceConn connection = (IceConn) client_data;
+  IceProcessMessagesStatus status;
+
+  /* This blocks infinitely sometimes. I don't know what
+   * to do about it. Checking "condition" just breaks
+   * session management.
+   */
+  status = IceProcessMessages (connection, NULL, NULL);
+
+  if (status == IceProcessMessagesIOError)
+    {
+#if 0
+      IcePointer context = IceGetConnectionContext (connection);
+#endif
+      
+      /* We were disconnected; close our connection to the
+       * session manager, this will result in the ICE connection
+       * being cleaned up, since it is owned by libSM.
+       */
+      disconnect ();
+      meta_quit (META_EXIT_SUCCESS);
+
+      return FALSE;
+    }
+  
+  return TRUE;
+}
+
+/* This is called when a new ICE connection is made.  It arranges for
+   the ICE connection to be handled via the event loop.  */
+static void
+new_ice_connection (IceConn connection, IcePointer client_data, Bool opening,
+		    IcePointer *watch_data)
+{
+  guint input_id;
+
+  if (opening)
+    {
+      /* Make sure we don't pass on these file descriptors to any
+       * exec'ed children
+       */
+      GIOChannel *channel;
+      
+      fcntl (IceConnectionNumber (connection), F_SETFD,
+             fcntl (IceConnectionNumber (connection), F_GETFD, 0) | FD_CLOEXEC);
+
+      channel = g_io_channel_unix_new (IceConnectionNumber (connection));
+      
+      input_id = g_io_add_watch (channel,
+                                 G_IO_IN | G_IO_ERR,
+                                 process_ice_messages,
+                                 connection);
+
+      g_io_channel_unref (channel);
+      
+      *watch_data = (IcePointer) GUINT_TO_POINTER (input_id);
+    }
+  else 
+    {
+      input_id = GPOINTER_TO_UINT ((gpointer) *watch_data);
+
+      g_source_remove (input_id);
+    }
+}
+
+static IceIOErrorHandler ice_installed_handler;
+
+/* We call any handler installed before (or after) mate_ice_init but 
+   avoid calling the default libICE handler which does an exit() */
+static void
+ice_io_error_handler (IceConn connection)
+{
+    if (ice_installed_handler)
+      (*ice_installed_handler) (connection);
+}    
+
+static void
+ice_init (void)
+{
+  static gboolean ice_initted = FALSE;
+
+  if (! ice_initted)
+    {
+      IceIOErrorHandler default_handler;
+
+      ice_installed_handler = IceSetIOErrorHandler (NULL);
+      default_handler = IceSetIOErrorHandler (ice_io_error_handler);
+
+      if (ice_installed_handler == default_handler)
+	ice_installed_handler = NULL;
+
+      IceAddConnectionWatch (new_ice_connection, NULL);
+
+      ice_initted = TRUE;
+    }
+}
+
+typedef enum
+{
+  STATE_DISCONNECTED,
+  STATE_IDLE,
+  STATE_SAVING_PHASE_1,
+  STATE_WAITING_FOR_PHASE_2,
+  STATE_SAVING_PHASE_2,
+  STATE_WAITING_FOR_INTERACT,
+  STATE_DONE_WITH_INTERACT,
+  STATE_SKIPPING_GLOBAL_SAVE,
+  STATE_FROZEN,
+  STATE_REGISTERING
+} ClientState;
+
+static void save_phase_2_callback       (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void interact_callback           (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void shutdown_cancelled_callback (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void save_complete_callback      (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void die_callback                (SmcConn   smc_conn,
+                                         SmPointer client_data);
+static void save_yourself_callback      (SmcConn   smc_conn,
+                                         SmPointer client_data,
+                                         int       save_style,
+                                         Bool      shutdown,
+                                         int       interact_style,
+                                         Bool      fast);
+static void set_clone_restart_commands  (void);
+
+static char *client_id = NULL;
+static gpointer session_connection = NULL;
+static ClientState current_state = STATE_DISCONNECTED;
+static gboolean interaction_allowed = FALSE;
+
+void
+meta_session_init (const char *previous_client_id,
+                   const char *previous_save_file)
+{
+  /* Some code here from twm */
+  char buf[256];
+  unsigned long mask;
+  SmcCallbacks callbacks;
+  char *saved_client_id;
+  
+  meta_topic (META_DEBUG_SM, "Initializing session with save file '%s'\n",
+              previous_save_file ? previous_save_file : "(none)");
+
+  if (previous_save_file)
+    {
+      saved_client_id = load_state (previous_save_file);
+      previous_client_id = saved_client_id;
+    }
+  else if (previous_client_id)
+    {
+      char *save_file = g_strconcat (previous_client_id, ".ms", NULL);
+      saved_client_id = load_state (save_file);
+      g_free (save_file);
+    }
+  else
+    {
+      saved_client_id = NULL;
+    }
+  
+  ice_init ();
+  
+  mask = SmcSaveYourselfProcMask | SmcDieProcMask |
+    SmcSaveCompleteProcMask | SmcShutdownCancelledProcMask;
+  
+  callbacks.save_yourself.callback = save_yourself_callback;
+  callbacks.save_yourself.client_data = NULL;
+  
+  callbacks.die.callback = die_callback;
+  callbacks.die.client_data = NULL;
+  
+  callbacks.save_complete.callback = save_complete_callback;
+  callbacks.save_complete.client_data = NULL;
+  
+  callbacks.shutdown_cancelled.callback = shutdown_cancelled_callback;
+  callbacks.shutdown_cancelled.client_data = NULL;
+  
+  session_connection =
+    SmcOpenConnection (NULL, /* use SESSION_MANAGER env */
+                       NULL, /* means use existing ICE connection */
+                       SmProtoMajor,
+                       SmProtoMinor,
+                       mask,
+                       &callbacks,
+                       (char*) previous_client_id,
+                       &client_id,
+                       255, buf);
+  
+  if (session_connection == NULL)
+    {
+      meta_topic (META_DEBUG_SM, 
+                  "Failed to a open connection to a session manager, so window positions will not be saved: %s\n",
+                  buf);
+
+      goto out;
+    }
+  else
+    {
+      if (client_id == NULL)
+        meta_bug ("Session manager gave us a NULL client ID?");
+      meta_topic (META_DEBUG_SM, "Obtained session ID '%s'\n", client_id);
+    }
+
+  if (previous_client_id && strcmp (previous_client_id, client_id) == 0)
+    current_state = STATE_IDLE;
+  else
+    current_state = STATE_REGISTERING;
+  
+  {
+    SmProp prop1, prop2, prop3, prop4, prop5, prop6, *props[6];
+    SmPropValue prop1val, prop2val, prop3val, prop4val, prop5val, prop6val;
+    char pid[32];
+    char hint = SmRestartImmediately;
+    char priority = 20; /* low to run before other apps */
+    
+    prop1.name = SmProgram;
+    prop1.type = SmARRAY8;
+    prop1.num_vals = 1;
+    prop1.vals = &prop1val;
+    prop1val.value = "marco";
+    prop1val.length = strlen ("marco");
+
+    /* twm sets getuid() for this, but the SM spec plainly
+     * says pw_name, twm is on crack
+     */
+    prop2.name = SmUserID;
+    prop2.type = SmARRAY8;
+    prop2.num_vals = 1;
+    prop2.vals = &prop2val;
+    prop2val.value = (char*) g_get_user_name ();
+    prop2val.length = strlen (prop2val.value);
+	
+    prop3.name = SmRestartStyleHint;
+    prop3.type = SmCARD8;
+    prop3.num_vals = 1;
+    prop3.vals = &prop3val;
+    prop3val.value = &hint;
+    prop3val.length = 1;
+
+    sprintf (pid, "%d", getpid ());
+    prop4.name = SmProcessID;
+    prop4.type = SmARRAY8;
+    prop4.num_vals = 1;
+    prop4.vals = &prop4val;
+    prop4val.value = pid;
+    prop4val.length = strlen (prop4val.value);    
+
+    /* Always start in home directory */
+    prop5.name = SmCurrentDirectory;
+    prop5.type = SmARRAY8;
+    prop5.num_vals = 1;
+    prop5.vals = &prop5val;
+    prop5val.value = (char*) g_get_home_dir ();
+    prop5val.length = strlen (prop5val.value);
+
+    prop6.name = "_GSM_Priority";
+    prop6.type = SmCARD8;
+    prop6.num_vals = 1;
+    prop6.vals = &prop6val;
+    prop6val.value = &priority;
+    prop6val.length = 1;
+    
+    props[0] = &prop1;
+    props[1] = &prop2;
+    props[2] = &prop3;
+    props[3] = &prop4;
+    props[4] = &prop5;
+    props[5] = &prop6;
+    
+    SmcSetProperties (session_connection, 6, props);
+  }
+
+ out:
+  g_free (saved_client_id);
+}
+
+void
+meta_session_shutdown (void)
+{
+  /* Change our restart mode to IfRunning */
+  
+  SmProp prop1;
+  SmPropValue prop1val;
+  SmProp *props[1];
+  char hint = SmRestartIfRunning;
+
+  if (!meta_get_display ())
+    {
+      meta_verbose ("Cannot close session because there is no display");
+      return;
+    }
+
+  warn_about_lame_clients_and_finish_interact (FALSE);
+
+  if (session_connection == NULL)
+    return;
+  
+  prop1.name = SmRestartStyleHint;
+  prop1.type = SmCARD8;
+  prop1.num_vals = 1;
+  prop1.vals = &prop1val;
+  prop1val.value = &hint;
+  prop1val.length = 1;
+    
+  props[0] = &prop1;
+  
+  SmcSetProperties (session_connection, 1, props);
+}
+
+static void
+disconnect (void)
+{
+  SmcCloseConnection (session_connection, 0, NULL);
+  session_connection = NULL;
+  current_state = STATE_DISCONNECTED;
+}
+
+static void
+save_yourself_possibly_done (gboolean shutdown,
+                             gboolean successful)
+{
+  meta_topic (META_DEBUG_SM,
+              "save possibly done shutdown = %d success = %d\n",
+              shutdown, successful);
+  
+  if (current_state == STATE_SAVING_PHASE_1)
+    {
+      Status status;
+      
+      status = SmcRequestSaveYourselfPhase2 (session_connection,
+                                             save_phase_2_callback,
+                                             GINT_TO_POINTER (shutdown));
+
+      if (status)
+        current_state = STATE_WAITING_FOR_PHASE_2;
+
+      meta_topic (META_DEBUG_SM,
+                  "Requested phase 2, status = %d\n", status);
+    }
+
+  if (current_state == STATE_SAVING_PHASE_2 &&
+      interaction_allowed)
+    {
+      Status status;
+
+      status = SmcInteractRequest (session_connection,
+                                   /* ignore this feature of the protocol by always
+                                    * claiming normal
+                                    */
+                                   SmDialogNormal,
+                                   interact_callback,
+                                   GINT_TO_POINTER (shutdown));
+
+      if (status)
+        current_state = STATE_WAITING_FOR_INTERACT;
+
+      meta_topic (META_DEBUG_SM,
+                  "Requested interact, status = %d\n", status);
+    }
+  
+  if (current_state == STATE_SAVING_PHASE_1 ||
+      current_state == STATE_SAVING_PHASE_2 ||
+      current_state == STATE_DONE_WITH_INTERACT ||
+      current_state == STATE_SKIPPING_GLOBAL_SAVE)
+    {
+      meta_topic (META_DEBUG_SM, "Sending SaveYourselfDone\n");
+      
+      SmcSaveYourselfDone (session_connection,
+                           successful);
+      
+      if (shutdown)
+        current_state = STATE_FROZEN;
+      else
+        current_state = STATE_IDLE;
+    }
+}
+
+static void 
+save_phase_2_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  gboolean shutdown;
+
+  meta_topic (META_DEBUG_SM, "Phase 2 save");
+  
+  shutdown = GPOINTER_TO_INT (client_data);
+  
+  current_state = STATE_SAVING_PHASE_2;
+
+  save_state ();
+  
+  save_yourself_possibly_done (shutdown, TRUE);
+}
+
+static void
+save_yourself_callback (SmcConn   smc_conn,
+                        SmPointer client_data,
+                        int       save_style,
+                        Bool      shutdown,
+                        int       interact_style,
+                        Bool      fast)
+{
+  gboolean successful;
+
+  meta_topic (META_DEBUG_SM, "SaveYourself received");
+  
+  successful = TRUE;
+  
+  /* The first SaveYourself after registering for the first time
+   * is a special case (SM specs 7.2).
+   */
+
+#if 0 /* I think the MateClient rationale for this doesn't apply */
+  if (current_state == STATE_REGISTERING)
+    {
+      current_state = STATE_IDLE;
+      /* Double check that this is a section 7.2 SaveYourself: */
+      
+      if (save_style == SmSaveLocal && 
+	  interact_style == SmInteractStyleNone &&
+	  !shutdown && !fast)
+	{
+	  /* The protocol requires this even if xsm ignores it. */
+	  SmcSaveYourselfDone (session_connection, successful);
+	  return;
+	}
+    }
+#endif
+
+  /* ignore Global style saves
+   * 
+   * This interpretaion of the Local/Global/Both styles
+   * was discussed extensively on the xdg-list. See:
+   *
+   * https://listman.redhat.com/pipermail/xdg-list/2002-July/000615.html
+   */
+  if (save_style == SmSaveGlobal)
+    {
+      current_state = STATE_SKIPPING_GLOBAL_SAVE;
+      save_yourself_possibly_done (shutdown, successful);
+      return;
+    }
+
+  interaction_allowed = interact_style != SmInteractStyleNone;
+  
+  current_state = STATE_SAVING_PHASE_1;
+
+  regenerate_save_file ();
+  
+  set_clone_restart_commands ();
+
+  save_yourself_possibly_done (shutdown, successful);
+}
+
+
+static void
+die_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  meta_topic (META_DEBUG_SM, "Exiting at request of session manager\n");
+  disconnect ();
+  meta_quit (META_EXIT_SUCCESS);
+}
+
+static void
+save_complete_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  /* nothing */
+  meta_topic (META_DEBUG_SM, "SaveComplete received\n");
+}
+
+static void
+shutdown_cancelled_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  meta_topic (META_DEBUG_SM, "Shutdown cancelled received\n");
+  
+  if (session_connection != NULL &&
+      (current_state != STATE_IDLE && current_state != STATE_FROZEN))
+    {
+      SmcSaveYourselfDone (session_connection, True);
+      current_state = STATE_IDLE;
+    }
+}
+
+static void 
+interact_callback (SmcConn smc_conn, SmPointer client_data)
+{
+  /* nothing */
+  gboolean shutdown;
+
+  meta_topic (META_DEBUG_SM, "Interaction permission received\n");
+  
+  shutdown = GPOINTER_TO_INT (client_data);
+
+  current_state = STATE_DONE_WITH_INTERACT;
+
+  warn_about_lame_clients_and_finish_interact (shutdown);
+}
+
+static void
+set_clone_restart_commands (void)
+{
+  char *restartv[10];
+  char *clonev[10];
+  char *discardv[10];
+  int i;
+  SmProp prop1, prop2, prop3, *props[3];
+  
+  /* Restart (use same client ID) */
+  
+  prop1.name = SmRestartCommand;
+  prop1.type = SmLISTofARRAY8;
+  
+  g_return_if_fail (client_id);
+  
+  i = 0;
+  restartv[i] = "marco";
+  ++i;
+  restartv[i] = "--sm-client-id";
+  ++i;
+  restartv[i] = client_id;
+  ++i;
+  restartv[i] = NULL;
+
+  prop1.vals = g_new (SmPropValue, i);
+  i = 0;
+  while (restartv[i])
+    {
+      prop1.vals[i].value = restartv[i];
+      prop1.vals[i].length = strlen (restartv[i]);
+      ++i;
+    }
+  prop1.num_vals = i;
+
+  /* Clone (no client ID) */
+  
+  i = 0;
+  clonev[i] = "marco";
+  ++i;
+  clonev[i] = NULL;
+
+  prop2.name = SmCloneCommand;
+  prop2.type = SmLISTofARRAY8;
+  
+  prop2.vals = g_new (SmPropValue, i);
+  i = 0;
+  while (clonev[i])
+    {
+      prop2.vals[i].value = clonev[i];
+      prop2.vals[i].length = strlen (clonev[i]);
+      ++i;
+    }
+  prop2.num_vals = i;
+
+  /* Discard */
+  
+  i = 0;
+  discardv[i] = "rm";
+  ++i;
+  discardv[i] = "-f";
+  ++i;
+  discardv[i] = (char*) full_save_file ();
+  ++i;
+  discardv[i] = NULL;
+  
+  prop3.name = SmDiscardCommand;
+  prop3.type = SmLISTofARRAY8;
+  
+  prop3.vals = g_new (SmPropValue, i);
+  i = 0;
+  while (discardv[i])
+    {
+      prop3.vals[i].value = discardv[i];
+      prop3.vals[i].length = strlen (discardv[i]);
+      ++i;
+    }
+  prop3.num_vals = i;
+
+  
+  props[0] = &prop1;
+  props[1] = &prop2;
+  props[2] = &prop3;
+  
+  SmcSetProperties (session_connection, 3, props);
+
+  g_free (prop1.vals);
+  g_free (prop2.vals);
+  g_free (prop3.vals);
+}
+
+/* The remaining code in this file actually loads/saves the session,
+ * while the code above this comment handles chatting with the
+ * session manager.
+ */
+
+static const char*
+window_type_to_string (MetaWindowType type)
+{
+  switch (type)
+    {
+    case META_WINDOW_NORMAL:
+      return "normal";
+    case META_WINDOW_DESKTOP:
+      return "desktop";
+    case META_WINDOW_DOCK:
+      return "dock";
+    case META_WINDOW_DIALOG:
+      return "dialog";
+    case META_WINDOW_MODAL_DIALOG:
+      return "modal_dialog";
+    case META_WINDOW_TOOLBAR:
+      return "toolbar";
+    case META_WINDOW_MENU:
+      return "menu";
+    case META_WINDOW_SPLASHSCREEN:
+      return "splashscreen";
+    case META_WINDOW_UTILITY:
+      return "utility";
+    }
+
+  return "";
+} 
+
+static MetaWindowType
+window_type_from_string (const char *str)
+{
+  if (strcmp (str, "normal") == 0)
+    return META_WINDOW_NORMAL;
+  else if (strcmp (str, "desktop") == 0)
+    return META_WINDOW_DESKTOP;
+  else if (strcmp (str, "dock") == 0)
+    return META_WINDOW_DOCK;
+  else if (strcmp (str, "dialog") == 0)
+    return META_WINDOW_DIALOG;
+  else if (strcmp (str, "modal_dialog") == 0)
+    return META_WINDOW_MODAL_DIALOG;
+  else if (strcmp (str, "toolbar") == 0)
+    return META_WINDOW_TOOLBAR;
+  else if (strcmp (str, "menu") == 0)
+    return META_WINDOW_MENU;
+  else if (strcmp (str, "utility") == 0)
+    return META_WINDOW_UTILITY;
+  else if (strcmp (str, "splashscreen") == 0)
+    return META_WINDOW_SPLASHSCREEN;
+  else
+    return META_WINDOW_NORMAL;
+}
+
+static int
+window_gravity_from_string (const char *str)
+{
+  if (strcmp (str, "NorthWestGravity") == 0)
+    return NorthWestGravity;
+  else if (strcmp (str, "NorthGravity") == 0)
+    return NorthGravity;
+  else if (strcmp (str, "NorthEastGravity") == 0)
+    return NorthEastGravity;
+  else if (strcmp (str, "WestGravity") == 0)
+    return WestGravity;
+  else if (strcmp (str, "CenterGravity") == 0)
+    return CenterGravity;
+  else if (strcmp (str, "EastGravity") == 0)
+    return EastGravity;
+  else if (strcmp (str, "SouthWestGravity") == 0)
+    return SouthWestGravity;
+  else if (strcmp (str, "SouthGravity") == 0)
+    return SouthGravity;
+  else if (strcmp (str, "SouthEastGravity") == 0)
+    return SouthEastGravity;
+  else if (strcmp (str, "StaticGravity") == 0)
+    return StaticGravity;
+  else
+    return NorthWestGravity;
+}
+
+static char*
+encode_text_as_utf8_markup (const char *text)
+{
+  /* text can be any encoding, and is nul-terminated.
+   * we pretend it's Latin-1 and encode as UTF-8
+   */
+  GString *str;
+  const char *p;
+  char *escaped;
+  
+  str = g_string_new ("");
+
+  p = text;
+  while (*p)
+    {
+      g_string_append_unichar (str, *p);
+      ++p;
+    }
+
+  escaped = g_markup_escape_text (str->str, str->len);
+  g_string_free (str, TRUE);
+  
+  return escaped;
+}
+
+static char*
+decode_text_from_utf8 (const char *text)
+{
+  /* Convert back from the encoded (but not escaped) UTF-8 */
+  GString *str;
+  const char *p;
+
+  str = g_string_new ("");
+  
+  p = text;
+  while (*p)
+    {
+      /* obviously this barfs if the UTF-8 contains chars > 255 */
+      g_string_append_c (str, g_utf8_get_char (p));
+
+      p = g_utf8_next_char (p);
+    }
+
+  return g_string_free (str, FALSE);
+}
+
+static void
+save_state (void)
+{
+  char *marco_dir;
+  char *session_dir;
+  FILE *outfile;
+  GSList *windows;
+  GSList *tmp;
+  int stack_position;
+  
+  g_assert (client_id);
+
+  outfile = NULL;
+  
+  /*
+   * g_get_user_config_dir() is guaranteed to return an existing directory.
+   * Eventually, if SM stays with the WM, I'd like to make this
+   * something like <config>/window_placement in a standard format.
+   * Future optimisers should note also that by the time we get here
+   * we probably already have full_save_path figured out and therefore
+   * can just use the directory name from that.
+   */
+  marco_dir = g_strconcat (g_get_user_config_dir (),
+                              G_DIR_SEPARATOR_S "marco",
+                              NULL);
+  
+  session_dir = g_strconcat (marco_dir,
+                             G_DIR_SEPARATOR_S "sessions",
+                             NULL);
+
+  if (mkdir (marco_dir, 0700) < 0 &&
+      errno != EEXIST)
+    {
+      meta_warning (_("Could not create directory '%s': %s\n"),
+                    marco_dir, g_strerror (errno));
+    }
+
+  if (mkdir (session_dir, 0700) < 0 &&
+      errno != EEXIST)
+    {
+      meta_warning (_("Could not create directory '%s': %s\n"),
+                    session_dir, g_strerror (errno));
+    }
+
+  meta_topic (META_DEBUG_SM, "Saving session to '%s'\n", full_save_file ());
+  
+  outfile = fopen (full_save_file (), "w");
+
+  if (outfile == NULL)
+    {
+      meta_warning (_("Could not open session file '%s' for writing: %s\n"),
+                    full_save_file (), g_strerror (errno));
+      goto out;
+    }
+
+  /* The file format is:
+   * <marco_session id="foo">
+   *   <window id="bar" class="XTerm" name="xterm" title="/foo/bar" role="blah" type="normal" stacking="5">
+   *     <workspace index="2"/>
+   *     <workspace index="4"/>
+   *     <sticky/> <minimized/> <maximized/>
+   *     <geometry x="100" y="100" width="200" height="200" gravity="northwest"/>
+   *   </window>
+   * </marco_session>
+   *
+   * Note that attributes on <window> are the match info we use to
+   * see if the saved state applies to a restored window, and
+   * child elements are the saved state to be applied.
+   * 
+   */
+  
+  fprintf (outfile, "<marco_session id=\"%s\">\n",
+           client_id);
+
+  windows = meta_display_list_windows (meta_get_display ());
+  stack_position = 0;
+
+  windows = g_slist_sort (windows, meta_display_stack_cmp);
+  tmp = windows;
+  stack_position = 0;
+
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      if (window->sm_client_id)
+        {
+          char *sm_client_id;
+          char *res_class;
+          char *res_name;
+          char *role;
+          char *title;
+
+          /* client id, class, name, role are not expected to be
+           * in UTF-8 (I think they are in XPCS which is Latin-1?
+           * in practice they are always ascii though.)
+           */
+              
+          sm_client_id = encode_text_as_utf8_markup (window->sm_client_id);
+          res_class = window->res_class ?
+            encode_text_as_utf8_markup (window->res_class) : NULL;
+          res_name = window->res_name ?
+            encode_text_as_utf8_markup (window->res_name) : NULL;
+          role = window->role ?
+            encode_text_as_utf8_markup (window->role) : NULL;
+          if (window->title)
+            title = g_markup_escape_text (window->title, -1);
+          else
+            title = NULL;
+              
+          meta_topic (META_DEBUG_SM, "Saving session managed window %s, client ID '%s'\n",
+                      window->desc, window->sm_client_id);
+
+          fprintf (outfile,
+                   "  <window id=\"%s\" class=\"%s\" name=\"%s\" title=\"%s\" role=\"%s\" type=\"%s\" stacking=\"%d\">\n",
+                   sm_client_id,
+                   res_class ? res_class : "",
+                   res_name ? res_name : "",
+                   title ? title : "",
+                   role ? role : "",
+                   window_type_to_string (window->type),
+                   stack_position);
+
+          g_free (sm_client_id);
+          g_free (res_class);
+          g_free (res_name);
+          g_free (role);
+          g_free (title);
+              
+          /* Sticky */
+          if (window->on_all_workspaces)
+            fputs ("    <sticky/>\n", outfile);
+
+          /* Minimized */
+          if (window->minimized)
+            fputs ("    <minimized/>\n", outfile);
+
+          /* Maximized */
+          if (META_WINDOW_MAXIMIZED (window))
+            {
+              fprintf (outfile,
+                       "    <maximized saved_x=\"%d\" saved_y=\"%d\" saved_width=\"%d\" saved_height=\"%d\"/>\n", 
+                       window->saved_rect.x,
+                       window->saved_rect.y,
+                       window->saved_rect.width,
+                       window->saved_rect.height);
+            }
+              
+          /* Workspaces we're on */
+          {
+            int n;
+            n = meta_workspace_index (window->workspace);
+            fprintf (outfile,
+                     "    <workspace index=\"%d\"/>\n", n);
+          }
+
+          /* Gravity */
+          {
+            int x, y, w, h;
+            meta_window_get_geometry (window, &x, &y, &w, &h);
+            
+            fprintf (outfile,
+                     "    <geometry x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" gravity=\"%s\"/>\n",
+                     x, y, w, h,
+                     meta_gravity_to_string (window->size_hints.win_gravity));
+          }
+              
+          fputs ("  </window>\n", outfile);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_SM, "Not saving window '%s', not session managed\n",
+                      window->desc);
+        }
+          
+      tmp = tmp->next;
+      ++stack_position;
+    }
+      
+  g_slist_free (windows);
+
+  fputs ("</marco_session>\n", outfile);
+  
+ out:
+  if (outfile)
+    {
+      /* FIXME need a dialog for this */
+      if (ferror (outfile))
+        {
+          meta_warning (_("Error writing session file '%s': %s\n"),
+                        full_save_file (), g_strerror (errno));
+        }
+      if (fclose (outfile))
+        {
+          meta_warning (_("Error closing session file '%s': %s\n"),
+                        full_save_file (), g_strerror (errno));
+        }
+    }
+  
+  g_free (marco_dir);
+  g_free (session_dir);
+}
+
+typedef enum
+{
+  WINDOW_TAG_NONE,
+  WINDOW_TAG_DESKTOP,
+  WINDOW_TAG_STICKY,
+  WINDOW_TAG_MINIMIZED,
+  WINDOW_TAG_MAXIMIZED,
+  WINDOW_TAG_GEOMETRY
+} WindowTag;
+
+typedef struct
+{
+  MetaWindowSessionInfo *info;
+  char *previous_id;
+} ParseData;
+
+static void                   session_info_free (MetaWindowSessionInfo *info);
+static MetaWindowSessionInfo* session_info_new  (void);
+
+static void start_element_handler (GMarkupParseContext  *context,
+                                   const gchar          *element_name,
+                                   const gchar         **attribute_names,
+                                   const gchar         **attribute_values,
+                                   gpointer              user_data,
+                                   GError              **error);
+static void end_element_handler   (GMarkupParseContext  *context,
+                                   const gchar          *element_name,
+                                   gpointer              user_data,
+                                   GError              **error);
+static void text_handler          (GMarkupParseContext  *context,
+                                   const gchar          *text,
+                                   gsize                 text_len,
+                                   gpointer              user_data,
+                                   GError              **error);
+
+static GMarkupParser marco_session_parser = {
+  start_element_handler,
+  end_element_handler,
+  text_handler,
+  NULL,
+  NULL
+};
+
+static GSList *window_info_list = NULL;
+
+static char*
+load_state (const char *previous_save_file)
+{
+  GMarkupParseContext *context;
+  GError *error;
+  ParseData parse_data;
+  char *text;
+  gsize length;
+  char *session_file;
+
+  session_file = g_strconcat (g_get_user_config_dir (),
+                              G_DIR_SEPARATOR_S "marco"
+                              G_DIR_SEPARATOR_S "sessions" G_DIR_SEPARATOR_S,
+                              previous_save_file,
+                              NULL);
+
+  error = NULL;
+  if (!g_file_get_contents (session_file,
+                            &text,
+                            &length,
+                            &error))
+    {
+      char *canonical_session_file = session_file;
+
+      /* Maybe they were doing it the old way, with ~/.marco */
+      session_file = g_strconcat (g_get_home_dir (),
+                                  G_DIR_SEPARATOR_S ".marco"
+                                  G_DIR_SEPARATOR_S "sessions"
+                                  G_DIR_SEPARATOR_S,
+                                  previous_save_file,
+                                  NULL);
+      
+      if (!g_file_get_contents (session_file,
+                                &text,
+                                &length,
+                                NULL))
+        {
+          /* oh, just give up */
+
+          g_error_free (error);
+          g_free (session_file);
+          g_free (canonical_session_file);
+          return NULL;
+        }
+
+      g_free (canonical_session_file);
+    }
+
+  meta_topic (META_DEBUG_SM, "Parsing saved session file %s\n", session_file);
+  g_free (session_file);
+  session_file = NULL;
+  
+  parse_data.info = NULL;
+  parse_data.previous_id = NULL;
+  
+  context = g_markup_parse_context_new (&marco_session_parser,
+                                        0, &parse_data, NULL);
+
+  error = NULL;
+  if (!g_markup_parse_context_parse (context,
+                                     text,
+                                     length,
+                                     &error))
+    goto error;
+  
+  
+  error = NULL;
+  if (!g_markup_parse_context_end_parse (context, &error))
+    goto error;
+
+  g_markup_parse_context_free (context);
+
+  goto out;
+
+ error:
+  
+  meta_warning (_("Failed to parse saved session file: %s\n"),
+                error->message);
+  g_error_free (error);
+
+  if (parse_data.info)
+    session_info_free (parse_data.info);
+
+  g_free (parse_data.previous_id);
+  parse_data.previous_id = NULL;
+  
+ out:
+  
+  g_free (text);
+
+  return parse_data.previous_id;
+}
+
+/* FIXME this isn't very robust against bogus session files */
+static void
+start_element_handler  (GMarkupParseContext *context,
+                        const gchar         *element_name,
+                        const gchar        **attribute_names,
+                        const gchar        **attribute_values,
+                        gpointer             user_data,
+                        GError             **error)
+{
+  ParseData *pd;
+
+  pd = user_data;
+
+  if (strcmp (element_name, "marco_session") == 0)
+    {
+      /* Get previous ID */
+      int i;      
+
+      i = 0;
+      while (attribute_names[i])
+        {
+          const char *name;
+          const char *val;
+          
+          name = attribute_names[i];
+          val = attribute_values[i];
+
+          if (pd->previous_id)
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                       G_MARKUP_ERROR_PARSE,
+                           _("<marco_session> attribute seen but we already have the session ID"));
+              return;
+            }
+          
+          if (strcmp (name, "id") == 0)
+            {
+              pd->previous_id = decode_text_from_utf8 (val);
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "marco_session");
+              return;
+            }
+          
+          ++i;
+        }
+    }
+  else if (strcmp (element_name, "window") == 0)
+    {
+      int i;
+      
+      if (pd->info)
+        {
+          g_set_error (error,
+                       G_MARKUP_ERROR,
+                       G_MARKUP_ERROR_PARSE,
+                       _("nested <window> tag"));
+          return;
+        }
+      
+      pd->info = session_info_new ();
+
+      i = 0;
+      while (attribute_names[i])
+        {
+          const char *name;
+          const char *val;
+          
+          name = attribute_names[i];
+          val = attribute_values[i];
+          
+          if (strcmp (name, "id") == 0)
+            {
+              if (*val)
+                pd->info->id = decode_text_from_utf8 (val);
+            }
+          else if (strcmp (name, "class") == 0)
+            {
+              if (*val)
+                pd->info->res_class = decode_text_from_utf8 (val);
+            }
+          else if (strcmp (name, "name") == 0)
+            {
+              if (*val)
+                pd->info->res_name = decode_text_from_utf8 (val);
+            }
+          else if (strcmp (name, "title") == 0)
+            {
+              if (*val)
+                pd->info->title = g_strdup (val);
+            }
+          else if (strcmp (name, "role") == 0)
+            {
+              if (*val)
+                pd->info->role = decode_text_from_utf8 (val);
+            }
+          else if (strcmp (name, "type") == 0)
+            {
+              if (*val)
+                pd->info->type = window_type_from_string (val);
+            }
+          else if (strcmp (name, "stacking") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->stack_position = atoi (val);
+                  pd->info->stack_position_set = TRUE;
+                }
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "window");
+              session_info_free (pd->info);
+              pd->info = NULL;
+              return;
+            }
+          
+          ++i;
+        }
+    }
+  else if (strcmp (element_name, "workspace") == 0)
+    {
+      int i;
+
+      i = 0;
+      while (attribute_names[i])
+        {
+          const char *name;
+
+          name = attribute_names[i];
+          
+          if (strcmp (name, "index") == 0)
+            {
+              pd->info->workspace_indices =
+                g_slist_prepend (pd->info->workspace_indices,
+                                 GINT_TO_POINTER (atoi (attribute_values[i])));
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "window");
+              session_info_free (pd->info);
+              pd->info = NULL;
+              return;
+            }
+          
+          ++i;
+        }
+    }
+  else if (strcmp (element_name, "sticky") == 0)
+    {
+      pd->info->on_all_workspaces = TRUE;
+      pd->info->on_all_workspaces_set = TRUE;
+    }
+  else if (strcmp (element_name, "minimized") == 0)
+    {
+      pd->info->minimized = TRUE;
+      pd->info->minimized_set = TRUE;
+    }
+  else if (strcmp (element_name, "maximized") == 0)
+    {
+      int i;
+
+      i = 0;
+      pd->info->maximized = TRUE;
+      pd->info->maximized_set = TRUE;
+      while (attribute_names[i])
+        {
+          const char *name;
+          const char *val;
+
+          name = attribute_names[i];
+          val = attribute_values[i];
+
+          if (strcmp (name, "saved_x") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->saved_rect.x = atoi (val);
+                  pd->info->saved_rect_set = TRUE;
+                }
+            }
+          else if (strcmp (name, "saved_y") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->saved_rect.y = atoi (val);
+                  pd->info->saved_rect_set = TRUE;
+                }
+            }
+          else if (strcmp (name, "saved_width") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->saved_rect.width = atoi (val);
+                  pd->info->saved_rect_set = TRUE;
+                }
+            }
+          else if (strcmp (name, "saved_height") == 0)
+            {
+              if (*val)
+                {
+                  pd->info->saved_rect.height = atoi (val);
+                  pd->info->saved_rect_set = TRUE;
+                }
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "maximized");
+              return;
+            }
+
+          ++i;
+        }
+
+      if (pd->info->saved_rect_set)
+        meta_topic (META_DEBUG_SM, "Saved unmaximized size %d,%d %dx%d \n",
+                    pd->info->saved_rect.x,
+                    pd->info->saved_rect.y,
+                    pd->info->saved_rect.width,
+                    pd->info->saved_rect.height);
+    }  
+  else if (strcmp (element_name, "geometry") == 0)
+    {
+      int i;
+
+      pd->info->geometry_set = TRUE;
+      
+      i = 0;
+      while (attribute_names[i])
+        {
+          const char *name;
+          const char *val;
+          
+          name = attribute_names[i];
+          val = attribute_values[i];
+          
+          if (strcmp (name, "x") == 0)
+            {
+              if (*val)
+                pd->info->rect.x = atoi (val);
+            }
+          else if (strcmp (name, "y") == 0)
+            {
+              if (*val)
+                pd->info->rect.y = atoi (val);
+            }
+          else if (strcmp (name, "width") == 0)
+            {
+              if (*val)
+                pd->info->rect.width = atoi (val);
+            }
+          else if (strcmp (name, "height") == 0)
+            {
+              if (*val)
+                pd->info->rect.height = atoi (val);
+            }
+          else if (strcmp (name, "gravity") == 0)
+            {
+              if (*val)
+                pd->info->gravity = window_gravity_from_string (val);
+            }
+          else
+            {
+              g_set_error (error,
+                           G_MARKUP_ERROR,
+                           G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
+                           _("Unknown attribute %s on <%s> element"),
+                           name, "geometry");
+              return;
+            }
+          
+          ++i;
+        }
+
+      meta_topic (META_DEBUG_SM, "Loaded geometry %d,%d %dx%d gravity %s\n",
+                  pd->info->rect.x,
+                  pd->info->rect.y,
+                  pd->info->rect.width,
+                  pd->info->rect.height,
+                  meta_gravity_to_string (pd->info->gravity));
+    }
+  else
+    {
+      g_set_error (error,
+                   G_MARKUP_ERROR,
+                   G_MARKUP_ERROR_UNKNOWN_ELEMENT,
+                   _("Unknown element %s"),
+                   element_name);
+      return;
+    }
+}
+
+static void
+end_element_handler    (GMarkupParseContext *context,
+                        const gchar         *element_name,
+                        gpointer             user_data,
+                        GError             **error)
+{
+  ParseData *pd;
+
+  pd = user_data;
+
+  if (strcmp (element_name, "window") == 0)
+    {
+      g_assert (pd->info);
+
+      window_info_list = g_slist_prepend (window_info_list,
+                                          pd->info);
+      
+      meta_topic (META_DEBUG_SM, "Loaded window info from session with class: %s name: %s role: %s\n",
+                  pd->info->res_class ? pd->info->res_class : "(none)",
+                  pd->info->res_name ? pd->info->res_name : "(none)",
+                  pd->info->role ? pd->info->role : "(none)");
+      
+      pd->info = NULL;
+    }
+}
+
+static void
+text_handler           (GMarkupParseContext *context,
+                        const gchar         *text,
+                        gsize                text_len,
+                        gpointer             user_data,
+                        GError             **error)
+{
+  /* Right now we don't have any elements where we care about their
+   * content
+   */
+}
+
+static gboolean
+both_null_or_matching (const char *a,
+                       const char *b)
+{
+  if (a == NULL && b == NULL)
+    return TRUE;
+  else if (a && b && strcmp (a, b) == 0)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+static GSList*
+get_possible_matches (MetaWindow *window)
+{
+  /* Get all windows with this client ID */
+  GSList *retval;
+  GSList *tmp;
+  gboolean ignore_client_id;
+  
+  retval = NULL;
+
+  ignore_client_id = g_getenv ("MARCO_DEBUG_SM") != NULL;
+  
+  tmp = window_info_list;
+  while (tmp != NULL)
+    {
+      MetaWindowSessionInfo *info;
+
+      info = tmp->data;
+      
+      if ((ignore_client_id ||
+           both_null_or_matching (info->id, window->sm_client_id)) && 
+          both_null_or_matching (info->res_class, window->res_class) &&
+          both_null_or_matching (info->res_name, window->res_name) &&
+          both_null_or_matching (info->role, window->role))
+        {
+          meta_topic (META_DEBUG_SM, "Window %s may match saved window with class: %s name: %s role: %s\n",
+                      window->desc,
+                      info->res_class ? info->res_class : "(none)",
+                      info->res_name ? info->res_name : "(none)",
+                      info->role ? info->role : "(none)");
+
+          retval = g_slist_prepend (retval, info);
+        }
+      else
+        {
+          if (meta_is_verbose ())
+            {
+              if (!both_null_or_matching (info->id, window->sm_client_id))
+                meta_topic (META_DEBUG_SM, "Window %s has SM client ID %s, saved state has %s, no match\n",
+                            window->desc,
+                            window->sm_client_id ? window->sm_client_id : "(none)",
+                            info->id ? info->id : "(none)");
+              else if (!both_null_or_matching (info->res_class, window->res_class))
+                meta_topic (META_DEBUG_SM, "Window %s has class %s doesn't match saved class %s, no match\n",
+                            window->desc,
+                            window->res_class ? window->res_class : "(none)",
+                            info->res_class ? info->res_class : "(none)");
+              
+              else if (!both_null_or_matching (info->res_name, window->res_name))
+                meta_topic (META_DEBUG_SM, "Window %s has name %s doesn't match saved name %s, no match\n",
+                            window->desc,
+                            window->res_name ? window->res_name : "(none)",
+                            info->res_name ? info->res_name : "(none)");
+              else if (!both_null_or_matching (info->role, window->role))
+                meta_topic (META_DEBUG_SM, "Window %s has role %s doesn't match saved role %s, no match\n",
+                            window->desc,
+                            window->role ? window->role : "(none)",
+                            info->role ? info->role : "(none)");
+              else
+                meta_topic (META_DEBUG_SM, "???? should not happen - window %s doesn't match saved state %s for no good reason\n",
+                            window->desc, info->id);
+            }
+        }
+      
+      tmp = tmp->next;
+    }
+
+  return retval;
+}
+
+static const MetaWindowSessionInfo*
+find_best_match (GSList     *infos,
+                 MetaWindow *window)
+{
+  GSList *tmp;
+  const MetaWindowSessionInfo *matching_title;
+  const MetaWindowSessionInfo *matching_type;
+  
+  matching_title = NULL;
+  matching_type = NULL;
+  
+  tmp = infos;
+  while (tmp != NULL)
+    {
+      MetaWindowSessionInfo *info;
+
+      info = tmp->data;
+
+      if (matching_title == NULL &&
+          both_null_or_matching (info->title, window->title))
+        matching_title = info;
+
+      if (matching_type == NULL &&
+          info->type == window->type)
+        matching_type = info;
+      
+      tmp = tmp->next;
+    }
+
+  /* Prefer same title, then same type of window, then
+   * just pick something. Eventually we could enhance this
+   * to e.g. break ties by geometry hint similarity,
+   * or other window features.
+   */
+  
+  if (matching_title)
+    return matching_title;
+  else if (matching_type)
+    return matching_type;
+  else
+    return infos->data;
+}
+
+const MetaWindowSessionInfo*
+meta_window_lookup_saved_state (MetaWindow *window)
+{
+  GSList *possibles;
+  const MetaWindowSessionInfo *info;
+  
+  /* Window is not session managed.
+   * I haven't yet figured out how to deal with these
+   * in a way that doesn't cause broken side effects in
+   * situations other than on session restore.
+   */
+  if (window->sm_client_id == NULL)
+    {
+      meta_topic (META_DEBUG_SM,
+                  "Window %s is not session managed, not checking for saved state\n",
+                  window->desc);
+      return NULL;
+    }
+
+  possibles = get_possible_matches (window);
+
+  if (possibles == NULL)
+    {
+      meta_topic (META_DEBUG_SM, "Window %s has no possible matches in the list of saved window states\n",
+                  window->desc);
+      return NULL;
+    }
+
+  info = find_best_match (possibles, window);
+  
+  g_slist_free (possibles);
+  
+  return info;
+}
+
+void
+meta_window_release_saved_state (const MetaWindowSessionInfo *info)
+{
+  /* We don't want to use the same saved state again for another
+   * window.
+   */
+  window_info_list = g_slist_remove (window_info_list, info);
+
+  session_info_free ((MetaWindowSessionInfo*) info);
+}
+
+static void
+session_info_free (MetaWindowSessionInfo *info)
+{
+  g_free (info->id);
+  g_free (info->res_class);
+  g_free (info->res_name);
+  g_free (info->title);
+  g_free (info->role);
+
+  g_slist_free (info->workspace_indices);
+  
+  g_free (info);
+}
+
+static MetaWindowSessionInfo*
+session_info_new (void)
+{
+  MetaWindowSessionInfo *info;
+
+  info = g_new0 (MetaWindowSessionInfo, 1);
+
+  info->type = META_WINDOW_NORMAL;
+  info->gravity = NorthWestGravity;
+  
+  return info;
+}
+
+static char* full_save_path = NULL;
+
+static void
+regenerate_save_file (void)
+{
+  g_free (full_save_path);
+
+  if (client_id)
+    full_save_path = g_strconcat (g_get_user_config_dir (),
+                                  G_DIR_SEPARATOR_S "marco"
+                                  G_DIR_SEPARATOR_S "sessions" G_DIR_SEPARATOR_S,
+                                  client_id,
+                                  ".ms",
+                                  NULL);
+  else
+    full_save_path = NULL;
+}
+
+static const char*
+full_save_file (void)
+{
+  return full_save_path;
+}
+
+static int
+windows_cmp_by_title (MetaWindow *a,
+                      MetaWindow *b)
+{
+  return g_utf8_collate (a->title, b->title);
+}
+
+static void
+finish_interact (gboolean shutdown)
+{
+  if (current_state == STATE_DONE_WITH_INTERACT) /* paranoia */
+    {
+      SmcInteractDone (session_connection, False /* don't cancel logout */);
+      
+      save_yourself_possibly_done (shutdown, TRUE);
+    }
+}
+
+static void
+dialog_closed (GPid pid, int status, gpointer user_data)
+{
+  gboolean shutdown = GPOINTER_TO_INT (user_data);
+
+  if (WIFEXITED (status) && WEXITSTATUS (status) == 0) /* pressed "OK" */
+    {
+      finish_interact (shutdown);
+    }
+}
+
+static void
+warn_about_lame_clients_and_finish_interact (gboolean shutdown)
+{
+  GSList *lame = NULL;
+  GSList *windows;
+  GSList *lame_details = NULL;
+  GSList *tmp;
+  GSList *columns = NULL;
+  GPid pid;
+  
+  windows = meta_display_list_windows (meta_get_display ());
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+          
+      window = tmp->data;
+
+      /* only complain about normal windows, the others
+       * are kind of dumb to worry about
+       */
+      if (window->sm_client_id == NULL &&
+          window->type == META_WINDOW_NORMAL)
+        lame = g_slist_prepend (lame, window);
+          
+      tmp = tmp->next;
+    }
+      
+  g_slist_free (windows);
+  
+  if (lame == NULL)
+    {
+      /* No lame apps. */
+      finish_interact (shutdown);
+      return;
+    }
+
+  columns = g_slist_prepend (columns, "Window");
+  columns = g_slist_prepend (columns, "Class");
+
+  lame = g_slist_sort (lame, (GCompareFunc) windows_cmp_by_title);
+
+  tmp = lame;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      lame_details = g_slist_prepend (lame_details,
+                                      w->res_class ? w->res_class : "");
+      lame_details = g_slist_prepend (lame_details,
+                                      w->title);
+
+      tmp = tmp->next;
+    }
+  g_slist_free (lame);
+
+  pid = meta_show_dialog("--list",
+                         _("These windows do not support &quot;save current setup&quot; "
+                           "and will have to be restarted manually next time "
+                           "you log in."),
+                         "240",
+                         meta_screen_get_screen_number (meta_get_display()->active_screen),
+                         NULL, NULL,
+                         None,
+                         columns,
+                         lame_details);
+
+  g_slist_free (lame_details);
+
+  g_child_watch_add (pid, dialog_closed, GINT_TO_POINTER (shutdown));
+}
+
+#endif /* HAVE_SM */
diff --git a/src/core/session.h b/src/core/session.h
new file mode 100644
index 00000000..62a9370d
--- /dev/null
+++ b/src/core/session.h
@@ -0,0 +1,91 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file session.h   Session management
+ *
+ * Maps windows to information about their placing and state on startup.
+ * This is window matching, which we have a policy of leaving in general
+ * to programs such as Devil's Pie, but the session manager specification
+ * requires us to do it here.
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_SESSION_H
+#define META_SESSION_H
+
+#include "window-private.h"
+
+typedef struct _MetaWindowSessionInfo MetaWindowSessionInfo;
+
+struct _MetaWindowSessionInfo
+{
+  /* Fields we use to match against */
+
+  char *id;
+  char *res_class;
+  char *res_name;
+  char *title;
+  char *role;
+  MetaWindowType type;
+
+  /* Information we restore */
+  
+  GSList *workspace_indices;  
+
+  int stack_position;
+  
+  /* width/height should be multiplied by resize inc and
+   * added to base size; position should be interpreted in
+   * light of gravity. This preserves semantics of the
+   * window size/pos, even if fonts/themes change, etc.
+   */
+  int gravity;
+  MetaRectangle rect;
+  MetaRectangle saved_rect;
+  guint on_all_workspaces : 1;
+  guint minimized : 1;
+  guint maximized : 1;
+
+  guint stack_position_set : 1;
+  guint geometry_set : 1;
+  guint on_all_workspaces_set : 1;
+  guint minimized_set : 1;
+  guint maximized_set : 1;
+  guint saved_rect_set : 1;
+};
+
+/* If lookup_saved_state returns something, it should be used,
+ * and then released when you're done with it.
+ */
+const MetaWindowSessionInfo* meta_window_lookup_saved_state  (MetaWindow                  *window);
+void                         meta_window_release_saved_state (const MetaWindowSessionInfo *info);
+
+void meta_session_init (const char *client_id,
+                        const char *save_file);
+
+
+void meta_session_shutdown (void);
+
+#endif
+
+
+
+
diff --git a/src/core/stack.c b/src/core/stack.c
new file mode 100644
index 00000000..2e108d20
--- /dev/null
+++ b/src/core/stack.c
@@ -0,0 +1,1661 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file stack.c  Which windows cover which other windows
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2004 Rob Adams
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "stack.h"
+#include "window-private.h"
+#include "errors.h"
+#include "frame-private.h"
+#include "group.h"
+#include "prefs.h"
+#include "workspace.h"
+
+#include <X11/Xatom.h>
+
+#define WINDOW_HAS_TRANSIENT_TYPE(w)                    \
+          (w->type == META_WINDOW_DIALOG ||             \
+	   w->type == META_WINDOW_MODAL_DIALOG ||       \
+           w->type == META_WINDOW_TOOLBAR ||            \
+           w->type == META_WINDOW_MENU ||               \
+           w->type == META_WINDOW_UTILITY)
+
+#define WINDOW_TRANSIENT_FOR_WHOLE_GROUP(w)             \
+         ((w->xtransient_for == None ||                 \
+           w->transient_parent_is_root_window) &&       \
+          WINDOW_HAS_TRANSIENT_TYPE (w))
+
+#define WINDOW_IN_STACK(w) (w->stack_position >= 0)
+
+static void stack_sync_to_server (MetaStack *stack);
+static void meta_window_set_stack_position_no_sync (MetaWindow *window,
+                                                    int         position);
+static void stack_do_window_deletions (MetaStack *stack);
+static void stack_do_window_additions (MetaStack *stack);
+static void stack_do_relayer          (MetaStack *stack);
+static void stack_do_constrain        (MetaStack *stack);
+static void stack_do_resort           (MetaStack *stack);
+
+static void stack_ensure_sorted (MetaStack *stack);
+
+MetaStack*
+meta_stack_new (MetaScreen *screen)
+{
+  MetaStack *stack;
+  
+  stack = g_new (MetaStack, 1);
+
+  stack->screen = screen;
+  stack->windows = g_array_new (FALSE, FALSE, sizeof (Window));
+
+  stack->sorted = NULL;
+  stack->added = NULL;
+  stack->removed = NULL;
+
+  stack->freeze_count = 0;
+  stack->last_root_children_stacked = NULL;
+
+  stack->n_positions = 0;
+
+  stack->need_resort = FALSE;
+  stack->need_relayer = FALSE;
+  stack->need_constrain = FALSE;
+  
+  return stack;
+}
+
+void
+meta_stack_free (MetaStack *stack)
+{
+  g_array_free (stack->windows, TRUE);
+
+  g_list_free (stack->sorted);
+  g_list_free (stack->added);
+  g_list_free (stack->removed);
+
+  if (stack->last_root_children_stacked)
+    g_array_free (stack->last_root_children_stacked, TRUE);
+  
+  g_free (stack);
+}
+
+void
+meta_stack_add (MetaStack  *stack,
+                MetaWindow *window)
+{
+  meta_topic (META_DEBUG_STACK, "Adding window %s to the stack\n", window->desc);
+
+  if (window->stack_position >= 0)
+    meta_bug ("Window %s had stack position already\n", window->desc);
+  
+  stack->added = g_list_prepend (stack->added, window);
+
+  window->stack_position = stack->n_positions;
+  stack->n_positions += 1;
+  meta_topic (META_DEBUG_STACK,
+              "Window %s has stack_position initialized to %d\n",
+              window->desc, window->stack_position);
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_remove (MetaStack  *stack,
+                   MetaWindow *window)
+{
+  meta_topic (META_DEBUG_STACK, "Removing window %s from the stack\n", window->desc);
+
+  if (window->stack_position < 0)
+    meta_bug ("Window %s removed from stack but had no stack position\n",
+              window->desc);
+
+  /* Set window to top position, so removing it will not leave gaps
+   * in the set of positions
+   */
+  meta_window_set_stack_position_no_sync (window,
+                                          stack->n_positions - 1);
+  window->stack_position = -1;
+  stack->n_positions -= 1;  
+
+  /* We don't know if it's been moved from "added" to "stack" yet */
+  stack->added = g_list_remove (stack->added, window);
+  stack->sorted = g_list_remove (stack->sorted, window);
+
+  /* Remember the window ID to remove it from the stack array.
+   * The macro is safe to use: Window is guaranteed to be 32 bits, and
+   * GUINT_TO_POINTER says it only works on 32 bits.
+   */
+  stack->removed = g_list_prepend (stack->removed,
+                                   GUINT_TO_POINTER (window->xwindow));
+  if (window->frame)
+    stack->removed = g_list_prepend (stack->removed,
+                                     GUINT_TO_POINTER (window->frame->xwindow));
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_update_layer (MetaStack  *stack,
+                         MetaWindow *window)
+{
+  stack->need_relayer = TRUE;
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_update_transient (MetaStack  *stack,
+                             MetaWindow *window)
+{
+  stack->need_constrain = TRUE;
+  
+  stack_sync_to_server (stack);
+}
+
+/* raise/lower within a layer */
+void
+meta_stack_raise (MetaStack  *stack,
+                  MetaWindow *window)
+{  
+  meta_window_set_stack_position_no_sync (window,
+                                          stack->n_positions - 1);
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_lower (MetaStack  *stack,
+                  MetaWindow *window)
+{
+  meta_window_set_stack_position_no_sync (window, 0);
+  
+  stack_sync_to_server (stack);
+}
+
+void
+meta_stack_freeze (MetaStack *stack)
+{
+  stack->freeze_count += 1;
+}
+
+void
+meta_stack_thaw (MetaStack *stack)
+{
+  g_return_if_fail (stack->freeze_count > 0);
+  
+  stack->freeze_count -= 1;
+  stack_sync_to_server (stack);
+}
+
+static gboolean
+is_focused_foreach (MetaWindow *window,
+                    void       *data)
+{
+  if (window == window->display->expected_focus_window)
+    {
+      *((gboolean*) data) = TRUE;
+      return FALSE;
+    }
+  return TRUE;
+}
+
+static gboolean
+windows_on_different_xinerama (MetaWindow *a,
+                               MetaWindow *b)
+{
+  if (a->screen != b->screen)
+    return TRUE;
+
+  return meta_screen_get_xinerama_for_window (a->screen, a) !=
+    meta_screen_get_xinerama_for_window (b->screen, b);
+}
+
+/* Get layer ignoring any transient or group relationships */
+static MetaStackLayer
+get_standalone_layer (MetaWindow *window)
+{
+  MetaStackLayer layer;
+  gboolean focused_transient = FALSE;
+  
+  switch (window->type)
+    {
+    case META_WINDOW_DESKTOP:
+      layer = META_LAYER_DESKTOP;
+      break;
+
+    case META_WINDOW_DOCK:
+      /* still experimenting here */
+      if (window->wm_state_below)
+        layer = META_LAYER_BOTTOM;
+      else
+        layer = META_LAYER_DOCK;
+      break;
+
+    default:       
+      meta_window_foreach_transient (window,
+                                     is_focused_foreach,
+                                     &focused_transient);
+
+      if (window->wm_state_below)
+        layer = META_LAYER_BOTTOM;
+      else if (window->fullscreen &&
+               (focused_transient ||
+                window == window->display->expected_focus_window ||
+                window->display->expected_focus_window == NULL ||
+                (window->display->expected_focus_window != NULL &&
+                 windows_on_different_xinerama (window,
+                                                window->display->expected_focus_window))))
+        layer = META_LAYER_FULLSCREEN;
+      else if (window->wm_state_above)
+        layer = META_LAYER_TOP;
+      else
+        layer = META_LAYER_NORMAL;
+      break;
+    }
+
+  return layer;
+}
+
+/* Note that this function can never use window->layer only
+ * get_standalone_layer, or we'd have issues.
+ */
+static MetaStackLayer
+get_maximum_layer_in_group (MetaWindow *window)
+{
+  GSList *members;
+  MetaGroup *group;
+  GSList *tmp;
+  MetaStackLayer max;
+  MetaStackLayer layer;
+  
+  max = META_LAYER_DESKTOP;
+  
+  group = meta_window_get_group (window);
+
+  if (group != NULL)
+    members = meta_group_list_windows (group);
+  else
+    members = NULL;
+  
+  tmp = members;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      layer = get_standalone_layer (w);
+      if (layer > max)
+        max = layer;
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (members);
+  
+  return max;
+}
+
+static void
+compute_layer (MetaWindow *window)
+{
+  window->layer = get_standalone_layer (window);
+  
+  /* We can only do promotion-due-to-group for dialogs and other
+   * transients, or weird stuff happens like the desktop window and
+   * caja windows getting in the same layer, or all mate-terminal
+   * windows getting in fullscreen layer if any terminal is
+   * fullscreen.
+   */
+  if (WINDOW_HAS_TRANSIENT_TYPE(window) &&
+      (window->xtransient_for == None ||
+       window->transient_parent_is_root_window))
+    {
+      /* We only do the group thing if the dialog is NOT transient for
+       * a particular window. Imagine a group with a normal window, a dock,
+       * and a dialog transient for the normal window; you don't want the dialog
+       * above the dock if it wouldn't normally be.
+       */
+      
+      MetaStackLayer group_max;
+      
+      group_max = get_maximum_layer_in_group (window);
+      
+      if (group_max > window->layer)
+        {
+          meta_topic (META_DEBUG_STACK,
+                      "Promoting window %s from layer %u to %u due to group membership\n",
+                      window->desc, window->layer, group_max);
+          window->layer = group_max;
+        }
+    }
+
+  meta_topic (META_DEBUG_STACK, "Window %s on layer %u type = %u has_focus = %d\n",
+              window->desc, window->layer,
+              window->type, window->has_focus);
+}
+
+/* Front of the layer list is the topmost window,
+ * so the lower stack position is later in the list
+ */
+static int
+compare_window_position (void *a,
+                         void *b)
+{
+  MetaWindow *window_a = a;
+  MetaWindow *window_b = b;
+
+  /* Go by layer, then stack_position */
+  if (window_a->layer < window_b->layer)
+    return 1; /* move window_a later in list */
+  else if (window_a->layer > window_b->layer)
+    return -1;
+  else if (window_a->stack_position < window_b->stack_position)
+    return 1; /* move window_a later in list */
+  else if (window_a->stack_position > window_b->stack_position)
+    return -1;
+  else
+    return 0; /* not reached */
+}
+  
+/*
+ * Stacking constraints
+ * 
+ * Assume constraints of the form "AB" meaning "window A must be
+ * below window B"
+ *
+ * If we have windows stacked from bottom to top
+ * "ABC" then raise A we get "BCA". Say C is
+ * transient for B is transient for A. So
+ * we have constraints AB and BC.
+ *
+ * After raising A, we need to reapply the constraints.
+ * If we do this by raising one window at a time -
+ *
+ *  start:    BCA
+ *  apply AB: CAB
+ *  apply BC: ABC
+ *
+ * but apply constraints in the wrong order and it breaks:
+ * 
+ *  start:    BCA
+ *  apply BC: BCA
+ *  apply AB: CAB
+ *
+ * We make a directed graph of the constraints by linking
+ * from "above windows" to "below windows as follows:
+ * 
+ *   AB -> BC -> CD
+ *          \
+ *           CE
+ *
+ * If we then walk that graph and apply the constraints in the order
+ * that they appear, we will apply them correctly. Note that the
+ * graph MAY have cycles, so we have to guard against that.
+ *
+ */
+
+typedef struct Constraint Constraint;
+
+struct Constraint
+{
+  MetaWindow *above;
+  MetaWindow *below;
+
+  /* used to keep the constraint in the
+   * list of constraints for window "below"
+   */
+  Constraint *next;
+
+  /* used to create the graph. */
+  GSList *next_nodes;
+  
+  /* constraint has been applied, used
+   * to detect cycles.
+   */
+  unsigned int applied : 1;
+
+  /* constraint has a previous node in the graph,
+   * used to find places to start in the graph.
+   * (I think this also has the side effect
+   * of preventing cycles, since cycles will
+   * have no starting point - so maybe
+   * the "applied" flag isn't needed.)
+   */
+  unsigned int has_prev : 1;
+};
+
+/* We index the array of constraints by window
+ * stack positions, just because the stack
+ * positions are a convenient index.
+ */
+static void
+add_constraint (Constraint **constraints,
+                MetaWindow  *above,
+                MetaWindow  *below)
+{
+  Constraint *c;
+
+  g_assert (above->screen == below->screen);
+  
+  /* check if constraint is a duplicate */
+  c = constraints[below->stack_position];
+  while (c != NULL)
+    {
+      if (c->above == above)
+        return;
+      c = c->next;
+    }
+
+  /* if not, add the constraint */
+  c = g_new (Constraint, 1);
+  c->above = above;
+  c->below = below;
+  c->next = constraints[below->stack_position];
+  c->next_nodes = NULL;
+  c->applied = FALSE;
+  c->has_prev = FALSE;
+
+  constraints[below->stack_position] = c;
+}
+
+static void
+create_constraints (Constraint **constraints,
+                    GList       *windows)
+{
+  GList *tmp;
+  
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      if (!WINDOW_IN_STACK (w))
+        {
+          meta_topic (META_DEBUG_STACK, "Window %s not in the stack, not constraining it\n",
+                      w->desc);
+          tmp = tmp->next;
+          continue;
+        }
+      
+      if (WINDOW_TRANSIENT_FOR_WHOLE_GROUP (w))
+        {
+          GSList *group_windows;
+          GSList *tmp2;
+          MetaGroup *group;
+
+          group = meta_window_get_group (w);
+
+          if (group != NULL)
+            group_windows = meta_group_list_windows (group);
+          else
+            group_windows = NULL;
+          
+          tmp2 = group_windows;
+          
+          while (tmp2 != NULL)
+            {
+              MetaWindow *group_window = tmp2->data;
+
+              if (!WINDOW_IN_STACK (group_window) ||
+                  w->screen != group_window->screen)
+                {
+                  tmp2 = tmp2->next;
+                  continue;
+                }
+              
+#if 0
+              /* old way of doing it */
+              if (!(meta_window_is_ancestor_of_transient (w, group_window)) &&
+                  !WINDOW_TRANSIENT_FOR_WHOLE_GROUP (group_window))  /* note */;/*note*/
+#else
+              /* better way I think, so transient-for-group are constrained
+               * only above non-transient-type windows in their group
+               */
+              if (!WINDOW_HAS_TRANSIENT_TYPE (group_window))
+#endif
+                {
+                  meta_topic (META_DEBUG_STACK, "Constraining %s above %s as it's transient for its group\n",
+                              w->desc, group_window->desc);
+                  add_constraint (constraints, w, group_window);
+                }
+              
+              tmp2 = tmp2->next;
+            }
+
+          g_slist_free (group_windows);
+        }
+      else if (w->xtransient_for != None &&
+               !w->transient_parent_is_root_window)
+        {
+          MetaWindow *parent;
+          
+          parent =
+            meta_display_lookup_x_window (w->display, w->xtransient_for);
+
+          if (parent && WINDOW_IN_STACK (parent) &&
+              parent->screen == w->screen)
+            {
+              meta_topic (META_DEBUG_STACK, "Constraining %s above %s due to transiency\n",
+                          w->desc, parent->desc);
+              add_constraint (constraints, w, parent);
+            }
+        }
+      
+      tmp = tmp->next;
+    }
+}
+
+static void
+graph_constraints (Constraint **constraints,
+                   int          n_constraints)
+{
+  int i;
+
+  i = 0;
+  while (i < n_constraints)
+    {
+      Constraint *c;
+
+      /* If we have "A below B" and "B below C" then AB -> BC so we
+       * add BC to next_nodes in AB.
+       */
+      
+      c = constraints[i];
+      while (c != NULL)
+        {
+          Constraint *n;
+            
+          g_assert (c->below->stack_position == i);
+
+          /* Constraints where ->above is below are our
+           * next_nodes and we are their previous
+           */
+          n = constraints[c->above->stack_position];
+          while (n != NULL)
+            {
+              c->next_nodes = g_slist_prepend (c->next_nodes,
+                                               n);
+              /* c is a previous node of n */
+              n->has_prev = TRUE;
+              
+              n = n->next;
+            }
+          
+          c = c->next;
+        }
+
+      ++i;
+    }
+}
+
+static void
+free_constraints (Constraint **constraints,
+                  int          n_constraints)
+{
+  int i;
+
+  i = 0;
+  while (i < n_constraints)
+    {
+      Constraint *c;
+      
+      c = constraints[i];
+      while (c != NULL)
+        {
+          Constraint *next = c->next;
+          
+          g_slist_free (c->next_nodes);
+
+          g_free (c);
+          
+          c = next;
+        }
+
+      ++i;
+    }
+}
+
+static void
+ensure_above (MetaWindow *above,
+              MetaWindow *below)
+{  
+  if (WINDOW_HAS_TRANSIENT_TYPE(above) &&
+      above->layer < below->layer)
+    {
+      meta_topic (META_DEBUG_STACK,
+		  "Promoting window %s from layer %u to %u due to contraint\n",
+		  above->desc, above->layer, below->layer);
+      above->layer = below->layer;
+    }
+
+  if (above->stack_position < below->stack_position)
+    {
+      /* move above to below->stack_position bumping below down the stack */
+      meta_window_set_stack_position_no_sync (above, below->stack_position);
+      g_assert (below->stack_position + 1 == above->stack_position);
+    }
+  meta_topic (META_DEBUG_STACK, "%s above at %d > %s below at %d\n",
+              above->desc, above->stack_position,
+              below->desc, below->stack_position);
+}
+
+static void
+traverse_constraint (Constraint *c)
+{
+  GSList *tmp;
+
+  if (c->applied)
+    return;
+  
+  ensure_above (c->above, c->below);
+  c->applied = TRUE;
+  
+  tmp = c->next_nodes;
+  while (tmp != NULL)
+    {
+      traverse_constraint (tmp->data);
+
+      tmp = tmp->next;
+    }
+}
+
+static void
+apply_constraints (Constraint **constraints,
+                   int          n_constraints)
+{
+  GSList *heads;
+  GSList *tmp;
+  int i;
+
+  /* List all heads in an ordered constraint chain */
+  heads = NULL;
+  i = 0;
+  while (i < n_constraints)
+    {
+      Constraint *c;
+      
+      c = constraints[i];
+      while (c != NULL)
+        {
+          if (!c->has_prev)
+            heads = g_slist_prepend (heads, c);
+          
+          c = c->next;
+        }
+
+      ++i;
+    }
+
+  /* Now traverse the chain and apply constraints */
+  tmp = heads;
+  while (tmp != NULL)
+    {
+      Constraint *c = tmp->data;
+
+      traverse_constraint (c);
+      
+      tmp = tmp->next;
+    }
+
+  g_slist_free (heads);
+}
+
+/**
+ * Go through "deleted" and take the matching windows
+ * out of "windows".
+ */
+static void
+stack_do_window_deletions (MetaStack *stack)
+{
+  /* Do removals before adds, with paranoid idea that we might re-add
+   * the same window IDs.
+   */
+  GList *tmp;
+  int i;
+    
+  tmp = stack->removed;
+  while (tmp != NULL)
+    {
+      Window xwindow;
+      xwindow = GPOINTER_TO_UINT (tmp->data);
+
+      /* We go from the end figuring removals are more
+       * likely to be recent.
+       */
+      i = stack->windows->len;
+      while (i > 0)
+        {
+          --i;
+          
+          /* there's no guarantee we'll actually find windows to
+           * remove, e.g. the same xwindow could have been
+           * added/removed before we ever synced, and we put
+           * both the window->xwindow and window->frame->xwindow
+           * in the removal list.
+           */
+          if (xwindow == g_array_index (stack->windows, Window, i))
+            {
+              g_array_remove_index (stack->windows, i);
+              goto next;
+            }
+        }
+
+    next:
+      tmp = tmp->next;
+    }
+
+  g_list_free (stack->removed);
+  stack->removed = NULL;
+}
+
+static void
+stack_do_window_additions (MetaStack *stack)
+{
+  GList *tmp;
+  gint i, n_added;
+
+  n_added = g_list_length (stack->added);
+  if (n_added > 0)
+    {
+      Window *end;
+      int old_size;
+
+      meta_topic (META_DEBUG_STACK,
+                  "Adding %d windows to sorted list\n",
+                  n_added);
+      
+      old_size = stack->windows->len;
+      g_array_set_size (stack->windows, old_size + n_added);
+      
+      end = &g_array_index (stack->windows, Window, old_size);
+
+      /* stack->added has the most recent additions at the
+       * front of the list, so we need to reverse it
+       */
+      stack->added = g_list_reverse (stack->added);
+      
+      i = 0;
+      tmp = stack->added;
+      while (tmp != NULL)
+        {
+          MetaWindow *w;
+          
+          w = tmp->data;
+          
+          end[i] = w->xwindow;
+
+          /* add to the main list */
+          stack->sorted = g_list_prepend (stack->sorted, w);
+          
+          ++i;
+          tmp = tmp->next;
+        }
+      
+      stack->need_resort = TRUE; /* may not be needed as we add to top */
+      stack->need_constrain = TRUE;
+      stack->need_relayer = TRUE;
+    }
+
+  g_list_free (stack->added);
+  stack->added = NULL;
+}
+
+/**
+ * Update the layers that windows are in
+ */
+static void
+stack_do_relayer (MetaStack *stack)
+{
+  GList *tmp;
+    
+  if (!stack->need_relayer)
+      return;
+    
+  meta_topic (META_DEBUG_STACK,
+              "Recomputing layers\n");
+      
+  tmp = stack->sorted;
+
+  while (tmp != NULL)
+    {
+      MetaWindow *w;
+      MetaStackLayer old_layer;
+
+      w = tmp->data;
+      old_layer = w->layer;
+
+      compute_layer (w);
+
+      if (w->layer != old_layer)
+        {
+          meta_topic (META_DEBUG_STACK,
+                      "Window %s moved from layer %u to %u\n",
+                      w->desc, old_layer, w->layer);
+              
+          stack->need_resort = TRUE;
+          stack->need_constrain = TRUE;
+          /* don't need to constrain as constraining
+           * purely operates in terms of stack_position
+           * not layer
+           */
+        }
+          
+      tmp = tmp->next;
+    }
+
+  stack->need_relayer = FALSE;
+}
+
+/**
+ * Update stack_position and layer to reflect transiency
+ * constraints
+ */
+static void
+stack_do_constrain (MetaStack *stack)
+{
+  Constraint **constraints;
+
+  /* It'd be nice if this were all faster, probably */
+  
+  if (!stack->need_constrain)
+    return;
+
+  meta_topic (META_DEBUG_STACK,
+              "Reapplying constraints\n");
+
+  constraints = g_new0 (Constraint*,
+                        stack->n_positions);
+
+  create_constraints (constraints, stack->sorted);
+
+  graph_constraints (constraints, stack->n_positions);
+
+  apply_constraints (constraints, stack->n_positions);
+  
+  free_constraints (constraints, stack->n_positions);
+  g_free (constraints);
+  
+  stack->need_constrain = FALSE;
+}
+
+/**
+ * Sort stack->sorted with layers having priority over stack_position.
+ */
+static void
+stack_do_resort (MetaStack *stack)
+{
+  if (!stack->need_resort)
+    return;
+  
+  meta_topic (META_DEBUG_STACK,
+              "Sorting stack list\n");
+      
+  stack->sorted = g_list_sort (stack->sorted,
+                               (GCompareFunc) compare_window_position);
+
+  stack->need_resort = FALSE;
+}
+
+/**
+ * Puts the stack into canonical form.
+ *
+ * Honour the removed and added lists of the stack, and then recalculate
+ * all the layers (if the flag is set), re-run all the constraint calculations
+ * (if the flag is set), and finally re-sort the stack (if the flag is set,
+ * and if it wasn't already it might have become so during all the previous
+ * activity).
+ */
+static void
+stack_ensure_sorted (MetaStack *stack)
+{
+  stack_do_window_deletions (stack);
+  stack_do_window_additions (stack);
+  stack_do_relayer (stack);
+  stack_do_constrain (stack);
+  stack_do_resort (stack);
+}
+
+/**
+ * This function is used to avoid raising a window above popup
+ * menus and other such things.
+ *
+ * FIXME This is sort of an expensive function, should probably
+ * do something to avoid it. One approach would be to reverse
+ * the stacking algorithm to work by placing each window above
+ * the others, and start by lowering a window to the bottom
+ * (instead of the current way, which works by placing each
+ * window below another and starting with a raise)
+ */
+static void
+raise_window_relative_to_managed_windows (MetaScreen *screen,
+                                          Window      xwindow)
+{
+
+  Window ignored1, ignored2;
+  Window *children;
+  unsigned int n_children;
+  int i;
+
+  /* Normally XQueryTree() means "must grab server" but here
+   * we don't, since we know we won't manage any new windows
+   * or restack any windows before using the XQueryTree results.
+   */
+  
+  meta_error_trap_push_with_return (screen->display);
+  
+  XQueryTree (screen->display->xdisplay,
+              screen->xroot,
+              &ignored1, &ignored2, &children, &n_children);
+
+  if (meta_error_trap_pop_with_return (screen->display, TRUE) != Success)
+    {
+      meta_topic (META_DEBUG_STACK,
+                  "Error querying root children to raise window 0x%lx\n",
+                  xwindow);
+      return;
+    }
+
+  /* Children are in order from bottom to top. We want to
+   * find the topmost managed child, then configure
+   * our window to be above it.
+   */
+  i = n_children - 1;
+  while (i >= 0)
+    {
+      if (children[i] == xwindow)
+        {
+          /* Do nothing. This means we're already the topmost managed
+           * window, but it DOES NOT mean we are already just above
+           * the topmost managed window. This is important because if
+           * an override redirect window is up, and we map a new
+           * managed window, the new window is probably above the old
+           * popup by default, and we want to push it below that
+           * popup. So keep looking for a sibling managed window
+           * to be moved below.
+           */
+        }
+      else if (meta_display_lookup_x_window (screen->display,
+                                             children[i]) != NULL)
+        {
+          XWindowChanges changes;
+          
+          /* children[i] is the topmost managed child */
+          meta_topic (META_DEBUG_STACK,
+                      "Moving 0x%lx above topmost managed child window 0x%lx\n",
+                      xwindow, children[i]);
+
+          changes.sibling = children[i];
+          changes.stack_mode = Above;
+
+          meta_error_trap_push (screen->display);
+          XConfigureWindow (screen->display->xdisplay,
+                            xwindow,
+                            CWSibling | CWStackMode,
+                            &changes);
+          meta_error_trap_pop (screen->display, FALSE);
+
+          break;
+        }
+
+      --i;
+    }
+
+  if (i < 0)
+    {
+      /* No sibling to use, just lower ourselves to the bottom
+       * to be sure we're below any override redirect windows.
+       */
+      meta_error_trap_push (screen->display);
+      XLowerWindow (screen->display->xdisplay,
+                    xwindow);
+      meta_error_trap_pop (screen->display, FALSE);
+    }
+  
+  if (children)
+    XFree (children);
+}
+
+/**
+ * Order the windows on the X server to be the same as in our structure.
+ * We do this using XRestackWindows if we don't know the previous order,
+ * or XConfigureWindow on a few particular windows if we do and can figure
+ * out the minimum set of changes.  After that, we set __NET_CLIENT_LIST
+ * and __NET_CLIENT_LIST_STACKING.
+ */
+static void
+stack_sync_to_server (MetaStack *stack)
+{
+  GArray *stacked;
+  GArray *root_children_stacked;
+  GList *tmp;
+  
+  /* Bail out if frozen */
+  if (stack->freeze_count > 0)
+    return;
+  
+  meta_topic (META_DEBUG_STACK, "Syncing window stack to server\n");  
+
+  stack_ensure_sorted (stack);
+  
+  /* Create stacked xwindow arrays.
+   * Painfully, "stacked" is in bottom-to-top order for the
+   * _NET hints, and "root_children_stacked" is in top-to-bottom
+   * order for XRestackWindows()
+   */
+  stacked = g_array_new (FALSE, FALSE, sizeof (Window));
+  root_children_stacked = g_array_new (FALSE, FALSE, sizeof (Window));
+
+  meta_topic (META_DEBUG_STACK, "Top to bottom: ");
+  meta_push_no_msg_prefix ();
+  
+  tmp = stack->sorted;
+  while (tmp != NULL)
+    {
+      MetaWindow *w;
+      
+      w = tmp->data;
+      
+      /* remember, stacked is in reverse order (bottom to top) */
+      g_array_prepend_val (stacked, w->xwindow);
+      
+      /* build XRestackWindows() array from top to bottom */
+      if (w->frame)
+        g_array_append_val (root_children_stacked, w->frame->xwindow);
+      else
+        g_array_append_val (root_children_stacked, w->xwindow);
+      
+      meta_topic (META_DEBUG_STACK, "%u:%d - %s ", w->layer, w->stack_position, w->desc);
+          
+      tmp = tmp->next;
+    }
+
+  meta_topic (META_DEBUG_STACK, "\n");
+  meta_pop_no_msg_prefix ();
+
+  /* All windows should be in some stacking order */
+  if (stacked->len != stack->windows->len)
+    meta_bug ("%u windows stacked, %u windows exist in stack\n",
+              stacked->len, stack->windows->len);
+  
+  /* Sync to server */
+
+  meta_topic (META_DEBUG_STACK, "Restacking %u windows\n",
+              root_children_stacked->len);
+  
+  meta_error_trap_push (stack->screen->display);
+
+  if (stack->last_root_children_stacked == NULL)
+    {
+      /* Just impose our stack, we don't know the previous state.
+       * This involves a ton of circulate requests and may flicker.
+       */
+      meta_topic (META_DEBUG_STACK, "Don't know last stack state, restacking everything\n");
+
+      if (root_children_stacked->len > 0)
+        XRestackWindows (stack->screen->display->xdisplay,
+                         (Window *) root_children_stacked->data,
+                         root_children_stacked->len);
+    }
+  else if (root_children_stacked->len > 0)
+    {
+      /* Try to do minimal window moves to get the stack in order */
+      /* A point of note: these arrays include frames not client windows,
+       * so if a client window has changed frame since last_root_children_stacked
+       * was saved, then we may have inefficiency, but I don't think things
+       * break...
+       */
+      const Window *old_stack = (Window *) stack->last_root_children_stacked->data;
+      const Window *new_stack = (Window *) root_children_stacked->data;
+      const int old_len = stack->last_root_children_stacked->len;
+      const int new_len = root_children_stacked->len;
+      const Window *oldp = old_stack;
+      const Window *newp = new_stack;
+      const Window *old_end = old_stack + old_len;
+      const Window *new_end = new_stack + new_len;
+      Window last_window = None;
+      
+      while (oldp != old_end &&
+             newp != new_end)
+        {
+          if (*oldp == *newp)
+            {
+              /* Stacks are the same here, move on */
+              ++oldp;
+              last_window = *newp;
+              ++newp;
+            }
+          else if (meta_display_lookup_x_window (stack->screen->display,
+                                                 *oldp) == NULL)
+            {
+              /* *oldp is no longer known to us (probably destroyed),
+               * so we can just skip it
+               */
+              ++oldp;
+            }
+          else
+            {
+              /* Move *newp below last_window */
+              if (last_window == None)
+                {
+                  meta_topic (META_DEBUG_STACK, "Using window 0x%lx as topmost (but leaving it in-place)\n", *newp);
+
+                  raise_window_relative_to_managed_windows (stack->screen,
+                                                            *newp);
+                }
+              else
+                {
+                  /* This means that if last_window is dead, but not
+                   * *newp, then we fail to restack *newp; but on
+                   * unmanaging last_window, we'll fix it up.
+                   */
+                  
+                  XWindowChanges changes;
+
+                  changes.sibling = last_window;
+                  changes.stack_mode = Below;
+
+                  meta_topic (META_DEBUG_STACK, "Placing window 0x%lx below 0x%lx\n",
+                              *newp, last_window);
+                  
+                  XConfigureWindow (stack->screen->display->xdisplay,
+                                    *newp,
+                                    CWSibling | CWStackMode,
+                                    &changes);
+                }
+
+              last_window = *newp;
+              ++newp;
+            }
+        }
+
+      if (newp != new_end)
+        {
+          /* Restack remaining windows */
+          meta_topic (META_DEBUG_STACK, "Restacking remaining %d windows\n",
+                        (int) (new_end - newp));
+          /* We need to include an already-stacked window
+           * in the restack call, so we get in the proper position
+           * with respect to it.
+           */
+          if (newp != new_stack)
+            --newp;
+          XRestackWindows (stack->screen->display->xdisplay,
+                           (Window *) newp, new_end - newp);
+        }
+    }
+
+  meta_error_trap_pop (stack->screen->display, FALSE);
+  /* on error, a window was destroyed; it should eventually
+   * get removed from the stacking list when we unmanage it
+   * and we'll fix stacking at that time.
+   */
+  
+  /* Sync _NET_CLIENT_LIST and _NET_CLIENT_LIST_STACKING */
+
+  XChangeProperty (stack->screen->display->xdisplay,
+                   stack->screen->xroot,
+                   stack->screen->display->atom__NET_CLIENT_LIST,
+                   XA_WINDOW,
+                   32, PropModeReplace,
+                   (unsigned char *)stack->windows->data,
+                   stack->windows->len);
+  XChangeProperty (stack->screen->display->xdisplay,
+                   stack->screen->xroot,
+                   stack->screen->display->atom__NET_CLIENT_LIST_STACKING,
+                   XA_WINDOW,
+                   32, PropModeReplace,
+                   (unsigned char *)stacked->data,
+                   stacked->len);
+
+  g_array_free (stacked, TRUE);
+
+  if (stack->last_root_children_stacked)
+    g_array_free (stack->last_root_children_stacked, TRUE);
+  stack->last_root_children_stacked = root_children_stacked;
+  
+  /* That was scary... */
+}
+
+MetaWindow*
+meta_stack_get_top (MetaStack *stack)
+{
+  stack_ensure_sorted (stack);
+
+  if (stack->sorted)
+    return stack->sorted->data;
+  else
+    return NULL;
+}
+
+MetaWindow*
+meta_stack_get_bottom (MetaStack  *stack)
+{
+  GList *link;
+
+  stack_ensure_sorted (stack);
+
+  link = g_list_last (stack->sorted);
+  if (link != NULL)
+    return link->data;
+  else
+    return NULL;
+}
+
+MetaWindow*
+meta_stack_get_above (MetaStack      *stack,
+                      MetaWindow     *window,
+                      gboolean        only_within_layer)
+{
+  GList *link;
+  MetaWindow *above;
+  
+  stack_ensure_sorted (stack);
+  
+  link = g_list_find (stack->sorted, window);
+  if (link == NULL)
+    return NULL;
+  if (link->prev == NULL)
+    return NULL;
+
+  above = link->prev->data;
+
+  if (only_within_layer &&
+      above->layer != window->layer)
+    return NULL;
+  else
+    return above;
+}
+
+MetaWindow*
+meta_stack_get_below (MetaStack      *stack,
+                      MetaWindow     *window,
+                      gboolean        only_within_layer)
+{
+  GList *link;
+  MetaWindow *below;
+  
+  stack_ensure_sorted (stack);
+
+  link = g_list_find (stack->sorted, window);
+
+  if (link == NULL)
+    return NULL;
+  if (link->next == NULL)
+    return NULL;
+  
+  below = link->next->data;
+
+  if (only_within_layer &&
+      below->layer != window->layer)
+    return NULL;
+  else
+    return below;
+}
+
+static gboolean
+window_contains_point (MetaWindow *window,
+                       int         root_x,
+                       int         root_y)
+{
+  MetaRectangle rect;
+
+  meta_window_get_outer_rect (window, &rect);
+
+  return POINT_IN_RECT (root_x, root_y, rect);
+}
+
+static MetaWindow*
+get_default_focus_window (MetaStack     *stack,
+                          MetaWorkspace *workspace,
+                          MetaWindow    *not_this_one,
+                          gboolean       must_be_at_point,
+                          int            root_x,
+                          int            root_y)
+{
+  /* Find the topmost, focusable, mapped, window.
+   * not_this_one is being unfocused or going away, so exclude it.
+   * Also, prefer to focus transient parent of not_this_one,
+   * or top window in same group as not_this_one.
+   */
+
+  MetaWindow *topmost_dock;
+  MetaWindow *transient_parent;
+  MetaWindow *topmost_in_group;
+  MetaWindow *topmost_overall;
+  MetaGroup *not_this_one_group;
+  GList *link;
+  
+  topmost_dock = NULL;
+  transient_parent = NULL;
+  topmost_in_group = NULL;
+  topmost_overall = NULL;
+  if (not_this_one)
+    not_this_one_group = meta_window_get_group (not_this_one);
+  else
+    not_this_one_group = NULL;
+
+  stack_ensure_sorted (stack);
+
+  /* top of this layer is at the front of the list */
+  link = stack->sorted;
+      
+  while (link)
+    {
+      MetaWindow *window = link->data;
+
+      if (window &&
+          window != not_this_one &&
+          (window->unmaps_pending == 0) &&
+          !window->minimized &&
+          (window->input || window->take_focus) &&
+          (workspace == NULL ||
+           meta_window_located_on_workspace (window, workspace)))
+        {
+          if (topmost_dock == NULL &&
+              window->type == META_WINDOW_DOCK)
+            topmost_dock = window;
+
+          if (not_this_one != NULL)
+            {
+              if (transient_parent == NULL &&
+                  not_this_one->xtransient_for != None &&
+                  not_this_one->xtransient_for == window->xwindow &&
+                  (!must_be_at_point ||
+                   window_contains_point (window, root_x, root_y)))
+                transient_parent = window;
+
+              if (topmost_in_group == NULL &&
+                  not_this_one_group != NULL &&
+                  not_this_one_group == meta_window_get_group (window) &&
+                  (!must_be_at_point ||
+                   window_contains_point (window, root_x, root_y)))
+                topmost_in_group = window;
+            }
+
+          /* Note that DESKTOP windows can be topmost_overall so
+           * we prefer focusing desktop or other windows over
+           * focusing dock, even though docks are stacked higher.
+           */
+          if (topmost_overall == NULL &&
+              window->type != META_WINDOW_DOCK &&
+              (!must_be_at_point ||
+               window_contains_point (window, root_x, root_y)))
+            topmost_overall = window;
+
+          /* We could try to bail out early here for efficiency in
+           * some cases, but it's just not worth the code.
+           */
+        }
+
+      link = link->next;
+    }
+
+  if (transient_parent)
+    return transient_parent;
+  else if (topmost_in_group)
+    return topmost_in_group;
+  else if (topmost_overall)
+    return topmost_overall;
+  else
+    return topmost_dock;
+}
+
+MetaWindow*
+meta_stack_get_default_focus_window_at_point (MetaStack     *stack,
+                                              MetaWorkspace *workspace,
+                                              MetaWindow    *not_this_one,
+                                              int            root_x,
+                                              int            root_y)
+{
+  return get_default_focus_window (stack, workspace, not_this_one,
+                                   TRUE, root_x, root_y);
+}
+
+MetaWindow*
+meta_stack_get_default_focus_window (MetaStack     *stack,
+                                     MetaWorkspace *workspace,
+                                     MetaWindow    *not_this_one)
+{
+  return get_default_focus_window (stack, workspace, not_this_one,
+                                   FALSE, 0, 0);
+}
+
+GList*
+meta_stack_list_windows (MetaStack     *stack,
+                         MetaWorkspace *workspace)
+{
+  GList *workspace_windows = NULL;
+  GList *link;
+  
+  stack_ensure_sorted (stack); /* do adds/removes */
+  
+  link = stack->sorted;
+  
+  while (link)
+    {
+      MetaWindow *window = link->data;
+      
+      if (window &&
+          (workspace == NULL || meta_window_located_on_workspace (window, workspace)))
+        {
+          workspace_windows = g_list_prepend (workspace_windows,
+                                              window);
+        }
+      
+      link = link->next;
+    }
+
+  return workspace_windows;
+}
+
+int
+meta_stack_windows_cmp  (MetaStack  *stack,
+                         MetaWindow *window_a,
+                         MetaWindow *window_b)
+{
+  g_return_val_if_fail (window_a->screen == window_b->screen, 0);
+
+  /* -1 means a below b */
+
+  stack_ensure_sorted (stack); /* update constraints, layers */
+  
+  if (window_a->layer < window_b->layer)
+    return -1;
+  else if (window_a->layer > window_b->layer)
+    return 1;
+  else if (window_a->stack_position < window_b->stack_position)
+    return -1;
+  else if (window_a->stack_position > window_b->stack_position)
+    return 1;
+  else
+    return 0; /* not reached */
+}
+
+static int
+compare_just_window_stack_position (void *a,
+                                    void *b)
+{
+  MetaWindow *window_a = a;
+  MetaWindow *window_b = b;
+
+  if (window_a->stack_position < window_b->stack_position)
+    return -1; /* move window_a earlier in list */
+  else if (window_a->stack_position > window_b->stack_position)
+    return 1;
+  else
+    return 0; /* not reached */
+}
+
+GList*
+meta_stack_get_positions (MetaStack *stack)
+{
+  GList *tmp;
+
+  /* Make sure to handle any adds or removes */
+  stack_ensure_sorted (stack);
+
+  tmp = g_list_copy (stack->sorted);
+  tmp = g_list_sort (tmp, (GCompareFunc) compare_just_window_stack_position);
+
+  return tmp;
+}
+
+static gint
+compare_pointers (gconstpointer a,
+                  gconstpointer b)
+{
+  if (a > b)
+    return 1;
+  else if (a < b)
+    return -1;
+  else 
+    return 0;
+}
+
+static gboolean
+lists_contain_same_windows (GList *a,
+                            GList *b)
+{
+  GList *copy1, *copy2;
+  GList *tmp1, *tmp2;
+
+  if (g_list_length (a) != g_list_length (b))
+    return FALSE;
+
+  tmp1 = copy1 = g_list_sort (g_list_copy (a), compare_pointers);
+  tmp2 = copy2 = g_list_sort (g_list_copy (b), compare_pointers);
+
+  while (tmp1 && tmp1->data == tmp2->data)   /* tmp2 is non-NULL if tmp1 is */
+    {
+      tmp1 = tmp1->next;
+      tmp2 = tmp2->next;
+    }
+
+  g_list_free (copy1);
+  g_list_free (copy2);
+
+  return (tmp1 == NULL);    /* tmp2 is non-NULL if tmp1 is */
+}
+
+void
+meta_stack_set_positions (MetaStack *stack,
+                          GList     *windows)
+{
+  int i;
+  GList *tmp;
+
+  /* Make sure any adds or removes aren't in limbo -- is this needed? */
+  stack_ensure_sorted (stack);
+  
+  if (!lists_contain_same_windows (windows, stack->sorted))
+    {
+      meta_warning ("This list of windows has somehow changed; not resetting "
+                    "positions of the windows.\n");
+      return;
+    }
+
+  g_list_free (stack->sorted);
+  stack->sorted = g_list_copy (windows);
+
+  stack->need_resort = TRUE;
+  stack->need_constrain = TRUE;
+   
+  i = 0;
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+      w->stack_position = i++;
+      tmp = tmp->next;
+    }
+  
+  meta_topic (META_DEBUG_STACK,
+              "Reset the stack positions of (nearly) all windows\n");
+
+  stack_sync_to_server (stack);
+}
+
+void
+meta_window_set_stack_position_no_sync (MetaWindow *window,
+                                        int         position)
+{
+  int low, high, delta;
+  GList *tmp;
+  
+  g_return_if_fail (window->screen->stack != NULL);
+  g_return_if_fail (window->stack_position >= 0);
+  g_return_if_fail (position >= 0);
+  g_return_if_fail (position < window->screen->stack->n_positions);
+
+  if (position == window->stack_position)
+    {
+      meta_topic (META_DEBUG_STACK, "Window %s already has position %d\n",
+                  window->desc, position);
+      return;
+    }
+
+  window->screen->stack->need_resort = TRUE;
+  window->screen->stack->need_constrain = TRUE;
+  
+  if (position < window->stack_position)
+    {
+      low = position;
+      high = window->stack_position - 1;
+      delta = 1;
+    }
+  else
+    {
+      low = window->stack_position + 1;
+      high = position;
+      delta = -1;
+    }
+
+  tmp = window->screen->stack->sorted;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      if (w->stack_position >= low &&
+          w->stack_position <= high)
+        w->stack_position += delta;
+
+      tmp = tmp->next;
+    }
+  
+  window->stack_position = position;
+
+  meta_topic (META_DEBUG_STACK,
+              "Window %s had stack_position set to %d\n",
+              window->desc, window->stack_position);
+}
+
+void
+meta_window_set_stack_position (MetaWindow *window,
+                                int         position)
+{
+  meta_window_set_stack_position_no_sync (window, position);
+  stack_sync_to_server (window->screen->stack);
+}
diff --git a/src/core/stack.h b/src/core/stack.h
new file mode 100644
index 00000000..f9693897
--- /dev/null
+++ b/src/core/stack.h
@@ -0,0 +1,402 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file stack.h  Which windows cover which other windows
+ *
+ * There are two factors that determine window position.
+ * 
+ * One is window->stack_position, which is a unique integer
+ * indicating how windows are ordered with respect to one
+ * another. The ordering here transcends layers; it isn't changed
+ * as the window is moved among layers. This allows us to move several
+ * windows from one layer to another, while preserving the relative
+ * order of the moved windows. Also, it allows us to restore
+ * the stacking order from a saved session.
+ * 
+ * However when actually stacking windows on the screen, the
+ * layer overrides the stack_position; windows are first sorted
+ * by layer, then by stack_position within each layer.
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_STACK_H
+#define META_STACK_H
+
+#include "screen-private.h"
+
+/**
+ * Layers a window can be in.
+ * These MUST be in the order of stacking.
+ */
+typedef enum
+{
+  META_LAYER_DESKTOP        = 0,
+  META_LAYER_BOTTOM         = 1,
+  META_LAYER_NORMAL         = 2,
+  META_LAYER_TOP            = 4, /* Same as DOCK; see EWMH and bug 330717 */
+  META_LAYER_DOCK           = 4,
+  META_LAYER_FULLSCREEN     = 5,
+  META_LAYER_FOCUSED_WINDOW = 6,
+  META_LAYER_LAST           = 7
+} MetaStackLayer;
+
+/**
+ * A sorted list of windows bearing some level of resemblance to the stack of
+ * windows on the X server.
+ *
+ * (This is only used as a field within a MetaScreen; we treat it as a separate
+ * class for simplicity.)
+ */
+struct _MetaStack
+{
+  /** The MetaScreen containing this stack. */
+  MetaScreen *screen;
+
+  /**
+   * A sequence of all the Windows (X handles, not MetaWindows) of the windows
+   * we manage, sorted in order.  Suitable to be passed into _NET_CLIENT_LIST.
+   */
+  GArray *windows;
+
+  /** The MetaWindows of the windows we manage, sorted in order. */
+  GList *sorted;
+
+  /**
+   * MetaWindows waiting to be added to the "sorted" and "windows" list, after
+   * being added by meta_stack_add() and before being assimilated by
+   * stack_ensure_sorted().
+   *
+   * The order of the elements in this list is not important; what is important
+   * is the stack_position element of each window.
+   */
+  GList *added;
+
+  /**
+   * Windows (X handles, not MetaWindows) waiting to be removed from the
+   * "windows" list, after being removed by meta_stack_remove() and before
+   * being assimilated by stack_ensure_sorted().  (We already removed them
+   * from the "sorted" list.)
+   *
+   * The order of the elements in this list is not important.
+   */
+  GList *removed;
+  
+  /**
+   * If this is zero, the local stack oughtn't to be brought up to date with
+   * the X server's stack, because it is in the middle of being updated.
+   * If it is positive, the local stack is said to be "frozen", and will need
+   * to be thawed that many times before the stack can be brought up to date
+   * again.  You may freeze the stack with meta_stack_freeze() and thaw it
+   * with meta_stack_thaw().
+   */
+  int freeze_count;
+
+  /**
+   * The last-known stack of all windows, bottom to top.  We cache it here
+   * so that subsequent times we'll be able to do incremental moves.
+   */
+  GArray *last_root_children_stacked;
+
+  /**
+   * Number of stack positions; same as the length of added, but
+   * kept for quick reference.
+   */
+  gint n_positions;
+
+  /** Is the stack in need of re-sorting? */
+  unsigned int need_resort : 1;
+
+  /**
+   * Are the windows in the stack in need of having their
+   * layers recalculated?
+   */
+  unsigned int need_relayer : 1;
+
+  /**
+   * Are the windows in the stack in need of having their positions
+   * recalculated with respect to transiency (parent and child windows)?
+   */
+  unsigned int need_constrain : 1;
+};
+
+/**
+ * Creates and initialises a MetaStack.
+ *
+ * \param screen  The MetaScreen which will be the parent of this stack.
+ * \return The new screen.
+ */
+MetaStack *meta_stack_new       (MetaScreen     *screen);
+
+/**
+ * Destroys and frees a MetaStack.
+ *
+ * \param stack  The stack to destroy.
+ */
+void       meta_stack_free      (MetaStack      *stack);
+
+/**
+ * Adds a window to the local stack.  It is a fatal error to call this
+ * function on a window which already exists on the stack of any screen.
+ *
+ * \param window  The window to add
+ * \param stack  The stack to add it to
+ */
+void       meta_stack_add       (MetaStack      *stack,
+                                 MetaWindow     *window);
+
+/**
+ * Removes a window from the local stack.  It is a fatal error to call this
+ * function on a window which exists on the stack of any screen.
+ *
+ * \param window  The window to remove
+ * \param stack   The stack to remove it from
+ */
+void       meta_stack_remove    (MetaStack      *stack,
+                                 MetaWindow     *window);
+/**
+ * Recalculates the correct layer for all windows in the stack,
+ * and moves them about accordingly.
+ *
+ * \param window  Dummy parameter
+ * \param stack   The stack to recalculate
+ * \bug What's with the dummy parameter?
+ */
+void       meta_stack_update_layer    (MetaStack      *stack,
+                                       MetaWindow     *window);
+
+/**
+ * Recalculates the correct stacking order for all windows in the stack
+ * according to their transience, and moves them about accordingly.
+ *
+ * \param window  Dummy parameter
+ * \param stack   The stack to recalculate
+ * \bug What's with the dummy parameter?
+ */
+void       meta_stack_update_transient (MetaStack     *stack,
+                                        MetaWindow    *window);
+
+/**
+ * Move a window to the top of its layer.
+ *
+ * \param stack  The stack to modify.
+ * \param window  The window that's making an ascension.
+ *                (Amulet of Yendor not required.)
+ */
+void       meta_stack_raise     (MetaStack      *stack,
+                                 MetaWindow     *window);
+/**
+ * Move a window to the bottom of its layer.
+ *
+ * \param stack  The stack to modify.
+ * \param window  The window that's on the way downwards.
+ */
+void       meta_stack_lower     (MetaStack      *stack,
+                                 MetaWindow     *window);
+
+/**
+ * Prevent syncing to server until the next call of meta_stack_thaw(),
+ * so that we can carry out multiple operations in one go without having
+ * everything halfway reflected on the X server.
+ *
+ * (Calls to meta_stack_freeze() nest, so that multiple calls to
+ * meta_stack_freeze will require multiple calls to meta_stack_thaw().)
+ *
+ * \param stack  The stack to freeze.
+ */
+void       meta_stack_freeze    (MetaStack      *stack);
+
+/**
+ * Undoes a meta_stack_freeze(), and processes anything which has become
+ * necessary during the freeze.  It is an error to call this function if
+ * the stack has not been frozen.
+ *
+ * \param stack  The stack to thaw.
+ */
+void       meta_stack_thaw      (MetaStack      *stack);
+
+/**
+ * Finds the top window on the stack.
+ *
+ * \param stack  The stack to examine.
+ * \return The top window on the stack, or NULL in the vanishingly unlikely
+ *         event that you have no windows on your screen whatsoever.
+ */
+MetaWindow* meta_stack_get_top    (MetaStack  *stack);
+
+/**
+ * Finds the window at the bottom of the stack.  Since that's pretty much
+ * always the desktop, this isn't the most useful of functions, and nobody
+ * actually calls it.  We should probably get rid of it.
+ *
+ * \param stack  The stack to search
+ */
+MetaWindow* meta_stack_get_bottom (MetaStack  *stack);
+
+/**
+ * Finds the window above a given window in the stack.
+ * It is not an error to pass in a window which does not exist in
+ * the stack; the function will merely return NULL.
+ *
+ * \param stack   The stack to search.
+ * \param window  The window to look above.
+ * \param only_within_layer  If true, will return NULL if "window" is the
+ *                           top window in its layer.
+ * \return NULL if there is no such window;
+ *         the window above "window" otherwise.
+ */
+MetaWindow* meta_stack_get_above  (MetaStack  *stack,
+                                   MetaWindow *window,
+                                   gboolean    only_within_layer);
+
+/**
+ * Finds the window below a given window in the stack.
+ * It is not an error to pass in a window which does not exist in
+ * the stack; the function will merely return NULL.
+ *
+ * \param stack   The stack to search.
+ * \param window  The window to look below.
+ * \param only_within_layer  If true, will return NULL if "window" is the
+ *                           bottom window in its layer.
+ * \return NULL if there is no such window;
+ *         the window below "window" otherwise.
+ */
+MetaWindow* meta_stack_get_below  (MetaStack  *stack,
+                                   MetaWindow *window,
+                                   gboolean    only_within_layer);
+
+/**
+ * Find the topmost, focusable, mapped, window in a stack.  If you supply
+ * a window as "not_this_one", we won't return that one (presumably
+ * because it's going to be going away).  But if you do supply "not_this_one"
+ * and we find its parent, we'll return that; and if "not_this_one" is in
+ * a group, we'll return the top window of that group.
+ *
+ * Also, we are prejudiced against dock windows.  Every kind of window, even
+ * the desktop, will be returned in preference to a dock window.
+ *
+ * \param stack  The stack to search.
+ * \param workspace  NULL to search all workspaces; otherwise only windows
+ *                   from that workspace will be returned.
+ * \param not_this_one  Window to ignore because it's being unfocussed or
+ *                      going away.
+ * \return The window matching all these constraints or NULL if none does.
+ * 
+ * \bug Never called!
+  */
+MetaWindow* meta_stack_get_default_focus_window          (MetaStack     *stack,
+                                                          MetaWorkspace *workspace,
+                                                          MetaWindow    *not_this_one);
+
+/**
+ * Find the topmost, focusable, mapped, window in a stack.  If you supply
+ * a window as "not_this_one", we won't return that one (presumably
+ * because it's going to be going away).  But if you do supply "not_this_one"
+ * and we find its parent, we'll return that; and if "not_this_one" is in
+ * a group, we'll return the top window of that group.
+ *
+ * Also, we are prejudiced against dock windows.  Every kind of window, even
+ * the desktop, will be returned in preference to a dock window.
+ *
+ * \param stack  The stack to search.
+ * \param workspace  NULL to search all workspaces; otherwise only windows
+ *                   from that workspace will be returned.
+ * \param not_this_one  Window to ignore because it's being unfocussed or
+ *                      going away.
+ * \param root_x  The returned window must contain this point,
+ *                unless it's a dock.
+ * \param root_y  See root_x.
+ * \return The window matching all these constraints or NULL if none does.
+ */
+MetaWindow* meta_stack_get_default_focus_window_at_point (MetaStack     *stack,
+                                                          MetaWorkspace *workspace,
+                                                          MetaWindow    *not_this_one,
+                                                          int            root_x,
+                                                          int            root_y);
+
+/**
+ * Finds all the windows in the stack, in order.
+ *
+ * \param stack  The stack to examine.
+ * \param workspace  If non-NULL, only windows on this workspace will be
+ *                   returned; otherwise all windows in the stack will be
+ *                   returned.
+ * \return A list of windows, in stacking order, honouring layers.
+ */
+GList*      meta_stack_list_windows (MetaStack *stack,
+                                     MetaWorkspace *workspace);
+
+/**
+ * Comparison function for windows within a stack.  This is not directly
+ * suitable for use within a standard comparison routine, because it takes
+ * an extra parameter; you will need to wrap it.
+ *
+ * (FIXME: We could remove the stack parameter and use the stack of
+ * the screen of window A, and complain if the stack of the screen of
+ * window B differed; then this would be a usable general comparison function.)
+ *
+ * (FIXME: Apparently identical to compare_window_position(). Merge them.)
+ *
+ * \param stack  A stack containing both window_a and window_b
+ * \param window_a  A window
+ * \param window_b  Another window
+ * \return -1 if window_a is below window_b, honouring layers; 1 if it's
+ *         above it; 0 if you passed in the same window twice!
+ */
+int         meta_stack_windows_cmp  (MetaStack  *stack,
+                                     MetaWindow *window_a,
+                                     MetaWindow *window_b);
+
+/**
+ * Sets the position of a window within the stack.  This will only move it
+ * up or down within its layer.  It is an error to attempt to move this
+ * below position zero or above the last position in the stack (however, since
+ * we don't provide a simple way to tell the number of windows in the stack,
+ * this requirement may not be easy to fulfil).
+ *
+ * \param window  The window which is moving.
+ * \param position  Where it should move to (0 is the bottom).
+ */
+void meta_window_set_stack_position (MetaWindow *window,
+                                     int         position);
+
+/**
+ * Returns the current stack state, allowing rudimentary transactions.
+ *
+ * \param stack  The stack to examine.
+ * \return An opaque GList representing the current stack sort order;
+ *         it is the caller's responsibility to free it.
+ *         Pass this to meta_stack_set_positions() later if you want to restore
+ *         the state to where it was when you called this function.
+ */
+GList* meta_stack_get_positions (MetaStack *stack);
+
+/**
+ * Rolls back a transaction, given the list returned from
+ * meta_stack_get_positions().
+ *
+ * \param stack  The stack to roll back.
+ * \param windows  The list returned from meta_stack_get_positions().
+ */
+void   meta_stack_set_positions (MetaStack *stack,
+                                 GList     *windows);
+
+#endif
diff --git a/src/core/testasyncgetprop.c b/src/core/testasyncgetprop.c
new file mode 100644
index 00000000..ed044009
--- /dev/null
+++ b/src/core/testasyncgetprop.c
@@ -0,0 +1,497 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2002 Havoc Pennington
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation.
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of The Open Group shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from The Open Group.
+ */
+
+#include "async-getprop.h"
+
+#include <time.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <assert.h>
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef NULL
+#define NULL ((void*) 0)
+#endif
+
+#ifdef HAVE_BACKTRACE
+#include <execinfo.h>
+static void
+print_backtrace (void)
+{
+  void *bt[500];
+  int bt_size;
+  int i;
+  char **syms;
+
+  bt_size = backtrace (bt, 500);
+
+  syms = backtrace_symbols (bt, bt_size);
+
+  i = 0;
+  while (i < bt_size)
+    {
+      fprintf (stderr, "  %s\n", syms[i]);
+      ++i;
+    }
+
+  free (syms);
+}
+#else
+static void
+print_backtrace (void)
+{
+  fprintf (stderr, "Not compiled with backtrace support\n");
+}
+#endif
+
+static int error_trap_depth = 0;
+
+static int
+x_error_handler (Display     *xdisplay,
+                 XErrorEvent *error)
+{
+  char buf[64];
+
+  XGetErrorText (xdisplay, error->error_code, buf, 63);
+
+  if (error_trap_depth == 0)
+    {
+      print_backtrace ();
+      
+      fprintf (stderr, "Unexpected X error: %s serial %ld error_code %d request_code %d minor_code %d)\n",
+               buf,
+               error->serial,
+               error->error_code,
+               error->request_code,
+               error->minor_code);
+      
+      exit (1);
+    }
+
+  return 1; /* return value is meaningless */
+}
+
+static void
+error_trap_push (Display   *xdisplay)
+{
+  ++error_trap_depth;
+}
+
+static void
+error_trap_pop (Display   *xdisplay)
+{
+  if (error_trap_depth == 0)
+    {
+      fprintf (stderr, "Error trap underflow!\n");
+      exit (1);
+    }
+  
+  XSync (xdisplay, False); /* get all errors out of the queue */
+  --error_trap_depth;
+}
+
+static char*
+my_strdup (const char *str)
+{
+  char *s;
+
+  s = malloc (strlen (str) + 1);
+  if (s == NULL)
+    {
+      fprintf (stderr, "malloc failed\n");
+      exit (1);
+    }
+  strcpy (s, str);
+
+  return s;
+}
+
+static char*
+atom_name (Display *display,
+           Atom     atom)
+{
+  if (atom == None)
+    {
+      return my_strdup ("None");
+    }
+  else
+    {
+      char *xname;
+      char *ret;
+
+      error_trap_push (display);
+      xname = XGetAtomName (display, atom);
+      error_trap_pop (display);
+      if (xname == NULL)
+        return my_strdup ("[unknown atom]");
+
+      ret = my_strdup (xname);
+      XFree (xname);
+
+      return ret;
+    }
+}
+
+
+#define ELAPSED(start_time, current_time) \
+    (((((double)current_time.tv_sec - start_time.tv_sec) * 1000000 + \
+       (current_time.tv_usec - start_time.tv_usec))) / 1000.0)
+
+static struct timeval program_start_time;
+
+static Bool
+try_get_reply (Display           *xdisplay,
+               AgGetPropertyTask *task)
+{
+  if (ag_task_have_reply (task))
+    {
+      int result;
+      Atom actual_type;
+      int actual_format;
+      unsigned long n_items;
+      unsigned long bytes_after;
+      unsigned char *data;
+      char *name;
+      struct timeval current_time;
+
+      gettimeofday (&current_time, NULL);
+      
+      printf (" %gms (we have a reply for property %ld)\n",
+              ELAPSED (program_start_time, current_time),
+              ag_task_get_property (task));
+      
+      data = NULL;
+
+      name = atom_name (xdisplay,
+                        ag_task_get_property (task));
+      printf (" %s on 0x%lx:\n", name,
+              ag_task_get_window (task));
+      free (name);
+      
+      result = ag_task_get_reply_and_free (task,
+                                           &actual_type,
+                                           &actual_format,
+                                           &n_items,
+                                           &bytes_after,
+                                           &data);
+      task = NULL;
+
+      if (result != Success)
+        {
+          fprintf (stderr, "  error code %d getting reply\n", result);
+        }
+      else
+        {
+          name = atom_name (xdisplay, actual_type);
+          printf ("  actual_type = %s\n", name);
+          free (name);
+          
+          printf ("  actual_format = %d\n", actual_format);
+          
+          printf ("  n_items = %lu\n", n_items);
+          printf ("  bytes_after = %lu\n", bytes_after);
+          
+          printf ("  data = \"%s\"\n", data ? (char*) data : "NULL");
+        }
+
+      return True;
+    }
+
+  return False;
+}
+
+static void run_speed_comparison (Display *xdisplay,
+                                  Window   window);
+
+int
+main (int argc, char **argv)
+{
+  Display *xdisplay;
+  int i;
+  int n_left;
+  int n_props;
+  Window window;
+  const char *window_str;
+  char *end;
+  Atom *props;
+  struct timeval current_time;
+  
+  if (argc < 2)
+    {
+      fprintf (stderr, "specify window ID\n");
+      return 1;
+    }
+  
+  window_str = argv[1];
+
+  end = NULL;
+  window = strtoul (window_str, &end, 0);
+  if (end == NULL || *end != '\0')
+    {
+      fprintf (stderr, "\"%s\" does not parse as a window ID\n", window_str);
+      return 1;
+    }
+
+  xdisplay = XOpenDisplay (NULL);
+  if (xdisplay == NULL)
+    {
+      fprintf (stderr, "Could not open display\n");
+      return 1;
+    }
+
+  if (getenv ("MARCO_SYNC") != NULL)
+    XSynchronize (xdisplay, True);
+
+  XSetErrorHandler (x_error_handler);
+  
+  n_props = 0;
+  props = XListProperties (xdisplay, window, &n_props);
+  if (n_props == 0 || props == NULL)
+    {
+      fprintf (stderr, "Window has no properties\n");
+      return 1;
+    }
+
+  gettimeofday (&program_start_time, NULL);
+  
+  i = 0;
+  while (i < n_props)
+    {
+      gettimeofday (&current_time, NULL);
+      printf (" %gms (sending request for property %ld)\n",
+              ELAPSED (program_start_time, current_time),
+              props[i]);
+      if (ag_task_create (xdisplay,
+                          window, props[i],
+                          0, 0xffffffff,
+                          False,
+                          AnyPropertyType) == NULL)
+        {
+          fprintf (stderr, "Failed to send request\n");
+          return 1;
+        }
+      
+      ++i;
+    }
+
+  XFree (props);
+  props = NULL;
+
+  n_left = n_props;
+  
+  while (TRUE)
+    {
+      XEvent xevent;
+      int connection;
+      fd_set set;
+      AgGetPropertyTask *task;
+      
+      /* Mop up event queue */
+      while (XPending (xdisplay) > 0)
+        {                  
+          XNextEvent (xdisplay, &xevent);
+          gettimeofday (&current_time, NULL);
+          printf (" %gms (processing event type %d)\n",
+                  ELAPSED (program_start_time, current_time),
+                  xevent.xany.type);
+        }
+      
+      while ((task = ag_get_next_completed_task (xdisplay)))
+        {
+          try_get_reply (xdisplay, task);
+          n_left -= 1;
+        }
+
+      if (n_left == 0)
+        {
+          printf ("All %d replies received.\n", n_props);
+          break;
+        }
+
+      /* Wake up if we may have a reply */
+      connection = ConnectionNumber (xdisplay);
+
+      FD_ZERO (&set);
+      FD_SET (connection, &set);
+
+      gettimeofday (&current_time, NULL);
+      printf (" %gms (blocking for data %d left)\n",
+              ELAPSED (program_start_time, current_time), n_left);
+      select (connection + 1, &set, NULL, NULL, NULL);
+    }
+
+  run_speed_comparison (xdisplay, window);
+  
+  return 0;
+}
+
+/* This function doesn't have all the printf's
+ * and other noise, it just compares async to sync
+ */
+static void
+run_speed_comparison (Display *xdisplay,
+                      Window   window)
+{
+  int i;
+  int n_props;
+  struct timeval start, end;
+  int n_left;
+  
+  /* We just use atom values (0 to n_props) % 200, many are probably
+   * BadAtom, that's fine, but the %200 keeps most of them valid. The
+   * async case is about twice as advantageous when using valid atoms
+   * (or the issue may be that it's more advantageous when the
+   * properties are present and data is transmitted).
+   */
+  n_props = 4000;
+  printf ("Timing with %d property requests\n", n_props);
+  
+  gettimeofday (&start, NULL);
+  
+  i = 0;
+  while (i < n_props)
+    {
+      if (ag_task_create (xdisplay,
+                          window, (Atom) i % 200,
+                          0, 0xffffffff,
+                          False,
+                          AnyPropertyType) == NULL)
+        {
+          fprintf (stderr, "Failed to send request\n");
+          exit (1);
+        }
+      
+      ++i;
+    }
+
+  n_left = n_props;
+  
+  while (TRUE)
+    {
+      int connection;
+      fd_set set;
+      XEvent xevent;
+      AgGetPropertyTask *task;
+      
+      /* Mop up event queue */
+      while (XPending (xdisplay) > 0)
+        XNextEvent (xdisplay, &xevent);
+      
+      while ((task = ag_get_next_completed_task (xdisplay)))
+        {
+          int result;
+          Atom actual_type;
+          int actual_format;
+          unsigned long n_items;
+          unsigned long bytes_after;
+          unsigned char *data;
+
+          assert (ag_task_have_reply (task));
+          
+          data = NULL;
+          result = ag_task_get_reply_and_free (task,
+                                               &actual_type,
+                                               &actual_format,
+                                               &n_items,
+                                               &bytes_after,
+                                               &data);
+          
+          if (data)
+            XFree (data);
+          
+          n_left -= 1;
+        }
+      
+      if (n_left == 0)
+        break;
+
+      /* Wake up if we may have a reply */
+      connection = ConnectionNumber (xdisplay);
+
+      FD_ZERO (&set);
+      FD_SET (connection, &set);
+
+      select (connection + 1, &set, NULL, NULL, NULL);
+    }
+  
+  gettimeofday (&end, NULL);
+  
+  printf ("Async time: %gms\n",
+          ELAPSED (start, end));
+  
+  gettimeofday (&start, NULL);
+
+  error_trap_push (xdisplay);
+  
+  i = 0;
+  while (i < n_props)
+    {
+      Atom actual_type;
+      int actual_format;
+      unsigned long n_items;
+      unsigned long bytes_after;
+      unsigned char *data;
+      
+      data = NULL;
+      if (XGetWindowProperty (xdisplay, window,
+                              (Atom) i % 200,
+                              0, 0xffffffff,
+                              False,
+                              AnyPropertyType,
+                              &actual_type,
+                              &actual_format,
+                              &n_items,
+                              &bytes_after,
+                              &data) == Success)
+        {
+          if (data)
+            XFree (data);
+        }
+      
+      ++i;
+    }
+
+  error_trap_pop (xdisplay);
+  
+  gettimeofday (&end, NULL);
+  
+  printf ("Sync time:  %gms\n",
+          ELAPSED (start, end));
+}
diff --git a/src/core/testboxes.c b/src/core/testboxes.c
new file mode 100644
index 00000000..fc81f064
--- /dev/null
+++ b/src/core/testboxes.c
@@ -0,0 +1,1416 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco box operation testing program */
+
+/* 
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "boxes.h"
+#include <glib.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <X11/Xutil.h> /* Just for the definition of the various gravities */
+#include <time.h>      /* To initialize random seed */
+
+#define NUM_RANDOM_RUNS 10000
+
+static void
+init_random_ness ()
+{
+  srand(time(NULL));
+}
+
+static void
+get_random_rect (MetaRectangle *rect)
+{
+  rect->x = rand () % 1600;
+  rect->y = rand () % 1200;
+  rect->width  = rand () % 1600 + 1;
+  rect->height = rand () % 1200 + 1;
+}
+
+static MetaRectangle*
+new_meta_rect (int x, int y, int width, int height)
+{
+  MetaRectangle* temporary;
+  temporary = g_new (MetaRectangle, 1);
+  temporary->x = x;
+  temporary->y = y;
+  temporary->width  = width;
+  temporary->height = height;
+
+  return temporary;
+}
+
+static MetaStrut*
+new_meta_strut (int x, int y, int width, int height, int side)
+{
+  MetaStrut* temporary;
+  temporary = g_new (MetaStrut, 1);
+  temporary->rect = meta_rect(x, y, width, height);
+  temporary->side = side;
+
+  return temporary;
+}
+
+static MetaEdge*
+new_screen_edge (int x, int y, int width, int height, int side_type)
+{
+  MetaEdge* temporary;
+  temporary = g_new (MetaEdge, 1);
+  temporary->rect.x = x;
+  temporary->rect.y = y;
+  temporary->rect.width  = width;
+  temporary->rect.height = height;
+  temporary->side_type = side_type;
+  temporary->edge_type = META_EDGE_SCREEN;
+
+  return temporary;
+}
+
+static MetaEdge*
+new_xinerama_edge (int x, int y, int width, int height, int side_type)
+{
+  MetaEdge* temporary;
+  temporary = g_new (MetaEdge, 1);
+  temporary->rect.x = x;
+  temporary->rect.y = y;
+  temporary->rect.width  = width;
+  temporary->rect.height = height;
+  temporary->side_type = side_type;
+  temporary->edge_type = META_EDGE_XINERAMA;
+
+  return temporary;
+}
+
+static void
+test_area ()
+{
+  MetaRectangle temp;
+  int i;
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&temp);
+      g_assert (meta_rectangle_area (&temp) == temp.width * temp.height);
+    }
+
+  temp = meta_rect (0, 0, 5, 7);
+  g_assert (meta_rectangle_area (&temp) == 35);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_intersect ()
+{
+  MetaRectangle a = {100, 200,  50,  40};
+  MetaRectangle b = {  0,  50, 110, 152};
+  MetaRectangle c = {  0,   0,  10,  10};
+  MetaRectangle d = {100, 100,  50,  50};
+  MetaRectangle b_intersect_d = {100, 100, 10, 50};
+  MetaRectangle temp;
+  MetaRectangle temp2;
+
+  meta_rectangle_intersect (&a, &b, &temp);
+  temp2 = meta_rect (100, 200, 10, 2);
+  g_assert (meta_rectangle_equal (&temp, &temp2));
+  g_assert (meta_rectangle_area (&temp) == 20);
+
+  meta_rectangle_intersect (&a, &c, &temp);
+  g_assert (meta_rectangle_area (&temp) == 0);
+
+  meta_rectangle_intersect (&a, &d, &temp);
+  g_assert (meta_rectangle_area (&temp) == 0);
+
+  meta_rectangle_intersect (&b, &d, &b);
+  g_assert (meta_rectangle_equal (&b, &b_intersect_d));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_equal ()
+{
+  MetaRectangle a = {10, 12, 4, 18};
+  MetaRectangle b = a;
+  MetaRectangle c = {10, 12, 4, 19};
+  MetaRectangle d = {10, 12, 7, 18};
+  MetaRectangle e = {10, 62, 4, 18};
+  MetaRectangle f = {27, 12, 4, 18};
+
+  g_assert ( meta_rectangle_equal (&a, &b));
+  g_assert (!meta_rectangle_equal (&a, &c));
+  g_assert (!meta_rectangle_equal (&a, &d));
+  g_assert (!meta_rectangle_equal (&a, &e));
+  g_assert (!meta_rectangle_equal (&a, &f));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_overlap_funcs ()
+{
+  MetaRectangle temp1, temp2;
+  int i;
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&temp1);
+      get_random_rect (&temp2);
+      g_assert (meta_rectangle_overlap (&temp1, &temp2) ==
+                (meta_rectangle_horiz_overlap (&temp1, &temp2) &&
+                 meta_rectangle_vert_overlap (&temp1, &temp2)));
+    }
+
+  temp1 = meta_rect ( 0, 0, 10, 10);
+  temp2 = meta_rect (20, 0, 10,  5);
+  g_assert (!meta_rectangle_overlap (&temp1, &temp2));
+  g_assert (!meta_rectangle_horiz_overlap (&temp1, &temp2));
+  g_assert ( meta_rectangle_vert_overlap (&temp1, &temp2));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_basic_fitting ()
+{
+  MetaRectangle temp1, temp2, temp3;
+  int i;
+  /* Four cases:
+   *   case   temp1 fits temp2    temp1 could fit temp2
+   *     1           Y                      Y
+   *     2           N                      Y
+   *     3           Y                      N
+   *     4           N                      N
+   * Of the four cases, case 3 is impossible.  An alternate way of looking
+   * at this table is that either the middle column must be no, or the last
+   * column must be yes.  So we test that.  Also, we can repeat the test
+   * reversing temp1 and temp2.
+   */
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&temp1);
+      get_random_rect (&temp2);
+      g_assert (meta_rectangle_contains_rect (&temp1, &temp2) == FALSE ||
+                meta_rectangle_could_fit_rect (&temp1, &temp2) == TRUE);
+      g_assert (meta_rectangle_contains_rect (&temp2, &temp1) == FALSE ||
+                meta_rectangle_could_fit_rect (&temp2, &temp1) == TRUE);
+    }
+
+  temp1 = meta_rect ( 0, 0, 10, 10);
+  temp2 = meta_rect ( 5, 5,  5,  5);
+  temp3 = meta_rect ( 8, 2,  3,  7);
+  g_assert ( meta_rectangle_contains_rect (&temp1, &temp2));
+  g_assert (!meta_rectangle_contains_rect (&temp2, &temp1));
+  g_assert (!meta_rectangle_contains_rect (&temp1, &temp3));
+  g_assert ( meta_rectangle_could_fit_rect (&temp1, &temp3));
+  g_assert (!meta_rectangle_could_fit_rect (&temp3, &temp2));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+free_strut_list (GSList *struts)
+{
+  GSList *tmp = struts;
+  while (tmp)
+    {
+      g_free (tmp->data);
+      tmp = tmp->next;
+    }
+  g_slist_free (struts);
+}
+
+static GSList*
+get_strut_list (int which)
+{
+  GSList *ans;
+  MetaDirection wc = 0; /* wc == who cares? ;-) */
+
+  ans = NULL;
+
+  g_assert (which >=0 && which <= 6);
+  switch (which)
+    {
+    case 0:
+      break;
+    case 1:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 400, 1160, 1600,   40, wc));
+      break;
+    case 2:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800, 1100,  400,  100, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 300, 1150,  150,   50, wc));
+      break;
+    case 3:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800, 1100,  400,  100, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 300, 1150,   80,   50, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 700,  525,  200,  150, wc));
+      break;
+    case 4:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0,  800, 1200, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800,    0, 1600,   20, wc));
+      break;
+    case 5:
+      ans = g_slist_prepend (ans, new_meta_strut ( 800,    0, 1600,   20, wc));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0,  800, 1200, wc));
+      ans = g_slist_prepend (ans, new_meta_strut ( 800,   10,  800, 1200, wc));
+      break;
+    case 6:
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   40, wc));
+      ans = g_slist_prepend (ans, new_meta_strut (   0,    0, 1600,   20, wc));
+      break;
+    }
+
+  return ans;
+}
+
+static GList*
+get_screen_region (int which)
+{
+  GList *ret;
+  GSList *struts;
+  MetaRectangle basic_rect;
+
+  basic_rect = meta_rect (0, 0, 1600, 1200);
+  ret = NULL;
+
+  struts = get_strut_list (which);
+  ret = meta_rectangle_get_minimal_spanning_set_for_region (&basic_rect, struts);
+  free_strut_list (struts);
+
+  return ret;
+}
+
+static GList*
+get_screen_edges (int which)
+{
+  GList *ret;
+  GSList *struts;
+  MetaRectangle basic_rect;
+
+  basic_rect = meta_rect (0, 0, 1600, 1200);
+  ret = NULL;
+
+  struts = get_strut_list (which);
+  ret = meta_rectangle_find_onscreen_edges (&basic_rect, struts);
+  free_strut_list (struts);
+
+  return ret;
+}
+
+static GList*
+get_xinerama_edges (int which_xinerama_set, int which_strut_set)
+{
+  GList *ret;
+  GSList *struts;
+  GList *xins;
+
+  xins = NULL;
+  g_assert (which_xinerama_set >=0 && which_xinerama_set <= 3);
+  switch (which_xinerama_set)
+    {
+    case 0:
+      xins = g_list_prepend (xins, new_meta_rect (  0,   0, 1600, 1200));
+      break;
+    case 1:
+      xins = g_list_prepend (xins, new_meta_rect (  0,   0,  800, 1200));
+      xins = g_list_prepend (xins, new_meta_rect (800,   0,  800, 1200));
+      break;
+    case 2:
+      xins = g_list_prepend (xins, new_meta_rect (  0,   0, 1600,  600));
+      xins = g_list_prepend (xins, new_meta_rect (  0, 600, 1600,  600));
+      break;
+    case 3:
+      xins = g_list_prepend (xins, new_meta_rect (  0,   0, 1600,  600));
+      xins = g_list_prepend (xins, new_meta_rect (  0, 600,  800,  600));
+      xins = g_list_prepend (xins, new_meta_rect (800, 600,  800,  600));
+      break;
+    }
+
+  ret = NULL;
+
+  struts = get_strut_list (which_strut_set);
+  ret = meta_rectangle_find_nonintersected_xinerama_edges (xins, struts);
+
+  free_strut_list (struts);
+  meta_rectangle_free_list_and_elements (xins);
+
+  return ret;
+}
+
+#if 0
+static void
+test_merge_regions ()
+{
+  /* logarithmically distributed random number of struts (range?)
+   * logarithmically distributed random size of struts (up to screen size???)
+   * uniformly distributed location of center of struts (within screen)
+   * merge all regions that are possible
+   * print stats on problem setup
+   *   number of (non-completely-occluded?) struts 
+   *   percentage of screen covered
+   *   length of resulting non-minimal spanning set
+   *   length of resulting minimal spanning set
+   * print stats on merged regions:
+   *   number boxes merged
+   *   number of those merges that were of the form A contains B
+   *   number of those merges that were of the form A partially contains B
+   *   number of those merges that were of the form A is adjacent to B
+   */
+
+  GList* region;
+  GList* compare;
+  int num_contains, num_merged, num_part_contains, num_adjacent;
+
+  num_contains = num_merged = num_part_contains = num_adjacent = 0;
+  compare = region = get_screen_region (2);
+  g_assert (region);
+
+  printf ("Merging stats:\n");
+  printf ("  Length of initial list: %d\n", g_list_length (region));
+#ifdef PRINT_DEBUG
+  char rect1[RECT_LENGTH], rect2[RECT_LENGTH];
+  char region_list[(RECT_LENGTH + 2) * g_list_length (region)];
+  meta_rectangle_region_to_string (region, ", ", region_list);
+  printf ("  Initial rectangles: %s\n", region_list);
+#endif
+
+  while (compare && compare->next)
+    {
+      MetaRectangle *a = compare->data;
+      GList *other = compare->next;
+
+      g_assert (a->width > 0 && a->height > 0);
+
+      while (other)
+        {
+          MetaRectangle *b = other->data;
+          GList *delete_me = NULL;
+
+          g_assert (b->width > 0 && b->height > 0);
+
+#ifdef PRINT_DEBUG
+          printf ("    -- Comparing %s to %s --\n",
+                  meta_rectangle_to_string (a, rect1),
+                  meta_rectangle_to_string (b, rect2));
+#endif
+
+          /* If a contains b, just remove b */
+          if (meta_rectangle_contains_rect (a, b))
+            {
+              delete_me = other;
+              num_contains++;
+              num_merged++;
+            }
+          /* If b contains a, just remove a */
+          else if (meta_rectangle_contains_rect (a, b))
+            {
+              delete_me = compare;
+              num_contains++;
+              num_merged++;
+            }
+          /* If a and b might be mergeable horizontally */
+          else if (a->y == b->y && a->height == b->height)
+            {
+              /* If a and b overlap */
+              if (meta_rectangle_overlap (a, b))
+                {
+                  int new_x = MIN (a->x, b->x);
+                  a->width = MAX (a->x + a->width, b->x + b->width) - new_x;
+                  a->x = new_x;
+                  delete_me = other;
+                  num_part_contains++;
+                  num_merged++;
+                }
+              /* If a and b are adjacent */
+              else if (a->x + a->width == b->x || a->x == b->x + b->width)
+                {
+                  int new_x = MIN (a->x, b->x);
+                  a->width = MAX (a->x + a->width, b->x + b->width) - new_x;
+                  a->x = new_x;
+                  delete_me = other;
+                  num_adjacent++;
+                  num_merged++;
+                }
+            }
+          /* If a and b might be mergeable vertically */
+          else if (a->x == b->x && a->width == b->width)
+            {
+              /* If a and b overlap */
+              if (meta_rectangle_overlap (a, b))
+                {
+                  int new_y = MIN (a->y, b->y);
+                  a->height = MAX (a->y + a->height, b->y + b->height) - new_y;
+                  a->y = new_y;
+                  delete_me = other;
+                  num_part_contains++;
+                  num_merged++;
+                }
+              /* If a and b are adjacent */
+              else if (a->y + a->height == b->y || a->y == b->y + b->height)
+                {
+                  int new_y = MIN (a->y, b->y);
+                  a->height = MAX (a->y + a->height, b->y + b->height) - new_y;
+                  a->y = new_y;
+                  delete_me = other;
+                  num_adjacent++;
+                  num_merged++;
+                }
+            }
+
+          other = other->next;
+
+          /* Delete any rectangle in the list that is no longer wanted */
+          if (delete_me != NULL)
+            {
+#ifdef PRINT_DEBUG
+              MetaRectangle *bla = delete_me->data;
+              printf ("    Deleting rect %s\n",
+                      meta_rectangle_to_string (bla, rect1));
+#endif
+
+              /* Deleting the rect we're compare others to is a little tricker */
+              if (compare == delete_me)
+                {
+                  compare = compare->next;
+                  other = compare->next;
+                  a = compare->data;
+                }
+
+              /* Okay, we can free it now */
+              g_free (delete_me->data);
+              region = g_list_delete_link (region, delete_me);
+            }
+
+#ifdef PRINT_DEBUG
+          char region_list[(RECT_LENGTH + 2) * g_list_length (region)];
+          meta_rectangle_region_to_string (region, ", ", region_list);
+          printf ("      After comparison, new list is: %s\n", region_list);
+#endif
+        }
+
+      compare = compare->next;
+    }
+
+  printf ("  Num rectangles contained in others          : %d\n", 
+          num_contains);
+  printf ("  Num rectangles partially contained in others: %d\n", 
+          num_part_contains);
+  printf ("  Num rectangles adjacent to others           : %d\n", 
+          num_adjacent);
+  printf ("  Num rectangles merged with others           : %d\n",
+          num_merged);
+#ifdef PRINT_DEBUG
+  char region_list2[(RECT_LENGTH + 2) * g_list_length (region)];
+  meta_rectangle_region_to_string (region, ", ", region_list2);
+  printf ("  Final rectangles: %s\n", region_list2);
+#endif
+
+  meta_rectangle_free_spanning_set (region);
+  region = NULL;
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+#endif
+
+static void
+verify_lists_are_equal (GList *code, GList *answer)
+{
+  int which = 0;
+
+  while (code && answer)
+    {
+      MetaRectangle *a = code->data;
+      MetaRectangle *b = answer->data;
+
+      if (a->x      != b->x     ||
+          a->y      != b->y     ||
+          a->width  != b->width ||
+          a->height != b->height)
+        {
+          g_error ("%dth item in code answer answer lists do not match; "
+                   "code rect: %d,%d + %d,%d; answer rect: %d,%d + %d,%d\n",
+                   which,
+                   a->x, a->y, a->width, a->height,
+                   b->x, b->y, b->width, b->height);
+        }
+
+      code = code->next;
+      answer = answer->next;
+
+      which++;
+    }
+
+  /* Ought to be at the end of both lists; check if we aren't */
+  if (code)
+    {
+      MetaRectangle *tmp = code->data;
+      g_error ("code list longer than answer list by %d items; "
+               "first extra item: %d,%d +%d,%d\n",
+               g_list_length (code),
+               tmp->x, tmp->y, tmp->width, tmp->height);
+    }
+
+  if (answer)
+    {
+      MetaRectangle *tmp = answer->data;
+      g_error ("answer list longer than code list by %d items; "
+               "first extra item: %d,%d +%d,%d\n",
+               g_list_length (answer),
+               tmp->x, tmp->y, tmp->width, tmp->height);
+    }
+}
+
+static void
+test_regions_okay ()
+{
+  GList* region;
+  GList* tmp;
+
+  /*************************************************************/  
+  /* Make sure test region 0 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (0);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect (0, 0, 1600, 1200));
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/  
+  /* Make sure test region 1 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (1);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect (0, 20,  400, 1180));
+  tmp = g_list_prepend (tmp, new_meta_rect (0, 20, 1600, 1140));
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/
+  /* Make sure test region 2 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (2);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  300, 1180));
+  tmp = g_list_prepend (tmp, new_meta_rect ( 450,   20,  350, 1180));
+  tmp = g_list_prepend (tmp, new_meta_rect (1200,   20,  400, 1180));
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  800, 1130));
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20, 1600, 1080));
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/
+  /* Make sure test region 3 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (3);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect ( 380,  675,  420,  525)); /* 220500 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  300, 1180)); /* 354000 */
+  tmp = g_list_prepend (tmp, new_meta_rect ( 380,   20,  320, 1180)); /* 377600 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,  675,  800,  475)); /* 380000 */
+  tmp = g_list_prepend (tmp, new_meta_rect (1200,   20,  400, 1180)); /* 472000 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,  675, 1600,  425)); /* 680000 */
+  tmp = g_list_prepend (tmp, new_meta_rect ( 900,   20,  700, 1080)); /* 756000 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20,  700, 1130)); /* 791000 */
+  tmp = g_list_prepend (tmp, new_meta_rect (   0,   20, 1600,  505)); /* 808000 */
+#if 0
+  printf ("Got to here...\n");
+  char region_list[(RECT_LENGTH+2) * g_list_length (region)];
+  char tmp_list[   (RECT_LENGTH+2) * g_list_length (tmp)];
+  meta_rectangle_region_to_string (region, ", ", region_list);
+  meta_rectangle_region_to_string (region, ", ", tmp_list);
+  printf ("%s vs. %s\n", region_list, tmp_list);
+#endif
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/
+  /* Make sure test region 4 has the right spanning rectangles */
+  /*************************************************************/  
+  region = get_screen_region (4);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_meta_rect ( 800,   20,  800, 1180));
+  verify_lists_are_equal (region, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (region);
+
+  /*************************************************************/
+  /* Make sure test region 5 has the right spanning rectangles */
+  /*************************************************************/  
+  printf ("The next test intentionally causes a warning, "
+          "but it can be ignored.\n");
+  region = get_screen_region (5);
+  verify_lists_are_equal (region, NULL);
+
+  /* FIXME: Still to do:
+   *   - Create random struts and check the regions somehow
+   */
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_region_fitting ()
+{
+  GList* region;
+  MetaRectangle rect;
+
+  /* See test_basic_fitting() for how/why these automated random tests work */
+  int i;
+  region = get_screen_region (3);
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&rect);
+      g_assert (meta_rectangle_contained_in_region (region, &rect) == FALSE ||
+                meta_rectangle_could_fit_in_region (region, &rect) == TRUE);
+    }
+  meta_rectangle_free_list_and_elements (region);
+
+  /* Do some manual tests too */
+  region = get_screen_region (1);
+
+  rect = meta_rect (50, 50, 400, 400);
+  g_assert (meta_rectangle_could_fit_in_region (region, &rect));
+  g_assert (meta_rectangle_contained_in_region (region, &rect));
+
+  rect = meta_rect (250, 0, 500, 1150);
+  g_assert (!meta_rectangle_could_fit_in_region (region, &rect));
+  g_assert (!meta_rectangle_contained_in_region (region, &rect));
+
+  rect = meta_rect (250, 0, 400, 400);
+  g_assert (meta_rectangle_could_fit_in_region (region, &rect));
+  g_assert (!meta_rectangle_contained_in_region (region, &rect));
+
+  meta_rectangle_free_list_and_elements (region);
+
+  region = get_screen_region (2);
+  rect = meta_rect (1000, 50, 600, 1100);
+  g_assert (meta_rectangle_could_fit_in_region (region, &rect));
+  g_assert (!meta_rectangle_contained_in_region (region, &rect));
+
+  meta_rectangle_free_list_and_elements (region);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_clamping_to_region ()
+{
+  GList* region;
+  MetaRectangle rect;
+  MetaRectangle min_size;
+  FixedDirections fixed_directions;
+  int i;
+
+  min_size.height = min_size.width = 1;
+  fixed_directions = 0;
+
+  region = get_screen_region (3);
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      MetaRectangle temp;
+      get_random_rect (&rect);
+      temp = rect;
+      meta_rectangle_clamp_to_fit_into_region (region,
+                                               fixed_directions,
+                                               &rect,
+                                               &min_size);
+      g_assert (meta_rectangle_could_fit_in_region (region, &rect) == TRUE);
+      g_assert (rect.x == temp.x && rect.y == temp.y);
+    }
+  meta_rectangle_free_list_and_elements (region);
+
+  /* Do some manual tests too */
+  region = get_screen_region (1);
+
+  rect = meta_rect (50, 50, 10000, 10000);
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 1600 && rect.height == 1140);
+
+  rect = meta_rect (275, -50, 410, 10000);
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 400 && rect.height == 1180);
+
+  rect = meta_rect (50, 50, 10000, 10000);
+  min_size.height = 1170;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 400 && rect.height == 1180);
+
+  printf ("The next test intentionally causes a warning, "
+          "but it can be ignored.\n");
+  rect = meta_rect (50, 50, 10000, 10000);
+  min_size.width = 600;  min_size.height = 1170;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 600 && rect.height == 1170);
+
+  rect = meta_rect (350, 50, 100, 1100);
+  min_size.width = 1;  min_size.height = 1;
+  fixed_directions = FIXED_DIRECTION_X;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 100 && rect.height == 1100);
+
+  rect = meta_rect (300, 70, 500, 1100);
+  min_size.width = 1;  min_size.height = 1;
+  fixed_directions = FIXED_DIRECTION_Y;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 400 && rect.height == 1100);
+
+  printf ("The next test intentionally causes a warning, "
+          "but it can be ignored.\n");
+  rect = meta_rect (300, 70, 999999, 999999);
+  min_size.width = 100;  min_size.height = 200;
+  fixed_directions = FIXED_DIRECTION_Y;
+  meta_rectangle_clamp_to_fit_into_region (region,
+                                           fixed_directions,
+                                           &rect,
+                                           &min_size);
+  g_assert (rect.width == 100 && rect.height == 999999);
+
+  meta_rectangle_free_list_and_elements (region);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static gboolean
+rect_overlaps_region (const GList         *spanning_rects,
+                      const MetaRectangle *rect)
+{
+  /* FIXME: Should I move this to boxes.[ch]? */
+  const GList *temp;
+  gboolean     overlaps;
+
+  temp = spanning_rects;
+  overlaps = FALSE;
+  while (!overlaps && temp != NULL)
+    {
+      overlaps = overlaps || meta_rectangle_overlap (temp->data, rect);
+      temp = temp->next;
+    }
+
+  return overlaps;
+}
+
+gboolean time_to_print = FALSE;
+
+static void
+test_clipping_to_region ()
+{
+  GList* region;
+  MetaRectangle rect, temp;
+  FixedDirections fixed_directions = 0;
+  int i;
+
+  region = get_screen_region (3);
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&rect);
+      if (rect_overlaps_region (region, &rect))
+        {
+          meta_rectangle_clip_to_region (region, 0, &rect);
+          g_assert (meta_rectangle_contained_in_region (region, &rect) == TRUE);
+        }
+    }
+  meta_rectangle_free_list_and_elements (region);
+
+  /* Do some manual tests too */
+  region = get_screen_region (2);
+
+  rect = meta_rect (-50, -10, 10000, 10000);
+  meta_rectangle_clip_to_region (region,
+                                 fixed_directions,
+                                 &rect);
+  g_assert (meta_rectangle_equal (region->data, &rect));
+
+  rect = meta_rect (300, 1000, 400, 200);
+  temp = meta_rect (300, 1000, 400, 150);
+  meta_rectangle_clip_to_region (region,
+                                 fixed_directions,
+                                 &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (400, 1000, 300, 200);
+  temp = meta_rect (450, 1000, 250, 200);
+  meta_rectangle_clip_to_region (region,
+                                 fixed_directions,
+                                 &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (400, 1000, 300, 200);
+  temp = meta_rect (400, 1000, 300, 150);
+  meta_rectangle_clip_to_region (region,
+                                 FIXED_DIRECTION_X,
+                                 &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (400, 1000, 300, 200);
+  temp = meta_rect (400, 1000, 300, 150);
+  meta_rectangle_clip_to_region (region,
+                                 FIXED_DIRECTION_X,
+                                 &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  meta_rectangle_free_list_and_elements (region);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_shoving_into_region ()
+{
+  GList* region;
+  MetaRectangle rect, temp;
+  FixedDirections fixed_directions = 0;
+  int i;
+
+  region = get_screen_region (3);
+  for (i = 0; i < NUM_RANDOM_RUNS; i++)
+    {
+      get_random_rect (&rect);
+      if (meta_rectangle_could_fit_in_region (region, &rect))
+        {
+          meta_rectangle_shove_into_region (region, 0, &rect);
+          g_assert (meta_rectangle_contained_in_region (region, &rect));
+        }
+    }
+  meta_rectangle_free_list_and_elements (region);
+
+  /* Do some manual tests too */
+  region = get_screen_region (2);
+
+  rect = meta_rect (300, 1000, 400, 200);
+  temp = meta_rect (300,  950, 400, 200);
+  meta_rectangle_shove_into_region (region,
+                                    fixed_directions,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (425, 1000, 300, 200);
+  temp = meta_rect (450, 1000, 300, 200);
+  meta_rectangle_shove_into_region (region,
+                                    fixed_directions,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (425, 1000, 300, 200);
+  temp = meta_rect (425,  950, 300, 200);
+  meta_rectangle_shove_into_region (region,
+                                    FIXED_DIRECTION_X,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 300, 1000, 400, 200);
+  temp = meta_rect (1200, 1000, 400, 200);
+  meta_rectangle_shove_into_region (region,
+                                    FIXED_DIRECTION_Y,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 800, 1150, 400,  50);  /* Completely "offscreen" :) */
+  temp = meta_rect ( 800, 1050, 400,  50);
+  meta_rectangle_shove_into_region (region,
+                                    0,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (-1000,  0, 400, 150);  /* Offscreen in 2 directions */
+  temp = meta_rect (    0, 20, 400, 150);
+  meta_rectangle_shove_into_region (region,
+                                    0,
+                                    &rect);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  meta_rectangle_free_list_and_elements (region);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+verify_edge_lists_are_equal (GList *code, GList *answer)
+{
+  int which = 0;
+
+  while (code && answer)
+    {
+      MetaEdge *a = code->data;
+      MetaEdge *b = answer->data;
+
+      if (!meta_rectangle_equal (&a->rect, &b->rect) ||
+          a->side_type != b->side_type ||
+          a->edge_type != b->edge_type)
+        {
+          g_error ("%dth item in code answer answer lists do not match; "
+                   "code rect: %d,%d + %d,%d; answer rect: %d,%d + %d,%d\n",
+                   which,
+                   a->rect.x, a->rect.y, a->rect.width, a->rect.height,
+                   b->rect.x, b->rect.y, b->rect.width, b->rect.height);
+        }
+
+      code = code->next;
+      answer = answer->next;
+
+      which++;
+    }
+
+  /* Ought to be at the end of both lists; check if we aren't */
+  if (code)
+    {
+      MetaEdge *tmp = code->data;
+      g_error ("code list longer than answer list by %d items; "
+               "first extra item rect: %d,%d +%d,%d\n",
+               g_list_length (code),
+               tmp->rect.x, tmp->rect.y, tmp->rect.width, tmp->rect.height);
+    }
+
+  if (answer)
+    {
+      MetaEdge *tmp = answer->data;
+      g_error ("answer list longer than code list by %d items; "
+               "first extra item rect: %d,%d +%d,%d\n",
+               g_list_length (answer),
+               tmp->rect.x, tmp->rect.y, tmp->rect.width, tmp->rect.height);
+    }
+}
+
+static void
+test_find_onscreen_edges ()
+{
+  GList* edges;
+  GList* tmp;
+
+  int left   = META_DIRECTION_LEFT;
+  int right  = META_DIRECTION_RIGHT;
+  int top    = META_DIRECTION_TOP;
+  int bottom = META_DIRECTION_BOTTOM;
+
+  /*************************************************/  
+  /* Make sure test region 0 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (0);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200, 1600, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,    0, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,    0, 0, 1200, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,    0, 0, 1200, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 1 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (1);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 400, 1160, 1200, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1140, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 400, 1160, 0,   40, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 0, 1180, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 2 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (2);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1200,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 450, 1200,  350, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200,  300, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150,  150, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1180, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100, 0,  100, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150, 0,   50, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1100, 0,  100, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 450, 1150, 0,   50, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 0, 1180, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 3 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (3);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1200,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 380, 1200,  420, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200,  300, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150,   80, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 700,  525, 200,  0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 700,  675, 200,  0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1180, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100, 0,  100, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 700,  525, 0,  150, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150, 0,   50, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1100, 0,  100, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 900,  525, 0,  150, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 380, 1150, 0,   50, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 0, 1180, left));
+
+#if 0
+  #define FUDGE 50 /* number of edges */
+  char big_buffer1[(EDGE_LENGTH+2)*FUDGE], big_buffer2[(EDGE_LENGTH+2)*FUDGE];
+  meta_rectangle_edge_list_to_string (edges, "\n ", big_buffer1);
+  meta_rectangle_edge_list_to_string (tmp,   "\n ", big_buffer2);
+  printf("Generated edge list:\n %s\nComparison edges list:\n %s\n", 
+         big_buffer1, big_buffer2);
+#endif
+
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 4 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (4);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1200, 800,  0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800,   20, 800,  0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1180, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800,   20, 0, 1180, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 5 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (5);
+  tmp = NULL;
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************/  
+  /* Make sure test region 6 has the correct edges */
+  /*************************************************/  
+  edges = get_screen_edges (6);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200, 1600,  0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   40, 1600,  0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   40, 0,  1160, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   40, 0,  1160, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_find_nonintersected_xinerama_edges ()
+{
+  GList* edges;
+  GList* tmp;
+
+  int left   = META_DIRECTION_LEFT;
+  int right  = META_DIRECTION_RIGHT;
+  int top    = META_DIRECTION_TOP;
+  int bottom = META_DIRECTION_BOTTOM;
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 0 for with region 0 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (0, 0);
+  tmp = NULL;
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 2 for with region 1 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (2, 1);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600, 1600, 0, bottom));
+  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600, 1600, 0, top));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 1 for with region 2 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (1, 2);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,   20, 0, 1080, right));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,   20, 0, 1180, left));
+#if 0
+  #define FUDGE 50
+  char big_buffer1[(EDGE_LENGTH+2)*FUDGE], big_buffer2[(EDGE_LENGTH+2)*FUDGE];
+  meta_rectangle_edge_list_to_string (edges, "\n ", big_buffer1);
+  meta_rectangle_edge_list_to_string (tmp,   "\n ", big_buffer2);
+  printf("Generated edge list:\n %s\nComparison edges list:\n %s\n", 
+         big_buffer1, big_buffer2);
+#endif
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 3 for with region 3 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (3, 3);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 900,  600,  700, 0, bottom));
+  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600,  700, 0, bottom));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 900,  600,  700, 0, top));
+  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600,  700, 0, top));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  675, 0,  425, right));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  675, 0,  525, left));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 3 for with region 4 has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (3, 4);
+  tmp = NULL;
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  600,  800, 0, bottom));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  600,  800, 0, top));
+  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  600,  0, 600, right));
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  /*************************************************************************/  
+  /* Make sure test xinerama set 3 for with region 5has the correct edges */
+  /*************************************************************************/  
+  edges = get_xinerama_edges (3, 5);
+  tmp = NULL;
+  verify_edge_lists_are_equal (edges, tmp);
+  meta_rectangle_free_list_and_elements (tmp);
+  meta_rectangle_free_list_and_elements (edges);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_gravity_resize ()
+{
+  MetaRectangle oldrect, rect, temp;
+
+  rect.x = -500;  /* Some random amount not equal to oldrect.x to ensure that
+                   * the resize is done with respect to oldrect instead of rect
+                   */
+  oldrect = meta_rect ( 50,  300, 250, 400);
+  temp    = meta_rect ( 50,  300,  20,   5);
+  meta_rectangle_resize_with_gravity (&oldrect,
+                                      &rect,
+                                      NorthWestGravity,
+                                      20,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect (165,  300,  20,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      NorthGravity,
+                                      20,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect (280,  300,  20,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      NorthEastGravity,
+                                      20,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect ( 50,  695,  50,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      SouthWestGravity,
+                                      50,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect (150,  695,  50,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      SouthGravity,
+                                      50,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 50,  300, 250, 400);
+  temp = meta_rect (250,  695,  50,   5);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      SouthEastGravity,
+                                      50,
+                                      5);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (167,  738, 237, 843);
+  temp = meta_rect (167, 1113, 832,  93);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      WestGravity,
+                                      832,
+                                      93);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect ( 167,  738, 237, 843);
+  temp = meta_rect (-131, 1113, 833,  93);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      CenterGravity,
+                                      832,
+                                      93);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (300, 1000, 400, 200);
+  temp = meta_rect (270,  994, 430, 212);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      EastGravity,
+                                      430,
+                                      211);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  rect = meta_rect (300, 1000, 400, 200);
+  temp = meta_rect (300, 1000, 430, 211);
+  meta_rectangle_resize_with_gravity (&rect,
+                                      &rect,
+                                      StaticGravity,
+                                      430,
+                                      211);
+  g_assert (meta_rectangle_equal (&rect, &temp));
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+static void
+test_find_closest_point_to_line ()
+{
+  double x1, y1, x2, y2, px, py, rx, ry;
+  double answer_x, answer_y;
+
+  x1 =  3.0;  y1 =  49.0;
+  x2 =  2.0;  y2 = - 1.0;
+  px = -2.6;  py =  19.1;
+  answer_x = 2.4; answer_y = 19;
+  meta_rectangle_find_linepoint_closest_to_point (x1,  y1,
+                                                  x2,  y2,
+                                                  px,  py,
+                                                  &rx, &ry);
+  g_assert (rx == answer_x && ry == answer_y);
+
+  /* Special test for x1 == x2, so that slop of line is infinite */
+  x1 =  3.0;  y1 =  49.0;
+  x2 =  3.0;  y2 = - 1.0;
+  px = -2.6;  py =  19.1;
+  answer_x = 3.0; answer_y = 19.1;
+  meta_rectangle_find_linepoint_closest_to_point (x1,  y1,
+                                                  x2,  y2,
+                                                  px,  py,
+                                                  &rx, &ry);
+  g_assert (rx == answer_x && ry == answer_y);
+
+  /* Special test for y1 == y2, so perp line has slope of infinity */
+  x1 =  3.14;  y1 =   7.0;
+  x2 =  2.718; y2 =   7.0;
+  px = -2.6;   py =  19.1;
+  answer_x = -2.6; answer_y = 7;
+  meta_rectangle_find_linepoint_closest_to_point (x1,  y1,
+                                                  x2,  y2,
+                                                  px,  py,
+                                                  &rx, &ry);
+  g_assert (rx == answer_x && ry == answer_y);
+
+  /* Test when we the point we want to be closest to is actually on the line */
+  x1 =  3.0;  y1 =  49.0;
+  x2 =  2.0;  y2 = - 1.0;
+  px =  2.4;  py =  19.0;
+  answer_x = 2.4; answer_y = 19;
+  meta_rectangle_find_linepoint_closest_to_point (x1,  y1,
+                                                  x2,  y2,
+                                                  px,  py,
+                                                  &rx, &ry);
+  g_assert (rx == answer_x && ry == answer_y);
+
+  printf ("%s passed.\n", G_STRFUNC);
+}
+
+int
+main()
+{
+  init_random_ness ();
+  test_area ();
+  test_intersect ();
+  test_equal ();
+  test_overlap_funcs ();
+  test_basic_fitting ();
+
+  test_regions_okay ();
+  test_region_fitting ();
+
+  test_clamping_to_region ();
+  test_clipping_to_region ();
+  test_shoving_into_region ();
+
+  /* And now the functions dealing with edges more than boxes */
+  test_find_onscreen_edges ();
+  test_find_nonintersected_xinerama_edges ();
+
+  /* And now the misfit functions that don't quite fit in anywhere else... */
+  test_gravity_resize ();
+  test_find_closest_point_to_line ();
+
+  printf ("All tests passed.\n");
+  return 0;
+}
diff --git a/src/core/util.c b/src/core/util.c
new file mode 100644
index 00000000..6dd27f8e
--- /dev/null
+++ b/src/core/util.c
@@ -0,0 +1,641 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco utilities */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _POSIX_C_SOURCE 200112L /* for fdopen() */
+
+#include <config.h>
+#include "util.h"
+#include "main.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <X11/Xlib.h>   /* must explicitly be included for Solaris; #326746 */
+#include <X11/Xutil.h>  /* Just for the definition of the various gravities */
+
+#ifdef HAVE_BACKTRACE
+#include <execinfo.h>
+void
+meta_print_backtrace (void)
+{
+  void *bt[500];
+  int bt_size;
+  int i;
+  char **syms;
+  
+  bt_size = backtrace (bt, 500);
+
+  syms = backtrace_symbols (bt, bt_size);
+  
+  i = 0;
+  while (i < bt_size)
+    {
+      meta_verbose ("  %s\n", syms[i]);
+      ++i;
+    }
+
+  free (syms);
+}
+#else
+void
+meta_print_backtrace (void)
+{
+  meta_verbose ("Not compiled with backtrace support\n");
+}
+#endif
+
+static gboolean is_verbose = FALSE;
+static gboolean is_debugging = FALSE;
+static gboolean replace_current = FALSE;
+static int no_prefix = 0;
+
+#ifdef WITH_VERBOSE_MODE
+static FILE* logfile = NULL;
+
+static void
+ensure_logfile (void)
+{
+  if (logfile == NULL && g_getenv ("MARCO_USE_LOGFILE"))
+    {
+      char *filename = NULL;
+      char *tmpl;
+      int fd;
+      GError *err;
+      
+      tmpl = g_strdup_printf ("marco-%d-debug-log-XXXXXX",
+                              (int) getpid ());
+
+      err = NULL;
+      fd = g_file_open_tmp (tmpl,
+                            &filename,
+                            &err);
+
+      g_free (tmpl);
+      
+      if (err != NULL)
+        {
+          meta_warning (_("Failed to open debug log: %s\n"),
+                        err->message);
+          g_error_free (err);
+          return;
+        }
+      
+      logfile = fdopen (fd, "w");
+      
+      if (logfile == NULL)
+        {
+          meta_warning (_("Failed to fdopen() log file %s: %s\n"),
+                        filename, strerror (errno));
+          close (fd);
+        }
+      else
+        {
+          g_printerr (_("Opened log file %s\n"), filename);
+        }
+      
+      g_free (filename);
+    }
+}
+#endif
+
+gboolean
+meta_is_verbose (void)
+{
+  return is_verbose;
+}
+
+void
+meta_set_verbose (gboolean setting)
+{
+#ifndef WITH_VERBOSE_MODE
+  if (setting)
+    meta_fatal (_("Marco was compiled without support for verbose mode\n"));
+#else 
+  if (setting)
+    ensure_logfile ();
+#endif
+  
+  is_verbose = setting;
+}
+
+gboolean
+meta_is_debugging (void)
+{
+  return is_debugging;
+}
+
+void
+meta_set_debugging (gboolean setting)
+{
+#ifdef WITH_VERBOSE_MODE
+  if (setting)
+    ensure_logfile ();
+#endif
+
+  is_debugging = setting;
+}
+
+gboolean
+meta_get_replace_current_wm (void)
+{
+  return replace_current;
+}
+
+void
+meta_set_replace_current_wm (gboolean setting)
+{
+  replace_current = setting;
+}
+
+char *
+meta_g_utf8_strndup (const gchar *src,
+                     gsize        n)
+{
+  const gchar *s = src;
+  while (n && *s)
+    {
+      s = g_utf8_next_char (s);
+      n--;
+    }
+
+  return g_strndup (src, s - src);
+}
+
+static int
+utf8_fputs (const char *str,
+            FILE       *f)
+{
+  char *l;
+  int retval;
+  
+  l = g_locale_from_utf8 (str, -1, NULL, NULL, NULL);
+
+  if (l == NULL)
+    retval = fputs (str, f); /* just print it anyway, better than nothing */
+  else
+    retval = fputs (l, f);
+
+  g_free (l);
+
+  return retval;
+}
+
+void
+meta_free_gslist_and_elements (GSList *list_to_deep_free)
+{
+  g_slist_foreach (list_to_deep_free,
+                   (void (*)(gpointer,gpointer))&g_free, /* ew, for ugly */
+                   NULL);
+  g_slist_free (list_to_deep_free);
+}
+
+#ifdef WITH_VERBOSE_MODE
+void
+meta_debug_spew_real (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+  
+  g_return_if_fail (format != NULL);
+
+  if (!is_debugging)
+    return;
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  out = logfile ? logfile : stderr;
+  
+  if (no_prefix == 0)
+    utf8_fputs (_("Window manager: "), out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+void
+meta_verbose_real (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+
+  g_return_if_fail (format != NULL);
+
+  if (!is_verbose)
+    return;
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  out = logfile ? logfile : stderr;
+  
+  if (no_prefix == 0)
+    utf8_fputs ("Window manager: ", out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+topic_name (MetaDebugTopic topic)
+{
+  switch (topic)
+    {
+    case META_DEBUG_FOCUS:
+      return "FOCUS";
+    case META_DEBUG_WORKAREA:
+      return "WORKAREA";
+    case META_DEBUG_STACK:
+      return "STACK";
+    case META_DEBUG_THEMES:
+      return "THEMES";
+    case META_DEBUG_SM:
+      return "SM";
+    case META_DEBUG_EVENTS:
+      return "EVENTS";
+    case META_DEBUG_WINDOW_STATE:
+      return "WINDOW_STATE";
+    case META_DEBUG_WINDOW_OPS:
+      return "WINDOW_OPS";
+    case META_DEBUG_PLACEMENT:
+      return "PLACEMENT";
+    case META_DEBUG_GEOMETRY:
+      return "GEOMETRY";
+    case META_DEBUG_PING:
+      return "PING";
+    case META_DEBUG_XINERAMA:
+      return "XINERAMA";
+    case META_DEBUG_KEYBINDINGS:
+      return "KEYBINDINGS";
+    case META_DEBUG_SYNC:
+      return "SYNC";
+    case META_DEBUG_ERRORS:
+      return "ERRORS";
+    case META_DEBUG_STARTUP:
+      return "STARTUP";
+    case META_DEBUG_PREFS:
+      return "PREFS";
+    case META_DEBUG_GROUPS:
+      return "GROUPS";
+    case META_DEBUG_RESIZING:
+      return "RESIZING";
+    case META_DEBUG_SHAPES:
+      return "SHAPES";
+    case META_DEBUG_COMPOSITOR:
+      return "COMPOSITOR";
+    case META_DEBUG_EDGE_RESISTANCE:
+      return "EDGE_RESISTANCE";
+    }
+
+  return "WM";
+}
+
+static int sync_count = 0;
+
+void
+meta_topic_real (MetaDebugTopic topic,
+                 const char *format,
+                 ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+
+  g_return_if_fail (format != NULL);
+
+  if (!is_verbose)
+    return;
+  
+  va_start (args, format);  
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  out = logfile ? logfile : stderr;
+
+  if (no_prefix == 0)
+    fprintf (out, "%s: ", topic_name (topic));
+
+  if (topic == META_DEBUG_SYNC)
+    {
+      ++sync_count;
+      fprintf (out, "%d: ", sync_count);
+    }
+  
+  utf8_fputs (str, out);
+  
+  fflush (out);
+  
+  g_free (str);
+}
+#endif /* WITH_VERBOSE_MODE */
+
+void
+meta_bug (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+
+  g_return_if_fail (format != NULL);
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+#ifdef WITH_VERBOSE_MODE
+  out = logfile ? logfile : stderr;
+#else
+  out = stderr;
+#endif
+
+  if (no_prefix == 0)
+    utf8_fputs (_("Bug in window manager: "), out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+
+  meta_print_backtrace ();
+  
+  /* stop us in a debugger */
+  abort ();
+}
+
+void
+meta_warning (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+  
+  g_return_if_fail (format != NULL);
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+#ifdef WITH_VERBOSE_MODE
+  out = logfile ? logfile : stderr;
+#else
+  out = stderr;
+#endif
+
+  if (no_prefix == 0)
+    utf8_fputs (_("Window manager warning: "), out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+}
+
+void
+meta_fatal (const char *format, ...)
+{
+  va_list args;
+  gchar *str;
+  FILE *out;
+  
+  g_return_if_fail (format != NULL);
+  
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+#ifdef WITH_VERBOSE_MODE
+  out = logfile ? logfile : stderr;
+#else
+  out = stderr;
+#endif
+
+  if (no_prefix == 0)
+    utf8_fputs (_("Window manager error: "), out);
+  utf8_fputs (str, out);
+
+  fflush (out);
+  
+  g_free (str);
+
+  meta_exit (META_EXIT_ERROR);
+}
+
+void
+meta_push_no_msg_prefix (void)
+{
+  ++no_prefix;
+}
+
+void
+meta_pop_no_msg_prefix (void)
+{
+  g_return_if_fail (no_prefix > 0);
+
+  --no_prefix;
+}
+
+void
+meta_exit (MetaExitCode code)
+{
+  
+  exit (code);
+}
+
+gint
+meta_unsigned_long_equal (gconstpointer v1,
+                          gconstpointer v2)
+{
+  return *((const gulong*) v1) == *((const gulong*) v2);
+}
+
+guint
+meta_unsigned_long_hash  (gconstpointer v)
+{
+  gulong val = * (const gulong *) v;
+
+  /* I'm not sure this works so well. */
+#if GLIB_SIZEOF_LONG > 4
+  return (guint) (val ^ (val >> 32));
+#else
+  return val;
+#endif
+}
+
+const char*
+meta_gravity_to_string (int gravity)
+{
+  switch (gravity)
+    {
+    case NorthWestGravity:
+      return "NorthWestGravity";
+      break;
+    case NorthGravity:
+      return "NorthGravity";
+      break;
+    case NorthEastGravity:
+      return "NorthEastGravity";
+      break;
+    case WestGravity:
+      return "WestGravity";
+      break;
+    case CenterGravity:
+      return "CenterGravity";
+      break;
+    case EastGravity:
+      return "EastGravity";
+      break;
+    case SouthWestGravity:
+      return "SouthWestGravity";
+      break;
+    case SouthGravity:
+      return "SouthGravity";
+      break;
+    case SouthEastGravity:
+      return "SouthEastGravity";
+      break;
+    case StaticGravity:
+      return "StaticGravity";
+      break;
+    default:
+      return "NorthWestGravity";
+      break;
+    }
+}
+
+GPid
+meta_show_dialog (const char *type,
+                  const char *message,
+                  const char *timeout,
+                  const gint screen_number,
+                  const char *ok_text,
+                  const char *cancel_text,
+                  const int transient_for,
+                  GSList *columns,
+                  GSList *entries)
+{
+  GError *error = NULL;
+  char *screen_number_text = g_strdup_printf("%d", screen_number);
+  GSList *tmp;
+  int i=0;
+  GPid child_pid;
+  const char **argvl = g_malloc(sizeof (char*) *
+                                (17 +
+                                 g_slist_length (columns)*2 +
+                                 g_slist_length (entries)));
+
+  argvl[i++] = "matedialog";
+  argvl[i++] = type;
+  argvl[i++] = "--screen";
+  argvl[i++] = screen_number_text;
+  argvl[i++] = "--class";
+  argvl[i++] = "marco-dialog";
+  argvl[i++] = "--title";
+  /* Translators: This is the title used on dialog boxes */
+  argvl[i++] = _("Marco");
+  argvl[i++] = "--text";
+  argvl[i++] = message;
+  
+  if (timeout)
+    {
+      argvl[i++] = "--timeout";
+      argvl[i++] = timeout;
+    }
+
+  if (ok_text)
+    {
+      argvl[i++] = "--ok-label";
+      argvl[i++] = ok_text;
+     }
+
+  if (cancel_text)
+    {
+      argvl[i++] = "--cancel-label";
+      argvl[i++] = cancel_text;
+    }
+  
+  tmp = columns;
+  while (tmp)
+    {
+      argvl[i++] = "--column";
+      argvl[i++] = tmp->data;
+      tmp = tmp->next;
+    }
+
+  tmp = entries;
+  while (tmp)
+    {
+      argvl[i++] = tmp->data;
+      tmp = tmp->next;
+    }
+    
+  argvl[i] = NULL;
+
+  if (transient_for)
+    {
+      gchar *env = g_strdup_printf("%d", transient_for);
+      setenv ("WINDOWID", env, 1);
+      g_free (env);
+    }
+
+  g_spawn_async (
+                 "/",
+                 (gchar**) argvl, /* ugh */
+                 NULL,
+                 G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
+                 NULL, NULL,
+                 &child_pid,
+                 &error
+                 );
+
+  if (transient_for)
+    unsetenv ("WINDOWID");
+
+  g_free (argvl);
+  g_free (screen_number_text);
+
+  if (error)
+    {
+      meta_warning ("%s\n", error->message);
+      g_error_free (error);
+    }
+
+  return child_pid;
+}
+/* eof util.c */
+
diff --git a/src/core/window-private.h b/src/core/window-private.h
new file mode 100644
index 00000000..1a966275
--- /dev/null
+++ b/src/core/window-private.h
@@ -0,0 +1,640 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file window-private.h  Windows which Marco manages
+ *
+ * Managing X windows.
+ * This file contains methods on this class which are available to
+ * routines in core but not outside it.  (See window.h for the routines
+ * which the rest of the world is allowed to use.)
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat, Inc.
+ * Copyright (C) 2003, 2004 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_WINDOW_PRIVATE_H
+#define META_WINDOW_PRIVATE_H
+
+#include <config.h>
+#include "window.h"
+#include "screen-private.h"
+#include "util.h"
+#include "stack.h"
+#include "iconcache.h"
+#include <X11/Xutil.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+typedef struct _MetaGroup MetaGroup;
+typedef struct _MetaWindowQueue MetaWindowQueue;
+
+typedef gboolean (*MetaWindowForeachFunc) (MetaWindow *window,
+                                           void       *data);
+
+typedef enum
+{
+  META_WINDOW_NORMAL,
+  META_WINDOW_DESKTOP,
+  META_WINDOW_DOCK,
+  META_WINDOW_DIALOG,
+  META_WINDOW_MODAL_DIALOG,
+  META_WINDOW_TOOLBAR,
+  META_WINDOW_MENU,
+  META_WINDOW_UTILITY,
+  META_WINDOW_SPLASHSCREEN
+} MetaWindowType;
+
+typedef enum
+{
+  META_MAXIMIZE_HORIZONTAL = 1 << 0,
+  META_MAXIMIZE_VERTICAL   = 1 << 1
+} MetaMaximizeFlags;
+
+typedef enum {
+  META_CLIENT_TYPE_UNKNOWN = 0,
+  META_CLIENT_TYPE_APPLICATION = 1,
+  META_CLIENT_TYPE_PAGER = 2,
+  META_CLIENT_TYPE_MAX_RECOGNIZED = 2
+} MetaClientType;
+
+typedef enum {
+  META_QUEUE_CALC_SHOWING = 1 << 0,
+  META_QUEUE_MOVE_RESIZE  = 1 << 1,
+  META_QUEUE_UPDATE_ICON  = 1 << 2,
+} MetaQueueType;
+
+#define NUMBER_OF_QUEUES 3
+
+struct _MetaWindow
+{
+  MetaDisplay *display;
+  MetaScreen *screen;
+  MetaWorkspace *workspace;
+  Window xwindow;
+  /* may be NULL! not all windows get decorated */
+  MetaFrame *frame;
+  int depth;
+  Visual *xvisual;
+  Colormap colormap;
+  char *desc; /* used in debug spew */
+  char *title;
+
+  char *icon_name;
+  GdkPixbuf *icon;
+  GdkPixbuf *mini_icon;
+  MetaIconCache icon_cache;
+  Pixmap wm_hints_pixmap;
+  Pixmap wm_hints_mask;
+  
+  MetaWindowType type;
+  Atom type_atom;
+  
+  /* NOTE these five are not in UTF-8, we just treat them as random
+   * binary data
+   */
+  char *res_class;
+  char *res_name;
+  char *role;
+  char *sm_client_id;
+  char *wm_client_machine;
+  char *startup_id;
+
+  int net_wm_pid;
+  
+  Window xtransient_for;
+  Window xgroup_leader;
+  Window xclient_leader;
+
+  /* Initial workspace property */
+  int initial_workspace;  
+  
+  /* Initial timestamp property */
+  guint32 initial_timestamp;  
+  
+  /* Whether we're maximized */
+  guint maximized_horizontally : 1;
+  guint maximized_vertically : 1;
+
+  /* Whether we have to maximize/minimize after placement */
+  guint maximize_horizontally_after_placement : 1;
+  guint maximize_vertically_after_placement : 1;
+  guint minimize_after_placement : 1;
+
+  /* Whether we're shaded */
+  guint shaded : 1;
+
+  /* Whether we're fullscreen */
+  guint fullscreen : 1;
+
+  /* Whether we have to fullscreen after placement */
+  guint fullscreen_after_placement : 1;
+
+  /* Area to cover when in fullscreen mode.  If _NET_WM_FULLSCREEN_MONITORS has
+   * been overridden (via a client message), the window will cover the union of
+   * these monitors.  If not, this is the single monitor which the window's
+   * origin is on. */
+  long fullscreen_monitors[4];
+  
+  /* Whether we're trying to constrain the window to be fully onscreen */
+  guint require_fully_onscreen : 1;
+
+  /* Whether we're trying to constrain the window to be on a single xinerama */
+  guint require_on_single_xinerama : 1;
+
+  /* Whether we're trying to constrain the window's titlebar to be onscreen */
+  guint require_titlebar_visible : 1;
+
+  /* Whether we're sticky in the multi-workspace sense
+   * (vs. the not-scroll-with-viewport sense, we don't
+   * have no stupid viewports)
+   */
+  guint on_all_workspaces : 1;
+
+  /* Minimize is the state controlled by the minimize button */
+  guint minimized : 1;
+  guint was_minimized : 1;
+  guint tab_unminimized : 1;
+
+  /* Whether the window is mapped; actual server-side state
+   * see also unmaps_pending
+   */
+  guint mapped : 1;
+  
+  /* Iconic is the state in WM_STATE; happens for workspaces/shading
+   * in addition to minimize
+   */
+  guint iconic : 1;
+  /* initially_iconic is the WM_HINTS setting when we first manage
+   * the window. It's taken to mean initially minimized.
+   */
+  guint initially_iconic : 1;
+
+  /* whether an initial workspace was explicitly set */
+  guint initial_workspace_set : 1;
+  
+  /* whether an initial timestamp was explicitly set */
+  guint initial_timestamp_set : 1;
+  
+  /* whether net_wm_user_time has been set yet */
+  guint net_wm_user_time_set : 1;
+  
+  /* These are the flags from WM_PROTOCOLS */
+  guint take_focus : 1;
+  guint delete_window : 1;
+  guint net_wm_ping : 1;
+  /* Globally active / No input */
+  guint input : 1;
+  
+  /* MWM hints about features of window */
+  guint mwm_decorated : 1;
+  guint mwm_border_only : 1;
+  guint mwm_has_close_func : 1;
+  guint mwm_has_minimize_func : 1;
+  guint mwm_has_maximize_func : 1;
+  guint mwm_has_move_func : 1;
+  guint mwm_has_resize_func : 1;
+  
+  /* Computed features of window */
+  guint decorated : 1;
+  guint border_only : 1;
+  guint always_sticky : 1;
+  guint has_close_func : 1;
+  guint has_minimize_func : 1;
+  guint has_maximize_func : 1;
+  guint has_shade_func : 1;
+  guint has_move_func : 1;
+  guint has_resize_func : 1;
+  guint has_fullscreen_func : 1;
+  
+  /* Weird "_NET_WM_STATE_MODAL" flag */
+  guint wm_state_modal : 1;
+
+  /* TRUE if the client forced these on */
+  guint wm_state_skip_taskbar : 1;
+  guint wm_state_skip_pager : 1;
+
+  /* Computed whether to skip taskbar or not */
+  guint skip_taskbar : 1;
+  guint skip_pager : 1;
+
+  /* TRUE if client set these */
+  guint wm_state_above : 1;
+  guint wm_state_below : 1;
+
+  /* EWHH demands attention flag */
+  guint wm_state_demands_attention : 1;
+  
+  /* this flag tracks receipt of focus_in focus_out and
+   * determines whether we draw the focus
+   */
+  guint has_focus : 1;
+  
+  /* Have we placed this window? */
+  guint placed : 1;
+
+  /* Must we force_save_user_window_placement? */
+  guint force_save_user_rect : 1;
+
+  /* Is this not a transient of the focus window which is being denied focus? */
+  guint denied_focus_and_not_transient : 1;
+
+  /* Has this window not ever been shown yet? */
+  guint showing_for_first_time : 1;
+
+  /* Are we in meta_window_free()? */
+  guint unmanaging : 1;
+
+  /* Are we in meta_window_new()? */
+  guint constructing : 1;
+  
+  /* Are we in the various queues? (Bitfield: see META_WINDOW_IS_IN_QUEUE) */
+  guint is_in_queues : NUMBER_OF_QUEUES;
+ 
+  /* Used by keybindings.c */
+  guint keys_grabbed : 1;     /* normal keybindings grabbed */
+  guint grab_on_frame : 1;    /* grabs are on the frame */
+  guint all_keys_grabbed : 1; /* AnyKey grabbed */
+  
+  /* Set if the reason for unmanaging the window is that
+   * it was withdrawn
+   */
+  guint withdrawn : 1;
+
+  /* TRUE if constrain_position should calc placement.
+   * only relevant if !window->placed
+   */
+  guint calc_placement : 1;
+
+  /* Transient parent is a root window */
+  guint transient_parent_is_root_window : 1;
+
+  /* Info on which props we got our attributes from */
+  guint using_net_wm_name              : 1; /* vs. plain wm_name */
+  guint using_net_wm_visible_name      : 1; /* tracked so we can clear it */
+  guint using_net_wm_icon_name         : 1; /* vs. plain wm_icon_name */
+  guint using_net_wm_visible_icon_name : 1; /* tracked so we can clear it */
+
+  /* has a shape mask */
+  guint has_shape : 1;
+
+  /* icon props have changed */
+  guint need_reread_icon : 1;
+  
+  /* if TRUE, window was maximized at start of current grab op */
+  guint shaken_loose : 1;
+
+  /* if TRUE we have a grab on the focus click buttons */
+  guint have_focus_click_grab : 1;
+
+  /* if TRUE, application is buggy and SYNC resizing is turned off */
+  guint disable_sync : 1;
+
+  /* Note: can be NULL */
+  GSList *struts;
+
+#ifdef HAVE_XSYNC
+  /* XSync update counter */
+  XSyncCounter sync_request_counter;
+  guint sync_request_serial;
+  GTimeVal sync_request_time;
+#endif
+  
+  /* Number of UnmapNotify that are caused by us, if
+   * we get UnmapNotify with none pending then the client
+   * is withdrawing the window.
+   */
+  int unmaps_pending;
+
+  /* set to the most recent user-interaction event timestamp that we
+     know about for this window */
+  guint32 net_wm_user_time;
+
+  /* window that gets updated net_wm_user_time values */
+  Window user_time_window;
+  
+  /* The size we set the window to last (i.e. what we believe
+   * to be its actual size on the server). The x, y are
+   * the actual server-side x,y so are relative to the frame
+   * (meaning that they just hold the frame width and height) 
+   * or the root window (meaning they specify the location
+   * of the top left of the inner window) as appropriate.
+   */
+  MetaRectangle rect;
+
+  /* The geometry to restore when we unmaximize.  The position is in
+   * root window coords, even if there's a frame, which contrasts with
+   * window->rect above.  Note that this gives the position and size
+   * of the client window (i.e. ignoring the frame).
+   */
+  MetaRectangle saved_rect;
+
+  /* This is the geometry the window had after the last user-initiated
+   * move/resize operations. We use this whenever we are moving the
+   * implicitly (for example, if we move to avoid a panel, we can snap
+   * back to this position if the panel moves again).  Note that this
+   * gives the position and size of the client window (i.e. ignoring
+   * the frame).
+   *
+   * Position valid if user_has_moved, size valid if user_has_resized
+   *
+   * Position always in root coords, unlike window->rect.
+   */
+  MetaRectangle user_rect;
+  
+  /* Requested geometry */
+  int border_width;
+  /* x/y/w/h here get filled with ConfigureRequest values */
+  XSizeHints size_hints;
+
+  /* Managed by stack.c */
+  MetaStackLayer layer;
+  int stack_position; /* see comment in stack.h */
+  
+  /* Current dialog open for this window */
+  int dialog_pid;
+
+  /* maintained by group.c */
+  MetaGroup *group;
+};
+
+/* These differ from window->has_foo_func in that they consider
+ * the dynamic window state such as "maximized", not just the
+ * window's type
+ */
+#define META_WINDOW_MAXIMIZED(w)       ((w)->maximized_horizontally && \
+                                        (w)->maximized_vertically)
+#define META_WINDOW_MAXIMIZED_VERTICALLY(w)    ((w)->maximized_vertically)
+#define META_WINDOW_MAXIMIZED_HORIZONTALLY(w)  ((w)->maximized_horizontally)
+#define META_WINDOW_ALLOWS_MOVE(w)     ((w)->has_move_func && !(w)->fullscreen)
+#define META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS(w)   ((w)->has_resize_func && !META_WINDOW_MAXIMIZED (w) && !(w)->fullscreen && !(w)->shaded)
+#define META_WINDOW_ALLOWS_RESIZE(w)   (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) &&                \
+                                        (((w)->size_hints.min_width < (w)->size_hints.max_width) ||  \
+                                         ((w)->size_hints.min_height < (w)->size_hints.max_height)))
+#define META_WINDOW_ALLOWS_HORIZONTAL_RESIZE(w) (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) && (w)->size_hints.min_width < (w)->size_hints.max_width)
+#define META_WINDOW_ALLOWS_VERTICAL_RESIZE(w)   (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) && (w)->size_hints.min_height < (w)->size_hints.max_height)
+
+MetaWindow* meta_window_new                (MetaDisplay *display,
+                                            Window       xwindow,
+                                            gboolean     must_be_viewable);
+MetaWindow* meta_window_new_with_attrs     (MetaDisplay *display,
+                                            Window       xwindow,
+                                            gboolean     must_be_viewable,
+                                            XWindowAttributes *attrs);
+void        meta_window_free               (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_calc_showing       (MetaWindow  *window);
+void        meta_window_queue              (MetaWindow  *window,
+                                            guint queuebits);
+void        meta_window_minimize           (MetaWindow  *window);
+void        meta_window_unminimize         (MetaWindow  *window);
+void        meta_window_maximize           (MetaWindow        *window,
+                                            MetaMaximizeFlags  directions);
+void        meta_window_maximize_internal  (MetaWindow        *window,
+                                            MetaMaximizeFlags  directions,
+                                            MetaRectangle     *saved_rect);
+void        meta_window_unmaximize         (MetaWindow        *window,
+                                            MetaMaximizeFlags  directions);
+void        meta_window_make_above         (MetaWindow  *window);
+void        meta_window_unmake_above       (MetaWindow  *window);
+void        meta_window_shade              (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_unshade            (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_change_workspace   (MetaWindow  *window,
+                                            MetaWorkspace *workspace);
+void        meta_window_stick              (MetaWindow  *window);
+void        meta_window_unstick            (MetaWindow  *window);
+
+void        meta_window_activate           (MetaWindow  *window,
+                                            guint32      current_time);
+void        meta_window_activate_with_workspace  (MetaWindow    *window,
+                                                  guint32        current_time,
+                                                  MetaWorkspace *workspace);   
+void        meta_window_make_fullscreen_internal (MetaWindow    *window);
+void        meta_window_make_fullscreen    (MetaWindow  *window);
+void        meta_window_unmake_fullscreen  (MetaWindow  *window);
+void        meta_window_update_fullscreen_monitors (MetaWindow    *window,
+                                                    unsigned long  top,
+                                                    unsigned long  bottom,
+                                                    unsigned long  left,
+                                                    unsigned long  right);
+
+/* args to move are window pos, not frame pos */
+void        meta_window_move               (MetaWindow  *window,
+                                            gboolean     user_op,
+                                            int          root_x_nw,
+                                            int          root_y_nw);
+void        meta_window_resize             (MetaWindow  *window,
+                                            gboolean     user_op,
+                                            int          w,
+                                            int          h);
+void        meta_window_move_resize        (MetaWindow  *window,
+                                            gboolean     user_op,
+                                            int          root_x_nw,
+                                            int          root_y_nw,
+                                            int          w,
+                                            int          h);
+void        meta_window_resize_with_gravity (MetaWindow  *window,
+                                             gboolean     user_op,
+                                             int          w,
+                                             int          h,
+                                             int          gravity);
+
+
+/* Return whether the window would be showing if we were on its workspace */
+gboolean    meta_window_showing_on_its_workspace (MetaWindow *window);
+
+/* Return whether the window should be currently mapped */
+gboolean    meta_window_should_be_showing   (MetaWindow  *window);
+
+/* See warning in window.c about this function */
+gboolean    __window_is_terminal (MetaWindow *window);
+
+void        meta_window_update_struts      (MetaWindow  *window);
+
+/* this gets root coords */
+void        meta_window_get_position       (MetaWindow  *window,
+                                            int         *x,
+                                            int         *y);
+
+/* Gets root coords for x, y, width & height of client window; uses
+ * meta_window_get_position for x & y.
+ */
+void        meta_window_get_client_root_coords (MetaWindow    *window,
+                                                MetaRectangle *rect);
+
+/* gets position we need to set to stay in current position,
+ * assuming position will be gravity-compensated. i.e.
+ * this is the position a client would send in a configure
+ * request.
+ */
+void        meta_window_get_gravity_position (MetaWindow  *window,
+                                              int          gravity,
+                                              int         *x,
+                                              int         *y);
+/* Get geometry for saving in the session; x/y are gravity
+ * position, and w/h are in resize inc above the base size.
+ */
+void        meta_window_get_geometry         (MetaWindow  *window,
+                                              int         *x,
+                                              int         *y,
+                                              int         *width,
+                                              int         *height);
+void        meta_window_get_outer_rect       (const MetaWindow *window,
+                                              MetaRectangle    *rect);
+void        meta_window_get_xor_rect         (MetaWindow          *window,
+                                              const MetaRectangle *grab_wireframe_rect,
+                                              MetaRectangle       *xor_rect);
+void        meta_window_begin_wireframe (MetaWindow *window);
+void        meta_window_update_wireframe (MetaWindow *window,
+                                          int         x,
+                                          int         y,
+                                          int         width,
+                                          int         height);
+void        meta_window_end_wireframe (MetaWindow *window);
+
+void        meta_window_delete             (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_kill               (MetaWindow  *window);
+void        meta_window_focus              (MetaWindow  *window,
+                                            guint32      timestamp);
+void        meta_window_raise              (MetaWindow  *window);
+void        meta_window_lower              (MetaWindow  *window);
+
+void        meta_window_update_unfocused_button_grabs (MetaWindow *window);
+
+/* Sends a client message */
+void meta_window_send_icccm_message (MetaWindow *window,
+                                     Atom        atom,
+                                     guint32     timestamp);
+
+
+void     meta_window_move_resize_request(MetaWindow *window,
+                                         guint       value_mask,
+                                         int         gravity,
+                                         int         x,
+                                         int         y,
+                                         int         width,
+                                         int         height);
+gboolean meta_window_configure_request (MetaWindow *window,
+                                        XEvent     *event);
+gboolean meta_window_property_notify   (MetaWindow *window,
+                                        XEvent     *event);
+gboolean meta_window_client_message    (MetaWindow *window,
+                                        XEvent     *event);
+gboolean meta_window_notify_focus      (MetaWindow *window,
+                                        XEvent     *event);
+
+void     meta_window_set_current_workspace_hint (MetaWindow *window);
+
+unsigned long meta_window_get_net_wm_desktop (MetaWindow *window);
+
+void meta_window_show_menu (MetaWindow *window,
+                            int         root_x,
+                            int         root_y,
+                            int         button,
+                            guint32     timestamp);
+
+gboolean meta_window_titlebar_is_onscreen    (MetaWindow *window);
+void     meta_window_shove_titlebar_onscreen (MetaWindow *window);
+
+void meta_window_set_gravity (MetaWindow *window,
+                              int         gravity);
+
+void meta_window_handle_mouse_grab_op_event (MetaWindow *window,
+                                             XEvent     *event);
+
+GList* meta_window_get_workspaces (MetaWindow *window);
+
+gboolean meta_window_located_on_workspace (MetaWindow    *window,
+                                           MetaWorkspace *workspace);
+
+void meta_window_get_work_area_current_xinerama (MetaWindow    *window,
+                                                 MetaRectangle *area);
+void meta_window_get_work_area_for_xinerama     (MetaWindow    *window,
+                                                 int            which_xinerama,
+                                                 MetaRectangle *area);
+void meta_window_get_work_area_all_xineramas    (MetaWindow    *window,
+                                                 MetaRectangle *area);
+
+
+gboolean meta_window_same_application (MetaWindow *window,
+                                       MetaWindow *other_window);
+
+#define META_WINDOW_IN_NORMAL_TAB_CHAIN_TYPE(w) \
+  ((w)->type != META_WINDOW_DOCK && (w)->type != META_WINDOW_DESKTOP)
+#define META_WINDOW_IN_NORMAL_TAB_CHAIN(w) \
+  (((w)->input || (w)->take_focus ) && META_WINDOW_IN_NORMAL_TAB_CHAIN_TYPE (w) && (!(w)->skip_taskbar))
+#define META_WINDOW_IN_DOCK_TAB_CHAIN(w) \
+  (((w)->input || (w)->take_focus) && (! META_WINDOW_IN_NORMAL_TAB_CHAIN_TYPE (w) || (w)->skip_taskbar))
+#define META_WINDOW_IN_GROUP_TAB_CHAIN(w, g) \
+  (((w)->input || (w)->take_focus) && (!g || meta_window_get_group(w)==g))
+
+void meta_window_refresh_resize_popup (MetaWindow *window);
+
+void meta_window_free_delete_dialog (MetaWindow *window);
+
+void     meta_window_foreach_transient        (MetaWindow            *window,
+                                               MetaWindowForeachFunc  func,
+                                               void                  *data);
+gboolean meta_window_is_ancestor_of_transient (MetaWindow            *window,
+                                               MetaWindow            *transient);
+void     meta_window_foreach_ancestor         (MetaWindow            *window,
+                                               MetaWindowForeachFunc  func,
+                                               void                  *data);
+MetaWindow* meta_window_find_root_ancestor    (MetaWindow *window);
+
+
+void meta_window_begin_grab_op (MetaWindow *window,
+                                MetaGrabOp  op,
+                                gboolean    frame_action,
+                                guint32     timestamp);
+
+void meta_window_update_keyboard_resize (MetaWindow *window,
+                                         gboolean    update_cursor);
+void meta_window_update_keyboard_move   (MetaWindow *window);
+
+void meta_window_update_layer (MetaWindow *window);
+
+gboolean meta_window_get_icon_geometry (MetaWindow    *window,
+                                        MetaRectangle *rect);
+
+const char* meta_window_get_startup_id (MetaWindow *window);
+
+void meta_window_recalc_features    (MetaWindow *window);
+void meta_window_recalc_window_type (MetaWindow *window);
+
+void meta_window_stack_just_below (MetaWindow *window,
+                                   MetaWindow *below_this_one);
+
+void meta_window_set_user_time (MetaWindow *window,
+                                guint32     timestamp);
+
+void meta_window_set_demands_attention (MetaWindow *window);
+
+void meta_window_unset_demands_attention (MetaWindow *window);
+
+void meta_window_update_icon_now (MetaWindow *window);
+
+void meta_window_update_role (MetaWindow *window);
+void meta_window_update_net_wm_type (MetaWindow *window);
+
+#endif
diff --git a/src/core/window-props.c b/src/core/window-props.c
new file mode 100644
index 00000000..b7b3e12d
--- /dev/null
+++ b/src/core/window-props.c
@@ -0,0 +1,1553 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file window-props.c    MetaWindow property handling
+ *
+ * A system which can inspect sets of properties of given windows
+ * and take appropriate action given their values.
+ *
+ * Note that all the meta_window_reload_propert* functions require a
+ * round trip to the server.
+ *
+ * The guts of this system are in meta_display_init_window_prop_hooks().
+ * Reading this function will give you insight into how this all fits
+ * together.
+ */
+
+/* 
+ * Copyright (C) 2001, 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * Copyright (C) 2009 Thomas Thurman
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _SVID_SOURCE /* for gethostname() */
+
+#include <config.h>
+#include "window-props.h"
+#include "errors.h"
+#include "xprops.h"
+#include "frame-private.h"
+#include "group.h"
+#include <X11/Xatom.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <pwd.h>
+
+#ifdef HAVE_GTOP
+#include <glibtop/procuid.h>
+#include <errno.h>
+#include <pwd.h>
+#endif /* HAVE_GTOP */
+
+#ifndef HOST_NAME_MAX
+/* Solaris headers apparently don't define this so do so manually; #326745 */
+#define HOST_NAME_MAX 255
+#endif
+
+typedef void (* ReloadValueFunc) (MetaWindow    *window,
+                                  MetaPropValue *value,
+                                  gboolean       initial);
+
+typedef struct MetaWindowPropHooks
+{
+  Atom              property;
+  MetaPropValueType type;
+  ReloadValueFunc   reload_func;
+} MetaWindowPropHooks;
+
+static MetaWindowPropHooks* find_hooks (MetaDisplay *display,
+                                        Atom         property);
+
+
+void
+meta_window_reload_property (MetaWindow *window,
+                             Atom        property,
+                             gboolean    initial)
+{
+  meta_window_reload_properties (window, &property, 1, initial);
+}
+
+void
+meta_window_reload_properties (MetaWindow *window,
+                               const Atom *properties,
+                               int         n_properties,
+                               gboolean    initial)
+{
+  meta_window_reload_properties_from_xwindow (window,
+                                              window->xwindow,
+                                              properties,
+                                              n_properties,
+                                              initial);
+}
+
+void
+meta_window_reload_property_from_xwindow (MetaWindow *window,
+                                          Window      xwindow,
+                                          Atom        property,
+                                          gboolean    initial)
+{
+  meta_window_reload_properties_from_xwindow (window, xwindow, &property, 1,
+                                              initial);
+}
+
+void
+meta_window_reload_properties_from_xwindow (MetaWindow *window,
+                                            Window      xwindow,
+                                            const Atom *properties,
+                                            int         n_properties,
+                                            gboolean    initial)
+{
+  int i;
+  MetaPropValue *values;
+
+  g_return_if_fail (properties != NULL);
+  g_return_if_fail (n_properties > 0);
+  
+  values = g_new0 (MetaPropValue, n_properties);
+
+  for (i=0; i<n_properties; i++)
+    {
+      MetaWindowPropHooks *hooks = find_hooks (window->display,
+                                               properties[i]);
+    
+      if (!hooks || hooks->type == META_PROP_VALUE_INVALID)
+        {
+          values[i].type = META_PROP_VALUE_INVALID;
+          values[i].atom = None;
+        }
+      else
+        {
+          values[i].type = hooks->type;
+          values[i].atom = properties[i];
+        }
+    }
+  
+  meta_prop_get_values (window->display, xwindow,
+                        values, n_properties);
+
+  for (i=0; i<n_properties; i++)
+    {
+      MetaWindowPropHooks *hooks = find_hooks (window->display,
+                                               properties[i]);
+
+      if (hooks && hooks->reload_func != NULL)
+        (* hooks->reload_func) (window, &values[i], initial);
+    }
+
+  meta_prop_free_values (values, n_properties);
+  
+  g_free (values);
+}
+
+static void
+reload_wm_client_machine (MetaWindow    *window,
+                          MetaPropValue *value,
+                          gboolean       initial)
+{
+  g_free (window->wm_client_machine);
+  window->wm_client_machine = NULL;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    window->wm_client_machine = g_strdup (value->v.str);
+
+  meta_verbose ("Window has client machine \"%s\"\n",
+                window->wm_client_machine ? window->wm_client_machine : "unset");
+}
+
+static void
+complain_about_broken_client (MetaWindow    *window,
+                              MetaPropValue *value,
+                              gboolean       initial)
+{
+  meta_warning ("Broken client! Window %s changed client leader window or SM client ID\n",
+                window->desc);
+}
+
+static void
+reload_net_wm_window_type (MetaWindow    *window,
+                           MetaPropValue *value,
+                           gboolean       initial)
+{
+  meta_window_update_net_wm_type (window);
+}
+
+static void
+reload_icon (MetaWindow    *window,
+             Atom           atom)
+{
+  meta_icon_cache_property_changed (&window->icon_cache,
+                                    window->display,
+                                    atom);
+  meta_window_queue(window, META_QUEUE_UPDATE_ICON);
+}
+
+static void
+reload_net_wm_icon (MetaWindow    *window,
+                    MetaPropValue *value,
+                    gboolean       initial)
+{
+  reload_icon (window, window->display->atom__NET_WM_ICON);
+}
+
+static void
+reload_kwm_win_icon (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  reload_icon (window, window->display->atom__KWM_WIN_ICON);
+}
+
+static void
+reload_struts (MetaWindow    *window,
+               MetaPropValue *value,
+               gboolean       initial)
+{
+  meta_window_update_struts (window);
+}
+
+static void
+reload_wm_window_role (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+{
+  meta_window_update_role (window);
+}
+
+static void
+reload_net_wm_pid (MetaWindow    *window,
+                   MetaPropValue *value,
+                   gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      gulong cardinal = (int) value->v.cardinal;
+      
+      if (cardinal <= 0)
+        meta_warning (_("Application set a bogus _NET_WM_PID %lu\n"),
+                      cardinal);
+      else
+        {
+          window->net_wm_pid = cardinal;
+          meta_verbose ("Window has _NET_WM_PID %d\n",
+                        window->net_wm_pid);
+        }
+    }
+}
+
+static void
+reload_net_wm_user_time (MetaWindow    *window,
+                         MetaPropValue *value,
+                         gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      gulong cardinal = value->v.cardinal;
+      meta_window_set_user_time (window, cardinal);
+    }
+}
+
+static void
+reload_net_wm_user_time_window (MetaWindow    *window,
+                                MetaPropValue *value,
+                                gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      /* Unregister old NET_WM_USER_TIME_WINDOW */
+      if (window->user_time_window != None)
+        {
+          /* See the comment to the meta_display_register_x_window call below. */
+          meta_display_unregister_x_window (window->display,
+                                            window->user_time_window);
+          /* Don't get events on not-managed windows */
+          XSelectInput (window->display->xdisplay,
+                        window->user_time_window,
+                        NoEventMask);
+        }
+
+
+      /* Obtain the new NET_WM_USER_TIME_WINDOW and register it */
+      window->user_time_window = value->v.xwindow;
+      if (window->user_time_window != None)
+        {
+          /* Kind of a hack; display.c:event_callback() ignores events
+           * for unknown windows.  We make window->user_time_window
+           * known by registering it with window (despite the fact
+           * that window->xwindow is already registered with window).
+           * This basically means that property notifies to either the
+           * window->user_time_window or window->xwindow will be
+           * treated identically and will result in functions for
+           * window being called to update it.  Maybe we should ignore
+           * any property notifies to window->user_time_window other
+           * than atom__NET_WM_USER_TIME ones, but I just don't care
+           * and it's not specified in the spec anyway.
+           */
+          meta_display_register_x_window (window->display,
+                                          &window->user_time_window,
+                                          window);
+          /* Just listen for property notify events */
+          XSelectInput (window->display->xdisplay,
+                        window->user_time_window,
+                        PropertyChangeMask);
+
+          /* Manually load the _NET_WM_USER_TIME field from the given window
+           * at this time as well.  If the user_time_window ever broadens in
+           * scope, we'll probably want to load all relevant properties here.
+           */
+          meta_window_reload_property_from_xwindow (
+            window,
+            window->user_time_window,
+            window->display->atom__NET_WM_USER_TIME,
+            initial);
+        }
+    }
+}
+
+/**
+ * Finds who owns a particular process, if we can.
+ *
+ * \param process  The process's ID.
+ * \result         Set to the ID of the user, if we returned true.
+ *
+ * \result  True if we could tell.
+ */
+static gboolean
+owner_of_process (pid_t process, uid_t *result)
+{
+#ifdef HAVE_GTOP
+  glibtop_proc_uid process_details;
+      
+  glibtop_get_proc_uid (&process_details, process);
+
+  *result = process_details.uid;
+  return TRUE;
+#else
+  /* I don't know, maybe we could do something hairy like see whether
+   * /proc/$PID exists and who owns it, in case they have procfs.
+   */
+  return FALSE;
+#endif /* HAVE_GTOP */
+}
+
+#define MAX_TITLE_LENGTH 512
+
+/**
+ * Called by set_window_title and set_icon_title to set the value of
+ * *target to title. It required and atom is set, it will update the
+ * appropriate property.
+ *
+ * Returns TRUE if a new title was set.
+ */
+static gboolean
+set_title_text (MetaWindow  *window,
+                gboolean     previous_was_modified,
+                const char  *title,
+                Atom         atom,
+                char       **target)
+{
+  char hostname[HOST_NAME_MAX + 1];
+  gboolean modified = FALSE;
+  
+  if (!target)
+    return FALSE;
+  
+  g_free (*target);
+  
+  if (!title)
+    *target = g_strdup ("");
+  else if (g_utf8_strlen (title, MAX_TITLE_LENGTH + 1) > MAX_TITLE_LENGTH)
+    {
+      *target = meta_g_utf8_strndup (title, MAX_TITLE_LENGTH);
+      modified = TRUE;
+    }
+  /* if WM_CLIENT_MACHINE indicates this machine is on a remote host
+   * let's place that hostname in the title */
+  else if (window->wm_client_machine &&
+           !gethostname (hostname, HOST_NAME_MAX + 1) &&
+           strcmp (hostname, window->wm_client_machine))
+    {
+      /* Translators: the title of a window from another machine */
+      *target = g_strdup_printf (_("%s (on %s)"),
+                      title, window->wm_client_machine);
+      modified = TRUE;
+    }
+  else if (window->net_wm_pid != -1)
+    {
+      /* We know the process which owns this window; perhaps we can
+       * find out the name of its owner (if it's not us).
+       */
+
+      char *found_name = NULL;
+
+      uid_t window_owner = 0;
+      gboolean window_owner_known =
+              owner_of_process (window->net_wm_pid, &window_owner);
+
+      /* Assume a window with unknown ownership is ours (call it usufruct!) */
+      gboolean window_owner_is_us =
+              !window_owner_known || window_owner==getuid ();
+      
+      if (window_owner_is_us)
+        {
+          /* we own it, so fall back to the simple case */
+          *target = g_strdup (title);
+        }
+      else
+        {
+          /* it belongs to window_owner.  So what's their name? */
+
+          if (window_owner==0)
+            {
+              /* Simple case-- don't bother to look it up.  It's root. */
+              *target = g_strdup_printf (_("%s (as superuser)"),
+                                         title);
+            }
+          else
+            {
+              /* Okay, let's look up the name. */
+              struct passwd *pwd;
+
+              errno = 0;
+              pwd = getpwuid (window_owner);
+              if (errno==0 && pwd!=NULL)
+                {
+                  found_name = pwd->pw_name;
+                }
+            
+              if (found_name)
+                /* Translators: the title of a window owned by another user
+                 * on this machine */
+                *target = g_strdup_printf (_("%s (as %s)"),
+                                           title,
+                                           found_name);
+              else
+                /* Translators: the title of a window owned by another user
+                 * on this machine, whose name we don't know */
+                *target = g_strdup_printf (_("%s (as another user)"),
+                                           title);
+            }
+          /* either way we changed it */
+          modified = TRUE;
+              
+        }
+    }
+  else
+    *target = g_strdup (title);
+
+  if (modified && atom != None)
+    meta_prop_set_utf8_string_hint (window->display,
+                                    window->xwindow,
+                                    atom, *target);
+
+  /* Bug 330671 -- Don't forget to clear _NET_WM_VISIBLE_(ICON_)NAME */
+  if (!modified && previous_was_modified)
+    {
+      meta_error_trap_push (window->display);
+      XDeleteProperty (window->display->xdisplay,
+                       window->xwindow,
+                       atom);
+      meta_error_trap_pop (window->display, FALSE);
+    }
+
+  return modified;
+}
+
+static void
+set_window_title (MetaWindow *window,
+                  const char *title)
+{
+  char *str;
+ 
+  gboolean modified =
+    set_title_text (window,
+                    window->using_net_wm_visible_name,
+                    title,
+                    window->display->atom__NET_WM_VISIBLE_NAME,
+                    &window->title);
+  window->using_net_wm_visible_name = modified;
+  
+  /* strndup is a hack since GNU libc has broken %.10s */
+  str = g_strndup (window->title, 10);
+  g_free (window->desc);
+  window->desc = g_strdup_printf ("0x%lx (%s)", window->xwindow, str);
+  g_free (str);
+
+  if (window->frame)
+    meta_ui_set_frame_title (window->screen->ui,
+                             window->frame->xwindow,
+                             window->title);
+}
+
+static void
+reload_net_wm_name (MetaWindow    *window,
+                    MetaPropValue *value,
+                    gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      set_window_title (window, value->v.str);
+      window->using_net_wm_name = TRUE;
+
+      meta_verbose ("Using _NET_WM_NAME for new title of %s: \"%s\"\n",
+                    window->desc, window->title);
+    }
+  else
+    {
+      set_window_title (window, NULL);
+      window->using_net_wm_name = FALSE;
+      if (!initial)
+        meta_window_reload_property (window, XA_WM_NAME, FALSE);
+    }
+}
+
+static void
+reload_wm_name (MetaWindow    *window,
+                MetaPropValue *value,
+                gboolean       initial)
+{
+  if (window->using_net_wm_name)
+    {
+      meta_verbose ("Ignoring WM_NAME \"%s\" as _NET_WM_NAME is set\n",
+                    value->v.str);
+      return;
+    }
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      set_window_title (window, value->v.str);
+
+      meta_verbose ("Using WM_NAME for new title of %s: \"%s\"\n",
+                    window->desc, window->title);
+    }
+  else
+    {
+      set_window_title (window, NULL);
+    }
+}
+
+static void
+set_icon_title (MetaWindow *window,
+                const char *title)
+{
+  gboolean modified =
+    set_title_text (window,
+                    window->using_net_wm_visible_icon_name,
+                    title,
+                    window->display->atom__NET_WM_VISIBLE_ICON_NAME,
+                    &window->icon_name);
+  window->using_net_wm_visible_icon_name = modified;
+}
+
+static void
+reload_net_wm_icon_name (MetaWindow    *window,
+                         MetaPropValue *value,
+                         gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      set_icon_title (window, value->v.str);
+      window->using_net_wm_icon_name = TRUE;
+
+      meta_verbose ("Using _NET_WM_ICON_NAME for new title of %s: \"%s\"\n",
+                    window->desc, window->title);
+    }
+  else
+    {
+      set_icon_title (window, NULL);
+      window->using_net_wm_icon_name = FALSE;
+      if (!initial)
+        meta_window_reload_property (window, XA_WM_ICON_NAME, FALSE);
+    }
+}
+
+static void
+reload_wm_icon_name (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  if (window->using_net_wm_icon_name)
+    {
+      meta_verbose ("Ignoring WM_ICON_NAME \"%s\" as _NET_WM_ICON_NAME is set\n",
+                    value->v.str);
+      return;
+    }
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      set_icon_title (window, value->v.str);
+      
+      meta_verbose ("Using WM_ICON_NAME for new title of %s: \"%s\"\n",
+                    window->desc, window->title);
+    }
+  else
+    {
+      set_icon_title (window, NULL);
+    }
+}
+
+static void
+reload_net_wm_state (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  int i;
+
+  /* We know this is only an initial window creation,
+   * clients don't change the property.
+   */
+
+  if (!initial) {
+    /* no, they DON'T change the property */
+    meta_verbose ("Ignoring _NET_WM_STATE: we should be the one who set "
+                  "the property in the first place\n");
+    return;
+  }
+
+  window->shaded = FALSE;
+  window->maximized_horizontally = FALSE;
+  window->maximized_vertically = FALSE;
+  window->fullscreen = FALSE;
+  window->wm_state_modal = FALSE;
+  window->wm_state_skip_taskbar = FALSE;
+  window->wm_state_skip_pager = FALSE;
+  window->wm_state_above = FALSE;
+  window->wm_state_below = FALSE;
+  window->wm_state_demands_attention = FALSE;
+
+  if (value->type == META_PROP_VALUE_INVALID)
+    return;
+
+  i = 0;
+  while (i < value->v.atom_list.n_atoms)
+    {
+      if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_SHADED)
+        window->shaded = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_MAXIMIZED_HORZ)
+        window->maximize_horizontally_after_placement = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_MAXIMIZED_VERT)
+        window->maximize_vertically_after_placement = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_HIDDEN)
+        window->minimize_after_placement = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_MODAL)
+        window->wm_state_modal = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_SKIP_TASKBAR)
+        window->wm_state_skip_taskbar = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_SKIP_PAGER)
+        window->wm_state_skip_pager = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_FULLSCREEN)
+        window->fullscreen_after_placement = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_ABOVE)
+        window->wm_state_above = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_BELOW)
+        window->wm_state_below = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_DEMANDS_ATTENTION)
+        window->wm_state_demands_attention = TRUE;
+      else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_STICKY)
+        window->on_all_workspaces = TRUE;
+
+      ++i;
+    }
+
+  meta_verbose ("Reloaded _NET_WM_STATE for %s\n",
+                window->desc);
+
+  meta_window_recalc_window_type (window);
+}
+
+static void
+reload_mwm_hints (MetaWindow    *window,
+                  MetaPropValue *value,
+                  gboolean       initial)
+{
+  MotifWmHints *hints;
+
+  window->mwm_decorated = TRUE;
+  window->mwm_border_only = FALSE;
+  window->mwm_has_close_func = TRUE;
+  window->mwm_has_minimize_func = TRUE;
+  window->mwm_has_maximize_func = TRUE;
+  window->mwm_has_move_func = TRUE;
+  window->mwm_has_resize_func = TRUE;
+
+  if (value->type == META_PROP_VALUE_INVALID)
+    {
+      meta_verbose ("Window %s has no MWM hints\n", window->desc);
+      meta_window_recalc_features (window);
+      return;
+    }
+
+  hints = value->v.motif_hints;
+
+  /* We support those MWM hints deemed non-stupid */
+
+  meta_verbose ("Window %s has MWM hints\n",
+                window->desc);
+
+  if (hints->flags & MWM_HINTS_DECORATIONS)
+    {
+      meta_verbose ("Window %s sets MWM_HINTS_DECORATIONS 0x%lx\n",
+          window->desc, hints->decorations);
+
+      if (hints->decorations == 0)
+        window->mwm_decorated = FALSE;
+      /* some input methods use this */
+      else if (hints->decorations == MWM_DECOR_BORDER)
+        window->mwm_border_only = TRUE;
+    }
+  else
+    meta_verbose ("Decorations flag unset\n");
+
+  if (hints->flags & MWM_HINTS_FUNCTIONS)
+    {
+      gboolean toggle_value;
+
+      meta_verbose ("Window %s sets MWM_HINTS_FUNCTIONS 0x%lx\n",
+                    window->desc, hints->functions);
+
+      /* If _ALL is specified, then other flags indicate what to turn off;
+       * if ALL is not specified, flags are what to turn on.
+       * at least, I think so
+       */
+
+      if ((hints->functions & MWM_FUNC_ALL) == 0)
+        {
+          toggle_value = TRUE;
+
+          meta_verbose ("Window %s disables all funcs then reenables some\n",
+                        window->desc);
+          window->mwm_has_close_func = FALSE;
+          window->mwm_has_minimize_func = FALSE;
+          window->mwm_has_maximize_func = FALSE;
+          window->mwm_has_move_func = FALSE;
+          window->mwm_has_resize_func = FALSE;
+        }
+      else
+        {
+          meta_verbose ("Window %s enables all funcs then disables some\n",
+                        window->desc);
+          toggle_value = FALSE;
+        }
+
+      if ((hints->functions & MWM_FUNC_CLOSE) != 0)
+        {
+          meta_verbose ("Window %s toggles close via MWM hints\n",
+                        window->desc);
+          window->mwm_has_close_func = toggle_value;
+        }
+      if ((hints->functions & MWM_FUNC_MINIMIZE) != 0)
+        {
+          meta_verbose ("Window %s toggles minimize via MWM hints\n",
+                        window->desc);
+          window->mwm_has_minimize_func = toggle_value;
+        }
+      if ((hints->functions & MWM_FUNC_MAXIMIZE) != 0)
+        {
+          meta_verbose ("Window %s toggles maximize via MWM hints\n",
+                        window->desc);
+          window->mwm_has_maximize_func = toggle_value;
+        }
+      if ((hints->functions & MWM_FUNC_MOVE) != 0)
+        {
+          meta_verbose ("Window %s toggles move via MWM hints\n",
+                        window->desc);
+          window->mwm_has_move_func = toggle_value;
+        }
+      if ((hints->functions & MWM_FUNC_RESIZE) != 0)
+        {
+          meta_verbose ("Window %s toggles resize via MWM hints\n",
+                        window->desc);
+          window->mwm_has_resize_func = toggle_value;
+        }
+    }
+  else
+    meta_verbose ("Functions flag unset\n");
+
+  meta_window_recalc_features (window);
+  
+  /* We do all this anyhow at the end of meta_window_new() */
+  if (!window->constructing)
+    {
+      if (window->decorated)
+        meta_window_ensure_frame (window);
+      else
+        meta_window_destroy_frame (window);
+      
+      meta_window_queue (window,
+                         META_QUEUE_MOVE_RESIZE |
+                         /* because ensure/destroy frame may unmap: */
+                         META_QUEUE_CALC_SHOWING);
+    }
+}
+
+static void
+reload_wm_class (MetaWindow    *window,
+                 MetaPropValue *value,
+                 gboolean       initial)
+{
+  if (window->res_class)
+    g_free (window->res_class);
+  if (window->res_name)
+    g_free (window->res_name);
+
+  window->res_class = NULL;
+  window->res_name = NULL;
+
+  if (value->type != META_PROP_VALUE_INVALID)
+    { 
+      if (value->v.class_hint.res_name)
+        window->res_name = g_strdup (value->v.class_hint.res_name);
+
+      if (value->v.class_hint.res_class)
+        window->res_class = g_strdup (value->v.class_hint.res_class);
+    }
+
+  meta_verbose ("Window %s class: '%s' name: '%s'\n",
+      window->desc,
+      window->res_class ? window->res_class : "none",
+      window->res_name ? window->res_name : "none");
+}
+
+static void
+reload_net_wm_desktop (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      window->initial_workspace_set = TRUE;
+      window->initial_workspace = value->v.cardinal;
+      meta_topic (META_DEBUG_PLACEMENT,
+                  "Read initial workspace prop %d for %s\n",
+                  window->initial_workspace, window->desc);
+    }
+}
+
+static void
+reload_net_startup_id (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+{
+  guint32 timestamp = window->net_wm_user_time;
+  MetaWorkspace *workspace = NULL;
+  
+  g_free (window->startup_id);
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    window->startup_id = g_strdup (value->v.str);
+  else
+    window->startup_id = NULL;
+    
+  /* Update timestamp and workspace on a running window */
+  if (!window->constructing)
+  {
+    window->initial_timestamp_set = 0;  
+    window->initial_workspace_set = 0;
+    
+    if (meta_screen_apply_startup_properties (window->screen, window))
+      {
+  
+        if (window->initial_timestamp_set)
+          timestamp = window->initial_timestamp;
+        if (window->initial_workspace_set)
+          workspace = meta_screen_get_workspace_by_index (window->screen, window->initial_workspace);
+    
+        meta_window_activate_with_workspace (window, timestamp, workspace);
+      }
+  }
+  
+  meta_verbose ("New _NET_STARTUP_ID \"%s\" for %s\n",
+                window->startup_id ? window->startup_id : "unset",
+                window->desc);
+}
+
+static void
+reload_update_counter (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+#ifdef HAVE_XSYNC
+      XSyncCounter counter = value->v.xcounter;
+
+      window->sync_request_counter = counter;
+      meta_verbose ("Window has _NET_WM_SYNC_REQUEST_COUNTER 0x%lx\n",
+                    window->sync_request_counter);
+#endif
+    }
+}
+
+#define FLAG_TOGGLED_ON(old,new,flag) \
+ (((old)->flags & (flag)) == 0 &&     \
+  ((new)->flags & (flag)) != 0)
+
+#define FLAG_TOGGLED_OFF(old,new,flag) \
+ (((old)->flags & (flag)) != 0 &&      \
+  ((new)->flags & (flag)) == 0)
+
+#define FLAG_CHANGED(old,new,flag) \
+  (FLAG_TOGGLED_ON(old,new,flag) || FLAG_TOGGLED_OFF(old,new,flag))
+
+static void
+spew_size_hints_differences (const XSizeHints *old,
+                             const XSizeHints *new)
+{
+  if (FLAG_CHANGED (old, new, USPosition))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: USPosition now %s\n",
+                FLAG_TOGGLED_ON (old, new, USPosition) ? "set" : "unset");
+  if (FLAG_CHANGED (old, new, USSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: USSize now %s\n",
+                FLAG_TOGGLED_ON (old, new, USSize) ? "set" : "unset");
+  if (FLAG_CHANGED (old, new, PPosition))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PPosition now %s\n",
+                FLAG_TOGGLED_ON (old, new, PPosition) ? "set" : "unset");
+  if (FLAG_CHANGED (old, new, PSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PSize now %s\n",
+                FLAG_TOGGLED_ON (old, new, PSize) ? "set" : "unset");
+  if (FLAG_CHANGED (old, new, PMinSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PMinSize now %s (%d x %d -> %d x %d)\n",
+                FLAG_TOGGLED_ON (old, new, PMinSize) ? "set" : "unset",
+                old->min_width, old->min_height,
+                new->min_width, new->min_height);
+  if (FLAG_CHANGED (old, new, PMaxSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PMaxSize now %s (%d x %d -> %d x %d)\n",
+                FLAG_TOGGLED_ON (old, new, PMaxSize) ? "set" : "unset",
+                old->max_width, old->max_height,
+                new->max_width, new->max_height);
+  if (FLAG_CHANGED (old, new, PResizeInc))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PResizeInc now %s (width_inc %d -> %d height_inc %d -> %d)\n",
+                FLAG_TOGGLED_ON (old, new, PResizeInc) ? "set" : "unset",
+                old->width_inc, new->width_inc,
+                old->height_inc, new->height_inc);
+  if (FLAG_CHANGED (old, new, PAspect))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PAspect now %s (min %d/%d -> %d/%d max %d/%d -> %d/%d)\n",
+                FLAG_TOGGLED_ON (old, new, PAspect) ? "set" : "unset",
+                old->min_aspect.x, old->min_aspect.y,
+                new->min_aspect.x, new->min_aspect.y,
+                old->max_aspect.x, old->max_aspect.y,
+                new->max_aspect.x, new->max_aspect.y);
+  if (FLAG_CHANGED (old, new, PBaseSize))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PBaseSize now %s (%d x %d -> %d x %d)\n",
+                FLAG_TOGGLED_ON (old, new, PBaseSize) ? "set" : "unset",
+                old->base_width, old->base_height,
+                new->base_width, new->base_height);
+  if (FLAG_CHANGED (old, new, PWinGravity))
+    meta_topic (META_DEBUG_GEOMETRY, "XSizeHints: PWinGravity now %s  (%d -> %d)\n",
+                FLAG_TOGGLED_ON (old, new, PWinGravity) ? "set" : "unset",
+                old->win_gravity, new->win_gravity);  
+}
+
+void
+meta_set_normal_hints (MetaWindow *window,
+                       XSizeHints *hints)
+{
+  int x, y, w, h;
+  double minr, maxr;
+  /* Some convenience vars */
+  int minw, minh, maxw, maxh;   /* min/max width/height                      */
+  int basew, baseh, winc, hinc; /* base width/height, width/height increment */
+
+  /* Save the last ConfigureRequest, which we put here.
+   * Values here set in the hints are supposed to
+   * be ignored.
+   */
+  x = window->size_hints.x;
+  y = window->size_hints.y;
+  w = window->size_hints.width;
+  h = window->size_hints.height;
+
+  /* as far as I can tell, value->v.size_hints.flags is just to
+   * check whether we had old-style normal hints without gravity,
+   * base size as returned by XGetNormalHints(), so we don't
+   * really use it as we fixup window->size_hints to have those
+   * fields if they're missing.
+   */
+
+  /*
+   * When the window is first created, NULL hints will
+   * be passed in which will initialize all of the fields
+   * as if flags were zero
+   */
+  if (hints)
+    window->size_hints = *hints;
+  else
+    window->size_hints.flags = 0;
+
+  /* Put back saved ConfigureRequest. */
+  window->size_hints.x = x;
+  window->size_hints.y = y;
+  window->size_hints.width = w;
+  window->size_hints.height = h;
+
+  /* Get base size hints */
+  if (window->size_hints.flags & PBaseSize)
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Window %s sets base size %d x %d\n",
+                  window->desc,
+                  window->size_hints.base_width,
+                  window->size_hints.base_height);
+    }
+  else if (window->size_hints.flags & PMinSize)
+    {
+      window->size_hints.base_width = window->size_hints.min_width;
+      window->size_hints.base_height = window->size_hints.min_height;
+    }
+  else
+    {
+      window->size_hints.base_width = 0;
+      window->size_hints.base_height = 0;
+    }
+  window->size_hints.flags |= PBaseSize;
+
+  /* Get min size hints */
+  if (window->size_hints.flags & PMinSize)
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Window %s sets min size %d x %d\n",
+                  window->desc,
+                  window->size_hints.min_width,
+                  window->size_hints.min_height);
+    }
+  else if (window->size_hints.flags & PBaseSize)
+    {
+      window->size_hints.min_width = window->size_hints.base_width;
+      window->size_hints.min_height = window->size_hints.base_height;
+    }
+  else
+    {
+      window->size_hints.min_width = 0;
+      window->size_hints.min_height = 0;
+    }
+  window->size_hints.flags |= PMinSize;
+
+  /* Get max size hints */
+  if (window->size_hints.flags & PMaxSize)
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Window %s sets max size %d x %d\n",
+                  window->desc,
+                  window->size_hints.max_width,
+                  window->size_hints.max_height);
+    }
+  else
+    {
+      window->size_hints.max_width = G_MAXINT;
+      window->size_hints.max_height = G_MAXINT;
+      window->size_hints.flags |= PMaxSize;
+    }
+
+  /* Get resize increment hints */
+  if (window->size_hints.flags & PResizeInc)
+    {
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets resize width inc: %d height inc: %d\n",
+                  window->desc,
+                  window->size_hints.width_inc,
+                  window->size_hints.height_inc);
+    }
+  else
+    {
+      window->size_hints.width_inc = 1;
+      window->size_hints.height_inc = 1;
+      window->size_hints.flags |= PResizeInc;
+    }
+
+  /* Get aspect ratio hints */
+  if (window->size_hints.flags & PAspect)
+    {
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets min_aspect: %d/%d max_aspect: %d/%d\n",
+                  window->desc,
+                  window->size_hints.min_aspect.x,
+                  window->size_hints.min_aspect.y,
+                  window->size_hints.max_aspect.x,
+                  window->size_hints.max_aspect.y);
+    }
+  else
+    {
+      window->size_hints.min_aspect.x = 1;
+      window->size_hints.min_aspect.y = G_MAXINT;
+      window->size_hints.max_aspect.x = G_MAXINT;
+      window->size_hints.max_aspect.y = 1;
+      window->size_hints.flags |= PAspect;
+    }
+
+  /* Get gravity hint */
+  if (window->size_hints.flags & PWinGravity)
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Window %s sets gravity %d\n",
+                  window->desc,
+                  window->size_hints.win_gravity);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s doesn't set gravity, using NW\n",
+                  window->desc);
+      window->size_hints.win_gravity = NorthWestGravity;
+      window->size_hints.flags |= PWinGravity;
+    }
+
+  /*** Lots of sanity checking ***/
+
+  /* Verify all min & max hints are at least 1 pixel */
+  if (window->size_hints.min_width < 1)
+    {
+      /* someone is on crack */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets min width to 0, which makes no sense\n",
+                  window->desc);
+      window->size_hints.min_width = 1;
+    }
+  if (window->size_hints.max_width < 1)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets max width to 0, which makes no sense\n",
+                  window->desc);
+      window->size_hints.max_width = 1;
+    }
+  if (window->size_hints.min_height < 1)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets min height to 0, which makes no sense\n",
+                  window->desc);
+      window->size_hints.min_height = 1;
+    }
+  if (window->size_hints.max_height < 1)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets max height to 0, which makes no sense\n",
+                  window->desc);
+      window->size_hints.max_height = 1;
+    }
+
+  /* Verify size increment hints are at least 1 pixel */
+  if (window->size_hints.width_inc < 1)
+    {
+      /* app authors find so many ways to smoke crack */
+      window->size_hints.width_inc = 1;
+      meta_topic (META_DEBUG_GEOMETRY, "Corrected 0 width_inc to 1\n");
+    }
+  if (window->size_hints.height_inc < 1)
+    {
+      /* another cracksmoker */
+      window->size_hints.height_inc = 1;
+      meta_topic (META_DEBUG_GEOMETRY, "Corrected 0 height_inc to 1\n");
+    }
+  /* divide by 0 cracksmokers; note that x & y in (min|max)_aspect are
+   * numerator & denominator
+   */
+  if (window->size_hints.min_aspect.y < 1)
+    window->size_hints.min_aspect.y = 1;
+  if (window->size_hints.max_aspect.y < 1)
+    window->size_hints.max_aspect.y = 1;
+
+  minw  = window->size_hints.min_width;  minh  = window->size_hints.min_height;
+  maxw  = window->size_hints.max_width;  maxh  = window->size_hints.max_height;
+  basew = window->size_hints.base_width; baseh = window->size_hints.base_height;
+  winc  = window->size_hints.width_inc;  hinc  = window->size_hints.height_inc;
+
+  /* Make sure min and max size hints are consistent with the base + increment
+   * size hints.  If they're not, it's not a real big deal, but it means the
+   * effective min and max size are more restrictive than the application
+   * specified values.
+   */
+  if ((minw - basew) % winc != 0)
+    {
+      /* Take advantage of integer division throwing away the remainder... */
+      window->size_hints.min_width = basew + ((minw - basew)/winc + 1)*winc;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s has width_inc (%d) that does not evenly divide "
+                  "min_width - base_width (%d - %d); thus effective "
+                  "min_width is really %d\n",
+                  window->desc,
+                  winc, minw, basew, window->size_hints.min_width);
+      minw = window->size_hints.min_width;
+    }
+  if (maxw != G_MAXINT && (maxw - basew) % winc != 0)
+    {
+      /* Take advantage of integer division throwing away the remainder... */
+      window->size_hints.max_width = basew + ((maxw - basew)/winc)*winc;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s has width_inc (%d) that does not evenly divide "
+                  "max_width - base_width (%d - %d); thus effective "
+                  "max_width is really %d\n",
+                  window->desc,
+                  winc, maxw, basew, window->size_hints.max_width);
+      maxw = window->size_hints.max_width;
+    }
+  if ((minh - baseh) % hinc != 0)
+    {
+      /* Take advantage of integer division throwing away the remainder... */
+      window->size_hints.min_height = baseh + ((minh - baseh)/hinc + 1)*hinc;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s has height_inc (%d) that does not evenly divide "
+                  "min_height - base_height (%d - %d); thus effective "
+                  "min_height is really %d\n",
+                  window->desc,
+                  hinc, minh, baseh, window->size_hints.min_height);
+      minh = window->size_hints.min_height;
+    }
+  if (maxh != G_MAXINT && (maxh - baseh) % hinc != 0)
+    {
+      /* Take advantage of integer division throwing away the remainder... */
+      window->size_hints.max_height = baseh + ((maxh - baseh)/hinc)*hinc;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s has height_inc (%d) that does not evenly divide "
+                  "max_height - base_height (%d - %d); thus effective "
+                  "max_height is really %d\n",
+                  window->desc,
+                  hinc, maxh, baseh, window->size_hints.max_height);
+      maxh = window->size_hints.max_height;
+    }
+
+  /* make sure maximum size hints are compatible with minimum size hints; min
+   * size hints take precedence.
+   */
+  if (window->size_hints.max_width < window->size_hints.min_width)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets max width %d less than min width %d, "
+                  "disabling resize\n",
+                  window->desc,
+                  window->size_hints.max_width,
+                  window->size_hints.min_width);
+      maxw = window->size_hints.max_width = window->size_hints.min_width;
+    }
+  if (window->size_hints.max_height < window->size_hints.min_height)
+    {
+      /* another cracksmoker */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets max height %d less than min height %d, "
+                  "disabling resize\n",
+                  window->desc,
+                  window->size_hints.max_height,
+                  window->size_hints.min_height);
+      maxh = window->size_hints.max_height = window->size_hints.min_height;
+    }
+
+  /* Make sure the aspect ratio hints are sane. */
+  minr =         window->size_hints.min_aspect.x /
+         (double)window->size_hints.min_aspect.y;
+  maxr =         window->size_hints.max_aspect.x /
+         (double)window->size_hints.max_aspect.y;
+  if (minr > maxr)
+    {
+      /* another cracksmoker; not even minimally (self) consistent */
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Window %s sets min aspect ratio larger than max aspect "
+                  "ratio; disabling aspect ratio constraints.\n",
+                  window->desc);
+      window->size_hints.min_aspect.x = 1;
+      window->size_hints.min_aspect.y = G_MAXINT;
+      window->size_hints.max_aspect.x = G_MAXINT;
+      window->size_hints.max_aspect.y = 1;
+    }
+  else /* check consistency of aspect ratio hints with other hints */
+    {
+      if (minh > 0 && minr > (maxw / (double)minh))
+        {
+          /* another cracksmoker */
+          meta_topic (META_DEBUG_GEOMETRY,
+                      "Window %s sets min aspect ratio larger than largest "
+                      "aspect ratio possible given min/max size constraints; "
+                      "disabling min aspect ratio constraint.\n",
+                      window->desc);
+          window->size_hints.min_aspect.x = 1;
+          window->size_hints.min_aspect.y = G_MAXINT;
+        }
+      if (maxr < (minw / (double)maxh))
+        {
+          /* another cracksmoker */
+          meta_topic (META_DEBUG_GEOMETRY,
+                      "Window %s sets max aspect ratio smaller than smallest "
+                      "aspect ratio possible given min/max size constraints; "
+                      "disabling max aspect ratio constraint.\n",
+                      window->desc);
+          window->size_hints.max_aspect.x = G_MAXINT;
+          window->size_hints.max_aspect.y = 1;
+        }
+      /* FIXME: Would be nice to check that aspect ratios are
+       * consistent with base and size increment constraints.
+       */
+    }
+}
+
+static void
+reload_normal_hints (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      XSizeHints old_hints;
+  
+      meta_topic (META_DEBUG_GEOMETRY, "Updating WM_NORMAL_HINTS for %s\n", window->desc);
+
+      old_hints = window->size_hints;
+  
+      meta_set_normal_hints (window, value->v.size_hints.hints);
+      
+      spew_size_hints_differences (&old_hints, &window->size_hints);
+      
+      meta_window_recalc_features (window);
+
+      if (!initial)
+        meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+    }
+}
+
+static void
+reload_wm_protocols (MetaWindow    *window,
+                     MetaPropValue *value,
+                     gboolean       initial)
+{
+  int i;
+  
+  window->take_focus = FALSE;
+  window->delete_window = FALSE;
+  window->net_wm_ping = FALSE;
+  
+  if (value->type == META_PROP_VALUE_INVALID)    
+    return;
+
+  i = 0;
+  while (i < value->v.atom_list.n_atoms)
+    {
+      if (value->v.atom_list.atoms[i] ==
+          window->display->atom_WM_TAKE_FOCUS)
+        window->take_focus = TRUE;
+      else if (value->v.atom_list.atoms[i] ==
+               window->display->atom_WM_DELETE_WINDOW)
+        window->delete_window = TRUE;
+      else if (value->v.atom_list.atoms[i] ==
+               window->display->atom__NET_WM_PING)
+        window->net_wm_ping = TRUE;
+      ++i;
+    }
+  
+  meta_verbose ("New _NET_STARTUP_ID \"%s\" for %s\n",
+                window->startup_id ? window->startup_id : "unset",
+                window->desc);
+}
+
+static void
+reload_wm_hints (MetaWindow    *window,
+                 MetaPropValue *value,
+                 gboolean       initial)
+{
+  Window old_group_leader;
+  
+  old_group_leader = window->xgroup_leader;
+  
+  /* Fill in defaults */
+  window->input = TRUE;
+  window->initially_iconic = FALSE;
+  window->xgroup_leader = None;
+  window->wm_hints_pixmap = None;
+  window->wm_hints_mask = None;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    {
+      const XWMHints *hints = value->v.wm_hints;
+      
+      if (hints->flags & InputHint)
+        window->input = hints->input;
+
+      if (hints->flags & StateHint)
+        window->initially_iconic = (hints->initial_state == IconicState);
+
+      if (hints->flags & WindowGroupHint)
+        window->xgroup_leader = hints->window_group;
+
+      if (hints->flags & IconPixmapHint)
+        window->wm_hints_pixmap = hints->icon_pixmap;
+
+      if (hints->flags & IconMaskHint)
+        window->wm_hints_mask = hints->icon_mask;
+      
+      meta_verbose ("Read WM_HINTS input: %d iconic: %d group leader: 0x%lx pixmap: 0x%lx mask: 0x%lx\n",
+                    window->input, window->initially_iconic,
+                    window->xgroup_leader,
+                    window->wm_hints_pixmap,
+                    window->wm_hints_mask);
+    }
+
+  if (window->xgroup_leader != old_group_leader)
+    {
+      meta_verbose ("Window %s changed its group leader to 0x%lx\n",
+                    window->desc, window->xgroup_leader);
+      
+      meta_window_group_leader_changed (window);
+    }
+
+  meta_icon_cache_property_changed (&window->icon_cache,
+                                    window->display,
+                                    XA_WM_HINTS);
+
+  meta_window_queue (window, META_QUEUE_UPDATE_ICON | META_QUEUE_MOVE_RESIZE);
+}
+
+static void
+reload_transient_for (MetaWindow    *window,
+                      MetaPropValue *value,
+                      gboolean       initial)
+{
+  window->xtransient_for = None;
+  
+  if (value->type != META_PROP_VALUE_INVALID)
+    window->xtransient_for = value->v.xwindow;
+
+  /* Make sure transient_for is valid */
+  if (window->xtransient_for != None &&
+      meta_display_lookup_x_window (window->display, 
+                                    window->xtransient_for) == NULL)
+    {
+      meta_warning (_("Invalid WM_TRANSIENT_FOR window 0x%lx specified "
+                      "for %s.\n"),
+                    window->xtransient_for, window->desc);
+      window->xtransient_for = None;
+    }
+
+  window->transient_parent_is_root_window =
+    window->xtransient_for == window->screen->xroot;
+
+  if (window->xtransient_for != None)
+    meta_verbose ("Window %s transient for 0x%lx (root = %d)\n", window->desc,
+        window->xtransient_for, window->transient_parent_is_root_window);
+  else
+    meta_verbose ("Window %s is not transient\n", window->desc);
+
+  /* may now be a dialog */
+  meta_window_recalc_window_type (window);
+
+  /* update stacking constraints */
+  meta_stack_update_transient (window->screen->stack, window);
+
+  /* possibly change its group. We treat being a window's transient as
+   * equivalent to making it your group leader, to work around shortcomings
+   * in programs such as xmms-- see #328211.
+   */
+  if (window->xtransient_for != None &&
+      window->xgroup_leader != None &&
+      window->xtransient_for != window->xgroup_leader)
+    meta_window_group_leader_changed (window);
+
+  if (!window->constructing)
+    meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+}
+
+/**
+ * Initialises the property hooks system.  Each row in the table named "hooks"
+ * represents an action to take when a property is found on a newly-created
+ * window, or when a property changes its value.
+ *
+ * The first column shows which atom the row concerns.
+ * The second gives the type of the property data.  The property will be
+ * queried for its new value, unless the type is given as
+ * META_PROP_VALUE_INVALID, in which case nothing will be queried.
+ * The third column gives the name of a callback which gets called with the
+ * new value.  (If the new value was not retrieved because the second column
+ * was META_PROP_VALUE_INVALID, the callback still gets called anyway.)
+ * This value may be NULL, in which case no callback will be called.
+ */
+void
+meta_display_init_window_prop_hooks (MetaDisplay *display)
+{
+  MetaWindowPropHooks hooks[] = {
+    { display->atom_WM_STATE,          META_PROP_VALUE_INVALID,  NULL },
+    { display->atom_WM_CLIENT_MACHINE, META_PROP_VALUE_STRING,   reload_wm_client_machine },
+    { display->atom__NET_WM_PID,       META_PROP_VALUE_CARDINAL, reload_net_wm_pid },
+    { display->atom__NET_WM_USER_TIME, META_PROP_VALUE_CARDINAL, reload_net_wm_user_time },
+    { display->atom__NET_WM_NAME,      META_PROP_VALUE_UTF8,     reload_net_wm_name },
+    { XA_WM_NAME,                      META_PROP_VALUE_TEXT_PROPERTY, reload_wm_name },
+    { display->atom__NET_WM_ICON,      META_PROP_VALUE_INVALID,  reload_net_wm_icon },
+    { display->atom__KWM_WIN_ICON,     META_PROP_VALUE_INVALID,  reload_kwm_win_icon },
+    { display->atom__NET_WM_ICON_NAME, META_PROP_VALUE_UTF8,     reload_net_wm_icon_name },
+    { XA_WM_ICON_NAME,                 META_PROP_VALUE_TEXT_PROPERTY, reload_wm_icon_name },
+    { display->atom__NET_WM_STATE,     META_PROP_VALUE_ATOM_LIST, reload_net_wm_state },
+    { display->atom__MOTIF_WM_HINTS,   META_PROP_VALUE_MOTIF_HINTS, reload_mwm_hints },
+    { display->atom__NET_WM_ICON_GEOMETRY, META_PROP_VALUE_INVALID, NULL },
+    { XA_WM_CLASS,                     META_PROP_VALUE_CLASS_HINT, reload_wm_class },
+    { display->atom_WM_CLIENT_LEADER,  META_PROP_VALUE_INVALID, complain_about_broken_client },
+    { display->atom_SM_CLIENT_ID,      META_PROP_VALUE_INVALID, complain_about_broken_client },
+    { display->atom_WM_WINDOW_ROLE,    META_PROP_VALUE_INVALID, reload_wm_window_role },
+    { display->atom__NET_WM_WINDOW_TYPE, META_PROP_VALUE_INVALID, reload_net_wm_window_type },
+    { display->atom__NET_WM_DESKTOP,   META_PROP_VALUE_CARDINAL, reload_net_wm_desktop },
+    { display->atom__NET_WM_STRUT,         META_PROP_VALUE_INVALID, reload_struts },
+    { display->atom__NET_WM_STRUT_PARTIAL, META_PROP_VALUE_INVALID, reload_struts },
+    { display->atom__NET_STARTUP_ID,  META_PROP_VALUE_UTF8,     reload_net_startup_id },
+    { display->atom__NET_WM_SYNC_REQUEST_COUNTER, META_PROP_VALUE_SYNC_COUNTER, reload_update_counter },
+    { XA_WM_NORMAL_HINTS,              META_PROP_VALUE_SIZE_HINTS, reload_normal_hints },
+    { display->atom_WM_PROTOCOLS,      META_PROP_VALUE_ATOM_LIST, reload_wm_protocols },
+    { XA_WM_HINTS,                     META_PROP_VALUE_WM_HINTS,  reload_wm_hints },
+    { XA_WM_TRANSIENT_FOR,             META_PROP_VALUE_WINDOW,    reload_transient_for },
+    { display->atom__NET_WM_USER_TIME_WINDOW, META_PROP_VALUE_WINDOW, reload_net_wm_user_time_window },
+    { 0 },
+  };
+
+  MetaWindowPropHooks *table = g_memdup (hooks, sizeof (hooks)),
+    *cursor = table;
+
+  g_assert (display->prop_hooks == NULL);
+
+  display->prop_hooks_table = (gpointer) table;
+  display->prop_hooks = g_hash_table_new (NULL, NULL);
+
+  while (cursor->property)
+    {
+      /* Atoms are safe to use with GINT_TO_POINTER because it's safe with
+       * anything 32 bits or less, and atoms are 32 bits with the top three
+       * bits clear.  (Scheifler & Gettys, 2e, p372)
+       */
+      g_hash_table_insert (display->prop_hooks,
+                           GINT_TO_POINTER (cursor->property),
+                           cursor);
+      cursor++;
+    }
+}
+
+void
+meta_display_free_window_prop_hooks (MetaDisplay *display)
+{
+  g_hash_table_unref (display->prop_hooks);
+  display->prop_hooks = NULL;
+
+  g_free (display->prop_hooks_table);
+  display->prop_hooks_table = NULL;
+}
+
+/**
+ * Finds the hooks for a particular property.
+ */
+static MetaWindowPropHooks*
+find_hooks (MetaDisplay *display,
+            Atom         property)
+{
+  return g_hash_table_lookup (display->prop_hooks,
+                              GINT_TO_POINTER (property));
+}
diff --git a/src/core/window-props.h b/src/core/window-props.h
new file mode 100644
index 00000000..1e60eff0
--- /dev/null
+++ b/src/core/window-props.h
@@ -0,0 +1,129 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file window-props.h    MetaWindow property handling
+ *
+ * A system which can inspect sets of properties of given windows
+ * and take appropriate action given their values.
+ *
+ * Note that all the meta_window_reload_propert* functions require a
+ * round trip to the server.
+ */
+
+/* 
+ * Copyright (C) 2001, 2002 Red Hat, Inc.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_WINDOW_PROPS_H
+#define META_WINDOW_PROPS_H
+
+#include "window-private.h"
+
+/**
+ * Requests the current values of a single property for a given
+ * window from the server, and deals with it appropriately.
+ * Does not return it to the caller (it's been dealt with!)
+ *
+ * \param window     The window.
+ * \param property   A single X atom.
+ */
+void meta_window_reload_property   (MetaWindow *window,
+                                    Atom        property,
+                                    gboolean    initial);
+
+
+/**
+ * Requests the current values of a set of properties for a given
+ * window from the server, and deals with them appropriately.
+ * Does not return them to the caller (they've been dealt with!)
+ *
+ * \param window      The window.
+ * \param properties  A pointer to a list of X atoms, "n_properties" long.
+ * \param n_properties  The length of the properties list.
+ */
+void meta_window_reload_properties (MetaWindow *window,
+                                    const Atom *properties,
+                                    int         n_properties,
+                                    gboolean    initial);
+
+/**
+ * Requests the current values of a single property for a given
+ * window from the server, and deals with it appropriately.
+ * Does not return it to the caller (it's been dealt with!)
+ *
+ * \param window     A window on the same display as the one we're
+ *                   investigating (only used to find the display)
+ * \param xwindow    The X handle for the window.
+ * \param property   A single X atom.
+ */
+void meta_window_reload_property_from_xwindow
+                                   (MetaWindow *window,
+                                    Window      xwindow,
+                                    Atom        property,
+                                    gboolean    initial);
+
+/**
+ * Requests the current values of a set of properties for a given
+ * window from the server, and deals with them appropriately.
+ * Does not return them to the caller (they've been dealt with!)
+ *
+ * \param window     A window on the same display as the one we're
+ *                   investigating (only used to find the display)
+ * \param xwindow     The X handle for the window.
+ * \param properties  A pointer to a list of X atoms, "n_properties" long.
+ * \param n_properties  The length of the properties list.
+ */
+void meta_window_reload_properties_from_xwindow
+                                   (MetaWindow *window,
+                                    Window      xwindow,
+                                    const Atom *properties,
+                                    int         n_properties,
+                                    gboolean    initial);
+
+/**
+ * Initialises the hooks used for the reload_propert* functions
+ * on a particular display, and stores a pointer to them in the
+ * display.
+ *
+ * \param display  The display.
+ */
+void meta_display_init_window_prop_hooks (MetaDisplay *display);
+
+/**
+ * Frees the hooks used for the reload_propert* functions
+ * for a particular display.
+ *
+ * \param display  The display.
+ */
+void meta_display_free_window_prop_hooks (MetaDisplay *display);
+
+/**
+ * Sets the size hints for a window.  This happens when a
+ * WM_NORMAL_HINTS property is set on a window, but it is public
+ * because the size hints are set to defaults when a window is
+ * created.  See
+ * http://tronche.com/gui/x/icccm/sec-4.html#WM_NORMAL_HINTS
+ * for the X details.
+ *
+ * \param window   The window to set the size hints on.
+ * \param hints    Either some X size hints, or NULL for default.
+ */
+void meta_set_normal_hints (MetaWindow *window,
+			    XSizeHints *hints);
+
+#endif /* META_WINDOW_PROPS_H */
diff --git a/src/core/window.c b/src/core/window.c
new file mode 100644
index 00000000..08ab9ec9
--- /dev/null
+++ b/src/core/window.c
@@ -0,0 +1,8178 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X managed windows */
+
+/*
+ * Copyright (C) 2001 Havoc Pennington, Anders Carlsson
+ * Copyright (C) 2002, 2003 Red Hat, Inc.
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004-2006 Elijah Newren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "window-private.h"
+#include "edge-resistance.h"
+#include "util.h"
+#include "frame-private.h"
+#include "errors.h"
+#include "workspace.h"
+#include "stack.h"
+#include "keybindings.h"
+#include "ui.h"
+#include "place.h"
+#include "session.h"
+#include "effects.h"
+#include "prefs.h"
+#include "resizepopup.h"
+#include "xprops.h"
+#include "group.h"
+#include "window-props.h"
+#include "constraints.h"
+#include "compositor.h"
+#include "effects.h"
+
+#include <X11/Xatom.h>
+#include <string.h>
+
+#ifdef HAVE_SHAPE
+#include <X11/extensions/shape.h>
+#endif
+
+static int destroying_windows_disallowed = 0;
+
+
+static void     update_sm_hints           (MetaWindow     *window);
+static void     update_net_frame_extents  (MetaWindow     *window);
+static void     recalc_window_type        (MetaWindow     *window);
+static void     recalc_window_features    (MetaWindow     *window);
+static void     invalidate_work_areas     (MetaWindow     *window);
+static void     recalc_window_type        (MetaWindow     *window);
+static void     set_wm_state              (MetaWindow     *window,
+                                           int             state);
+static void     set_net_wm_state          (MetaWindow     *window);
+
+static void     send_configure_notify     (MetaWindow     *window);
+static gboolean process_property_notify   (MetaWindow     *window,
+                                           XPropertyEvent *event);
+static void     meta_window_show          (MetaWindow     *window);
+static void     meta_window_hide          (MetaWindow     *window);
+
+static void     meta_window_save_rect         (MetaWindow    *window);
+static void     save_user_window_placement    (MetaWindow    *window);
+static void     force_save_user_window_placement (MetaWindow    *window);
+
+static void meta_window_move_resize_internal (MetaWindow         *window,
+                                              MetaMoveResizeFlags flags,
+                                              int                 resize_gravity,
+                                              int                 root_x_nw,
+                                              int                 root_y_nw,
+                                              int                 w,
+                                              int                 h);
+
+static void     ensure_mru_position_after (MetaWindow *window,
+                                           MetaWindow *after_this_one);
+
+
+static void meta_window_move_resize_now (MetaWindow  *window);
+
+static void meta_window_unqueue (MetaWindow *window, guint queuebits);
+
+static void     update_move           (MetaWindow   *window,
+                                       gboolean      snap,
+                                       int           x,
+                                       int           y);
+static gboolean update_move_timeout   (gpointer data);
+static void     update_resize         (MetaWindow   *window,
+                                       gboolean      snap,
+                                       int           x,
+                                       int           y,
+                                       gboolean      force);
+static gboolean update_resize_timeout (gpointer data);
+
+
+static void meta_window_flush_calc_showing   (MetaWindow *window);
+
+static gboolean queue_calc_showing_func (MetaWindow *window,
+                                         void       *data);
+
+static void meta_window_apply_session_info (MetaWindow                  *window,
+                                            const MetaWindowSessionInfo *info);
+
+static void unmaximize_window_before_freeing (MetaWindow        *window);
+static void unminimize_window_and_all_transient_parents (MetaWindow *window);
+
+/* Idle handlers for the three queues. The "data" parameter in each case
+ * will be a GINT_TO_POINTER of the index into the queue arrays to use.
+ *
+ * TODO: Possibly there is still some code duplication among these, which we
+ * need to sort out at some point.
+ */
+static gboolean idle_calc_showing (gpointer data);
+static gboolean idle_move_resize (gpointer data);
+static gboolean idle_update_icon (gpointer data);
+
+#ifdef WITH_VERBOSE_MODE
+static const char*
+wm_state_to_string (int state)
+{
+  switch (state)
+    {
+    case NormalState:
+      return "NormalState";
+    case IconicState:
+      return "IconicState";
+    case WithdrawnState:
+      return "WithdrawnState";
+    }
+
+  return "Unknown";
+}
+#endif
+
+static gboolean
+is_desktop_or_dock_foreach (MetaWindow *window,
+                            void       *data)
+{
+  gboolean *result = data;
+
+  *result =
+    window->type == META_WINDOW_DESKTOP ||
+    window->type == META_WINDOW_DOCK;
+  if (*result)
+    return FALSE; /* stop as soon as we find one */
+  else
+    return TRUE;
+}
+
+/* window is the window that's newly mapped provoking
+ * the possible change
+ */
+static void
+maybe_leave_show_desktop_mode (MetaWindow *window)
+{
+  gboolean is_desktop_or_dock;
+
+  if (!window->screen->active_workspace->showing_desktop)
+    return;
+
+  /* If the window is a transient for the dock or desktop, don't
+   * leave show desktop mode when the window opens. That's
+   * so you can e.g. hide all windows, manipulate a file on
+   * the desktop via a dialog, then unshow windows again.
+   */
+  is_desktop_or_dock = FALSE;
+  is_desktop_or_dock_foreach (window,
+                              &is_desktop_or_dock);
+
+  meta_window_foreach_ancestor (window, is_desktop_or_dock_foreach,
+                                &is_desktop_or_dock);
+
+  if (!is_desktop_or_dock)
+    {
+      meta_screen_minimize_all_on_active_workspace_except (window->screen,
+                                                           window);
+      meta_screen_unshow_desktop (window->screen);
+    }
+}
+
+MetaWindow*
+meta_window_new (MetaDisplay *display,
+                 Window       xwindow,
+                 gboolean     must_be_viewable)
+{
+  XWindowAttributes attrs;
+  MetaWindow *window;
+
+  meta_display_grab (display);
+  meta_error_trap_push (display); /* Push a trap over all of window
+                                   * creation, to reduce XSync() calls
+                                   */
+
+  meta_error_trap_push_with_return (display);
+
+  if (XGetWindowAttributes (display->xdisplay,xwindow, &attrs))
+   {
+      if(meta_error_trap_pop_with_return (display, TRUE) != Success)
+       {
+          meta_verbose ("Failed to get attributes for window 0x%lx\n",
+                        xwindow);
+          meta_error_trap_pop (display, TRUE);
+          meta_display_ungrab (display);
+          return NULL;
+       }
+      window = meta_window_new_with_attrs (display, xwindow,
+                                       must_be_viewable, &attrs);
+   }
+  else
+   {
+         meta_error_trap_pop_with_return (display, TRUE);
+         meta_verbose ("Failed to get attributes for window 0x%lx\n",
+                        xwindow);
+         meta_error_trap_pop (display, TRUE);
+         meta_display_ungrab (display);
+         return NULL;
+   }
+
+
+  meta_error_trap_pop (display, FALSE);
+  meta_display_ungrab (display);
+
+  return window;
+}
+
+MetaWindow*
+meta_window_new_with_attrs (MetaDisplay       *display,
+                            Window             xwindow,
+                            gboolean           must_be_viewable,
+                            XWindowAttributes *attrs)
+{
+  MetaWindow *window;
+  GSList *tmp;
+  MetaWorkspace *space;
+  gulong existing_wm_state;
+  gulong event_mask;
+  MetaMoveResizeFlags flags;
+#define N_INITIAL_PROPS 19
+  Atom initial_props[N_INITIAL_PROPS];
+  int i;
+  gboolean has_shape;
+
+  g_assert (attrs != NULL);
+  g_assert (N_INITIAL_PROPS == (int) G_N_ELEMENTS (initial_props));
+
+  meta_verbose ("Attempting to manage 0x%lx\n", xwindow);
+
+  if (meta_display_xwindow_is_a_no_focus_window (display, xwindow))
+    {
+      meta_verbose ("Not managing no_focus_window 0x%lx\n",
+                    xwindow);
+      return NULL;
+    }
+
+  if (attrs->override_redirect)
+    {
+      meta_verbose ("Deciding not to manage override_redirect window 0x%lx\n", xwindow);
+      return NULL;
+    }
+
+  /* Grab server */
+  meta_display_grab (display);
+  meta_error_trap_push (display); /* Push a trap over all of window
+                                   * creation, to reduce XSync() calls
+                                   */
+
+  meta_verbose ("must_be_viewable = %d attrs->map_state = %d (%s)\n",
+                must_be_viewable,
+                attrs->map_state,
+                (attrs->map_state == IsUnmapped) ?
+                "IsUnmapped" :
+                (attrs->map_state == IsViewable) ?
+                "IsViewable" :
+                (attrs->map_state == IsUnviewable) ?
+                "IsUnviewable" :
+                "(unknown)");
+
+  existing_wm_state = WithdrawnState;
+  if (must_be_viewable && attrs->map_state != IsViewable)
+    {
+      /* Only manage if WM_STATE is IconicState or NormalState */
+      gulong state;
+
+      /* WM_STATE isn't a cardinal, it's type WM_STATE, but is an int */
+      if (!(meta_prop_get_cardinal_with_atom_type (display, xwindow,
+                                                   display->atom_WM_STATE,
+                                                   display->atom_WM_STATE,
+                                                   &state) &&
+            (state == IconicState || state == NormalState)))
+        {
+          meta_verbose ("Deciding not to manage unmapped or unviewable window 0x%lx\n", xwindow);
+          meta_error_trap_pop (display, TRUE);
+          meta_display_ungrab (display);
+          return NULL;
+        }
+
+      existing_wm_state = state;
+      meta_verbose ("WM_STATE of %lx = %s\n", xwindow,
+                    wm_state_to_string (existing_wm_state));
+    }
+
+  meta_error_trap_push_with_return (display);
+
+  XAddToSaveSet (display->xdisplay, xwindow);
+
+  event_mask =
+    PropertyChangeMask | EnterWindowMask | LeaveWindowMask |
+    FocusChangeMask | ColormapChangeMask;
+
+  XSelectInput (display->xdisplay, xwindow, event_mask);
+
+  has_shape = FALSE;
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (display))
+    {
+      int x_bounding, y_bounding, x_clip, y_clip;
+      unsigned w_bounding, h_bounding, w_clip, h_clip;
+      int bounding_shaped, clip_shaped;
+
+      XShapeSelectInput (display->xdisplay, xwindow, ShapeNotifyMask);
+
+      XShapeQueryExtents (display->xdisplay, xwindow,
+                          &bounding_shaped, &x_bounding, &y_bounding,
+                          &w_bounding, &h_bounding,
+                          &clip_shaped, &x_clip, &y_clip,
+                          &w_clip, &h_clip);
+
+      has_shape = bounding_shaped != FALSE;
+
+      meta_topic (META_DEBUG_SHAPES,
+                  "Window has_shape = %d extents %d,%d %u x %u\n",
+                  has_shape, x_bounding, y_bounding,
+                  w_bounding, h_bounding);
+    }
+#endif
+
+  /* Get rid of any borders */
+  if (attrs->border_width != 0)
+    XSetWindowBorderWidth (display->xdisplay, xwindow, 0);
+
+  /* Get rid of weird gravities */
+  if (attrs->win_gravity != NorthWestGravity)
+    {
+      XSetWindowAttributes set_attrs;
+
+      set_attrs.win_gravity = NorthWestGravity;
+
+      XChangeWindowAttributes (display->xdisplay,
+                               xwindow,
+                               CWWinGravity,
+                               &set_attrs);
+    }
+
+  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+    {
+      meta_verbose ("Window 0x%lx disappeared just as we tried to manage it\n",
+                    xwindow);
+      meta_error_trap_pop (display, FALSE);
+      meta_display_ungrab (display);
+      return NULL;
+    }
+
+  g_assert (!attrs->override_redirect);
+
+  window = g_new (MetaWindow, 1);
+
+  window->constructing = TRUE;
+
+  window->dialog_pid = -1;
+
+  window->xwindow = xwindow;
+
+  /* this is in window->screen->display, but that's too annoying to
+   * type
+   */
+  window->display = display;
+  window->workspace = NULL;
+
+#ifdef HAVE_XSYNC
+  window->sync_request_counter = None;
+  window->sync_request_serial = 0;
+  window->sync_request_time.tv_sec = 0;
+  window->sync_request_time.tv_usec = 0;
+#endif
+
+  window->screen = NULL;
+  tmp = display->screens;
+  while (tmp != NULL)
+    {
+      MetaScreen *scr = tmp->data;
+
+      if (scr->xroot == attrs->root)
+        {
+          window->screen = tmp->data;
+          break;
+        }
+
+      tmp = tmp->next;
+    }
+
+  g_assert (window->screen);
+
+  window->desc = g_strdup_printf ("0x%lx", window->xwindow);
+
+  /* avoid tons of stack updates */
+  meta_stack_freeze (window->screen->stack);
+
+  window->has_shape = has_shape;
+
+  window->rect.x = attrs->x;
+  window->rect.y = attrs->y;
+  window->rect.width = attrs->width;
+  window->rect.height = attrs->height;
+
+  /* And border width, size_hints are the "request" */
+  window->border_width = attrs->border_width;
+  window->size_hints.x = attrs->x;
+  window->size_hints.y = attrs->y;
+  window->size_hints.width = attrs->width;
+  window->size_hints.height = attrs->height;
+  /* initialize the remaining size_hints as if size_hints.flags were zero */
+  meta_set_normal_hints (window, NULL);
+
+  /* And this is our unmaximized size */
+  window->saved_rect = window->rect;
+  window->user_rect = window->rect;
+
+  window->depth = attrs->depth;
+  window->xvisual = attrs->visual;
+  window->colormap = attrs->colormap;
+
+  window->title = NULL;
+  window->icon_name = NULL;
+  window->icon = NULL;
+  window->mini_icon = NULL;
+  meta_icon_cache_init (&window->icon_cache);
+  window->wm_hints_pixmap = None;
+  window->wm_hints_mask = None;
+
+  window->frame = NULL;
+  window->has_focus = FALSE;
+
+  window->maximized_horizontally = FALSE;
+  window->maximized_vertically = FALSE;
+  window->maximize_horizontally_after_placement = FALSE;
+  window->maximize_vertically_after_placement = FALSE;
+  window->minimize_after_placement = FALSE;
+  window->fullscreen_after_placement = FALSE;
+  window->fullscreen_monitors[0] = -1;
+  window->require_fully_onscreen = TRUE;
+  window->require_on_single_xinerama = TRUE;
+  window->require_titlebar_visible = TRUE;
+  window->on_all_workspaces = FALSE;
+  window->shaded = FALSE;
+  window->initially_iconic = FALSE;
+  window->minimized = FALSE;
+  window->was_minimized = FALSE;
+  window->tab_unminimized = FALSE;
+  window->iconic = FALSE;
+  window->mapped = attrs->map_state != IsUnmapped;
+  /* if already mapped, no need to worry about focus-on-first-time-showing */
+  window->showing_for_first_time = !window->mapped;
+  /* if already mapped we don't want to do the placement thing */
+  window->placed = window->mapped;
+  if (window->placed)
+    meta_topic (META_DEBUG_PLACEMENT,
+                "Not placing window 0x%lx since it's already mapped\n",
+                xwindow);
+  window->force_save_user_rect = TRUE;
+  window->denied_focus_and_not_transient = FALSE;
+  window->unmanaging = FALSE;
+  window->is_in_queues = 0;
+  window->keys_grabbed = FALSE;
+  window->grab_on_frame = FALSE;
+  window->all_keys_grabbed = FALSE;
+  window->withdrawn = FALSE;
+  window->initial_workspace_set = FALSE;
+  window->initial_timestamp_set = FALSE;
+  window->net_wm_user_time_set = FALSE;
+  window->user_time_window = None;
+  window->calc_placement = FALSE;
+  window->shaken_loose = FALSE;
+  window->have_focus_click_grab = FALSE;
+  window->disable_sync = FALSE;
+
+  window->unmaps_pending = 0;
+
+  window->mwm_decorated = TRUE;
+  window->mwm_border_only = FALSE;
+  window->mwm_has_close_func = TRUE;
+  window->mwm_has_minimize_func = TRUE;
+  window->mwm_has_maximize_func = TRUE;
+  window->mwm_has_move_func = TRUE;
+  window->mwm_has_resize_func = TRUE;
+
+  window->decorated = TRUE;
+  window->has_close_func = TRUE;
+  window->has_minimize_func = TRUE;
+  window->has_maximize_func = TRUE;
+  window->has_move_func = TRUE;
+  window->has_resize_func = TRUE;
+
+  window->has_shade_func = TRUE;
+
+  window->has_fullscreen_func = TRUE;
+
+  window->always_sticky = FALSE;
+
+  window->wm_state_modal = FALSE;
+  window->skip_taskbar = FALSE;
+  window->skip_pager = FALSE;
+  window->wm_state_skip_taskbar = FALSE;
+  window->wm_state_skip_pager = FALSE;
+  window->wm_state_above = FALSE;
+  window->wm_state_below = FALSE;
+  window->wm_state_demands_attention = FALSE;
+
+  window->res_class = NULL;
+  window->res_name = NULL;
+  window->role = NULL;
+  window->sm_client_id = NULL;
+  window->wm_client_machine = NULL;
+  window->startup_id = NULL;
+
+  window->net_wm_pid = -1;
+
+  window->xtransient_for = None;
+  window->xclient_leader = None;
+  window->transient_parent_is_root_window = FALSE;
+
+  window->type = META_WINDOW_NORMAL;
+  window->type_atom = None;
+
+  window->struts = NULL;
+
+  window->using_net_wm_name              = FALSE;
+  window->using_net_wm_visible_name      = FALSE;
+  window->using_net_wm_icon_name         = FALSE;
+  window->using_net_wm_visible_icon_name = FALSE;
+
+  window->need_reread_icon = TRUE;
+
+  window->layer = META_LAYER_LAST; /* invalid value */
+  window->stack_position = -1;
+  window->initial_workspace = 0; /* not used */
+  window->initial_timestamp = 0; /* not used */
+
+  meta_display_register_x_window (display, &window->xwindow, window);
+
+
+  /* assign the window to its group, or create a new group if needed
+   */
+  window->group = NULL;
+  window->xgroup_leader = None;
+  meta_window_compute_group (window);
+
+  /* Fill these in the order we want them to be gotten.  we want to
+   * get window name and class first so we can use them in error
+   * messages and such.  However, name is modified depending on
+   * wm_client_machine, so push it slightly sooner.
+   */
+  i = 0;
+  initial_props[i++] = display->atom_WM_CLIENT_MACHINE;
+  initial_props[i++] = display->atom__NET_WM_PID;
+  initial_props[i++] = display->atom__NET_WM_NAME;
+  initial_props[i++] = XA_WM_CLASS;
+  initial_props[i++] = XA_WM_NAME;
+  initial_props[i++] = display->atom__NET_WM_ICON_NAME;
+  initial_props[i++] = XA_WM_ICON_NAME;
+  initial_props[i++] = display->atom__NET_WM_DESKTOP;
+  initial_props[i++] = display->atom__NET_STARTUP_ID;
+  initial_props[i++] = display->atom__NET_WM_SYNC_REQUEST_COUNTER;
+  initial_props[i++] = XA_WM_NORMAL_HINTS;
+  initial_props[i++] = display->atom_WM_PROTOCOLS;
+  initial_props[i++] = XA_WM_HINTS;
+  initial_props[i++] = display->atom__NET_WM_USER_TIME;
+  initial_props[i++] = display->atom__NET_WM_STATE;
+  initial_props[i++] = display->atom__MOTIF_WM_HINTS;
+  initial_props[i++] = XA_WM_TRANSIENT_FOR;
+  initial_props[i++] = display->atom__NET_WM_USER_TIME_WINDOW;
+  initial_props[i++] = display->atom__NET_WM_FULLSCREEN_MONITORS;
+  g_assert (N_INITIAL_PROPS == i);
+
+  meta_window_reload_properties (window, initial_props, N_INITIAL_PROPS, TRUE);
+
+  update_sm_hints (window); /* must come after transient_for */
+  meta_window_update_role (window);
+  meta_window_update_net_wm_type (window);
+  meta_window_update_icon_now (window);
+
+  if (window->initially_iconic)
+    {
+      /* WM_HINTS said minimized */
+      window->minimized = TRUE;
+      meta_verbose ("Window %s asked to start out minimized\n", window->desc);
+    }
+
+  if (existing_wm_state == IconicState)
+    {
+      /* WM_STATE said minimized */
+      window->minimized = TRUE;
+      meta_verbose ("Window %s had preexisting WM_STATE = IconicState, minimizing\n",
+                    window->desc);
+
+      /* Assume window was previously placed, though perhaps it's
+       * been iconic its whole life, we have no way of knowing.
+       */
+      window->placed = TRUE;
+    }
+
+  /* Apply any window attributes such as initial workspace
+   * based on startup notification
+   */
+  meta_screen_apply_startup_properties (window->screen, window);
+
+  /* Try to get a "launch timestamp" for the window.  If the window is
+   * a transient, we'd like to be able to get a last-usage timestamp
+   * from the parent window.  If the window has no parent, there isn't
+   * much we can do...except record the current time so that any children
+   * can use this time as a fallback.
+   */
+  if (!window->net_wm_user_time_set) {
+    MetaWindow *parent = NULL;
+    if (window->xtransient_for)
+      parent = meta_display_lookup_x_window (window->display,
+                                             window->xtransient_for);
+
+    /* First, maybe the app was launched with startup notification using an
+     * obsolete version of the spec; use that timestamp if it exists.
+     */
+    if (window->initial_timestamp_set)
+      /* NOTE: Do NOT toggle net_wm_user_time_set to true; this is just
+       * being recorded as a fallback for potential transients
+       */
+      window->net_wm_user_time = window->initial_timestamp;
+    else if (parent != NULL)
+      meta_window_set_user_time(window, parent->net_wm_user_time);
+    else
+      /* NOTE: Do NOT toggle net_wm_user_time_set to true; this is just
+       * being recorded as a fallback for potential transients
+       */
+      window->net_wm_user_time =
+        meta_display_get_current_time_roundtrip (window->display);
+  }
+
+  if (window->decorated)
+    meta_window_ensure_frame (window);
+
+  meta_window_grab_keys (window);
+  if (window->type != META_WINDOW_DOCK)
+    {
+      meta_display_grab_window_buttons (window->display, window->xwindow);
+      meta_display_grab_focus_window_button (window->display, window);
+    }
+
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK)
+    {
+      /* Change the default, but don't enforce this if the user
+       * focuses the dock/desktop and unsticks it using key shortcuts.
+       * Need to set this before adding to the workspaces so the MRU
+       * lists will be updated.
+       */
+      window->on_all_workspaces = TRUE;
+    }
+
+  /* For the workspace, first honor hints,
+   * if that fails put transients with parents,
+   * otherwise put window on active space
+   */
+
+  if (window->initial_workspace_set)
+    {
+      if (window->initial_workspace == (int) 0xFFFFFFFF)
+        {
+          meta_topic (META_DEBUG_PLACEMENT,
+                      "Window %s is initially on all spaces\n",
+                      window->desc);
+
+	  /* need to set on_all_workspaces first so that it will be
+	   * added to all the MRU lists
+	   */
+          window->on_all_workspaces = TRUE;
+          meta_workspace_add_window (window->screen->active_workspace, window);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_PLACEMENT,
+                      "Window %s is initially on space %d\n",
+                      window->desc, window->initial_workspace);
+
+          space =
+            meta_screen_get_workspace_by_index (window->screen,
+                                                window->initial_workspace);
+
+          if (space)
+            meta_workspace_add_window (space, window);
+        }
+    }
+
+  if (window->workspace == NULL &&
+      window->xtransient_for != None)
+    {
+      /* Try putting dialog on parent's workspace */
+      MetaWindow *parent;
+
+      parent = meta_display_lookup_x_window (window->display,
+                                             window->xtransient_for);
+
+      if (parent && parent->workspace)
+        {
+          meta_topic (META_DEBUG_PLACEMENT,
+                      "Putting window %s on same workspace as parent %s\n",
+                      window->desc, parent->desc);
+
+          if (parent->on_all_workspaces)
+            window->on_all_workspaces = TRUE;
+
+	  /* this will implicitly add to the appropriate MRU lists
+	   */
+          meta_workspace_add_window (parent->workspace, window);
+        }
+    }
+
+  if (window->workspace == NULL)
+    {
+      meta_topic (META_DEBUG_PLACEMENT,
+                  "Putting window %s on active workspace\n",
+                  window->desc);
+
+      space = window->screen->active_workspace;
+
+      meta_workspace_add_window (space, window);
+    }
+
+  /* for the various on_all_workspaces = TRUE possible above */
+  meta_window_set_current_workspace_hint (window);
+
+  meta_window_update_struts (window);
+
+  /* Must add window to stack before doing move/resize, since the
+   * window might have fullscreen size (i.e. should have been
+   * fullscreen'd; acrobat is one such braindead case; it withdraws
+   * and remaps its window whenever trying to become fullscreen...)
+   * and thus constraints may try to auto-fullscreen it which also
+   * means restacking it.
+   */
+  meta_stack_add (window->screen->stack,
+                  window);
+
+  /* Put our state back where it should be,
+   * passing TRUE for is_configure_request, ICCCM says
+   * initial map is handled same as configure request
+   */
+  flags =
+    META_IS_CONFIGURE_REQUEST | META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    window->size_hints.win_gravity,
+                                    window->size_hints.x,
+                                    window->size_hints.y,
+                                    window->size_hints.width,
+                                    window->size_hints.height);
+
+  /* Now try applying saved stuff from the session */
+  {
+    const MetaWindowSessionInfo *info;
+
+    info = meta_window_lookup_saved_state (window);
+
+    if (info)
+      {
+        meta_window_apply_session_info (window, info);
+        meta_window_release_saved_state (info);
+      }
+  }
+
+  /* FIXME we have a tendency to set this then immediately
+   * change it again.
+   */
+  set_wm_state (window, window->iconic ? IconicState : NormalState);
+  set_net_wm_state (window);
+
+  /* Sync stack changes */
+  meta_stack_thaw (window->screen->stack);
+
+  /* disable show desktop mode unless we're a desktop component */
+  maybe_leave_show_desktop_mode (window);
+
+  meta_window_queue (window, META_QUEUE_CALC_SHOWING);
+  /* See bug 303284; a transient of the given window can already exist, in which
+   * case we think it should probably be shown.
+   */
+  meta_window_foreach_transient (window,
+                                 queue_calc_showing_func,
+                                 NULL);
+  /* See bug 334899; the window may have minimized ancestors
+   * which need to be shown.
+   *
+   * However, we shouldn't unminimize windows here when opening
+   * a new display because that breaks passing _NET_WM_STATE_HIDDEN
+   * between window managers when replacing them; see bug 358042.
+   *
+   * And we shouldn't unminimize windows if they were initially
+   * iconic.
+   */
+  if (!display->display_opening && !window->initially_iconic)
+    unminimize_window_and_all_transient_parents (window);
+
+  meta_error_trap_pop (display, FALSE); /* pop the XSync()-reducing trap */
+  meta_display_ungrab (display);
+
+  window->constructing = FALSE;
+
+  return window;
+}
+
+/* This function should only be called from the end of meta_window_new_with_attrs () */
+static void
+meta_window_apply_session_info (MetaWindow *window,
+                                const MetaWindowSessionInfo *info)
+{
+  if (info->stack_position_set)
+    {
+      meta_topic (META_DEBUG_SM,
+                  "Restoring stack position %d for window %s\n",
+                  info->stack_position, window->desc);
+
+      /* FIXME well, I'm not sure how to do this. */
+    }
+
+  if (info->minimized_set)
+    {
+      meta_topic (META_DEBUG_SM,
+                  "Restoring minimized state %d for window %s\n",
+                  info->minimized, window->desc);
+
+      if (window->has_minimize_func && info->minimized)
+        meta_window_minimize (window);
+    }
+
+  if (info->maximized_set)
+    {
+      meta_topic (META_DEBUG_SM,
+                  "Restoring maximized state %d for window %s\n",
+                  info->maximized, window->desc);
+
+      if (window->has_maximize_func && info->maximized)
+        {
+          meta_window_maximize (window,
+                                META_MAXIMIZE_HORIZONTAL |
+                                META_MAXIMIZE_VERTICAL);
+
+          if (info->saved_rect_set)
+            {
+              meta_topic (META_DEBUG_SM,
+                          "Restoring saved rect %d,%d %dx%d for window %s\n",
+                          info->saved_rect.x,
+                          info->saved_rect.y,
+                          info->saved_rect.width,
+                          info->saved_rect.height,
+                          window->desc);
+
+              window->saved_rect.x = info->saved_rect.x;
+              window->saved_rect.y = info->saved_rect.y;
+              window->saved_rect.width = info->saved_rect.width;
+              window->saved_rect.height = info->saved_rect.height;
+            }
+	}
+    }
+
+  if (info->on_all_workspaces_set)
+    {
+      window->on_all_workspaces = info->on_all_workspaces;
+      meta_topic (META_DEBUG_SM,
+                  "Restoring sticky state %d for window %s\n",
+                  window->on_all_workspaces, window->desc);
+    }
+
+  if (info->workspace_indices)
+    {
+      GSList *tmp;
+      GSList *spaces;
+
+      spaces = NULL;
+
+      tmp = info->workspace_indices;
+      while (tmp != NULL)
+        {
+          MetaWorkspace *space;
+
+          space =
+            meta_screen_get_workspace_by_index (window->screen,
+                                                GPOINTER_TO_INT (tmp->data));
+
+          if (space)
+            spaces = g_slist_prepend (spaces, space);
+
+          tmp = tmp->next;
+        }
+
+      if (spaces)
+        {
+          /* This briefly breaks the invariant that we are supposed
+           * to always be on some workspace. But we paranoically
+           * ensured that one of the workspaces from the session was
+           * indeed valid, so we know we'll go right back to one.
+           */
+          if (window->workspace)
+            meta_workspace_remove_window (window->workspace, window);
+
+          /* Only restore to the first workspace if the window
+           * happened to be on more than one, since we have replaces
+           * window->workspaces with window->workspace
+           */
+          meta_workspace_add_window (spaces->data, window);
+
+          meta_topic (META_DEBUG_SM,
+                      "Restoring saved window %s to workspace %d\n",
+                      window->desc,
+                      meta_workspace_index (spaces->data));
+
+          g_slist_free (spaces);
+        }
+    }
+
+  if (info->geometry_set)
+    {
+      int x, y, w, h;
+      MetaMoveResizeFlags flags;
+
+      window->placed = TRUE; /* don't do placement algorithms later */
+
+      x = info->rect.x;
+      y = info->rect.y;
+
+      w = window->size_hints.base_width +
+        info->rect.width * window->size_hints.width_inc;
+      h = window->size_hints.base_height +
+        info->rect.height * window->size_hints.height_inc;
+
+      /* Force old gravity, ignoring anything now set */
+      window->size_hints.win_gravity = info->gravity;
+
+      meta_topic (META_DEBUG_SM,
+                  "Restoring pos %d,%d size %d x %d for %s\n",
+                  x, y, w, h, window->desc);
+
+      flags = META_DO_GRAVITY_ADJUST | META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
+      meta_window_move_resize_internal (window,
+                                        flags,
+                                        window->size_hints.win_gravity,
+                                        x, y, w, h);
+    }
+}
+
+void
+meta_window_free (MetaWindow  *window,
+                  guint32      timestamp)
+{
+  GList *tmp;
+
+  meta_verbose ("Unmanaging 0x%lx\n", window->xwindow);
+
+  if (window->display->compositor)
+    meta_compositor_free_window (window->display->compositor, window);
+
+  if (window->display->window_with_menu == window)
+    {
+      meta_ui_window_menu_free (window->display->window_menu);
+      window->display->window_menu = NULL;
+      window->display->window_with_menu = NULL;
+    }
+
+  if (destroying_windows_disallowed > 0)
+    meta_bug ("Tried to destroy window %s while destruction was not allowed\n",
+              window->desc);
+
+  window->unmanaging = TRUE;
+
+  if (window->fullscreen)
+    {
+      MetaGroup *group;
+
+      /* If the window is fullscreen, it may be forcing
+       * other windows in its group to a higher layer
+       */
+
+      meta_stack_freeze (window->screen->stack);
+      group = meta_window_get_group (window);
+      if (group)
+        meta_group_update_layers (group);
+      meta_stack_thaw (window->screen->stack);
+    }
+
+  meta_window_shutdown_group (window); /* safe to do this early as
+                                        * group.c won't re-add to the
+                                        * group if window->unmanaging
+                                        */
+
+  /* If we have the focus, focus some other window.
+   * This is done first, so that if the unmap causes
+   * an EnterNotify the EnterNotify will have final say
+   * on what gets focused, maintaining sloppy focus
+   * invariants.
+   */
+  if (window->has_focus)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing default window since we're unmanaging %s\n",
+                  window->desc);
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window,
+                                           timestamp);
+    }
+  else if (window->display->expected_focus_window == window)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing default window since expected focus window freed %s\n",
+                  window->desc);
+      window->display->expected_focus_window = NULL;
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window,
+                                           timestamp);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Unmanaging window %s which doesn't currently have focus\n",
+                  window->desc);
+    }
+
+  if (window->struts)
+    {
+      meta_free_gslist_and_elements (window->struts);
+      window->struts = NULL;
+
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Unmanaging window %s which has struts, so invalidating work areas\n",
+                  window->desc);
+      invalidate_work_areas (window);
+    }
+
+  if (window->display->grab_window == window)
+    meta_display_end_grab_op (window->display, timestamp);
+
+  g_assert (window->display->grab_window != window);
+
+  if (window->display->focus_window == window)
+    {
+      window->display->focus_window = NULL;
+      meta_compositor_set_active_window (window->display->compositor,
+                                         window->screen, NULL);
+    }
+
+  if (window->maximized_horizontally || window->maximized_vertically)
+    unmaximize_window_before_freeing (window);
+
+  /* The XReparentWindow call in meta_window_destroy_frame() moves the
+   * window so we need to send a configure notify; see bug 399552.  (We
+   * also do this just in case a window got unmaximized.)
+   */
+  send_configure_notify (window);
+
+  meta_window_unqueue (window, META_QUEUE_CALC_SHOWING |
+                               META_QUEUE_MOVE_RESIZE |
+                               META_QUEUE_UPDATE_ICON);
+  meta_window_free_delete_dialog (window);
+
+  if (window->workspace)
+    meta_workspace_remove_window (window->workspace, window);
+
+  g_assert (window->workspace == NULL);
+
+#ifndef G_DISABLE_CHECKS
+  tmp = window->screen->workspaces;
+  while (tmp != NULL)
+    {
+      MetaWorkspace *workspace = tmp->data;
+
+      g_assert (g_list_find (workspace->windows, window) == NULL);
+      g_assert (g_list_find (workspace->mru_list, window) == NULL);
+
+      tmp = tmp->next;
+    }
+#endif
+
+  meta_stack_remove (window->screen->stack, window);
+
+  if (window->frame)
+    meta_window_destroy_frame (window);
+
+  if (window->withdrawn)
+    {
+      /* We need to clean off the window's state so it
+       * won't be restored if the app maps it again.
+       */
+      meta_error_trap_push (window->display);
+      meta_verbose ("Cleaning state from window %s\n", window->desc);
+      XDeleteProperty (window->display->xdisplay,
+                       window->xwindow,
+                       window->display->atom__NET_WM_DESKTOP);
+      XDeleteProperty (window->display->xdisplay,
+                       window->xwindow,
+                       window->display->atom__NET_WM_STATE);
+      XDeleteProperty (window->display->xdisplay,
+                       window->xwindow,
+                       window->display->atom__NET_WM_FULLSCREEN_MONITORS);
+      set_wm_state (window, WithdrawnState);
+      meta_error_trap_pop (window->display, FALSE);
+    }
+  else
+    {
+      /* We need to put WM_STATE so that others will understand it on
+       * restart.
+       */
+      if (!window->minimized)
+        {
+          meta_error_trap_push (window->display);
+          set_wm_state (window, NormalState);
+          meta_error_trap_pop (window->display, FALSE);
+        }
+
+      /* And we need to be sure the window is mapped so other WMs
+       * know that it isn't Withdrawn
+       */
+      meta_error_trap_push (window->display);
+      XMapWindow (window->display->xdisplay,
+                  window->xwindow);
+      meta_error_trap_pop (window->display, FALSE);
+    }
+
+  meta_window_ungrab_keys (window);
+  meta_display_ungrab_window_buttons (window->display, window->xwindow);
+  meta_display_ungrab_focus_window_button (window->display, window);
+
+  meta_display_unregister_x_window (window->display, window->xwindow);
+
+
+  meta_error_trap_push (window->display);
+
+  /* Put back anything we messed up */
+  if (window->border_width != 0)
+    XSetWindowBorderWidth (window->display->xdisplay,
+                           window->xwindow,
+                           window->border_width);
+
+  /* No save set */
+  XRemoveFromSaveSet (window->display->xdisplay,
+                      window->xwindow);
+
+  /* Don't get events on not-managed windows */
+  XSelectInput (window->display->xdisplay,
+                window->xwindow,
+                NoEventMask);
+
+  /* Stop getting events for the window's _NET_WM_USER_TIME_WINDOW too */
+  if (window->user_time_window != None)
+    {
+      meta_display_unregister_x_window (window->display,
+                                        window->user_time_window);
+      XSelectInput (window->display->xdisplay,
+                    window->user_time_window,
+                    NoEventMask);
+      window->user_time_window = None;
+    }
+
+#ifdef HAVE_SHAPE
+  if (META_DISPLAY_HAS_SHAPE (window->display))
+    XShapeSelectInput (window->display->xdisplay, window->xwindow, NoEventMask);
+#endif
+
+  meta_error_trap_pop (window->display, FALSE);
+
+  if (window->icon)
+    g_object_unref (G_OBJECT (window->icon));
+
+  if (window->mini_icon)
+    g_object_unref (G_OBJECT (window->mini_icon));
+
+  meta_icon_cache_free (&window->icon_cache);
+
+  g_free (window->sm_client_id);
+  g_free (window->wm_client_machine);
+  g_free (window->startup_id);
+  g_free (window->role);
+  g_free (window->res_class);
+  g_free (window->res_name);
+  g_free (window->title);
+  g_free (window->icon_name);
+  g_free (window->desc);
+  g_free (window);
+}
+
+static void
+set_wm_state (MetaWindow *window,
+              int         state)
+{
+  unsigned long data[2];
+
+  meta_verbose ("Setting wm state %s on %s\n",
+                wm_state_to_string (state), window->desc);
+
+  /* Marco doesn't use icon windows, so data[1] should be None
+   * according to the ICCCM 2.0 Section 4.1.3.1.
+   */
+  data[0] = state;
+  data[1] = None;
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom_WM_STATE,
+                   window->display->atom_WM_STATE,
+                   32, PropModeReplace, (guchar*) data, 2);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+static void
+set_net_wm_state (MetaWindow *window)
+{
+  int i;
+  unsigned long data[12];
+
+  i = 0;
+  if (window->shaded)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_SHADED;
+      ++i;
+    }
+  if (window->wm_state_modal)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_MODAL;
+      ++i;
+    }
+  if (window->skip_pager)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_SKIP_PAGER;
+      ++i;
+    }
+  if (window->skip_taskbar)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_SKIP_TASKBAR;
+      ++i;
+    }
+  if (window->maximized_horizontally)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_MAXIMIZED_HORZ;
+      ++i;
+    }
+  if (window->maximized_vertically)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_MAXIMIZED_VERT;
+      ++i;
+    }
+  if (window->fullscreen)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_FULLSCREEN;
+      ++i;
+    }
+  if (!meta_window_showing_on_its_workspace (window) || window->shaded)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_HIDDEN;
+      ++i;
+    }
+  if (window->wm_state_above)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_ABOVE;
+      ++i;
+    }
+  if (window->wm_state_below)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_BELOW;
+      ++i;
+    }
+  if (window->wm_state_demands_attention)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_DEMANDS_ATTENTION;
+      ++i;
+    }
+  if (window->on_all_workspaces)
+    {
+      data[i] = window->display->atom__NET_WM_STATE_STICKY;
+      ++i;
+    }
+
+  meta_verbose ("Setting _NET_WM_STATE with %d atoms\n", i);
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom__NET_WM_STATE,
+                   XA_ATOM,
+                   32, PropModeReplace, (guchar*) data, i);
+  meta_error_trap_pop (window->display, FALSE);
+
+  if (window->fullscreen)
+    {
+      data[0] = window->fullscreen_monitors[0];
+      data[1] = window->fullscreen_monitors[1];
+      data[2] = window->fullscreen_monitors[2];
+      data[3] = window->fullscreen_monitors[3];
+
+      meta_verbose ("Setting _NET_WM_FULLSCREEN_MONITORS\n");
+      meta_error_trap_push (window->display);
+      XChangeProperty (window->display->xdisplay,
+                       window->xwindow,
+                       window->display->atom__NET_WM_FULLSCREEN_MONITORS,
+                       XA_CARDINAL, 32, PropModeReplace,
+                       (guchar*) data, 4);
+      meta_error_trap_pop (window->display, FALSE);
+    }
+}
+
+gboolean
+meta_window_located_on_workspace (MetaWindow    *window,
+                                  MetaWorkspace *workspace)
+{
+  return (window->on_all_workspaces && window->screen == workspace->screen) ||
+    (window->workspace == workspace);
+}
+
+static gboolean
+is_minimized_foreach (MetaWindow *window,
+                      void       *data)
+{
+  gboolean *result = data;
+
+  *result = window->minimized;
+  if (*result)
+    return FALSE; /* stop as soon as we find one */
+  else
+    return TRUE;
+}
+
+static gboolean
+ancestor_is_minimized (MetaWindow *window)
+{
+  gboolean is_minimized;
+
+  is_minimized = FALSE;
+
+  meta_window_foreach_ancestor (window, is_minimized_foreach, &is_minimized);
+
+  return is_minimized;
+}
+
+gboolean
+meta_window_showing_on_its_workspace (MetaWindow *window)
+{
+  gboolean showing;
+  gboolean is_desktop_or_dock;
+  MetaWorkspace* workspace_of_window;
+
+  showing = TRUE;
+
+  /* 1. See if we're minimized */
+  if (window->minimized)
+    showing = FALSE;
+
+  /* 2. See if we're in "show desktop" mode */
+  is_desktop_or_dock = FALSE;
+  is_desktop_or_dock_foreach (window,
+                              &is_desktop_or_dock);
+
+  meta_window_foreach_ancestor (window, is_desktop_or_dock_foreach,
+                                &is_desktop_or_dock);
+
+  if (window->on_all_workspaces)
+    workspace_of_window = window->screen->active_workspace;
+  else if (window->workspace)
+    workspace_of_window = window->workspace;
+  else /* This only seems to be needed for startup */
+    workspace_of_window = NULL;
+
+  if (showing &&
+      workspace_of_window && workspace_of_window->showing_desktop &&
+      !is_desktop_or_dock)
+    {
+      meta_verbose ("We're showing the desktop on the workspace(s) that window %s is on\n",
+                    window->desc);
+      showing = FALSE;
+    }
+
+  /* 3. See if an ancestor is minimized (note that
+   *    ancestor's "mapped" field may not be up to date
+   *    since it's being computed in this same idle queue)
+   */
+
+  if (showing)
+    {
+      if (ancestor_is_minimized (window))
+        showing = FALSE;
+    }
+
+#if 0
+  /* 4. See if we're drawing wireframe
+   */
+  if (window->display->grab_window == window &&
+      window->display->grab_wireframe_active)
+    showing = FALSE;
+#endif
+
+  return showing;
+}
+
+gboolean
+meta_window_should_be_showing (MetaWindow  *window)
+{
+  gboolean on_workspace;
+
+  meta_verbose ("Should be showing for window %s\n", window->desc);
+
+  /* See if we're on the workspace */
+  on_workspace = meta_window_located_on_workspace (window,
+                                                   window->screen->active_workspace);
+
+  if (!on_workspace)
+    meta_verbose ("Window %s is not on workspace %d\n",
+                  window->desc,
+                  meta_workspace_index (window->screen->active_workspace));
+  else
+    meta_verbose ("Window %s is on the active workspace %d\n",
+                  window->desc,
+                  meta_workspace_index (window->screen->active_workspace));
+
+  if (window->on_all_workspaces)
+    meta_verbose ("Window %s is on all workspaces\n", window->desc);
+
+  return on_workspace && meta_window_showing_on_its_workspace (window);
+}
+
+static void
+finish_minimize (gpointer data)
+{
+  MetaWindow *window = data;
+  /* FIXME: It really sucks to put timestamp pinging here; it'd
+   * probably make more sense in implement_showing() so that it's at
+   * least not duplicated in meta_window_show; but since
+   * finish_minimize is a callback making things just slightly icky, I
+   * haven't done that yet.
+   */
+  guint32 timestamp = meta_display_get_current_time_roundtrip (window->display);
+
+  meta_window_hide (window);
+  if (window->has_focus)
+    {
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window,
+                                           timestamp);
+    }
+}
+
+static void
+implement_showing (MetaWindow *window,
+                   gboolean    showing)
+{
+  /* Actually show/hide the window */
+  meta_verbose ("Implement showing = %d for window %s\n",
+                showing, window->desc);
+
+  if (!showing)
+    {
+      gboolean on_workspace;
+
+      on_workspace = meta_window_located_on_workspace (window,
+                                                       window->screen->active_workspace);
+
+      /* Really this effects code should probably
+       * be in meta_window_hide so the window->mapped
+       * test isn't duplicated here. Anyhow, we animate
+       * if we are mapped now, we are supposed to
+       * be minimized, and we are on the current workspace.
+       */
+      if (on_workspace && window->minimized && window->mapped &&
+          !meta_prefs_get_reduced_resources ())
+        {
+          MetaRectangle icon_rect, window_rect;
+          gboolean result;
+
+          /* Check if the window has an icon geometry */
+          result = meta_window_get_icon_geometry (window, &icon_rect);
+
+          if (!result)
+            {
+              /* just animate into the corner somehow - maybe
+               * not a good idea...
+               */
+              icon_rect.x = window->screen->rect.width;
+              icon_rect.y = window->screen->rect.height;
+              icon_rect.width = 1;
+              icon_rect.height = 1;
+            }
+
+          meta_window_get_outer_rect (window, &window_rect);
+
+          meta_effect_run_minimize (window,
+                                    &window_rect,
+                                    &icon_rect,
+                                    finish_minimize,
+                                    window);
+        }
+      else
+        {
+          finish_minimize (window);
+        }
+    }
+  else
+    {
+      meta_window_show (window);
+    }
+}
+
+void
+meta_window_calc_showing (MetaWindow  *window)
+{
+  implement_showing (window, meta_window_should_be_showing (window));
+}
+
+static guint queue_idle[NUMBER_OF_QUEUES] = {0, 0, 0};
+static GSList *queue_pending[NUMBER_OF_QUEUES] = {NULL, NULL, NULL};
+
+static int
+stackcmp (gconstpointer a, gconstpointer b)
+{
+  MetaWindow *aw = (gpointer) a;
+  MetaWindow *bw = (gpointer) b;
+
+  if (aw->screen != bw->screen)
+    return 0; /* don't care how they sort with respect to each other */
+  else
+    return meta_stack_windows_cmp (aw->screen->stack,
+                                   aw, bw);
+}
+
+static gboolean
+idle_calc_showing (gpointer data)
+{
+  GSList *tmp;
+  GSList *copy;
+  GSList *should_show;
+  GSList *should_hide;
+  GSList *unplaced;
+  GSList *displays;
+  MetaWindow *first_window;
+  guint queue_index = GPOINTER_TO_INT (data);
+
+  meta_topic (META_DEBUG_WINDOW_STATE,
+              "Clearing the calc_showing queue\n");
+
+  /* Work with a copy, for reentrancy. The allowed reentrancy isn't
+   * complete; destroying a window while we're in here would result in
+   * badness. But it's OK to queue/unqueue calc_showings.
+   */
+  copy = g_slist_copy (queue_pending[queue_index]);
+  g_slist_free (queue_pending[queue_index]);
+  queue_pending[queue_index] = NULL;
+  queue_idle[queue_index] = 0;
+
+  destroying_windows_disallowed += 1;
+
+  /* We map windows from top to bottom and unmap from bottom to
+   * top, to avoid extra expose events. The exception is
+   * for unplaced windows, which have to be mapped from bottom to
+   * top so placement works.
+   */
+  should_show = NULL;
+  should_hide = NULL;
+  unplaced = NULL;
+  displays = NULL;
+
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      if (!window->placed)
+        unplaced = g_slist_prepend (unplaced, window);
+      else if (meta_window_should_be_showing (window))
+        should_show = g_slist_prepend (should_show, window);
+      else
+        should_hide = g_slist_prepend (should_hide, window);
+
+      tmp = tmp->next;
+    }
+
+  /* bottom to top */
+  unplaced = g_slist_sort (unplaced, stackcmp);
+  should_hide = g_slist_sort (should_hide, stackcmp);
+  /* top to bottom */
+  should_show = g_slist_sort (should_show, stackcmp);
+  should_show = g_slist_reverse (should_show);
+
+  first_window = copy->data;
+
+  meta_display_grab (first_window->display);
+
+  tmp = unplaced;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      meta_window_calc_showing (window);
+
+      tmp = tmp->next;
+    }
+
+  tmp = should_show;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      implement_showing (window, TRUE);
+
+      tmp = tmp->next;
+    }
+
+  tmp = should_hide;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      implement_showing (window, FALSE);
+
+      tmp = tmp->next;
+    }
+
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      /* important to set this here for reentrancy -
+       * if we queue a window again while it's in "copy",
+       * then queue_calc_showing will just return since
+       * we are still in the calc_showing queue
+       */
+      window->is_in_queues &= ~META_QUEUE_CALC_SHOWING;
+
+      tmp = tmp->next;
+    }
+
+  if (meta_prefs_get_focus_mode () != META_FOCUS_MODE_CLICK)
+    {
+      /* When display->mouse_mode is false, we want to ignore
+       * EnterNotify events unless they come from mouse motion.  To do
+       * that, we set a sentinel property on the root window if we're
+       * not in mouse_mode.
+       */
+      tmp = should_show;
+      while (tmp != NULL)
+        {
+          MetaWindow *window = tmp->data;
+
+          if (!window->display->mouse_mode)
+            meta_display_increment_focus_sentinel (window->display);
+
+          tmp = tmp->next;
+        }
+    }
+
+  meta_display_ungrab (first_window->display);
+
+  g_slist_free (copy);
+
+  g_slist_free (unplaced);
+  g_slist_free (should_show);
+  g_slist_free (should_hide);
+  g_slist_free (displays);
+
+  destroying_windows_disallowed -= 1;
+
+  return FALSE;
+}
+
+#ifdef WITH_VERBOSE_MODE
+static const gchar* meta_window_queue_names[NUMBER_OF_QUEUES] =
+  {"calc_showing", "move_resize", "update_icon"};
+#endif
+
+static void
+meta_window_unqueue (MetaWindow *window, guint queuebits)
+{
+  gint queuenum;
+
+  for (queuenum=0; queuenum<NUMBER_OF_QUEUES; queuenum++)
+    {
+      if ((queuebits & 1<<queuenum) /* they have asked to unqueue */
+          &&
+          (window->is_in_queues & 1<<queuenum)) /* it's in the queue */
+        {
+
+          meta_topic (META_DEBUG_WINDOW_STATE,
+              "Removing %s from the %s queue\n",
+              window->desc,
+              meta_window_queue_names[queuenum]);
+
+          /* Note that window may not actually be in the queue
+           * because it may have been in "copy" inside the idle handler
+           */
+          queue_pending[queuenum] = g_slist_remove (queue_pending[queuenum], window);
+          window->is_in_queues &= ~(1<<queuenum);
+
+          /* Okay, so maybe we've used up all the entries in the queue.
+           * In that case, we should kill the function that deals with
+           * the queue, because there's nothing left for it to do.
+           */
+          if (queue_pending[queuenum] == NULL && queue_idle[queuenum] != 0)
+            {
+              g_source_remove (queue_idle[queuenum]);
+              queue_idle[queuenum] = 0;
+            }
+        }
+    }
+}
+
+static void
+meta_window_flush_calc_showing (MetaWindow *window)
+{
+  if (window->is_in_queues & META_QUEUE_CALC_SHOWING)
+    {
+      meta_window_unqueue (window, META_QUEUE_CALC_SHOWING);
+      meta_window_calc_showing (window);
+    }
+}
+
+void
+meta_window_queue (MetaWindow *window, guint queuebits)
+{
+  guint queuenum;
+
+  for (queuenum=0; queuenum<NUMBER_OF_QUEUES; queuenum++)
+    {
+      if (queuebits & 1<<queuenum)
+        {
+          /* Data which varies between queues.
+           * Yes, these do look a lot like associative arrays:
+           * I seem to be turning into a Perl programmer.
+           */
+
+          const gint window_queue_idle_priority[NUMBER_OF_QUEUES] =
+            {
+              G_PRIORITY_DEFAULT_IDLE,  /* CALC_SHOWING */
+              META_PRIORITY_RESIZE,     /* MOVE_RESIZE */
+              G_PRIORITY_DEFAULT_IDLE   /* UPDATE_ICON */
+            };
+
+          const GSourceFunc window_queue_idle_handler[NUMBER_OF_QUEUES] =
+            {
+              idle_calc_showing,
+              idle_move_resize,
+              idle_update_icon,
+            };
+
+          /* If we're about to drop the window, there's no point in putting
+           * it on a queue.
+           */
+          if (window->unmanaging)
+            break;
+
+          /* If the window already claims to be in that queue, there's no
+           * point putting it in the queue.
+           */
+          if (window->is_in_queues & 1<<queuenum)
+            break;
+
+          meta_topic (META_DEBUG_WINDOW_STATE,
+              "Putting %s in the %s queue\n",
+              window->desc,
+              meta_window_queue_names[queuenum]);
+
+          /* So, mark it as being in this queue. */
+          window->is_in_queues |= 1<<queuenum;
+
+          /* There's not a lot of point putting things into a queue if
+           * nobody's on the other end pulling them out. Therefore,
+           * let's check to see whether an idle handler exists to do
+           * that. If not, we'll create one.
+           */
+
+          if (queue_idle[queuenum] == 0)
+            queue_idle[queuenum] = g_idle_add_full
+              (
+                window_queue_idle_priority[queuenum],
+                window_queue_idle_handler[queuenum],
+                GUINT_TO_POINTER(queuenum),
+                NULL
+              );
+
+          /* And now we actually put it on the queue. */
+          queue_pending[queuenum] = g_slist_prepend (queue_pending[queuenum],
+                                                     window);
+      }
+  }
+}
+
+static gboolean
+intervening_user_event_occurred (MetaWindow *window)
+{
+  guint32 compare;
+  MetaWindow *focus_window;
+
+  focus_window = window->display->focus_window;
+
+  meta_topic (META_DEBUG_STARTUP,
+              "COMPARISON:\n"
+              "  net_wm_user_time_set : %d\n"
+              "  net_wm_user_time     : %u\n"
+              "  initial_timestamp_set: %d\n"
+              "  initial_timestamp    : %u\n",
+              window->net_wm_user_time_set,
+              window->net_wm_user_time,
+              window->initial_timestamp_set,
+              window->initial_timestamp);
+  if (focus_window != NULL)
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "COMPARISON (continued):\n"
+                  "  focus_window             : %s\n"
+                  "  fw->net_wm_user_time_set : %d\n"
+                  "  fw->net_wm_user_time     : %u\n",
+                  focus_window->desc,
+                  focus_window->net_wm_user_time_set,
+                  focus_window->net_wm_user_time);
+    }
+
+  /* We expect the most common case for not focusing a new window
+   * to be when a hint to not focus it has been set.  Since we can
+   * deal with that case rapidly, we use special case it--this is
+   * merely a preliminary optimization.  :)
+   */
+  if ( ((window->net_wm_user_time_set == TRUE) &&
+       (window->net_wm_user_time == 0))
+      ||
+       ((window->initial_timestamp_set == TRUE) &&
+       (window->initial_timestamp == 0)))
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "window %s explicitly requested no focus\n",
+                  window->desc);
+      return TRUE;
+    }
+
+  if (!(window->net_wm_user_time_set) && !(window->initial_timestamp_set))
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "no information about window %s found\n",
+                  window->desc);
+      return FALSE;
+    }
+
+  if (focus_window != NULL &&
+      !focus_window->net_wm_user_time_set)
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "focus window, %s, doesn't have a user time set yet!\n",
+                  window->desc);
+      return FALSE;
+    }
+
+  /* To determine the "launch" time of an application,
+   * startup-notification can set the TIMESTAMP and the
+   * application (usually via its toolkit such as gtk or qt) can
+   * set the _NET_WM_USER_TIME.  If both are set, we need to be
+   * using the newer of the two values.
+   *
+   * See http://bugzilla.gnome.org/show_bug.cgi?id=573922
+   */
+  compare = 0;
+  if (window->net_wm_user_time_set &&
+      window->initial_timestamp_set)
+    compare =
+      XSERVER_TIME_IS_BEFORE (window->net_wm_user_time,
+                              window->initial_timestamp) ?
+      window->initial_timestamp : window->net_wm_user_time;
+  else if (window->net_wm_user_time_set)
+    compare = window->net_wm_user_time;
+  else if (window->initial_timestamp_set)
+    compare = window->initial_timestamp;
+
+  if ((focus_window != NULL) &&
+      XSERVER_TIME_IS_BEFORE (compare, focus_window->net_wm_user_time))
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "window %s focus prevented by other activity; %u < %u\n",
+                  window->desc,
+                  compare,
+                  focus_window->net_wm_user_time);
+      return TRUE;
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "new window %s with no intervening events\n",
+                  window->desc);
+      return FALSE;
+    }
+}
+
+/* This function is an ugly hack.  It's experimental in nature and ought to be
+ * replaced by a real hint from the app to the WM if we decide the experimental
+ * behavior is worthwhile.  The basic idea is to get more feedback about how
+ * usage scenarios of "strict" focus users and what they expect.  See #326159.
+ */
+gboolean
+__window_is_terminal (MetaWindow *window)
+{
+  if (window == NULL || window->res_class == NULL)
+    return FALSE;
+
+  /*
+   * Compare res_class, which is not user-settable, and thus theoretically
+   * a more-reliable indication of term-ness.
+   */
+
+  /* mate-terminal -- if you couldn't guess */
+  if (strcmp (window->res_class, "Mate-terminal") == 0)
+    return TRUE;
+  /* xterm, rxvt, aterm */
+  else if (strcmp (window->res_class, "XTerm") == 0)
+    return TRUE;
+  /* konsole, KDE's terminal program */
+  else if (strcmp (window->res_class, "Konsole") == 0)
+    return TRUE;
+  /* rxvt-unicode */
+  else if (strcmp (window->res_class, "URxvt") == 0)
+    return TRUE;
+  /* eterm */
+  else if (strcmp (window->res_class, "Eterm") == 0)
+    return TRUE;
+  /* KTerm -- some terminal not KDE based; so not like Konsole */
+  else if (strcmp (window->res_class, "KTerm") == 0)
+    return TRUE;
+  /* Multi-mate-terminal */
+  else if (strcmp (window->res_class, "Multi-mate-terminal") == 0)
+    return TRUE;
+  /* mlterm ("multi lingual terminal emulator on X") */
+  else if (strcmp (window->res_class, "mlterm") == 0)
+    return TRUE;
+  /* Terminal -- XFCE Terminal */
+  else if (strcmp (window->res_class, "Terminal") == 0)
+    return TRUE;
+
+  return FALSE;
+}
+
+/* This function determines what state the window should have assuming that it
+ * and the focus_window have no relation
+ */
+static void
+window_state_on_map (MetaWindow *window,
+                     gboolean *takes_focus,
+                     gboolean *places_on_top)
+{
+  gboolean intervening_events;
+
+  intervening_events = intervening_user_event_occurred (window);
+
+  *takes_focus = !intervening_events;
+  *places_on_top = *takes_focus;
+
+  /* don't initially focus windows that are intended to not accept
+   * focus
+   */
+  if (!(window->input || window->take_focus))
+    {
+      *takes_focus = FALSE;
+      return;
+    }
+
+  /* Terminal usage may be different; some users intend to launch
+   * many apps in quick succession or to just view things in the new
+   * window while still interacting with the terminal.  In that case,
+   * apps launched from the terminal should not take focus.  This
+   * isn't quite the same as not allowing focus to transfer from
+   * terminals due to new window map, but the latter is a much easier
+   * approximation to enforce so we do that.
+   */
+  if (*takes_focus &&
+      meta_prefs_get_focus_new_windows () == META_FOCUS_NEW_WINDOWS_STRICT &&
+      !window->display->allow_terminal_deactivation &&
+      __window_is_terminal (window->display->focus_window) &&
+      !meta_window_is_ancestor_of_transient (window->display->focus_window,
+                                             window))
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "focus_window is terminal; not focusing new window.\n");
+      *takes_focus = FALSE;
+      *places_on_top = FALSE;
+    }
+
+  switch (window->type)
+    {
+    case META_WINDOW_UTILITY:
+    case META_WINDOW_TOOLBAR:
+      *takes_focus = FALSE;
+      *places_on_top = FALSE;
+      break;
+    case META_WINDOW_DOCK:
+    case META_WINDOW_DESKTOP:
+    case META_WINDOW_SPLASHSCREEN:
+    case META_WINDOW_MENU:
+      /* don't focus any of these; places_on_top may be irrelevant for some of
+       * these (e.g. dock)--but you never know--the focus window might also be
+       * of the same type in some weird situation...
+       */
+      *takes_focus = FALSE;
+      break;
+    case META_WINDOW_NORMAL:
+    case META_WINDOW_DIALOG:
+    case META_WINDOW_MODAL_DIALOG:
+      /* The default is correct for these */
+      break;
+    }
+}
+
+static gboolean
+windows_overlap (const MetaWindow *w1, const MetaWindow *w2)
+{
+  MetaRectangle w1rect, w2rect;
+  meta_window_get_outer_rect (w1, &w1rect);
+  meta_window_get_outer_rect (w2, &w2rect);
+  return meta_rectangle_overlap (&w1rect, &w2rect);
+}
+
+/* Returns whether a new window would be covered by any
+ * existing window on the same workspace that is set
+ * to be "above" ("always on top").  A window that is not
+ * set "above" would be underneath the new window anyway.
+ *
+ * We take "covered" to mean even partially covered, but
+ * some people might prefer entirely covered.  I think it
+ * is more useful to behave this way if any part of the
+ * window is covered, because a partial coverage could be
+ * (say) ninety per cent and almost indistinguishable from total.
+ */
+static gboolean
+window_would_be_covered (const MetaWindow *newbie)
+{
+  MetaWorkspace *workspace = newbie->workspace;
+  GList *tmp, *windows;
+
+  windows = meta_workspace_list_windows (workspace);
+
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      if (w->wm_state_above && w != newbie)
+        {
+          /* We have found a window that is "above". Perhaps it overlaps. */
+          if (windows_overlap (w, newbie))
+            {
+              g_list_free (windows); /* clean up... */
+              return TRUE; /* yes, it does */
+            }
+        }
+
+      tmp = tmp->next;
+    }
+
+  g_list_free (windows);
+  return FALSE; /* none found */
+}
+
+/* XXX META_EFFECT_*_MAP */
+void
+meta_window_show (MetaWindow *window)
+{
+  gboolean did_show;
+  gboolean takes_focus_on_map;
+  gboolean place_on_top_on_map;
+  gboolean needs_stacking_adjustment;
+  MetaWindow *focus_window;
+  guint32     timestamp;
+
+  /* FIXME: It really sucks to put timestamp pinging here; it'd
+   * probably make more sense in implement_showing() so that it's at
+   * least not duplicated in finish_minimize.  *shrug*
+   */
+  timestamp = meta_display_get_current_time_roundtrip (window->display);
+
+  meta_topic (META_DEBUG_WINDOW_STATE,
+              "Showing window %s, shaded: %d iconic: %d placed: %d\n",
+              window->desc, window->shaded, window->iconic, window->placed);
+
+  focus_window = window->display->focus_window;  /* May be NULL! */
+  did_show = FALSE;
+  window_state_on_map (window, &takes_focus_on_map, &place_on_top_on_map);
+  needs_stacking_adjustment = FALSE;
+
+  meta_topic (META_DEBUG_WINDOW_STATE,
+              "Window %s %s focus on map, and %s place on top on map.\n",
+              window->desc,
+              takes_focus_on_map ? "does" : "does not",
+              place_on_top_on_map ? "does" : "does not");
+
+  /* Now, in some rare cases we should *not* put a new window on top.
+   * These cases include certain types of windows showing for the first
+   * time, and any window which would be covered because of another window
+   * being set "above" ("always on top").
+   *
+   * FIXME: Although "place_on_top_on_map" and "takes_focus_on_map" are
+   * generally based on the window type, there is a special case when the
+   * focus window is a terminal for them both to be false; this should
+   * probably rather be a term in the "if" condition below.
+   */
+
+  if ( focus_window != NULL && window->showing_for_first_time &&
+      ( (!place_on_top_on_map && !takes_focus_on_map) ||
+      window_would_be_covered (window) )
+    ) {
+      if (meta_window_is_ancestor_of_transient (focus_window, window))
+        {
+          /* This happens for error dialogs or alerts; these need to remain on
+           * top, but it would be confusing to have its ancestor remain
+           * focused.
+           */
+          meta_topic (META_DEBUG_STARTUP,
+                      "The focus window %s is an ancestor of the newly mapped "
+                      "window %s which isn't being focused.  Unfocusing the "
+                      "ancestor.\n",
+                      focus_window->desc, window->desc);
+
+          meta_display_focus_the_no_focus_window (window->display,
+                                                  window->screen,
+                                                  timestamp);
+        }
+      else
+        {
+          needs_stacking_adjustment = TRUE;
+          if (!window->placed)
+            window->denied_focus_and_not_transient = TRUE;
+        }
+    }
+
+  if (!window->placed)
+    {
+      /* We have to recalc the placement here since other windows may
+       * have been mapped/placed since we last did constrain_position
+       */
+
+      /* calc_placement is an efficiency hack to avoid
+       * multiple placement calculations before we finally
+       * show the window.
+       */
+      window->calc_placement = TRUE;
+      meta_window_move_resize_now (window);
+      window->calc_placement = FALSE;
+
+      /* don't ever do the initial position constraint thing again.
+       * This is toggled here so that initially-iconified windows
+       * still get placed when they are ultimately shown.
+       */
+      window->placed = TRUE;
+
+      /* Don't want to accidentally reuse the fact that we had been denied
+       * focus in any future constraints unless we're denied focus again.
+       */
+      window->denied_focus_and_not_transient = FALSE;
+    }
+
+  if (needs_stacking_adjustment)
+    {
+      gboolean overlap;
+
+      /* This window isn't getting focus on map.  We may need to do some
+       * special handing with it in regards to
+       *   - the stacking of the window
+       *   - the MRU position of the window
+       *   - the demands attention setting of the window
+       *
+       * Firstly, set the flag so we don't give the window focus anyway
+       * and confuse people.
+       */
+
+      takes_focus_on_map = FALSE;
+
+      overlap = windows_overlap (window, focus_window);
+
+      /* We want alt tab to go to the denied-focus window */
+      ensure_mru_position_after (window, focus_window);
+
+      /* We don't want the denied-focus window to obscure the focus
+       * window, and if we're in both click-to-focus mode and
+       * raise-on-click mode then we want to maintain the invariant
+       * that MRU order == stacking order.  The need for this if
+       * comes from the fact that in sloppy/mouse focus the focus
+       * window may not overlap other windows and also can be
+       * considered "below" them; this combination means that
+       * placing the denied-focus window "below" the focus window
+       * in the stack when it doesn't overlap it confusingly places
+       * that new window below a lot of other windows.
+       */
+      if (overlap ||
+          (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK &&
+           meta_prefs_get_raise_on_click ()))
+        meta_window_stack_just_below (window, focus_window);
+
+      /* If the window will be obscured by the focus window, then the
+       * user might not notice the window appearing so set the
+       * demands attention hint.
+       *
+       * We set the hint ourselves rather than calling
+       * meta_window_set_demands_attention() because that would cause
+       * a recalculation of overlap, and a call to set_net_wm_state()
+       * which we are going to call ourselves here a few lines down.
+       */
+      if (overlap)
+        window->wm_state_demands_attention = TRUE;
+    }
+
+  /* Shaded means the frame is mapped but the window is not */
+
+  if (window->frame && !window->frame->mapped)
+    {
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "Frame actually needs map\n");
+      window->frame->mapped = TRUE;
+      meta_ui_map_frame (window->screen->ui, window->frame->xwindow);
+      did_show = TRUE;
+    }
+
+  if (window->shaded)
+    {
+      if (window->mapped)
+        {
+          meta_topic (META_DEBUG_WINDOW_STATE,
+                      "%s actually needs unmap (shaded)\n", window->desc);
+          meta_topic (META_DEBUG_WINDOW_STATE,
+                      "Incrementing unmaps_pending on %s for shade\n",
+                      window->desc);
+          window->mapped = FALSE;
+          window->unmaps_pending += 1;
+          meta_error_trap_push (window->display);
+          XUnmapWindow (window->display->xdisplay, window->xwindow);
+          meta_error_trap_pop (window->display, FALSE);
+        }
+
+      if (!window->iconic)
+        {
+          window->iconic = TRUE;
+          set_wm_state (window, IconicState);
+        }
+    }
+  else
+    {
+      if (!window->mapped)
+        {
+          meta_topic (META_DEBUG_WINDOW_STATE,
+                      "%s actually needs map\n", window->desc);
+          window->mapped = TRUE;
+          meta_error_trap_push (window->display);
+          XMapWindow (window->display->xdisplay, window->xwindow);
+          meta_error_trap_pop (window->display, FALSE);
+          did_show = TRUE;
+
+          if (window->was_minimized)
+            {
+              MetaRectangle window_rect;
+              MetaRectangle icon_rect;
+
+              window->was_minimized = FALSE;
+
+              if (meta_window_get_icon_geometry (window, &icon_rect))
+                {
+                  meta_window_get_outer_rect (window, &window_rect);
+
+                  meta_effect_run_unminimize (window,
+                                              &window_rect,
+                                              &icon_rect,
+                                              NULL, NULL);
+                }
+            }
+        }
+
+      if (window->iconic)
+        {
+          window->iconic = FALSE;
+          set_wm_state (window, NormalState);
+        }
+    }
+
+  /* We don't want to worry about all cases from inside
+   * implement_showing(); we only want to worry about focus if this
+   * window has not been shown before.
+   */
+  if (window->showing_for_first_time)
+    {
+      window->showing_for_first_time = FALSE;
+      if (takes_focus_on_map)
+        {
+          meta_window_focus (window, timestamp);
+        }
+      else
+        {
+          /* Prevent EnterNotify events in sloppy/mouse focus from
+           * erroneously focusing the window that had been denied
+           * focus.  FIXME: This introduces a race; I have a couple
+           * ideas for a better way to accomplish the same thing, but
+           * they're more involved so do it this way for now.
+           */
+          meta_display_increment_focus_sentinel (window->display);
+        }
+    }
+
+  set_net_wm_state (window);
+
+  if (did_show && window->struts)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Mapped window %s with struts, so invalidating work areas\n",
+                  window->desc);
+      invalidate_work_areas (window);
+    }
+
+  /*
+   * Now that we have shown the window, we no longer want to consider the
+   * initial timestamp in any subsequent deliberations whether to focus this
+   * window or not, so clear the flag.
+   *
+   * See http://bugzilla.gnome.org/show_bug.cgi?id=573922
+   */
+  window->initial_timestamp_set = FALSE;
+}
+
+/* XXX META_EFFECT_*_UNMAP */
+static void
+meta_window_hide (MetaWindow *window)
+{
+  gboolean did_hide;
+
+  meta_topic (META_DEBUG_WINDOW_STATE,
+              "Hiding window %s\n", window->desc);
+
+  did_hide = FALSE;
+
+  if (window->frame && window->frame->mapped)
+    {
+      meta_topic (META_DEBUG_WINDOW_STATE, "Frame actually needs unmap\n");
+      window->frame->mapped = FALSE;
+      meta_ui_unmap_frame (window->screen->ui, window->frame->xwindow);
+      did_hide = TRUE;
+    }
+
+  if (window->mapped)
+    {
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "%s actually needs unmap\n", window->desc);
+      meta_topic (META_DEBUG_WINDOW_STATE,
+                  "Incrementing unmaps_pending on %s for hide\n",
+                  window->desc);
+      window->mapped = FALSE;
+      window->unmaps_pending += 1;
+      meta_error_trap_push (window->display);
+      XUnmapWindow (window->display->xdisplay, window->xwindow);
+      meta_error_trap_pop (window->display, FALSE);
+      did_hide = TRUE;
+    }
+
+  if (!window->iconic)
+    {
+      window->iconic = TRUE;
+      set_wm_state (window, IconicState);
+    }
+
+  set_net_wm_state (window);
+
+  if (did_hide && window->struts)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Unmapped window %s with struts, so invalidating work areas\n",
+                  window->desc);
+      invalidate_work_areas (window);
+    }
+}
+
+static gboolean
+queue_calc_showing_func (MetaWindow *window,
+                         void       *data)
+{
+  meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+  return TRUE;
+}
+
+void
+meta_window_minimize (MetaWindow  *window)
+{
+  if (!window->minimized)
+    {
+      window->minimized = TRUE;
+      meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+
+      meta_window_foreach_transient (window,
+                                     queue_calc_showing_func,
+                                     NULL);
+
+      if (window->has_focus)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focusing default window due to minimization of focus window %s\n",
+                      window->desc);
+        }
+      else
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Minimizing window %s which doesn't have the focus\n",
+                      window->desc);
+        }
+    }
+}
+
+void
+meta_window_unminimize (MetaWindow  *window)
+{
+  if (window->minimized)
+    {
+      window->minimized = FALSE;
+      window->was_minimized = TRUE;
+      meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+
+      meta_window_foreach_transient (window,
+                                     queue_calc_showing_func,
+                                     NULL);
+    }
+}
+
+static void
+ensure_size_hints_satisfied (MetaRectangle    *rect,
+                             const XSizeHints *size_hints)
+{
+  int minw, minh, maxw, maxh;   /* min/max width/height                      */
+  int basew, baseh, winc, hinc; /* base width/height, width/height increment */
+  int extra_width, extra_height;
+
+  minw  = size_hints->min_width;  minh  = size_hints->min_height;
+  maxw  = size_hints->max_width;  maxh  = size_hints->max_height;
+  basew = size_hints->base_width; baseh = size_hints->base_height;
+  winc  = size_hints->width_inc;  hinc  = size_hints->height_inc;
+
+  /* First, enforce min/max size constraints */
+  rect->width  = CLAMP (rect->width,  minw, maxw);
+  rect->height = CLAMP (rect->height, minh, maxh);
+
+  /* Now, verify size increment constraints are satisfied, or make them be */
+  extra_width  = (rect->width  - basew) % winc;
+  extra_height = (rect->height - baseh) % hinc;
+
+  rect->width  -= extra_width;
+  rect->height -= extra_height;
+
+  /* Adjusting width/height down, as done above, may violate minimum size
+   * constraints, so one last fix.
+   */
+  if (rect->width  < minw)
+    rect->width  += ((minw - rect->width)/winc  + 1)*winc;
+  if (rect->height < minh)
+    rect->height += ((minh - rect->height)/hinc + 1)*hinc;
+}
+
+static void
+meta_window_save_rect (MetaWindow *window)
+{
+  if (!(META_WINDOW_MAXIMIZED (window) || window->fullscreen))
+    {
+      /* save size/pos as appropriate args for move_resize */
+      if (!window->maximized_horizontally)
+        {
+          window->saved_rect.x      = window->rect.x;
+          window->saved_rect.width  = window->rect.width;
+          if (window->frame)
+            window->saved_rect.x   += window->frame->rect.x;
+        }
+      if (!window->maximized_vertically)
+        {
+          window->saved_rect.y      = window->rect.y;
+          window->saved_rect.height = window->rect.height;
+          if (window->frame)
+            window->saved_rect.y   += window->frame->rect.y;
+        }
+    }
+}
+
+/**
+ * Save the user_rect regardless of whether the window is maximized or
+ * fullscreen. See save_user_window_placement() for most uses.
+ *
+ * \param window  Store current position of this window for future reference
+ */
+static void
+force_save_user_window_placement (MetaWindow *window)
+{
+  meta_window_get_client_root_coords (window, &window->user_rect);
+}
+
+/**
+ * Save the user_rect, but only if the window is neither maximized nor
+ * fullscreen, otherwise the window may snap back to those dimensions
+ * (bug #461927).
+ *
+ * \param window  Store current position of this window for future reference
+ */
+static void
+save_user_window_placement (MetaWindow *window)
+{
+  if (!(META_WINDOW_MAXIMIZED (window) || window->fullscreen))
+    {
+      MetaRectangle user_rect;
+
+      meta_window_get_client_root_coords (window, &user_rect);
+
+      if (!window->maximized_horizontally)
+	{
+	  window->user_rect.x     = user_rect.x;
+	  window->user_rect.width = user_rect.width;
+	}
+      if (!window->maximized_vertically)
+	{
+	  window->user_rect.y      = user_rect.y;
+	  window->user_rect.height = user_rect.height;
+	}
+    }
+}
+
+void
+meta_window_maximize_internal (MetaWindow        *window,
+                               MetaMaximizeFlags  directions,
+                               MetaRectangle     *saved_rect)
+{
+  /* At least one of the two directions ought to be set */
+  gboolean maximize_horizontally, maximize_vertically;
+  maximize_horizontally = directions & META_MAXIMIZE_HORIZONTAL;
+  maximize_vertically   = directions & META_MAXIMIZE_VERTICAL;
+  g_assert (maximize_horizontally || maximize_vertically);
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Maximizing %s%s\n",
+              window->desc,
+              maximize_horizontally && maximize_vertically ? "" :
+                maximize_horizontally ? " horizontally" :
+                  maximize_vertically ? " vertically" : "BUGGGGG");
+
+  if (saved_rect != NULL)
+    window->saved_rect = *saved_rect;
+  else
+    meta_window_save_rect (window);
+
+  window->maximized_horizontally =
+    window->maximized_horizontally || maximize_horizontally;
+  window->maximized_vertically =
+    window->maximized_vertically   || maximize_vertically;
+  if (maximize_horizontally || maximize_vertically)
+    window->force_save_user_rect = FALSE;
+
+  /* Fix for #336850: If the frame shape isn't reapplied, it is
+   * possible that the frame will retains its rounded corners. That
+   * happens if the client's size when maximized equals the unmaximized
+   * size.
+   */
+  if (window->frame)
+    window->frame->need_reapply_frame_shape = TRUE;
+
+  recalc_window_features (window);
+  set_net_wm_state (window);
+}
+
+void
+meta_window_maximize (MetaWindow        *window,
+                      MetaMaximizeFlags  directions)
+{
+  /* At least one of the two directions ought to be set */
+  gboolean maximize_horizontally, maximize_vertically;
+  maximize_horizontally = directions & META_MAXIMIZE_HORIZONTAL;
+  maximize_vertically   = directions & META_MAXIMIZE_VERTICAL;
+  g_assert (maximize_horizontally || maximize_vertically);
+
+  /* Only do something if the window isn't already maximized in the
+   * given direction(s).
+   */
+  if ((maximize_horizontally && !window->maximized_horizontally) ||
+      (maximize_vertically   && !window->maximized_vertically))
+    {
+      if (window->shaded && maximize_vertically)
+        {
+          /* Shading sucks anyway; I'm not adding a timestamp argument
+           * to this function just for this niche usage & corner case.
+           */
+          guint32 timestamp =
+            meta_display_get_current_time_roundtrip (window->display);
+          meta_window_unshade (window, timestamp);
+        }
+
+      /* if the window hasn't been placed yet, we'll maximize it then
+       */
+      if (!window->placed)
+	{
+	  window->maximize_horizontally_after_placement =
+            window->maximize_horizontally_after_placement ||
+            maximize_horizontally;
+	  window->maximize_vertically_after_placement =
+            window->maximize_vertically_after_placement ||
+            maximize_vertically;
+	  return;
+	}
+
+      meta_window_maximize_internal (window,
+                                     directions,
+                                     NULL);
+
+      /* move_resize with new maximization constraints
+       */
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+    }
+}
+
+static void
+unmaximize_window_before_freeing (MetaWindow        *window)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Unmaximizing %s just before freeing\n",
+              window->desc);
+
+  window->maximized_horizontally = FALSE;
+  window->maximized_vertically = FALSE;
+
+  if (window->withdrawn)                /* See bug #137185 */
+    {
+      window->rect = window->saved_rect;
+      set_net_wm_state (window);
+    }
+  else if (window->screen->closing)     /* See bug #358042 */
+    {
+      /* Do NOT update net_wm_state: this screen is closing,
+       * it likely will be managed by another window manager
+       * that will need the current _NET_WM_STATE atoms.
+       * Moreover, it will need to know the unmaximized geometry,
+       * therefore move_resize the window to saved_rect here
+       * before closing it. */
+      meta_window_move_resize (window,
+                               FALSE,
+                               window->saved_rect.x,
+                               window->saved_rect.y,
+                               window->saved_rect.width,
+                               window->saved_rect.height);
+    }
+}
+
+void
+meta_window_unmaximize (MetaWindow        *window,
+                        MetaMaximizeFlags  directions)
+{
+  /* At least one of the two directions ought to be set */
+  gboolean unmaximize_horizontally, unmaximize_vertically;
+  unmaximize_horizontally = directions & META_MAXIMIZE_HORIZONTAL;
+  unmaximize_vertically   = directions & META_MAXIMIZE_VERTICAL;
+  g_assert (unmaximize_horizontally || unmaximize_vertically);
+
+  /* Only do something if the window isn't already maximized in the
+   * given direction(s).
+   */
+  if ((unmaximize_horizontally && window->maximized_horizontally) ||
+      (unmaximize_vertically   && window->maximized_vertically))
+    {
+      MetaRectangle target_rect;
+
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Unmaximizing %s%s\n",
+                  window->desc,
+                  unmaximize_horizontally && unmaximize_vertically ? "" :
+                    unmaximize_horizontally ? " horizontally" :
+                      unmaximize_vertically ? " vertically" : "BUGGGGG");
+
+      window->maximized_horizontally =
+        window->maximized_horizontally && !unmaximize_horizontally;
+      window->maximized_vertically =
+        window->maximized_vertically   && !unmaximize_vertically;
+
+      /* Unmaximize to the saved_rect position in the direction(s)
+       * being unmaximized.
+       */
+      meta_window_get_client_root_coords (window, &target_rect);
+      if (unmaximize_horizontally)
+        {
+          target_rect.x     = window->saved_rect.x;
+          target_rect.width = window->saved_rect.width;
+        }
+      if (unmaximize_vertically)
+        {
+          target_rect.y      = window->saved_rect.y;
+          target_rect.height = window->saved_rect.height;
+        }
+
+      /* Window's size hints may have changed while maximized, making
+       * saved_rect invalid.  #329152
+       */
+      ensure_size_hints_satisfied (&target_rect, &window->size_hints);
+
+      /* When we unmaximize, if we're doing a mouse move also we could
+       * get the window suddenly jumping to the upper left corner of
+       * the workspace, since that's where it was when the grab op
+       * started.  So we need to update the grab state.
+       */
+      if (meta_grab_op_is_moving (window->display->grab_op) &&
+          window->display->grab_window == window)
+        {
+          window->display->grab_anchor_window_pos = target_rect;
+        }
+
+      meta_window_move_resize (window,
+                               FALSE,
+                               target_rect.x,
+                               target_rect.y,
+                               target_rect.width,
+                               target_rect.height);
+
+      /* Make sure user_rect is current.
+       */
+      force_save_user_window_placement (window);
+
+      if (window->display->grab_wireframe_active)
+        {
+          window->display->grab_wireframe_rect = target_rect;
+        }
+
+      recalc_window_features (window);
+      set_net_wm_state (window);
+    }
+}
+
+void
+meta_window_make_above (MetaWindow  *window)
+{
+  window->wm_state_above = TRUE;
+  meta_window_update_layer (window);
+  meta_window_raise (window);
+  set_net_wm_state (window);
+}
+
+void
+meta_window_unmake_above (MetaWindow  *window)
+{
+  window->wm_state_above = FALSE;
+  meta_window_raise (window);
+  meta_window_update_layer (window);
+  set_net_wm_state (window);
+}
+
+void
+meta_window_make_fullscreen_internal (MetaWindow  *window)
+{
+  if (!window->fullscreen)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Fullscreening %s\n", window->desc);
+
+      if (window->shaded)
+        {
+          /* Shading sucks anyway; I'm not adding a timestamp argument
+           * to this function just for this niche usage & corner case.
+           */
+          guint32 timestamp =
+            meta_display_get_current_time_roundtrip (window->display);
+          meta_window_unshade (window, timestamp);
+        }
+
+      meta_window_save_rect (window);
+
+      window->fullscreen = TRUE;
+      window->force_save_user_rect = FALSE;
+
+      meta_stack_freeze (window->screen->stack);
+      meta_window_update_layer (window);
+
+      meta_window_raise (window);
+      meta_stack_thaw (window->screen->stack);
+
+      recalc_window_features (window);
+      set_net_wm_state (window);
+    }
+}
+
+void
+meta_window_make_fullscreen (MetaWindow  *window)
+{
+  if (!window->fullscreen)
+    {
+      meta_window_make_fullscreen_internal (window);
+      /* move_resize with new constraints
+       */
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+    }
+}
+
+void
+meta_window_unmake_fullscreen (MetaWindow  *window)
+{
+  if (window->fullscreen)
+    {
+      MetaRectangle target_rect;
+
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Unfullscreening %s\n", window->desc);
+
+      window->fullscreen = FALSE;
+      target_rect = window->saved_rect;
+
+      /* Window's size hints may have changed while maximized, making
+       * saved_rect invalid.  #329152
+       */
+      ensure_size_hints_satisfied (&target_rect, &window->size_hints);
+
+      meta_window_move_resize (window,
+                               FALSE,
+                               target_rect.x,
+                               target_rect.y,
+                               target_rect.width,
+                               target_rect.height);
+
+      /* Make sure user_rect is current.
+       */
+      force_save_user_window_placement (window);
+
+      meta_window_update_layer (window);
+
+      recalc_window_features (window);
+      set_net_wm_state (window);
+    }
+}
+
+void
+meta_window_update_fullscreen_monitors (MetaWindow    *window,
+                                        unsigned long  top,
+                                        unsigned long  bottom,
+                                        unsigned long  left,
+                                        unsigned long  right)
+{
+  if ((int)top < window->screen->n_xinerama_infos &&
+      (int)bottom < window->screen->n_xinerama_infos &&
+      (int)left < window->screen->n_xinerama_infos &&
+      (int)right < window->screen->n_xinerama_infos)
+    {
+      window->fullscreen_monitors[0] = top;
+      window->fullscreen_monitors[1] = bottom;
+      window->fullscreen_monitors[2] = left;
+      window->fullscreen_monitors[3] = right;
+    }
+  else
+    {
+      window->fullscreen_monitors[0] = -1;
+    }
+
+  if (window->fullscreen)
+    {
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+    }
+}
+
+void
+meta_window_shade (MetaWindow  *window,
+                   guint32      timestamp)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Shading %s\n", window->desc);
+  if (!window->shaded)
+    {
+      window->shaded = TRUE;
+
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);
+
+      /* After queuing the calc showing, since _focus flushes it,
+       * and we need to focus the frame
+       */
+      meta_topic (META_DEBUG_FOCUS,
+                  "Re-focusing window %s after shading it\n",
+                  window->desc);
+      meta_window_focus (window, timestamp);
+
+      set_net_wm_state (window);
+    }
+}
+
+void
+meta_window_unshade (MetaWindow  *window,
+                     guint32      timestamp)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Unshading %s\n", window->desc);
+  if (window->shaded)
+    {
+      window->shaded = FALSE;
+      meta_window_queue(window, META_QUEUE_MOVE_RESIZE | META_QUEUE_CALC_SHOWING);
+
+      /* focus the window */
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing window %s after unshading it\n",
+                  window->desc);
+      meta_window_focus (window, timestamp);
+
+      set_net_wm_state (window);
+    }
+}
+
+static gboolean
+unminimize_func (MetaWindow *window,
+                 void       *data)
+{
+  meta_window_unminimize (window);
+  return TRUE;
+}
+
+static void
+unminimize_window_and_all_transient_parents (MetaWindow *window)
+{
+  meta_window_unminimize (window);
+  meta_window_foreach_ancestor (window, unminimize_func, NULL);
+}
+
+static void
+window_activate (MetaWindow     *window,
+                 guint32         timestamp,
+                 MetaClientType  source_indication,
+                 MetaWorkspace  *workspace)
+{
+  gboolean can_ignore_outdated_timestamps;
+  meta_topic (META_DEBUG_FOCUS,
+              "_NET_ACTIVE_WINDOW message sent for %s at time %u "
+              "by client type %u.\n",
+              window->desc, timestamp, source_indication);
+
+  /* Older EWMH spec didn't specify a timestamp; we decide to honor these only
+   * if the app specifies that it is a pager.
+   *
+   * Update: Unconditionally honor 0 timestamps for now; we'll fight
+   * that battle later.  Just remove the "FALSE &&" in order to only
+   * honor 0 timestamps for pagers.
+   */
+  can_ignore_outdated_timestamps =
+    (timestamp != 0 || (FALSE && source_indication != META_CLIENT_TYPE_PAGER));
+  if (XSERVER_TIME_IS_BEFORE (timestamp, window->display->last_user_time) &&
+      can_ignore_outdated_timestamps)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "last_user_time (%u) is more recent; ignoring "
+                  " _NET_ACTIVE_WINDOW message.\n",
+                  window->display->last_user_time);
+      meta_window_set_demands_attention(window);
+      return;
+    }
+
+  /* For those stupid pagers, get a valid timestamp and show a warning */
+  if (timestamp == 0)
+    {
+      meta_warning ("meta_window_activate called by a pager with a 0 timestamp; "
+                    "the pager needs to be fixed.\n");
+      timestamp = meta_display_get_current_time_roundtrip (window->display);
+    }
+
+  meta_window_set_user_time (window, timestamp);
+
+  /* disable show desktop mode unless we're a desktop component */
+  maybe_leave_show_desktop_mode (window);
+
+  /* Get window on current or given workspace */
+  if (workspace == NULL)
+    workspace = window->screen->active_workspace;
+
+  /* For non-transient windows, we just set up a pulsing indicator,
+     rather than move windows or workspaces.
+     See http://bugzilla.gnome.org/show_bug.cgi?id=482354 */
+  if (window->xtransient_for == None &&
+      !meta_window_located_on_workspace (window, workspace))
+    {
+      meta_window_set_demands_attention (window);
+      /* We've marked it as demanding, don't need to do anything else. */
+      return;
+    }
+  else if (window->xtransient_for != None)
+    {
+      /* Move transients to current workspace - preference dialogs should appear over
+         the source window.  */
+      meta_window_change_workspace (window, workspace);
+    }
+
+  if (window->shaded)
+    meta_window_unshade (window, timestamp);
+
+  unminimize_window_and_all_transient_parents (window);
+
+  if (meta_prefs_get_raise_on_click () ||
+      source_indication == META_CLIENT_TYPE_PAGER)
+    meta_window_raise (window);
+
+  meta_topic (META_DEBUG_FOCUS,
+              "Focusing window %s due to activation\n",
+              window->desc);
+  meta_window_focus (window, timestamp);
+}
+
+/* This function exists since most of the functionality in window_activate
+ * is useful for Marco, but Marco shouldn't need to specify a client
+ * type for itself.  ;-)
+ */
+void
+meta_window_activate (MetaWindow     *window,
+                      guint32         timestamp)
+{
+  /* We're not really a pager, but the behavior we want is the same as if
+   * we were such.  If we change the pager behavior later, we could revisit
+   * this and just add extra flags to window_activate.
+   */
+  window_activate (window, timestamp, META_CLIENT_TYPE_PAGER, NULL);
+}
+
+void
+meta_window_activate_with_workspace (MetaWindow     *window,
+                                     guint32         timestamp,
+                                     MetaWorkspace  *workspace)
+{
+  /* We're not really a pager, but the behavior we want is the same as if
+   * we were such.  If we change the pager behavior later, we could revisit
+   * this and just add extra flags to window_activate.
+   */
+  window_activate (window, timestamp, META_CLIENT_TYPE_APPLICATION, workspace);
+}
+
+/* Manually fix all the weirdness explained in the big comment at the
+ * beginning of meta_window_move_resize_internal() giving positions
+ * expected by meta_window_constrain (i.e. positions & sizes of the
+ * internal or client window).
+ */
+static void
+adjust_for_gravity (MetaWindow        *window,
+                    MetaFrameGeometry *fgeom,
+                    gboolean           coords_assume_border,
+                    int                gravity,
+                    MetaRectangle     *rect)
+{
+  int ref_x, ref_y;
+  int bw;
+  int child_x, child_y;
+  int frame_width, frame_height;
+
+  if (coords_assume_border)
+    bw = window->border_width;
+  else
+    bw = 0;
+
+  if (fgeom)
+    {
+      child_x = fgeom->left_width;
+      child_y = fgeom->top_height;
+      frame_width = child_x + rect->width + fgeom->right_width;
+      frame_height = child_y + rect->height + fgeom->bottom_height;
+    }
+  else
+    {
+      child_x = 0;
+      child_y = 0;
+      frame_width = rect->width;
+      frame_height = rect->height;
+    }
+
+  /* We're computing position to pass to window_move, which is
+   * the position of the client window (StaticGravity basically)
+   *
+   * (see WM spec description of gravity computation, but note that
+   * their formulas assume we're honoring the border width, rather
+   * than compensating for having turned it off)
+   */
+  switch (gravity)
+    {
+    case NorthWestGravity:
+      ref_x = rect->x;
+      ref_y = rect->y;
+      break;
+    case NorthGravity:
+      ref_x = rect->x + rect->width / 2 + bw;
+      ref_y = rect->y;
+      break;
+    case NorthEastGravity:
+      ref_x = rect->x + rect->width + bw * 2;
+      ref_y = rect->y;
+      break;
+    case WestGravity:
+      ref_x = rect->x;
+      ref_y = rect->y + rect->height / 2 + bw;
+      break;
+    case CenterGravity:
+      ref_x = rect->x + rect->width / 2 + bw;
+      ref_y = rect->y + rect->height / 2 + bw;
+      break;
+    case EastGravity:
+      ref_x = rect->x + rect->width + bw * 2;
+      ref_y = rect->y + rect->height / 2 + bw;
+      break;
+    case SouthWestGravity:
+      ref_x = rect->x;
+      ref_y = rect->y + rect->height + bw * 2;
+      break;
+    case SouthGravity:
+      ref_x = rect->x + rect->width / 2 + bw;
+      ref_y = rect->y + rect->height + bw * 2;
+      break;
+    case SouthEastGravity:
+      ref_x = rect->x + rect->width + bw * 2;
+      ref_y = rect->y + rect->height + bw * 2;
+      break;
+    case StaticGravity:
+    default:
+      ref_x = rect->x;
+      ref_y = rect->y;
+      break;
+    }
+
+  switch (gravity)
+    {
+    case NorthWestGravity:
+      rect->x = ref_x + child_x;
+      rect->y = ref_y + child_y;
+      break;
+    case NorthGravity:
+      rect->x = ref_x - frame_width / 2 + child_x;
+      rect->y = ref_y + child_y;
+      break;
+    case NorthEastGravity:
+      rect->x = ref_x - frame_width + child_x;
+      rect->y = ref_y + child_y;
+      break;
+    case WestGravity:
+      rect->x = ref_x + child_x;
+      rect->y = ref_y - frame_height / 2 + child_y;
+      break;
+    case CenterGravity:
+      rect->x = ref_x - frame_width / 2 + child_x;
+      rect->y = ref_y - frame_height / 2 + child_y;
+      break;
+    case EastGravity:
+      rect->x = ref_x - frame_width + child_x;
+      rect->y = ref_y - frame_height / 2 + child_y;
+      break;
+    case SouthWestGravity:
+      rect->x = ref_x + child_x;
+      rect->y = ref_y - frame_height + child_y;
+      break;
+    case SouthGravity:
+      rect->x = ref_x - frame_width / 2 + child_x;
+      rect->y = ref_y - frame_height + child_y;
+      break;
+    case SouthEastGravity:
+      rect->x = ref_x - frame_width + child_x;
+      rect->y = ref_y - frame_height + child_y;
+      break;
+    case StaticGravity:
+    default:
+      rect->x = ref_x;
+      rect->y = ref_y;
+      break;
+    }
+}
+
+static gboolean
+static_gravity_works (MetaDisplay *display)
+{
+  return display->static_gravity_works;
+}
+
+#ifdef HAVE_XSYNC
+static void
+send_sync_request (MetaWindow *window)
+{
+  XSyncValue value;
+  XClientMessageEvent ev;
+
+  window->sync_request_serial++;
+
+  XSyncIntToValue (&value, window->sync_request_serial);
+
+  ev.type = ClientMessage;
+  ev.window = window->xwindow;
+  ev.message_type = window->display->atom_WM_PROTOCOLS;
+  ev.format = 32;
+  ev.data.l[0] = window->display->atom__NET_WM_SYNC_REQUEST;
+  /* FIXME: meta_display_get_current_time() is bad, but since calls
+   * come from meta_window_move_resize_internal (which in turn come
+   * from all over), I'm not sure what we can do to fix it.  Do we
+   * want to use _roundtrip, though?
+   */
+  ev.data.l[1] = meta_display_get_current_time (window->display);
+  ev.data.l[2] = XSyncValueLow32 (value);
+  ev.data.l[3] = XSyncValueHigh32 (value);
+
+  /* We don't need to trap errors here as we are already
+   * inside an error_trap_push()/pop() pair.
+   */
+  XSendEvent (window->display->xdisplay,
+	      window->xwindow, False, 0, (XEvent*) &ev);
+
+  g_get_current_time (&window->sync_request_time);
+}
+#endif
+
+static void
+meta_window_move_resize_internal (MetaWindow          *window,
+                                  MetaMoveResizeFlags  flags,
+                                  int                  gravity,
+                                  int                  root_x_nw,
+                                  int                  root_y_nw,
+                                  int                  w,
+                                  int                  h)
+{
+  /* meta_window_move_resize_internal gets called with very different
+   * meanings for root_x_nw and root_y_nw.  w & h are always the area
+   * of the inner or client window (i.e. excluding the frame) and
+   * gravity is the relevant gravity associated with the request (note
+   * that gravity is ignored for move-only operations unless its
+   * e.g. a configure request).  The location is different for
+   * different cases because of how this function gets called; note
+   * that in all cases what we want to find out is the upper left
+   * corner of the position of the inner window:
+   *
+   *   Case | Called from (flags; gravity)
+   *   -----+-----------------------------------------------
+   *    1   | A resize only ConfigureRequest
+   *    1   | meta_window_resize
+   *    1   | meta_window_resize_with_gravity
+   *    2   | New window
+   *    2   | Session restore
+   *    2   | A not-resize-only ConfigureRequest/net_moveresize_window request
+   *    3   | meta_window_move
+   *    3   | meta_window_move_resize
+   *
+   * For each of the cases, root_x_nw and root_y_nw must be treated as follows:
+   *
+   *   (1) They should be entirely ignored; instead the previous position
+   *       and size of the window should be resized according to the given
+   *       gravity in order to determine the new position of the window.
+   *   (2) Needs to be fixed up by adjust_for_gravity() as these
+   *       coordinates are relative to some corner or side of the outer
+   *       window (except for the case of StaticGravity) and we want to
+   *       know the location of the upper left corner of the inner window.
+   *   (3) These values are already the desired positon of the NW corner
+   *       of the inner window
+   */
+  XWindowChanges values;
+  unsigned int mask;
+  gboolean need_configure_notify;
+  MetaFrameGeometry fgeom;
+  gboolean need_move_client = FALSE;
+  gboolean need_move_frame = FALSE;
+  gboolean need_resize_client = FALSE;
+  gboolean need_resize_frame = FALSE;
+  int frame_size_dx;
+  int frame_size_dy;
+  int size_dx;
+  int size_dy;
+  gboolean is_configure_request;
+  gboolean do_gravity_adjust;
+  gboolean is_user_action;
+  gboolean configure_frame_first;
+  gboolean use_static_gravity;
+  /* used for the configure request, but may not be final
+   * destination due to StaticGravity etc.
+   */
+  int client_move_x;
+  int client_move_y;
+  MetaRectangle new_rect;
+  MetaRectangle old_rect;
+
+  is_configure_request = (flags & META_IS_CONFIGURE_REQUEST) != 0;
+  do_gravity_adjust = (flags & META_DO_GRAVITY_ADJUST) != 0;
+  is_user_action = (flags & META_IS_USER_ACTION) != 0;
+
+  /* The action has to be a move or a resize or both... */
+  g_assert (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION));
+
+  /* We don't need it in the idle queue anymore. */
+  meta_window_unqueue (window, META_QUEUE_MOVE_RESIZE);
+
+  meta_window_get_client_root_coords (window, &old_rect);
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Move/resize %s to %d,%d %dx%d%s%s from %d,%d %dx%d\n",
+              window->desc, root_x_nw, root_y_nw, w, h,
+              is_configure_request ? " (configure request)" : "",
+              is_user_action ? " (user move/resize)" : "",
+              old_rect.x, old_rect.y, old_rect.width, old_rect.height);
+
+  if (window->frame)
+    meta_frame_calc_geometry (window->frame,
+                              &fgeom);
+
+  new_rect.x = root_x_nw;
+  new_rect.y = root_y_nw;
+  new_rect.width  = w;
+  new_rect.height = h;
+
+  /* If this is a resize only, the position should be ignored and
+   * instead obtained by resizing the old rectangle according to the
+   * relevant gravity.
+   */
+  if ((flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION)) ==
+      META_IS_RESIZE_ACTION)
+    {
+      meta_rectangle_resize_with_gravity (&old_rect,
+                                          &new_rect,
+                                          gravity,
+                                          new_rect.width,
+                                          new_rect.height);
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Compensated for gravity in resize action; new pos %d,%d\n",
+                  new_rect.x, new_rect.y);
+    }
+  else if (is_configure_request || do_gravity_adjust)
+    {
+      adjust_for_gravity (window,
+                          window->frame ? &fgeom : NULL,
+                          /* configure request coords assume
+                           * the border width existed
+                           */
+                          is_configure_request,
+                          gravity,
+                          &new_rect);
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Compensated for configure_request/do_gravity_adjust needing "
+                  "weird positioning; new pos %d,%d\n",
+                  new_rect.x, new_rect.y);
+    }
+
+  meta_window_constrain (window,
+                         window->frame ? &fgeom : NULL,
+                         flags,
+                         gravity,
+                         &old_rect,
+                         &new_rect);
+
+  w = new_rect.width;
+  h = new_rect.height;
+  root_x_nw = new_rect.x;
+  root_y_nw = new_rect.y;
+
+  if (w != window->rect.width ||
+      h != window->rect.height)
+    need_resize_client = TRUE;
+
+  window->rect.width = w;
+  window->rect.height = h;
+
+  if (window->frame)
+    {
+      int new_w, new_h;
+
+      new_w = window->rect.width + fgeom.left_width + fgeom.right_width;
+
+      if (window->shaded)
+        new_h = fgeom.top_height;
+      else
+        new_h = window->rect.height + fgeom.top_height + fgeom.bottom_height;
+
+      frame_size_dx = new_w - window->frame->rect.width;
+      frame_size_dy = new_h - window->frame->rect.height;
+
+      need_resize_frame = (frame_size_dx != 0 || frame_size_dy != 0);
+
+      window->frame->rect.width = new_w;
+      window->frame->rect.height = new_h;
+
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "Calculated frame size %dx%d\n",
+                  window->frame->rect.width,
+                  window->frame->rect.height);
+    }
+  else
+    {
+      frame_size_dx = 0;
+      frame_size_dy = 0;
+    }
+
+  /* For nice effect, when growing the window we want to move/resize
+   * the frame first, when shrinking the window we want to move/resize
+   * the client first. If we grow one way and shrink the other,
+   * see which way we're moving "more"
+   *
+   * Mail from Owen subject "Suggestion: Gravity and resizing from the left"
+   * http://mail.gnome.org/archives/wm-spec-list/1999-November/msg00088.html
+   *
+   * An annoying fact you need to know in this code is that StaticGravity
+   * does nothing if you _only_ resize or _only_ move the frame;
+   * it must move _and_ resize, otherwise you get NorthWestGravity
+   * behavior. The move and resize must actually occur, it is not
+   * enough to set CWX | CWWidth but pass in the current size/pos.
+   */
+
+  if (window->frame)
+    {
+      int new_x, new_y;
+      int frame_pos_dx, frame_pos_dy;
+
+      /* Compute new frame coords */
+      new_x = root_x_nw - fgeom.left_width;
+      new_y = root_y_nw - fgeom.top_height;
+
+      frame_pos_dx = new_x - window->frame->rect.x;
+      frame_pos_dy = new_y - window->frame->rect.y;
+
+      need_move_frame = (frame_pos_dx != 0 || frame_pos_dy != 0);
+
+      window->frame->rect.x = new_x;
+      window->frame->rect.y = new_y;
+
+      /* If frame will both move and resize, then StaticGravity
+       * on the child window will kick in and implicitly move
+       * the child with respect to the frame. The implicit
+       * move will keep the child in the same place with
+       * respect to the root window. If frame only moves
+       * or only resizes, then the child will just move along
+       * with the frame.
+       */
+
+      /* window->rect.x, window->rect.y are relative to frame,
+       * remember they are the server coords
+       */
+
+      new_x = fgeom.left_width;
+      new_y = fgeom.top_height;
+
+      if (need_resize_frame && need_move_frame &&
+          static_gravity_works (window->display))
+        {
+          /* static gravity kicks in because frame
+           * is both moved and resized
+           */
+          /* when we move the frame by frame_pos_dx, frame_pos_dy the
+           * client will implicitly move relative to frame by the
+           * inverse delta.
+           *
+           * When moving client then frame, we move the client by the
+           * frame delta, to be canceled out by the implicit move by
+           * the inverse frame delta, resulting in a client at new_x,
+           * new_y.
+           *
+           * When moving frame then client, we move the client
+           * by the same delta as the frame, because the client
+           * was "left behind" by the frame - resulting in a client
+           * at new_x, new_y.
+           *
+           * In both cases we need to move the client window
+           * in all cases where we had to move the frame window.
+           */
+
+          client_move_x = new_x + frame_pos_dx;
+          client_move_y = new_y + frame_pos_dy;
+
+          if (need_move_frame)
+            need_move_client = TRUE;
+
+          use_static_gravity = TRUE;
+        }
+      else
+        {
+          client_move_x = new_x;
+          client_move_y = new_y;
+
+          if (client_move_x != window->rect.x ||
+              client_move_y != window->rect.y)
+            need_move_client = TRUE;
+
+          use_static_gravity = FALSE;
+        }
+
+      /* This is the final target position, but not necessarily what
+       * we pass to XConfigureWindow, due to StaticGravity implicit
+       * movement.
+       */
+      window->rect.x = new_x;
+      window->rect.y = new_y;
+    }
+  else
+    {
+      if (root_x_nw != window->rect.x ||
+          root_y_nw != window->rect.y)
+        need_move_client = TRUE;
+
+      window->rect.x = root_x_nw;
+      window->rect.y = root_y_nw;
+
+      client_move_x = window->rect.x;
+      client_move_y = window->rect.y;
+
+      use_static_gravity = FALSE;
+    }
+
+  /* If frame extents have changed, fill in other frame fields and
+     change frame's extents property. */
+  if (window->frame &&
+      (window->frame->child_x != fgeom.left_width ||
+       window->frame->child_y != fgeom.top_height ||
+       window->frame->right_width != fgeom.right_width ||
+       window->frame->bottom_height != fgeom.bottom_height))
+    {
+      window->frame->child_x = fgeom.left_width;
+      window->frame->child_y = fgeom.top_height;
+      window->frame->right_width = fgeom.right_width;
+      window->frame->bottom_height = fgeom.bottom_height;
+
+      update_net_frame_extents (window);
+    }
+
+  /* See ICCCM 4.1.5 for when to send ConfigureNotify */
+
+  need_configure_notify = FALSE;
+
+  /* If this is a configure request and we change nothing, then we
+   * must send configure notify.
+   */
+  if  (is_configure_request &&
+       !(need_move_client || need_move_frame ||
+         need_resize_client || need_resize_frame ||
+         window->border_width != 0))
+    need_configure_notify = TRUE;
+
+  /* We must send configure notify if we move but don't resize, since
+   * the client window may not get a real event
+   */
+  if ((need_move_client || need_move_frame) &&
+      !(need_resize_client || need_resize_frame))
+    need_configure_notify = TRUE;
+
+  /* MapRequest events with a PPosition or UPosition hint with a frame
+   * are moved by marco without resizing; send a configure notify
+   * in such cases.  See #322840.  (Note that window->constructing is
+   * only true iff this call is due to a MapRequest, and when
+   * PPosition/UPosition hints aren't set, marco seems to send a
+   * ConfigureNotify anyway due to the above code.)
+   */
+  if (window->constructing && window->frame &&
+      ((window->size_hints.flags & PPosition) ||
+       (window->size_hints.flags & USPosition)))
+    need_configure_notify = TRUE;
+
+  /* The rest of this function syncs our new size/pos with X as
+   * efficiently as possible
+   */
+
+  /* configure frame first if we grow more than we shrink
+   */
+  size_dx = w - window->rect.width;
+  size_dy = h - window->rect.height;
+
+  configure_frame_first = (size_dx + size_dy >= 0);
+
+  if (use_static_gravity)
+    meta_window_set_gravity (window, StaticGravity);
+
+  if (configure_frame_first && window->frame)
+    meta_frame_sync_to_window (window->frame,
+                               gravity,
+                               need_move_frame, need_resize_frame);
+
+  values.border_width = 0;
+  values.x = client_move_x;
+  values.y = client_move_y;
+  values.width = window->rect.width;
+  values.height = window->rect.height;
+
+  mask = 0;
+  if (is_configure_request && window->border_width != 0)
+    mask |= CWBorderWidth; /* must force to 0 */
+  if (need_move_client)
+    mask |= (CWX | CWY);
+  if (need_resize_client)
+    mask |= (CWWidth | CWHeight);
+
+  if (mask != 0)
+    {
+      {
+        int newx, newy;
+        meta_window_get_position (window, &newx, &newy);
+        meta_topic (META_DEBUG_GEOMETRY,
+                    "Syncing new client geometry %d,%d %dx%d, border: %s pos: %s size: %s\n",
+                    newx, newy,
+                    window->rect.width, window->rect.height,
+                    mask & CWBorderWidth ? "true" : "false",
+                    need_move_client ? "true" : "false",
+                    need_resize_client ? "true" : "false");
+      }
+
+      meta_error_trap_push (window->display);
+
+#ifdef HAVE_XSYNC
+      if (window->sync_request_counter != None &&
+	  window->display->grab_sync_request_alarm != None &&
+	  window->sync_request_time.tv_usec == 0 &&
+	  window->sync_request_time.tv_sec == 0)
+	{
+	  /* turn off updating */
+	  if (window->display->compositor)
+	    meta_compositor_set_updates (window->display->compositor, window, FALSE);
+
+	  send_sync_request (window);
+	}
+#endif
+
+      XConfigureWindow (window->display->xdisplay,
+                        window->xwindow,
+                        mask,
+                        &values);
+
+      meta_error_trap_pop (window->display, FALSE);
+    }
+
+  if (!configure_frame_first && window->frame)
+    meta_frame_sync_to_window (window->frame,
+                               gravity,
+                               need_move_frame, need_resize_frame);
+
+  /* Put gravity back to be nice to lesser window managers */
+  if (use_static_gravity)
+    meta_window_set_gravity (window, NorthWestGravity);
+
+  if (need_configure_notify)
+    send_configure_notify (window);
+
+  if (!window->placed && window->force_save_user_rect && !window->fullscreen)
+    force_save_user_window_placement (window);
+  else if (is_user_action)
+    save_user_window_placement (window);
+
+  if (need_move_frame || need_resize_frame ||
+      need_move_client || need_resize_client)
+    {
+      int newx, newy;
+      meta_window_get_position (window, &newx, &newy);
+      meta_topic (META_DEBUG_GEOMETRY,
+                  "New size/position %d,%d %dx%d (user %d,%d %dx%d)\n",
+                  newx, newy, window->rect.width, window->rect.height,
+                  window->user_rect.x, window->user_rect.y,
+                  window->user_rect.width, window->user_rect.height);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_GEOMETRY, "Size/position not modified\n");
+    }
+
+  if (window->display->grab_wireframe_active)
+    meta_window_update_wireframe (window, root_x_nw, root_y_nw, w, h);
+  else
+    meta_window_refresh_resize_popup (window);
+
+  /* Invariants leaving this function are:
+   *   a) window->rect and frame->rect reflect the actual
+   *      server-side size/pos of window->xwindow and frame->xwindow
+   *   b) all constraints are obeyed by window->rect and frame->rect
+   */
+}
+
+void
+meta_window_resize (MetaWindow  *window,
+                    gboolean     user_op,
+                    int          w,
+                    int          h)
+{
+  int x, y;
+  MetaMoveResizeFlags flags;
+
+  meta_window_get_position (window, &x, &y);
+
+  flags = (user_op ? META_IS_USER_ACTION : 0) | META_IS_RESIZE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    NorthWestGravity,
+                                    x, y, w, h);
+}
+
+void
+meta_window_move (MetaWindow  *window,
+                  gboolean     user_op,
+                  int          root_x_nw,
+                  int          root_y_nw)
+{
+  MetaMoveResizeFlags flags =
+    (user_op ? META_IS_USER_ACTION : 0) | META_IS_MOVE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    NorthWestGravity,
+                                    root_x_nw, root_y_nw,
+                                    window->rect.width,
+                                    window->rect.height);
+}
+
+void
+meta_window_move_resize (MetaWindow  *window,
+                         gboolean     user_op,
+                         int          root_x_nw,
+                         int          root_y_nw,
+                         int          w,
+                         int          h)
+{
+  MetaMoveResizeFlags flags =
+    (user_op ? META_IS_USER_ACTION : 0) |
+    META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    NorthWestGravity,
+                                    root_x_nw, root_y_nw,
+                                    w, h);
+}
+
+void
+meta_window_resize_with_gravity (MetaWindow *window,
+                                 gboolean     user_op,
+                                 int          w,
+                                 int          h,
+                                 int          gravity)
+{
+  int x, y;
+  MetaMoveResizeFlags flags;
+
+  meta_window_get_position (window, &x, &y);
+
+  flags = (user_op ? META_IS_USER_ACTION : 0) | META_IS_RESIZE_ACTION;
+  meta_window_move_resize_internal (window,
+                                    flags,
+                                    gravity,
+                                    x, y, w, h);
+}
+
+static void
+meta_window_move_resize_now (MetaWindow  *window)
+{
+  /* If constraints have changed then we want to snap back to wherever
+   * the user had the window.  We use user_rect for this reason.  See
+   * also bug 426519 comment 3.
+   */
+  meta_window_move_resize (window, FALSE,
+                           window->user_rect.x,
+                           window->user_rect.y,
+                           window->user_rect.width,
+                           window->user_rect.height);
+}
+
+static gboolean
+idle_move_resize (gpointer data)
+{
+  GSList *tmp;
+  GSList *copy;
+  guint queue_index = GPOINTER_TO_INT (data);
+
+  meta_topic (META_DEBUG_GEOMETRY, "Clearing the move_resize queue\n");
+
+  /* Work with a copy, for reentrancy. The allowed reentrancy isn't
+   * complete; destroying a window while we're in here would result in
+   * badness. But it's OK to queue/unqueue move_resizes.
+   */
+  copy = g_slist_copy (queue_pending[queue_index]);
+  g_slist_free (queue_pending[queue_index]);
+  queue_pending[queue_index] = NULL;
+  queue_idle[queue_index] = 0;
+
+  destroying_windows_disallowed += 1;
+
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      /* As a side effect, sets window->move_resize_queued = FALSE */
+      meta_window_move_resize_now (window);
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (copy);
+
+  destroying_windows_disallowed -= 1;
+
+  return FALSE;
+}
+
+void
+meta_window_get_position (MetaWindow  *window,
+                          int         *x,
+                          int         *y)
+{
+  if (window->frame)
+    {
+      if (x)
+        *x = window->frame->rect.x + window->frame->child_x;
+      if (y)
+        *y = window->frame->rect.y + window->frame->child_y;
+    }
+  else
+    {
+      if (x)
+        *x = window->rect.x;
+      if (y)
+        *y = window->rect.y;
+    }
+}
+
+void
+meta_window_get_client_root_coords (MetaWindow    *window,
+                                    MetaRectangle *rect)
+{
+  meta_window_get_position (window, &rect->x, &rect->y);
+  rect->width  = window->rect.width;
+  rect->height = window->rect.height;
+}
+
+void
+meta_window_get_gravity_position (MetaWindow  *window,
+                                  int          gravity,
+                                  int         *root_x,
+                                  int         *root_y)
+{
+  MetaRectangle frame_extents;
+  int w, h;
+  int x, y;
+
+  w = window->rect.width;
+  h = window->rect.height;
+
+  if (gravity == StaticGravity)
+    {
+      frame_extents = window->rect;
+      if (window->frame)
+        {
+          frame_extents.x = window->frame->rect.x + window->frame->child_x;
+          frame_extents.y = window->frame->rect.y + window->frame->child_y;
+        }
+    }
+  else
+    {
+      if (window->frame == NULL)
+        frame_extents = window->rect;
+      else
+        frame_extents = window->frame->rect;
+    }
+
+  x = frame_extents.x;
+  y = frame_extents.y;
+
+  switch (gravity)
+    {
+    case NorthGravity:
+    case CenterGravity:
+    case SouthGravity:
+      /* Find center of frame. */
+      x += frame_extents.width / 2;
+      /* Center client window on that point. */
+      x -= w / 2;
+      break;
+
+    case SouthEastGravity:
+    case EastGravity:
+    case NorthEastGravity:
+      /* Find right edge of frame */
+      x += frame_extents.width;
+      /* Align left edge of client at that point. */
+      x -= w;
+      break;
+    default:
+      break;
+    }
+
+  switch (gravity)
+    {
+    case WestGravity:
+    case CenterGravity:
+    case EastGravity:
+      /* Find center of frame. */
+      y += frame_extents.height / 2;
+      /* Center client window there. */
+      y -= h / 2;
+      break;
+    case SouthWestGravity:
+    case SouthGravity:
+    case SouthEastGravity:
+      /* Find south edge of frame */
+      y += frame_extents.height;
+      /* Place bottom edge of client there */
+      y -= h;
+      break;
+    default:
+      break;
+    }
+
+  if (root_x)
+    *root_x = x;
+  if (root_y)
+    *root_y = y;
+}
+
+void
+meta_window_get_geometry (MetaWindow  *window,
+                          int         *x,
+                          int         *y,
+                          int         *width,
+                          int         *height)
+{
+  meta_window_get_gravity_position (window,
+                                    window->size_hints.win_gravity,
+                                    x, y);
+
+  *width = (window->rect.width - window->size_hints.base_width) /
+    window->size_hints.width_inc;
+  *height = (window->rect.height - window->size_hints.base_height) /
+    window->size_hints.height_inc;
+}
+
+void
+meta_window_get_outer_rect (const MetaWindow *window,
+                            MetaRectangle    *rect)
+{
+  if (window->frame)
+    *rect = window->frame->rect;
+  else
+    *rect = window->rect;
+}
+
+void
+meta_window_get_xor_rect (MetaWindow          *window,
+                          const MetaRectangle *grab_wireframe_rect,
+                          MetaRectangle       *xor_rect)
+{
+  if (window->frame)
+    {
+      xor_rect->x = grab_wireframe_rect->x - window->frame->child_x;
+      xor_rect->y = grab_wireframe_rect->y - window->frame->child_y;
+      xor_rect->width = grab_wireframe_rect->width + window->frame->child_x + window->frame->right_width;
+
+      if (window->shaded)
+        xor_rect->height = window->frame->child_y;
+      else
+        xor_rect->height = grab_wireframe_rect->height + window->frame->child_y + window->frame->bottom_height;
+    }
+  else
+    *xor_rect = *grab_wireframe_rect;
+}
+
+/* Figure out the numbers that show up in the
+ * resize popup when in reduced resources mode.
+ */
+static void
+meta_window_get_wireframe_geometry (MetaWindow    *window,
+                                    int           *width,
+                                    int           *height)
+{
+  if (!window->display->grab_wireframe_active)
+    return;
+
+  if ((width == NULL) || (height == NULL))
+    return;
+
+  if ((window->display->grab_window->size_hints.width_inc <= 1) ||
+      (window->display->grab_window->size_hints.height_inc <= 1))
+    {
+      *width = -1;
+      *height = -1;
+      return;
+    }
+
+  *width = window->display->grab_wireframe_rect.width -
+      window->display->grab_window->size_hints.base_width;
+  *width /= window->display->grab_window->size_hints.width_inc;
+
+  *height = window->display->grab_wireframe_rect.height -
+      window->display->grab_window->size_hints.base_height;
+  *height /= window->display->grab_window->size_hints.height_inc;
+}
+
+/* XXX META_EFFECT_ALT_TAB, well, this and others */
+void
+meta_window_begin_wireframe (MetaWindow *window)
+{
+
+  MetaRectangle new_xor;
+  int display_width, display_height;
+
+  meta_window_get_client_root_coords (window,
+                                      &window->display->grab_wireframe_rect);
+
+  meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
+                            &new_xor);
+  meta_window_get_wireframe_geometry (window, &display_width, &display_height);
+
+  meta_effects_begin_wireframe (window->screen,
+                                &new_xor, display_width, display_height);
+
+  window->display->grab_wireframe_last_xor_rect = new_xor;
+  window->display->grab_wireframe_last_display_width = display_width;
+  window->display->grab_wireframe_last_display_height = display_height;
+}
+
+void
+meta_window_update_wireframe (MetaWindow *window,
+                              int         x,
+                              int         y,
+                              int         width,
+                              int         height)
+{
+
+  MetaRectangle new_xor;
+  int display_width, display_height;
+
+  window->display->grab_wireframe_rect.x = x;
+  window->display->grab_wireframe_rect.y = y;
+  window->display->grab_wireframe_rect.width = width;
+  window->display->grab_wireframe_rect.height = height;
+
+  meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
+                            &new_xor);
+  meta_window_get_wireframe_geometry (window, &display_width, &display_height);
+
+  meta_effects_update_wireframe (window->screen,
+                                 &window->display->grab_wireframe_last_xor_rect,
+                                 window->display->grab_wireframe_last_display_width,
+                                 window->display->grab_wireframe_last_display_height,
+                                 &new_xor, display_width, display_height);
+
+  window->display->grab_wireframe_last_xor_rect = new_xor;
+  window->display->grab_wireframe_last_display_width = display_width;
+  window->display->grab_wireframe_last_display_height = display_height;
+}
+
+void
+meta_window_end_wireframe (MetaWindow *window)
+{
+  meta_effects_end_wireframe (window->display->grab_window->screen,
+                              &window->display->grab_wireframe_last_xor_rect,
+                              window->display->grab_wireframe_last_display_width,
+                              window->display->grab_wireframe_last_display_height);
+}
+
+const char*
+meta_window_get_startup_id (MetaWindow *window)
+{
+  if (window->startup_id == NULL)
+    {
+      MetaGroup *group;
+
+      group = meta_window_get_group (window);
+
+      if (group != NULL)
+        return meta_group_get_startup_id (group);
+    }
+
+  return window->startup_id;
+}
+
+static MetaWindow*
+get_modal_transient (MetaWindow *window)
+{
+  GSList *windows;
+  GSList *tmp;
+  MetaWindow *modal_transient;
+
+  /* A window can't be the transient of itself, but this is just for
+   * convenience in the loop below; we manually fix things up at the
+   * end if no real modal transient was found.
+   */
+  modal_transient = window;
+
+  windows = meta_display_list_windows (window->display);
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *transient = tmp->data;
+
+      if (transient->xtransient_for == modal_transient->xwindow &&
+          transient->wm_state_modal)
+        {
+          modal_transient = transient;
+          tmp = windows;
+          continue;
+        }
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (windows);
+
+  if (window == modal_transient)
+    modal_transient = NULL;
+
+  return modal_transient;
+}
+
+/* XXX META_EFFECT_FOCUS */
+void
+meta_window_focus (MetaWindow  *window,
+                   guint32      timestamp)
+{
+  MetaWindow *modal_transient;
+
+  meta_topic (META_DEBUG_FOCUS,
+              "Setting input focus to window %s, input: %d take_focus: %d\n",
+              window->desc, window->input, window->take_focus);
+
+  if (window->display->grab_window &&
+      window->display->grab_window->all_keys_grabbed)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Current focus window %s has global keygrab, not focusing window %s after all\n",
+                  window->display->grab_window->desc, window->desc);
+      return;
+    }
+
+  modal_transient = get_modal_transient (window);
+  if (modal_transient != NULL &&
+      !modal_transient->unmanaging)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "%s has %s as a modal transient, so focusing it instead.\n",
+                  window->desc, modal_transient->desc);
+      if (!modal_transient->on_all_workspaces &&
+          modal_transient->workspace != window->screen->active_workspace)
+        meta_window_change_workspace (modal_transient,
+                                      window->screen->active_workspace);
+      window = modal_transient;
+    }
+
+  meta_window_flush_calc_showing (window);
+
+  if (!window->mapped && !window->shaded)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Window %s is not showing, not focusing after all\n",
+                  window->desc);
+      return;
+    }
+
+  /* For output-only or shaded windows, focus the frame.
+   * This seems to result in the client window getting key events
+   * though, so I don't know if it's icccm-compliant.
+   *
+   * Still, we have to do this or keynav breaks for these windows.
+   */
+  if (window->frame &&
+      (window->shaded ||
+       !(window->input || window->take_focus)))
+    {
+      if (window->frame)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focusing frame of %s\n", window->desc);
+          meta_display_set_input_focus_window (window->display,
+                                               window,
+                                               TRUE,
+                                               timestamp);
+        }
+    }
+  else
+    {
+      if (window->input)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Setting input focus on %s since input = true\n",
+                      window->desc);
+          meta_display_set_input_focus_window (window->display,
+                                               window,
+                                               FALSE,
+                                               timestamp);
+        }
+
+      if (window->take_focus)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Sending WM_TAKE_FOCUS to %s since take_focus = true\n",
+                      window->desc);
+          meta_window_send_icccm_message (window,
+                                          window->display->atom_WM_TAKE_FOCUS,
+                                          timestamp);
+          window->display->expected_focus_window = window;
+        }
+    }
+
+  if (window->wm_state_demands_attention)
+    meta_window_unset_demands_attention(window);
+
+  meta_effect_run_focus(window, NULL, NULL);
+}
+
+static void
+meta_window_change_workspace_without_transients (MetaWindow    *window,
+                                                 MetaWorkspace *workspace)
+{
+  meta_verbose ("Changing window %s to workspace %d\n",
+                window->desc, meta_workspace_index (workspace));
+
+  /* unstick if stuck. meta_window_unstick would call
+   * meta_window_change_workspace recursively if the window
+   * is not in the active workspace.
+   */
+  if (window->on_all_workspaces)
+    meta_window_unstick (window);
+
+  /* See if we're already on this space. If not, make sure we are */
+  if (window->workspace != workspace)
+    {
+      meta_workspace_remove_window (window->workspace, window);
+      meta_workspace_add_window (workspace, window);
+    }
+}
+
+static gboolean
+change_workspace_foreach (MetaWindow *window,
+                          void       *data)
+{
+  meta_window_change_workspace_without_transients (window, data);
+  return TRUE;
+}
+
+void
+meta_window_change_workspace (MetaWindow    *window,
+                              MetaWorkspace *workspace)
+{
+  meta_window_change_workspace_without_transients (window, workspace);
+
+  meta_window_foreach_transient (window, change_workspace_foreach,
+                                 workspace);
+  meta_window_foreach_ancestor (window, change_workspace_foreach,
+                                workspace);
+}
+
+static void
+window_stick_impl (MetaWindow  *window)
+{
+  GList *tmp;
+  MetaWorkspace *workspace;
+
+  meta_verbose ("Sticking window %s current on_all_workspaces = %d\n",
+                window->desc, window->on_all_workspaces);
+
+  if (window->on_all_workspaces)
+    return;
+
+  /* We don't change window->workspaces, because we revert
+   * to that original workspace list if on_all_workspaces is
+   * toggled back off.
+   */
+  window->on_all_workspaces = TRUE;
+
+  /* We do, however, change the MRU lists of all the workspaces
+   */
+  tmp = window->screen->workspaces;
+  while (tmp)
+    {
+      workspace = (MetaWorkspace *) tmp->data;
+      if (!g_list_find (workspace->mru_list, window))
+        workspace->mru_list = g_list_prepend (workspace->mru_list, window);
+
+      tmp = tmp->next;
+    }
+
+  meta_window_set_current_workspace_hint (window);
+
+  meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+}
+
+static void
+window_unstick_impl (MetaWindow  *window)
+{
+  GList *tmp;
+  MetaWorkspace *workspace;
+
+  if (!window->on_all_workspaces)
+    return;
+
+  /* Revert to window->workspaces */
+
+  window->on_all_workspaces = FALSE;
+
+  /* Remove window from MRU lists that it doesn't belong in */
+  tmp = window->screen->workspaces;
+  while (tmp)
+    {
+      workspace = (MetaWorkspace *) tmp->data;
+      if (window->workspace != workspace)
+        workspace->mru_list = g_list_remove (workspace->mru_list, window);
+      tmp = tmp->next;
+    }
+
+  /* We change ourselves to the active workspace, since otherwise you'd get
+   * a weird window-vaporization effect. Once we have UI for being
+   * on more than one workspace this should probably be add_workspace
+   * not change_workspace.
+   */
+  if (window->screen->active_workspace != window->workspace)
+    meta_window_change_workspace (window, window->screen->active_workspace);
+
+  meta_window_set_current_workspace_hint (window);
+
+  meta_window_queue(window, META_QUEUE_CALC_SHOWING);
+}
+
+static gboolean
+stick_foreach_func (MetaWindow *window,
+                    void       *data)
+{
+  gboolean stick;
+
+  stick = *(gboolean*)data;
+  if (stick)
+    window_stick_impl (window);
+  else
+    window_unstick_impl (window);
+  return TRUE;
+}
+
+void
+meta_window_stick (MetaWindow  *window)
+{
+  gboolean stick = TRUE;
+  window_stick_impl (window);
+  meta_window_foreach_transient (window,
+                                 stick_foreach_func,
+                                 &stick);
+}
+
+void
+meta_window_unstick (MetaWindow  *window)
+{
+  gboolean stick = FALSE;
+  window_unstick_impl (window);
+  meta_window_foreach_transient (window,
+                                 stick_foreach_func,
+                                 &stick);
+}
+
+unsigned long
+meta_window_get_net_wm_desktop (MetaWindow *window)
+{
+  if (window->on_all_workspaces)
+    return 0xFFFFFFFF;
+  else
+    return meta_workspace_index (window->workspace);
+}
+
+static void
+update_net_frame_extents (MetaWindow *window)
+{
+  unsigned long data[4] = { 0, 0, 0, 0 };
+
+  if (window->frame)
+    {
+      /* Left */
+      data[0] = window->frame->child_x;
+      /* Right */
+      data[1] = window->frame->right_width;
+      /* Top */
+      data[2] = window->frame->child_y;
+      /* Bottom */
+      data[3] = window->frame->bottom_height;
+    }
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Setting _NET_FRAME_EXTENTS on managed window 0x%lx "
+              "to left = %lu, right = %lu, top = %lu, bottom = %lu\n",
+              window->xwindow, data[0], data[1], data[2], data[3]);
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom__NET_FRAME_EXTENTS,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 4);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+void
+meta_window_set_current_workspace_hint (MetaWindow *window)
+{
+  /* FIXME if on more than one workspace, we claim to be "sticky",
+   * the WM spec doesn't say what to do here.
+   */
+  unsigned long data[1];
+
+  if (window->workspace == NULL)
+    {
+      /* this happens when unmanaging windows */
+      return;
+    }
+
+  data[0] = meta_window_get_net_wm_desktop (window);
+
+  meta_verbose ("Setting _NET_WM_DESKTOP of %s to %lu\n",
+                window->desc, data[0]);
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom__NET_WM_DESKTOP,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+static gboolean
+find_root_ancestor (MetaWindow *window,
+                    void       *data)
+{
+  MetaWindow **ancestor = data;
+
+  /* Overwrite the previously "most-root" ancestor with the new one found */
+  *ancestor = window;
+
+  /* We want this to continue until meta_window_foreach_ancestor quits because
+   * there are no more valid ancestors.
+   */
+  return TRUE;
+}
+
+MetaWindow *
+meta_window_find_root_ancestor (MetaWindow *window)
+{
+  MetaWindow *ancestor;
+  ancestor = window;
+  meta_window_foreach_ancestor (window, find_root_ancestor, &ancestor);
+  return ancestor;
+}
+
+void
+meta_window_raise (MetaWindow  *window)
+{
+  MetaWindow *ancestor;
+  ancestor = meta_window_find_root_ancestor (window);
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Raising window %s, ancestor of %s\n",
+              ancestor->desc, window->desc);
+
+  /* Raise the ancestor of the window (if the window has no ancestor,
+   * then ancestor will be set to the window itself); do this because
+   * it's weird to see windows from other apps stacked between a child
+   * and parent window of the currently active app.  The stacking
+   * constraints in stack.c then magically take care of raising all
+   * the child windows appropriately.
+   */
+  if (window->screen->stack == ancestor->screen->stack)
+    meta_stack_raise (window->screen->stack, ancestor);
+  else
+    {
+      meta_warning (
+                    "Either stacks aren't per screen or some window has a weird "
+                    "transient_for hint; window->screen->stack != "
+                    "ancestor->screen->stack.  window = %s, ancestor = %s.\n",
+                    window->desc, ancestor->desc);
+      /* We could raise the window here, but don't want to do that twice and
+       * so we let the case below handle that.
+       */
+    }
+
+  /* Okay, so stacking constraints misses one case: If a window has
+   * two children and we want to raise one of those children, then
+   * raising the ancestor isn't enough; we need to also raise the
+   * correct child.  See bug 307875.
+   */
+  if (window != ancestor)
+    meta_stack_raise (window->screen->stack, window);
+}
+
+void
+meta_window_lower (MetaWindow  *window)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Lowering window %s\n", window->desc);
+
+  meta_stack_lower (window->screen->stack, window);
+}
+
+void
+meta_window_send_icccm_message (MetaWindow *window,
+                                Atom        atom,
+                                guint32     timestamp)
+{
+  /* This comment and code are from twm, copyright
+   * Open Group, Evans & Sutherland, etc.
+   */
+
+  /*
+   * ICCCM Client Messages - Section 4.2.8 of the ICCCM dictates that all
+   * client messages will have the following form:
+   *
+   *     event type	ClientMessage
+   *     message type	_XA_WM_PROTOCOLS
+   *     window		tmp->w
+   *     format		32
+   *     data[0]		message atom
+   *     data[1]		time stamp
+   */
+
+    XClientMessageEvent ev;
+
+    ev.type = ClientMessage;
+    ev.window = window->xwindow;
+    ev.message_type = window->display->atom_WM_PROTOCOLS;
+    ev.format = 32;
+    ev.data.l[0] = atom;
+    ev.data.l[1] = timestamp;
+
+    meta_error_trap_push (window->display);
+    XSendEvent (window->display->xdisplay,
+                window->xwindow, False, 0, (XEvent*) &ev);
+    meta_error_trap_pop (window->display, FALSE);
+}
+
+void
+meta_window_move_resize_request (MetaWindow *window,
+                                 guint       value_mask,
+                                 int         gravity,
+                                 int         new_x,
+                                 int         new_y,
+                                 int         new_width,
+                                 int         new_height)
+{
+  int x, y, width, height;
+  gboolean allow_position_change;
+  gboolean in_grab_op;
+  MetaMoveResizeFlags flags;
+
+  /* We ignore configure requests while the user is moving/resizing
+   * the window, since these represent the app sucking and fighting
+   * the user, most likely due to a bug in the app (e.g. pfaedit
+   * seemed to do this)
+   *
+   * Still have to do the ConfigureNotify and all, but pretend the
+   * app asked for the current size/position instead of the new one.
+   */
+  in_grab_op = FALSE;
+  if (window->display->grab_op != META_GRAB_OP_NONE &&
+      window == window->display->grab_window)
+    {
+      switch (window->display->grab_op)
+        {
+        case META_GRAB_OP_MOVING:
+        case META_GRAB_OP_RESIZING_SE:
+        case META_GRAB_OP_RESIZING_S:
+        case META_GRAB_OP_RESIZING_SW:
+        case META_GRAB_OP_RESIZING_N:
+        case META_GRAB_OP_RESIZING_NE:
+        case META_GRAB_OP_RESIZING_NW:
+        case META_GRAB_OP_RESIZING_W:
+        case META_GRAB_OP_RESIZING_E:
+          in_grab_op = TRUE;
+          break;
+        default:
+          break;
+        }
+    }
+
+  /* it's essential to use only the explicitly-set fields,
+   * and otherwise use our current up-to-date position.
+   *
+   * Otherwise you get spurious position changes when the app changes
+   * size, for example, if window->rect is not in sync with the
+   * server-side position in effect when the configure request was
+   * generated.
+   */
+  meta_window_get_gravity_position (window,
+                                    gravity,
+                                    &x, &y);
+
+  allow_position_change = FALSE;
+
+  if (meta_prefs_get_disable_workarounds ())
+    {
+      if (window->type == META_WINDOW_DIALOG ||
+          window->type == META_WINDOW_MODAL_DIALOG ||
+          window->type == META_WINDOW_SPLASHSCREEN)
+        ; /* No position change for these */
+      else if ((window->size_hints.flags & PPosition) ||
+               /* USPosition is just stale if window is placed;
+                * no --geometry involved here.
+                */
+               ((window->size_hints.flags & USPosition) &&
+                !window->placed))
+        allow_position_change = TRUE;
+    }
+  else
+    {
+      allow_position_change = TRUE;
+    }
+
+  if (in_grab_op)
+    allow_position_change = FALSE;
+
+  if (allow_position_change)
+    {
+      if (value_mask & CWX)
+        x = new_x;
+      if (value_mask & CWY)
+        y = new_y;
+      if (value_mask & (CWX | CWY))
+        {
+          /* Once manually positioned, windows shouldn't be placed
+           * by the window manager.
+           */
+          window->placed = TRUE;
+        }
+    }
+  else
+    {
+      meta_topic (META_DEBUG_GEOMETRY,
+		  "Not allowing position change for window %s PPosition 0x%lx USPosition 0x%lx type %u\n",
+		  window->desc, window->size_hints.flags & PPosition,
+		  window->size_hints.flags & USPosition,
+		  window->type);
+    }
+
+  width = window->rect.width;
+  height = window->rect.height;
+  if (!in_grab_op)
+    {
+      if (value_mask & CWWidth)
+        width = new_width;
+
+      if (value_mask & CWHeight)
+        height = new_height;
+    }
+
+  /* ICCCM 4.1.5 */
+
+  /* We're ignoring the value_mask here, since sizes
+   * not in the mask will be the current window geometry.
+   */
+  window->size_hints.x = x;
+  window->size_hints.y = y;
+  window->size_hints.width = width;
+  window->size_hints.height = height;
+
+  /* NOTE: We consider ConfigureRequests to be "user" actions in one
+   * way, but not in another.  Explanation of the two cases are in the
+   * next two big comments.
+   */
+
+  /* The constraints code allows user actions to move windows
+   * offscreen, etc., and configure request actions would often send
+   * windows offscreen when users don't want it if not constrained
+   * (e.g. hitting a dropdown triangle in a fileselector to show more
+   * options, which makes the window bigger).  Thus we do not set
+   * META_IS_USER_ACTION in flags to the
+   * meta_window_move_resize_internal() call.
+   */
+  flags = META_IS_CONFIGURE_REQUEST;
+  if (value_mask & (CWX | CWY))
+    flags |= META_IS_MOVE_ACTION;
+  if (value_mask & (CWWidth | CWHeight))
+    flags |= META_IS_RESIZE_ACTION;
+
+  if (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION))
+    meta_window_move_resize_internal (window,
+                                      flags,
+                                      gravity,
+                                      x,
+                                      y,
+                                      width,
+                                      height);
+
+  /* window->user_rect exists to allow "snapping-back" the window if a
+   * new strut is set (causing the window to move) and then the strut
+   * is later removed without the user moving the window in the
+   * interim.  We'd like to "snap-back" to the position specified by
+   * ConfigureRequest events (at least the constrained version of the
+   * ConfigureRequest, since that is guaranteed to be onscreen) so we
+   * set user_rect here.
+   *
+   * See also bug 426519.
+   */
+  save_user_window_placement (window);
+}
+
+gboolean
+meta_window_configure_request (MetaWindow *window,
+                               XEvent     *event)
+{
+  /* Note that x, y is the corner of the window border,
+   * and width, height is the size of the window inside
+   * its border, but that we always deny border requests
+   * and give windows a border of 0. But we save the
+   * requested border here.
+   */
+  if (event->xconfigurerequest.value_mask & CWBorderWidth)
+    window->border_width = event->xconfigurerequest.border_width;
+
+  meta_window_move_resize_request(window,
+                                  event->xconfigurerequest.value_mask,
+                                  window->size_hints.win_gravity,
+                                  event->xconfigurerequest.x,
+                                  event->xconfigurerequest.y,
+                                  event->xconfigurerequest.width,
+                                  event->xconfigurerequest.height);
+
+  /* Handle stacking. We only handle raises/lowers, mostly because
+   * stack.c really can't deal with anything else.  I guess we'll fix
+   * that if a client turns up that really requires it. Only a very
+   * few clients even require the raise/lower (and in fact all client
+   * attempts to deal with stacking order are essentially broken,
+   * since they have no idea what other clients are involved or how
+   * the stack looks).
+   *
+   * I'm pretty sure no interesting client uses TopIf, BottomIf, or
+   * Opposite anyway, so the only possible missing thing is
+   * Above/Below with a sibling set. For now we just pretend there's
+   * never a sibling set and always do the full raise/lower instead of
+   * the raise-just-above/below-sibling.
+   */
+  if (event->xconfigurerequest.value_mask & CWStackMode)
+    {
+      MetaWindow *active_window;
+      active_window = window->display->expected_focus_window;
+      if (meta_prefs_get_disable_workarounds () ||
+          !meta_prefs_get_raise_on_click ())
+        {
+          meta_topic (META_DEBUG_STACK,
+                      "%s sent an xconfigure stacking request; this is "
+                      "broken behavior and the request is being ignored.\n",
+                      window->desc);
+        }
+      else if (active_window &&
+               !meta_window_same_application (window, active_window) &&
+               XSERVER_TIME_IS_BEFORE (window->net_wm_user_time,
+                                       active_window->net_wm_user_time))
+        {
+          meta_topic (META_DEBUG_STACK,
+                      "Ignoring xconfigure stacking request from %s (with "
+                      "user_time %u); currently active application is %s (with "
+                      "user_time %u).\n",
+                      window->desc,
+                      window->net_wm_user_time,
+                      active_window->desc,
+                      active_window->net_wm_user_time);
+          if (event->xconfigurerequest.detail == Above)
+            meta_window_set_demands_attention(window);
+        }
+      else
+        {
+          switch (event->xconfigurerequest.detail)
+            {
+            case Above:
+              meta_window_raise (window);
+              break;
+            case Below:
+              meta_window_lower (window);
+              break;
+            case TopIf:
+            case BottomIf:
+            case Opposite:
+              break;
+            }
+        }
+    }
+
+  return TRUE;
+}
+
+gboolean
+meta_window_property_notify (MetaWindow *window,
+                             XEvent     *event)
+{
+  return process_property_notify (window, &event->xproperty);
+}
+
+#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT      0
+#define _NET_WM_MOVERESIZE_SIZE_TOP          1
+#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT     2
+#define _NET_WM_MOVERESIZE_SIZE_RIGHT        3
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT  4
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOM       5
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT   6
+#define _NET_WM_MOVERESIZE_SIZE_LEFT         7
+#define _NET_WM_MOVERESIZE_MOVE              8
+#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD     9
+#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD    10
+#define _NET_WM_MOVERESIZE_CANCEL           11
+
+gboolean
+meta_window_client_message (MetaWindow *window,
+                            XEvent     *event)
+{
+  MetaDisplay *display;
+
+  display = window->display;
+
+  if (event->xclient.message_type ==
+      display->atom__NET_CLOSE_WINDOW)
+    {
+      guint32 timestamp;
+
+      if (event->xclient.data.l[0] != 0)
+	timestamp = event->xclient.data.l[0];
+      else
+        {
+          meta_warning ("Receiving a NET_CLOSE_WINDOW message for %s without "
+                        "a timestamp!  This means some buggy (outdated) "
+                        "application is on the loose!\n",
+                        window->desc);
+          timestamp = meta_display_get_current_time (window->display);
+        }
+
+      meta_window_delete (window, timestamp);
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_WM_DESKTOP)
+    {
+      int space;
+      MetaWorkspace *workspace;
+
+      space = event->xclient.data.l[0];
+
+      meta_verbose ("Request to move %s to workspace %d\n",
+                    window->desc, space);
+
+      workspace =
+        meta_screen_get_workspace_by_index (window->screen,
+                                            space);
+
+      if (workspace)
+        {
+          if (window->on_all_workspaces)
+            meta_window_unstick (window);
+          meta_window_change_workspace (window, workspace);
+        }
+      else if (space == (int) 0xFFFFFFFF)
+        {
+          meta_window_stick (window);
+        }
+      else
+        {
+          meta_verbose ("No such workspace %d for screen\n", space);
+        }
+
+      meta_verbose ("Window %s now on_all_workspaces = %d\n",
+                    window->desc, window->on_all_workspaces);
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_WM_STATE)
+    {
+      gulong action;
+      Atom first;
+      Atom second;
+
+      action = event->xclient.data.l[0];
+      first = event->xclient.data.l[1];
+      second = event->xclient.data.l[2];
+
+      if (meta_is_verbose ())
+        {
+          char *str1;
+          char *str2;
+
+          meta_error_trap_push_with_return (display);
+          str1 = XGetAtomName (display->xdisplay, first);
+          if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+            str1 = NULL;
+
+          meta_error_trap_push_with_return (display);
+          str2 = XGetAtomName (display->xdisplay, second);
+          if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+            str2 = NULL;
+
+          meta_verbose ("Request to change _NET_WM_STATE action %lu atom1: %s atom2: %s\n",
+                        action,
+                        str1 ? str1 : "(unknown)",
+                        str2 ? str2 : "(unknown)");
+
+          meta_XFree (str1);
+          meta_XFree (str2);
+        }
+
+      if (first == display->atom__NET_WM_STATE_SHADED ||
+          second == display->atom__NET_WM_STATE_SHADED)
+        {
+          gboolean shade;
+          guint32 timestamp;
+
+          /* Stupid protocol has no timestamp; of course, shading
+           * sucks anyway so who really cares that we're forced to do
+           * a roundtrip here?
+           */
+          timestamp = meta_display_get_current_time_roundtrip (window->display);
+
+          shade = (action == _NET_WM_STATE_ADD ||
+                   (action == _NET_WM_STATE_TOGGLE && !window->shaded));
+          if (shade && window->has_shade_func)
+            meta_window_shade (window, timestamp);
+          else
+            meta_window_unshade (window, timestamp);
+        }
+
+      if (first == display->atom__NET_WM_STATE_FULLSCREEN ||
+          second == display->atom__NET_WM_STATE_FULLSCREEN)
+        {
+          gboolean make_fullscreen;
+
+          make_fullscreen = (action == _NET_WM_STATE_ADD ||
+                             (action == _NET_WM_STATE_TOGGLE && !window->fullscreen));
+          if (make_fullscreen && window->has_fullscreen_func)
+            meta_window_make_fullscreen (window);
+          else
+            meta_window_unmake_fullscreen (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_MAXIMIZED_HORZ ||
+          second == display->atom__NET_WM_STATE_MAXIMIZED_HORZ)
+        {
+          gboolean max;
+
+          max = (action == _NET_WM_STATE_ADD ||
+                 (action == _NET_WM_STATE_TOGGLE &&
+                  !window->maximized_horizontally));
+          if (max && window->has_maximize_func)
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_maximize (window, META_MAXIMIZE_HORIZONTAL);
+            }
+          else
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_unmaximize (window, META_MAXIMIZE_HORIZONTAL);
+            }
+        }
+
+      if (first == display->atom__NET_WM_STATE_MAXIMIZED_VERT ||
+          second == display->atom__NET_WM_STATE_MAXIMIZED_VERT)
+        {
+          gboolean max;
+
+          max = (action == _NET_WM_STATE_ADD ||
+                 (action == _NET_WM_STATE_TOGGLE &&
+                  !window->maximized_vertically));
+          if (max && window->has_maximize_func)
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_maximize (window, META_MAXIMIZE_VERTICAL);
+            }
+          else
+            {
+              if (meta_prefs_get_raise_on_click ())
+                meta_window_raise (window);
+              meta_window_unmaximize (window, META_MAXIMIZE_VERTICAL);
+            }
+        }
+
+      if (first == display->atom__NET_WM_STATE_MODAL ||
+          second == display->atom__NET_WM_STATE_MODAL)
+        {
+          window->wm_state_modal =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->wm_state_modal);
+
+          recalc_window_type (window);
+          meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
+        }
+
+      if (first == display->atom__NET_WM_STATE_SKIP_PAGER ||
+          second == display->atom__NET_WM_STATE_SKIP_PAGER)
+        {
+          window->wm_state_skip_pager =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->skip_pager);
+
+          recalc_window_features (window);
+          set_net_wm_state (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_SKIP_TASKBAR ||
+          second == display->atom__NET_WM_STATE_SKIP_TASKBAR)
+        {
+          window->wm_state_skip_taskbar =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->skip_taskbar);
+
+          recalc_window_features (window);
+          set_net_wm_state (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_ABOVE ||
+          second == display->atom__NET_WM_STATE_ABOVE)
+        {
+          window->wm_state_above =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->wm_state_above);
+
+          meta_window_update_layer (window);
+          set_net_wm_state (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_BELOW ||
+          second == display->atom__NET_WM_STATE_BELOW)
+        {
+          window->wm_state_below =
+            (action == _NET_WM_STATE_ADD) ||
+            (action == _NET_WM_STATE_TOGGLE && !window->wm_state_below);
+
+          meta_window_update_layer (window);
+          set_net_wm_state (window);
+        }
+
+      if (first == display->atom__NET_WM_STATE_DEMANDS_ATTENTION ||
+          second == display->atom__NET_WM_STATE_DEMANDS_ATTENTION)
+        {
+          if ((action == _NET_WM_STATE_ADD) ||
+              (action == _NET_WM_STATE_TOGGLE && !window->wm_state_demands_attention))
+            meta_window_set_demands_attention (window);
+          else
+            meta_window_unset_demands_attention (window);
+        }
+
+       if (first == display->atom__NET_WM_STATE_STICKY ||
+          second == display->atom__NET_WM_STATE_STICKY)
+        {
+          if ((action == _NET_WM_STATE_ADD) ||
+              (action == _NET_WM_STATE_TOGGLE && !window->on_all_workspaces))
+            meta_window_stick (window);
+          else
+            meta_window_unstick (window);
+        }
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom_WM_CHANGE_STATE)
+    {
+      meta_verbose ("WM_CHANGE_STATE client message, state: %ld\n",
+                    event->xclient.data.l[0]);
+      if (event->xclient.data.l[0] == IconicState &&
+          window->has_minimize_func)
+        meta_window_minimize (window);
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_WM_MOVERESIZE)
+    {
+      int x_root;
+      int y_root;
+      int action;
+      MetaGrabOp op;
+      int button;
+      guint32 timestamp;
+
+      /* _NET_WM_MOVERESIZE messages are almost certainly going to come from
+       * clients when users click on the fake "frame" that the client has,
+       * thus we should also treat such messages as though it were a
+       * "frame action".
+       */
+      gboolean const frame_action = TRUE;
+
+      x_root = event->xclient.data.l[0];
+      y_root = event->xclient.data.l[1];
+      action = event->xclient.data.l[2];
+      button = event->xclient.data.l[3];
+
+      /* FIXME: What a braindead protocol; no timestamp?!? */
+      timestamp = meta_display_get_current_time_roundtrip (display);
+      meta_warning ("Received a _NET_WM_MOVERESIZE message for %s; these "
+                    "messages lack timestamps and therefore suck.\n",
+                    window->desc);
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Received _NET_WM_MOVERESIZE message on %s, %d,%d action = %d, button %d\n",
+                  window->desc,
+                  x_root, y_root, action, button);
+
+      op = META_GRAB_OP_NONE;
+      switch (action)
+        {
+        case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
+          op = META_GRAB_OP_RESIZING_NW;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_TOP:
+          op = META_GRAB_OP_RESIZING_N;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
+          op = META_GRAB_OP_RESIZING_NE;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_RIGHT:
+          op = META_GRAB_OP_RESIZING_E;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
+          op = META_GRAB_OP_RESIZING_SE;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
+          op = META_GRAB_OP_RESIZING_S;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
+          op = META_GRAB_OP_RESIZING_SW;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_LEFT:
+          op = META_GRAB_OP_RESIZING_W;
+          break;
+        case _NET_WM_MOVERESIZE_MOVE:
+          op = META_GRAB_OP_MOVING;
+          break;
+        case _NET_WM_MOVERESIZE_SIZE_KEYBOARD:
+          op = META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN;
+          break;
+        case _NET_WM_MOVERESIZE_MOVE_KEYBOARD:
+          op = META_GRAB_OP_KEYBOARD_MOVING;
+          break;
+        case _NET_WM_MOVERESIZE_CANCEL:
+          /* handled below */
+          break;
+        default:
+          break;
+        }
+
+      if (action == _NET_WM_MOVERESIZE_CANCEL)
+        {
+          meta_display_end_grab_op (window->display, timestamp);
+        }
+      else if (op != META_GRAB_OP_NONE &&
+          ((window->has_move_func && op == META_GRAB_OP_KEYBOARD_MOVING) ||
+           (window->has_resize_func && op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN)))
+        {
+          meta_window_begin_grab_op (window, op, frame_action, timestamp);
+        }
+      else if (op != META_GRAB_OP_NONE &&
+               ((window->has_move_func && op == META_GRAB_OP_MOVING) ||
+               (window->has_resize_func &&
+                (op != META_GRAB_OP_MOVING &&
+                 op != META_GRAB_OP_KEYBOARD_MOVING))))
+        {
+          /*
+           * the button SHOULD already be included in the message
+           */
+          if (button == 0)
+            {
+              int x, y, query_root_x, query_root_y;
+              Window root, child;
+              guint mask;
+
+              /* The race conditions in this _NET_WM_MOVERESIZE thing
+               * are mind-boggling
+               */
+              mask = 0;
+              meta_error_trap_push (window->display);
+              XQueryPointer (window->display->xdisplay,
+                             window->xwindow,
+                             &root, &child,
+                             &query_root_x, &query_root_y,
+                             &x, &y,
+                             &mask);
+              meta_error_trap_pop (window->display, TRUE);
+
+              if (mask & Button1Mask)
+                button = 1;
+              else if (mask & Button2Mask)
+                button = 2;
+              else if (mask & Button3Mask)
+                button = 3;
+              else
+                button = 0;
+            }
+
+          if (button != 0)
+            {
+              meta_topic (META_DEBUG_WINDOW_OPS,
+                          "Beginning move/resize with button = %d\n", button);
+              meta_display_begin_grab_op (window->display,
+                                          window->screen,
+                                          window,
+                                          op,
+                                          FALSE,
+                                          frame_action,
+                                          button, 0,
+                                          timestamp,
+                                          x_root,
+                                          y_root);
+            }
+        }
+
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_MOVERESIZE_WINDOW)
+    {
+      int gravity, source;
+      guint value_mask;
+
+      gravity = (event->xclient.data.l[0] & 0xff);
+      value_mask = (event->xclient.data.l[0] & 0xf00) >> 8;
+      source = (event->xclient.data.l[0] & 0xf000) >> 12;
+
+      if (gravity == 0)
+        gravity = window->size_hints.win_gravity;
+
+      meta_window_move_resize_request(window,
+                                      value_mask,
+                                      gravity,
+                                      event->xclient.data.l[1],  /* x */
+                                      event->xclient.data.l[2],  /* y */
+                                      event->xclient.data.l[3],  /* width */
+                                      event->xclient.data.l[4]); /* height */
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_ACTIVE_WINDOW)
+    {
+      MetaClientType source_indication;
+      guint32        timestamp;
+
+      meta_verbose ("_NET_ACTIVE_WINDOW request for window '%s', activating\n",
+                    window->desc);
+
+      source_indication = event->xclient.data.l[0];
+      timestamp = event->xclient.data.l[1];
+
+      if (source_indication > META_CLIENT_TYPE_MAX_RECOGNIZED)
+        source_indication = META_CLIENT_TYPE_UNKNOWN;
+
+      if (timestamp == 0)
+        {
+          /* Client using older EWMH _NET_ACTIVE_WINDOW without a timestamp */
+          meta_warning ("Buggy client sent a _NET_ACTIVE_WINDOW message with a "
+                        "timestamp of 0 for %s\n",
+                        window->desc);
+          timestamp = meta_display_get_current_time (display);
+        }
+
+      window_activate (window, timestamp, source_indication, NULL);
+      return TRUE;
+    }
+  else if (event->xclient.message_type ==
+           display->atom__NET_WM_FULLSCREEN_MONITORS)
+    {
+      MetaClientType source_indication;
+      gulong top, bottom, left, right;
+
+      meta_verbose ("_NET_WM_FULLSCREEN_MONITORS request for window '%s'\n",
+                    window->desc);
+
+      top = event->xclient.data.l[0];
+      bottom = event->xclient.data.l[1];
+      left = event->xclient.data.l[2];
+      right = event->xclient.data.l[3];
+      source_indication = event->xclient.data.l[4];
+
+      meta_window_update_fullscreen_monitors (window, top, bottom, left, right);
+    }
+
+  return FALSE;
+}
+
+gboolean
+meta_window_notify_focus (MetaWindow *window,
+                          XEvent     *event)
+{
+  /* note the event can be on either the window or the frame,
+   * we focus the frame for shaded windows
+   */
+
+  /* The event can be FocusIn, FocusOut, or UnmapNotify.
+   * On UnmapNotify we have to pretend it's focus out,
+   * because we won't get a focus out if it occurs, apparently.
+   */
+
+  /* We ignore grabs, though this is questionable.
+   * It may be better to increase the intelligence of
+   * the focus window tracking.
+   *
+   * The problem is that keybindings for windows are done with
+   * XGrabKey, which means focus_window disappears and the front of
+   * the MRU list gets confused from what the user expects once a
+   * keybinding is used.
+   */
+  meta_topic (META_DEBUG_FOCUS,
+              "Focus %s event received on %s 0x%lx (%s) "
+              "mode %s detail %s\n",
+              event->type == FocusIn ? "in" :
+              event->type == FocusOut ? "out" :
+              event->type == UnmapNotify ? "unmap" :
+              "???",
+              window->desc, event->xany.window,
+              event->xany.window == window->xwindow ?
+              "client window" :
+              (window->frame && event->xany.window == window->frame->xwindow) ?
+              "frame window" :
+              "unknown window",
+              event->type != UnmapNotify ?
+              meta_event_mode_to_string (event->xfocus.mode) : "n/a",
+              event->type != UnmapNotify ?
+              meta_event_detail_to_string (event->xfocus.detail) : "n/a");
+
+  /* FIXME our pointer tracking is broken; see how
+   * gtk+/gdk/x11/gdkevents-x11.c or XFree86/xc/programs/xterm/misc.c
+   * handle it for the correct way.  In brief you need to track
+   * pointer focus and regular focus, and handle EnterNotify in
+   * PointerRoot mode with no window manager.  However as noted above,
+   * accurate focus tracking will break things because we want to keep
+   * windows "focused" when using keybindings on them, and also we
+   * sometimes "focus" a window by focusing its frame or
+   * no_focus_window; so this all needs rethinking massively.
+   *
+   * My suggestion is to change it so that we clearly separate
+   * actual keyboard focus tracking using the xterm algorithm,
+   * and marco's "pretend" focus window, and go through all
+   * the code and decide which one should be used in each place;
+   * a hard bit is deciding on a policy for that.
+   *
+   * http://bugzilla.gnome.org/show_bug.cgi?id=90382
+   */
+
+  if ((event->type == FocusIn ||
+       event->type == FocusOut) &&
+      (event->xfocus.mode == NotifyGrab ||
+       event->xfocus.mode == NotifyUngrab ||
+       /* From WindowMaker, ignore all funky pointer root events */
+       event->xfocus.detail > NotifyNonlinearVirtual))
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Ignoring focus event generated by a grab or other weirdness\n");
+      return TRUE;
+    }
+
+  if (event->type == FocusIn)
+    {
+      if (window != window->display->focus_window)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "* Focus --> %s\n", window->desc);
+          window->display->focus_window = window;
+          window->has_focus = TRUE;
+          meta_compositor_set_active_window (window->display->compositor,
+                                             window->screen, window);
+
+          /* Move to the front of the focusing workspace's MRU list.
+           * We should only be "removing" it from the MRU list if it's
+           * not already there.  Note that it's possible that we might
+           * be processing this FocusIn after we've changed to a
+           * different workspace; we should therefore update the MRU
+           * list only if the window is actually on the active
+           * workspace.
+           */
+          if (window->screen->active_workspace &&
+              meta_window_located_on_workspace (window,
+                                                window->screen->active_workspace))
+            {
+              GList* link;
+              link = g_list_find (window->screen->active_workspace->mru_list,
+                                  window);
+              g_assert (link);
+
+              window->screen->active_workspace->mru_list =
+                g_list_remove_link (window->screen->active_workspace->mru_list,
+                                    link);
+              g_list_free (link);
+
+              window->screen->active_workspace->mru_list =
+                g_list_prepend (window->screen->active_workspace->mru_list,
+                                window);
+            }
+
+          if (window->frame)
+            meta_frame_queue_draw (window->frame);
+
+          meta_error_trap_push (window->display);
+          XInstallColormap (window->display->xdisplay,
+                            window->colormap);
+          meta_error_trap_pop (window->display, FALSE);
+
+          /* move into FOCUSED_WINDOW layer */
+          meta_window_update_layer (window);
+
+          /* Ungrab click to focus button since the sync grab can interfere
+           * with some things you might do inside the focused window, by
+           * causing the client to get funky enter/leave events.
+           *
+           * The reason we usually have a passive grab on the window is
+           * so that we can intercept clicks and raise the window in
+           * response. For click-to-focus we don't need that since the
+           * focused window is already raised. When raise_on_click is
+           * FALSE we also don't need that since we don't do anything
+           * when the window is clicked.
+           *
+           * There is dicussion in bugs 102209, 115072, and 461577
+           */
+          if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK ||
+              !meta_prefs_get_raise_on_click())
+            meta_display_ungrab_focus_window_button (window->display, window);
+        }
+    }
+  else if (event->type == FocusOut ||
+           event->type == UnmapNotify)
+    {
+      if (event->type == FocusOut &&
+          event->xfocus.detail == NotifyInferior)
+        {
+          /* This event means the client moved focus to a subwindow */
+          meta_topic (META_DEBUG_FOCUS,
+                      "Ignoring focus out on %s with NotifyInferior\n",
+                      window->desc);
+          return TRUE;
+        }
+
+      if (window == window->display->focus_window)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "%s is now the previous focus window due to being focused out or unmapped\n",
+                      window->desc);
+
+          meta_topic (META_DEBUG_FOCUS,
+                      "* Focus --> NULL (was %s)\n", window->desc);
+
+          window->display->focus_window = NULL;
+          window->has_focus = FALSE;
+          if (window->frame)
+            meta_frame_queue_draw (window->frame);
+
+          meta_compositor_set_active_window (window->display->compositor,
+                                             window->screen, NULL);
+
+          meta_error_trap_push (window->display);
+          XUninstallColormap (window->display->xdisplay,
+                              window->colormap);
+          meta_error_trap_pop (window->display, FALSE);
+
+          /* move out of FOCUSED_WINDOW layer */
+          meta_window_update_layer (window);
+
+          /* Re-grab for click to focus and raise-on-click, if necessary */
+          if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK ||
+              !meta_prefs_get_raise_on_click ())
+            meta_display_grab_focus_window_button (window->display, window);
+       }
+    }
+
+  /* Now set _NET_ACTIVE_WINDOW hint */
+  meta_display_update_active_window_hint (window->display);
+
+  return FALSE;
+}
+
+static gboolean
+process_property_notify (MetaWindow     *window,
+                         XPropertyEvent *event)
+{
+  Window xid = window->xwindow;
+
+  if (meta_is_verbose ()) /* avoid looking up the name if we don't have to */
+    {
+      char *property_name = XGetAtomName (window->display->xdisplay,
+                                          event->atom);
+
+      meta_verbose ("Property notify on %s for %s\n",
+                    window->desc, property_name);
+      XFree (property_name);
+    }
+
+  if (event->atom == window->display->atom__NET_WM_USER_TIME &&
+      window->user_time_window)
+    {
+      xid = window->user_time_window;
+    }
+
+  meta_window_reload_property (window, event->atom, FALSE);
+
+  return TRUE;
+}
+
+static void
+send_configure_notify (MetaWindow *window)
+{
+  XEvent event;
+
+  /* from twm */
+
+  event.type = ConfigureNotify;
+  event.xconfigure.display = window->display->xdisplay;
+  event.xconfigure.event = window->xwindow;
+  event.xconfigure.window = window->xwindow;
+  event.xconfigure.x = window->rect.x - window->border_width;
+  event.xconfigure.y = window->rect.y - window->border_width;
+  if (window->frame)
+    {
+      if (window->withdrawn)
+        {
+          /* WARNING: x & y need to be set to whatever the XReparentWindow
+           * call in meta_window_destroy_frame will use so that the window
+           * has the right coordinates.  Currently, that means no change to
+           * x & y.
+           */
+        }
+      else
+        {
+          /* Need to be in root window coordinates */
+          event.xconfigure.x += window->frame->rect.x;
+          event.xconfigure.y += window->frame->rect.y;
+        }
+    }
+  event.xconfigure.width = window->rect.width;
+  event.xconfigure.height = window->rect.height;
+  event.xconfigure.border_width = window->border_width; /* requested not actual */
+  event.xconfigure.above = None; /* FIXME */
+  event.xconfigure.override_redirect = False;
+
+  meta_topic (META_DEBUG_GEOMETRY,
+              "Sending synthetic configure notify to %s with x: %d y: %d w: %d h: %d\n",
+              window->desc,
+              event.xconfigure.x, event.xconfigure.y,
+              event.xconfigure.width, event.xconfigure.height);
+
+  meta_error_trap_push (window->display);
+  XSendEvent (window->display->xdisplay,
+              window->xwindow,
+              False, StructureNotifyMask, &event);
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+gboolean
+meta_window_get_icon_geometry (MetaWindow    *window,
+                               MetaRectangle *rect)
+{
+  gulong *geometry = NULL;
+  int nitems;
+
+  if (meta_prop_get_cardinal_list (window->display,
+                                   window->xwindow,
+                                   window->display->atom__NET_WM_ICON_GEOMETRY,
+                                   &geometry, &nitems))
+    {
+      if (nitems != 4)
+        {
+          meta_verbose ("_NET_WM_ICON_GEOMETRY on %s has %d values instead of 4\n",
+                        window->desc, nitems);
+          meta_XFree (geometry);
+          return FALSE;
+        }
+
+      if (rect)
+        {
+          rect->x = geometry[0];
+          rect->y = geometry[1];
+          rect->width = geometry[2];
+          rect->height = geometry[3];
+        }
+
+      meta_XFree (geometry);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static Window
+read_client_leader (MetaDisplay *display,
+                    Window       xwindow)
+{
+  Window retval = None;
+
+  meta_prop_get_window (display, xwindow,
+                        display->atom_WM_CLIENT_LEADER,
+                        &retval);
+
+  return retval;
+}
+
+typedef struct
+{
+  Window leader;
+} ClientLeaderData;
+
+static gboolean
+find_client_leader_func (MetaWindow *ancestor,
+                         void       *data)
+{
+  ClientLeaderData *d;
+
+  d = data;
+
+  d->leader = read_client_leader (ancestor->display,
+                                  ancestor->xwindow);
+
+  /* keep going if no client leader found */
+  return d->leader == None;
+}
+
+static void
+update_sm_hints (MetaWindow *window)
+{
+  Window leader;
+
+  window->xclient_leader = None;
+  window->sm_client_id = NULL;
+
+  /* If not on the current window, we can get the client
+   * leader from transient parents. If we find a client
+   * leader, we read the SM_CLIENT_ID from it.
+   */
+  leader = read_client_leader (window->display, window->xwindow);
+  if (leader == None)
+    {
+      ClientLeaderData d;
+      d.leader = None;
+      meta_window_foreach_ancestor (window, find_client_leader_func,
+                                    &d);
+      leader = d.leader;
+    }
+
+  if (leader != None)
+    {
+      char *str;
+
+      window->xclient_leader = leader;
+
+      if (meta_prop_get_latin1_string (window->display, leader,
+                                       window->display->atom_SM_CLIENT_ID,
+                                       &str))
+        {
+          window->sm_client_id = g_strdup (str);
+          meta_XFree (str);
+        }
+    }
+  else
+    {
+      meta_verbose ("Didn't find a client leader for %s\n", window->desc);
+
+      if (!meta_prefs_get_disable_workarounds ())
+        {
+          /* Some broken apps (kdelibs fault?) set SM_CLIENT_ID on the app
+           * instead of the client leader
+           */
+          char *str;
+
+          str = NULL;
+          if (meta_prop_get_latin1_string (window->display, window->xwindow,
+                                           window->display->atom_SM_CLIENT_ID,
+                                           &str))
+            {
+              if (window->sm_client_id == NULL) /* first time through */
+                meta_warning (_("Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER window as specified in the ICCCM.\n"),
+                              window->desc);
+
+              window->sm_client_id = g_strdup (str);
+              meta_XFree (str);
+            }
+        }
+    }
+
+  meta_verbose ("Window %s client leader: 0x%lx SM_CLIENT_ID: '%s'\n",
+                window->desc, window->xclient_leader,
+                window->sm_client_id ? window->sm_client_id : "none");
+}
+
+void
+meta_window_update_role (MetaWindow *window)
+{
+  char *str;
+
+  if (window->role)
+    g_free (window->role);
+  window->role = NULL;
+
+  if (meta_prop_get_latin1_string (window->display, window->xwindow,
+                                   window->display->atom_WM_WINDOW_ROLE,
+                                   &str))
+    {
+      window->role = g_strdup (str);
+      meta_XFree (str);
+    }
+
+  meta_verbose ("Updated role of %s to '%s'\n",
+                window->desc, window->role ? window->role : "null");
+}
+
+void
+meta_window_update_net_wm_type (MetaWindow *window)
+{
+  int n_atoms;
+  Atom *atoms;
+  int i;
+
+  window->type_atom = None;
+  n_atoms = 0;
+  atoms = NULL;
+
+  meta_prop_get_atom_list (window->display, window->xwindow,
+                           window->display->atom__NET_WM_WINDOW_TYPE,
+                           &atoms, &n_atoms);
+
+  i = 0;
+  while (i < n_atoms)
+    {
+      /* We break as soon as we find one we recognize,
+       * supposed to prefer those near the front of the list
+       */
+      if (atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DOCK ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_MENU ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
+        {
+          window->type_atom = atoms[i];
+          break;
+        }
+
+      ++i;
+    }
+
+  meta_XFree (atoms);
+
+  if (meta_is_verbose ())
+    {
+      char *str;
+
+      str = NULL;
+      if (window->type_atom != None)
+        {
+          meta_error_trap_push (window->display);
+          str = XGetAtomName (window->display->xdisplay, window->type_atom);
+          meta_error_trap_pop (window->display, TRUE);
+        }
+
+      meta_verbose ("Window %s type atom %s\n", window->desc,
+                    str ? str : "(none)");
+
+      if (str)
+        meta_XFree (str);
+    }
+
+  meta_window_recalc_window_type (window);
+}
+
+static void
+redraw_icon (MetaWindow *window)
+{
+  /* We could probably be smart and just redraw the icon here,
+   * instead of the whole frame.
+   */
+  if (window->frame && (window->mapped || window->frame->mapped))
+    meta_ui_queue_frame_draw (window->screen->ui, window->frame->xwindow);
+}
+
+void
+meta_window_update_icon_now (MetaWindow *window)
+{
+  GdkPixbuf *icon;
+  GdkPixbuf *mini_icon;
+
+  icon = NULL;
+  mini_icon = NULL;
+
+  if (meta_read_icons (window->screen,
+                       window->xwindow,
+                       &window->icon_cache,
+                       window->wm_hints_pixmap,
+                       window->wm_hints_mask,
+                       &icon,
+                       META_ICON_WIDTH, META_ICON_HEIGHT,
+                       &mini_icon,
+                       META_MINI_ICON_WIDTH,
+                       META_MINI_ICON_HEIGHT))
+    {
+      if (window->icon)
+        g_object_unref (G_OBJECT (window->icon));
+
+      if (window->mini_icon)
+        g_object_unref (G_OBJECT (window->mini_icon));
+
+      window->icon = icon;
+      window->mini_icon = mini_icon;
+
+      redraw_icon (window);
+    }
+
+  g_assert (window->icon);
+  g_assert (window->mini_icon);
+}
+
+static gboolean
+idle_update_icon (gpointer data)
+{
+  GSList *tmp;
+  GSList *copy;
+  guint queue_index = GPOINTER_TO_INT (data);
+
+  meta_topic (META_DEBUG_GEOMETRY, "Clearing the update_icon queue\n");
+
+  /* Work with a copy, for reentrancy. The allowed reentrancy isn't
+   * complete; destroying a window while we're in here would result in
+   * badness. But it's OK to queue/unqueue update_icons.
+   */
+  copy = g_slist_copy (queue_pending[queue_index]);
+  g_slist_free (queue_pending[queue_index]);
+  queue_pending[queue_index] = NULL;
+  queue_idle[queue_index] = 0;
+
+  destroying_windows_disallowed += 1;
+
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window;
+
+      window = tmp->data;
+
+      meta_window_update_icon_now (window);
+      window->is_in_queues &= ~META_QUEUE_UPDATE_ICON;
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (copy);
+
+  destroying_windows_disallowed -= 1;
+
+  return FALSE;
+}
+
+GList*
+meta_window_get_workspaces (MetaWindow *window)
+{
+  if (window->on_all_workspaces)
+    return window->screen->workspaces;
+  else
+    return window->workspace->list_containing_self;
+}
+
+static void
+invalidate_work_areas (MetaWindow *window)
+{
+  GList *tmp;
+
+  tmp = meta_window_get_workspaces (window);
+
+  while (tmp != NULL)
+    {
+      meta_workspace_invalidate_work_area (tmp->data);
+      tmp = tmp->next;
+    }
+}
+
+void
+meta_window_update_struts (MetaWindow *window)
+{
+  GSList *old_struts;
+  GSList *new_struts;
+  GSList *old_iter, *new_iter;
+  gulong *struts = NULL;
+  int nitems;
+  gboolean changed;
+
+  meta_verbose ("Updating struts for %s\n", window->desc);
+
+  old_struts = window->struts;
+  new_struts = NULL;
+
+  if (meta_prop_get_cardinal_list (window->display,
+                                   window->xwindow,
+                                   window->display->atom__NET_WM_STRUT_PARTIAL,
+                                   &struts, &nitems))
+    {
+      if (nitems != 12)
+        meta_verbose ("_NET_WM_STRUT_PARTIAL on %s has %d values instead "
+                      "of 12\n",
+                      window->desc, nitems);
+      else
+        {
+          /* Pull out the strut info for each side in the hint */
+          int i;
+          for (i=0; i<4; i++)
+            {
+              MetaStrut *temp;
+              int thickness, strut_begin, strut_end;
+
+              thickness = struts[i];
+              if (thickness == 0)
+                continue;
+              strut_begin = struts[4+(i*2)];
+              strut_end   = struts[4+(i*2)+1];
+
+              temp = g_new (MetaStrut, 1);
+              temp->side = 1 << i; /* See MetaSide def.  Matches nicely, eh? */
+              temp->rect = window->screen->rect;
+              switch (temp->side)
+                {
+                case META_SIDE_RIGHT:
+                  temp->rect.x = BOX_RIGHT(temp->rect) - thickness;
+                  /* Intentionally fall through without breaking */
+                case META_SIDE_LEFT:
+                  temp->rect.width  = thickness;
+                  temp->rect.y      = strut_begin;
+                  temp->rect.height = strut_end - strut_begin + 1;
+                  break;
+                case META_SIDE_BOTTOM:
+                  temp->rect.y = BOX_BOTTOM(temp->rect) - thickness;
+                  /* Intentionally fall through without breaking */
+                case META_SIDE_TOP:
+                  temp->rect.height = thickness;
+                  temp->rect.x      = strut_begin;
+                  temp->rect.width  = strut_end - strut_begin + 1;
+                  break;
+                default:
+                  g_assert_not_reached ();
+                }
+
+              new_struts = g_slist_prepend (new_struts, temp);
+            }
+
+          meta_verbose ("_NET_WM_STRUT_PARTIAL struts %lu %lu %lu %lu for "
+                        "window %s\n",
+                        struts[0], struts[1], struts[2], struts[3],
+                        window->desc);
+        }
+      meta_XFree (struts);
+    }
+  else
+    {
+      meta_verbose ("No _NET_WM_STRUT property for %s\n",
+                    window->desc);
+    }
+
+  if (!new_struts &&
+      meta_prop_get_cardinal_list (window->display,
+                                   window->xwindow,
+                                   window->display->atom__NET_WM_STRUT,
+                                   &struts, &nitems))
+    {
+      if (nitems != 4)
+        meta_verbose ("_NET_WM_STRUT on %s has %d values instead of 4\n",
+                      window->desc, nitems);
+      else
+        {
+          /* Pull out the strut info for each side in the hint */
+          int i;
+          for (i=0; i<4; i++)
+            {
+              MetaStrut *temp;
+              int thickness;
+
+              thickness = struts[i];
+              if (thickness == 0)
+                continue;
+
+              temp = g_new (MetaStrut, 1);
+              temp->side = 1 << i;
+              temp->rect = window->screen->rect;
+              switch (temp->side)
+                {
+                case META_SIDE_RIGHT:
+                  temp->rect.x = BOX_RIGHT(temp->rect) - thickness;
+                  /* Intentionally fall through without breaking */
+                case META_SIDE_LEFT:
+                  temp->rect.width  = thickness;
+                  break;
+                case META_SIDE_BOTTOM:
+                  temp->rect.y = BOX_BOTTOM(temp->rect) - thickness;
+                  /* Intentionally fall through without breaking */
+                case META_SIDE_TOP:
+                  temp->rect.height = thickness;
+                  break;
+                default:
+                  g_assert_not_reached ();
+                }
+
+              new_struts = g_slist_prepend (new_struts, temp);
+            }
+
+          meta_verbose ("_NET_WM_STRUT struts %lu %lu %lu %lu for window %s\n",
+                        struts[0], struts[1], struts[2], struts[3],
+                        window->desc);
+        }
+      meta_XFree (struts);
+    }
+  else if (!new_struts)
+    {
+      meta_verbose ("No _NET_WM_STRUT property for %s\n",
+                    window->desc);
+    }
+
+  /* Determine whether old_struts and new_struts are the same */
+  old_iter = old_struts;
+  new_iter = new_struts;
+  while (old_iter && new_iter)
+    {
+      MetaStrut *old_strut = (MetaStrut*) old_iter->data;
+      MetaStrut *new_strut = (MetaStrut*) new_iter->data;
+
+      if (old_strut->side != new_strut->side ||
+          !meta_rectangle_equal (&old_strut->rect, &new_strut->rect))
+        break;
+
+      old_iter = old_iter->next;
+      new_iter = new_iter->next;
+    }
+  changed = (old_iter != NULL || new_iter != NULL);
+
+  /* Update appropriately */
+  meta_free_gslist_and_elements (old_struts);
+  window->struts = new_struts;
+  if (changed)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Invalidating work areas of window %s due to struts update\n",
+                  window->desc);
+      invalidate_work_areas (window);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Struts on %s were unchanged\n", window->desc);
+    }
+}
+
+void
+meta_window_recalc_window_type (MetaWindow *window)
+{
+  recalc_window_type (window);
+}
+
+static void
+recalc_window_type (MetaWindow *window)
+{
+  MetaWindowType old_type;
+
+  old_type = window->type;
+
+  if (window->type_atom != None)
+    {
+      if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP)
+        window->type = META_WINDOW_DESKTOP;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DOCK)
+        window->type = META_WINDOW_DOCK;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR)
+        window->type = META_WINDOW_TOOLBAR;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_MENU)
+        window->type = META_WINDOW_MENU;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG)
+        window->type = META_WINDOW_DIALOG;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL)
+        window->type = META_WINDOW_NORMAL;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY)
+        window->type = META_WINDOW_UTILITY;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
+        window->type = META_WINDOW_SPLASHSCREEN;
+      else
+        meta_bug ("Set a type atom for %s that wasn't handled in recalc_window_type\n",
+                  window->desc);
+    }
+  else if (window->xtransient_for != None)
+    {
+      window->type = META_WINDOW_DIALOG;
+    }
+  else
+    {
+      window->type = META_WINDOW_NORMAL;
+    }
+
+  if (window->type == META_WINDOW_DIALOG &&
+      window->wm_state_modal)
+    window->type = META_WINDOW_MODAL_DIALOG;
+
+  meta_verbose ("Calculated type %u for %s, old type %u\n",
+                window->type, window->desc, old_type);
+
+  if (old_type != window->type)
+    {
+      recalc_window_features (window);
+
+      set_net_wm_state (window);
+
+      /* Update frame */
+      if (window->decorated)
+        meta_window_ensure_frame (window);
+      else
+        meta_window_destroy_frame (window);
+
+      /* update stacking constraints */
+      meta_window_update_layer (window);
+
+      meta_window_grab_keys (window);
+    }
+}
+
+static void
+set_allowed_actions_hint (MetaWindow *window)
+{
+#define MAX_N_ACTIONS 12
+  unsigned long data[MAX_N_ACTIONS];
+  int i;
+
+  i = 0;
+  if (window->has_move_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_MOVE;
+      ++i;
+    }
+  if (window->has_resize_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_RESIZE;
+      ++i;
+    }
+  if (window->has_fullscreen_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_FULLSCREEN;
+      ++i;
+    }
+  if (window->has_minimize_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_MINIMIZE;
+      ++i;
+    }
+  if (window->has_shade_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_SHADE;
+      ++i;
+    }
+  /* sticky according to EWMH is different from marco's sticky;
+   * marco doesn't support EWMH sticky
+   */
+  if (window->has_maximize_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_MAXIMIZE_HORZ;
+      ++i;
+      data[i] = window->display->atom__NET_WM_ACTION_MAXIMIZE_VERT;
+      ++i;
+    }
+  /* We always allow this */
+  data[i] = window->display->atom__NET_WM_ACTION_CHANGE_DESKTOP;
+  ++i;
+  if (window->has_close_func)
+    {
+      data[i] = window->display->atom__NET_WM_ACTION_CLOSE;
+      ++i;
+    }
+
+  /* I guess we always allow above/below operations */
+  data[i] = window->display->atom__NET_WM_ACTION_ABOVE;
+  ++i;
+  data[i] = window->display->atom__NET_WM_ACTION_BELOW;
+  ++i;
+
+  g_assert (i <= MAX_N_ACTIONS);
+
+  meta_verbose ("Setting _NET_WM_ALLOWED_ACTIONS with %d atoms\n", i);
+
+  meta_error_trap_push (window->display);
+  XChangeProperty (window->display->xdisplay, window->xwindow,
+                   window->display->atom__NET_WM_ALLOWED_ACTIONS,
+                   XA_ATOM,
+                   32, PropModeReplace, (guchar*) data, i);
+  meta_error_trap_pop (window->display, FALSE);
+#undef MAX_N_ACTIONS
+}
+
+void
+meta_window_recalc_features (MetaWindow *window)
+{
+  recalc_window_features (window);
+}
+
+static void
+recalc_window_features (MetaWindow *window)
+{
+  gboolean old_has_close_func;
+  gboolean old_has_minimize_func;
+  gboolean old_has_move_func;
+  gboolean old_has_resize_func;
+  gboolean old_has_shade_func;
+  gboolean old_always_sticky;
+
+  old_has_close_func = window->has_close_func;
+  old_has_minimize_func = window->has_minimize_func;
+  old_has_move_func = window->has_move_func;
+  old_has_resize_func = window->has_resize_func;
+  old_has_shade_func = window->has_shade_func;
+  old_always_sticky = window->always_sticky;
+
+  /* Use MWM hints initially */
+  window->decorated = window->mwm_decorated;
+  window->border_only = window->mwm_border_only;
+  window->has_close_func = window->mwm_has_close_func;
+  window->has_minimize_func = window->mwm_has_minimize_func;
+  window->has_maximize_func = window->mwm_has_maximize_func;
+  window->has_move_func = window->mwm_has_move_func;
+
+  window->has_resize_func = TRUE;
+
+  /* If min_size == max_size, then don't allow resize */
+  if (window->size_hints.min_width == window->size_hints.max_width &&
+      window->size_hints.min_height == window->size_hints.max_height)
+    window->has_resize_func = FALSE;
+  else if (!window->mwm_has_resize_func)
+    {
+      /* We ignore mwm_has_resize_func because WM_NORMAL_HINTS is the
+       * authoritative source for that info. Some apps such as mplayer or
+       * xine disable resize via MWM but not WM_NORMAL_HINTS, but that
+       * leads to e.g. us not fullscreening their windows.  Apps that set
+       * MWM but not WM_NORMAL_HINTS are basically broken. We complain
+       * about these apps but make them work.
+       */
+
+      meta_warning (_("Window %s sets an MWM hint indicating it isn't resizable, but sets min size %d x %d and max size %d x %d; this doesn't make much sense.\n"),
+                    window->desc,
+                    window->size_hints.min_width,
+                    window->size_hints.min_height,
+                    window->size_hints.max_width,
+                    window->size_hints.max_height);
+    }
+
+  window->has_shade_func = TRUE;
+  window->has_fullscreen_func = TRUE;
+
+  window->always_sticky = FALSE;
+
+  /* Semantic category overrides the MWM hints */
+  if (window->type == META_WINDOW_TOOLBAR)
+    window->decorated = FALSE;
+
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK)
+    window->always_sticky = TRUE;
+
+  if (window->type == META_WINDOW_DESKTOP ||
+      window->type == META_WINDOW_DOCK ||
+      window->type == META_WINDOW_SPLASHSCREEN)
+    {
+      window->decorated = FALSE;
+      window->has_close_func = FALSE;
+      window->has_shade_func = FALSE;
+
+      /* FIXME this keeps panels and things from using
+       * NET_WM_MOVERESIZE; the problem is that some
+       * panels (edge panels) have fixed possible locations,
+       * and others ("floating panels") do not.
+       *
+       * Perhaps we should require edge panels to explicitly
+       * disable movement?
+       */
+      window->has_move_func = FALSE;
+      window->has_resize_func = FALSE;
+    }
+
+  if (window->type != META_WINDOW_NORMAL)
+    {
+      window->has_minimize_func = FALSE;
+      window->has_maximize_func = FALSE;
+      window->has_fullscreen_func = FALSE;
+    }
+
+  if (!window->has_resize_func)
+    {
+      window->has_maximize_func = FALSE;
+
+      /* don't allow fullscreen if we can't resize, unless the size
+       * is entire screen size (kind of broken, because we
+       * actually fullscreen to xinerama head size not screen size)
+       */
+      if (window->size_hints.min_width == window->screen->rect.width &&
+          window->size_hints.min_height == window->screen->rect.height)
+        ; /* leave fullscreen available */
+      else
+        window->has_fullscreen_func = FALSE;
+    }
+
+  /* We leave fullscreen windows decorated, just push the frame outside
+   * the screen. This avoids flickering to unparent them.
+   *
+   * Note that setting has_resize_func = FALSE here must come after the
+   * above code that may disable fullscreen, because if the window
+   * is not resizable purely due to fullscreen, we don't want to
+   * disable fullscreen mode.
+   */
+  if (window->fullscreen)
+    {
+      window->has_shade_func = FALSE;
+      window->has_move_func = FALSE;
+      window->has_resize_func = FALSE;
+      window->has_maximize_func = FALSE;
+    }
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Window %s fullscreen = %d not resizable, maximizable = %d fullscreenable = %d min size %dx%d max size %dx%d\n",
+              window->desc,
+              window->fullscreen,
+              window->has_maximize_func, window->has_fullscreen_func,
+              window->size_hints.min_width,
+              window->size_hints.min_height,
+              window->size_hints.max_width,
+              window->size_hints.max_height);
+
+  /* no shading if not decorated */
+  if (!window->decorated || window->border_only)
+    window->has_shade_func = FALSE;
+
+  window->skip_taskbar = FALSE;
+  window->skip_pager = FALSE;
+
+  if (window->wm_state_skip_taskbar)
+    window->skip_taskbar = TRUE;
+
+  if (window->wm_state_skip_pager)
+    window->skip_pager = TRUE;
+
+  switch (window->type)
+    {
+      /* Force skip taskbar/pager on these window types */
+    case META_WINDOW_DESKTOP:
+    case META_WINDOW_DOCK:
+    case META_WINDOW_TOOLBAR:
+    case META_WINDOW_MENU:
+    case META_WINDOW_UTILITY:
+    case META_WINDOW_SPLASHSCREEN:
+      window->skip_taskbar = TRUE;
+      window->skip_pager = TRUE;
+      break;
+
+    case META_WINDOW_DIALOG:
+    case META_WINDOW_MODAL_DIALOG:
+      /* only skip taskbar if we have a real transient parent */
+      if (window->xtransient_for != None &&
+          window->xtransient_for != window->screen->xroot)
+        window->skip_taskbar = TRUE;
+      break;
+
+    case META_WINDOW_NORMAL:
+      break;
+    }
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Window %s decorated = %d border_only = %d has_close = %d has_minimize = %d has_maximize = %d has_move = %d has_shade = %d skip_taskbar = %d skip_pager = %d\n",
+              window->desc,
+              window->decorated,
+              window->border_only,
+              window->has_close_func,
+              window->has_minimize_func,
+              window->has_maximize_func,
+              window->has_move_func,
+              window->has_shade_func,
+              window->skip_taskbar,
+              window->skip_pager);
+
+  /* FIXME:
+   * Lame workaround for recalc_window_features
+   * being used overzealously. The fix is to
+   * only recalc_window_features when something
+   * has actually changed.
+   */
+  if (window->constructing                               ||
+      old_has_close_func != window->has_close_func       ||
+      old_has_minimize_func != window->has_minimize_func ||
+      old_has_move_func != window->has_move_func         ||
+      old_has_resize_func != window->has_resize_func     ||
+      old_has_shade_func != window->has_shade_func       ||
+      old_always_sticky != window->always_sticky)
+    set_allowed_actions_hint (window);
+
+  /* FIXME perhaps should ensure if we don't have a shade func,
+   * we aren't shaded, etc.
+   */
+}
+
+static void
+menu_callback (MetaWindowMenu *menu,
+               Display        *xdisplay,
+               Window          client_xwindow,
+               guint32         timestamp,
+               MetaMenuOp      op,
+               int             workspace_index,
+               gpointer        data)
+{
+  MetaDisplay *display;
+  MetaWindow *window;
+  MetaWorkspace *workspace;
+
+  display = meta_display_for_x_display (xdisplay);
+  window = meta_display_lookup_x_window (display, client_xwindow);
+  workspace = NULL;
+
+  if (window != NULL) /* window can be NULL */
+    {
+      meta_verbose ("Menu op %u on %s\n", op, window->desc);
+
+      switch (op)
+        {
+        case META_MENU_OP_NONE:
+          /* nothing */
+          break;
+
+        case META_MENU_OP_DELETE:
+          meta_window_delete (window, timestamp);
+          break;
+
+        case META_MENU_OP_MINIMIZE:
+          meta_window_minimize (window);
+          break;
+
+        case META_MENU_OP_UNMAXIMIZE:
+          meta_window_unmaximize (window,
+                                  META_MAXIMIZE_HORIZONTAL |
+                                  META_MAXIMIZE_VERTICAL);
+          break;
+
+        case META_MENU_OP_MAXIMIZE:
+          meta_window_maximize (window,
+                                META_MAXIMIZE_HORIZONTAL |
+                                META_MAXIMIZE_VERTICAL);
+          break;
+
+        case META_MENU_OP_UNSHADE:
+          meta_window_unshade (window, timestamp);
+          break;
+
+        case META_MENU_OP_SHADE:
+          meta_window_shade (window, timestamp);
+          break;
+
+        case META_MENU_OP_MOVE_LEFT:
+          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+                                                   META_MOTION_LEFT);
+          break;
+
+        case META_MENU_OP_MOVE_RIGHT:
+          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+                                                   META_MOTION_RIGHT);
+          break;
+
+        case META_MENU_OP_MOVE_UP:
+          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+                                                   META_MOTION_UP);
+          break;
+
+        case META_MENU_OP_MOVE_DOWN:
+          workspace = meta_workspace_get_neighbor (window->screen->active_workspace,
+                                                   META_MOTION_DOWN);
+          break;
+
+        case META_MENU_OP_WORKSPACES:
+          workspace = meta_screen_get_workspace_by_index (window->screen,
+                                                          workspace_index);
+          break;
+
+        case META_MENU_OP_STICK:
+          meta_window_stick (window);
+          break;
+
+        case META_MENU_OP_UNSTICK:
+          meta_window_unstick (window);
+          break;
+
+        case META_MENU_OP_ABOVE:
+        case META_MENU_OP_UNABOVE:
+          if (window->wm_state_above == FALSE)
+            meta_window_make_above (window);
+          else
+            meta_window_unmake_above (window);
+          break;
+
+        case META_MENU_OP_MOVE:
+          meta_window_begin_grab_op (window,
+                                     META_GRAB_OP_KEYBOARD_MOVING,
+                                     TRUE,
+                                     timestamp);
+          break;
+
+        case META_MENU_OP_RESIZE:
+          meta_window_begin_grab_op (window,
+                                     META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
+                                     TRUE,
+                                     timestamp);
+          break;
+
+        case META_MENU_OP_RECOVER:
+          meta_window_shove_titlebar_onscreen (window);
+          break;
+
+        default:
+          meta_warning (G_STRLOC": Unknown window op\n");
+          break;
+        }
+
+      if (workspace)
+	{
+	  meta_window_change_workspace (window,
+					workspace);
+#if 0
+	  meta_workspace_activate (workspace);
+	  meta_window_raise (window);
+#endif
+	}
+    }
+  else
+    {
+      meta_verbose ("Menu callback on nonexistent window\n");
+    }
+
+  if (display->window_menu == menu)
+    {
+      display->window_menu = NULL;
+      display->window_with_menu = NULL;
+    }
+
+  meta_ui_window_menu_free (menu);
+}
+
+void
+meta_window_show_menu (MetaWindow *window,
+                       int         root_x,
+                       int         root_y,
+                       int         button,
+                       guint32     timestamp)
+{
+  MetaMenuOp ops;
+  MetaMenuOp insensitive;
+  MetaWindowMenu *menu;
+  MetaWorkspaceLayout layout;
+  int n_workspaces;
+  gboolean ltr;
+
+  if (window->display->window_menu)
+    {
+      meta_ui_window_menu_free (window->display->window_menu);
+      window->display->window_menu = NULL;
+      window->display->window_with_menu = NULL;
+    }
+
+  ops = META_MENU_OP_NONE;
+  insensitive = META_MENU_OP_NONE;
+
+  ops |= (META_MENU_OP_DELETE | META_MENU_OP_MINIMIZE | META_MENU_OP_MOVE | META_MENU_OP_RESIZE);
+
+  if (!meta_window_titlebar_is_onscreen (window) &&
+      window->type != META_WINDOW_DOCK &&
+      window->type != META_WINDOW_DESKTOP)
+    ops |= META_MENU_OP_RECOVER;
+
+  n_workspaces = meta_screen_get_n_workspaces (window->screen);
+
+  if (n_workspaces > 1)
+    ops |= META_MENU_OP_WORKSPACES;
+
+  meta_screen_calc_workspace_layout (window->screen,
+                                     n_workspaces,
+                                     meta_workspace_index ( window->screen->active_workspace),
+                                     &layout);
+
+  if (!window->on_all_workspaces)
+    {
+      ltr = meta_ui_get_direction() == META_UI_DIRECTION_LTR;
+
+      if (layout.current_col > 0)
+        ops |= ltr ? META_MENU_OP_MOVE_LEFT : META_MENU_OP_MOVE_RIGHT;
+      if ((layout.current_col < layout.cols - 1) &&
+          (layout.current_row * layout.cols + (layout.current_col + 1) < n_workspaces))
+        ops |= ltr ? META_MENU_OP_MOVE_RIGHT : META_MENU_OP_MOVE_LEFT;
+      if (layout.current_row > 0)
+        ops |= META_MENU_OP_MOVE_UP;
+      if ((layout.current_row < layout.rows - 1) &&
+          ((layout.current_row + 1) * layout.cols + layout.current_col < n_workspaces))
+        ops |= META_MENU_OP_MOVE_DOWN;
+    }
+
+  meta_screen_free_workspace_layout (&layout);
+
+  if (META_WINDOW_MAXIMIZED (window))
+    ops |= META_MENU_OP_UNMAXIMIZE;
+  else
+    ops |= META_MENU_OP_MAXIMIZE;
+
+#if 0
+  if (window->shaded)
+    ops |= META_MENU_OP_UNSHADE;
+  else
+    ops |= META_MENU_OP_SHADE;
+#endif
+
+  ops |= META_MENU_OP_UNSTICK;
+  ops |= META_MENU_OP_STICK;
+
+  if (window->wm_state_above)
+    ops |= META_MENU_OP_UNABOVE;
+  else
+    ops |= META_MENU_OP_ABOVE;
+
+  if (!window->has_maximize_func)
+    insensitive |= META_MENU_OP_UNMAXIMIZE | META_MENU_OP_MAXIMIZE;
+
+  /*if (!window->has_minimize_func)
+    insensitive |= META_MENU_OP_MINIMIZE;*/
+
+  /*if (!window->has_close_func)
+    insensitive |= META_MENU_OP_DELETE;*/
+
+  if (!window->has_shade_func)
+    insensitive |= META_MENU_OP_SHADE | META_MENU_OP_UNSHADE;
+
+  if (!META_WINDOW_ALLOWS_MOVE (window))
+    insensitive |= META_MENU_OP_MOVE;
+
+  if (!META_WINDOW_ALLOWS_RESIZE (window))
+    insensitive |= META_MENU_OP_RESIZE;
+
+   if (window->always_sticky)
+     insensitive |= META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES;
+
+  if ((window->type == META_WINDOW_DESKTOP) ||
+      (window->type == META_WINDOW_DOCK) ||
+      (window->type == META_WINDOW_SPLASHSCREEN))
+    insensitive |= META_MENU_OP_ABOVE | META_MENU_OP_UNABOVE;
+
+  /* If all operations are disabled, just quit without showing the menu.
+   * This is the case, for example, with META_WINDOW_DESKTOP windows.
+   */
+  if ((ops & ~insensitive) == 0)
+    return;
+
+  menu =
+    meta_ui_window_menu_new (window->screen->ui,
+                             window->xwindow,
+                             ops,
+                             insensitive,
+                             meta_window_get_net_wm_desktop (window),
+                             meta_screen_get_n_workspaces (window->screen),
+                             menu_callback,
+                             NULL);
+
+  window->display->window_menu = menu;
+  window->display->window_with_menu = window;
+
+  meta_verbose ("Popping up window menu for %s\n", window->desc);
+
+  meta_ui_window_menu_popup (menu, root_x, root_y, button, timestamp);
+}
+
+void
+meta_window_shove_titlebar_onscreen (MetaWindow *window)
+{
+  MetaRectangle  outer_rect;
+  GList         *onscreen_region;
+  int            horiz_amount, vert_amount;
+  int            newx, newy;
+
+  /* If there's no titlebar, don't bother */
+  if (!window->frame)
+    return;
+
+  /* Get the basic info we need */
+  meta_window_get_outer_rect (window, &outer_rect);
+  onscreen_region = window->screen->active_workspace->screen_region;
+
+  /* Extend the region (just in case the window is too big to fit on the
+   * screen), then shove the window on screen, then return the region to
+   * normal.
+   */
+  horiz_amount = outer_rect.width;
+  vert_amount  = outer_rect.height;
+  meta_rectangle_expand_region (onscreen_region,
+                                horiz_amount,
+                                horiz_amount,
+                                0,
+                                vert_amount);
+  meta_rectangle_shove_into_region(onscreen_region,
+                                   FIXED_DIRECTION_X,
+                                   &outer_rect);
+  meta_rectangle_expand_region (onscreen_region,
+                                -horiz_amount,
+                                -horiz_amount,
+                                0,
+                                -vert_amount);
+
+  newx = outer_rect.x + window->frame->child_x;
+  newy = outer_rect.y + window->frame->child_y;
+  meta_window_move_resize (window,
+                           FALSE,
+                           newx,
+                           newy,
+                           window->rect.width,
+                           window->rect.height);
+}
+
+gboolean
+meta_window_titlebar_is_onscreen (MetaWindow *window)
+{
+  MetaRectangle  titlebar_rect;
+  GList         *onscreen_region;
+  int            titlebar_size;
+  gboolean       is_onscreen;
+
+  const int min_height_needed  = 8;
+  const int min_width_percent  = 0.5;
+  const int min_width_absolute = 50;
+
+  /* Titlebar can't be offscreen if there is no titlebar... */
+  if (!window->frame)
+    return FALSE;
+
+  /* Get the rectangle corresponding to the titlebar */
+  meta_window_get_outer_rect (window, &titlebar_rect);
+  titlebar_rect.height = window->frame->child_y;
+  titlebar_size = meta_rectangle_area (&titlebar_rect);
+
+  /* Run through the spanning rectangles for the screen and see if one of
+   * them overlaps with the titlebar sufficiently to consider it onscreen.
+   */
+  is_onscreen = FALSE;
+  onscreen_region = window->screen->active_workspace->screen_region;
+  while (onscreen_region)
+    {
+      MetaRectangle *spanning_rect = onscreen_region->data;
+      MetaRectangle overlap;
+
+      meta_rectangle_intersect (&titlebar_rect, spanning_rect, &overlap);
+      if (overlap.height > MIN (titlebar_rect.height, min_height_needed) &&
+          overlap.width  > MIN (titlebar_rect.width * min_width_percent,
+                                min_width_absolute))
+        {
+          is_onscreen = TRUE;
+          break;
+        }
+
+      onscreen_region = onscreen_region->next;
+    }
+
+  return is_onscreen;
+}
+
+static double
+timeval_to_ms (const GTimeVal *timeval)
+{
+  return (timeval->tv_sec * G_USEC_PER_SEC + timeval->tv_usec) / 1000.0;
+}
+
+static double
+time_diff (const GTimeVal *first,
+	   const GTimeVal *second)
+{
+  double first_ms = timeval_to_ms (first);
+  double second_ms = timeval_to_ms (second);
+
+  return first_ms - second_ms;
+}
+
+static gboolean
+check_moveresize_frequency (MetaWindow *window,
+			    gdouble    *remaining)
+{
+  GTimeVal current_time;
+
+  g_get_current_time (&current_time);
+
+#ifdef HAVE_XSYNC
+  if (!window->disable_sync &&
+      window->display->grab_sync_request_alarm != None)
+    {
+      if (window->sync_request_time.tv_sec != 0 ||
+	  window->sync_request_time.tv_usec != 0)
+	{
+	  double elapsed =
+	    time_diff (&current_time, &window->sync_request_time);
+
+	  if (elapsed < 1000.0)
+	    {
+	      /* We want to be sure that the timeout happens at
+	       * a time where elapsed will definitely be
+	       * greater than 1000, so we can disable sync
+	       */
+	      if (remaining)
+		*remaining = 1000.0 - elapsed + 100;
+
+	      return FALSE;
+	    }
+	  else
+	    {
+	      /* We have now waited for more than a second for the
+	       * application to respond to the sync request
+	       */
+	      window->disable_sync = TRUE;
+	      return TRUE;
+	    }
+	}
+      else
+	{
+	  /* No outstanding sync requests. Go ahead and resize
+	   */
+	  return TRUE;
+	}
+    }
+  else
+#endif /* HAVE_XSYNC */
+    {
+      const double max_resizes_per_second = 25.0;
+      const double ms_between_resizes = 1000.0 / max_resizes_per_second;
+      double elapsed;
+
+      elapsed = time_diff (&current_time, &window->display->grab_last_moveresize_time);
+
+      if (elapsed >= 0.0 && elapsed < ms_between_resizes)
+	{
+	  meta_topic (META_DEBUG_RESIZING,
+		      "Delaying move/resize as only %g of %g ms elapsed\n",
+		      elapsed, ms_between_resizes);
+
+	  if (remaining)
+	    *remaining = (ms_between_resizes - elapsed);
+
+	  return FALSE;
+	}
+
+      meta_topic (META_DEBUG_RESIZING,
+		  " Checked moveresize freq, allowing move/resize now (%g of %g seconds elapsed)\n",
+		  elapsed / 1000.0, 1.0 / max_resizes_per_second);
+
+      return TRUE;
+    }
+}
+
+static gboolean
+update_move_timeout (gpointer data)
+{
+  MetaWindow *window = data;
+
+  update_move (window,
+               window->display->grab_last_user_action_was_snap,
+               window->display->grab_latest_motion_x,
+               window->display->grab_latest_motion_y);
+
+  return FALSE;
+}
+
+static void
+update_move (MetaWindow  *window,
+             gboolean     snap,
+             int          x,
+             int          y)
+{
+  int dx, dy;
+  int new_x, new_y;
+  MetaRectangle old;
+  int shake_threshold;
+  MetaDisplay *display = window->display;
+
+  display->grab_latest_motion_x = x;
+  display->grab_latest_motion_y = y;
+
+  dx = x - display->grab_anchor_root_x;
+  dy = y - display->grab_anchor_root_y;
+
+  new_x = display->grab_anchor_window_pos.x + dx;
+  new_y = display->grab_anchor_window_pos.y + dy;
+
+  meta_verbose ("x,y = %d,%d anchor ptr %d,%d anchor pos %d,%d dx,dy %d,%d\n",
+                x, y,
+                display->grab_anchor_root_x,
+                display->grab_anchor_root_y,
+                display->grab_anchor_window_pos.x,
+                display->grab_anchor_window_pos.y,
+                dx, dy);
+
+  /* Don't bother doing anything if no move has been specified.  (This
+   * happens often, even in keyboard moving, due to the warping of the
+   * pointer.
+   */
+  if (dx == 0 && dy == 0)
+    return;
+
+  /* shake loose (unmaximize) maximized window if dragged beyond the threshold
+   * in the Y direction. You can't pull a window loose via X motion.
+   */
+
+#define DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR 6
+  shake_threshold = meta_ui_get_drag_threshold (window->screen->ui) *
+    DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR;
+
+  if (META_WINDOW_MAXIMIZED (window) && ABS (dy) >= shake_threshold)
+    {
+      double prop;
+
+      /* Shake loose */
+      window->shaken_loose = TRUE;
+
+      /* move the unmaximized window to the cursor */
+      prop =
+        ((double)(x - display->grab_initial_window_pos.x)) /
+        ((double)display->grab_initial_window_pos.width);
+
+      display->grab_initial_window_pos.x =
+        x - window->saved_rect.width * prop;
+      display->grab_initial_window_pos.y = y;
+
+      if (window->frame)
+        {
+          display->grab_initial_window_pos.y += window->frame->child_y / 2;
+        }
+
+      window->saved_rect.x = display->grab_initial_window_pos.x;
+      window->saved_rect.y = display->grab_initial_window_pos.y;
+      display->grab_anchor_root_x = x;
+      display->grab_anchor_root_y = y;
+
+      meta_window_unmaximize (window,
+                              META_MAXIMIZE_HORIZONTAL |
+                              META_MAXIMIZE_VERTICAL);
+
+      return;
+    }
+  /* remaximize window on an other xinerama monitor if window has
+   * been shaken loose or it is still maximized (then move straight)
+   */
+  else if (window->shaken_loose || META_WINDOW_MAXIMIZED (window))
+    {
+      const MetaXineramaScreenInfo *wxinerama;
+      MetaRectangle work_area;
+      int monitor;
+
+      wxinerama = meta_screen_get_xinerama_for_window (window->screen, window);
+
+      for (monitor = 0; monitor < window->screen->n_xinerama_infos; monitor++)
+        {
+          meta_window_get_work_area_for_xinerama (window, monitor, &work_area);
+
+          /* check if cursor is near the top of a xinerama work area */
+          if (x >= work_area.x &&
+              x < (work_area.x + work_area.width) &&
+              y >= work_area.y &&
+              y < (work_area.y + shake_threshold))
+            {
+              /* move the saved rect if window will become maximized on an
+               * other monitor so user isn't surprised on a later unmaximize
+               */
+              if (wxinerama->number != monitor)
+                {
+                  window->saved_rect.x = work_area.x;
+                  window->saved_rect.y = work_area.y;
+
+                  if (window->frame)
+                    {
+                      window->saved_rect.x += window->frame->child_x;
+                      window->saved_rect.y += window->frame->child_y;
+                    }
+
+                  window->user_rect.x = window->saved_rect.x;
+                  window->user_rect.y = window->saved_rect.y;
+
+                  meta_window_unmaximize (window,
+                                          META_MAXIMIZE_HORIZONTAL |
+                                          META_MAXIMIZE_VERTICAL);
+                }
+
+              display->grab_initial_window_pos = work_area;
+              display->grab_anchor_root_x = x;
+              display->grab_anchor_root_y = y;
+              window->shaken_loose = FALSE;
+
+              meta_window_maximize (window,
+                                    META_MAXIMIZE_HORIZONTAL |
+                                    META_MAXIMIZE_VERTICAL);
+
+              return;
+            }
+        }
+    }
+
+  if (display->grab_wireframe_active)
+    old = display->grab_wireframe_rect;
+  else
+    meta_window_get_client_root_coords (window, &old);
+
+  /* Don't allow movement in the maximized directions */
+  if (window->maximized_horizontally)
+    new_x = old.x;
+  if (window->maximized_vertically)
+    new_y = old.y;
+
+  /* Do any edge resistance/snapping */
+  meta_window_edge_resistance_for_move (window,
+                                        old.x,
+                                        old.y,
+                                        &new_x,
+                                        &new_y,
+                                        update_move_timeout,
+                                        snap,
+                                        FALSE);
+
+  if (display->compositor)
+    {
+      int root_x = new_x - display->grab_anchor_window_pos.x + display->grab_anchor_root_x;
+      int root_y = new_y - display->grab_anchor_window_pos.y + display->grab_anchor_root_y;
+
+      meta_compositor_update_move (display->compositor,
+				   window, root_x, root_y);
+    }
+
+  if (display->grab_wireframe_active)
+    meta_window_update_wireframe (window, new_x, new_y,
+                                  display->grab_wireframe_rect.width,
+                                  display->grab_wireframe_rect.height);
+  else
+    meta_window_move (window, TRUE, new_x, new_y);
+}
+
+static gboolean
+update_resize_timeout (gpointer data)
+{
+  MetaWindow *window = data;
+
+  update_resize (window,
+                 window->display->grab_last_user_action_was_snap,
+                 window->display->grab_latest_motion_x,
+                 window->display->grab_latest_motion_y,
+                 TRUE);
+  return FALSE;
+}
+
+static void
+update_resize (MetaWindow *window,
+               gboolean    snap,
+               int x, int y,
+               gboolean force)
+{
+  int dx, dy;
+  int new_w, new_h;
+  int gravity;
+  MetaRectangle old;
+  int new_x, new_y;
+  double remaining;
+
+  window->display->grab_latest_motion_x = x;
+  window->display->grab_latest_motion_y = y;
+
+  dx = x - window->display->grab_anchor_root_x;
+  dy = y - window->display->grab_anchor_root_y;
+
+  new_w = window->display->grab_anchor_window_pos.width;
+  new_h = window->display->grab_anchor_window_pos.height;
+
+  /* Don't bother doing anything if no move has been specified.  (This
+   * happens often, even in keyboard resizing, due to the warping of the
+   * pointer.
+   */
+  if (dx == 0 && dy == 0)
+    return;
+
+  /* FIXME this is only used in wireframe mode */
+  new_x = window->display->grab_anchor_window_pos.x;
+  new_y = window->display->grab_anchor_window_pos.y;
+
+  if (window->display->grab_op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN)
+    {
+      if ((dx > 0) && (dy > 0))
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_SE;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if ((dx < 0) && (dy > 0))
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_SW;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if ((dx > 0) && (dy < 0))
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NE;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if ((dx < 0) && (dy < 0))
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NW;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if (dx < 0)
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if (dx > 0)
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if (dy > 0)
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+      else if (dy < 0)
+        {
+          window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N;
+          meta_window_update_keyboard_resize (window, TRUE);
+        }
+    }
+
+  /* FIXME: This stupidity only needed because of wireframe mode and
+   * the fact that wireframe isn't making use of
+   * meta_rectangle_resize_with_gravity().  If we were to use that, we
+   * could just increment new_w and new_h by dx and dy in all cases.
+   */
+  switch (window->display->grab_op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+      new_w += dx;
+      break;
+
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_SW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+      new_w -= dx;
+      new_x += dx;
+      break;
+
+    default:
+      break;
+    }
+
+  switch (window->display->grab_op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:
+    case META_GRAB_OP_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+      new_h += dy;
+      break;
+
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      new_h -= dy;
+      new_y += dy;
+      break;
+    default:
+      break;
+    }
+
+  if (!check_moveresize_frequency (window, &remaining) && !force)
+    {
+      /* we are ignoring an event here, so we schedule a
+       * compensation event when we would otherwise not ignore
+       * an event. Otherwise we can become stuck if the user never
+       * generates another event.
+       */
+      if (!window->display->grab_resize_timeout_id)
+	{
+	  window->display->grab_resize_timeout_id =
+	    g_timeout_add ((int)remaining, update_resize_timeout, window);
+	}
+
+      return;
+    }
+
+  /* If we get here, it means the client should have redrawn itself */
+  if (window->display->compositor)
+    meta_compositor_set_updates (window->display->compositor, window, TRUE);
+
+  /* Remove any scheduled compensation events */
+  if (window->display->grab_resize_timeout_id)
+    {
+      g_source_remove (window->display->grab_resize_timeout_id);
+      window->display->grab_resize_timeout_id = 0;
+    }
+
+  if (window->display->grab_wireframe_active)
+    old = window->display->grab_wireframe_rect;
+  else
+    old = window->rect;  /* Don't actually care about x,y */
+
+  /* One sided resizing ought to actually be one-sided, despite the fact that
+   * aspect ratio windows don't interact nicely with the above stuff.  So,
+   * to avoid some nasty flicker, we enforce that.
+   */
+  switch (window->display->grab_op)
+    {
+    case META_GRAB_OP_RESIZING_S:
+    case META_GRAB_OP_RESIZING_N:
+      new_w = old.width;
+      break;
+
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_RESIZING_W:
+      new_h = old.height;
+      break;
+
+    default:
+      break;
+    }
+
+  /* compute gravity of client during operation */
+  gravity = meta_resize_gravity_from_grab_op (window->display->grab_op);
+  g_assert (gravity >= 0);
+
+  /* Do any edge resistance/snapping */
+  meta_window_edge_resistance_for_resize (window,
+                                          old.width,
+                                          old.height,
+                                          &new_w,
+                                          &new_h,
+                                          gravity,
+                                          update_resize_timeout,
+                                          snap,
+                                          FALSE);
+
+  if (window->display->grab_wireframe_active)
+    {
+      if ((new_x + new_w <= new_x) || (new_y + new_h <= new_y))
+        return;
+
+      /* FIXME This is crap. For example, the wireframe isn't
+       * constrained in the way that a real resize would be. An
+       * obvious elegant solution is to unmap the window during
+       * wireframe, but still resize it; however, that probably
+       * confuses broken clients that have problems with opaque
+       * resize, they probably don't track their visibility.
+       */
+      meta_window_update_wireframe (window, new_x, new_y, new_w, new_h);
+    }
+  else
+    {
+      /* We don't need to update unless the specified width and height
+       * are actually different from what we had before.
+       */
+      if (old.width != new_w || old.height != new_h)
+        meta_window_resize_with_gravity (window, TRUE, new_w, new_h, gravity);
+    }
+
+  /* Store the latest resize time, if we actually resized. */
+  if (window->rect.width != old.width || window->rect.height != old.height)
+    g_get_current_time (&window->display->grab_last_moveresize_time);
+}
+
+typedef struct
+{
+  const XEvent *current_event;
+  int           count;
+  guint32       last_time;
+} EventScannerData;
+
+static Bool
+find_last_time_predicate (Display  *display,
+                          XEvent   *xevent,
+                          XPointer  arg)
+{
+  EventScannerData *esd = (void*) arg;
+
+  if (esd->current_event->type == xevent->type &&
+      esd->current_event->xany.window == xevent->xany.window)
+    {
+      esd->count += 1;
+      esd->last_time = xevent->xmotion.time;
+    }
+
+  return False;
+}
+
+static gboolean
+check_use_this_motion_notify (MetaWindow *window,
+                              XEvent     *event)
+{
+  EventScannerData esd;
+  XEvent useless;
+
+  /* This code is copied from Owen's GDK code. */
+
+  if (window->display->grab_motion_notify_time != 0)
+    {
+      /* == is really the right test, but I'm all for paranoia */
+      if (window->display->grab_motion_notify_time <=
+          event->xmotion.time)
+        {
+          meta_topic (META_DEBUG_RESIZING,
+                      "Arrived at event with time %u (waiting for %u), using it\n",
+                      (unsigned int)event->xmotion.time,
+                      window->display->grab_motion_notify_time);
+          window->display->grab_motion_notify_time = 0;
+          return TRUE;
+        }
+      else
+        return FALSE; /* haven't reached the saved timestamp yet */
+    }
+
+  esd.current_event = event;
+  esd.count = 0;
+  esd.last_time = 0;
+
+  /* "useless" isn't filled in because the predicate never returns True */
+  XCheckIfEvent (window->display->xdisplay,
+                 &useless,
+                 find_last_time_predicate,
+                 (XPointer) &esd);
+
+  if (esd.count > 0)
+    meta_topic (META_DEBUG_RESIZING,
+                "Will skip %d motion events and use the event with time %u\n",
+                esd.count, (unsigned int) esd.last_time);
+
+  if (esd.last_time == 0)
+    return TRUE;
+  else
+    {
+      /* Save this timestamp, and ignore all motion notify
+       * until we get to the one with this stamp.
+       */
+      window->display->grab_motion_notify_time = esd.last_time;
+      return FALSE;
+    }
+}
+
+void
+meta_window_handle_mouse_grab_op_event (MetaWindow *window,
+                                        XEvent     *event)
+{
+#ifdef HAVE_XSYNC
+  if (event->type == (window->display->xsync_event_base + XSyncAlarmNotify))
+    {
+      meta_topic (META_DEBUG_RESIZING,
+                  "Alarm event received last motion x = %d y = %d\n",
+                  window->display->grab_latest_motion_x,
+                  window->display->grab_latest_motion_y);
+
+      /* If sync was previously disabled, turn it back on and hope
+       * the application has come to its senses (maybe it was just
+       * busy with a pagefault or a long computation).
+       */
+      window->disable_sync = FALSE;
+      window->sync_request_time.tv_sec = 0;
+      window->sync_request_time.tv_usec = 0;
+
+      /* This means we are ready for another configure. */
+      switch (window->display->grab_op)
+        {
+        case META_GRAB_OP_RESIZING_E:
+        case META_GRAB_OP_RESIZING_W:
+        case META_GRAB_OP_RESIZING_S:
+        case META_GRAB_OP_RESIZING_N:
+        case META_GRAB_OP_RESIZING_SE:
+        case META_GRAB_OP_RESIZING_SW:
+        case META_GRAB_OP_RESIZING_NE:
+        case META_GRAB_OP_RESIZING_NW:
+        case META_GRAB_OP_KEYBOARD_RESIZING_S:
+        case META_GRAB_OP_KEYBOARD_RESIZING_N:
+        case META_GRAB_OP_KEYBOARD_RESIZING_W:
+        case META_GRAB_OP_KEYBOARD_RESIZING_E:
+        case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+        case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+        case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+        case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+          /* no pointer round trip here, to keep in sync */
+          update_resize (window,
+                         window->display->grab_last_user_action_was_snap,
+                         window->display->grab_latest_motion_x,
+                         window->display->grab_latest_motion_y,
+                         TRUE);
+          break;
+
+        default:
+          break;
+        }
+    }
+#endif /* HAVE_XSYNC */
+
+  switch (event->type)
+    {
+    case ButtonRelease:
+      meta_display_check_threshold_reached (window->display,
+                                            event->xbutton.x_root,
+                                            event->xbutton.y_root);
+      /* If the user was snap moving then ignore the button release
+       * because they may have let go of shift before releasing the
+       * mouse button and they almost certainly do not want a
+       * non-snapped movement to occur from the button release.
+       */
+      if (!window->display->grab_last_user_action_was_snap)
+        {
+          if (meta_grab_op_is_moving (window->display->grab_op))
+            {
+              if (event->xbutton.root == window->screen->xroot)
+                update_move (window, event->xbutton.state & ShiftMask,
+                             event->xbutton.x_root, event->xbutton.y_root);
+            }
+          else if (meta_grab_op_is_resizing (window->display->grab_op))
+            {
+              if (event->xbutton.root == window->screen->xroot)
+                update_resize (window,
+                               event->xbutton.state & ShiftMask,
+                               event->xbutton.x_root,
+                               event->xbutton.y_root,
+                               TRUE);
+	      if (window->display->compositor)
+		meta_compositor_set_updates (window->display->compositor, window, TRUE);
+            }
+        }
+
+      meta_display_end_grab_op (window->display, event->xbutton.time);
+      break;
+
+    case MotionNotify:
+      meta_display_check_threshold_reached (window->display,
+                                            event->xmotion.x_root,
+                                            event->xmotion.y_root);
+      if (meta_grab_op_is_moving (window->display->grab_op))
+        {
+          if (event->xmotion.root == window->screen->xroot)
+            {
+              if (check_use_this_motion_notify (window,
+                                                event))
+                update_move (window,
+                             event->xmotion.state & ShiftMask,
+                             event->xmotion.x_root,
+                             event->xmotion.y_root);
+            }
+        }
+      else if (meta_grab_op_is_resizing (window->display->grab_op))
+        {
+          if (event->xmotion.root == window->screen->xroot)
+            {
+              if (check_use_this_motion_notify (window,
+                                                event))
+                update_resize (window,
+                               event->xmotion.state & ShiftMask,
+                               event->xmotion.x_root,
+                               event->xmotion.y_root,
+                               FALSE);
+            }
+        }
+      break;
+
+    default:
+      break;
+    }
+}
+
+void
+meta_window_set_gravity (MetaWindow *window,
+                         int         gravity)
+{
+  XSetWindowAttributes attrs;
+
+  meta_verbose ("Setting gravity of %s to %d\n", window->desc, gravity);
+
+  attrs.win_gravity = gravity;
+
+  meta_error_trap_push (window->display);
+
+  XChangeWindowAttributes (window->display->xdisplay,
+                           window->xwindow,
+                           CWWinGravity,
+                           &attrs);
+
+  meta_error_trap_pop (window->display, FALSE);
+}
+
+static void
+get_work_area_xinerama (MetaWindow    *window,
+                        MetaRectangle *area,
+                        int            which_xinerama)
+{
+  GList *tmp;
+
+  g_assert (which_xinerama >= 0);
+
+  /* Initialize to the whole xinerama */
+  *area = window->screen->xinerama_infos[which_xinerama].rect;
+
+  tmp = meta_window_get_workspaces (window);
+  while (tmp != NULL)
+    {
+      MetaRectangle workspace_work_area;
+      meta_workspace_get_work_area_for_xinerama (tmp->data,
+                                                 which_xinerama,
+                                                 &workspace_work_area);
+      meta_rectangle_intersect (area,
+                                &workspace_work_area,
+                                area);
+      tmp = tmp->next;
+    }
+
+  meta_topic (META_DEBUG_WORKAREA,
+              "Window %s xinerama %d has work area %d,%d %d x %d\n",
+              window->desc, which_xinerama,
+              area->x, area->y, area->width, area->height);
+}
+
+void
+meta_window_get_work_area_current_xinerama (MetaWindow    *window,
+					    MetaRectangle *area)
+{
+  const MetaXineramaScreenInfo *xinerama = NULL;
+  xinerama = meta_screen_get_xinerama_for_window (window->screen,
+						  window);
+
+  meta_window_get_work_area_for_xinerama (window,
+                                          xinerama->number,
+                                          area);
+}
+
+void
+meta_window_get_work_area_for_xinerama (MetaWindow    *window,
+					int            which_xinerama,
+					MetaRectangle *area)
+{
+  g_return_if_fail (which_xinerama >= 0);
+
+  get_work_area_xinerama (window,
+                          area,
+                          which_xinerama);
+}
+
+void
+meta_window_get_work_area_all_xineramas (MetaWindow    *window,
+                                         MetaRectangle *area)
+{
+  GList *tmp;
+
+  /* Initialize to the whole screen */
+  *area = window->screen->rect;
+
+  tmp = meta_window_get_workspaces (window);
+  while (tmp != NULL)
+    {
+      MetaRectangle workspace_work_area;
+      meta_workspace_get_work_area_all_xineramas (tmp->data,
+                                                  &workspace_work_area);
+      meta_rectangle_intersect (area,
+                                &workspace_work_area,
+                                area);
+      tmp = tmp->next;
+    }
+
+  meta_topic (META_DEBUG_WORKAREA,
+              "Window %s has whole-screen work area %d,%d %d x %d\n",
+              window->desc, area->x, area->y, area->width, area->height);
+}
+
+
+gboolean
+meta_window_same_application (MetaWindow *window,
+                              MetaWindow *other_window)
+{
+  MetaGroup *group       = meta_window_get_group (window);
+  MetaGroup *other_group = meta_window_get_group (other_window);
+
+  return
+    group!=NULL &&
+    other_group!=NULL &&
+    group==other_group;
+}
+
+void
+meta_window_refresh_resize_popup (MetaWindow *window)
+{
+  if (window->display->grab_op == META_GRAB_OP_NONE)
+    return;
+
+  if (window->display->grab_window != window)
+    return;
+
+  /* We shouldn't ever get called when the wireframe is active
+   * because that's handled by a different code path in effects.c
+   */
+  if (window->display->grab_wireframe_active)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "refresh_resize_popup called when wireframe active\n");
+      return;
+    }
+
+  switch (window->display->grab_op)
+    {
+    case META_GRAB_OP_RESIZING_SE:
+    case META_GRAB_OP_RESIZING_S:
+    case META_GRAB_OP_RESIZING_SW:
+    case META_GRAB_OP_RESIZING_N:
+    case META_GRAB_OP_RESIZING_NE:
+    case META_GRAB_OP_RESIZING_NW:
+    case META_GRAB_OP_RESIZING_W:
+    case META_GRAB_OP_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+    case META_GRAB_OP_KEYBOARD_RESIZING_S:
+    case META_GRAB_OP_KEYBOARD_RESIZING_N:
+    case META_GRAB_OP_KEYBOARD_RESIZING_W:
+    case META_GRAB_OP_KEYBOARD_RESIZING_E:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+    case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+    case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+      break;
+
+    default:
+      /* Not resizing */
+      return;
+    }
+
+  if (window->display->grab_resize_popup == NULL)
+    {
+      if (window->size_hints.width_inc > 1 ||
+          window->size_hints.height_inc > 1)
+        window->display->grab_resize_popup =
+          meta_ui_resize_popup_new (window->display->xdisplay,
+                                    window->screen->number);
+    }
+
+  if (window->display->grab_resize_popup != NULL)
+    {
+      MetaRectangle rect;
+
+      if (window->display->grab_wireframe_active)
+        rect = window->display->grab_wireframe_rect;
+      else
+        meta_window_get_client_root_coords (window, &rect);
+
+      meta_ui_resize_popup_set (window->display->grab_resize_popup,
+                                rect,
+                                window->size_hints.base_width,
+                                window->size_hints.base_height,
+                                window->size_hints.width_inc,
+                                window->size_hints.height_inc);
+
+      meta_ui_resize_popup_set_showing (window->display->grab_resize_popup,
+                                        TRUE);
+    }
+}
+
+void
+meta_window_foreach_transient (MetaWindow            *window,
+                               MetaWindowForeachFunc  func,
+                               void                  *data)
+{
+  GSList *windows;
+  GSList *tmp;
+
+  windows = meta_display_list_windows (window->display);
+
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *transient = tmp->data;
+
+      if (meta_window_is_ancestor_of_transient (window, transient))
+        {
+          if (!(* func) (transient, data))
+            break;
+        }
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (windows);
+}
+
+void
+meta_window_foreach_ancestor (MetaWindow            *window,
+                              MetaWindowForeachFunc  func,
+                              void                  *data)
+{
+  MetaWindow *w;
+  MetaWindow *tortoise;
+
+  w = window;
+  tortoise = window;
+  while (TRUE)
+    {
+      if (w->xtransient_for == None ||
+          w->transient_parent_is_root_window)
+        break;
+
+      w = meta_display_lookup_x_window (w->display, w->xtransient_for);
+
+      if (w == NULL || w == tortoise)
+        break;
+
+      if (!(* func) (w, data))
+        break;
+
+      if (w->xtransient_for == None ||
+          w->transient_parent_is_root_window)
+        break;
+
+      w = meta_display_lookup_x_window (w->display, w->xtransient_for);
+
+      if (w == NULL || w == tortoise)
+        break;
+
+      if (!(* func) (w, data))
+        break;
+
+      tortoise = meta_display_lookup_x_window (tortoise->display,
+                                               tortoise->xtransient_for);
+
+      /* "w" should have already covered all ground covered by the
+       * tortoise, so the following must hold.
+       */
+      g_assert (tortoise != NULL);
+      g_assert (tortoise->xtransient_for != None);
+      g_assert (!tortoise->transient_parent_is_root_window);
+    }
+}
+
+typedef struct
+{
+  MetaWindow *ancestor;
+  gboolean found;
+} FindAncestorData;
+
+static gboolean
+find_ancestor_func (MetaWindow *window,
+                    void       *data)
+{
+  FindAncestorData *d = data;
+
+  if (window == d->ancestor)
+    {
+      d->found = TRUE;
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+meta_window_is_ancestor_of_transient (MetaWindow *window,
+                                      MetaWindow *transient)
+{
+  FindAncestorData d;
+
+  d.ancestor = window;
+  d.found = FALSE;
+
+  meta_window_foreach_ancestor (transient, find_ancestor_func, &d);
+
+  return d.found;
+}
+
+/* Warp pointer to location appropriate for grab,
+ * return root coordinates where pointer ended up.
+ */
+static gboolean
+warp_grab_pointer (MetaWindow          *window,
+                   MetaGrabOp           grab_op,
+                   int                 *x,
+                   int                 *y)
+{
+  MetaRectangle  rect;
+  MetaDisplay   *display;
+
+  display = window->display;
+
+  /* We may not have done begin_grab_op yet, i.e. may not be in a grab
+   */
+
+  if (window == display->grab_window && display->grab_wireframe_active)
+    {
+      meta_window_get_xor_rect (window, &display->grab_wireframe_rect, &rect);
+    }
+  else
+    {
+      meta_window_get_outer_rect (window, &rect);
+    }
+
+  switch (grab_op)
+    {
+      case META_GRAB_OP_KEYBOARD_MOVING:
+      case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN:
+        *x = rect.width / 2;
+        *y = rect.height / 2;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_S:
+        *x = rect.width / 2;
+        *y = rect.height - 1;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_N:
+        *x = rect.width / 2;
+        *y = 0;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_W:
+        *x = 0;
+        *y = rect.height / 2;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_E:
+        *x = rect.width - 1;
+        *y = rect.height / 2;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_SE:
+        *x = rect.width - 1;
+        *y = rect.height - 1;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_NE:
+        *x = rect.width - 1;
+        *y = 0;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_SW:
+        *x = 0;
+        *y = rect.height - 1;
+        break;
+
+      case META_GRAB_OP_KEYBOARD_RESIZING_NW:
+        *x = 0;
+        *y = 0;
+        break;
+
+      default:
+        return FALSE;
+    }
+
+  *x += rect.x;
+  *y += rect.y;
+
+  /* Avoid weird bouncing at the screen edge; see bug 154706 */
+  *x = CLAMP (*x, 0, window->screen->rect.width-1);
+  *y = CLAMP (*y, 0, window->screen->rect.height-1);
+
+  meta_error_trap_push_with_return (display);
+
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Warping pointer to %d,%d with window at %d,%d\n",
+              *x, *y, rect.x, rect.y);
+
+  /* Need to update the grab positions so that the MotionNotify and other
+   * events generated by the XWarpPointer() call below don't cause complete
+   * funkiness.  See bug 124582 and bug 122670.
+   */
+  display->grab_anchor_root_x = *x;
+  display->grab_anchor_root_y = *y;
+  display->grab_latest_motion_x = *x;
+  display->grab_latest_motion_y = *y;
+  if (display->grab_wireframe_active)
+    display->grab_anchor_window_pos = display->grab_wireframe_rect;
+  else
+    meta_window_get_client_root_coords (window,
+                                        &display->grab_anchor_window_pos);
+
+  XWarpPointer (display->xdisplay,
+                None,
+                window->screen->xroot,
+                0, 0, 0, 0,
+                *x, *y);
+
+  if (meta_error_trap_pop_with_return (display, FALSE) != Success)
+    {
+      meta_verbose ("Failed to warp pointer for window %s\n",
+                    window->desc);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+void
+meta_window_begin_grab_op (MetaWindow *window,
+                           MetaGrabOp  op,
+                           gboolean    frame_action,
+                           guint32     timestamp)
+{
+  int x, y;
+
+  warp_grab_pointer (window,
+                     op, &x, &y);
+
+  meta_display_begin_grab_op (window->display,
+                              window->screen,
+                              window,
+                              op,
+                              FALSE,
+                              frame_action,
+                              0 /* button */,
+                              0,
+                              timestamp,
+                              x, y);
+}
+
+void
+meta_window_update_keyboard_resize (MetaWindow *window,
+                                    gboolean    update_cursor)
+{
+  int x, y;
+
+  warp_grab_pointer (window,
+                     window->display->grab_op,
+                     &x, &y);
+
+  if (update_cursor)
+    {
+      guint32 timestamp;
+      /* FIXME: Using CurrentTime is really bad mojo */
+      timestamp = CurrentTime;
+      meta_display_set_grab_op_cursor (window->display,
+                                       NULL,
+                                       window->display->grab_op,
+                                       TRUE,
+                                       window->display->grab_xwindow,
+                                       timestamp);
+    }
+}
+
+void
+meta_window_update_keyboard_move (MetaWindow *window)
+{
+  int x, y;
+
+  warp_grab_pointer (window,
+                     window->display->grab_op,
+                     &x, &y);
+}
+
+void
+meta_window_update_layer (MetaWindow *window)
+{
+  MetaGroup *group;
+
+  meta_stack_freeze (window->screen->stack);
+  group = meta_window_get_group (window);
+  if (group)
+    meta_group_update_layers (group);
+  else
+    meta_stack_update_layer (window->screen->stack, window);
+  meta_stack_thaw (window->screen->stack);
+}
+
+/* ensure_mru_position_after ensures that window appears after
+ * below_this_one in the active_workspace's mru_list (i.e. it treats
+ * window as having been less recently used than below_this_one)
+ */
+static void
+ensure_mru_position_after (MetaWindow *window,
+                           MetaWindow *after_this_one)
+{
+  /* This is sort of slow since it runs through the entire list more
+   * than once (especially considering the fact that we expect the
+   * windows of interest to be the first two elements in the list),
+   * but it doesn't matter while we're only using it on new window
+   * map.
+   */
+
+  GList* active_mru_list;
+  GList* window_position;
+  GList* after_this_one_position;
+
+  active_mru_list         = window->screen->active_workspace->mru_list;
+  window_position         = g_list_find (active_mru_list, window);
+  after_this_one_position = g_list_find (active_mru_list, after_this_one);
+
+  /* after_this_one_position is NULL when we switch workspaces, but in
+   * that case we don't need to do any MRU shuffling so we can simply
+   * return.
+   */
+  if (after_this_one_position == NULL)
+    return;
+
+  if (g_list_length (window_position) > g_list_length (after_this_one_position))
+    {
+      window->screen->active_workspace->mru_list =
+        g_list_delete_link (window->screen->active_workspace->mru_list,
+                            window_position);
+
+      window->screen->active_workspace->mru_list =
+        g_list_insert_before (window->screen->active_workspace->mru_list,
+                              after_this_one_position->next,
+                              window);
+    }
+}
+
+void
+meta_window_stack_just_below (MetaWindow *window,
+                              MetaWindow *below_this_one)
+{
+  g_return_if_fail (window         != NULL);
+  g_return_if_fail (below_this_one != NULL);
+
+  if (window->stack_position > below_this_one->stack_position)
+    {
+      meta_topic (META_DEBUG_STACK,
+                  "Setting stack position of window %s to %d (making it below window %s).\n",
+                  window->desc,
+                  below_this_one->stack_position,
+                  below_this_one->desc);
+      meta_window_set_stack_position (window, below_this_one->stack_position);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STACK,
+                  "Window %s  was already below window %s.\n",
+                  window->desc, below_this_one->desc);
+    }
+}
+
+void
+meta_window_set_user_time (MetaWindow *window,
+                           guint32     timestamp)
+{
+  /* FIXME: If Soeren's suggestion in bug 151984 is implemented, it will allow
+   * us to sanity check the timestamp here and ensure it doesn't correspond to
+   * a future time.
+   */
+
+  /* Only update the time if this timestamp is newer... */
+  if (window->net_wm_user_time_set &&
+      XSERVER_TIME_IS_BEFORE (timestamp, window->net_wm_user_time))
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Window %s _NET_WM_USER_TIME not updated to %u, because it "
+                  "is less than %u\n",
+                  window->desc, timestamp, window->net_wm_user_time);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_STARTUP,
+                  "Window %s has _NET_WM_USER_TIME of %u\n",
+                  window->desc, timestamp);
+      window->net_wm_user_time_set = TRUE;
+      window->net_wm_user_time = timestamp;
+      if (XSERVER_TIME_IS_BEFORE (window->display->last_user_time, timestamp))
+        window->display->last_user_time = timestamp;
+
+      /* If this is a terminal, user interaction with it means the user likely
+       * doesn't want to have focus transferred for now due to new windows.
+       */
+      if (meta_prefs_get_focus_new_windows () ==
+               META_FOCUS_NEW_WINDOWS_STRICT &&
+          __window_is_terminal (window))
+        window->display->allow_terminal_deactivation = FALSE;
+    }
+}
+
+/* Sets the demands_attention hint on a window, but only
+ * if it's at least partially obscured (see #305882).
+ */
+void
+meta_window_set_demands_attention (MetaWindow *window)
+{
+  MetaRectangle candidate_rect, other_rect;
+  GList *stack = window->screen->stack->sorted;
+  MetaWindow *other_window;
+  gboolean obscured = FALSE;
+
+  MetaWorkspace *workspace = window->screen->active_workspace;
+  if (workspace!=window->workspace)
+    {
+      /* windows on other workspaces are necessarily obscured */
+      obscured = TRUE;
+    }
+  else if (window->minimized)
+    {
+      obscured = TRUE;
+    }
+  else
+    {
+      meta_window_get_outer_rect (window, &candidate_rect);
+
+      /* The stack is sorted with the top windows first. */
+
+      while (stack != NULL && stack->data != window)
+        {
+          other_window = stack->data;
+          stack = stack->next;
+
+          if (other_window->on_all_workspaces ||
+              window->on_all_workspaces ||
+              other_window->workspace == window->workspace)
+            {
+              meta_window_get_outer_rect (other_window, &other_rect);
+
+              if (meta_rectangle_overlap (&candidate_rect, &other_rect))
+                {
+                  obscured = TRUE;
+                  break;
+                }
+            }
+        }
+    }
+
+  if (obscured)
+    {
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                  "Marking %s as needing attention\n",
+                  window->desc);
+
+      window->wm_state_demands_attention = TRUE;
+      set_net_wm_state (window);
+    }
+  else
+    {
+      /* If the window's in full view, there's no point setting the flag. */
+
+      meta_topic (META_DEBUG_WINDOW_OPS,
+                 "Not marking %s as needing attention because "
+                 "it's in full view\n",
+                 window->desc);
+    }
+}
+
+void
+meta_window_unset_demands_attention (MetaWindow *window)
+{
+  meta_topic (META_DEBUG_WINDOW_OPS,
+      "Marking %s as not needing attention\n", window->desc);
+
+  window->wm_state_demands_attention = FALSE;
+  set_net_wm_state (window);
+}
+
+MetaFrame *
+meta_window_get_frame (MetaWindow *window)
+{
+  return window->frame;
+}
+
+gboolean
+meta_window_has_focus (MetaWindow *window)
+{
+  return window->has_focus;
+}
+
+gboolean
+meta_window_is_shaded (MetaWindow *window)
+{
+  return window->shaded;
+}
+
+MetaRectangle *
+meta_window_get_rect (MetaWindow *window)
+{
+  return &window->rect;
+}
+
+MetaScreen *
+meta_window_get_screen (MetaWindow *window)
+{
+  return window->screen;
+}
+
+MetaDisplay *
+meta_window_get_display (MetaWindow *window)
+{
+  return window->display;
+}
+
+Window
+meta_window_get_xwindow (MetaWindow *window)
+{
+  return window->xwindow;
+}
diff --git a/src/core/workspace.c b/src/core/workspace.c
new file mode 100644
index 00000000..2b28fe0b
--- /dev/null
+++ b/src/core/workspace.c
@@ -0,0 +1,1038 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco Workspaces */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003 Rob Adams
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "workspace.h"
+#include "errors.h"
+#include "prefs.h"
+#include <X11/Xatom.h>
+#include <string.h>
+#include <canberra-gtk.h>
+
+void meta_workspace_queue_calc_showing   (MetaWorkspace *workspace);
+static void set_active_space_hint        (MetaScreen *screen);
+static void focus_ancestor_or_mru_window (MetaWorkspace *workspace,
+                                          MetaWindow    *not_this_one,
+                                          guint32        timestamp);
+static void free_this                    (gpointer candidate,
+                                          gpointer dummy);
+static void workspace_free_struts        (MetaWorkspace *workspace);
+
+static void
+maybe_add_to_list (MetaScreen *screen, MetaWindow *window, gpointer data)
+{
+  GList **mru_list = data;
+
+  if (window->on_all_workspaces)
+    *mru_list = g_list_prepend (*mru_list, window);
+}
+
+MetaWorkspace*
+meta_workspace_new (MetaScreen *screen)
+{
+  MetaWorkspace *workspace;
+
+  workspace = g_new (MetaWorkspace, 1);
+
+  workspace->screen = screen;
+  workspace->screen->workspaces =
+    g_list_append (workspace->screen->workspaces, workspace);
+  workspace->windows = NULL;
+  workspace->mru_list = NULL;
+  meta_screen_foreach_window (screen, maybe_add_to_list, &workspace->mru_list);
+
+  workspace->work_areas_invalid = TRUE;
+  workspace->work_area_xinerama = NULL;
+  workspace->work_area_screen.x = 0;
+  workspace->work_area_screen.y = 0;
+  workspace->work_area_screen.width = 0;
+  workspace->work_area_screen.height = 0;
+
+  workspace->screen_region = NULL;
+  workspace->xinerama_region = NULL;
+  workspace->screen_edges = NULL;
+  workspace->xinerama_edges = NULL;
+  workspace->list_containing_self = g_list_prepend (NULL, workspace);
+
+  workspace->all_struts = NULL;
+
+  workspace->showing_desktop = FALSE;
+  
+  return workspace;
+}
+
+/** Foreach function for workspace_free_struts() */
+static void
+free_this (gpointer candidate, gpointer dummy)
+{
+  g_free (candidate);
+}
+
+/**
+ * Frees the struts list of a workspace.
+ *
+ * \param workspace  The workspace.
+ */
+static void
+workspace_free_struts (MetaWorkspace *workspace)
+{
+  if (workspace->all_struts == NULL)
+    return;
+    
+  g_slist_foreach (workspace->all_struts, free_this, NULL);
+  g_slist_free (workspace->all_struts);
+  workspace->all_struts = NULL;
+}
+
+void
+meta_workspace_free (MetaWorkspace *workspace)
+{
+  GList *tmp;
+  MetaScreen *screen;
+  int i;
+
+  g_return_if_fail (workspace != workspace->screen->active_workspace);
+
+  /* Here we assume all the windows are already on another workspace
+   * as well, so they won't be "orphaned"
+   */
+  
+  tmp = workspace->windows;
+  while (tmp != NULL)
+    {
+      GList *next;
+      MetaWindow *window = tmp->data;
+      next = tmp->next;
+
+      /* pop front of list we're iterating over */
+      meta_workspace_remove_window (workspace, window);
+      g_assert (window->workspace != NULL);
+
+      tmp = next;
+    }
+
+  g_assert (workspace->windows == NULL);
+
+  screen = workspace->screen;
+  
+  workspace->screen->workspaces =
+    g_list_remove (workspace->screen->workspaces, workspace);
+  
+  g_free (workspace->work_area_xinerama);
+
+  g_list_free (workspace->mru_list);
+  g_list_free (workspace->list_containing_self);
+
+  /* screen.c:update_num_workspaces(), which calls us, removes windows from
+   * workspaces first, which can cause the workareas on the workspace to be
+   * invalidated (and hence for struts/regions/edges to be freed).
+   * So, no point trying to double free it; that causes a crash
+   * anyway.  #361804.
+   */
+
+  if (!workspace->work_areas_invalid)
+    {
+      workspace_free_struts (workspace);
+      for (i = 0; i < screen->n_xinerama_infos; i++)
+        meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]);
+      g_free (workspace->xinerama_region);
+      meta_rectangle_free_list_and_elements (workspace->screen_region);
+      meta_rectangle_free_list_and_elements (workspace->screen_edges);
+      meta_rectangle_free_list_and_elements (workspace->xinerama_edges);
+    }
+
+  g_free (workspace);
+
+  /* don't bother to reset names, pagers can just ignore
+   * extra ones
+   */
+}
+
+void
+meta_workspace_add_window (MetaWorkspace *workspace,
+                           MetaWindow    *window)
+{
+  g_return_if_fail (window->workspace == NULL);
+  
+  /* If the window is on all workspaces, we want to add it to all mru
+   * lists, otherwise just add it to this workspaces mru list
+   */
+  if (window->on_all_workspaces) 
+    {
+      if (window->workspace == NULL)
+        {
+          GList* tmp = window->screen->workspaces;
+          while (tmp)
+            {
+              MetaWorkspace* work = (MetaWorkspace*) tmp->data;
+              if (!g_list_find (work->mru_list, window))
+                work->mru_list = g_list_prepend (work->mru_list, window);
+
+              tmp = tmp->next;
+            }
+        }
+    }
+  else
+    {
+      g_assert (g_list_find (workspace->mru_list, window) == NULL);
+      workspace->mru_list = g_list_prepend (workspace->mru_list, window);
+    }
+
+  workspace->windows = g_list_prepend (workspace->windows, window);
+  window->workspace = workspace;
+
+  meta_window_set_current_workspace_hint (window);
+  
+  if (window->struts)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Invalidating work area of workspace %d since we're adding window %s to it\n",
+                  meta_workspace_index (workspace), window->desc);
+      meta_workspace_invalidate_work_area (workspace);
+    }
+
+  /* queue a move_resize since changing workspaces may change
+   * the relevant struts
+   */
+  meta_window_queue (window, META_QUEUE_CALC_SHOWING|META_QUEUE_MOVE_RESIZE);
+}
+
+void
+meta_workspace_remove_window (MetaWorkspace *workspace,
+                              MetaWindow    *window)
+{
+  g_return_if_fail (window->workspace == workspace);
+
+  workspace->windows = g_list_remove (workspace->windows, window);
+  window->workspace = NULL;
+
+  /* If the window is on all workspaces, we don't want to remove it
+   * from the MRU list unless this causes it to be removed from all 
+   * workspaces
+   */
+  if (window->on_all_workspaces) 
+    {
+      GList* tmp = window->screen->workspaces;
+      while (tmp)
+        {
+          MetaWorkspace* work = (MetaWorkspace*) tmp->data;
+          work->mru_list = g_list_remove (work->mru_list, window);
+
+          tmp = tmp->next;
+        }
+    }
+  else
+    {
+      workspace->mru_list = g_list_remove (workspace->mru_list, window);
+      g_assert (g_list_find (workspace->mru_list, window) == NULL);
+    }
+
+  meta_window_set_current_workspace_hint (window);
+  
+  if (window->struts)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Invalidating work area of workspace %d since we're removing window %s from it\n",
+                  meta_workspace_index (workspace), window->desc);
+      meta_workspace_invalidate_work_area (workspace);
+    }
+
+  /* queue a move_resize since changing workspaces may change
+   * the relevant struts
+   */
+  meta_window_queue (window, META_QUEUE_CALC_SHOWING|META_QUEUE_MOVE_RESIZE);
+}
+
+void
+meta_workspace_relocate_windows (MetaWorkspace *workspace,
+                                 MetaWorkspace *new_home)
+{
+  GList *tmp;
+  GList *copy;
+  
+  g_return_if_fail (workspace != new_home);
+
+  /* can't modify list we're iterating over */
+  copy = g_list_copy (workspace->windows);
+  
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      meta_workspace_remove_window (workspace, window);
+      meta_workspace_add_window (new_home, window);
+      
+      tmp = tmp->next;
+    }
+
+  g_list_free (copy);
+  
+  g_assert (workspace->windows == NULL);
+}
+
+void
+meta_workspace_queue_calc_showing  (MetaWorkspace *workspace)
+{
+  GList *tmp;
+
+  tmp = workspace->windows;
+  while (tmp != NULL)
+    {
+      meta_window_queue (tmp->data, META_QUEUE_CALC_SHOWING);
+
+      tmp = tmp->next;
+    }
+}
+
+static void workspace_switch_sound(MetaWorkspace *from,
+                                   MetaWorkspace *to) {
+
+  MetaWorkspaceLayout layout;
+  int i, nw, x, y, fi, ti;
+  const char *e;
+
+  nw = meta_screen_get_n_workspaces(from->screen);
+  fi = meta_workspace_index(from);
+  ti = meta_workspace_index(to);
+
+  meta_screen_calc_workspace_layout(from->screen,
+                                    nw,
+                                    fi,
+                                    &layout);
+
+  for (i = 0; i < nw; i++)
+    if (layout.grid[i] == ti)
+      break;
+
+  if (i >= nw) {
+    meta_bug("Failed to find destination workspace in layout\n");
+    goto finish;
+  }
+
+  y = i / layout.cols;
+  x = i % layout.cols;
+
+  /* We priorize horizontal over vertical movements here. The
+     rationale for this is that horizontal movements are probably more
+     interesting for sound effects because speakers are usually
+     positioned on a horizontal and not a vertical axis. i.e. your
+     spatial "Woosh!" effects will easily be able to encode horizontal
+     movement but not such much vertical movement. */
+
+  if (x < layout.current_col)
+    e = "desktop-switch-left";
+  else if (x > layout.current_col)
+    e = "desktop-switch-right";
+  else if (y < layout.current_row)
+    e = "desktop-switch-up";
+  else if (y > layout.current_row)
+    e = "desktop-switch-down";
+  else {
+    meta_bug("Uh, origin and destination workspace at same logic position!\n");
+    goto finish;
+  }
+
+  ca_context_play(ca_gtk_context_get(), 1,
+                  CA_PROP_EVENT_ID, e,
+                  CA_PROP_EVENT_DESCRIPTION, "Desktop switched",
+                  CA_PROP_CANBERRA_CACHE_CONTROL, "permanent",
+                  NULL);
+
+ finish:
+  meta_screen_free_workspace_layout (&layout);
+}
+
+void
+meta_workspace_activate_with_focus (MetaWorkspace *workspace,
+                                    MetaWindow    *focus_this,
+                                    guint32        timestamp)
+{
+  MetaWorkspace *old;
+  MetaWindow *move_window;
+  
+  meta_verbose ("Activating workspace %d\n",
+                meta_workspace_index (workspace));
+  
+  if (workspace->screen->active_workspace == workspace)
+    return;
+
+  if (workspace->screen->active_workspace)
+    workspace_switch_sound(workspace->screen->active_workspace, workspace);
+
+  /* Note that old can be NULL; e.g. when starting up */
+  old = workspace->screen->active_workspace;
+  
+  workspace->screen->active_workspace = workspace;
+
+  set_active_space_hint (workspace->screen);
+
+  /* If the "show desktop" mode is active for either the old workspace
+   * or the new one *but not both*, then update the
+   * _net_showing_desktop hint
+   */
+  if (old && (old->showing_desktop ^ workspace->showing_desktop))
+    meta_screen_update_showing_desktop_hint (workspace->screen);
+
+  if (old == NULL)
+    return;
+
+  move_window = NULL;
+  if (workspace->screen->display->grab_op == META_GRAB_OP_MOVING ||
+      workspace->screen->display->grab_op == META_GRAB_OP_KEYBOARD_MOVING)
+    move_window = workspace->screen->display->grab_window;
+      
+  if (move_window != NULL)
+    {
+      if (move_window->on_all_workspaces)
+        move_window = NULL; /* don't move it after all */
+
+      /* We put the window on the new workspace, flip spaces,
+       * then remove from old workspace, so the window
+       * never gets unmapped and we maintain the button grab
+       * on it.
+       *
+       * \bug  This comment appears to be the reverse of what happens
+       */
+      if (move_window && (move_window->workspace != workspace))
+        {
+          meta_workspace_remove_window (old, move_window);
+          meta_workspace_add_window (workspace, move_window);
+        }
+    }
+
+  meta_workspace_queue_calc_showing (old);
+  meta_workspace_queue_calc_showing (workspace);
+
+  /* FIXME: Why do we need this?!?  Isn't it handled in the lines above? */
+  if (move_window)
+      /* Removes window from other spaces */
+      meta_window_change_workspace (move_window, workspace);
+
+  if (focus_this)
+    {
+      meta_window_focus (focus_this, timestamp);
+      meta_window_raise (focus_this);
+    }
+  else if (move_window)
+    {
+      meta_window_raise (move_window);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_FOCUS, "Focusing default window on new workspace\n");
+      meta_workspace_focus_default_window (workspace, NULL, timestamp);
+    }
+}
+
+void
+meta_workspace_activate (MetaWorkspace *workspace,
+                         guint32        timestamp)
+{
+  meta_workspace_activate_with_focus (workspace, NULL, timestamp);
+}
+
+int
+meta_workspace_index (MetaWorkspace *workspace)
+{
+  int ret;
+
+  ret = g_list_index (workspace->screen->workspaces, workspace);
+
+  if (ret < 0)
+    meta_bug ("Workspace does not exist to index!\n");
+
+  return ret;
+}
+
+/* get windows contained on workspace, including workspace->windows
+ * and also sticky windows.
+ */
+GList*
+meta_workspace_list_windows (MetaWorkspace *workspace)
+{
+  GSList *display_windows;
+  GSList *tmp;
+  GList *workspace_windows;
+  
+  display_windows = meta_display_list_windows (workspace->screen->display);
+
+  workspace_windows = NULL;
+  tmp = display_windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *window = tmp->data;
+
+      if (meta_window_located_on_workspace (window, workspace))
+        workspace_windows = g_list_prepend (workspace_windows,
+                                            window);
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (display_windows);
+
+  return workspace_windows;
+}
+
+static void
+set_active_space_hint (MetaScreen *screen)
+{
+  unsigned long data[1];
+
+  /* this is because we destroy the spaces in order,
+   * so we always end up setting a current desktop of
+   * 0 when closing a screen, so lose the current desktop
+   * on restart. By doing this we keep the current
+   * desktop on restart.
+   */
+  if (screen->closing > 0)
+    return;
+  
+  data[0] = meta_workspace_index (screen->active_workspace);
+
+  meta_verbose ("Setting _NET_CURRENT_DESKTOP to %lu\n", data[0]);
+  
+  meta_error_trap_push (screen->display);
+  XChangeProperty (screen->display->xdisplay, screen->xroot,
+                   screen->display->atom__NET_CURRENT_DESKTOP,
+                   XA_CARDINAL,
+                   32, PropModeReplace, (guchar*) data, 1);
+  meta_error_trap_pop (screen->display, FALSE);
+}
+
+void
+meta_workspace_invalidate_work_area (MetaWorkspace *workspace)
+{
+  GList *tmp;
+  GList *windows;
+  int i;
+  
+  if (workspace->work_areas_invalid)
+    {
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Work area for workspace %d is already invalid\n",
+                  meta_workspace_index (workspace));
+      return;
+    }
+
+  meta_topic (META_DEBUG_WORKAREA,
+              "Invalidating work area for workspace %d\n",
+              meta_workspace_index (workspace));
+
+  g_free (workspace->work_area_xinerama);
+  workspace->work_area_xinerama = NULL;
+      
+  workspace_free_struts (workspace);
+
+  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+    meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]);
+  g_free (workspace->xinerama_region);
+  meta_rectangle_free_list_and_elements (workspace->screen_region);
+  meta_rectangle_free_list_and_elements (workspace->screen_edges);
+  meta_rectangle_free_list_and_elements (workspace->xinerama_edges);
+  workspace->xinerama_region = NULL;
+  workspace->screen_region = NULL;
+  workspace->screen_edges = NULL;
+  workspace->xinerama_edges = NULL;
+  
+  workspace->work_areas_invalid = TRUE;
+
+  /* redo the size/position constraints on all windows */
+  windows = meta_workspace_list_windows (workspace);
+  tmp = windows;
+  while (tmp != NULL)
+    {
+      MetaWindow *w = tmp->data;
+
+      meta_window_queue (w, META_QUEUE_MOVE_RESIZE);
+      
+      tmp = tmp->next;
+    }
+
+  g_list_free (windows);
+
+  meta_screen_queue_workarea_recalc (workspace->screen);
+}
+
+static void
+ensure_work_areas_validated (MetaWorkspace *workspace)
+{
+  GList         *windows;
+  GList         *tmp;
+  MetaRectangle  work_area;
+  int            i;  /* C89 absolutely sucks... */
+
+  if (!workspace->work_areas_invalid)
+    return;
+
+  g_assert (workspace->all_struts == NULL);
+  g_assert (workspace->xinerama_region == NULL);
+  g_assert (workspace->screen_region == NULL);
+  g_assert (workspace->screen_edges == NULL);
+  g_assert (workspace->xinerama_edges == NULL);
+
+  /* STEP 1: Get the list of struts */  
+  windows = meta_workspace_list_windows (workspace);
+  for (tmp = windows; tmp != NULL; tmp = tmp->next)
+    {
+      MetaWindow *win = tmp->data;
+      GSList *s_iter;
+
+      for (s_iter = win->struts; s_iter != NULL; s_iter = s_iter->next) {
+        MetaStrut *cpy = g_new (MetaStrut, 1);
+        *cpy = *((MetaStrut *)s_iter->data);
+        workspace->all_struts = g_slist_prepend (workspace->all_struts,
+                                                 cpy);
+      }
+    }
+  g_list_free (windows);
+
+  /* STEP 2: Get the maximal/spanning rects for the onscreen and
+   *         on-single-xinerama regions
+   */  
+  g_assert (workspace->xinerama_region == NULL);
+  g_assert (workspace->screen_region   == NULL);
+
+  workspace->xinerama_region = g_new (GList*,
+                                      workspace->screen->n_xinerama_infos);
+  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+    {
+      workspace->xinerama_region[i] =
+        meta_rectangle_get_minimal_spanning_set_for_region (
+          &workspace->screen->xinerama_infos[i].rect,
+          workspace->all_struts);
+    }
+  workspace->screen_region =
+    meta_rectangle_get_minimal_spanning_set_for_region (
+      &workspace->screen->rect,
+      workspace->all_struts);
+
+  /* STEP 3: Get the work areas (region-to-maximize-to) for the screen and
+   *         xineramas.
+   */
+  work_area = workspace->screen->rect;  /* start with the screen */
+  if (workspace->screen_region == NULL)
+    work_area = meta_rect (0, 0, -1, -1);
+  else
+    meta_rectangle_clip_to_region (workspace->screen_region,
+                                   FIXED_DIRECTION_NONE,
+                                   &work_area);
+
+  /* Lots of paranoia checks, forcing work_area_screen to be sane */
+#define MIN_SANE_AREA 100
+  if (work_area.width < MIN_SANE_AREA)
+    {
+      meta_warning ("struts occupy an unusually large percentage of the screen; "
+                    "available remaining width = %d < %d",
+                    work_area.width, MIN_SANE_AREA);
+      if (work_area.width < 1)
+        {
+          work_area.x = (workspace->screen->rect.width - MIN_SANE_AREA)/2;
+          work_area.width = MIN_SANE_AREA;
+        }
+      else
+        {
+          int amount = (MIN_SANE_AREA - work_area.width)/2;
+          work_area.x     -=   amount;
+          work_area.width += 2*amount;
+        }
+    }
+  if (work_area.height < MIN_SANE_AREA)
+    {
+      meta_warning ("struts occupy an unusually large percentage of the screen; "
+                    "available remaining height = %d < %d",
+                    work_area.height, MIN_SANE_AREA);
+      if (work_area.height < 1)
+        {
+          work_area.y = (workspace->screen->rect.height - MIN_SANE_AREA)/2;
+          work_area.height = MIN_SANE_AREA;
+        }
+      else
+        {
+          int amount = (MIN_SANE_AREA - work_area.height)/2;
+          work_area.y      -=   amount;
+          work_area.height += 2*amount;
+        }
+    }
+  workspace->work_area_screen = work_area;
+  meta_topic (META_DEBUG_WORKAREA,
+              "Computed work area for workspace %d: %d,%d %d x %d\n",
+              meta_workspace_index (workspace),
+              workspace->work_area_screen.x,
+              workspace->work_area_screen.y,
+              workspace->work_area_screen.width,
+              workspace->work_area_screen.height);    
+
+  /* Now find the work areas for each xinerama */
+  g_free (workspace->work_area_xinerama);
+  workspace->work_area_xinerama = g_new (MetaRectangle,
+                                         workspace->screen->n_xinerama_infos);
+
+  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+    {
+      work_area = workspace->screen->xinerama_infos[i].rect;
+
+      if (workspace->xinerama_region[i] == NULL)
+        /* FIXME: constraints.c untested with this, but it might be nice for
+         * a screen reader or magnifier.
+         */
+        work_area = meta_rect (work_area.x, work_area.y, -1, -1);
+      else
+        meta_rectangle_clip_to_region (workspace->xinerama_region[i],
+                                       FIXED_DIRECTION_NONE,
+                                       &work_area);
+
+      workspace->work_area_xinerama[i] = work_area;
+      meta_topic (META_DEBUG_WORKAREA,
+                  "Computed work area for workspace %d "
+                  "xinerama %d: %d,%d %d x %d\n",
+                  meta_workspace_index (workspace),
+                  i,
+                  workspace->work_area_xinerama[i].x,
+                  workspace->work_area_xinerama[i].y,
+                  workspace->work_area_xinerama[i].width,
+                  workspace->work_area_xinerama[i].height);
+    }
+
+  /* STEP 4: Make sure the screen_region is nonempty (separate from step 2
+   *         since it relies on step 3).
+   */  
+  if (workspace->screen_region == NULL)
+    {
+      MetaRectangle *nonempty_region;
+      nonempty_region = g_new (MetaRectangle, 1);
+      *nonempty_region = workspace->work_area_screen;
+      workspace->screen_region = g_list_prepend (NULL, nonempty_region);
+    }
+
+  /* STEP 5: Cache screen and xinerama edges for edge resistance and snapping */
+  g_assert (workspace->screen_edges    == NULL);
+  g_assert (workspace->xinerama_edges  == NULL);
+  workspace->screen_edges =
+    meta_rectangle_find_onscreen_edges (&workspace->screen->rect,
+                                        workspace->all_struts);
+  tmp = NULL;
+  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+    tmp = g_list_prepend (tmp, &workspace->screen->xinerama_infos[i].rect);
+  workspace->xinerama_edges =
+    meta_rectangle_find_nonintersected_xinerama_edges (tmp,
+                                                       workspace->all_struts);
+  g_list_free (tmp);
+
+  /* We're all done, YAAY!  Record that everything has been validated. */
+  workspace->work_areas_invalid = FALSE;
+}
+
+void
+meta_workspace_get_work_area_for_xinerama (MetaWorkspace *workspace,
+                                           int            which_xinerama,
+                                           MetaRectangle *area)
+{
+  g_assert (which_xinerama >= 0);
+
+  ensure_work_areas_validated (workspace);
+  g_assert (which_xinerama < workspace->screen->n_xinerama_infos);
+  
+  *area = workspace->work_area_xinerama[which_xinerama];
+}
+
+void
+meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
+                                            MetaRectangle *area)
+{
+  ensure_work_areas_validated (workspace);
+  
+  *area = workspace->work_area_screen;
+}
+
+GList*
+meta_workspace_get_onscreen_region (MetaWorkspace *workspace)
+{
+  ensure_work_areas_validated (workspace);
+
+  return workspace->screen_region;
+}
+
+GList*
+meta_workspace_get_onxinerama_region (MetaWorkspace *workspace,
+                                      int            which_xinerama)
+{
+  ensure_work_areas_validated (workspace);
+
+  return workspace->xinerama_region[which_xinerama];
+}
+
+#ifdef WITH_VERBOSE_MODE
+static char *
+meta_motion_direction_to_string (MetaMotionDirection direction)
+{
+  switch (direction)
+    {
+    case META_MOTION_UP:
+      return "Up";
+    case META_MOTION_DOWN:
+      return "Down";
+    case META_MOTION_LEFT:
+      return "Left";
+    case META_MOTION_RIGHT:
+      return "Right";
+    }
+
+  return "Unknown";
+}
+#endif /* WITH_VERBOSE_MODE */
+
+MetaWorkspace*
+meta_workspace_get_neighbor (MetaWorkspace      *workspace,
+                             MetaMotionDirection direction)
+{
+  MetaWorkspaceLayout layout;  
+  int i, current_space, num_workspaces;
+  gboolean ltr;
+
+  current_space = meta_workspace_index (workspace);
+  num_workspaces = meta_screen_get_n_workspaces (workspace->screen);
+  meta_screen_calc_workspace_layout (workspace->screen, num_workspaces,
+                                     current_space, &layout);
+
+  meta_verbose ("Getting neighbor of %d in direction %s\n",
+                current_space, meta_motion_direction_to_string (direction));
+  
+  ltr = meta_ui_get_direction() == META_UI_DIRECTION_LTR;
+
+  switch (direction) 
+    {
+    case META_MOTION_LEFT:
+      layout.current_col -= ltr ? 1 : -1;
+      break;
+    case META_MOTION_RIGHT:
+      layout.current_col += ltr ? 1 : -1;
+      break;
+    case META_MOTION_UP:
+      layout.current_row -= 1;
+      break;
+    case META_MOTION_DOWN:
+      layout.current_row += 1;
+      break;
+    }
+
+  if (layout.current_col < 0)
+    layout.current_col = 0;
+  if (layout.current_col >= layout.cols)
+    layout.current_col = layout.cols - 1;
+  if (layout.current_row < 0)
+    layout.current_row = 0;
+  if (layout.current_row >= layout.rows)
+    layout.current_row = layout.rows - 1;
+
+  i = layout.grid[layout.current_row * layout.cols + layout.current_col];
+
+  if (i < 0)
+    i = current_space;
+
+  if (i >= num_workspaces)
+    meta_bug ("calc_workspace_layout left an invalid (too-high) workspace number %d in the grid\n",
+              i);
+    
+  meta_verbose ("Neighbor workspace is %d at row %d col %d\n",
+                i, layout.current_row, layout.current_col);
+
+  meta_screen_free_workspace_layout (&layout);
+  
+  return meta_screen_get_workspace_by_index (workspace->screen, i);
+}
+
+const char*
+meta_workspace_get_name (MetaWorkspace *workspace)
+{
+  return meta_prefs_get_workspace_name (meta_workspace_index (workspace));
+}
+
+void
+meta_workspace_focus_default_window (MetaWorkspace *workspace,
+                                     MetaWindow    *not_this_one,
+                                     guint32        timestamp)
+{
+  if (timestamp == CurrentTime)
+    {
+      meta_warning ("CurrentTime used to choose focus window; "
+                    "focus window may not be correct.\n");
+    }
+
+
+  if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK ||
+      !workspace->screen->display->mouse_mode)
+    focus_ancestor_or_mru_window (workspace, not_this_one, timestamp);
+  else
+    {
+      MetaWindow * window;
+      window = meta_screen_get_mouse_window (workspace->screen, not_this_one);
+      if (window &&
+          window->type != META_WINDOW_DOCK &&
+          window->type != META_WINDOW_DESKTOP)
+        {
+          if (timestamp == CurrentTime)
+            {
+
+              /* We would like for this to never happen.  However, if
+               * it does happen then we kludge since using CurrentTime
+               * can mean ugly race conditions--and we can avoid these
+               * by allowing EnterNotify events (which come with
+               * timestamps) to handle focus.
+               */
+
+              meta_topic (META_DEBUG_FOCUS,
+                          "Not focusing mouse window %s because EnterNotify events should handle that\n", window->desc);
+            }
+          else
+            {
+              meta_topic (META_DEBUG_FOCUS,
+                          "Focusing mouse window %s\n", window->desc);
+              meta_window_focus (window, timestamp);
+            }
+
+          if (workspace->screen->display->autoraise_window != window &&
+              meta_prefs_get_auto_raise ()) 
+            {
+              meta_display_queue_autoraise_callback (workspace->screen->display,
+                                                     window);
+            }
+        }
+      else if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_SLOPPY)
+        focus_ancestor_or_mru_window (workspace, not_this_one, timestamp);
+      else if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_MOUSE)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Setting focus to no_focus_window, since no valid "
+                      "window to focus found.\n");
+          meta_display_focus_the_no_focus_window (workspace->screen->display,
+                                                  workspace->screen,
+                                                  timestamp);
+        }
+    }
+}
+
+static gboolean
+record_ancestor (MetaWindow *window,
+                 void       *data)
+{
+  MetaWindow **result = data;
+
+  *result = window;
+  return FALSE; /* quit with the first ancestor we find */
+}
+
+/* Focus ancestor of not_this_one if there is one, otherwise focus the MRU
+ * window on active workspace
+ */
+static void
+focus_ancestor_or_mru_window (MetaWorkspace *workspace,
+                              MetaWindow    *not_this_one,
+                              guint32        timestamp)
+{
+  MetaWindow *window = NULL;
+  MetaWindow *desktop_window = NULL;
+  GList *tmp;
+
+  if (not_this_one)
+    meta_topic (META_DEBUG_FOCUS,
+                "Focusing MRU window excluding %s\n", not_this_one->desc);
+  else
+    meta_topic (META_DEBUG_FOCUS,
+                "Focusing MRU window\n");
+
+  /* First, check to see if we need to focus an ancestor of a window */  
+  if (not_this_one)
+    {
+      MetaWindow *ancestor;
+      ancestor = NULL;
+      meta_window_foreach_ancestor (not_this_one, record_ancestor, &ancestor);
+      if (ancestor != NULL)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Focusing %s, ancestor of %s\n", 
+                      ancestor->desc, not_this_one->desc);
+      
+          meta_window_focus (ancestor, timestamp);
+
+          /* Also raise the window if in click-to-focus */
+          if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK)
+            meta_window_raise (ancestor);
+
+          return;
+        }
+    }
+
+  /* No ancestor, look for the MRU window */
+  tmp = workspace->mru_list;  
+
+  while (tmp)
+    {
+      MetaWindow* tmp_window;
+      tmp_window = ((MetaWindow*) tmp->data);
+      if (tmp_window != not_this_one           &&
+          meta_window_showing_on_its_workspace (tmp_window) &&
+          tmp_window->type != META_WINDOW_DOCK &&
+          tmp_window->type != META_WINDOW_DESKTOP)
+        {
+          window = tmp->data;
+          break;
+        }
+      else if (tmp_window != not_this_one      &&
+               desktop_window == NULL          &&
+               meta_window_showing_on_its_workspace (tmp_window) &&
+               tmp_window->type == META_WINDOW_DESKTOP)
+        {
+          /* Found the most recently used desktop window */
+          desktop_window = tmp_window;
+        }
+
+      tmp = tmp->next;
+    }
+
+  /* If no window was found, default to the MRU desktop-window */
+  if (window == NULL)
+    window = desktop_window;
+
+  if (window)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing workspace MRU window %s\n", window->desc);
+      
+      meta_window_focus (window, timestamp);
+
+      /* Also raise the window if in click-to-focus */
+      if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK)
+        meta_window_raise (window);
+    }
+  else
+    {
+      meta_topic (META_DEBUG_FOCUS, "No MRU window to focus found; focusing no_focus_window.\n");
+      meta_display_focus_the_no_focus_window (workspace->screen->display,
+                                              workspace->screen,
+                                              timestamp);
+    }
+}
diff --git a/src/core/workspace.h b/src/core/workspace.h
new file mode 100644
index 00000000..f4079ebb
--- /dev/null
+++ b/src/core/workspace.h
@@ -0,0 +1,113 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file workspace.h    Workspaces
+ *
+ * A workspace is a set of windows which all live on the same
+ * screen.  (You may also see the name "desktop" around the place,
+ * which is the EWMH's name for the same thing.)  Only one workspace
+ * of a screen may be active at once; all windows on all other workspaces
+ * are unmapped.
+ */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2004, 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef META_WORKSPACE_H
+#define META_WORKSPACE_H
+
+#include "window-private.h"
+
+/* Negative to avoid conflicting with real workspace
+ * numbers
+ */
+typedef enum
+{
+  META_MOTION_UP = -1,
+  META_MOTION_DOWN = -2,
+  META_MOTION_LEFT = -3,
+  META_MOTION_RIGHT = -4
+} MetaMotionDirection;
+
+struct _MetaWorkspace
+{
+  MetaScreen *screen;
+  
+  GList *windows;
+  GList *mru_list;
+
+  GList  *list_containing_self;
+
+  MetaRectangle work_area_screen;
+  MetaRectangle *work_area_xinerama;
+  GList  *screen_region;
+  GList  **xinerama_region;
+  GList  *screen_edges;
+  GList  *xinerama_edges;
+  GSList *all_struts;
+  guint work_areas_invalid : 1;
+
+  guint showing_desktop : 1;
+};
+
+MetaWorkspace* meta_workspace_new           (MetaScreen    *screen);
+void           meta_workspace_free          (MetaWorkspace *workspace);
+void           meta_workspace_add_window    (MetaWorkspace *workspace,
+                                             MetaWindow    *window);
+void           meta_workspace_remove_window (MetaWorkspace *workspace,
+                                             MetaWindow    *window);
+void           meta_workspace_relocate_windows (MetaWorkspace *workspace,
+                                                MetaWorkspace *new_home);
+void           meta_workspace_activate_with_focus (MetaWorkspace *workspace,
+                                                   MetaWindow    *focus_this,
+                                                   guint32        timestamp);
+void           meta_workspace_activate            (MetaWorkspace *workspace,
+                                                   guint32        timestamp);
+int            meta_workspace_index         (MetaWorkspace *workspace);
+GList*         meta_workspace_list_windows  (MetaWorkspace *workspace);
+
+void meta_workspace_invalidate_work_area (MetaWorkspace *workspace);
+
+
+void meta_workspace_get_work_area_for_xinerama  (MetaWorkspace *workspace,
+                                                 int            which_xinerama,
+                                                 MetaRectangle *area);
+void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
+                                                 MetaRectangle *area);
+GList* meta_workspace_get_onscreen_region       (MetaWorkspace *workspace);
+GList* meta_workspace_get_onxinerama_region     (MetaWorkspace *workspace,
+                                                 int            which_xinerama);
+void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
+                                                 MetaRectangle *area);
+
+void meta_workspace_focus_default_window (MetaWorkspace *workspace,
+                                          MetaWindow    *not_this_one,
+                                          guint32        timestamp);
+
+MetaWorkspace* meta_workspace_get_neighbor (MetaWorkspace      *workspace,
+                                            MetaMotionDirection direction);
+
+const char* meta_workspace_get_name (MetaWorkspace *workspace);
+
+#endif
+
+
+
+
diff --git a/src/core/xprops.c b/src/core/xprops.c
new file mode 100644
index 00000000..71e9eeae
--- /dev/null
+++ b/src/core/xprops.c
@@ -0,0 +1,1238 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X property convenience routines */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2002 Red Hat Inc.
+ *
+ * Some trivial property-unpacking code from Xlib:
+ *   Copyright 1987, 1988, 1998  The Open Group
+ *   Copyright 1988 by Wyse Technology, Inc., San Jose, Ca,
+ *   Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/***********************************************************
+Copyright 1988 by Wyse Technology, Inc., San Jose, Ca,
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL AND WYSE DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 
+EVENT SHALL DIGITAL OR WYSE BE LIABLE FOR ANY SPECIAL, INDIRECT OR 
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF 
+USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/*
+
+Copyright 1987, 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+
+#include <config.h>
+#include "xprops.h"
+#include "errors.h"
+#include "util.h"
+#include "async-getprop.h"
+#include "ui.h"
+#include "marco-Xatomtype.h"
+#include <X11/Xatom.h>
+#include <string.h>
+#include "window-private.h"
+
+typedef struct
+{
+  MetaDisplay   *display;
+  Window         xwindow;
+  Atom           xatom;
+  Atom           type;
+  int            format;
+  unsigned long  n_items;
+  unsigned long  bytes_after;
+  unsigned char *prop;
+} GetPropertyResults;
+
+static gboolean
+validate_or_free_results (GetPropertyResults *results,
+                          int                 expected_format,
+                          Atom                expected_type,
+                          gboolean            must_have_items)
+{
+  char *type_name;
+  char *expected_name;
+  char *prop_name;
+  const char *title;
+  const char *res_class;
+  const char *res_name;
+  MetaWindow *w;
+  
+  if (expected_format == results->format &&
+      expected_type == results->type &&
+      (!must_have_items || results->n_items > 0))
+    return TRUE;  
+  
+  meta_error_trap_push (results->display);
+  type_name = XGetAtomName (results->display->xdisplay, results->type);
+  expected_name = XGetAtomName (results->display->xdisplay, expected_type);
+  prop_name = XGetAtomName (results->display->xdisplay, results->xatom);
+  meta_error_trap_pop (results->display, TRUE);
+
+  w = meta_display_lookup_x_window (results->display, results->xwindow);
+
+  if (w != NULL)
+    {
+      title = w->title;
+      res_class = w->res_class;
+      res_name = w->res_name;
+    }
+  else
+    {
+      title = NULL;
+      res_class = NULL;
+      res_name = NULL;
+    }
+  
+  if (title == NULL)
+    title = "unknown";
+
+  if (res_class == NULL)
+    res_class = "unknown";
+
+  if (res_name == NULL)
+    res_name = "unknown";
+  
+  meta_warning (_("Window 0x%lx has property %s\nthat was expected to have type %s format %d\nand actually has type %s format %d n_items %d.\nThis is most likely an application bug, not a window manager bug.\nThe window has title=\"%s\" class=\"%s\" name=\"%s\"\n"),
+                results->xwindow,
+                prop_name ? prop_name : "(bad atom)",
+                expected_name ? expected_name : "(bad atom)",
+                expected_format,
+                type_name ? type_name : "(bad atom)",
+                results->format, (int) results->n_items,
+                title, res_class, res_name);
+
+  if (type_name)
+    XFree (type_name);
+  if (expected_name)
+    XFree (expected_name);
+  if (prop_name)
+    XFree (prop_name);
+
+  if (results->prop)
+    {
+      XFree (results->prop);
+      results->prop = NULL;
+    }
+  
+  return FALSE;
+}
+
+static gboolean
+get_property (MetaDisplay        *display,
+              Window              xwindow,
+              Atom                xatom,
+              Atom                req_type,
+              GetPropertyResults *results)
+{
+  results->display = display;
+  results->xwindow = xwindow;
+  results->xatom = xatom;
+  results->prop = NULL;
+  results->n_items = 0;
+  results->type = None;
+  results->bytes_after = 0;
+  results->format = 0;
+  
+  meta_error_trap_push_with_return (display);
+  if (XGetWindowProperty (display->xdisplay, xwindow, xatom,
+                          0, G_MAXLONG,
+                          False, req_type, &results->type, &results->format,
+                          &results->n_items,
+                          &results->bytes_after,
+                          &results->prop) != Success ||
+      results->type == None)
+    {
+      if (results->prop)
+        XFree (results->prop);
+      meta_error_trap_pop_with_return (display, TRUE);
+      return FALSE;
+    }
+
+  if (meta_error_trap_pop_with_return (display, TRUE) != Success)
+    {
+      if (results->prop)
+        XFree (results->prop);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+atom_list_from_results (GetPropertyResults *results,
+                        Atom              **atoms_p,
+                        int                *n_atoms_p)
+{
+  if (!validate_or_free_results (results, 32, XA_ATOM, FALSE))
+    return FALSE;  
+
+  *atoms_p = (Atom*) results->prop;
+  *n_atoms_p = results->n_items;
+  results->prop = NULL;  
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_atom_list (MetaDisplay *display,
+                         Window       xwindow,
+                         Atom         xatom,
+                         Atom       **atoms_p,
+                         int         *n_atoms_p)
+{
+  GetPropertyResults results;
+
+  *atoms_p = NULL;
+  *n_atoms_p = 0;
+
+  if (!get_property (display, xwindow, xatom, XA_ATOM,
+                     &results))
+    return FALSE;
+
+  return atom_list_from_results (&results, atoms_p, n_atoms_p);
+}
+
+static gboolean
+cardinal_list_from_results (GetPropertyResults *results,
+                            gulong            **cardinals_p,
+                            int                *n_cardinals_p)
+{
+  if (!validate_or_free_results (results, 32, XA_CARDINAL, FALSE))
+    return FALSE;  
+
+  *cardinals_p = (gulong*) results->prop;
+  *n_cardinals_p = results->n_items;
+  results->prop = NULL;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_cardinal_list (MetaDisplay *display,
+                             Window       xwindow,
+                             Atom         xatom,
+                             gulong     **cardinals_p,
+                             int         *n_cardinals_p)
+{
+  GetPropertyResults results;
+
+  *cardinals_p = NULL;
+  *n_cardinals_p = 0;
+
+  if (!get_property (display, xwindow, xatom, XA_CARDINAL,
+                     &results))
+    return FALSE;
+
+  return cardinal_list_from_results (&results, cardinals_p, n_cardinals_p);
+}
+
+static gboolean
+motif_hints_from_results (GetPropertyResults *results,
+                          MotifWmHints      **hints_p)
+{
+  int real_size, max_size;
+#define MAX_ITEMS sizeof (MotifWmHints)/sizeof (gulong)
+  
+  *hints_p = NULL;  
+
+  if (results->type == None || results->n_items <= 0)
+    {
+      meta_verbose ("Motif hints had unexpected type or n_items\n");
+      if (results->prop)
+        {
+          XFree (results->prop);
+          results->prop = NULL;
+        }
+      return FALSE;
+    }
+
+  /* The issue here is that some old crufty code will set a smaller
+   * MotifWmHints than the one we expect, apparently.  I'm not sure of
+   * the history behind it. See bug #89841 for example.
+   */
+  *hints_p = ag_Xmalloc (sizeof (MotifWmHints));
+  if (*hints_p == NULL)
+    {
+      if (results->prop)
+        {
+          XFree (results->prop);
+          results->prop = NULL;
+        }
+      return FALSE;
+    }
+  real_size = results->n_items * sizeof (gulong);
+  max_size = MAX_ITEMS * sizeof (gulong);
+  memcpy (*hints_p, results->prop, MIN (real_size, max_size));
+
+  if (results->prop)
+    {
+      XFree (results->prop);
+      results->prop = NULL;
+    }
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_motif_hints (MetaDisplay   *display,
+                           Window         xwindow,
+                           Atom           xatom,
+                           MotifWmHints **hints_p)
+{
+  GetPropertyResults results;
+  
+  *hints_p = NULL;
+
+  if (!get_property (display, xwindow, xatom, AnyPropertyType,
+                     &results))
+    return FALSE;
+
+  return motif_hints_from_results (&results, hints_p);
+}
+
+static gboolean
+latin1_string_from_results (GetPropertyResults *results,
+                            char              **str_p)
+{
+  *str_p = NULL;
+  
+  if (!validate_or_free_results (results, 8, XA_STRING, FALSE))
+    return FALSE;
+
+  *str_p = (char*) results->prop;
+  results->prop = NULL;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_latin1_string (MetaDisplay *display,
+                             Window       xwindow,
+                             Atom         xatom,
+                             char       **str_p)
+{
+  GetPropertyResults results;
+
+  *str_p = NULL;
+
+  if (!get_property (display, xwindow, xatom, XA_STRING,
+                     &results))
+    return FALSE;
+  
+  return latin1_string_from_results (&results, str_p);
+}
+
+static gboolean
+utf8_string_from_results (GetPropertyResults *results,
+                          char              **str_p)
+{
+  *str_p = NULL;
+  
+  if (!validate_or_free_results (results, 8,
+                                 results->display->atom_UTF8_STRING, FALSE))
+    return FALSE;
+
+  if (results->n_items > 0 &&
+      !g_utf8_validate ((gchar *)results->prop, results->n_items, NULL))
+    {
+      char *name;
+
+      name = XGetAtomName (results->display->xdisplay, results->xatom);
+      meta_warning (_("Property %s on window 0x%lx contained invalid UTF-8\n"),
+                    name, results->xwindow);
+      meta_XFree (name);
+      XFree (results->prop);
+      results->prop = NULL;
+      
+      return FALSE;
+    }
+  
+  *str_p = (char*) results->prop;
+  results->prop = NULL;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_utf8_string (MetaDisplay *display,
+                           Window       xwindow,
+                           Atom         xatom,
+                           char       **str_p)
+{
+  GetPropertyResults results;
+
+  *str_p = NULL;
+
+  if (!get_property (display, xwindow, xatom,
+                     display->atom_UTF8_STRING,
+                     &results))
+    return FALSE;
+
+  return utf8_string_from_results (&results, str_p);
+}
+
+/* this one freakishly returns g_malloc memory */
+static gboolean
+utf8_list_from_results (GetPropertyResults *results,
+                        char             ***str_p,
+                        int                *n_str_p)
+{
+  int i;
+  int n_strings;
+  char **retval;
+  const char *p;
+  
+  *str_p = NULL;
+  *n_str_p = 0;
+
+  if (!validate_or_free_results (results, 8,
+                                 results->display->atom_UTF8_STRING, FALSE))
+    return FALSE;
+  
+  /* I'm not sure this is right, but I'm guessing the
+   * property is nul-separated
+   */
+  i = 0;
+  n_strings = 0;
+  while (i < (int) results->n_items)
+    {
+      if (results->prop[i] == '\0')
+        ++n_strings;
+      ++i;
+    }
+
+  if (results->prop[results->n_items - 1] != '\0')
+    ++n_strings;
+ 
+  /* we're guaranteed that results->prop has a nul on the end
+   * by XGetWindowProperty
+   */
+  
+  retval = g_new0 (char*, n_strings + 1);
+
+  p = (char *)results->prop;
+  i = 0;
+  while (i < n_strings)
+    {
+      if (!g_utf8_validate (p, -1, NULL))
+        {
+          char *name;
+
+          meta_error_trap_push (results->display);
+          name = XGetAtomName (results->display->xdisplay, results->xatom);
+          meta_error_trap_pop (results->display, TRUE);
+          meta_warning (_("Property %s on window 0x%lx contained invalid UTF-8 for item %d in the list\n"),
+                        name, results->xwindow, i);
+          meta_XFree (name);
+          meta_XFree (results->prop);
+          results->prop = NULL;
+          
+          g_strfreev (retval);
+          return FALSE;
+        }
+
+      retval[i] = g_strdup (p);
+      
+      p = p + strlen (p) + 1;
+      ++i;
+    }
+  
+  *str_p = retval;
+  *n_str_p = i;
+
+  meta_XFree (results->prop);
+  results->prop = NULL;
+
+  return TRUE;
+}
+
+/* returns g_malloc not Xmalloc memory */
+gboolean
+meta_prop_get_utf8_list (MetaDisplay   *display,
+                         Window         xwindow,
+                         Atom           xatom,
+                         char        ***str_p,
+                         int           *n_str_p)
+{
+  GetPropertyResults results;
+
+  *str_p = NULL;
+
+  if (!get_property (display, xwindow, xatom,
+                     display->atom_UTF8_STRING,
+                     &results))
+    return FALSE;
+
+  return utf8_list_from_results (&results, str_p, n_str_p);
+}
+
+void
+meta_prop_set_utf8_string_hint (MetaDisplay *display,
+                                Window xwindow,
+                                Atom atom,
+                                const char *val)
+{
+  meta_error_trap_push (display);
+  XChangeProperty (display->xdisplay, 
+                   xwindow, atom,
+                   display->atom_UTF8_STRING, 
+                   8, PropModeReplace, (guchar*) val, strlen (val));
+  meta_error_trap_pop (display, FALSE);
+}
+
+static gboolean
+window_from_results (GetPropertyResults *results,
+                     Window             *window_p)
+{
+  if (!validate_or_free_results (results, 32, XA_WINDOW, TRUE))
+    return FALSE;  
+
+  *window_p = *(Window*) results->prop;
+  XFree (results->prop);
+  results->prop = NULL;  
+  
+  return TRUE;
+}
+
+#ifdef HAVE_XSYNC
+static gboolean
+counter_from_results (GetPropertyResults *results,
+                      XSyncCounter       *counter_p)
+{
+  if (!validate_or_free_results (results, 32,
+                                 XA_CARDINAL,
+                                 TRUE))
+    return FALSE;  
+
+  *counter_p = *(XSyncCounter*) results->prop;
+  XFree (results->prop);
+  results->prop = NULL;
+  
+  return TRUE;
+}
+#endif
+
+gboolean
+meta_prop_get_window (MetaDisplay *display,
+                      Window       xwindow,
+                      Atom         xatom,
+                      Window      *window_p)
+{
+  GetPropertyResults results;
+
+  *window_p = None;
+  
+  if (!get_property (display, xwindow, xatom, XA_WINDOW,
+                     &results))
+    return FALSE;
+
+  return window_from_results (&results, window_p);
+}
+
+gboolean
+meta_prop_get_cardinal (MetaDisplay   *display,
+                        Window         xwindow,
+                        Atom           xatom,
+                        gulong        *cardinal_p)
+{
+  return meta_prop_get_cardinal_with_atom_type (display, xwindow, xatom,
+                                                XA_CARDINAL, cardinal_p);
+}
+
+static gboolean
+cardinal_with_atom_type_from_results (GetPropertyResults *results,
+                                      Atom                prop_type,
+                                      gulong             *cardinal_p)
+{
+  if (!validate_or_free_results (results, 32, prop_type, TRUE))
+    return FALSE;  
+
+  *cardinal_p = *(gulong*) results->prop;
+  XFree (results->prop);
+  results->prop = NULL;  
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_cardinal_with_atom_type (MetaDisplay   *display,
+                                       Window         xwindow,
+                                       Atom           xatom,
+                                       Atom           prop_type,
+                                       gulong        *cardinal_p)
+{
+  GetPropertyResults results;
+
+  *cardinal_p = 0;
+
+  if (!get_property (display, xwindow, xatom, prop_type,
+                     &results))
+    return FALSE;
+
+  return cardinal_with_atom_type_from_results (&results, prop_type, cardinal_p);
+}
+
+static gboolean
+text_property_from_results (GetPropertyResults *results,
+                            char              **utf8_str_p)
+{
+  XTextProperty tp;
+
+  *utf8_str_p = NULL;
+  
+  tp.value = results->prop;
+  results->prop = NULL;
+  tp.encoding = results->type;
+  tp.format = results->format;
+  tp.nitems = results->n_items;  
+  
+  *utf8_str_p = meta_text_property_to_utf8 (results->display->xdisplay,
+                                            &tp);
+  
+  if (tp.value != NULL)
+    XFree (tp.value);
+  
+  return *utf8_str_p != NULL;
+}
+
+gboolean
+meta_prop_get_text_property (MetaDisplay   *display,
+                             Window         xwindow,
+                             Atom           xatom,
+                             char         **utf8_str_p)
+{
+  GetPropertyResults results;
+  
+  if (!get_property (display, xwindow, xatom, AnyPropertyType,
+                     &results))
+    return FALSE;
+
+  return text_property_from_results (&results, utf8_str_p);
+}
+
+/* From Xmd.h */
+#ifndef cvtINT32toInt
+#if SIZEOF_VOID_P == 8
+#define cvtINT8toInt(val)   ((((unsigned int)val) & 0x00000080) ? (((unsigned int)val) | 0xffffffffffffff00) : ((unsigned int)val))
+#define cvtINT16toInt(val)  ((((unsigned int)val) & 0x00008000) ? (((unsigned int)val) | 0xffffffffffff0000) : ((unsigned int)val))
+#define cvtINT32toInt(val)  ((((unsigned int)val) & 0x80000000) ? (((unsigned int)val) | 0xffffffff00000000) : ((unsigned int)val))
+#define cvtINT8toShort(val)  cvtINT8toInt(val)
+#define cvtINT16toShort(val) cvtINT16toInt(val)
+#define cvtINT32toShort(val) cvtINT32toInt(val)
+#define cvtINT8toLong(val)  cvtINT8toInt(val)
+#define cvtINT16toLong(val) cvtINT16toInt(val)
+#define cvtINT32toLong(val) cvtINT32toInt(val)
+#else
+#define cvtINT8toInt(val) (val)
+#define cvtINT16toInt(val) (val)
+#define cvtINT32toInt(val) (val)
+#define cvtINT8toShort(val) (val)
+#define cvtINT16toShort(val) (val)
+#define cvtINT32toShort(val) (val)
+#define cvtINT8toLong(val) (val)
+#define cvtINT16toLong(val) (val)
+#define cvtINT32toLong(val) (val)
+#endif /* SIZEOF_VOID_P == 8 */
+#endif /* cvtINT32toInt() */
+
+static gboolean
+wm_hints_from_results (GetPropertyResults *results,
+                       XWMHints          **hints_p)
+{
+  XWMHints *hints;
+  xPropWMHints *raw;
+  
+  *hints_p = NULL;
+  
+  if (!validate_or_free_results (results, 32, XA_WM_HINTS, TRUE))
+    return FALSE;  
+
+  /* pre-R3 bogusly truncated window_group, don't fail on them */  
+  if (results->n_items < (NumPropWMHintsElements - 1))
+    {
+      meta_verbose ("WM_HINTS property too short: %d should be %d\n",
+                    (int) results->n_items, NumPropWMHintsElements - 1);
+      if (results->prop)
+        {
+          XFree (results->prop);
+          results->prop = NULL;
+        }
+      return FALSE;
+    }
+  
+  hints = ag_Xmalloc0 (sizeof (XWMHints));
+
+  raw = (xPropWMHints*) results->prop;
+  
+  hints->flags = raw->flags;
+  hints->input = (raw->input ? True : False);
+  hints->initial_state = cvtINT32toInt (raw->initialState);
+  hints->icon_pixmap = raw->iconPixmap;
+  hints->icon_window = raw->iconWindow;
+  hints->icon_x = cvtINT32toInt (raw->iconX);
+  hints->icon_y = cvtINT32toInt (raw->iconY);
+  hints->icon_mask = raw->iconMask;
+  if (results->n_items >= NumPropWMHintsElements)
+    hints->window_group = raw->windowGroup;
+  else
+    hints->window_group = 0;
+
+  if (results->prop)
+    {
+      XFree (results->prop);
+      results->prop = NULL;
+    }
+
+  *hints_p = hints;
+
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_wm_hints (MetaDisplay   *display,
+                        Window         xwindow,
+                        Atom           xatom,
+                        XWMHints     **hints_p)
+{
+  GetPropertyResults results;
+
+  *hints_p = NULL;
+  
+  if (!get_property (display, xwindow, xatom, XA_WM_HINTS,
+                     &results))
+    return FALSE;
+
+  return wm_hints_from_results (&results, hints_p);
+}
+
+static gboolean
+class_hint_from_results (GetPropertyResults *results,
+                         XClassHint         *class_hint)
+{
+  int len_name, len_class;
+  
+  class_hint->res_class = NULL;
+  class_hint->res_name = NULL;
+  
+  if (!validate_or_free_results (results, 8, XA_STRING, FALSE))
+    return FALSE;
+  
+  len_name = strlen ((char *) results->prop);
+  if (! (class_hint->res_name = ag_Xmalloc (len_name+1)))
+    {
+      XFree (results->prop);
+      results->prop = NULL;
+      return FALSE;
+    }
+  
+  strcpy (class_hint->res_name, (char *)results->prop);
+
+  if (len_name == (int) results->n_items)
+    len_name--;
+  
+  len_class = strlen ((char *)results->prop + len_name + 1);
+  
+  if (! (class_hint->res_class = ag_Xmalloc(len_class+1)))
+    {
+      XFree(class_hint->res_name);
+      class_hint->res_name = NULL;
+      XFree (results->prop);
+      results->prop = NULL;
+      return FALSE;
+    }
+  
+  strcpy (class_hint->res_class, (char *)results->prop + len_name + 1);
+
+  XFree (results->prop);
+  results->prop = NULL;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_class_hint (MetaDisplay   *display,
+                          Window         xwindow,
+                          Atom           xatom,
+                          XClassHint    *class_hint)
+{
+  GetPropertyResults results;
+  
+  class_hint->res_class = NULL;
+  class_hint->res_name = NULL;
+  
+  if (!get_property (display, xwindow, xatom, XA_STRING,
+                     &results))
+    return FALSE;
+
+  return class_hint_from_results (&results, class_hint);
+}
+
+static gboolean
+size_hints_from_results (GetPropertyResults *results,
+                         XSizeHints        **hints_p,
+                         gulong             *flags_p)
+{
+  xPropSizeHints *raw;
+  XSizeHints *hints;
+  
+  *hints_p = NULL;
+  *flags_p = 0;
+  
+  if (!validate_or_free_results (results, 32, XA_WM_SIZE_HINTS, FALSE))
+    return FALSE;
+
+  if (results->n_items < OldNumPropSizeElements)
+    return FALSE;
+
+  raw = (xPropSizeHints*) results->prop;
+
+  hints = ag_Xmalloc (sizeof (XSizeHints));
+  
+  /* XSizeHints misdeclares these as int instead of long */
+  hints->flags = raw->flags;
+  hints->x = cvtINT32toInt (raw->x);
+  hints->y = cvtINT32toInt (raw->y);
+  hints->width = cvtINT32toInt (raw->width);
+  hints->height = cvtINT32toInt (raw->height);
+  hints->min_width  = cvtINT32toInt (raw->minWidth);
+  hints->min_height = cvtINT32toInt (raw->minHeight);
+  hints->max_width  = cvtINT32toInt (raw->maxWidth);
+  hints->max_height = cvtINT32toInt (raw->maxHeight);
+  hints->width_inc  = cvtINT32toInt (raw->widthInc);
+  hints->height_inc = cvtINT32toInt (raw->heightInc);
+  hints->min_aspect.x = cvtINT32toInt (raw->minAspectX);
+  hints->min_aspect.y = cvtINT32toInt (raw->minAspectY);
+  hints->max_aspect.x = cvtINT32toInt (raw->maxAspectX);
+  hints->max_aspect.y = cvtINT32toInt (raw->maxAspectY);
+
+  *flags_p = (USPosition | USSize | PAllHints);
+  if (results->n_items >= NumPropSizeElements)
+    {
+      hints->base_width= cvtINT32toInt (raw->baseWidth);
+      hints->base_height= cvtINT32toInt (raw->baseHeight);
+      hints->win_gravity= cvtINT32toInt (raw->winGravity);
+      *flags_p |= (PBaseSize | PWinGravity);
+    }
+
+  hints->flags &= (*flags_p);	/* get rid of unwanted bits */
+  
+  XFree (results->prop);
+  results->prop = NULL;
+
+  *hints_p = hints;
+  
+  return TRUE;
+}
+
+gboolean
+meta_prop_get_size_hints (MetaDisplay   *display,
+                          Window         xwindow,
+                          Atom           xatom,
+                          XSizeHints   **hints_p,
+                          gulong        *flags_p)
+{
+  GetPropertyResults results;
+
+  *hints_p = NULL;
+  *flags_p = 0;
+  
+  if (!get_property (display, xwindow, xatom, XA_WM_SIZE_HINTS,
+                     &results))
+    return FALSE;
+
+  return size_hints_from_results (&results, hints_p, flags_p);
+}
+
+static AgGetPropertyTask*
+get_task (MetaDisplay        *display,
+          Window              xwindow,
+          Atom                xatom,
+          Atom                req_type)
+{
+  return ag_task_create (display->xdisplay,
+                         xwindow,
+                         xatom, 0, G_MAXLONG,
+                         False, req_type);
+}
+
+static char*
+latin1_to_utf8 (const char *text)
+{
+  GString *str;
+  const char *p;
+  
+  str = g_string_new ("");
+
+  p = text;
+  while (*p)
+    {
+      g_string_append_unichar (str, *p);
+      ++p;
+    }
+
+  return g_string_free (str, FALSE);
+}
+
+void
+meta_prop_get_values (MetaDisplay   *display,
+                      Window         xwindow,
+                      MetaPropValue *values,
+                      int            n_values)
+{
+  int i;
+  AgGetPropertyTask **tasks;
+
+  meta_verbose ("Requesting %d properties of 0x%lx at once\n",
+                n_values, xwindow);
+  
+  if (n_values == 0)
+    return;
+  
+  tasks = g_new0 (AgGetPropertyTask*, n_values);
+
+  /* Start up tasks. The "values" array can have values
+   * with atom == None, which means to ignore that element.
+   */
+  i = 0;
+  while (i < n_values)
+    {
+      if (values[i].required_type == None)
+        {
+          switch (values[i].type)
+            {
+            case META_PROP_VALUE_INVALID:
+              /* This means we don't really want a value, e.g. got
+               * property notify on an atom we don't care about.
+               */
+              if (values[i].atom != None)
+                meta_bug ("META_PROP_VALUE_INVALID requested in %s\n", G_STRFUNC);
+              break;
+            case META_PROP_VALUE_UTF8_LIST:
+            case META_PROP_VALUE_UTF8:
+              values[i].required_type = display->atom_UTF8_STRING;
+              break;
+            case META_PROP_VALUE_STRING:
+            case META_PROP_VALUE_STRING_AS_UTF8:
+              values[i].required_type = XA_STRING;
+              break;
+            case META_PROP_VALUE_MOTIF_HINTS:
+              values[i].required_type = AnyPropertyType;
+              break;
+            case META_PROP_VALUE_CARDINAL_LIST:
+            case META_PROP_VALUE_CARDINAL:
+              values[i].required_type = XA_CARDINAL;
+              break;
+            case META_PROP_VALUE_WINDOW:
+              values[i].required_type = XA_WINDOW;
+              break;
+            case META_PROP_VALUE_ATOM_LIST:
+              values[i].required_type = XA_ATOM;
+              break;
+            case META_PROP_VALUE_TEXT_PROPERTY:
+              values[i].required_type = AnyPropertyType;
+              break;
+            case META_PROP_VALUE_WM_HINTS:
+              values[i].required_type = XA_WM_HINTS;
+              break;
+            case META_PROP_VALUE_CLASS_HINT:
+              values[i].required_type = XA_STRING;
+              break;
+            case META_PROP_VALUE_SIZE_HINTS:
+              values[i].required_type = XA_WM_SIZE_HINTS;
+              break;
+            case META_PROP_VALUE_SYNC_COUNTER:
+	      values[i].required_type = XA_CARDINAL;
+              break;
+            }
+        }
+
+      if (values[i].atom != None)
+        tasks[i] = get_task (display, xwindow,
+                             values[i].atom, values[i].required_type);
+      
+      ++i;
+    }  
+  
+  /* Get replies for all our tasks */
+  meta_topic (META_DEBUG_SYNC, "Syncing to get %d GetProperty replies in %s\n",
+              n_values, G_STRFUNC);
+  XSync (display->xdisplay, False);
+  
+  /* Collect results, should arrive in order requested */
+  i = 0;
+  while (i < n_values)
+    {
+      AgGetPropertyTask *task;
+      GetPropertyResults results;
+      
+      if (tasks[i] == NULL)
+        {
+          /* Probably values[i].type was None, or ag_task_create()
+           * returned NULL.
+           */
+          values[i].type = META_PROP_VALUE_INVALID;
+          goto next;
+        }
+      
+      task = ag_get_next_completed_task (display->xdisplay);
+      g_assert (task != NULL);
+      g_assert (ag_task_have_reply (task));
+
+      results.display = display;
+      results.xwindow = xwindow;
+      results.xatom = values[i].atom;
+      results.prop = NULL;
+      results.n_items = 0;
+      results.type = None;
+      results.bytes_after = 0;
+      results.format = 0;
+      
+      if (ag_task_get_reply_and_free (task,
+                                      &results.type, &results.format,
+                                      &results.n_items,
+                                      &results.bytes_after,
+                                      &results.prop) != Success ||
+          results.type == None)
+        {
+          values[i].type = META_PROP_VALUE_INVALID;
+          if (results.prop)
+            {
+              XFree (results.prop);
+              results.prop = NULL;
+            }
+          goto next;
+        }
+
+      switch (values[i].type)
+        {
+        case META_PROP_VALUE_INVALID:
+          g_assert_not_reached ();
+          break;
+        case META_PROP_VALUE_UTF8_LIST:
+          if (!utf8_list_from_results (&results,
+                                       &values[i].v.string_list.strings,
+                                       &values[i].v.string_list.n_strings))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_UTF8:
+          if (!utf8_string_from_results (&results,
+                                         &values[i].v.str))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_STRING:
+          if (!latin1_string_from_results (&results,
+                                           &values[i].v.str))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_STRING_AS_UTF8:
+          if (!latin1_string_from_results (&results,
+                                           &values[i].v.str))
+            values[i].type = META_PROP_VALUE_INVALID;
+          else
+            {
+              char *new_str;
+              char *xmalloc_new_str;
+
+              new_str = latin1_to_utf8 (values[i].v.str);
+              xmalloc_new_str = ag_Xmalloc (strlen (new_str) + 1);
+              if (xmalloc_new_str != NULL)
+                {
+                  strcpy (xmalloc_new_str, new_str);
+                  meta_XFree (values[i].v.str);
+                  values[i].v.str = xmalloc_new_str;
+                }
+
+              g_free (new_str);
+            }
+          break;
+        case META_PROP_VALUE_MOTIF_HINTS:
+          if (!motif_hints_from_results (&results,
+                                         &values[i].v.motif_hints))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_CARDINAL_LIST:
+          if (!cardinal_list_from_results (&results,
+                                           &values[i].v.cardinal_list.cardinals,
+                                           &values[i].v.cardinal_list.n_cardinals))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_CARDINAL:
+          if (!cardinal_with_atom_type_from_results (&results,
+                                                     values[i].required_type,
+                                                     &values[i].v.cardinal))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_WINDOW:
+          if (!window_from_results (&results,
+                                    &values[i].v.xwindow))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_ATOM_LIST:
+          if (!atom_list_from_results (&results,
+                                       &values[i].v.atom_list.atoms,
+                                       &values[i].v.atom_list.n_atoms))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_TEXT_PROPERTY:
+          if (!text_property_from_results (&results, &values[i].v.str))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_WM_HINTS:
+          if (!wm_hints_from_results (&results, &values[i].v.wm_hints))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_CLASS_HINT:
+          if (!class_hint_from_results (&results, &values[i].v.class_hint))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_SIZE_HINTS:
+          if (!size_hints_from_results (&results,
+                                        &values[i].v.size_hints.hints,
+                                        &values[i].v.size_hints.flags))
+            values[i].type = META_PROP_VALUE_INVALID;
+          break;
+        case META_PROP_VALUE_SYNC_COUNTER:
+#ifdef HAVE_XSYNC
+          if (!counter_from_results (&results,
+                                     &values[i].v.xcounter))
+            values[i].type = META_PROP_VALUE_INVALID;
+#else
+          values[i].type = META_PROP_VALUE_INVALID;
+          if (results.prop)
+            {
+              XFree (results.prop);
+              results.prop = NULL;
+            }
+#endif
+          break;
+        }
+
+    next:
+      ++i;
+    }
+
+  g_free (tasks);
+}
+
+static void
+free_value (MetaPropValue *value)
+{
+  switch (value->type)
+    {
+    case META_PROP_VALUE_INVALID:          
+      break;
+    case META_PROP_VALUE_UTF8:
+    case META_PROP_VALUE_STRING:
+    case META_PROP_VALUE_STRING_AS_UTF8:
+      meta_XFree (value->v.str);
+      break;
+    case META_PROP_VALUE_MOTIF_HINTS:
+      meta_XFree (value->v.motif_hints);
+      break;          
+    case META_PROP_VALUE_CARDINAL:
+      break;
+    case META_PROP_VALUE_WINDOW:          
+      break;
+    case META_PROP_VALUE_ATOM_LIST:
+      meta_XFree (value->v.atom_list.atoms);
+      break;
+    case META_PROP_VALUE_TEXT_PROPERTY:
+      meta_XFree (value->v.str);
+      break;
+    case META_PROP_VALUE_WM_HINTS:
+      meta_XFree (value->v.wm_hints);
+      break;
+    case META_PROP_VALUE_CLASS_HINT:
+      meta_XFree (value->v.class_hint.res_class);
+      meta_XFree (value->v.class_hint.res_name);
+      break;
+    case META_PROP_VALUE_SIZE_HINTS:
+      meta_XFree (value->v.size_hints.hints);
+      break;
+    case META_PROP_VALUE_UTF8_LIST:
+      g_strfreev (value->v.string_list.strings);
+      break;
+    case META_PROP_VALUE_CARDINAL_LIST:
+      meta_XFree (value->v.cardinal_list.cardinals);
+      break;
+    case META_PROP_VALUE_SYNC_COUNTER:
+      break;
+    }
+}
+
+void
+meta_prop_free_values (MetaPropValue *values,
+                       int            n_values)
+{
+  int i;
+
+  i = 0;
+  while (i < n_values)
+    {
+      free_value (&values[i]);
+      ++i;
+    }
+
+  /* Zero the whole thing to quickly detect breakage */
+  memset (values, '\0', sizeof (MetaPropValue) * n_values);
+}