Add patch to clean up some uses of CurrentTime

2 files changed, 914 insertions, 3 deletions

diff --git a/metacity-2.16.0-currenttime-fixes.patch b/metacity-2.16.0-currenttime-fixes.patch
new file mode 100644
index 0000000..8b35cac
--- /dev/null
+++ b/metacity-2.16.0-currenttime-fixes.patch
@@ -0,0 +1,905 @@
+--- metacity-2.16.0/src/display.h.currenttime-fixes	2006-08-27 17:49:39.000000000 -0400
++++ metacity-2.16.0/src/display.h	2006-09-21 14:48:00.000000000 -0400
+@@ -388,7 +388,8 @@
+   )
+ 
+ gboolean      meta_display_open                (void);
+-void          meta_display_close               (MetaDisplay *display);
++void          meta_display_close               (MetaDisplay *display,
++                                                guint32      timestamp);
+ MetaScreen*   meta_display_screen_for_root     (MetaDisplay *display,
+                                                 Window       xroot);
+ MetaScreen*   meta_display_screen_for_x_screen (MetaDisplay *display,
+@@ -399,10 +400,12 @@
+ void          meta_display_ungrab              (MetaDisplay *display);
+ 
+ void          meta_display_unmanage_screen     (MetaDisplay *display,
+-                                                MetaScreen  *screen);
++                                                MetaScreen  *screen,
++                                                guint32      timestamp);
+ 
+ void          meta_display_unmanage_windows_for_screen (MetaDisplay *display,
+-                                                        MetaScreen  *screen);
++                                                        MetaScreen  *screen,
++                                                        guint32      timestamp);
+ 
+ /* A given MetaWindow may have various X windows that "belong"
+  * to it, such as the frame window.
+--- metacity-2.16.0/src/frames.c.currenttime-fixes	2006-08-27 17:49:41.000000000 -0400
++++ metacity-2.16.0/src/frames.c	2006-09-21 14:48:00.000000000 -0400
+@@ -1254,10 +1254,12 @@
+               {
+                 if (flags & META_FRAME_SHADED)
+                   meta_core_unshade (gdk_display,
+-                                     frame->xwindow);
++                                     frame->xwindow,
++                                     event->time);
+                 else
+                   meta_core_shade (gdk_display,
+-                                   frame->xwindow);
++                                   frame->xwindow,
++                                   event->time);
+               }
+           }
+           break;          
+--- metacity-2.16.0/src/screen.h.currenttime-fixes	2006-08-27 17:49:46.000000000 -0400
++++ metacity-2.16.0/src/screen.h	2006-09-21 14:51:55.000000000 -0400
+@@ -123,7 +123,8 @@
+ MetaScreen*   meta_screen_new                 (MetaDisplay                *display,
+                                                int                         number,
+                                                Time                        timestamp);
+-void          meta_screen_free                (MetaScreen                 *screen);
++void          meta_screen_free                (MetaScreen                 *screen,
++					       guint32			   timestamp);
+ void          meta_screen_manage_all_windows  (MetaScreen                 *screen);
+ MetaScreen*   meta_screen_for_x_screen        (Screen                     *xscreen);
+ void          meta_screen_foreach_window      (MetaScreen                 *screen,
+--- metacity-2.16.0/src/window.c.currenttime-fixes	2006-08-28 18:05:39.000000000 -0400
++++ metacity-2.16.0/src/window.c	2006-09-21 14:48:00.000000000 -0400
+@@ -910,7 +910,8 @@
+ }
+ 
+ void
+-meta_window_free (MetaWindow  *window)
++meta_window_free (MetaWindow  *window,
++                  guint32      timestamp)
+ {
+   GList *tmp;
+   
+@@ -963,7 +964,9 @@
+       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, meta_display_get_current_time_roundtrip (window->display));
++      meta_workspace_focus_default_window (window->screen->active_workspace,
++                                           window,
++                                           timestamp);
+     }
+   else if (window->display->expected_focus_window == window)
+     {
+@@ -971,7 +974,9 @@
+                   "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, meta_display_get_current_time_roundtrip (window->display));
++      meta_workspace_focus_default_window (window->screen->active_workspace,
++                                           window,
++                                           timestamp);
+     }
+   else
+     {
+@@ -992,8 +997,7 @@
+     }
+   
+   if (window->display->grab_window == window)
+-    meta_display_end_grab_op (window->display,
+-                              meta_display_get_current_time (window->display));
++    meta_display_end_grab_op (window->display, timestamp);
+ 
+   g_assert (window->display->grab_window != window);
+   
+@@ -1338,14 +1342,20 @@
+ 		 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,
+-	 meta_display_get_current_time_roundtrip (window->display));
++      meta_workspace_focus_default_window (window->screen->active_workspace,
++                                           window, 
++                                           timestamp);
+     }
+ }
+ 
+@@ -1373,11 +1383,11 @@
+       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);
++          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)
+             {
+@@ -1392,16 +1402,16 @@
+ 
+           meta_window_get_outer_rect (window, &window_rect);
+ 
+-	  meta_effect_run_minimize (window,
+-				    &window_rect,
+-				    &icon_rect,
+-				    finish_minimize,
+-				    window);
+-	}
++          meta_effect_run_minimize (window,
++                                    &window_rect,
++                                    &icon_rect,
++                                    finish_minimize,
++                                    window);
++        }
+       else
+-	{
+-	  finish_minimize (NULL, window);
+-	}
++        {
++          finish_minimize (NULL, window);
++        }
+     }
+   else
+     {
+@@ -1851,6 +1861,13 @@
+   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",
+@@ -1884,7 +1901,9 @@
+                       "ancestor.\n",
+                       focus_window->desc, window->desc);
+ 
+-          meta_display_focus_the_no_focus_window (window->display, window->screen, meta_display_get_current_time_roundtrip (window->display));
++          meta_display_focus_the_no_focus_window (window->display,
++                                                  window->screen,
++                                                  timestamp);
+         }
+       else
+         {
+@@ -2000,8 +2019,7 @@
+       window->showing_for_first_time = FALSE;
+       if (takes_focus_on_map)
+         {                
+-          meta_window_focus (window,
+-                             meta_display_get_current_time_roundtrip (window->display));
++          meta_window_focus (window, timestamp);
+         }
+       else
+         {
+@@ -2251,7 +2269,14 @@
+       (maximize_vertically   && !window->maximized_vertically))
+     {
+       if (window->shaded && maximize_vertically)
+-        meta_window_unshade (window);
++        {
++          /* 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
+        */
+@@ -2374,7 +2399,14 @@
+                   "Fullscreening %s\n", window->desc);
+ 
+       if (window->shaded)
+-        meta_window_unshade (window);
++        {
++          /* 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);
+       
+@@ -2428,7 +2460,8 @@
+ }
+ 
+ void
+-meta_window_shade (MetaWindow  *window)
++meta_window_shade (MetaWindow  *window,
++                   guint32      timestamp)
+ {
+   meta_topic (META_DEBUG_WINDOW_OPS,
+               "Shading %s\n", window->desc);
+@@ -2469,15 +2502,15 @@
+       meta_topic (META_DEBUG_FOCUS,
+                   "Re-focusing window %s after shading it\n",
+                   window->desc);
+-      meta_window_focus (window,
+-                         meta_display_get_current_time_roundtrip (window->display));
++      meta_window_focus (window, timestamp);
+       
+       set_net_wm_state (window);
+     }
+ }
+ 
+ void
+-meta_window_unshade (MetaWindow  *window)
++meta_window_unshade (MetaWindow  *window,
++                     guint32      timestamp)
+ {
+   meta_topic (META_DEBUG_WINDOW_OPS,
+               "Unshading %s\n", window->desc);
+@@ -2491,8 +2524,7 @@
+       meta_topic (META_DEBUG_FOCUS,
+                   "Focusing window %s after unshading it\n",
+                   window->desc);
+-      meta_window_focus (window,
+-                         meta_display_get_current_time_roundtrip (window->display));
++      meta_window_focus (window, timestamp);
+ 
+       set_net_wm_state (window);
+     }
+@@ -2546,11 +2578,12 @@
+     }
+ 
+   /* 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);
+-  }
++  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);
+ 
+@@ -2564,7 +2597,7 @@
+     meta_window_change_workspace (window, workspace);
+   
+   if (window->shaded)
+-    meta_window_unshade (window);
++    meta_window_unshade (window, timestamp);
+ 
+   unminimize_window_and_all_transient_parents (window);
+ 
+@@ -2762,6 +2795,11 @@
+   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);
+@@ -4416,7 +4454,13 @@
+       if (event->xclient.data.l[0] != 0)
+ 	timestamp = event->xclient.data.l[0];
+       else
+-	timestamp = meta_display_get_current_time (window->display);
++        {
++          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);
+ 
+@@ -4496,13 +4540,20 @@
+           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);
++            meta_window_shade (window, timestamp);
+           else
+-            meta_window_unshade (window);
++            meta_window_unshade (window, timestamp);
+         }
+ 
+       if (first == display->atom_net_wm_state_fullscreen ||
+@@ -4648,12 +4699,18 @@
+       int action;
+       MetaGrabOp op;
+       int button;
++      guint32 timestamp;
+       
+       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,
+@@ -4703,10 +4760,7 @@
+           ((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,
+-                                     meta_display_get_current_time (window->display));
++          meta_window_begin_grab_op (window, op, timestamp);
+         }
+       else if (op != META_GRAB_OP_NONE &&
+                ((window->has_move_func && op == META_GRAB_OP_MOVING) ||
+@@ -4756,7 +4810,7 @@
+                                           op,
+                                           FALSE, 0 /* event_serial */,
+                                           button, 0,
+-                                          meta_display_get_current_time (window->display),
++                                          timestamp,
+                                           x_root,
+                                           y_root);
+             }
+@@ -4780,8 +4834,13 @@
+         source_indication = META_CLIENT_TYPE_UNKNOWN;
+ 
+       if (timestamp == 0)
+-        /* Client using older EWMH _NET_ACTIVE_WINDOW without a timestamp */
+-        timestamp = meta_display_get_current_time (window->display);
++        {
++          /* 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;
+@@ -6085,11 +6144,11 @@
+           break;
+ 
+         case META_MENU_OP_UNSHADE:
+-          meta_window_unshade (window);
++          meta_window_unshade (window, timestamp);
+           break;
+       
+         case META_MENU_OP_SHADE:
+-          meta_window_shade (window);
++          meta_window_shade (window, timestamp);
+           break;
+       
+         case META_MENU_OP_MOVE_LEFT:
+@@ -6136,13 +6195,13 @@
+         case META_MENU_OP_MOVE:
+           meta_window_begin_grab_op (window,
+                                      META_GRAB_OP_KEYBOARD_MOVING,
+-                                     meta_display_get_current_time (window->display));
++                                     timestamp);
+           break;
+ 
+         case META_MENU_OP_RESIZE:
+           meta_window_begin_grab_op (window,
+                                      META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN,
+-                                     meta_display_get_current_time (window->display));
++                                     timestamp);
+           break;
+ 
+         case META_MENU_OP_RECOVER:
+@@ -6694,7 +6753,7 @@
+ update_resize (MetaWindow *window,
+                gboolean    snap,
+                int x, int y,
+-	       gboolean force)
++               gboolean force)
+ {
+   int dx, dy;
+   int new_w, new_h;
+@@ -7037,7 +7096,7 @@
+                          window->display->grab_last_user_action_was_snap,
+                          window->display->grab_latest_motion_x,
+                          window->display->grab_latest_motion_y,
+-			 TRUE);
++                         TRUE);
+           break;
+           
+         default:
+@@ -7587,12 +7646,15 @@
+ 
+   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,
+-                                       meta_display_get_current_time (window->display));
++                                       timestamp);
+     }
+ }
+ 
+--- metacity-2.16.0/src/core.c.currenttime-fixes	2006-08-27 17:49:38.000000000 -0400
++++ metacity-2.16.0/src/core.c	2006-09-21 14:48:00.000000000 -0400
+@@ -339,20 +339,22 @@
+ 
+ void
+ meta_core_unshade (Display *xdisplay,
+-                   Window   frame_xwindow)
++                   Window   frame_xwindow,
++                   guint32  timestamp)
+ {
+   MetaWindow *window = get_window (xdisplay, frame_xwindow);
+ 
+-  meta_window_unshade (window);
++  meta_window_unshade (window, timestamp);
+ }
+ 
+ void
+ meta_core_shade (Display *xdisplay,
+-                 Window   frame_xwindow)
++                 Window   frame_xwindow,
++                 guint32  timestamp)
+ {
+   MetaWindow *window = get_window (xdisplay, frame_xwindow);
+   
+-  meta_window_shade (window);
++  meta_window_shade (window, timestamp);
+ }
+ 
+ void
+--- metacity-2.16.0/src/window.h.currenttime-fixes	2006-08-27 17:49:56.000000000 -0400
++++ metacity-2.16.0/src/window.h	2006-09-21 14:48:00.000000000 -0400
+@@ -381,7 +381,8 @@
+                                             Window       xwindow,
+                                             gboolean     must_be_viewable,
+                                             XWindowAttributes *attrs);
+-void        meta_window_free               (MetaWindow  *window);
++void        meta_window_free               (MetaWindow  *window,
++                                            guint32      timestamp);
+ void        meta_window_calc_showing       (MetaWindow  *window);
+ void        meta_window_queue_calc_showing (MetaWindow  *window);
+ void        meta_window_minimize           (MetaWindow  *window);
+@@ -395,8 +396,10 @@
+                                             MetaMaximizeFlags  directions);
+ void        meta_window_make_above         (MetaWindow  *window);
+ void        meta_window_unmake_above       (MetaWindow  *window);
+-void        meta_window_shade              (MetaWindow  *window);
+-void        meta_window_unshade            (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);
+--- metacity-2.16.0/src/core.h.currenttime-fixes	2006-08-27 17:49:38.000000000 -0400
++++ metacity-2.16.0/src/core.h	2006-09-21 14:48:00.000000000 -0400
+@@ -95,9 +95,11 @@
+                                  Window   frame_xwindow,
+                                  guint32  timestamp);
+ void meta_core_unshade          (Display *xdisplay,
+-                                 Window   frame_xwindow);
++                                 Window   frame_xwindow,
++                                 guint32  timestamp);
+ void meta_core_shade            (Display *xdisplay,
+-                                 Window   frame_xwindow);
++                                 Window   frame_xwindow,
++                                 guint32  timestamp);
+ void meta_core_unstick          (Display *xdisplay,
+                                  Window   frame_xwindow);
+ void meta_core_stick            (Display *xdisplay,
+--- metacity-2.16.0/src/keybindings.c.currenttime-fixes	2006-09-21 14:48:00.000000000 -0400
++++ metacity-2.16.0/src/keybindings.c	2006-09-21 14:48:00.000000000 -0400
+@@ -3300,9 +3300,9 @@
+   if (window)
+     {
+       if (window->shaded)
+-        meta_window_unshade (window);
++        meta_window_unshade (window, event->xkey.time);
+       else if (window->has_shade_func)
+-        meta_window_shade (window);
++        meta_window_shade (window, event->xkey.time);
+     }
+ }
+ 
+--- metacity-2.16.0/src/main.c.currenttime-fixes	2006-08-27 17:49:43.000000000 -0400
++++ metacity-2.16.0/src/main.c	2006-09-21 14:48:00.000000000 -0400
+@@ -399,7 +399,9 @@
+     tmp = displays;
+     while (tmp != NULL)
+       {
+-        meta_display_close (tmp->data);
++        guint32 timestamp;
++        timestamp = CurrentTime; /* I doubt correct timestamps matter here */
++        meta_display_close (tmp->data, timestamp);
+         tmp = tmp->next;
+       }
+     g_slist_free (displays);
+--- metacity-2.16.0/src/display.c.currenttime-fixes	2006-09-21 14:48:00.000000000 -0400
++++ metacity-2.16.0/src/display.c	2006-09-21 14:48:00.000000000 -0400
+@@ -705,7 +705,7 @@
+       /* This would typically happen because all the screens already
+        * have window managers.
+        */
+-      meta_display_close (display);
++      meta_display_close (display, timestamp);
+       return FALSE;
+     }
+  
+@@ -840,7 +840,8 @@
+ }
+ 
+ void
+-meta_display_close (MetaDisplay *display)
++meta_display_close (MetaDisplay *display,
++                    guint32      timestamp)
+ {
+   GSList *tmp;
+ 
+@@ -866,7 +867,7 @@
+   while (tmp != NULL)
+     {
+       MetaScreen *screen = tmp->data;
+-      meta_screen_free (screen);
++      meta_screen_free (screen, timestamp);
+       tmp = tmp->next;
+     }
+ 
+@@ -1998,9 +1999,16 @@
+     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, CurrentTime);
++            meta_display_end_grab_op (display, timestamp);
+           
+           if (frame_was_receiver)
+             {
+@@ -2012,7 +2020,8 @@
+             }
+           else
+             {
+-              meta_window_free (window); /* Unmanage destroyed window */
++              /* Unmanage destroyed window */
++              meta_window_free (window, timestamp);
+               window = NULL;
+             }
+         }
+@@ -2020,10 +2029,17 @@
+     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, CurrentTime);      
++            meta_display_end_grab_op (display, timestamp);
+       
+           if (!frame_was_receiver)
+             {
+@@ -2033,10 +2049,11 @@
+                               "Window %s withdrawn\n",
+                               window->desc);
+ 
+-		  meta_effect_run_close (window, NULL, NULL);
+-		  
++                  meta_effect_run_close (window, NULL, NULL);
++
++                  /* Unmanage withdrawn window */		  
+                   window->withdrawn = TRUE;
+-                  meta_window_free (window); /* Unmanage withdrawn window */
++                  meta_window_free (window, timestamp);
+                   window = NULL;
+                 }
+               else
+@@ -2204,7 +2221,12 @@
+       /* 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.
+@@ -2254,7 +2276,12 @@
+ 
+                   /* Handle clients using the older version of the spec... */
+                   if (time == 0 && workspace)
+-                    time = meta_display_get_current_time_roundtrip (display);
++                    {
++                      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);
+@@ -2273,22 +2300,26 @@
+ 
+                   meta_prefs_set_num_workspaces (num_spaces);
+                 }
+-	      else if (event->xclient.message_type ==
+-		       display->atom_net_showing_desktop)
+-		{
+-		  gboolean showing_desktop;
++              else if (event->xclient.message_type ==
++                       display->atom_net_showing_desktop)
++                {
++                  gboolean showing_desktop;
++                  guint32  timestamp;
+                   
+-		  showing_desktop = event->xclient.data.l[0] != 0;
+-		  meta_verbose ("Request to %s desktop\n", showing_desktop ? "show" : "hide");
++                  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, meta_display_get_current_time_roundtrip (display));
+-		  else
+-		    {
+-		      meta_screen_unshow_desktop (screen);
+-		      meta_workspace_focus_default_window (screen->active_workspace, NULL, meta_display_get_current_time_roundtrip (display));
+-		    }
+-		}
++                  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_metacity_restart_message)
+                 {
+@@ -3329,8 +3360,8 @@
+         {
+           meta_topic (META_DEBUG_WINDOW_OPS,
+                       "grabbing all keys failed, ungrabbing pointer\n");
+-          XUngrabPointer (display->xdisplay, CurrentTime);
+-	  display->grab_have_pointer = FALSE;
++          XUngrabPointer (display->xdisplay, timestamp);
++          display->grab_have_pointer = FALSE;
+           return FALSE;
+         }
+     }
+@@ -4674,7 +4705,9 @@
+       meta_verbose ("Got selection clear for screen %d on display %s\n",
+                     screen->number, display->name);
+       
+-      meta_display_unmanage_screen (display, screen);
++      meta_display_unmanage_screen (display, 
++                                    screen,
++                                    event->xselectionclear.time);
+ 
+       /* display and screen may both be invalid memory... */
+       
+@@ -4698,23 +4731,25 @@
+ 
+ void
+ meta_display_unmanage_screen (MetaDisplay *display,
+-                              MetaScreen  *screen)
++                              MetaScreen  *screen,
++                              guint32      timestamp)
+ {
+   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);
++  meta_screen_free (screen, timestamp);
+   display->screens = g_slist_remove (display->screens, screen);
+ 
+   if (display->screens == NULL)
+-    meta_display_close (display);
++    meta_display_close (display, timestamp);
+ }
+ 
+ void
+ meta_display_unmanage_windows_for_screen (MetaDisplay *display,
+-                                          MetaScreen  *screen)
++                                          MetaScreen  *screen,
++                                          guint32      timestamp)
+ {
+   GSList *tmp;
+   GSList *winlist;
+@@ -4724,8 +4759,8 @@
+   /* Unmanage all windows */
+   tmp = winlist;
+   while (tmp != NULL)
+-    {      
+-      meta_window_free (tmp->data);
++    {
++      meta_window_free (tmp->data, timestamp);
+       
+       tmp = tmp->next;
+     }
+--- metacity-2.16.0/src/screen.c.currenttime-fixes	2006-09-04 12:55:13.000000000 -0400
++++ metacity-2.16.0/src/screen.c	2006-09-21 14:48:00.000000000 -0400
+@@ -52,7 +52,8 @@
+ static char* get_screen_name (MetaDisplay *display,
+                               int          number);
+ 
+-static void update_num_workspaces  (MetaScreen *screen);
++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,
+@@ -608,7 +609,7 @@
+    * so create that required workspace.
+    */
+   meta_workspace_activate (meta_workspace_new (screen), timestamp);
+-  update_num_workspaces (screen);
++  update_num_workspaces (screen, timestamp);
+   
+   set_workspace_names (screen);
+ 
+@@ -654,7 +655,8 @@
+ }
+ 
+ void
+-meta_screen_free (MetaScreen *screen)
++meta_screen_free (MetaScreen *screen,
++                  guint32     timestamp)
+ {
+   MetaDisplay *display;
+   XGCValues gc_values = { 0 };
+@@ -671,7 +673,7 @@
+ 				       screen);
+     }
+   
+-  meta_display_unmanage_windows_for_screen (display, screen);
++  meta_display_unmanage_windows_for_screen (display, screen, timestamp);
+   
+   meta_prefs_remove_listener (prefs_changed_callback, screen);
+   
+@@ -855,7 +857,12 @@
+   
+   if (pref == META_PREF_NUM_WORKSPACES)
+     {
+-      update_num_workspaces (screen);
++      /* GConf 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)
+     {
+@@ -1083,7 +1090,8 @@
+ }
+ 
+ static void
+-update_num_workspaces (MetaScreen *screen)
++update_num_workspaces (MetaScreen *screen,
++                       guint32     timestamp)
+ {
+   int new_num;
+   GList *tmp;
+@@ -1136,7 +1144,7 @@
+     }
+ 
+   if (need_change_space)
+-    meta_workspace_activate (last_remaining, meta_display_get_current_time_roundtrip (screen->display));
++    meta_workspace_activate (last_remaining, timestamp);
+ 
+   /* Should now be safe to free the workspaces */
+   tmp = extras;
+--- metacity-2.16.0/src/delete.c.currenttime-fixes	2006-08-27 17:49:38.000000000 -0400
++++ metacity-2.16.0/src/delete.c	2006-09-21 14:48:00.000000000 -0400
+@@ -34,7 +34,8 @@
+ #include <stdlib.h>
+ #include <stdio.h>
+ 
+-static void meta_window_present_delete_dialog (MetaWindow *window);
++static void meta_window_present_delete_dialog (MetaWindow *window,
++                                               guint32     timestamp);
+ 
+ static void
+ delete_ping_reply_func (MetaDisplay *display,
+@@ -311,7 +312,7 @@
+ 
+   if (window->dialog_pid >= 0)
+     {
+-      meta_window_present_delete_dialog (window);
++      meta_window_present_delete_dialog (window, timestamp);
+       return;
+     }
+   
+@@ -476,7 +477,7 @@
+ }
+ 
+ static void
+-meta_window_present_delete_dialog (MetaWindow *window)
++meta_window_present_delete_dialog (MetaWindow *window, guint32 timestamp)
+ {
+   meta_topic (META_DEBUG_PING,
+               "Presenting existing ping dialog for %s\n",
+@@ -501,8 +502,7 @@
+               w->res_class &&
+               g_strcasecmp (w->res_class, "metacity-dialog") == 0)
+             {
+-              meta_window_activate (w,
+-                                    meta_display_get_current_time (w->display));
++              meta_window_activate (w, timestamp);
+               break;
+             }
+           
diff --git a/metacity.spec b/metacity.spec
index 85ec2b3..3d7ece5 100644
--- a/metacity.spec
+++ b/metacity.spec
@@ -22,7 +22,7 @@ BuildRequires: libglade2-devel >= 2.0.0BuildRequires: intltool >= 0.35
 BuildRequires: startup-notification-devel >= 0.7
 BuildRequires: libtool automake autoconf gettext
 BuildRequires: xorg-x11-proto-devel >= 7.0-13
-BuildRequires: libSM-devel, libGL-devel, libGLU-devel, libICE-devel, libX11-devel
+BuildRequires: libSM-devel, libICE-devel, libX11-devel
 BuildRequires: libXext-devel, libXinerama-devel, libXrandr-devel, libXrender-devel
 BuildRequires: libXcursor-devel
 
@@ -30,8 +30,8 @@ Requires: startup-notification >= 0.7
 Requires: redhat-artwork >= 0.62
 Requires: pkgconfig
 
-Patch1: metacity-2.13.89.0.2006.02.16-static-cm.patch
 Patch2: metacity-2.16.0-losing-focus.patch
+Patch3: metacity-2.16.0-currenttime-fixes.patch
 
 %description
 
@@ -41,8 +41,9 @@ GNOME 2.
 %prep
 %setup -q -n %{metacity_filename}
 
-%patch1 -p1 -b .static-cm
 %patch2 -p0 -b .losing-focus
+%patch3 -p1 -b .currenttime-fixes
+
 
 %build
 rm -rf $RPM_BUILD_ROOT
@@ -118,6 +119,11 @@ fi
 %{_mandir}/man1/*
 
 %changelog
+* Fri Sep 21 2006 Soren Sandmann <sandmann@redhat.com>
+- Remove GL dependencies.
+- Remove static-cm patch
+- add patch to fix more CurrentTime race conditions (bug 206263)
+
 * Thu Sep 14 2006 Ray Strode <rstrode@redhat.com> - 2.16.0-3.fc6
 - remove stale ctrl-alt-delete patch